drivers/net/ethernet/qlogic/qlcnic/qlcnic_sysfs.c

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