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