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