[SCSI] iscsi class: sysfs group is_visible callout for session attrs
[linux-2.6.git] / drivers / scsi / be2iscsi / be_main.c
index a6a2c64..93a3c70 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2009 ServerEngines
+ * Copyright (C) 2005 - 2011 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -7,24 +7,26 @@
  * as published by the Free Software Foundation.  The full GNU General
  * Public License is included in this distribution in the file called COPYING.
  *
- * Written by: Jayamohan Kallickal (jayamohank@serverengines.com)
+ * Written by: Jayamohan Kallickal (jayamohan.kallickal@emulex.com)
  *
  * Contact Information:
- * linux-drivers@serverengines.com
- *
- *  ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
+ * linux-drivers@emulex.com
  *
+ * Emulex
+ * 3333 Susan Street
+ * Costa Mesa, CA 92626
  */
+
 #include <linux/reboot.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/blkdev.h>
 #include <linux/pci.h>
 #include <linux/string.h>
 #include <linux/kernel.h>
 #include <linux/semaphore.h>
+#include <linux/iscsi_boot_sysfs.h>
 
 #include <scsi/libiscsi.h>
 #include <scsi/scsi_transport_iscsi.h>
@@ -40,7 +42,8 @@
 static unsigned int be_iopoll_budget = 10;
 static unsigned int be_max_phys_size = 64;
 static unsigned int enable_msix = 1;
-static unsigned int ring_mode;
+static unsigned int gcrashmode = 0;
+static unsigned int num_hba = 0;
 
 MODULE_DEVICE_TABLE(pci, beiscsi_pci_id_table);
 MODULE_DESCRIPTION(DRV_DESC " " BUILD_STR);
@@ -59,13 +62,331 @@ static int beiscsi_slave_configure(struct scsi_device *sdev)
        return 0;
 }
 
+static int beiscsi_eh_abort(struct scsi_cmnd *sc)
+{
+       struct iscsi_cls_session *cls_session;
+       struct iscsi_task *aborted_task = (struct iscsi_task *)sc->SCp.ptr;
+       struct beiscsi_io_task *aborted_io_task;
+       struct iscsi_conn *conn;
+       struct beiscsi_conn *beiscsi_conn;
+       struct beiscsi_hba *phba;
+       struct iscsi_session *session;
+       struct invalidate_command_table *inv_tbl;
+       struct be_dma_mem nonemb_cmd;
+       unsigned int cid, tag, num_invalidate;
+
+       cls_session = starget_to_session(scsi_target(sc->device));
+       session = cls_session->dd_data;
+
+       spin_lock_bh(&session->lock);
+       if (!aborted_task || !aborted_task->sc) {
+               /* we raced */
+               spin_unlock_bh(&session->lock);
+               return SUCCESS;
+       }
+
+       aborted_io_task = aborted_task->dd_data;
+       if (!aborted_io_task->scsi_cmnd) {
+               /* raced or invalid command */
+               spin_unlock_bh(&session->lock);
+               return SUCCESS;
+       }
+       spin_unlock_bh(&session->lock);
+       conn = aborted_task->conn;
+       beiscsi_conn = conn->dd_data;
+       phba = beiscsi_conn->phba;
+
+       /* invalidate iocb */
+       cid = beiscsi_conn->beiscsi_conn_cid;
+       inv_tbl = phba->inv_tbl;
+       memset(inv_tbl, 0x0, sizeof(*inv_tbl));
+       inv_tbl->cid = cid;
+       inv_tbl->icd = aborted_io_task->psgl_handle->sgl_index;
+       num_invalidate = 1;
+       nonemb_cmd.va = pci_alloc_consistent(phba->ctrl.pdev,
+                               sizeof(struct invalidate_commands_params_in),
+                               &nonemb_cmd.dma);
+       if (nonemb_cmd.va == NULL) {
+               SE_DEBUG(DBG_LVL_1,
+                        "Failed to allocate memory for"
+                        "mgmt_invalidate_icds\n");
+               return FAILED;
+       }
+       nonemb_cmd.size = sizeof(struct invalidate_commands_params_in);
+
+       tag = mgmt_invalidate_icds(phba, inv_tbl, num_invalidate,
+                                  cid, &nonemb_cmd);
+       if (!tag) {
+               shost_printk(KERN_WARNING, phba->shost,
+                            "mgmt_invalidate_icds could not be"
+                            " submitted\n");
+               pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+                                   nonemb_cmd.va, nonemb_cmd.dma);
+
+               return FAILED;
+       } else {
+               wait_event_interruptible(phba->ctrl.mcc_wait[tag],
+                                        phba->ctrl.mcc_numtag[tag]);
+               free_mcc_tag(&phba->ctrl, tag);
+       }
+       pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+                           nonemb_cmd.va, nonemb_cmd.dma);
+       return iscsi_eh_abort(sc);
+}
+
+static int beiscsi_eh_device_reset(struct scsi_cmnd *sc)
+{
+       struct iscsi_task *abrt_task;
+       struct beiscsi_io_task *abrt_io_task;
+       struct iscsi_conn *conn;
+       struct beiscsi_conn *beiscsi_conn;
+       struct beiscsi_hba *phba;
+       struct iscsi_session *session;
+       struct iscsi_cls_session *cls_session;
+       struct invalidate_command_table *inv_tbl;
+       struct be_dma_mem nonemb_cmd;
+       unsigned int cid, tag, i, num_invalidate;
+       int rc = FAILED;
+
+       /* invalidate iocbs */
+       cls_session = starget_to_session(scsi_target(sc->device));
+       session = cls_session->dd_data;
+       spin_lock_bh(&session->lock);
+       if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN)
+               goto unlock;
+
+       conn = session->leadconn;
+       beiscsi_conn = conn->dd_data;
+       phba = beiscsi_conn->phba;
+       cid = beiscsi_conn->beiscsi_conn_cid;
+       inv_tbl = phba->inv_tbl;
+       memset(inv_tbl, 0x0, sizeof(*inv_tbl) * BE2_CMDS_PER_CXN);
+       num_invalidate = 0;
+       for (i = 0; i < conn->session->cmds_max; i++) {
+               abrt_task = conn->session->cmds[i];
+               abrt_io_task = abrt_task->dd_data;
+               if (!abrt_task->sc || abrt_task->state == ISCSI_TASK_FREE)
+                       continue;
+
+               if (abrt_task->sc->device->lun != abrt_task->sc->device->lun)
+                       continue;
+
+               inv_tbl->cid = cid;
+               inv_tbl->icd = abrt_io_task->psgl_handle->sgl_index;
+               num_invalidate++;
+               inv_tbl++;
+       }
+       spin_unlock_bh(&session->lock);
+       inv_tbl = phba->inv_tbl;
+
+       nonemb_cmd.va = pci_alloc_consistent(phba->ctrl.pdev,
+                               sizeof(struct invalidate_commands_params_in),
+                               &nonemb_cmd.dma);
+       if (nonemb_cmd.va == NULL) {
+               SE_DEBUG(DBG_LVL_1,
+                        "Failed to allocate memory for"
+                        "mgmt_invalidate_icds\n");
+               return FAILED;
+       }
+       nonemb_cmd.size = sizeof(struct invalidate_commands_params_in);
+       memset(nonemb_cmd.va, 0, nonemb_cmd.size);
+       tag = mgmt_invalidate_icds(phba, inv_tbl, num_invalidate,
+                                  cid, &nonemb_cmd);
+       if (!tag) {
+               shost_printk(KERN_WARNING, phba->shost,
+                            "mgmt_invalidate_icds could not be"
+                            " submitted\n");
+               pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+                                   nonemb_cmd.va, nonemb_cmd.dma);
+               return FAILED;
+       } else {
+               wait_event_interruptible(phba->ctrl.mcc_wait[tag],
+                                        phba->ctrl.mcc_numtag[tag]);
+               free_mcc_tag(&phba->ctrl, tag);
+       }
+       pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+                           nonemb_cmd.va, nonemb_cmd.dma);
+       return iscsi_eh_device_reset(sc);
+unlock:
+       spin_unlock_bh(&session->lock);
+       return rc;
+}
+
+static ssize_t beiscsi_show_boot_tgt_info(void *data, int type, char *buf)
+{
+       struct beiscsi_hba *phba = data;
+       struct mgmt_session_info *boot_sess = &phba->boot_sess;
+       struct mgmt_conn_info *boot_conn = &boot_sess->conn_list[0];
+       char *str = buf;
+       int rc;
+
+       switch (type) {
+       case ISCSI_BOOT_TGT_NAME:
+               rc = sprintf(buf, "%.*s\n",
+                           (int)strlen(boot_sess->target_name),
+                           (char *)&boot_sess->target_name);
+               break;
+       case ISCSI_BOOT_TGT_IP_ADDR:
+               if (boot_conn->dest_ipaddr.ip_type == 0x1)
+                       rc = sprintf(buf, "%pI4\n",
+                               (char *)&boot_conn->dest_ipaddr.ip_address);
+               else
+                       rc = sprintf(str, "%pI6\n",
+                               (char *)&boot_conn->dest_ipaddr.ip_address);
+               break;
+       case ISCSI_BOOT_TGT_PORT:
+               rc = sprintf(str, "%d\n", boot_conn->dest_port);
+               break;
+
+       case ISCSI_BOOT_TGT_CHAP_NAME:
+               rc = sprintf(str,  "%.*s\n",
+                            boot_conn->negotiated_login_options.auth_data.chap.
+                            target_chap_name_length,
+                            (char *)&boot_conn->negotiated_login_options.
+                            auth_data.chap.target_chap_name);
+               break;
+       case ISCSI_BOOT_TGT_CHAP_SECRET:
+               rc = sprintf(str,  "%.*s\n",
+                            boot_conn->negotiated_login_options.auth_data.chap.
+                            target_secret_length,
+                            (char *)&boot_conn->negotiated_login_options.
+                            auth_data.chap.target_secret);
+               break;
+       case ISCSI_BOOT_TGT_REV_CHAP_NAME:
+               rc = sprintf(str,  "%.*s\n",
+                            boot_conn->negotiated_login_options.auth_data.chap.
+                            intr_chap_name_length,
+                            (char *)&boot_conn->negotiated_login_options.
+                            auth_data.chap.intr_chap_name);
+               break;
+       case ISCSI_BOOT_TGT_REV_CHAP_SECRET:
+               rc = sprintf(str,  "%.*s\n",
+                            boot_conn->negotiated_login_options.auth_data.chap.
+                            intr_secret_length,
+                            (char *)&boot_conn->negotiated_login_options.
+                            auth_data.chap.intr_secret);
+               break;
+       case ISCSI_BOOT_TGT_FLAGS:
+               rc = sprintf(str, "2\n");
+               break;
+       case ISCSI_BOOT_TGT_NIC_ASSOC:
+               rc = sprintf(str, "0\n");
+               break;
+       default:
+               rc = -ENOSYS;
+               break;
+       }
+       return rc;
+}
+
+static ssize_t beiscsi_show_boot_ini_info(void *data, int type, char *buf)
+{
+       struct beiscsi_hba *phba = data;
+       char *str = buf;
+       int rc;
+
+       switch (type) {
+       case ISCSI_BOOT_INI_INITIATOR_NAME:
+               rc = sprintf(str, "%s\n", phba->boot_sess.initiator_iscsiname);
+               break;
+       default:
+               rc = -ENOSYS;
+               break;
+       }
+       return rc;
+}
+
+static ssize_t beiscsi_show_boot_eth_info(void *data, int type, char *buf)
+{
+       struct beiscsi_hba *phba = data;
+       char *str = buf;
+       int rc;
+
+       switch (type) {
+       case ISCSI_BOOT_ETH_FLAGS:
+               rc = sprintf(str, "2\n");
+               break;
+       case ISCSI_BOOT_ETH_INDEX:
+               rc = sprintf(str, "0\n");
+               break;
+       case ISCSI_BOOT_ETH_MAC:
+               rc  = beiscsi_get_macaddr(buf, phba);
+               if (rc < 0) {
+                       SE_DEBUG(DBG_LVL_1, "beiscsi_get_macaddr Failed\n");
+                       return rc;
+               }
+       break;
+       default:
+               rc = -ENOSYS;
+               break;
+       }
+       return rc;
+}
+
+
+static mode_t beiscsi_tgt_get_attr_visibility(void *data, int type)
+{
+       int rc;
+
+       switch (type) {
+       case ISCSI_BOOT_TGT_NAME:
+       case ISCSI_BOOT_TGT_IP_ADDR:
+       case ISCSI_BOOT_TGT_PORT:
+       case ISCSI_BOOT_TGT_CHAP_NAME:
+       case ISCSI_BOOT_TGT_CHAP_SECRET:
+       case ISCSI_BOOT_TGT_REV_CHAP_NAME:
+       case ISCSI_BOOT_TGT_REV_CHAP_SECRET:
+       case ISCSI_BOOT_TGT_NIC_ASSOC:
+       case ISCSI_BOOT_TGT_FLAGS:
+               rc = S_IRUGO;
+               break;
+       default:
+               rc = 0;
+               break;
+       }
+       return rc;
+}
+
+static mode_t beiscsi_ini_get_attr_visibility(void *data, int type)
+{
+       int rc;
+
+       switch (type) {
+       case ISCSI_BOOT_INI_INITIATOR_NAME:
+               rc = S_IRUGO;
+               break;
+       default:
+               rc = 0;
+               break;
+       }
+       return rc;
+}
+
+
+static mode_t beiscsi_eth_get_attr_visibility(void *data, int type)
+{
+       int rc;
+
+       switch (type) {
+       case ISCSI_BOOT_ETH_FLAGS:
+       case ISCSI_BOOT_ETH_MAC:
+       case ISCSI_BOOT_ETH_INDEX:
+               rc = S_IRUGO;
+               break;
+       default:
+               rc = 0;
+               break;
+       }
+       return rc;
+}
+
 /*------------------- PCI Driver operations and data ----------------- */
 static DEFINE_PCI_DEVICE_TABLE(beiscsi_pci_id_table) = {
        { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) },
+       { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID2) },
        { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID1) },
        { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID2) },
        { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID3) },
-       { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID4) },
        { 0 }
 };
 MODULE_DEVICE_TABLE(pci, beiscsi_pci_id_table);
@@ -75,12 +396,12 @@ static struct scsi_host_template beiscsi_sht = {
        .name = "ServerEngines 10Gbe open-iscsi Initiator Driver",
        .proc_name = DRV_NAME,
        .queuecommand = iscsi_queuecommand,
-       .eh_abort_handler = iscsi_eh_abort,
        .change_queue_depth = iscsi_change_queue_depth,
        .slave_configure = beiscsi_slave_configure,
        .target_alloc = iscsi_target_alloc,
-       .eh_device_reset_handler = iscsi_eh_device_reset,
-       .eh_target_reset_handler = iscsi_eh_target_reset,
+       .eh_abort_handler = beiscsi_eh_abort,
+       .eh_device_reset_handler = beiscsi_eh_device_reset,
+       .eh_target_reset_handler = iscsi_eh_session_reset,
        .sg_tablesize = BEISCSI_SGLIST_ELEMENTS,
        .can_queue = BE2_IO_DEPTH,
        .this_id = -1,
@@ -99,7 +420,7 @@ static struct beiscsi_hba *beiscsi_hba_alloc(struct pci_dev *pcidev)
        shost = iscsi_host_alloc(&beiscsi_sht, sizeof(*phba), 0);
        if (!shost) {
                dev_err(&pcidev->dev, "beiscsi_hba_alloc -"
-                       "iscsi_host_alloc failed \n");
+                       "iscsi_host_alloc failed\n");
                return NULL;
        }
        shost->dma_boundary = pcidev->dma_mask;
@@ -116,6 +437,7 @@ static struct beiscsi_hba *beiscsi_hba_alloc(struct pci_dev *pcidev)
 
        if (iscsi_host_add(shost, &phba->pcidev->dev))
                goto free_devices;
+
        return phba;
 
 free_devices:
@@ -144,6 +466,7 @@ static int beiscsi_map_pci_bars(struct beiscsi_hba *phba,
                                struct pci_dev *pcidev)
 {
        u8 __iomem *addr;
+       int pcicfg_reg;
 
        addr = ioremap_nocache(pci_resource_start(pcidev, 2),
                               pci_resource_len(pcidev, 2));
@@ -160,13 +483,19 @@ static int beiscsi_map_pci_bars(struct beiscsi_hba *phba,
        phba->db_va = addr;
        phba->db_pa.u.a64.address =  pci_resource_start(pcidev, 4);
 
-       addr = ioremap_nocache(pci_resource_start(pcidev, 1),
-                              pci_resource_len(pcidev, 1));
+       if (phba->generation == BE_GEN2)
+               pcicfg_reg = 1;
+       else
+               pcicfg_reg = 0;
+
+       addr = ioremap_nocache(pci_resource_start(pcidev, pcicfg_reg),
+                              pci_resource_len(pcidev, pcicfg_reg));
+
        if (addr == NULL)
                goto pci_map_err;
        phba->ctrl.pcicfg = addr;
        phba->pci_va = addr;
-       phba->pci_pa.u.a64.address = pci_resource_start(pcidev, 1);
+       phba->pci_pa.u.a64.address = pci_resource_start(pcidev, pcicfg_reg);
        return 0;
 
 pci_map_err:
@@ -236,8 +565,8 @@ static void beiscsi_get_params(struct beiscsi_hba *phba)
                                    + BE2_TMFS
                                    + BE2_NOPOUT_REQ));
        phba->params.cxns_per_ctrl = phba->fw_config.iscsi_cid_count;
-       phba->params.asyncpdus_per_ctrl = phba->fw_config.iscsi_cid_count;;
-       phba->params.icds_per_ctrl = phba->fw_config.iscsi_icd_count;;
+       phba->params.asyncpdus_per_ctrl = phba->fw_config.iscsi_cid_count * 2;
+       phba->params.icds_per_ctrl = phba->fw_config.iscsi_icd_count;
        phba->params.num_sge_per_io = BE2_SGE;
        phba->params.defpdu_hdr_sz = BE2_DEFPDU_HDR_SZ;
        phba->params.defpdu_data_sz = BE2_DEFPDU_DATA_SZ;
@@ -247,7 +576,7 @@ static void beiscsi_get_params(struct beiscsi_hba *phba)
                                    + BE2_TMFS) / 512) + 1) * 512;
        phba->params.num_eq_entries = (phba->params.num_eq_entries < 1024)
                                ? 1024 : phba->params.num_eq_entries;
-       SE_DEBUG(DBG_LVL_8, "phba->params.num_eq_entries=%d \n",
+       SE_DEBUG(DBG_LVL_8, "phba->params.num_eq_entries=%d\n",
                             phba->params.num_eq_entries);
        phba->params.num_cq_entries =
            (((BE2_CMDS_PER_CXN * 2 +  phba->fw_config.iscsi_cid_count * 2
@@ -400,7 +729,7 @@ static irqreturn_t be_isr(int irq, void *dev_id)
        int isr;
 
        phba = dev_id;
-       ctrl = &phba->ctrl;;
+       ctrl = &phba->ctrl;
        isr = ioread32(ctrl->csr + CEV_ISR0_OFFSET +
                       (PCI_FUNC(ctrl->pdev->devfn) * CEV_ISR_SIZE));
        if (!isr)
@@ -492,7 +821,7 @@ static int beiscsi_init_irqs(struct beiscsi_hba *phba)
        struct pci_dev *pcidev = phba->pcidev;
        struct hwi_controller *phwi_ctrlr;
        struct hwi_context_memory *phwi_context;
-       int ret, msix_vec, i = 0;
+       int ret, msix_vec, i, j;
        char desc[32];
 
        phwi_ctrlr = phba->phwi_ctrlr;
@@ -504,10 +833,25 @@ static int beiscsi_init_irqs(struct beiscsi_hba *phba)
                        msix_vec = phba->msix_entries[i].vector;
                        ret = request_irq(msix_vec, be_isr_msix, 0, desc,
                                          &phwi_context->be_eq[i]);
+                       if (ret) {
+                               shost_printk(KERN_ERR, phba->shost,
+                                            "beiscsi_init_irqs-Failed to"
+                                            "register msix for i = %d\n", i);
+                               if (!i)
+                                       return ret;
+                               goto free_msix_irqs;
+                       }
                }
                msix_vec = phba->msix_entries[i].vector;
                ret = request_irq(msix_vec, be_isr_mcc, 0, "beiscsi_msix_mcc",
                                  &phwi_context->be_eq[i]);
+               if (ret) {
+                       shost_printk(KERN_ERR, phba->shost, "beiscsi_init_irqs-"
+                                    "Failed to register beiscsi_msix_mcc\n");
+                       i++;
+                       goto free_msix_irqs;
+               }
+
        } else {
                ret = request_irq(pcidev->irq, be_isr, IRQF_SHARED,
                                  "beiscsi", phba);
@@ -518,6 +862,10 @@ static int beiscsi_init_irqs(struct beiscsi_hba *phba)
                }
        }
        return 0;
+free_msix_irqs:
+       for (j = i - 1; j == 0; j++)
+               free_irq(msix_vec, &phwi_context->be_eq[j]);
+       return ret;
 }
 
 static void hwi_ring_cq_db(struct beiscsi_hba *phba,
@@ -568,7 +916,7 @@ beiscsi_process_async_pdu(struct beiscsi_conn *beiscsi_conn,
                break;
        default:
                shost_printk(KERN_WARNING, phba->shost,
-                            "Unrecognized opcode 0x%x in async msg \n",
+                            "Unrecognized opcode 0x%x in async msg\n",
                             (ppdu->
                             dw[offsetof(struct amap_pdu_base, opcode) / 32]
                                                & PDUBASE_OPCODE_MASK));
@@ -587,7 +935,7 @@ static struct sgl_handle *alloc_io_sgl_handle(struct beiscsi_hba *phba)
 
        if (phba->io_sgl_hndl_avbl) {
                SE_DEBUG(DBG_LVL_8,
-                        "In alloc_io_sgl_handle,io_sgl_alloc_index=%d \n",
+                        "In alloc_io_sgl_handle,io_sgl_alloc_index=%d\n",
                         phba->io_sgl_alloc_index);
                psgl_handle = phba->io_sgl_hndl_base[phba->
                                                io_sgl_alloc_index];
@@ -606,7 +954,7 @@ static struct sgl_handle *alloc_io_sgl_handle(struct beiscsi_hba *phba)
 static void
 free_io_sgl_handle(struct beiscsi_hba *phba, struct sgl_handle *psgl_handle)
 {
-       SE_DEBUG(DBG_LVL_8, "In free_,io_sgl_free_index=%d \n",
+       SE_DEBUG(DBG_LVL_8, "In free_,io_sgl_free_index=%d\n",
                 phba->io_sgl_free_index);
        if (phba->io_sgl_hndl_base[phba->io_sgl_free_index]) {
                /*
@@ -615,7 +963,7 @@ free_io_sgl_handle(struct beiscsi_hba *phba, struct sgl_handle *psgl_handle)
                 */
                 SE_DEBUG(DBG_LVL_8,
                         "Double Free in IO SGL io_sgl_free_index=%d,"
-                        "value there=%p \n", phba->io_sgl_free_index,
+                        "value there=%p\n", phba->io_sgl_free_index,
                         phba->io_sgl_hndl_base[phba->io_sgl_free_index]);
                return;
        }
@@ -671,9 +1019,7 @@ static void
 free_wrb_handle(struct beiscsi_hba *phba, struct hwi_wrb_context *pwrb_context,
                struct wrb_handle *pwrb_handle)
 {
-       if (!ring_mode)
-               pwrb_context->pwrb_handle_base[pwrb_context->free_index] =
-                                              pwrb_handle;
+       pwrb_context->pwrb_handle_base[pwrb_context->free_index] = pwrb_handle;
        pwrb_context->wrb_handles_available++;
        if (pwrb_context->free_index == (phba->params.wrbs_per_cxn - 1))
                pwrb_context->free_index = 0;
@@ -682,7 +1028,7 @@ free_wrb_handle(struct beiscsi_hba *phba, struct hwi_wrb_context *pwrb_context,
 
        SE_DEBUG(DBG_LVL_8,
                 "FREE WRB: pwrb_handle=%p free_index=0x%x"
-                "wrb_handles_available=%d \n",
+                "wrb_handles_available=%d\n",
                 pwrb_handle, pwrb_context->free_index,
                 pwrb_context->wrb_handles_available);
 }
@@ -694,7 +1040,7 @@ static struct sgl_handle *alloc_mgmt_sgl_handle(struct beiscsi_hba *phba)
        if (phba->eh_sgl_hndl_avbl) {
                psgl_handle = phba->eh_sgl_hndl_base[phba->eh_sgl_alloc_index];
                phba->eh_sgl_hndl_base[phba->eh_sgl_alloc_index] = NULL;
-               SE_DEBUG(DBG_LVL_8, "mgmt_sgl_alloc_index=%d=0x%x \n",
+               SE_DEBUG(DBG_LVL_8, "mgmt_sgl_alloc_index=%d=0x%x\n",
                         phba->eh_sgl_alloc_index, phba->eh_sgl_alloc_index);
                phba->eh_sgl_hndl_avbl--;
                if (phba->eh_sgl_alloc_index ==
@@ -712,7 +1058,7 @@ void
 free_mgmt_sgl_handle(struct beiscsi_hba *phba, struct sgl_handle *psgl_handle)
 {
 
-       SE_DEBUG(DBG_LVL_8, "In  free_mgmt_sgl_handle,eh_sgl_free_index=%d \n",
+       SE_DEBUG(DBG_LVL_8, "In  free_mgmt_sgl_handle,eh_sgl_free_index=%d\n",
                             phba->eh_sgl_free_index);
        if (phba->eh_sgl_hndl_base[phba->eh_sgl_free_index]) {
                /*
@@ -720,7 +1066,7 @@ free_mgmt_sgl_handle(struct beiscsi_hba *phba, struct sgl_handle *psgl_handle)
                 * failed in xmit_task or alloc_pdu.
                 */
                SE_DEBUG(DBG_LVL_8,
-                        "Double Free in eh SGL ,eh_sgl_free_index=%d \n",
+                        "Double Free in eh SGL ,eh_sgl_free_index=%d\n",
                         phba->eh_sgl_free_index);
                return;
        }
@@ -865,7 +1211,6 @@ hwi_complete_drvr_msgs(struct beiscsi_conn *beiscsi_conn,
 {
        struct hwi_wrb_context *pwrb_context;
        struct wrb_handle *pwrb_handle = NULL;
-       struct sgl_handle *psgl_handle = NULL;
        struct hwi_controller *phwi_ctrlr;
        struct iscsi_task *task;
        struct beiscsi_io_task *io_task;
@@ -873,23 +1218,14 @@ hwi_complete_drvr_msgs(struct beiscsi_conn *beiscsi_conn,
        struct iscsi_session *session = conn->session;
 
        phwi_ctrlr = phba->phwi_ctrlr;
-       if (ring_mode) {
-               psgl_handle = phba->sgl_hndl_array[((psol->
-                             dw[offsetof(struct amap_sol_cqe_ring, icd_index) /
-                               32] & SOL_ICD_INDEX_MASK) >> 6)];
-               pwrb_context = &phwi_ctrlr->wrb_context[psgl_handle->cid];
-               task = psgl_handle->task;
-               pwrb_handle = NULL;
-       } else {
-               pwrb_context = &phwi_ctrlr->wrb_context[((psol->
+       pwrb_context = &phwi_ctrlr->wrb_context[((psol->
                                dw[offsetof(struct amap_sol_cqe, cid) / 32] &
                                SOL_CID_MASK) >> 6) -
                                phba->fw_config.iscsi_cid_start];
-               pwrb_handle = pwrb_context->pwrb_handle_basestd[((psol->
+       pwrb_handle = pwrb_context->pwrb_handle_basestd[((psol->
                                dw[offsetof(struct amap_sol_cqe, wrb_index) /
                                32] & SOL_WRB_INDEX_MASK) >> 16)];
-               task = pwrb_handle->pio_handle;
-       }
+       task = pwrb_handle->pio_handle;
 
        io_task = task->dd_data;
        spin_lock(&phba->mgmt_sgl_lock);
@@ -930,55 +1266,46 @@ static void hwi_complete_cmd(struct beiscsi_conn *beiscsi_conn,
        struct iscsi_wrb *pwrb = NULL;
        struct hwi_controller *phwi_ctrlr;
        struct iscsi_task *task;
-       struct sgl_handle *psgl_handle = NULL;
        unsigned int type;
        struct iscsi_conn *conn = beiscsi_conn->conn;
        struct iscsi_session *session = conn->session;
 
        phwi_ctrlr = phba->phwi_ctrlr;
-       if (ring_mode) {
-               psgl_handle = phba->sgl_hndl_array[((psol->
-                             dw[offsetof(struct amap_sol_cqe_ring, icd_index) /
-                             32] & SOL_ICD_INDEX_MASK) >> 6)];
-               task = psgl_handle->task;
-               type = psgl_handle->type;
-       } else {
-               pwrb_context = &phwi_ctrlr->
-                               wrb_context[((psol->dw[offsetof
+       pwrb_context = &phwi_ctrlr->wrb_context[((psol->dw[offsetof
                                (struct amap_sol_cqe, cid) / 32]
                                & SOL_CID_MASK) >> 6) -
                                phba->fw_config.iscsi_cid_start];
-               pwrb_handle = pwrb_context->pwrb_handle_basestd[((psol->
+       pwrb_handle = pwrb_context->pwrb_handle_basestd[((psol->
                                dw[offsetof(struct amap_sol_cqe, wrb_index) /
                                32] & SOL_WRB_INDEX_MASK) >> 16)];
-               task = pwrb_handle->pio_handle;
-               pwrb = pwrb_handle->pwrb;
-               type = (pwrb->dw[offsetof(struct amap_iscsi_wrb, type) / 32] &
-                        WRB_TYPE_MASK) >> 28;
-       }
+       task = pwrb_handle->pio_handle;
+       pwrb = pwrb_handle->pwrb;
+       type = (pwrb->dw[offsetof(struct amap_iscsi_wrb, type) / 32] &
+                                WRB_TYPE_MASK) >> 28;
+
        spin_lock_bh(&session->lock);
        switch (type) {
        case HWH_TYPE_IO:
        case HWH_TYPE_IO_RD:
                if ((task->hdr->opcode & ISCSI_OPCODE_MASK) ==
-                   ISCSI_OP_NOOP_OUT) {
+                    ISCSI_OP_NOOP_OUT)
                        be_complete_nopin_resp(beiscsi_conn, task, psol);
-               } else
+               else
                        be_complete_io(beiscsi_conn, task, psol);
                break;
 
        case HWH_TYPE_LOGOUT:
-               be_complete_logout(beiscsi_conn, task, psol);
+               if ((task->hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGOUT)
+                       be_complete_logout(beiscsi_conn, task, psol);
+               else
+                       be_complete_tmf(beiscsi_conn, task, psol);
+
                break;
 
        case HWH_TYPE_LOGIN:
                SE_DEBUG(DBG_LVL_1,
                         "\t\t No HWH_TYPE_LOGIN Expected in hwi_complete_cmd"
-                        "- Solicited path \n");
-               break;
-
-       case HWH_TYPE_TMF:
-               be_complete_tmf(beiscsi_conn, task, psol);
+                        "- Solicited path\n");
                break;
 
        case HWH_TYPE_NOP:
@@ -986,15 +1313,7 @@ static void hwi_complete_cmd(struct beiscsi_conn *beiscsi_conn,
                break;
 
        default:
-               if (ring_mode)
-                       shost_printk(KERN_WARNING, phba->shost,
-                               "In hwi_complete_cmd, unknown type = %d"
-                               "icd_index 0x%x CID 0x%x\n", type,
-                               ((psol->dw[offsetof(struct amap_sol_cqe_ring,
-                               icd_index) / 32] & SOL_ICD_INDEX_MASK) >> 6),
-                               psgl_handle->cid);
-               else
-                       shost_printk(KERN_WARNING, phba->shost,
+               shost_printk(KERN_WARNING, phba->shost,
                                "In hwi_complete_cmd, unknown type = %d"
                                "wrb_index 0x%x CID 0x%x\n", type,
                                ((psol->dw[offsetof(struct amap_iscsi_wrb,
@@ -1069,7 +1388,7 @@ hwi_get_async_handle(struct beiscsi_hba *phba,
        default:
                pbusy_list = NULL;
                shost_printk(KERN_WARNING, phba->shost,
-                       "Unexpected code=%d \n",
+                       "Unexpected code=%d\n",
                         pdpdu_cqe->dw[offsetof(struct amap_i_t_dpdu_cqe,
                                        code) / 32] & PDUCQE_CODE_MASK);
                return NULL;
@@ -1457,7 +1776,7 @@ static void  beiscsi_process_mcc_isr(struct beiscsi_hba *phba)
                        else
                                SE_DEBUG(DBG_LVL_1,
                                        " Unsupported Async Event, flags"
-                                       " = 0x%08x \n", mcc_compl->flags);
+                                       " = 0x%08x\n", mcc_compl->flags);
                } else if (mcc_compl->flags & CQE_FLAGS_COMPLETED_MASK) {
                        be_mcc_compl_process_isr(&phba->ctrl, mcc_compl);
                        atomic_dec(&phba->ctrl.mcc_obj.q.used);
@@ -1483,7 +1802,6 @@ static unsigned int beiscsi_process_cq(struct be_eq_obj *pbe_eq)
        unsigned int num_processed = 0;
        unsigned int tot_nump = 0;
        struct beiscsi_conn *beiscsi_conn;
-       struct sgl_handle *psgl_handle = NULL;
        struct beiscsi_endpoint *beiscsi_ep;
        struct iscsi_endpoint *ep;
        struct beiscsi_hba *phba;
@@ -1496,18 +1814,11 @@ static unsigned int beiscsi_process_cq(struct be_eq_obj *pbe_eq)
               CQE_VALID_MASK) {
                be_dws_le_to_cpu(sol, sizeof(struct sol_cqe));
 
-               if (ring_mode) {
-                       psgl_handle = phba->sgl_hndl_array[((sol->
-                                     dw[offsetof(struct amap_sol_cqe_ring,
-                                     icd_index) / 32] & SOL_ICD_INDEX_MASK)
-                                     >> 6)];
-                       ep = phba->ep_array[psgl_handle->cid];
-               } else {
-                       ep = phba->ep_array[(u32) ((sol->
+               ep = phba->ep_array[(u32) ((sol->
                                   dw[offsetof(struct amap_sol_cqe, cid) / 32] &
                                   SOL_CID_MASK) >> 6) -
                                   phba->fw_config.iscsi_cid_start];
-               }
+
                beiscsi_ep = ep->dd_data;
                beiscsi_conn = beiscsi_ep->conn;
 
@@ -1524,7 +1835,7 @@ static unsigned int beiscsi_process_cq(struct be_eq_obj *pbe_eq)
                        hwi_complete_cmd(beiscsi_conn, phba, sol);
                        break;
                case DRIVERMSG_NOTIFY:
-                       SE_DEBUG(DBG_LVL_8, "Received DRIVERMSG_NOTIFY \n");
+                       SE_DEBUG(DBG_LVL_8, "Received DRIVERMSG_NOTIFY\n");
                        dmsg = (struct dmsg_cqe *)sol;
                        hwi_complete_drvr_msgs(beiscsi_conn, phba, sol);
                        break;
@@ -1553,21 +1864,13 @@ static unsigned int beiscsi_process_cq(struct be_eq_obj *pbe_eq)
                case CMD_CXN_KILLED_ITT_INVALID:
                case CMD_CXN_KILLED_SEQ_OUTOFORDER:
                case CMD_CXN_KILLED_INVALID_DATASN_RCVD:
-                       if (ring_mode) {
-                               SE_DEBUG(DBG_LVL_1,
-                                "CQ Error notification for cmd.. "
-                                "code %d cid 0x%x\n",
-                                sol->dw[offsetof(struct amap_sol_cqe, code) /
-                                32] & CQE_CODE_MASK, psgl_handle->cid);
-                       } else {
-                               SE_DEBUG(DBG_LVL_1,
+                       SE_DEBUG(DBG_LVL_1,
                                 "CQ Error notification for cmd.. "
                                 "code %d cid 0x%x\n",
                                 sol->dw[offsetof(struct amap_sol_cqe, code) /
                                 32] & CQE_CODE_MASK,
                                 (sol->dw[offsetof(struct amap_sol_cqe, cid) /
                                 32] & SOL_CID_MASK));
-                       }
                        break;
                case UNSOL_DATA_DIGEST_ERROR_NOTIFY:
                        SE_DEBUG(DBG_LVL_1,
@@ -1589,37 +1892,23 @@ static unsigned int beiscsi_process_cq(struct be_eq_obj *pbe_eq)
                case CXN_KILLED_OVER_RUN_RESIDUAL:
                case CXN_KILLED_UNDER_RUN_RESIDUAL:
                case CXN_KILLED_CMND_DATA_NOT_ON_SAME_CONN:
-                       if (ring_mode) {
-                               SE_DEBUG(DBG_LVL_1, "CQ Error %d, reset CID "
-                                "0x%x...\n",
-                                sol->dw[offsetof(struct amap_sol_cqe, code) /
-                                32] & CQE_CODE_MASK, psgl_handle->cid);
-                       } else {
-                               SE_DEBUG(DBG_LVL_1, "CQ Error %d, reset CID "
+                       SE_DEBUG(DBG_LVL_1, "CQ Error %d, reset CID "
                                 "0x%x...\n",
                                 sol->dw[offsetof(struct amap_sol_cqe, code) /
                                 32] & CQE_CODE_MASK,
                                 (sol->dw[offsetof(struct amap_sol_cqe, cid) /
                                 32] & CQE_CID_MASK));
-                       }
                        iscsi_conn_failure(beiscsi_conn->conn,
                                           ISCSI_ERR_CONN_FAILED);
                        break;
                case CXN_KILLED_RST_SENT:
                case CXN_KILLED_RST_RCVD:
-                       if (ring_mode) {
-                               SE_DEBUG(DBG_LVL_1, "CQ Error %d, reset"
-                               "received/sent on CID 0x%x...\n",
-                                sol->dw[offsetof(struct amap_sol_cqe, code) /
-                                32] & CQE_CODE_MASK, psgl_handle->cid);
-                       } else {
-                               SE_DEBUG(DBG_LVL_1, "CQ Error %d, reset"
+                       SE_DEBUG(DBG_LVL_1, "CQ Error %d, reset"
                                "received/sent on CID 0x%x...\n",
                                 sol->dw[offsetof(struct amap_sol_cqe, code) /
                                 32] & CQE_CODE_MASK,
                                 (sol->dw[offsetof(struct amap_sol_cqe, cid) /
                                 32] & CQE_CID_MASK));
-                       }
                        iscsi_conn_failure(beiscsi_conn->conn,
                                           ISCSI_ERR_CONN_FAILED);
                        break;
@@ -1699,7 +1988,7 @@ hwi_write_sgl(struct iscsi_wrb *pwrb, struct scatterlist *sg,
              unsigned int num_sg, struct beiscsi_io_task *io_task)
 {
        struct iscsi_sge *psgl;
-       unsigned short sg_len, index;
+       unsigned int sg_len, index;
        unsigned int sge_len = 0;
        unsigned long long addr;
        struct scatterlist *l_sg;
@@ -1711,30 +2000,27 @@ hwi_write_sgl(struct iscsi_wrb *pwrb, struct scatterlist *sg,
                                      io_task->bhs_pa.u.a32.address_hi);
 
        l_sg = sg;
-       for (index = 0; (index < num_sg) && (index < 2); index++, sg_next(sg)) {
+       for (index = 0; (index < num_sg) && (index < 2); index++,
+                                                        sg = sg_next(sg)) {
                if (index == 0) {
                        sg_len = sg_dma_len(sg);
                        addr = (u64) sg_dma_address(sg);
                        AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_addr_lo, pwrb,
-                                                       (addr & 0xFFFFFFFF));
+                                               ((u32)(addr & 0xFFFFFFFF)));
                        AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_addr_hi, pwrb,
-                                                       (addr >> 32));
+                                                       ((u32)(addr >> 32)));
                        AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_len, pwrb,
                                                        sg_len);
                        sge_len = sg_len;
-                       AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_last, pwrb,
-                                                       1);
                } else {
-                       AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_last, pwrb,
-                                                       0);
                        AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_r2t_offset,
                                                        pwrb, sge_len);
                        sg_len = sg_dma_len(sg);
                        addr = (u64) sg_dma_address(sg);
                        AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_addr_lo, pwrb,
-                                                       (addr & 0xFFFFFFFF));
+                                               ((u32)(addr & 0xFFFFFFFF)));
                        AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_addr_hi, pwrb,
-                                                       (addr >> 32));
+                                                       ((u32)(addr >> 32)));
                        AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_len, pwrb,
                                                        sg_len);
                }
@@ -1749,13 +2035,27 @@ hwi_write_sgl(struct iscsi_wrb *pwrb, struct scatterlist *sg,
        AMAP_SET_BITS(struct amap_iscsi_sge, addr_lo, psgl,
                        io_task->bhs_pa.u.a32.address_lo);
 
-       if (num_sg == 2)
-               AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_last, pwrb, 1);
+       if (num_sg == 1) {
+               AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_last, pwrb,
+                                                               1);
+               AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_last, pwrb,
+                                                               0);
+       } else if (num_sg == 2) {
+               AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_last, pwrb,
+                                                               0);
+               AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_last, pwrb,
+                                                               1);
+       } else {
+               AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_last, pwrb,
+                                                               0);
+               AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_last, pwrb,
+                                                               0);
+       }
        sg = l_sg;
        psgl++;
        psgl++;
        offset = 0;
-       for (index = 0; index < num_sg; index++, sg_next(sg), psgl++) {
+       for (index = 0; index < num_sg; index++, sg = sg_next(sg), psgl++) {
                sg_len = sg_dma_len(sg);
                addr = (u64) sg_dma_address(sg);
                AMAP_SET_BITS(struct amap_iscsi_sge, addr_lo, psgl,
@@ -1796,9 +2096,9 @@ static void hwi_write_buffer(struct iscsi_wrb *pwrb, struct iscsi_task *task)
                        addr = 0;
                }
                AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_addr_lo, pwrb,
-                                               (addr & 0xFFFFFFFF));
+                                               ((u32)(addr & 0xFFFFFFFF)));
                AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_addr_hi, pwrb,
-                                               (addr >> 32));
+                                               ((u32)(addr >> 32)));
                AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_len, pwrb,
                                                task->data_count);
 
@@ -1828,9 +2128,9 @@ static void hwi_write_buffer(struct iscsi_wrb *pwrb, struct iscsi_task *task)
                psgl++;
                if (task->data) {
                        AMAP_SET_BITS(struct amap_iscsi_sge, addr_lo, psgl,
-                                               (addr & 0xFFFFFFFF));
+                                               ((u32)(addr & 0xFFFFFFFF)));
                        AMAP_SET_BITS(struct amap_iscsi_sge, addr_hi, psgl,
-                                               (addr >> 32));
+                                               ((u32)(addr >> 32)));
                }
                AMAP_SET_BITS(struct amap_iscsi_sge, len, psgl, 0x106);
        }
@@ -1978,7 +2278,8 @@ free_mem:
                                            mem_descr->mem_array[j - 1].size,
                                            mem_descr->mem_array[j - 1].
                                            virtual_address,
-                                           mem_descr->mem_array[j - 1].
+                                           (unsigned long)mem_descr->
+                                           mem_array[j - 1].
                                            bus_address.u.a64.address);
                }
                if (i) {
@@ -2091,11 +2392,10 @@ static void beiscsi_init_wrb_handle(struct beiscsi_hba *phba)
        }
        idx = 0;
        pwrb = mem_descr_wrb->mem_array[idx].virtual_address;
-       num_cxn_wrb =
-           ((mem_descr_wrb->mem_array[idx].size) / (sizeof(struct iscsi_wrb)) *
-            phba->params.wrbs_per_cxn);
-
-       for (index = 0; index < phba->params.cxns_per_ctrl; index += 2) {
+       num_cxn_wrb = (mem_descr_wrb->mem_array[idx].size) /
+                     ((sizeof(struct iscsi_wrb) *
+                       phba->params.wrbs_per_cxn));
+       for (index = 0; index < phba->params.cxns_per_ctrl * 2; index += 2) {
                pwrb_context = &phwi_ctrlr->wrb_context[index];
                if (num_cxn_wrb) {
                        for (j = 0; j < phba->params.wrbs_per_cxn; j++) {
@@ -2107,9 +2407,9 @@ static void beiscsi_init_wrb_handle(struct beiscsi_hba *phba)
                } else {
                        idx++;
                        pwrb = mem_descr_wrb->mem_array[idx].virtual_address;
-                       num_cxn_wrb = ((mem_descr_wrb->mem_array[idx].size) /
-                                       (sizeof(struct iscsi_wrb)) *
-                                       phba->params.wrbs_per_cxn);
+                       num_cxn_wrb = (mem_descr_wrb->mem_array[idx].size) /
+                                     ((sizeof(struct iscsi_wrb) *
+                                       phba->params.wrbs_per_cxn));
                        for (j = 0; j < phba->params.wrbs_per_cxn; j++) {
                                pwrb_handle = pwrb_context->pwrb_handle_base[j];
                                pwrb_handle->pwrb = pwrb;
@@ -2148,10 +2448,10 @@ static void hwi_init_async_pdu_ctx(struct beiscsi_hba *phba)
        if (mem_descr->mem_array[0].virtual_address) {
                SE_DEBUG(DBG_LVL_8,
                         "hwi_init_async_pdu_ctx HWI_MEM_ASYNC_HEADER_BUF"
-                        "va=%p \n", mem_descr->mem_array[0].virtual_address);
+                        "va=%p\n", mem_descr->mem_array[0].virtual_address);
        } else
                shost_printk(KERN_WARNING, phba->shost,
-                            "No Virtual address \n");
+                            "No Virtual address\n");
 
        pasync_ctx->async_header.va_base =
                        mem_descr->mem_array[0].virtual_address;
@@ -2164,10 +2464,10 @@ static void hwi_init_async_pdu_ctx(struct beiscsi_hba *phba)
        if (mem_descr->mem_array[0].virtual_address) {
                SE_DEBUG(DBG_LVL_8,
                         "hwi_init_async_pdu_ctx HWI_MEM_ASYNC_HEADER_RING"
-                        "va=%p \n", mem_descr->mem_array[0].virtual_address);
+                        "va=%p\n", mem_descr->mem_array[0].virtual_address);
        } else
                shost_printk(KERN_WARNING, phba->shost,
-                           "No Virtual address \n");
+                           "No Virtual address\n");
        pasync_ctx->async_header.ring_base =
                        mem_descr->mem_array[0].virtual_address;
 
@@ -2176,10 +2476,10 @@ static void hwi_init_async_pdu_ctx(struct beiscsi_hba *phba)
        if (mem_descr->mem_array[0].virtual_address) {
                SE_DEBUG(DBG_LVL_8,
                         "hwi_init_async_pdu_ctx HWI_MEM_ASYNC_HEADER_HANDLE"
-                        "va=%p \n", mem_descr->mem_array[0].virtual_address);
+                        "va=%p\n", mem_descr->mem_array[0].virtual_address);
        } else
                shost_printk(KERN_WARNING, phba->shost,
-                           "No Virtual address \n");
+                           "No Virtual address\n");
 
        pasync_ctx->async_header.handle_base =
                        mem_descr->mem_array[0].virtual_address;
@@ -2191,10 +2491,10 @@ static void hwi_init_async_pdu_ctx(struct beiscsi_hba *phba)
        if (mem_descr->mem_array[0].virtual_address) {
                SE_DEBUG(DBG_LVL_8,
                         "hwi_init_async_pdu_ctx HWI_MEM_ASYNC_DATA_BUF"
-                        "va=%p \n", mem_descr->mem_array[0].virtual_address);
+                        "va=%p\n", mem_descr->mem_array[0].virtual_address);
        } else
                shost_printk(KERN_WARNING, phba->shost,
-                           "No Virtual address \n");
+                           "No Virtual address\n");
        pasync_ctx->async_data.va_base =
                        mem_descr->mem_array[0].virtual_address;
        pasync_ctx->async_data.pa_base.u.a64.address =
@@ -2205,10 +2505,10 @@ static void hwi_init_async_pdu_ctx(struct beiscsi_hba *phba)
        if (mem_descr->mem_array[0].virtual_address) {
                SE_DEBUG(DBG_LVL_8,
                         "hwi_init_async_pdu_ctx HWI_MEM_ASYNC_DATA_RING"
-                        "va=%p \n", mem_descr->mem_array[0].virtual_address);
+                        "va=%p\n", mem_descr->mem_array[0].virtual_address);
        } else
                shost_printk(KERN_WARNING, phba->shost,
-                            "No Virtual address \n");
+                            "No Virtual address\n");
 
        pasync_ctx->async_data.ring_base =
                        mem_descr->mem_array[0].virtual_address;
@@ -2217,7 +2517,7 @@ static void hwi_init_async_pdu_ctx(struct beiscsi_hba *phba)
        mem_descr += HWI_MEM_ASYNC_DATA_HANDLE;
        if (!mem_descr->mem_array[0].virtual_address)
                shost_printk(KERN_WARNING, phba->shost,
-                           "No Virtual address \n");
+                           "No Virtual address\n");
 
        pasync_ctx->async_data.handle_base =
                        mem_descr->mem_array[0].virtual_address;
@@ -2289,7 +2589,7 @@ be_sgl_create_contiguous(void *virtual_address,
        WARN_ON(!sgl);
 
        sgl->va = virtual_address;
-       sgl->dma = physical_address;
+       sgl->dma = (unsigned long)physical_address;
        sgl->size = length;
 
        return 0;
@@ -2372,7 +2672,7 @@ static int beiscsi_create_eqs(struct beiscsi_hba *phba,
                                    sizeof(struct be_eq_entry), eq_vaddress);
                if (ret) {
                        shost_printk(KERN_ERR, phba->shost,
-                                    "be_fill_queue Failed for EQ \n");
+                                    "be_fill_queue Failed for EQ\n");
                        goto create_eq_error;
                }
 
@@ -2382,7 +2682,7 @@ static int beiscsi_create_eqs(struct beiscsi_hba *phba,
                if (ret) {
                        shost_printk(KERN_ERR, phba->shost,
                                     "beiscsi_cmd_eq_create"
-                                    "Failedfor EQ \n");
+                                    "Failedfor EQ\n");
                        goto create_eq_error;
                }
                SE_DEBUG(DBG_LVL_8, "eqid = %d\n", phwi_context->be_eq[i].q.id);
@@ -2430,7 +2730,7 @@ static int beiscsi_create_cqs(struct beiscsi_hba *phba,
                                    sizeof(struct sol_cqe), cq_vaddress);
                if (ret) {
                        shost_printk(KERN_ERR, phba->shost,
-                                    "be_fill_queue Failed for ISCSI CQ \n");
+                                    "be_fill_queue Failed for ISCSI CQ\n");
                        goto create_cq_error;
                }
 
@@ -2440,7 +2740,7 @@ static int beiscsi_create_cqs(struct beiscsi_hba *phba,
                if (ret) {
                        shost_printk(KERN_ERR, phba->shost,
                                     "beiscsi_cmd_eq_create"
-                                    "Failed for ISCSI CQ \n");
+                                    "Failed for ISCSI CQ\n");
                        goto create_cq_error;
                }
                SE_DEBUG(DBG_LVL_8, "iscsi cq_id is %d for eq_id %d\n",
@@ -2490,7 +2790,8 @@ beiscsi_create_def_hdr(struct beiscsi_hba *phba,
                             "be_fill_queue Failed for DEF PDU HDR\n");
                return ret;
        }
-       mem->dma = mem_descr->mem_array[idx].bus_address.u.a64.address;
+       mem->dma = (unsigned long)mem_descr->mem_array[idx].
+                                 bus_address.u.a64.address;
        ret = be_cmd_create_default_pdu_queue(&phba->ctrl, cq, dq,
                                              def_pdu_ring_sz,
                                              phba->params.defpdu_hdr_sz);
@@ -2534,7 +2835,8 @@ beiscsi_create_def_data(struct beiscsi_hba *phba,
                             "be_fill_queue Failed for DEF PDU DATA\n");
                return ret;
        }
-       mem->dma = mem_descr->mem_array[idx].bus_address.u.a64.address;
+       mem->dma = (unsigned long)mem_descr->mem_array[idx].
+                                 bus_address.u.a64.address;
        ret = be_cmd_create_default_pdu_queue(&phba->ctrl, cq, dataq,
                                              def_pdu_ring_sz,
                                              phba->params.defpdu_data_sz);
@@ -2548,7 +2850,7 @@ beiscsi_create_def_data(struct beiscsi_hba *phba,
        SE_DEBUG(DBG_LVL_8, "iscsi def data id is %d\n",
                 phwi_context->be_def_dataq.id);
        hwi_post_async_buffers(phba, 0);
-       SE_DEBUG(DBG_LVL_8, "DEFAULT PDU DATA RING CREATED \n");
+       SE_DEBUG(DBG_LVL_8, "DEFAULT PDU DATA RING CREATED\n");
        return 0;
 }
 
@@ -2580,7 +2882,7 @@ beiscsi_post_pages(struct beiscsi_hba *phba)
                }
                pm_arr++;
        }
-       SE_DEBUG(DBG_LVL_8, "POSTED PAGES \n");
+       SE_DEBUG(DBG_LVL_8, "POSTED PAGES\n");
        return 0;
 }
 
@@ -2603,7 +2905,7 @@ static int be_queue_alloc(struct beiscsi_hba *phba, struct be_queue_info *q,
        mem->size = len * entry_size;
        mem->va = pci_alloc_consistent(phba->pcidev, mem->size, &mem->dma);
        if (!mem->va)
-               return -1;
+               return -ENOMEM;
        memset(mem->va, 0, mem->size);
        return 0;
 }
@@ -2675,6 +2977,7 @@ beiscsi_create_wrb_rings(struct beiscsi_hba *phba,
                if (status != 0) {
                        shost_printk(KERN_ERR, phba->shost,
                                     "wrbq create failed.");
+                       kfree(pwrb_arr);
                        return status;
                }
                phwi_ctrlr->wrb_context[i * 2].cid = phwi_context->be_wrbq[i].
@@ -2798,7 +3101,7 @@ mcc_cq_destroy:
 mcc_cq_free:
        be_queue_free(phba, cq);
 err:
-       return -1;
+       return -ENOMEM;
 }
 
 static int find_num_cpus(void)
@@ -2809,7 +3112,7 @@ static int find_num_cpus(void)
        if (num_cpus >= MAX_CPUS)
                num_cpus = MAX_CPUS - 1;
 
-       SE_DEBUG(DBG_LVL_8, "num_cpus = %d \n", num_cpus);
+       SE_DEBUG(DBG_LVL_8, "num_cpus = %d\n", num_cpus);
        return num_cpus;
 }
 
@@ -2832,7 +3135,7 @@ static int hwi_init_port(struct beiscsi_hba *phba)
 
        status = beiscsi_create_eqs(phba, phwi_context);
        if (status != 0) {
-               shost_printk(KERN_ERR, phba->shost, "EQ not created \n");
+               shost_printk(KERN_ERR, phba->shost, "EQ not created\n");
                goto error;
        }
 
@@ -2843,15 +3146,10 @@ static int hwi_init_port(struct beiscsi_hba *phba)
        status = mgmt_check_supported_fw(ctrl, phba);
        if (status != 0) {
                shost_printk(KERN_ERR, phba->shost,
-                            "Unsupported fw version \n");
+                            "Unsupported fw version\n");
                goto error;
        }
 
-       if (phba->fw_config.iscsi_features == 0x1)
-               ring_mode = 1;
-       else
-               ring_mode = 0;
-
        status = beiscsi_create_cqs(phba, phwi_context);
        if (status != 0) {
                shost_printk(KERN_ERR, phba->shost, "CQ not created\n");
@@ -2904,7 +3202,7 @@ static int hwi_init_controller(struct beiscsi_hba *phba)
        if (1 == phba->init_mem[HWI_MEM_ADDN_CONTEXT].num_elements) {
                phwi_ctrlr->phwi_ctxt = (struct hwi_context_memory *)phba->
                    init_mem[HWI_MEM_ADDN_CONTEXT].mem_array[0].virtual_address;
-               SE_DEBUG(DBG_LVL_8, " phwi_ctrlr->phwi_ctxt=%p \n",
+               SE_DEBUG(DBG_LVL_8, " phwi_ctrlr->phwi_ctxt=%p\n",
                         phwi_ctrlr->phwi_ctxt);
        } else {
                shost_printk(KERN_ERR, phba->shost,
@@ -2937,8 +3235,8 @@ static void beiscsi_free_mem(struct beiscsi_hba *phba)
                        pci_free_consistent(phba->pcidev,
                          mem_descr->mem_array[j - 1].size,
                          mem_descr->mem_array[j - 1].virtual_address,
-                         mem_descr->mem_array[j - 1].bus_address.
-                               u.a64.address);
+                         (unsigned long)mem_descr->mem_array[j - 1].
+                         bus_address.u.a64.address);
                }
                kfree(mem_descr->mem_array);
                mem_descr++;
@@ -2954,7 +3252,7 @@ static int beiscsi_init_controller(struct beiscsi_hba *phba)
        ret = beiscsi_get_memory(phba);
        if (ret < 0) {
                shost_printk(KERN_ERR, phba->shost, "beiscsi_dev_probe -"
-                            "Failed in beiscsi_alloc_memory \n");
+                            "Failed in beiscsi_alloc_memory\n");
                return ret;
        }
 
@@ -2979,17 +3277,6 @@ static int beiscsi_init_sgl_handle(struct beiscsi_hba *phba)
        phba->io_sgl_hndl_avbl = 0;
        phba->eh_sgl_hndl_avbl = 0;
 
-       if (ring_mode) {
-               phba->sgl_hndl_array = kzalloc(sizeof(struct sgl_handle *) *
-                                             phba->params.icds_per_ctrl,
-                                                GFP_KERNEL);
-               if (!phba->sgl_hndl_array) {
-                       shost_printk(KERN_ERR, phba->shost,
-                            "Mem Alloc Failed. Failing to load\n");
-                       return -ENOMEM;
-               }
-       }
-
        mem_descr_sglh = phba->init_mem;
        mem_descr_sglh += HWI_MEM_SGLH;
        if (1 == mem_descr_sglh->num_elements) {
@@ -2997,8 +3284,6 @@ static int beiscsi_init_sgl_handle(struct beiscsi_hba *phba)
                                                 phba->params.ios_per_ctrl,
                                                 GFP_KERNEL);
                if (!phba->io_sgl_hndl_base) {
-                       if (ring_mode)
-                               kfree(phba->sgl_hndl_array);
                        shost_printk(KERN_ERR, phba->shost,
                                     "Mem Alloc Failed. Failing to load\n");
                        return -ENOMEM;
@@ -3044,12 +3329,12 @@ static int beiscsi_init_sgl_handle(struct beiscsi_hba *phba)
        }
        SE_DEBUG(DBG_LVL_8,
                 "phba->io_sgl_hndl_avbl=%d"
-                "phba->eh_sgl_hndl_avbl=%d \n",
+                "phba->eh_sgl_hndl_avbl=%d\n",
                 phba->io_sgl_hndl_avbl,
                 phba->eh_sgl_hndl_avbl);
        mem_descr_sg = phba->init_mem;
        mem_descr_sg += HWI_MEM_SGE;
-       SE_DEBUG(DBG_LVL_8, "\n mem_descr_sg->num_elements=%d \n",
+       SE_DEBUG(DBG_LVL_8, "\n mem_descr_sg->num_elements=%d\n",
                 mem_descr_sg->num_elements);
        arr_index = 0;
        idx = 0;
@@ -3098,7 +3383,7 @@ static int hba_setup_cid_tbls(struct beiscsi_hba *phba)
        if (!phba->ep_array) {
                shost_printk(KERN_ERR, phba->shost,
                             "Failed to allocate memory in "
-                            "hba_setup_cid_tbls \n");
+                            "hba_setup_cid_tbls\n");
                kfree(phba->cid_array);
                return -ENOMEM;
        }
@@ -3111,7 +3396,7 @@ static int hba_setup_cid_tbls(struct beiscsi_hba *phba)
        return 0;
 }
 
-static unsigned char hwi_enable_intr(struct beiscsi_hba *phba)
+static void hwi_enable_intr(struct beiscsi_hba *phba)
 {
        struct be_ctrl_info *ctrl = &phba->ctrl;
        struct hwi_controller *phwi_ctrlr;
@@ -3127,22 +3412,25 @@ static unsigned char hwi_enable_intr(struct beiscsi_hba *phba)
        addr = (u8 __iomem *) ((u8 __iomem *) ctrl->pcicfg +
                        PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET);
        reg = ioread32(addr);
-       SE_DEBUG(DBG_LVL_8, "reg =x%08x \n", reg);
 
        enabled = reg & MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
        if (!enabled) {
                reg |= MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
-               SE_DEBUG(DBG_LVL_8, "reg =x%08x addr=%p \n", reg, addr);
+               SE_DEBUG(DBG_LVL_8, "reg =x%08x addr=%p\n", reg, addr);
                iowrite32(reg, addr);
+       }
+
+       if (!phba->msix_enabled) {
+               eq = &phwi_context->be_eq[0].q;
+               SE_DEBUG(DBG_LVL_8, "eq->id=%d\n", eq->id);
+               hwi_ring_eq_db(phba, eq->id, 0, 0, 1, 1);
+       } else {
                for (i = 0; i <= phba->num_cpus; i++) {
                        eq = &phwi_context->be_eq[i].q;
-                       SE_DEBUG(DBG_LVL_8, "eq->id=%d \n", eq->id);
+                       SE_DEBUG(DBG_LVL_8, "eq->id=%d\n", eq->id);
                        hwi_ring_eq_db(phba, eq->id, 0, 0, 1, 1);
                }
-       } else
-               shost_printk(KERN_WARNING, phba->shost,
-                            "In hwi_enable_intr, Not Enabled \n");
-       return true;
+       }
 }
 
 static void hwi_disable_intr(struct beiscsi_hba *phba)
@@ -3158,7 +3446,146 @@ static void hwi_disable_intr(struct beiscsi_hba *phba)
                iowrite32(reg, addr);
        } else
                shost_printk(KERN_WARNING, phba->shost,
-                            "In hwi_disable_intr, Already Disabled \n");
+                            "In hwi_disable_intr, Already Disabled\n");
+}
+
+static int beiscsi_get_boot_info(struct beiscsi_hba *phba)
+{
+       struct be_cmd_resp_get_boot_target *boot_resp;
+       struct be_cmd_resp_get_session *session_resp;
+       struct be_mcc_wrb *wrb;
+       struct be_dma_mem nonemb_cmd;
+       unsigned int tag, wrb_num;
+       unsigned short status, extd_status;
+       struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
+       int ret = -ENOMEM;
+
+       tag = beiscsi_get_boot_target(phba);
+       if (!tag) {
+               SE_DEBUG(DBG_LVL_1, "be_cmd_get_mac_addr Failed\n");
+               return -EAGAIN;
+       } else
+               wait_event_interruptible(phba->ctrl.mcc_wait[tag],
+                                        phba->ctrl.mcc_numtag[tag]);
+
+       wrb_num = (phba->ctrl.mcc_numtag[tag] & 0x00FF0000) >> 16;
+       extd_status = (phba->ctrl.mcc_numtag[tag] & 0x0000FF00) >> 8;
+       status = phba->ctrl.mcc_numtag[tag] & 0x000000FF;
+       if (status || extd_status) {
+               SE_DEBUG(DBG_LVL_1, "be_cmd_get_mac_addr Failed"
+                                   " status = %d extd_status = %d\n",
+                                   status, extd_status);
+               free_mcc_tag(&phba->ctrl, tag);
+               return -EBUSY;
+       }
+       wrb = queue_get_wrb(mccq, wrb_num);
+       free_mcc_tag(&phba->ctrl, tag);
+       boot_resp = embedded_payload(wrb);
+
+       if (boot_resp->boot_session_handle < 0) {
+               shost_printk(KERN_INFO, phba->shost, "No Boot Session.\n");
+               return -ENXIO;
+       }
+
+       nonemb_cmd.va = pci_alloc_consistent(phba->ctrl.pdev,
+                               sizeof(*session_resp),
+                               &nonemb_cmd.dma);
+       if (nonemb_cmd.va == NULL) {
+               SE_DEBUG(DBG_LVL_1,
+                        "Failed to allocate memory for"
+                        "beiscsi_get_session_info\n");
+               return -ENOMEM;
+       }
+
+       memset(nonemb_cmd.va, 0, sizeof(*session_resp));
+       tag = beiscsi_get_session_info(phba,
+               boot_resp->boot_session_handle, &nonemb_cmd);
+       if (!tag) {
+               SE_DEBUG(DBG_LVL_1, "beiscsi_get_session_info"
+                       " Failed\n");
+               goto boot_freemem;
+       } else
+               wait_event_interruptible(phba->ctrl.mcc_wait[tag],
+                                        phba->ctrl.mcc_numtag[tag]);
+
+       wrb_num = (phba->ctrl.mcc_numtag[tag] & 0x00FF0000) >> 16;
+       extd_status = (phba->ctrl.mcc_numtag[tag] & 0x0000FF00) >> 8;
+       status = phba->ctrl.mcc_numtag[tag] & 0x000000FF;
+       if (status || extd_status) {
+               SE_DEBUG(DBG_LVL_1, "beiscsi_get_session_info Failed"
+                                   " status = %d extd_status = %d\n",
+                                   status, extd_status);
+               free_mcc_tag(&phba->ctrl, tag);
+               goto boot_freemem;
+       }
+       wrb = queue_get_wrb(mccq, wrb_num);
+       free_mcc_tag(&phba->ctrl, tag);
+       session_resp = nonemb_cmd.va ;
+
+       memcpy(&phba->boot_sess, &session_resp->session_info,
+              sizeof(struct mgmt_session_info));
+       ret = 0;
+
+boot_freemem:
+       pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+                   nonemb_cmd.va, nonemb_cmd.dma);
+       return ret;
+}
+
+static void beiscsi_boot_release(void *data)
+{
+       struct beiscsi_hba *phba = data;
+
+       scsi_host_put(phba->shost);
+}
+
+static int beiscsi_setup_boot_info(struct beiscsi_hba *phba)
+{
+       struct iscsi_boot_kobj *boot_kobj;
+
+       /* get boot info using mgmt cmd */
+       if (beiscsi_get_boot_info(phba))
+               /* Try to see if we can carry on without this */
+               return 0;
+
+       phba->boot_kset = iscsi_boot_create_host_kset(phba->shost->host_no);
+       if (!phba->boot_kset)
+               return -ENOMEM;
+
+       /* get a ref because the show function will ref the phba */
+       if (!scsi_host_get(phba->shost))
+               goto free_kset;
+       boot_kobj = iscsi_boot_create_target(phba->boot_kset, 0, phba,
+                                            beiscsi_show_boot_tgt_info,
+                                            beiscsi_tgt_get_attr_visibility,
+                                            beiscsi_boot_release);
+       if (!boot_kobj)
+               goto put_shost;
+
+       if (!scsi_host_get(phba->shost))
+               goto free_kset;
+       boot_kobj = iscsi_boot_create_initiator(phba->boot_kset, 0, phba,
+                                               beiscsi_show_boot_ini_info,
+                                               beiscsi_ini_get_attr_visibility,
+                                               beiscsi_boot_release);
+       if (!boot_kobj)
+               goto put_shost;
+
+       if (!scsi_host_get(phba->shost))
+               goto free_kset;
+       boot_kobj = iscsi_boot_create_ethernet(phba->boot_kset, 0, phba,
+                                              beiscsi_show_boot_eth_info,
+                                              beiscsi_eth_get_attr_visibility,
+                                              beiscsi_boot_release);
+       if (!boot_kobj)
+               goto put_shost;
+       return 0;
+
+put_shost:
+       scsi_host_put(phba->shost);
+free_kset:
+       iscsi_boot_destroy_kset(phba->boot_kset);
+       return -ENOMEM;
 }
 
 static int beiscsi_init_port(struct beiscsi_hba *phba)
@@ -3169,22 +3596,20 @@ static int beiscsi_init_port(struct beiscsi_hba *phba)
        if (ret < 0) {
                shost_printk(KERN_ERR, phba->shost,
                             "beiscsi_dev_probe - Failed in"
-                            "beiscsi_init_controller \n");
+                            "beiscsi_init_controller\n");
                return ret;
        }
        ret = beiscsi_init_sgl_handle(phba);
        if (ret < 0) {
                shost_printk(KERN_ERR, phba->shost,
                             "beiscsi_dev_probe - Failed in"
-                            "beiscsi_init_sgl_handle \n");
+                            "beiscsi_init_sgl_handle\n");
                goto do_cleanup_ctrlr;
        }
 
        if (hba_setup_cid_tbls(phba)) {
                shost_printk(KERN_ERR, phba->shost,
                             "Failed in hba_setup_cid_tbls\n");
-               if (ring_mode)
-                       kfree(phba->sgl_hndl_array);
                kfree(phba->io_sgl_hndl_base);
                kfree(phba->eh_sgl_hndl_base);
                goto do_cleanup_ctrlr;
@@ -3232,17 +3657,15 @@ static void hwi_purge_eq(struct beiscsi_hba *phba)
 
 static void beiscsi_clean_port(struct beiscsi_hba *phba)
 {
-       unsigned char mgmt_status;
+       int mgmt_status;
 
        mgmt_status = mgmt_epfw_cleanup(phba, CMD_CONNECTION_CHUTE_0);
        if (mgmt_status)
                shost_printk(KERN_WARNING, phba->shost,
-                            "mgmt_epfw_cleanup FAILED \n");
+                            "mgmt_epfw_cleanup FAILED\n");
 
        hwi_purge_eq(phba);
        hwi_cleanup(phba);
-       if (ring_mode)
-               kfree(phba->sgl_hndl_array);
        kfree(phba->io_sgl_hndl_base);
        kfree(phba->eh_sgl_hndl_base);
        kfree(phba->cid_array);
@@ -3328,8 +3751,7 @@ beiscsi_offload_connection(struct beiscsi_conn *beiscsi_conn,
        be_dws_le_to_cpu(pwrb, sizeof(struct iscsi_target_context_update_wrb));
 
        doorbell |= beiscsi_conn->beiscsi_conn_cid & DB_WRB_POST_CID_MASK;
-       if (!ring_mode)
-               doorbell |= (pwrb_handle->wrb_index & DB_DEF_PDU_WRB_INDEX_MASK)
+       doorbell |= (pwrb_handle->wrb_index & DB_DEF_PDU_WRB_INDEX_MASK)
                             << DB_DEF_PDU_WRB_INDEX_SHIFT;
        doorbell |= 1 << DB_DEF_PDU_NUM_POSTED_SHIFT;
 
@@ -3367,19 +3789,17 @@ static int beiscsi_alloc_pdu(struct iscsi_task *task, uint8_t opcode)
        dma_addr_t paddr;
 
        io_task->cmd_bhs = pci_pool_alloc(beiscsi_sess->bhs_pool,
-                                         GFP_KERNEL, &paddr);
+                                         GFP_ATOMIC, &paddr);
        if (!io_task->cmd_bhs)
                return -ENOMEM;
        io_task->bhs_pa.u.a64.address = paddr;
        io_task->libiscsi_itt = (itt_t)task->itt;
-       io_task->pwrb_handle = alloc_wrb_handle(phba,
-                                               beiscsi_conn->beiscsi_conn_cid -
-                                               phba->fw_config.iscsi_cid_start
-                                               );
        io_task->conn = beiscsi_conn;
 
        task->hdr = (struct iscsi_hdr *)&io_task->cmd_bhs->iscsi_hdr;
        task->hdr_max = sizeof(struct be_cmd_bhs);
+       io_task->psgl_handle = NULL;
+       io_task->psgl_handle = NULL;
 
        if (task->sc) {
                spin_lock(&phba->io_sgl_lock);
@@ -3387,6 +3807,11 @@ static int beiscsi_alloc_pdu(struct iscsi_task *task, uint8_t opcode)
                spin_unlock(&phba->io_sgl_lock);
                if (!io_task->psgl_handle)
                        goto free_hndls;
+               io_task->pwrb_handle = alloc_wrb_handle(phba,
+                                       beiscsi_conn->beiscsi_conn_cid -
+                                       phba->fw_config.iscsi_cid_start);
+               if (!io_task->pwrb_handle)
+                       goto free_io_hndls;
        } else {
                io_task->scsi_cmnd = NULL;
                if ((opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGIN) {
@@ -3401,9 +3826,20 @@ static int beiscsi_alloc_pdu(struct iscsi_task *task, uint8_t opcode)
                                beiscsi_conn->login_in_progress = 1;
                                beiscsi_conn->plogin_sgl_handle =
                                                        io_task->psgl_handle;
+                               io_task->pwrb_handle =
+                                       alloc_wrb_handle(phba,
+                                       beiscsi_conn->beiscsi_conn_cid -
+                                       phba->fw_config.iscsi_cid_start);
+                               if (!io_task->pwrb_handle)
+                                       goto free_io_hndls;
+                               beiscsi_conn->plogin_wrb_handle =
+                                                       io_task->pwrb_handle;
+
                        } else {
                                io_task->psgl_handle =
                                                beiscsi_conn->plogin_sgl_handle;
+                               io_task->pwrb_handle =
+                                               beiscsi_conn->plogin_wrb_handle;
                        }
                } else {
                        spin_lock(&phba->mgmt_sgl_lock);
@@ -3411,34 +3847,43 @@ static int beiscsi_alloc_pdu(struct iscsi_task *task, uint8_t opcode)
                        spin_unlock(&phba->mgmt_sgl_lock);
                        if (!io_task->psgl_handle)
                                goto free_hndls;
+                       io_task->pwrb_handle =
+                                       alloc_wrb_handle(phba,
+                                       beiscsi_conn->beiscsi_conn_cid -
+                                       phba->fw_config.iscsi_cid_start);
+                       if (!io_task->pwrb_handle)
+                               goto free_mgmt_hndls;
+
                }
        }
        itt = (itt_t) cpu_to_be32(((unsigned int)io_task->pwrb_handle->
                                 wrb_index << 16) | (unsigned int)
                                (io_task->psgl_handle->sgl_index));
-       if (ring_mode) {
-               phba->sgl_hndl_array[io_task->psgl_handle->sgl_index -
-                                    phba->fw_config.iscsi_icd_start] =
-                                    io_task->psgl_handle;
-               io_task->psgl_handle->task = task;
-               io_task->psgl_handle->cid = beiscsi_conn->beiscsi_conn_cid  -
-                                           phba->fw_config.iscsi_cid_start;
-       } else
-               io_task->pwrb_handle->pio_handle = task;
+       io_task->pwrb_handle->pio_handle = task;
 
        io_task->cmd_bhs->iscsi_hdr.itt = itt;
        return 0;
 
+free_io_hndls:
+       spin_lock(&phba->io_sgl_lock);
+       free_io_sgl_handle(phba, io_task->psgl_handle);
+       spin_unlock(&phba->io_sgl_lock);
+       goto free_hndls;
+free_mgmt_hndls:
+       spin_lock(&phba->mgmt_sgl_lock);
+       free_mgmt_sgl_handle(phba, io_task->psgl_handle);
+       spin_unlock(&phba->mgmt_sgl_lock);
 free_hndls:
        phwi_ctrlr = phba->phwi_ctrlr;
        pwrb_context = &phwi_ctrlr->wrb_context[
                        beiscsi_conn->beiscsi_conn_cid -
                        phba->fw_config.iscsi_cid_start];
-       free_wrb_handle(phba, pwrb_context, io_task->pwrb_handle);
+       if (io_task->pwrb_handle)
+               free_wrb_handle(phba, pwrb_context, io_task->pwrb_handle);
        io_task->pwrb_handle = NULL;
        pci_pool_free(beiscsi_sess->bhs_pool, io_task->cmd_bhs,
                      io_task->bhs_pa.u.a64.address);
-       SE_DEBUG(DBG_LVL_1, "Alloc of SGL_ICD Failed \n");
+       SE_DEBUG(DBG_LVL_1, "Alloc of SGL_ICD Failed\n");
        return -ENOMEM;
 }
 
@@ -3473,7 +3918,8 @@ static void beiscsi_cleanup_task(struct iscsi_task *task)
                        io_task->psgl_handle = NULL;
                }
        } else {
-               if ((task->hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGIN)
+               if (task->hdr &&
+                  ((task->hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGIN))
                        return;
                if (io_task->psgl_handle) {
                        spin_lock(&phba->mgmt_sgl_lock);
@@ -3510,27 +3956,20 @@ static int beiscsi_iotask(struct iscsi_task *task, struct scatterlist *sg,
                              ISCSI_OPCODE_SCSI_DATA_OUT);
                AMAP_SET_BITS(struct amap_pdu_data_out, final_bit,
                              &io_task->cmd_bhs->iscsi_data_pdu, 1);
-               if (ring_mode)
-                       io_task->psgl_handle->type = INI_WR_CMD;
-               else
-                       AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
-                                     INI_WR_CMD);
+               AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
+                             INI_WR_CMD);
                AMAP_SET_BITS(struct amap_iscsi_wrb, dsp, pwrb, 1);
        } else {
-               if (ring_mode)
-                       io_task->psgl_handle->type = INI_RD_CMD;
-               else
-                       AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
-                                     INI_RD_CMD);
+               AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
+                             INI_RD_CMD);
                AMAP_SET_BITS(struct amap_iscsi_wrb, dsp, pwrb, 0);
        }
        memcpy(&io_task->cmd_bhs->iscsi_data_pdu.
               dw[offsetof(struct amap_pdu_data_out, lun) / 32],
-              io_task->cmd_bhs->iscsi_hdr.lun, sizeof(struct scsi_lun));
+              &io_task->cmd_bhs->iscsi_hdr.lun, sizeof(struct scsi_lun));
 
        AMAP_SET_BITS(struct amap_iscsi_wrb, lun, pwrb,
-                     cpu_to_be16((unsigned short)io_task->cmd_bhs->iscsi_hdr.
-                                 lun[0]));
+                     cpu_to_be16(*(unsigned short *)&io_task->cmd_bhs->iscsi_hdr.lun));
        AMAP_SET_BITS(struct amap_iscsi_wrb, r2t_exp_dtl, pwrb, xferlen);
        AMAP_SET_BITS(struct amap_iscsi_wrb, wrb_idx, pwrb,
                      io_task->pwrb_handle->wrb_index);
@@ -3546,8 +3985,7 @@ static int beiscsi_iotask(struct iscsi_task *task, struct scatterlist *sg,
        be_dws_le_to_cpu(pwrb, sizeof(struct iscsi_wrb));
 
        doorbell |= beiscsi_conn->beiscsi_conn_cid & DB_WRB_POST_CID_MASK;
-       if (!ring_mode)
-               doorbell |= (io_task->pwrb_handle->wrb_index &
+       doorbell |= (io_task->pwrb_handle->wrb_index &
                     DB_DEF_PDU_WRB_INDEX_MASK) << DB_DEF_PDU_WRB_INDEX_SHIFT;
        doorbell |= 1 << DB_DEF_PDU_NUM_POSTED_SHIFT;
 
@@ -3557,22 +3995,17 @@ static int beiscsi_iotask(struct iscsi_task *task, struct scatterlist *sg,
 
 static int beiscsi_mtask(struct iscsi_task *task)
 {
-       struct beiscsi_io_task *aborted_io_task, *io_task = task->dd_data;
+       struct beiscsi_io_task *io_task = task->dd_data;
        struct iscsi_conn *conn = task->conn;
        struct beiscsi_conn *beiscsi_conn = conn->dd_data;
        struct beiscsi_hba *phba = beiscsi_conn->phba;
-       struct iscsi_session *session;
        struct iscsi_wrb *pwrb = NULL;
-       struct hwi_controller *phwi_ctrlr;
-       struct hwi_wrb_context *pwrb_context;
-       struct wrb_handle *pwrb_handle;
        unsigned int doorbell = 0;
-       unsigned int i, cid;
-       struct iscsi_task *aborted_task;
-       unsigned int tag;
+       unsigned int cid;
 
        cid = beiscsi_conn->beiscsi_conn_cid;
        pwrb = io_task->pwrb_handle->pwrb;
+       memset(pwrb, 0, sizeof(*pwrb));
        AMAP_SET_BITS(struct amap_iscsi_wrb, cmdsn_itt, pwrb,
                      be32_to_cpu(task->cmdsn));
        AMAP_SET_BITS(struct amap_iscsi_wrb, wrb_idx, pwrb,
@@ -3582,85 +4015,47 @@ static int beiscsi_mtask(struct iscsi_task *task)
 
        switch (task->hdr->opcode & ISCSI_OPCODE_MASK) {
        case ISCSI_OP_LOGIN:
-               if (ring_mode)
-                       io_task->psgl_handle->type = TGT_DM_CMD;
-               else
-                       AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
-                                     TGT_DM_CMD);
+               AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
+                             TGT_DM_CMD);
                AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 0);
                AMAP_SET_BITS(struct amap_iscsi_wrb, cmdsn_itt, pwrb, 1);
                hwi_write_buffer(pwrb, task);
                break;
        case ISCSI_OP_NOOP_OUT:
-               if (ring_mode)
-                       io_task->psgl_handle->type = INI_RD_CMD;
-               else
+               if (task->hdr->ttt != ISCSI_RESERVED_TAG) {
                        AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
-                                     INI_RD_CMD);
-               if (task->hdr->ttt == ISCSI_RESERVED_TAG)
+                                     TGT_DM_CMD);
+                       AMAP_SET_BITS(struct amap_iscsi_wrb, cmdsn_itt,
+                                     pwrb, 0);
                        AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 0);
-               else
+               } else {
+                       AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
+                                     INI_RD_CMD);
                        AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 1);
+               }
                hwi_write_buffer(pwrb, task);
                break;
        case ISCSI_OP_TEXT:
-               if (ring_mode)
-                       io_task->psgl_handle->type = INI_WR_CMD;
-               else
-                       AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
-                                     INI_WR_CMD);
+               AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
+                             TGT_DM_CMD);
                AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 0);
-               AMAP_SET_BITS(struct amap_iscsi_wrb, dsp, pwrb, 1);
                hwi_write_buffer(pwrb, task);
                break;
        case ISCSI_OP_SCSI_TMFUNC:
-               session = conn->session;
-               i = ((struct iscsi_tm *)task->hdr)->rtt;
-               phwi_ctrlr = phba->phwi_ctrlr;
-               pwrb_context = &phwi_ctrlr->wrb_context[cid -
-                                           phba->fw_config.iscsi_cid_start];
-               pwrb_handle = pwrb_context->pwrb_handle_basestd[be32_to_cpu(i)
-                                                               >> 16];
-               aborted_task = pwrb_handle->pio_handle;
-                if (!aborted_task)
-                       return 0;
-
-               aborted_io_task = aborted_task->dd_data;
-               if (!aborted_io_task->scsi_cmnd)
-                       return 0;
-
-               tag = mgmt_invalidate_icds(phba,
-                                    aborted_io_task->psgl_handle->sgl_index,
-                                    cid);
-               if (!tag) {
-                       shost_printk(KERN_WARNING, phba->shost,
-                                    "mgmt_invalidate_icds could not be"
-                                    " submitted\n");
-               } else {
-                       wait_event_interruptible(phba->ctrl.mcc_wait[tag],
-                                                phba->ctrl.mcc_numtag[tag]);
-                       free_mcc_tag(&phba->ctrl, tag);
-               }
-               if (ring_mode)
-                       io_task->psgl_handle->type = INI_TMF_CMD;
-               else
-                       AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
-                                     INI_TMF_CMD);
+               AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
+                             INI_TMF_CMD);
                AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 0);
                hwi_write_buffer(pwrb, task);
                break;
        case ISCSI_OP_LOGOUT:
                AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 0);
-               if (ring_mode)
-                       io_task->psgl_handle->type = HWH_TYPE_LOGOUT;
-               else
                AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
-                               HWH_TYPE_LOGOUT);
+                             HWH_TYPE_LOGOUT);
                hwi_write_buffer(pwrb, task);
                break;
 
        default:
-               SE_DEBUG(DBG_LVL_1, "opcode =%d Not supported \n",
+               SE_DEBUG(DBG_LVL_1, "opcode =%d Not supported\n",
                         task->hdr->opcode & ISCSI_OPCODE_MASK);
                return -EINVAL;
        }
@@ -3672,8 +4067,7 @@ static int beiscsi_mtask(struct iscsi_task *task)
        be_dws_le_to_cpu(pwrb, sizeof(struct iscsi_wrb));
 
        doorbell |= cid & DB_WRB_POST_CID_MASK;
-       if (!ring_mode)
-               doorbell |= (io_task->pwrb_handle->wrb_index &
+       doorbell |= (io_task->pwrb_handle->wrb_index &
                     DB_DEF_PDU_WRB_INDEX_MASK) << DB_DEF_PDU_WRB_INDEX_SHIFT;
        doorbell |= 1 << DB_DEF_PDU_NUM_POSTED_SHIFT;
        iowrite32(doorbell, phba->db_va + DB_TXULP0_OFFSET);
@@ -3682,17 +4076,12 @@ static int beiscsi_mtask(struct iscsi_task *task)
 
 static int beiscsi_task_xmit(struct iscsi_task *task)
 {
-       struct iscsi_conn *conn = task->conn;
        struct beiscsi_io_task *io_task = task->dd_data;
        struct scsi_cmnd *sc = task->sc;
-       struct beiscsi_conn *beiscsi_conn = conn->dd_data;
        struct scatterlist *sg;
        int num_sg;
        unsigned int  writedir = 0, xferlen = 0;
 
-       SE_DEBUG(DBG_LVL_4, "\n cid=%d In beiscsi_task_xmit task=%p conn=%p \t"
-                "beiscsi_conn=%p \n", beiscsi_conn->beiscsi_conn_cid,
-                task, conn, beiscsi_conn);
        if (!sc)
                return beiscsi_mtask(task);
 
@@ -3702,13 +4091,11 @@ static int beiscsi_task_xmit(struct iscsi_task *task)
                SE_DEBUG(DBG_LVL_1, " scsi_dma_map Failed\n")
                return num_sg;
        }
-       SE_DEBUG(DBG_LVL_4, "xferlen=0x%08x scmd=%p num_sg=%d sernum=%lu\n",
-                 (scsi_bufflen(sc)), sc, num_sg, sc->serial_number);
        xferlen = scsi_bufflen(sc);
        sg = scsi_sglist(sc);
        if (sc->sc_data_direction == DMA_TO_DEVICE) {
                writedir = 1;
-               SE_DEBUG(DBG_LVL_4, "task->imm_count=0x%08x \n",
+               SE_DEBUG(DBG_LVL_4, "task->imm_count=0x%08x\n",
                         task->imm_count);
        } else
                writedir = 0;
@@ -3722,10 +4109,12 @@ static void beiscsi_remove(struct pci_dev *pcidev)
        struct hwi_context_memory *phwi_context;
        struct be_eq_obj *pbe_eq;
        unsigned int i, msix_vec;
+       u8 *real_offset = 0;
+       u32 value = 0;
 
        phba = (struct beiscsi_hba *)pci_get_drvdata(pcidev);
        if (!phba) {
-               dev_err(&pcidev->dev, "beiscsi_remove called with no phba \n");
+               dev_err(&pcidev->dev, "beiscsi_remove called with no phba\n");
                return;
        }
 
@@ -3750,11 +4139,20 @@ static void beiscsi_remove(struct pci_dev *pcidev)
 
        beiscsi_clean_port(phba);
        beiscsi_free_mem(phba);
+       real_offset = (u8 *)phba->csr_va + MPU_EP_SEMAPHORE;
+
+       value = readl((void *)real_offset);
+
+       if (value & 0x00010000) {
+               value &= 0xfffeffff;
+               writel(value, (void *)real_offset);
+       }
        beiscsi_unmap_pci_function(phba);
        pci_free_consistent(phba->pcidev,
                            phba->ctrl.mbox_mem_alloced.size,
                            phba->ctrl.mbox_mem_alloced.va,
                            phba->ctrl.mbox_mem_alloced.dma);
+       iscsi_boot_destroy_kset(phba->boot_kset);
        iscsi_host_remove(phba->shost);
        pci_dev_put(phba->pcidev);
        iscsi_host_free(phba->shost);
@@ -3782,29 +4180,44 @@ static int __devinit beiscsi_dev_probe(struct pci_dev *pcidev,
        struct hwi_controller *phwi_ctrlr;
        struct hwi_context_memory *phwi_context;
        struct be_eq_obj *pbe_eq;
-       int ret, msix_vec, num_cpus, i;
+       int ret, num_cpus, i;
+       u8 *real_offset = 0;
+       u32 value = 0;
 
        ret = beiscsi_enable_pci(pcidev);
        if (ret < 0) {
-               shost_printk(KERN_ERR, phba->shost, "beiscsi_dev_probe-"
-                            "Failed to enable pci device \n");
+               dev_err(&pcidev->dev, "beiscsi_dev_probe-"
+                       " Failed to enable pci device\n");
                return ret;
        }
 
        phba = beiscsi_hba_alloc(pcidev);
        if (!phba) {
                dev_err(&pcidev->dev, "beiscsi_dev_probe-"
-                       " Failed in beiscsi_hba_alloc \n");
+                       " Failed in beiscsi_hba_alloc\n");
                goto disable_pci;
        }
-       SE_DEBUG(DBG_LVL_8, " phba = %p \n", phba);
+
+       switch (pcidev->device) {
+       case BE_DEVICE_ID1:
+       case OC_DEVICE_ID1:
+       case OC_DEVICE_ID2:
+               phba->generation = BE_GEN2;
+               break;
+       case BE_DEVICE_ID2:
+       case OC_DEVICE_ID3:
+               phba->generation = BE_GEN3;
+               break;
+       default:
+               phba->generation = 0;
+       }
 
        if (enable_msix)
                num_cpus = find_num_cpus();
        else
                num_cpus = 1;
        phba->num_cpus = num_cpus;
-       SE_DEBUG(DBG_LVL_8, "num_cpus = %d \n", phba->num_cpus);
+       SE_DEBUG(DBG_LVL_8, "num_cpus = %d\n", phba->num_cpus);
 
        if (enable_msix)
                beiscsi_msix_enable(phba);
@@ -3815,6 +4228,33 @@ static int __devinit beiscsi_dev_probe(struct pci_dev *pcidev,
                goto hba_free;
        }
 
+       if (!num_hba) {
+               real_offset = (u8 *)phba->csr_va + MPU_EP_SEMAPHORE;
+               value = readl((void *)real_offset);
+               if (value & 0x00010000) {
+                       gcrashmode++;
+                       shost_printk(KERN_ERR, phba->shost,
+                               "Loading Driver in crashdump mode\n");
+                       ret = beiscsi_pci_soft_reset(phba);
+                       if (ret) {
+                               shost_printk(KERN_ERR, phba->shost,
+                                       "Reset Failed. Aborting Crashdump\n");
+                               goto hba_free;
+                       }
+                       ret = be_chk_reset_complete(phba);
+                       if (ret) {
+                               shost_printk(KERN_ERR, phba->shost,
+                                       "Failed to get out of reset."
+                                       "Aborting Crashdump\n");
+                               goto hba_free;
+                       }
+               } else {
+                       value |= 0x00010000;
+                       writel(value, (void *)real_offset);
+                       num_hba++;
+               }
+       }
+
        spin_lock_init(&phba->io_sgl_lock);
        spin_lock_init(&phba->mgmt_sgl_lock);
        spin_lock_init(&phba->isr_lock);
@@ -3825,8 +4265,8 @@ static int __devinit beiscsi_dev_probe(struct pci_dev *pcidev,
                goto free_port;
        }
        phba->shost->max_id = phba->fw_config.iscsi_cid_count;
-       phba->shost->can_queue = phba->params.ios_per_ctrl;
        beiscsi_get_params(phba);
+       phba->shost->can_queue = phba->params.ios_per_ctrl;
        ret = beiscsi_init_port(phba);
        if (ret < 0) {
                shost_printk(KERN_ERR, phba->shost, "beiscsi_dev_probe-"
@@ -3845,7 +4285,7 @@ static int __devinit beiscsi_dev_probe(struct pci_dev *pcidev,
 
        snprintf(phba->wq_name, sizeof(phba->wq_name), "beiscsi_q_irq%u",
                 phba->shost->host_no);
-       phba->wq = create_workqueue(phba->wq_name);
+       phba->wq = alloc_workqueue(phba->wq_name, WQ_MEM_RECLAIM, 1);
        if (!phba->wq) {
                shost_printk(KERN_ERR, phba->shost, "beiscsi_dev_probe-"
                                "Failed to allocate work queue\n");
@@ -3870,25 +4310,19 @@ static int __devinit beiscsi_dev_probe(struct pci_dev *pcidev,
                             "Failed to beiscsi_init_irqs\n");
                goto free_blkenbld;
        }
-       ret = hwi_enable_intr(phba);
-       if (ret < 0) {
-               shost_printk(KERN_ERR, phba->shost, "beiscsi_dev_probe-"
-                            "Failed to hwi_enable_intr\n");
-               goto free_ctrlr;
-       }
-       SE_DEBUG(DBG_LVL_8, "\n\n\n SUCCESS - DRIVER LOADED \n\n\n");
+       hwi_enable_intr(phba);
+
+       if (beiscsi_setup_boot_info(phba))
+               /*
+                * log error but continue, because we may not be using
+                * iscsi boot.
+                */
+               shost_printk(KERN_ERR, phba->shost, "Could not set up "
+                            "iSCSI boot info.");
+
+       SE_DEBUG(DBG_LVL_8, "\n\n\n SUCCESS - DRIVER LOADED\n\n\n");
        return 0;
 
-free_ctrlr:
-       if (phba->msix_enabled) {
-               for (i = 0; i <= phba->num_cpus; i++) {
-                       msix_vec = phba->msix_entries[i].vector;
-                       free_irq(msix_vec, &phwi_context->be_eq[i]);
-               }
-       } else
-               if (phba->pcidev->irq)
-                       free_irq(phba->pcidev->irq, phba);
-       pci_disable_msix(phba->pcidev);
 free_blkenbld:
        destroy_workqueue(phba->wq);
        if (blk_iopoll_enabled)
@@ -3900,12 +4334,23 @@ free_twq:
        beiscsi_clean_port(phba);
        beiscsi_free_mem(phba);
 free_port:
+       real_offset = (u8 *)phba->csr_va + MPU_EP_SEMAPHORE;
+
+       value = readl((void *)real_offset);
+
+       if (value & 0x00010000) {
+               value &= 0xfffeffff;
+               writel(value, (void *)real_offset);
+       }
+
        pci_free_consistent(phba->pcidev,
                            phba->ctrl.mbox_mem_alloced.size,
                            phba->ctrl.mbox_mem_alloced.va,
                           phba->ctrl.mbox_mem_alloced.dma);
        beiscsi_unmap_pci_function(phba);
 hba_free:
+       if (phba->msix_enabled)
+               pci_disable_msix(phba->pcidev);
        iscsi_host_remove(phba->shost);
        pci_dev_put(phba->pcidev);
        iscsi_host_free(phba->shost);
@@ -3917,32 +4362,8 @@ disable_pci:
 struct iscsi_transport beiscsi_iscsi_transport = {
        .owner = THIS_MODULE,
        .name = DRV_NAME,
-       .caps = CAP_RECOVERY_L0 | CAP_HDRDGST |
+       .caps = CAP_RECOVERY_L0 | CAP_HDRDGST | CAP_TEXT_NEGO |
                CAP_MULTI_R2T | CAP_DATADGST | CAP_DATA_PATH_OFFLOAD,
-       .param_mask = ISCSI_MAX_RECV_DLENGTH |
-               ISCSI_MAX_XMIT_DLENGTH |
-               ISCSI_HDRDGST_EN |
-               ISCSI_DATADGST_EN |
-               ISCSI_INITIAL_R2T_EN |
-               ISCSI_MAX_R2T |
-               ISCSI_IMM_DATA_EN |
-               ISCSI_FIRST_BURST |
-               ISCSI_MAX_BURST |
-               ISCSI_PDU_INORDER_EN |
-               ISCSI_DATASEQ_INORDER_EN |
-               ISCSI_ERL |
-               ISCSI_CONN_PORT |
-               ISCSI_CONN_ADDRESS |
-               ISCSI_EXP_STATSN |
-               ISCSI_PERSISTENT_PORT |
-               ISCSI_PERSISTENT_ADDRESS |
-               ISCSI_TARGET_NAME | ISCSI_TPGT |
-               ISCSI_USERNAME | ISCSI_PASSWORD |
-               ISCSI_USERNAME_IN | ISCSI_PASSWORD_IN |
-               ISCSI_FAST_ABORT | ISCSI_ABORT_TMO |
-               ISCSI_LU_RESET_TMO |
-               ISCSI_PING_TMO | ISCSI_RECV_TMO |
-               ISCSI_IFACE_NAME | ISCSI_INITIATOR_NAME,
        .host_param_mask = ISCSI_HOST_HWADDRESS | ISCSI_HOST_IPADDRESS |
                                ISCSI_HOST_INITIATOR_NAME,
        .create_session = beiscsi_session_create,
@@ -3950,18 +4371,20 @@ struct iscsi_transport beiscsi_iscsi_transport = {
        .create_conn = beiscsi_conn_create,
        .bind_conn = beiscsi_conn_bind,
        .destroy_conn = iscsi_conn_teardown,
+       .attr_is_visible = be2iscsi_attr_is_visible,
        .set_param = beiscsi_set_param,
-       .get_conn_param = beiscsi_conn_get_param,
+       .get_conn_param = iscsi_conn_get_param,
        .get_session_param = iscsi_session_get_param,
        .get_host_param = beiscsi_get_host_param,
        .start_conn = beiscsi_conn_start,
-       .stop_conn = beiscsi_conn_stop,
+       .stop_conn = iscsi_conn_stop,
        .send_pdu = iscsi_conn_send_pdu,
        .xmit_task = beiscsi_task_xmit,
        .cleanup_task = beiscsi_cleanup_task,
        .alloc_pdu = beiscsi_alloc_pdu,
        .parse_pdu_itt = beiscsi_parse_pdu,
        .get_stats = beiscsi_conn_get_stats,
+       .get_ep_param = beiscsi_ep_get_param,
        .ep_connect = beiscsi_ep_connect,
        .ep_poll = beiscsi_ep_poll,
        .ep_disconnect = beiscsi_ep_disconnect,
@@ -3986,9 +4409,9 @@ static int __init beiscsi_module_init(void)
                SE_DEBUG(DBG_LVL_1,
                         "beiscsi_module_init - Unable to  register beiscsi"
                         "transport.\n");
-               ret = -ENOMEM;
+               return -ENOMEM;
        }
-       SE_DEBUG(DBG_LVL_8, "In beiscsi_module_init, tt=%p \n",
+       SE_DEBUG(DBG_LVL_8, "In beiscsi_module_init, tt=%p\n",
                 &beiscsi_iscsi_transport);
 
        ret = pci_register_driver(&beiscsi_pci_driver);
@@ -3998,7 +4421,6 @@ static int __init beiscsi_module_init(void)
                         "beiscsi pci driver.\n");
                goto unregister_iscsi_transport;
        }
-       ring_mode = 0;
        return 0;
 
 unregister_iscsi_transport: