1 files changed, 319 insertions, 53 deletions

diff --git a/drivers/net/qlcnic/qlcnic_main.c b/drivers/net/qlcnic/qlcnic_main.c
index 1003eb76fda..655bccd7f8f 100644
--- a/drivers/net/qlcnic/qlcnic_main.c
+++ b/drivers/net/qlcnic/qlcnic_main.c
@@ -35,14 +35,14 @@
 #include <linux/inetdevice.h>
 #include <linux/sysfs.h>
 
-MODULE_DESCRIPTION("QLogic 10 GbE Converged Ethernet Driver");
+MODULE_DESCRIPTION("QLogic 1/10 GbE Converged/Intelligent Ethernet Driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(QLCNIC_LINUX_VERSIONID);
 MODULE_FIRMWARE(QLCNIC_UNIFIED_ROMIMAGE_NAME);
 
 char qlcnic_driver_name[] = "qlcnic";
-static const char qlcnic_driver_string[] = "QLogic Converged Ethernet Driver v"
-    QLCNIC_LINUX_VERSIONID;
+static const char qlcnic_driver_string[] = "QLogic 1/10 GbE "
+        "Converged/Intelligent Ethernet Driver v" QLCNIC_LINUX_VERSIONID;
 
 static int port_mode = QLCNIC_PORT_MODE_AUTO_NEG;
 
@@ -65,6 +65,10 @@ static int load_fw_file;
 module_param(load_fw_file, int, 0644);
 MODULE_PARM_DESC(load_fw_file, "Load firmware from (0=flash, 1=file");
 
+static int qlcnic_config_npars;
+module_param(qlcnic_config_npars, int, 0644);
+MODULE_PARM_DESC(qlcnic_config_npars, "Configure NPARs (0=disabled, 1=enabled");
+
 static int __devinit qlcnic_probe(struct pci_dev *pdev,
                 const struct pci_device_id *ent);
 static void __devexit qlcnic_remove(struct pci_dev *pdev);
@@ -79,6 +83,7 @@ static void qlcnic_schedule_work(struct qlcnic_adapter *adapter,
                 work_func_t func, int delay);
 static void qlcnic_cancel_fw_work(struct qlcnic_adapter *adapter);
 static int qlcnic_poll(struct napi_struct *napi, int budget);
+static int qlcnic_rx_poll(struct napi_struct *napi, int budget);
 #ifdef CONFIG_NET_POLL_CONTROLLER
 static void qlcnic_poll_controller(struct net_device *netdev);
 #endif
@@ -99,7 +104,14 @@ static irqreturn_t qlcnic_msix_intr(int irq, void *data);
 
 static struct net_device_stats *qlcnic_get_stats(struct net_device *netdev);
 static void qlcnic_config_indev_addr(struct net_device *dev, unsigned long);
-
+static int qlcnic_start_firmware(struct qlcnic_adapter *);
+
+static void qlcnic_dev_set_npar_ready(struct qlcnic_adapter *);
+static void qlcnicvf_clear_ilb_mode(struct qlcnic_adapter *);
+static int qlcnicvf_set_ilb_mode(struct qlcnic_adapter *);
+static int qlcnicvf_config_led(struct qlcnic_adapter *, u32, u32);
+static int qlcnicvf_config_bridged_mode(struct qlcnic_adapter *, u32);
+static int qlcnicvf_start_firmware(struct qlcnic_adapter *);
 /*  PCI Device ID Table  */
 #define ENTRY(device) \
         {PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, (device)), \
@@ -120,12 +132,6 @@ qlcnic_update_cmd_producer(struct qlcnic_adapter *adapter,
                 struct qlcnic_host_tx_ring *tx_ring)
 {
         writel(tx_ring->producer, tx_ring->crb_cmd_producer);
-
-        if (qlcnic_tx_avail(tx_ring) <= TX_STOP_THRESH) {
-                netif_stop_queue(adapter->netdev);
-                smp_mb();
-                adapter->stats.xmit_off++;
-        }
 }
 
 static const u32 msi_tgt_status[8] = {
@@ -184,8 +190,13 @@ qlcnic_napi_add(struct qlcnic_adapter *adapter, struct net_device *netdev)
 
         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
                 sds_ring = &recv_ctx->sds_rings[ring];
-                netif_napi_add(netdev, &sds_ring->napi,
-                                qlcnic_poll, QLCNIC_NETDEV_WEIGHT);
+
+                if (ring == adapter->max_sds_rings - 1)
+                        netif_napi_add(netdev, &sds_ring->napi, qlcnic_poll,
+                                QLCNIC_NETDEV_WEIGHT/adapter->max_sds_rings);
+                else
+                        netif_napi_add(netdev, &sds_ring->napi,
+                                qlcnic_rx_poll, QLCNIC_NETDEV_WEIGHT*2);
         }
 
         return 0;
@@ -307,19 +318,14 @@ static void qlcnic_init_msix_entries(struct qlcnic_adapter *adapter, int count)
 static int
 qlcnic_read_mac_addr(struct qlcnic_adapter *adapter)
 {
-        int i;
-        unsigned char *p;
-        u64 mac_addr;
+        u8 mac_addr[ETH_ALEN];
         struct net_device *netdev = adapter->netdev;
         struct pci_dev *pdev = adapter->pdev;
 
-        if (qlcnic_get_mac_addr(adapter, &mac_addr) != 0)
+        if (adapter->nic_ops->get_mac_addr(adapter, mac_addr) != 0)
                 return -EIO;
 
-        p = (unsigned char *)&mac_addr;
-        for (i = 0; i < 6; i++)
-                netdev->dev_addr[i] = *(p + 5 - i);
-
+        memcpy(netdev->dev_addr, mac_addr, ETH_ALEN);
         memcpy(netdev->perm_addr, netdev->dev_addr, netdev->addr_len);
         memcpy(adapter->mac_addr, netdev->dev_addr, netdev->addr_len);
 
@@ -371,6 +377,33 @@ static const struct net_device_ops qlcnic_netdev_ops = {
 #endif
 };
 
+static struct qlcnic_nic_template qlcnic_ops = {
+        .get_mac_addr = qlcnic_get_mac_addr,
+        .config_bridged_mode = qlcnic_config_bridged_mode,
+        .config_led = qlcnic_config_led,
+        .set_ilb_mode = qlcnic_set_ilb_mode,
+        .clear_ilb_mode = qlcnic_clear_ilb_mode,
+        .start_firmware = qlcnic_start_firmware
+};
+
+static struct qlcnic_nic_template qlcnic_pf_ops = {
+        .get_mac_addr = qlcnic_get_mac_address,
+        .config_bridged_mode = qlcnic_config_bridged_mode,
+        .config_led = qlcnic_config_led,
+        .set_ilb_mode = qlcnic_set_ilb_mode,
+        .clear_ilb_mode = qlcnic_clear_ilb_mode,
+        .start_firmware = qlcnic_start_firmware
+};
+
+static struct qlcnic_nic_template qlcnic_vf_ops = {
+        .get_mac_addr = qlcnic_get_mac_address,
+        .config_bridged_mode = qlcnicvf_config_bridged_mode,
+        .config_led = qlcnicvf_config_led,
+        .set_ilb_mode = qlcnicvf_set_ilb_mode,
+        .clear_ilb_mode = qlcnicvf_clear_ilb_mode,
+        .start_firmware = qlcnicvf_start_firmware
+};
+
 static void
 qlcnic_setup_intr(struct qlcnic_adapter *adapter)
 {
@@ -453,6 +486,121 @@ qlcnic_cleanup_pci_map(struct qlcnic_adapter *adapter)
 }
 
 static int
+qlcnic_set_function_modes(struct qlcnic_adapter *adapter)
+{
+        u8 id;
+        u32 ref_count;
+        int i, ret = 1;
+        u32 data = QLCNIC_MGMT_FUNC;
+        void __iomem *priv_op = adapter->ahw.pci_base0 + QLCNIC_DRV_OP_MODE;
+
+        /* If other drivers are not in use set their privilege level */
+        ref_count = QLCRD32(adapter, QLCNIC_CRB_DEV_REF_COUNT);
+        ret = qlcnic_api_lock(adapter);
+        if (ret)
+                goto err_lock;
+        if (QLC_DEV_CLR_REF_CNT(ref_count, adapter->ahw.pci_func))
+                goto err_npar;
+
+        if (qlcnic_config_npars) {
+                for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
+                        id = adapter->npars[i].id;
+                        if (adapter->npars[i].type != QLCNIC_TYPE_NIC ||
+                                id == adapter->ahw.pci_func)
+                                continue;
+                        data |= (qlcnic_config_npars &
+                                        QLC_DEV_SET_DRV(0xf, id));
+                }
+        } else {
+                data = readl(priv_op);
+                data = (data & ~QLC_DEV_SET_DRV(0xf, adapter->ahw.pci_func)) |
+                        (QLC_DEV_SET_DRV(QLCNIC_MGMT_FUNC,
+                        adapter->ahw.pci_func));
+        }
+        writel(data, priv_op);
+err_npar:
+        qlcnic_api_unlock(adapter);
+err_lock:
+        return ret;
+}
+
+static u32
+qlcnic_get_driver_mode(struct qlcnic_adapter *adapter)
+{
+        void __iomem *msix_base_addr;
+        void __iomem *priv_op;
+        u32 func;
+        u32 msix_base;
+        u32 op_mode, priv_level;
+
+        /* Determine FW API version */
+        adapter->fw_hal_version = readl(adapter->ahw.pci_base0 + QLCNIC_FW_API);
+        if (adapter->fw_hal_version == ~0) {
+                adapter->nic_ops = &qlcnic_ops;
+                adapter->fw_hal_version = QLCNIC_FW_BASE;
+                adapter->ahw.pci_func = PCI_FUNC(adapter->pdev->devfn);
+                adapter->capabilities = QLCRD32(adapter, CRB_FW_CAPABILITIES_1);
+                dev_info(&adapter->pdev->dev,
+                        "FW does not support nic partion\n");
+                return adapter->fw_hal_version;
+        }
+
+        /* Find PCI function number */
+        pci_read_config_dword(adapter->pdev, QLCNIC_MSIX_TABLE_OFFSET, &func);
+        msix_base_addr = adapter->ahw.pci_base0 + QLCNIC_MSIX_BASE;
+        msix_base = readl(msix_base_addr);
+        func = (func - msix_base)/QLCNIC_MSIX_TBL_PGSIZE;
+        adapter->ahw.pci_func = func;
+
+        qlcnic_get_nic_info(adapter, adapter->ahw.pci_func);
+
+        if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED)) {
+                adapter->nic_ops = &qlcnic_ops;
+                return adapter->fw_hal_version;
+        }
+
+        /* Determine function privilege level */
+        priv_op = adapter->ahw.pci_base0 + QLCNIC_DRV_OP_MODE;
+        op_mode = readl(priv_op);
+        if (op_mode == QLC_DEV_DRV_DEFAULT)
+                priv_level = QLCNIC_MGMT_FUNC;
+        else
+                priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw.pci_func);
+
+        switch (priv_level) {
+        case QLCNIC_MGMT_FUNC:
+                adapter->op_mode = QLCNIC_MGMT_FUNC;
+                adapter->nic_ops = &qlcnic_pf_ops;
+                qlcnic_get_pci_info(adapter);
+                /* Set privilege level for other functions */
+                qlcnic_set_function_modes(adapter);
+                dev_info(&adapter->pdev->dev,
+                        "HAL Version: %d, Management function\n",
+                        adapter->fw_hal_version);
+                break;
+        case QLCNIC_PRIV_FUNC:
+                adapter->op_mode = QLCNIC_PRIV_FUNC;
+                dev_info(&adapter->pdev->dev,
+                        "HAL Version: %d, Privileged function\n",
+                        adapter->fw_hal_version);
+                adapter->nic_ops = &qlcnic_pf_ops;
+                break;
+        case QLCNIC_NON_PRIV_FUNC:
+                adapter->op_mode = QLCNIC_NON_PRIV_FUNC;
+                dev_info(&adapter->pdev->dev,
+                        "HAL Version: %d Non Privileged function\n",
+                        adapter->fw_hal_version);
+                adapter->nic_ops = &qlcnic_vf_ops;
+                break;
+        default:
+                dev_info(&adapter->pdev->dev, "Unknown function mode: %d\n",
+                        priv_level);
+                return 0;
+        }
+        return adapter->fw_hal_version;
+}
+
+static int
 qlcnic_setup_pci_map(struct qlcnic_adapter *adapter)
 {
         void __iomem *mem_ptr0 = NULL;
@@ -460,7 +608,6 @@ qlcnic_setup_pci_map(struct qlcnic_adapter *adapter)
         unsigned long mem_len, pci_len0 = 0;
 
         struct pci_dev *pdev = adapter->pdev;
-        int pci_func = adapter->ahw.pci_func;
 
         /* remap phys address */
         mem_base = pci_resource_start(pdev, 0); /* 0 is for BAR 0 */
@@ -483,8 +630,13 @@ qlcnic_setup_pci_map(struct qlcnic_adapter *adapter)
         adapter->ahw.pci_base0 = mem_ptr0;
         adapter->ahw.pci_len0 = pci_len0;
 
+        if (!qlcnic_get_driver_mode(adapter)) {
+                iounmap(adapter->ahw.pci_base0);
+                return -EIO;
+        }
+
         adapter->ahw.ocm_win_crb = qlcnic_get_ioaddr(adapter,
-                QLCNIC_PCIX_PS_REG(PCIX_OCM_WINDOW_REG(pci_func)));
+                QLCNIC_PCIX_PS_REG(PCIX_OCM_WINDOW_REG(adapter->ahw.pci_func)));
 
         return 0;
 }
@@ -509,7 +661,7 @@ static void get_brd_name(struct qlcnic_adapter *adapter, char *name)
         }
 
         if (!found)
-                name = "Unknown";
+                sprintf(name, "%pM Gigabit Ethernet", adapter->mac_addr);
 }
 
 static void
@@ -553,8 +705,6 @@ qlcnic_check_options(struct qlcnic_adapter *adapter)
         dev_info(&pdev->dev, "firmware v%d.%d.%d\n",
                         fw_major, fw_minor, fw_build);
 
-        adapter->capabilities = QLCRD32(adapter, CRB_FW_CAPABILITIES_1);
-
         adapter->flags &= ~QLCNIC_LRO_ENABLED;
 
         if (adapter->ahw.port_type == QLCNIC_XGBE) {
@@ -565,6 +715,8 @@ qlcnic_check_options(struct qlcnic_adapter *adapter)
                 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
         }
 
+        qlcnic_get_nic_info(adapter, adapter->ahw.pci_func);
+
         adapter->msix_supported = !!use_msi_x;
         adapter->rss_supported = !!use_msi_x;
 
@@ -591,8 +743,12 @@ qlcnic_start_firmware(struct qlcnic_adapter *adapter)
 
         if (load_fw_file)
                 qlcnic_request_firmware(adapter);
-        else
+        else {
+                if (qlcnic_check_flash_fw_ver(adapter))
+                        goto err_out;
+
                 adapter->fw_type = QLCNIC_FLASH_ROMIMAGE;
+        }
 
         err = qlcnic_need_fw_reset(adapter);
         if (err < 0)
@@ -633,6 +789,10 @@ wait_init:
 
         qlcnic_check_options(adapter);
 
+        if (adapter->flags & QLCNIC_ESWITCH_ENABLED &&
+                adapter->op_mode != QLCNIC_NON_PRIV_FUNC)
+                qlcnic_dev_set_npar_ready(adapter);
+
         adapter->need_fw_reset = 0;
 
         qlcnic_release_firmware(adapter);
@@ -971,18 +1131,17 @@ qlcnic_setup_netdev(struct qlcnic_adapter *adapter,
         adapter->max_mc_count = 38;
 
         netdev->netdev_ops         = &qlcnic_netdev_ops;
-        netdev->watchdog_timeo     = 2*HZ;
+        netdev->watchdog_timeo     = 5*HZ;
 
         qlcnic_change_mtu(netdev, netdev->mtu);
 
         SET_ETHTOOL_OPS(netdev, &qlcnic_ethtool_ops);
 
-        netdev->features |= (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO);
-        netdev->features |= (NETIF_F_GRO);
-        netdev->vlan_features |= (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO);
+        netdev->features |= (NETIF_F_SG | NETIF_F_IP_CSUM |
+                NETIF_F_IPV6_CSUM | NETIF_F_GRO | NETIF_F_TSO | NETIF_F_TSO6);
 
-        netdev->features |= (NETIF_F_IPV6_CSUM | NETIF_F_TSO6);
-        netdev->vlan_features |= (NETIF_F_IPV6_CSUM | NETIF_F_TSO6);
+        netdev->vlan_features |= (NETIF_F_SG | NETIF_F_IP_CSUM |
+                NETIF_F_IPV6_CSUM | NETIF_F_TSO | NETIF_F_TSO6);
 
         if (pci_using_dac) {
                 netdev->features |= NETIF_F_HIGHDMA;
@@ -1036,7 +1195,6 @@ qlcnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         struct net_device *netdev = NULL;
         struct qlcnic_adapter *adapter = NULL;
         int err;
-        int pci_func_id = PCI_FUNC(pdev->devfn);
         uint8_t revision_id;
         uint8_t pci_using_dac;
 
@@ -1072,7 +1230,6 @@ qlcnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         adapter->netdev  = netdev;
         adapter->pdev    = pdev;
         adapter->dev_rst_time = jiffies;
-        adapter->ahw.pci_func  = pci_func_id;
 
         revision_id = pdev->revision;
         adapter->ahw.revision_id = revision_id;
@@ -1088,7 +1245,7 @@ qlcnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 goto err_out_free_netdev;
 
         /* This will be reset for mezz cards  */
-        adapter->portnum = pci_func_id;
+        adapter->portnum = adapter->ahw.pci_func;
 
         err = qlcnic_get_board_info(adapter);
         if (err) {
@@ -1102,7 +1259,7 @@ qlcnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         if (qlcnic_setup_idc_param(adapter))
                 goto err_out_iounmap;
 
-        err = qlcnic_start_firmware(adapter);
+        err = adapter->nic_ops->start_firmware(adapter);
         if (err) {
                 dev_err(&pdev->dev, "Loading fw failed.Please Reboot\n");
                 goto err_out_decr_ref;
@@ -1175,6 +1332,11 @@ static void __devexit qlcnic_remove(struct pci_dev *pdev)
 
         qlcnic_detach(adapter);
 
+        if (adapter->npars != NULL)
+                kfree(adapter->npars);
+        if (adapter->eswitch != NULL)
+                kfree(adapter->eswitch);
+
         qlcnic_clr_all_drv_state(adapter);
 
         clear_bit(__QLCNIC_RESETTING, &adapter->state);
@@ -1263,7 +1425,7 @@ qlcnic_resume(struct pci_dev *pdev)
         pci_set_master(pdev);
         pci_restore_state(pdev);
 
-        err = qlcnic_start_firmware(adapter);
+        err = adapter->nic_ops->start_firmware(adapter);
         if (err) {
                 dev_err(&pdev->dev, "failed to start firmware\n");
                 return err;
@@ -1340,11 +1502,11 @@ qlcnic_tso_check(struct net_device *netdev,
         u8 opcode = TX_ETHER_PKT;
         __be16 protocol = skb->protocol;
         u16 flags = 0, vid = 0;
-        u32 producer;
         int copied, offset, copy_len, hdr_len = 0, tso = 0, vlan_oob = 0;
         struct cmd_desc_type0 *hwdesc;
         struct vlan_ethhdr *vh;
         struct qlcnic_adapter *adapter = netdev_priv(netdev);
+        u32 producer = tx_ring->producer;
 
         if (protocol == cpu_to_be16(ETH_P_8021Q)) {
 
@@ -1360,6 +1522,11 @@ qlcnic_tso_check(struct net_device *netdev,
                 vlan_oob = 1;
         }
 
+        if (*(skb->data) & BIT_0) {
+                flags |= BIT_0;
+                memcpy(&first_desc->eth_addr, skb->data, ETH_ALEN);
+        }
+
         if ((netdev->features & (NETIF_F_TSO | NETIF_F_TSO6)) &&
                         skb_shinfo(skb)->gso_size > 0) {
 
@@ -1409,7 +1576,6 @@ qlcnic_tso_check(struct net_device *netdev,
         /* For LSO, we need to copy the MAC/IP/TCP headers into
          * the descriptor ring
          */
-        producer = tx_ring->producer;
         copied = 0;
         offset = 2;
 
@@ -1537,10 +1703,15 @@ qlcnic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
         /* 4 fragments per cmd des */
         no_of_desc = (frag_count + 3) >> 2;
 
-        if (unlikely(no_of_desc + 2 > qlcnic_tx_avail(tx_ring))) {
+        if (unlikely(qlcnic_tx_avail(tx_ring) <= TX_STOP_THRESH)) {
                 netif_stop_queue(netdev);
-                adapter->stats.xmit_off++;
-                return NETDEV_TX_BUSY;
+                smp_mb();
+                if (qlcnic_tx_avail(tx_ring) > TX_STOP_THRESH)
+                        netif_start_queue(netdev);
+                else {
+                        adapter->stats.xmit_off++;
+                        return NETDEV_TX_BUSY;
+                }
         }
 
         producer = tx_ring->producer;
@@ -1846,14 +2017,12 @@ static int qlcnic_process_cmd_ring(struct qlcnic_adapter *adapter)
                 smp_mb();
 
                 if (netif_queue_stopped(netdev) && netif_carrier_ok(netdev)) {
-                        __netif_tx_lock(tx_ring->txq, smp_processor_id());
                         if (qlcnic_tx_avail(tx_ring) > TX_STOP_THRESH) {
                                 netif_wake_queue(netdev);
-                                adapter->tx_timeo_cnt = 0;
                                 adapter->stats.xmit_on++;
                         }
-                        __netif_tx_unlock(tx_ring->txq);
                 }
+                adapter->tx_timeo_cnt = 0;
         }
         /*
          * If everything is freed up to consumer then check if the ring is full
@@ -1898,6 +2067,25 @@ static int qlcnic_poll(struct napi_struct *napi, int budget)
         return work_done;
 }
 
+static int qlcnic_rx_poll(struct napi_struct *napi, int budget)
+{
+        struct qlcnic_host_sds_ring *sds_ring =
+                container_of(napi, struct qlcnic_host_sds_ring, napi);
+
+        struct qlcnic_adapter *adapter = sds_ring->adapter;
+        int work_done;
+
+        work_done = qlcnic_process_rcv_ring(sds_ring, budget);
+
+        if (work_done < budget) {
+                napi_complete(&sds_ring->napi);
+                if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
+                        qlcnic_enable_int(sds_ring);
+        }
+
+        return work_done;
+}
+
 #ifdef CONFIG_NET_POLL_CONTROLLER
 static void qlcnic_poll_controller(struct net_device *netdev)
 {
@@ -2109,7 +2297,7 @@ qlcnic_fwinit_work(struct work_struct *work)
 {
         struct qlcnic_adapter *adapter = container_of(work,
                         struct qlcnic_adapter, fw_work.work);
-        u32 dev_state = 0xf;
+        u32 dev_state = 0xf, npar_state;
 
         if (qlcnic_api_lock(adapter))
                 goto err_ret;
@@ -2122,6 +2310,19 @@ qlcnic_fwinit_work(struct work_struct *work)
                 return;
         }
 
+        if (adapter->op_mode == QLCNIC_NON_PRIV_FUNC) {
+                npar_state = QLCRD32(adapter, QLCNIC_CRB_DEV_NPAR_STATE);
+                if (npar_state == QLCNIC_DEV_NPAR_RDY) {
+                        qlcnic_api_unlock(adapter);
+                        goto wait_npar;
+                } else {
+                        qlcnic_schedule_work(adapter, qlcnic_fwinit_work,
+                                FW_POLL_DELAY);
+                        qlcnic_api_unlock(adapter);
+                        return;
+                }
+        }
+
         if (adapter->fw_wait_cnt++ > adapter->reset_ack_timeo) {
                 dev_err(&adapter->pdev->dev, "Reset:Failed to get ack %d sec\n",
                                         adapter->reset_ack_timeo);
@@ -2154,7 +2355,7 @@ skip_ack_check:
 
                 qlcnic_api_unlock(adapter);
 
-                if (!qlcnic_start_firmware(adapter)) {
+                if (!adapter->nic_ops->start_firmware(adapter)) {
                         qlcnic_schedule_work(adapter, qlcnic_attach_work, 0);
                         return;
                 }
@@ -2163,6 +2364,7 @@ skip_ack_check:
 
         qlcnic_api_unlock(adapter);
 
+wait_npar:
         dev_state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
         QLCDB(adapter, HW, "Func waiting: Device state=%u\n", dev_state);
 
@@ -2177,7 +2379,7 @@ skip_ack_check:
                 break;
 
         default:
-                if (!qlcnic_start_firmware(adapter)) {
+                if (!adapter->nic_ops->start_firmware(adapter)) {
                         qlcnic_schedule_work(adapter, qlcnic_attach_work, 0);
                         return;
                 }
@@ -2251,6 +2453,26 @@ qlcnic_dev_request_reset(struct qlcnic_adapter *adapter)
         qlcnic_api_unlock(adapter);
 }
 
+/* Transit to NPAR READY state from NPAR NOT READY state */
+static void
+qlcnic_dev_set_npar_ready(struct qlcnic_adapter *adapter)
+{
+        u32 state;
+
+        if (qlcnic_api_lock(adapter))
+                return;
+
+        state = QLCRD32(adapter, QLCNIC_CRB_DEV_NPAR_STATE);
+
+        if (state != QLCNIC_DEV_NPAR_RDY) {
+                QLCWR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE,
+                        QLCNIC_DEV_NPAR_RDY);
+                QLCDB(adapter, DRV, "NPAR READY state set\n");
+        }
+
+        qlcnic_api_unlock(adapter);
+}
+
 static void
 qlcnic_schedule_work(struct qlcnic_adapter *adapter,
                 work_func_t func, int delay)
@@ -2365,6 +2587,46 @@ reschedule:
         qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
 }
 
+static int
+qlcnicvf_start_firmware(struct qlcnic_adapter *adapter)
+{
+        int err;
+
+        err = qlcnic_can_start_firmware(adapter);
+        if (err)
+                return err;
+
+        qlcnic_check_options(adapter);
+
+        adapter->need_fw_reset = 0;
+
+        return err;
+}
+
+static int
+qlcnicvf_config_bridged_mode(struct qlcnic_adapter *adapter, u32 enable)
+{
+        return -EOPNOTSUPP;
+}
+
+static int
+qlcnicvf_config_led(struct qlcnic_adapter *adapter, u32 state, u32 rate)
+{
+        return -EOPNOTSUPP;
+}
+
+static int
+qlcnicvf_set_ilb_mode(struct qlcnic_adapter *adapter)
+{
+        return -EOPNOTSUPP;
+}
+
+static void
+qlcnicvf_clear_ilb_mode(struct qlcnic_adapter *adapter)
+{
+        return;
+}
+
 static ssize_t
 qlcnic_store_bridged_mode(struct device *dev,
                 struct device_attribute *attr, const char *buf, size_t len)
@@ -2382,7 +2644,7 @@ qlcnic_store_bridged_mode(struct device *dev,
         if (strict_strtoul(buf, 2, &new))
                 goto err_out;
 
-        if (!qlcnic_config_bridged_mode(adapter, !!new))
+        if (!adapter->nic_ops->config_bridged_mode(adapter, !!new))
                 ret = len;
 
 err_out:
@@ -2464,7 +2726,8 @@ qlcnic_sysfs_validate_crb(struct qlcnic_adapter *adapter,
 }
 
 static ssize_t
-qlcnic_sysfs_read_crb(struct kobject *kobj, struct bin_attribute *attr,
+qlcnic_sysfs_read_crb(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                 char *buf, loff_t offset, size_t size)
 {
         struct device *dev = container_of(kobj, struct device, kobj);
@@ -2488,7 +2751,8 @@ qlcnic_sysfs_read_crb(struct kobject *kobj, struct bin_attribute *attr,
 }
 
 static ssize_t
-qlcnic_sysfs_write_crb(struct kobject *kobj, struct bin_attribute *attr,
+qlcnic_sysfs_write_crb(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                 char *buf, loff_t offset, size_t size)
 {
         struct device *dev = container_of(kobj, struct device, kobj);
@@ -2525,7 +2789,8 @@ qlcnic_sysfs_validate_mem(struct qlcnic_adapter *adapter,
 }
 
 static ssize_t
-qlcnic_sysfs_read_mem(struct kobject *kobj, struct bin_attribute *attr,
+qlcnic_sysfs_read_mem(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                 char *buf, loff_t offset, size_t size)
 {
         struct device *dev = container_of(kobj, struct device, kobj);
@@ -2546,7 +2811,8 @@ qlcnic_sysfs_read_mem(struct kobject *kobj, struct bin_attribute *attr,
 }
 
 static ssize_t
-qlcnic_sysfs_write_mem(struct kobject *kobj, struct bin_attribute *attr,
+qlcnic_sysfs_write_mem(struct file *filp, struct kobject *kobj,
+                struct bin_attribute *attr,
                 char *buf, loff_t offset, size_t size)
 {
         struct device *dev = container_of(kobj, struct device, kobj);