drivers/net/qlcnic/qlcnic_main.c

   1 /*
   2  * Copyright (C) 2009 - QLogic Corporation.
   3  * All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  18  * MA  02111-1307, USA.
  19  *
  20  * The full GNU General Public License is included in this distribution
  21  * in the file called "COPYING".
  22  *
  23  */
  24
  25 #include <linux/slab.h>
  26 #include <linux/vmalloc.h>
  27 #include <linux/interrupt.h>
  28
  29 #include "qlcnic.h"
  30
  31 #include <linux/swab.h>
  32 #include <linux/dma-mapping.h>
  33 #include <linux/if_vlan.h>
  34 #include <net/ip.h>
  35 #include <linux/ipv6.h>
  36 #include <linux/inetdevice.h>
  37 #include <linux/sysfs.h>
  38 #include <linux/aer.h>
  39
  40 MODULE_DESCRIPTION("QLogic 1/10 GbE Converged/Intelligent Ethernet Driver");
  41 MODULE_LICENSE("GPL");
  42 MODULE_VERSION(QLCNIC_LINUX_VERSIONID);
  43 MODULE_FIRMWARE(QLCNIC_UNIFIED_ROMIMAGE_NAME);
  44
  45 char qlcnic_driver_name[] = "qlcnic";
  46 static const char qlcnic_driver_string[] = "QLogic 1/10 GbE "
  47         "Converged/Intelligent Ethernet Driver v" QLCNIC_LINUX_VERSIONID;
  48
  49 static struct workqueue_struct *qlcnic_wq;
  50 static int qlcnic_mac_learn;
  51 module_param(qlcnic_mac_learn, int, 0644);
  52 MODULE_PARM_DESC(qlcnic_mac_learn, "Mac Filter (0=disabled, 1=enabled)");
  53
  54 static int use_msi = 1;
  55 module_param(use_msi, int, 0644);
  56 MODULE_PARM_DESC(use_msi, "MSI interrupt (0=disabled, 1=enabled");
  57
  58 static int use_msi_x = 1;
  59 module_param(use_msi_x, int, 0644);
  60 MODULE_PARM_DESC(use_msi_x, "MSI-X interrupt (0=disabled, 1=enabled");
  61
  62 static int auto_fw_reset = AUTO_FW_RESET_ENABLED;
  63 module_param(auto_fw_reset, int, 0644);
  64 MODULE_PARM_DESC(auto_fw_reset, "Auto firmware reset (0=disabled, 1=enabled");
  65
  66 static int load_fw_file;
  67 module_param(load_fw_file, int, 0644);
  68 MODULE_PARM_DESC(load_fw_file, "Load firmware from (0=flash, 1=file");
  69
  70 static int qlcnic_config_npars;
  71 module_param(qlcnic_config_npars, int, 0644);
  72 MODULE_PARM_DESC(qlcnic_config_npars, "Configure NPARs (0=disabled, 1=enabled");
  73
  74 static int __devinit qlcnic_probe(struct pci_dev *pdev,
  75                 const struct pci_device_id *ent);
  76 static void __devexit qlcnic_remove(struct pci_dev *pdev);
  77 static int qlcnic_open(struct net_device *netdev);
  78 static int qlcnic_close(struct net_device *netdev);
  79 static void qlcnic_tx_timeout(struct net_device *netdev);
  80 static void qlcnic_attach_work(struct work_struct *work);
  81 static void qlcnic_fwinit_work(struct work_struct *work);
  82 static void qlcnic_fw_poll_work(struct work_struct *work);
  83 static void qlcnic_schedule_work(struct qlcnic_adapter *adapter,
  84                 work_func_t func, int delay);
  85 static void qlcnic_cancel_fw_work(struct qlcnic_adapter *adapter);
  86 static int qlcnic_poll(struct napi_struct *napi, int budget);
  87 static int qlcnic_rx_poll(struct napi_struct *napi, int budget);
  88 #ifdef CONFIG_NET_POLL_CONTROLLER
  89 static void qlcnic_poll_controller(struct net_device *netdev);
  90 #endif
  91
  92 static void qlcnic_create_sysfs_entries(struct qlcnic_adapter *adapter);
  93 static void qlcnic_remove_sysfs_entries(struct qlcnic_adapter *adapter);
  94 static void qlcnic_create_diag_entries(struct qlcnic_adapter *adapter);
  95 static void qlcnic_remove_diag_entries(struct qlcnic_adapter *adapter);
  96
  97 static void qlcnic_idc_debug_info(struct qlcnic_adapter *adapter, u8 encoding);
  98 static void qlcnic_clr_all_drv_state(struct qlcnic_adapter *adapter, u8);
  99 static int qlcnic_can_start_firmware(struct qlcnic_adapter *adapter);
 100
 101 static irqreturn_t qlcnic_tmp_intr(int irq, void *data);
 102 static irqreturn_t qlcnic_intr(int irq, void *data);
 103 static irqreturn_t qlcnic_msi_intr(int irq, void *data);
 104 static irqreturn_t qlcnic_msix_intr(int irq, void *data);
 105
 106 static struct net_device_stats *qlcnic_get_stats(struct net_device *netdev);
 107 static void qlcnic_restore_indev_addr(struct net_device *dev, unsigned long);
 108 static int qlcnic_start_firmware(struct qlcnic_adapter *);
 109
 110 static void qlcnic_alloc_lb_filters_mem(struct qlcnic_adapter *adapter);
 111 static void qlcnic_free_lb_filters_mem(struct qlcnic_adapter *adapter);
 112 static void qlcnic_dev_set_npar_ready(struct qlcnic_adapter *);
 113 static int qlcnicvf_config_led(struct qlcnic_adapter *, u32, u32);
 114 static int qlcnicvf_config_bridged_mode(struct qlcnic_adapter *, u32);
 115 static int qlcnicvf_start_firmware(struct qlcnic_adapter *);
 116 static void qlcnic_set_netdev_features(struct qlcnic_adapter *,
 117                                 struct qlcnic_esw_func_cfg *);
 118 /*  PCI Device ID Table  */
 119 #define ENTRY(device) \
 120         {PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, (device)), \
 121         .class = PCI_CLASS_NETWORK_ETHERNET << 8, .class_mask = ~0}
 122
 123 #define PCI_DEVICE_ID_QLOGIC_QLE824X  0x8020
 124
 125 static DEFINE_PCI_DEVICE_TABLE(qlcnic_pci_tbl) = {
 126         ENTRY(PCI_DEVICE_ID_QLOGIC_QLE824X),
 127         {0,}
 128 };
 129
 130 MODULE_DEVICE_TABLE(pci, qlcnic_pci_tbl);
 131
 132
 133 void
 134 qlcnic_update_cmd_producer(struct qlcnic_adapter *adapter,
 135                 struct qlcnic_host_tx_ring *tx_ring)
 136 {
 137         writel(tx_ring->producer, tx_ring->crb_cmd_producer);
 138 }
 139
 140 static const u32 msi_tgt_status[8] = {
 141         ISR_INT_TARGET_STATUS, ISR_INT_TARGET_STATUS_F1,
 142         ISR_INT_TARGET_STATUS_F2, ISR_INT_TARGET_STATUS_F3,
 143         ISR_INT_TARGET_STATUS_F4, ISR_INT_TARGET_STATUS_F5,
 144         ISR_INT_TARGET_STATUS_F6, ISR_INT_TARGET_STATUS_F7
 145 };
 146
 147 static const
 148 struct qlcnic_legacy_intr_set legacy_intr[] = QLCNIC_LEGACY_INTR_CONFIG;
 149
 150 static inline void qlcnic_disable_int(struct qlcnic_host_sds_ring *sds_ring)
 151 {
 152         writel(0, sds_ring->crb_intr_mask);
 153 }
 154
 155 static inline void qlcnic_enable_int(struct qlcnic_host_sds_ring *sds_ring)
 156 {
 157         struct qlcnic_adapter *adapter = sds_ring->adapter;
 158
 159         writel(0x1, sds_ring->crb_intr_mask);
 160
 161         if (!QLCNIC_IS_MSI_FAMILY(adapter))
 162                 writel(0xfbff, adapter->tgt_mask_reg);
 163 }
 164
 165 static int
 166 qlcnic_alloc_sds_rings(struct qlcnic_recv_context *recv_ctx, int count)
 167 {
 168         int size = sizeof(struct qlcnic_host_sds_ring) * count;
 169
 170         recv_ctx->sds_rings = kzalloc(size, GFP_KERNEL);
 171
 172         return recv_ctx->sds_rings == NULL;
 173 }
 174
 175 static void
 176 qlcnic_free_sds_rings(struct qlcnic_recv_context *recv_ctx)
 177 {
 178         if (recv_ctx->sds_rings != NULL)
 179                 kfree(recv_ctx->sds_rings);
 180
 181         recv_ctx->sds_rings = NULL;
 182 }
 183
 184 static int
 185 qlcnic_napi_add(struct qlcnic_adapter *adapter, struct net_device *netdev)
 186 {
 187         int ring;
 188         struct qlcnic_host_sds_ring *sds_ring;
 189         struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
 190
 191         if (qlcnic_alloc_sds_rings(recv_ctx, adapter->max_sds_rings))
 192                 return -ENOMEM;
 193
 194         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
 195                 sds_ring = &recv_ctx->sds_rings[ring];
 196
 197                 if (ring == adapter->max_sds_rings - 1)
 198                         netif_napi_add(netdev, &sds_ring->napi, qlcnic_poll,
 199                                 QLCNIC_NETDEV_WEIGHT/adapter->max_sds_rings);
 200                 else
 201                         netif_napi_add(netdev, &sds_ring->napi,
 202                                 qlcnic_rx_poll, QLCNIC_NETDEV_WEIGHT*2);
 203         }
 204
 205         return 0;
 206 }
 207
 208 static void
 209 qlcnic_napi_del(struct qlcnic_adapter *adapter)
 210 {
 211         int ring;
 212         struct qlcnic_host_sds_ring *sds_ring;
 213         struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
 214
 215         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
 216                 sds_ring = &recv_ctx->sds_rings[ring];
 217                 netif_napi_del(&sds_ring->napi);
 218         }
 219
 220         qlcnic_free_sds_rings(&adapter->recv_ctx);
 221 }
 222
 223 static void
 224 qlcnic_napi_enable(struct qlcnic_adapter *adapter)
 225 {
 226         int ring;
 227         struct qlcnic_host_sds_ring *sds_ring;
 228         struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
 229
 230         if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
 231                 return;
 232
 233         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
 234                 sds_ring = &recv_ctx->sds_rings[ring];
 235                 napi_enable(&sds_ring->napi);
 236                 qlcnic_enable_int(sds_ring);
 237         }
 238 }
 239
 240 static void
 241 qlcnic_napi_disable(struct qlcnic_adapter *adapter)
 242 {
 243         int ring;
 244         struct qlcnic_host_sds_ring *sds_ring;
 245         struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
 246
 247         if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
 248                 return;
 249
 250         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
 251                 sds_ring = &recv_ctx->sds_rings[ring];
 252                 qlcnic_disable_int(sds_ring);
 253                 napi_synchronize(&sds_ring->napi);
 254                 napi_disable(&sds_ring->napi);
 255         }
 256 }
 257
 258 static void qlcnic_clear_stats(struct qlcnic_adapter *adapter)
 259 {
 260         memset(&adapter->stats, 0, sizeof(adapter->stats));
 261 }
 262
 263 static void qlcnic_set_msix_bit(struct pci_dev *pdev, int enable)
 264 {
 265         u32 control;
 266         int pos;
 267
 268         pos = pci_find_capability(pdev, PCI_CAP_ID_MSIX);
 269         if (pos) {
 270                 pci_read_config_dword(pdev, pos, &control);
 271                 if (enable)
 272                         control |= PCI_MSIX_FLAGS_ENABLE;
 273                 else
 274                         control = 0;
 275                 pci_write_config_dword(pdev, pos, control);
 276         }
 277 }
 278
 279 static void qlcnic_init_msix_entries(struct qlcnic_adapter *adapter, int count)
 280 {
 281         int i;
 282
 283         for (i = 0; i < count; i++)
 284                 adapter->msix_entries[i].entry = i;
 285 }
 286
 287 static int
 288 qlcnic_read_mac_addr(struct qlcnic_adapter *adapter)
 289 {
 290         u8 mac_addr[ETH_ALEN];
 291         struct net_device *netdev = adapter->netdev;
 292         struct pci_dev *pdev = adapter->pdev;
 293
 294         if (qlcnic_get_mac_address(adapter, mac_addr) != 0)
 295                 return -EIO;
 296
 297         memcpy(netdev->dev_addr, mac_addr, ETH_ALEN);
 298         memcpy(netdev->perm_addr, netdev->dev_addr, netdev->addr_len);
 299         memcpy(adapter->mac_addr, netdev->dev_addr, netdev->addr_len);
 300
 301         /* set station address */
 302
 303         if (!is_valid_ether_addr(netdev->perm_addr))
 304                 dev_warn(&pdev->dev, "Bad MAC address %pM.\n",
 305                                         netdev->dev_addr);
 306
 307         return 0;
 308 }
 309
 310 static int qlcnic_set_mac(struct net_device *netdev, void *p)
 311 {
 312         struct qlcnic_adapter *adapter = netdev_priv(netdev);
 313         struct sockaddr *addr = p;
 314
 315         if ((adapter->flags & QLCNIC_MAC_OVERRIDE_DISABLED))
 316                 return -EOPNOTSUPP;
 317
 318         if (!is_valid_ether_addr(addr->sa_data))
 319                 return -EINVAL;
 320
 321         if (test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
 322                 netif_device_detach(netdev);
 323                 qlcnic_napi_disable(adapter);
 324         }
 325
 326         memcpy(adapter->mac_addr, addr->sa_data, netdev->addr_len);
 327         memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
 328         qlcnic_set_multi(adapter->netdev);
 329
 330         if (test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
 331                 netif_device_attach(netdev);
 332                 qlcnic_napi_enable(adapter);
 333         }
 334         return 0;
 335 }
 336
 337 static void qlcnic_vlan_rx_register(struct net_device *netdev,
 338                 struct vlan_group *grp)
 339 {
 340         struct qlcnic_adapter *adapter = netdev_priv(netdev);
 341         adapter->vlgrp = grp;
 342 }
 343
 344 static const struct net_device_ops qlcnic_netdev_ops = {
 345         .ndo_open          = qlcnic_open,
 346         .ndo_stop          = qlcnic_close,
 347         .ndo_start_xmit    = qlcnic_xmit_frame,
 348         .ndo_get_stats     = qlcnic_get_stats,
 349         .ndo_validate_addr = eth_validate_addr,
 350         .ndo_set_multicast_list = qlcnic_set_multi,
 351         .ndo_set_mac_address    = qlcnic_set_mac,
 352         .ndo_change_mtu    = qlcnic_change_mtu,
 353         .ndo_tx_timeout    = qlcnic_tx_timeout,
 354         .ndo_vlan_rx_register = qlcnic_vlan_rx_register,
 355 #ifdef CONFIG_NET_POLL_CONTROLLER
 356         .ndo_poll_controller = qlcnic_poll_controller,
 357 #endif
 358 };
 359
 360 static struct qlcnic_nic_template qlcnic_ops = {
 361         .config_bridged_mode = qlcnic_config_bridged_mode,
 362         .config_led = qlcnic_config_led,
 363         .start_firmware = qlcnic_start_firmware
 364 };
 365
 366 static struct qlcnic_nic_template qlcnic_vf_ops = {
 367         .config_bridged_mode = qlcnicvf_config_bridged_mode,
 368         .config_led = qlcnicvf_config_led,
 369         .start_firmware = qlcnicvf_start_firmware
 370 };
 371
 372 static void
 373 qlcnic_setup_intr(struct qlcnic_adapter *adapter)
 374 {
 375         const struct qlcnic_legacy_intr_set *legacy_intrp;
 376         struct pci_dev *pdev = adapter->pdev;
 377         int err, num_msix;
 378
 379         if (adapter->rss_supported) {
 380                 num_msix = (num_online_cpus() >= MSIX_ENTRIES_PER_ADAPTER) ?
 381                         MSIX_ENTRIES_PER_ADAPTER : 2;
 382         } else
 383                 num_msix = 1;
 384
 385         adapter->max_sds_rings = 1;
 386
 387         adapter->flags &= ~(QLCNIC_MSI_ENABLED | QLCNIC_MSIX_ENABLED);
 388
 389         legacy_intrp = &legacy_intr[adapter->ahw.pci_func];
 390
 391         adapter->int_vec_bit = legacy_intrp->int_vec_bit;
 392         adapter->tgt_status_reg = qlcnic_get_ioaddr(adapter,
 393                         legacy_intrp->tgt_status_reg);
 394         adapter->tgt_mask_reg = qlcnic_get_ioaddr(adapter,
 395                         legacy_intrp->tgt_mask_reg);
 396         adapter->isr_int_vec = qlcnic_get_ioaddr(adapter, ISR_INT_VECTOR);
 397
 398         adapter->crb_int_state_reg = qlcnic_get_ioaddr(adapter,
 399                         ISR_INT_STATE_REG);
 400
 401         qlcnic_set_msix_bit(pdev, 0);
 402
 403         if (adapter->msix_supported) {
 404
 405                 qlcnic_init_msix_entries(adapter, num_msix);
 406                 err = pci_enable_msix(pdev, adapter->msix_entries, num_msix);
 407                 if (err == 0) {
 408                         adapter->flags |= QLCNIC_MSIX_ENABLED;
 409                         qlcnic_set_msix_bit(pdev, 1);
 410
 411                         if (adapter->rss_supported)
 412                                 adapter->max_sds_rings = num_msix;
 413
 414                         dev_info(&pdev->dev, "using msi-x interrupts\n");
 415                         return;
 416                 }
 417
 418                 if (err > 0)
 419                         pci_disable_msix(pdev);
 420
 421                 /* fall through for msi */
 422         }
 423
 424         if (use_msi && !pci_enable_msi(pdev)) {
 425                 adapter->flags |= QLCNIC_MSI_ENABLED;
 426                 adapter->tgt_status_reg = qlcnic_get_ioaddr(adapter,
 427                                 msi_tgt_status[adapter->ahw.pci_func]);
 428                 dev_info(&pdev->dev, "using msi interrupts\n");
 429                 adapter->msix_entries[0].vector = pdev->irq;
 430                 return;
 431         }
 432
 433         dev_info(&pdev->dev, "using legacy interrupts\n");
 434         adapter->msix_entries[0].vector = pdev->irq;
 435 }
 436
 437 static void
 438 qlcnic_teardown_intr(struct qlcnic_adapter *adapter)
 439 {
 440         if (adapter->flags & QLCNIC_MSIX_ENABLED)
 441                 pci_disable_msix(adapter->pdev);
 442         if (adapter->flags & QLCNIC_MSI_ENABLED)
 443                 pci_disable_msi(adapter->pdev);
 444 }
 445
 446 static void
 447 qlcnic_cleanup_pci_map(struct qlcnic_adapter *adapter)
 448 {
 449         if (adapter->ahw.pci_base0 != NULL)
 450                 iounmap(adapter->ahw.pci_base0);
 451 }
 452
 453 static int
 454 qlcnic_init_pci_info(struct qlcnic_adapter *adapter)
 455 {
 456         struct qlcnic_pci_info *pci_info;
 457         int i, ret = 0;
 458         u8 pfn;
 459
 460         pci_info = kcalloc(QLCNIC_MAX_PCI_FUNC, sizeof(*pci_info), GFP_KERNEL);
 461         if (!pci_info)
 462                 return -ENOMEM;
 463
 464         adapter->npars = kzalloc(sizeof(struct qlcnic_npar_info) *
 465                                 QLCNIC_MAX_PCI_FUNC, GFP_KERNEL);
 466         if (!adapter->npars) {
 467                 ret = -ENOMEM;
 468                 goto err_pci_info;
 469         }
 470
 471         adapter->eswitch = kzalloc(sizeof(struct qlcnic_eswitch) *
 472                                 QLCNIC_NIU_MAX_XG_PORTS, GFP_KERNEL);
 473         if (!adapter->eswitch) {
 474                 ret = -ENOMEM;
 475                 goto err_npars;
 476         }
 477
 478         ret = qlcnic_get_pci_info(adapter, pci_info);
 479         if (ret)
 480                 goto err_eswitch;
 481
 482         for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
 483                 pfn = pci_info[i].id;
 484                 if (pfn > QLCNIC_MAX_PCI_FUNC)
 485                         return QL_STATUS_INVALID_PARAM;
 486                 adapter->npars[pfn].active = (u8)pci_info[i].active;
 487                 adapter->npars[pfn].type = (u8)pci_info[i].type;
 488                 adapter->npars[pfn].phy_port = (u8)pci_info[i].default_port;
 489                 adapter->npars[pfn].min_bw = pci_info[i].tx_min_bw;
 490                 adapter->npars[pfn].max_bw = pci_info[i].tx_max_bw;
 491         }
 492
 493         for (i = 0; i < QLCNIC_NIU_MAX_XG_PORTS; i++)
 494                 adapter->eswitch[i].flags |= QLCNIC_SWITCH_ENABLE;
 495
 496         kfree(pci_info);
 497         return 0;
 498
 499 err_eswitch:
 500         kfree(adapter->eswitch);
 501         adapter->eswitch = NULL;
 502 err_npars:
 503         kfree(adapter->npars);
 504         adapter->npars = NULL;
 505 err_pci_info:
 506         kfree(pci_info);
 507
 508         return ret;
 509 }
 510
 511 static int
 512 qlcnic_set_function_modes(struct qlcnic_adapter *adapter)
 513 {
 514         u8 id;
 515         u32 ref_count;
 516         int i, ret = 1;
 517         u32 data = QLCNIC_MGMT_FUNC;
 518         void __iomem *priv_op = adapter->ahw.pci_base0 + QLCNIC_DRV_OP_MODE;
 519
 520         /* If other drivers are not in use set their privilege level */
 521         ref_count = QLCRD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
 522         ret = qlcnic_api_lock(adapter);
 523         if (ret)
 524                 goto err_lock;
 525
 526         if (qlcnic_config_npars) {
 527                 for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
 528                         id = i;
 529                         if (adapter->npars[i].type != QLCNIC_TYPE_NIC ||
 530                                 id == adapter->ahw.pci_func)
 531                                 continue;
 532                         data |= (qlcnic_config_npars &
 533                                         QLC_DEV_SET_DRV(0xf, id));
 534                 }
 535         } else {
 536                 data = readl(priv_op);
 537                 data = (data & ~QLC_DEV_SET_DRV(0xf, adapter->ahw.pci_func)) |
 538                         (QLC_DEV_SET_DRV(QLCNIC_MGMT_FUNC,
 539                         adapter->ahw.pci_func));
 540         }
 541         writel(data, priv_op);
 542         qlcnic_api_unlock(adapter);
 543 err_lock:
 544         return ret;
 545 }
 546
 547 static void
 548 qlcnic_check_vf(struct qlcnic_adapter *adapter)
 549 {
 550         void __iomem *msix_base_addr;
 551         void __iomem *priv_op;
 552         u32 func;
 553         u32 msix_base;
 554         u32 op_mode, priv_level;
 555
 556         /* Determine FW API version */
 557         adapter->fw_hal_version = readl(adapter->ahw.pci_base0 + QLCNIC_FW_API);
 558
 559         /* Find PCI function number */
 560         pci_read_config_dword(adapter->pdev, QLCNIC_MSIX_TABLE_OFFSET, &func);
 561         msix_base_addr = adapter->ahw.pci_base0 + QLCNIC_MSIX_BASE;
 562         msix_base = readl(msix_base_addr);
 563         func = (func - msix_base)/QLCNIC_MSIX_TBL_PGSIZE;
 564         adapter->ahw.pci_func = func;
 565
 566         /* Determine function privilege level */
 567         priv_op = adapter->ahw.pci_base0 + QLCNIC_DRV_OP_MODE;
 568         op_mode = readl(priv_op);
 569         if (op_mode == QLC_DEV_DRV_DEFAULT)
 570                 priv_level = QLCNIC_MGMT_FUNC;
 571         else
 572                 priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw.pci_func);
 573
 574         if (priv_level == QLCNIC_NON_PRIV_FUNC) {
 575                 adapter->op_mode = QLCNIC_NON_PRIV_FUNC;
 576                 dev_info(&adapter->pdev->dev,
 577                         "HAL Version: %d Non Privileged function\n",
 578                         adapter->fw_hal_version);
 579                 adapter->nic_ops = &qlcnic_vf_ops;
 580         } else
 581                 adapter->nic_ops = &qlcnic_ops;
 582 }
 583
 584 static int
 585 qlcnic_setup_pci_map(struct qlcnic_adapter *adapter)
 586 {
 587         void __iomem *mem_ptr0 = NULL;
 588         resource_size_t mem_base;
 589         unsigned long mem_len, pci_len0 = 0;
 590
 591         struct pci_dev *pdev = adapter->pdev;
 592
 593         /* remap phys address */
 594         mem_base = pci_resource_start(pdev, 0); /* 0 is for BAR 0 */
 595         mem_len = pci_resource_len(pdev, 0);
 596
 597         if (mem_len == QLCNIC_PCI_2MB_SIZE) {
 598
 599                 mem_ptr0 = pci_ioremap_bar(pdev, 0);
 600                 if (mem_ptr0 == NULL) {
 601                         dev_err(&pdev->dev, "failed to map PCI bar 0\n");
 602                         return -EIO;
 603                 }
 604                 pci_len0 = mem_len;
 605         } else {
 606                 return -EIO;
 607         }
 608
 609         dev_info(&pdev->dev, "%dMB memory map\n", (int)(mem_len>>20));
 610
 611         adapter->ahw.pci_base0 = mem_ptr0;
 612         adapter->ahw.pci_len0 = pci_len0;
 613
 614         qlcnic_check_vf(adapter);
 615
 616         adapter->ahw.ocm_win_crb = qlcnic_get_ioaddr(adapter,
 617                 QLCNIC_PCIX_PS_REG(PCIX_OCM_WINDOW_REG(adapter->ahw.pci_func)));
 618
 619         return 0;
 620 }
 621
 622 static void get_brd_name(struct qlcnic_adapter *adapter, char *name)
 623 {
 624         struct pci_dev *pdev = adapter->pdev;
 625         int i, found = 0;
 626
 627         for (i = 0; i < NUM_SUPPORTED_BOARDS; ++i) {
 628                 if (qlcnic_boards[i].vendor == pdev->vendor &&
 629                         qlcnic_boards[i].device == pdev->device &&
 630                         qlcnic_boards[i].sub_vendor == pdev->subsystem_vendor &&
 631                         qlcnic_boards[i].sub_device == pdev->subsystem_device) {
 632                                 sprintf(name, "%pM: %s" ,
 633                                         adapter->mac_addr,
 634                                         qlcnic_boards[i].short_name);
 635                                 found = 1;
 636                                 break;
 637                 }
 638
 639         }
 640
 641         if (!found)
 642                 sprintf(name, "%pM Gigabit Ethernet", adapter->mac_addr);
 643 }
 644
 645 static void
 646 qlcnic_check_options(struct qlcnic_adapter *adapter)
 647 {
 648         u32 fw_major, fw_minor, fw_build;
 649         struct pci_dev *pdev = adapter->pdev;
 650
 651         fw_major = QLCRD32(adapter, QLCNIC_FW_VERSION_MAJOR);
 652         fw_minor = QLCRD32(adapter, QLCNIC_FW_VERSION_MINOR);
 653         fw_build = QLCRD32(adapter, QLCNIC_FW_VERSION_SUB);
 654
 655         adapter->fw_version = QLCNIC_VERSION_CODE(fw_major, fw_minor, fw_build);
 656
 657         dev_info(&pdev->dev, "firmware v%d.%d.%d\n",
 658                         fw_major, fw_minor, fw_build);
 659
 660         if (adapter->ahw.port_type == QLCNIC_XGBE) {
 661                 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_10G;
 662                 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
 663         } else if (adapter->ahw.port_type == QLCNIC_GBE) {
 664                 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_1G;
 665                 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
 666         }
 667
 668         adapter->msix_supported = !!use_msi_x;
 669         adapter->rss_supported = !!use_msi_x;
 670
 671         adapter->num_txd = MAX_CMD_DESCRIPTORS;
 672
 673         adapter->max_rds_rings = MAX_RDS_RINGS;
 674 }
 675
 676 static int
 677 qlcnic_initialize_nic(struct qlcnic_adapter *adapter)
 678 {
 679         int err;
 680         struct qlcnic_info nic_info;
 681
 682         err = qlcnic_get_nic_info(adapter, &nic_info, adapter->ahw.pci_func);
 683         if (err)
 684                 return err;
 685
 686         adapter->physical_port = (u8)nic_info.phys_port;
 687         adapter->switch_mode = nic_info.switch_mode;
 688         adapter->max_tx_ques = nic_info.max_tx_ques;
 689         adapter->max_rx_ques = nic_info.max_rx_ques;
 690         adapter->capabilities = nic_info.capabilities;
 691         adapter->max_mac_filters = nic_info.max_mac_filters;
 692         adapter->max_mtu = nic_info.max_mtu;
 693
 694         if (adapter->capabilities & BIT_6)
 695                 adapter->flags |= QLCNIC_ESWITCH_ENABLED;
 696         else
 697                 adapter->flags &= ~QLCNIC_ESWITCH_ENABLED;
 698
 699         return err;
 700 }
 701
 702 static void
 703 qlcnic_set_vlan_config(struct qlcnic_adapter *adapter,
 704                 struct qlcnic_esw_func_cfg *esw_cfg)
 705 {
 706         if (esw_cfg->discard_tagged)
 707                 adapter->flags &= ~QLCNIC_TAGGING_ENABLED;
 708         else
 709                 adapter->flags |= QLCNIC_TAGGING_ENABLED;
 710
 711         if (esw_cfg->vlan_id)
 712                 adapter->pvid = esw_cfg->vlan_id;
 713         else
 714                 adapter->pvid = 0;
 715 }
 716
 717 static void
 718 qlcnic_set_eswitch_port_features(struct qlcnic_adapter *adapter,
 719                 struct qlcnic_esw_func_cfg *esw_cfg)
 720 {
 721         adapter->flags &= ~(QLCNIC_MACSPOOF | QLCNIC_MAC_OVERRIDE_DISABLED |
 722                                 QLCNIC_PROMISC_DISABLED);
 723
 724         if (esw_cfg->mac_anti_spoof)
 725                 adapter->flags |= QLCNIC_MACSPOOF;
 726
 727         if (!esw_cfg->mac_override)
 728                 adapter->flags |= QLCNIC_MAC_OVERRIDE_DISABLED;
 729
 730         if (!esw_cfg->promisc_mode)
 731                 adapter->flags |= QLCNIC_PROMISC_DISABLED;
 732
 733         qlcnic_set_netdev_features(adapter, esw_cfg);
 734 }
 735
 736 static int
 737 qlcnic_set_eswitch_port_config(struct qlcnic_adapter *adapter)
 738 {
 739         struct qlcnic_esw_func_cfg esw_cfg;
 740
 741         if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
 742                 return 0;
 743
 744         esw_cfg.pci_func = adapter->ahw.pci_func;
 745         if (qlcnic_get_eswitch_port_config(adapter, &esw_cfg))
 746                         return -EIO;
 747         qlcnic_set_vlan_config(adapter, &esw_cfg);
 748         qlcnic_set_eswitch_port_features(adapter, &esw_cfg);
 749
 750         return 0;
 751 }
 752
 753 static void
 754 qlcnic_set_netdev_features(struct qlcnic_adapter *adapter,
 755                 struct qlcnic_esw_func_cfg *esw_cfg)
 756 {
 757         struct net_device *netdev = adapter->netdev;
 758         unsigned long features, vlan_features;
 759
 760         features = (NETIF_F_SG | NETIF_F_IP_CSUM |
 761                         NETIF_F_IPV6_CSUM | NETIF_F_GRO);
 762         vlan_features = (NETIF_F_SG | NETIF_F_IP_CSUM |
 763                         NETIF_F_IPV6_CSUM);
 764
 765         if (adapter->capabilities & QLCNIC_FW_CAPABILITY_TSO) {
 766                 features |= (NETIF_F_TSO | NETIF_F_TSO6);
 767                 vlan_features |= (NETIF_F_TSO | NETIF_F_TSO6);
 768         }
 769         if (adapter->capabilities & QLCNIC_FW_CAPABILITY_HW_LRO)
 770                 features |= NETIF_F_LRO;
 771
 772         if (esw_cfg->offload_flags & BIT_0) {
 773                 netdev->features |= features;
 774                 adapter->rx_csum = 1;
 775                 if (!(esw_cfg->offload_flags & BIT_1))
 776                         netdev->features &= ~NETIF_F_TSO;
 777                 if (!(esw_cfg->offload_flags & BIT_2))
 778                         netdev->features &= ~NETIF_F_TSO6;
 779         } else {
 780                 netdev->features &= ~features;
 781                 adapter->rx_csum = 0;
 782         }
 783
 784         netdev->vlan_features = (features & vlan_features);
 785 }
 786
 787 static int
 788 qlcnic_check_eswitch_mode(struct qlcnic_adapter *adapter)
 789 {
 790         void __iomem *priv_op;
 791         u32 op_mode, priv_level;
 792         int err = 0;
 793
 794         err = qlcnic_initialize_nic(adapter);
 795         if (err)
 796                 return err;
 797
 798         if (adapter->flags & QLCNIC_ADAPTER_INITIALIZED)
 799                 return 0;
 800
 801         priv_op = adapter->ahw.pci_base0 + QLCNIC_DRV_OP_MODE;
 802         op_mode = readl(priv_op);
 803         priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw.pci_func);
 804
 805         if (op_mode == QLC_DEV_DRV_DEFAULT)
 806                 priv_level = QLCNIC_MGMT_FUNC;
 807         else
 808                 priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw.pci_func);
 809
 810         if (adapter->flags & QLCNIC_ESWITCH_ENABLED) {
 811                 if (priv_level == QLCNIC_MGMT_FUNC) {
 812                         adapter->op_mode = QLCNIC_MGMT_FUNC;
 813                         err = qlcnic_init_pci_info(adapter);
 814                         if (err)
 815                                 return err;
 816                         /* Set privilege level for other functions */
 817                         qlcnic_set_function_modes(adapter);
 818                         dev_info(&adapter->pdev->dev,
 819                                 "HAL Version: %d, Management function\n",
 820                                 adapter->fw_hal_version);
 821                 } else if (priv_level == QLCNIC_PRIV_FUNC) {
 822                         adapter->op_mode = QLCNIC_PRIV_FUNC;
 823                         dev_info(&adapter->pdev->dev,
 824                                 "HAL Version: %d, Privileged function\n",
 825                                 adapter->fw_hal_version);
 826                 }
 827         }
 828
 829         adapter->flags |= QLCNIC_ADAPTER_INITIALIZED;
 830
 831         return err;
 832 }
 833
 834 static int
 835 qlcnic_set_default_offload_settings(struct qlcnic_adapter *adapter)
 836 {
 837         struct qlcnic_esw_func_cfg esw_cfg;
 838         struct qlcnic_npar_info *npar;
 839         u8 i;
 840
 841         if (adapter->need_fw_reset)
 842                 return 0;
 843
 844         for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
 845                 if (adapter->npars[i].type != QLCNIC_TYPE_NIC)
 846                         continue;
 847                 memset(&esw_cfg, 0, sizeof(struct qlcnic_esw_func_cfg));
 848                 esw_cfg.pci_func = i;
 849                 esw_cfg.offload_flags = BIT_0;
 850                 esw_cfg.mac_override = BIT_0;
 851                 esw_cfg.promisc_mode = BIT_0;
 852                 if (adapter->capabilities  & QLCNIC_FW_CAPABILITY_TSO)
 853                         esw_cfg.offload_flags |= (BIT_1 | BIT_2);
 854                 if (qlcnic_config_switch_port(adapter, &esw_cfg))
 855                         return -EIO;
 856                 npar = &adapter->npars[i];
 857                 npar->pvid = esw_cfg.vlan_id;
 858                 npar->mac_override = esw_cfg.mac_override;
 859                 npar->mac_anti_spoof = esw_cfg.mac_anti_spoof;
 860                 npar->discard_tagged = esw_cfg.discard_tagged;
 861                 npar->promisc_mode = esw_cfg.promisc_mode;
 862                 npar->offload_flags = esw_cfg.offload_flags;
 863         }
 864
 865         return 0;
 866 }
 867
 868 static int
 869 qlcnic_reset_eswitch_config(struct qlcnic_adapter *adapter,
 870                         struct qlcnic_npar_info *npar, int pci_func)
 871 {
 872         struct qlcnic_esw_func_cfg esw_cfg;
 873         esw_cfg.op_mode = QLCNIC_PORT_DEFAULTS;
 874         esw_cfg.pci_func = pci_func;
 875         esw_cfg.vlan_id = npar->pvid;
 876         esw_cfg.mac_override = npar->mac_override;
 877         esw_cfg.discard_tagged = npar->discard_tagged;
 878         esw_cfg.mac_anti_spoof = npar->mac_anti_spoof;
 879         esw_cfg.offload_flags = npar->offload_flags;
 880         esw_cfg.promisc_mode = npar->promisc_mode;
 881         if (qlcnic_config_switch_port(adapter, &esw_cfg))
 882                 return -EIO;
 883
 884         esw_cfg.op_mode = QLCNIC_ADD_VLAN;
 885         if (qlcnic_config_switch_port(adapter, &esw_cfg))
 886                 return -EIO;
 887
 888         return 0;
 889 }
 890
 891 static int
 892 qlcnic_reset_npar_config(struct qlcnic_adapter *adapter)
 893 {
 894         int i, err;
 895         struct qlcnic_npar_info *npar;
 896         struct qlcnic_info nic_info;
 897
 898         if (!adapter->need_fw_reset)
 899                 return 0;
 900
 901         /* Set the NPAR config data after FW reset */
 902         for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
 903                 npar = &adapter->npars[i];
 904                 if (npar->type != QLCNIC_TYPE_NIC)
 905                         continue;
 906                 err = qlcnic_get_nic_info(adapter, &nic_info, i);
 907                 if (err)
 908                         return err;
 909                 nic_info.min_tx_bw = npar->min_bw;
 910                 nic_info.max_tx_bw = npar->max_bw;
 911                 err = qlcnic_set_nic_info(adapter, &nic_info);
 912                 if (err)
 913                         return err;
 914
 915                 if (npar->enable_pm) {
 916                         err = qlcnic_config_port_mirroring(adapter,
 917                                                         npar->dest_npar, 1, i);
 918                         if (err)
 919                                 return err;
 920                 }
 921                 err = qlcnic_reset_eswitch_config(adapter, npar, i);
 922                 if (err)
 923                         return err;
 924         }
 925         return 0;
 926 }
 927
 928 static int qlcnic_check_npar_opertional(struct qlcnic_adapter *adapter)
 929 {
 930         u8 npar_opt_timeo = QLCNIC_DEV_NPAR_OPER_TIMEO;
 931         u32 npar_state;
 932
 933         if (adapter->op_mode == QLCNIC_MGMT_FUNC)
 934                 return 0;
 935
 936         npar_state = QLCRD32(adapter, QLCNIC_CRB_DEV_NPAR_STATE);
 937         while (npar_state != QLCNIC_DEV_NPAR_OPER && --npar_opt_timeo) {
 938                 msleep(1000);
 939                 npar_state = QLCRD32(adapter, QLCNIC_CRB_DEV_NPAR_STATE);
 940         }
 941         if (!npar_opt_timeo) {
 942                 dev_err(&adapter->pdev->dev,
 943                         "Waiting for NPAR state to opertional timeout\n");
 944                 return -EIO;
 945         }
 946         return 0;
 947 }
 948
 949 static int
 950 qlcnic_set_mgmt_operations(struct qlcnic_adapter *adapter)
 951 {
 952         int err;
 953
 954         if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED) ||
 955                     adapter->op_mode != QLCNIC_MGMT_FUNC)
 956                 return 0;
 957
 958         err = qlcnic_set_default_offload_settings(adapter);
 959         if (err)
 960                 return err;
 961
 962         err = qlcnic_reset_npar_config(adapter);
 963         if (err)
 964                 return err;
 965
 966         qlcnic_dev_set_npar_ready(adapter);
 967
 968         return err;
 969 }
 970
 971 static int
 972 qlcnic_start_firmware(struct qlcnic_adapter *adapter)
 973 {
 974         int err;
 975
 976         err = qlcnic_can_start_firmware(adapter);
 977         if (err < 0)
 978                 return err;
 979         else if (!err)
 980                 goto check_fw_status;
 981
 982         if (load_fw_file)
 983                 qlcnic_request_firmware(adapter);
 984         else {
 985                 err = qlcnic_check_flash_fw_ver(adapter);
 986                 if (err)
 987                         goto err_out;
 988
 989                 adapter->fw_type = QLCNIC_FLASH_ROMIMAGE;
 990         }
 991
 992         err = qlcnic_need_fw_reset(adapter);
 993         if (err == 0)
 994                 goto check_fw_status;
 995
 996         err = qlcnic_pinit_from_rom(adapter);
 997         if (err)
 998                 goto err_out;
 999
1000         err = qlcnic_load_firmware(adapter);
1001         if (err)
1002                 goto err_out;
1003
1004         qlcnic_release_firmware(adapter);
1005         QLCWR32(adapter, CRB_DRIVER_VERSION, QLCNIC_DRIVER_VERSION);
1006
1007 check_fw_status:
1008         err = qlcnic_check_fw_status(adapter);
1009         if (err)
1010                 goto err_out;
1011
1012         QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_READY);
1013         qlcnic_idc_debug_info(adapter, 1);
1014
1015         err = qlcnic_check_eswitch_mode(adapter);
1016         if (err) {
1017                 dev_err(&adapter->pdev->dev,
1018                         "Memory allocation failed for eswitch\n");
1019                 goto err_out;
1020         }
1021         err = qlcnic_set_mgmt_operations(adapter);
1022         if (err)
1023                 goto err_out;
1024
1025         qlcnic_check_options(adapter);
1026         adapter->need_fw_reset = 0;
1027
1028         qlcnic_release_firmware(adapter);
1029         return 0;
1030
1031 err_out:
1032         QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_FAILED);
1033         dev_err(&adapter->pdev->dev, "Device state set to failed\n");
1034
1035         qlcnic_release_firmware(adapter);
1036         return err;
1037 }
1038
1039 static int
1040 qlcnic_request_irq(struct qlcnic_adapter *adapter)
1041 {
1042         irq_handler_t handler;
1043         struct qlcnic_host_sds_ring *sds_ring;
1044         int err, ring;
1045
1046         unsigned long flags = 0;
1047         struct net_device *netdev = adapter->netdev;
1048         struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
1049
1050         if (adapter->diag_test == QLCNIC_INTERRUPT_TEST) {
1051                 handler = qlcnic_tmp_intr;
1052                 if (!QLCNIC_IS_MSI_FAMILY(adapter))
1053                         flags |= IRQF_SHARED;
1054
1055         } else {
1056                 if (adapter->flags & QLCNIC_MSIX_ENABLED)
1057                         handler = qlcnic_msix_intr;
1058                 else if (adapter->flags & QLCNIC_MSI_ENABLED)
1059                         handler = qlcnic_msi_intr;
1060                 else {
1061                         flags |= IRQF_SHARED;
1062                         handler = qlcnic_intr;
1063                 }
1064         }
1065         adapter->irq = netdev->irq;
1066
1067         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1068                 sds_ring = &recv_ctx->sds_rings[ring];
1069                 sprintf(sds_ring->name, "%s[%d]", netdev->name, ring);
1070                 err = request_irq(sds_ring->irq, handler,
1071                                   flags, sds_ring->name, sds_ring);
1072                 if (err)
1073                         return err;
1074         }
1075
1076         return 0;
1077 }
1078
1079 static void
1080 qlcnic_free_irq(struct qlcnic_adapter *adapter)
1081 {
1082         int ring;
1083         struct qlcnic_host_sds_ring *sds_ring;
1084
1085         struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
1086
1087         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1088                 sds_ring = &recv_ctx->sds_rings[ring];
1089                 free_irq(sds_ring->irq, sds_ring);
1090         }
1091 }
1092
1093 static void
1094 qlcnic_init_coalesce_defaults(struct qlcnic_adapter *adapter)
1095 {
1096         adapter->coal.flags = QLCNIC_INTR_DEFAULT;
1097         adapter->coal.normal.data.rx_time_us =
1098                 QLCNIC_DEFAULT_INTR_COALESCE_RX_TIME_US;
1099         adapter->coal.normal.data.rx_packets =
1100                 QLCNIC_DEFAULT_INTR_COALESCE_RX_PACKETS;
1101         adapter->coal.normal.data.tx_time_us =
1102                 QLCNIC_DEFAULT_INTR_COALESCE_TX_TIME_US;
1103         adapter->coal.normal.data.tx_packets =
1104                 QLCNIC_DEFAULT_INTR_COALESCE_TX_PACKETS;
1105 }
1106
1107 static int
1108 __qlcnic_up(struct qlcnic_adapter *adapter, struct net_device *netdev)
1109 {
1110         int ring;
1111         struct qlcnic_host_rds_ring *rds_ring;
1112
1113         if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1114                 return -EIO;
1115
1116         if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
1117                 return 0;
1118         if (qlcnic_set_eswitch_port_config(adapter))
1119                 return -EIO;
1120
1121         if (qlcnic_fw_create_ctx(adapter))
1122                 return -EIO;
1123
1124         for (ring = 0; ring < adapter->max_rds_rings; ring++) {
1125                 rds_ring = &adapter->recv_ctx.rds_rings[ring];
1126                 qlcnic_post_rx_buffers(adapter, ring, rds_ring);
1127         }
1128
1129         qlcnic_set_multi(netdev);
1130         qlcnic_fw_cmd_set_mtu(adapter, netdev->mtu);
1131
1132         adapter->ahw.linkup = 0;
1133
1134         if (adapter->max_sds_rings > 1)
1135                 qlcnic_config_rss(adapter, 1);
1136
1137         qlcnic_config_intr_coalesce(adapter);
1138
1139         if (netdev->features & NETIF_F_LRO)
1140                 qlcnic_config_hw_lro(adapter, QLCNIC_LRO_ENABLED);
1141
1142         qlcnic_napi_enable(adapter);
1143
1144         qlcnic_linkevent_request(adapter, 1);
1145
1146         adapter->reset_context = 0;
1147         set_bit(__QLCNIC_DEV_UP, &adapter->state);
1148         return 0;
1149 }
1150
1151 /* Usage: During resume and firmware recovery module.*/
1152
1153 static int
1154 qlcnic_up(struct qlcnic_adapter *adapter, struct net_device *netdev)
1155 {
1156         int err = 0;
1157
1158         rtnl_lock();
1159         if (netif_running(netdev))
1160                 err = __qlcnic_up(adapter, netdev);
1161         rtnl_unlock();
1162
1163         return err;
1164 }
1165
1166 static void
1167 __qlcnic_down(struct qlcnic_adapter *adapter, struct net_device *netdev)
1168 {
1169         if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1170                 return;
1171
1172         if (!test_and_clear_bit(__QLCNIC_DEV_UP, &adapter->state))
1173                 return;
1174
1175         smp_mb();
1176         spin_lock(&adapter->tx_clean_lock);
1177         netif_carrier_off(netdev);
1178         netif_tx_disable(netdev);
1179
1180         qlcnic_free_mac_list(adapter);
1181
1182         if (adapter->fhash.fnum)
1183                 qlcnic_delete_lb_filters(adapter);
1184
1185         qlcnic_nic_set_promisc(adapter, QLCNIC_NIU_NON_PROMISC_MODE);
1186
1187         qlcnic_napi_disable(adapter);
1188
1189         qlcnic_fw_destroy_ctx(adapter);
1190
1191         qlcnic_reset_rx_buffers_list(adapter);
1192         qlcnic_release_tx_buffers(adapter);
1193         spin_unlock(&adapter->tx_clean_lock);
1194 }
1195
1196 /* Usage: During suspend and firmware recovery module */
1197
1198 static void
1199 qlcnic_down(struct qlcnic_adapter *adapter, struct net_device *netdev)
1200 {
1201         rtnl_lock();
1202         if (netif_running(netdev))
1203                 __qlcnic_down(adapter, netdev);
1204         rtnl_unlock();
1205
1206 }
1207
1208 static int
1209 qlcnic_attach(struct qlcnic_adapter *adapter)
1210 {
1211         struct net_device *netdev = adapter->netdev;
1212         struct pci_dev *pdev = adapter->pdev;
1213         int err;
1214
1215         if (adapter->is_up == QLCNIC_ADAPTER_UP_MAGIC)
1216                 return 0;
1217
1218         err = qlcnic_napi_add(adapter, netdev);
1219         if (err)
1220                 return err;
1221
1222         err = qlcnic_alloc_sw_resources(adapter);
1223         if (err) {
1224                 dev_err(&pdev->dev, "Error in setting sw resources\n");
1225                 goto err_out_napi_del;
1226         }
1227
1228         err = qlcnic_alloc_hw_resources(adapter);
1229         if (err) {
1230                 dev_err(&pdev->dev, "Error in setting hw resources\n");
1231                 goto err_out_free_sw;
1232         }
1233
1234         err = qlcnic_request_irq(adapter);
1235         if (err) {
1236                 dev_err(&pdev->dev, "failed to setup interrupt\n");
1237                 goto err_out_free_hw;
1238         }
1239
1240         qlcnic_init_coalesce_defaults(adapter);
1241
1242         qlcnic_create_sysfs_entries(adapter);
1243
1244         adapter->is_up = QLCNIC_ADAPTER_UP_MAGIC;
1245         return 0;
1246
1247 err_out_free_hw:
1248         qlcnic_free_hw_resources(adapter);
1249 err_out_free_sw:
1250         qlcnic_free_sw_resources(adapter);
1251 err_out_napi_del:
1252         qlcnic_napi_del(adapter);
1253         return err;
1254 }
1255
1256 static void
1257 qlcnic_detach(struct qlcnic_adapter *adapter)
1258 {
1259         if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1260                 return;
1261
1262         qlcnic_remove_sysfs_entries(adapter);
1263
1264         qlcnic_free_hw_resources(adapter);
1265         qlcnic_release_rx_buffers(adapter);
1266         qlcnic_free_irq(adapter);
1267         qlcnic_napi_del(adapter);
1268         qlcnic_free_sw_resources(adapter);
1269
1270         adapter->is_up = 0;
1271 }
1272
1273 void qlcnic_diag_free_res(struct net_device *netdev, int max_sds_rings)
1274 {
1275         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1276         struct qlcnic_host_sds_ring *sds_ring;
1277         int ring;
1278
1279         clear_bit(__QLCNIC_DEV_UP, &adapter->state);
1280         if (adapter->diag_test == QLCNIC_INTERRUPT_TEST) {
1281                 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1282                         sds_ring = &adapter->recv_ctx.sds_rings[ring];
1283                         qlcnic_disable_int(sds_ring);
1284                 }
1285         }
1286
1287         qlcnic_fw_destroy_ctx(adapter);
1288
1289         qlcnic_detach(adapter);
1290
1291         adapter->diag_test = 0;
1292         adapter->max_sds_rings = max_sds_rings;
1293
1294         if (qlcnic_attach(adapter))
1295                 goto out;
1296
1297         if (netif_running(netdev))
1298                 __qlcnic_up(adapter, netdev);
1299 out:
1300         netif_device_attach(netdev);
1301 }
1302
1303 int qlcnic_diag_alloc_res(struct net_device *netdev, int test)
1304 {
1305         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1306         struct qlcnic_host_sds_ring *sds_ring;
1307         struct qlcnic_host_rds_ring *rds_ring;
1308         int ring;
1309         int ret;
1310
1311         netif_device_detach(netdev);
1312
1313         if (netif_running(netdev))
1314                 __qlcnic_down(adapter, netdev);
1315
1316         qlcnic_detach(adapter);
1317
1318         adapter->max_sds_rings = 1;
1319         adapter->diag_test = test;
1320
1321         ret = qlcnic_attach(adapter);
1322         if (ret) {
1323                 netif_device_attach(netdev);
1324                 return ret;
1325         }
1326
1327         ret = qlcnic_fw_create_ctx(adapter);
1328         if (ret) {
1329                 qlcnic_detach(adapter);
1330                 netif_device_attach(netdev);
1331                 return ret;
1332         }
1333
1334         for (ring = 0; ring < adapter->max_rds_rings; ring++) {
1335                 rds_ring = &adapter->recv_ctx.rds_rings[ring];
1336                 qlcnic_post_rx_buffers(adapter, ring, rds_ring);
1337         }
1338
1339         if (adapter->diag_test == QLCNIC_INTERRUPT_TEST) {
1340                 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1341                         sds_ring = &adapter->recv_ctx.sds_rings[ring];
1342                         qlcnic_enable_int(sds_ring);
1343                 }
1344         }
1345         set_bit(__QLCNIC_DEV_UP, &adapter->state);
1346
1347         return 0;
1348 }
1349
1350 /* Reset context in hardware only */
1351 static int
1352 qlcnic_reset_hw_context(struct qlcnic_adapter *adapter)
1353 {
1354         struct net_device *netdev = adapter->netdev;
1355
1356         if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
1357                 return -EBUSY;
1358
1359         netif_device_detach(netdev);
1360
1361         qlcnic_down(adapter, netdev);
1362
1363         qlcnic_up(adapter, netdev);
1364
1365         netif_device_attach(netdev);
1366
1367         clear_bit(__QLCNIC_RESETTING, &adapter->state);
1368         return 0;
1369 }
1370
1371 int
1372 qlcnic_reset_context(struct qlcnic_adapter *adapter)
1373 {
1374         int err = 0;
1375         struct net_device *netdev = adapter->netdev;
1376
1377         if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
1378                 return -EBUSY;
1379
1380         if (adapter->is_up == QLCNIC_ADAPTER_UP_MAGIC) {
1381
1382                 netif_device_detach(netdev);
1383
1384                 if (netif_running(netdev))
1385                         __qlcnic_down(adapter, netdev);
1386
1387                 qlcnic_detach(adapter);
1388
1389                 if (netif_running(netdev)) {
1390                         err = qlcnic_attach(adapter);
1391                         if (!err)
1392                                 __qlcnic_up(adapter, netdev);
1393                 }
1394
1395                 netif_device_attach(netdev);
1396         }
1397
1398         clear_bit(__QLCNIC_RESETTING, &adapter->state);
1399         return err;
1400 }
1401
1402 static int
1403 qlcnic_setup_netdev(struct qlcnic_adapter *adapter,
1404                 struct net_device *netdev, u8 pci_using_dac)
1405 {
1406         int err;
1407         struct pci_dev *pdev = adapter->pdev;
1408
1409         adapter->rx_csum = 1;
1410         adapter->mc_enabled = 0;
1411         adapter->max_mc_count = 38;
1412
1413         netdev->netdev_ops         = &qlcnic_netdev_ops;
1414         netdev->watchdog_timeo     = 5*HZ;
1415
1416         qlcnic_change_mtu(netdev, netdev->mtu);
1417
1418         SET_ETHTOOL_OPS(netdev, &qlcnic_ethtool_ops);
1419
1420         netdev->features |= (NETIF_F_SG | NETIF_F_IP_CSUM |
1421                 NETIF_F_IPV6_CSUM | NETIF_F_GRO | NETIF_F_HW_VLAN_RX);
1422         netdev->vlan_features |= (NETIF_F_SG | NETIF_F_IP_CSUM |
1423                 NETIF_F_IPV6_CSUM);
1424
1425         if (adapter->capabilities & QLCNIC_FW_CAPABILITY_TSO) {
1426                 netdev->features |= (NETIF_F_TSO | NETIF_F_TSO6);
1427                 netdev->vlan_features |= (NETIF_F_TSO | NETIF_F_TSO6);
1428         }
1429
1430         if (pci_using_dac) {
1431                 netdev->features |= NETIF_F_HIGHDMA;
1432                 netdev->vlan_features |= NETIF_F_HIGHDMA;
1433         }
1434
1435         if (adapter->capabilities & QLCNIC_FW_CAPABILITY_FVLANTX)
1436                 netdev->features |= (NETIF_F_HW_VLAN_TX);
1437
1438         if (adapter->capabilities & QLCNIC_FW_CAPABILITY_HW_LRO)
1439                 netdev->features |= NETIF_F_LRO;
1440         netdev->irq = adapter->msix_entries[0].vector;
1441
1442         netif_carrier_off(netdev);
1443         netif_stop_queue(netdev);
1444
1445         err = register_netdev(netdev);
1446         if (err) {
1447                 dev_err(&pdev->dev, "failed to register net device\n");
1448                 return err;
1449         }
1450
1451         return 0;
1452 }
1453
1454 static int qlcnic_set_dma_mask(struct pci_dev *pdev, u8 *pci_using_dac)
1455 {
1456         if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) &&
1457                         !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
1458                 *pci_using_dac = 1;
1459         else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) &&
1460                         !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)))
1461                 *pci_using_dac = 0;
1462         else {
1463                 dev_err(&pdev->dev, "Unable to set DMA mask, aborting\n");
1464                 return -EIO;
1465         }
1466
1467         return 0;
1468 }
1469
1470 static int __devinit
1471 qlcnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1472 {
1473         struct net_device *netdev = NULL;
1474         struct qlcnic_adapter *adapter = NULL;
1475         int err;
1476         uint8_t revision_id;
1477         uint8_t pci_using_dac;
1478         char brd_name[QLCNIC_MAX_BOARD_NAME_LEN];
1479
1480         err = pci_enable_device(pdev);
1481         if (err)
1482                 return err;
1483
1484         if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
1485                 err = -ENODEV;
1486                 goto err_out_disable_pdev;
1487         }
1488
1489         err = qlcnic_set_dma_mask(pdev, &pci_using_dac);
1490         if (err)
1491                 goto err_out_disable_pdev;
1492
1493         err = pci_request_regions(pdev, qlcnic_driver_name);
1494         if (err)
1495                 goto err_out_disable_pdev;
1496
1497         pci_set_master(pdev);
1498         pci_enable_pcie_error_reporting(pdev);
1499
1500         netdev = alloc_etherdev(sizeof(struct qlcnic_adapter));
1501         if (!netdev) {
1502                 dev_err(&pdev->dev, "failed to allocate net_device\n");
1503                 err = -ENOMEM;
1504                 goto err_out_free_res;
1505         }
1506
1507         SET_NETDEV_DEV(netdev, &pdev->dev);
1508
1509         adapter = netdev_priv(netdev);
1510         adapter->netdev  = netdev;
1511         adapter->pdev    = pdev;
1512         adapter->dev_rst_time = jiffies;
1513
1514         revision_id = pdev->revision;
1515         adapter->ahw.revision_id = revision_id;
1516
1517         rwlock_init(&adapter->ahw.crb_lock);
1518         mutex_init(&adapter->ahw.mem_lock);
1519
1520         spin_lock_init(&adapter->tx_clean_lock);
1521         INIT_LIST_HEAD(&adapter->mac_list);
1522
1523         err = qlcnic_setup_pci_map(adapter);
1524         if (err)
1525                 goto err_out_free_netdev;
1526
1527         /* This will be reset for mezz cards  */
1528         adapter->portnum = adapter->ahw.pci_func;
1529
1530         err = qlcnic_get_board_info(adapter);
1531         if (err) {
1532                 dev_err(&pdev->dev, "Error getting board config info.\n");
1533                 goto err_out_iounmap;
1534         }
1535
1536         err = qlcnic_setup_idc_param(adapter);
1537         if (err)
1538                 goto err_out_iounmap;
1539
1540         err = adapter->nic_ops->start_firmware(adapter);
1541         if (err) {
1542                 dev_err(&pdev->dev, "Loading fw failed.Please Reboot\n");
1543                 goto err_out_decr_ref;
1544         }
1545
1546         if (qlcnic_read_mac_addr(adapter))
1547                 dev_warn(&pdev->dev, "failed to read mac addr\n");
1548
1549         if (adapter->portnum == 0) {
1550                 get_brd_name(adapter, brd_name);
1551
1552                 pr_info("%s: %s Board Chip rev 0x%x\n",
1553                                 module_name(THIS_MODULE),
1554                                 brd_name, adapter->ahw.revision_id);
1555         }
1556
1557         qlcnic_clear_stats(adapter);
1558
1559         qlcnic_setup_intr(adapter);
1560
1561         err = qlcnic_setup_netdev(adapter, netdev, pci_using_dac);
1562         if (err)
1563                 goto err_out_disable_msi;
1564
1565         pci_set_drvdata(pdev, adapter);
1566
1567         qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
1568
1569         switch (adapter->ahw.port_type) {
1570         case QLCNIC_GBE:
1571                 dev_info(&adapter->pdev->dev, "%s: GbE port initialized\n",
1572                                 adapter->netdev->name);
1573                 break;
1574         case QLCNIC_XGBE:
1575                 dev_info(&adapter->pdev->dev, "%s: XGbE port initialized\n",
1576                                 adapter->netdev->name);
1577                 break;
1578         }
1579
1580         qlcnic_alloc_lb_filters_mem(adapter);
1581         qlcnic_create_diag_entries(adapter);
1582
1583         return 0;
1584
1585 err_out_disable_msi:
1586         qlcnic_teardown_intr(adapter);
1587
1588 err_out_decr_ref:
1589         qlcnic_clr_all_drv_state(adapter, 0);
1590
1591 err_out_iounmap:
1592         qlcnic_cleanup_pci_map(adapter);
1593
1594 err_out_free_netdev:
1595         free_netdev(netdev);
1596
1597 err_out_free_res:
1598         pci_release_regions(pdev);
1599
1600 err_out_disable_pdev:
1601         pci_set_drvdata(pdev, NULL);
1602         pci_disable_device(pdev);
1603         return err;
1604 }
1605
1606 static void __devexit qlcnic_remove(struct pci_dev *pdev)
1607 {
1608         struct qlcnic_adapter *adapter;
1609         struct net_device *netdev;
1610
1611         adapter = pci_get_drvdata(pdev);
1612         if (adapter == NULL)
1613                 return;
1614
1615         netdev = adapter->netdev;
1616
1617         qlcnic_cancel_fw_work(adapter);
1618
1619         unregister_netdev(netdev);
1620
1621         qlcnic_detach(adapter);
1622
1623         if (adapter->npars != NULL)
1624                 kfree(adapter->npars);
1625         if (adapter->eswitch != NULL)
1626                 kfree(adapter->eswitch);
1627
1628         qlcnic_clr_all_drv_state(adapter, 0);
1629
1630         clear_bit(__QLCNIC_RESETTING, &adapter->state);
1631
1632         qlcnic_free_lb_filters_mem(adapter);
1633
1634         qlcnic_teardown_intr(adapter);
1635
1636         qlcnic_remove_diag_entries(adapter);
1637
1638         qlcnic_cleanup_pci_map(adapter);
1639
1640         qlcnic_release_firmware(adapter);
1641
1642         pci_disable_pcie_error_reporting(pdev);
1643         pci_release_regions(pdev);
1644         pci_disable_device(pdev);
1645         pci_set_drvdata(pdev, NULL);
1646
1647         free_netdev(netdev);
1648 }
1649 static int __qlcnic_shutdown(struct pci_dev *pdev)
1650 {
1651         struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
1652         struct net_device *netdev = adapter->netdev;
1653         int retval;
1654
1655         netif_device_detach(netdev);
1656
1657         qlcnic_cancel_fw_work(adapter);
1658
1659         if (netif_running(netdev))
1660                 qlcnic_down(adapter, netdev);
1661
1662         qlcnic_clr_all_drv_state(adapter, 0);
1663
1664         clear_bit(__QLCNIC_RESETTING, &adapter->state);
1665
1666         retval = pci_save_state(pdev);
1667         if (retval)
1668                 return retval;
1669
1670         if (qlcnic_wol_supported(adapter)) {
1671                 pci_enable_wake(pdev, PCI_D3cold, 1);
1672                 pci_enable_wake(pdev, PCI_D3hot, 1);
1673         }
1674
1675         return 0;
1676 }
1677
1678 static void qlcnic_shutdown(struct pci_dev *pdev)
1679 {
1680         if (__qlcnic_shutdown(pdev))
1681                 return;
1682
1683         pci_disable_device(pdev);
1684 }
1685
1686 #ifdef CONFIG_PM
1687 static int
1688 qlcnic_suspend(struct pci_dev *pdev, pm_message_t state)
1689 {
1690         int retval;
1691
1692         retval = __qlcnic_shutdown(pdev);
1693         if (retval)
1694                 return retval;
1695
1696         pci_set_power_state(pdev, pci_choose_state(pdev, state));
1697         return 0;
1698 }
1699
1700 static int
1701 qlcnic_resume(struct pci_dev *pdev)
1702 {
1703         struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
1704         struct net_device *netdev = adapter->netdev;
1705         int err;
1706
1707         err = pci_enable_device(pdev);
1708         if (err)
1709                 return err;
1710
1711         pci_set_power_state(pdev, PCI_D0);
1712         pci_set_master(pdev);
1713         pci_restore_state(pdev);
1714
1715         err = adapter->nic_ops->start_firmware(adapter);
1716         if (err) {
1717                 dev_err(&pdev->dev, "failed to start firmware\n");
1718                 return err;
1719         }
1720
1721         if (netif_running(netdev)) {
1722                 err = qlcnic_up(adapter, netdev);
1723                 if (err)
1724                         goto done;
1725
1726                 qlcnic_restore_indev_addr(netdev, NETDEV_UP);
1727         }
1728 done:
1729         netif_device_attach(netdev);
1730         qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
1731         return 0;
1732 }
1733 #endif
1734
1735 static int qlcnic_open(struct net_device *netdev)
1736 {
1737         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1738         int err;
1739
1740         err = qlcnic_attach(adapter);
1741         if (err)
1742                 return err;
1743
1744         err = __qlcnic_up(adapter, netdev);
1745         if (err)
1746                 goto err_out;
1747
1748         netif_start_queue(netdev);
1749
1750         return 0;
1751
1752 err_out:
1753         qlcnic_detach(adapter);
1754         return err;
1755 }
1756
1757 /*
1758  * qlcnic_close - Disables a network interface entry point
1759  */
1760 static int qlcnic_close(struct net_device *netdev)
1761 {
1762         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1763
1764         __qlcnic_down(adapter, netdev);
1765         return 0;
1766 }
1767
1768 static void
1769 qlcnic_alloc_lb_filters_mem(struct qlcnic_adapter *adapter)
1770 {
1771         void *head;
1772         int i;
1773
1774         if (!qlcnic_mac_learn)
1775                 return;
1776
1777         spin_lock_init(&adapter->mac_learn_lock);
1778
1779         head = kcalloc(QLCNIC_LB_MAX_FILTERS, sizeof(struct hlist_head),
1780                                                                 GFP_KERNEL);
1781         if (!head)
1782                 return;
1783
1784         adapter->fhash.fmax = QLCNIC_LB_MAX_FILTERS;
1785         adapter->fhash.fhead = (struct hlist_head *)head;
1786
1787         for (i = 0; i < adapter->fhash.fmax; i++)
1788                 INIT_HLIST_HEAD(&adapter->fhash.fhead[i]);
1789 }
1790
1791 static void qlcnic_free_lb_filters_mem(struct qlcnic_adapter *adapter)
1792 {
1793         if (adapter->fhash.fmax && adapter->fhash.fhead)
1794                 kfree(adapter->fhash.fhead);
1795
1796         adapter->fhash.fhead = NULL;
1797         adapter->fhash.fmax = 0;
1798 }
1799
1800 static void qlcnic_change_filter(struct qlcnic_adapter *adapter,
1801                 u64 uaddr, __le16 vlan_id, struct qlcnic_host_tx_ring *tx_ring)
1802 {
1803         struct cmd_desc_type0 *hwdesc;
1804         struct qlcnic_nic_req *req;
1805         struct qlcnic_mac_req *mac_req;
1806         struct qlcnic_vlan_req *vlan_req;
1807         u32 producer;
1808         u64 word;
1809
1810         producer = tx_ring->producer;
1811         hwdesc = &tx_ring->desc_head[tx_ring->producer];
1812
1813         req = (struct qlcnic_nic_req *)hwdesc;
1814         memset(req, 0, sizeof(struct qlcnic_nic_req));
1815         req->qhdr = cpu_to_le64(QLCNIC_REQUEST << 23);
1816
1817         word = QLCNIC_MAC_EVENT | ((u64)(adapter->portnum) << 16);
1818         req->req_hdr = cpu_to_le64(word);
1819
1820         mac_req = (struct qlcnic_mac_req *)&(req->words[0]);
1821         mac_req->op = vlan_id ? QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_ADD;
1822         memcpy(mac_req->mac_addr, &uaddr, ETH_ALEN);
1823
1824         vlan_req = (struct qlcnic_vlan_req *)&req->words[1];
1825         vlan_req->vlan_id = vlan_id;
1826
1827         tx_ring->producer = get_next_index(producer, tx_ring->num_desc);
1828 }
1829
1830 #define QLCNIC_MAC_HASH(MAC)\
1831         ((((MAC) & 0x70000) >> 0x10) | (((MAC) & 0x70000000000ULL) >> 0x25))
1832
1833 static void
1834 qlcnic_send_filter(struct qlcnic_adapter *adapter,
1835                 struct qlcnic_host_tx_ring *tx_ring,
1836                 struct cmd_desc_type0 *first_desc,
1837                 struct sk_buff *skb)
1838 {
1839         struct ethhdr *phdr = (struct ethhdr *)(skb->data);
1840         struct qlcnic_filter *fil, *tmp_fil;
1841         struct hlist_node *tmp_hnode, *n;
1842         struct hlist_head *head;
1843         u64 src_addr = 0;
1844         __le16 vlan_id = 0;
1845         u8 hindex;
1846
1847         if (!compare_ether_addr(phdr->h_source, adapter->mac_addr))
1848                 return;
1849
1850         if (adapter->fhash.fnum >= adapter->fhash.fmax)
1851                 return;
1852
1853         /* Only NPAR capable devices support vlan based learning*/
1854         if (adapter->flags & QLCNIC_ESWITCH_ENABLED)
1855                 vlan_id = first_desc->vlan_TCI;
1856         memcpy(&src_addr, phdr->h_source, ETH_ALEN);
1857         hindex = QLCNIC_MAC_HASH(src_addr) & (QLCNIC_LB_MAX_FILTERS - 1);
1858         head = &(adapter->fhash.fhead[hindex]);
1859
1860         hlist_for_each_entry_safe(tmp_fil, tmp_hnode, n, head, fnode) {
1861                 if (!memcmp(tmp_fil->faddr, &src_addr, ETH_ALEN) &&
1862                             tmp_fil->vlan_id == vlan_id) {
1863
1864                         if (jiffies >
1865                             (QLCNIC_READD_AGE * HZ + tmp_fil->ftime))
1866                                 qlcnic_change_filter(adapter, src_addr, vlan_id,
1867                                                                 tx_ring);
1868                         tmp_fil->ftime = jiffies;
1869                         return;
1870                 }
1871         }
1872
1873         fil = kzalloc(sizeof(struct qlcnic_filter), GFP_ATOMIC);
1874         if (!fil)
1875                 return;
1876
1877         qlcnic_change_filter(adapter, src_addr, vlan_id, tx_ring);
1878
1879         fil->ftime = jiffies;
1880         fil->vlan_id = vlan_id;
1881         memcpy(fil->faddr, &src_addr, ETH_ALEN);
1882         spin_lock(&adapter->mac_learn_lock);
1883         hlist_add_head(&(fil->fnode), head);
1884         adapter->fhash.fnum++;
1885         spin_unlock(&adapter->mac_learn_lock);
1886 }
1887
1888 static void
1889 qlcnic_tso_check(struct net_device *netdev,
1890                 struct qlcnic_host_tx_ring *tx_ring,
1891                 struct cmd_desc_type0 *first_desc,
1892                 struct sk_buff *skb)
1893 {
1894         u8 opcode = TX_ETHER_PKT;
1895         __be16 protocol = skb->protocol;
1896         u16 flags = 0;
1897         int copied, offset, copy_len, hdr_len = 0, tso = 0;
1898         struct cmd_desc_type0 *hwdesc;
1899         struct vlan_ethhdr *vh;
1900         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1901         u32 producer = tx_ring->producer;
1902         __le16 vlan_oob = first_desc->flags_opcode &
1903                                 cpu_to_le16(FLAGS_VLAN_OOB);
1904
1905         if (*(skb->data) & BIT_0) {
1906                 flags |= BIT_0;
1907                 memcpy(&first_desc->eth_addr, skb->data, ETH_ALEN);
1908         }
1909
1910         if ((netdev->features & (NETIF_F_TSO | NETIF_F_TSO6)) &&
1911                         skb_shinfo(skb)->gso_size > 0) {
1912
1913                 hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
1914
1915                 first_desc->mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
1916                 first_desc->total_hdr_length = hdr_len;
1917                 if (vlan_oob) {
1918                         first_desc->total_hdr_length += VLAN_HLEN;
1919                         first_desc->tcp_hdr_offset = VLAN_HLEN;
1920                         first_desc->ip_hdr_offset = VLAN_HLEN;
1921                         /* Only in case of TSO on vlan device */
1922                         flags |= FLAGS_VLAN_TAGGED;
1923                 }
1924
1925                 opcode = (protocol == cpu_to_be16(ETH_P_IPV6)) ?
1926                                 TX_TCP_LSO6 : TX_TCP_LSO;
1927                 tso = 1;
1928
1929         } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
1930                 u8 l4proto;
1931
1932                 if (protocol == cpu_to_be16(ETH_P_IP)) {
1933                         l4proto = ip_hdr(skb)->protocol;
1934
1935                         if (l4proto == IPPROTO_TCP)
1936                                 opcode = TX_TCP_PKT;
1937                         else if (l4proto == IPPROTO_UDP)
1938                                 opcode = TX_UDP_PKT;
1939                 } else if (protocol == cpu_to_be16(ETH_P_IPV6)) {
1940                         l4proto = ipv6_hdr(skb)->nexthdr;
1941
1942                         if (l4proto == IPPROTO_TCP)
1943                                 opcode = TX_TCPV6_PKT;
1944                         else if (l4proto == IPPROTO_UDP)
1945                                 opcode = TX_UDPV6_PKT;
1946                 }
1947         }
1948
1949         first_desc->tcp_hdr_offset += skb_transport_offset(skb);
1950         first_desc->ip_hdr_offset += skb_network_offset(skb);
1951         qlcnic_set_tx_flags_opcode(first_desc, flags, opcode);
1952
1953         if (!tso)
1954                 return;
1955
1956         /* For LSO, we need to copy the MAC/IP/TCP headers into
1957          * the descriptor ring
1958          */
1959         copied = 0;
1960         offset = 2;
1961
1962         if (vlan_oob) {
1963                 /* Create a TSO vlan header template for firmware */
1964
1965                 hwdesc = &tx_ring->desc_head[producer];
1966                 tx_ring->cmd_buf_arr[producer].skb = NULL;
1967
1968                 copy_len = min((int)sizeof(struct cmd_desc_type0) - offset,
1969                                 hdr_len + VLAN_HLEN);
1970
1971                 vh = (struct vlan_ethhdr *)((char *)hwdesc + 2);
1972                 skb_copy_from_linear_data(skb, vh, 12);
1973                 vh->h_vlan_proto = htons(ETH_P_8021Q);
1974                 vh->h_vlan_TCI = (__be16)swab16((u16)first_desc->vlan_TCI);
1975
1976                 skb_copy_from_linear_data_offset(skb, 12,
1977                                 (char *)vh + 16, copy_len - 16);
1978
1979                 copied = copy_len - VLAN_HLEN;
1980                 offset = 0;
1981
1982                 producer = get_next_index(producer, tx_ring->num_desc);
1983         }
1984
1985         while (copied < hdr_len) {
1986
1987                 copy_len = min((int)sizeof(struct cmd_desc_type0) - offset,
1988                                 (hdr_len - copied));
1989
1990                 hwdesc = &tx_ring->desc_head[producer];
1991                 tx_ring->cmd_buf_arr[producer].skb = NULL;
1992
1993                 skb_copy_from_linear_data_offset(skb, copied,
1994                                  (char *)hwdesc + offset, copy_len);
1995
1996                 copied += copy_len;
1997                 offset = 0;
1998
1999                 producer = get_next_index(producer, tx_ring->num_desc);
2000         }
2001
2002         tx_ring->producer = producer;
2003         barrier();
2004         adapter->stats.lso_frames++;
2005 }
2006
2007 static int
2008 qlcnic_map_tx_skb(struct pci_dev *pdev,
2009                 struct sk_buff *skb, struct qlcnic_cmd_buffer *pbuf)
2010 {
2011         struct qlcnic_skb_frag *nf;
2012         struct skb_frag_struct *frag;
2013         int i, nr_frags;
2014         dma_addr_t map;
2015
2016         nr_frags = skb_shinfo(skb)->nr_frags;
2017         nf = &pbuf->frag_array[0];
2018
2019         map = pci_map_single(pdev, skb->data,
2020                         skb_headlen(skb), PCI_DMA_TODEVICE);
2021         if (pci_dma_mapping_error(pdev, map))
2022                 goto out_err;
2023
2024         nf->dma = map;
2025         nf->length = skb_headlen(skb);
2026
2027         for (i = 0; i < nr_frags; i++) {
2028                 frag = &skb_shinfo(skb)->frags[i];
2029                 nf = &pbuf->frag_array[i+1];
2030
2031                 map = pci_map_page(pdev, frag->page, frag->page_offset,
2032                                 frag->size, PCI_DMA_TODEVICE);
2033                 if (pci_dma_mapping_error(pdev, map))
2034                         goto unwind;
2035
2036                 nf->dma = map;
2037                 nf->length = frag->size;
2038         }
2039
2040         return 0;
2041
2042 unwind:
2043         while (--i >= 0) {
2044                 nf = &pbuf->frag_array[i+1];
2045                 pci_unmap_page(pdev, nf->dma, nf->length, PCI_DMA_TODEVICE);
2046         }
2047
2048         nf = &pbuf->frag_array[0];
2049         pci_unmap_single(pdev, nf->dma, skb_headlen(skb), PCI_DMA_TODEVICE);
2050
2051 out_err:
2052         return -ENOMEM;
2053 }
2054
2055 static int
2056 qlcnic_check_tx_tagging(struct qlcnic_adapter *adapter,
2057                         struct sk_buff *skb,
2058                         struct cmd_desc_type0 *first_desc)
2059 {
2060         u8 opcode = 0;
2061         u16 flags = 0;
2062         __be16 protocol = skb->protocol;
2063         struct vlan_ethhdr *vh;
2064
2065         if (protocol == cpu_to_be16(ETH_P_8021Q)) {
2066                 vh = (struct vlan_ethhdr *)skb->data;
2067                 protocol = vh->h_vlan_encapsulated_proto;
2068                 flags = FLAGS_VLAN_TAGGED;
2069                 qlcnic_set_tx_vlan_tci(first_desc, ntohs(vh->h_vlan_TCI));
2070         } else if (vlan_tx_tag_present(skb)) {
2071                 flags = FLAGS_VLAN_OOB;
2072                 qlcnic_set_tx_vlan_tci(first_desc, vlan_tx_tag_get(skb));
2073         }
2074         if (unlikely(adapter->pvid)) {
2075                 if (first_desc->vlan_TCI &&
2076                                 !(adapter->flags & QLCNIC_TAGGING_ENABLED))
2077                         return -EIO;
2078                 if (first_desc->vlan_TCI &&
2079                                 (adapter->flags & QLCNIC_TAGGING_ENABLED))
2080                         goto set_flags;
2081
2082                 flags = FLAGS_VLAN_OOB;
2083                 qlcnic_set_tx_vlan_tci(first_desc, adapter->pvid);
2084         }
2085 set_flags:
2086         qlcnic_set_tx_flags_opcode(first_desc, flags, opcode);
2087         return 0;
2088 }
2089
2090 static inline void
2091 qlcnic_clear_cmddesc(u64 *desc)
2092 {
2093         desc[0] = 0ULL;
2094         desc[2] = 0ULL;
2095         desc[7] = 0ULL;
2096 }
2097
2098 netdev_tx_t
2099 qlcnic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
2100 {
2101         struct qlcnic_adapter *adapter = netdev_priv(netdev);
2102         struct qlcnic_host_tx_ring *tx_ring = adapter->tx_ring;
2103         struct qlcnic_cmd_buffer *pbuf;
2104         struct qlcnic_skb_frag *buffrag;
2105         struct cmd_desc_type0 *hwdesc, *first_desc;
2106         struct pci_dev *pdev;
2107         struct ethhdr *phdr;
2108         int i, k;
2109
2110         u32 producer;
2111         int frag_count, no_of_desc;
2112         u32 num_txd = tx_ring->num_desc;
2113
2114         if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
2115                 netif_stop_queue(netdev);
2116                 return NETDEV_TX_BUSY;
2117         }
2118
2119         if (adapter->flags & QLCNIC_MACSPOOF) {
2120                 phdr = (struct ethhdr *)skb->data;
2121                 if (compare_ether_addr(phdr->h_source,
2122                                         adapter->mac_addr))
2123                         goto drop_packet;
2124         }
2125
2126         frag_count = skb_shinfo(skb)->nr_frags + 1;
2127
2128         /* 4 fragments per cmd des */
2129         no_of_desc = (frag_count + 3) >> 2;
2130
2131         if (unlikely(qlcnic_tx_avail(tx_ring) <= TX_STOP_THRESH)) {
2132                 netif_stop_queue(netdev);
2133                 smp_mb();
2134                 if (qlcnic_tx_avail(tx_ring) > TX_STOP_THRESH)
2135                         netif_start_queue(netdev);
2136                 else {
2137                         adapter->stats.xmit_off++;
2138                         return NETDEV_TX_BUSY;
2139                 }
2140         }
2141
2142         producer = tx_ring->producer;
2143         pbuf = &tx_ring->cmd_buf_arr[producer];
2144
2145         pdev = adapter->pdev;
2146
2147         first_desc = hwdesc = &tx_ring->desc_head[producer];
2148         qlcnic_clear_cmddesc((u64 *)hwdesc);
2149
2150         if (qlcnic_check_tx_tagging(adapter, skb, first_desc))
2151                 goto drop_packet;
2152
2153         if (qlcnic_map_tx_skb(pdev, skb, pbuf)) {
2154                 adapter->stats.tx_dma_map_error++;
2155                 goto drop_packet;
2156         }
2157
2158         pbuf->skb = skb;
2159         pbuf->frag_count = frag_count;
2160
2161         qlcnic_set_tx_frags_len(first_desc, frag_count, skb->len);
2162         qlcnic_set_tx_port(first_desc, adapter->portnum);
2163
2164         for (i = 0; i < frag_count; i++) {
2165
2166                 k = i % 4;
2167
2168                 if ((k == 0) && (i > 0)) {
2169                         /* move to next desc.*/
2170                         producer = get_next_index(producer, num_txd);
2171                         hwdesc = &tx_ring->desc_head[producer];
2172                         qlcnic_clear_cmddesc((u64 *)hwdesc);
2173                         tx_ring->cmd_buf_arr[producer].skb = NULL;
2174                 }
2175
2176                 buffrag = &pbuf->frag_array[i];
2177
2178                 hwdesc->buffer_length[k] = cpu_to_le16(buffrag->length);
2179                 switch (k) {
2180                 case 0:
2181                         hwdesc->addr_buffer1 = cpu_to_le64(buffrag->dma);
2182                         break;
2183                 case 1:
2184                         hwdesc->addr_buffer2 = cpu_to_le64(buffrag->dma);
2185                         break;
2186                 case 2:
2187                         hwdesc->addr_buffer3 = cpu_to_le64(buffrag->dma);
2188                         break;
2189                 case 3:
2190                         hwdesc->addr_buffer4 = cpu_to_le64(buffrag->dma);
2191                         break;
2192                 }
2193         }
2194
2195         tx_ring->producer = get_next_index(producer, num_txd);
2196
2197         qlcnic_tso_check(netdev, tx_ring, first_desc, skb);
2198
2199         if (qlcnic_mac_learn)
2200                 qlcnic_send_filter(adapter, tx_ring, first_desc, skb);
2201
2202         qlcnic_update_cmd_producer(adapter, tx_ring);
2203
2204         adapter->stats.txbytes += skb->len;
2205         adapter->stats.xmitcalled++;
2206
2207         return NETDEV_TX_OK;
2208
2209 drop_packet:
2210         adapter->stats.txdropped++;
2211         dev_kfree_skb_any(skb);
2212         return NETDEV_TX_OK;
2213 }
2214
2215 static int qlcnic_check_temp(struct qlcnic_adapter *adapter)
2216 {
2217         struct net_device *netdev = adapter->netdev;
2218         u32 temp, temp_state, temp_val;
2219         int rv = 0;
2220
2221         temp = QLCRD32(adapter, CRB_TEMP_STATE);
2222
2223         temp_state = qlcnic_get_temp_state(temp);
2224         temp_val = qlcnic_get_temp_val(temp);
2225
2226         if (temp_state == QLCNIC_TEMP_PANIC) {
2227                 dev_err(&netdev->dev,
2228                        "Device temperature %d degrees C exceeds"
2229                        " maximum allowed. Hardware has been shut down.\n",
2230                        temp_val);
2231                 rv = 1;
2232         } else if (temp_state == QLCNIC_TEMP_WARN) {
2233                 if (adapter->temp == QLCNIC_TEMP_NORMAL) {
2234                         dev_err(&netdev->dev,
2235                                "Device temperature %d degrees C "
2236                                "exceeds operating range."
2237                                " Immediate action needed.\n",
2238                                temp_val);
2239                 }
2240         } else {
2241                 if (adapter->temp == QLCNIC_TEMP_WARN) {
2242                         dev_info(&netdev->dev,
2243                                "Device temperature is now %d degrees C"
2244                                " in normal range.\n", temp_val);
2245                 }
2246         }
2247         adapter->temp = temp_state;
2248         return rv;
2249 }
2250
2251 void qlcnic_advert_link_change(struct qlcnic_adapter *adapter, int linkup)
2252 {
2253         struct net_device *netdev = adapter->netdev;
2254
2255         if (adapter->ahw.linkup && !linkup) {
2256                 netdev_info(netdev, "NIC Link is down\n");
2257                 adapter->ahw.linkup = 0;
2258                 if (netif_running(netdev)) {
2259                         netif_carrier_off(netdev);
2260                         netif_stop_queue(netdev);
2261                 }
2262         } else if (!adapter->ahw.linkup && linkup) {
2263                 netdev_info(netdev, "NIC Link is up\n");
2264                 adapter->ahw.linkup = 1;
2265                 if (netif_running(netdev)) {
2266                         netif_carrier_on(netdev);
2267                         netif_wake_queue(netdev);
2268                 }
2269         }
2270 }
2271
2272 static void qlcnic_tx_timeout(struct net_device *netdev)
2273 {
2274         struct qlcnic_adapter *adapter = netdev_priv(netdev);
2275
2276         if (test_bit(__QLCNIC_RESETTING, &adapter->state))
2277                 return;
2278
2279         dev_err(&netdev->dev, "transmit timeout, resetting.\n");
2280
2281         if (++adapter->tx_timeo_cnt >= QLCNIC_MAX_TX_TIMEOUTS)
2282                 adapter->need_fw_reset = 1;
2283         else
2284                 adapter->reset_context = 1;
2285 }
2286
2287 static struct net_device_stats *qlcnic_get_stats(struct net_device *netdev)
2288 {
2289         struct qlcnic_adapter *adapter = netdev_priv(netdev);
2290         struct net_device_stats *stats = &netdev->stats;
2291
2292         stats->rx_packets = adapter->stats.rx_pkts + adapter->stats.lro_pkts;
2293         stats->tx_packets = adapter->stats.xmitfinished;
2294         stats->rx_bytes = adapter->stats.rxbytes + adapter->stats.lrobytes;
2295         stats->tx_bytes = adapter->stats.txbytes;
2296         stats->rx_dropped = adapter->stats.rxdropped;
2297         stats->tx_dropped = adapter->stats.txdropped;
2298
2299         return stats;
2300 }
2301
2302 static irqreturn_t qlcnic_clear_legacy_intr(struct qlcnic_adapter *adapter)
2303 {
2304         u32 status;
2305
2306         status = readl(adapter->isr_int_vec);
2307
2308         if (!(status & adapter->int_vec_bit))
2309                 return IRQ_NONE;
2310
2311         /* check interrupt state machine, to be sure */
2312         status = readl(adapter->crb_int_state_reg);
2313         if (!ISR_LEGACY_INT_TRIGGERED(status))
2314                 return IRQ_NONE;
2315
2316         writel(0xffffffff, adapter->tgt_status_reg);
2317         /* read twice to ensure write is flushed */
2318         readl(adapter->isr_int_vec);
2319         readl(adapter->isr_int_vec);
2320
2321         return IRQ_HANDLED;
2322 }
2323
2324 static irqreturn_t qlcnic_tmp_intr(int irq, void *data)
2325 {
2326         struct qlcnic_host_sds_ring *sds_ring = data;
2327         struct qlcnic_adapter *adapter = sds_ring->adapter;
2328
2329         if (adapter->flags & QLCNIC_MSIX_ENABLED)
2330                 goto done;
2331         else if (adapter->flags & QLCNIC_MSI_ENABLED) {
2332                 writel(0xffffffff, adapter->tgt_status_reg);
2333                 goto done;
2334         }
2335
2336         if (qlcnic_clear_legacy_intr(adapter) == IRQ_NONE)
2337                 return IRQ_NONE;
2338
2339 done:
2340         adapter->diag_cnt++;
2341         qlcnic_enable_int(sds_ring);
2342         return IRQ_HANDLED;
2343 }
2344
2345 static irqreturn_t qlcnic_intr(int irq, void *data)
2346 {
2347         struct qlcnic_host_sds_ring *sds_ring = data;
2348         struct qlcnic_adapter *adapter = sds_ring->adapter;
2349
2350         if (qlcnic_clear_legacy_intr(adapter) == IRQ_NONE)
2351                 return IRQ_NONE;
2352
2353         napi_schedule(&sds_ring->napi);
2354
2355         return IRQ_HANDLED;
2356 }
2357
2358 static irqreturn_t qlcnic_msi_intr(int irq, void *data)
2359 {
2360         struct qlcnic_host_sds_ring *sds_ring = data;
2361         struct qlcnic_adapter *adapter = sds_ring->adapter;
2362
2363         /* clear interrupt */
2364         writel(0xffffffff, adapter->tgt_status_reg);
2365
2366         napi_schedule(&sds_ring->napi);
2367         return IRQ_HANDLED;
2368 }
2369
2370 static irqreturn_t qlcnic_msix_intr(int irq, void *data)
2371 {
2372         struct qlcnic_host_sds_ring *sds_ring = data;
2373
2374         napi_schedule(&sds_ring->napi);
2375         return IRQ_HANDLED;
2376 }
2377
2378 static int qlcnic_process_cmd_ring(struct qlcnic_adapter *adapter)
2379 {
2380         u32 sw_consumer, hw_consumer;
2381         int count = 0, i;
2382         struct qlcnic_cmd_buffer *buffer;
2383         struct pci_dev *pdev = adapter->pdev;
2384         struct net_device *netdev = adapter->netdev;
2385         struct qlcnic_skb_frag *frag;
2386         int done;
2387         struct qlcnic_host_tx_ring *tx_ring = adapter->tx_ring;
2388
2389         if (!spin_trylock(&adapter->tx_clean_lock))
2390                 return 1;
2391
2392         sw_consumer = tx_ring->sw_consumer;
2393         hw_consumer = le32_to_cpu(*(tx_ring->hw_consumer));
2394
2395         while (sw_consumer != hw_consumer) {
2396                 buffer = &tx_ring->cmd_buf_arr[sw_consumer];
2397                 if (buffer->skb) {
2398                         frag = &buffer->frag_array[0];
2399                         pci_unmap_single(pdev, frag->dma, frag->length,
2400                                          PCI_DMA_TODEVICE);
2401                         frag->dma = 0ULL;
2402                         for (i = 1; i < buffer->frag_count; i++) {
2403                                 frag++;
2404                                 pci_unmap_page(pdev, frag->dma, frag->length,
2405                                                PCI_DMA_TODEVICE);
2406                                 frag->dma = 0ULL;
2407                         }
2408
2409                         adapter->stats.xmitfinished++;
2410                         dev_kfree_skb_any(buffer->skb);
2411                         buffer->skb = NULL;
2412                 }
2413
2414                 sw_consumer = get_next_index(sw_consumer, tx_ring->num_desc);
2415                 if (++count >= MAX_STATUS_HANDLE)
2416                         break;
2417         }
2418
2419         if (count && netif_running(netdev)) {
2420                 tx_ring->sw_consumer = sw_consumer;
2421
2422                 smp_mb();
2423
2424                 if (netif_queue_stopped(netdev) && netif_carrier_ok(netdev)) {
2425                         if (qlcnic_tx_avail(tx_ring) > TX_STOP_THRESH) {
2426                                 netif_wake_queue(netdev);
2427                                 adapter->stats.xmit_on++;
2428                         }
2429                 }
2430                 adapter->tx_timeo_cnt = 0;
2431         }
2432         /*
2433          * If everything is freed up to consumer then check if the ring is full
2434          * If the ring is full then check if more needs to be freed and
2435          * schedule the call back again.
2436          *
2437          * This happens when there are 2 CPUs. One could be freeing and the
2438          * other filling it. If the ring is full when we get out of here and
2439          * the card has already interrupted the host then the host can miss the
2440          * interrupt.
2441          *
2442          * There is still a possible race condition and the host could miss an
2443          * interrupt. The card has to take care of this.
2444          */
2445         hw_consumer = le32_to_cpu(*(tx_ring->hw_consumer));
2446         done = (sw_consumer == hw_consumer);
2447         spin_unlock(&adapter->tx_clean_lock);
2448
2449         return done;
2450 }
2451
2452 static int qlcnic_poll(struct napi_struct *napi, int budget)
2453 {
2454         struct qlcnic_host_sds_ring *sds_ring =
2455                 container_of(napi, struct qlcnic_host_sds_ring, napi);
2456
2457         struct qlcnic_adapter *adapter = sds_ring->adapter;
2458
2459         int tx_complete;
2460         int work_done;
2461
2462         tx_complete = qlcnic_process_cmd_ring(adapter);
2463
2464         work_done = qlcnic_process_rcv_ring(sds_ring, budget);
2465
2466         if ((work_done < budget) && tx_complete) {
2467                 napi_complete(&sds_ring->napi);
2468                 if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
2469                         qlcnic_enable_int(sds_ring);
2470         }
2471
2472         return work_done;
2473 }
2474
2475 static int qlcnic_rx_poll(struct napi_struct *napi, int budget)
2476 {
2477         struct qlcnic_host_sds_ring *sds_ring =
2478                 container_of(napi, struct qlcnic_host_sds_ring, napi);
2479
2480         struct qlcnic_adapter *adapter = sds_ring->adapter;
2481         int work_done;
2482
2483         work_done = qlcnic_process_rcv_ring(sds_ring, budget);
2484
2485         if (work_done < budget) {
2486                 napi_complete(&sds_ring->napi);
2487                 if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
2488                         qlcnic_enable_int(sds_ring);
2489         }
2490
2491         return work_done;
2492 }
2493
2494 #ifdef CONFIG_NET_POLL_CONTROLLER
2495 static void qlcnic_poll_controller(struct net_device *netdev)
2496 {
2497         int ring;
2498         struct qlcnic_host_sds_ring *sds_ring;
2499         struct qlcnic_adapter *adapter = netdev_priv(netdev);
2500         struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
2501
2502         disable_irq(adapter->irq);
2503         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
2504                 sds_ring = &recv_ctx->sds_rings[ring];
2505                 qlcnic_intr(adapter->irq, sds_ring);
2506         }
2507         enable_irq(adapter->irq);
2508 }
2509 #endif
2510
2511 static void
2512 qlcnic_idc_debug_info(struct qlcnic_adapter *adapter, u8 encoding)
2513 {
2514         u32 val;
2515
2516         val = adapter->portnum & 0xf;
2517         val |= encoding << 7;
2518         val |= (jiffies - adapter->dev_rst_time) << 8;
2519
2520         QLCWR32(adapter, QLCNIC_CRB_DRV_SCRATCH, val);
2521         adapter->dev_rst_time = jiffies;
2522 }
2523
2524 static int
2525 qlcnic_set_drv_state(struct qlcnic_adapter *adapter, u8 state)
2526 {
2527         u32  val;
2528
2529         WARN_ON(state != QLCNIC_DEV_NEED_RESET &&
2530                         state != QLCNIC_DEV_NEED_QUISCENT);
2531
2532         if (qlcnic_api_lock(adapter))
2533                 return -EIO;
2534
2535         val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2536
2537         if (state == QLCNIC_DEV_NEED_RESET)
2538                 QLC_DEV_SET_RST_RDY(val, adapter->portnum);
2539         else if (state == QLCNIC_DEV_NEED_QUISCENT)
2540                 QLC_DEV_SET_QSCNT_RDY(val, adapter->portnum);
2541
2542         QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2543
2544         qlcnic_api_unlock(adapter);
2545
2546         return 0;
2547 }
2548
2549 static int
2550 qlcnic_clr_drv_state(struct qlcnic_adapter *adapter)
2551 {
2552         u32  val;
2553
2554         if (qlcnic_api_lock(adapter))
2555                 return -EBUSY;
2556
2557         val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2558         QLC_DEV_CLR_RST_QSCNT(val, adapter->portnum);
2559         QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2560
2561         qlcnic_api_unlock(adapter);
2562
2563         return 0;
2564 }
2565
2566 static void
2567 qlcnic_clr_all_drv_state(struct qlcnic_adapter *adapter, u8 failed)
2568 {
2569         u32  val;
2570
2571         if (qlcnic_api_lock(adapter))
2572                 goto err;
2573
2574         val = QLCRD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
2575         QLC_DEV_CLR_REF_CNT(val, adapter->portnum);
2576         QLCWR32(adapter, QLCNIC_CRB_DRV_ACTIVE, val);
2577
2578         if (failed) {
2579                 QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_FAILED);
2580                 dev_info(&adapter->pdev->dev,
2581                                 "Device state set to Failed. Please Reboot\n");
2582         } else if (!(val & 0x11111111))
2583                 QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_COLD);
2584
2585         val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2586         QLC_DEV_CLR_RST_QSCNT(val, adapter->portnum);
2587         QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2588
2589         qlcnic_api_unlock(adapter);
2590 err:
2591         adapter->fw_fail_cnt = 0;
2592         clear_bit(__QLCNIC_START_FW, &adapter->state);
2593         clear_bit(__QLCNIC_RESETTING, &adapter->state);
2594 }
2595
2596 /* Grab api lock, before checking state */
2597 static int
2598 qlcnic_check_drv_state(struct qlcnic_adapter *adapter)
2599 {
2600         int act, state;
2601
2602         state = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2603         act = QLCRD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
2604
2605         if (((state & 0x11111111) == (act & 0x11111111)) ||
2606                         ((act & 0x11111111) == ((state >> 1) & 0x11111111)))
2607                 return 0;
2608         else
2609                 return 1;
2610 }
2611
2612 static int qlcnic_check_idc_ver(struct qlcnic_adapter *adapter)
2613 {
2614         u32 val = QLCRD32(adapter, QLCNIC_CRB_DRV_IDC_VER);
2615
2616         if (val != QLCNIC_DRV_IDC_VER) {
2617                 dev_warn(&adapter->pdev->dev, "IDC Version mismatch, driver's"
2618                         " idc ver = %x; reqd = %x\n", QLCNIC_DRV_IDC_VER, val);
2619         }
2620
2621         return 0;
2622 }
2623
2624 static int
2625 qlcnic_can_start_firmware(struct qlcnic_adapter *adapter)
2626 {
2627         u32 val, prev_state;
2628         u8 dev_init_timeo = adapter->dev_init_timeo;
2629         u8 portnum = adapter->portnum;
2630         u8 ret;
2631
2632         if (test_and_clear_bit(__QLCNIC_START_FW, &adapter->state))
2633                 return 1;
2634
2635         if (qlcnic_api_lock(adapter))
2636                 return -1;
2637
2638         val = QLCRD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
2639         if (!(val & (1 << (portnum * 4)))) {
2640                 QLC_DEV_SET_REF_CNT(val, portnum);
2641                 QLCWR32(adapter, QLCNIC_CRB_DRV_ACTIVE, val);
2642         }
2643
2644         prev_state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2645         QLCDB(adapter, HW, "Device state = %u\n", prev_state);
2646
2647         switch (prev_state) {
2648         case QLCNIC_DEV_COLD:
2649                 QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_INITIALIZING);
2650                 QLCWR32(adapter, QLCNIC_CRB_DRV_IDC_VER, QLCNIC_DRV_IDC_VER);
2651                 qlcnic_idc_debug_info(adapter, 0);
2652                 qlcnic_api_unlock(adapter);
2653                 return 1;
2654
2655         case QLCNIC_DEV_READY:
2656                 ret = qlcnic_check_idc_ver(adapter);
2657                 qlcnic_api_unlock(adapter);
2658                 return ret;
2659
2660         case QLCNIC_DEV_NEED_RESET:
2661                 val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2662                 QLC_DEV_SET_RST_RDY(val, portnum);
2663                 QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2664                 break;
2665
2666         case QLCNIC_DEV_NEED_QUISCENT:
2667                 val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2668                 QLC_DEV_SET_QSCNT_RDY(val, portnum);
2669                 QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2670                 break;
2671
2672         case QLCNIC_DEV_FAILED:
2673                 dev_err(&adapter->pdev->dev, "Device in failed state.\n");
2674                 qlcnic_api_unlock(adapter);
2675                 return -1;
2676
2677         case QLCNIC_DEV_INITIALIZING:
2678         case QLCNIC_DEV_QUISCENT:
2679                 break;
2680         }
2681
2682         qlcnic_api_unlock(adapter);
2683
2684         do {
2685                 msleep(1000);
2686                 prev_state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2687
2688                 if (prev_state == QLCNIC_DEV_QUISCENT)
2689                         continue;
2690         } while ((prev_state != QLCNIC_DEV_READY) && --dev_init_timeo);
2691
2692         if (!dev_init_timeo) {
2693                 dev_err(&adapter->pdev->dev,
2694                         "Waiting for device to initialize timeout\n");
2695                 return -1;
2696         }
2697
2698         if (qlcnic_api_lock(adapter))
2699                 return -1;
2700
2701         val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2702         QLC_DEV_CLR_RST_QSCNT(val, portnum);
2703         QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2704
2705         ret = qlcnic_check_idc_ver(adapter);
2706         qlcnic_api_unlock(adapter);
2707
2708         return ret;
2709 }
2710
2711 static void
2712 qlcnic_fwinit_work(struct work_struct *work)
2713 {
2714         struct qlcnic_adapter *adapter = container_of(work,
2715                         struct qlcnic_adapter, fw_work.work);
2716         u32 dev_state = 0xf;
2717
2718         if (qlcnic_api_lock(adapter))
2719                 goto err_ret;
2720
2721         dev_state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2722         if (dev_state == QLCNIC_DEV_QUISCENT ||
2723             dev_state == QLCNIC_DEV_NEED_QUISCENT) {
2724                 qlcnic_api_unlock(adapter);
2725                 qlcnic_schedule_work(adapter, qlcnic_fwinit_work,
2726                                                 FW_POLL_DELAY * 2);
2727                 return;
2728         }
2729
2730         if (adapter->op_mode == QLCNIC_NON_PRIV_FUNC) {
2731                 qlcnic_api_unlock(adapter);
2732                 goto wait_npar;
2733         }
2734
2735         if (adapter->fw_wait_cnt++ > adapter->reset_ack_timeo) {
2736                 dev_err(&adapter->pdev->dev, "Reset:Failed to get ack %d sec\n",
2737                                         adapter->reset_ack_timeo);
2738                 goto skip_ack_check;
2739         }
2740
2741         if (!qlcnic_check_drv_state(adapter)) {
2742 skip_ack_check:
2743                 dev_state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2744
2745                 if (dev_state == QLCNIC_DEV_NEED_RESET) {
2746                         QLCWR32(adapter, QLCNIC_CRB_DEV_STATE,
2747                                                 QLCNIC_DEV_INITIALIZING);
2748                         set_bit(__QLCNIC_START_FW, &adapter->state);
2749                         QLCDB(adapter, DRV, "Restarting fw\n");
2750                         qlcnic_idc_debug_info(adapter, 0);
2751                 }
2752
2753                 qlcnic_api_unlock(adapter);
2754
2755                 if (!adapter->nic_ops->start_firmware(adapter)) {
2756                         qlcnic_schedule_work(adapter, qlcnic_attach_work, 0);
2757                         adapter->fw_wait_cnt = 0;
2758                         return;
2759                 }
2760                 goto err_ret;
2761         }
2762
2763         qlcnic_api_unlock(adapter);
2764
2765 wait_npar:
2766         dev_state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2767         QLCDB(adapter, HW, "Func waiting: Device state=%u\n", dev_state);
2768
2769         switch (dev_state) {
2770         case QLCNIC_DEV_READY:
2771                 if (!adapter->nic_ops->start_firmware(adapter)) {
2772                         qlcnic_schedule_work(adapter, qlcnic_attach_work, 0);
2773                         adapter->fw_wait_cnt = 0;
2774                         return;
2775                 }
2776         case QLCNIC_DEV_FAILED:
2777                 break;
2778         default:
2779                 qlcnic_schedule_work(adapter,
2780                         qlcnic_fwinit_work, FW_POLL_DELAY);
2781                 return;
2782         }
2783
2784 err_ret:
2785         dev_err(&adapter->pdev->dev, "Fwinit work failed state=%u "
2786                 "fw_wait_cnt=%u\n", dev_state, adapter->fw_wait_cnt);
2787         netif_device_attach(adapter->netdev);
2788         qlcnic_clr_all_drv_state(adapter, 0);
2789 }
2790
2791 static void
2792 qlcnic_detach_work(struct work_struct *work)
2793 {
2794         struct qlcnic_adapter *adapter = container_of(work,
2795                         struct qlcnic_adapter, fw_work.work);
2796         struct net_device *netdev = adapter->netdev;
2797         u32 status;
2798
2799         netif_device_detach(netdev);
2800
2801         /* Dont grab rtnl lock during Quiscent mode */
2802         if (adapter->dev_state == QLCNIC_DEV_NEED_QUISCENT) {
2803                 if (netif_running(netdev))
2804                         __qlcnic_down(adapter, netdev);
2805         } else
2806                 qlcnic_down(adapter, netdev);
2807
2808         status = QLCRD32(adapter, QLCNIC_PEG_HALT_STATUS1);
2809
2810         if (status & QLCNIC_RCODE_FATAL_ERROR)
2811                 goto err_ret;
2812
2813         if (adapter->temp == QLCNIC_TEMP_PANIC)
2814                 goto err_ret;
2815
2816         if (qlcnic_set_drv_state(adapter, adapter->dev_state))
2817                 goto err_ret;
2818
2819         adapter->fw_wait_cnt = 0;
2820
2821         qlcnic_schedule_work(adapter, qlcnic_fwinit_work, FW_POLL_DELAY);
2822
2823         return;
2824
2825 err_ret:
2826         dev_err(&adapter->pdev->dev, "detach failed; status=%d temp=%d\n",
2827                         status, adapter->temp);
2828         netif_device_attach(netdev);
2829         qlcnic_clr_all_drv_state(adapter, 1);
2830 }
2831
2832 /*Transit NPAR state to NON Operational */
2833 static void
2834 qlcnic_set_npar_non_operational(struct qlcnic_adapter *adapter)
2835 {
2836         u32 state;
2837
2838         state = QLCRD32(adapter, QLCNIC_CRB_DEV_NPAR_STATE);
2839         if (state == QLCNIC_DEV_NPAR_NON_OPER)
2840                 return;
2841
2842         if (qlcnic_api_lock(adapter))
2843                 return;
2844         QLCWR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE, QLCNIC_DEV_NPAR_NON_OPER);
2845         qlcnic_api_unlock(adapter);
2846 }
2847
2848 /* Caller should held RESETTING bit.
2849  * This should be call in sync with qlcnic_request_quiscent_mode.
2850  */
2851 void qlcnic_clear_quiscent_mode(struct qlcnic_adapter *adapter)
2852 {
2853         qlcnic_clr_drv_state(adapter);
2854         qlcnic_api_lock(adapter);
2855         QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_READY);
2856         qlcnic_api_unlock(adapter);
2857 }
2858
2859 /* Caller should held RESETTING bit.
2860  */
2861 int qlcnic_request_quiscent_mode(struct qlcnic_adapter *adapter)
2862 {
2863         u8 timeo = adapter->dev_init_timeo / 2;
2864         u32 state;
2865
2866         if (qlcnic_api_lock(adapter))
2867                 return -EIO;
2868
2869         state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2870         if (state != QLCNIC_DEV_READY)
2871                 return -EIO;
2872
2873         QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_NEED_QUISCENT);
2874         qlcnic_api_unlock(adapter);
2875         QLCDB(adapter, DRV, "NEED QUISCENT state set\n");
2876         qlcnic_idc_debug_info(adapter, 0);
2877
2878         qlcnic_set_drv_state(adapter, QLCNIC_DEV_NEED_QUISCENT);
2879
2880         do {
2881                 msleep(2000);
2882                 state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2883                 if (state == QLCNIC_DEV_QUISCENT)
2884                         return 0;
2885                 if (!qlcnic_check_drv_state(adapter)) {
2886                         if (qlcnic_api_lock(adapter))
2887                                 return -EIO;
2888                         QLCWR32(adapter, QLCNIC_CRB_DEV_STATE,
2889                                                         QLCNIC_DEV_QUISCENT);
2890                         qlcnic_api_unlock(adapter);
2891                         QLCDB(adapter, DRV, "QUISCENT mode set\n");
2892                         return 0;
2893                 }
2894         } while (--timeo);
2895
2896         dev_err(&adapter->pdev->dev, "Failed to quiesce device, DRV_STATE=%08x"
2897                 " DRV_ACTIVE=%08x\n", QLCRD32(adapter, QLCNIC_CRB_DRV_STATE),
2898                 QLCRD32(adapter, QLCNIC_CRB_DRV_ACTIVE));
2899         qlcnic_clear_quiscent_mode(adapter);
2900         return -EIO;
2901 }
2902
2903 /*Transit to RESET state from READY state only */
2904 static void
2905 qlcnic_dev_request_reset(struct qlcnic_adapter *adapter)
2906 {
2907         u32 state;
2908
2909         adapter->need_fw_reset = 1;
2910         if (qlcnic_api_lock(adapter))
2911                 return;
2912
2913         state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2914
2915         if (state == QLCNIC_DEV_READY) {
2916                 QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_NEED_RESET);
2917                 QLCDB(adapter, DRV, "NEED_RESET state set\n");
2918                 qlcnic_idc_debug_info(adapter, 0);
2919         }
2920
2921         QLCWR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE, QLCNIC_DEV_NPAR_NON_OPER);
2922         qlcnic_api_unlock(adapter);
2923 }
2924
2925 /* Transit to NPAR READY state from NPAR NOT READY state */
2926 static void
2927 qlcnic_dev_set_npar_ready(struct qlcnic_adapter *adapter)
2928 {
2929         if (qlcnic_api_lock(adapter))
2930                 return;
2931
2932         QLCWR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE, QLCNIC_DEV_NPAR_OPER);
2933         QLCDB(adapter, DRV, "NPAR operational state set\n");
2934
2935         qlcnic_api_unlock(adapter);
2936 }
2937
2938 static void
2939 qlcnic_schedule_work(struct qlcnic_adapter *adapter,
2940                 work_func_t func, int delay)
2941 {
2942         if (test_bit(__QLCNIC_AER, &adapter->state))
2943                 return;
2944
2945         INIT_DELAYED_WORK(&adapter->fw_work, func);
2946         queue_delayed_work(qlcnic_wq, &adapter->fw_work,
2947                                         round_jiffies_relative(delay));
2948 }
2949
2950 static void
2951 qlcnic_cancel_fw_work(struct qlcnic_adapter *adapter)
2952 {
2953         while (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
2954                 msleep(10);
2955
2956         cancel_delayed_work_sync(&adapter->fw_work);
2957 }
2958
2959 static void
2960 qlcnic_attach_work(struct work_struct *work)
2961 {
2962         struct qlcnic_adapter *adapter = container_of(work,
2963                                 struct qlcnic_adapter, fw_work.work);
2964         struct net_device *netdev = adapter->netdev;
2965         u32 npar_state;
2966
2967         if (adapter->op_mode != QLCNIC_MGMT_FUNC) {
2968                 npar_state = QLCRD32(adapter, QLCNIC_CRB_DEV_NPAR_STATE);
2969                 if (adapter->fw_wait_cnt++ > QLCNIC_DEV_NPAR_OPER_TIMEO)
2970                         qlcnic_clr_all_drv_state(adapter, 0);
2971                 else if (npar_state != QLCNIC_DEV_NPAR_OPER)
2972                         qlcnic_schedule_work(adapter, qlcnic_attach_work,
2973                                                         FW_POLL_DELAY);
2974                 else
2975                         goto attach;
2976                 QLCDB(adapter, DRV, "Waiting for NPAR state to operational\n");
2977                 return;
2978         }
2979 attach:
2980         if (netif_running(netdev)) {
2981                 if (qlcnic_up(adapter, netdev))
2982                         goto done;
2983
2984                 qlcnic_restore_indev_addr(netdev, NETDEV_UP);
2985         }
2986
2987 done:
2988         netif_device_attach(netdev);
2989         adapter->fw_fail_cnt = 0;
2990         clear_bit(__QLCNIC_RESETTING, &adapter->state);
2991
2992         if (!qlcnic_clr_drv_state(adapter))
2993                 qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
2994                                                         FW_POLL_DELAY);
2995 }
2996
2997 static int
2998 qlcnic_check_health(struct qlcnic_adapter *adapter)
2999 {
3000         u32 state = 0, heartbeat;
3001         struct net_device *netdev = adapter->netdev;
3002
3003         if (qlcnic_check_temp(adapter))
3004                 goto detach;
3005
3006         if (adapter->need_fw_reset)
3007                 qlcnic_dev_request_reset(adapter);
3008
3009         state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
3010         if (state == QLCNIC_DEV_NEED_RESET) {
3011                 qlcnic_set_npar_non_operational(adapter);
3012                 adapter->need_fw_reset = 1;
3013         } else if (state == QLCNIC_DEV_NEED_QUISCENT)
3014                 goto detach;
3015
3016         heartbeat = QLCRD32(adapter, QLCNIC_PEG_ALIVE_COUNTER);
3017         if (heartbeat != adapter->heartbeat) {
3018                 adapter->heartbeat = heartbeat;
3019                 adapter->fw_fail_cnt = 0;
3020                 if (adapter->need_fw_reset)
3021                         goto detach;
3022
3023                 if (adapter->reset_context &&
3024                     auto_fw_reset == AUTO_FW_RESET_ENABLED) {
3025                         qlcnic_reset_hw_context(adapter);
3026                         adapter->netdev->trans_start = jiffies;
3027                 }
3028
3029                 return 0;
3030         }
3031
3032         if (++adapter->fw_fail_cnt < FW_FAIL_THRESH)
3033                 return 0;
3034
3035         qlcnic_dev_request_reset(adapter);
3036
3037         if ((auto_fw_reset == AUTO_FW_RESET_ENABLED))
3038                 clear_bit(__QLCNIC_FW_ATTACHED, &adapter->state);
3039
3040         dev_info(&netdev->dev, "firmware hang detected\n");
3041
3042 detach:
3043         adapter->dev_state = (state == QLCNIC_DEV_NEED_QUISCENT) ? state :
3044                 QLCNIC_DEV_NEED_RESET;
3045
3046         if ((auto_fw_reset == AUTO_FW_RESET_ENABLED) &&
3047                 !test_and_set_bit(__QLCNIC_RESETTING, &adapter->state)) {
3048
3049                 qlcnic_schedule_work(adapter, qlcnic_detach_work, 0);
3050                 QLCDB(adapter, DRV, "fw recovery scheduled.\n");
3051         }
3052
3053         return 1;
3054 }
3055
3056 static void
3057 qlcnic_fw_poll_work(struct work_struct *work)
3058 {
3059         struct qlcnic_adapter *adapter = container_of(work,
3060                                 struct qlcnic_adapter, fw_work.work);
3061
3062         if (test_bit(__QLCNIC_RESETTING, &adapter->state))
3063                 goto reschedule;
3064
3065
3066         if (qlcnic_check_health(adapter))
3067                 return;
3068
3069         if (adapter->fhash.fnum)
3070                 qlcnic_prune_lb_filters(adapter);
3071
3072 reschedule:
3073         qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
3074 }
3075
3076 static int qlcnic_is_first_func(struct pci_dev *pdev)
3077 {
3078         struct pci_dev *oth_pdev;
3079         int val = pdev->devfn;
3080
3081         while (val-- > 0) {
3082                 oth_pdev = pci_get_domain_bus_and_slot(pci_domain_nr
3083                         (pdev->bus), pdev->bus->number,
3084                         PCI_DEVFN(PCI_SLOT(pdev->devfn), val));
3085                 if (!oth_pdev)
3086                         continue;
3087
3088                 if (oth_pdev->current_state != PCI_D3cold) {
3089                         pci_dev_put(oth_pdev);
3090                         return 0;
3091                 }
3092                 pci_dev_put(oth_pdev);
3093         }
3094         return 1;
3095 }
3096
3097 static int qlcnic_attach_func(struct pci_dev *pdev)
3098 {
3099         int err, first_func;
3100         struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3101         struct net_device *netdev = adapter->netdev;
3102
3103         pdev->error_state = pci_channel_io_normal;
3104
3105         err = pci_enable_device(pdev);
3106         if (err)
3107                 return err;
3108
3109         pci_set_power_state(pdev, PCI_D0);
3110         pci_set_master(pdev);
3111         pci_restore_state(pdev);
3112
3113         first_func = qlcnic_is_first_func(pdev);
3114
3115         if (qlcnic_api_lock(adapter))
3116                 return -EINVAL;
3117
3118         if (adapter->op_mode != QLCNIC_NON_PRIV_FUNC && first_func) {
3119                 adapter->need_fw_reset = 1;
3120                 set_bit(__QLCNIC_START_FW, &adapter->state);
3121                 QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_INITIALIZING);
3122                 QLCDB(adapter, DRV, "Restarting fw\n");
3123         }
3124         qlcnic_api_unlock(adapter);
3125
3126         err = adapter->nic_ops->start_firmware(adapter);
3127         if (err)
3128                 return err;
3129
3130         qlcnic_clr_drv_state(adapter);
3131         qlcnic_setup_intr(adapter);
3132
3133         if (netif_running(netdev)) {
3134                 err = qlcnic_attach(adapter);
3135                 if (err) {
3136                         qlcnic_clr_all_drv_state(adapter, 1);
3137                         clear_bit(__QLCNIC_AER, &adapter->state);
3138                         netif_device_attach(netdev);
3139                         return err;
3140                 }
3141
3142                 err = qlcnic_up(adapter, netdev);
3143                 if (err)
3144                         goto done;
3145
3146                 qlcnic_restore_indev_addr(netdev, NETDEV_UP);
3147         }
3148  done:
3149         netif_device_attach(netdev);
3150         return err;
3151 }
3152
3153 static pci_ers_result_t qlcnic_io_error_detected(struct pci_dev *pdev,
3154                                                 pci_channel_state_t state)
3155 {
3156         struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3157         struct net_device *netdev = adapter->netdev;
3158
3159         if (state == pci_channel_io_perm_failure)
3160                 return PCI_ERS_RESULT_DISCONNECT;
3161
3162         if (state == pci_channel_io_normal)
3163                 return PCI_ERS_RESULT_RECOVERED;
3164
3165         set_bit(__QLCNIC_AER, &adapter->state);
3166         netif_device_detach(netdev);
3167
3168         cancel_delayed_work_sync(&adapter->fw_work);
3169
3170         if (netif_running(netdev))
3171                 qlcnic_down(adapter, netdev);
3172
3173         qlcnic_detach(adapter);
3174         qlcnic_teardown_intr(adapter);
3175
3176         clear_bit(__QLCNIC_RESETTING, &adapter->state);
3177
3178         pci_save_state(pdev);
3179         pci_disable_device(pdev);
3180
3181         return PCI_ERS_RESULT_NEED_RESET;
3182 }
3183
3184 static pci_ers_result_t qlcnic_io_slot_reset(struct pci_dev *pdev)
3185 {
3186         return qlcnic_attach_func(pdev) ? PCI_ERS_RESULT_DISCONNECT :
3187                                 PCI_ERS_RESULT_RECOVERED;
3188 }
3189
3190 static void qlcnic_io_resume(struct pci_dev *pdev)
3191 {
3192         struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3193
3194         pci_cleanup_aer_uncorrect_error_status(pdev);
3195
3196         if (QLCRD32(adapter, QLCNIC_CRB_DEV_STATE) == QLCNIC_DEV_READY &&
3197             test_and_clear_bit(__QLCNIC_AER, &adapter->state))
3198                 qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
3199                                                 FW_POLL_DELAY);
3200 }
3201
3202 static int
3203 qlcnicvf_start_firmware(struct qlcnic_adapter *adapter)
3204 {
3205         int err;
3206
3207         err = qlcnic_can_start_firmware(adapter);
3208         if (err)
3209                 return err;
3210
3211         err = qlcnic_check_npar_opertional(adapter);
3212         if (err)
3213                 return err;
3214
3215         err = qlcnic_initialize_nic(adapter);
3216         if (err)
3217                 return err;
3218
3219         qlcnic_check_options(adapter);
3220
3221         err = qlcnic_set_eswitch_port_config(adapter);
3222         if (err)
3223                 return err;
3224
3225         adapter->need_fw_reset = 0;
3226
3227         return err;
3228 }
3229
3230 static int
3231 qlcnicvf_config_bridged_mode(struct qlcnic_adapter *adapter, u32 enable)
3232 {
3233         return -EOPNOTSUPP;
3234 }
3235
3236 static int
3237 qlcnicvf_config_led(struct qlcnic_adapter *adapter, u32 state, u32 rate)
3238 {
3239         return -EOPNOTSUPP;
3240 }
3241
3242 static ssize_t
3243 qlcnic_store_bridged_mode(struct device *dev,
3244                 struct device_attribute *attr, const char *buf, size_t len)
3245 {
3246         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3247         unsigned long new;
3248         int ret = -EINVAL;
3249
3250         if (!(adapter->capabilities & QLCNIC_FW_CAPABILITY_BDG))
3251                 goto err_out;
3252
3253         if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
3254                 goto err_out;
3255
3256         if (strict_strtoul(buf, 2, &new))
3257                 goto err_out;
3258
3259         if (!adapter->nic_ops->config_bridged_mode(adapter, !!new))
3260                 ret = len;
3261
3262 err_out:
3263         return ret;
3264 }
3265
3266 static ssize_t
3267 qlcnic_show_bridged_mode(struct device *dev,
3268                 struct device_attribute *attr, char *buf)
3269 {
3270         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3271         int bridged_mode = 0;
3272
3273         if (adapter->capabilities & QLCNIC_FW_CAPABILITY_BDG)
3274                 bridged_mode = !!(adapter->flags & QLCNIC_BRIDGE_ENABLED);
3275
3276         return sprintf(buf, "%d\n", bridged_mode);
3277 }
3278
3279 static struct device_attribute dev_attr_bridged_mode = {
3280        .attr = {.name = "bridged_mode", .mode = (S_IRUGO | S_IWUSR)},
3281        .show = qlcnic_show_bridged_mode,
3282        .store = qlcnic_store_bridged_mode,
3283 };
3284
3285 static ssize_t
3286 qlcnic_store_diag_mode(struct device *dev,
3287                 struct device_attribute *attr, const char *buf, size_t len)
3288 {
3289         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3290         unsigned long new;
3291
3292         if (strict_strtoul(buf, 2, &new))
3293                 return -EINVAL;
3294
3295         if (!!new != !!(adapter->flags & QLCNIC_DIAG_ENABLED))
3296                 adapter->flags ^= QLCNIC_DIAG_ENABLED;
3297
3298         return len;
3299 }
3300
3301 static ssize_t
3302 qlcnic_show_diag_mode(struct device *dev,
3303                 struct device_attribute *attr, char *buf)
3304 {
3305         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3306
3307         return sprintf(buf, "%d\n",
3308                         !!(adapter->flags & QLCNIC_DIAG_ENABLED));
3309 }
3310
3311 static struct device_attribute dev_attr_diag_mode = {
3312         .attr = {.name = "diag_mode", .mode = (S_IRUGO | S_IWUSR)},
3313         .show = qlcnic_show_diag_mode,
3314         .store = qlcnic_store_diag_mode,
3315 };
3316
3317 static int
3318 qlcnic_sysfs_validate_crb(struct qlcnic_adapter *adapter,
3319                 loff_t offset, size_t size)
3320 {
3321         size_t crb_size = 4;
3322
3323         if (!(adapter->flags & QLCNIC_DIAG_ENABLED))
3324                 return -EIO;
3325
3326         if (offset < QLCNIC_PCI_CRBSPACE) {
3327                 if (ADDR_IN_RANGE(offset, QLCNIC_PCI_CAMQM,
3328                                         QLCNIC_PCI_CAMQM_END))
3329                         crb_size = 8;
3330                 else
3331                         return -EINVAL;
3332         }
3333
3334         if ((size != crb_size) || (offset & (crb_size-1)))
3335                 return  -EINVAL;
3336
3337         return 0;
3338 }
3339
3340 static ssize_t
3341 qlcnic_sysfs_read_crb(struct file *filp, struct kobject *kobj,
3342                 struct bin_attribute *attr,
3343                 char *buf, loff_t offset, size_t size)
3344 {
3345         struct device *dev = container_of(kobj, struct device, kobj);
3346         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3347         u32 data;
3348         u64 qmdata;
3349         int ret;
3350
3351         ret = qlcnic_sysfs_validate_crb(adapter, offset, size);
3352         if (ret != 0)
3353                 return ret;
3354
3355         if (ADDR_IN_RANGE(offset, QLCNIC_PCI_CAMQM, QLCNIC_PCI_CAMQM_END)) {
3356                 qlcnic_pci_camqm_read_2M(adapter, offset, &qmdata);
3357                 memcpy(buf, &qmdata, size);
3358         } else {
3359                 data = QLCRD32(adapter, offset);
3360                 memcpy(buf, &data, size);
3361         }
3362         return size;
3363 }
3364
3365 static ssize_t
3366 qlcnic_sysfs_write_crb(struct file *filp, struct kobject *kobj,
3367                 struct bin_attribute *attr,
3368                 char *buf, loff_t offset, size_t size)
3369 {
3370         struct device *dev = container_of(kobj, struct device, kobj);
3371         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3372         u32 data;
3373         u64 qmdata;
3374         int ret;
3375
3376         ret = qlcnic_sysfs_validate_crb(adapter, offset, size);
3377         if (ret != 0)
3378                 return ret;
3379
3380         if (ADDR_IN_RANGE(offset, QLCNIC_PCI_CAMQM, QLCNIC_PCI_CAMQM_END)) {
3381                 memcpy(&qmdata, buf, size);
3382                 qlcnic_pci_camqm_write_2M(adapter, offset, qmdata);
3383         } else {
3384                 memcpy(&data, buf, size);
3385                 QLCWR32(adapter, offset, data);
3386         }
3387         return size;
3388 }
3389
3390 static int
3391 qlcnic_sysfs_validate_mem(struct qlcnic_adapter *adapter,
3392                 loff_t offset, size_t size)
3393 {
3394         if (!(adapter->flags & QLCNIC_DIAG_ENABLED))
3395                 return -EIO;
3396
3397         if ((size != 8) || (offset & 0x7))
3398                 return  -EIO;
3399
3400         return 0;
3401 }
3402
3403 static ssize_t
3404 qlcnic_sysfs_read_mem(struct file *filp, struct kobject *kobj,
3405                 struct bin_attribute *attr,
3406                 char *buf, loff_t offset, size_t size)
3407 {
3408         struct device *dev = container_of(kobj, struct device, kobj);
3409         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3410         u64 data;
3411         int ret;
3412
3413         ret = qlcnic_sysfs_validate_mem(adapter, offset, size);
3414         if (ret != 0)
3415                 return ret;
3416
3417         if (qlcnic_pci_mem_read_2M(adapter, offset, &data))
3418                 return -EIO;
3419
3420         memcpy(buf, &data, size);
3421
3422         return size;
3423 }
3424
3425 static ssize_t
3426 qlcnic_sysfs_write_mem(struct file *filp, struct kobject *kobj,
3427                 struct bin_attribute *attr,
3428                 char *buf, loff_t offset, size_t size)
3429 {
3430         struct device *dev = container_of(kobj, struct device, kobj);
3431         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3432         u64 data;
3433         int ret;
3434
3435         ret = qlcnic_sysfs_validate_mem(adapter, offset, size);
3436         if (ret != 0)
3437                 return ret;
3438
3439         memcpy(&data, buf, size);
3440
3441         if (qlcnic_pci_mem_write_2M(adapter, offset, data))
3442                 return -EIO;
3443
3444         return size;
3445 }
3446
3447
3448 static struct bin_attribute bin_attr_crb = {
3449         .attr = {.name = "crb", .mode = (S_IRUGO | S_IWUSR)},
3450         .size = 0,
3451         .read = qlcnic_sysfs_read_crb,
3452         .write = qlcnic_sysfs_write_crb,
3453 };
3454
3455 static struct bin_attribute bin_attr_mem = {
3456         .attr = {.name = "mem", .mode = (S_IRUGO | S_IWUSR)},
3457         .size = 0,
3458         .read = qlcnic_sysfs_read_mem,
3459         .write = qlcnic_sysfs_write_mem,
3460 };
3461
3462 static int
3463 validate_pm_config(struct qlcnic_adapter *adapter,
3464                         struct qlcnic_pm_func_cfg *pm_cfg, int count)
3465 {
3466
3467         u8 src_pci_func, s_esw_id, d_esw_id;
3468         u8 dest_pci_func;
3469         int i;
3470
3471         for (i = 0; i < count; i++) {
3472                 src_pci_func = pm_cfg[i].pci_func;
3473                 dest_pci_func = pm_cfg[i].dest_npar;
3474                 if (src_pci_func >= QLCNIC_MAX_PCI_FUNC
3475                                 || dest_pci_func >= QLCNIC_MAX_PCI_FUNC)
3476                         return QL_STATUS_INVALID_PARAM;
3477
3478                 if (adapter->npars[src_pci_func].type != QLCNIC_TYPE_NIC)
3479                         return QL_STATUS_INVALID_PARAM;
3480
3481                 if (adapter->npars[dest_pci_func].type != QLCNIC_TYPE_NIC)
3482                         return QL_STATUS_INVALID_PARAM;
3483
3484                 s_esw_id = adapter->npars[src_pci_func].phy_port;
3485                 d_esw_id = adapter->npars[dest_pci_func].phy_port;
3486
3487                 if (s_esw_id != d_esw_id)
3488                         return QL_STATUS_INVALID_PARAM;
3489
3490         }
3491         return 0;
3492
3493 }
3494
3495 static ssize_t
3496 qlcnic_sysfs_write_pm_config(struct file *filp, struct kobject *kobj,
3497         struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3498 {
3499         struct device *dev = container_of(kobj, struct device, kobj);
3500         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3501         struct qlcnic_pm_func_cfg *pm_cfg;
3502         u32 id, action, pci_func;
3503         int count, rem, i, ret;
3504
3505         count   = size / sizeof(struct qlcnic_pm_func_cfg);
3506         rem     = size % sizeof(struct qlcnic_pm_func_cfg);
3507         if (rem)
3508                 return QL_STATUS_INVALID_PARAM;
3509
3510         pm_cfg = (struct qlcnic_pm_func_cfg *) buf;
3511
3512         ret = validate_pm_config(adapter, pm_cfg, count);
3513         if (ret)
3514                 return ret;
3515         for (i = 0; i < count; i++) {
3516                 pci_func = pm_cfg[i].pci_func;
3517                 action = !!pm_cfg[i].action;
3518                 id = adapter->npars[pci_func].phy_port;
3519                 ret = qlcnic_config_port_mirroring(adapter, id,
3520                                                 action, pci_func);
3521                 if (ret)
3522                         return ret;
3523         }
3524
3525         for (i = 0; i < count; i++) {
3526                 pci_func = pm_cfg[i].pci_func;
3527                 id = adapter->npars[pci_func].phy_port;
3528                 adapter->npars[pci_func].enable_pm = !!pm_cfg[i].action;
3529                 adapter->npars[pci_func].dest_npar = id;
3530         }
3531         return size;
3532 }
3533
3534 static ssize_t
3535 qlcnic_sysfs_read_pm_config(struct file *filp, struct kobject *kobj,
3536         struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3537 {
3538         struct device *dev = container_of(kobj, struct device, kobj);
3539         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3540         struct qlcnic_pm_func_cfg pm_cfg[QLCNIC_MAX_PCI_FUNC];
3541         int i;
3542
3543         if (size != sizeof(pm_cfg))
3544                 return QL_STATUS_INVALID_PARAM;
3545
3546         for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
3547                 if (adapter->npars[i].type != QLCNIC_TYPE_NIC)
3548                         continue;
3549                 pm_cfg[i].action = adapter->npars[i].enable_pm;
3550                 pm_cfg[i].dest_npar = 0;
3551                 pm_cfg[i].pci_func = i;
3552         }
3553         memcpy(buf, &pm_cfg, size);
3554
3555         return size;
3556 }
3557
3558 static int
3559 validate_esw_config(struct qlcnic_adapter *adapter,
3560         struct qlcnic_esw_func_cfg *esw_cfg, int count)
3561 {
3562         u32 op_mode;
3563         u8 pci_func;
3564         int i;
3565
3566         op_mode = readl(adapter->ahw.pci_base0 + QLCNIC_DRV_OP_MODE);
3567
3568         for (i = 0; i < count; i++) {
3569                 pci_func = esw_cfg[i].pci_func;
3570                 if (pci_func >= QLCNIC_MAX_PCI_FUNC)
3571                         return QL_STATUS_INVALID_PARAM;
3572
3573                 if (adapter->op_mode == QLCNIC_MGMT_FUNC)
3574                         if (adapter->npars[pci_func].type != QLCNIC_TYPE_NIC)
3575                                 return QL_STATUS_INVALID_PARAM;
3576
3577                 switch (esw_cfg[i].op_mode) {
3578                 case QLCNIC_PORT_DEFAULTS:
3579                         if (QLC_DEV_GET_DRV(op_mode, pci_func) !=
3580                                                 QLCNIC_NON_PRIV_FUNC) {
3581                                 esw_cfg[i].mac_anti_spoof = 0;
3582                                 esw_cfg[i].mac_override = 1;
3583                                 esw_cfg[i].promisc_mode = 1;
3584                         }
3585                         break;
3586                 case QLCNIC_ADD_VLAN:
3587                         if (!IS_VALID_VLAN(esw_cfg[i].vlan_id))
3588                                 return QL_STATUS_INVALID_PARAM;
3589                         if (!esw_cfg[i].op_type)
3590                                 return QL_STATUS_INVALID_PARAM;
3591                         break;
3592                 case QLCNIC_DEL_VLAN:
3593                         if (!esw_cfg[i].op_type)
3594                                 return QL_STATUS_INVALID_PARAM;
3595                         break;
3596                 default:
3597                         return QL_STATUS_INVALID_PARAM;
3598                 }
3599         }
3600         return 0;
3601 }
3602
3603 static ssize_t
3604 qlcnic_sysfs_write_esw_config(struct file *file, struct kobject *kobj,
3605         struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3606 {
3607         struct device *dev = container_of(kobj, struct device, kobj);
3608         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3609         struct qlcnic_esw_func_cfg *esw_cfg;
3610         struct qlcnic_npar_info *npar;
3611         int count, rem, i, ret;
3612         u8 pci_func, op_mode = 0;
3613
3614         count   = size / sizeof(struct qlcnic_esw_func_cfg);
3615         rem     = size % sizeof(struct qlcnic_esw_func_cfg);
3616         if (rem)
3617                 return QL_STATUS_INVALID_PARAM;
3618
3619         esw_cfg = (struct qlcnic_esw_func_cfg *) buf;
3620         ret = validate_esw_config(adapter, esw_cfg, count);
3621         if (ret)
3622                 return ret;
3623
3624         for (i = 0; i < count; i++) {
3625                 if (adapter->op_mode == QLCNIC_MGMT_FUNC)
3626                         if (qlcnic_config_switch_port(adapter, &esw_cfg[i]))
3627                                 return QL_STATUS_INVALID_PARAM;
3628
3629                 if (adapter->ahw.pci_func != esw_cfg[i].pci_func)
3630                         continue;
3631
3632                 op_mode = esw_cfg[i].op_mode;
3633                 qlcnic_get_eswitch_port_config(adapter, &esw_cfg[i]);
3634                 esw_cfg[i].op_mode = op_mode;
3635                 esw_cfg[i].pci_func = adapter->ahw.pci_func;
3636
3637                 switch (esw_cfg[i].op_mode) {
3638                 case QLCNIC_PORT_DEFAULTS:
3639                         qlcnic_set_eswitch_port_features(adapter, &esw_cfg[i]);
3640                         break;
3641                 case QLCNIC_ADD_VLAN:
3642                         qlcnic_set_vlan_config(adapter, &esw_cfg[i]);
3643                         break;
3644                 case QLCNIC_DEL_VLAN:
3645                         esw_cfg[i].vlan_id = 0;
3646                         qlcnic_set_vlan_config(adapter, &esw_cfg[i]);
3647                         break;
3648                 }
3649         }
3650
3651         if (adapter->op_mode != QLCNIC_MGMT_FUNC)
3652                 goto out;
3653
3654         for (i = 0; i < count; i++) {
3655                 pci_func = esw_cfg[i].pci_func;
3656                 npar = &adapter->npars[pci_func];
3657                 switch (esw_cfg[i].op_mode) {
3658                 case QLCNIC_PORT_DEFAULTS:
3659                         npar->promisc_mode = esw_cfg[i].promisc_mode;
3660                         npar->mac_override = esw_cfg[i].mac_override;
3661                         npar->offload_flags = esw_cfg[i].offload_flags;
3662                         npar->mac_anti_spoof = esw_cfg[i].mac_anti_spoof;
3663                         npar->discard_tagged = esw_cfg[i].discard_tagged;
3664                         break;
3665                 case QLCNIC_ADD_VLAN:
3666                         npar->pvid = esw_cfg[i].vlan_id;
3667                         break;
3668                 case QLCNIC_DEL_VLAN:
3669                         npar->pvid = 0;
3670                         break;
3671                 }
3672         }
3673 out:
3674         return size;
3675 }
3676
3677 static ssize_t
3678 qlcnic_sysfs_read_esw_config(struct file *file, struct kobject *kobj,
3679         struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3680 {
3681         struct device *dev = container_of(kobj, struct device, kobj);
3682         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3683         struct qlcnic_esw_func_cfg esw_cfg[QLCNIC_MAX_PCI_FUNC];
3684         u8 i;
3685
3686         if (size != sizeof(esw_cfg))
3687                 return QL_STATUS_INVALID_PARAM;
3688
3689         for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
3690                 if (adapter->npars[i].type != QLCNIC_TYPE_NIC)
3691                         continue;
3692                 esw_cfg[i].pci_func = i;
3693                 if (qlcnic_get_eswitch_port_config(adapter, &esw_cfg[i]))
3694                         return QL_STATUS_INVALID_PARAM;
3695         }
3696         memcpy(buf, &esw_cfg, size);
3697
3698         return size;
3699 }
3700
3701 static int
3702 validate_npar_config(struct qlcnic_adapter *adapter,
3703                                 struct qlcnic_npar_func_cfg *np_cfg, int count)
3704 {
3705         u8 pci_func, i;
3706
3707         for (i = 0; i < count; i++) {
3708                 pci_func = np_cfg[i].pci_func;
3709                 if (pci_func >= QLCNIC_MAX_PCI_FUNC)
3710                         return QL_STATUS_INVALID_PARAM;
3711
3712                 if (adapter->npars[pci_func].type != QLCNIC_TYPE_NIC)
3713                         return QL_STATUS_INVALID_PARAM;
3714
3715                 if (!IS_VALID_BW(np_cfg[i].min_bw)
3716                                 || !IS_VALID_BW(np_cfg[i].max_bw)
3717                                 || !IS_VALID_RX_QUEUES(np_cfg[i].max_rx_queues)
3718                                 || !IS_VALID_TX_QUEUES(np_cfg[i].max_tx_queues))
3719                         return QL_STATUS_INVALID_PARAM;
3720         }
3721         return 0;
3722 }
3723
3724 static ssize_t
3725 qlcnic_sysfs_write_npar_config(struct file *file, struct kobject *kobj,
3726         struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3727 {
3728         struct device *dev = container_of(kobj, struct device, kobj);
3729         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3730         struct qlcnic_info nic_info;
3731         struct qlcnic_npar_func_cfg *np_cfg;
3732         int i, count, rem, ret;
3733         u8 pci_func;
3734
3735         count   = size / sizeof(struct qlcnic_npar_func_cfg);
3736         rem     = size % sizeof(struct qlcnic_npar_func_cfg);
3737         if (rem)
3738                 return QL_STATUS_INVALID_PARAM;
3739
3740         np_cfg = (struct qlcnic_npar_func_cfg *) buf;
3741         ret = validate_npar_config(adapter, np_cfg, count);
3742         if (ret)
3743                 return ret;
3744
3745         for (i = 0; i < count ; i++) {
3746                 pci_func = np_cfg[i].pci_func;
3747                 ret = qlcnic_get_nic_info(adapter, &nic_info, pci_func);
3748                 if (ret)
3749                         return ret;
3750                 nic_info.pci_func = pci_func;
3751                 nic_info.min_tx_bw = np_cfg[i].min_bw;
3752                 nic_info.max_tx_bw = np_cfg[i].max_bw;
3753                 ret = qlcnic_set_nic_info(adapter, &nic_info);
3754                 if (ret)
3755                         return ret;
3756                 adapter->npars[i].min_bw = nic_info.min_tx_bw;
3757                 adapter->npars[i].max_bw = nic_info.max_tx_bw;
3758         }
3759
3760         return size;
3761
3762 }
3763 static ssize_t
3764 qlcnic_sysfs_read_npar_config(struct file *file, struct kobject *kobj,
3765         struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3766 {
3767         struct device *dev = container_of(kobj, struct device, kobj);
3768         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3769         struct qlcnic_info nic_info;
3770         struct qlcnic_npar_func_cfg np_cfg[QLCNIC_MAX_PCI_FUNC];
3771         int i, ret;
3772
3773         if (size != sizeof(np_cfg))
3774                 return QL_STATUS_INVALID_PARAM;
3775
3776         for (i = 0; i < QLCNIC_MAX_PCI_FUNC ; i++) {
3777                 if (adapter->npars[i].type != QLCNIC_TYPE_NIC)
3778                         continue;
3779                 ret = qlcnic_get_nic_info(adapter, &nic_info, i);
3780                 if (ret)
3781                         return ret;
3782
3783                 np_cfg[i].pci_func = i;
3784                 np_cfg[i].op_mode = (u8)nic_info.op_mode;
3785                 np_cfg[i].port_num = nic_info.phys_port;
3786                 np_cfg[i].fw_capab = nic_info.capabilities;
3787                 np_cfg[i].min_bw = nic_info.min_tx_bw ;
3788                 np_cfg[i].max_bw = nic_info.max_tx_bw;
3789                 np_cfg[i].max_tx_queues = nic_info.max_tx_ques;
3790                 np_cfg[i].max_rx_queues = nic_info.max_rx_ques;
3791         }
3792         memcpy(buf, &np_cfg, size);
3793         return size;
3794 }
3795
3796 static ssize_t
3797 qlcnic_sysfs_get_port_stats(struct file *file, struct kobject *kobj,
3798         struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3799 {
3800         struct device *dev = container_of(kobj, struct device, kobj);
3801         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3802         struct qlcnic_esw_statistics port_stats;
3803         int ret;
3804
3805         if (size != sizeof(struct qlcnic_esw_statistics))
3806                 return QL_STATUS_INVALID_PARAM;
3807
3808         if (offset >= QLCNIC_MAX_PCI_FUNC)
3809                 return QL_STATUS_INVALID_PARAM;
3810
3811         memset(&port_stats, 0, size);
3812         ret = qlcnic_get_port_stats(adapter, offset, QLCNIC_QUERY_RX_COUNTER,
3813                                                                 &port_stats.rx);
3814         if (ret)
3815                 return ret;
3816
3817         ret = qlcnic_get_port_stats(adapter, offset, QLCNIC_QUERY_TX_COUNTER,
3818                                                                 &port_stats.tx);
3819         if (ret)
3820                 return ret;
3821
3822         memcpy(buf, &port_stats, size);
3823         return size;
3824 }
3825
3826 static ssize_t
3827 qlcnic_sysfs_get_esw_stats(struct file *file, struct kobject *kobj,
3828         struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3829 {
3830         struct device *dev = container_of(kobj, struct device, kobj);
3831         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3832         struct qlcnic_esw_statistics esw_stats;
3833         int ret;
3834
3835         if (size != sizeof(struct qlcnic_esw_statistics))
3836                 return QL_STATUS_INVALID_PARAM;
3837
3838         if (offset >= QLCNIC_NIU_MAX_XG_PORTS)
3839                 return QL_STATUS_INVALID_PARAM;
3840
3841         memset(&esw_stats, 0, size);
3842         ret = qlcnic_get_eswitch_stats(adapter, offset, QLCNIC_QUERY_RX_COUNTER,
3843                                                                 &esw_stats.rx);
3844         if (ret)
3845                 return ret;
3846
3847         ret = qlcnic_get_eswitch_stats(adapter, offset, QLCNIC_QUERY_TX_COUNTER,
3848                                                                 &esw_stats.tx);
3849         if (ret)
3850                 return ret;
3851
3852         memcpy(buf, &esw_stats, size);
3853         return size;
3854 }
3855
3856 static ssize_t
3857 qlcnic_sysfs_clear_esw_stats(struct file *file, struct kobject *kobj,
3858         struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3859 {
3860         struct device *dev = container_of(kobj, struct device, kobj);
3861         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3862         int ret;
3863
3864         if (offset >= QLCNIC_NIU_MAX_XG_PORTS)
3865                 return QL_STATUS_INVALID_PARAM;
3866
3867         ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_ESWITCH, offset,
3868                                                 QLCNIC_QUERY_RX_COUNTER);
3869         if (ret)
3870                 return ret;
3871
3872         ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_ESWITCH, offset,
3873                                                 QLCNIC_QUERY_TX_COUNTER);
3874         if (ret)
3875                 return ret;
3876
3877         return size;
3878 }
3879
3880 static ssize_t
3881 qlcnic_sysfs_clear_port_stats(struct file *file, struct kobject *kobj,
3882         struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3883 {
3884
3885         struct device *dev = container_of(kobj, struct device, kobj);
3886         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3887         int ret;
3888
3889         if (offset >= QLCNIC_MAX_PCI_FUNC)
3890                 return QL_STATUS_INVALID_PARAM;
3891
3892         ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_PORT, offset,
3893                                                 QLCNIC_QUERY_RX_COUNTER);
3894         if (ret)
3895                 return ret;
3896
3897         ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_PORT, offset,
3898                                                 QLCNIC_QUERY_TX_COUNTER);
3899         if (ret)
3900                 return ret;
3901
3902         return size;
3903 }
3904
3905 static ssize_t
3906 qlcnic_sysfs_read_pci_config(struct file *file, struct kobject *kobj,
3907         struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3908 {
3909         struct device *dev = container_of(kobj, struct device, kobj);
3910         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3911         struct qlcnic_pci_func_cfg pci_cfg[QLCNIC_MAX_PCI_FUNC];
3912         struct qlcnic_pci_info *pci_info;
3913         int i, ret;
3914
3915         if (size != sizeof(pci_cfg))
3916                 return QL_STATUS_INVALID_PARAM;
3917
3918         pci_info = kcalloc(QLCNIC_MAX_PCI_FUNC, sizeof(*pci_info), GFP_KERNEL);
3919         if (!pci_info)
3920                 return -ENOMEM;
3921
3922         ret = qlcnic_get_pci_info(adapter, pci_info);
3923         if (ret) {
3924                 kfree(pci_info);
3925                 return ret;
3926         }
3927
3928         for (i = 0; i < QLCNIC_MAX_PCI_FUNC ; i++) {
3929                 pci_cfg[i].pci_func = pci_info[i].id;
3930                 pci_cfg[i].func_type = pci_info[i].type;
3931                 pci_cfg[i].port_num = pci_info[i].default_port;
3932                 pci_cfg[i].min_bw = pci_info[i].tx_min_bw;
3933                 pci_cfg[i].max_bw = pci_info[i].tx_max_bw;
3934                 memcpy(&pci_cfg[i].def_mac_addr, &pci_info[i].mac, ETH_ALEN);
3935         }
3936         memcpy(buf, &pci_cfg, size);
3937         kfree(pci_info);
3938         return size;
3939 }
3940 static struct bin_attribute bin_attr_npar_config = {
3941         .attr = {.name = "npar_config", .mode = (S_IRUGO | S_IWUSR)},
3942         .size = 0,
3943         .read = qlcnic_sysfs_read_npar_config,
3944         .write = qlcnic_sysfs_write_npar_config,
3945 };
3946
3947 static struct bin_attribute bin_attr_pci_config = {
3948         .attr = {.name = "pci_config", .mode = (S_IRUGO | S_IWUSR)},
3949         .size = 0,
3950         .read = qlcnic_sysfs_read_pci_config,
3951         .write = NULL,
3952 };
3953
3954 static struct bin_attribute bin_attr_port_stats = {
3955         .attr = {.name = "port_stats", .mode = (S_IRUGO | S_IWUSR)},
3956         .size = 0,
3957         .read = qlcnic_sysfs_get_port_stats,
3958         .write = qlcnic_sysfs_clear_port_stats,
3959 };
3960
3961 static struct bin_attribute bin_attr_esw_stats = {
3962         .attr = {.name = "esw_stats", .mode = (S_IRUGO | S_IWUSR)},
3963         .size = 0,
3964         .read = qlcnic_sysfs_get_esw_stats,
3965         .write = qlcnic_sysfs_clear_esw_stats,
3966 };
3967
3968 static struct bin_attribute bin_attr_esw_config = {
3969         .attr = {.name = "esw_config", .mode = (S_IRUGO | S_IWUSR)},
3970         .size = 0,
3971         .read = qlcnic_sysfs_read_esw_config,
3972         .write = qlcnic_sysfs_write_esw_config,
3973 };
3974
3975 static struct bin_attribute bin_attr_pm_config = {
3976         .attr = {.name = "pm_config", .mode = (S_IRUGO | S_IWUSR)},
3977         .size = 0,
3978         .read = qlcnic_sysfs_read_pm_config,
3979         .write = qlcnic_sysfs_write_pm_config,
3980 };
3981
3982 static void
3983 qlcnic_create_sysfs_entries(struct qlcnic_adapter *adapter)
3984 {
3985         struct device *dev = &adapter->pdev->dev;
3986
3987         if (adapter->capabilities & QLCNIC_FW_CAPABILITY_BDG)
3988                 if (device_create_file(dev, &dev_attr_bridged_mode))
3989                         dev_warn(dev,
3990                                 "failed to create bridged_mode sysfs entry\n");
3991 }
3992
3993 static void
3994 qlcnic_remove_sysfs_entries(struct qlcnic_adapter *adapter)
3995 {
3996         struct device *dev = &adapter->pdev->dev;
3997
3998         if (adapter->capabilities & QLCNIC_FW_CAPABILITY_BDG)
3999                 device_remove_file(dev, &dev_attr_bridged_mode);
4000 }
4001
4002 static void
4003 qlcnic_create_diag_entries(struct qlcnic_adapter *adapter)
4004 {
4005         struct device *dev = &adapter->pdev->dev;
4006
4007         if (device_create_bin_file(dev, &bin_attr_port_stats))
4008                 dev_info(dev, "failed to create port stats sysfs entry");
4009
4010         if (adapter->op_mode == QLCNIC_NON_PRIV_FUNC)
4011                 return;
4012         if (device_create_file(dev, &dev_attr_diag_mode))
4013                 dev_info(dev, "failed to create diag_mode sysfs entry\n");
4014         if (device_create_bin_file(dev, &bin_attr_crb))
4015                 dev_info(dev, "failed to create crb sysfs entry\n");
4016         if (device_create_bin_file(dev, &bin_attr_mem))
4017                 dev_info(dev, "failed to create mem sysfs entry\n");
4018         if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
4019                 return;
4020         if (device_create_bin_file(dev, &bin_attr_esw_config))
4021                 dev_info(dev, "failed to create esw config sysfs entry");
4022         if (adapter->op_mode != QLCNIC_MGMT_FUNC)
4023                 return;
4024         if (device_create_bin_file(dev, &bin_attr_pci_config))
4025                 dev_info(dev, "failed to create pci config sysfs entry");
4026         if (device_create_bin_file(dev, &bin_attr_npar_config))
4027                 dev_info(dev, "failed to create npar config sysfs entry");
4028         if (device_create_bin_file(dev, &bin_attr_pm_config))
4029                 dev_info(dev, "failed to create pm config sysfs entry");
4030         if (device_create_bin_file(dev, &bin_attr_esw_stats))
4031                 dev_info(dev, "failed to create eswitch stats sysfs entry");
4032 }
4033
4034 static void
4035 qlcnic_remove_diag_entries(struct qlcnic_adapter *adapter)
4036 {
4037         struct device *dev = &adapter->pdev->dev;
4038
4039         device_remove_bin_file(dev, &bin_attr_port_stats);
4040
4041         if (adapter->op_mode == QLCNIC_NON_PRIV_FUNC)
4042                 return;
4043         device_remove_file(dev, &dev_attr_diag_mode);
4044         device_remove_bin_file(dev, &bin_attr_crb);
4045         device_remove_bin_file(dev, &bin_attr_mem);
4046         if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
4047                 return;
4048         device_remove_bin_file(dev, &bin_attr_esw_config);
4049         if (adapter->op_mode != QLCNIC_MGMT_FUNC)
4050                 return;
4051         device_remove_bin_file(dev, &bin_attr_pci_config);
4052         device_remove_bin_file(dev, &bin_attr_npar_config);
4053         device_remove_bin_file(dev, &bin_attr_pm_config);
4054         device_remove_bin_file(dev, &bin_attr_esw_stats);
4055 }
4056
4057 #ifdef CONFIG_INET
4058
4059 #define is_qlcnic_netdev(dev) (dev->netdev_ops == &qlcnic_netdev_ops)
4060
4061 static void
4062 qlcnic_config_indev_addr(struct qlcnic_adapter *adapter,
4063                         struct net_device *dev, unsigned long event)
4064 {
4065         struct in_device *indev;
4066
4067         indev = in_dev_get(dev);
4068         if (!indev)
4069                 return;
4070
4071         for_ifa(indev) {
4072                 switch (event) {
4073                 case NETDEV_UP:
4074                         qlcnic_config_ipaddr(adapter,
4075                                         ifa->ifa_address, QLCNIC_IP_UP);
4076                         break;
4077                 case NETDEV_DOWN:
4078                         qlcnic_config_ipaddr(adapter,
4079                                         ifa->ifa_address, QLCNIC_IP_DOWN);
4080                         break;
4081                 default:
4082                         break;
4083                 }
4084         } endfor_ifa(indev);
4085
4086         in_dev_put(indev);
4087 }
4088
4089 static void
4090 qlcnic_restore_indev_addr(struct net_device *netdev, unsigned long event)
4091 {
4092         struct qlcnic_adapter *adapter = netdev_priv(netdev);
4093         struct net_device *dev;
4094         u16 vid;
4095
4096         qlcnic_config_indev_addr(adapter, netdev, event);
4097
4098         if (!adapter->vlgrp)
4099                 return;
4100
4101         for (vid = 0; vid < VLAN_N_VID; vid++) {
4102                 dev = vlan_group_get_device(adapter->vlgrp, vid);
4103                 if (!dev)
4104                         continue;
4105
4106                 qlcnic_config_indev_addr(adapter, dev, event);
4107         }
4108 }
4109
4110 static int qlcnic_netdev_event(struct notifier_block *this,
4111                                  unsigned long event, void *ptr)
4112 {
4113         struct qlcnic_adapter *adapter;
4114         struct net_device *dev = (struct net_device *)ptr;
4115
4116 recheck:
4117         if (dev == NULL)
4118                 goto done;
4119
4120         if (dev->priv_flags & IFF_802_1Q_VLAN) {
4121                 dev = vlan_dev_real_dev(dev);
4122                 goto recheck;
4123         }
4124
4125         if (!is_qlcnic_netdev(dev))
4126                 goto done;
4127
4128         adapter = netdev_priv(dev);
4129
4130         if (!adapter)
4131                 goto done;
4132
4133         if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
4134                 goto done;
4135
4136         qlcnic_config_indev_addr(adapter, dev, event);
4137 done:
4138         return NOTIFY_DONE;
4139 }
4140
4141 static int
4142 qlcnic_inetaddr_event(struct notifier_block *this,
4143                 unsigned long event, void *ptr)
4144 {
4145         struct qlcnic_adapter *adapter;
4146         struct net_device *dev;
4147
4148         struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
4149
4150         dev = ifa->ifa_dev ? ifa->ifa_dev->dev : NULL;
4151
4152 recheck:
4153         if (dev == NULL)
4154                 goto done;
4155
4156         if (dev->priv_flags & IFF_802_1Q_VLAN) {
4157                 dev = vlan_dev_real_dev(dev);
4158                 goto recheck;
4159         }
4160
4161         if (!is_qlcnic_netdev(dev))
4162                 goto done;
4163
4164         adapter = netdev_priv(dev);
4165
4166         if (!adapter)
4167                 goto done;
4168
4169         if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
4170                 goto done;
4171
4172         switch (event) {
4173         case NETDEV_UP:
4174                 qlcnic_config_ipaddr(adapter, ifa->ifa_address, QLCNIC_IP_UP);
4175                 break;
4176         case NETDEV_DOWN:
4177                 qlcnic_config_ipaddr(adapter, ifa->ifa_address, QLCNIC_IP_DOWN);
4178                 break;
4179         default:
4180                 break;
4181         }
4182
4183 done:
4184         return NOTIFY_DONE;
4185 }
4186
4187 static struct notifier_block    qlcnic_netdev_cb = {
4188         .notifier_call = qlcnic_netdev_event,
4189 };
4190
4191 static struct notifier_block qlcnic_inetaddr_cb = {
4192         .notifier_call = qlcnic_inetaddr_event,
4193 };
4194 #else
4195 static void
4196 qlcnic_restore_indev_addr(struct net_device *dev, unsigned long event)
4197 { }
4198 #endif
4199 static struct pci_error_handlers qlcnic_err_handler = {
4200         .error_detected = qlcnic_io_error_detected,
4201         .slot_reset = qlcnic_io_slot_reset,
4202         .resume = qlcnic_io_resume,
4203 };
4204
4205 static struct pci_driver qlcnic_driver = {
4206         .name = qlcnic_driver_name,
4207         .id_table = qlcnic_pci_tbl,
4208         .probe = qlcnic_probe,
4209         .remove = __devexit_p(qlcnic_remove),
4210 #ifdef CONFIG_PM
4211         .suspend = qlcnic_suspend,
4212         .resume = qlcnic_resume,
4213 #endif
4214         .shutdown = qlcnic_shutdown,
4215         .err_handler = &qlcnic_err_handler
4216
4217 };
4218
4219 static int __init qlcnic_init_module(void)
4220 {
4221         int ret;
4222
4223         printk(KERN_INFO "%s\n", qlcnic_driver_string);
4224
4225         qlcnic_wq = create_singlethread_workqueue("qlcnic");
4226         if (qlcnic_wq == NULL) {
4227                 printk(KERN_ERR "qlcnic: cannot create workqueue\n");
4228                 return -ENOMEM;
4229         }
4230
4231 #ifdef CONFIG_INET
4232         register_netdevice_notifier(&qlcnic_netdev_cb);
4233         register_inetaddr_notifier(&qlcnic_inetaddr_cb);
4234 #endif
4235
4236         ret = pci_register_driver(&qlcnic_driver);
4237         if (ret) {
4238 #ifdef CONFIG_INET
4239                 unregister_inetaddr_notifier(&qlcnic_inetaddr_cb);
4240                 unregister_netdevice_notifier(&qlcnic_netdev_cb);
4241 #endif
4242                 destroy_workqueue(qlcnic_wq);
4243         }
4244
4245         return ret;
4246 }
4247
4248 module_init(qlcnic_init_module);
4249
4250 static void __exit qlcnic_exit_module(void)
4251 {
4252
4253         pci_unregister_driver(&qlcnic_driver);
4254
4255 #ifdef CONFIG_INET
4256         unregister_inetaddr_notifier(&qlcnic_inetaddr_cb);
4257         unregister_netdevice_notifier(&qlcnic_netdev_cb);
4258 #endif
4259         destroy_workqueue(qlcnic_wq);
4260 }
4261
4262 module_exit(qlcnic_exit_module);