Merge tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi-misc-2.6

SCSI updates from James Bottomley:
 "The update includes the usual assortment of driver updates (lpfc,
  qla2xxx, qla4xxx, bfa, bnx2fc, bnx2i, isci, fcoe, hpsa) plus a huge
  amount of infrastructure work in the SAS library and transport class
  as well as an iSCSI update.  There's also a new SCSI based virtio
  driver."

* tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi-misc-2.6: (177 commits)
  [SCSI] qla4xxx: Update driver version to 5.02.00-k15
  [SCSI] qla4xxx: trivial cleanup
  [SCSI] qla4xxx: Fix sparse warning
  [SCSI] qla4xxx: Add support for multiple session per host.
  [SCSI] qla4xxx: Export CHAP index as sysfs attribute
  [SCSI] scsi_transport: Export CHAP index as sysfs attribute
  [SCSI] qla4xxx: Add support to display CHAP list and delete CHAP entry
  [SCSI] iscsi_transport: Add support to display CHAP list and delete CHAP entry
  [SCSI] pm8001: fix endian issue with code optimization.
  [SCSI] pm8001: Fix possible racing condition.
  [SCSI] pm8001: Fix bogus interrupt state flag issue.
  [SCSI] ipr: update PCI ID definitions for new adapters
  [SCSI] qla2xxx: handle default case in qla2x00_request_firmware()
  [SCSI] isci: improvements in driver unloading routine
  [SCSI] isci: improve phy event warnings
  [SCSI] isci: debug, provide state-enum-to-string conversions
  [SCSI] scsi_transport_sas: 'enable' phys on reset
  [SCSI] libsas: don't recover end devices attached to disabled phys
  [SCSI] libsas: fixup target_port_protocols for expanders that don't report sata
  [SCSI] libsas: set attached device type and target protocols for local phys
  ...

11 files changed, 808 insertions, 51 deletions

diff --git a/drivers/scsi/qla4xxx/ql4_def.h b/drivers/scsi/qla4xxx/ql4_def.h
index bfe68545203f..7f2492e88be7 100644
--- a/drivers/scsi/qla4xxx/ql4_def.h
+++ b/drivers/scsi/qla4xxx/ql4_def.h
@@ -150,8 +150,6 @@
 #define QL4_SESS_RECOVERY_TMO           120     /* iSCSI session */
                                                 /* recovery timeout */
 
-#define MSB(x) ((uint8_t)((uint16_t)(x) >> 8))
-#define LSW(x) ((uint16_t)(x))
 #define LSDW(x) ((u32)((u64)(x)))
 #define MSDW(x) ((u32)((((u64)(x)) >> 16) >> 16))
 
@@ -223,6 +221,15 @@ struct srb {
         uint16_t reserved2;
 };
 
+/* Mailbox request block structure */
+struct mrb {
+        struct scsi_qla_host *ha;
+        struct mbox_cmd_iocb *mbox;
+        uint32_t mbox_cmd;
+        uint16_t iocb_cnt;              /* Number of used iocbs */
+        uint32_t pid;
+};
+
 /*
  * Asynchronous Event Queue structure
  */
@@ -265,7 +272,7 @@ struct ddb_entry {
                                            * retried */
         uint32_t default_time2wait;       /* Default Min time between
                                            * relogins (+aens) */
-
+        uint16_t chap_tbl_idx;
 };
 
 struct qla_ddb_index {
@@ -284,6 +291,7 @@ struct ql4_tuple_ddb {
         uint16_t options;
 #define DDB_OPT_IPV6 0x0e0e
 #define DDB_OPT_IPV4 0x0f0f
+        uint8_t isid[6];
 };
 
 /*
@@ -303,7 +311,28 @@ struct ql4_tuple_ddb {
 #define DF_ISNS_DISCOVERED      2       /* Device was discovered via iSNS */
 #define DF_FO_MASKED            3
 
+enum qla4_work_type {
+        QLA4_EVENT_AEN,
+        QLA4_EVENT_PING_STATUS,
+};
 
+struct qla4_work_evt {
+        struct list_head list;
+        enum qla4_work_type type;
+        union {
+                struct {
+                        enum iscsi_host_event_code code;
+                        uint32_t data_size;
+                        uint8_t data[0];
+                } aen;
+                struct {
+                        uint32_t status;
+                        uint32_t pid;
+                        uint32_t data_size;
+                        uint8_t data[0];
+                } ping;
+        } u;
+};
 
 struct ql82xx_hw_data {
         /* Offsets for flash/nvram access (set to ~0 if not used). */
@@ -657,6 +686,7 @@ struct scsi_qla_host {
         struct dma_pool *chap_dma_pool;
         uint8_t *chap_list; /* CHAP table cache */
         struct mutex  chap_sem;
+
 #define CHAP_DMA_BLOCK_SIZE    512
         struct workqueue_struct *task_wq;
         unsigned long ddb_idx_map[MAX_DDB_ENTRIES / BITS_PER_LONG];
@@ -674,6 +704,15 @@ struct scsi_qla_host {
         uint16_t sec_ddb_idx;
         int is_reset;
         uint16_t temperature;
+
+        /* event work list */
+        struct list_head work_list;
+        spinlock_t work_lock;
+
+        /* mbox iocb */
+#define MAX_MRB         128
+        struct mrb *active_mrb_array[MAX_MRB];
+        uint32_t mrb_index;
 };
 
 struct ql4_task_data {
diff --git a/drivers/scsi/qla4xxx/ql4_fw.h b/drivers/scsi/qla4xxx/ql4_fw.h
index 7825c141bc1a..210cd1d64475 100644
--- a/drivers/scsi/qla4xxx/ql4_fw.h
+++ b/drivers/scsi/qla4xxx/ql4_fw.h
@@ -331,6 +331,10 @@ struct qla_flt_region {
 /*  Mailbox command definitions */
 #define MBOX_CMD_ABOUT_FW                       0x0009
 #define MBOX_CMD_PING                           0x000B
+#define PING_IPV6_PROTOCOL_ENABLE               0x1
+#define PING_IPV6_LINKLOCAL_ADDR                0x4
+#define PING_IPV6_ADDR0                         0x8
+#define PING_IPV6_ADDR1                         0xC
 #define MBOX_CMD_ENABLE_INTRS                   0x0010
 #define INTR_DISABLE                            0
 #define INTR_ENABLE                             1
@@ -396,6 +400,10 @@ struct qla_flt_region {
 #define FW_ADDSTATE_DHCPv4_LEASE_EXPIRED        0x0008
 #define FW_ADDSTATE_LINK_UP                     0x0010
 #define FW_ADDSTATE_ISNS_SVC_ENABLED            0x0020
+#define FW_ADDSTATE_LINK_SPEED_10MBPS           0x0100
+#define FW_ADDSTATE_LINK_SPEED_100MBPS          0x0200
+#define FW_ADDSTATE_LINK_SPEED_1GBPS            0x0400
+#define FW_ADDSTATE_LINK_SPEED_10GBPS           0x0800
 
 #define MBOX_CMD_GET_DATABASE_ENTRY_DEFAULTS    0x006B
 #define IPV6_DEFAULT_DDB_ENTRY                  0x0001
@@ -918,6 +926,8 @@ struct qla4_header {
 #define ET_CMND_T3               0x19
 #define ET_PASSTHRU0             0x3A
 #define ET_PASSTHRU_STATUS       0x3C
+#define ET_MBOX_CMD             0x38
+#define ET_MBOX_STATUS          0x39
 
         uint8_t entryStatus;
         uint8_t systemDefined;
@@ -1118,6 +1128,20 @@ struct passthru_status {
         uint8_t res4[16];       /* 30-3F */
 };
 
+struct mbox_cmd_iocb {
+        struct qla4_header hdr; /* 00-03 */
+        uint32_t handle;        /* 04-07 */
+        uint32_t in_mbox[8];    /* 08-25 */
+        uint32_t res1[6];       /* 26-3F */
+};
+
+struct mbox_status_iocb {
+        struct qla4_header hdr; /* 00-03 */
+        uint32_t handle;        /* 04-07 */
+        uint32_t out_mbox[8];   /* 08-25 */
+        uint32_t res1[6];       /* 26-3F */
+};
+
 /*
  * ISP queue - response queue entry definition.
  */
diff --git a/drivers/scsi/qla4xxx/ql4_glbl.h b/drivers/scsi/qla4xxx/ql4_glbl.h
index d0dd4b330206..910536667cf5 100644
--- a/drivers/scsi/qla4xxx/ql4_glbl.h
+++ b/drivers/scsi/qla4xxx/ql4_glbl.h
@@ -81,6 +81,8 @@ int qla4xxx_set_flash(struct scsi_qla_host *ha, dma_addr_t dma_addr,
                       uint32_t offset, uint32_t length, uint32_t options);
 int qla4xxx_mailbox_command(struct scsi_qla_host *ha, uint8_t inCount,
                 uint8_t outCount, uint32_t *mbx_cmd, uint32_t *mbx_sts);
+int qla4xxx_get_chap_index(struct scsi_qla_host *ha, char *username,
+                           char *password, int bidi, uint16_t *chap_index);
 
 void qla4xxx_queue_iocb(struct scsi_qla_host *ha);
 void qla4xxx_complete_iocb(struct scsi_qla_host *ha);
@@ -181,6 +183,13 @@ int qla4xxx_flash_ddb_change(struct scsi_qla_host *ha, uint32_t fw_ddb_index,
 int qla4xxx_ddb_change(struct scsi_qla_host *ha, uint32_t fw_ddb_index,
                        struct ddb_entry *ddb_entry, uint32_t state);
 void qla4xxx_build_ddb_list(struct scsi_qla_host *ha, int is_reset);
+int qla4xxx_post_aen_work(struct scsi_qla_host *ha, uint32_t aen_code,
+                          uint32_t data_size, uint8_t *data);
+int qla4xxx_ping_iocb(struct scsi_qla_host *ha, uint32_t options,
+                      uint32_t payload_size, uint32_t pid, uint8_t *ipaddr);
+int qla4xxx_post_ping_evt_work(struct scsi_qla_host *ha,
+                               uint32_t status, uint32_t pid,
+                               uint32_t data_size, uint8_t *data);
 
 /* BSG Functions */
 int qla4xxx_bsg_request(struct bsg_job *bsg_job);
diff --git a/drivers/scsi/qla4xxx/ql4_init.c b/drivers/scsi/qla4xxx/ql4_init.c
index 90614f38b55d..90ee5d8fa731 100644
--- a/drivers/scsi/qla4xxx/ql4_init.c
+++ b/drivers/scsi/qla4xxx/ql4_init.c
@@ -86,6 +86,7 @@ static void qla4xxx_init_response_q_entries(struct scsi_qla_host *ha)
 int qla4xxx_init_rings(struct scsi_qla_host *ha)
 {
         unsigned long flags = 0;
+        int i;
 
         /* Initialize request queue. */
         spin_lock_irqsave(&ha->hardware_lock, flags);
@@ -125,6 +126,10 @@ int qla4xxx_init_rings(struct scsi_qla_host *ha)
 
         qla4xxx_init_response_q_entries(ha);
 
+        /* Initialize mabilbox active array */
+        for (i = 0; i < MAX_MRB; i++)
+                ha->active_mrb_array[i] = NULL;
+
         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 
         return QLA_SUCCESS;
diff --git a/drivers/scsi/qla4xxx/ql4_iocb.c b/drivers/scsi/qla4xxx/ql4_iocb.c
index 410669351906..2a2022a6bb9b 100644
--- a/drivers/scsi/qla4xxx/ql4_iocb.c
+++ b/drivers/scsi/qla4xxx/ql4_iocb.c
@@ -445,3 +445,95 @@ queuing_error:
         spin_unlock_irqrestore(&ha->hardware_lock, flags);
         return ret;
 }
+
+static struct mrb *qla4xxx_get_new_mrb(struct scsi_qla_host *ha)
+{
+        struct mrb *mrb;
+
+        mrb = kzalloc(sizeof(*mrb), GFP_KERNEL);
+        if (!mrb)
+                return mrb;
+
+        mrb->ha = ha;
+        return mrb;
+}
+
+static int qla4xxx_send_mbox_iocb(struct scsi_qla_host *ha, struct mrb *mrb,
+                                  uint32_t *in_mbox)
+{
+        int rval = QLA_SUCCESS;
+        uint32_t i;
+        unsigned long flags;
+        uint32_t index = 0;
+
+        /* Acquire hardware specific lock */
+        spin_lock_irqsave(&ha->hardware_lock, flags);
+
+        /* Get pointer to the queue entry for the marker */
+        rval = qla4xxx_get_req_pkt(ha, (struct queue_entry **) &(mrb->mbox));
+        if (rval != QLA_SUCCESS)
+                goto exit_mbox_iocb;
+
+        index = ha->mrb_index;
+        /* get valid mrb index*/
+        for (i = 0; i < MAX_MRB; i++) {
+                index++;
+                if (index == MAX_MRB)
+                        index = 1;
+                if (ha->active_mrb_array[index] == NULL) {
+                        ha->mrb_index = index;
+                        break;
+                }
+        }
+
+        mrb->iocb_cnt = 1;
+        ha->active_mrb_array[index] = mrb;
+        mrb->mbox->handle = index;
+        mrb->mbox->hdr.entryType = ET_MBOX_CMD;
+        mrb->mbox->hdr.entryCount = mrb->iocb_cnt;
+        memcpy(mrb->mbox->in_mbox, in_mbox, 32);
+        mrb->mbox_cmd = in_mbox[0];
+        wmb();
+
+        ha->isp_ops->queue_iocb(ha);
+exit_mbox_iocb:
+        spin_unlock_irqrestore(&ha->hardware_lock, flags);
+        return rval;
+}
+
+int qla4xxx_ping_iocb(struct scsi_qla_host *ha, uint32_t options,
+                      uint32_t payload_size, uint32_t pid, uint8_t *ipaddr)
+{
+        uint32_t in_mbox[8];
+        struct mrb *mrb = NULL;
+        int rval = QLA_SUCCESS;
+
+        memset(in_mbox, 0, sizeof(in_mbox));
+
+        mrb = qla4xxx_get_new_mrb(ha);
+        if (!mrb) {
+                DEBUG2(ql4_printk(KERN_WARNING, ha, "%s: fail to get new mrb\n",
+                                  __func__));
+                rval = QLA_ERROR;
+                goto exit_ping;
+        }
+
+        in_mbox[0] = MBOX_CMD_PING;
+        in_mbox[1] = options;
+        memcpy(&in_mbox[2], &ipaddr[0], 4);
+        memcpy(&in_mbox[3], &ipaddr[4], 4);
+        memcpy(&in_mbox[4], &ipaddr[8], 4);
+        memcpy(&in_mbox[5], &ipaddr[12], 4);
+        in_mbox[6] = payload_size;
+
+        mrb->pid = pid;
+        rval = qla4xxx_send_mbox_iocb(ha, mrb, in_mbox);
+
+        if (rval != QLA_SUCCESS)
+                goto exit_ping;
+
+        return rval;
+exit_ping:
+        kfree(mrb);
+        return rval;
+}
diff --git a/drivers/scsi/qla4xxx/ql4_isr.c b/drivers/scsi/qla4xxx/ql4_isr.c
index 95828862eea0..7c9f28b7da72 100644
--- a/drivers/scsi/qla4xxx/ql4_isr.c
+++ b/drivers/scsi/qla4xxx/ql4_isr.c
@@ -385,6 +385,71 @@ static void qla4xxx_passthru_status_entry(struct scsi_qla_host *ha,
         queue_work(ha->task_wq, &task_data->task_work);
 }
 
+static struct mrb *qla4xxx_del_mrb_from_active_array(struct scsi_qla_host *ha,
+                                                     uint32_t index)
+{
+        struct mrb *mrb = NULL;
+
+        /* validate handle and remove from active array */
+        if (index >= MAX_MRB)
+                return mrb;
+
+        mrb = ha->active_mrb_array[index];
+        ha->active_mrb_array[index] = NULL;
+        if (!mrb)
+                return mrb;
+
+        /* update counters */
+        ha->req_q_count += mrb->iocb_cnt;
+        ha->iocb_cnt -= mrb->iocb_cnt;
+
+        return mrb;
+}
+
+static void qla4xxx_mbox_status_entry(struct scsi_qla_host *ha,
+                                      struct mbox_status_iocb *mbox_sts_entry)
+{
+        struct mrb *mrb;
+        uint32_t status;
+        uint32_t data_size;
+
+        mrb = qla4xxx_del_mrb_from_active_array(ha,
+                                        le32_to_cpu(mbox_sts_entry->handle));
+
+        if (mrb == NULL) {
+                ql4_printk(KERN_WARNING, ha, "%s: mrb[%d] is null\n", __func__,
+                           mbox_sts_entry->handle);
+                return;
+        }
+
+        switch (mrb->mbox_cmd) {
+        case MBOX_CMD_PING:
+                DEBUG2(ql4_printk(KERN_INFO, ha, "%s: mbox_cmd = 0x%x, "
+                                  "mbox_sts[0] = 0x%x, mbox_sts[6] = 0x%x\n",
+                                  __func__, mrb->mbox_cmd,
+                                  mbox_sts_entry->out_mbox[0],
+                                  mbox_sts_entry->out_mbox[6]));
+
+                if (mbox_sts_entry->out_mbox[0] == MBOX_STS_COMMAND_COMPLETE)
+                        status = QLA_SUCCESS;
+                else
+                        status = QLA_ERROR;
+
+                data_size = sizeof(mbox_sts_entry->out_mbox);
+
+                qla4xxx_post_ping_evt_work(ha, status, mrb->pid, data_size,
+                                        (uint8_t *) mbox_sts_entry->out_mbox);
+                break;
+
+        default:
+                DEBUG2(ql4_printk(KERN_WARNING, ha, "%s: invalid mbox_cmd = "
+                                  "0x%x\n", __func__, mrb->mbox_cmd));
+        }
+
+        kfree(mrb);
+        return;
+}
+
 /**
  * qla4xxx_process_response_queue - process response queue completions
  * @ha: Pointer to host adapter structure.
@@ -461,6 +526,13 @@ void qla4xxx_process_response_queue(struct scsi_qla_host *ha)
                                       "ignoring\n", ha->host_no, __func__));
                         break;
 
+                case ET_MBOX_STATUS:
+                        DEBUG2(ql4_printk(KERN_INFO, ha,
+                                          "%s: mbox status IOCB\n", __func__));
+                        qla4xxx_mbox_status_entry(ha,
+                                        (struct mbox_status_iocb *)sts_entry);
+                        break;
+
                 default:
                         /*
                          * Invalid entry in response queue, reset RISC
@@ -576,6 +648,9 @@ static void qla4xxx_isr_decode_mailbox(struct scsi_qla_host * ha,
                                 set_bit(DPC_LINK_CHANGED, &ha->dpc_flags);
 
                         ql4_printk(KERN_INFO, ha, "%s: LINK UP\n", __func__);
+                        qla4xxx_post_aen_work(ha, ISCSI_EVENT_LINKUP,
+                                              sizeof(mbox_sts),
+                                              (uint8_t *) mbox_sts);
                         break;
 
                 case MBOX_ASTS_LINK_DOWN:
@@ -584,6 +659,9 @@ static void qla4xxx_isr_decode_mailbox(struct scsi_qla_host * ha,
                                 set_bit(DPC_LINK_CHANGED, &ha->dpc_flags);
 
                         ql4_printk(KERN_INFO, ha, "%s: LINK DOWN\n", __func__);
+                        qla4xxx_post_aen_work(ha, ISCSI_EVENT_LINKDOWN,
+                                              sizeof(mbox_sts),
+                                              (uint8_t *) mbox_sts);
                         break;
 
                 case MBOX_ASTS_HEARTBEAT:
diff --git a/drivers/scsi/qla4xxx/ql4_mbx.c b/drivers/scsi/qla4xxx/ql4_mbx.c
index e1e66a45e4d0..7ac21dabbf22 100644
--- a/drivers/scsi/qla4xxx/ql4_mbx.c
+++ b/drivers/scsi/qla4xxx/ql4_mbx.c
@@ -622,7 +622,7 @@ int qla4xxx_get_firmware_status(struct scsi_qla_host * ha)
                 return QLA_ERROR;
         }
 
-        ql4_printk(KERN_INFO, ha, "%ld firmare IOCBs available (%d).\n",
+        ql4_printk(KERN_INFO, ha, "%ld firmware IOCBs available (%d).\n",
             ha->host_no, mbox_sts[2]);
 
         return QLA_SUCCESS;
@@ -661,6 +661,8 @@ int qla4xxx_get_fwddb_entry(struct scsi_qla_host *ha,
         }
         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
         memset(&mbox_sts, 0, sizeof(mbox_sts));
+        if (fw_ddb_entry)
+                memset(fw_ddb_entry, 0, sizeof(struct dev_db_entry));
 
         mbox_cmd[0] = MBOX_CMD_GET_DATABASE_ENTRY;
         mbox_cmd[1] = (uint32_t) fw_ddb_index;
@@ -1424,8 +1426,8 @@ exit_set_chap:
  * match is found. If a match is not found then add the entry in FLASH and
  * return the index at which entry is written in the FLASH.
  **/
-static int qla4xxx_get_chap_index(struct scsi_qla_host *ha, char *username,
-                            char *password, int bidi, uint16_t *chap_index)
+int qla4xxx_get_chap_index(struct scsi_qla_host *ha, char *username,
+                           char *password, int bidi, uint16_t *chap_index)
 {
         int i, rval;
         int free_index = -1;
@@ -1444,6 +1446,11 @@ static int qla4xxx_get_chap_index(struct scsi_qla_host *ha, char *username,
                 return QLA_ERROR;
         }
 
+        if (!username || !password) {
+                ql4_printk(KERN_ERR, ha, "Do not have username and psw\n");
+                return QLA_ERROR;
+        }
+
         mutex_lock(&ha->chap_sem);
         for (i = 0; i < max_chap_entries; i++) {
                 chap_table = (struct ql4_chap_table *)ha->chap_list + i;
@@ -1600,7 +1607,7 @@ int qla4xxx_set_param_ddbentry(struct scsi_qla_host *ha,
         char *ip;
         uint16_t iscsi_opts = 0;
         uint32_t options = 0;
-        uint16_t idx;
+        uint16_t idx, *ptid;
 
         fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
                                           &fw_ddb_entry_dma, GFP_KERNEL);
@@ -1626,6 +1633,14 @@ int qla4xxx_set_param_ddbentry(struct scsi_qla_host *ha,
                 goto exit_set_param;
         }
 
+        ptid = (uint16_t *)&fw_ddb_entry->isid[1];
+        *ptid = cpu_to_le16((uint16_t)ddb_entry->sess->target_id);
+
+        DEBUG2(ql4_printk(KERN_INFO, ha, "ISID [%02x%02x%02x%02x%02x%02x]\n",
+                          fw_ddb_entry->isid[5], fw_ddb_entry->isid[4],
+                          fw_ddb_entry->isid[3], fw_ddb_entry->isid[2],
+                          fw_ddb_entry->isid[1], fw_ddb_entry->isid[0]));
+
         iscsi_opts = le16_to_cpu(fw_ddb_entry->iscsi_options);
         memset(fw_ddb_entry->iscsi_alias, 0, sizeof(fw_ddb_entry->iscsi_alias));
 
diff --git a/drivers/scsi/qla4xxx/ql4_nx.c b/drivers/scsi/qla4xxx/ql4_nx.c
index 65253dfbe962..e1e46b6dac75 100644
--- a/drivers/scsi/qla4xxx/ql4_nx.c
+++ b/drivers/scsi/qla4xxx/ql4_nx.c
@@ -841,11 +841,8 @@ qla4_8xxx_rom_lock(struct scsi_qla_host *ha)
                 done = qla4_8xxx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM2_LOCK));
                 if (done == 1)
                         break;
-                if (timeout >= qla4_8xxx_rom_lock_timeout) {
-                        ql4_printk(KERN_WARNING, ha,
-                            "%s: Failed to acquire rom lock", __func__);
+                if (timeout >= qla4_8xxx_rom_lock_timeout)
                         return -1;
-                }
 
                 timeout++;
 
@@ -996,18 +993,6 @@ qla4_8xxx_pinit_from_rom(struct scsi_qla_host *ha, int verbose)
         else
                 qla4_8xxx_wr_32(ha, QLA82XX_ROMUSB_GLB_SW_RESET, 0xffffffff);
 
-        /* reset ms */
-        val = qla4_8xxx_rd_32(ha, QLA82XX_CRB_QDR_NET + 0xe4);
-        val |= (1 << 1);
-        qla4_8xxx_wr_32(ha, QLA82XX_CRB_QDR_NET + 0xe4, val);
-
-        msleep(20);
-        /* unreset ms */
-        val = qla4_8xxx_rd_32(ha, QLA82XX_CRB_QDR_NET + 0xe4);
-        val &= ~(1 << 1);
-        qla4_8xxx_wr_32(ha, QLA82XX_CRB_QDR_NET + 0xe4, val);
-        msleep(20);
-
         qla4_8xxx_rom_unlock(ha);
 
         /* Read the signature value from the flash.
diff --git a/drivers/scsi/qla4xxx/ql4_nx.h b/drivers/scsi/qla4xxx/ql4_nx.h
index dc45ac923691..dc7500e47b8b 100644
--- a/drivers/scsi/qla4xxx/ql4_nx.h
+++ b/drivers/scsi/qla4xxx/ql4_nx.h
@@ -623,6 +623,7 @@ struct crb_addr_pair {
 
 #define ADDR_ERROR      ((unsigned long) 0xffffffff)
 #define MAX_CTL_CHECK   1000
+#define QLA82XX_FWERROR_CODE(code)      ((code >> 8) & 0x1fffff)
 
 /***************************************************************************
  *              PCI related defines.
diff --git a/drivers/scsi/qla4xxx/ql4_os.c b/drivers/scsi/qla4xxx/ql4_os.c
index edf503437e96..3d9419460e0c 100644
--- a/drivers/scsi/qla4xxx/ql4_os.c
+++ b/drivers/scsi/qla4xxx/ql4_os.c
@@ -32,14 +32,14 @@ static struct kmem_cache *srb_cachep;
 /*
  * Module parameter information and variables
  */
-int ql4xdisablesysfsboot = 1;
+static int ql4xdisablesysfsboot = 1;
 module_param(ql4xdisablesysfsboot, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(ql4xdisablesysfsboot,
                  " Set to disable exporting boot targets to sysfs.\n"
                  "\t\t  0 - Export boot targets\n"
                  "\t\t  1 - Do not export boot targets (Default)");
 
-int ql4xdontresethba = 0;
+int ql4xdontresethba;
 module_param(ql4xdontresethba, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(ql4xdontresethba,
                  " Don't reset the HBA for driver recovery.\n"
@@ -71,7 +71,7 @@ MODULE_PARM_DESC(ql4xmaxqdepth,
 static int ql4xsess_recovery_tmo = QL4_SESS_RECOVERY_TMO;
 module_param(ql4xsess_recovery_tmo, int, S_IRUGO);
 MODULE_PARM_DESC(ql4xsess_recovery_tmo,
-                "Target Session Recovery Timeout.\n"
+                " Target Session Recovery Timeout.\n"
                 "\t\t  Default: 120 sec.");
 
 static int qla4xxx_wait_for_hba_online(struct scsi_qla_host *ha);
@@ -83,6 +83,8 @@ static void qla4xxx_config_dma_addressing(struct scsi_qla_host *ha);
 /*
  * iSCSI template entry points
  */
+static int qla4xxx_session_get_param(struct iscsi_cls_session *cls_sess,
+                                     enum iscsi_param param, char *buf);
 static int qla4xxx_conn_get_param(struct iscsi_cls_conn *conn,
                                   enum iscsi_param param, char *buf);
 static int qla4xxx_host_get_param(struct Scsi_Host *shost,
@@ -118,6 +120,13 @@ static void qla4xxx_task_cleanup(struct iscsi_task *);
 static void qla4xxx_fail_session(struct iscsi_cls_session *cls_session);
 static void qla4xxx_conn_get_stats(struct iscsi_cls_conn *cls_conn,
                                    struct iscsi_stats *stats);
+static int qla4xxx_send_ping(struct Scsi_Host *shost, uint32_t iface_num,
+                             uint32_t iface_type, uint32_t payload_size,
+                             uint32_t pid, struct sockaddr *dst_addr);
+static int qla4xxx_get_chap_list(struct Scsi_Host *shost, uint16_t chap_tbl_idx,
+                                 uint32_t *num_entries, char *buf);
+static int qla4xxx_delete_chap(struct Scsi_Host *shost, uint16_t chap_tbl_idx);
+
 /*
  * SCSI host template entry points
  */
@@ -179,7 +188,7 @@ static struct iscsi_transport qla4xxx_iscsi_transport = {
         .destroy_conn           = qla4xxx_conn_destroy,
         .set_param              = iscsi_set_param,
         .get_conn_param         = qla4xxx_conn_get_param,
-        .get_session_param      = iscsi_session_get_param,
+        .get_session_param      = qla4xxx_session_get_param,
         .get_ep_param           = qla4xxx_get_ep_param,
         .ep_connect             = qla4xxx_ep_connect,
         .ep_poll                = qla4xxx_ep_poll,
@@ -194,10 +203,93 @@ static struct iscsi_transport qla4xxx_iscsi_transport = {
         .set_iface_param        = qla4xxx_iface_set_param,
         .get_iface_param        = qla4xxx_get_iface_param,
         .bsg_request            = qla4xxx_bsg_request,
+        .send_ping              = qla4xxx_send_ping,
+        .get_chap               = qla4xxx_get_chap_list,
+        .delete_chap            = qla4xxx_delete_chap,
 };
 
 static struct scsi_transport_template *qla4xxx_scsi_transport;
 
+static int qla4xxx_send_ping(struct Scsi_Host *shost, uint32_t iface_num,
+                             uint32_t iface_type, uint32_t payload_size,
+                             uint32_t pid, struct sockaddr *dst_addr)
+{
+        struct scsi_qla_host *ha = to_qla_host(shost);
+        struct sockaddr_in *addr;
+        struct sockaddr_in6 *addr6;
+        uint32_t options = 0;
+        uint8_t ipaddr[IPv6_ADDR_LEN];
+        int rval;
+
+        memset(ipaddr, 0, IPv6_ADDR_LEN);
+        /* IPv4 to IPv4 */
+        if ((iface_type == ISCSI_IFACE_TYPE_IPV4) &&
+            (dst_addr->sa_family == AF_INET)) {
+                addr = (struct sockaddr_in *)dst_addr;
+                memcpy(ipaddr, &addr->sin_addr.s_addr, IP_ADDR_LEN);
+                DEBUG2(ql4_printk(KERN_INFO, ha, "%s: IPv4 Ping src: %pI4 "
+                                  "dest: %pI4\n", __func__,
+                                  &ha->ip_config.ip_address, ipaddr));
+                rval = qla4xxx_ping_iocb(ha, options, payload_size, pid,
+                                         ipaddr);
+                if (rval)
+                        rval = -EINVAL;
+        } else if ((iface_type == ISCSI_IFACE_TYPE_IPV6) &&
+                   (dst_addr->sa_family == AF_INET6)) {
+                /* IPv6 to IPv6 */
+                addr6 = (struct sockaddr_in6 *)dst_addr;
+                memcpy(ipaddr, &addr6->sin6_addr.in6_u.u6_addr8, IPv6_ADDR_LEN);
+
+                options |= PING_IPV6_PROTOCOL_ENABLE;
+
+                /* Ping using LinkLocal address */
+                if ((iface_num == 0) || (iface_num == 1)) {
+                        DEBUG2(ql4_printk(KERN_INFO, ha, "%s: LinkLocal Ping "
+                                          "src: %pI6 dest: %pI6\n", __func__,
+                                          &ha->ip_config.ipv6_link_local_addr,
+                                          ipaddr));
+                        options |= PING_IPV6_LINKLOCAL_ADDR;
+                        rval = qla4xxx_ping_iocb(ha, options, payload_size,
+                                                 pid, ipaddr);
+                } else {
+                        ql4_printk(KERN_WARNING, ha, "%s: iface num = %d "
+                                   "not supported\n", __func__, iface_num);
+                        rval = -ENOSYS;
+                        goto exit_send_ping;
+                }
+
+                /*
+                 * If ping using LinkLocal address fails, try ping using
+                 * IPv6 address
+                 */
+                if (rval != QLA_SUCCESS) {
+                        options &= ~PING_IPV6_LINKLOCAL_ADDR;
+                        if (iface_num == 0) {
+                                options |= PING_IPV6_ADDR0;
+                                DEBUG2(ql4_printk(KERN_INFO, ha, "%s: IPv6 "
+                                                  "Ping src: %pI6 "
+                                                  "dest: %pI6\n", __func__,
+                                                  &ha->ip_config.ipv6_addr0,
+                                                  ipaddr));
+                        } else if (iface_num == 1) {
+                                options |= PING_IPV6_ADDR1;
+                                DEBUG2(ql4_printk(KERN_INFO, ha, "%s: IPv6 "
+                                                  "Ping src: %pI6 "
+                                                  "dest: %pI6\n", __func__,
+                                                  &ha->ip_config.ipv6_addr1,
+                                                  ipaddr));
+                        }
+                        rval = qla4xxx_ping_iocb(ha, options, payload_size,
+                                                 pid, ipaddr);
+                        if (rval)
+                                rval = -EINVAL;
+                }
+        } else
+                rval = -ENOSYS;
+exit_send_ping:
+        return rval;
+}
+
 static umode_t ql4_attr_is_visible(int param_type, int param)
 {
         switch (param_type) {
@@ -206,6 +298,8 @@ static umode_t ql4_attr_is_visible(int param_type, int param)
                 case ISCSI_HOST_PARAM_HWADDRESS:
                 case ISCSI_HOST_PARAM_IPADDRESS:
                 case ISCSI_HOST_PARAM_INITIATOR_NAME:
+                case ISCSI_HOST_PARAM_PORT_STATE:
+                case ISCSI_HOST_PARAM_PORT_SPEED:
                         return S_IRUGO;
                 default:
                         return 0;
@@ -225,6 +319,12 @@ static umode_t ql4_attr_is_visible(int param_type, int param)
                 case ISCSI_PARAM_MAX_RECV_DLENGTH:
                 case ISCSI_PARAM_MAX_XMIT_DLENGTH:
                 case ISCSI_PARAM_IFACE_NAME:
+                case ISCSI_PARAM_CHAP_OUT_IDX:
+                case ISCSI_PARAM_CHAP_IN_IDX:
+                case ISCSI_PARAM_USERNAME:
+                case ISCSI_PARAM_PASSWORD:
+                case ISCSI_PARAM_USERNAME_IN:
+                case ISCSI_PARAM_PASSWORD_IN:
                         return S_IRUGO;
                 default:
                         return 0;
@@ -255,6 +355,189 @@ static umode_t ql4_attr_is_visible(int param_type, int param)
         return 0;
 }
 
+static int qla4xxx_get_chap_list(struct Scsi_Host *shost, uint16_t chap_tbl_idx,
+                                  uint32_t *num_entries, char *buf)
+{
+        struct scsi_qla_host *ha = to_qla_host(shost);
+        struct ql4_chap_table *chap_table;
+        struct iscsi_chap_rec *chap_rec;
+        int max_chap_entries = 0;
+        int valid_chap_entries = 0;
+        int ret = 0, i;
+
+        if (is_qla8022(ha))
+                max_chap_entries = (ha->hw.flt_chap_size / 2) /
+                                        sizeof(struct ql4_chap_table);
+        else
+                max_chap_entries = MAX_CHAP_ENTRIES_40XX;
+
+        ql4_printk(KERN_INFO, ha, "%s: num_entries = %d, CHAP idx = %d\n",
+                        __func__, *num_entries, chap_tbl_idx);
+
+        if (!buf) {
+                ret = -ENOMEM;
+                goto exit_get_chap_list;
+        }
+
+        chap_rec = (struct iscsi_chap_rec *) buf;
+        mutex_lock(&ha->chap_sem);
+        for (i = chap_tbl_idx; i < max_chap_entries; i++) {
+                chap_table = (struct ql4_chap_table *)ha->chap_list + i;
+                if (chap_table->cookie !=
+                    __constant_cpu_to_le16(CHAP_VALID_COOKIE))
+                        continue;
+
+                chap_rec->chap_tbl_idx = i;
+                strncpy(chap_rec->username, chap_table->name,
+                        ISCSI_CHAP_AUTH_NAME_MAX_LEN);
+                strncpy(chap_rec->password, chap_table->secret,
+                        QL4_CHAP_MAX_SECRET_LEN);
+                chap_rec->password_length = chap_table->secret_len;
+
+                if (chap_table->flags & BIT_7) /* local */
+                        chap_rec->chap_type = CHAP_TYPE_OUT;
+
+                if (chap_table->flags & BIT_6) /* peer */
+                        chap_rec->chap_type = CHAP_TYPE_IN;
+
+                chap_rec++;
+
+                valid_chap_entries++;
+                if (valid_chap_entries == *num_entries)
+                        break;
+                else
+                        continue;
+        }
+        mutex_unlock(&ha->chap_sem);
+
+exit_get_chap_list:
+        ql4_printk(KERN_INFO, ha, "%s: Valid CHAP Entries = %d\n",
+                        __func__,  valid_chap_entries);
+        *num_entries = valid_chap_entries;
+        return ret;
+}
+
+static int __qla4xxx_is_chap_active(struct device *dev, void *data)
+{
+        int ret = 0;
+        uint16_t *chap_tbl_idx = (uint16_t *) data;
+        struct iscsi_cls_session *cls_session;
+        struct iscsi_session *sess;
+        struct ddb_entry *ddb_entry;
+
+        if (!iscsi_is_session_dev(dev))
+                goto exit_is_chap_active;
+
+        cls_session = iscsi_dev_to_session(dev);
+        sess = cls_session->dd_data;
+        ddb_entry = sess->dd_data;
+
+        if (iscsi_session_chkready(cls_session))
+                goto exit_is_chap_active;
+
+        if (ddb_entry->chap_tbl_idx == *chap_tbl_idx)
+                ret = 1;
+
+exit_is_chap_active:
+        return ret;
+}
+
+static int qla4xxx_is_chap_active(struct Scsi_Host *shost,
+                                  uint16_t chap_tbl_idx)
+{
+        int ret = 0;
+
+        ret = device_for_each_child(&shost->shost_gendev, &chap_tbl_idx,
+                                    __qla4xxx_is_chap_active);
+
+        return ret;
+}
+
+static int qla4xxx_delete_chap(struct Scsi_Host *shost, uint16_t chap_tbl_idx)
+{
+        struct scsi_qla_host *ha = to_qla_host(shost);
+        struct ql4_chap_table *chap_table;
+        dma_addr_t chap_dma;
+        int max_chap_entries = 0;
+        uint32_t offset = 0;
+        uint32_t chap_size;
+        int ret = 0;
+
+        chap_table = dma_pool_alloc(ha->chap_dma_pool, GFP_KERNEL, &chap_dma);
+        if (chap_table == NULL)
+                return -ENOMEM;
+
+        memset(chap_table, 0, sizeof(struct ql4_chap_table));
+
+        if (is_qla8022(ha))
+                max_chap_entries = (ha->hw.flt_chap_size / 2) /
+                                   sizeof(struct ql4_chap_table);
+        else
+                max_chap_entries = MAX_CHAP_ENTRIES_40XX;
+
+        if (chap_tbl_idx > max_chap_entries) {
+                ret = -EINVAL;
+                goto exit_delete_chap;
+        }
+
+        /* Check if chap index is in use.
+         * If chap is in use don't delet chap entry */
+        ret = qla4xxx_is_chap_active(shost, chap_tbl_idx);
+        if (ret) {
+                ql4_printk(KERN_INFO, ha, "CHAP entry %d is in use, cannot "
+                           "delete from flash\n", chap_tbl_idx);
+                ret = -EBUSY;
+                goto exit_delete_chap;
+        }
+
+        chap_size = sizeof(struct ql4_chap_table);
+        if (is_qla40XX(ha))
+                offset = FLASH_CHAP_OFFSET | (chap_tbl_idx * chap_size);
+        else {
+                offset = FLASH_RAW_ACCESS_ADDR + (ha->hw.flt_region_chap << 2);
+                /* flt_chap_size is CHAP table size for both ports
+                 * so divide it by 2 to calculate the offset for second port
+                 */
+                if (ha->port_num == 1)
+                        offset += (ha->hw.flt_chap_size / 2);
+                offset += (chap_tbl_idx * chap_size);
+        }
+
+        ret = qla4xxx_get_flash(ha, chap_dma, offset, chap_size);
+        if (ret != QLA_SUCCESS) {
+                ret = -EINVAL;
+                goto exit_delete_chap;
+        }
+
+        DEBUG2(ql4_printk(KERN_INFO, ha, "Chap Cookie: x%x\n",
+                          __le16_to_cpu(chap_table->cookie)));
+
+        if (__le16_to_cpu(chap_table->cookie) != CHAP_VALID_COOKIE) {
+                ql4_printk(KERN_ERR, ha, "No valid chap entry found\n");
+                goto exit_delete_chap;
+        }
+
+        chap_table->cookie = __constant_cpu_to_le16(0xFFFF);
+
+        offset = FLASH_CHAP_OFFSET |
+                        (chap_tbl_idx * sizeof(struct ql4_chap_table));
+        ret = qla4xxx_set_flash(ha, chap_dma, offset, chap_size,
+                                FLASH_OPT_RMW_COMMIT);
+        if (ret == QLA_SUCCESS && ha->chap_list) {
+                mutex_lock(&ha->chap_sem);
+                /* Update ha chap_list cache */
+                memcpy((struct ql4_chap_table *)ha->chap_list + chap_tbl_idx,
+                        chap_table, sizeof(struct ql4_chap_table));
+                mutex_unlock(&ha->chap_sem);
+        }
+        if (ret != QLA_SUCCESS)
+                ret =  -EINVAL;
+
+exit_delete_chap:
+        dma_pool_free(ha->chap_dma_pool, chap_table, chap_dma);
+        return ret;
+}
+
 static int qla4xxx_get_iface_param(struct iscsi_iface *iface,
                                    enum iscsi_param_type param_type,
                                    int param, char *buf)
@@ -548,6 +831,43 @@ static enum blk_eh_timer_return qla4xxx_eh_cmd_timed_out(struct scsi_cmnd *sc)
         return ret;
 }
 
+static void qla4xxx_set_port_speed(struct Scsi_Host *shost)
+{
+        struct scsi_qla_host *ha = to_qla_host(shost);
+        struct iscsi_cls_host *ihost = shost_priv(shost);
+        uint32_t speed = ISCSI_PORT_SPEED_UNKNOWN;
+
+        qla4xxx_get_firmware_state(ha);
+
+        switch (ha->addl_fw_state & 0x0F00) {
+        case FW_ADDSTATE_LINK_SPEED_10MBPS:
+                speed = ISCSI_PORT_SPEED_10MBPS;
+                break;
+        case FW_ADDSTATE_LINK_SPEED_100MBPS:
+                speed = ISCSI_PORT_SPEED_100MBPS;
+                break;
+        case FW_ADDSTATE_LINK_SPEED_1GBPS:
+                speed = ISCSI_PORT_SPEED_1GBPS;
+                break;
+        case FW_ADDSTATE_LINK_SPEED_10GBPS:
+                speed = ISCSI_PORT_SPEED_10GBPS;
+                break;
+        }
+        ihost->port_speed = speed;
+}
+
+static void qla4xxx_set_port_state(struct Scsi_Host *shost)
+{
+        struct scsi_qla_host *ha = to_qla_host(shost);
+        struct iscsi_cls_host *ihost = shost_priv(shost);
+        uint32_t state = ISCSI_PORT_STATE_DOWN;
+
+        if (test_bit(AF_LINK_UP, &ha->flags))
+                state = ISCSI_PORT_STATE_UP;
+
+        ihost->port_state = state;
+}
+
 static int qla4xxx_host_get_param(struct Scsi_Host *shost,
                                   enum iscsi_host_param param, char *buf)
 {
@@ -564,6 +884,14 @@ static int qla4xxx_host_get_param(struct Scsi_Host *shost,
         case ISCSI_HOST_PARAM_INITIATOR_NAME:
                 len = sprintf(buf, "%s\n", ha->name_string);
                 break;
+        case ISCSI_HOST_PARAM_PORT_STATE:
+                qla4xxx_set_port_state(shost);
+                len = sprintf(buf, "%s\n", iscsi_get_port_state_name(shost));
+                break;
+        case ISCSI_HOST_PARAM_PORT_SPEED:
+                qla4xxx_set_port_speed(shost);
+                len = sprintf(buf, "%s\n", iscsi_get_port_speed_name(shost));
+                break;
         default:
                 return -ENOSYS;
         }
@@ -968,6 +1296,41 @@ exit_init_fw_cb:
         return rval;
 }
 
+static int qla4xxx_session_get_param(struct iscsi_cls_session *cls_sess,
+                                     enum iscsi_param param, char *buf)
+{
+        struct iscsi_session *sess = cls_sess->dd_data;
+        struct ddb_entry *ddb_entry = sess->dd_data;
+        struct scsi_qla_host *ha = ddb_entry->ha;
+        int rval, len;
+        uint16_t idx;
+
+        switch (param) {
+        case ISCSI_PARAM_CHAP_IN_IDX:
+                rval = qla4xxx_get_chap_index(ha, sess->username_in,
+                                              sess->password_in, BIDI_CHAP,
+                                              &idx);
+                if (rval)
+                        return -EINVAL;
+
+                len = sprintf(buf, "%hu\n", idx);
+                break;
+        case ISCSI_PARAM_CHAP_OUT_IDX:
+                rval = qla4xxx_get_chap_index(ha, sess->username,
+                                              sess->password, LOCAL_CHAP,
+                                              &idx);
+                if (rval)
+                        return -EINVAL;
+
+                len = sprintf(buf, "%hu\n", idx);
+                break;
+        default:
+                return iscsi_session_get_param(cls_sess, param, buf);
+        }
+
+        return len;
+}
+
 static int qla4xxx_conn_get_param(struct iscsi_cls_conn *cls_conn,
                                   enum iscsi_param param, char *buf)
 {
@@ -1506,13 +1869,17 @@ static void qla4xxx_copy_fwddb_param(struct scsi_qla_host *ha,
 {
         int buflen = 0;
         struct iscsi_session *sess;
+        struct ddb_entry *ddb_entry;
         struct iscsi_conn *conn;
         char ip_addr[DDB_IPADDR_LEN];
         uint16_t options = 0;
 
         sess = cls_sess->dd_data;
+        ddb_entry = sess->dd_data;
         conn = cls_conn->dd_data;
 
+        ddb_entry->chap_tbl_idx = le16_to_cpu(fw_ddb_entry->chap_tbl_idx);
+
         conn->max_recv_dlength = BYTE_UNITS *
                           le16_to_cpu(fw_ddb_entry->iscsi_max_rcv_data_seg_len);
 
@@ -1552,6 +1919,8 @@ static void qla4xxx_copy_fwddb_param(struct scsi_qla_host *ha,
                         (char *)ha->name_string, buflen);
         iscsi_set_param(cls_conn, ISCSI_PARAM_PERSISTENT_ADDRESS,
                         (char *)ip_addr, buflen);
+        iscsi_set_param(cls_conn, ISCSI_PARAM_TARGET_ALIAS,
+                        (char *)fw_ddb_entry->iscsi_alias, buflen);
 }
 
 void qla4xxx_update_session_conn_fwddb_param(struct scsi_qla_host *ha,
@@ -1638,6 +2007,7 @@ void qla4xxx_update_session_conn_param(struct scsi_qla_host *ha,
                                 le16_to_cpu(fw_ddb_entry->iscsi_def_time2wait);
 
         /* Update params */
+        ddb_entry->chap_tbl_idx = le16_to_cpu(fw_ddb_entry->chap_tbl_idx);
         conn->max_recv_dlength = BYTE_UNITS *
                           le16_to_cpu(fw_ddb_entry->iscsi_max_rcv_data_seg_len);
 
@@ -1666,6 +2036,9 @@ void qla4xxx_update_session_conn_param(struct scsi_qla_host *ha,
         memcpy(sess->initiatorname, ha->name_string,
                min(sizeof(ha->name_string), sizeof(sess->initiatorname)));
 
+        iscsi_set_param(cls_conn, ISCSI_PARAM_TARGET_ALIAS,
+                        (char *)fw_ddb_entry->iscsi_alias, 0);
+
 exit_session_conn_param:
         if (fw_ddb_entry)
                 dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
@@ -2113,7 +2486,7 @@ void qla4_8xxx_watchdog(struct scsi_qla_host *ha)
                                 halt_status = qla4_8xxx_rd_32(ha,
                                                 QLA82XX_PEG_HALT_STATUS1);
 
-                                if (LSW(MSB(halt_status)) == 0x67)
+                                if (QLA82XX_FWERROR_CODE(halt_status) == 0x67)
                                         ql4_printk(KERN_ERR, ha, "%s:"
                                                    " Firmware aborted with"
                                                    " error code 0x00006700."
@@ -2230,6 +2603,10 @@ static void qla4xxx_timer(struct scsi_qla_host *ha)
                 }
         }
 
+        /* Process any deferred work. */
+        if (!list_empty(&ha->work_list))
+                start_dpc++;
+
         /* Wakeup the dpc routine for this adapter, if needed. */
         if (start_dpc ||
              test_bit(DPC_RESET_HA, &ha->dpc_flags) ||
@@ -2795,6 +3172,109 @@ void qla4xxx_wake_dpc(struct scsi_qla_host *ha)
                 queue_work(ha->dpc_thread, &ha->dpc_work);
 }
 
+static struct qla4_work_evt *
+qla4xxx_alloc_work(struct scsi_qla_host *ha, uint32_t data_size,
+                   enum qla4_work_type type)
+{
+        struct qla4_work_evt *e;
+        uint32_t size = sizeof(struct qla4_work_evt) + data_size;
+
+        e = kzalloc(size, GFP_ATOMIC);
+        if (!e)
+                return NULL;
+
+        INIT_LIST_HEAD(&e->list);
+        e->type = type;
+        return e;
+}
+
+static void qla4xxx_post_work(struct scsi_qla_host *ha,
+                             struct qla4_work_evt *e)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&ha->work_lock, flags);
+        list_add_tail(&e->list, &ha->work_list);
+        spin_unlock_irqrestore(&ha->work_lock, flags);
+        qla4xxx_wake_dpc(ha);
+}
+
+int qla4xxx_post_aen_work(struct scsi_qla_host *ha,
+                          enum iscsi_host_event_code aen_code,
+                          uint32_t data_size, uint8_t *data)
+{
+        struct qla4_work_evt *e;
+
+        e = qla4xxx_alloc_work(ha, data_size, QLA4_EVENT_AEN);
+        if (!e)
+                return QLA_ERROR;
+
+        e->u.aen.code = aen_code;
+        e->u.aen.data_size = data_size;
+        memcpy(e->u.aen.data, data, data_size);
+
+        qla4xxx_post_work(ha, e);
+
+        return QLA_SUCCESS;
+}
+
+int qla4xxx_post_ping_evt_work(struct scsi_qla_host *ha,
+                               uint32_t status, uint32_t pid,
+                               uint32_t data_size, uint8_t *data)
+{
+        struct qla4_work_evt *e;
+
+        e = qla4xxx_alloc_work(ha, data_size, QLA4_EVENT_PING_STATUS);
+        if (!e)
+                return QLA_ERROR;
+
+        e->u.ping.status = status;
+        e->u.ping.pid = pid;
+        e->u.ping.data_size = data_size;
+        memcpy(e->u.ping.data, data, data_size);
+
+        qla4xxx_post_work(ha, e);
+
+        return QLA_SUCCESS;
+}
+
+static void qla4xxx_do_work(struct scsi_qla_host *ha)
+{
+        struct qla4_work_evt *e, *tmp;
+        unsigned long flags;
+        LIST_HEAD(work);
+
+        spin_lock_irqsave(&ha->work_lock, flags);
+        list_splice_init(&ha->work_list, &work);
+        spin_unlock_irqrestore(&ha->work_lock, flags);
+
+        list_for_each_entry_safe(e, tmp, &work, list) {
+                list_del_init(&e->list);
+
+                switch (e->type) {
+                case QLA4_EVENT_AEN:
+                        iscsi_post_host_event(ha->host_no,
+                                              &qla4xxx_iscsi_transport,
+                                              e->u.aen.code,
+                                              e->u.aen.data_size,
+                                              e->u.aen.data);
+                        break;
+                case QLA4_EVENT_PING_STATUS:
+                        iscsi_ping_comp_event(ha->host_no,
+                                              &qla4xxx_iscsi_transport,
+                                              e->u.ping.status,
+                                              e->u.ping.pid,
+                                              e->u.ping.data_size,
+                                              e->u.ping.data);
+                        break;
+                default:
+                        ql4_printk(KERN_WARNING, ha, "event type: 0x%x not "
+                                   "supported", e->type);
+                }
+                kfree(e);
+        }
+}
+
 /**
  * qla4xxx_do_dpc - dpc routine
  * @data: in our case pointer to adapter structure
@@ -2826,6 +3306,9 @@ static void qla4xxx_do_dpc(struct work_struct *work)
                 return;
         }
 
+        /* post events to application */
+        qla4xxx_do_work(ha);
+
         if (is_qla8022(ha)) {
                 if (test_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags)) {
                         qla4_8xxx_idc_lock(ha);
@@ -3341,9 +3824,8 @@ static int get_fw_boot_info(struct scsi_qla_host *ha, uint16_t ddb_index[])
                 /* Check Boot Mode */
                 val = rd_nvram_byte(ha, addr);
                 if (!(val & 0x07)) {
-                        DEBUG2(ql4_printk(KERN_ERR, ha,
-                                          "%s: Failed Boot options : 0x%x\n",
-                                          __func__, val));
+                        DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Adapter boot "
+                                          "options : 0x%x\n", __func__, val));
                         ret = QLA_ERROR;
                         goto exit_boot_info;
                 }
@@ -3388,9 +3870,8 @@ static int get_fw_boot_info(struct scsi_qla_host *ha, uint16_t ddb_index[])
                 }
                 /* Check Boot Mode */
                 if (!(buf[1] & 0x07)) {
-                        DEBUG2(ql4_printk(KERN_INFO, ha,
-                                          "Failed: Boot options : 0x%x\n",
-                                          buf[1]));
+                        DEBUG2(ql4_printk(KERN_INFO, ha, "Firmware boot options"
+                                          " : 0x%x\n", buf[1]));
                         ret = QLA_ERROR;
                         goto exit_boot_info_free;
                 }
@@ -3411,12 +3892,11 @@ static int get_fw_boot_info(struct scsi_qla_host *ha, uint16_t ddb_index[])
                           " target ID %d\n", __func__, ddb_index[0],
                           ddb_index[1]));
 
-        ha->pri_ddb_idx = ddb_index[0];
-        ha->sec_ddb_idx = ddb_index[1];
-
 exit_boot_info_free:
         dma_free_coherent(&ha->pdev->dev, size, buf, buf_dma);
 exit_boot_info:
+        ha->pri_ddb_idx = ddb_index[0];
+        ha->sec_ddb_idx = ddb_index[1];
         return ret;
 }
 
@@ -3497,8 +3977,8 @@ static int qla4xxx_get_boot_target(struct scsi_qla_host *ha,
 
         if (qla4xxx_bootdb_by_index(ha, fw_ddb_entry,
                                    fw_ddb_entry_dma, ddb_index)) {
-                DEBUG2(ql4_printk(KERN_ERR, ha,
-                                  "%s: Flash DDB read Failed\n", __func__));
+                DEBUG2(ql4_printk(KERN_INFO, ha, "%s: No Flash DDB found at "
+                                  "index [%d]\n", __func__, ddb_index));
                 ret = QLA_ERROR;
                 goto exit_boot_target;
         }
@@ -3576,8 +4056,8 @@ static int qla4xxx_get_boot_info(struct scsi_qla_host *ha)
         ddb_index[1] = 0xffff;
         ret = get_fw_boot_info(ha, ddb_index);
         if (ret != QLA_SUCCESS) {
-                DEBUG2(ql4_printk(KERN_ERR, ha,
-                                  "%s: Failed to set boot info.\n", __func__));
+                DEBUG2(ql4_printk(KERN_INFO, ha,
+                                "%s: No boot target configured.\n", __func__));
                 return ret;
         }
 
@@ -3590,8 +4070,8 @@ static int qla4xxx_get_boot_info(struct scsi_qla_host *ha)
         rval = qla4xxx_get_boot_target(ha, &(ha->boot_tgt.boot_pri_sess),
                                       ddb_index[0]);
         if (rval != QLA_SUCCESS) {
-                DEBUG2(ql4_printk(KERN_ERR, ha, "%s: Failed to get "
-                                  "primary target\n", __func__));
+                DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Primary boot target not "
+                                  "configured\n", __func__));
         } else
                 ret = QLA_SUCCESS;
 
@@ -3602,8 +4082,8 @@ sec_target:
         rval = qla4xxx_get_boot_target(ha, &(ha->boot_tgt.boot_sec_sess),
                                       ddb_index[1]);
         if (rval != QLA_SUCCESS) {
-                DEBUG2(ql4_printk(KERN_ERR, ha, "%s: Failed to get "
-                                  "secondary target\n", __func__));
+                DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Secondary boot target not"
+                                  " configured\n", __func__));
         } else
                 ret = QLA_SUCCESS;
 
@@ -3772,11 +4252,13 @@ static void qla4xxx_convert_param_ddb(struct dev_db_entry *fw_ddb_entry,
                 sprintf(tddb->ip_addr, "%pI4", fw_ddb_entry->ip_addr);
 
         tddb->port = le16_to_cpu(fw_ddb_entry->port);
+        memcpy(&tddb->isid[0], &fw_ddb_entry->isid[0], sizeof(tddb->isid));
 }
 
 static int qla4xxx_compare_tuple_ddb(struct scsi_qla_host *ha,
                                      struct ql4_tuple_ddb *old_tddb,
-                                     struct ql4_tuple_ddb *new_tddb)
+                                     struct ql4_tuple_ddb *new_tddb,
+                                     uint8_t is_isid_compare)
 {
         if (strcmp(old_tddb->iscsi_name, new_tddb->iscsi_name))
                 return QLA_ERROR;
@@ -3787,6 +4269,26 @@ static int qla4xxx_compare_tuple_ddb(struct scsi_qla_host *ha,
         if (old_tddb->port != new_tddb->port)
                 return QLA_ERROR;
 
+        /* For multi sessions, driver generates the ISID, so do not compare
+         * ISID in reset path since it would be a comparision between the
+         * driver generated ISID and firmware generated ISID. This could
+         * lead to adding duplicated DDBs in the list as driver generated
+         * ISID would not match firmware generated ISID.
+         */
+        if (is_isid_compare) {
+                DEBUG2(ql4_printk(KERN_INFO, ha, "%s: old ISID [%02x%02x%02x"
+                        "%02x%02x%02x] New ISID [%02x%02x%02x%02x%02x%02x]\n",
+                        __func__, old_tddb->isid[5], old_tddb->isid[4],
+                        old_tddb->isid[3], old_tddb->isid[2], old_tddb->isid[1],
+                        old_tddb->isid[0], new_tddb->isid[5], new_tddb->isid[4],
+                        new_tddb->isid[3], new_tddb->isid[2], new_tddb->isid[1],
+                        new_tddb->isid[0]));
+
+                if (memcmp(&old_tddb->isid[0], &new_tddb->isid[0],
+                           sizeof(old_tddb->isid)))
+                        return QLA_ERROR;
+        }
+
         DEBUG2(ql4_printk(KERN_INFO, ha,
                           "Match Found, fw[%d,%d,%s,%s], [%d,%d,%s,%s]",
                           old_tddb->port, old_tddb->tpgt, old_tddb->ip_addr,
@@ -3829,7 +4331,7 @@ static int qla4xxx_is_session_exists(struct scsi_qla_host *ha,
                         continue;
 
                 qla4xxx_get_param_ddb(ddb_entry, tmp_tddb);
-                if (!qla4xxx_compare_tuple_ddb(ha, fw_tddb, tmp_tddb)) {
+                if (!qla4xxx_compare_tuple_ddb(ha, fw_tddb, tmp_tddb, false)) {
                         ret = QLA_SUCCESS; /* found */
                         goto exit_check;
                 }
@@ -3872,7 +4374,7 @@ static int qla4xxx_is_flash_ddb_exists(struct scsi_qla_host *ha,
 
         list_for_each_entry_safe(nt_ddb_idx, nt_ddb_idx_tmp, list_nt, list) {
                 qla4xxx_convert_param_ddb(&nt_ddb_idx->fw_ddb, tmp_tddb);
-                if (!qla4xxx_compare_tuple_ddb(ha, fw_tddb, tmp_tddb)) {
+                if (!qla4xxx_compare_tuple_ddb(ha, fw_tddb, tmp_tddb, true)) {
                         ret = QLA_SUCCESS; /* found */
                         goto exit_check;
                 }
@@ -4038,6 +4540,10 @@ static void qla4xxx_build_st_list(struct scsi_qla_host *ha,
                 if (ret == QLA_ERROR)
                         break;
 
+                /* Ignore DDB if invalid state (unassigned) */
+                if (state == DDB_DS_UNASSIGNED)
+                        goto continue_next_st;
+
                 /* Check if ST, add to the list_st */
                 if (strlen((char *) fw_ddb_entry->iscsi_name) != 0)
                         goto continue_next_st;
@@ -4397,6 +4903,9 @@ static int __devinit qla4xxx_probe_adapter(struct pci_dev *pdev,
 
         spin_lock_init(&ha->hardware_lock);
 
+        /* Initialize work list */
+        INIT_LIST_HEAD(&ha->work_list);
+
         /* Allocate dma buffers */
         if (qla4xxx_mem_alloc(ha)) {
                 ql4_printk(KERN_WARNING, ha,
@@ -4524,8 +5033,8 @@ static int __devinit qla4xxx_probe_adapter(struct pci_dev *pdev,
                ha->patch_number, ha->build_number);
 
         if (qla4xxx_setup_boot_info(ha))
-                ql4_printk(KERN_ERR, ha, "%s:ISCSI boot info setup failed\n",
-                           __func__);
+                ql4_printk(KERN_ERR, ha,
+                           "%s: No iSCSI boot target configured\n", __func__);
 
                 /* Perform the build ddb list and login to each */
         qla4xxx_build_ddb_list(ha, INIT_ADAPTER);
diff --git a/drivers/scsi/qla4xxx/ql4_version.h b/drivers/scsi/qla4xxx/ql4_version.h
index 133989b3a9f4..ede9af944141 100644
--- a/drivers/scsi/qla4xxx/ql4_version.h
+++ b/drivers/scsi/qla4xxx/ql4_version.h
@@ -5,4 +5,4 @@
  * See LICENSE.qla4xxx for copyright and licensing details.
  */
 
-#define QLA4XXX_DRIVER_VERSION  "5.02.00-k12"
+#define QLA4XXX_DRIVER_VERSION  "5.02.00-k15"