1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * QLogic qlcnic NIC Driver
4  * Copyright (c) 2009-2013 QLogic Corporation
5  */
6 
7 #include <linux/slab.h>
8 #include <linux/interrupt.h>
9 #include <linux/swab.h>
10 #include <linux/dma-mapping.h>
11 #include <net/ip.h>
12 #include <linux/ipv6.h>
13 #include <linux/inetdevice.h>
14 #include <linux/sysfs.h>
15 #include <linux/log2.h>
16 #ifdef CONFIG_QLCNIC_HWMON
17 #include <linux/hwmon.h>
18 #include <linux/hwmon-sysfs.h>
19 #endif
20 
21 #include "qlcnic.h"
22 #include "qlcnic_hw.h"
23 
24 int qlcnicvf_config_bridged_mode(struct qlcnic_adapter *adapter, u32 enable)
25 {
26 	return -EOPNOTSUPP;
27 }
28 
29 int qlcnicvf_config_led(struct qlcnic_adapter *adapter, u32 state, u32 rate)
30 {
31 	return -EOPNOTSUPP;
32 }
33 
34 static ssize_t qlcnic_store_bridged_mode(struct device *dev,
35 					 struct device_attribute *attr,
36 					 const char *buf, size_t len)
37 {
38 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
39 	unsigned long new;
40 	int ret = -EINVAL;
41 
42 	if (!(adapter->ahw->capabilities & QLCNIC_FW_CAPABILITY_BDG))
43 		goto err_out;
44 
45 	if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
46 		goto err_out;
47 
48 	if (kstrtoul(buf, 2, &new))
49 		goto err_out;
50 
51 	if (!qlcnic_config_bridged_mode(adapter, !!new))
52 		ret = len;
53 
54 err_out:
55 	return ret;
56 }
57 
58 static ssize_t qlcnic_show_bridged_mode(struct device *dev,
59 					struct device_attribute *attr,
60 					char *buf)
61 {
62 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
63 	int bridged_mode = 0;
64 
65 	if (adapter->ahw->capabilities & QLCNIC_FW_CAPABILITY_BDG)
66 		bridged_mode = !!(adapter->flags & QLCNIC_BRIDGE_ENABLED);
67 
68 	return sprintf(buf, "%d\n", bridged_mode);
69 }
70 
71 static ssize_t qlcnic_store_diag_mode(struct device *dev,
72 				      struct device_attribute *attr,
73 				      const char *buf, size_t len)
74 {
75 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
76 	unsigned long new;
77 
78 	if (kstrtoul(buf, 2, &new))
79 		return -EINVAL;
80 
81 	if (!!new != !!(adapter->flags & QLCNIC_DIAG_ENABLED))
82 		adapter->flags ^= QLCNIC_DIAG_ENABLED;
83 
84 	return len;
85 }
86 
87 static ssize_t qlcnic_show_diag_mode(struct device *dev,
88 				     struct device_attribute *attr, char *buf)
89 {
90 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
91 	return sprintf(buf, "%d\n", !!(adapter->flags & QLCNIC_DIAG_ENABLED));
92 }
93 
94 static int qlcnic_validate_beacon(struct qlcnic_adapter *adapter, u16 beacon,
95 				  u8 *state, u8 *rate)
96 {
97 	*rate = LSB(beacon);
98 	*state = MSB(beacon);
99 
100 	QLCDB(adapter, DRV, "rate %x state %x\n", *rate, *state);
101 
102 	if (!*state) {
103 		*rate = __QLCNIC_MAX_LED_RATE;
104 		return 0;
105 	} else if (*state > __QLCNIC_MAX_LED_STATE) {
106 		return -EINVAL;
107 	}
108 
109 	if ((!*rate) || (*rate > __QLCNIC_MAX_LED_RATE))
110 		return -EINVAL;
111 
112 	return 0;
113 }
114 
115 static int qlcnic_83xx_store_beacon(struct qlcnic_adapter *adapter,
116 				    const char *buf, size_t len)
117 {
118 	struct qlcnic_hardware_context *ahw = adapter->ahw;
119 	unsigned long h_beacon;
120 	int err;
121 
122 	if (test_bit(__QLCNIC_RESETTING, &adapter->state))
123 		return -EIO;
124 
125 	if (kstrtoul(buf, 2, &h_beacon))
126 		return -EINVAL;
127 
128 	qlcnic_get_beacon_state(adapter);
129 
130 	if (ahw->beacon_state == h_beacon)
131 		return len;
132 
133 	rtnl_lock();
134 	if (!ahw->beacon_state) {
135 		if (test_and_set_bit(__QLCNIC_LED_ENABLE, &adapter->state)) {
136 			rtnl_unlock();
137 			return -EBUSY;
138 		}
139 	}
140 
141 	if (h_beacon)
142 		err = qlcnic_83xx_config_led(adapter, 1, h_beacon);
143 	else
144 		err = qlcnic_83xx_config_led(adapter, 0, !h_beacon);
145 	if (!err)
146 		ahw->beacon_state = h_beacon;
147 
148 	if (!ahw->beacon_state)
149 		clear_bit(__QLCNIC_LED_ENABLE, &adapter->state);
150 
151 	rtnl_unlock();
152 	return len;
153 }
154 
155 static int qlcnic_82xx_store_beacon(struct qlcnic_adapter *adapter,
156 				    const char *buf, size_t len)
157 {
158 	struct qlcnic_hardware_context *ahw = adapter->ahw;
159 	int err, drv_sds_rings = adapter->drv_sds_rings;
160 	u16 beacon;
161 	u8 b_state, b_rate;
162 
163 	if (len != sizeof(u16))
164 		return -EINVAL;
165 
166 	memcpy(&beacon, buf, sizeof(u16));
167 	err = qlcnic_validate_beacon(adapter, beacon, &b_state, &b_rate);
168 	if (err)
169 		return err;
170 
171 	qlcnic_get_beacon_state(adapter);
172 
173 	if (ahw->beacon_state == b_state)
174 		return len;
175 
176 	rtnl_lock();
177 	if (!ahw->beacon_state) {
178 		if (test_and_set_bit(__QLCNIC_LED_ENABLE, &adapter->state)) {
179 			rtnl_unlock();
180 			return -EBUSY;
181 		}
182 	}
183 
184 	if (test_bit(__QLCNIC_RESETTING, &adapter->state)) {
185 		err = -EIO;
186 		goto out;
187 	}
188 
189 	if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
190 		err = qlcnic_diag_alloc_res(adapter->netdev, QLCNIC_LED_TEST);
191 		if (err)
192 			goto out;
193 		set_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state);
194 	}
195 
196 	err = qlcnic_config_led(adapter, b_state, b_rate);
197 	if (!err) {
198 		err = len;
199 		ahw->beacon_state = b_state;
200 	}
201 
202 	if (test_and_clear_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state))
203 		qlcnic_diag_free_res(adapter->netdev, drv_sds_rings);
204 
205 out:
206 	if (!ahw->beacon_state)
207 		clear_bit(__QLCNIC_LED_ENABLE, &adapter->state);
208 	rtnl_unlock();
209 
210 	return err;
211 }
212 
213 static ssize_t qlcnic_store_beacon(struct device *dev,
214 				   struct device_attribute *attr,
215 				   const char *buf, size_t len)
216 {
217 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
218 	int err = 0;
219 
220 	if (adapter->ahw->op_mode == QLCNIC_NON_PRIV_FUNC) {
221 		dev_warn(dev,
222 			 "LED test not supported in non privileged mode\n");
223 		return -EOPNOTSUPP;
224 	}
225 
226 	if (qlcnic_82xx_check(adapter))
227 		err = qlcnic_82xx_store_beacon(adapter, buf, len);
228 	else if (qlcnic_83xx_check(adapter))
229 		err = qlcnic_83xx_store_beacon(adapter, buf, len);
230 	else
231 		return -EIO;
232 
233 	return err;
234 }
235 
236 static ssize_t qlcnic_show_beacon(struct device *dev,
237 				  struct device_attribute *attr, char *buf)
238 {
239 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
240 
241 	return sprintf(buf, "%d\n", adapter->ahw->beacon_state);
242 }
243 
244 static int qlcnic_sysfs_validate_crb(struct qlcnic_adapter *adapter,
245 				     loff_t offset, size_t size)
246 {
247 	size_t crb_size = 4;
248 
249 	if (!(adapter->flags & QLCNIC_DIAG_ENABLED))
250 		return -EIO;
251 
252 	if (offset < QLCNIC_PCI_CRBSPACE) {
253 		if (ADDR_IN_RANGE(offset, QLCNIC_PCI_CAMQM,
254 				  QLCNIC_PCI_CAMQM_END))
255 			crb_size = 8;
256 		else
257 			return -EINVAL;
258 	}
259 
260 	if ((size != crb_size) || (offset & (crb_size-1)))
261 		return  -EINVAL;
262 
263 	return 0;
264 }
265 
266 static ssize_t qlcnic_sysfs_read_crb(struct file *filp, struct kobject *kobj,
267 				     struct bin_attribute *attr, char *buf,
268 				     loff_t offset, size_t size)
269 {
270 	struct device *dev = kobj_to_dev(kobj);
271 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
272 	int ret;
273 
274 	ret = qlcnic_sysfs_validate_crb(adapter, offset, size);
275 	if (ret != 0)
276 		return ret;
277 	qlcnic_read_crb(adapter, buf, offset, size);
278 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
279 
280 	return size;
281 }
282 
283 static ssize_t qlcnic_sysfs_write_crb(struct file *filp, struct kobject *kobj,
284 				      struct bin_attribute *attr, char *buf,
285 				      loff_t offset, size_t size)
286 {
287 	struct device *dev = kobj_to_dev(kobj);
288 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
289 	int ret;
290 
291 	ret = qlcnic_sysfs_validate_crb(adapter, offset, size);
292 	if (ret != 0)
293 		return ret;
294 
295 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
296 	qlcnic_write_crb(adapter, buf, offset, size);
297 	return size;
298 }
299 
300 static int qlcnic_sysfs_validate_mem(struct qlcnic_adapter *adapter,
301 				     loff_t offset, size_t size)
302 {
303 	if (!(adapter->flags & QLCNIC_DIAG_ENABLED))
304 		return -EIO;
305 
306 	if ((size != 8) || (offset & 0x7))
307 		return  -EIO;
308 
309 	return 0;
310 }
311 
312 static ssize_t qlcnic_sysfs_read_mem(struct file *filp, struct kobject *kobj,
313 				     struct bin_attribute *attr, char *buf,
314 				     loff_t offset, size_t size)
315 {
316 	struct device *dev = kobj_to_dev(kobj);
317 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
318 	u64 data;
319 	int ret;
320 
321 	ret = qlcnic_sysfs_validate_mem(adapter, offset, size);
322 	if (ret != 0)
323 		return ret;
324 
325 	if (qlcnic_pci_mem_read_2M(adapter, offset, &data))
326 		return -EIO;
327 
328 	memcpy(buf, &data, size);
329 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
330 
331 	return size;
332 }
333 
334 static ssize_t qlcnic_sysfs_write_mem(struct file *filp, struct kobject *kobj,
335 				      struct bin_attribute *attr, char *buf,
336 				      loff_t offset, size_t size)
337 {
338 	struct device *dev = kobj_to_dev(kobj);
339 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
340 	u64 data;
341 	int ret;
342 
343 	ret = qlcnic_sysfs_validate_mem(adapter, offset, size);
344 	if (ret != 0)
345 		return ret;
346 
347 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
348 	memcpy(&data, buf, size);
349 
350 	if (qlcnic_pci_mem_write_2M(adapter, offset, data))
351 		return -EIO;
352 
353 	return size;
354 }
355 
356 int qlcnic_is_valid_nic_func(struct qlcnic_adapter *adapter, u8 pci_func)
357 {
358 	int i;
359 
360 	for (i = 0; i < adapter->ahw->total_nic_func; i++) {
361 		if (adapter->npars[i].pci_func == pci_func)
362 			return i;
363 	}
364 
365 	dev_err(&adapter->pdev->dev, "%s: Invalid nic function\n", __func__);
366 	return -EINVAL;
367 }
368 
369 static int validate_pm_config(struct qlcnic_adapter *adapter,
370 			      struct qlcnic_pm_func_cfg *pm_cfg, int count)
371 {
372 	u8 src_pci_func, s_esw_id, d_esw_id;
373 	u8 dest_pci_func;
374 	int i, src_index, dest_index;
375 
376 	for (i = 0; i < count; i++) {
377 		src_pci_func = pm_cfg[i].pci_func;
378 		dest_pci_func = pm_cfg[i].dest_npar;
379 		src_index = qlcnic_is_valid_nic_func(adapter, src_pci_func);
380 		if (src_index < 0)
381 			return -EINVAL;
382 
383 		dest_index = qlcnic_is_valid_nic_func(adapter, dest_pci_func);
384 		if (dest_index < 0)
385 			return -EINVAL;
386 
387 		s_esw_id = adapter->npars[src_index].phy_port;
388 		d_esw_id = adapter->npars[dest_index].phy_port;
389 
390 		if (s_esw_id != d_esw_id)
391 			return -EINVAL;
392 	}
393 
394 	return 0;
395 }
396 
397 static ssize_t qlcnic_sysfs_write_pm_config(struct file *filp,
398 					    struct kobject *kobj,
399 					    struct bin_attribute *attr,
400 					    char *buf, loff_t offset,
401 					    size_t size)
402 {
403 	struct device *dev = kobj_to_dev(kobj);
404 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
405 	struct qlcnic_pm_func_cfg *pm_cfg;
406 	u32 id, action, pci_func;
407 	int count, rem, i, ret, index;
408 
409 	count	= size / sizeof(struct qlcnic_pm_func_cfg);
410 	rem	= size % sizeof(struct qlcnic_pm_func_cfg);
411 	if (rem)
412 		return -EINVAL;
413 
414 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
415 	pm_cfg = (struct qlcnic_pm_func_cfg *)buf;
416 	ret = validate_pm_config(adapter, pm_cfg, count);
417 
418 	if (ret)
419 		return ret;
420 	for (i = 0; i < count; i++) {
421 		pci_func = pm_cfg[i].pci_func;
422 		action = !!pm_cfg[i].action;
423 		index = qlcnic_is_valid_nic_func(adapter, pci_func);
424 		if (index < 0)
425 			return -EINVAL;
426 
427 		id = adapter->npars[index].phy_port;
428 		ret = qlcnic_config_port_mirroring(adapter, id,
429 						   action, pci_func);
430 		if (ret)
431 			return ret;
432 	}
433 
434 	for (i = 0; i < count; i++) {
435 		pci_func = pm_cfg[i].pci_func;
436 		index = qlcnic_is_valid_nic_func(adapter, pci_func);
437 		if (index < 0)
438 			return -EINVAL;
439 		id = adapter->npars[index].phy_port;
440 		adapter->npars[index].enable_pm = !!pm_cfg[i].action;
441 		adapter->npars[index].dest_npar = id;
442 	}
443 
444 	return size;
445 }
446 
447 static ssize_t qlcnic_sysfs_read_pm_config(struct file *filp,
448 					   struct kobject *kobj,
449 					   struct bin_attribute *attr,
450 					   char *buf, loff_t offset,
451 					   size_t size)
452 {
453 	struct device *dev = kobj_to_dev(kobj);
454 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
455 	struct qlcnic_pm_func_cfg *pm_cfg;
456 	u8 pci_func;
457 	u32 count;
458 	int i;
459 
460 	memset(buf, 0, size);
461 	pm_cfg = (struct qlcnic_pm_func_cfg *)buf;
462 	count = size / sizeof(struct qlcnic_pm_func_cfg);
463 	for (i = 0; i < adapter->ahw->total_nic_func; i++) {
464 		pci_func = adapter->npars[i].pci_func;
465 		if (pci_func >= count) {
466 			dev_dbg(dev, "%s: Total nic functions[%d], App sent function count[%d]\n",
467 				__func__, adapter->ahw->total_nic_func, count);
468 			continue;
469 		}
470 		if (!adapter->npars[i].eswitch_status)
471 			continue;
472 
473 		pm_cfg[pci_func].action = adapter->npars[i].enable_pm;
474 		pm_cfg[pci_func].dest_npar = 0;
475 		pm_cfg[pci_func].pci_func = i;
476 	}
477 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
478 	return size;
479 }
480 
481 static int validate_esw_config(struct qlcnic_adapter *adapter,
482 			       struct qlcnic_esw_func_cfg *esw_cfg, int count)
483 {
484 	struct qlcnic_hardware_context *ahw = adapter->ahw;
485 	int i, ret;
486 	u32 op_mode;
487 	u8 pci_func;
488 
489 	if (qlcnic_82xx_check(adapter))
490 		op_mode = readl(ahw->pci_base0 + QLCNIC_DRV_OP_MODE);
491 	else
492 		op_mode = QLCRDX(ahw, QLC_83XX_DRV_OP_MODE);
493 
494 	for (i = 0; i < count; i++) {
495 		pci_func = esw_cfg[i].pci_func;
496 		if (pci_func >= ahw->max_vnic_func)
497 			return -EINVAL;
498 
499 		if (adapter->ahw->op_mode == QLCNIC_MGMT_FUNC)
500 			if (qlcnic_is_valid_nic_func(adapter, pci_func) < 0)
501 				return -EINVAL;
502 
503 		switch (esw_cfg[i].op_mode) {
504 		case QLCNIC_PORT_DEFAULTS:
505 			if (qlcnic_82xx_check(adapter)) {
506 				ret = QLC_DEV_GET_DRV(op_mode, pci_func);
507 			} else {
508 				ret = QLC_83XX_GET_FUNC_PRIVILEGE(op_mode,
509 								  pci_func);
510 				esw_cfg[i].offload_flags = 0;
511 			}
512 
513 			if (ret != QLCNIC_NON_PRIV_FUNC) {
514 				if (esw_cfg[i].mac_anti_spoof != 0)
515 					return -EINVAL;
516 				if (esw_cfg[i].mac_override != 1)
517 					return -EINVAL;
518 				if (esw_cfg[i].promisc_mode != 1)
519 					return -EINVAL;
520 			}
521 			break;
522 		case QLCNIC_ADD_VLAN:
523 			if (!IS_VALID_VLAN(esw_cfg[i].vlan_id))
524 				return -EINVAL;
525 			if (!esw_cfg[i].op_type)
526 				return -EINVAL;
527 			break;
528 		case QLCNIC_DEL_VLAN:
529 			if (!esw_cfg[i].op_type)
530 				return -EINVAL;
531 			break;
532 		default:
533 			return -EINVAL;
534 		}
535 	}
536 
537 	return 0;
538 }
539 
540 static ssize_t qlcnic_sysfs_write_esw_config(struct file *file,
541 					     struct kobject *kobj,
542 					     struct bin_attribute *attr,
543 					     char *buf, loff_t offset,
544 					     size_t size)
545 {
546 	struct device *dev = kobj_to_dev(kobj);
547 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
548 	struct qlcnic_esw_func_cfg *esw_cfg;
549 	struct qlcnic_npar_info *npar;
550 	int count, rem, i, ret;
551 	int index;
552 	u8 op_mode = 0, pci_func;
553 
554 	count	= size / sizeof(struct qlcnic_esw_func_cfg);
555 	rem	= size % sizeof(struct qlcnic_esw_func_cfg);
556 	if (rem)
557 		return -EINVAL;
558 
559 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
560 	esw_cfg = (struct qlcnic_esw_func_cfg *)buf;
561 	ret = validate_esw_config(adapter, esw_cfg, count);
562 	if (ret)
563 		return ret;
564 
565 	for (i = 0; i < count; i++) {
566 		if (adapter->ahw->op_mode == QLCNIC_MGMT_FUNC)
567 			if (qlcnic_config_switch_port(adapter, &esw_cfg[i]))
568 				return -EINVAL;
569 
570 		if (adapter->ahw->pci_func != esw_cfg[i].pci_func)
571 			continue;
572 
573 		op_mode = esw_cfg[i].op_mode;
574 		qlcnic_get_eswitch_port_config(adapter, &esw_cfg[i]);
575 		esw_cfg[i].op_mode = op_mode;
576 		esw_cfg[i].pci_func = adapter->ahw->pci_func;
577 
578 		switch (esw_cfg[i].op_mode) {
579 		case QLCNIC_PORT_DEFAULTS:
580 			qlcnic_set_eswitch_port_features(adapter, &esw_cfg[i]);
581 			rtnl_lock();
582 			qlcnic_set_netdev_features(adapter, &esw_cfg[i]);
583 			rtnl_unlock();
584 			break;
585 		case QLCNIC_ADD_VLAN:
586 			qlcnic_set_vlan_config(adapter, &esw_cfg[i]);
587 			break;
588 		case QLCNIC_DEL_VLAN:
589 			esw_cfg[i].vlan_id = 0;
590 			qlcnic_set_vlan_config(adapter, &esw_cfg[i]);
591 			break;
592 		}
593 	}
594 
595 	if (adapter->ahw->op_mode != QLCNIC_MGMT_FUNC)
596 		goto out;
597 
598 	for (i = 0; i < count; i++) {
599 		pci_func = esw_cfg[i].pci_func;
600 		index = qlcnic_is_valid_nic_func(adapter, pci_func);
601 		if (index < 0)
602 			return -EINVAL;
603 		npar = &adapter->npars[index];
604 		switch (esw_cfg[i].op_mode) {
605 		case QLCNIC_PORT_DEFAULTS:
606 			npar->promisc_mode = esw_cfg[i].promisc_mode;
607 			npar->mac_override = esw_cfg[i].mac_override;
608 			npar->offload_flags = esw_cfg[i].offload_flags;
609 			npar->mac_anti_spoof = esw_cfg[i].mac_anti_spoof;
610 			npar->discard_tagged = esw_cfg[i].discard_tagged;
611 			break;
612 		case QLCNIC_ADD_VLAN:
613 			npar->pvid = esw_cfg[i].vlan_id;
614 			break;
615 		case QLCNIC_DEL_VLAN:
616 			npar->pvid = 0;
617 			break;
618 		}
619 	}
620 out:
621 	return size;
622 }
623 
624 static ssize_t qlcnic_sysfs_read_esw_config(struct file *file,
625 					    struct kobject *kobj,
626 					    struct bin_attribute *attr,
627 					    char *buf, loff_t offset,
628 					    size_t size)
629 {
630 	struct device *dev = kobj_to_dev(kobj);
631 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
632 	struct qlcnic_esw_func_cfg *esw_cfg;
633 	u8 pci_func;
634 	u32 count;
635 	int i;
636 
637 	memset(buf, 0, size);
638 	esw_cfg = (struct qlcnic_esw_func_cfg *)buf;
639 	count = size / sizeof(struct qlcnic_esw_func_cfg);
640 	for (i = 0; i < adapter->ahw->total_nic_func; i++) {
641 		pci_func = adapter->npars[i].pci_func;
642 		if (pci_func >= count) {
643 			dev_dbg(dev, "%s: Total nic functions[%d], App sent function count[%d]\n",
644 				__func__, adapter->ahw->total_nic_func, count);
645 			continue;
646 		}
647 		if (!adapter->npars[i].eswitch_status)
648 			continue;
649 
650 		esw_cfg[pci_func].pci_func = pci_func;
651 		if (qlcnic_get_eswitch_port_config(adapter, &esw_cfg[pci_func]))
652 			return -EINVAL;
653 	}
654 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
655 	return size;
656 }
657 
658 static int validate_npar_config(struct qlcnic_adapter *adapter,
659 				struct qlcnic_npar_func_cfg *np_cfg,
660 				int count)
661 {
662 	u8 pci_func, i;
663 
664 	for (i = 0; i < count; i++) {
665 		pci_func = np_cfg[i].pci_func;
666 		if (qlcnic_is_valid_nic_func(adapter, pci_func) < 0)
667 			return -EINVAL;
668 
669 		if (!IS_VALID_BW(np_cfg[i].min_bw) ||
670 		    !IS_VALID_BW(np_cfg[i].max_bw))
671 			return -EINVAL;
672 	}
673 	return 0;
674 }
675 
676 static ssize_t qlcnic_sysfs_write_npar_config(struct file *file,
677 					      struct kobject *kobj,
678 					      struct bin_attribute *attr,
679 					      char *buf, loff_t offset,
680 					      size_t size)
681 {
682 	struct device *dev = kobj_to_dev(kobj);
683 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
684 	struct qlcnic_info nic_info;
685 	struct qlcnic_npar_func_cfg *np_cfg;
686 	int i, count, rem, ret, index;
687 	u8 pci_func;
688 
689 	count	= size / sizeof(struct qlcnic_npar_func_cfg);
690 	rem	= size % sizeof(struct qlcnic_npar_func_cfg);
691 	if (rem)
692 		return -EINVAL;
693 
694 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
695 	np_cfg = (struct qlcnic_npar_func_cfg *)buf;
696 	ret = validate_npar_config(adapter, np_cfg, count);
697 	if (ret)
698 		return ret;
699 
700 	for (i = 0; i < count; i++) {
701 		pci_func = np_cfg[i].pci_func;
702 
703 		memset(&nic_info, 0, sizeof(struct qlcnic_info));
704 		ret = qlcnic_get_nic_info(adapter, &nic_info, pci_func);
705 		if (ret)
706 			return ret;
707 		nic_info.pci_func = pci_func;
708 		nic_info.min_tx_bw = np_cfg[i].min_bw;
709 		nic_info.max_tx_bw = np_cfg[i].max_bw;
710 		ret = qlcnic_set_nic_info(adapter, &nic_info);
711 		if (ret)
712 			return ret;
713 		index = qlcnic_is_valid_nic_func(adapter, pci_func);
714 		if (index < 0)
715 			return -EINVAL;
716 		adapter->npars[index].min_bw = nic_info.min_tx_bw;
717 		adapter->npars[index].max_bw = nic_info.max_tx_bw;
718 	}
719 
720 	return size;
721 }
722 
723 static ssize_t qlcnic_sysfs_read_npar_config(struct file *file,
724 					     struct kobject *kobj,
725 					     struct bin_attribute *attr,
726 					     char *buf, loff_t offset,
727 					     size_t size)
728 {
729 	struct device *dev = kobj_to_dev(kobj);
730 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
731 	struct qlcnic_npar_func_cfg *np_cfg;
732 	struct qlcnic_info nic_info;
733 	u8 pci_func;
734 	int i, ret;
735 	u32 count;
736 
737 	memset(&nic_info, 0, sizeof(struct qlcnic_info));
738 	memset(buf, 0, size);
739 	np_cfg = (struct qlcnic_npar_func_cfg *)buf;
740 
741 	count = size / sizeof(struct qlcnic_npar_func_cfg);
742 	for (i = 0; i < adapter->ahw->total_nic_func; i++) {
743 		if (adapter->npars[i].pci_func >= count) {
744 			dev_dbg(dev, "%s: Total nic functions[%d], App sent function count[%d]\n",
745 				__func__, adapter->ahw->total_nic_func, count);
746 			continue;
747 		}
748 		if (!adapter->npars[i].eswitch_status)
749 			continue;
750 		pci_func = adapter->npars[i].pci_func;
751 		if (qlcnic_is_valid_nic_func(adapter, pci_func) < 0)
752 			continue;
753 		ret = qlcnic_get_nic_info(adapter, &nic_info, pci_func);
754 		if (ret)
755 			return ret;
756 
757 		np_cfg[pci_func].pci_func = pci_func;
758 		np_cfg[pci_func].op_mode = (u8)nic_info.op_mode;
759 		np_cfg[pci_func].port_num = nic_info.phys_port;
760 		np_cfg[pci_func].fw_capab = nic_info.capabilities;
761 		np_cfg[pci_func].min_bw = nic_info.min_tx_bw;
762 		np_cfg[pci_func].max_bw = nic_info.max_tx_bw;
763 		np_cfg[pci_func].max_tx_queues = nic_info.max_tx_ques;
764 		np_cfg[pci_func].max_rx_queues = nic_info.max_rx_ques;
765 	}
766 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
767 	return size;
768 }
769 
770 static ssize_t qlcnic_sysfs_get_port_stats(struct file *file,
771 					   struct kobject *kobj,
772 					   struct bin_attribute *attr,
773 					   char *buf, loff_t offset,
774 					   size_t size)
775 {
776 	struct device *dev = kobj_to_dev(kobj);
777 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
778 	struct qlcnic_esw_statistics port_stats;
779 	int ret;
780 
781 	if (qlcnic_83xx_check(adapter))
782 		return -EOPNOTSUPP;
783 
784 	if (size != sizeof(struct qlcnic_esw_statistics))
785 		return -EINVAL;
786 
787 	if (offset >= adapter->ahw->max_vnic_func)
788 		return -EINVAL;
789 
790 	memset(&port_stats, 0, size);
791 	ret = qlcnic_get_port_stats(adapter, offset, QLCNIC_QUERY_RX_COUNTER,
792 				    &port_stats.rx);
793 	if (ret)
794 		return ret;
795 
796 	ret = qlcnic_get_port_stats(adapter, offset, QLCNIC_QUERY_TX_COUNTER,
797 				    &port_stats.tx);
798 	if (ret)
799 		return ret;
800 
801 	memcpy(buf, &port_stats, size);
802 	return size;
803 }
804 
805 static ssize_t qlcnic_sysfs_get_esw_stats(struct file *file,
806 					  struct kobject *kobj,
807 					  struct bin_attribute *attr,
808 					  char *buf, loff_t offset,
809 					  size_t size)
810 {
811 	struct device *dev = kobj_to_dev(kobj);
812 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
813 	struct qlcnic_esw_statistics esw_stats;
814 	int ret;
815 
816 	if (qlcnic_83xx_check(adapter))
817 		return -EOPNOTSUPP;
818 
819 	if (size != sizeof(struct qlcnic_esw_statistics))
820 		return -EINVAL;
821 
822 	if (offset >= QLCNIC_NIU_MAX_XG_PORTS)
823 		return -EINVAL;
824 
825 	memset(&esw_stats, 0, size);
826 	ret = qlcnic_get_eswitch_stats(adapter, offset, QLCNIC_QUERY_RX_COUNTER,
827 				       &esw_stats.rx);
828 	if (ret)
829 		return ret;
830 
831 	ret = qlcnic_get_eswitch_stats(adapter, offset, QLCNIC_QUERY_TX_COUNTER,
832 				       &esw_stats.tx);
833 	if (ret)
834 		return ret;
835 
836 	memcpy(buf, &esw_stats, size);
837 	return size;
838 }
839 
840 static ssize_t qlcnic_sysfs_clear_esw_stats(struct file *file,
841 					    struct kobject *kobj,
842 					    struct bin_attribute *attr,
843 					    char *buf, loff_t offset,
844 					    size_t size)
845 {
846 	struct device *dev = kobj_to_dev(kobj);
847 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
848 	int ret;
849 
850 	if (qlcnic_83xx_check(adapter))
851 		return -EOPNOTSUPP;
852 
853 	if (offset >= QLCNIC_NIU_MAX_XG_PORTS)
854 		return -EINVAL;
855 
856 	ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_ESWITCH, offset,
857 				     QLCNIC_QUERY_RX_COUNTER);
858 	if (ret)
859 		return ret;
860 
861 	ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_ESWITCH, offset,
862 				     QLCNIC_QUERY_TX_COUNTER);
863 	if (ret)
864 		return ret;
865 
866 	return size;
867 }
868 
869 static ssize_t qlcnic_sysfs_clear_port_stats(struct file *file,
870 					     struct kobject *kobj,
871 					     struct bin_attribute *attr,
872 					     char *buf, loff_t offset,
873 					     size_t size)
874 {
875 
876 	struct device *dev = kobj_to_dev(kobj);
877 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
878 	int ret;
879 
880 	if (qlcnic_83xx_check(adapter))
881 		return -EOPNOTSUPP;
882 
883 	if (offset >= adapter->ahw->max_vnic_func)
884 		return -EINVAL;
885 
886 	ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_PORT, offset,
887 				     QLCNIC_QUERY_RX_COUNTER);
888 	if (ret)
889 		return ret;
890 
891 	ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_PORT, offset,
892 				     QLCNIC_QUERY_TX_COUNTER);
893 	if (ret)
894 		return ret;
895 
896 	return size;
897 }
898 
899 static ssize_t qlcnic_sysfs_read_pci_config(struct file *file,
900 					    struct kobject *kobj,
901 					    struct bin_attribute *attr,
902 					    char *buf, loff_t offset,
903 					    size_t size)
904 {
905 	struct device *dev = kobj_to_dev(kobj);
906 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
907 	struct qlcnic_pci_func_cfg *pci_cfg;
908 	struct qlcnic_pci_info *pci_info;
909 	int i, ret;
910 	u32 count;
911 
912 	pci_info = kcalloc(size, sizeof(*pci_info), GFP_KERNEL);
913 	if (!pci_info)
914 		return -ENOMEM;
915 
916 	ret = qlcnic_get_pci_info(adapter, pci_info);
917 	if (ret) {
918 		kfree(pci_info);
919 		return ret;
920 	}
921 
922 	pci_cfg = (struct qlcnic_pci_func_cfg *)buf;
923 	count = size / sizeof(struct qlcnic_pci_func_cfg);
924 	qlcnic_swap32_buffer((u32 *)pci_info, size / sizeof(u32));
925 	for (i = 0; i < count; i++) {
926 		pci_cfg[i].pci_func = pci_info[i].id;
927 		pci_cfg[i].func_type = pci_info[i].type;
928 		pci_cfg[i].func_state = 0;
929 		pci_cfg[i].port_num = pci_info[i].default_port;
930 		pci_cfg[i].min_bw = pci_info[i].tx_min_bw;
931 		pci_cfg[i].max_bw = pci_info[i].tx_max_bw;
932 		memcpy(&pci_cfg[i].def_mac_addr, &pci_info[i].mac, ETH_ALEN);
933 	}
934 
935 	kfree(pci_info);
936 	return size;
937 }
938 
939 static ssize_t qlcnic_83xx_sysfs_flash_read_handler(struct file *filp,
940 						    struct kobject *kobj,
941 						    struct bin_attribute *attr,
942 						    char *buf, loff_t offset,
943 						    size_t size)
944 {
945 	unsigned char *p_read_buf;
946 	int  ret, count;
947 	struct device *dev = kobj_to_dev(kobj);
948 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
949 
950 	if (!size)
951 		return -EINVAL;
952 
953 	count = size / sizeof(u32);
954 
955 	if (size % sizeof(u32))
956 		count++;
957 
958 	p_read_buf = kcalloc(size, sizeof(unsigned char), GFP_KERNEL);
959 	if (!p_read_buf)
960 		return -ENOMEM;
961 	if (qlcnic_83xx_lock_flash(adapter) != 0) {
962 		kfree(p_read_buf);
963 		return -EIO;
964 	}
965 
966 	ret = qlcnic_83xx_lockless_flash_read32(adapter, offset, p_read_buf,
967 						count);
968 
969 	if (ret) {
970 		qlcnic_83xx_unlock_flash(adapter);
971 		kfree(p_read_buf);
972 		return ret;
973 	}
974 
975 	qlcnic_83xx_unlock_flash(adapter);
976 	qlcnic_swap32_buffer((u32 *)p_read_buf, count);
977 	memcpy(buf, p_read_buf, size);
978 	kfree(p_read_buf);
979 
980 	return size;
981 }
982 
983 static int qlcnic_83xx_sysfs_flash_bulk_write(struct qlcnic_adapter *adapter,
984 					      char *buf, loff_t offset,
985 					      size_t size)
986 {
987 	int  i, ret, count;
988 	unsigned char *p_cache, *p_src;
989 
990 	p_cache = kcalloc(size, sizeof(unsigned char), GFP_KERNEL);
991 	if (!p_cache)
992 		return -ENOMEM;
993 
994 	count = size / sizeof(u32);
995 	qlcnic_swap32_buffer((u32 *)buf, count);
996 	memcpy(p_cache, buf, size);
997 	p_src = p_cache;
998 
999 	if (qlcnic_83xx_lock_flash(adapter) != 0) {
1000 		kfree(p_cache);
1001 		return -EIO;
1002 	}
1003 
1004 	if (adapter->ahw->fdt.mfg_id == adapter->flash_mfg_id) {
1005 		ret = qlcnic_83xx_enable_flash_write(adapter);
1006 		if (ret) {
1007 			kfree(p_cache);
1008 			qlcnic_83xx_unlock_flash(adapter);
1009 			return -EIO;
1010 		}
1011 	}
1012 
1013 	for (i = 0; i < count / QLC_83XX_FLASH_WRITE_MAX; i++) {
1014 		ret = qlcnic_83xx_flash_bulk_write(adapter, offset,
1015 						   (u32 *)p_src,
1016 						   QLC_83XX_FLASH_WRITE_MAX);
1017 
1018 		if (ret) {
1019 			if (adapter->ahw->fdt.mfg_id == adapter->flash_mfg_id) {
1020 				ret = qlcnic_83xx_disable_flash_write(adapter);
1021 				if (ret) {
1022 					kfree(p_cache);
1023 					qlcnic_83xx_unlock_flash(adapter);
1024 					return -EIO;
1025 				}
1026 			}
1027 
1028 			kfree(p_cache);
1029 			qlcnic_83xx_unlock_flash(adapter);
1030 			return -EIO;
1031 		}
1032 
1033 		p_src = p_src + sizeof(u32)*QLC_83XX_FLASH_WRITE_MAX;
1034 		offset = offset + sizeof(u32)*QLC_83XX_FLASH_WRITE_MAX;
1035 	}
1036 
1037 	if (adapter->ahw->fdt.mfg_id == adapter->flash_mfg_id) {
1038 		ret = qlcnic_83xx_disable_flash_write(adapter);
1039 		if (ret) {
1040 			kfree(p_cache);
1041 			qlcnic_83xx_unlock_flash(adapter);
1042 			return -EIO;
1043 		}
1044 	}
1045 
1046 	kfree(p_cache);
1047 	qlcnic_83xx_unlock_flash(adapter);
1048 
1049 	return 0;
1050 }
1051 
1052 static int qlcnic_83xx_sysfs_flash_write(struct qlcnic_adapter *adapter,
1053 					 char *buf, loff_t offset, size_t size)
1054 {
1055 	int  i, ret, count;
1056 	unsigned char *p_cache, *p_src;
1057 
1058 	p_cache = kcalloc(size, sizeof(unsigned char), GFP_KERNEL);
1059 	if (!p_cache)
1060 		return -ENOMEM;
1061 
1062 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
1063 	memcpy(p_cache, buf, size);
1064 	p_src = p_cache;
1065 	count = size / sizeof(u32);
1066 
1067 	if (qlcnic_83xx_lock_flash(adapter) != 0) {
1068 		kfree(p_cache);
1069 		return -EIO;
1070 	}
1071 
1072 	if (adapter->ahw->fdt.mfg_id == adapter->flash_mfg_id) {
1073 		ret = qlcnic_83xx_enable_flash_write(adapter);
1074 		if (ret) {
1075 			kfree(p_cache);
1076 			qlcnic_83xx_unlock_flash(adapter);
1077 			return -EIO;
1078 		}
1079 	}
1080 
1081 	for (i = 0; i < count; i++) {
1082 		ret = qlcnic_83xx_flash_write32(adapter, offset, (u32 *)p_src);
1083 		if (ret) {
1084 			if (adapter->ahw->fdt.mfg_id == adapter->flash_mfg_id) {
1085 				ret = qlcnic_83xx_disable_flash_write(adapter);
1086 				if (ret) {
1087 					kfree(p_cache);
1088 					qlcnic_83xx_unlock_flash(adapter);
1089 					return -EIO;
1090 				}
1091 			}
1092 			kfree(p_cache);
1093 			qlcnic_83xx_unlock_flash(adapter);
1094 			return -EIO;
1095 		}
1096 
1097 		p_src = p_src + sizeof(u32);
1098 		offset = offset + sizeof(u32);
1099 	}
1100 
1101 	if (adapter->ahw->fdt.mfg_id == adapter->flash_mfg_id) {
1102 		ret = qlcnic_83xx_disable_flash_write(adapter);
1103 		if (ret) {
1104 			kfree(p_cache);
1105 			qlcnic_83xx_unlock_flash(adapter);
1106 			return -EIO;
1107 		}
1108 	}
1109 
1110 	kfree(p_cache);
1111 	qlcnic_83xx_unlock_flash(adapter);
1112 
1113 	return 0;
1114 }
1115 
1116 static ssize_t qlcnic_83xx_sysfs_flash_write_handler(struct file *filp,
1117 						     struct kobject *kobj,
1118 						     struct bin_attribute *attr,
1119 						     char *buf, loff_t offset,
1120 						     size_t size)
1121 {
1122 	int  ret;
1123 	static int flash_mode;
1124 	unsigned long data;
1125 	struct device *dev = kobj_to_dev(kobj);
1126 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
1127 
1128 	ret = kstrtoul(buf, 16, &data);
1129 	if (ret)
1130 		return ret;
1131 
1132 	switch (data) {
1133 	case QLC_83XX_FLASH_SECTOR_ERASE_CMD:
1134 		flash_mode = QLC_83XX_ERASE_MODE;
1135 		ret = qlcnic_83xx_erase_flash_sector(adapter, offset);
1136 		if (ret) {
1137 			dev_err(&adapter->pdev->dev,
1138 				"%s failed at %d\n", __func__, __LINE__);
1139 			return -EIO;
1140 		}
1141 		break;
1142 
1143 	case QLC_83XX_FLASH_BULK_WRITE_CMD:
1144 		flash_mode = QLC_83XX_BULK_WRITE_MODE;
1145 		break;
1146 
1147 	case QLC_83XX_FLASH_WRITE_CMD:
1148 		flash_mode = QLC_83XX_WRITE_MODE;
1149 		break;
1150 	default:
1151 		if (flash_mode == QLC_83XX_BULK_WRITE_MODE) {
1152 			ret = qlcnic_83xx_sysfs_flash_bulk_write(adapter, buf,
1153 								 offset, size);
1154 			if (ret) {
1155 				dev_err(&adapter->pdev->dev,
1156 					"%s failed at %d\n",
1157 					__func__, __LINE__);
1158 				return -EIO;
1159 			}
1160 		}
1161 
1162 		if (flash_mode == QLC_83XX_WRITE_MODE) {
1163 			ret = qlcnic_83xx_sysfs_flash_write(adapter, buf,
1164 							    offset, size);
1165 			if (ret) {
1166 				dev_err(&adapter->pdev->dev,
1167 					"%s failed at %d\n", __func__,
1168 					__LINE__);
1169 				return -EIO;
1170 			}
1171 		}
1172 	}
1173 
1174 	return size;
1175 }
1176 
1177 static const struct device_attribute dev_attr_bridged_mode = {
1178 	.attr = { .name = "bridged_mode", .mode = 0644 },
1179 	.show = qlcnic_show_bridged_mode,
1180 	.store = qlcnic_store_bridged_mode,
1181 };
1182 
1183 static const struct device_attribute dev_attr_diag_mode = {
1184 	.attr = { .name = "diag_mode", .mode = 0644 },
1185 	.show = qlcnic_show_diag_mode,
1186 	.store = qlcnic_store_diag_mode,
1187 };
1188 
1189 static const struct device_attribute dev_attr_beacon = {
1190 	.attr = { .name = "beacon", .mode = 0644 },
1191 	.show = qlcnic_show_beacon,
1192 	.store = qlcnic_store_beacon,
1193 };
1194 
1195 static const struct bin_attribute bin_attr_crb = {
1196 	.attr = { .name = "crb", .mode = 0644 },
1197 	.size = 0,
1198 	.read = qlcnic_sysfs_read_crb,
1199 	.write = qlcnic_sysfs_write_crb,
1200 };
1201 
1202 static const struct bin_attribute bin_attr_mem = {
1203 	.attr = { .name = "mem", .mode = 0644 },
1204 	.size = 0,
1205 	.read = qlcnic_sysfs_read_mem,
1206 	.write = qlcnic_sysfs_write_mem,
1207 };
1208 
1209 static const struct bin_attribute bin_attr_npar_config = {
1210 	.attr = { .name = "npar_config", .mode = 0644 },
1211 	.size = 0,
1212 	.read = qlcnic_sysfs_read_npar_config,
1213 	.write = qlcnic_sysfs_write_npar_config,
1214 };
1215 
1216 static const struct bin_attribute bin_attr_pci_config = {
1217 	.attr = { .name = "pci_config", .mode = 0644 },
1218 	.size = 0,
1219 	.read = qlcnic_sysfs_read_pci_config,
1220 	.write = NULL,
1221 };
1222 
1223 static const struct bin_attribute bin_attr_port_stats = {
1224 	.attr = { .name = "port_stats", .mode = 0644 },
1225 	.size = 0,
1226 	.read = qlcnic_sysfs_get_port_stats,
1227 	.write = qlcnic_sysfs_clear_port_stats,
1228 };
1229 
1230 static const struct bin_attribute bin_attr_esw_stats = {
1231 	.attr = { .name = "esw_stats", .mode = 0644 },
1232 	.size = 0,
1233 	.read = qlcnic_sysfs_get_esw_stats,
1234 	.write = qlcnic_sysfs_clear_esw_stats,
1235 };
1236 
1237 static const struct bin_attribute bin_attr_esw_config = {
1238 	.attr = { .name = "esw_config", .mode = 0644 },
1239 	.size = 0,
1240 	.read = qlcnic_sysfs_read_esw_config,
1241 	.write = qlcnic_sysfs_write_esw_config,
1242 };
1243 
1244 static const struct bin_attribute bin_attr_pm_config = {
1245 	.attr = { .name = "pm_config", .mode = 0644 },
1246 	.size = 0,
1247 	.read = qlcnic_sysfs_read_pm_config,
1248 	.write = qlcnic_sysfs_write_pm_config,
1249 };
1250 
1251 static const struct bin_attribute bin_attr_flash = {
1252 	.attr = { .name = "flash", .mode = 0644 },
1253 	.size = 0,
1254 	.read = qlcnic_83xx_sysfs_flash_read_handler,
1255 	.write = qlcnic_83xx_sysfs_flash_write_handler,
1256 };
1257 
1258 #ifdef CONFIG_QLCNIC_HWMON
1259 
1260 static ssize_t qlcnic_hwmon_show_temp(struct device *dev,
1261 				      struct device_attribute *dev_attr,
1262 				      char *buf)
1263 {
1264 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
1265 	unsigned int temperature = 0, value = 0;
1266 
1267 	if (qlcnic_83xx_check(adapter))
1268 		value = QLCRDX(adapter->ahw, QLC_83XX_ASIC_TEMP);
1269 	else if (qlcnic_82xx_check(adapter))
1270 		value = QLC_SHARED_REG_RD32(adapter, QLCNIC_ASIC_TEMP);
1271 
1272 	temperature = qlcnic_get_temp_val(value);
1273 	/* display millidegree celcius */
1274 	temperature *= 1000;
1275 	return sprintf(buf, "%u\n", temperature);
1276 }
1277 
1278 /* hwmon-sysfs attributes */
1279 static SENSOR_DEVICE_ATTR(temp1_input, 0444,
1280 			  qlcnic_hwmon_show_temp, NULL, 1);
1281 
1282 static struct attribute *qlcnic_hwmon_attrs[] = {
1283 	&sensor_dev_attr_temp1_input.dev_attr.attr,
1284 	NULL
1285 };
1286 
1287 ATTRIBUTE_GROUPS(qlcnic_hwmon);
1288 
1289 void qlcnic_register_hwmon_dev(struct qlcnic_adapter *adapter)
1290 {
1291 	struct device *dev = &adapter->pdev->dev;
1292 	struct device *hwmon_dev;
1293 
1294 	/* Skip hwmon registration for a VF device */
1295 	if (qlcnic_sriov_vf_check(adapter)) {
1296 		adapter->ahw->hwmon_dev = NULL;
1297 		return;
1298 	}
1299 	hwmon_dev = hwmon_device_register_with_groups(dev, qlcnic_driver_name,
1300 						      adapter,
1301 						      qlcnic_hwmon_groups);
1302 	if (IS_ERR(hwmon_dev)) {
1303 		dev_err(dev, "Cannot register with hwmon, err=%ld\n",
1304 			PTR_ERR(hwmon_dev));
1305 		hwmon_dev = NULL;
1306 	}
1307 	adapter->ahw->hwmon_dev = hwmon_dev;
1308 }
1309 
1310 void qlcnic_unregister_hwmon_dev(struct qlcnic_adapter *adapter)
1311 {
1312 	struct device *hwmon_dev = adapter->ahw->hwmon_dev;
1313 	if (hwmon_dev) {
1314 		hwmon_device_unregister(hwmon_dev);
1315 		adapter->ahw->hwmon_dev = NULL;
1316 	}
1317 }
1318 #endif
1319 
1320 void qlcnic_create_sysfs_entries(struct qlcnic_adapter *adapter)
1321 {
1322 	struct device *dev = &adapter->pdev->dev;
1323 
1324 	if (adapter->ahw->capabilities & QLCNIC_FW_CAPABILITY_BDG)
1325 		if (device_create_file(dev, &dev_attr_bridged_mode))
1326 			dev_warn(dev,
1327 				 "failed to create bridged_mode sysfs entry\n");
1328 }
1329 
1330 void qlcnic_remove_sysfs_entries(struct qlcnic_adapter *adapter)
1331 {
1332 	struct device *dev = &adapter->pdev->dev;
1333 
1334 	if (adapter->ahw->capabilities & QLCNIC_FW_CAPABILITY_BDG)
1335 		device_remove_file(dev, &dev_attr_bridged_mode);
1336 }
1337 
1338 static void qlcnic_create_diag_entries(struct qlcnic_adapter *adapter)
1339 {
1340 	struct device *dev = &adapter->pdev->dev;
1341 
1342 	if (device_create_bin_file(dev, &bin_attr_port_stats))
1343 		dev_info(dev, "failed to create port stats sysfs entry");
1344 
1345 	if (adapter->ahw->op_mode == QLCNIC_NON_PRIV_FUNC)
1346 		return;
1347 	if (device_create_file(dev, &dev_attr_diag_mode))
1348 		dev_info(dev, "failed to create diag_mode sysfs entry\n");
1349 	if (device_create_bin_file(dev, &bin_attr_crb))
1350 		dev_info(dev, "failed to create crb sysfs entry\n");
1351 	if (device_create_bin_file(dev, &bin_attr_mem))
1352 		dev_info(dev, "failed to create mem sysfs entry\n");
1353 
1354 	if (test_bit(__QLCNIC_MAINTENANCE_MODE, &adapter->state))
1355 		return;
1356 
1357 	if (device_create_bin_file(dev, &bin_attr_pci_config))
1358 		dev_info(dev, "failed to create pci config sysfs entry");
1359 
1360 	if (device_create_file(dev, &dev_attr_beacon))
1361 		dev_info(dev, "failed to create beacon sysfs entry");
1362 
1363 	if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
1364 		return;
1365 	if (device_create_bin_file(dev, &bin_attr_esw_config))
1366 		dev_info(dev, "failed to create esw config sysfs entry");
1367 	if (adapter->ahw->op_mode != QLCNIC_MGMT_FUNC)
1368 		return;
1369 	if (device_create_bin_file(dev, &bin_attr_npar_config))
1370 		dev_info(dev, "failed to create npar config sysfs entry");
1371 	if (device_create_bin_file(dev, &bin_attr_pm_config))
1372 		dev_info(dev, "failed to create pm config sysfs entry");
1373 	if (device_create_bin_file(dev, &bin_attr_esw_stats))
1374 		dev_info(dev, "failed to create eswitch stats sysfs entry");
1375 }
1376 
1377 static void qlcnic_remove_diag_entries(struct qlcnic_adapter *adapter)
1378 {
1379 	struct device *dev = &adapter->pdev->dev;
1380 
1381 	device_remove_bin_file(dev, &bin_attr_port_stats);
1382 
1383 	if (adapter->ahw->op_mode == QLCNIC_NON_PRIV_FUNC)
1384 		return;
1385 	device_remove_file(dev, &dev_attr_diag_mode);
1386 	device_remove_bin_file(dev, &bin_attr_crb);
1387 	device_remove_bin_file(dev, &bin_attr_mem);
1388 
1389 	if (test_bit(__QLCNIC_MAINTENANCE_MODE, &adapter->state))
1390 		return;
1391 
1392 	device_remove_bin_file(dev, &bin_attr_pci_config);
1393 	device_remove_file(dev, &dev_attr_beacon);
1394 	if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
1395 		return;
1396 	device_remove_bin_file(dev, &bin_attr_esw_config);
1397 	if (adapter->ahw->op_mode != QLCNIC_MGMT_FUNC)
1398 		return;
1399 	device_remove_bin_file(dev, &bin_attr_npar_config);
1400 	device_remove_bin_file(dev, &bin_attr_pm_config);
1401 	device_remove_bin_file(dev, &bin_attr_esw_stats);
1402 }
1403 
1404 void qlcnic_82xx_add_sysfs(struct qlcnic_adapter *adapter)
1405 {
1406 	qlcnic_create_diag_entries(adapter);
1407 }
1408 
1409 void qlcnic_82xx_remove_sysfs(struct qlcnic_adapter *adapter)
1410 {
1411 	qlcnic_remove_diag_entries(adapter);
1412 }
1413 
1414 void qlcnic_83xx_add_sysfs(struct qlcnic_adapter *adapter)
1415 {
1416 	struct device *dev = &adapter->pdev->dev;
1417 
1418 	qlcnic_create_diag_entries(adapter);
1419 
1420 	if (sysfs_create_bin_file(&dev->kobj, &bin_attr_flash))
1421 		dev_info(dev, "failed to create flash sysfs entry\n");
1422 }
1423 
1424 void qlcnic_83xx_remove_sysfs(struct qlcnic_adapter *adapter)
1425 {
1426 	struct device *dev = &adapter->pdev->dev;
1427 
1428 	qlcnic_remove_diag_entries(adapter);
1429 	sysfs_remove_bin_file(&dev->kobj, &bin_attr_flash);
1430 }
1431