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