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

   1 /*
   2  * QLogic qlcnic NIC Driver
   3  * Copyright (c) 2009-2013 QLogic Corporation
   4  *
   5  * See LICENSE.qlcnic for copyright and licensing details.
   6  */
   7
   8 #include <linux/vmalloc.h>
   9 #include <linux/interrupt.h>
  10
  11 #include "qlcnic.h"
  12 #include "qlcnic_sriov.h"
  13 #include "qlcnic_hw.h"
  14
  15 #include <linux/swab.h>
  16 #include <linux/dma-mapping.h>
  17 #include <linux/if_vlan.h>
  18 #include <net/ip.h>
  19 #include <linux/ipv6.h>
  20 #include <linux/inetdevice.h>
  21 #include <linux/aer.h>
  22 #include <linux/log2.h>
  23 #include <linux/pci.h>
  24
  25 MODULE_DESCRIPTION("QLogic 1/10 GbE Converged/Intelligent Ethernet Driver");
  26 MODULE_LICENSE("GPL");
  27 MODULE_VERSION(QLCNIC_LINUX_VERSIONID);
  28 MODULE_FIRMWARE(QLCNIC_UNIFIED_ROMIMAGE_NAME);
  29
  30 char qlcnic_driver_name[] = "qlcnic";
  31 static const char qlcnic_driver_string[] = "QLogic 1/10 GbE "
  32         "Converged/Intelligent Ethernet Driver v" QLCNIC_LINUX_VERSIONID;
  33
  34 static int qlcnic_mac_learn;
  35 module_param(qlcnic_mac_learn, int, 0444);
  36 MODULE_PARM_DESC(qlcnic_mac_learn,
  37                  "Mac Filter (0=learning is disabled, 1=Driver learning is enabled, 2=FDB learning is enabled)");
  38
  39 int qlcnic_use_msi = 1;
  40 MODULE_PARM_DESC(use_msi, "MSI interrupt (0=disabled, 1=enabled");
  41 module_param_named(use_msi, qlcnic_use_msi, int, 0444);
  42
  43 int qlcnic_use_msi_x = 1;
  44 MODULE_PARM_DESC(use_msi_x, "MSI-X interrupt (0=disabled, 1=enabled");
  45 module_param_named(use_msi_x, qlcnic_use_msi_x, int, 0444);
  46
  47 int qlcnic_auto_fw_reset = 1;
  48 MODULE_PARM_DESC(auto_fw_reset, "Auto firmware reset (0=disabled, 1=enabled");
  49 module_param_named(auto_fw_reset, qlcnic_auto_fw_reset, int, 0644);
  50
  51 int qlcnic_load_fw_file;
  52 MODULE_PARM_DESC(load_fw_file, "Load firmware from (0=flash, 1=file");
  53 module_param_named(load_fw_file, qlcnic_load_fw_file, int, 0444);
  54
  55 int qlcnic_config_npars;
  56 module_param(qlcnic_config_npars, int, 0444);
  57 MODULE_PARM_DESC(qlcnic_config_npars, "Configure NPARs (0=disabled, 1=enabled");
  58
  59 static int qlcnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
  60 static void qlcnic_remove(struct pci_dev *pdev);
  61 static int qlcnic_open(struct net_device *netdev);
  62 static int qlcnic_close(struct net_device *netdev);
  63 static void qlcnic_tx_timeout(struct net_device *netdev);
  64 static void qlcnic_attach_work(struct work_struct *work);
  65 static void qlcnic_fwinit_work(struct work_struct *work);
  66 static void qlcnic_fw_poll_work(struct work_struct *work);
  67 #ifdef CONFIG_NET_POLL_CONTROLLER
  68 static void qlcnic_poll_controller(struct net_device *netdev);
  69 #endif
  70
  71 static void qlcnic_idc_debug_info(struct qlcnic_adapter *adapter, u8 encoding);
  72 static void qlcnic_clr_all_drv_state(struct qlcnic_adapter *adapter, u8);
  73 static int qlcnic_can_start_firmware(struct qlcnic_adapter *adapter);
  74
  75 static irqreturn_t qlcnic_tmp_intr(int irq, void *data);
  76 static irqreturn_t qlcnic_intr(int irq, void *data);
  77 static irqreturn_t qlcnic_msi_intr(int irq, void *data);
  78 static irqreturn_t qlcnic_msix_intr(int irq, void *data);
  79 static irqreturn_t qlcnic_msix_tx_intr(int irq, void *data);
  80
  81 static struct net_device_stats *qlcnic_get_stats(struct net_device *netdev);
  82 static int qlcnic_start_firmware(struct qlcnic_adapter *);
  83
  84 static void qlcnic_free_lb_filters_mem(struct qlcnic_adapter *adapter);
  85 static void qlcnic_dev_set_npar_ready(struct qlcnic_adapter *);
  86 static int qlcnicvf_start_firmware(struct qlcnic_adapter *);
  87 static void qlcnic_set_netdev_features(struct qlcnic_adapter *,
  88                                 struct qlcnic_esw_func_cfg *);
  89 static int qlcnic_vlan_rx_add(struct net_device *, __be16, u16);
  90 static int qlcnic_vlan_rx_del(struct net_device *, __be16, u16);
  91
  92 #define QLCNIC_IS_TSO_CAPABLE(adapter)  \
  93         ((adapter)->ahw->capabilities & QLCNIC_FW_CAPABILITY_TSO)
  94
  95 static u32 qlcnic_vlan_tx_check(struct qlcnic_adapter *adapter)
  96 {
  97         struct qlcnic_hardware_context *ahw = adapter->ahw;
  98
  99         if (adapter->pdev->device == PCI_DEVICE_ID_QLOGIC_QLE824X)
 100                 return ahw->capabilities & QLCNIC_FW_CAPABILITY_FVLANTX;
 101         else
 102                 return 1;
 103 }
 104
 105 /*  PCI Device ID Table  */
 106 #define ENTRY(device) \
 107         {PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, (device)), \
 108         .class = PCI_CLASS_NETWORK_ETHERNET << 8, .class_mask = ~0}
 109
 110 static DEFINE_PCI_DEVICE_TABLE(qlcnic_pci_tbl) = {
 111         ENTRY(PCI_DEVICE_ID_QLOGIC_QLE824X),
 112         ENTRY(PCI_DEVICE_ID_QLOGIC_QLE834X),
 113         ENTRY(PCI_DEVICE_ID_QLOGIC_VF_QLE834X),
 114         {0,}
 115 };
 116
 117 MODULE_DEVICE_TABLE(pci, qlcnic_pci_tbl);
 118
 119
 120 inline void qlcnic_update_cmd_producer(struct qlcnic_host_tx_ring *tx_ring)
 121 {
 122         writel(tx_ring->producer, tx_ring->crb_cmd_producer);
 123 }
 124
 125 static const u32 msi_tgt_status[8] = {
 126         ISR_INT_TARGET_STATUS, ISR_INT_TARGET_STATUS_F1,
 127         ISR_INT_TARGET_STATUS_F2, ISR_INT_TARGET_STATUS_F3,
 128         ISR_INT_TARGET_STATUS_F4, ISR_INT_TARGET_STATUS_F5,
 129         ISR_INT_TARGET_STATUS_F6, ISR_INT_TARGET_STATUS_F7
 130 };
 131
 132 static const u32 qlcnic_reg_tbl[] = {
 133         0x1B20A8,       /* PEG_HALT_STAT1 */
 134         0x1B20AC,       /* PEG_HALT_STAT2 */
 135         0x1B20B0,       /* FW_HEARTBEAT */
 136         0x1B2100,       /* LOCK ID */
 137         0x1B2128,       /* FW_CAPABILITIES */
 138         0x1B2138,       /* drv active */
 139         0x1B2140,       /* dev state */
 140         0x1B2144,       /* drv state */
 141         0x1B2148,       /* drv scratch */
 142         0x1B214C,       /* dev partition info */
 143         0x1B2174,       /* drv idc ver */
 144         0x1B2150,       /* fw version major */
 145         0x1B2154,       /* fw version minor */
 146         0x1B2158,       /* fw version sub */
 147         0x1B219C,       /* npar state */
 148         0x1B21FC,       /* FW_IMG_VALID */
 149         0x1B2250,       /* CMD_PEG_STATE */
 150         0x1B233C,       /* RCV_PEG_STATE */
 151         0x1B23B4,       /* ASIC TEMP */
 152         0x1B216C,       /* FW api */
 153         0x1B2170,       /* drv op mode */
 154         0x13C010,       /* flash lock */
 155         0x13C014,       /* flash unlock */
 156 };
 157
 158 static const struct qlcnic_board_info qlcnic_boards[] = {
 159         {0x1077, 0x8020, 0x1077, 0x203,
 160          "8200 Series Single Port 10GbE Converged Network Adapter"
 161          "(TCP/IP Networking)"},
 162         {0x1077, 0x8020, 0x1077, 0x207,
 163          "8200 Series Dual Port 10GbE Converged Network Adapter"
 164          "(TCP/IP Networking)"},
 165         {0x1077, 0x8020, 0x1077, 0x20b,
 166          "3200 Series Dual Port 10Gb Intelligent Ethernet Adapter"},
 167         {0x1077, 0x8020, 0x1077, 0x20c,
 168          "3200 Series Quad Port 1Gb Intelligent Ethernet Adapter"},
 169         {0x1077, 0x8020, 0x1077, 0x20f,
 170          "3200 Series Single Port 10Gb Intelligent Ethernet Adapter"},
 171         {0x1077, 0x8020, 0x103c, 0x3733,
 172          "NC523SFP 10Gb 2-port Server Adapter"},
 173         {0x1077, 0x8020, 0x103c, 0x3346,
 174          "CN1000Q Dual Port Converged Network Adapter"},
 175         {0x1077, 0x8020, 0x1077, 0x210,
 176          "QME8242-k 10GbE Dual Port Mezzanine Card"},
 177         {0x1077, 0x8020, 0x0, 0x0, "cLOM8214 1/10GbE Controller"},
 178 };
 179
 180 #define NUM_SUPPORTED_BOARDS ARRAY_SIZE(qlcnic_boards)
 181 #define QLC_MAX_SDS_RINGS       8
 182
 183 static const
 184 struct qlcnic_legacy_intr_set legacy_intr[] = QLCNIC_LEGACY_INTR_CONFIG;
 185
 186 int qlcnic_alloc_sds_rings(struct qlcnic_recv_context *recv_ctx, int count)
 187 {
 188         int size = sizeof(struct qlcnic_host_sds_ring) * count;
 189
 190         recv_ctx->sds_rings = kzalloc(size, GFP_KERNEL);
 191
 192         return recv_ctx->sds_rings == NULL;
 193 }
 194
 195 void qlcnic_free_sds_rings(struct qlcnic_recv_context *recv_ctx)
 196 {
 197         if (recv_ctx->sds_rings != NULL)
 198                 kfree(recv_ctx->sds_rings);
 199
 200         recv_ctx->sds_rings = NULL;
 201 }
 202
 203 int qlcnic_read_mac_addr(struct qlcnic_adapter *adapter)
 204 {
 205         u8 mac_addr[ETH_ALEN];
 206         struct net_device *netdev = adapter->netdev;
 207         struct pci_dev *pdev = adapter->pdev;
 208
 209         if (qlcnic_get_mac_address(adapter, mac_addr) != 0)
 210                 return -EIO;
 211
 212         memcpy(netdev->dev_addr, mac_addr, ETH_ALEN);
 213         memcpy(adapter->mac_addr, netdev->dev_addr, netdev->addr_len);
 214
 215         /* set station address */
 216
 217         if (!is_valid_ether_addr(netdev->dev_addr))
 218                 dev_warn(&pdev->dev, "Bad MAC address %pM.\n",
 219                                         netdev->dev_addr);
 220
 221         return 0;
 222 }
 223
 224 static int qlcnic_set_mac(struct net_device *netdev, void *p)
 225 {
 226         struct qlcnic_adapter *adapter = netdev_priv(netdev);
 227         struct sockaddr *addr = p;
 228
 229         if (qlcnic_sriov_vf_check(adapter))
 230                 return -EINVAL;
 231
 232         if ((adapter->flags & QLCNIC_MAC_OVERRIDE_DISABLED))
 233                 return -EOPNOTSUPP;
 234
 235         if (!is_valid_ether_addr(addr->sa_data))
 236                 return -EINVAL;
 237
 238         if (test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
 239                 netif_device_detach(netdev);
 240                 qlcnic_napi_disable(adapter);
 241         }
 242
 243         memcpy(adapter->mac_addr, addr->sa_data, netdev->addr_len);
 244         memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
 245         qlcnic_set_multi(adapter->netdev);
 246
 247         if (test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
 248                 netif_device_attach(netdev);
 249                 qlcnic_napi_enable(adapter);
 250         }
 251         return 0;
 252 }
 253
 254 static int qlcnic_fdb_del(struct ndmsg *ndm, struct nlattr *tb[],
 255                         struct net_device *netdev, const unsigned char *addr)
 256 {
 257         struct qlcnic_adapter *adapter = netdev_priv(netdev);
 258         int err = -EOPNOTSUPP;
 259
 260         if (!adapter->fdb_mac_learn)
 261                 return ndo_dflt_fdb_del(ndm, tb, netdev, addr);
 262
 263         if (adapter->flags & QLCNIC_ESWITCH_ENABLED) {
 264                 if (is_unicast_ether_addr(addr))
 265                         err = qlcnic_nic_del_mac(adapter, addr);
 266                 else if (is_multicast_ether_addr(addr))
 267                         err = dev_mc_del(netdev, addr);
 268                 else
 269                         err =  -EINVAL;
 270         }
 271         return err;
 272 }
 273
 274 static int qlcnic_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
 275                         struct net_device *netdev,
 276                         const unsigned char *addr, u16 flags)
 277 {
 278         struct qlcnic_adapter *adapter = netdev_priv(netdev);
 279         int err = 0;
 280
 281         if (!adapter->fdb_mac_learn)
 282                 return ndo_dflt_fdb_add(ndm, tb, netdev, addr, flags);
 283
 284         if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED)) {
 285                 pr_info("%s: FDB e-switch is not enabled\n", __func__);
 286                 return -EOPNOTSUPP;
 287         }
 288
 289         if (ether_addr_equal(addr, adapter->mac_addr))
 290                 return err;
 291
 292         if (is_unicast_ether_addr(addr))
 293                 err = qlcnic_nic_add_mac(adapter, addr, 0);
 294         else if (is_multicast_ether_addr(addr))
 295                 err = dev_mc_add_excl(netdev, addr);
 296         else
 297                 err = -EINVAL;
 298
 299         return err;
 300 }
 301
 302 static int qlcnic_fdb_dump(struct sk_buff *skb, struct netlink_callback *ncb,
 303                         struct net_device *netdev, int idx)
 304 {
 305         struct qlcnic_adapter *adapter = netdev_priv(netdev);
 306
 307         if (!adapter->fdb_mac_learn)
 308                 return ndo_dflt_fdb_dump(skb, ncb, netdev, idx);
 309
 310         if (adapter->flags & QLCNIC_ESWITCH_ENABLED)
 311                 idx = ndo_dflt_fdb_dump(skb, ncb, netdev, idx);
 312
 313         return idx;
 314 }
 315
 316 static void qlcnic_82xx_cancel_idc_work(struct qlcnic_adapter *adapter)
 317 {
 318         while (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
 319                 usleep_range(10000, 11000);
 320
 321         cancel_delayed_work_sync(&adapter->fw_work);
 322 }
 323
 324 static const struct net_device_ops qlcnic_netdev_ops = {
 325         .ndo_open          = qlcnic_open,
 326         .ndo_stop          = qlcnic_close,
 327         .ndo_start_xmit    = qlcnic_xmit_frame,
 328         .ndo_get_stats     = qlcnic_get_stats,
 329         .ndo_validate_addr = eth_validate_addr,
 330         .ndo_set_rx_mode   = qlcnic_set_multi,
 331         .ndo_set_mac_address    = qlcnic_set_mac,
 332         .ndo_change_mtu    = qlcnic_change_mtu,
 333         .ndo_fix_features  = qlcnic_fix_features,
 334         .ndo_set_features  = qlcnic_set_features,
 335         .ndo_tx_timeout    = qlcnic_tx_timeout,
 336         .ndo_vlan_rx_add_vid    = qlcnic_vlan_rx_add,
 337         .ndo_vlan_rx_kill_vid   = qlcnic_vlan_rx_del,
 338         .ndo_fdb_add            = qlcnic_fdb_add,
 339         .ndo_fdb_del            = qlcnic_fdb_del,
 340         .ndo_fdb_dump           = qlcnic_fdb_dump,
 341 #ifdef CONFIG_NET_POLL_CONTROLLER
 342         .ndo_poll_controller = qlcnic_poll_controller,
 343 #endif
 344 #ifdef CONFIG_QLCNIC_SRIOV
 345         .ndo_set_vf_mac         = qlcnic_sriov_set_vf_mac,
 346         .ndo_set_vf_tx_rate     = qlcnic_sriov_set_vf_tx_rate,
 347         .ndo_get_vf_config      = qlcnic_sriov_get_vf_config,
 348         .ndo_set_vf_vlan        = qlcnic_sriov_set_vf_vlan,
 349 #endif
 350 };
 351
 352 static const struct net_device_ops qlcnic_netdev_failed_ops = {
 353         .ndo_open          = qlcnic_open,
 354 };
 355
 356 static struct qlcnic_nic_template qlcnic_ops = {
 357         .config_bridged_mode    = qlcnic_config_bridged_mode,
 358         .config_led             = qlcnic_82xx_config_led,
 359         .start_firmware         = qlcnic_82xx_start_firmware,
 360         .request_reset          = qlcnic_82xx_dev_request_reset,
 361         .cancel_idc_work        = qlcnic_82xx_cancel_idc_work,
 362         .napi_add               = qlcnic_82xx_napi_add,
 363         .napi_del               = qlcnic_82xx_napi_del,
 364         .config_ipaddr          = qlcnic_82xx_config_ipaddr,
 365         .clear_legacy_intr      = qlcnic_82xx_clear_legacy_intr,
 366 };
 367
 368 struct qlcnic_nic_template qlcnic_vf_ops = {
 369         .config_bridged_mode    = qlcnicvf_config_bridged_mode,
 370         .config_led             = qlcnicvf_config_led,
 371         .start_firmware         = qlcnicvf_start_firmware
 372 };
 373
 374 static struct qlcnic_hardware_ops qlcnic_hw_ops = {
 375         .read_crb                       = qlcnic_82xx_read_crb,
 376         .write_crb                      = qlcnic_82xx_write_crb,
 377         .read_reg                       = qlcnic_82xx_hw_read_wx_2M,
 378         .write_reg                      = qlcnic_82xx_hw_write_wx_2M,
 379         .get_mac_address                = qlcnic_82xx_get_mac_address,
 380         .setup_intr                     = qlcnic_82xx_setup_intr,
 381         .alloc_mbx_args                 = qlcnic_82xx_alloc_mbx_args,
 382         .mbx_cmd                        = qlcnic_82xx_issue_cmd,
 383         .get_func_no                    = qlcnic_82xx_get_func_no,
 384         .api_lock                       = qlcnic_82xx_api_lock,
 385         .api_unlock                     = qlcnic_82xx_api_unlock,
 386         .add_sysfs                      = qlcnic_82xx_add_sysfs,
 387         .remove_sysfs                   = qlcnic_82xx_remove_sysfs,
 388         .process_lb_rcv_ring_diag       = qlcnic_82xx_process_rcv_ring_diag,
 389         .create_rx_ctx                  = qlcnic_82xx_fw_cmd_create_rx_ctx,
 390         .create_tx_ctx                  = qlcnic_82xx_fw_cmd_create_tx_ctx,
 391         .del_rx_ctx                     = qlcnic_82xx_fw_cmd_del_rx_ctx,
 392         .del_tx_ctx                     = qlcnic_82xx_fw_cmd_del_tx_ctx,
 393         .setup_link_event               = qlcnic_82xx_linkevent_request,
 394         .get_nic_info                   = qlcnic_82xx_get_nic_info,
 395         .get_pci_info                   = qlcnic_82xx_get_pci_info,
 396         .set_nic_info                   = qlcnic_82xx_set_nic_info,
 397         .change_macvlan                 = qlcnic_82xx_sre_macaddr_change,
 398         .napi_enable                    = qlcnic_82xx_napi_enable,
 399         .napi_disable                   = qlcnic_82xx_napi_disable,
 400         .config_intr_coal               = qlcnic_82xx_config_intr_coalesce,
 401         .config_rss                     = qlcnic_82xx_config_rss,
 402         .config_hw_lro                  = qlcnic_82xx_config_hw_lro,
 403         .config_loopback                = qlcnic_82xx_set_lb_mode,
 404         .clear_loopback                 = qlcnic_82xx_clear_lb_mode,
 405         .config_promisc_mode            = qlcnic_82xx_nic_set_promisc,
 406         .change_l2_filter               = qlcnic_82xx_change_filter,
 407         .get_board_info                 = qlcnic_82xx_get_board_info,
 408         .free_mac_list                  = qlcnic_82xx_free_mac_list,
 409 };
 410
 411 int qlcnic_enable_msix(struct qlcnic_adapter *adapter, u32 num_msix)
 412 {
 413         struct pci_dev *pdev = adapter->pdev;
 414         int err = -1, i;
 415         int max_tx_rings, tx_vector;
 416
 417         if (adapter->flags & QLCNIC_TX_INTR_SHARED) {
 418                 max_tx_rings = 0;
 419                 tx_vector = 0;
 420         } else {
 421                 max_tx_rings = adapter->max_drv_tx_rings;
 422                 tx_vector = 1;
 423         }
 424
 425         if (!adapter->msix_entries) {
 426                 adapter->msix_entries = kcalloc(num_msix,
 427                                                 sizeof(struct msix_entry),
 428                                                 GFP_KERNEL);
 429                 if (!adapter->msix_entries)
 430                         return -ENOMEM;
 431         }
 432
 433         adapter->max_sds_rings = 1;
 434         adapter->flags &= ~(QLCNIC_MSI_ENABLED | QLCNIC_MSIX_ENABLED);
 435
 436         if (adapter->ahw->msix_supported) {
 437  enable_msix:
 438                 for (i = 0; i < num_msix; i++)
 439                         adapter->msix_entries[i].entry = i;
 440                 err = pci_enable_msix(pdev, adapter->msix_entries, num_msix);
 441                 if (err == 0) {
 442                         adapter->flags |= QLCNIC_MSIX_ENABLED;
 443                         if (qlcnic_83xx_check(adapter)) {
 444                                 adapter->ahw->num_msix = num_msix;
 445                                 /* subtract mail box and tx ring vectors */
 446                                 adapter->max_sds_rings = num_msix -
 447                                                          max_tx_rings - 1;
 448                         } else {
 449                                 adapter->max_sds_rings = num_msix;
 450                         }
 451                         dev_info(&pdev->dev, "using msi-x interrupts\n");
 452                         return err;
 453                 } else if (err > 0) {
 454                         dev_info(&pdev->dev,
 455                                  "Unable to allocate %d MSI-X interrupt vectors\n",
 456                                  num_msix);
 457                         if (qlcnic_83xx_check(adapter)) {
 458                                 if (err < (QLC_83XX_MINIMUM_VECTOR - tx_vector))
 459                                         return err;
 460                                 err -= (max_tx_rings + 1);
 461                                 num_msix = rounddown_pow_of_two(err);
 462                                 num_msix += (max_tx_rings + 1);
 463                         } else {
 464                                 num_msix = rounddown_pow_of_two(err);
 465                         }
 466
 467                         if (num_msix) {
 468                                 dev_info(&pdev->dev,
 469                                          "Trying to allocate %d MSI-X interrupt vectors\n",
 470                                          num_msix);
 471                                 goto enable_msix;
 472                         }
 473                 } else {
 474                         dev_info(&pdev->dev,
 475                                  "Unable to allocate %d MSI-X interrupt vectors\n",
 476                                  num_msix);
 477                 }
 478         }
 479
 480         return err;
 481 }
 482
 483 static int qlcnic_enable_msi_legacy(struct qlcnic_adapter *adapter)
 484 {
 485         int err = 0;
 486         u32 offset, mask_reg;
 487         const struct qlcnic_legacy_intr_set *legacy_intrp;
 488         struct qlcnic_hardware_context *ahw = adapter->ahw;
 489         struct pci_dev *pdev = adapter->pdev;
 490
 491         if (qlcnic_use_msi && !pci_enable_msi(pdev)) {
 492                 adapter->flags |= QLCNIC_MSI_ENABLED;
 493                 offset = msi_tgt_status[adapter->ahw->pci_func];
 494                 adapter->tgt_status_reg = qlcnic_get_ioaddr(adapter->ahw,
 495                                                             offset);
 496                 dev_info(&pdev->dev, "using msi interrupts\n");
 497                 adapter->msix_entries[0].vector = pdev->irq;
 498                 return err;
 499         }
 500         if (qlcnic_use_msi || qlcnic_use_msi_x)
 501                 return -EOPNOTSUPP;
 502
 503         legacy_intrp = &legacy_intr[adapter->ahw->pci_func];
 504         adapter->ahw->int_vec_bit = legacy_intrp->int_vec_bit;
 505         offset = legacy_intrp->tgt_status_reg;
 506         adapter->tgt_status_reg = qlcnic_get_ioaddr(ahw, offset);
 507         mask_reg = legacy_intrp->tgt_mask_reg;
 508         adapter->tgt_mask_reg = qlcnic_get_ioaddr(ahw, mask_reg);
 509         adapter->isr_int_vec = qlcnic_get_ioaddr(ahw, ISR_INT_VECTOR);
 510         adapter->crb_int_state_reg = qlcnic_get_ioaddr(ahw, ISR_INT_STATE_REG);
 511         dev_info(&pdev->dev, "using legacy interrupts\n");
 512         adapter->msix_entries[0].vector = pdev->irq;
 513         return err;
 514 }
 515
 516 int qlcnic_82xx_setup_intr(struct qlcnic_adapter *adapter, u8 num_intr)
 517 {
 518         int num_msix, err = 0;
 519
 520         if (!num_intr)
 521                 num_intr = QLCNIC_DEF_NUM_STS_DESC_RINGS;
 522
 523         if (adapter->ahw->msix_supported)
 524                 num_msix = rounddown_pow_of_two(min_t(int, num_online_cpus(),
 525                                                 num_intr));
 526         else
 527                 num_msix = 1;
 528
 529         err = qlcnic_enable_msix(adapter, num_msix);
 530         if (err == -ENOMEM || !err)
 531                 return err;
 532
 533         err = qlcnic_enable_msi_legacy(adapter);
 534         if (!err)
 535                 return err;
 536
 537         return -EIO;
 538 }
 539
 540 void qlcnic_teardown_intr(struct qlcnic_adapter *adapter)
 541 {
 542         if (adapter->flags & QLCNIC_MSIX_ENABLED)
 543                 pci_disable_msix(adapter->pdev);
 544         if (adapter->flags & QLCNIC_MSI_ENABLED)
 545                 pci_disable_msi(adapter->pdev);
 546
 547         kfree(adapter->msix_entries);
 548         adapter->msix_entries = NULL;
 549
 550         if (adapter->ahw->intr_tbl) {
 551                 vfree(adapter->ahw->intr_tbl);
 552                 adapter->ahw->intr_tbl = NULL;
 553         }
 554 }
 555
 556 static void qlcnic_cleanup_pci_map(struct qlcnic_hardware_context *ahw)
 557 {
 558         if (ahw->pci_base0 != NULL)
 559                 iounmap(ahw->pci_base0);
 560 }
 561
 562 static int qlcnic_get_act_pci_func(struct qlcnic_adapter *adapter)
 563 {
 564         struct qlcnic_pci_info *pci_info;
 565         int ret;
 566
 567         if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED)) {
 568                 switch (adapter->ahw->port_type) {
 569                 case QLCNIC_GBE:
 570                         adapter->ahw->act_pci_func = QLCNIC_NIU_MAX_GBE_PORTS;
 571                         break;
 572                 case QLCNIC_XGBE:
 573                         adapter->ahw->act_pci_func = QLCNIC_NIU_MAX_XG_PORTS;
 574                         break;
 575                 }
 576                 return 0;
 577         }
 578
 579         if (adapter->ahw->op_mode == QLCNIC_MGMT_FUNC)
 580                 return 0;
 581
 582         pci_info = kcalloc(QLCNIC_MAX_PCI_FUNC, sizeof(*pci_info), GFP_KERNEL);
 583         if (!pci_info)
 584                 return -ENOMEM;
 585
 586         ret = qlcnic_get_pci_info(adapter, pci_info);
 587         kfree(pci_info);
 588         return ret;
 589 }
 590
 591 int qlcnic_init_pci_info(struct qlcnic_adapter *adapter)
 592 {
 593         struct qlcnic_pci_info *pci_info;
 594         int i, ret = 0, j = 0;
 595         u16 act_pci_func;
 596         u8 pfn;
 597
 598         pci_info = kcalloc(QLCNIC_MAX_PCI_FUNC, sizeof(*pci_info), GFP_KERNEL);
 599         if (!pci_info)
 600                 return -ENOMEM;
 601
 602         ret = qlcnic_get_pci_info(adapter, pci_info);
 603         if (ret)
 604                 goto err_pci_info;
 605
 606         act_pci_func = adapter->ahw->act_pci_func;
 607
 608         adapter->npars = kzalloc(sizeof(struct qlcnic_npar_info) *
 609                                  act_pci_func, GFP_KERNEL);
 610         if (!adapter->npars) {
 611                 ret = -ENOMEM;
 612                 goto err_pci_info;
 613         }
 614
 615         adapter->eswitch = kzalloc(sizeof(struct qlcnic_eswitch) *
 616                                 QLCNIC_NIU_MAX_XG_PORTS, GFP_KERNEL);
 617         if (!adapter->eswitch) {
 618                 ret = -ENOMEM;
 619                 goto err_npars;
 620         }
 621
 622         for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
 623                 pfn = pci_info[i].id;
 624
 625                 if (pfn >= QLCNIC_MAX_PCI_FUNC) {
 626                         ret = QL_STATUS_INVALID_PARAM;
 627                         goto err_eswitch;
 628                 }
 629
 630                 if (!pci_info[i].active ||
 631                     (pci_info[i].type != QLCNIC_TYPE_NIC))
 632                         continue;
 633
 634                 adapter->npars[j].pci_func = pfn;
 635                 adapter->npars[j].active = (u8)pci_info[i].active;
 636                 adapter->npars[j].type = (u8)pci_info[i].type;
 637                 adapter->npars[j].phy_port = (u8)pci_info[i].default_port;
 638                 adapter->npars[j].min_bw = pci_info[i].tx_min_bw;
 639                 adapter->npars[j].max_bw = pci_info[i].tx_max_bw;
 640                 j++;
 641         }
 642
 643         for (i = 0; i < QLCNIC_NIU_MAX_XG_PORTS; i++) {
 644                 adapter->eswitch[i].flags |= QLCNIC_SWITCH_ENABLE;
 645                 if (qlcnic_83xx_check(adapter))
 646                         qlcnic_enable_eswitch(adapter, i, 1);
 647         }
 648
 649         kfree(pci_info);
 650         return 0;
 651
 652 err_eswitch:
 653         kfree(adapter->eswitch);
 654         adapter->eswitch = NULL;
 655 err_npars:
 656         kfree(adapter->npars);
 657         adapter->npars = NULL;
 658 err_pci_info:
 659         kfree(pci_info);
 660
 661         return ret;
 662 }
 663
 664 static int
 665 qlcnic_set_function_modes(struct qlcnic_adapter *adapter)
 666 {
 667         u8 id;
 668         int i, ret = 1;
 669         u32 data = QLCNIC_MGMT_FUNC;
 670         struct qlcnic_hardware_context *ahw = adapter->ahw;
 671
 672         ret = qlcnic_api_lock(adapter);
 673         if (ret)
 674                 goto err_lock;
 675
 676         if (qlcnic_config_npars) {
 677                 for (i = 0; i < ahw->act_pci_func; i++) {
 678                         id = adapter->npars[i].pci_func;
 679                         if (id == ahw->pci_func)
 680                                 continue;
 681                         data |= (qlcnic_config_npars &
 682                                         QLC_DEV_SET_DRV(0xf, id));
 683                 }
 684         } else {
 685                 data = QLC_SHARED_REG_RD32(adapter, QLCNIC_DRV_OP_MODE);
 686                 data = (data & ~QLC_DEV_SET_DRV(0xf, ahw->pci_func)) |
 687                         (QLC_DEV_SET_DRV(QLCNIC_MGMT_FUNC,
 688                                          ahw->pci_func));
 689         }
 690         QLC_SHARED_REG_WR32(adapter, QLCNIC_DRV_OP_MODE, data);
 691         qlcnic_api_unlock(adapter);
 692 err_lock:
 693         return ret;
 694 }
 695
 696 static void qlcnic_check_vf(struct qlcnic_adapter *adapter,
 697                             const struct pci_device_id *ent)
 698 {
 699         u32 op_mode, priv_level;
 700
 701         /* Determine FW API version */
 702         adapter->ahw->fw_hal_version = QLC_SHARED_REG_RD32(adapter,
 703                                                            QLCNIC_FW_API);
 704
 705         /* Find PCI function number */
 706         qlcnic_get_func_no(adapter);
 707
 708         /* Determine function privilege level */
 709         op_mode = QLC_SHARED_REG_RD32(adapter, QLCNIC_DRV_OP_MODE);
 710         if (op_mode == QLC_DEV_DRV_DEFAULT)
 711                 priv_level = QLCNIC_MGMT_FUNC;
 712         else
 713                 priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
 714
 715         if (priv_level == QLCNIC_NON_PRIV_FUNC) {
 716                 adapter->ahw->op_mode = QLCNIC_NON_PRIV_FUNC;
 717                 dev_info(&adapter->pdev->dev,
 718                         "HAL Version: %d Non Privileged function\n",
 719                          adapter->ahw->fw_hal_version);
 720                 adapter->nic_ops = &qlcnic_vf_ops;
 721         } else
 722                 adapter->nic_ops = &qlcnic_ops;
 723 }
 724
 725 #define QLCNIC_82XX_BAR0_LENGTH 0x00200000UL
 726 #define QLCNIC_83XX_BAR0_LENGTH 0x4000
 727 static void qlcnic_get_bar_length(u32 dev_id, ulong *bar)
 728 {
 729         switch (dev_id) {
 730         case PCI_DEVICE_ID_QLOGIC_QLE824X:
 731                 *bar = QLCNIC_82XX_BAR0_LENGTH;
 732                 break;
 733         case PCI_DEVICE_ID_QLOGIC_QLE834X:
 734         case PCI_DEVICE_ID_QLOGIC_VF_QLE834X:
 735                 *bar = QLCNIC_83XX_BAR0_LENGTH;
 736                 break;
 737         default:
 738                 *bar = 0;
 739         }
 740 }
 741
 742 static int qlcnic_setup_pci_map(struct pci_dev *pdev,
 743                                 struct qlcnic_hardware_context *ahw)
 744 {
 745         u32 offset;
 746         void __iomem *mem_ptr0 = NULL;
 747         unsigned long mem_len, pci_len0 = 0, bar0_len;
 748
 749         /* remap phys address */
 750         mem_len = pci_resource_len(pdev, 0);
 751
 752         qlcnic_get_bar_length(pdev->device, &bar0_len);
 753         if (mem_len >= bar0_len) {
 754
 755                 mem_ptr0 = pci_ioremap_bar(pdev, 0);
 756                 if (mem_ptr0 == NULL) {
 757                         dev_err(&pdev->dev, "failed to map PCI bar 0\n");
 758                         return -EIO;
 759                 }
 760                 pci_len0 = mem_len;
 761         } else {
 762                 return -EIO;
 763         }
 764
 765         dev_info(&pdev->dev, "%dKB memory map\n", (int)(mem_len >> 10));
 766
 767         ahw->pci_base0 = mem_ptr0;
 768         ahw->pci_len0 = pci_len0;
 769         offset = QLCNIC_PCIX_PS_REG(PCIX_OCM_WINDOW_REG(ahw->pci_func));
 770         qlcnic_get_ioaddr(ahw, offset);
 771
 772         return 0;
 773 }
 774
 775 static void qlcnic_get_board_name(struct qlcnic_adapter *adapter, char *name)
 776 {
 777         struct pci_dev *pdev = adapter->pdev;
 778         int i, found = 0;
 779
 780         for (i = 0; i < NUM_SUPPORTED_BOARDS; ++i) {
 781                 if (qlcnic_boards[i].vendor == pdev->vendor &&
 782                         qlcnic_boards[i].device == pdev->device &&
 783                         qlcnic_boards[i].sub_vendor == pdev->subsystem_vendor &&
 784                         qlcnic_boards[i].sub_device == pdev->subsystem_device) {
 785                                 sprintf(name, "%pM: %s" ,
 786                                         adapter->mac_addr,
 787                                         qlcnic_boards[i].short_name);
 788                                 found = 1;
 789                                 break;
 790                 }
 791
 792         }
 793
 794         if (!found)
 795                 sprintf(name, "%pM Gigabit Ethernet", adapter->mac_addr);
 796 }
 797
 798 static void
 799 qlcnic_check_options(struct qlcnic_adapter *adapter)
 800 {
 801         int err;
 802         u32 fw_major, fw_minor, fw_build, prev_fw_version;
 803         struct pci_dev *pdev = adapter->pdev;
 804         struct qlcnic_hardware_context *ahw = adapter->ahw;
 805         struct qlcnic_fw_dump *fw_dump = &ahw->fw_dump;
 806
 807         prev_fw_version = adapter->fw_version;
 808
 809         fw_major = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_MAJOR);
 810         fw_minor = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_MINOR);
 811         fw_build = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_SUB);
 812
 813         adapter->fw_version = QLCNIC_VERSION_CODE(fw_major, fw_minor, fw_build);
 814
 815         err = qlcnic_get_board_info(adapter);
 816         if (err) {
 817                 dev_err(&pdev->dev, "Error getting board config info.\n");
 818                 return;
 819         }
 820         if (ahw->op_mode != QLCNIC_NON_PRIV_FUNC) {
 821                 if (fw_dump->tmpl_hdr == NULL ||
 822                                 adapter->fw_version > prev_fw_version) {
 823                         if (fw_dump->tmpl_hdr)
 824                                 vfree(fw_dump->tmpl_hdr);
 825                         if (!qlcnic_fw_cmd_get_minidump_temp(adapter))
 826                                 dev_info(&pdev->dev,
 827                                         "Supports FW dump capability\n");
 828                 }
 829         }
 830
 831         dev_info(&pdev->dev, "Driver v%s, firmware v%d.%d.%d\n",
 832                  QLCNIC_LINUX_VERSIONID, fw_major, fw_minor, fw_build);
 833
 834         if (adapter->ahw->port_type == QLCNIC_XGBE) {
 835                 if (adapter->flags & QLCNIC_ESWITCH_ENABLED) {
 836                         adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_VF;
 837                         adapter->max_rxd = MAX_RCV_DESCRIPTORS_VF;
 838                 } else {
 839                         adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_10G;
 840                         adapter->max_rxd = MAX_RCV_DESCRIPTORS_10G;
 841                 }
 842
 843                 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
 844                 adapter->max_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
 845
 846         } else if (adapter->ahw->port_type == QLCNIC_GBE) {
 847                 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_1G;
 848                 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
 849                 adapter->max_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
 850                 adapter->max_rxd = MAX_RCV_DESCRIPTORS_1G;
 851         }
 852
 853         adapter->ahw->msix_supported = !!qlcnic_use_msi_x;
 854
 855         adapter->num_txd = MAX_CMD_DESCRIPTORS;
 856
 857         adapter->max_rds_rings = MAX_RDS_RINGS;
 858 }
 859
 860 static int
 861 qlcnic_initialize_nic(struct qlcnic_adapter *adapter)
 862 {
 863         int err;
 864         struct qlcnic_info nic_info;
 865
 866         memset(&nic_info, 0, sizeof(struct qlcnic_info));
 867         err = qlcnic_get_nic_info(adapter, &nic_info, adapter->ahw->pci_func);
 868         if (err)
 869                 return err;
 870
 871         adapter->ahw->physical_port = (u8)nic_info.phys_port;
 872         adapter->ahw->switch_mode = nic_info.switch_mode;
 873         adapter->ahw->max_tx_ques = nic_info.max_tx_ques;
 874         adapter->ahw->max_rx_ques = nic_info.max_rx_ques;
 875         adapter->ahw->capabilities = nic_info.capabilities;
 876
 877         if (adapter->ahw->capabilities & QLCNIC_FW_CAPABILITY_MORE_CAPS) {
 878                 u32 temp;
 879                 temp = QLCRD32(adapter, CRB_FW_CAPABILITIES_2);
 880                 adapter->ahw->capabilities2 = temp;
 881         }
 882         adapter->ahw->max_mac_filters = nic_info.max_mac_filters;
 883         adapter->ahw->max_mtu = nic_info.max_mtu;
 884
 885         /* Disable NPAR for 83XX */
 886         if (qlcnic_83xx_check(adapter))
 887                 return err;
 888
 889         if (adapter->ahw->capabilities & BIT_6)
 890                 adapter->flags |= QLCNIC_ESWITCH_ENABLED;
 891         else
 892                 adapter->flags &= ~QLCNIC_ESWITCH_ENABLED;
 893
 894         return err;
 895 }
 896
 897 void qlcnic_set_vlan_config(struct qlcnic_adapter *adapter,
 898                             struct qlcnic_esw_func_cfg *esw_cfg)
 899 {
 900         if (esw_cfg->discard_tagged)
 901                 adapter->flags &= ~QLCNIC_TAGGING_ENABLED;
 902         else
 903                 adapter->flags |= QLCNIC_TAGGING_ENABLED;
 904
 905         if (esw_cfg->vlan_id) {
 906                 adapter->rx_pvid = esw_cfg->vlan_id;
 907                 adapter->tx_pvid = esw_cfg->vlan_id;
 908         } else {
 909                 adapter->rx_pvid = 0;
 910                 adapter->tx_pvid = 0;
 911         }
 912 }
 913
 914 static int
 915 qlcnic_vlan_rx_add(struct net_device *netdev, __be16 proto, u16 vid)
 916 {
 917         struct qlcnic_adapter *adapter = netdev_priv(netdev);
 918         int err;
 919
 920         if (qlcnic_sriov_vf_check(adapter)) {
 921                 err = qlcnic_sriov_cfg_vf_guest_vlan(adapter, vid, 1);
 922                 if (err) {
 923                         netdev_err(netdev,
 924                                    "Cannot add VLAN filter for VLAN id %d, err=%d",
 925                                    vid, err);
 926                         return err;
 927                 }
 928         }
 929
 930         set_bit(vid, adapter->vlans);
 931         return 0;
 932 }
 933
 934 static int
 935 qlcnic_vlan_rx_del(struct net_device *netdev, __be16 proto, u16 vid)
 936 {
 937         struct qlcnic_adapter *adapter = netdev_priv(netdev);
 938         int err;
 939
 940         if (qlcnic_sriov_vf_check(adapter)) {
 941                 err = qlcnic_sriov_cfg_vf_guest_vlan(adapter, vid, 0);
 942                 if (err) {
 943                         netdev_err(netdev,
 944                                    "Cannot delete VLAN filter for VLAN id %d, err=%d",
 945                                    vid, err);
 946                         return err;
 947                 }
 948         }
 949
 950         qlcnic_restore_indev_addr(netdev, NETDEV_DOWN);
 951         clear_bit(vid, adapter->vlans);
 952         return 0;
 953 }
 954
 955 void qlcnic_set_eswitch_port_features(struct qlcnic_adapter *adapter,
 956                                       struct qlcnic_esw_func_cfg *esw_cfg)
 957 {
 958         adapter->flags &= ~(QLCNIC_MACSPOOF | QLCNIC_MAC_OVERRIDE_DISABLED |
 959                                 QLCNIC_PROMISC_DISABLED);
 960
 961         if (esw_cfg->mac_anti_spoof)
 962                 adapter->flags |= QLCNIC_MACSPOOF;
 963
 964         if (!esw_cfg->mac_override)
 965                 adapter->flags |= QLCNIC_MAC_OVERRIDE_DISABLED;
 966
 967         if (!esw_cfg->promisc_mode)
 968                 adapter->flags |= QLCNIC_PROMISC_DISABLED;
 969
 970         qlcnic_set_netdev_features(adapter, esw_cfg);
 971 }
 972
 973 int qlcnic_set_eswitch_port_config(struct qlcnic_adapter *adapter)
 974 {
 975         struct qlcnic_esw_func_cfg esw_cfg;
 976
 977         if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
 978                 return 0;
 979
 980         esw_cfg.pci_func = adapter->ahw->pci_func;
 981         if (qlcnic_get_eswitch_port_config(adapter, &esw_cfg))
 982                         return -EIO;
 983         qlcnic_set_vlan_config(adapter, &esw_cfg);
 984         qlcnic_set_eswitch_port_features(adapter, &esw_cfg);
 985
 986         return 0;
 987 }
 988
 989 static void
 990 qlcnic_set_netdev_features(struct qlcnic_adapter *adapter,
 991                 struct qlcnic_esw_func_cfg *esw_cfg)
 992 {
 993         struct net_device *netdev = adapter->netdev;
 994         unsigned long features, vlan_features;
 995
 996         if (qlcnic_83xx_check(adapter))
 997                 return;
 998
 999         features = (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_RXCSUM |
1000                     NETIF_F_IPV6_CSUM | NETIF_F_GRO);
1001         vlan_features = (NETIF_F_SG | NETIF_F_IP_CSUM |
1002                         NETIF_F_IPV6_CSUM);
1003
1004         if (QLCNIC_IS_TSO_CAPABLE(adapter)) {
1005                 features |= (NETIF_F_TSO | NETIF_F_TSO6);
1006                 vlan_features |= (NETIF_F_TSO | NETIF_F_TSO6);
1007         }
1008
1009         if (netdev->features & NETIF_F_LRO)
1010                 features |= NETIF_F_LRO;
1011
1012         if (esw_cfg->offload_flags & BIT_0) {
1013                 netdev->features |= features;
1014                 adapter->rx_csum = 1;
1015                 if (!(esw_cfg->offload_flags & BIT_1)) {
1016                         netdev->features &= ~NETIF_F_TSO;
1017                         features &= ~NETIF_F_TSO;
1018                 }
1019                 if (!(esw_cfg->offload_flags & BIT_2)) {
1020                         netdev->features &= ~NETIF_F_TSO6;
1021                         features &= ~NETIF_F_TSO6;
1022                 }
1023         } else {
1024                 netdev->features &= ~features;
1025                 features &= ~features;
1026                 adapter->rx_csum = 0;
1027         }
1028
1029         netdev->vlan_features = (features & vlan_features);
1030 }
1031
1032 static int
1033 qlcnic_check_eswitch_mode(struct qlcnic_adapter *adapter)
1034 {
1035         u32 op_mode, priv_level;
1036         int err = 0;
1037
1038         err = qlcnic_initialize_nic(adapter);
1039         if (err)
1040                 return err;
1041
1042         if (adapter->flags & QLCNIC_ADAPTER_INITIALIZED)
1043                 return 0;
1044
1045         op_mode = QLC_SHARED_REG_RD32(adapter, QLCNIC_DRV_OP_MODE);
1046         priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
1047
1048         if (op_mode == QLC_DEV_DRV_DEFAULT)
1049                 priv_level = QLCNIC_MGMT_FUNC;
1050         else
1051                 priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
1052
1053         if (adapter->flags & QLCNIC_ESWITCH_ENABLED) {
1054                 if (priv_level == QLCNIC_MGMT_FUNC) {
1055                         adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
1056                         err = qlcnic_init_pci_info(adapter);
1057                         if (err)
1058                                 return err;
1059                         /* Set privilege level for other functions */
1060                         qlcnic_set_function_modes(adapter);
1061                         dev_info(&adapter->pdev->dev,
1062                                 "HAL Version: %d, Management function\n",
1063                                  adapter->ahw->fw_hal_version);
1064                 } else if (priv_level == QLCNIC_PRIV_FUNC) {
1065                         adapter->ahw->op_mode = QLCNIC_PRIV_FUNC;
1066                         dev_info(&adapter->pdev->dev,
1067                                 "HAL Version: %d, Privileged function\n",
1068                                  adapter->ahw->fw_hal_version);
1069                 }
1070         }
1071
1072         adapter->flags |= QLCNIC_ADAPTER_INITIALIZED;
1073
1074         return err;
1075 }
1076
1077 int qlcnic_set_default_offload_settings(struct qlcnic_adapter *adapter)
1078 {
1079         struct qlcnic_esw_func_cfg esw_cfg;
1080         struct qlcnic_npar_info *npar;
1081         u8 i;
1082
1083         if (adapter->need_fw_reset)
1084                 return 0;
1085
1086         for (i = 0; i < adapter->ahw->act_pci_func; i++) {
1087                 memset(&esw_cfg, 0, sizeof(struct qlcnic_esw_func_cfg));
1088                 esw_cfg.pci_func = adapter->npars[i].pci_func;
1089                 esw_cfg.mac_override = BIT_0;
1090                 esw_cfg.promisc_mode = BIT_0;
1091                 if (qlcnic_82xx_check(adapter)) {
1092                         esw_cfg.offload_flags = BIT_0;
1093                         if (QLCNIC_IS_TSO_CAPABLE(adapter))
1094                                 esw_cfg.offload_flags |= (BIT_1 | BIT_2);
1095                 }
1096                 if (qlcnic_config_switch_port(adapter, &esw_cfg))
1097                         return -EIO;
1098                 npar = &adapter->npars[i];
1099                 npar->pvid = esw_cfg.vlan_id;
1100                 npar->mac_override = esw_cfg.mac_override;
1101                 npar->mac_anti_spoof = esw_cfg.mac_anti_spoof;
1102                 npar->discard_tagged = esw_cfg.discard_tagged;
1103                 npar->promisc_mode = esw_cfg.promisc_mode;
1104                 npar->offload_flags = esw_cfg.offload_flags;
1105         }
1106
1107         return 0;
1108 }
1109
1110
1111 static int
1112 qlcnic_reset_eswitch_config(struct qlcnic_adapter *adapter,
1113                         struct qlcnic_npar_info *npar, int pci_func)
1114 {
1115         struct qlcnic_esw_func_cfg esw_cfg;
1116         esw_cfg.op_mode = QLCNIC_PORT_DEFAULTS;
1117         esw_cfg.pci_func = pci_func;
1118         esw_cfg.vlan_id = npar->pvid;
1119         esw_cfg.mac_override = npar->mac_override;
1120         esw_cfg.discard_tagged = npar->discard_tagged;
1121         esw_cfg.mac_anti_spoof = npar->mac_anti_spoof;
1122         esw_cfg.offload_flags = npar->offload_flags;
1123         esw_cfg.promisc_mode = npar->promisc_mode;
1124         if (qlcnic_config_switch_port(adapter, &esw_cfg))
1125                 return -EIO;
1126
1127         esw_cfg.op_mode = QLCNIC_ADD_VLAN;
1128         if (qlcnic_config_switch_port(adapter, &esw_cfg))
1129                 return -EIO;
1130
1131         return 0;
1132 }
1133
1134 int qlcnic_reset_npar_config(struct qlcnic_adapter *adapter)
1135 {
1136         int i, err;
1137         struct qlcnic_npar_info *npar;
1138         struct qlcnic_info nic_info;
1139         u8 pci_func;
1140
1141         if (qlcnic_82xx_check(adapter))
1142                 if (!adapter->need_fw_reset)
1143                         return 0;
1144
1145         /* Set the NPAR config data after FW reset */
1146         for (i = 0; i < adapter->ahw->act_pci_func; i++) {
1147                 npar = &adapter->npars[i];
1148                 pci_func = npar->pci_func;
1149                 memset(&nic_info, 0, sizeof(struct qlcnic_info));
1150                 err = qlcnic_get_nic_info(adapter, &nic_info, pci_func);
1151                 if (err)
1152                         return err;
1153                 nic_info.min_tx_bw = npar->min_bw;
1154                 nic_info.max_tx_bw = npar->max_bw;
1155                 err = qlcnic_set_nic_info(adapter, &nic_info);
1156                 if (err)
1157                         return err;
1158
1159                 if (npar->enable_pm) {
1160                         err = qlcnic_config_port_mirroring(adapter,
1161                                                            npar->dest_npar, 1,
1162                                                            pci_func);
1163                         if (err)
1164                                 return err;
1165                 }
1166                 err = qlcnic_reset_eswitch_config(adapter, npar, pci_func);
1167                 if (err)
1168                         return err;
1169         }
1170         return 0;
1171 }
1172
1173 static int qlcnic_check_npar_opertional(struct qlcnic_adapter *adapter)
1174 {
1175         u8 npar_opt_timeo = QLCNIC_DEV_NPAR_OPER_TIMEO;
1176         u32 npar_state;
1177
1178         if (adapter->ahw->op_mode == QLCNIC_MGMT_FUNC)
1179                 return 0;
1180
1181         npar_state = QLC_SHARED_REG_RD32(adapter,
1182                                          QLCNIC_CRB_DEV_NPAR_STATE);
1183         while (npar_state != QLCNIC_DEV_NPAR_OPER && --npar_opt_timeo) {
1184                 msleep(1000);
1185                 npar_state = QLC_SHARED_REG_RD32(adapter,
1186                                                  QLCNIC_CRB_DEV_NPAR_STATE);
1187         }
1188         if (!npar_opt_timeo) {
1189                 dev_err(&adapter->pdev->dev,
1190                         "Waiting for NPAR state to operational timeout\n");
1191                 return -EIO;
1192         }
1193         return 0;
1194 }
1195
1196 static int
1197 qlcnic_set_mgmt_operations(struct qlcnic_adapter *adapter)
1198 {
1199         int err;
1200
1201         if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED) ||
1202             adapter->ahw->op_mode != QLCNIC_MGMT_FUNC)
1203                 return 0;
1204
1205         err = qlcnic_set_default_offload_settings(adapter);
1206         if (err)
1207                 return err;
1208
1209         err = qlcnic_reset_npar_config(adapter);
1210         if (err)
1211                 return err;
1212
1213         qlcnic_dev_set_npar_ready(adapter);
1214
1215         return err;
1216 }
1217
1218 int qlcnic_82xx_start_firmware(struct qlcnic_adapter *adapter)
1219 {
1220         int err;
1221
1222         err = qlcnic_can_start_firmware(adapter);
1223         if (err < 0)
1224                 return err;
1225         else if (!err)
1226                 goto check_fw_status;
1227
1228         if (qlcnic_load_fw_file)
1229                 qlcnic_request_firmware(adapter);
1230         else {
1231                 err = qlcnic_check_flash_fw_ver(adapter);
1232                 if (err)
1233                         goto err_out;
1234
1235                 adapter->ahw->fw_type = QLCNIC_FLASH_ROMIMAGE;
1236         }
1237
1238         err = qlcnic_need_fw_reset(adapter);
1239         if (err == 0)
1240                 goto check_fw_status;
1241
1242         err = qlcnic_pinit_from_rom(adapter);
1243         if (err)
1244                 goto err_out;
1245
1246         err = qlcnic_load_firmware(adapter);
1247         if (err)
1248                 goto err_out;
1249
1250         qlcnic_release_firmware(adapter);
1251         QLCWR32(adapter, CRB_DRIVER_VERSION, QLCNIC_DRIVER_VERSION);
1252
1253 check_fw_status:
1254         err = qlcnic_check_fw_status(adapter);
1255         if (err)
1256                 goto err_out;
1257
1258         QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_READY);
1259         qlcnic_idc_debug_info(adapter, 1);
1260         err = qlcnic_check_eswitch_mode(adapter);
1261         if (err) {
1262                 dev_err(&adapter->pdev->dev,
1263                         "Memory allocation failed for eswitch\n");
1264                 goto err_out;
1265         }
1266         err = qlcnic_set_mgmt_operations(adapter);
1267         if (err)
1268                 goto err_out;
1269
1270         qlcnic_check_options(adapter);
1271         adapter->need_fw_reset = 0;
1272
1273         qlcnic_release_firmware(adapter);
1274         return 0;
1275
1276 err_out:
1277         QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_FAILED);
1278         dev_err(&adapter->pdev->dev, "Device state set to failed\n");
1279
1280         qlcnic_release_firmware(adapter);
1281         return err;
1282 }
1283
1284 static int
1285 qlcnic_request_irq(struct qlcnic_adapter *adapter)
1286 {
1287         irq_handler_t handler;
1288         struct qlcnic_host_sds_ring *sds_ring;
1289         struct qlcnic_host_tx_ring *tx_ring;
1290         int err, ring;
1291
1292         unsigned long flags = 0;
1293         struct net_device *netdev = adapter->netdev;
1294         struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1295
1296         if (adapter->ahw->diag_test == QLCNIC_INTERRUPT_TEST) {
1297                 if (qlcnic_82xx_check(adapter))
1298                         handler = qlcnic_tmp_intr;
1299                 if (!QLCNIC_IS_MSI_FAMILY(adapter))
1300                         flags |= IRQF_SHARED;
1301
1302         } else {
1303                 if (adapter->flags & QLCNIC_MSIX_ENABLED)
1304                         handler = qlcnic_msix_intr;
1305                 else if (adapter->flags & QLCNIC_MSI_ENABLED)
1306                         handler = qlcnic_msi_intr;
1307                 else {
1308                         flags |= IRQF_SHARED;
1309                         if (qlcnic_82xx_check(adapter))
1310                                 handler = qlcnic_intr;
1311                         else
1312                                 handler = qlcnic_83xx_intr;
1313                 }
1314         }
1315         adapter->irq = netdev->irq;
1316
1317         if (adapter->ahw->diag_test != QLCNIC_LOOPBACK_TEST) {
1318                 if (qlcnic_82xx_check(adapter) ||
1319                     (qlcnic_83xx_check(adapter) &&
1320                      (adapter->flags & QLCNIC_MSIX_ENABLED))) {
1321                         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1322                                 sds_ring = &recv_ctx->sds_rings[ring];
1323                                 snprintf(sds_ring->name, sizeof(int) + IFNAMSIZ,
1324                                          "%s[%d]", netdev->name, ring);
1325                                 err = request_irq(sds_ring->irq, handler, flags,
1326                                                   sds_ring->name, sds_ring);
1327                                 if (err)
1328                                         return err;
1329                         }
1330                 }
1331                 if (qlcnic_83xx_check(adapter) &&
1332                     (adapter->flags & QLCNIC_MSIX_ENABLED) &&
1333                     !(adapter->flags & QLCNIC_TX_INTR_SHARED)) {
1334                         handler = qlcnic_msix_tx_intr;
1335                         for (ring = 0; ring < adapter->max_drv_tx_rings;
1336                              ring++) {
1337                                 tx_ring = &adapter->tx_ring[ring];
1338                                 snprintf(tx_ring->name, sizeof(int) + IFNAMSIZ,
1339                                          "%s[%d]", netdev->name,
1340                                          adapter->max_sds_rings + ring);
1341                                 err = request_irq(tx_ring->irq, handler, flags,
1342                                                   tx_ring->name, tx_ring);
1343                                 if (err)
1344                                         return err;
1345                         }
1346                 }
1347         }
1348         return 0;
1349 }
1350
1351 static void
1352 qlcnic_free_irq(struct qlcnic_adapter *adapter)
1353 {
1354         int ring;
1355         struct qlcnic_host_sds_ring *sds_ring;
1356         struct qlcnic_host_tx_ring *tx_ring;
1357
1358         struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1359
1360         if (adapter->ahw->diag_test != QLCNIC_LOOPBACK_TEST) {
1361                 if (qlcnic_82xx_check(adapter) ||
1362                     (qlcnic_83xx_check(adapter) &&
1363                      (adapter->flags & QLCNIC_MSIX_ENABLED))) {
1364                         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1365                                 sds_ring = &recv_ctx->sds_rings[ring];
1366                                 free_irq(sds_ring->irq, sds_ring);
1367                         }
1368                 }
1369                 if (qlcnic_83xx_check(adapter) &&
1370                     !(adapter->flags & QLCNIC_TX_INTR_SHARED)) {
1371                         for (ring = 0; ring < adapter->max_drv_tx_rings;
1372                              ring++) {
1373                                 tx_ring = &adapter->tx_ring[ring];
1374                                 if (tx_ring->irq)
1375                                         free_irq(tx_ring->irq, tx_ring);
1376                         }
1377                 }
1378         }
1379 }
1380
1381 static void qlcnic_get_lro_mss_capability(struct qlcnic_adapter *adapter)
1382 {
1383         u32 capab = 0;
1384
1385         if (qlcnic_82xx_check(adapter)) {
1386                 if (adapter->ahw->capabilities2 &
1387                     QLCNIC_FW_CAPABILITY_2_LRO_MAX_TCP_SEG)
1388                         adapter->flags |= QLCNIC_FW_LRO_MSS_CAP;
1389         } else {
1390                 capab = adapter->ahw->capabilities;
1391                 if (QLC_83XX_GET_FW_LRO_MSS_CAPABILITY(capab))
1392                         adapter->flags |= QLCNIC_FW_LRO_MSS_CAP;
1393         }
1394 }
1395
1396 int __qlcnic_up(struct qlcnic_adapter *adapter, struct net_device *netdev)
1397 {
1398         int ring;
1399         struct qlcnic_host_rds_ring *rds_ring;
1400
1401         if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1402                 return -EIO;
1403
1404         if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
1405                 return 0;
1406         if (qlcnic_set_eswitch_port_config(adapter))
1407                 return -EIO;
1408         qlcnic_get_lro_mss_capability(adapter);
1409
1410         if (qlcnic_fw_create_ctx(adapter))
1411                 return -EIO;
1412
1413         for (ring = 0; ring < adapter->max_rds_rings; ring++) {
1414                 rds_ring = &adapter->recv_ctx->rds_rings[ring];
1415                 qlcnic_post_rx_buffers(adapter, rds_ring, ring);
1416         }
1417
1418         qlcnic_set_multi(netdev);
1419         qlcnic_fw_cmd_set_mtu(adapter, netdev->mtu);
1420
1421         adapter->ahw->linkup = 0;
1422
1423         if (adapter->max_sds_rings > 1)
1424                 qlcnic_config_rss(adapter, 1);
1425
1426         qlcnic_config_intr_coalesce(adapter);
1427
1428         if (netdev->features & NETIF_F_LRO)
1429                 qlcnic_config_hw_lro(adapter, QLCNIC_LRO_ENABLED);
1430
1431         qlcnic_napi_enable(adapter);
1432
1433         qlcnic_linkevent_request(adapter, 1);
1434
1435         adapter->ahw->reset_context = 0;
1436         set_bit(__QLCNIC_DEV_UP, &adapter->state);
1437         return 0;
1438 }
1439
1440 int qlcnic_up(struct qlcnic_adapter *adapter, struct net_device *netdev)
1441 {
1442         int err = 0;
1443
1444         rtnl_lock();
1445         if (netif_running(netdev))
1446                 err = __qlcnic_up(adapter, netdev);
1447         rtnl_unlock();
1448
1449         return err;
1450 }
1451
1452 void __qlcnic_down(struct qlcnic_adapter *adapter, struct net_device *netdev)
1453 {
1454         if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1455                 return;
1456
1457         if (!test_and_clear_bit(__QLCNIC_DEV_UP, &adapter->state))
1458                 return;
1459
1460         if (qlcnic_sriov_vf_check(adapter))
1461                 qlcnic_sriov_cleanup_async_list(&adapter->ahw->sriov->bc);
1462         smp_mb();
1463         spin_lock(&adapter->tx_clean_lock);
1464         netif_carrier_off(netdev);
1465         adapter->ahw->linkup = 0;
1466         netif_tx_disable(netdev);
1467
1468         qlcnic_free_mac_list(adapter);
1469
1470         if (adapter->fhash.fnum)
1471                 qlcnic_delete_lb_filters(adapter);
1472
1473         qlcnic_nic_set_promisc(adapter, QLCNIC_NIU_NON_PROMISC_MODE);
1474
1475         qlcnic_napi_disable(adapter);
1476
1477         qlcnic_fw_destroy_ctx(adapter);
1478         adapter->flags &= ~QLCNIC_FW_LRO_MSS_CAP;
1479
1480         qlcnic_reset_rx_buffers_list(adapter);
1481         qlcnic_release_tx_buffers(adapter);
1482         spin_unlock(&adapter->tx_clean_lock);
1483 }
1484
1485 /* Usage: During suspend and firmware recovery module */
1486
1487 void qlcnic_down(struct qlcnic_adapter *adapter, struct net_device *netdev)
1488 {
1489         rtnl_lock();
1490         if (netif_running(netdev))
1491                 __qlcnic_down(adapter, netdev);
1492         rtnl_unlock();
1493
1494 }
1495
1496 int
1497 qlcnic_attach(struct qlcnic_adapter *adapter)
1498 {
1499         struct net_device *netdev = adapter->netdev;
1500         struct pci_dev *pdev = adapter->pdev;
1501         int err;
1502
1503         if (adapter->is_up == QLCNIC_ADAPTER_UP_MAGIC)
1504                 return 0;
1505
1506         err = qlcnic_napi_add(adapter, netdev);
1507         if (err)
1508                 return err;
1509
1510         err = qlcnic_alloc_sw_resources(adapter);
1511         if (err) {
1512                 dev_err(&pdev->dev, "Error in setting sw resources\n");
1513                 goto err_out_napi_del;
1514         }
1515
1516         err = qlcnic_alloc_hw_resources(adapter);
1517         if (err) {
1518                 dev_err(&pdev->dev, "Error in setting hw resources\n");
1519                 goto err_out_free_sw;
1520         }
1521
1522         err = qlcnic_request_irq(adapter);
1523         if (err) {
1524                 dev_err(&pdev->dev, "failed to setup interrupt\n");
1525                 goto err_out_free_hw;
1526         }
1527
1528         qlcnic_create_sysfs_entries(adapter);
1529
1530         adapter->is_up = QLCNIC_ADAPTER_UP_MAGIC;
1531         return 0;
1532
1533 err_out_free_hw:
1534         qlcnic_free_hw_resources(adapter);
1535 err_out_free_sw:
1536         qlcnic_free_sw_resources(adapter);
1537 err_out_napi_del:
1538         qlcnic_napi_del(adapter);
1539         return err;
1540 }
1541
1542 void qlcnic_detach(struct qlcnic_adapter *adapter)
1543 {
1544         if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1545                 return;
1546
1547         qlcnic_remove_sysfs_entries(adapter);
1548
1549         qlcnic_free_hw_resources(adapter);
1550         qlcnic_release_rx_buffers(adapter);
1551         qlcnic_free_irq(adapter);
1552         qlcnic_napi_del(adapter);
1553         qlcnic_free_sw_resources(adapter);
1554
1555         adapter->is_up = 0;
1556 }
1557
1558 void qlcnic_diag_free_res(struct net_device *netdev, int max_sds_rings)
1559 {
1560         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1561         struct qlcnic_host_sds_ring *sds_ring;
1562         int ring;
1563
1564         clear_bit(__QLCNIC_DEV_UP, &adapter->state);
1565         if (adapter->ahw->diag_test == QLCNIC_INTERRUPT_TEST) {
1566                 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1567                         sds_ring = &adapter->recv_ctx->sds_rings[ring];
1568                         qlcnic_disable_int(sds_ring);
1569                 }
1570         }
1571
1572         qlcnic_fw_destroy_ctx(adapter);
1573
1574         qlcnic_detach(adapter);
1575
1576         adapter->ahw->diag_test = 0;
1577         adapter->max_sds_rings = max_sds_rings;
1578
1579         if (qlcnic_attach(adapter))
1580                 goto out;
1581
1582         if (netif_running(netdev))
1583                 __qlcnic_up(adapter, netdev);
1584 out:
1585         netif_device_attach(netdev);
1586 }
1587
1588 static int qlcnic_alloc_adapter_resources(struct qlcnic_adapter *adapter)
1589 {
1590         int err = 0;
1591         adapter->recv_ctx = kzalloc(sizeof(struct qlcnic_recv_context),
1592                                 GFP_KERNEL);
1593         if (!adapter->recv_ctx) {
1594                 err = -ENOMEM;
1595                 goto err_out;
1596         }
1597         /* Initialize interrupt coalesce parameters */
1598         adapter->ahw->coal.flag = QLCNIC_INTR_DEFAULT;
1599         adapter->ahw->coal.rx_time_us = QLCNIC_DEFAULT_INTR_COALESCE_RX_TIME_US;
1600         adapter->ahw->coal.rx_packets = QLCNIC_DEFAULT_INTR_COALESCE_RX_PACKETS;
1601         /* clear stats */
1602         memset(&adapter->stats, 0, sizeof(adapter->stats));
1603 err_out:
1604         return err;
1605 }
1606
1607 static void qlcnic_free_adapter_resources(struct qlcnic_adapter *adapter)
1608 {
1609         kfree(adapter->recv_ctx);
1610         adapter->recv_ctx = NULL;
1611
1612         if (adapter->ahw->fw_dump.tmpl_hdr) {
1613                 vfree(adapter->ahw->fw_dump.tmpl_hdr);
1614                 adapter->ahw->fw_dump.tmpl_hdr = NULL;
1615         }
1616
1617         kfree(adapter->ahw->reset.buff);
1618         adapter->ahw->fw_dump.tmpl_hdr = NULL;
1619 }
1620
1621 int qlcnic_diag_alloc_res(struct net_device *netdev, int test)
1622 {
1623         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1624         struct qlcnic_host_sds_ring *sds_ring;
1625         struct qlcnic_host_rds_ring *rds_ring;
1626         int ring;
1627         int ret;
1628
1629         netif_device_detach(netdev);
1630
1631         if (netif_running(netdev))
1632                 __qlcnic_down(adapter, netdev);
1633
1634         qlcnic_detach(adapter);
1635
1636         adapter->max_sds_rings = 1;
1637         adapter->ahw->diag_test = test;
1638         adapter->ahw->linkup = 0;
1639
1640         ret = qlcnic_attach(adapter);
1641         if (ret) {
1642                 netif_device_attach(netdev);
1643                 return ret;
1644         }
1645
1646         ret = qlcnic_fw_create_ctx(adapter);
1647         if (ret) {
1648                 qlcnic_detach(adapter);
1649                 netif_device_attach(netdev);
1650                 return ret;
1651         }
1652
1653         for (ring = 0; ring < adapter->max_rds_rings; ring++) {
1654                 rds_ring = &adapter->recv_ctx->rds_rings[ring];
1655                 qlcnic_post_rx_buffers(adapter, rds_ring, ring);
1656         }
1657
1658         if (adapter->ahw->diag_test == QLCNIC_INTERRUPT_TEST) {
1659                 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1660                         sds_ring = &adapter->recv_ctx->sds_rings[ring];
1661                         qlcnic_enable_int(sds_ring);
1662                 }
1663         }
1664
1665         if (adapter->ahw->diag_test == QLCNIC_LOOPBACK_TEST) {
1666                 adapter->ahw->loopback_state = 0;
1667                 qlcnic_linkevent_request(adapter, 1);
1668         }
1669
1670         set_bit(__QLCNIC_DEV_UP, &adapter->state);
1671
1672         return 0;
1673 }
1674
1675 /* Reset context in hardware only */
1676 static int
1677 qlcnic_reset_hw_context(struct qlcnic_adapter *adapter)
1678 {
1679         struct net_device *netdev = adapter->netdev;
1680
1681         if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
1682                 return -EBUSY;
1683
1684         netif_device_detach(netdev);
1685
1686         qlcnic_down(adapter, netdev);
1687
1688         qlcnic_up(adapter, netdev);
1689
1690         netif_device_attach(netdev);
1691
1692         clear_bit(__QLCNIC_RESETTING, &adapter->state);
1693         dev_err(&adapter->pdev->dev, "%s:\n", __func__);
1694         return 0;
1695 }
1696
1697 int
1698 qlcnic_reset_context(struct qlcnic_adapter *adapter)
1699 {
1700         int err = 0;
1701         struct net_device *netdev = adapter->netdev;
1702
1703         if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
1704                 return -EBUSY;
1705
1706         if (adapter->is_up == QLCNIC_ADAPTER_UP_MAGIC) {
1707
1708                 netif_device_detach(netdev);
1709
1710                 if (netif_running(netdev))
1711                         __qlcnic_down(adapter, netdev);
1712
1713                 qlcnic_detach(adapter);
1714
1715                 if (netif_running(netdev)) {
1716                         err = qlcnic_attach(adapter);
1717                         if (!err) {
1718                                 __qlcnic_up(adapter, netdev);
1719                                 qlcnic_restore_indev_addr(netdev, NETDEV_UP);
1720                         }
1721                 }
1722
1723                 netif_device_attach(netdev);
1724         }
1725
1726         clear_bit(__QLCNIC_RESETTING, &adapter->state);
1727         return err;
1728 }
1729
1730 int
1731 qlcnic_setup_netdev(struct qlcnic_adapter *adapter, struct net_device *netdev,
1732                     int pci_using_dac)
1733 {
1734         int err;
1735         struct pci_dev *pdev = adapter->pdev;
1736
1737         adapter->rx_csum = 1;
1738         adapter->ahw->mc_enabled = 0;
1739         adapter->ahw->max_mc_count = QLCNIC_MAX_MC_COUNT;
1740
1741         netdev->netdev_ops         = &qlcnic_netdev_ops;
1742         netdev->watchdog_timeo     = QLCNIC_WATCHDOG_TIMEOUTVALUE * HZ;
1743
1744         qlcnic_change_mtu(netdev, netdev->mtu);
1745
1746         if (qlcnic_sriov_vf_check(adapter))
1747                 SET_ETHTOOL_OPS(netdev, &qlcnic_sriov_vf_ethtool_ops);
1748         else
1749                 SET_ETHTOOL_OPS(netdev, &qlcnic_ethtool_ops);
1750
1751         netdev->features |= (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_RXCSUM |
1752                              NETIF_F_IPV6_CSUM | NETIF_F_GRO |
1753                              NETIF_F_HW_VLAN_CTAG_RX);
1754         netdev->vlan_features |= (NETIF_F_SG | NETIF_F_IP_CSUM |
1755                                   NETIF_F_IPV6_CSUM);
1756
1757         if (QLCNIC_IS_TSO_CAPABLE(adapter)) {
1758                 netdev->features |= (NETIF_F_TSO | NETIF_F_TSO6);
1759                 netdev->vlan_features |= (NETIF_F_TSO | NETIF_F_TSO6);
1760         }
1761
1762         if (pci_using_dac) {
1763                 netdev->features |= NETIF_F_HIGHDMA;
1764                 netdev->vlan_features |= NETIF_F_HIGHDMA;
1765         }
1766
1767         if (qlcnic_vlan_tx_check(adapter))
1768                 netdev->features |= (NETIF_F_HW_VLAN_CTAG_TX);
1769
1770         if (qlcnic_sriov_vf_check(adapter))
1771                 netdev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
1772
1773         if (adapter->ahw->capabilities & QLCNIC_FW_CAPABILITY_HW_LRO)
1774                 netdev->features |= NETIF_F_LRO;
1775
1776         netdev->hw_features = netdev->features;
1777         netdev->irq = adapter->msix_entries[0].vector;
1778
1779         err = register_netdev(netdev);
1780         if (err) {
1781                 dev_err(&pdev->dev, "failed to register net device\n");
1782                 return err;
1783         }
1784
1785         return 0;
1786 }
1787
1788 static int qlcnic_set_dma_mask(struct pci_dev *pdev, int *pci_using_dac)
1789 {
1790         if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) &&
1791                         !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
1792                 *pci_using_dac = 1;
1793         else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) &&
1794                         !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)))
1795                 *pci_using_dac = 0;
1796         else {
1797                 dev_err(&pdev->dev, "Unable to set DMA mask, aborting\n");
1798                 return -EIO;
1799         }
1800
1801         return 0;
1802 }
1803
1804 void qlcnic_free_tx_rings(struct qlcnic_adapter *adapter)
1805 {
1806         int ring;
1807         struct qlcnic_host_tx_ring *tx_ring;
1808
1809         for (ring = 0; ring < adapter->max_drv_tx_rings; ring++) {
1810                 tx_ring = &adapter->tx_ring[ring];
1811                 if (tx_ring && tx_ring->cmd_buf_arr != NULL) {
1812                         vfree(tx_ring->cmd_buf_arr);
1813                         tx_ring->cmd_buf_arr = NULL;
1814                 }
1815         }
1816         if (adapter->tx_ring != NULL)
1817                 kfree(adapter->tx_ring);
1818 }
1819
1820 int qlcnic_alloc_tx_rings(struct qlcnic_adapter *adapter,
1821                           struct net_device *netdev)
1822 {
1823         int ring, vector, index;
1824         struct qlcnic_host_tx_ring *tx_ring;
1825         struct qlcnic_cmd_buffer *cmd_buf_arr;
1826
1827         tx_ring = kcalloc(adapter->max_drv_tx_rings,
1828                           sizeof(struct qlcnic_host_tx_ring), GFP_KERNEL);
1829         if (tx_ring == NULL)
1830                 return -ENOMEM;
1831
1832         adapter->tx_ring = tx_ring;
1833
1834         for (ring = 0; ring < adapter->max_drv_tx_rings; ring++) {
1835                 tx_ring = &adapter->tx_ring[ring];
1836                 tx_ring->num_desc = adapter->num_txd;
1837                 tx_ring->txq = netdev_get_tx_queue(netdev, ring);
1838                 cmd_buf_arr = vzalloc(TX_BUFF_RINGSIZE(tx_ring));
1839                 if (cmd_buf_arr == NULL) {
1840                         qlcnic_free_tx_rings(adapter);
1841                         return -ENOMEM;
1842                 }
1843                 memset(cmd_buf_arr, 0, TX_BUFF_RINGSIZE(tx_ring));
1844                 tx_ring->cmd_buf_arr = cmd_buf_arr;
1845         }
1846
1847         if (qlcnic_83xx_check(adapter)) {
1848                 for (ring = 0; ring < adapter->max_drv_tx_rings; ring++) {
1849                         tx_ring = &adapter->tx_ring[ring];
1850                         tx_ring->adapter = adapter;
1851                         if (adapter->flags & QLCNIC_MSIX_ENABLED) {
1852                                 index = adapter->max_sds_rings + ring;
1853                                 vector = adapter->msix_entries[index].vector;
1854                                 tx_ring->irq = vector;
1855                         }
1856                 }
1857         }
1858         return 0;
1859 }
1860
1861 static int
1862 qlcnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1863 {
1864         struct net_device *netdev = NULL;
1865         struct qlcnic_adapter *adapter = NULL;
1866         struct qlcnic_hardware_context *ahw;
1867         int err, pci_using_dac = -1;
1868         u32 capab2;
1869         char board_name[QLCNIC_MAX_BOARD_NAME_LEN + 19]; /* MAC + ": " + name */
1870
1871         if (pdev->is_virtfn)
1872                 return -ENODEV;
1873
1874         err = pci_enable_device(pdev);
1875         if (err)
1876                 return err;
1877
1878         if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
1879                 err = -ENODEV;
1880                 goto err_out_disable_pdev;
1881         }
1882
1883         err = qlcnic_set_dma_mask(pdev, &pci_using_dac);
1884         if (err)
1885                 goto err_out_disable_pdev;
1886
1887         err = pci_request_regions(pdev, qlcnic_driver_name);
1888         if (err)
1889                 goto err_out_disable_pdev;
1890
1891         pci_set_master(pdev);
1892         pci_enable_pcie_error_reporting(pdev);
1893
1894         ahw = kzalloc(sizeof(struct qlcnic_hardware_context), GFP_KERNEL);
1895         if (!ahw)
1896                 goto err_out_free_res;
1897
1898         switch (ent->device) {
1899         case PCI_DEVICE_ID_QLOGIC_QLE824X:
1900                 ahw->hw_ops = &qlcnic_hw_ops;
1901                 ahw->reg_tbl = (u32 *) qlcnic_reg_tbl;
1902                 break;
1903         case PCI_DEVICE_ID_QLOGIC_QLE834X:
1904                 qlcnic_83xx_register_map(ahw);
1905                 break;
1906         case PCI_DEVICE_ID_QLOGIC_VF_QLE834X:
1907                 qlcnic_sriov_vf_register_map(ahw);
1908                 break;
1909         default:
1910                 goto err_out_free_hw_res;
1911         }
1912
1913         err = qlcnic_setup_pci_map(pdev, ahw);
1914         if (err)
1915                 goto err_out_free_hw_res;
1916
1917         netdev = alloc_etherdev(sizeof(struct qlcnic_adapter));
1918         if (!netdev) {
1919                 err = -ENOMEM;
1920                 goto err_out_iounmap;
1921         }
1922
1923         SET_NETDEV_DEV(netdev, &pdev->dev);
1924
1925         adapter = netdev_priv(netdev);
1926         adapter->netdev  = netdev;
1927         adapter->pdev    = pdev;
1928         adapter->ahw = ahw;
1929
1930         adapter->qlcnic_wq = create_singlethread_workqueue("qlcnic");
1931         if (adapter->qlcnic_wq == NULL) {
1932                 dev_err(&pdev->dev, "Failed to create workqueue\n");
1933                 goto err_out_free_netdev;
1934         }
1935
1936         err = qlcnic_alloc_adapter_resources(adapter);
1937         if (err)
1938                 goto err_out_free_netdev;
1939
1940         adapter->dev_rst_time = jiffies;
1941         adapter->ahw->revision_id = pdev->revision;
1942         if (qlcnic_mac_learn == FDB_MAC_LEARN)
1943                 adapter->fdb_mac_learn = true;
1944         else if (qlcnic_mac_learn == DRV_MAC_LEARN)
1945                 adapter->drv_mac_learn = true;
1946         adapter->max_drv_tx_rings = 1;
1947
1948         rwlock_init(&adapter->ahw->crb_lock);
1949         mutex_init(&adapter->ahw->mem_lock);
1950
1951         spin_lock_init(&adapter->tx_clean_lock);
1952         INIT_LIST_HEAD(&adapter->mac_list);
1953
1954         if (qlcnic_82xx_check(adapter)) {
1955                 qlcnic_check_vf(adapter, ent);
1956                 adapter->portnum = adapter->ahw->pci_func;
1957                 err = qlcnic_start_firmware(adapter);
1958                 if (err) {
1959                         dev_err(&pdev->dev, "Loading fw failed.Please Reboot\n");
1960                         goto err_out_free_hw;
1961                 }
1962
1963                 err = qlcnic_setup_idc_param(adapter);
1964                 if (err)
1965                         goto err_out_free_hw;
1966
1967                 adapter->flags |= QLCNIC_NEED_FLR;
1968         } else if (qlcnic_83xx_check(adapter)) {
1969                 qlcnic_83xx_check_vf(adapter, ent);
1970                 adapter->portnum = adapter->ahw->pci_func;
1971                 err = qlcnic_83xx_init(adapter, pci_using_dac);
1972                 if (err) {
1973                         dev_err(&pdev->dev, "%s: failed\n", __func__);
1974                         goto err_out_free_hw;
1975                 }
1976                 if (qlcnic_sriov_vf_check(adapter))
1977                         return 0;
1978         } else {
1979                 dev_err(&pdev->dev,
1980                         "%s: failed. Please Reboot\n", __func__);
1981                 goto err_out_free_hw;
1982         }
1983
1984         if (qlcnic_read_mac_addr(adapter))
1985                 dev_warn(&pdev->dev, "failed to read mac addr\n");
1986
1987         if (adapter->portnum == 0) {
1988                 qlcnic_get_board_name(adapter, board_name);
1989
1990                 pr_info("%s: %s Board Chip rev 0x%x\n",
1991                         module_name(THIS_MODULE),
1992                         board_name, adapter->ahw->revision_id);
1993         }
1994
1995         if (qlcnic_83xx_check(adapter) && !qlcnic_use_msi_x &&
1996             !!qlcnic_use_msi)
1997                 dev_warn(&pdev->dev,
1998                          "83xx adapter do not support MSI interrupts\n");
1999
2000         err = qlcnic_setup_intr(adapter, 0);
2001         if (err) {
2002                 dev_err(&pdev->dev, "Failed to setup interrupt\n");
2003                 goto err_out_disable_msi;
2004         }
2005
2006         if (qlcnic_83xx_check(adapter)) {
2007                 err = qlcnic_83xx_setup_mbx_intr(adapter);
2008                 if (err)
2009                         goto err_out_disable_msi;
2010         }
2011
2012         err = qlcnic_setup_netdev(adapter, netdev, pci_using_dac);
2013         if (err)
2014                 goto err_out_disable_mbx_intr;
2015
2016         if (qlcnic_82xx_check(adapter)) {
2017                 if (ahw->capabilities & QLCNIC_FW_CAPABILITY_MORE_CAPS) {
2018                         capab2 = QLCRD32(adapter, CRB_FW_CAPABILITIES_2);
2019                         if (capab2 & QLCNIC_FW_CAPABILITY_2_OCBB)
2020                                 qlcnic_fw_cmd_set_drv_version(adapter);
2021                 }
2022         }
2023
2024         pci_set_drvdata(pdev, adapter);
2025
2026         if (qlcnic_82xx_check(adapter))
2027                 qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
2028                                      FW_POLL_DELAY);
2029
2030         switch (adapter->ahw->port_type) {
2031         case QLCNIC_GBE:
2032                 dev_info(&adapter->pdev->dev, "%s: GbE port initialized\n",
2033                                 adapter->netdev->name);
2034                 break;
2035         case QLCNIC_XGBE:
2036                 dev_info(&adapter->pdev->dev, "%s: XGbE port initialized\n",
2037                                 adapter->netdev->name);
2038                 break;
2039         }
2040
2041         if (qlcnic_get_act_pci_func(adapter))
2042                 goto err_out_disable_mbx_intr;
2043
2044         if (adapter->drv_mac_learn)
2045                 qlcnic_alloc_lb_filters_mem(adapter);
2046
2047         qlcnic_add_sysfs(adapter);
2048
2049         return 0;
2050
2051 err_out_disable_mbx_intr:
2052         if (qlcnic_83xx_check(adapter))
2053                 qlcnic_83xx_free_mbx_intr(adapter);
2054
2055 err_out_disable_msi:
2056         qlcnic_teardown_intr(adapter);
2057         qlcnic_cancel_idc_work(adapter);
2058         qlcnic_clr_all_drv_state(adapter, 0);
2059
2060 err_out_free_hw:
2061         qlcnic_free_adapter_resources(adapter);
2062
2063 err_out_free_netdev:
2064         free_netdev(netdev);
2065
2066 err_out_iounmap:
2067         qlcnic_cleanup_pci_map(ahw);
2068
2069 err_out_free_hw_res:
2070         kfree(ahw);
2071
2072 err_out_free_res:
2073         pci_release_regions(pdev);
2074
2075 err_out_disable_pdev:
2076         pci_set_drvdata(pdev, NULL);
2077         pci_disable_device(pdev);
2078         return err;
2079 }
2080
2081 static void qlcnic_remove(struct pci_dev *pdev)
2082 {
2083         struct qlcnic_adapter *adapter;
2084         struct net_device *netdev;
2085         struct qlcnic_hardware_context *ahw;
2086
2087         adapter = pci_get_drvdata(pdev);
2088         if (adapter == NULL)
2089                 return;
2090
2091         netdev = adapter->netdev;
2092         qlcnic_sriov_pf_disable(adapter);
2093
2094         qlcnic_cancel_idc_work(adapter);
2095         ahw = adapter->ahw;
2096
2097         unregister_netdev(netdev);
2098         qlcnic_sriov_cleanup(adapter);
2099
2100         if (qlcnic_83xx_check(adapter)) {
2101                 qlcnic_83xx_free_mbx_intr(adapter);
2102                 qlcnic_83xx_register_nic_idc_func(adapter, 0);
2103                 cancel_delayed_work_sync(&adapter->idc_aen_work);
2104         }
2105
2106         qlcnic_detach(adapter);
2107
2108         if (adapter->npars != NULL)
2109                 kfree(adapter->npars);
2110         if (adapter->eswitch != NULL)
2111                 kfree(adapter->eswitch);
2112
2113         if (qlcnic_82xx_check(adapter))
2114                 qlcnic_clr_all_drv_state(adapter, 0);
2115
2116         clear_bit(__QLCNIC_RESETTING, &adapter->state);
2117
2118         qlcnic_free_lb_filters_mem(adapter);
2119
2120         qlcnic_teardown_intr(adapter);
2121
2122         qlcnic_remove_sysfs(adapter);
2123
2124         qlcnic_cleanup_pci_map(adapter->ahw);
2125
2126         qlcnic_release_firmware(adapter);
2127
2128         pci_disable_pcie_error_reporting(pdev);
2129         pci_release_regions(pdev);
2130         pci_disable_device(pdev);
2131         pci_set_drvdata(pdev, NULL);
2132
2133         if (adapter->qlcnic_wq) {
2134                 destroy_workqueue(adapter->qlcnic_wq);
2135                 adapter->qlcnic_wq = NULL;
2136         }
2137         qlcnic_free_adapter_resources(adapter);
2138         kfree(ahw);
2139         free_netdev(netdev);
2140 }
2141 static int __qlcnic_shutdown(struct pci_dev *pdev)
2142 {
2143         struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
2144         struct net_device *netdev = adapter->netdev;
2145         int retval;
2146
2147         netif_device_detach(netdev);
2148
2149         qlcnic_cancel_idc_work(adapter);
2150
2151         if (netif_running(netdev))
2152                 qlcnic_down(adapter, netdev);
2153
2154         qlcnic_sriov_cleanup(adapter);
2155         if (qlcnic_82xx_check(adapter))
2156                 qlcnic_clr_all_drv_state(adapter, 0);
2157
2158         clear_bit(__QLCNIC_RESETTING, &adapter->state);
2159
2160         retval = pci_save_state(pdev);
2161         if (retval)
2162                 return retval;
2163         if (qlcnic_82xx_check(adapter)) {
2164                 if (qlcnic_wol_supported(adapter)) {
2165                         pci_enable_wake(pdev, PCI_D3cold, 1);
2166                         pci_enable_wake(pdev, PCI_D3hot, 1);
2167                 }
2168         }
2169
2170         return 0;
2171 }
2172
2173 static void qlcnic_shutdown(struct pci_dev *pdev)
2174 {
2175         if (__qlcnic_shutdown(pdev))
2176                 return;
2177
2178         pci_disable_device(pdev);
2179 }
2180
2181 #ifdef CONFIG_PM
2182 static int
2183 qlcnic_suspend(struct pci_dev *pdev, pm_message_t state)
2184 {
2185         int retval;
2186
2187         retval = __qlcnic_shutdown(pdev);
2188         if (retval)
2189                 return retval;
2190
2191         pci_set_power_state(pdev, pci_choose_state(pdev, state));
2192         return 0;
2193 }
2194
2195 static int
2196 qlcnic_resume(struct pci_dev *pdev)
2197 {
2198         struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
2199         struct net_device *netdev = adapter->netdev;
2200         int err;
2201
2202         err = pci_enable_device(pdev);
2203         if (err)
2204                 return err;
2205
2206         pci_set_power_state(pdev, PCI_D0);
2207         pci_set_master(pdev);
2208         pci_restore_state(pdev);
2209
2210         err = qlcnic_start_firmware(adapter);
2211         if (err) {
2212                 dev_err(&pdev->dev, "failed to start firmware\n");
2213                 return err;
2214         }
2215
2216         if (netif_running(netdev)) {
2217                 err = qlcnic_up(adapter, netdev);
2218                 if (err)
2219                         goto done;
2220
2221                 qlcnic_restore_indev_addr(netdev, NETDEV_UP);
2222         }
2223 done:
2224         netif_device_attach(netdev);
2225         qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
2226         return 0;
2227 }
2228 #endif
2229
2230 static int qlcnic_open(struct net_device *netdev)
2231 {
2232         struct qlcnic_adapter *adapter = netdev_priv(netdev);
2233         int err;
2234
2235         netif_carrier_off(netdev);
2236
2237         err = qlcnic_attach(adapter);
2238         if (err)
2239                 return err;
2240
2241         err = __qlcnic_up(adapter, netdev);
2242         if (err)
2243                 goto err_out;
2244
2245         netif_start_queue(netdev);
2246
2247         return 0;
2248
2249 err_out:
2250         qlcnic_detach(adapter);
2251         return err;
2252 }
2253
2254 /*
2255  * qlcnic_close - Disables a network interface entry point
2256  */
2257 static int qlcnic_close(struct net_device *netdev)
2258 {
2259         struct qlcnic_adapter *adapter = netdev_priv(netdev);
2260
2261         __qlcnic_down(adapter, netdev);
2262
2263         return 0;
2264 }
2265
2266 void qlcnic_alloc_lb_filters_mem(struct qlcnic_adapter *adapter)
2267 {
2268         void *head;
2269         int i;
2270         struct net_device *netdev = adapter->netdev;
2271         u32 filter_size = 0;
2272         u16 act_pci_func = 0;
2273
2274         if (adapter->fhash.fmax && adapter->fhash.fhead)
2275                 return;
2276
2277         act_pci_func = adapter->ahw->act_pci_func;
2278         spin_lock_init(&adapter->mac_learn_lock);
2279         spin_lock_init(&adapter->rx_mac_learn_lock);
2280
2281         if (qlcnic_82xx_check(adapter)) {
2282                 filter_size = QLCNIC_LB_MAX_FILTERS;
2283                 adapter->fhash.fbucket_size = QLCNIC_LB_BUCKET_SIZE;
2284         } else {
2285                 filter_size = QLC_83XX_LB_MAX_FILTERS;
2286                 adapter->fhash.fbucket_size = QLC_83XX_LB_BUCKET_SIZE;
2287         }
2288
2289         head = kcalloc(adapter->fhash.fbucket_size,
2290                        sizeof(struct hlist_head), GFP_ATOMIC);
2291
2292         if (!head)
2293                 return;
2294
2295         adapter->fhash.fmax = (filter_size / act_pci_func);
2296         adapter->fhash.fhead = head;
2297
2298         netdev_info(netdev, "active nic func = %d, mac filter size=%d\n",
2299                     act_pci_func, adapter->fhash.fmax);
2300
2301         for (i = 0; i < adapter->fhash.fbucket_size; i++)
2302                 INIT_HLIST_HEAD(&adapter->fhash.fhead[i]);
2303
2304         adapter->rx_fhash.fbucket_size = adapter->fhash.fbucket_size;
2305
2306         head = kcalloc(adapter->rx_fhash.fbucket_size,
2307                        sizeof(struct hlist_head), GFP_ATOMIC);
2308
2309         if (!head)
2310                 return;
2311
2312         adapter->rx_fhash.fmax = (filter_size / act_pci_func);
2313         adapter->rx_fhash.fhead = head;
2314
2315         for (i = 0; i < adapter->rx_fhash.fbucket_size; i++)
2316                 INIT_HLIST_HEAD(&adapter->rx_fhash.fhead[i]);
2317 }
2318
2319 static void qlcnic_free_lb_filters_mem(struct qlcnic_adapter *adapter)
2320 {
2321         if (adapter->fhash.fmax && adapter->fhash.fhead)
2322                 kfree(adapter->fhash.fhead);
2323
2324         adapter->fhash.fhead = NULL;
2325         adapter->fhash.fmax = 0;
2326
2327         if (adapter->rx_fhash.fmax && adapter->rx_fhash.fhead)
2328                 kfree(adapter->rx_fhash.fhead);
2329
2330         adapter->rx_fhash.fmax = 0;
2331         adapter->rx_fhash.fhead = NULL;
2332 }
2333
2334 int qlcnic_check_temp(struct qlcnic_adapter *adapter)
2335 {
2336         struct net_device *netdev = adapter->netdev;
2337         u32 temp_state, temp_val, temp = 0;
2338         int rv = 0;
2339
2340         if (qlcnic_83xx_check(adapter))
2341                 temp = QLCRDX(adapter->ahw, QLC_83XX_ASIC_TEMP);
2342
2343         if (qlcnic_82xx_check(adapter))
2344                 temp = QLC_SHARED_REG_RD32(adapter, QLCNIC_ASIC_TEMP);
2345
2346         temp_state = qlcnic_get_temp_state(temp);
2347         temp_val = qlcnic_get_temp_val(temp);
2348
2349         if (temp_state == QLCNIC_TEMP_PANIC) {
2350                 dev_err(&netdev->dev,
2351                        "Device temperature %d degrees C exceeds"
2352                        " maximum allowed. Hardware has been shut down.\n",
2353                        temp_val);
2354                 rv = 1;
2355         } else if (temp_state == QLCNIC_TEMP_WARN) {
2356                 if (adapter->ahw->temp == QLCNIC_TEMP_NORMAL) {
2357                         dev_err(&netdev->dev,
2358                                "Device temperature %d degrees C "
2359                                "exceeds operating range."
2360                                " Immediate action needed.\n",
2361                                temp_val);
2362                 }
2363         } else {
2364                 if (adapter->ahw->temp == QLCNIC_TEMP_WARN) {
2365                         dev_info(&netdev->dev,
2366                                "Device temperature is now %d degrees C"
2367                                " in normal range.\n", temp_val);
2368                 }
2369         }
2370         adapter->ahw->temp = temp_state;
2371         return rv;
2372 }
2373
2374 static void qlcnic_tx_timeout(struct net_device *netdev)
2375 {
2376         struct qlcnic_adapter *adapter = netdev_priv(netdev);
2377
2378         if (test_bit(__QLCNIC_RESETTING, &adapter->state))
2379                 return;
2380
2381         dev_err(&netdev->dev, "transmit timeout, resetting.\n");
2382
2383         if (++adapter->tx_timeo_cnt >= QLCNIC_MAX_TX_TIMEOUTS)
2384                 adapter->need_fw_reset = 1;
2385         else
2386                 adapter->ahw->reset_context = 1;
2387 }
2388
2389 static struct net_device_stats *qlcnic_get_stats(struct net_device *netdev)
2390 {
2391         struct qlcnic_adapter *adapter = netdev_priv(netdev);
2392         struct net_device_stats *stats = &netdev->stats;
2393
2394         stats->rx_packets = adapter->stats.rx_pkts + adapter->stats.lro_pkts;
2395         stats->tx_packets = adapter->stats.xmitfinished;
2396         stats->rx_bytes = adapter->stats.rxbytes + adapter->stats.lrobytes;
2397         stats->tx_bytes = adapter->stats.txbytes;
2398         stats->rx_dropped = adapter->stats.rxdropped;
2399         stats->tx_dropped = adapter->stats.txdropped;
2400
2401         return stats;
2402 }
2403
2404 irqreturn_t qlcnic_82xx_clear_legacy_intr(struct qlcnic_adapter *adapter)
2405 {
2406         u32 status;
2407
2408         status = readl(adapter->isr_int_vec);
2409
2410         if (!(status & adapter->ahw->int_vec_bit))
2411                 return IRQ_NONE;
2412
2413         /* check interrupt state machine, to be sure */
2414         status = readl(adapter->crb_int_state_reg);
2415         if (!ISR_LEGACY_INT_TRIGGERED(status))
2416                 return IRQ_NONE;
2417
2418         writel(0xffffffff, adapter->tgt_status_reg);
2419         /* read twice to ensure write is flushed */
2420         readl(adapter->isr_int_vec);
2421         readl(adapter->isr_int_vec);
2422
2423         return IRQ_HANDLED;
2424 }
2425
2426 static irqreturn_t qlcnic_tmp_intr(int irq, void *data)
2427 {
2428         struct qlcnic_host_sds_ring *sds_ring = data;
2429         struct qlcnic_adapter *adapter = sds_ring->adapter;
2430
2431         if (adapter->flags & QLCNIC_MSIX_ENABLED)
2432                 goto done;
2433         else if (adapter->flags & QLCNIC_MSI_ENABLED) {
2434                 writel(0xffffffff, adapter->tgt_status_reg);
2435                 goto done;
2436         }
2437
2438         if (qlcnic_clear_legacy_intr(adapter) == IRQ_NONE)
2439                 return IRQ_NONE;
2440
2441 done:
2442         adapter->ahw->diag_cnt++;
2443         qlcnic_enable_int(sds_ring);
2444         return IRQ_HANDLED;
2445 }
2446
2447 static irqreturn_t qlcnic_intr(int irq, void *data)
2448 {
2449         struct qlcnic_host_sds_ring *sds_ring = data;
2450         struct qlcnic_adapter *adapter = sds_ring->adapter;
2451
2452         if (qlcnic_clear_legacy_intr(adapter) == IRQ_NONE)
2453                 return IRQ_NONE;
2454
2455         napi_schedule(&sds_ring->napi);
2456
2457         return IRQ_HANDLED;
2458 }
2459
2460 static irqreturn_t qlcnic_msi_intr(int irq, void *data)
2461 {
2462         struct qlcnic_host_sds_ring *sds_ring = data;
2463         struct qlcnic_adapter *adapter = sds_ring->adapter;
2464
2465         /* clear interrupt */
2466         writel(0xffffffff, adapter->tgt_status_reg);
2467
2468         napi_schedule(&sds_ring->napi);
2469         return IRQ_HANDLED;
2470 }
2471
2472 static irqreturn_t qlcnic_msix_intr(int irq, void *data)
2473 {
2474         struct qlcnic_host_sds_ring *sds_ring = data;
2475
2476         napi_schedule(&sds_ring->napi);
2477         return IRQ_HANDLED;
2478 }
2479
2480 static irqreturn_t qlcnic_msix_tx_intr(int irq, void *data)
2481 {
2482         struct qlcnic_host_tx_ring *tx_ring = data;
2483
2484         napi_schedule(&tx_ring->napi);
2485         return IRQ_HANDLED;
2486 }
2487
2488 #ifdef CONFIG_NET_POLL_CONTROLLER
2489 static void qlcnic_poll_controller(struct net_device *netdev)
2490 {
2491         int ring;
2492         struct qlcnic_host_sds_ring *sds_ring;
2493         struct qlcnic_adapter *adapter = netdev_priv(netdev);
2494         struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
2495
2496         disable_irq(adapter->irq);
2497         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
2498                 sds_ring = &recv_ctx->sds_rings[ring];
2499                 qlcnic_intr(adapter->irq, sds_ring);
2500         }
2501         enable_irq(adapter->irq);
2502 }
2503 #endif
2504
2505 static void
2506 qlcnic_idc_debug_info(struct qlcnic_adapter *adapter, u8 encoding)
2507 {
2508         u32 val;
2509
2510         val = adapter->portnum & 0xf;
2511         val |= encoding << 7;
2512         val |= (jiffies - adapter->dev_rst_time) << 8;
2513
2514         QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_SCRATCH, val);
2515         adapter->dev_rst_time = jiffies;
2516 }
2517
2518 static int
2519 qlcnic_set_drv_state(struct qlcnic_adapter *adapter, u8 state)
2520 {
2521         u32  val;
2522
2523         WARN_ON(state != QLCNIC_DEV_NEED_RESET &&
2524                         state != QLCNIC_DEV_NEED_QUISCENT);
2525
2526         if (qlcnic_api_lock(adapter))
2527                 return -EIO;
2528
2529         val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
2530
2531         if (state == QLCNIC_DEV_NEED_RESET)
2532                 QLC_DEV_SET_RST_RDY(val, adapter->portnum);
2533         else if (state == QLCNIC_DEV_NEED_QUISCENT)
2534                 QLC_DEV_SET_QSCNT_RDY(val, adapter->portnum);
2535
2536         QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2537
2538         qlcnic_api_unlock(adapter);
2539
2540         return 0;
2541 }
2542
2543 static int
2544 qlcnic_clr_drv_state(struct qlcnic_adapter *adapter)
2545 {
2546         u32  val;
2547
2548         if (qlcnic_api_lock(adapter))
2549                 return -EBUSY;
2550
2551         val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
2552         QLC_DEV_CLR_RST_QSCNT(val, adapter->portnum);
2553         QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2554
2555         qlcnic_api_unlock(adapter);
2556
2557         return 0;
2558 }
2559
2560 static void
2561 qlcnic_clr_all_drv_state(struct qlcnic_adapter *adapter, u8 failed)
2562 {
2563         u32  val;
2564
2565         if (qlcnic_api_lock(adapter))
2566                 goto err;
2567
2568         val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
2569         QLC_DEV_CLR_REF_CNT(val, adapter->portnum);
2570         QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_ACTIVE, val);
2571
2572         if (failed) {
2573                 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
2574                                     QLCNIC_DEV_FAILED);
2575                 dev_info(&adapter->pdev->dev,
2576                                 "Device state set to Failed. Please Reboot\n");
2577         } else if (!(val & 0x11111111))
2578                 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
2579                                     QLCNIC_DEV_COLD);
2580
2581         val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
2582         QLC_DEV_CLR_RST_QSCNT(val, adapter->portnum);
2583         QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2584
2585         qlcnic_api_unlock(adapter);
2586 err:
2587         adapter->fw_fail_cnt = 0;
2588         adapter->flags &= ~QLCNIC_FW_HANG;
2589         clear_bit(__QLCNIC_START_FW, &adapter->state);
2590         clear_bit(__QLCNIC_RESETTING, &adapter->state);
2591 }
2592
2593 /* Grab api lock, before checking state */
2594 static int
2595 qlcnic_check_drv_state(struct qlcnic_adapter *adapter)
2596 {
2597         int act, state, active_mask;
2598         struct qlcnic_hardware_context *ahw = adapter->ahw;
2599
2600         state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
2601         act = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
2602
2603         if (adapter->flags & QLCNIC_FW_RESET_OWNER) {
2604                 active_mask = (~(1 << (ahw->pci_func * 4)));
2605                 act = act & active_mask;
2606         }
2607
2608         if (((state & 0x11111111) == (act & 0x11111111)) ||
2609                         ((act & 0x11111111) == ((state >> 1) & 0x11111111)))
2610                 return 0;
2611         else
2612                 return 1;
2613 }
2614
2615 static int qlcnic_check_idc_ver(struct qlcnic_adapter *adapter)
2616 {
2617         u32 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_IDC_VER);
2618
2619         if (val != QLCNIC_DRV_IDC_VER) {
2620                 dev_warn(&adapter->pdev->dev, "IDC Version mismatch, driver's"
2621                         " idc ver = %x; reqd = %x\n", QLCNIC_DRV_IDC_VER, val);
2622         }
2623
2624         return 0;
2625 }
2626
2627 static int
2628 qlcnic_can_start_firmware(struct qlcnic_adapter *adapter)
2629 {
2630         u32 val, prev_state;
2631         u8 dev_init_timeo = adapter->dev_init_timeo;
2632         u8 portnum = adapter->portnum;
2633         u8 ret;
2634
2635         if (test_and_clear_bit(__QLCNIC_START_FW, &adapter->state))
2636                 return 1;
2637
2638         if (qlcnic_api_lock(adapter))
2639                 return -1;
2640
2641         val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
2642         if (!(val & (1 << (portnum * 4)))) {
2643                 QLC_DEV_SET_REF_CNT(val, portnum);
2644                 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_ACTIVE, val);
2645         }
2646
2647         prev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
2648         QLCDB(adapter, HW, "Device state = %u\n", prev_state);
2649
2650         switch (prev_state) {
2651         case QLCNIC_DEV_COLD:
2652                 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
2653                                     QLCNIC_DEV_INITIALIZING);
2654                 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_IDC_VER,
2655                                     QLCNIC_DRV_IDC_VER);
2656                 qlcnic_idc_debug_info(adapter, 0);
2657                 qlcnic_api_unlock(adapter);
2658                 return 1;
2659
2660         case QLCNIC_DEV_READY:
2661                 ret = qlcnic_check_idc_ver(adapter);
2662                 qlcnic_api_unlock(adapter);
2663                 return ret;
2664
2665         case QLCNIC_DEV_NEED_RESET:
2666                 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
2667                 QLC_DEV_SET_RST_RDY(val, portnum);
2668                 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2669                 break;
2670
2671         case QLCNIC_DEV_NEED_QUISCENT:
2672                 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
2673                 QLC_DEV_SET_QSCNT_RDY(val, portnum);
2674                 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2675                 break;
2676
2677         case QLCNIC_DEV_FAILED:
2678                 dev_err(&adapter->pdev->dev, "Device in failed state.\n");
2679                 qlcnic_api_unlock(adapter);
2680                 return -1;
2681
2682         case QLCNIC_DEV_INITIALIZING:
2683         case QLCNIC_DEV_QUISCENT:
2684                 break;
2685         }
2686
2687         qlcnic_api_unlock(adapter);
2688
2689         do {
2690                 msleep(1000);
2691                 prev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
2692
2693                 if (prev_state == QLCNIC_DEV_QUISCENT)
2694                         continue;
2695         } while ((prev_state != QLCNIC_DEV_READY) && --dev_init_timeo);
2696
2697         if (!dev_init_timeo) {
2698                 dev_err(&adapter->pdev->dev,
2699                         "Waiting for device to initialize timeout\n");
2700                 return -1;
2701         }
2702
2703         if (qlcnic_api_lock(adapter))
2704                 return -1;
2705
2706         val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
2707         QLC_DEV_CLR_RST_QSCNT(val, portnum);
2708         QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2709
2710         ret = qlcnic_check_idc_ver(adapter);
2711         qlcnic_api_unlock(adapter);
2712
2713         return ret;
2714 }
2715
2716 static void
2717 qlcnic_fwinit_work(struct work_struct *work)
2718 {
2719         struct qlcnic_adapter *adapter = container_of(work,
2720                         struct qlcnic_adapter, fw_work.work);
2721         u32 dev_state = 0xf;
2722         u32 val;
2723
2724         if (qlcnic_api_lock(adapter))
2725                 goto err_ret;
2726
2727         dev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
2728         if (dev_state == QLCNIC_DEV_QUISCENT ||
2729             dev_state == QLCNIC_DEV_NEED_QUISCENT) {
2730                 qlcnic_api_unlock(adapter);
2731                 qlcnic_schedule_work(adapter, qlcnic_fwinit_work,
2732                                                 FW_POLL_DELAY * 2);
2733                 return;
2734         }
2735
2736         if (adapter->ahw->op_mode == QLCNIC_NON_PRIV_FUNC) {
2737                 qlcnic_api_unlock(adapter);
2738                 goto wait_npar;
2739         }
2740
2741         if (dev_state == QLCNIC_DEV_INITIALIZING ||
2742             dev_state == QLCNIC_DEV_READY) {
2743                 dev_info(&adapter->pdev->dev, "Detected state change from "
2744                                 "DEV_NEED_RESET, skipping ack check\n");
2745                 goto skip_ack_check;
2746         }
2747
2748         if (adapter->fw_wait_cnt++ > adapter->reset_ack_timeo) {
2749                 dev_info(&adapter->pdev->dev, "Reset:Failed to get ack %d sec\n",
2750                                         adapter->reset_ack_timeo);
2751                 goto skip_ack_check;
2752         }
2753
2754         if (!qlcnic_check_drv_state(adapter)) {
2755 skip_ack_check:
2756                 dev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
2757
2758                 if (dev_state == QLCNIC_DEV_NEED_RESET) {
2759                         QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
2760                                             QLCNIC_DEV_INITIALIZING);
2761                         set_bit(__QLCNIC_START_FW, &adapter->state);
2762                         QLCDB(adapter, DRV, "Restarting fw\n");
2763                         qlcnic_idc_debug_info(adapter, 0);
2764                         val = QLC_SHARED_REG_RD32(adapter,
2765                                                   QLCNIC_CRB_DRV_STATE);
2766                         QLC_DEV_SET_RST_RDY(val, adapter->portnum);
2767                         QLC_SHARED_REG_WR32(adapter,
2768                                             QLCNIC_CRB_DRV_STATE, val);
2769                 }
2770
2771                 qlcnic_api_unlock(adapter);
2772
2773                 rtnl_lock();
2774                 if (adapter->ahw->fw_dump.enable &&
2775                     (adapter->flags & QLCNIC_FW_RESET_OWNER)) {
2776                         QLCDB(adapter, DRV, "Take FW dump\n");
2777                         qlcnic_dump_fw(adapter);
2778                         adapter->flags |= QLCNIC_FW_HANG;
2779                 }
2780                 rtnl_unlock();
2781
2782                 adapter->flags &= ~QLCNIC_FW_RESET_OWNER;
2783                 if (!adapter->nic_ops->start_firmware(adapter)) {
2784                         qlcnic_schedule_work(adapter, qlcnic_attach_work, 0);
2785                         adapter->fw_wait_cnt = 0;
2786                         return;
2787                 }
2788                 goto err_ret;
2789         }
2790
2791         qlcnic_api_unlock(adapter);
2792
2793 wait_npar:
2794         dev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
2795         QLCDB(adapter, HW, "Func waiting: Device state=%u\n", dev_state);
2796
2797         switch (dev_state) {
2798         case QLCNIC_DEV_READY:
2799                 if (!qlcnic_start_firmware(adapter)) {
2800                         qlcnic_schedule_work(adapter, qlcnic_attach_work, 0);
2801                         adapter->fw_wait_cnt = 0;
2802                         return;
2803                 }
2804         case QLCNIC_DEV_FAILED:
2805                 break;
2806         default:
2807                 qlcnic_schedule_work(adapter,
2808                         qlcnic_fwinit_work, FW_POLL_DELAY);
2809                 return;
2810         }
2811
2812 err_ret:
2813         dev_err(&adapter->pdev->dev, "Fwinit work failed state=%u "
2814                 "fw_wait_cnt=%u\n", dev_state, adapter->fw_wait_cnt);
2815         netif_device_attach(adapter->netdev);
2816         qlcnic_clr_all_drv_state(adapter, 0);
2817 }
2818
2819 static void
2820 qlcnic_detach_work(struct work_struct *work)
2821 {
2822         struct qlcnic_adapter *adapter = container_of(work,
2823                         struct qlcnic_adapter, fw_work.work);
2824         struct net_device *netdev = adapter->netdev;
2825         u32 status;
2826
2827         netif_device_detach(netdev);
2828
2829         /* Dont grab rtnl lock during Quiscent mode */
2830         if (adapter->dev_state == QLCNIC_DEV_NEED_QUISCENT) {
2831                 if (netif_running(netdev))
2832                         __qlcnic_down(adapter, netdev);
2833         } else
2834                 qlcnic_down(adapter, netdev);
2835
2836         status = QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_HALT_STATUS1);
2837
2838         if (status & QLCNIC_RCODE_FATAL_ERROR) {
2839                 dev_err(&adapter->pdev->dev,
2840                         "Detaching the device: peg halt status1=0x%x\n",
2841                                         status);
2842
2843                 if (QLCNIC_FWERROR_CODE(status) == QLCNIC_FWERROR_FAN_FAILURE) {
2844                         dev_err(&adapter->pdev->dev,
2845                         "On board active cooling fan failed. "
2846                                 "Device has been halted.\n");
2847                         dev_err(&adapter->pdev->dev,
2848                                 "Replace the adapter.\n");
2849                 }
2850
2851                 goto err_ret;
2852         }
2853
2854         if (adapter->ahw->temp == QLCNIC_TEMP_PANIC) {
2855                 dev_err(&adapter->pdev->dev, "Detaching the device: temp=%d\n",
2856                         adapter->ahw->temp);
2857                 goto err_ret;
2858         }
2859
2860         /* Dont ack if this instance is the reset owner */
2861         if (!(adapter->flags & QLCNIC_FW_RESET_OWNER)) {
2862                 if (qlcnic_set_drv_state(adapter, adapter->dev_state)) {
2863                         dev_err(&adapter->pdev->dev,
2864                                 "Failed to set driver state,"
2865                                         "detaching the device.\n");
2866                         goto err_ret;
2867                 }
2868         }
2869
2870         adapter->fw_wait_cnt = 0;
2871
2872         qlcnic_schedule_work(adapter, qlcnic_fwinit_work, FW_POLL_DELAY);
2873
2874         return;
2875
2876 err_ret:
2877         netif_device_attach(netdev);
2878         qlcnic_clr_all_drv_state(adapter, 1);
2879 }
2880
2881 /*Transit NPAR state to NON Operational */
2882 static void
2883 qlcnic_set_npar_non_operational(struct qlcnic_adapter *adapter)
2884 {
2885         u32 state;
2886
2887         state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_NPAR_STATE);
2888         if (state == QLCNIC_DEV_NPAR_NON_OPER)
2889                 return;
2890
2891         if (qlcnic_api_lock(adapter))
2892                 return;
2893         QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE,
2894                             QLCNIC_DEV_NPAR_NON_OPER);
2895         qlcnic_api_unlock(adapter);
2896 }
2897
2898 void qlcnic_82xx_dev_request_reset(struct qlcnic_adapter *adapter, u32 key)
2899 {
2900         u32 state, xg_val = 0, gb_val = 0;
2901
2902         qlcnic_xg_set_xg0_mask(xg_val);
2903         qlcnic_xg_set_xg1_mask(xg_val);
2904         QLCWR32(adapter, QLCNIC_NIU_XG_PAUSE_CTL, xg_val);
2905         qlcnic_gb_set_gb0_mask(gb_val);
2906         qlcnic_gb_set_gb1_mask(gb_val);
2907         qlcnic_gb_set_gb2_mask(gb_val);
2908         qlcnic_gb_set_gb3_mask(gb_val);
2909         QLCWR32(adapter, QLCNIC_NIU_GB_PAUSE_CTL, gb_val);
2910         dev_info(&adapter->pdev->dev, "Pause control frames disabled"
2911                                 " on all ports\n");
2912         adapter->need_fw_reset = 1;
2913
2914         if (qlcnic_api_lock(adapter))
2915                 return;
2916
2917         state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
2918
2919         if (state == QLCNIC_DEV_READY) {
2920                 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
2921                                     QLCNIC_DEV_NEED_RESET);
2922                 adapter->flags |= QLCNIC_FW_RESET_OWNER;
2923                 QLCDB(adapter, DRV, "NEED_RESET state set\n");
2924                 qlcnic_idc_debug_info(adapter, 0);
2925         }
2926
2927         QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE,
2928                             QLCNIC_DEV_NPAR_NON_OPER);
2929         qlcnic_api_unlock(adapter);
2930 }
2931
2932 /* Transit to NPAR READY state from NPAR NOT READY state */
2933 static void
2934 qlcnic_dev_set_npar_ready(struct qlcnic_adapter *adapter)
2935 {
2936         if (qlcnic_api_lock(adapter))
2937                 return;
2938
2939         QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE,
2940                             QLCNIC_DEV_NPAR_OPER);
2941         QLCDB(adapter, DRV, "NPAR operational state set\n");
2942
2943         qlcnic_api_unlock(adapter);
2944 }
2945
2946 void qlcnic_schedule_work(struct qlcnic_adapter *adapter,
2947                           work_func_t func, int delay)
2948 {
2949         if (test_bit(__QLCNIC_AER, &adapter->state))
2950                 return;
2951
2952         INIT_DELAYED_WORK(&adapter->fw_work, func);
2953         queue_delayed_work(adapter->qlcnic_wq, &adapter->fw_work,
2954                            round_jiffies_relative(delay));
2955 }
2956
2957 static void
2958 qlcnic_attach_work(struct work_struct *work)
2959 {
2960         struct qlcnic_adapter *adapter = container_of(work,
2961                                 struct qlcnic_adapter, fw_work.work);
2962         struct net_device *netdev = adapter->netdev;
2963         u32 npar_state;
2964
2965         if (adapter->ahw->op_mode != QLCNIC_MGMT_FUNC) {
2966                 npar_state = QLC_SHARED_REG_RD32(adapter,
2967                                                  QLCNIC_CRB_DEV_NPAR_STATE);
2968                 if (adapter->fw_wait_cnt++ > QLCNIC_DEV_NPAR_OPER_TIMEO)
2969                         qlcnic_clr_all_drv_state(adapter, 0);
2970                 else if (npar_state != QLCNIC_DEV_NPAR_OPER)
2971                         qlcnic_schedule_work(adapter, qlcnic_attach_work,
2972                                                         FW_POLL_DELAY);
2973                 else
2974                         goto attach;
2975                 QLCDB(adapter, DRV, "Waiting for NPAR state to operational\n");
2976                 return;
2977         }
2978 attach:
2979         if (netif_running(netdev)) {
2980                 if (qlcnic_up(adapter, netdev))
2981                         goto done;
2982
2983                 qlcnic_restore_indev_addr(netdev, NETDEV_UP);
2984         }
2985
2986 done:
2987         netif_device_attach(netdev);
2988         adapter->fw_fail_cnt = 0;
2989         adapter->flags &= ~QLCNIC_FW_HANG;
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         u32 peg_status;
3002
3003         if (qlcnic_check_temp(adapter))
3004                 goto detach;
3005
3006         if (adapter->need_fw_reset)
3007                 qlcnic_dev_request_reset(adapter, 0);
3008
3009         state = QLC_SHARED_REG_RD32(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 = QLC_SHARED_REG_RD32(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->ahw->reset_context && qlcnic_auto_fw_reset) {
3024                         qlcnic_reset_hw_context(adapter);
3025                         adapter->netdev->trans_start = jiffies;
3026                 }
3027
3028                 return 0;
3029         }
3030
3031         if (++adapter->fw_fail_cnt < FW_FAIL_THRESH)
3032                 return 0;
3033
3034         adapter->flags |= QLCNIC_FW_HANG;
3035
3036         qlcnic_dev_request_reset(adapter, 0);
3037
3038         if (qlcnic_auto_fw_reset)
3039                 clear_bit(__QLCNIC_FW_ATTACHED, &adapter->state);
3040
3041         dev_err(&adapter->pdev->dev, "firmware hang detected\n");
3042         peg_status = QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_HALT_STATUS1);
3043         dev_err(&adapter->pdev->dev, "Dumping hw/fw registers\n"
3044                         "PEG_HALT_STATUS1: 0x%x, PEG_HALT_STATUS2: 0x%x,\n"
3045                         "PEG_NET_0_PC: 0x%x, PEG_NET_1_PC: 0x%x,\n"
3046                         "PEG_NET_2_PC: 0x%x, PEG_NET_3_PC: 0x%x,\n"
3047                         "PEG_NET_4_PC: 0x%x\n",
3048                         peg_status,
3049                         QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_HALT_STATUS2),
3050                         QLCRD32(adapter, QLCNIC_CRB_PEG_NET_0 + 0x3c),
3051                         QLCRD32(adapter, QLCNIC_CRB_PEG_NET_1 + 0x3c),
3052                         QLCRD32(adapter, QLCNIC_CRB_PEG_NET_2 + 0x3c),
3053                         QLCRD32(adapter, QLCNIC_CRB_PEG_NET_3 + 0x3c),
3054                         QLCRD32(adapter, QLCNIC_CRB_PEG_NET_4 + 0x3c));
3055         if (QLCNIC_FWERROR_CODE(peg_status) == 0x67)
3056                 dev_err(&adapter->pdev->dev,
3057                         "Firmware aborted with error code 0x00006700. "
3058                                 "Device is being reset.\n");
3059 detach:
3060         adapter->dev_state = (state == QLCNIC_DEV_NEED_QUISCENT) ? state :
3061                 QLCNIC_DEV_NEED_RESET;
3062
3063         if (qlcnic_auto_fw_reset && !test_and_set_bit(__QLCNIC_RESETTING,
3064                                                       &adapter->state)) {
3065
3066                 qlcnic_schedule_work(adapter, qlcnic_detach_work, 0);
3067                 QLCDB(adapter, DRV, "fw recovery scheduled.\n");
3068         }
3069
3070         return 1;
3071 }
3072
3073 static void
3074 qlcnic_fw_poll_work(struct work_struct *work)
3075 {
3076         struct qlcnic_adapter *adapter = container_of(work,
3077                                 struct qlcnic_adapter, fw_work.work);
3078
3079         if (test_bit(__QLCNIC_RESETTING, &adapter->state))
3080                 goto reschedule;
3081
3082
3083         if (qlcnic_check_health(adapter))
3084                 return;
3085
3086         if (adapter->fhash.fnum)
3087                 qlcnic_prune_lb_filters(adapter);
3088
3089 reschedule:
3090         qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
3091 }
3092
3093 static int qlcnic_is_first_func(struct pci_dev *pdev)
3094 {
3095         struct pci_dev *oth_pdev;
3096         int val = pdev->devfn;
3097
3098         while (val-- > 0) {
3099                 oth_pdev = pci_get_domain_bus_and_slot(pci_domain_nr
3100                         (pdev->bus), pdev->bus->number,
3101                         PCI_DEVFN(PCI_SLOT(pdev->devfn), val));
3102                 if (!oth_pdev)
3103                         continue;
3104
3105                 if (oth_pdev->current_state != PCI_D3cold) {
3106                         pci_dev_put(oth_pdev);
3107                         return 0;
3108                 }
3109                 pci_dev_put(oth_pdev);
3110         }
3111         return 1;
3112 }
3113
3114 static int qlcnic_attach_func(struct pci_dev *pdev)
3115 {
3116         int err, first_func;
3117         struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3118         struct net_device *netdev = adapter->netdev;
3119
3120         pdev->error_state = pci_channel_io_normal;
3121
3122         err = pci_enable_device(pdev);
3123         if (err)
3124                 return err;
3125
3126         pci_set_power_state(pdev, PCI_D0);
3127         pci_set_master(pdev);
3128         pci_restore_state(pdev);
3129
3130         first_func = qlcnic_is_first_func(pdev);
3131
3132         if (qlcnic_api_lock(adapter))
3133                 return -EINVAL;
3134
3135         if (adapter->ahw->op_mode != QLCNIC_NON_PRIV_FUNC && first_func) {
3136                 adapter->need_fw_reset = 1;
3137                 set_bit(__QLCNIC_START_FW, &adapter->state);
3138                 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
3139                                     QLCNIC_DEV_INITIALIZING);
3140                 QLCDB(adapter, DRV, "Restarting fw\n");
3141         }
3142         qlcnic_api_unlock(adapter);
3143
3144         err = qlcnic_start_firmware(adapter);
3145         if (err)
3146                 return err;
3147
3148         qlcnic_clr_drv_state(adapter);
3149         kfree(adapter->msix_entries);
3150         adapter->msix_entries = NULL;
3151         err = qlcnic_setup_intr(adapter, 0);
3152
3153         if (err) {
3154                 kfree(adapter->msix_entries);
3155                 netdev_err(netdev, "failed to setup interrupt\n");
3156                 return err;
3157         }
3158
3159         if (qlcnic_83xx_check(adapter)) {
3160                 /* register for NIC IDC AEN Events */
3161                 qlcnic_83xx_register_nic_idc_func(adapter, 1);
3162                 err = qlcnic_83xx_setup_mbx_intr(adapter);
3163                 if (err) {
3164                         dev_err(&adapter->pdev->dev,
3165                                 "failed to setup mbx interrupt\n");
3166                         qlcnic_clr_all_drv_state(adapter, 1);
3167                         clear_bit(__QLCNIC_AER, &adapter->state);
3168                         goto done;
3169                 }
3170         }
3171
3172         if (netif_running(netdev)) {
3173                 err = qlcnic_attach(adapter);
3174                 if (err) {
3175                         qlcnic_clr_all_drv_state(adapter, 1);
3176                         clear_bit(__QLCNIC_AER, &adapter->state);
3177                         netif_device_attach(netdev);
3178                         return err;
3179                 }
3180
3181                 err = qlcnic_up(adapter, netdev);
3182                 if (err)
3183                         goto done;
3184
3185                 qlcnic_restore_indev_addr(netdev, NETDEV_UP);
3186         }
3187  done:
3188         netif_device_attach(netdev);
3189         return err;
3190 }
3191
3192 static pci_ers_result_t qlcnic_io_error_detected(struct pci_dev *pdev,
3193                                                 pci_channel_state_t state)
3194 {
3195         struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3196         struct net_device *netdev = adapter->netdev;
3197
3198         if (state == pci_channel_io_perm_failure)
3199                 return PCI_ERS_RESULT_DISCONNECT;
3200
3201         if (state == pci_channel_io_normal)
3202                 return PCI_ERS_RESULT_RECOVERED;
3203
3204         set_bit(__QLCNIC_AER, &adapter->state);
3205         netif_device_detach(netdev);
3206
3207         cancel_delayed_work_sync(&adapter->fw_work);
3208
3209         if (netif_running(netdev))
3210                 qlcnic_down(adapter, netdev);
3211
3212         if (qlcnic_83xx_check(adapter)) {
3213                 qlcnic_83xx_free_mbx_intr(adapter);
3214                 qlcnic_83xx_register_nic_idc_func(adapter, 0);
3215                 cancel_delayed_work_sync(&adapter->idc_aen_work);
3216         }
3217
3218         qlcnic_detach(adapter);
3219         qlcnic_teardown_intr(adapter);
3220
3221         clear_bit(__QLCNIC_RESETTING, &adapter->state);
3222
3223         pci_save_state(pdev);
3224         pci_disable_device(pdev);
3225
3226         return PCI_ERS_RESULT_NEED_RESET;
3227 }
3228
3229 static pci_ers_result_t qlcnic_io_slot_reset(struct pci_dev *pdev)
3230 {
3231         return qlcnic_attach_func(pdev) ? PCI_ERS_RESULT_DISCONNECT :
3232                                 PCI_ERS_RESULT_RECOVERED;
3233 }
3234
3235 static void qlcnic_io_resume(struct pci_dev *pdev)
3236 {
3237         u32 state;
3238         struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3239
3240         pci_cleanup_aer_uncorrect_error_status(pdev);
3241         state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
3242         if (state == QLCNIC_DEV_READY && test_and_clear_bit(__QLCNIC_AER,
3243                                                             &adapter->state))
3244                 qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
3245                                                 FW_POLL_DELAY);
3246 }
3247
3248 static int
3249 qlcnicvf_start_firmware(struct qlcnic_adapter *adapter)
3250 {
3251         int err;
3252
3253         err = qlcnic_can_start_firmware(adapter);
3254         if (err)
3255                 return err;
3256
3257         err = qlcnic_check_npar_opertional(adapter);
3258         if (err)
3259                 return err;
3260
3261         err = qlcnic_initialize_nic(adapter);
3262         if (err)
3263                 return err;
3264
3265         qlcnic_check_options(adapter);
3266
3267         err = qlcnic_set_eswitch_port_config(adapter);
3268         if (err)
3269                 return err;
3270
3271         adapter->need_fw_reset = 0;
3272
3273         return err;
3274 }
3275
3276 int qlcnic_validate_max_rss(u8 max_hw, u8 val)
3277 {
3278         u32 max_allowed;
3279
3280         if (max_hw > QLC_MAX_SDS_RINGS) {
3281                 max_hw = QLC_MAX_SDS_RINGS;
3282                 pr_info("max rss reset to %d\n", QLC_MAX_SDS_RINGS);
3283         }
3284
3285         max_allowed = rounddown_pow_of_two(min_t(int, max_hw,
3286                                                  num_online_cpus()));
3287         if ((val > max_allowed) || (val < 2) || !is_power_of_2(val)) {
3288                 pr_info("rss_ring valid range [2 - %x] in powers of 2\n",
3289                         max_allowed);
3290                 return -EINVAL;
3291         }
3292         return 0;
3293 }
3294
3295 int qlcnic_set_max_rss(struct qlcnic_adapter *adapter, u8 data, size_t len)
3296 {
3297         int err;
3298         struct net_device *netdev = adapter->netdev;
3299
3300         if (test_bit(__QLCNIC_RESETTING, &adapter->state))
3301                 return -EBUSY;
3302
3303         netif_device_detach(netdev);
3304         if (netif_running(netdev))
3305                 __qlcnic_down(adapter, netdev);
3306
3307         qlcnic_detach(adapter);
3308
3309         if (qlcnic_83xx_check(adapter)) {
3310                 qlcnic_83xx_free_mbx_intr(adapter);
3311                 qlcnic_83xx_enable_mbx_poll(adapter);
3312         }
3313
3314         qlcnic_teardown_intr(adapter);
3315         err = qlcnic_setup_intr(adapter, data);
3316         if (err) {
3317                 kfree(adapter->msix_entries);
3318                 netdev_err(netdev, "failed to setup interrupt\n");
3319                 return err;
3320         }
3321
3322         if (qlcnic_83xx_check(adapter)) {
3323                 /* register for NIC IDC AEN Events */
3324                 qlcnic_83xx_register_nic_idc_func(adapter, 1);
3325                 err = qlcnic_83xx_setup_mbx_intr(adapter);
3326                 qlcnic_83xx_disable_mbx_poll(adapter);
3327                 if (err) {
3328                         dev_err(&adapter->pdev->dev,
3329                                 "failed to setup mbx interrupt\n");
3330                         goto done;
3331                 }
3332         }
3333
3334         if (netif_running(netdev)) {
3335                 err = qlcnic_attach(adapter);
3336                 if (err)
3337                         goto done;
3338                 err = __qlcnic_up(adapter, netdev);
3339                 if (err)
3340                         goto done;
3341                 qlcnic_restore_indev_addr(netdev, NETDEV_UP);
3342         }
3343         err = len;
3344  done:
3345         netif_device_attach(netdev);
3346         clear_bit(__QLCNIC_RESETTING, &adapter->state);
3347         return err;
3348 }
3349
3350 #ifdef CONFIG_INET
3351
3352 #define is_qlcnic_netdev(dev) (dev->netdev_ops == &qlcnic_netdev_ops)
3353
3354 static void
3355 qlcnic_config_indev_addr(struct qlcnic_adapter *adapter,
3356                         struct net_device *dev, unsigned long event)
3357 {
3358         struct in_device *indev;
3359
3360         indev = in_dev_get(dev);
3361         if (!indev)
3362                 return;
3363
3364         for_ifa(indev) {
3365                 switch (event) {
3366                 case NETDEV_UP:
3367                         qlcnic_config_ipaddr(adapter,
3368                                         ifa->ifa_address, QLCNIC_IP_UP);
3369                         break;
3370                 case NETDEV_DOWN:
3371                         qlcnic_config_ipaddr(adapter,
3372                                         ifa->ifa_address, QLCNIC_IP_DOWN);
3373                         break;
3374                 default:
3375                         break;
3376                 }
3377         } endfor_ifa(indev);
3378
3379         in_dev_put(indev);
3380 }
3381
3382 void qlcnic_restore_indev_addr(struct net_device *netdev, unsigned long event)
3383 {
3384         struct qlcnic_adapter *adapter = netdev_priv(netdev);
3385         struct net_device *dev;
3386         u16 vid;
3387
3388         qlcnic_config_indev_addr(adapter, netdev, event);
3389
3390         rcu_read_lock();
3391         for_each_set_bit(vid, adapter->vlans, VLAN_N_VID) {
3392                 dev = __vlan_find_dev_deep(netdev, htons(ETH_P_8021Q), vid);
3393                 if (!dev)
3394                         continue;
3395                 qlcnic_config_indev_addr(adapter, dev, event);
3396         }
3397         rcu_read_unlock();
3398 }
3399
3400 static int qlcnic_netdev_event(struct notifier_block *this,
3401                                  unsigned long event, void *ptr)
3402 {
3403         struct qlcnic_adapter *adapter;
3404         struct net_device *dev = (struct net_device *)ptr;
3405
3406 recheck:
3407         if (dev == NULL)
3408                 goto done;
3409
3410         if (dev->priv_flags & IFF_802_1Q_VLAN) {
3411                 dev = vlan_dev_real_dev(dev);
3412                 goto recheck;
3413         }
3414
3415         if (!is_qlcnic_netdev(dev))
3416                 goto done;
3417
3418         adapter = netdev_priv(dev);
3419
3420         if (!adapter)
3421                 goto done;
3422
3423         if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
3424                 goto done;
3425
3426         qlcnic_config_indev_addr(adapter, dev, event);
3427 done:
3428         return NOTIFY_DONE;
3429 }
3430
3431 static int
3432 qlcnic_inetaddr_event(struct notifier_block *this,
3433                 unsigned long event, void *ptr)
3434 {
3435         struct qlcnic_adapter *adapter;
3436         struct net_device *dev;
3437
3438         struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
3439
3440         dev = ifa->ifa_dev ? ifa->ifa_dev->dev : NULL;
3441
3442 recheck:
3443         if (dev == NULL)
3444                 goto done;
3445
3446         if (dev->priv_flags & IFF_802_1Q_VLAN) {
3447                 dev = vlan_dev_real_dev(dev);
3448                 goto recheck;
3449         }
3450
3451         if (!is_qlcnic_netdev(dev))
3452                 goto done;
3453
3454         adapter = netdev_priv(dev);
3455
3456         if (!adapter)
3457                 goto done;
3458
3459         if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
3460                 goto done;
3461
3462         switch (event) {
3463         case NETDEV_UP:
3464                 qlcnic_config_ipaddr(adapter, ifa->ifa_address, QLCNIC_IP_UP);
3465
3466                 break;
3467         case NETDEV_DOWN:
3468                 qlcnic_config_ipaddr(adapter, ifa->ifa_address, QLCNIC_IP_DOWN);
3469
3470                 break;
3471         default:
3472                 break;
3473         }
3474
3475 done:
3476         return NOTIFY_DONE;
3477 }
3478
3479 static struct notifier_block    qlcnic_netdev_cb = {
3480         .notifier_call = qlcnic_netdev_event,
3481 };
3482
3483 static struct notifier_block qlcnic_inetaddr_cb = {
3484         .notifier_call = qlcnic_inetaddr_event,
3485 };
3486 #else
3487 void qlcnic_restore_indev_addr(struct net_device *dev, unsigned long event)
3488 { }
3489 #endif
3490 static const struct pci_error_handlers qlcnic_err_handler = {
3491         .error_detected = qlcnic_io_error_detected,
3492         .slot_reset = qlcnic_io_slot_reset,
3493         .resume = qlcnic_io_resume,
3494 };
3495
3496 static struct pci_driver qlcnic_driver = {
3497         .name = qlcnic_driver_name,
3498         .id_table = qlcnic_pci_tbl,
3499         .probe = qlcnic_probe,
3500         .remove = qlcnic_remove,
3501 #ifdef CONFIG_PM
3502         .suspend = qlcnic_suspend,
3503         .resume = qlcnic_resume,
3504 #endif
3505         .shutdown = qlcnic_shutdown,
3506         .err_handler = &qlcnic_err_handler,
3507 #ifdef CONFIG_QLCNIC_SRIOV
3508         .sriov_configure = qlcnic_pci_sriov_configure,
3509 #endif
3510
3511 };
3512
3513 static int __init qlcnic_init_module(void)
3514 {
3515         int ret;
3516
3517         printk(KERN_INFO "%s\n", qlcnic_driver_string);
3518
3519 #ifdef CONFIG_INET
3520         register_netdevice_notifier(&qlcnic_netdev_cb);
3521         register_inetaddr_notifier(&qlcnic_inetaddr_cb);
3522 #endif
3523
3524         ret = pci_register_driver(&qlcnic_driver);
3525         if (ret) {
3526 #ifdef CONFIG_INET
3527                 unregister_inetaddr_notifier(&qlcnic_inetaddr_cb);
3528                 unregister_netdevice_notifier(&qlcnic_netdev_cb);
3529 #endif
3530         }
3531
3532         return ret;
3533 }
3534
3535 module_init(qlcnic_init_module);
3536
3537 static void __exit qlcnic_exit_module(void)
3538 {
3539         pci_unregister_driver(&qlcnic_driver);
3540
3541 #ifdef CONFIG_INET
3542         unregister_inetaddr_notifier(&qlcnic_inetaddr_cb);
3543         unregister_netdevice_notifier(&qlcnic_netdev_cb);
3544 #endif
3545 }
3546
3547 module_exit(qlcnic_exit_module);