1 /*
2  * QLogic qlcnic NIC Driver
3  * Copyright (c) 2009-2013 QLogic Corporation
4  *
5  * See LICENSE.qlcnic for copyright and licensing details.
6  */
7 
8 #include <linux/slab.h>
9 #include <linux/interrupt.h>
10 #include <linux/swab.h>
11 #include <linux/dma-mapping.h>
12 #include <net/ip.h>
13 #include <linux/ipv6.h>
14 #include <linux/inetdevice.h>
15 #include <linux/sysfs.h>
16 #include <linux/aer.h>
17 #include <linux/log2.h>
18 #ifdef CONFIG_QLCNIC_HWMON
19 #include <linux/hwmon.h>
20 #include <linux/hwmon-sysfs.h>
21 #endif
22 
23 #include "qlcnic.h"
24 #include "qlcnic_hw.h"
25 
26 int qlcnicvf_config_bridged_mode(struct qlcnic_adapter *adapter, u32 enable)
27 {
28 	return -EOPNOTSUPP;
29 }
30 
31 int qlcnicvf_config_led(struct qlcnic_adapter *adapter, u32 state, u32 rate)
32 {
33 	return -EOPNOTSUPP;
34 }
35 
36 static ssize_t qlcnic_store_bridged_mode(struct device *dev,
37 					 struct device_attribute *attr,
38 					 const char *buf, size_t len)
39 {
40 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
41 	unsigned long new;
42 	int ret = -EINVAL;
43 
44 	if (!(adapter->ahw->capabilities & QLCNIC_FW_CAPABILITY_BDG))
45 		goto err_out;
46 
47 	if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
48 		goto err_out;
49 
50 	if (kstrtoul(buf, 2, &new))
51 		goto err_out;
52 
53 	if (!qlcnic_config_bridged_mode(adapter, !!new))
54 		ret = len;
55 
56 err_out:
57 	return ret;
58 }
59 
60 static ssize_t qlcnic_show_bridged_mode(struct device *dev,
61 					struct device_attribute *attr,
62 					char *buf)
63 {
64 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
65 	int bridged_mode = 0;
66 
67 	if (adapter->ahw->capabilities & QLCNIC_FW_CAPABILITY_BDG)
68 		bridged_mode = !!(adapter->flags & QLCNIC_BRIDGE_ENABLED);
69 
70 	return sprintf(buf, "%d\n", bridged_mode);
71 }
72 
73 static ssize_t qlcnic_store_diag_mode(struct device *dev,
74 				      struct device_attribute *attr,
75 				      const char *buf, size_t len)
76 {
77 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
78 	unsigned long new;
79 
80 	if (kstrtoul(buf, 2, &new))
81 		return -EINVAL;
82 
83 	if (!!new != !!(adapter->flags & QLCNIC_DIAG_ENABLED))
84 		adapter->flags ^= QLCNIC_DIAG_ENABLED;
85 
86 	return len;
87 }
88 
89 static ssize_t qlcnic_show_diag_mode(struct device *dev,
90 				     struct device_attribute *attr, char *buf)
91 {
92 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
93 	return sprintf(buf, "%d\n", !!(adapter->flags & QLCNIC_DIAG_ENABLED));
94 }
95 
96 static int qlcnic_validate_beacon(struct qlcnic_adapter *adapter, u16 beacon,
97 				  u8 *state, u8 *rate)
98 {
99 	*rate = LSB(beacon);
100 	*state = MSB(beacon);
101 
102 	QLCDB(adapter, DRV, "rate %x state %x\n", *rate, *state);
103 
104 	if (!*state) {
105 		*rate = __QLCNIC_MAX_LED_RATE;
106 		return 0;
107 	} else if (*state > __QLCNIC_MAX_LED_STATE) {
108 		return -EINVAL;
109 	}
110 
111 	if ((!*rate) || (*rate > __QLCNIC_MAX_LED_RATE))
112 		return -EINVAL;
113 
114 	return 0;
115 }
116 
117 static int qlcnic_83xx_store_beacon(struct qlcnic_adapter *adapter,
118 				    const char *buf, size_t len)
119 {
120 	struct qlcnic_hardware_context *ahw = adapter->ahw;
121 	unsigned long h_beacon;
122 	int err;
123 
124 	if (test_bit(__QLCNIC_RESETTING, &adapter->state))
125 		return -EIO;
126 
127 	if (kstrtoul(buf, 2, &h_beacon))
128 		return -EINVAL;
129 
130 	qlcnic_get_beacon_state(adapter);
131 
132 	if (ahw->beacon_state == h_beacon)
133 		return len;
134 
135 	rtnl_lock();
136 	if (!ahw->beacon_state) {
137 		if (test_and_set_bit(__QLCNIC_LED_ENABLE, &adapter->state)) {
138 			rtnl_unlock();
139 			return -EBUSY;
140 		}
141 	}
142 
143 	if (h_beacon)
144 		err = qlcnic_83xx_config_led(adapter, 1, h_beacon);
145 	else
146 		err = qlcnic_83xx_config_led(adapter, 0, !h_beacon);
147 	if (!err)
148 		ahw->beacon_state = h_beacon;
149 
150 	if (!ahw->beacon_state)
151 		clear_bit(__QLCNIC_LED_ENABLE, &adapter->state);
152 
153 	rtnl_unlock();
154 	return len;
155 }
156 
157 static int qlcnic_82xx_store_beacon(struct qlcnic_adapter *adapter,
158 				    const char *buf, size_t len)
159 {
160 	struct qlcnic_hardware_context *ahw = adapter->ahw;
161 	int err, drv_sds_rings = adapter->drv_sds_rings;
162 	u16 beacon;
163 	u8 b_state, b_rate;
164 
165 	if (len != sizeof(u16))
166 		return -EINVAL;
167 
168 	memcpy(&beacon, buf, sizeof(u16));
169 	err = qlcnic_validate_beacon(adapter, beacon, &b_state, &b_rate);
170 	if (err)
171 		return err;
172 
173 	qlcnic_get_beacon_state(adapter);
174 
175 	if (ahw->beacon_state == b_state)
176 		return len;
177 
178 	rtnl_lock();
179 	if (!ahw->beacon_state) {
180 		if (test_and_set_bit(__QLCNIC_LED_ENABLE, &adapter->state)) {
181 			rtnl_unlock();
182 			return -EBUSY;
183 		}
184 	}
185 
186 	if (test_bit(__QLCNIC_RESETTING, &adapter->state)) {
187 		err = -EIO;
188 		goto out;
189 	}
190 
191 	if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
192 		err = qlcnic_diag_alloc_res(adapter->netdev, QLCNIC_LED_TEST);
193 		if (err)
194 			goto out;
195 		set_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state);
196 	}
197 
198 	err = qlcnic_config_led(adapter, b_state, b_rate);
199 	if (!err) {
200 		err = len;
201 		ahw->beacon_state = b_state;
202 	}
203 
204 	if (test_and_clear_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state))
205 		qlcnic_diag_free_res(adapter->netdev, drv_sds_rings);
206 
207 out:
208 	if (!ahw->beacon_state)
209 		clear_bit(__QLCNIC_LED_ENABLE, &adapter->state);
210 	rtnl_unlock();
211 
212 	return err;
213 }
214 
215 static ssize_t qlcnic_store_beacon(struct device *dev,
216 				   struct device_attribute *attr,
217 				   const char *buf, size_t len)
218 {
219 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
220 	int err = 0;
221 
222 	if (adapter->ahw->op_mode == QLCNIC_NON_PRIV_FUNC) {
223 		dev_warn(dev,
224 			 "LED test not supported in non privileged mode\n");
225 		return -EOPNOTSUPP;
226 	}
227 
228 	if (qlcnic_82xx_check(adapter))
229 		err = qlcnic_82xx_store_beacon(adapter, buf, len);
230 	else if (qlcnic_83xx_check(adapter))
231 		err = qlcnic_83xx_store_beacon(adapter, buf, len);
232 	else
233 		return -EIO;
234 
235 	return err;
236 }
237 
238 static ssize_t qlcnic_show_beacon(struct device *dev,
239 				  struct device_attribute *attr, char *buf)
240 {
241 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
242 
243 	return sprintf(buf, "%d\n", adapter->ahw->beacon_state);
244 }
245 
246 static int qlcnic_sysfs_validate_crb(struct qlcnic_adapter *adapter,
247 				     loff_t offset, size_t size)
248 {
249 	size_t crb_size = 4;
250 
251 	if (!(adapter->flags & QLCNIC_DIAG_ENABLED))
252 		return -EIO;
253 
254 	if (offset < QLCNIC_PCI_CRBSPACE) {
255 		if (ADDR_IN_RANGE(offset, QLCNIC_PCI_CAMQM,
256 				  QLCNIC_PCI_CAMQM_END))
257 			crb_size = 8;
258 		else
259 			return -EINVAL;
260 	}
261 
262 	if ((size != crb_size) || (offset & (crb_size-1)))
263 		return  -EINVAL;
264 
265 	return 0;
266 }
267 
268 static ssize_t qlcnic_sysfs_read_crb(struct file *filp, struct kobject *kobj,
269 				     struct bin_attribute *attr, char *buf,
270 				     loff_t offset, size_t size)
271 {
272 	struct device *dev = container_of(kobj, struct device, kobj);
273 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
274 	int ret;
275 
276 	ret = qlcnic_sysfs_validate_crb(adapter, offset, size);
277 	if (ret != 0)
278 		return ret;
279 	qlcnic_read_crb(adapter, buf, offset, size);
280 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
281 
282 	return size;
283 }
284 
285 static ssize_t qlcnic_sysfs_write_crb(struct file *filp, struct kobject *kobj,
286 				      struct bin_attribute *attr, char *buf,
287 				      loff_t offset, size_t size)
288 {
289 	struct device *dev = container_of(kobj, struct device, kobj);
290 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
291 	int ret;
292 
293 	ret = qlcnic_sysfs_validate_crb(adapter, offset, size);
294 	if (ret != 0)
295 		return ret;
296 
297 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
298 	qlcnic_write_crb(adapter, buf, offset, size);
299 	return size;
300 }
301 
302 static int qlcnic_sysfs_validate_mem(struct qlcnic_adapter *adapter,
303 				     loff_t offset, size_t size)
304 {
305 	if (!(adapter->flags & QLCNIC_DIAG_ENABLED))
306 		return -EIO;
307 
308 	if ((size != 8) || (offset & 0x7))
309 		return  -EIO;
310 
311 	return 0;
312 }
313 
314 static ssize_t qlcnic_sysfs_read_mem(struct file *filp, struct kobject *kobj,
315 				     struct bin_attribute *attr, char *buf,
316 				     loff_t offset, size_t size)
317 {
318 	struct device *dev = container_of(kobj, struct device, kobj);
319 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
320 	u64 data;
321 	int ret;
322 
323 	ret = qlcnic_sysfs_validate_mem(adapter, offset, size);
324 	if (ret != 0)
325 		return ret;
326 
327 	if (qlcnic_pci_mem_read_2M(adapter, offset, &data))
328 		return -EIO;
329 
330 	memcpy(buf, &data, size);
331 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
332 
333 	return size;
334 }
335 
336 static ssize_t qlcnic_sysfs_write_mem(struct file *filp, struct kobject *kobj,
337 				      struct bin_attribute *attr, char *buf,
338 				      loff_t offset, size_t size)
339 {
340 	struct device *dev = container_of(kobj, struct device, kobj);
341 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
342 	u64 data;
343 	int ret;
344 
345 	ret = qlcnic_sysfs_validate_mem(adapter, offset, size);
346 	if (ret != 0)
347 		return ret;
348 
349 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
350 	memcpy(&data, buf, size);
351 
352 	if (qlcnic_pci_mem_write_2M(adapter, offset, data))
353 		return -EIO;
354 
355 	return size;
356 }
357 
358 int qlcnic_is_valid_nic_func(struct qlcnic_adapter *adapter, u8 pci_func)
359 {
360 	int i;
361 
362 	for (i = 0; i < adapter->ahw->total_nic_func; i++) {
363 		if (adapter->npars[i].pci_func == pci_func)
364 			return i;
365 	}
366 
367 	dev_err(&adapter->pdev->dev, "%s: Invalid nic function\n", __func__);
368 	return -EINVAL;
369 }
370 
371 static int validate_pm_config(struct qlcnic_adapter *adapter,
372 			      struct qlcnic_pm_func_cfg *pm_cfg, int count)
373 {
374 	u8 src_pci_func, s_esw_id, d_esw_id;
375 	u8 dest_pci_func;
376 	int i, src_index, dest_index;
377 
378 	for (i = 0; i < count; i++) {
379 		src_pci_func = pm_cfg[i].pci_func;
380 		dest_pci_func = pm_cfg[i].dest_npar;
381 		src_index = qlcnic_is_valid_nic_func(adapter, src_pci_func);
382 		if (src_index < 0)
383 			return -EINVAL;
384 
385 		dest_index = qlcnic_is_valid_nic_func(adapter, dest_pci_func);
386 		if (dest_index < 0)
387 			return -EINVAL;
388 
389 		s_esw_id = adapter->npars[src_index].phy_port;
390 		d_esw_id = adapter->npars[dest_index].phy_port;
391 
392 		if (s_esw_id != d_esw_id)
393 			return -EINVAL;
394 	}
395 
396 	return 0;
397 }
398 
399 static ssize_t qlcnic_sysfs_write_pm_config(struct file *filp,
400 					    struct kobject *kobj,
401 					    struct bin_attribute *attr,
402 					    char *buf, loff_t offset,
403 					    size_t size)
404 {
405 	struct device *dev = container_of(kobj, struct device, kobj);
406 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
407 	struct qlcnic_pm_func_cfg *pm_cfg;
408 	u32 id, action, pci_func;
409 	int count, rem, i, ret, index;
410 
411 	count	= size / sizeof(struct qlcnic_pm_func_cfg);
412 	rem	= size % sizeof(struct qlcnic_pm_func_cfg);
413 	if (rem)
414 		return -EINVAL;
415 
416 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
417 	pm_cfg = (struct qlcnic_pm_func_cfg *)buf;
418 	ret = validate_pm_config(adapter, pm_cfg, count);
419 
420 	if (ret)
421 		return ret;
422 	for (i = 0; i < count; i++) {
423 		pci_func = pm_cfg[i].pci_func;
424 		action = !!pm_cfg[i].action;
425 		index = qlcnic_is_valid_nic_func(adapter, pci_func);
426 		if (index < 0)
427 			return -EINVAL;
428 
429 		id = adapter->npars[index].phy_port;
430 		ret = qlcnic_config_port_mirroring(adapter, id,
431 						   action, pci_func);
432 		if (ret)
433 			return ret;
434 	}
435 
436 	for (i = 0; i < count; i++) {
437 		pci_func = pm_cfg[i].pci_func;
438 		index = qlcnic_is_valid_nic_func(adapter, pci_func);
439 		if (index < 0)
440 			return -EINVAL;
441 		id = adapter->npars[index].phy_port;
442 		adapter->npars[index].enable_pm = !!pm_cfg[i].action;
443 		adapter->npars[index].dest_npar = id;
444 	}
445 
446 	return size;
447 }
448 
449 static ssize_t qlcnic_sysfs_read_pm_config(struct file *filp,
450 					   struct kobject *kobj,
451 					   struct bin_attribute *attr,
452 					   char *buf, loff_t offset,
453 					   size_t size)
454 {
455 	struct device *dev = container_of(kobj, struct device, kobj);
456 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
457 	struct qlcnic_pm_func_cfg *pm_cfg;
458 	u8 pci_func;
459 	u32 count;
460 	int i;
461 
462 	memset(buf, 0, size);
463 	pm_cfg = (struct qlcnic_pm_func_cfg *)buf;
464 	count = size / sizeof(struct qlcnic_pm_func_cfg);
465 	for (i = 0; i < adapter->ahw->total_nic_func; i++) {
466 		pci_func = adapter->npars[i].pci_func;
467 		if (pci_func >= count) {
468 			dev_dbg(dev, "%s: Total nic functions[%d], App sent function count[%d]\n",
469 				__func__, adapter->ahw->total_nic_func, count);
470 			continue;
471 		}
472 		if (!adapter->npars[i].eswitch_status)
473 			continue;
474 
475 		pm_cfg[pci_func].action = adapter->npars[i].enable_pm;
476 		pm_cfg[pci_func].dest_npar = 0;
477 		pm_cfg[pci_func].pci_func = i;
478 	}
479 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
480 	return size;
481 }
482 
483 static int validate_esw_config(struct qlcnic_adapter *adapter,
484 			       struct qlcnic_esw_func_cfg *esw_cfg, int count)
485 {
486 	struct qlcnic_hardware_context *ahw = adapter->ahw;
487 	int i, ret;
488 	u32 op_mode;
489 	u8 pci_func;
490 
491 	if (qlcnic_82xx_check(adapter))
492 		op_mode = readl(ahw->pci_base0 + QLCNIC_DRV_OP_MODE);
493 	else
494 		op_mode = QLCRDX(ahw, QLC_83XX_DRV_OP_MODE);
495 
496 	for (i = 0; i < count; i++) {
497 		pci_func = esw_cfg[i].pci_func;
498 		if (pci_func >= ahw->max_vnic_func)
499 			return -EINVAL;
500 
501 		if (adapter->ahw->op_mode == QLCNIC_MGMT_FUNC)
502 			if (qlcnic_is_valid_nic_func(adapter, pci_func) < 0)
503 				return -EINVAL;
504 
505 		switch (esw_cfg[i].op_mode) {
506 		case QLCNIC_PORT_DEFAULTS:
507 			if (qlcnic_82xx_check(adapter)) {
508 				ret = QLC_DEV_GET_DRV(op_mode, pci_func);
509 			} else {
510 				ret = QLC_83XX_GET_FUNC_PRIVILEGE(op_mode,
511 								  pci_func);
512 				esw_cfg[i].offload_flags = 0;
513 			}
514 
515 			if (ret != QLCNIC_NON_PRIV_FUNC) {
516 				if (esw_cfg[i].mac_anti_spoof != 0)
517 					return -EINVAL;
518 				if (esw_cfg[i].mac_override != 1)
519 					return -EINVAL;
520 				if (esw_cfg[i].promisc_mode != 1)
521 					return -EINVAL;
522 			}
523 			break;
524 		case QLCNIC_ADD_VLAN:
525 			if (!IS_VALID_VLAN(esw_cfg[i].vlan_id))
526 				return -EINVAL;
527 			if (!esw_cfg[i].op_type)
528 				return -EINVAL;
529 			break;
530 		case QLCNIC_DEL_VLAN:
531 			if (!esw_cfg[i].op_type)
532 				return -EINVAL;
533 			break;
534 		default:
535 			return -EINVAL;
536 		}
537 	}
538 
539 	return 0;
540 }
541 
542 static ssize_t qlcnic_sysfs_write_esw_config(struct file *file,
543 					     struct kobject *kobj,
544 					     struct bin_attribute *attr,
545 					     char *buf, loff_t offset,
546 					     size_t size)
547 {
548 	struct device *dev = container_of(kobj, struct device, kobj);
549 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
550 	struct qlcnic_esw_func_cfg *esw_cfg;
551 	struct qlcnic_npar_info *npar;
552 	int count, rem, i, ret;
553 	int index;
554 	u8 op_mode = 0, pci_func;
555 
556 	count	= size / sizeof(struct qlcnic_esw_func_cfg);
557 	rem	= size % sizeof(struct qlcnic_esw_func_cfg);
558 	if (rem)
559 		return -EINVAL;
560 
561 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
562 	esw_cfg = (struct qlcnic_esw_func_cfg *)buf;
563 	ret = validate_esw_config(adapter, esw_cfg, count);
564 	if (ret)
565 		return ret;
566 
567 	for (i = 0; i < count; i++) {
568 		if (adapter->ahw->op_mode == QLCNIC_MGMT_FUNC)
569 			if (qlcnic_config_switch_port(adapter, &esw_cfg[i]))
570 				return -EINVAL;
571 
572 		if (adapter->ahw->pci_func != esw_cfg[i].pci_func)
573 			continue;
574 
575 		op_mode = esw_cfg[i].op_mode;
576 		qlcnic_get_eswitch_port_config(adapter, &esw_cfg[i]);
577 		esw_cfg[i].op_mode = op_mode;
578 		esw_cfg[i].pci_func = adapter->ahw->pci_func;
579 
580 		switch (esw_cfg[i].op_mode) {
581 		case QLCNIC_PORT_DEFAULTS:
582 			qlcnic_set_eswitch_port_features(adapter, &esw_cfg[i]);
583 			rtnl_lock();
584 			qlcnic_set_netdev_features(adapter, &esw_cfg[i]);
585 			rtnl_unlock();
586 			break;
587 		case QLCNIC_ADD_VLAN:
588 			qlcnic_set_vlan_config(adapter, &esw_cfg[i]);
589 			break;
590 		case QLCNIC_DEL_VLAN:
591 			esw_cfg[i].vlan_id = 0;
592 			qlcnic_set_vlan_config(adapter, &esw_cfg[i]);
593 			break;
594 		}
595 	}
596 
597 	if (adapter->ahw->op_mode != QLCNIC_MGMT_FUNC)
598 		goto out;
599 
600 	for (i = 0; i < count; i++) {
601 		pci_func = esw_cfg[i].pci_func;
602 		index = qlcnic_is_valid_nic_func(adapter, pci_func);
603 		if (index < 0)
604 			return -EINVAL;
605 		npar = &adapter->npars[index];
606 		switch (esw_cfg[i].op_mode) {
607 		case QLCNIC_PORT_DEFAULTS:
608 			npar->promisc_mode = esw_cfg[i].promisc_mode;
609 			npar->mac_override = esw_cfg[i].mac_override;
610 			npar->offload_flags = esw_cfg[i].offload_flags;
611 			npar->mac_anti_spoof = esw_cfg[i].mac_anti_spoof;
612 			npar->discard_tagged = esw_cfg[i].discard_tagged;
613 			break;
614 		case QLCNIC_ADD_VLAN:
615 			npar->pvid = esw_cfg[i].vlan_id;
616 			break;
617 		case QLCNIC_DEL_VLAN:
618 			npar->pvid = 0;
619 			break;
620 		}
621 	}
622 out:
623 	return size;
624 }
625 
626 static ssize_t qlcnic_sysfs_read_esw_config(struct file *file,
627 					    struct kobject *kobj,
628 					    struct bin_attribute *attr,
629 					    char *buf, loff_t offset,
630 					    size_t size)
631 {
632 	struct device *dev = container_of(kobj, struct device, kobj);
633 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
634 	struct qlcnic_esw_func_cfg *esw_cfg;
635 	u8 pci_func;
636 	u32 count;
637 	int i;
638 
639 	memset(buf, 0, size);
640 	esw_cfg = (struct qlcnic_esw_func_cfg *)buf;
641 	count = size / sizeof(struct qlcnic_esw_func_cfg);
642 	for (i = 0; i < adapter->ahw->total_nic_func; i++) {
643 		pci_func = adapter->npars[i].pci_func;
644 		if (pci_func >= count) {
645 			dev_dbg(dev, "%s: Total nic functions[%d], App sent function count[%d]\n",
646 				__func__, adapter->ahw->total_nic_func, count);
647 			continue;
648 		}
649 		if (!adapter->npars[i].eswitch_status)
650 			continue;
651 
652 		esw_cfg[pci_func].pci_func = pci_func;
653 		if (qlcnic_get_eswitch_port_config(adapter, &esw_cfg[pci_func]))
654 			return -EINVAL;
655 	}
656 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
657 	return size;
658 }
659 
660 static int validate_npar_config(struct qlcnic_adapter *adapter,
661 				struct qlcnic_npar_func_cfg *np_cfg,
662 				int count)
663 {
664 	u8 pci_func, i;
665 
666 	for (i = 0; i < count; i++) {
667 		pci_func = np_cfg[i].pci_func;
668 		if (qlcnic_is_valid_nic_func(adapter, pci_func) < 0)
669 			return -EINVAL;
670 
671 		if (!IS_VALID_BW(np_cfg[i].min_bw) ||
672 		    !IS_VALID_BW(np_cfg[i].max_bw))
673 			return -EINVAL;
674 	}
675 	return 0;
676 }
677 
678 static ssize_t qlcnic_sysfs_write_npar_config(struct file *file,
679 					      struct kobject *kobj,
680 					      struct bin_attribute *attr,
681 					      char *buf, loff_t offset,
682 					      size_t size)
683 {
684 	struct device *dev = container_of(kobj, struct device, kobj);
685 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
686 	struct qlcnic_info nic_info;
687 	struct qlcnic_npar_func_cfg *np_cfg;
688 	int i, count, rem, ret, index;
689 	u8 pci_func;
690 
691 	count	= size / sizeof(struct qlcnic_npar_func_cfg);
692 	rem	= size % sizeof(struct qlcnic_npar_func_cfg);
693 	if (rem)
694 		return -EINVAL;
695 
696 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
697 	np_cfg = (struct qlcnic_npar_func_cfg *)buf;
698 	ret = validate_npar_config(adapter, np_cfg, count);
699 	if (ret)
700 		return ret;
701 
702 	for (i = 0; i < count; i++) {
703 		pci_func = np_cfg[i].pci_func;
704 
705 		memset(&nic_info, 0, sizeof(struct qlcnic_info));
706 		ret = qlcnic_get_nic_info(adapter, &nic_info, pci_func);
707 		if (ret)
708 			return ret;
709 		nic_info.pci_func = pci_func;
710 		nic_info.min_tx_bw = np_cfg[i].min_bw;
711 		nic_info.max_tx_bw = np_cfg[i].max_bw;
712 		ret = qlcnic_set_nic_info(adapter, &nic_info);
713 		if (ret)
714 			return ret;
715 		index = qlcnic_is_valid_nic_func(adapter, pci_func);
716 		if (index < 0)
717 			return -EINVAL;
718 		adapter->npars[index].min_bw = nic_info.min_tx_bw;
719 		adapter->npars[index].max_bw = nic_info.max_tx_bw;
720 	}
721 
722 	return size;
723 }
724 
725 static ssize_t qlcnic_sysfs_read_npar_config(struct file *file,
726 					     struct kobject *kobj,
727 					     struct bin_attribute *attr,
728 					     char *buf, loff_t offset,
729 					     size_t size)
730 {
731 	struct device *dev = container_of(kobj, struct device, kobj);
732 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
733 	struct qlcnic_npar_func_cfg *np_cfg;
734 	struct qlcnic_info nic_info;
735 	u8 pci_func;
736 	int i, ret;
737 	u32 count;
738 
739 	memset(&nic_info, 0, sizeof(struct qlcnic_info));
740 	memset(buf, 0, size);
741 	np_cfg = (struct qlcnic_npar_func_cfg *)buf;
742 
743 	count = size / sizeof(struct qlcnic_npar_func_cfg);
744 	for (i = 0; i < adapter->ahw->total_nic_func; i++) {
745 		if (adapter->npars[i].pci_func >= count) {
746 			dev_dbg(dev, "%s: Total nic functions[%d], App sent function count[%d]\n",
747 				__func__, adapter->ahw->total_nic_func, count);
748 			continue;
749 		}
750 		if (!adapter->npars[i].eswitch_status)
751 			continue;
752 		pci_func = adapter->npars[i].pci_func;
753 		if (qlcnic_is_valid_nic_func(adapter, pci_func) < 0)
754 			continue;
755 		ret = qlcnic_get_nic_info(adapter, &nic_info, pci_func);
756 		if (ret)
757 			return ret;
758 
759 		np_cfg[pci_func].pci_func = pci_func;
760 		np_cfg[pci_func].op_mode = (u8)nic_info.op_mode;
761 		np_cfg[pci_func].port_num = nic_info.phys_port;
762 		np_cfg[pci_func].fw_capab = nic_info.capabilities;
763 		np_cfg[pci_func].min_bw = nic_info.min_tx_bw;
764 		np_cfg[pci_func].max_bw = nic_info.max_tx_bw;
765 		np_cfg[pci_func].max_tx_queues = nic_info.max_tx_ques;
766 		np_cfg[pci_func].max_rx_queues = nic_info.max_rx_ques;
767 	}
768 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
769 	return size;
770 }
771 
772 static ssize_t qlcnic_sysfs_get_port_stats(struct file *file,
773 					   struct kobject *kobj,
774 					   struct bin_attribute *attr,
775 					   char *buf, loff_t offset,
776 					   size_t size)
777 {
778 	struct device *dev = container_of(kobj, struct device, kobj);
779 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
780 	struct qlcnic_esw_statistics port_stats;
781 	int ret;
782 
783 	if (qlcnic_83xx_check(adapter))
784 		return -EOPNOTSUPP;
785 
786 	if (size != sizeof(struct qlcnic_esw_statistics))
787 		return -EINVAL;
788 
789 	if (offset >= adapter->ahw->max_vnic_func)
790 		return -EINVAL;
791 
792 	memset(&port_stats, 0, size);
793 	ret = qlcnic_get_port_stats(adapter, offset, QLCNIC_QUERY_RX_COUNTER,
794 				    &port_stats.rx);
795 	if (ret)
796 		return ret;
797 
798 	ret = qlcnic_get_port_stats(adapter, offset, QLCNIC_QUERY_TX_COUNTER,
799 				    &port_stats.tx);
800 	if (ret)
801 		return ret;
802 
803 	memcpy(buf, &port_stats, size);
804 	return size;
805 }
806 
807 static ssize_t qlcnic_sysfs_get_esw_stats(struct file *file,
808 					  struct kobject *kobj,
809 					  struct bin_attribute *attr,
810 					  char *buf, loff_t offset,
811 					  size_t size)
812 {
813 	struct device *dev = container_of(kobj, struct device, kobj);
814 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
815 	struct qlcnic_esw_statistics esw_stats;
816 	int ret;
817 
818 	if (qlcnic_83xx_check(adapter))
819 		return -EOPNOTSUPP;
820 
821 	if (size != sizeof(struct qlcnic_esw_statistics))
822 		return -EINVAL;
823 
824 	if (offset >= QLCNIC_NIU_MAX_XG_PORTS)
825 		return -EINVAL;
826 
827 	memset(&esw_stats, 0, size);
828 	ret = qlcnic_get_eswitch_stats(adapter, offset, QLCNIC_QUERY_RX_COUNTER,
829 				       &esw_stats.rx);
830 	if (ret)
831 		return ret;
832 
833 	ret = qlcnic_get_eswitch_stats(adapter, offset, QLCNIC_QUERY_TX_COUNTER,
834 				       &esw_stats.tx);
835 	if (ret)
836 		return ret;
837 
838 	memcpy(buf, &esw_stats, size);
839 	return size;
840 }
841 
842 static ssize_t qlcnic_sysfs_clear_esw_stats(struct file *file,
843 					    struct kobject *kobj,
844 					    struct bin_attribute *attr,
845 					    char *buf, loff_t offset,
846 					    size_t size)
847 {
848 	struct device *dev = container_of(kobj, struct device, kobj);
849 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
850 	int ret;
851 
852 	if (qlcnic_83xx_check(adapter))
853 		return -EOPNOTSUPP;
854 
855 	if (offset >= QLCNIC_NIU_MAX_XG_PORTS)
856 		return -EINVAL;
857 
858 	ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_ESWITCH, offset,
859 				     QLCNIC_QUERY_RX_COUNTER);
860 	if (ret)
861 		return ret;
862 
863 	ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_ESWITCH, offset,
864 				     QLCNIC_QUERY_TX_COUNTER);
865 	if (ret)
866 		return ret;
867 
868 	return size;
869 }
870 
871 static ssize_t qlcnic_sysfs_clear_port_stats(struct file *file,
872 					     struct kobject *kobj,
873 					     struct bin_attribute *attr,
874 					     char *buf, loff_t offset,
875 					     size_t size)
876 {
877 
878 	struct device *dev = container_of(kobj, struct device, kobj);
879 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
880 	int ret;
881 
882 	if (qlcnic_83xx_check(adapter))
883 		return -EOPNOTSUPP;
884 
885 	if (offset >= adapter->ahw->max_vnic_func)
886 		return -EINVAL;
887 
888 	ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_PORT, offset,
889 				     QLCNIC_QUERY_RX_COUNTER);
890 	if (ret)
891 		return ret;
892 
893 	ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_PORT, offset,
894 				     QLCNIC_QUERY_TX_COUNTER);
895 	if (ret)
896 		return ret;
897 
898 	return size;
899 }
900 
901 static ssize_t qlcnic_sysfs_read_pci_config(struct file *file,
902 					    struct kobject *kobj,
903 					    struct bin_attribute *attr,
904 					    char *buf, loff_t offset,
905 					    size_t size)
906 {
907 	struct device *dev = container_of(kobj, struct device, kobj);
908 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
909 	struct qlcnic_pci_func_cfg *pci_cfg;
910 	struct qlcnic_pci_info *pci_info;
911 	int i, ret;
912 	u32 count;
913 
914 	pci_info = kcalloc(size, sizeof(*pci_info), GFP_KERNEL);
915 	if (!pci_info)
916 		return -ENOMEM;
917 
918 	ret = qlcnic_get_pci_info(adapter, pci_info);
919 	if (ret) {
920 		kfree(pci_info);
921 		return ret;
922 	}
923 
924 	pci_cfg = (struct qlcnic_pci_func_cfg *)buf;
925 	count = size / sizeof(struct qlcnic_pci_func_cfg);
926 	qlcnic_swap32_buffer((u32 *)pci_info, size / sizeof(u32));
927 	for (i = 0; i < count; i++) {
928 		pci_cfg[i].pci_func = pci_info[i].id;
929 		pci_cfg[i].func_type = pci_info[i].type;
930 		pci_cfg[i].func_state = 0;
931 		pci_cfg[i].port_num = pci_info[i].default_port;
932 		pci_cfg[i].min_bw = pci_info[i].tx_min_bw;
933 		pci_cfg[i].max_bw = pci_info[i].tx_max_bw;
934 		memcpy(&pci_cfg[i].def_mac_addr, &pci_info[i].mac, ETH_ALEN);
935 	}
936 
937 	kfree(pci_info);
938 	return size;
939 }
940 
941 static ssize_t qlcnic_83xx_sysfs_flash_read_handler(struct file *filp,
942 						    struct kobject *kobj,
943 						    struct bin_attribute *attr,
944 						    char *buf, loff_t offset,
945 						    size_t size)
946 {
947 	unsigned char *p_read_buf;
948 	int  ret, count;
949 	struct device *dev = container_of(kobj, struct device, kobj);
950 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
951 
952 	if (!size)
953 		return -EINVAL;
954 
955 	count = size / sizeof(u32);
956 
957 	if (size % sizeof(u32))
958 		count++;
959 
960 	p_read_buf = kcalloc(size, sizeof(unsigned char), GFP_KERNEL);
961 	if (!p_read_buf)
962 		return -ENOMEM;
963 	if (qlcnic_83xx_lock_flash(adapter) != 0) {
964 		kfree(p_read_buf);
965 		return -EIO;
966 	}
967 
968 	ret = qlcnic_83xx_lockless_flash_read32(adapter, offset, p_read_buf,
969 						count);
970 
971 	if (ret) {
972 		qlcnic_83xx_unlock_flash(adapter);
973 		kfree(p_read_buf);
974 		return ret;
975 	}
976 
977 	qlcnic_83xx_unlock_flash(adapter);
978 	qlcnic_swap32_buffer((u32 *)p_read_buf, count);
979 	memcpy(buf, p_read_buf, size);
980 	kfree(p_read_buf);
981 
982 	return size;
983 }
984 
985 static int qlcnic_83xx_sysfs_flash_bulk_write(struct qlcnic_adapter *adapter,
986 					      char *buf, loff_t offset,
987 					      size_t size)
988 {
989 	int  i, ret, count;
990 	unsigned char *p_cache, *p_src;
991 
992 	p_cache = kcalloc(size, sizeof(unsigned char), GFP_KERNEL);
993 	if (!p_cache)
994 		return -ENOMEM;
995 
996 	count = size / sizeof(u32);
997 	qlcnic_swap32_buffer((u32 *)buf, count);
998 	memcpy(p_cache, buf, size);
999 	p_src = p_cache;
1000 
1001 	if (qlcnic_83xx_lock_flash(adapter) != 0) {
1002 		kfree(p_cache);
1003 		return -EIO;
1004 	}
1005 
1006 	if (adapter->ahw->fdt.mfg_id == adapter->flash_mfg_id) {
1007 		ret = qlcnic_83xx_enable_flash_write(adapter);
1008 		if (ret) {
1009 			kfree(p_cache);
1010 			qlcnic_83xx_unlock_flash(adapter);
1011 			return -EIO;
1012 		}
1013 	}
1014 
1015 	for (i = 0; i < count / QLC_83XX_FLASH_WRITE_MAX; i++) {
1016 		ret = qlcnic_83xx_flash_bulk_write(adapter, offset,
1017 						   (u32 *)p_src,
1018 						   QLC_83XX_FLASH_WRITE_MAX);
1019 
1020 		if (ret) {
1021 			if (adapter->ahw->fdt.mfg_id == adapter->flash_mfg_id) {
1022 				ret = qlcnic_83xx_disable_flash_write(adapter);
1023 				if (ret) {
1024 					kfree(p_cache);
1025 					qlcnic_83xx_unlock_flash(adapter);
1026 					return -EIO;
1027 				}
1028 			}
1029 
1030 			kfree(p_cache);
1031 			qlcnic_83xx_unlock_flash(adapter);
1032 			return -EIO;
1033 		}
1034 
1035 		p_src = p_src + sizeof(u32)*QLC_83XX_FLASH_WRITE_MAX;
1036 		offset = offset + sizeof(u32)*QLC_83XX_FLASH_WRITE_MAX;
1037 	}
1038 
1039 	if (adapter->ahw->fdt.mfg_id == adapter->flash_mfg_id) {
1040 		ret = qlcnic_83xx_disable_flash_write(adapter);
1041 		if (ret) {
1042 			kfree(p_cache);
1043 			qlcnic_83xx_unlock_flash(adapter);
1044 			return -EIO;
1045 		}
1046 	}
1047 
1048 	kfree(p_cache);
1049 	qlcnic_83xx_unlock_flash(adapter);
1050 
1051 	return 0;
1052 }
1053 
1054 static int qlcnic_83xx_sysfs_flash_write(struct qlcnic_adapter *adapter,
1055 					 char *buf, loff_t offset, size_t size)
1056 {
1057 	int  i, ret, count;
1058 	unsigned char *p_cache, *p_src;
1059 
1060 	p_cache = kcalloc(size, sizeof(unsigned char), GFP_KERNEL);
1061 	if (!p_cache)
1062 		return -ENOMEM;
1063 
1064 	qlcnic_swap32_buffer((u32 *)buf, size / sizeof(u32));
1065 	memcpy(p_cache, buf, size);
1066 	p_src = p_cache;
1067 	count = size / sizeof(u32);
1068 
1069 	if (qlcnic_83xx_lock_flash(adapter) != 0) {
1070 		kfree(p_cache);
1071 		return -EIO;
1072 	}
1073 
1074 	if (adapter->ahw->fdt.mfg_id == adapter->flash_mfg_id) {
1075 		ret = qlcnic_83xx_enable_flash_write(adapter);
1076 		if (ret) {
1077 			kfree(p_cache);
1078 			qlcnic_83xx_unlock_flash(adapter);
1079 			return -EIO;
1080 		}
1081 	}
1082 
1083 	for (i = 0; i < count; i++) {
1084 		ret = qlcnic_83xx_flash_write32(adapter, offset, (u32 *)p_src);
1085 		if (ret) {
1086 			if (adapter->ahw->fdt.mfg_id == adapter->flash_mfg_id) {
1087 				ret = qlcnic_83xx_disable_flash_write(adapter);
1088 				if (ret) {
1089 					kfree(p_cache);
1090 					qlcnic_83xx_unlock_flash(adapter);
1091 					return -EIO;
1092 				}
1093 			}
1094 			kfree(p_cache);
1095 			qlcnic_83xx_unlock_flash(adapter);
1096 			return -EIO;
1097 		}
1098 
1099 		p_src = p_src + sizeof(u32);
1100 		offset = offset + sizeof(u32);
1101 	}
1102 
1103 	if (adapter->ahw->fdt.mfg_id == adapter->flash_mfg_id) {
1104 		ret = qlcnic_83xx_disable_flash_write(adapter);
1105 		if (ret) {
1106 			kfree(p_cache);
1107 			qlcnic_83xx_unlock_flash(adapter);
1108 			return -EIO;
1109 		}
1110 	}
1111 
1112 	kfree(p_cache);
1113 	qlcnic_83xx_unlock_flash(adapter);
1114 
1115 	return 0;
1116 }
1117 
1118 static ssize_t qlcnic_83xx_sysfs_flash_write_handler(struct file *filp,
1119 						     struct kobject *kobj,
1120 						     struct bin_attribute *attr,
1121 						     char *buf, loff_t offset,
1122 						     size_t size)
1123 {
1124 	int  ret;
1125 	static int flash_mode;
1126 	unsigned long data;
1127 	struct device *dev = container_of(kobj, struct device, kobj);
1128 	struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
1129 
1130 	ret = kstrtoul(buf, 16, &data);
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