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