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

   1 #include <linux/slab.h>
   2 #include <linux/vmalloc.h>
   3 #include <linux/interrupt.h>
   4
   5 #include "qlcnic.h"
   6
   7 #include <linux/swab.h>
   8 #include <linux/dma-mapping.h>
   9 #include <net/ip.h>
  10 #include <linux/ipv6.h>
  11 #include <linux/inetdevice.h>
  12 #include <linux/sysfs.h>
  13 #include <linux/aer.h>
  14 #include <linux/log2.h>
  15
  16 int qlcnicvf_config_bridged_mode(struct qlcnic_adapter *adapter, u32 enable)
  17 {
  18         return -EOPNOTSUPP;
  19 }
  20
  21 int qlcnicvf_config_led(struct qlcnic_adapter *adapter, u32 state, u32 rate)
  22 {
  23         return -EOPNOTSUPP;
  24 }
  25
  26 static ssize_t qlcnic_store_bridged_mode(struct device *dev,
  27                                          struct device_attribute *attr,
  28                                          const char *buf, size_t len)
  29 {
  30         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
  31         unsigned long new;
  32         int ret = -EINVAL;
  33
  34         if (!(adapter->capabilities & QLCNIC_FW_CAPABILITY_BDG))
  35                 goto err_out;
  36
  37         if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
  38                 goto err_out;
  39
  40         if (strict_strtoul(buf, 2, &new))
  41                 goto err_out;
  42
  43         if (!adapter->nic_ops->config_bridged_mode(adapter, !!new))
  44                 ret = len;
  45
  46 err_out:
  47         return ret;
  48 }
  49
  50 static ssize_t qlcnic_show_bridged_mode(struct device *dev,
  51                                         struct device_attribute *attr,
  52                                         char *buf)
  53 {
  54         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
  55         int bridged_mode = 0;
  56
  57         if (adapter->capabilities & QLCNIC_FW_CAPABILITY_BDG)
  58                 bridged_mode = !!(adapter->flags & QLCNIC_BRIDGE_ENABLED);
  59
  60         return sprintf(buf, "%d\n", bridged_mode);
  61 }
  62
  63 static ssize_t qlcnic_store_diag_mode(struct device *dev,
  64                                       struct device_attribute *attr,
  65                                       const char *buf, size_t len)
  66 {
  67         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
  68         unsigned long new;
  69
  70         if (strict_strtoul(buf, 2, &new))
  71                 return -EINVAL;
  72
  73         if (!!new != !!(adapter->flags & QLCNIC_DIAG_ENABLED))
  74                 adapter->flags ^= QLCNIC_DIAG_ENABLED;
  75
  76         return len;
  77 }
  78
  79 static ssize_t qlcnic_show_diag_mode(struct device *dev,
  80                                      struct device_attribute *attr, char *buf)
  81 {
  82         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
  83
  84         return sprintf(buf, "%d\n",
  85                        !!(adapter->flags & QLCNIC_DIAG_ENABLED));
  86 }
  87
  88 static int qlcnic_validate_beacon(struct qlcnic_adapter *adapter, u16 beacon,
  89                                   u8 *state, u8 *rate)
  90 {
  91         *rate = LSB(beacon);
  92         *state = MSB(beacon);
  93
  94         QLCDB(adapter, DRV, "rate %x state %x\n", *rate, *state);
  95
  96         if (!*state) {
  97                 *rate = __QLCNIC_MAX_LED_RATE;
  98                 return 0;
  99         } else if (*state > __QLCNIC_MAX_LED_STATE) {
 100                 return -EINVAL;
 101         }
 102
 103         if ((!*rate) || (*rate > __QLCNIC_MAX_LED_RATE))
 104                 return -EINVAL;
 105
 106         return 0;
 107 }
 108
 109 static ssize_t qlcnic_store_beacon(struct device *dev,
 110                                    struct device_attribute *attr,
 111                                    const char *buf, size_t len)
 112 {
 113         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
 114         int max_sds_rings = adapter->max_sds_rings;
 115         u16 beacon;
 116         u8 b_state, b_rate;
 117         int err;
 118
 119         if (adapter->op_mode == QLCNIC_NON_PRIV_FUNC) {
 120                 dev_warn(dev,
 121                          "LED test not supported in non privileged mode\n");
 122                 return -EOPNOTSUPP;
 123         }
 124
 125         if (len != sizeof(u16))
 126                 return QL_STATUS_INVALID_PARAM;
 127
 128         memcpy(&beacon, buf, sizeof(u16));
 129         err = qlcnic_validate_beacon(adapter, beacon, &b_state, &b_rate);
 130         if (err)
 131                 return err;
 132
 133         if (adapter->ahw->beacon_state == b_state)
 134                 return len;
 135
 136         rtnl_lock();
 137
 138         if (!adapter->ahw->beacon_state)
 139                 if (test_and_set_bit(__QLCNIC_LED_ENABLE, &adapter->state)) {
 140                         rtnl_unlock();
 141                         return -EBUSY;
 142                 }
 143
 144         if (test_bit(__QLCNIC_RESETTING, &adapter->state)) {
 145                 err = -EIO;
 146                 goto out;
 147         }
 148
 149         if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
 150                 err = qlcnic_diag_alloc_res(adapter->netdev, QLCNIC_LED_TEST);
 151                 if (err)
 152                         goto out;
 153                 set_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state);
 154         }
 155
 156         err = qlcnic_config_led(adapter, b_state, b_rate);
 157
 158         if (!err) {
 159                 err = len;
 160                 adapter->ahw->beacon_state = b_state;
 161         }
 162
 163         if (test_and_clear_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state))
 164                 qlcnic_diag_free_res(adapter->netdev, max_sds_rings);
 165
 166  out:
 167         if (!adapter->ahw->beacon_state)
 168                 clear_bit(__QLCNIC_LED_ENABLE, &adapter->state);
 169         rtnl_unlock();
 170
 171         return err;
 172 }
 173
 174 static ssize_t qlcnic_show_beacon(struct device *dev,
 175                                   struct device_attribute *attr, char *buf)
 176 {
 177         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
 178
 179         return sprintf(buf, "%d\n", adapter->ahw->beacon_state);
 180 }
 181
 182 static int qlcnic_sysfs_validate_crb(struct qlcnic_adapter *adapter,
 183                                      loff_t offset, size_t size)
 184 {
 185         size_t crb_size = 4;
 186
 187         if (!(adapter->flags & QLCNIC_DIAG_ENABLED))
 188                 return -EIO;
 189
 190         if (offset < QLCNIC_PCI_CRBSPACE) {
 191                 if (ADDR_IN_RANGE(offset, QLCNIC_PCI_CAMQM,
 192                                   QLCNIC_PCI_CAMQM_END))
 193                         crb_size = 8;
 194                 else
 195                         return -EINVAL;
 196         }
 197
 198         if ((size != crb_size) || (offset & (crb_size-1)))
 199                 return  -EINVAL;
 200
 201         return 0;
 202 }
 203
 204 static ssize_t qlcnic_sysfs_read_crb(struct file *filp, struct kobject *kobj,
 205                                      struct bin_attribute *attr, char *buf,
 206                                      loff_t offset, size_t size)
 207 {
 208         struct device *dev = container_of(kobj, struct device, kobj);
 209         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
 210         u32 data;
 211         u64 qmdata;
 212         int ret;
 213
 214         ret = qlcnic_sysfs_validate_crb(adapter, offset, size);
 215         if (ret != 0)
 216                 return ret;
 217
 218         if (ADDR_IN_RANGE(offset, QLCNIC_PCI_CAMQM, QLCNIC_PCI_CAMQM_END)) {
 219                 qlcnic_pci_camqm_read_2M(adapter, offset, &qmdata);
 220                 memcpy(buf, &qmdata, size);
 221         } else {
 222                 data = QLCRD32(adapter, offset);
 223                 memcpy(buf, &data, size);
 224         }
 225         return size;
 226 }
 227
 228 static ssize_t qlcnic_sysfs_write_crb(struct file *filp, struct kobject *kobj,
 229                                       struct bin_attribute *attr, char *buf,
 230                                       loff_t offset, size_t size)
 231 {
 232         struct device *dev = container_of(kobj, struct device, kobj);
 233         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
 234         u32 data;
 235         u64 qmdata;
 236         int ret;
 237
 238         ret = qlcnic_sysfs_validate_crb(adapter, offset, size);
 239         if (ret != 0)
 240                 return ret;
 241
 242         if (ADDR_IN_RANGE(offset, QLCNIC_PCI_CAMQM, QLCNIC_PCI_CAMQM_END)) {
 243                 memcpy(&qmdata, buf, size);
 244                 qlcnic_pci_camqm_write_2M(adapter, offset, qmdata);
 245         } else {
 246                 memcpy(&data, buf, size);
 247                 QLCWR32(adapter, offset, data);
 248         }
 249         return size;
 250 }
 251
 252 static int qlcnic_sysfs_validate_mem(struct qlcnic_adapter *adapter,
 253                                      loff_t offset, size_t size)
 254 {
 255         if (!(adapter->flags & QLCNIC_DIAG_ENABLED))
 256                 return -EIO;
 257
 258         if ((size != 8) || (offset & 0x7))
 259                 return  -EIO;
 260
 261         return 0;
 262 }
 263
 264 static ssize_t qlcnic_sysfs_read_mem(struct file *filp, struct kobject *kobj,
 265                                      struct bin_attribute *attr, char *buf,
 266                                      loff_t offset, size_t size)
 267 {
 268         struct device *dev = container_of(kobj, struct device, kobj);
 269         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
 270         u64 data;
 271         int ret;
 272
 273         ret = qlcnic_sysfs_validate_mem(adapter, offset, size);
 274         if (ret != 0)
 275                 return ret;
 276
 277         if (qlcnic_pci_mem_read_2M(adapter, offset, &data))
 278                 return -EIO;
 279
 280         memcpy(buf, &data, size);
 281
 282         return size;
 283 }
 284
 285 static ssize_t qlcnic_sysfs_write_mem(struct file *filp, struct kobject *kobj,
 286                                       struct bin_attribute *attr, char *buf,
 287                                       loff_t offset, size_t size)
 288 {
 289         struct device *dev = container_of(kobj, struct device, kobj);
 290         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
 291         u64 data;
 292         int ret;
 293
 294         ret = qlcnic_sysfs_validate_mem(adapter, offset, size);
 295         if (ret != 0)
 296                 return ret;
 297
 298         memcpy(&data, buf, size);
 299
 300         if (qlcnic_pci_mem_write_2M(adapter, offset, data))
 301                 return -EIO;
 302
 303         return size;
 304 }
 305
 306 static int validate_pm_config(struct qlcnic_adapter *adapter,
 307                               struct qlcnic_pm_func_cfg *pm_cfg, int count)
 308 {
 309         u8 src_pci_func, s_esw_id, d_esw_id, dest_pci_func;
 310         int i;
 311
 312         for (i = 0; i < count; i++) {
 313                 src_pci_func = pm_cfg[i].pci_func;
 314                 dest_pci_func = pm_cfg[i].dest_npar;
 315                 if (src_pci_func >= QLCNIC_MAX_PCI_FUNC ||
 316                     dest_pci_func >= QLCNIC_MAX_PCI_FUNC)
 317                         return QL_STATUS_INVALID_PARAM;
 318
 319                 if (adapter->npars[src_pci_func].type != QLCNIC_TYPE_NIC)
 320                         return QL_STATUS_INVALID_PARAM;
 321
 322                 if (adapter->npars[dest_pci_func].type != QLCNIC_TYPE_NIC)
 323                         return QL_STATUS_INVALID_PARAM;
 324
 325                 s_esw_id = adapter->npars[src_pci_func].phy_port;
 326                 d_esw_id = adapter->npars[dest_pci_func].phy_port;
 327
 328                 if (s_esw_id != d_esw_id)
 329                         return QL_STATUS_INVALID_PARAM;
 330         }
 331         return 0;
 332
 333 }
 334
 335 static ssize_t qlcnic_sysfs_write_pm_config(struct file *filp,
 336                                             struct kobject *kobj,
 337                                             struct bin_attribute *attr,
 338                                             char *buf, loff_t offset,
 339                                             size_t size)
 340 {
 341         struct device *dev = container_of(kobj, struct device, kobj);
 342         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
 343         struct qlcnic_pm_func_cfg *pm_cfg;
 344         u32 id, action, pci_func;
 345         int count, rem, i, ret;
 346
 347         count   = size / sizeof(struct qlcnic_pm_func_cfg);
 348         rem     = size % sizeof(struct qlcnic_pm_func_cfg);
 349         if (rem)
 350                 return QL_STATUS_INVALID_PARAM;
 351
 352         pm_cfg = (struct qlcnic_pm_func_cfg *)buf;
 353
 354         ret = validate_pm_config(adapter, pm_cfg, count);
 355         if (ret)
 356                 return ret;
 357         for (i = 0; i < count; i++) {
 358                 pci_func = pm_cfg[i].pci_func;
 359                 action = !!pm_cfg[i].action;
 360                 id = adapter->npars[pci_func].phy_port;
 361                 ret = qlcnic_config_port_mirroring(adapter, id, action,
 362                                                    pci_func);
 363                 if (ret)
 364                         return ret;
 365         }
 366
 367         for (i = 0; i < count; i++) {
 368                 pci_func = pm_cfg[i].pci_func;
 369                 id = adapter->npars[pci_func].phy_port;
 370                 adapter->npars[pci_func].enable_pm = !!pm_cfg[i].action;
 371                 adapter->npars[pci_func].dest_npar = id;
 372         }
 373         return size;
 374 }
 375
 376 static ssize_t qlcnic_sysfs_read_pm_config(struct file *filp,
 377                                            struct kobject *kobj,
 378                                            struct bin_attribute *attr,
 379                                            char *buf, loff_t offset,
 380                                            size_t size)
 381 {
 382         struct device *dev = container_of(kobj, struct device, kobj);
 383         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
 384         struct qlcnic_pm_func_cfg pm_cfg[QLCNIC_MAX_PCI_FUNC];
 385         int i;
 386
 387         if (size != sizeof(pm_cfg))
 388                 return QL_STATUS_INVALID_PARAM;
 389
 390         for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
 391                 if (adapter->npars[i].type != QLCNIC_TYPE_NIC)
 392                         continue;
 393                 pm_cfg[i].action = adapter->npars[i].enable_pm;
 394                 pm_cfg[i].dest_npar = 0;
 395                 pm_cfg[i].pci_func = i;
 396         }
 397         memcpy(buf, &pm_cfg, size);
 398
 399         return size;
 400 }
 401
 402 static int validate_esw_config(struct qlcnic_adapter *adapter,
 403                                struct qlcnic_esw_func_cfg *esw_cfg, int count)
 404 {
 405         u32 op_mode;
 406         u8 pci_func;
 407         int i;
 408
 409         op_mode = readl(adapter->ahw->pci_base0 + QLCNIC_DRV_OP_MODE);
 410
 411         for (i = 0; i < count; i++) {
 412                 pci_func = esw_cfg[i].pci_func;
 413                 if (pci_func >= QLCNIC_MAX_PCI_FUNC)
 414                         return QL_STATUS_INVALID_PARAM;
 415
 416                 if (adapter->op_mode == QLCNIC_MGMT_FUNC) {
 417                         if (adapter->npars[pci_func].type != QLCNIC_TYPE_NIC)
 418                                 return QL_STATUS_INVALID_PARAM;
 419                 }
 420
 421                 switch (esw_cfg[i].op_mode) {
 422                 case QLCNIC_PORT_DEFAULTS:
 423                         if (QLC_DEV_GET_DRV(op_mode, pci_func) !=
 424                                             QLCNIC_NON_PRIV_FUNC) {
 425                                 if (esw_cfg[i].mac_anti_spoof != 0)
 426                                         return QL_STATUS_INVALID_PARAM;
 427                                 if (esw_cfg[i].mac_override != 1)
 428                                         return QL_STATUS_INVALID_PARAM;
 429                                 if (esw_cfg[i].promisc_mode != 1)
 430                                         return QL_STATUS_INVALID_PARAM;
 431                         }
 432                         break;
 433                 case QLCNIC_ADD_VLAN:
 434                         if (!IS_VALID_VLAN(esw_cfg[i].vlan_id))
 435                                 return QL_STATUS_INVALID_PARAM;
 436                         if (!esw_cfg[i].op_type)
 437                                 return QL_STATUS_INVALID_PARAM;
 438                         break;
 439                 case QLCNIC_DEL_VLAN:
 440                         if (!esw_cfg[i].op_type)
 441                                 return QL_STATUS_INVALID_PARAM;
 442                         break;
 443                 default:
 444                         return QL_STATUS_INVALID_PARAM;
 445                 }
 446         }
 447         return 0;
 448 }
 449
 450 static ssize_t qlcnic_sysfs_write_esw_config(struct file *file,
 451                                              struct kobject *kobj,
 452                                              struct bin_attribute *attr,
 453                                              char *buf, loff_t offset,
 454                                              size_t size)
 455 {
 456         struct device *dev = container_of(kobj, struct device, kobj);
 457         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
 458         struct qlcnic_esw_func_cfg *esw_cfg;
 459         struct qlcnic_npar_info *npar;
 460         int count, rem, i, ret;
 461         u8 pci_func, op_mode = 0;
 462
 463         count   = size / sizeof(struct qlcnic_esw_func_cfg);
 464         rem     = size % sizeof(struct qlcnic_esw_func_cfg);
 465         if (rem)
 466                 return QL_STATUS_INVALID_PARAM;
 467
 468         esw_cfg = (struct qlcnic_esw_func_cfg *)buf;
 469         ret = validate_esw_config(adapter, esw_cfg, count);
 470         if (ret)
 471                 return ret;
 472
 473         for (i = 0; i < count; i++) {
 474                 if (adapter->op_mode == QLCNIC_MGMT_FUNC) {
 475                         if (qlcnic_config_switch_port(adapter, &esw_cfg[i]))
 476                                 return QL_STATUS_INVALID_PARAM;
 477                 }
 478
 479                 if (adapter->ahw->pci_func != esw_cfg[i].pci_func)
 480                         continue;
 481
 482                 op_mode = esw_cfg[i].op_mode;
 483                 qlcnic_get_eswitch_port_config(adapter, &esw_cfg[i]);
 484                 esw_cfg[i].op_mode = op_mode;
 485                 esw_cfg[i].pci_func = adapter->ahw->pci_func;
 486
 487                 switch (esw_cfg[i].op_mode) {
 488                 case QLCNIC_PORT_DEFAULTS:
 489                         qlcnic_set_eswitch_port_features(adapter, &esw_cfg[i]);
 490                         break;
 491                 case QLCNIC_ADD_VLAN:
 492                         qlcnic_set_vlan_config(adapter, &esw_cfg[i]);
 493                         break;
 494                 case QLCNIC_DEL_VLAN:
 495                         esw_cfg[i].vlan_id = 0;
 496                         qlcnic_set_vlan_config(adapter, &esw_cfg[i]);
 497                         break;
 498                 }
 499         }
 500
 501         if (adapter->op_mode != QLCNIC_MGMT_FUNC)
 502                 goto out;
 503
 504         for (i = 0; i < count; i++) {
 505                 pci_func = esw_cfg[i].pci_func;
 506                 npar = &adapter->npars[pci_func];
 507                 switch (esw_cfg[i].op_mode) {
 508                 case QLCNIC_PORT_DEFAULTS:
 509                         npar->promisc_mode = esw_cfg[i].promisc_mode;
 510                         npar->mac_override = esw_cfg[i].mac_override;
 511                         npar->offload_flags = esw_cfg[i].offload_flags;
 512                         npar->mac_anti_spoof = esw_cfg[i].mac_anti_spoof;
 513                         npar->discard_tagged = esw_cfg[i].discard_tagged;
 514                         break;
 515                 case QLCNIC_ADD_VLAN:
 516                         npar->pvid = esw_cfg[i].vlan_id;
 517                         break;
 518                 case QLCNIC_DEL_VLAN:
 519                         npar->pvid = 0;
 520                         break;
 521                 }
 522         }
 523 out:
 524         return size;
 525 }
 526
 527 static ssize_t qlcnic_sysfs_read_esw_config(struct file *file,
 528                                             struct kobject *kobj,
 529                                             struct bin_attribute *attr,
 530                                             char *buf, loff_t offset,
 531                                             size_t size)
 532 {
 533         struct device *dev = container_of(kobj, struct device, kobj);
 534         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
 535         struct qlcnic_esw_func_cfg esw_cfg[QLCNIC_MAX_PCI_FUNC];
 536         u8 i;
 537
 538         if (size != sizeof(esw_cfg))
 539                 return QL_STATUS_INVALID_PARAM;
 540
 541         for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
 542                 if (adapter->npars[i].type != QLCNIC_TYPE_NIC)
 543                         continue;
 544                 esw_cfg[i].pci_func = i;
 545                 if (qlcnic_get_eswitch_port_config(adapter, &esw_cfg[i]))
 546                         return QL_STATUS_INVALID_PARAM;
 547         }
 548         memcpy(buf, &esw_cfg, size);
 549
 550         return size;
 551 }
 552
 553 static int validate_npar_config(struct qlcnic_adapter *adapter,
 554                                 struct qlcnic_npar_func_cfg *np_cfg,
 555                                 int count)
 556 {
 557         u8 pci_func, i;
 558
 559         for (i = 0; i < count; i++) {
 560                 pci_func = np_cfg[i].pci_func;
 561                 if (pci_func >= QLCNIC_MAX_PCI_FUNC)
 562                         return QL_STATUS_INVALID_PARAM;
 563
 564                 if (adapter->npars[pci_func].type != QLCNIC_TYPE_NIC)
 565                         return QL_STATUS_INVALID_PARAM;
 566
 567                 if (!IS_VALID_BW(np_cfg[i].min_bw) ||
 568                     !IS_VALID_BW(np_cfg[i].max_bw))
 569                         return QL_STATUS_INVALID_PARAM;
 570         }
 571         return 0;
 572 }
 573
 574 static ssize_t qlcnic_sysfs_write_npar_config(struct file *file,
 575                                               struct kobject *kobj,
 576                                               struct bin_attribute *attr,
 577                                               char *buf, loff_t offset,
 578                                               size_t size)
 579 {
 580         struct device *dev = container_of(kobj, struct device, kobj);
 581         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
 582         struct qlcnic_info nic_info;
 583         struct qlcnic_npar_func_cfg *np_cfg;
 584         int i, count, rem, ret;
 585         u8 pci_func;
 586
 587         count   = size / sizeof(struct qlcnic_npar_func_cfg);
 588         rem     = size % sizeof(struct qlcnic_npar_func_cfg);
 589         if (rem)
 590                 return QL_STATUS_INVALID_PARAM;
 591
 592         np_cfg = (struct qlcnic_npar_func_cfg *)buf;
 593         ret = validate_npar_config(adapter, np_cfg, count);
 594         if (ret)
 595                 return ret;
 596
 597         for (i = 0; i < count ; i++) {
 598                 pci_func = np_cfg[i].pci_func;
 599                 ret = qlcnic_get_nic_info(adapter, &nic_info, pci_func);
 600                 if (ret)
 601                         return ret;
 602                 nic_info.pci_func = pci_func;
 603                 nic_info.min_tx_bw = np_cfg[i].min_bw;
 604                 nic_info.max_tx_bw = np_cfg[i].max_bw;
 605                 ret = qlcnic_set_nic_info(adapter, &nic_info);
 606                 if (ret)
 607                         return ret;
 608                 adapter->npars[i].min_bw = nic_info.min_tx_bw;
 609                 adapter->npars[i].max_bw = nic_info.max_tx_bw;
 610         }
 611
 612         return size;
 613
 614 }
 615
 616 static ssize_t qlcnic_sysfs_read_npar_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_info nic_info;
 625         struct qlcnic_npar_func_cfg np_cfg[QLCNIC_MAX_PCI_FUNC];
 626         int i, ret;
 627
 628         if (size != sizeof(np_cfg))
 629                 return QL_STATUS_INVALID_PARAM;
 630
 631         for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
 632                 if (adapter->npars[i].type != QLCNIC_TYPE_NIC)
 633                         continue;
 634                 ret = qlcnic_get_nic_info(adapter, &nic_info, i);
 635                 if (ret)
 636                         return ret;
 637
 638                 np_cfg[i].pci_func = i;
 639                 np_cfg[i].op_mode = (u8)nic_info.op_mode;
 640                 np_cfg[i].port_num = nic_info.phys_port;
 641                 np_cfg[i].fw_capab = nic_info.capabilities;
 642                 np_cfg[i].min_bw = nic_info.min_tx_bw;
 643                 np_cfg[i].max_bw = nic_info.max_tx_bw;
 644                 np_cfg[i].max_tx_queues = nic_info.max_tx_ques;
 645                 np_cfg[i].max_rx_queues = nic_info.max_rx_ques;
 646         }
 647         memcpy(buf, &np_cfg, size);
 648         return size;
 649 }
 650
 651 static ssize_t qlcnic_sysfs_get_port_stats(struct file *file,
 652                                            struct kobject *kobj,
 653                                            struct bin_attribute *attr,
 654                                            char *buf, loff_t offset,
 655                                            size_t size)
 656 {
 657         struct device *dev = container_of(kobj, struct device, kobj);
 658         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
 659         struct qlcnic_esw_statistics port_stats;
 660         int ret;
 661
 662         if (size != sizeof(struct qlcnic_esw_statistics))
 663                 return QL_STATUS_INVALID_PARAM;
 664
 665         if (offset >= QLCNIC_MAX_PCI_FUNC)
 666                 return QL_STATUS_INVALID_PARAM;
 667
 668         memset(&port_stats, 0, size);
 669         ret = qlcnic_get_port_stats(adapter, offset, QLCNIC_QUERY_RX_COUNTER,
 670                                     &port_stats.rx);
 671         if (ret)
 672                 return ret;
 673
 674         ret = qlcnic_get_port_stats(adapter, offset, QLCNIC_QUERY_TX_COUNTER,
 675                                     &port_stats.tx);
 676         if (ret)
 677                 return ret;
 678
 679         memcpy(buf, &port_stats, size);
 680         return size;
 681 }
 682
 683 static ssize_t qlcnic_sysfs_get_esw_stats(struct file *file,
 684                                           struct kobject *kobj,
 685                                           struct bin_attribute *attr,
 686                                           char *buf, loff_t offset,
 687                                           size_t size)
 688 {
 689         struct device *dev = container_of(kobj, struct device, kobj);
 690         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
 691         struct qlcnic_esw_statistics esw_stats;
 692         int ret;
 693
 694         if (size != sizeof(struct qlcnic_esw_statistics))
 695                 return QL_STATUS_INVALID_PARAM;
 696
 697         if (offset >= QLCNIC_NIU_MAX_XG_PORTS)
 698                 return QL_STATUS_INVALID_PARAM;
 699
 700         memset(&esw_stats, 0, size);
 701         ret = qlcnic_get_eswitch_stats(adapter, offset, QLCNIC_QUERY_RX_COUNTER,
 702                                        &esw_stats.rx);
 703         if (ret)
 704                 return ret;
 705
 706         ret = qlcnic_get_eswitch_stats(adapter, offset, QLCNIC_QUERY_TX_COUNTER,
 707                                        &esw_stats.tx);
 708         if (ret)
 709                 return ret;
 710
 711         memcpy(buf, &esw_stats, size);
 712         return size;
 713 }
 714
 715 static ssize_t qlcnic_sysfs_clear_esw_stats(struct file *file,
 716                                             struct kobject *kobj,
 717                                             struct bin_attribute *attr,
 718                                             char *buf, loff_t offset,
 719                                             size_t size)
 720 {
 721         struct device *dev = container_of(kobj, struct device, kobj);
 722         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
 723         int ret;
 724
 725         if (offset >= QLCNIC_NIU_MAX_XG_PORTS)
 726                 return QL_STATUS_INVALID_PARAM;
 727
 728         ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_ESWITCH, offset,
 729                                      QLCNIC_QUERY_RX_COUNTER);
 730         if (ret)
 731                 return ret;
 732
 733         ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_ESWITCH, offset,
 734                                      QLCNIC_QUERY_TX_COUNTER);
 735         if (ret)
 736                 return ret;
 737
 738         return size;
 739 }
 740
 741 static ssize_t qlcnic_sysfs_clear_port_stats(struct file *file,
 742                                              struct kobject *kobj,
 743                                              struct bin_attribute *attr,
 744                                              char *buf, loff_t offset,
 745                                              size_t size)
 746 {
 747         struct device *dev = container_of(kobj, struct device, kobj);
 748         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
 749         int ret;
 750
 751         if (offset >= QLCNIC_MAX_PCI_FUNC)
 752                 return QL_STATUS_INVALID_PARAM;
 753
 754         ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_PORT, offset,
 755                                      QLCNIC_QUERY_RX_COUNTER);
 756         if (ret)
 757                 return ret;
 758
 759         ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_PORT, offset,
 760                                      QLCNIC_QUERY_TX_COUNTER);
 761         if (ret)
 762                 return ret;
 763
 764         return size;
 765 }
 766
 767 static ssize_t qlcnic_sysfs_read_pci_config(struct file *file,
 768                                             struct kobject *kobj,
 769                                             struct bin_attribute *attr,
 770                                             char *buf, loff_t offset,
 771                                             size_t size)
 772 {
 773         struct device *dev = container_of(kobj, struct device, kobj);
 774         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
 775         struct qlcnic_pci_func_cfg pci_cfg[QLCNIC_MAX_PCI_FUNC];
 776         struct qlcnic_pci_info *pci_info;
 777         int i, ret;
 778
 779         if (size != sizeof(pci_cfg))
 780                 return QL_STATUS_INVALID_PARAM;
 781
 782         pci_info = kcalloc(QLCNIC_MAX_PCI_FUNC, sizeof(*pci_info), GFP_KERNEL);
 783         if (!pci_info)
 784                 return -ENOMEM;
 785
 786         ret = qlcnic_get_pci_info(adapter, pci_info);
 787         if (ret) {
 788                 kfree(pci_info);
 789                 return ret;
 790         }
 791
 792         for (i = 0; i < QLCNIC_MAX_PCI_FUNC ; i++) {
 793                 pci_cfg[i].pci_func = pci_info[i].id;
 794                 pci_cfg[i].func_type = pci_info[i].type;
 795                 pci_cfg[i].port_num = pci_info[i].default_port;
 796                 pci_cfg[i].min_bw = pci_info[i].tx_min_bw;
 797                 pci_cfg[i].max_bw = pci_info[i].tx_max_bw;
 798                 memcpy(&pci_cfg[i].def_mac_addr, &pci_info[i].mac, ETH_ALEN);
 799         }
 800         memcpy(buf, &pci_cfg, size);
 801         kfree(pci_info);
 802         return size;
 803 }
 804
 805 static struct device_attribute dev_attr_bridged_mode = {
 806        .attr = {.name = "bridged_mode", .mode = (S_IRUGO | S_IWUSR)},
 807        .show = qlcnic_show_bridged_mode,
 808        .store = qlcnic_store_bridged_mode,
 809 };
 810
 811 static struct device_attribute dev_attr_diag_mode = {
 812         .attr = {.name = "diag_mode", .mode = (S_IRUGO | S_IWUSR)},
 813         .show = qlcnic_show_diag_mode,
 814         .store = qlcnic_store_diag_mode,
 815 };
 816
 817 static struct device_attribute dev_attr_beacon = {
 818         .attr = {.name = "beacon", .mode = (S_IRUGO | S_IWUSR)},
 819         .show = qlcnic_show_beacon,
 820         .store = qlcnic_store_beacon,
 821 };
 822
 823 static struct bin_attribute bin_attr_crb = {
 824         .attr = {.name = "crb", .mode = (S_IRUGO | S_IWUSR)},
 825         .size = 0,
 826         .read = qlcnic_sysfs_read_crb,
 827         .write = qlcnic_sysfs_write_crb,
 828 };
 829
 830 static struct bin_attribute bin_attr_mem = {
 831         .attr = {.name = "mem", .mode = (S_IRUGO | S_IWUSR)},
 832         .size = 0,
 833         .read = qlcnic_sysfs_read_mem,
 834         .write = qlcnic_sysfs_write_mem,
 835 };
 836
 837 static struct bin_attribute bin_attr_npar_config = {
 838         .attr = {.name = "npar_config", .mode = (S_IRUGO | S_IWUSR)},
 839         .size = 0,
 840         .read = qlcnic_sysfs_read_npar_config,
 841         .write = qlcnic_sysfs_write_npar_config,
 842 };
 843
 844 static struct bin_attribute bin_attr_pci_config = {
 845         .attr = {.name = "pci_config", .mode = (S_IRUGO | S_IWUSR)},
 846         .size = 0,
 847         .read = qlcnic_sysfs_read_pci_config,
 848         .write = NULL,
 849 };
 850
 851 static struct bin_attribute bin_attr_port_stats = {
 852         .attr = {.name = "port_stats", .mode = (S_IRUGO | S_IWUSR)},
 853         .size = 0,
 854         .read = qlcnic_sysfs_get_port_stats,
 855         .write = qlcnic_sysfs_clear_port_stats,
 856 };
 857
 858 static struct bin_attribute bin_attr_esw_stats = {
 859         .attr = {.name = "esw_stats", .mode = (S_IRUGO | S_IWUSR)},
 860         .size = 0,
 861         .read = qlcnic_sysfs_get_esw_stats,
 862         .write = qlcnic_sysfs_clear_esw_stats,
 863 };
 864
 865 static struct bin_attribute bin_attr_esw_config = {
 866         .attr = {.name = "esw_config", .mode = (S_IRUGO | S_IWUSR)},
 867         .size = 0,
 868         .read = qlcnic_sysfs_read_esw_config,
 869         .write = qlcnic_sysfs_write_esw_config,
 870 };
 871
 872 static struct bin_attribute bin_attr_pm_config = {
 873         .attr = {.name = "pm_config", .mode = (S_IRUGO | S_IWUSR)},
 874         .size = 0,
 875         .read = qlcnic_sysfs_read_pm_config,
 876         .write = qlcnic_sysfs_write_pm_config,
 877 };
 878
 879 void qlcnic_create_sysfs_entries(struct qlcnic_adapter *adapter)
 880 {
 881         struct device *dev = &adapter->pdev->dev;
 882
 883         if (adapter->capabilities & QLCNIC_FW_CAPABILITY_BDG)
 884                 if (device_create_file(dev, &dev_attr_bridged_mode))
 885                         dev_warn(dev,
 886                                  "failed to create bridged_mode sysfs entry\n");
 887 }
 888
 889 void qlcnic_remove_sysfs_entries(struct qlcnic_adapter *adapter)
 890 {
 891         struct device *dev = &adapter->pdev->dev;
 892
 893         if (adapter->capabilities & QLCNIC_FW_CAPABILITY_BDG)
 894                 device_remove_file(dev, &dev_attr_bridged_mode);
 895 }
 896
 897 void qlcnic_create_diag_entries(struct qlcnic_adapter *adapter)
 898 {
 899         struct device *dev = &adapter->pdev->dev;
 900         u32 state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
 901
 902         if (device_create_bin_file(dev, &bin_attr_port_stats))
 903                 dev_info(dev, "failed to create port stats sysfs entry");
 904
 905         if (adapter->op_mode == QLCNIC_NON_PRIV_FUNC)
 906                 return;
 907         if (device_create_file(dev, &dev_attr_diag_mode))
 908                 dev_info(dev, "failed to create diag_mode sysfs entry\n");
 909         if (device_create_bin_file(dev, &bin_attr_crb))
 910                 dev_info(dev, "failed to create crb sysfs entry\n");
 911         if (device_create_bin_file(dev, &bin_attr_mem))
 912                 dev_info(dev, "failed to create mem sysfs entry\n");
 913
 914         if (state == QLCNIC_DEV_FAILED || (state == QLCNIC_DEV_BADBAD))
 915                 return;
 916
 917         if (device_create_bin_file(dev, &bin_attr_pci_config))
 918                 dev_info(dev, "failed to create pci config sysfs entry");
 919         if (device_create_file(dev, &dev_attr_beacon))
 920                 dev_info(dev, "failed to create beacon sysfs entry");
 921
 922         if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
 923                 return;
 924         if (device_create_bin_file(dev, &bin_attr_esw_config))
 925                 dev_info(dev, "failed to create esw config sysfs entry");
 926         if (adapter->op_mode != QLCNIC_MGMT_FUNC)
 927                 return;
 928         if (device_create_bin_file(dev, &bin_attr_npar_config))
 929                 dev_info(dev, "failed to create npar config sysfs entry");
 930         if (device_create_bin_file(dev, &bin_attr_pm_config))
 931                 dev_info(dev, "failed to create pm config sysfs entry");
 932         if (device_create_bin_file(dev, &bin_attr_esw_stats))
 933                 dev_info(dev, "failed to create eswitch stats sysfs entry");
 934 }
 935
 936 void qlcnic_remove_diag_entries(struct qlcnic_adapter *adapter)
 937 {
 938         struct device *dev = &adapter->pdev->dev;
 939         u32 state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
 940
 941         device_remove_bin_file(dev, &bin_attr_port_stats);
 942
 943         if (adapter->op_mode == QLCNIC_NON_PRIV_FUNC)
 944                 return;
 945         device_remove_file(dev, &dev_attr_diag_mode);
 946         device_remove_bin_file(dev, &bin_attr_crb);
 947         device_remove_bin_file(dev, &bin_attr_mem);
 948         if (state == QLCNIC_DEV_FAILED || (state == QLCNIC_DEV_BADBAD))
 949                 return;
 950         device_remove_bin_file(dev, &bin_attr_pci_config);
 951         device_remove_file(dev, &dev_attr_beacon);
 952         if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
 953                 return;
 954         device_remove_bin_file(dev, &bin_attr_esw_config);
 955         if (adapter->op_mode != QLCNIC_MGMT_FUNC)
 956                 return;
 957         device_remove_bin_file(dev, &bin_attr_npar_config);
 958         device_remove_bin_file(dev, &bin_attr_pm_config);
 959         device_remove_bin_file(dev, &bin_attr_esw_stats);
 960 }