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 #include <linux/aer.h>
  38
  39 MODULE_DESCRIPTION("QLogic 1/10 GbE Converged/Intelligent Ethernet Driver");
  40 MODULE_LICENSE("GPL");
  41 MODULE_VERSION(QLCNIC_LINUX_VERSIONID);
  42 MODULE_FIRMWARE(QLCNIC_UNIFIED_ROMIMAGE_NAME);
  43
  44 char qlcnic_driver_name[] = "qlcnic";
  45 static const char qlcnic_driver_string[] = "QLogic 1/10 GbE "
  46         "Converged/Intelligent Ethernet Driver v" QLCNIC_LINUX_VERSIONID;
  47
  48 static int port_mode = QLCNIC_PORT_MODE_AUTO_NEG;
  49
  50 /* Default to restricted 1G auto-neg mode */
  51 static int wol_port_mode = 5;
  52
  53 static int use_msi = 1;
  54 module_param(use_msi, int, 0644);
  55 MODULE_PARM_DESC(use_msi, "MSI interrupt (0=disabled, 1=enabled");
  56
  57 static int use_msi_x = 1;
  58 module_param(use_msi_x, int, 0644);
  59 MODULE_PARM_DESC(use_msi_x, "MSI-X interrupt (0=disabled, 1=enabled");
  60
  61 static int auto_fw_reset = AUTO_FW_RESET_ENABLED;
  62 module_param(auto_fw_reset, int, 0644);
  63 MODULE_PARM_DESC(auto_fw_reset, "Auto firmware reset (0=disabled, 1=enabled");
  64
  65 static int load_fw_file;
  66 module_param(load_fw_file, int, 0644);
  67 MODULE_PARM_DESC(load_fw_file, "Load firmware from (0=flash, 1=file");
  68
  69 static int qlcnic_config_npars;
  70 module_param(qlcnic_config_npars, int, 0644);
  71 MODULE_PARM_DESC(qlcnic_config_npars, "Configure NPARs (0=disabled, 1=enabled");
  72
  73 static int __devinit qlcnic_probe(struct pci_dev *pdev,
  74                 const struct pci_device_id *ent);
  75 static void __devexit qlcnic_remove(struct pci_dev *pdev);
  76 static int qlcnic_open(struct net_device *netdev);
  77 static int qlcnic_close(struct net_device *netdev);
  78 static void qlcnic_tx_timeout(struct net_device *netdev);
  79 static void qlcnic_attach_work(struct work_struct *work);
  80 static void qlcnic_fwinit_work(struct work_struct *work);
  81 static void qlcnic_fw_poll_work(struct work_struct *work);
  82 static void qlcnic_schedule_work(struct qlcnic_adapter *adapter,
  83                 work_func_t func, int delay);
  84 static void qlcnic_cancel_fw_work(struct qlcnic_adapter *adapter);
  85 static int qlcnic_poll(struct napi_struct *napi, int budget);
  86 static int qlcnic_rx_poll(struct napi_struct *napi, int budget);
  87 #ifdef CONFIG_NET_POLL_CONTROLLER
  88 static void qlcnic_poll_controller(struct net_device *netdev);
  89 #endif
  90
  91 static void qlcnic_create_sysfs_entries(struct qlcnic_adapter *adapter);
  92 static void qlcnic_remove_sysfs_entries(struct qlcnic_adapter *adapter);
  93 static void qlcnic_create_diag_entries(struct qlcnic_adapter *adapter);
  94 static void qlcnic_remove_diag_entries(struct qlcnic_adapter *adapter);
  95
  96 static void qlcnic_idc_debug_info(struct qlcnic_adapter *adapter, u8 encoding);
  97 static void qlcnic_clr_all_drv_state(struct qlcnic_adapter *adapter, u8);
  98 static int qlcnic_can_start_firmware(struct qlcnic_adapter *adapter);
  99
 100 static irqreturn_t qlcnic_tmp_intr(int irq, void *data);
 101 static irqreturn_t qlcnic_intr(int irq, void *data);
 102 static irqreturn_t qlcnic_msi_intr(int irq, void *data);
 103 static irqreturn_t qlcnic_msix_intr(int irq, void *data);
 104
 105 static struct net_device_stats *qlcnic_get_stats(struct net_device *netdev);
 106 static void qlcnic_config_indev_addr(struct net_device *dev, unsigned long);
 107 static int qlcnic_start_firmware(struct qlcnic_adapter *);
 108
 109 static void qlcnic_dev_set_npar_ready(struct qlcnic_adapter *);
 110 static int qlcnicvf_config_led(struct qlcnic_adapter *, u32, u32);
 111 static int qlcnicvf_config_bridged_mode(struct qlcnic_adapter *, u32);
 112 static int qlcnicvf_start_firmware(struct qlcnic_adapter *);
 113 static void qlcnic_set_netdev_features(struct qlcnic_adapter *,
 114                                 struct qlcnic_esw_func_cfg *);
 115 /*  PCI Device ID Table  */
 116 #define ENTRY(device) \
 117         {PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, (device)), \
 118         .class = PCI_CLASS_NETWORK_ETHERNET << 8, .class_mask = ~0}
 119
 120 #define PCI_DEVICE_ID_QLOGIC_QLE824X  0x8020
 121
 122 static DEFINE_PCI_DEVICE_TABLE(qlcnic_pci_tbl) = {
 123         ENTRY(PCI_DEVICE_ID_QLOGIC_QLE824X),
 124         {0,}
 125 };
 126
 127 MODULE_DEVICE_TABLE(pci, qlcnic_pci_tbl);
 128
 129
 130 void
 131 qlcnic_update_cmd_producer(struct qlcnic_adapter *adapter,
 132                 struct qlcnic_host_tx_ring *tx_ring)
 133 {
 134         writel(tx_ring->producer, tx_ring->crb_cmd_producer);
 135 }
 136
 137 static const u32 msi_tgt_status[8] = {
 138         ISR_INT_TARGET_STATUS, ISR_INT_TARGET_STATUS_F1,
 139         ISR_INT_TARGET_STATUS_F2, ISR_INT_TARGET_STATUS_F3,
 140         ISR_INT_TARGET_STATUS_F4, ISR_INT_TARGET_STATUS_F5,
 141         ISR_INT_TARGET_STATUS_F6, ISR_INT_TARGET_STATUS_F7
 142 };
 143
 144 static const
 145 struct qlcnic_legacy_intr_set legacy_intr[] = QLCNIC_LEGACY_INTR_CONFIG;
 146
 147 static inline void qlcnic_disable_int(struct qlcnic_host_sds_ring *sds_ring)
 148 {
 149         writel(0, sds_ring->crb_intr_mask);
 150 }
 151
 152 static inline void qlcnic_enable_int(struct qlcnic_host_sds_ring *sds_ring)
 153 {
 154         struct qlcnic_adapter *adapter = sds_ring->adapter;
 155
 156         writel(0x1, sds_ring->crb_intr_mask);
 157
 158         if (!QLCNIC_IS_MSI_FAMILY(adapter))
 159                 writel(0xfbff, adapter->tgt_mask_reg);
 160 }
 161
 162 static int
 163 qlcnic_alloc_sds_rings(struct qlcnic_recv_context *recv_ctx, int count)
 164 {
 165         int size = sizeof(struct qlcnic_host_sds_ring) * count;
 166
 167         recv_ctx->sds_rings = kzalloc(size, GFP_KERNEL);
 168
 169         return (recv_ctx->sds_rings == NULL);
 170 }
 171
 172 static void
 173 qlcnic_free_sds_rings(struct qlcnic_recv_context *recv_ctx)
 174 {
 175         if (recv_ctx->sds_rings != NULL)
 176                 kfree(recv_ctx->sds_rings);
 177
 178         recv_ctx->sds_rings = NULL;
 179 }
 180
 181 static int
 182 qlcnic_napi_add(struct qlcnic_adapter *adapter, struct net_device *netdev)
 183 {
 184         int ring;
 185         struct qlcnic_host_sds_ring *sds_ring;
 186         struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
 187
 188         if (qlcnic_alloc_sds_rings(recv_ctx, adapter->max_sds_rings))
 189                 return -ENOMEM;
 190
 191         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
 192                 sds_ring = &recv_ctx->sds_rings[ring];
 193
 194                 if (ring == adapter->max_sds_rings - 1)
 195                         netif_napi_add(netdev, &sds_ring->napi, qlcnic_poll,
 196                                 QLCNIC_NETDEV_WEIGHT/adapter->max_sds_rings);
 197                 else
 198                         netif_napi_add(netdev, &sds_ring->napi,
 199                                 qlcnic_rx_poll, QLCNIC_NETDEV_WEIGHT*2);
 200         }
 201
 202         return 0;
 203 }
 204
 205 static void
 206 qlcnic_napi_del(struct qlcnic_adapter *adapter)
 207 {
 208         int ring;
 209         struct qlcnic_host_sds_ring *sds_ring;
 210         struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
 211
 212         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
 213                 sds_ring = &recv_ctx->sds_rings[ring];
 214                 netif_napi_del(&sds_ring->napi);
 215         }
 216
 217         qlcnic_free_sds_rings(&adapter->recv_ctx);
 218 }
 219
 220 static void
 221 qlcnic_napi_enable(struct qlcnic_adapter *adapter)
 222 {
 223         int ring;
 224         struct qlcnic_host_sds_ring *sds_ring;
 225         struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
 226
 227         if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
 228                 return;
 229
 230         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
 231                 sds_ring = &recv_ctx->sds_rings[ring];
 232                 napi_enable(&sds_ring->napi);
 233                 qlcnic_enable_int(sds_ring);
 234         }
 235 }
 236
 237 static void
 238 qlcnic_napi_disable(struct qlcnic_adapter *adapter)
 239 {
 240         int ring;
 241         struct qlcnic_host_sds_ring *sds_ring;
 242         struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
 243
 244         if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
 245                 return;
 246
 247         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
 248                 sds_ring = &recv_ctx->sds_rings[ring];
 249                 qlcnic_disable_int(sds_ring);
 250                 napi_synchronize(&sds_ring->napi);
 251                 napi_disable(&sds_ring->napi);
 252         }
 253 }
 254
 255 static void qlcnic_clear_stats(struct qlcnic_adapter *adapter)
 256 {
 257         memset(&adapter->stats, 0, sizeof(adapter->stats));
 258 }
 259
 260 static void qlcnic_set_port_mode(struct qlcnic_adapter *adapter)
 261 {
 262         u32 val, data;
 263
 264         val = adapter->ahw.board_type;
 265         if ((val == QLCNIC_BRDTYPE_P3_HMEZ) ||
 266                 (val == QLCNIC_BRDTYPE_P3_XG_LOM)) {
 267                 if (port_mode == QLCNIC_PORT_MODE_802_3_AP) {
 268                         data = QLCNIC_PORT_MODE_802_3_AP;
 269                         QLCWR32(adapter, QLCNIC_PORT_MODE_ADDR, data);
 270                 } else if (port_mode == QLCNIC_PORT_MODE_XG) {
 271                         data = QLCNIC_PORT_MODE_XG;
 272                         QLCWR32(adapter, QLCNIC_PORT_MODE_ADDR, data);
 273                 } else if (port_mode == QLCNIC_PORT_MODE_AUTO_NEG_1G) {
 274                         data = QLCNIC_PORT_MODE_AUTO_NEG_1G;
 275                         QLCWR32(adapter, QLCNIC_PORT_MODE_ADDR, data);
 276                 } else if (port_mode == QLCNIC_PORT_MODE_AUTO_NEG_XG) {
 277                         data = QLCNIC_PORT_MODE_AUTO_NEG_XG;
 278                         QLCWR32(adapter, QLCNIC_PORT_MODE_ADDR, data);
 279                 } else {
 280                         data = QLCNIC_PORT_MODE_AUTO_NEG;
 281                         QLCWR32(adapter, QLCNIC_PORT_MODE_ADDR, data);
 282                 }
 283
 284                 if ((wol_port_mode != QLCNIC_PORT_MODE_802_3_AP) &&
 285                         (wol_port_mode != QLCNIC_PORT_MODE_XG) &&
 286                         (wol_port_mode != QLCNIC_PORT_MODE_AUTO_NEG_1G) &&
 287                         (wol_port_mode != QLCNIC_PORT_MODE_AUTO_NEG_XG)) {
 288                         wol_port_mode = QLCNIC_PORT_MODE_AUTO_NEG;
 289                 }
 290                 QLCWR32(adapter, QLCNIC_WOL_PORT_MODE, wol_port_mode);
 291         }
 292 }
 293
 294 static void qlcnic_set_msix_bit(struct pci_dev *pdev, int enable)
 295 {
 296         u32 control;
 297         int pos;
 298
 299         pos = pci_find_capability(pdev, PCI_CAP_ID_MSIX);
 300         if (pos) {
 301                 pci_read_config_dword(pdev, pos, &control);
 302                 if (enable)
 303                         control |= PCI_MSIX_FLAGS_ENABLE;
 304                 else
 305                         control = 0;
 306                 pci_write_config_dword(pdev, pos, control);
 307         }
 308 }
 309
 310 static void qlcnic_init_msix_entries(struct qlcnic_adapter *adapter, int count)
 311 {
 312         int i;
 313
 314         for (i = 0; i < count; i++)
 315                 adapter->msix_entries[i].entry = i;
 316 }
 317
 318 static int
 319 qlcnic_read_mac_addr(struct qlcnic_adapter *adapter)
 320 {
 321         u8 mac_addr[ETH_ALEN];
 322         struct net_device *netdev = adapter->netdev;
 323         struct pci_dev *pdev = adapter->pdev;
 324
 325         if (adapter->nic_ops->get_mac_addr(adapter, mac_addr) != 0)
 326                 return -EIO;
 327
 328         memcpy(netdev->dev_addr, mac_addr, ETH_ALEN);
 329         memcpy(netdev->perm_addr, netdev->dev_addr, netdev->addr_len);
 330         memcpy(adapter->mac_addr, netdev->dev_addr, netdev->addr_len);
 331
 332         /* set station address */
 333
 334         if (!is_valid_ether_addr(netdev->perm_addr))
 335                 dev_warn(&pdev->dev, "Bad MAC address %pM.\n",
 336                                         netdev->dev_addr);
 337
 338         return 0;
 339 }
 340
 341 static int qlcnic_set_mac(struct net_device *netdev, void *p)
 342 {
 343         struct qlcnic_adapter *adapter = netdev_priv(netdev);
 344         struct sockaddr *addr = p;
 345
 346         if (!is_valid_ether_addr(addr->sa_data))
 347                 return -EINVAL;
 348
 349         if (test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
 350                 netif_device_detach(netdev);
 351                 qlcnic_napi_disable(adapter);
 352         }
 353
 354         memcpy(adapter->mac_addr, addr->sa_data, netdev->addr_len);
 355         memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
 356         qlcnic_set_multi(adapter->netdev);
 357
 358         if (test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
 359                 netif_device_attach(netdev);
 360                 qlcnic_napi_enable(adapter);
 361         }
 362         return 0;
 363 }
 364
 365 static const struct net_device_ops qlcnic_netdev_ops = {
 366         .ndo_open          = qlcnic_open,
 367         .ndo_stop          = qlcnic_close,
 368         .ndo_start_xmit    = qlcnic_xmit_frame,
 369         .ndo_get_stats     = qlcnic_get_stats,
 370         .ndo_validate_addr = eth_validate_addr,
 371         .ndo_set_multicast_list = qlcnic_set_multi,
 372         .ndo_set_mac_address    = qlcnic_set_mac,
 373         .ndo_change_mtu    = qlcnic_change_mtu,
 374         .ndo_tx_timeout    = qlcnic_tx_timeout,
 375 #ifdef CONFIG_NET_POLL_CONTROLLER
 376         .ndo_poll_controller = qlcnic_poll_controller,
 377 #endif
 378 };
 379
 380 static struct qlcnic_nic_template qlcnic_ops = {
 381         .get_mac_addr = qlcnic_get_mac_address,
 382         .config_bridged_mode = qlcnic_config_bridged_mode,
 383         .config_led = qlcnic_config_led,
 384         .start_firmware = qlcnic_start_firmware
 385 };
 386
 387 static struct qlcnic_nic_template qlcnic_vf_ops = {
 388         .get_mac_addr = qlcnic_get_mac_address,
 389         .config_bridged_mode = qlcnicvf_config_bridged_mode,
 390         .config_led = qlcnicvf_config_led,
 391         .start_firmware = qlcnicvf_start_firmware
 392 };
 393
 394 static void
 395 qlcnic_setup_intr(struct qlcnic_adapter *adapter)
 396 {
 397         const struct qlcnic_legacy_intr_set *legacy_intrp;
 398         struct pci_dev *pdev = adapter->pdev;
 399         int err, num_msix;
 400
 401         if (adapter->rss_supported) {
 402                 num_msix = (num_online_cpus() >= MSIX_ENTRIES_PER_ADAPTER) ?
 403                         MSIX_ENTRIES_PER_ADAPTER : 2;
 404         } else
 405                 num_msix = 1;
 406
 407         adapter->max_sds_rings = 1;
 408
 409         adapter->flags &= ~(QLCNIC_MSI_ENABLED | QLCNIC_MSIX_ENABLED);
 410
 411         legacy_intrp = &legacy_intr[adapter->ahw.pci_func];
 412
 413         adapter->int_vec_bit = legacy_intrp->int_vec_bit;
 414         adapter->tgt_status_reg = qlcnic_get_ioaddr(adapter,
 415                         legacy_intrp->tgt_status_reg);
 416         adapter->tgt_mask_reg = qlcnic_get_ioaddr(adapter,
 417                         legacy_intrp->tgt_mask_reg);
 418         adapter->isr_int_vec = qlcnic_get_ioaddr(adapter, ISR_INT_VECTOR);
 419
 420         adapter->crb_int_state_reg = qlcnic_get_ioaddr(adapter,
 421                         ISR_INT_STATE_REG);
 422
 423         qlcnic_set_msix_bit(pdev, 0);
 424
 425         if (adapter->msix_supported) {
 426
 427                 qlcnic_init_msix_entries(adapter, num_msix);
 428                 err = pci_enable_msix(pdev, adapter->msix_entries, num_msix);
 429                 if (err == 0) {
 430                         adapter->flags |= QLCNIC_MSIX_ENABLED;
 431                         qlcnic_set_msix_bit(pdev, 1);
 432
 433                         if (adapter->rss_supported)
 434                                 adapter->max_sds_rings = num_msix;
 435
 436                         dev_info(&pdev->dev, "using msi-x interrupts\n");
 437                         return;
 438                 }
 439
 440                 if (err > 0)
 441                         pci_disable_msix(pdev);
 442
 443                 /* fall through for msi */
 444         }
 445
 446         if (use_msi && !pci_enable_msi(pdev)) {
 447                 adapter->flags |= QLCNIC_MSI_ENABLED;
 448                 adapter->tgt_status_reg = qlcnic_get_ioaddr(adapter,
 449                                 msi_tgt_status[adapter->ahw.pci_func]);
 450                 dev_info(&pdev->dev, "using msi interrupts\n");
 451                 adapter->msix_entries[0].vector = pdev->irq;
 452                 return;
 453         }
 454
 455         dev_info(&pdev->dev, "using legacy interrupts\n");
 456         adapter->msix_entries[0].vector = pdev->irq;
 457 }
 458
 459 static void
 460 qlcnic_teardown_intr(struct qlcnic_adapter *adapter)
 461 {
 462         if (adapter->flags & QLCNIC_MSIX_ENABLED)
 463                 pci_disable_msix(adapter->pdev);
 464         if (adapter->flags & QLCNIC_MSI_ENABLED)
 465                 pci_disable_msi(adapter->pdev);
 466 }
 467
 468 static void
 469 qlcnic_cleanup_pci_map(struct qlcnic_adapter *adapter)
 470 {
 471         if (adapter->ahw.pci_base0 != NULL)
 472                 iounmap(adapter->ahw.pci_base0);
 473 }
 474
 475 static int
 476 qlcnic_init_pci_info(struct qlcnic_adapter *adapter)
 477 {
 478         struct qlcnic_pci_info *pci_info;
 479         int i, ret = 0;
 480         u8 pfn;
 481
 482         pci_info = kcalloc(QLCNIC_MAX_PCI_FUNC, sizeof(*pci_info), GFP_KERNEL);
 483         if (!pci_info)
 484                 return -ENOMEM;
 485
 486         adapter->npars = kzalloc(sizeof(struct qlcnic_npar_info) *
 487                                 QLCNIC_MAX_PCI_FUNC, GFP_KERNEL);
 488         if (!adapter->npars) {
 489                 ret = -ENOMEM;
 490                 goto err_pci_info;
 491         }
 492
 493         adapter->eswitch = kzalloc(sizeof(struct qlcnic_eswitch) *
 494                                 QLCNIC_NIU_MAX_XG_PORTS, GFP_KERNEL);
 495         if (!adapter->eswitch) {
 496                 ret = -ENOMEM;
 497                 goto err_npars;
 498         }
 499
 500         ret = qlcnic_get_pci_info(adapter, pci_info);
 501         if (ret)
 502                 goto err_eswitch;
 503
 504         for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
 505                 pfn = pci_info[i].id;
 506                 if (pfn > QLCNIC_MAX_PCI_FUNC)
 507                         return QL_STATUS_INVALID_PARAM;
 508                 adapter->npars[pfn].active = pci_info[i].active;
 509                 adapter->npars[pfn].type = pci_info[i].type;
 510                 adapter->npars[pfn].phy_port = pci_info[i].default_port;
 511                 adapter->npars[pfn].min_bw = pci_info[i].tx_min_bw;
 512                 adapter->npars[pfn].max_bw = pci_info[i].tx_max_bw;
 513         }
 514
 515         for (i = 0; i < QLCNIC_NIU_MAX_XG_PORTS; i++)
 516                 adapter->eswitch[i].flags |= QLCNIC_SWITCH_ENABLE;
 517
 518         kfree(pci_info);
 519         return 0;
 520
 521 err_eswitch:
 522         kfree(adapter->eswitch);
 523         adapter->eswitch = NULL;
 524 err_npars:
 525         kfree(adapter->npars);
 526         adapter->npars = NULL;
 527 err_pci_info:
 528         kfree(pci_info);
 529
 530         return ret;
 531 }
 532
 533 static int
 534 qlcnic_set_function_modes(struct qlcnic_adapter *adapter)
 535 {
 536         u8 id;
 537         u32 ref_count;
 538         int i, ret = 1;
 539         u32 data = QLCNIC_MGMT_FUNC;
 540         void __iomem *priv_op = adapter->ahw.pci_base0 + QLCNIC_DRV_OP_MODE;
 541
 542         /* If other drivers are not in use set their privilege level */
 543         ref_count = QLCRD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
 544         ret = qlcnic_api_lock(adapter);
 545         if (ret)
 546                 goto err_lock;
 547
 548         if (qlcnic_config_npars) {
 549                 for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
 550                         id = i;
 551                         if (adapter->npars[i].type != QLCNIC_TYPE_NIC ||
 552                                 id == adapter->ahw.pci_func)
 553                                 continue;
 554                         data |= (qlcnic_config_npars &
 555                                         QLC_DEV_SET_DRV(0xf, id));
 556                 }
 557         } else {
 558                 data = readl(priv_op);
 559                 data = (data & ~QLC_DEV_SET_DRV(0xf, adapter->ahw.pci_func)) |
 560                         (QLC_DEV_SET_DRV(QLCNIC_MGMT_FUNC,
 561                         adapter->ahw.pci_func));
 562         }
 563         writel(data, priv_op);
 564         qlcnic_api_unlock(adapter);
 565 err_lock:
 566         return ret;
 567 }
 568
 569 static u32
 570 qlcnic_get_driver_mode(struct qlcnic_adapter *adapter)
 571 {
 572         void __iomem *msix_base_addr;
 573         void __iomem *priv_op;
 574         struct qlcnic_info nic_info;
 575         u32 func;
 576         u32 msix_base;
 577         u32 op_mode, priv_level;
 578
 579         /* Determine FW API version */
 580         adapter->fw_hal_version = readl(adapter->ahw.pci_base0 + QLCNIC_FW_API);
 581
 582         /* Find PCI function number */
 583         pci_read_config_dword(adapter->pdev, QLCNIC_MSIX_TABLE_OFFSET, &func);
 584         msix_base_addr = adapter->ahw.pci_base0 + QLCNIC_MSIX_BASE;
 585         msix_base = readl(msix_base_addr);
 586         func = (func - msix_base)/QLCNIC_MSIX_TBL_PGSIZE;
 587         adapter->ahw.pci_func = func;
 588
 589         if (!qlcnic_get_nic_info(adapter, &nic_info, adapter->ahw.pci_func)) {
 590                 adapter->capabilities = nic_info.capabilities;
 591
 592                 if (adapter->capabilities & BIT_6)
 593                         adapter->flags |= QLCNIC_ESWITCH_ENABLED;
 594                 else
 595                         adapter->flags &= ~QLCNIC_ESWITCH_ENABLED;
 596         }
 597
 598         if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED)) {
 599                 adapter->nic_ops = &qlcnic_ops;
 600                 return adapter->fw_hal_version;
 601         }
 602
 603         /* Determine function privilege level */
 604         priv_op = adapter->ahw.pci_base0 + QLCNIC_DRV_OP_MODE;
 605         op_mode = readl(priv_op);
 606         if (op_mode == QLC_DEV_DRV_DEFAULT)
 607                 priv_level = QLCNIC_MGMT_FUNC;
 608         else
 609                 priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw.pci_func);
 610
 611         switch (priv_level) {
 612         case QLCNIC_MGMT_FUNC:
 613                 adapter->op_mode = QLCNIC_MGMT_FUNC;
 614                 adapter->nic_ops = &qlcnic_ops;
 615                 qlcnic_init_pci_info(adapter);
 616                 /* Set privilege level for other functions */
 617                 qlcnic_set_function_modes(adapter);
 618                 dev_info(&adapter->pdev->dev,
 619                         "HAL Version: %d, Management function\n",
 620                         adapter->fw_hal_version);
 621                 break;
 622         case QLCNIC_PRIV_FUNC:
 623                 adapter->op_mode = QLCNIC_PRIV_FUNC;
 624                 dev_info(&adapter->pdev->dev,
 625                         "HAL Version: %d, Privileged function\n",
 626                         adapter->fw_hal_version);
 627                 adapter->nic_ops = &qlcnic_ops;
 628                 break;
 629         case QLCNIC_NON_PRIV_FUNC:
 630                 adapter->op_mode = QLCNIC_NON_PRIV_FUNC;
 631                 dev_info(&adapter->pdev->dev,
 632                         "HAL Version: %d Non Privileged function\n",
 633                         adapter->fw_hal_version);
 634                 adapter->nic_ops = &qlcnic_vf_ops;
 635                 break;
 636         default:
 637                 dev_info(&adapter->pdev->dev, "Unknown function mode: %d\n",
 638                         priv_level);
 639                 return 0;
 640         }
 641         return adapter->fw_hal_version;
 642 }
 643
 644 static int
 645 qlcnic_setup_pci_map(struct qlcnic_adapter *adapter)
 646 {
 647         void __iomem *mem_ptr0 = NULL;
 648         resource_size_t mem_base;
 649         unsigned long mem_len, pci_len0 = 0;
 650
 651         struct pci_dev *pdev = adapter->pdev;
 652
 653         /* remap phys address */
 654         mem_base = pci_resource_start(pdev, 0); /* 0 is for BAR 0 */
 655         mem_len = pci_resource_len(pdev, 0);
 656
 657         if (mem_len == QLCNIC_PCI_2MB_SIZE) {
 658
 659                 mem_ptr0 = pci_ioremap_bar(pdev, 0);
 660                 if (mem_ptr0 == NULL) {
 661                         dev_err(&pdev->dev, "failed to map PCI bar 0\n");
 662                         return -EIO;
 663                 }
 664                 pci_len0 = mem_len;
 665         } else {
 666                 return -EIO;
 667         }
 668
 669         dev_info(&pdev->dev, "%dMB memory map\n", (int)(mem_len>>20));
 670
 671         adapter->ahw.pci_base0 = mem_ptr0;
 672         adapter->ahw.pci_len0 = pci_len0;
 673
 674         if (!qlcnic_get_driver_mode(adapter)) {
 675                 iounmap(adapter->ahw.pci_base0);
 676                 return -EIO;
 677         }
 678
 679         adapter->ahw.ocm_win_crb = qlcnic_get_ioaddr(adapter,
 680                 QLCNIC_PCIX_PS_REG(PCIX_OCM_WINDOW_REG(adapter->ahw.pci_func)));
 681
 682         return 0;
 683 }
 684
 685 static void get_brd_name(struct qlcnic_adapter *adapter, char *name)
 686 {
 687         struct pci_dev *pdev = adapter->pdev;
 688         int i, found = 0;
 689
 690         for (i = 0; i < NUM_SUPPORTED_BOARDS; ++i) {
 691                 if (qlcnic_boards[i].vendor == pdev->vendor &&
 692                         qlcnic_boards[i].device == pdev->device &&
 693                         qlcnic_boards[i].sub_vendor == pdev->subsystem_vendor &&
 694                         qlcnic_boards[i].sub_device == pdev->subsystem_device) {
 695                                 sprintf(name, "%pM: %s" ,
 696                                         adapter->mac_addr,
 697                                         qlcnic_boards[i].short_name);
 698                                 found = 1;
 699                                 break;
 700                 }
 701
 702         }
 703
 704         if (!found)
 705                 sprintf(name, "%pM Gigabit Ethernet", adapter->mac_addr);
 706 }
 707
 708 static void
 709 qlcnic_check_options(struct qlcnic_adapter *adapter)
 710 {
 711         u32 fw_major, fw_minor, fw_build;
 712         char brd_name[QLCNIC_MAX_BOARD_NAME_LEN];
 713         struct pci_dev *pdev = adapter->pdev;
 714         struct qlcnic_info nic_info;
 715
 716         fw_major = QLCRD32(adapter, QLCNIC_FW_VERSION_MAJOR);
 717         fw_minor = QLCRD32(adapter, QLCNIC_FW_VERSION_MINOR);
 718         fw_build = QLCRD32(adapter, QLCNIC_FW_VERSION_SUB);
 719
 720         adapter->fw_version = QLCNIC_VERSION_CODE(fw_major, fw_minor, fw_build);
 721
 722         if (adapter->portnum == 0) {
 723                 get_brd_name(adapter, brd_name);
 724
 725                 pr_info("%s: %s Board Chip rev 0x%x\n",
 726                                 module_name(THIS_MODULE),
 727                                 brd_name, adapter->ahw.revision_id);
 728         }
 729
 730         dev_info(&pdev->dev, "firmware v%d.%d.%d\n",
 731                         fw_major, fw_minor, fw_build);
 732
 733         adapter->flags &= ~QLCNIC_LRO_ENABLED;
 734
 735         if (adapter->ahw.port_type == QLCNIC_XGBE) {
 736                 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_10G;
 737                 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
 738         } else if (adapter->ahw.port_type == QLCNIC_GBE) {
 739                 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_1G;
 740                 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
 741         }
 742
 743         if (!qlcnic_get_nic_info(adapter, &nic_info, adapter->ahw.pci_func)) {
 744                 adapter->physical_port = nic_info.phys_port;
 745                 adapter->switch_mode = nic_info.switch_mode;
 746                 adapter->max_tx_ques = nic_info.max_tx_ques;
 747                 adapter->max_rx_ques = nic_info.max_rx_ques;
 748                 adapter->capabilities = nic_info.capabilities;
 749                 adapter->max_mac_filters = nic_info.max_mac_filters;
 750                 adapter->max_mtu = nic_info.max_mtu;
 751         }
 752
 753         adapter->msix_supported = !!use_msi_x;
 754         adapter->rss_supported = !!use_msi_x;
 755
 756         adapter->num_txd = MAX_CMD_DESCRIPTORS;
 757
 758         adapter->max_rds_rings = MAX_RDS_RINGS;
 759 }
 760
 761 static void
 762 qlcnic_set_vlan_config(struct qlcnic_adapter *adapter,
 763                 struct qlcnic_esw_func_cfg *esw_cfg)
 764 {
 765         if (esw_cfg->discard_tagged)
 766                 adapter->flags &= ~QLCNIC_TAGGING_ENABLED;
 767         else
 768                 adapter->flags |= QLCNIC_TAGGING_ENABLED;
 769
 770         if (esw_cfg->vlan_id)
 771                 adapter->pvid = esw_cfg->vlan_id;
 772         else
 773                 adapter->pvid = 0;
 774 }
 775
 776 static void
 777 qlcnic_set_eswitch_port_features(struct qlcnic_adapter *adapter,
 778                 struct qlcnic_esw_func_cfg *esw_cfg)
 779 {
 780         adapter->flags &= ~QLCNIC_MACSPOOF;
 781         if (adapter->op_mode == QLCNIC_NON_PRIV_FUNC)
 782                 if (esw_cfg->mac_anti_spoof)
 783                         adapter->flags |= QLCNIC_MACSPOOF;
 784
 785         qlcnic_set_netdev_features(adapter, esw_cfg);
 786 }
 787
 788 static int
 789 qlcnic_set_eswitch_port_config(struct qlcnic_adapter *adapter)
 790 {
 791         struct qlcnic_esw_func_cfg esw_cfg;
 792
 793         if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
 794                 return 0;
 795
 796         esw_cfg.pci_func = adapter->ahw.pci_func;
 797         if (qlcnic_get_eswitch_port_config(adapter, &esw_cfg))
 798                         return -EIO;
 799         qlcnic_set_vlan_config(adapter, &esw_cfg);
 800         qlcnic_set_eswitch_port_features(adapter, &esw_cfg);
 801
 802         return 0;
 803 }
 804
 805 static void
 806 qlcnic_set_netdev_features(struct qlcnic_adapter *adapter,
 807                 struct qlcnic_esw_func_cfg *esw_cfg)
 808 {
 809         struct net_device *netdev = adapter->netdev;
 810         unsigned long features, vlan_features;
 811
 812         features = (NETIF_F_SG | NETIF_F_IP_CSUM |
 813                         NETIF_F_IPV6_CSUM | NETIF_F_GRO);
 814         vlan_features = (NETIF_F_SG | NETIF_F_IP_CSUM |
 815                         NETIF_F_IPV6_CSUM);
 816
 817         if (adapter->capabilities & QLCNIC_FW_CAPABILITY_TSO) {
 818                 features |= (NETIF_F_TSO | NETIF_F_TSO6);
 819                 vlan_features |= (NETIF_F_TSO | NETIF_F_TSO6);
 820         }
 821         if (adapter->capabilities & QLCNIC_FW_CAPABILITY_HW_LRO)
 822                 features |= NETIF_F_LRO;
 823
 824         if (esw_cfg->offload_flags & BIT_0) {
 825                 netdev->features |= features;
 826                 adapter->rx_csum = 1;
 827                 if (!(esw_cfg->offload_flags & BIT_1))
 828                         netdev->features &= ~NETIF_F_TSO;
 829                 if (!(esw_cfg->offload_flags & BIT_2))
 830                         netdev->features &= ~NETIF_F_TSO6;
 831         } else {
 832                 netdev->features &= ~features;
 833                 adapter->rx_csum = 0;
 834         }
 835
 836         netdev->vlan_features = (features & vlan_features);
 837 }
 838
 839 static int
 840 qlcnic_set_default_offload_settings(struct qlcnic_adapter *adapter)
 841 {
 842         struct qlcnic_esw_func_cfg esw_cfg;
 843         struct qlcnic_npar_info *npar;
 844         u8 i;
 845
 846         if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED) ||
 847             adapter->need_fw_reset ||
 848             adapter->op_mode != QLCNIC_MGMT_FUNC)
 849                 return 0;
 850
 851         for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
 852                 if (adapter->npars[i].type != QLCNIC_TYPE_NIC)
 853                         continue;
 854                 memset(&esw_cfg, 0, sizeof(struct qlcnic_esw_func_cfg));
 855                 esw_cfg.pci_func = i;
 856                 esw_cfg.offload_flags = BIT_0;
 857                 esw_cfg.mac_learning = BIT_0;
 858                 if (adapter->capabilities  & QLCNIC_FW_CAPABILITY_TSO)
 859                         esw_cfg.offload_flags |= (BIT_1 | BIT_2);
 860                 if (qlcnic_config_switch_port(adapter, &esw_cfg))
 861                         return -EIO;
 862                 npar = &adapter->npars[i];
 863                 npar->pvid = esw_cfg.vlan_id;
 864                 npar->mac_learning = esw_cfg.offload_flags;
 865                 npar->mac_anti_spoof = esw_cfg.mac_anti_spoof;
 866                 npar->discard_tagged = esw_cfg.discard_tagged;
 867                 npar->promisc_mode = esw_cfg.promisc_mode;
 868                 npar->offload_flags = esw_cfg.offload_flags;
 869         }
 870
 871         return 0;
 872 }
 873
 874 static int
 875 qlcnic_reset_eswitch_config(struct qlcnic_adapter *adapter,
 876                         struct qlcnic_npar_info *npar, int pci_func)
 877 {
 878         struct qlcnic_esw_func_cfg esw_cfg;
 879         esw_cfg.op_mode = QLCNIC_PORT_DEFAULTS;
 880         esw_cfg.pci_func = pci_func;
 881         esw_cfg.vlan_id = npar->pvid;
 882         esw_cfg.mac_learning = npar->mac_learning;
 883         esw_cfg.discard_tagged = npar->discard_tagged;
 884         esw_cfg.mac_anti_spoof = npar->mac_anti_spoof;
 885         esw_cfg.offload_flags = npar->offload_flags;
 886         esw_cfg.promisc_mode = npar->promisc_mode;
 887         if (qlcnic_config_switch_port(adapter, &esw_cfg))
 888                 return -EIO;
 889
 890         esw_cfg.op_mode = QLCNIC_ADD_VLAN;
 891         if (qlcnic_config_switch_port(adapter, &esw_cfg))
 892                 return -EIO;
 893
 894         return 0;
 895 }
 896
 897 static int
 898 qlcnic_reset_npar_config(struct qlcnic_adapter *adapter)
 899 {
 900         int i, err;
 901         struct qlcnic_npar_info *npar;
 902         struct qlcnic_info nic_info;
 903
 904         if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED) ||
 905             !adapter->need_fw_reset || adapter->op_mode != QLCNIC_MGMT_FUNC)
 906                 return 0;
 907
 908         /* Set the NPAR config data after FW reset */
 909         for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
 910                 npar = &adapter->npars[i];
 911                 if (npar->type != QLCNIC_TYPE_NIC)
 912                         continue;
 913                 err = qlcnic_get_nic_info(adapter, &nic_info, i);
 914                 if (err)
 915                         return err;
 916                 nic_info.min_tx_bw = npar->min_bw;
 917                 nic_info.max_tx_bw = npar->max_bw;
 918                 err = qlcnic_set_nic_info(adapter, &nic_info);
 919                 if (err)
 920                         return err;
 921
 922                 if (npar->enable_pm) {
 923                         err = qlcnic_config_port_mirroring(adapter,
 924                                                         npar->dest_npar, 1, i);
 925                         if (err)
 926                                 return err;
 927                 }
 928                 err = qlcnic_reset_eswitch_config(adapter, npar, i);
 929                 if (err)
 930                         return err;
 931         }
 932         return 0;
 933 }
 934
 935 static int qlcnic_check_npar_opertional(struct qlcnic_adapter *adapter)
 936 {
 937         u8 npar_opt_timeo = QLCNIC_DEV_NPAR_OPER_TIMEO;
 938         u32 npar_state;
 939
 940         if (adapter->op_mode == QLCNIC_MGMT_FUNC)
 941                 return 0;
 942
 943         npar_state = QLCRD32(adapter, QLCNIC_CRB_DEV_NPAR_STATE);
 944         while (npar_state != QLCNIC_DEV_NPAR_OPER && --npar_opt_timeo) {
 945                 msleep(1000);
 946                 npar_state = QLCRD32(adapter, QLCNIC_CRB_DEV_NPAR_STATE);
 947         }
 948         if (!npar_opt_timeo) {
 949                 dev_err(&adapter->pdev->dev,
 950                         "Waiting for NPAR state to opertional timeout\n");
 951                 return -EIO;
 952         }
 953         return 0;
 954 }
 955
 956 static int
 957 qlcnic_start_firmware(struct qlcnic_adapter *adapter)
 958 {
 959         int err;
 960
 961         err = qlcnic_can_start_firmware(adapter);
 962         if (err < 0)
 963                 return err;
 964         else if (!err)
 965                 goto check_fw_status;
 966
 967         if (load_fw_file)
 968                 qlcnic_request_firmware(adapter);
 969         else {
 970                 if (qlcnic_check_flash_fw_ver(adapter))
 971                         goto err_out;
 972
 973                 adapter->fw_type = QLCNIC_FLASH_ROMIMAGE;
 974         }
 975
 976         err = qlcnic_need_fw_reset(adapter);
 977         if (err == 0)
 978                 goto set_dev_ready;
 979
 980         err = qlcnic_pinit_from_rom(adapter);
 981         if (err)
 982                 goto err_out;
 983         qlcnic_set_port_mode(adapter);
 984
 985         err = qlcnic_load_firmware(adapter);
 986         if (err)
 987                 goto err_out;
 988
 989         qlcnic_release_firmware(adapter);
 990         QLCWR32(adapter, CRB_DRIVER_VERSION, QLCNIC_DRIVER_VERSION);
 991
 992 check_fw_status:
 993         err = qlcnic_check_fw_status(adapter);
 994         if (err)
 995                 goto err_out;
 996
 997 set_dev_ready:
 998         QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_READY);
 999         qlcnic_idc_debug_info(adapter, 1);
1000
1001         if (qlcnic_set_default_offload_settings(adapter))
1002                 goto err_out;
1003         if (qlcnic_reset_npar_config(adapter))
1004                 goto err_out;
1005         qlcnic_dev_set_npar_ready(adapter);
1006         qlcnic_check_options(adapter);
1007         adapter->need_fw_reset = 0;
1008
1009         qlcnic_release_firmware(adapter);
1010         return 0;
1011
1012 err_out:
1013         QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_FAILED);
1014         dev_err(&adapter->pdev->dev, "Device state set to failed\n");
1015         qlcnic_release_firmware(adapter);
1016         return err;
1017 }
1018
1019 static int
1020 qlcnic_request_irq(struct qlcnic_adapter *adapter)
1021 {
1022         irq_handler_t handler;
1023         struct qlcnic_host_sds_ring *sds_ring;
1024         int err, ring;
1025
1026         unsigned long flags = 0;
1027         struct net_device *netdev = adapter->netdev;
1028         struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
1029
1030         if (adapter->diag_test == QLCNIC_INTERRUPT_TEST) {
1031                 handler = qlcnic_tmp_intr;
1032                 if (!QLCNIC_IS_MSI_FAMILY(adapter))
1033                         flags |= IRQF_SHARED;
1034
1035         } else {
1036                 if (adapter->flags & QLCNIC_MSIX_ENABLED)
1037                         handler = qlcnic_msix_intr;
1038                 else if (adapter->flags & QLCNIC_MSI_ENABLED)
1039                         handler = qlcnic_msi_intr;
1040                 else {
1041                         flags |= IRQF_SHARED;
1042                         handler = qlcnic_intr;
1043                 }
1044         }
1045         adapter->irq = netdev->irq;
1046
1047         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1048                 sds_ring = &recv_ctx->sds_rings[ring];
1049                 sprintf(sds_ring->name, "%s[%d]", netdev->name, ring);
1050                 err = request_irq(sds_ring->irq, handler,
1051                                   flags, sds_ring->name, sds_ring);
1052                 if (err)
1053                         return err;
1054         }
1055
1056         return 0;
1057 }
1058
1059 static void
1060 qlcnic_free_irq(struct qlcnic_adapter *adapter)
1061 {
1062         int ring;
1063         struct qlcnic_host_sds_ring *sds_ring;
1064
1065         struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
1066
1067         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1068                 sds_ring = &recv_ctx->sds_rings[ring];
1069                 free_irq(sds_ring->irq, sds_ring);
1070         }
1071 }
1072
1073 static void
1074 qlcnic_init_coalesce_defaults(struct qlcnic_adapter *adapter)
1075 {
1076         adapter->coal.flags = QLCNIC_INTR_DEFAULT;
1077         adapter->coal.normal.data.rx_time_us =
1078                 QLCNIC_DEFAULT_INTR_COALESCE_RX_TIME_US;
1079         adapter->coal.normal.data.rx_packets =
1080                 QLCNIC_DEFAULT_INTR_COALESCE_RX_PACKETS;
1081         adapter->coal.normal.data.tx_time_us =
1082                 QLCNIC_DEFAULT_INTR_COALESCE_TX_TIME_US;
1083         adapter->coal.normal.data.tx_packets =
1084                 QLCNIC_DEFAULT_INTR_COALESCE_TX_PACKETS;
1085 }
1086
1087 static int
1088 __qlcnic_up(struct qlcnic_adapter *adapter, struct net_device *netdev)
1089 {
1090         int ring;
1091         struct qlcnic_host_rds_ring *rds_ring;
1092
1093         if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1094                 return -EIO;
1095
1096         if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
1097                 return 0;
1098         if (qlcnic_set_eswitch_port_config(adapter))
1099                 return -EIO;
1100
1101         if (qlcnic_fw_create_ctx(adapter))
1102                 return -EIO;
1103
1104         for (ring = 0; ring < adapter->max_rds_rings; ring++) {
1105                 rds_ring = &adapter->recv_ctx.rds_rings[ring];
1106                 qlcnic_post_rx_buffers(adapter, ring, rds_ring);
1107         }
1108
1109         qlcnic_set_multi(netdev);
1110         qlcnic_fw_cmd_set_mtu(adapter, netdev->mtu);
1111
1112         adapter->ahw.linkup = 0;
1113
1114         if (adapter->max_sds_rings > 1)
1115                 qlcnic_config_rss(adapter, 1);
1116
1117         qlcnic_config_intr_coalesce(adapter);
1118
1119         if (netdev->features & NETIF_F_LRO)
1120                 qlcnic_config_hw_lro(adapter, QLCNIC_LRO_ENABLED);
1121
1122         qlcnic_napi_enable(adapter);
1123
1124         qlcnic_linkevent_request(adapter, 1);
1125
1126         adapter->reset_context = 0;
1127         set_bit(__QLCNIC_DEV_UP, &adapter->state);
1128         return 0;
1129 }
1130
1131 /* Usage: During resume and firmware recovery module.*/
1132
1133 static int
1134 qlcnic_up(struct qlcnic_adapter *adapter, struct net_device *netdev)
1135 {
1136         int err = 0;
1137
1138         rtnl_lock();
1139         if (netif_running(netdev))
1140                 err = __qlcnic_up(adapter, netdev);
1141         rtnl_unlock();
1142
1143         return err;
1144 }
1145
1146 static void
1147 __qlcnic_down(struct qlcnic_adapter *adapter, struct net_device *netdev)
1148 {
1149         if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1150                 return;
1151
1152         if (!test_and_clear_bit(__QLCNIC_DEV_UP, &adapter->state))
1153                 return;
1154
1155         smp_mb();
1156         spin_lock(&adapter->tx_clean_lock);
1157         netif_carrier_off(netdev);
1158         netif_tx_disable(netdev);
1159
1160         qlcnic_free_mac_list(adapter);
1161
1162         qlcnic_nic_set_promisc(adapter, QLCNIC_NIU_NON_PROMISC_MODE);
1163
1164         qlcnic_napi_disable(adapter);
1165
1166         qlcnic_fw_destroy_ctx(adapter);
1167
1168         qlcnic_reset_rx_buffers_list(adapter);
1169         qlcnic_release_tx_buffers(adapter);
1170         spin_unlock(&adapter->tx_clean_lock);
1171 }
1172
1173 /* Usage: During suspend and firmware recovery module */
1174
1175 static void
1176 qlcnic_down(struct qlcnic_adapter *adapter, struct net_device *netdev)
1177 {
1178         rtnl_lock();
1179         if (netif_running(netdev))
1180                 __qlcnic_down(adapter, netdev);
1181         rtnl_unlock();
1182
1183 }
1184
1185 static int
1186 qlcnic_attach(struct qlcnic_adapter *adapter)
1187 {
1188         struct net_device *netdev = adapter->netdev;
1189         struct pci_dev *pdev = adapter->pdev;
1190         int err;
1191
1192         if (adapter->is_up == QLCNIC_ADAPTER_UP_MAGIC)
1193                 return 0;
1194
1195         err = qlcnic_napi_add(adapter, netdev);
1196         if (err)
1197                 return err;
1198
1199         err = qlcnic_alloc_sw_resources(adapter);
1200         if (err) {
1201                 dev_err(&pdev->dev, "Error in setting sw resources\n");
1202                 goto err_out_napi_del;
1203         }
1204
1205         err = qlcnic_alloc_hw_resources(adapter);
1206         if (err) {
1207                 dev_err(&pdev->dev, "Error in setting hw resources\n");
1208                 goto err_out_free_sw;
1209         }
1210
1211         err = qlcnic_request_irq(adapter);
1212         if (err) {
1213                 dev_err(&pdev->dev, "failed to setup interrupt\n");
1214                 goto err_out_free_hw;
1215         }
1216
1217         qlcnic_init_coalesce_defaults(adapter);
1218
1219         qlcnic_create_sysfs_entries(adapter);
1220
1221         adapter->is_up = QLCNIC_ADAPTER_UP_MAGIC;
1222         return 0;
1223
1224 err_out_free_hw:
1225         qlcnic_free_hw_resources(adapter);
1226 err_out_free_sw:
1227         qlcnic_free_sw_resources(adapter);
1228 err_out_napi_del:
1229         qlcnic_napi_del(adapter);
1230         return err;
1231 }
1232
1233 static void
1234 qlcnic_detach(struct qlcnic_adapter *adapter)
1235 {
1236         if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1237                 return;
1238
1239         qlcnic_remove_sysfs_entries(adapter);
1240
1241         qlcnic_free_hw_resources(adapter);
1242         qlcnic_release_rx_buffers(adapter);
1243         qlcnic_free_irq(adapter);
1244         qlcnic_napi_del(adapter);
1245         qlcnic_free_sw_resources(adapter);
1246
1247         adapter->is_up = 0;
1248 }
1249
1250 void qlcnic_diag_free_res(struct net_device *netdev, int max_sds_rings)
1251 {
1252         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1253         struct qlcnic_host_sds_ring *sds_ring;
1254         int ring;
1255
1256         clear_bit(__QLCNIC_DEV_UP, &adapter->state);
1257         if (adapter->diag_test == QLCNIC_INTERRUPT_TEST) {
1258                 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1259                         sds_ring = &adapter->recv_ctx.sds_rings[ring];
1260                         qlcnic_disable_int(sds_ring);
1261                 }
1262         }
1263
1264         qlcnic_fw_destroy_ctx(adapter);
1265
1266         qlcnic_detach(adapter);
1267
1268         adapter->diag_test = 0;
1269         adapter->max_sds_rings = max_sds_rings;
1270
1271         if (qlcnic_attach(adapter))
1272                 goto out;
1273
1274         if (netif_running(netdev))
1275                 __qlcnic_up(adapter, netdev);
1276 out:
1277         netif_device_attach(netdev);
1278 }
1279
1280 int qlcnic_diag_alloc_res(struct net_device *netdev, int test)
1281 {
1282         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1283         struct qlcnic_host_sds_ring *sds_ring;
1284         struct qlcnic_host_rds_ring *rds_ring;
1285         int ring;
1286         int ret;
1287
1288         netif_device_detach(netdev);
1289
1290         if (netif_running(netdev))
1291                 __qlcnic_down(adapter, netdev);
1292
1293         qlcnic_detach(adapter);
1294
1295         adapter->max_sds_rings = 1;
1296         adapter->diag_test = test;
1297
1298         ret = qlcnic_attach(adapter);
1299         if (ret) {
1300                 netif_device_attach(netdev);
1301                 return ret;
1302         }
1303
1304         ret = qlcnic_fw_create_ctx(adapter);
1305         if (ret) {
1306                 qlcnic_detach(adapter);
1307                 netif_device_attach(netdev);
1308                 return ret;
1309         }
1310
1311         for (ring = 0; ring < adapter->max_rds_rings; ring++) {
1312                 rds_ring = &adapter->recv_ctx.rds_rings[ring];
1313                 qlcnic_post_rx_buffers(adapter, ring, rds_ring);
1314         }
1315
1316         if (adapter->diag_test == QLCNIC_INTERRUPT_TEST) {
1317                 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1318                         sds_ring = &adapter->recv_ctx.sds_rings[ring];
1319                         qlcnic_enable_int(sds_ring);
1320                 }
1321         }
1322         set_bit(__QLCNIC_DEV_UP, &adapter->state);
1323
1324         return 0;
1325 }
1326
1327 /* Reset context in hardware only */
1328 static int
1329 qlcnic_reset_hw_context(struct qlcnic_adapter *adapter)
1330 {
1331         struct net_device *netdev = adapter->netdev;
1332
1333         if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
1334                 return -EBUSY;
1335
1336         netif_device_detach(netdev);
1337
1338         qlcnic_down(adapter, netdev);
1339
1340         qlcnic_up(adapter, netdev);
1341
1342         netif_device_attach(netdev);
1343
1344         clear_bit(__QLCNIC_RESETTING, &adapter->state);
1345         return 0;
1346 }
1347
1348 int
1349 qlcnic_reset_context(struct qlcnic_adapter *adapter)
1350 {
1351         int err = 0;
1352         struct net_device *netdev = adapter->netdev;
1353
1354         if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
1355                 return -EBUSY;
1356
1357         if (adapter->is_up == QLCNIC_ADAPTER_UP_MAGIC) {
1358
1359                 netif_device_detach(netdev);
1360
1361                 if (netif_running(netdev))
1362                         __qlcnic_down(adapter, netdev);
1363
1364                 qlcnic_detach(adapter);
1365
1366                 if (netif_running(netdev)) {
1367                         err = qlcnic_attach(adapter);
1368                         if (!err)
1369                                 __qlcnic_up(adapter, netdev);
1370                 }
1371
1372                 netif_device_attach(netdev);
1373         }
1374
1375         clear_bit(__QLCNIC_RESETTING, &adapter->state);
1376         return err;
1377 }
1378
1379 static int
1380 qlcnic_setup_netdev(struct qlcnic_adapter *adapter,
1381                 struct net_device *netdev, u8 pci_using_dac)
1382 {
1383         int err;
1384         struct pci_dev *pdev = adapter->pdev;
1385
1386         adapter->rx_csum = 1;
1387         adapter->mc_enabled = 0;
1388         adapter->max_mc_count = 38;
1389
1390         netdev->netdev_ops         = &qlcnic_netdev_ops;
1391         netdev->watchdog_timeo     = 5*HZ;
1392
1393         qlcnic_change_mtu(netdev, netdev->mtu);
1394
1395         SET_ETHTOOL_OPS(netdev, &qlcnic_ethtool_ops);
1396
1397         netdev->features |= (NETIF_F_SG | NETIF_F_IP_CSUM |
1398                 NETIF_F_IPV6_CSUM | NETIF_F_GRO);
1399         netdev->vlan_features |= (NETIF_F_SG | NETIF_F_IP_CSUM |
1400                 NETIF_F_IPV6_CSUM);
1401
1402         if (adapter->capabilities & QLCNIC_FW_CAPABILITY_TSO) {
1403                 netdev->features |= (NETIF_F_TSO | NETIF_F_TSO6);
1404                 netdev->vlan_features |= (NETIF_F_TSO | NETIF_F_TSO6);
1405         }
1406
1407         if (pci_using_dac) {
1408                 netdev->features |= NETIF_F_HIGHDMA;
1409                 netdev->vlan_features |= NETIF_F_HIGHDMA;
1410         }
1411
1412         if (adapter->capabilities & QLCNIC_FW_CAPABILITY_FVLANTX)
1413                 netdev->features |= (NETIF_F_HW_VLAN_TX);
1414
1415         if (adapter->capabilities & QLCNIC_FW_CAPABILITY_HW_LRO)
1416                 netdev->features |= NETIF_F_LRO;
1417         netdev->irq = adapter->msix_entries[0].vector;
1418
1419         if (qlcnic_read_mac_addr(adapter))
1420                 dev_warn(&pdev->dev, "failed to read mac addr\n");
1421
1422         netif_carrier_off(netdev);
1423         netif_stop_queue(netdev);
1424
1425         err = register_netdev(netdev);
1426         if (err) {
1427                 dev_err(&pdev->dev, "failed to register net device\n");
1428                 return err;
1429         }
1430
1431         return 0;
1432 }
1433
1434 static int qlcnic_set_dma_mask(struct pci_dev *pdev, u8 *pci_using_dac)
1435 {
1436         if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) &&
1437                         !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
1438                 *pci_using_dac = 1;
1439         else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) &&
1440                         !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)))
1441                 *pci_using_dac = 0;
1442         else {
1443                 dev_err(&pdev->dev, "Unable to set DMA mask, aborting\n");
1444                 return -EIO;
1445         }
1446
1447         return 0;
1448 }
1449
1450 static int __devinit
1451 qlcnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1452 {
1453         struct net_device *netdev = NULL;
1454         struct qlcnic_adapter *adapter = NULL;
1455         int err;
1456         uint8_t revision_id;
1457         uint8_t pci_using_dac;
1458
1459         err = pci_enable_device(pdev);
1460         if (err)
1461                 return err;
1462
1463         if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
1464                 err = -ENODEV;
1465                 goto err_out_disable_pdev;
1466         }
1467
1468         err = qlcnic_set_dma_mask(pdev, &pci_using_dac);
1469         if (err)
1470                 goto err_out_disable_pdev;
1471
1472         err = pci_request_regions(pdev, qlcnic_driver_name);
1473         if (err)
1474                 goto err_out_disable_pdev;
1475
1476         pci_set_master(pdev);
1477         pci_enable_pcie_error_reporting(pdev);
1478
1479         netdev = alloc_etherdev(sizeof(struct qlcnic_adapter));
1480         if (!netdev) {
1481                 dev_err(&pdev->dev, "failed to allocate net_device\n");
1482                 err = -ENOMEM;
1483                 goto err_out_free_res;
1484         }
1485
1486         SET_NETDEV_DEV(netdev, &pdev->dev);
1487
1488         adapter = netdev_priv(netdev);
1489         adapter->netdev  = netdev;
1490         adapter->pdev    = pdev;
1491         adapter->dev_rst_time = jiffies;
1492
1493         revision_id = pdev->revision;
1494         adapter->ahw.revision_id = revision_id;
1495
1496         rwlock_init(&adapter->ahw.crb_lock);
1497         mutex_init(&adapter->ahw.mem_lock);
1498
1499         spin_lock_init(&adapter->tx_clean_lock);
1500         INIT_LIST_HEAD(&adapter->mac_list);
1501
1502         err = qlcnic_setup_pci_map(adapter);
1503         if (err)
1504                 goto err_out_free_netdev;
1505
1506         /* This will be reset for mezz cards  */
1507         adapter->portnum = adapter->ahw.pci_func;
1508
1509         err = qlcnic_get_board_info(adapter);
1510         if (err) {
1511                 dev_err(&pdev->dev, "Error getting board config info.\n");
1512                 goto err_out_iounmap;
1513         }
1514
1515         if (qlcnic_read_mac_addr(adapter))
1516                 dev_warn(&pdev->dev, "failed to read mac addr\n");
1517
1518         if (qlcnic_setup_idc_param(adapter))
1519                 goto err_out_iounmap;
1520
1521         err = adapter->nic_ops->start_firmware(adapter);
1522         if (err) {
1523                 dev_err(&pdev->dev, "Loading fw failed.Please Reboot\n");
1524                 goto err_out_decr_ref;
1525         }
1526
1527         qlcnic_clear_stats(adapter);
1528
1529         qlcnic_setup_intr(adapter);
1530
1531         err = qlcnic_setup_netdev(adapter, netdev, pci_using_dac);
1532         if (err)
1533                 goto err_out_disable_msi;
1534
1535         pci_set_drvdata(pdev, adapter);
1536
1537         qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
1538
1539         switch (adapter->ahw.port_type) {
1540         case QLCNIC_GBE:
1541                 dev_info(&adapter->pdev->dev, "%s: GbE port initialized\n",
1542                                 adapter->netdev->name);
1543                 break;
1544         case QLCNIC_XGBE:
1545                 dev_info(&adapter->pdev->dev, "%s: XGbE port initialized\n",
1546                                 adapter->netdev->name);
1547                 break;
1548         }
1549
1550         qlcnic_create_diag_entries(adapter);
1551
1552         return 0;
1553
1554 err_out_disable_msi:
1555         qlcnic_teardown_intr(adapter);
1556
1557 err_out_decr_ref:
1558         qlcnic_clr_all_drv_state(adapter, 0);
1559
1560 err_out_iounmap:
1561         qlcnic_cleanup_pci_map(adapter);
1562
1563 err_out_free_netdev:
1564         free_netdev(netdev);
1565
1566 err_out_free_res:
1567         pci_release_regions(pdev);
1568
1569 err_out_disable_pdev:
1570         pci_set_drvdata(pdev, NULL);
1571         pci_disable_device(pdev);
1572         return err;
1573 }
1574
1575 static void __devexit qlcnic_remove(struct pci_dev *pdev)
1576 {
1577         struct qlcnic_adapter *adapter;
1578         struct net_device *netdev;
1579
1580         adapter = pci_get_drvdata(pdev);
1581         if (adapter == NULL)
1582                 return;
1583
1584         netdev = adapter->netdev;
1585
1586         qlcnic_cancel_fw_work(adapter);
1587
1588         unregister_netdev(netdev);
1589
1590         qlcnic_detach(adapter);
1591
1592         if (adapter->npars != NULL)
1593                 kfree(adapter->npars);
1594         if (adapter->eswitch != NULL)
1595                 kfree(adapter->eswitch);
1596
1597         qlcnic_clr_all_drv_state(adapter, 0);
1598
1599         clear_bit(__QLCNIC_RESETTING, &adapter->state);
1600
1601         qlcnic_teardown_intr(adapter);
1602
1603         qlcnic_remove_diag_entries(adapter);
1604
1605         qlcnic_cleanup_pci_map(adapter);
1606
1607         qlcnic_release_firmware(adapter);
1608
1609         pci_disable_pcie_error_reporting(pdev);
1610         pci_release_regions(pdev);
1611         pci_disable_device(pdev);
1612         pci_set_drvdata(pdev, NULL);
1613
1614         free_netdev(netdev);
1615 }
1616 static int __qlcnic_shutdown(struct pci_dev *pdev)
1617 {
1618         struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
1619         struct net_device *netdev = adapter->netdev;
1620         int retval;
1621
1622         netif_device_detach(netdev);
1623
1624         qlcnic_cancel_fw_work(adapter);
1625
1626         if (netif_running(netdev))
1627                 qlcnic_down(adapter, netdev);
1628
1629         qlcnic_clr_all_drv_state(adapter, 0);
1630
1631         clear_bit(__QLCNIC_RESETTING, &adapter->state);
1632
1633         retval = pci_save_state(pdev);
1634         if (retval)
1635                 return retval;
1636
1637         if (qlcnic_wol_supported(adapter)) {
1638                 pci_enable_wake(pdev, PCI_D3cold, 1);
1639                 pci_enable_wake(pdev, PCI_D3hot, 1);
1640         }
1641
1642         return 0;
1643 }
1644
1645 static void qlcnic_shutdown(struct pci_dev *pdev)
1646 {
1647         if (__qlcnic_shutdown(pdev))
1648                 return;
1649
1650         pci_disable_device(pdev);
1651 }
1652
1653 #ifdef CONFIG_PM
1654 static int
1655 qlcnic_suspend(struct pci_dev *pdev, pm_message_t state)
1656 {
1657         int retval;
1658
1659         retval = __qlcnic_shutdown(pdev);
1660         if (retval)
1661                 return retval;
1662
1663         pci_set_power_state(pdev, pci_choose_state(pdev, state));
1664         return 0;
1665 }
1666
1667 static int
1668 qlcnic_resume(struct pci_dev *pdev)
1669 {
1670         struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
1671         struct net_device *netdev = adapter->netdev;
1672         int err;
1673
1674         err = pci_enable_device(pdev);
1675         if (err)
1676                 return err;
1677
1678         pci_set_power_state(pdev, PCI_D0);
1679         pci_set_master(pdev);
1680         pci_restore_state(pdev);
1681
1682         err = adapter->nic_ops->start_firmware(adapter);
1683         if (err) {
1684                 dev_err(&pdev->dev, "failed to start firmware\n");
1685                 return err;
1686         }
1687
1688         if (netif_running(netdev)) {
1689                 err = qlcnic_up(adapter, netdev);
1690                 if (err)
1691                         goto done;
1692
1693                 qlcnic_config_indev_addr(netdev, NETDEV_UP);
1694         }
1695 done:
1696         netif_device_attach(netdev);
1697         qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
1698         return 0;
1699 }
1700 #endif
1701
1702 static int qlcnic_open(struct net_device *netdev)
1703 {
1704         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1705         int err;
1706
1707         err = qlcnic_attach(adapter);
1708         if (err)
1709                 return err;
1710
1711         err = __qlcnic_up(adapter, netdev);
1712         if (err)
1713                 goto err_out;
1714
1715         netif_start_queue(netdev);
1716
1717         return 0;
1718
1719 err_out:
1720         qlcnic_detach(adapter);
1721         return err;
1722 }
1723
1724 /*
1725  * qlcnic_close - Disables a network interface entry point
1726  */
1727 static int qlcnic_close(struct net_device *netdev)
1728 {
1729         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1730
1731         __qlcnic_down(adapter, netdev);
1732         return 0;
1733 }
1734
1735 static void
1736 qlcnic_tso_check(struct net_device *netdev,
1737                 struct qlcnic_host_tx_ring *tx_ring,
1738                 struct cmd_desc_type0 *first_desc,
1739                 struct sk_buff *skb)
1740 {
1741         u8 opcode = TX_ETHER_PKT;
1742         __be16 protocol = skb->protocol;
1743         u16 flags = 0;
1744         int copied, offset, copy_len, hdr_len = 0, tso = 0;
1745         struct cmd_desc_type0 *hwdesc;
1746         struct vlan_ethhdr *vh;
1747         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1748         u32 producer = tx_ring->producer;
1749         int vlan_oob = first_desc->flags_opcode & cpu_to_le16(FLAGS_VLAN_OOB);
1750
1751         if (*(skb->data) & BIT_0) {
1752                 flags |= BIT_0;
1753                 memcpy(&first_desc->eth_addr, skb->data, ETH_ALEN);
1754         }
1755
1756         if ((netdev->features & (NETIF_F_TSO | NETIF_F_TSO6)) &&
1757                         skb_shinfo(skb)->gso_size > 0) {
1758
1759                 hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
1760
1761                 first_desc->mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
1762                 first_desc->total_hdr_length = hdr_len;
1763                 if (vlan_oob) {
1764                         first_desc->total_hdr_length += VLAN_HLEN;
1765                         first_desc->tcp_hdr_offset = VLAN_HLEN;
1766                         first_desc->ip_hdr_offset = VLAN_HLEN;
1767                         /* Only in case of TSO on vlan device */
1768                         flags |= FLAGS_VLAN_TAGGED;
1769                 }
1770
1771                 opcode = (protocol == cpu_to_be16(ETH_P_IPV6)) ?
1772                                 TX_TCP_LSO6 : TX_TCP_LSO;
1773                 tso = 1;
1774
1775         } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
1776                 u8 l4proto;
1777
1778                 if (protocol == cpu_to_be16(ETH_P_IP)) {
1779                         l4proto = ip_hdr(skb)->protocol;
1780
1781                         if (l4proto == IPPROTO_TCP)
1782                                 opcode = TX_TCP_PKT;
1783                         else if (l4proto == IPPROTO_UDP)
1784                                 opcode = TX_UDP_PKT;
1785                 } else if (protocol == cpu_to_be16(ETH_P_IPV6)) {
1786                         l4proto = ipv6_hdr(skb)->nexthdr;
1787
1788                         if (l4proto == IPPROTO_TCP)
1789                                 opcode = TX_TCPV6_PKT;
1790                         else if (l4proto == IPPROTO_UDP)
1791                                 opcode = TX_UDPV6_PKT;
1792                 }
1793         }
1794
1795         first_desc->tcp_hdr_offset += skb_transport_offset(skb);
1796         first_desc->ip_hdr_offset += skb_network_offset(skb);
1797         qlcnic_set_tx_flags_opcode(first_desc, flags, opcode);
1798
1799         if (!tso)
1800                 return;
1801
1802         /* For LSO, we need to copy the MAC/IP/TCP headers into
1803          * the descriptor ring
1804          */
1805         copied = 0;
1806         offset = 2;
1807
1808         if (vlan_oob) {
1809                 /* Create a TSO vlan header template for firmware */
1810
1811                 hwdesc = &tx_ring->desc_head[producer];
1812                 tx_ring->cmd_buf_arr[producer].skb = NULL;
1813
1814                 copy_len = min((int)sizeof(struct cmd_desc_type0) - offset,
1815                                 hdr_len + VLAN_HLEN);
1816
1817                 vh = (struct vlan_ethhdr *)((char *)hwdesc + 2);
1818                 skb_copy_from_linear_data(skb, vh, 12);
1819                 vh->h_vlan_proto = htons(ETH_P_8021Q);
1820                 vh->h_vlan_TCI = htons(first_desc->vlan_TCI);
1821                 skb_copy_from_linear_data_offset(skb, 12,
1822                                 (char *)vh + 16, copy_len - 16);
1823
1824                 copied = copy_len - VLAN_HLEN;
1825                 offset = 0;
1826
1827                 producer = get_next_index(producer, tx_ring->num_desc);
1828         }
1829
1830         while (copied < hdr_len) {
1831
1832                 copy_len = min((int)sizeof(struct cmd_desc_type0) - offset,
1833                                 (hdr_len - copied));
1834
1835                 hwdesc = &tx_ring->desc_head[producer];
1836                 tx_ring->cmd_buf_arr[producer].skb = NULL;
1837
1838                 skb_copy_from_linear_data_offset(skb, copied,
1839                                  (char *)hwdesc + offset, copy_len);
1840
1841                 copied += copy_len;
1842                 offset = 0;
1843
1844                 producer = get_next_index(producer, tx_ring->num_desc);
1845         }
1846
1847         tx_ring->producer = producer;
1848         barrier();
1849         adapter->stats.lso_frames++;
1850 }
1851
1852 static int
1853 qlcnic_map_tx_skb(struct pci_dev *pdev,
1854                 struct sk_buff *skb, struct qlcnic_cmd_buffer *pbuf)
1855 {
1856         struct qlcnic_skb_frag *nf;
1857         struct skb_frag_struct *frag;
1858         int i, nr_frags;
1859         dma_addr_t map;
1860
1861         nr_frags = skb_shinfo(skb)->nr_frags;
1862         nf = &pbuf->frag_array[0];
1863
1864         map = pci_map_single(pdev, skb->data,
1865                         skb_headlen(skb), PCI_DMA_TODEVICE);
1866         if (pci_dma_mapping_error(pdev, map))
1867                 goto out_err;
1868
1869         nf->dma = map;
1870         nf->length = skb_headlen(skb);
1871
1872         for (i = 0; i < nr_frags; i++) {
1873                 frag = &skb_shinfo(skb)->frags[i];
1874                 nf = &pbuf->frag_array[i+1];
1875
1876                 map = pci_map_page(pdev, frag->page, frag->page_offset,
1877                                 frag->size, PCI_DMA_TODEVICE);
1878                 if (pci_dma_mapping_error(pdev, map))
1879                         goto unwind;
1880
1881                 nf->dma = map;
1882                 nf->length = frag->size;
1883         }
1884
1885         return 0;
1886
1887 unwind:
1888         while (--i >= 0) {
1889                 nf = &pbuf->frag_array[i+1];
1890                 pci_unmap_page(pdev, nf->dma, nf->length, PCI_DMA_TODEVICE);
1891         }
1892
1893         nf = &pbuf->frag_array[0];
1894         pci_unmap_single(pdev, nf->dma, skb_headlen(skb), PCI_DMA_TODEVICE);
1895
1896 out_err:
1897         return -ENOMEM;
1898 }
1899
1900 static int
1901 qlcnic_check_tx_tagging(struct qlcnic_adapter *adapter,
1902                         struct sk_buff *skb,
1903                         struct cmd_desc_type0 *first_desc)
1904 {
1905         u8 opcode = 0;
1906         u16 flags = 0;
1907         __be16 protocol = skb->protocol;
1908         struct vlan_ethhdr *vh;
1909
1910         if (protocol == cpu_to_be16(ETH_P_8021Q)) {
1911                 vh = (struct vlan_ethhdr *)skb->data;
1912                 protocol = vh->h_vlan_encapsulated_proto;
1913                 flags = FLAGS_VLAN_TAGGED;
1914                 qlcnic_set_tx_vlan_tci(first_desc, ntohs(vh->h_vlan_TCI));
1915         } else if (vlan_tx_tag_present(skb)) {
1916                 flags = FLAGS_VLAN_OOB;
1917                 qlcnic_set_tx_vlan_tci(first_desc, vlan_tx_tag_get(skb));
1918         }
1919         if (unlikely(adapter->pvid)) {
1920                 if (first_desc->vlan_TCI &&
1921                                 !(adapter->flags & QLCNIC_TAGGING_ENABLED))
1922                         return -EIO;
1923                 if (first_desc->vlan_TCI &&
1924                                 (adapter->flags & QLCNIC_TAGGING_ENABLED))
1925                         goto set_flags;
1926
1927                 flags = FLAGS_VLAN_OOB;
1928                 qlcnic_set_tx_vlan_tci(first_desc, adapter->pvid);
1929         }
1930 set_flags:
1931         qlcnic_set_tx_flags_opcode(first_desc, flags, opcode);
1932         return 0;
1933 }
1934
1935 static inline void
1936 qlcnic_clear_cmddesc(u64 *desc)
1937 {
1938         desc[0] = 0ULL;
1939         desc[2] = 0ULL;
1940         desc[7] = 0ULL;
1941 }
1942
1943 netdev_tx_t
1944 qlcnic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
1945 {
1946         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1947         struct qlcnic_host_tx_ring *tx_ring = adapter->tx_ring;
1948         struct qlcnic_cmd_buffer *pbuf;
1949         struct qlcnic_skb_frag *buffrag;
1950         struct cmd_desc_type0 *hwdesc, *first_desc;
1951         struct pci_dev *pdev;
1952         int i, k;
1953
1954         u32 producer;
1955         int frag_count, no_of_desc;
1956         u32 num_txd = tx_ring->num_desc;
1957
1958         if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
1959                 netif_stop_queue(netdev);
1960                 return NETDEV_TX_BUSY;
1961         }
1962
1963         if (adapter->flags & QLCNIC_MACSPOOF) {
1964                 if (compare_ether_addr(eth_hdr(skb)->h_source,
1965                                         adapter->mac_addr))
1966                         goto drop_packet;
1967         }
1968
1969         frag_count = skb_shinfo(skb)->nr_frags + 1;
1970
1971         /* 4 fragments per cmd des */
1972         no_of_desc = (frag_count + 3) >> 2;
1973
1974         if (unlikely(qlcnic_tx_avail(tx_ring) <= TX_STOP_THRESH)) {
1975                 netif_stop_queue(netdev);
1976                 smp_mb();
1977                 if (qlcnic_tx_avail(tx_ring) > TX_STOP_THRESH)
1978                         netif_start_queue(netdev);
1979                 else {
1980                         adapter->stats.xmit_off++;
1981                         return NETDEV_TX_BUSY;
1982                 }
1983         }
1984
1985         producer = tx_ring->producer;
1986         pbuf = &tx_ring->cmd_buf_arr[producer];
1987
1988         pdev = adapter->pdev;
1989
1990         first_desc = hwdesc = &tx_ring->desc_head[producer];
1991         qlcnic_clear_cmddesc((u64 *)hwdesc);
1992
1993         if (qlcnic_check_tx_tagging(adapter, skb, first_desc))
1994                 goto drop_packet;
1995
1996         if (qlcnic_map_tx_skb(pdev, skb, pbuf)) {
1997                 adapter->stats.tx_dma_map_error++;
1998                 goto drop_packet;
1999         }
2000
2001         pbuf->skb = skb;
2002         pbuf->frag_count = frag_count;
2003
2004         qlcnic_set_tx_frags_len(first_desc, frag_count, skb->len);
2005         qlcnic_set_tx_port(first_desc, adapter->portnum);
2006
2007         for (i = 0; i < frag_count; i++) {
2008
2009                 k = i % 4;
2010
2011                 if ((k == 0) && (i > 0)) {
2012                         /* move to next desc.*/
2013                         producer = get_next_index(producer, num_txd);
2014                         hwdesc = &tx_ring->desc_head[producer];
2015                         qlcnic_clear_cmddesc((u64 *)hwdesc);
2016                         tx_ring->cmd_buf_arr[producer].skb = NULL;
2017                 }
2018
2019                 buffrag = &pbuf->frag_array[i];
2020
2021                 hwdesc->buffer_length[k] = cpu_to_le16(buffrag->length);
2022                 switch (k) {
2023                 case 0:
2024                         hwdesc->addr_buffer1 = cpu_to_le64(buffrag->dma);
2025                         break;
2026                 case 1:
2027                         hwdesc->addr_buffer2 = cpu_to_le64(buffrag->dma);
2028                         break;
2029                 case 2:
2030                         hwdesc->addr_buffer3 = cpu_to_le64(buffrag->dma);
2031                         break;
2032                 case 3:
2033                         hwdesc->addr_buffer4 = cpu_to_le64(buffrag->dma);
2034                         break;
2035                 }
2036         }
2037
2038         tx_ring->producer = get_next_index(producer, num_txd);
2039
2040         qlcnic_tso_check(netdev, tx_ring, first_desc, skb);
2041
2042         qlcnic_update_cmd_producer(adapter, tx_ring);
2043
2044         adapter->stats.txbytes += skb->len;
2045         adapter->stats.xmitcalled++;
2046
2047         return NETDEV_TX_OK;
2048
2049 drop_packet:
2050         adapter->stats.txdropped++;
2051         dev_kfree_skb_any(skb);
2052         return NETDEV_TX_OK;
2053 }
2054
2055 static int qlcnic_check_temp(struct qlcnic_adapter *adapter)
2056 {
2057         struct net_device *netdev = adapter->netdev;
2058         u32 temp, temp_state, temp_val;
2059         int rv = 0;
2060
2061         temp = QLCRD32(adapter, CRB_TEMP_STATE);
2062
2063         temp_state = qlcnic_get_temp_state(temp);
2064         temp_val = qlcnic_get_temp_val(temp);
2065
2066         if (temp_state == QLCNIC_TEMP_PANIC) {
2067                 dev_err(&netdev->dev,
2068                        "Device temperature %d degrees C exceeds"
2069                        " maximum allowed. Hardware has been shut down.\n",
2070                        temp_val);
2071                 rv = 1;
2072         } else if (temp_state == QLCNIC_TEMP_WARN) {
2073                 if (adapter->temp == QLCNIC_TEMP_NORMAL) {
2074                         dev_err(&netdev->dev,
2075                                "Device temperature %d degrees C "
2076                                "exceeds operating range."
2077                                " Immediate action needed.\n",
2078                                temp_val);
2079                 }
2080         } else {
2081                 if (adapter->temp == QLCNIC_TEMP_WARN) {
2082                         dev_info(&netdev->dev,
2083                                "Device temperature is now %d degrees C"
2084                                " in normal range.\n", temp_val);
2085                 }
2086         }
2087         adapter->temp = temp_state;
2088         return rv;
2089 }
2090
2091 void qlcnic_advert_link_change(struct qlcnic_adapter *adapter, int linkup)
2092 {
2093         struct net_device *netdev = adapter->netdev;
2094
2095         if (adapter->ahw.linkup && !linkup) {
2096                 netdev_info(netdev, "NIC Link is down\n");
2097                 adapter->ahw.linkup = 0;
2098                 if (netif_running(netdev)) {
2099                         netif_carrier_off(netdev);
2100                         netif_stop_queue(netdev);
2101                 }
2102         } else if (!adapter->ahw.linkup && linkup) {
2103                 netdev_info(netdev, "NIC Link is up\n");
2104                 adapter->ahw.linkup = 1;
2105                 if (netif_running(netdev)) {
2106                         netif_carrier_on(netdev);
2107                         netif_wake_queue(netdev);
2108                 }
2109         }
2110 }
2111
2112 static void qlcnic_tx_timeout(struct net_device *netdev)
2113 {
2114         struct qlcnic_adapter *adapter = netdev_priv(netdev);
2115
2116         if (test_bit(__QLCNIC_RESETTING, &adapter->state))
2117                 return;
2118
2119         dev_err(&netdev->dev, "transmit timeout, resetting.\n");
2120
2121         if (++adapter->tx_timeo_cnt >= QLCNIC_MAX_TX_TIMEOUTS)
2122                 adapter->need_fw_reset = 1;
2123         else
2124                 adapter->reset_context = 1;
2125 }
2126
2127 static struct net_device_stats *qlcnic_get_stats(struct net_device *netdev)
2128 {
2129         struct qlcnic_adapter *adapter = netdev_priv(netdev);
2130         struct net_device_stats *stats = &netdev->stats;
2131
2132         stats->rx_packets = adapter->stats.rx_pkts + adapter->stats.lro_pkts;
2133         stats->tx_packets = adapter->stats.xmitfinished;
2134         stats->rx_bytes = adapter->stats.rxbytes + adapter->stats.lrobytes;
2135         stats->tx_bytes = adapter->stats.txbytes;
2136         stats->rx_dropped = adapter->stats.rxdropped;
2137         stats->tx_dropped = adapter->stats.txdropped;
2138
2139         return stats;
2140 }
2141
2142 static irqreturn_t qlcnic_clear_legacy_intr(struct qlcnic_adapter *adapter)
2143 {
2144         u32 status;
2145
2146         status = readl(adapter->isr_int_vec);
2147
2148         if (!(status & adapter->int_vec_bit))
2149                 return IRQ_NONE;
2150
2151         /* check interrupt state machine, to be sure */
2152         status = readl(adapter->crb_int_state_reg);
2153         if (!ISR_LEGACY_INT_TRIGGERED(status))
2154                 return IRQ_NONE;
2155
2156         writel(0xffffffff, adapter->tgt_status_reg);
2157         /* read twice to ensure write is flushed */
2158         readl(adapter->isr_int_vec);
2159         readl(adapter->isr_int_vec);
2160
2161         return IRQ_HANDLED;
2162 }
2163
2164 static irqreturn_t qlcnic_tmp_intr(int irq, void *data)
2165 {
2166         struct qlcnic_host_sds_ring *sds_ring = data;
2167         struct qlcnic_adapter *adapter = sds_ring->adapter;
2168
2169         if (adapter->flags & QLCNIC_MSIX_ENABLED)
2170                 goto done;
2171         else if (adapter->flags & QLCNIC_MSI_ENABLED) {
2172                 writel(0xffffffff, adapter->tgt_status_reg);
2173                 goto done;
2174         }
2175
2176         if (qlcnic_clear_legacy_intr(adapter) == IRQ_NONE)
2177                 return IRQ_NONE;
2178
2179 done:
2180         adapter->diag_cnt++;
2181         qlcnic_enable_int(sds_ring);
2182         return IRQ_HANDLED;
2183 }
2184
2185 static irqreturn_t qlcnic_intr(int irq, void *data)
2186 {
2187         struct qlcnic_host_sds_ring *sds_ring = data;
2188         struct qlcnic_adapter *adapter = sds_ring->adapter;
2189
2190         if (qlcnic_clear_legacy_intr(adapter) == IRQ_NONE)
2191                 return IRQ_NONE;
2192
2193         napi_schedule(&sds_ring->napi);
2194
2195         return IRQ_HANDLED;
2196 }
2197
2198 static irqreturn_t qlcnic_msi_intr(int irq, void *data)
2199 {
2200         struct qlcnic_host_sds_ring *sds_ring = data;
2201         struct qlcnic_adapter *adapter = sds_ring->adapter;
2202
2203         /* clear interrupt */
2204         writel(0xffffffff, adapter->tgt_status_reg);
2205
2206         napi_schedule(&sds_ring->napi);
2207         return IRQ_HANDLED;
2208 }
2209
2210 static irqreturn_t qlcnic_msix_intr(int irq, void *data)
2211 {
2212         struct qlcnic_host_sds_ring *sds_ring = data;
2213
2214         napi_schedule(&sds_ring->napi);
2215         return IRQ_HANDLED;
2216 }
2217
2218 static int qlcnic_process_cmd_ring(struct qlcnic_adapter *adapter)
2219 {
2220         u32 sw_consumer, hw_consumer;
2221         int count = 0, i;
2222         struct qlcnic_cmd_buffer *buffer;
2223         struct pci_dev *pdev = adapter->pdev;
2224         struct net_device *netdev = adapter->netdev;
2225         struct qlcnic_skb_frag *frag;
2226         int done;
2227         struct qlcnic_host_tx_ring *tx_ring = adapter->tx_ring;
2228
2229         if (!spin_trylock(&adapter->tx_clean_lock))
2230                 return 1;
2231
2232         sw_consumer = tx_ring->sw_consumer;
2233         hw_consumer = le32_to_cpu(*(tx_ring->hw_consumer));
2234
2235         while (sw_consumer != hw_consumer) {
2236                 buffer = &tx_ring->cmd_buf_arr[sw_consumer];
2237                 if (buffer->skb) {
2238                         frag = &buffer->frag_array[0];
2239                         pci_unmap_single(pdev, frag->dma, frag->length,
2240                                          PCI_DMA_TODEVICE);
2241                         frag->dma = 0ULL;
2242                         for (i = 1; i < buffer->frag_count; i++) {
2243                                 frag++;
2244                                 pci_unmap_page(pdev, frag->dma, frag->length,
2245                                                PCI_DMA_TODEVICE);
2246                                 frag->dma = 0ULL;
2247                         }
2248
2249                         adapter->stats.xmitfinished++;
2250                         dev_kfree_skb_any(buffer->skb);
2251                         buffer->skb = NULL;
2252                 }
2253
2254                 sw_consumer = get_next_index(sw_consumer, tx_ring->num_desc);
2255                 if (++count >= MAX_STATUS_HANDLE)
2256                         break;
2257         }
2258
2259         if (count && netif_running(netdev)) {
2260                 tx_ring->sw_consumer = sw_consumer;
2261
2262                 smp_mb();
2263
2264                 if (netif_queue_stopped(netdev) && netif_carrier_ok(netdev)) {
2265                         if (qlcnic_tx_avail(tx_ring) > TX_STOP_THRESH) {
2266                                 netif_wake_queue(netdev);
2267                                 adapter->stats.xmit_on++;
2268                         }
2269                 }
2270                 adapter->tx_timeo_cnt = 0;
2271         }
2272         /*
2273          * If everything is freed up to consumer then check if the ring is full
2274          * If the ring is full then check if more needs to be freed and
2275          * schedule the call back again.
2276          *
2277          * This happens when there are 2 CPUs. One could be freeing and the
2278          * other filling it. If the ring is full when we get out of here and
2279          * the card has already interrupted the host then the host can miss the
2280          * interrupt.
2281          *
2282          * There is still a possible race condition and the host could miss an
2283          * interrupt. The card has to take care of this.
2284          */
2285         hw_consumer = le32_to_cpu(*(tx_ring->hw_consumer));
2286         done = (sw_consumer == hw_consumer);
2287         spin_unlock(&adapter->tx_clean_lock);
2288
2289         return done;
2290 }
2291
2292 static int qlcnic_poll(struct napi_struct *napi, int budget)
2293 {
2294         struct qlcnic_host_sds_ring *sds_ring =
2295                 container_of(napi, struct qlcnic_host_sds_ring, napi);
2296
2297         struct qlcnic_adapter *adapter = sds_ring->adapter;
2298
2299         int tx_complete;
2300         int work_done;
2301
2302         tx_complete = qlcnic_process_cmd_ring(adapter);
2303
2304         work_done = qlcnic_process_rcv_ring(sds_ring, budget);
2305
2306         if ((work_done < budget) && tx_complete) {
2307                 napi_complete(&sds_ring->napi);
2308                 if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
2309                         qlcnic_enable_int(sds_ring);
2310         }
2311
2312         return work_done;
2313 }
2314
2315 static int qlcnic_rx_poll(struct napi_struct *napi, int budget)
2316 {
2317         struct qlcnic_host_sds_ring *sds_ring =
2318                 container_of(napi, struct qlcnic_host_sds_ring, napi);
2319
2320         struct qlcnic_adapter *adapter = sds_ring->adapter;
2321         int work_done;
2322
2323         work_done = qlcnic_process_rcv_ring(sds_ring, budget);
2324
2325         if (work_done < budget) {
2326                 napi_complete(&sds_ring->napi);
2327                 if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
2328                         qlcnic_enable_int(sds_ring);
2329         }
2330
2331         return work_done;
2332 }
2333
2334 #ifdef CONFIG_NET_POLL_CONTROLLER
2335 static void qlcnic_poll_controller(struct net_device *netdev)
2336 {
2337         struct qlcnic_adapter *adapter = netdev_priv(netdev);
2338         disable_irq(adapter->irq);
2339         qlcnic_intr(adapter->irq, adapter);
2340         enable_irq(adapter->irq);
2341 }
2342 #endif
2343
2344 static void
2345 qlcnic_idc_debug_info(struct qlcnic_adapter *adapter, u8 encoding)
2346 {
2347         u32 val;
2348
2349         val = adapter->portnum & 0xf;
2350         val |= encoding << 7;
2351         val |= (jiffies - adapter->dev_rst_time) << 8;
2352
2353         QLCWR32(adapter, QLCNIC_CRB_DRV_SCRATCH, val);
2354         adapter->dev_rst_time = jiffies;
2355 }
2356
2357 static int
2358 qlcnic_set_drv_state(struct qlcnic_adapter *adapter, u8 state)
2359 {
2360         u32  val;
2361
2362         WARN_ON(state != QLCNIC_DEV_NEED_RESET &&
2363                         state != QLCNIC_DEV_NEED_QUISCENT);
2364
2365         if (qlcnic_api_lock(adapter))
2366                 return -EIO;
2367
2368         val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2369
2370         if (state == QLCNIC_DEV_NEED_RESET)
2371                 QLC_DEV_SET_RST_RDY(val, adapter->portnum);
2372         else if (state == QLCNIC_DEV_NEED_QUISCENT)
2373                 QLC_DEV_SET_QSCNT_RDY(val, adapter->portnum);
2374
2375         QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2376
2377         qlcnic_api_unlock(adapter);
2378
2379         return 0;
2380 }
2381
2382 static int
2383 qlcnic_clr_drv_state(struct qlcnic_adapter *adapter)
2384 {
2385         u32  val;
2386
2387         if (qlcnic_api_lock(adapter))
2388                 return -EBUSY;
2389
2390         val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2391         QLC_DEV_CLR_RST_QSCNT(val, adapter->portnum);
2392         QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2393
2394         qlcnic_api_unlock(adapter);
2395
2396         return 0;
2397 }
2398
2399 static void
2400 qlcnic_clr_all_drv_state(struct qlcnic_adapter *adapter, u8 failed)
2401 {
2402         u32  val;
2403
2404         if (qlcnic_api_lock(adapter))
2405                 goto err;
2406
2407         val = QLCRD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
2408         QLC_DEV_CLR_REF_CNT(val, adapter->portnum);
2409         QLCWR32(adapter, QLCNIC_CRB_DRV_ACTIVE, val);
2410
2411         if (failed) {
2412                 QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_FAILED);
2413                 dev_info(&adapter->pdev->dev,
2414                                 "Device state set to Failed. Please Reboot\n");
2415         } else if (!(val & 0x11111111))
2416                 QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_COLD);
2417
2418         val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2419         QLC_DEV_CLR_RST_QSCNT(val, adapter->portnum);
2420         QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2421
2422         qlcnic_api_unlock(adapter);
2423 err:
2424         adapter->fw_fail_cnt = 0;
2425         clear_bit(__QLCNIC_START_FW, &adapter->state);
2426         clear_bit(__QLCNIC_RESETTING, &adapter->state);
2427 }
2428
2429 /* Grab api lock, before checking state */
2430 static int
2431 qlcnic_check_drv_state(struct qlcnic_adapter *adapter)
2432 {
2433         int act, state;
2434
2435         state = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2436         act = QLCRD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
2437
2438         if (((state & 0x11111111) == (act & 0x11111111)) ||
2439                         ((act & 0x11111111) == ((state >> 1) & 0x11111111)))
2440                 return 0;
2441         else
2442                 return 1;
2443 }
2444
2445 static int qlcnic_check_idc_ver(struct qlcnic_adapter *adapter)
2446 {
2447         u32 val = QLCRD32(adapter, QLCNIC_CRB_DRV_IDC_VER);
2448
2449         if (val != QLCNIC_DRV_IDC_VER) {
2450                 dev_warn(&adapter->pdev->dev, "IDC Version mismatch, driver's"
2451                         " idc ver = %x; reqd = %x\n", QLCNIC_DRV_IDC_VER, val);
2452         }
2453
2454         return 0;
2455 }
2456
2457 static int
2458 qlcnic_can_start_firmware(struct qlcnic_adapter *adapter)
2459 {
2460         u32 val, prev_state;
2461         u8 dev_init_timeo = adapter->dev_init_timeo;
2462         u8 portnum = adapter->portnum;
2463         u8 ret;
2464
2465         if (test_and_clear_bit(__QLCNIC_START_FW, &adapter->state))
2466                 return 1;
2467
2468         if (qlcnic_api_lock(adapter))
2469                 return -1;
2470
2471         val = QLCRD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
2472         if (!(val & (1 << (portnum * 4)))) {
2473                 QLC_DEV_SET_REF_CNT(val, portnum);
2474                 QLCWR32(adapter, QLCNIC_CRB_DRV_ACTIVE, val);
2475         }
2476
2477         prev_state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2478         QLCDB(adapter, HW, "Device state = %u\n", prev_state);
2479
2480         switch (prev_state) {
2481         case QLCNIC_DEV_COLD:
2482                 QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_INITIALIZING);
2483                 QLCWR32(adapter, QLCNIC_CRB_DRV_IDC_VER, QLCNIC_DRV_IDC_VER);
2484                 qlcnic_idc_debug_info(adapter, 0);
2485                 qlcnic_api_unlock(adapter);
2486                 return 1;
2487
2488         case QLCNIC_DEV_READY:
2489                 ret = qlcnic_check_idc_ver(adapter);
2490                 qlcnic_api_unlock(adapter);
2491                 return ret;
2492
2493         case QLCNIC_DEV_NEED_RESET:
2494                 val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2495                 QLC_DEV_SET_RST_RDY(val, portnum);
2496                 QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2497                 break;
2498
2499         case QLCNIC_DEV_NEED_QUISCENT:
2500                 val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2501                 QLC_DEV_SET_QSCNT_RDY(val, portnum);
2502                 QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2503                 break;
2504
2505         case QLCNIC_DEV_FAILED:
2506                 dev_err(&adapter->pdev->dev, "Device in failed state.\n");
2507                 qlcnic_api_unlock(adapter);
2508                 return -1;
2509
2510         case QLCNIC_DEV_INITIALIZING:
2511         case QLCNIC_DEV_QUISCENT:
2512                 break;
2513         }
2514
2515         qlcnic_api_unlock(adapter);
2516
2517         do {
2518                 msleep(1000);
2519                 prev_state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2520
2521                 if (prev_state == QLCNIC_DEV_QUISCENT)
2522                         continue;
2523         } while ((prev_state != QLCNIC_DEV_READY) && --dev_init_timeo);
2524
2525         if (!dev_init_timeo) {
2526                 dev_err(&adapter->pdev->dev,
2527                         "Waiting for device to initialize timeout\n");
2528                 return -1;
2529         }
2530
2531         if (qlcnic_api_lock(adapter))
2532                 return -1;
2533
2534         val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2535         QLC_DEV_CLR_RST_QSCNT(val, portnum);
2536         QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2537
2538         ret = qlcnic_check_idc_ver(adapter);
2539         qlcnic_api_unlock(adapter);
2540
2541         return ret;
2542 }
2543
2544 static void
2545 qlcnic_fwinit_work(struct work_struct *work)
2546 {
2547         struct qlcnic_adapter *adapter = container_of(work,
2548                         struct qlcnic_adapter, fw_work.work);
2549         u32 dev_state = 0xf;
2550
2551         if (qlcnic_api_lock(adapter))
2552                 goto err_ret;
2553
2554         dev_state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2555         if (dev_state ==  QLCNIC_DEV_QUISCENT) {
2556                 qlcnic_api_unlock(adapter);
2557                 qlcnic_schedule_work(adapter, qlcnic_fwinit_work,
2558                                                 FW_POLL_DELAY * 2);
2559                 return;
2560         }
2561
2562         if (adapter->op_mode == QLCNIC_NON_PRIV_FUNC) {
2563                 qlcnic_api_unlock(adapter);
2564                 goto wait_npar;
2565         }
2566
2567         if (adapter->fw_wait_cnt++ > adapter->reset_ack_timeo) {
2568                 dev_err(&adapter->pdev->dev, "Reset:Failed to get ack %d sec\n",
2569                                         adapter->reset_ack_timeo);
2570                 goto skip_ack_check;
2571         }
2572
2573         if (!qlcnic_check_drv_state(adapter)) {
2574 skip_ack_check:
2575                 dev_state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2576
2577                 if (dev_state == QLCNIC_DEV_NEED_QUISCENT) {
2578                         QLCWR32(adapter, QLCNIC_CRB_DEV_STATE,
2579                                                 QLCNIC_DEV_QUISCENT);
2580                         qlcnic_schedule_work(adapter, qlcnic_fwinit_work,
2581                                                 FW_POLL_DELAY * 2);
2582                         QLCDB(adapter, DRV, "Quiscing the driver\n");
2583                         qlcnic_idc_debug_info(adapter, 0);
2584
2585                         qlcnic_api_unlock(adapter);
2586                         return;
2587                 }
2588
2589                 if (dev_state == QLCNIC_DEV_NEED_RESET) {
2590                         QLCWR32(adapter, QLCNIC_CRB_DEV_STATE,
2591                                                 QLCNIC_DEV_INITIALIZING);
2592                         set_bit(__QLCNIC_START_FW, &adapter->state);
2593                         QLCDB(adapter, DRV, "Restarting fw\n");
2594                         qlcnic_idc_debug_info(adapter, 0);
2595                 }
2596
2597                 qlcnic_api_unlock(adapter);
2598
2599                 if (!adapter->nic_ops->start_firmware(adapter)) {
2600                         qlcnic_schedule_work(adapter, qlcnic_attach_work, 0);
2601                         adapter->fw_wait_cnt = 0;
2602                         return;
2603                 }
2604                 goto err_ret;
2605         }
2606
2607         qlcnic_api_unlock(adapter);
2608
2609 wait_npar:
2610         dev_state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2611         QLCDB(adapter, HW, "Func waiting: Device state=%u\n", dev_state);
2612
2613         switch (dev_state) {
2614         case QLCNIC_DEV_READY:
2615                 if (!adapter->nic_ops->start_firmware(adapter)) {
2616                         qlcnic_schedule_work(adapter, qlcnic_attach_work, 0);
2617                         adapter->fw_wait_cnt = 0;
2618                         return;
2619                 }
2620         case QLCNIC_DEV_FAILED:
2621                 break;
2622         default:
2623                 qlcnic_schedule_work(adapter,
2624                         qlcnic_fwinit_work, FW_POLL_DELAY);
2625                 return;
2626         }
2627
2628 err_ret:
2629         dev_err(&adapter->pdev->dev, "Fwinit work failed state=%u "
2630                 "fw_wait_cnt=%u\n", dev_state, adapter->fw_wait_cnt);
2631         netif_device_attach(adapter->netdev);
2632         qlcnic_clr_all_drv_state(adapter, 0);
2633 }
2634
2635 static void
2636 qlcnic_detach_work(struct work_struct *work)
2637 {
2638         struct qlcnic_adapter *adapter = container_of(work,
2639                         struct qlcnic_adapter, fw_work.work);
2640         struct net_device *netdev = adapter->netdev;
2641         u32 status;
2642
2643         netif_device_detach(netdev);
2644
2645         qlcnic_down(adapter, netdev);
2646
2647         status = QLCRD32(adapter, QLCNIC_PEG_HALT_STATUS1);
2648
2649         if (status & QLCNIC_RCODE_FATAL_ERROR)
2650                 goto err_ret;
2651
2652         if (adapter->temp == QLCNIC_TEMP_PANIC)
2653                 goto err_ret;
2654
2655         if (qlcnic_set_drv_state(adapter, adapter->dev_state))
2656                 goto err_ret;
2657
2658         adapter->fw_wait_cnt = 0;
2659
2660         qlcnic_schedule_work(adapter, qlcnic_fwinit_work, FW_POLL_DELAY);
2661
2662         return;
2663
2664 err_ret:
2665         dev_err(&adapter->pdev->dev, "detach failed; status=%d temp=%d\n",
2666                         status, adapter->temp);
2667         netif_device_attach(netdev);
2668         qlcnic_clr_all_drv_state(adapter, 1);
2669 }
2670
2671 /*Transit NPAR state to NON Operational */
2672 static void
2673 qlcnic_set_npar_non_operational(struct qlcnic_adapter *adapter)
2674 {
2675         u32 state;
2676
2677         state = QLCRD32(adapter, QLCNIC_CRB_DEV_NPAR_STATE);
2678         if (state == QLCNIC_DEV_NPAR_NON_OPER)
2679                 return;
2680
2681         if (qlcnic_api_lock(adapter))
2682                 return;
2683         QLCWR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE, QLCNIC_DEV_NPAR_NON_OPER);
2684         qlcnic_api_unlock(adapter);
2685 }
2686
2687 /*Transit to RESET state from READY state only */
2688 static void
2689 qlcnic_dev_request_reset(struct qlcnic_adapter *adapter)
2690 {
2691         u32 state;
2692
2693         adapter->need_fw_reset = 1;
2694         if (qlcnic_api_lock(adapter))
2695                 return;
2696
2697         state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2698
2699         if (state == QLCNIC_DEV_READY) {
2700                 QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_NEED_RESET);
2701                 QLCDB(adapter, DRV, "NEED_RESET state set\n");
2702                 qlcnic_idc_debug_info(adapter, 0);
2703         }
2704
2705         QLCWR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE, QLCNIC_DEV_NPAR_NON_OPER);
2706         qlcnic_api_unlock(adapter);
2707 }
2708
2709 /* Transit to NPAR READY state from NPAR NOT READY state */
2710 static void
2711 qlcnic_dev_set_npar_ready(struct qlcnic_adapter *adapter)
2712 {
2713         if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED) ||
2714             adapter->op_mode != QLCNIC_MGMT_FUNC)
2715                 return;
2716         if (qlcnic_api_lock(adapter))
2717                 return;
2718
2719         QLCWR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE, QLCNIC_DEV_NPAR_OPER);
2720         QLCDB(adapter, DRV, "NPAR operational state set\n");
2721
2722         qlcnic_api_unlock(adapter);
2723 }
2724
2725 static void
2726 qlcnic_schedule_work(struct qlcnic_adapter *adapter,
2727                 work_func_t func, int delay)
2728 {
2729         if (test_bit(__QLCNIC_AER, &adapter->state))
2730                 return;
2731
2732         INIT_DELAYED_WORK(&adapter->fw_work, func);
2733         schedule_delayed_work(&adapter->fw_work, round_jiffies_relative(delay));
2734 }
2735
2736 static void
2737 qlcnic_cancel_fw_work(struct qlcnic_adapter *adapter)
2738 {
2739         while (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
2740                 msleep(10);
2741
2742         cancel_delayed_work_sync(&adapter->fw_work);
2743 }
2744
2745 static void
2746 qlcnic_attach_work(struct work_struct *work)
2747 {
2748         struct qlcnic_adapter *adapter = container_of(work,
2749                                 struct qlcnic_adapter, fw_work.work);
2750         struct net_device *netdev = adapter->netdev;
2751         u32 npar_state;
2752
2753         if (adapter->op_mode != QLCNIC_MGMT_FUNC) {
2754                 npar_state = QLCRD32(adapter, QLCNIC_CRB_DEV_NPAR_STATE);
2755                 if (adapter->fw_wait_cnt++ > QLCNIC_DEV_NPAR_OPER_TIMEO)
2756                         qlcnic_clr_all_drv_state(adapter, 0);
2757                 else if (npar_state != QLCNIC_DEV_NPAR_OPER)
2758                         qlcnic_schedule_work(adapter, qlcnic_attach_work,
2759                                                         FW_POLL_DELAY);
2760                 else
2761                         goto attach;
2762                 QLCDB(adapter, DRV, "Waiting for NPAR state to operational\n");
2763                 return;
2764         }
2765 attach:
2766         if (netif_running(netdev)) {
2767                 if (qlcnic_up(adapter, netdev))
2768                         goto done;
2769
2770                 qlcnic_config_indev_addr(netdev, NETDEV_UP);
2771         }
2772
2773 done:
2774         netif_device_attach(netdev);
2775         adapter->fw_fail_cnt = 0;
2776         clear_bit(__QLCNIC_RESETTING, &adapter->state);
2777
2778         if (!qlcnic_clr_drv_state(adapter))
2779                 qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
2780                                                         FW_POLL_DELAY);
2781 }
2782
2783 static int
2784 qlcnic_check_health(struct qlcnic_adapter *adapter)
2785 {
2786         u32 state = 0, heartbit;
2787         struct net_device *netdev = adapter->netdev;
2788
2789         if (qlcnic_check_temp(adapter))
2790                 goto detach;
2791
2792         if (adapter->need_fw_reset)
2793                 qlcnic_dev_request_reset(adapter);
2794
2795         state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2796         if (state == QLCNIC_DEV_NEED_RESET ||
2797             state == QLCNIC_DEV_NEED_QUISCENT) {
2798                 qlcnic_set_npar_non_operational(adapter);
2799                 adapter->need_fw_reset = 1;
2800         }
2801
2802         heartbit = QLCRD32(adapter, QLCNIC_PEG_ALIVE_COUNTER);
2803         if (heartbit != adapter->heartbit) {
2804                 adapter->heartbit = heartbit;
2805                 adapter->fw_fail_cnt = 0;
2806                 if (adapter->need_fw_reset)
2807                         goto detach;
2808
2809                 if (adapter->reset_context &&
2810                     auto_fw_reset == AUTO_FW_RESET_ENABLED) {
2811                         qlcnic_reset_hw_context(adapter);
2812                         adapter->netdev->trans_start = jiffies;
2813                 }
2814
2815                 return 0;
2816         }
2817
2818         if (++adapter->fw_fail_cnt < FW_FAIL_THRESH)
2819                 return 0;
2820
2821         qlcnic_dev_request_reset(adapter);
2822
2823         if ((auto_fw_reset == AUTO_FW_RESET_ENABLED))
2824                 clear_bit(__QLCNIC_FW_ATTACHED, &adapter->state);
2825
2826         dev_info(&netdev->dev, "firmware hang detected\n");
2827
2828 detach:
2829         adapter->dev_state = (state == QLCNIC_DEV_NEED_QUISCENT) ? state :
2830                 QLCNIC_DEV_NEED_RESET;
2831
2832         if ((auto_fw_reset == AUTO_FW_RESET_ENABLED) &&
2833                 !test_and_set_bit(__QLCNIC_RESETTING, &adapter->state)) {
2834
2835                 qlcnic_schedule_work(adapter, qlcnic_detach_work, 0);
2836                 QLCDB(adapter, DRV, "fw recovery scheduled.\n");
2837         }
2838
2839         return 1;
2840 }
2841
2842 static void
2843 qlcnic_fw_poll_work(struct work_struct *work)
2844 {
2845         struct qlcnic_adapter *adapter = container_of(work,
2846                                 struct qlcnic_adapter, fw_work.work);
2847
2848         if (test_bit(__QLCNIC_RESETTING, &adapter->state))
2849                 goto reschedule;
2850
2851
2852         if (qlcnic_check_health(adapter))
2853                 return;
2854
2855 reschedule:
2856         qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
2857 }
2858
2859 static int qlcnic_is_first_func(struct pci_dev *pdev)
2860 {
2861         struct pci_dev *oth_pdev;
2862         int val = pdev->devfn;
2863
2864         while (val-- > 0) {
2865                 oth_pdev = pci_get_domain_bus_and_slot(pci_domain_nr
2866                         (pdev->bus), pdev->bus->number,
2867                         PCI_DEVFN(PCI_SLOT(pdev->devfn), val));
2868                 if (!oth_pdev)
2869                         continue;
2870
2871                 if (oth_pdev->current_state != PCI_D3cold) {
2872                         pci_dev_put(oth_pdev);
2873                         return 0;
2874                 }
2875                 pci_dev_put(oth_pdev);
2876         }
2877         return 1;
2878 }
2879
2880 static int qlcnic_attach_func(struct pci_dev *pdev)
2881 {
2882         int err, first_func;
2883         struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
2884         struct net_device *netdev = adapter->netdev;
2885
2886         pdev->error_state = pci_channel_io_normal;
2887
2888         err = pci_enable_device(pdev);
2889         if (err)
2890                 return err;
2891
2892         pci_set_power_state(pdev, PCI_D0);
2893         pci_set_master(pdev);
2894         pci_restore_state(pdev);
2895
2896         first_func = qlcnic_is_first_func(pdev);
2897
2898         if (qlcnic_api_lock(adapter))
2899                 return -EINVAL;
2900
2901         if (adapter->op_mode != QLCNIC_NON_PRIV_FUNC && first_func) {
2902                 adapter->need_fw_reset = 1;
2903                 set_bit(__QLCNIC_START_FW, &adapter->state);
2904                 QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_INITIALIZING);
2905                 QLCDB(adapter, DRV, "Restarting fw\n");
2906         }
2907         qlcnic_api_unlock(adapter);
2908
2909         err = adapter->nic_ops->start_firmware(adapter);
2910         if (err)
2911                 return err;
2912
2913         qlcnic_clr_drv_state(adapter);
2914         qlcnic_setup_intr(adapter);
2915
2916         if (netif_running(netdev)) {
2917                 err = qlcnic_attach(adapter);
2918                 if (err) {
2919                         qlcnic_clr_all_drv_state(adapter, 1);
2920                         clear_bit(__QLCNIC_AER, &adapter->state);
2921                         netif_device_attach(netdev);
2922                         return err;
2923                 }
2924
2925                 err = qlcnic_up(adapter, netdev);
2926                 if (err)
2927                         goto done;
2928
2929                 qlcnic_config_indev_addr(netdev, NETDEV_UP);
2930         }
2931  done:
2932         netif_device_attach(netdev);
2933         return err;
2934 }
2935
2936 static pci_ers_result_t qlcnic_io_error_detected(struct pci_dev *pdev,
2937                                                 pci_channel_state_t state)
2938 {
2939         struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
2940         struct net_device *netdev = adapter->netdev;
2941
2942         if (state == pci_channel_io_perm_failure)
2943                 return PCI_ERS_RESULT_DISCONNECT;
2944
2945         if (state == pci_channel_io_normal)
2946                 return PCI_ERS_RESULT_RECOVERED;
2947
2948         set_bit(__QLCNIC_AER, &adapter->state);
2949         netif_device_detach(netdev);
2950
2951         cancel_delayed_work_sync(&adapter->fw_work);
2952
2953         if (netif_running(netdev))
2954                 qlcnic_down(adapter, netdev);
2955
2956         qlcnic_detach(adapter);
2957         qlcnic_teardown_intr(adapter);
2958
2959         clear_bit(__QLCNIC_RESETTING, &adapter->state);
2960
2961         pci_save_state(pdev);
2962         pci_disable_device(pdev);
2963
2964         return PCI_ERS_RESULT_NEED_RESET;
2965 }
2966
2967 static pci_ers_result_t qlcnic_io_slot_reset(struct pci_dev *pdev)
2968 {
2969         return qlcnic_attach_func(pdev) ? PCI_ERS_RESULT_DISCONNECT :
2970                                 PCI_ERS_RESULT_RECOVERED;
2971 }
2972
2973 static void qlcnic_io_resume(struct pci_dev *pdev)
2974 {
2975         struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
2976
2977         pci_cleanup_aer_uncorrect_error_status(pdev);
2978
2979         if (QLCRD32(adapter, QLCNIC_CRB_DEV_STATE) == QLCNIC_DEV_READY &&
2980             test_and_clear_bit(__QLCNIC_AER, &adapter->state))
2981                 qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
2982                                                 FW_POLL_DELAY);
2983 }
2984
2985 static int
2986 qlcnicvf_start_firmware(struct qlcnic_adapter *adapter)
2987 {
2988         int err;
2989
2990         err = qlcnic_can_start_firmware(adapter);
2991         if (err)
2992                 return err;
2993
2994         err = qlcnic_check_npar_opertional(adapter);
2995         if (err)
2996                 return err;
2997
2998         qlcnic_check_options(adapter);
2999
3000         adapter->need_fw_reset = 0;
3001
3002         return err;
3003 }
3004
3005 static int
3006 qlcnicvf_config_bridged_mode(struct qlcnic_adapter *adapter, u32 enable)
3007 {
3008         return -EOPNOTSUPP;
3009 }
3010
3011 static int
3012 qlcnicvf_config_led(struct qlcnic_adapter *adapter, u32 state, u32 rate)
3013 {
3014         return -EOPNOTSUPP;
3015 }
3016
3017 static ssize_t
3018 qlcnic_store_bridged_mode(struct device *dev,
3019                 struct device_attribute *attr, const char *buf, size_t len)
3020 {
3021         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3022         unsigned long new;
3023         int ret = -EINVAL;
3024
3025         if (!(adapter->capabilities & QLCNIC_FW_CAPABILITY_BDG))
3026                 goto err_out;
3027
3028         if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
3029                 goto err_out;
3030
3031         if (strict_strtoul(buf, 2, &new))
3032                 goto err_out;
3033
3034         if (!adapter->nic_ops->config_bridged_mode(adapter, !!new))
3035                 ret = len;
3036
3037 err_out:
3038         return ret;
3039 }
3040
3041 static ssize_t
3042 qlcnic_show_bridged_mode(struct device *dev,
3043                 struct device_attribute *attr, char *buf)
3044 {
3045         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3046         int bridged_mode = 0;
3047
3048         if (adapter->capabilities & QLCNIC_FW_CAPABILITY_BDG)
3049                 bridged_mode = !!(adapter->flags & QLCNIC_BRIDGE_ENABLED);
3050
3051         return sprintf(buf, "%d\n", bridged_mode);
3052 }
3053
3054 static struct device_attribute dev_attr_bridged_mode = {
3055        .attr = {.name = "bridged_mode", .mode = (S_IRUGO | S_IWUSR)},
3056        .show = qlcnic_show_bridged_mode,
3057        .store = qlcnic_store_bridged_mode,
3058 };
3059
3060 static ssize_t
3061 qlcnic_store_diag_mode(struct device *dev,
3062                 struct device_attribute *attr, const char *buf, size_t len)
3063 {
3064         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3065         unsigned long new;
3066
3067         if (strict_strtoul(buf, 2, &new))
3068                 return -EINVAL;
3069
3070         if (!!new != !!(adapter->flags & QLCNIC_DIAG_ENABLED))
3071                 adapter->flags ^= QLCNIC_DIAG_ENABLED;
3072
3073         return len;
3074 }
3075
3076 static ssize_t
3077 qlcnic_show_diag_mode(struct device *dev,
3078                 struct device_attribute *attr, char *buf)
3079 {
3080         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3081
3082         return sprintf(buf, "%d\n",
3083                         !!(adapter->flags & QLCNIC_DIAG_ENABLED));
3084 }
3085
3086 static struct device_attribute dev_attr_diag_mode = {
3087         .attr = {.name = "diag_mode", .mode = (S_IRUGO | S_IWUSR)},
3088         .show = qlcnic_show_diag_mode,
3089         .store = qlcnic_store_diag_mode,
3090 };
3091
3092 static int
3093 qlcnic_sysfs_validate_crb(struct qlcnic_adapter *adapter,
3094                 loff_t offset, size_t size)
3095 {
3096         size_t crb_size = 4;
3097
3098         if (!(adapter->flags & QLCNIC_DIAG_ENABLED))
3099                 return -EIO;
3100
3101         if (offset < QLCNIC_PCI_CRBSPACE) {
3102                 if (ADDR_IN_RANGE(offset, QLCNIC_PCI_CAMQM,
3103                                         QLCNIC_PCI_CAMQM_END))
3104                         crb_size = 8;
3105                 else
3106                         return -EINVAL;
3107         }
3108
3109         if ((size != crb_size) || (offset & (crb_size-1)))
3110                 return  -EINVAL;
3111
3112         return 0;
3113 }
3114
3115 static ssize_t
3116 qlcnic_sysfs_read_crb(struct file *filp, struct kobject *kobj,
3117                 struct bin_attribute *attr,
3118                 char *buf, loff_t offset, size_t size)
3119 {
3120         struct device *dev = container_of(kobj, struct device, kobj);
3121         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3122         u32 data;
3123         u64 qmdata;
3124         int ret;
3125
3126         ret = qlcnic_sysfs_validate_crb(adapter, offset, size);
3127         if (ret != 0)
3128                 return ret;
3129
3130         if (ADDR_IN_RANGE(offset, QLCNIC_PCI_CAMQM, QLCNIC_PCI_CAMQM_END)) {
3131                 qlcnic_pci_camqm_read_2M(adapter, offset, &qmdata);
3132                 memcpy(buf, &qmdata, size);
3133         } else {
3134                 data = QLCRD32(adapter, offset);
3135                 memcpy(buf, &data, size);
3136         }
3137         return size;
3138 }
3139
3140 static ssize_t
3141 qlcnic_sysfs_write_crb(struct file *filp, struct kobject *kobj,
3142                 struct bin_attribute *attr,
3143                 char *buf, loff_t offset, size_t size)
3144 {
3145         struct device *dev = container_of(kobj, struct device, kobj);
3146         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3147         u32 data;
3148         u64 qmdata;
3149         int ret;
3150
3151         ret = qlcnic_sysfs_validate_crb(adapter, offset, size);
3152         if (ret != 0)
3153                 return ret;
3154
3155         if (ADDR_IN_RANGE(offset, QLCNIC_PCI_CAMQM, QLCNIC_PCI_CAMQM_END)) {
3156                 memcpy(&qmdata, buf, size);
3157                 qlcnic_pci_camqm_write_2M(adapter, offset, qmdata);
3158         } else {
3159                 memcpy(&data, buf, size);
3160                 QLCWR32(adapter, offset, data);
3161         }
3162         return size;
3163 }
3164
3165 static int
3166 qlcnic_sysfs_validate_mem(struct qlcnic_adapter *adapter,
3167                 loff_t offset, size_t size)
3168 {
3169         if (!(adapter->flags & QLCNIC_DIAG_ENABLED))
3170                 return -EIO;
3171
3172         if ((size != 8) || (offset & 0x7))
3173                 return  -EIO;
3174
3175         return 0;
3176 }
3177
3178 static ssize_t
3179 qlcnic_sysfs_read_mem(struct file *filp, struct kobject *kobj,
3180                 struct bin_attribute *attr,
3181                 char *buf, loff_t offset, size_t size)
3182 {
3183         struct device *dev = container_of(kobj, struct device, kobj);
3184         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3185         u64 data;
3186         int ret;
3187
3188         ret = qlcnic_sysfs_validate_mem(adapter, offset, size);
3189         if (ret != 0)
3190                 return ret;
3191
3192         if (qlcnic_pci_mem_read_2M(adapter, offset, &data))
3193                 return -EIO;
3194
3195         memcpy(buf, &data, size);
3196
3197         return size;
3198 }
3199
3200 static ssize_t
3201 qlcnic_sysfs_write_mem(struct file *filp, struct kobject *kobj,
3202                 struct bin_attribute *attr,
3203                 char *buf, loff_t offset, size_t size)
3204 {
3205         struct device *dev = container_of(kobj, struct device, kobj);
3206         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3207         u64 data;
3208         int ret;
3209
3210         ret = qlcnic_sysfs_validate_mem(adapter, offset, size);
3211         if (ret != 0)
3212                 return ret;
3213
3214         memcpy(&data, buf, size);
3215
3216         if (qlcnic_pci_mem_write_2M(adapter, offset, data))
3217                 return -EIO;
3218
3219         return size;
3220 }
3221
3222
3223 static struct bin_attribute bin_attr_crb = {
3224         .attr = {.name = "crb", .mode = (S_IRUGO | S_IWUSR)},
3225         .size = 0,
3226         .read = qlcnic_sysfs_read_crb,
3227         .write = qlcnic_sysfs_write_crb,
3228 };
3229
3230 static struct bin_attribute bin_attr_mem = {
3231         .attr = {.name = "mem", .mode = (S_IRUGO | S_IWUSR)},
3232         .size = 0,
3233         .read = qlcnic_sysfs_read_mem,
3234         .write = qlcnic_sysfs_write_mem,
3235 };
3236
3237 static int
3238 validate_pm_config(struct qlcnic_adapter *adapter,
3239                         struct qlcnic_pm_func_cfg *pm_cfg, int count)
3240 {
3241
3242         u8 src_pci_func, s_esw_id, d_esw_id;
3243         u8 dest_pci_func;
3244         int i;
3245
3246         for (i = 0; i < count; i++) {
3247                 src_pci_func = pm_cfg[i].pci_func;
3248                 dest_pci_func = pm_cfg[i].dest_npar;
3249                 if (src_pci_func >= QLCNIC_MAX_PCI_FUNC
3250                                 || dest_pci_func >= QLCNIC_MAX_PCI_FUNC)
3251                         return QL_STATUS_INVALID_PARAM;
3252
3253                 if (adapter->npars[src_pci_func].type != QLCNIC_TYPE_NIC)
3254                         return QL_STATUS_INVALID_PARAM;
3255
3256                 if (adapter->npars[dest_pci_func].type != QLCNIC_TYPE_NIC)
3257                         return QL_STATUS_INVALID_PARAM;
3258
3259                 s_esw_id = adapter->npars[src_pci_func].phy_port;
3260                 d_esw_id = adapter->npars[dest_pci_func].phy_port;
3261
3262                 if (s_esw_id != d_esw_id)
3263                         return QL_STATUS_INVALID_PARAM;
3264
3265         }
3266         return 0;
3267
3268 }
3269
3270 static ssize_t
3271 qlcnic_sysfs_write_pm_config(struct file *filp, struct kobject *kobj,
3272         struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3273 {
3274         struct device *dev = container_of(kobj, struct device, kobj);
3275         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3276         struct qlcnic_pm_func_cfg *pm_cfg;
3277         u32 id, action, pci_func;
3278         int count, rem, i, ret;
3279
3280         count   = size / sizeof(struct qlcnic_pm_func_cfg);
3281         rem     = size % sizeof(struct qlcnic_pm_func_cfg);
3282         if (rem)
3283                 return QL_STATUS_INVALID_PARAM;
3284
3285         pm_cfg = (struct qlcnic_pm_func_cfg *) buf;
3286
3287         ret = validate_pm_config(adapter, pm_cfg, count);
3288         if (ret)
3289                 return ret;
3290         for (i = 0; i < count; i++) {
3291                 pci_func = pm_cfg[i].pci_func;
3292                 action = !!pm_cfg[i].action;
3293                 id = adapter->npars[pci_func].phy_port;
3294                 ret = qlcnic_config_port_mirroring(adapter, id,
3295                                                 action, pci_func);
3296                 if (ret)
3297                         return ret;
3298         }
3299
3300         for (i = 0; i < count; i++) {
3301                 pci_func = pm_cfg[i].pci_func;
3302                 id = adapter->npars[pci_func].phy_port;
3303                 adapter->npars[pci_func].enable_pm = !!pm_cfg[i].action;
3304                 adapter->npars[pci_func].dest_npar = id;
3305         }
3306         return size;
3307 }
3308
3309 static ssize_t
3310 qlcnic_sysfs_read_pm_config(struct file *filp, struct kobject *kobj,
3311         struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3312 {
3313         struct device *dev = container_of(kobj, struct device, kobj);
3314         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3315         struct qlcnic_pm_func_cfg pm_cfg[QLCNIC_MAX_PCI_FUNC];
3316         int i;
3317
3318         if (size != sizeof(pm_cfg))
3319                 return QL_STATUS_INVALID_PARAM;
3320
3321         for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
3322                 if (adapter->npars[i].type != QLCNIC_TYPE_NIC)
3323                         continue;
3324                 pm_cfg[i].action = adapter->npars[i].enable_pm;
3325                 pm_cfg[i].dest_npar = 0;
3326                 pm_cfg[i].pci_func = i;
3327         }
3328         memcpy(buf, &pm_cfg, size);
3329
3330         return size;
3331 }
3332
3333 static int
3334 validate_esw_config(struct qlcnic_adapter *adapter,
3335         struct qlcnic_esw_func_cfg *esw_cfg, int count)
3336 {
3337         u8 pci_func;
3338         int i;
3339         for (i = 0; i < count; i++) {
3340                 pci_func = esw_cfg[i].pci_func;
3341                 if (pci_func >= QLCNIC_MAX_PCI_FUNC)
3342                         return QL_STATUS_INVALID_PARAM;
3343
3344                 if (adapter->op_mode == QLCNIC_MGMT_FUNC)
3345                         if (adapter->npars[pci_func].type != QLCNIC_TYPE_NIC)
3346                                 return QL_STATUS_INVALID_PARAM;
3347
3348                 switch (esw_cfg[i].op_mode) {
3349                 case QLCNIC_PORT_DEFAULTS:
3350                         break;
3351                 case QLCNIC_ADD_VLAN:
3352                         if (!IS_VALID_VLAN(esw_cfg[i].vlan_id))
3353                                 return QL_STATUS_INVALID_PARAM;
3354                         if (!esw_cfg[i].op_type)
3355                                 return QL_STATUS_INVALID_PARAM;
3356                         break;
3357                 case QLCNIC_DEL_VLAN:
3358                         if (!esw_cfg[i].op_type)
3359                                 return QL_STATUS_INVALID_PARAM;
3360                         break;
3361                 default:
3362                         return QL_STATUS_INVALID_PARAM;
3363                 }
3364         }
3365         return 0;
3366 }
3367
3368 static ssize_t
3369 qlcnic_sysfs_write_esw_config(struct file *file, struct kobject *kobj,
3370         struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3371 {
3372         struct device *dev = container_of(kobj, struct device, kobj);
3373         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3374         struct qlcnic_esw_func_cfg *esw_cfg;
3375         struct qlcnic_npar_info *npar;
3376         int count, rem, i, ret;
3377         u8 pci_func, op_mode = 0;
3378
3379         count   = size / sizeof(struct qlcnic_esw_func_cfg);
3380         rem     = size % sizeof(struct qlcnic_esw_func_cfg);
3381         if (rem)
3382                 return QL_STATUS_INVALID_PARAM;
3383
3384         esw_cfg = (struct qlcnic_esw_func_cfg *) buf;
3385         ret = validate_esw_config(adapter, esw_cfg, count);
3386         if (ret)
3387                 return ret;
3388
3389         for (i = 0; i < count; i++) {
3390                 if (adapter->op_mode == QLCNIC_MGMT_FUNC)
3391                         if (qlcnic_config_switch_port(adapter, &esw_cfg[i]))
3392                                 return QL_STATUS_INVALID_PARAM;
3393
3394                 if (adapter->ahw.pci_func != esw_cfg[i].pci_func)
3395                         continue;
3396
3397                 op_mode = esw_cfg[i].op_mode;
3398                 qlcnic_get_eswitch_port_config(adapter, &esw_cfg[i]);
3399                 esw_cfg[i].op_mode = op_mode;
3400                 esw_cfg[i].pci_func = adapter->ahw.pci_func;
3401
3402                 switch (esw_cfg[i].op_mode) {
3403                 case QLCNIC_PORT_DEFAULTS:
3404                         qlcnic_set_eswitch_port_features(adapter, &esw_cfg[i]);
3405                         break;
3406                 case QLCNIC_ADD_VLAN:
3407                         qlcnic_set_vlan_config(adapter, &esw_cfg[i]);
3408                         break;
3409                 case QLCNIC_DEL_VLAN:
3410                         esw_cfg[i].vlan_id = 0;
3411                         qlcnic_set_vlan_config(adapter, &esw_cfg[i]);
3412                         break;
3413                 }
3414         }
3415
3416         if (adapter->op_mode != QLCNIC_MGMT_FUNC)
3417                 goto out;
3418
3419         for (i = 0; i < count; i++) {
3420                 pci_func = esw_cfg[i].pci_func;
3421                 npar = &adapter->npars[pci_func];
3422                 switch (esw_cfg[i].op_mode) {
3423                 case QLCNIC_PORT_DEFAULTS:
3424                         npar->promisc_mode = esw_cfg[i].promisc_mode;
3425                         npar->mac_learning = esw_cfg[i].mac_learning;
3426                         npar->offload_flags = esw_cfg[i].offload_flags;
3427                         npar->mac_anti_spoof = esw_cfg[i].mac_anti_spoof;
3428                         npar->discard_tagged = esw_cfg[i].discard_tagged;
3429                         break;
3430                 case QLCNIC_ADD_VLAN:
3431                         npar->pvid = esw_cfg[i].vlan_id;
3432                         break;
3433                 case QLCNIC_DEL_VLAN:
3434                         npar->pvid = 0;
3435                         break;
3436                 }
3437         }
3438 out:
3439         return size;
3440 }
3441
3442 static ssize_t
3443 qlcnic_sysfs_read_esw_config(struct file *file, struct kobject *kobj,
3444         struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3445 {
3446         struct device *dev = container_of(kobj, struct device, kobj);
3447         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3448         struct qlcnic_esw_func_cfg esw_cfg[QLCNIC_MAX_PCI_FUNC];
3449         u8 i;
3450
3451         if (size != sizeof(esw_cfg))
3452                 return QL_STATUS_INVALID_PARAM;
3453
3454         for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
3455                 if (adapter->npars[i].type != QLCNIC_TYPE_NIC)
3456                         continue;
3457                 esw_cfg[i].pci_func = i;
3458                 if (qlcnic_get_eswitch_port_config(adapter, &esw_cfg[i]))
3459                         return QL_STATUS_INVALID_PARAM;
3460         }
3461         memcpy(buf, &esw_cfg, size);
3462
3463         return size;
3464 }
3465
3466 static int
3467 validate_npar_config(struct qlcnic_adapter *adapter,
3468                                 struct qlcnic_npar_func_cfg *np_cfg, int count)
3469 {
3470         u8 pci_func, i;
3471
3472         for (i = 0; i < count; i++) {
3473                 pci_func = np_cfg[i].pci_func;
3474                 if (pci_func >= QLCNIC_MAX_PCI_FUNC)
3475                         return QL_STATUS_INVALID_PARAM;
3476
3477                 if (adapter->npars[pci_func].type != QLCNIC_TYPE_NIC)
3478                         return QL_STATUS_INVALID_PARAM;
3479
3480                 if (!IS_VALID_BW(np_cfg[i].min_bw)
3481                                 || !IS_VALID_BW(np_cfg[i].max_bw)
3482                                 || !IS_VALID_RX_QUEUES(np_cfg[i].max_rx_queues)
3483                                 || !IS_VALID_TX_QUEUES(np_cfg[i].max_tx_queues))
3484                         return QL_STATUS_INVALID_PARAM;
3485         }
3486         return 0;
3487 }
3488
3489 static ssize_t
3490 qlcnic_sysfs_write_npar_config(struct file *file, struct kobject *kobj,
3491         struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3492 {
3493         struct device *dev = container_of(kobj, struct device, kobj);
3494         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3495         struct qlcnic_info nic_info;
3496         struct qlcnic_npar_func_cfg *np_cfg;
3497         int i, count, rem, ret;
3498         u8 pci_func;
3499
3500         count   = size / sizeof(struct qlcnic_npar_func_cfg);
3501         rem     = size % sizeof(struct qlcnic_npar_func_cfg);
3502         if (rem)
3503                 return QL_STATUS_INVALID_PARAM;
3504
3505         np_cfg = (struct qlcnic_npar_func_cfg *) buf;
3506         ret = validate_npar_config(adapter, np_cfg, count);
3507         if (ret)
3508                 return ret;
3509
3510         for (i = 0; i < count ; i++) {
3511                 pci_func = np_cfg[i].pci_func;
3512                 ret = qlcnic_get_nic_info(adapter, &nic_info, pci_func);
3513                 if (ret)
3514                         return ret;
3515                 nic_info.pci_func = pci_func;
3516                 nic_info.min_tx_bw = np_cfg[i].min_bw;
3517                 nic_info.max_tx_bw = np_cfg[i].max_bw;
3518                 ret = qlcnic_set_nic_info(adapter, &nic_info);
3519                 if (ret)
3520                         return ret;
3521                 adapter->npars[i].min_bw = nic_info.min_tx_bw;
3522                 adapter->npars[i].max_bw = nic_info.max_tx_bw;
3523         }
3524
3525         return size;
3526
3527 }
3528 static ssize_t
3529 qlcnic_sysfs_read_npar_config(struct file *file, struct kobject *kobj,
3530         struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3531 {
3532         struct device *dev = container_of(kobj, struct device, kobj);
3533         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3534         struct qlcnic_info nic_info;
3535         struct qlcnic_npar_func_cfg np_cfg[QLCNIC_MAX_PCI_FUNC];
3536         int i, ret;
3537
3538         if (size != sizeof(np_cfg))
3539                 return QL_STATUS_INVALID_PARAM;
3540
3541         for (i = 0; i < QLCNIC_MAX_PCI_FUNC ; i++) {
3542                 if (adapter->npars[i].type != QLCNIC_TYPE_NIC)
3543                         continue;
3544                 ret = qlcnic_get_nic_info(adapter, &nic_info, i);
3545                 if (ret)
3546                         return ret;
3547
3548                 np_cfg[i].pci_func = i;
3549                 np_cfg[i].op_mode = nic_info.op_mode;
3550                 np_cfg[i].port_num = nic_info.phys_port;
3551                 np_cfg[i].fw_capab = nic_info.capabilities;
3552                 np_cfg[i].min_bw = nic_info.min_tx_bw ;
3553                 np_cfg[i].max_bw = nic_info.max_tx_bw;
3554                 np_cfg[i].max_tx_queues = nic_info.max_tx_ques;
3555                 np_cfg[i].max_rx_queues = nic_info.max_rx_ques;
3556         }
3557         memcpy(buf, &np_cfg, size);
3558         return size;
3559 }
3560
3561 static ssize_t
3562 qlcnic_sysfs_get_port_stats(struct file *file, struct kobject *kobj,
3563         struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3564 {
3565         struct device *dev = container_of(kobj, struct device, kobj);
3566         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3567         struct qlcnic_esw_statistics port_stats;
3568         int ret;
3569
3570         if (size != sizeof(struct qlcnic_esw_statistics))
3571                 return QL_STATUS_INVALID_PARAM;
3572
3573         if (offset >= QLCNIC_MAX_PCI_FUNC)
3574                 return QL_STATUS_INVALID_PARAM;
3575
3576         memset(&port_stats, 0, size);
3577         ret = qlcnic_get_port_stats(adapter, offset, QLCNIC_QUERY_RX_COUNTER,
3578                                                                 &port_stats.rx);
3579         if (ret)
3580                 return ret;
3581
3582         ret = qlcnic_get_port_stats(adapter, offset, QLCNIC_QUERY_TX_COUNTER,
3583                                                                 &port_stats.tx);
3584         if (ret)
3585                 return ret;
3586
3587         memcpy(buf, &port_stats, size);
3588         return size;
3589 }
3590
3591 static ssize_t
3592 qlcnic_sysfs_get_esw_stats(struct file *file, struct kobject *kobj,
3593         struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3594 {
3595         struct device *dev = container_of(kobj, struct device, kobj);
3596         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3597         struct qlcnic_esw_statistics esw_stats;
3598         int ret;
3599
3600         if (size != sizeof(struct qlcnic_esw_statistics))
3601                 return QL_STATUS_INVALID_PARAM;
3602
3603         if (offset >= QLCNIC_NIU_MAX_XG_PORTS)
3604                 return QL_STATUS_INVALID_PARAM;
3605
3606         memset(&esw_stats, 0, size);
3607         ret = qlcnic_get_eswitch_stats(adapter, offset, QLCNIC_QUERY_RX_COUNTER,
3608                                                                 &esw_stats.rx);
3609         if (ret)
3610                 return ret;
3611
3612         ret = qlcnic_get_eswitch_stats(adapter, offset, QLCNIC_QUERY_TX_COUNTER,
3613                                                                 &esw_stats.tx);
3614         if (ret)
3615                 return ret;
3616
3617         memcpy(buf, &esw_stats, size);
3618         return size;
3619 }
3620
3621 static ssize_t
3622 qlcnic_sysfs_clear_esw_stats(struct file *file, struct kobject *kobj,
3623         struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3624 {
3625         struct device *dev = container_of(kobj, struct device, kobj);
3626         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3627         int ret;
3628
3629         if (offset >= QLCNIC_NIU_MAX_XG_PORTS)
3630                 return QL_STATUS_INVALID_PARAM;
3631
3632         ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_ESWITCH, offset,
3633                                                 QLCNIC_QUERY_RX_COUNTER);
3634         if (ret)
3635                 return ret;
3636
3637         ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_ESWITCH, offset,
3638                                                 QLCNIC_QUERY_TX_COUNTER);
3639         if (ret)
3640                 return ret;
3641
3642         return size;
3643 }
3644
3645 static ssize_t
3646 qlcnic_sysfs_clear_port_stats(struct file *file, struct kobject *kobj,
3647         struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3648 {
3649
3650         struct device *dev = container_of(kobj, struct device, kobj);
3651         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3652         int ret;
3653
3654         if (offset >= QLCNIC_MAX_PCI_FUNC)
3655                 return QL_STATUS_INVALID_PARAM;
3656
3657         ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_PORT, offset,
3658                                                 QLCNIC_QUERY_RX_COUNTER);
3659         if (ret)
3660                 return ret;
3661
3662         ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_PORT, offset,
3663                                                 QLCNIC_QUERY_TX_COUNTER);
3664         if (ret)
3665                 return ret;
3666
3667         return size;
3668 }
3669
3670 static ssize_t
3671 qlcnic_sysfs_read_pci_config(struct file *file, struct kobject *kobj,
3672         struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3673 {
3674         struct device *dev = container_of(kobj, struct device, kobj);
3675         struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3676         struct qlcnic_pci_func_cfg pci_cfg[QLCNIC_MAX_PCI_FUNC];
3677         struct qlcnic_pci_info *pci_info;
3678         int i, ret;
3679
3680         if (size != sizeof(pci_cfg))
3681                 return QL_STATUS_INVALID_PARAM;
3682
3683         pci_info = kcalloc(QLCNIC_MAX_PCI_FUNC, sizeof(*pci_info), GFP_KERNEL);
3684         if (!pci_info)
3685                 return -ENOMEM;
3686
3687         ret = qlcnic_get_pci_info(adapter, pci_info);
3688         if (ret) {
3689                 kfree(pci_info);
3690                 return ret;
3691         }
3692
3693         for (i = 0; i < QLCNIC_MAX_PCI_FUNC ; i++) {
3694                 pci_cfg[i].pci_func = pci_info[i].id;
3695                 pci_cfg[i].func_type = pci_info[i].type;
3696                 pci_cfg[i].port_num = pci_info[i].default_port;
3697                 pci_cfg[i].min_bw = pci_info[i].tx_min_bw;
3698                 pci_cfg[i].max_bw = pci_info[i].tx_max_bw;
3699                 memcpy(&pci_cfg[i].def_mac_addr, &pci_info[i].mac, ETH_ALEN);
3700         }
3701         memcpy(buf, &pci_cfg, size);
3702         kfree(pci_info);
3703         return size;
3704 }
3705 static struct bin_attribute bin_attr_npar_config = {
3706         .attr = {.name = "npar_config", .mode = (S_IRUGO | S_IWUSR)},
3707         .size = 0,
3708         .read = qlcnic_sysfs_read_npar_config,
3709         .write = qlcnic_sysfs_write_npar_config,
3710 };
3711
3712 static struct bin_attribute bin_attr_pci_config = {
3713         .attr = {.name = "pci_config", .mode = (S_IRUGO | S_IWUSR)},
3714         .size = 0,
3715         .read = qlcnic_sysfs_read_pci_config,
3716         .write = NULL,
3717 };
3718
3719 static struct bin_attribute bin_attr_port_stats = {
3720         .attr = {.name = "port_stats", .mode = (S_IRUGO | S_IWUSR)},
3721         .size = 0,
3722         .read = qlcnic_sysfs_get_port_stats,
3723         .write = qlcnic_sysfs_clear_port_stats,
3724 };
3725
3726 static struct bin_attribute bin_attr_esw_stats = {
3727         .attr = {.name = "esw_stats", .mode = (S_IRUGO | S_IWUSR)},
3728         .size = 0,
3729         .read = qlcnic_sysfs_get_esw_stats,
3730         .write = qlcnic_sysfs_clear_esw_stats,
3731 };
3732
3733 static struct bin_attribute bin_attr_esw_config = {
3734         .attr = {.name = "esw_config", .mode = (S_IRUGO | S_IWUSR)},
3735         .size = 0,
3736         .read = qlcnic_sysfs_read_esw_config,
3737         .write = qlcnic_sysfs_write_esw_config,
3738 };
3739
3740 static struct bin_attribute bin_attr_pm_config = {
3741         .attr = {.name = "pm_config", .mode = (S_IRUGO | S_IWUSR)},
3742         .size = 0,
3743         .read = qlcnic_sysfs_read_pm_config,
3744         .write = qlcnic_sysfs_write_pm_config,
3745 };
3746
3747 static void
3748 qlcnic_create_sysfs_entries(struct qlcnic_adapter *adapter)
3749 {
3750         struct device *dev = &adapter->pdev->dev;
3751
3752         if (adapter->capabilities & QLCNIC_FW_CAPABILITY_BDG)
3753                 if (device_create_file(dev, &dev_attr_bridged_mode))
3754                         dev_warn(dev,
3755                                 "failed to create bridged_mode sysfs entry\n");
3756 }
3757
3758 static void
3759 qlcnic_remove_sysfs_entries(struct qlcnic_adapter *adapter)
3760 {
3761         struct device *dev = &adapter->pdev->dev;
3762
3763         if (adapter->capabilities & QLCNIC_FW_CAPABILITY_BDG)
3764                 device_remove_file(dev, &dev_attr_bridged_mode);
3765 }
3766
3767 static void
3768 qlcnic_create_diag_entries(struct qlcnic_adapter *adapter)
3769 {
3770         struct device *dev = &adapter->pdev->dev;
3771
3772         if (device_create_bin_file(dev, &bin_attr_port_stats))
3773                 dev_info(dev, "failed to create port stats sysfs entry");
3774
3775         if (adapter->op_mode == QLCNIC_NON_PRIV_FUNC)
3776                 return;
3777         if (device_create_file(dev, &dev_attr_diag_mode))
3778                 dev_info(dev, "failed to create diag_mode sysfs entry\n");
3779         if (device_create_bin_file(dev, &bin_attr_crb))
3780                 dev_info(dev, "failed to create crb sysfs entry\n");
3781         if (device_create_bin_file(dev, &bin_attr_mem))
3782                 dev_info(dev, "failed to create mem sysfs entry\n");
3783         if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
3784                 return;
3785         if (device_create_bin_file(dev, &bin_attr_esw_config))
3786                 dev_info(dev, "failed to create esw config sysfs entry");
3787         if (adapter->op_mode != QLCNIC_MGMT_FUNC)
3788                 return;
3789         if (device_create_bin_file(dev, &bin_attr_pci_config))
3790                 dev_info(dev, "failed to create pci config sysfs entry");
3791         if (device_create_bin_file(dev, &bin_attr_npar_config))
3792                 dev_info(dev, "failed to create npar config sysfs entry");
3793         if (device_create_bin_file(dev, &bin_attr_pm_config))
3794                 dev_info(dev, "failed to create pm config sysfs entry");
3795         if (device_create_bin_file(dev, &bin_attr_esw_stats))
3796                 dev_info(dev, "failed to create eswitch stats sysfs entry");
3797 }
3798
3799 static void
3800 qlcnic_remove_diag_entries(struct qlcnic_adapter *adapter)
3801 {
3802         struct device *dev = &adapter->pdev->dev;
3803
3804         device_remove_bin_file(dev, &bin_attr_port_stats);
3805
3806         if (adapter->op_mode == QLCNIC_NON_PRIV_FUNC)
3807                 return;
3808         device_remove_file(dev, &dev_attr_diag_mode);
3809         device_remove_bin_file(dev, &bin_attr_crb);
3810         device_remove_bin_file(dev, &bin_attr_mem);
3811         if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
3812                 return;
3813         device_remove_bin_file(dev, &bin_attr_esw_config);
3814         if (adapter->op_mode != QLCNIC_MGMT_FUNC)
3815                 return;
3816         device_remove_bin_file(dev, &bin_attr_pci_config);
3817         device_remove_bin_file(dev, &bin_attr_npar_config);
3818         device_remove_bin_file(dev, &bin_attr_pm_config);
3819         device_remove_bin_file(dev, &bin_attr_esw_stats);
3820 }
3821
3822 #ifdef CONFIG_INET
3823
3824 #define is_qlcnic_netdev(dev) (dev->netdev_ops == &qlcnic_netdev_ops)
3825
3826 static void
3827 qlcnic_config_indev_addr(struct net_device *dev, unsigned long event)
3828 {
3829         struct in_device *indev;
3830         struct qlcnic_adapter *adapter = netdev_priv(dev);
3831
3832         indev = in_dev_get(dev);
3833         if (!indev)
3834                 return;
3835
3836         for_ifa(indev) {
3837                 switch (event) {
3838                 case NETDEV_UP:
3839                         qlcnic_config_ipaddr(adapter,
3840                                         ifa->ifa_address, QLCNIC_IP_UP);
3841                         break;
3842                 case NETDEV_DOWN:
3843                         qlcnic_config_ipaddr(adapter,
3844                                         ifa->ifa_address, QLCNIC_IP_DOWN);
3845                         break;
3846                 default:
3847                         break;
3848                 }
3849         } endfor_ifa(indev);
3850
3851         in_dev_put(indev);
3852 }
3853
3854 static int qlcnic_netdev_event(struct notifier_block *this,
3855                                  unsigned long event, void *ptr)
3856 {
3857         struct qlcnic_adapter *adapter;
3858         struct net_device *dev = (struct net_device *)ptr;
3859
3860 recheck:
3861         if (dev == NULL)
3862                 goto done;
3863
3864         if (dev->priv_flags & IFF_802_1Q_VLAN) {
3865                 dev = vlan_dev_real_dev(dev);
3866                 goto recheck;
3867         }
3868
3869         if (!is_qlcnic_netdev(dev))
3870                 goto done;
3871
3872         adapter = netdev_priv(dev);
3873
3874         if (!adapter)
3875                 goto done;
3876
3877         if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
3878                 goto done;
3879
3880         qlcnic_config_indev_addr(dev, event);
3881 done:
3882         return NOTIFY_DONE;
3883 }
3884
3885 static int
3886 qlcnic_inetaddr_event(struct notifier_block *this,
3887                 unsigned long event, void *ptr)
3888 {
3889         struct qlcnic_adapter *adapter;
3890         struct net_device *dev;
3891
3892         struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
3893
3894         dev = ifa->ifa_dev ? ifa->ifa_dev->dev : NULL;
3895
3896 recheck:
3897         if (dev == NULL || !netif_running(dev))
3898                 goto done;
3899
3900         if (dev->priv_flags & IFF_802_1Q_VLAN) {
3901                 dev = vlan_dev_real_dev(dev);
3902                 goto recheck;
3903         }
3904
3905         if (!is_qlcnic_netdev(dev))
3906                 goto done;
3907
3908         adapter = netdev_priv(dev);
3909
3910         if (!adapter)
3911                 goto done;
3912
3913         if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
3914                 goto done;
3915
3916         switch (event) {
3917         case NETDEV_UP:
3918                 qlcnic_config_ipaddr(adapter, ifa->ifa_address, QLCNIC_IP_UP);
3919                 break;
3920         case NETDEV_DOWN:
3921                 qlcnic_config_ipaddr(adapter, ifa->ifa_address, QLCNIC_IP_DOWN);
3922                 break;
3923         default:
3924                 break;
3925         }
3926
3927 done:
3928         return NOTIFY_DONE;
3929 }
3930
3931 static struct notifier_block    qlcnic_netdev_cb = {
3932         .notifier_call = qlcnic_netdev_event,
3933 };
3934
3935 static struct notifier_block qlcnic_inetaddr_cb = {
3936         .notifier_call = qlcnic_inetaddr_event,
3937 };
3938 #else
3939 static void
3940 qlcnic_config_indev_addr(struct net_device *dev, unsigned long event)
3941 { }
3942 #endif
3943 static struct pci_error_handlers qlcnic_err_handler = {
3944         .error_detected = qlcnic_io_error_detected,
3945         .slot_reset = qlcnic_io_slot_reset,
3946         .resume = qlcnic_io_resume,
3947 };
3948
3949 static struct pci_driver qlcnic_driver = {
3950         .name = qlcnic_driver_name,
3951         .id_table = qlcnic_pci_tbl,
3952         .probe = qlcnic_probe,
3953         .remove = __devexit_p(qlcnic_remove),
3954 #ifdef CONFIG_PM
3955         .suspend = qlcnic_suspend,
3956         .resume = qlcnic_resume,
3957 #endif
3958         .shutdown = qlcnic_shutdown,
3959         .err_handler = &qlcnic_err_handler
3960
3961 };
3962
3963 static int __init qlcnic_init_module(void)
3964 {
3965         int ret;
3966
3967         printk(KERN_INFO "%s\n", qlcnic_driver_string);
3968
3969 #ifdef CONFIG_INET
3970         register_netdevice_notifier(&qlcnic_netdev_cb);
3971         register_inetaddr_notifier(&qlcnic_inetaddr_cb);
3972 #endif
3973
3974         ret = pci_register_driver(&qlcnic_driver);
3975         if (ret) {
3976 #ifdef CONFIG_INET
3977                 unregister_inetaddr_notifier(&qlcnic_inetaddr_cb);
3978                 unregister_netdevice_notifier(&qlcnic_netdev_cb);
3979 #endif
3980         }
3981
3982         return ret;
3983 }
3984
3985 module_init(qlcnic_init_module);
3986
3987 static void __exit qlcnic_exit_module(void)
3988 {
3989
3990         pci_unregister_driver(&qlcnic_driver);
3991
3992 #ifdef CONFIG_INET
3993         unregister_inetaddr_notifier(&qlcnic_inetaddr_cb);
3994         unregister_netdevice_notifier(&qlcnic_netdev_cb);
3995 #endif
3996 }
3997
3998 module_exit(qlcnic_exit_module);