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