drivers/net/qlcnic/qlcnic_main.c

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