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} 1432