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