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