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