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