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

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