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