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