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

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