64 files changed, 412 insertions, 329 deletions

diff --git a/drivers/scsi/3w-sas.c b/drivers/scsi/3w-sas.c
index e8f5f7c63190..cd096104bcec 100644
--- a/drivers/scsi/3w-sas.c
+++ b/drivers/scsi/3w-sas.c
@@ -646,8 +646,9 @@ static int twl_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
         unsigned long *cpu_addr;
         int retval = 1;
 
-        cpu_addr = dma_zalloc_coherent(&tw_dev->tw_pci_dev->dev,
-                        size * TW_Q_LENGTH, &dma_handle, GFP_KERNEL);
+        cpu_addr = dma_alloc_coherent(&tw_dev->tw_pci_dev->dev,
+                                      size * TW_Q_LENGTH, &dma_handle,
+                                      GFP_KERNEL);
         if (!cpu_addr) {
                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed");
                 goto out;
diff --git a/drivers/scsi/53c700.c b/drivers/scsi/53c700.c
index 128d658d472a..16957d7ac414 100644
--- a/drivers/scsi/53c700.c
+++ b/drivers/scsi/53c700.c
@@ -295,7 +295,7 @@ NCR_700_detect(struct scsi_host_template *tpnt,
         if(tpnt->sdev_attrs == NULL)
                 tpnt->sdev_attrs = NCR_700_dev_attrs;
 
-        memory = dma_alloc_attrs(hostdata->dev, TOTAL_MEM_SIZE, &pScript,
+        memory = dma_alloc_attrs(dev, TOTAL_MEM_SIZE, &pScript,
                                  GFP_KERNEL, DMA_ATTR_NON_CONSISTENT);
         if(memory == NULL) {
                 printk(KERN_ERR "53c700: Failed to allocate memory for driver, detaching\n");
diff --git a/drivers/scsi/a100u2w.c b/drivers/scsi/a100u2w.c
index ff53fd0d12f2..66c514310f3c 100644
--- a/drivers/scsi/a100u2w.c
+++ b/drivers/scsi/a100u2w.c
@@ -1123,8 +1123,8 @@ static int inia100_probe_one(struct pci_dev *pdev,
 
         /* Get total memory needed for SCB */
         sz = ORC_MAXQUEUE * sizeof(struct orc_scb);
-        host->scb_virt = dma_zalloc_coherent(&pdev->dev, sz, &host->scb_phys,
-                                             GFP_KERNEL);
+        host->scb_virt = dma_alloc_coherent(&pdev->dev, sz, &host->scb_phys,
+                                            GFP_KERNEL);
         if (!host->scb_virt) {
                 printk("inia100: SCB memory allocation error\n");
                 goto out_host_put;
@@ -1132,8 +1132,8 @@ static int inia100_probe_one(struct pci_dev *pdev,
 
         /* Get total memory needed for ESCB */
         sz = ORC_MAXQUEUE * sizeof(struct orc_extended_scb);
-        host->escb_virt = dma_zalloc_coherent(&pdev->dev, sz, &host->escb_phys,
-                                              GFP_KERNEL);
+        host->escb_virt = dma_alloc_coherent(&pdev->dev, sz, &host->escb_phys,
+                                             GFP_KERNEL);
         if (!host->escb_virt) {
                 printk("inia100: ESCB memory allocation error\n");
                 goto out_free_scb_array;
diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c
index 634ddb90e7aa..7e56a11836c1 100644
--- a/drivers/scsi/aacraid/linit.c
+++ b/drivers/scsi/aacraid/linit.c
@@ -1747,11 +1747,10 @@ static int aac_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
                 shost->max_sectors = (shost->sg_tablesize * 8) + 112;
         }
 
-        error = dma_set_max_seg_size(&pdev->dev,
-                (aac->adapter_info.options & AAC_OPT_NEW_COMM) ?
-                        (shost->max_sectors << 9) : 65536);
-        if (error)
-                goto out_deinit;
+        if (aac->adapter_info.options & AAC_OPT_NEW_COMM)
+                shost->max_segment_size = shost->max_sectors << 9;
+        else
+                shost->max_segment_size = 65536;
 
         /*
          * Firmware printf works only with older firmware.
diff --git a/drivers/scsi/aic94xx/aic94xx_init.c b/drivers/scsi/aic94xx/aic94xx_init.c
index f83f79b07b50..07efcb9b5b94 100644
--- a/drivers/scsi/aic94xx/aic94xx_init.c
+++ b/drivers/scsi/aic94xx/aic94xx_init.c
@@ -280,7 +280,7 @@ static ssize_t asd_show_dev_rev(struct device *dev,
         return snprintf(buf, PAGE_SIZE, "%s\n",
                         asd_dev_rev[asd_ha->revision_id]);
 }
-static DEVICE_ATTR(revision, S_IRUGO, asd_show_dev_rev, NULL);
+static DEVICE_ATTR(aic_revision, S_IRUGO, asd_show_dev_rev, NULL);
 
 static ssize_t asd_show_dev_bios_build(struct device *dev,
                                        struct device_attribute *attr,char *buf)
@@ -477,7 +477,7 @@ static int asd_create_dev_attrs(struct asd_ha_struct *asd_ha)
 {
         int err;
 
-        err = device_create_file(&asd_ha->pcidev->dev, &dev_attr_revision);
+        err = device_create_file(&asd_ha->pcidev->dev, &dev_attr_aic_revision);
         if (err)
                 return err;
 
@@ -499,13 +499,13 @@ err_update_bios:
 err_biosb:
         device_remove_file(&asd_ha->pcidev->dev, &dev_attr_bios_build);
 err_rev:
-        device_remove_file(&asd_ha->pcidev->dev, &dev_attr_revision);
+        device_remove_file(&asd_ha->pcidev->dev, &dev_attr_aic_revision);
         return err;
 }
 
 static void asd_remove_dev_attrs(struct asd_ha_struct *asd_ha)
 {
-        device_remove_file(&asd_ha->pcidev->dev, &dev_attr_revision);
+        device_remove_file(&asd_ha->pcidev->dev, &dev_attr_aic_revision);
         device_remove_file(&asd_ha->pcidev->dev, &dev_attr_bios_build);
         device_remove_file(&asd_ha->pcidev->dev, &dev_attr_pcba_sn);
         device_remove_file(&asd_ha->pcidev->dev, &dev_attr_update_bios);
diff --git a/drivers/scsi/arcmsr/arcmsr_hba.c b/drivers/scsi/arcmsr/arcmsr_hba.c
index 0f6751b0a633..57c6fa388bf6 100644
--- a/drivers/scsi/arcmsr/arcmsr_hba.c
+++ b/drivers/scsi/arcmsr/arcmsr_hba.c
@@ -587,8 +587,10 @@ static bool arcmsr_alloc_io_queue(struct AdapterControlBlock *acb)
         case ACB_ADAPTER_TYPE_B: {
                 struct MessageUnit_B *reg;
                 acb->roundup_ccbsize = roundup(sizeof(struct MessageUnit_B), 32);
-                dma_coherent = dma_zalloc_coherent(&pdev->dev, acb->roundup_ccbsize,
-                        &dma_coherent_handle, GFP_KERNEL);
+                dma_coherent = dma_alloc_coherent(&pdev->dev,
+                                                  acb->roundup_ccbsize,
+                                                  &dma_coherent_handle,
+                                                  GFP_KERNEL);
                 if (!dma_coherent) {
                         pr_notice("arcmsr%d: DMA allocation failed\n", acb->host->host_no);
                         return false;
@@ -617,8 +619,10 @@ static bool arcmsr_alloc_io_queue(struct AdapterControlBlock *acb)
                 struct MessageUnit_D *reg;
 
                 acb->roundup_ccbsize = roundup(sizeof(struct MessageUnit_D), 32);
-                dma_coherent = dma_zalloc_coherent(&pdev->dev, acb->roundup_ccbsize,
-                        &dma_coherent_handle, GFP_KERNEL);
+                dma_coherent = dma_alloc_coherent(&pdev->dev,
+                                                  acb->roundup_ccbsize,
+                                                  &dma_coherent_handle,
+                                                  GFP_KERNEL);
                 if (!dma_coherent) {
                         pr_notice("arcmsr%d: DMA allocation failed\n", acb->host->host_no);
                         return false;
@@ -659,8 +663,10 @@ static bool arcmsr_alloc_io_queue(struct AdapterControlBlock *acb)
                 uint32_t completeQ_size;
                 completeQ_size = sizeof(struct deliver_completeQ) * ARCMSR_MAX_HBE_DONEQUEUE + 128;
                 acb->roundup_ccbsize = roundup(completeQ_size, 32);
-                dma_coherent = dma_zalloc_coherent(&pdev->dev, acb->roundup_ccbsize,
-                        &dma_coherent_handle, GFP_KERNEL);
+                dma_coherent = dma_alloc_coherent(&pdev->dev,
+                                                  acb->roundup_ccbsize,
+                                                  &dma_coherent_handle,
+                                                  GFP_KERNEL);
                 if (!dma_coherent){
                         pr_notice("arcmsr%d: DMA allocation failed\n", acb->host->host_no);
                         return false;
diff --git a/drivers/scsi/be2iscsi/be_main.c b/drivers/scsi/be2iscsi/be_main.c
index 39f3820572b4..74e260027c7d 100644
--- a/drivers/scsi/be2iscsi/be_main.c
+++ b/drivers/scsi/be2iscsi/be_main.c
@@ -3321,8 +3321,8 @@ static int be_queue_alloc(struct beiscsi_hba *phba, struct be_queue_info *q,
         q->len = len;
         q->entry_size = entry_size;
         mem->size = len * entry_size;
-        mem->va = dma_zalloc_coherent(&phba->pcidev->dev, mem->size, &mem->dma,
-                        GFP_KERNEL);
+        mem->va = dma_alloc_coherent(&phba->pcidev->dev, mem->size, &mem->dma,
+                                     GFP_KERNEL);
         if (!mem->va)
                 return -ENOMEM;
         return 0;
diff --git a/drivers/scsi/be2iscsi/be_mgmt.c b/drivers/scsi/be2iscsi/be_mgmt.c
index ca7b7bbc8371..d4febaadfaa3 100644
--- a/drivers/scsi/be2iscsi/be_mgmt.c
+++ b/drivers/scsi/be2iscsi/be_mgmt.c
@@ -293,8 +293,8 @@ static int beiscsi_prep_nemb_cmd(struct beiscsi_hba *phba,
                                  struct be_dma_mem *cmd,
                                  u8 subsystem, u8 opcode, u32 size)
 {
-        cmd->va = dma_zalloc_coherent(&phba->ctrl.pdev->dev, size, &cmd->dma,
-                        GFP_KERNEL);
+        cmd->va = dma_alloc_coherent(&phba->ctrl.pdev->dev, size, &cmd->dma,
+                                     GFP_KERNEL);
         if (!cmd->va) {
                 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
                             "BG_%d : Failed to allocate memory for if info\n");
@@ -1510,10 +1510,9 @@ int beiscsi_mgmt_invalidate_icds(struct beiscsi_hba *phba,
                 return -EINVAL;
 
         nonemb_cmd.size = sizeof(union be_invldt_cmds_params);
-        nonemb_cmd.va = dma_zalloc_coherent(&phba->ctrl.pdev->dev,
-                                              nonemb_cmd.size,
-                                              &nonemb_cmd.dma,
-                                              GFP_KERNEL);
+        nonemb_cmd.va = dma_alloc_coherent(&phba->ctrl.pdev->dev,
+                                           nonemb_cmd.size, &nonemb_cmd.dma,
+                                           GFP_KERNEL);
         if (!nonemb_cmd.va) {
                 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_EH,
                             "BM_%d : invldt_cmds_params alloc failed\n");
diff --git a/drivers/scsi/bfa/bfad_bsg.c b/drivers/scsi/bfa/bfad_bsg.c
index 5d163ca1b366..d8e6d7480f35 100644
--- a/drivers/scsi/bfa/bfad_bsg.c
+++ b/drivers/scsi/bfa/bfad_bsg.c
@@ -3264,9 +3264,9 @@ bfad_fcxp_map_sg(struct bfad_s *bfad, void *payload_kbuf,
         /* Allocate dma coherent memory */
         buf_info = buf_base;
         buf_info->size = payload_len;
-        buf_info->virt = dma_zalloc_coherent(&bfad->pcidev->dev,
-                                             buf_info->size, &buf_info->phys,
-                                             GFP_KERNEL);
+        buf_info->virt = dma_alloc_coherent(&bfad->pcidev->dev,
+                                            buf_info->size, &buf_info->phys,
+                                            GFP_KERNEL);
         if (!buf_info->virt)
                 goto out_free_mem;
 
diff --git a/drivers/scsi/bnx2fc/bnx2fc_hwi.c b/drivers/scsi/bnx2fc/bnx2fc_hwi.c
index e8ae4d671d23..039328d9ef13 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_hwi.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_hwi.c
@@ -1857,10 +1857,10 @@ int bnx2fc_setup_task_ctx(struct bnx2fc_hba *hba)
          * entries. Hence the limit with one page is 8192 task context
          * entries.
          */
-        hba->task_ctx_bd_tbl = dma_zalloc_coherent(&hba->pcidev->dev,
-                                                   PAGE_SIZE,
-                                                   &hba->task_ctx_bd_dma,
-                                                   GFP_KERNEL);
+        hba->task_ctx_bd_tbl = dma_alloc_coherent(&hba->pcidev->dev,
+                                                  PAGE_SIZE,
+                                                  &hba->task_ctx_bd_dma,
+                                                  GFP_KERNEL);
         if (!hba->task_ctx_bd_tbl) {
                 printk(KERN_ERR PFX "unable to allocate task context BDT\n");
                 rc = -1;
@@ -1894,10 +1894,10 @@ int bnx2fc_setup_task_ctx(struct bnx2fc_hba *hba)
         task_ctx_bdt = (struct regpair *)hba->task_ctx_bd_tbl;
         for (i = 0; i < task_ctx_arr_sz; i++) {
 
-                hba->task_ctx[i] = dma_zalloc_coherent(&hba->pcidev->dev,
-                                                       PAGE_SIZE,
-                                                       &hba->task_ctx_dma[i],
-                                                       GFP_KERNEL);
+                hba->task_ctx[i] = dma_alloc_coherent(&hba->pcidev->dev,
+                                                      PAGE_SIZE,
+                                                      &hba->task_ctx_dma[i],
+                                                      GFP_KERNEL);
                 if (!hba->task_ctx[i]) {
                         printk(KERN_ERR PFX "unable to alloc task context\n");
                         rc = -1;
@@ -2031,19 +2031,19 @@ static int bnx2fc_allocate_hash_table(struct bnx2fc_hba *hba)
         }
 
         for (i = 0; i < segment_count; ++i) {
-                hba->hash_tbl_segments[i] = dma_zalloc_coherent(&hba->pcidev->dev,
-                                                                BNX2FC_HASH_TBL_CHUNK_SIZE,
-                                                                &dma_segment_array[i],
-                                                                GFP_KERNEL);
+                hba->hash_tbl_segments[i] = dma_alloc_coherent(&hba->pcidev->dev,
+                                                               BNX2FC_HASH_TBL_CHUNK_SIZE,
+                                                               &dma_segment_array[i],
+                                                               GFP_KERNEL);
                 if (!hba->hash_tbl_segments[i]) {
                         printk(KERN_ERR PFX "hash segment alloc failed\n");
                         goto cleanup_dma;
                 }
         }
 
-        hba->hash_tbl_pbl = dma_zalloc_coherent(&hba->pcidev->dev, PAGE_SIZE,
-                                                &hba->hash_tbl_pbl_dma,
-                                                GFP_KERNEL);
+        hba->hash_tbl_pbl = dma_alloc_coherent(&hba->pcidev->dev, PAGE_SIZE,
+                                               &hba->hash_tbl_pbl_dma,
+                                               GFP_KERNEL);
         if (!hba->hash_tbl_pbl) {
                 printk(KERN_ERR PFX "hash table pbl alloc failed\n");
                 goto cleanup_dma;
@@ -2104,10 +2104,9 @@ int bnx2fc_setup_fw_resc(struct bnx2fc_hba *hba)
                 return -ENOMEM;
 
         mem_size = BNX2FC_NUM_MAX_SESS * sizeof(struct regpair);
-        hba->t2_hash_tbl_ptr = dma_zalloc_coherent(&hba->pcidev->dev,
-                                                   mem_size,
-                                                   &hba->t2_hash_tbl_ptr_dma,
-                                                   GFP_KERNEL);
+        hba->t2_hash_tbl_ptr = dma_alloc_coherent(&hba->pcidev->dev, mem_size,
+                                                  &hba->t2_hash_tbl_ptr_dma,
+                                                  GFP_KERNEL);
         if (!hba->t2_hash_tbl_ptr) {
                 printk(KERN_ERR PFX "unable to allocate t2 hash table ptr\n");
                 bnx2fc_free_fw_resc(hba);
@@ -2116,9 +2115,9 @@ int bnx2fc_setup_fw_resc(struct bnx2fc_hba *hba)
 
         mem_size = BNX2FC_NUM_MAX_SESS *
                                 sizeof(struct fcoe_t2_hash_table_entry);
-        hba->t2_hash_tbl = dma_zalloc_coherent(&hba->pcidev->dev, mem_size,
-                                               &hba->t2_hash_tbl_dma,
-                                               GFP_KERNEL);
+        hba->t2_hash_tbl = dma_alloc_coherent(&hba->pcidev->dev, mem_size,
+                                              &hba->t2_hash_tbl_dma,
+                                              GFP_KERNEL);
         if (!hba->t2_hash_tbl) {
                 printk(KERN_ERR PFX "unable to allocate t2 hash table\n");
                 bnx2fc_free_fw_resc(hba);
@@ -2140,9 +2139,9 @@ int bnx2fc_setup_fw_resc(struct bnx2fc_hba *hba)
                 return -ENOMEM;
         }
 
-        hba->stats_buffer = dma_zalloc_coherent(&hba->pcidev->dev, PAGE_SIZE,
-                                                &hba->stats_buf_dma,
-                                                GFP_KERNEL);
+        hba->stats_buffer = dma_alloc_coherent(&hba->pcidev->dev, PAGE_SIZE,
+                                               &hba->stats_buf_dma,
+                                               GFP_KERNEL);
         if (!hba->stats_buffer) {
                 printk(KERN_ERR PFX "unable to alloc Stats Buffer\n");
                 bnx2fc_free_fw_resc(hba);
diff --git a/drivers/scsi/bnx2fc/bnx2fc_io.c b/drivers/scsi/bnx2fc/bnx2fc_io.c
index 350257c13a5b..bc9f2a2365f4 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_io.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_io.c
@@ -240,6 +240,7 @@ struct bnx2fc_cmd_mgr *bnx2fc_cmd_mgr_alloc(struct bnx2fc_hba *hba)
                 return NULL;
         }
 
+        cmgr->hba = hba;
         cmgr->free_list = kcalloc(arr_sz, sizeof(*cmgr->free_list),
                                   GFP_KERNEL);
         if (!cmgr->free_list) {
@@ -256,7 +257,6 @@ struct bnx2fc_cmd_mgr *bnx2fc_cmd_mgr_alloc(struct bnx2fc_hba *hba)
                 goto mem_err;
         }
 
-        cmgr->hba = hba;
         cmgr->cmds = (struct bnx2fc_cmd **)(cmgr + 1);
 
         for (i = 0; i < arr_sz; i++)  {
@@ -295,7 +295,7 @@ struct bnx2fc_cmd_mgr *bnx2fc_cmd_mgr_alloc(struct bnx2fc_hba *hba)
 
         /* Allocate pool of io_bdts - one for each bnx2fc_cmd */
         mem_size = num_ios * sizeof(struct io_bdt *);
-        cmgr->io_bdt_pool = kmalloc(mem_size, GFP_KERNEL);
+        cmgr->io_bdt_pool = kzalloc(mem_size, GFP_KERNEL);
         if (!cmgr->io_bdt_pool) {
                 printk(KERN_ERR PFX "failed to alloc io_bdt_pool\n");
                 goto mem_err;
diff --git a/drivers/scsi/bnx2fc/bnx2fc_tgt.c b/drivers/scsi/bnx2fc/bnx2fc_tgt.c
index e3d1c7c440c8..d735e87e416a 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_tgt.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_tgt.c
@@ -672,8 +672,8 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         tgt->sq_mem_size = (tgt->sq_mem_size + (CNIC_PAGE_SIZE - 1)) &
                            CNIC_PAGE_MASK;
 
-        tgt->sq = dma_zalloc_coherent(&hba->pcidev->dev, tgt->sq_mem_size,
-                                      &tgt->sq_dma, GFP_KERNEL);
+        tgt->sq = dma_alloc_coherent(&hba->pcidev->dev, tgt->sq_mem_size,
+                                     &tgt->sq_dma, GFP_KERNEL);
         if (!tgt->sq) {
                 printk(KERN_ERR PFX "unable to allocate SQ memory %d\n",
                         tgt->sq_mem_size);
@@ -685,8 +685,8 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         tgt->cq_mem_size = (tgt->cq_mem_size + (CNIC_PAGE_SIZE - 1)) &
                            CNIC_PAGE_MASK;
 
-        tgt->cq = dma_zalloc_coherent(&hba->pcidev->dev, tgt->cq_mem_size,
-                                      &tgt->cq_dma, GFP_KERNEL);
+        tgt->cq = dma_alloc_coherent(&hba->pcidev->dev, tgt->cq_mem_size,
+                                     &tgt->cq_dma, GFP_KERNEL);
         if (!tgt->cq) {
                 printk(KERN_ERR PFX "unable to allocate CQ memory %d\n",
                         tgt->cq_mem_size);
@@ -698,8 +698,8 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         tgt->rq_mem_size = (tgt->rq_mem_size + (CNIC_PAGE_SIZE - 1)) &
                            CNIC_PAGE_MASK;
 
-        tgt->rq = dma_zalloc_coherent(&hba->pcidev->dev, tgt->rq_mem_size,
-                                      &tgt->rq_dma, GFP_KERNEL);
+        tgt->rq = dma_alloc_coherent(&hba->pcidev->dev, tgt->rq_mem_size,
+                                     &tgt->rq_dma, GFP_KERNEL);
         if (!tgt->rq) {
                 printk(KERN_ERR PFX "unable to allocate RQ memory %d\n",
                         tgt->rq_mem_size);
@@ -710,8 +710,8 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         tgt->rq_pbl_size = (tgt->rq_pbl_size + (CNIC_PAGE_SIZE - 1)) &
                            CNIC_PAGE_MASK;
 
-        tgt->rq_pbl = dma_zalloc_coherent(&hba->pcidev->dev, tgt->rq_pbl_size,
-                                          &tgt->rq_pbl_dma, GFP_KERNEL);
+        tgt->rq_pbl = dma_alloc_coherent(&hba->pcidev->dev, tgt->rq_pbl_size,
+                                         &tgt->rq_pbl_dma, GFP_KERNEL);
         if (!tgt->rq_pbl) {
                 printk(KERN_ERR PFX "unable to allocate RQ PBL %d\n",
                         tgt->rq_pbl_size);
@@ -735,9 +735,9 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         tgt->xferq_mem_size = (tgt->xferq_mem_size + (CNIC_PAGE_SIZE - 1)) &
                                CNIC_PAGE_MASK;
 
-        tgt->xferq = dma_zalloc_coherent(&hba->pcidev->dev,
-                                         tgt->xferq_mem_size, &tgt->xferq_dma,
-                                         GFP_KERNEL);
+        tgt->xferq = dma_alloc_coherent(&hba->pcidev->dev,
+                                        tgt->xferq_mem_size, &tgt->xferq_dma,
+                                        GFP_KERNEL);
         if (!tgt->xferq) {
                 printk(KERN_ERR PFX "unable to allocate XFERQ %d\n",
                         tgt->xferq_mem_size);
@@ -749,9 +749,9 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         tgt->confq_mem_size = (tgt->confq_mem_size + (CNIC_PAGE_SIZE - 1)) &
                                CNIC_PAGE_MASK;
 
-        tgt->confq = dma_zalloc_coherent(&hba->pcidev->dev,
-                                         tgt->confq_mem_size, &tgt->confq_dma,
-                                         GFP_KERNEL);
+        tgt->confq = dma_alloc_coherent(&hba->pcidev->dev,
+                                        tgt->confq_mem_size, &tgt->confq_dma,
+                                        GFP_KERNEL);
         if (!tgt->confq) {
                 printk(KERN_ERR PFX "unable to allocate CONFQ %d\n",
                         tgt->confq_mem_size);
@@ -763,9 +763,9 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         tgt->confq_pbl_size =
                 (tgt->confq_pbl_size + (CNIC_PAGE_SIZE - 1)) & CNIC_PAGE_MASK;
 
-        tgt->confq_pbl = dma_zalloc_coherent(&hba->pcidev->dev,
-                                             tgt->confq_pbl_size,
-                                             &tgt->confq_pbl_dma, GFP_KERNEL);
+        tgt->confq_pbl = dma_alloc_coherent(&hba->pcidev->dev,
+                                            tgt->confq_pbl_size,
+                                            &tgt->confq_pbl_dma, GFP_KERNEL);
         if (!tgt->confq_pbl) {
                 printk(KERN_ERR PFX "unable to allocate CONFQ PBL %d\n",
                         tgt->confq_pbl_size);
@@ -787,9 +787,9 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         /* Allocate and map ConnDB */
         tgt->conn_db_mem_size = sizeof(struct fcoe_conn_db);
 
-        tgt->conn_db = dma_zalloc_coherent(&hba->pcidev->dev,
-                                           tgt->conn_db_mem_size,
-                                           &tgt->conn_db_dma, GFP_KERNEL);
+        tgt->conn_db = dma_alloc_coherent(&hba->pcidev->dev,
+                                          tgt->conn_db_mem_size,
+                                          &tgt->conn_db_dma, GFP_KERNEL);
         if (!tgt->conn_db) {
                 printk(KERN_ERR PFX "unable to allocate conn_db %d\n",
                                                 tgt->conn_db_mem_size);
@@ -802,8 +802,8 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         tgt->lcq_mem_size = (tgt->lcq_mem_size + (CNIC_PAGE_SIZE - 1)) &
                              CNIC_PAGE_MASK;
 
-        tgt->lcq = dma_zalloc_coherent(&hba->pcidev->dev, tgt->lcq_mem_size,
-                                       &tgt->lcq_dma, GFP_KERNEL);
+        tgt->lcq = dma_alloc_coherent(&hba->pcidev->dev, tgt->lcq_mem_size,
+                                      &tgt->lcq_dma, GFP_KERNEL);
 
         if (!tgt->lcq) {
                 printk(KERN_ERR PFX "unable to allocate lcq %d\n",
diff --git a/drivers/scsi/bnx2i/bnx2i_hwi.c b/drivers/scsi/bnx2i/bnx2i_hwi.c
index 91f5316aa3ab..fae6f71e677d 100644
--- a/drivers/scsi/bnx2i/bnx2i_hwi.c
+++ b/drivers/scsi/bnx2i/bnx2i_hwi.c
@@ -1070,8 +1070,8 @@ int bnx2i_alloc_qp_resc(struct bnx2i_hba *hba, struct bnx2i_endpoint *ep)
 
         /* Allocate memory area for actual SQ element */
         ep->qp.sq_virt =
-                dma_zalloc_coherent(&hba->pcidev->dev, ep->qp.sq_mem_size,
-                                        &ep->qp.sq_phys, GFP_KERNEL);
+                dma_alloc_coherent(&hba->pcidev->dev, ep->qp.sq_mem_size,
+                                   &ep->qp.sq_phys, GFP_KERNEL);
         if (!ep->qp.sq_virt) {
                 printk(KERN_ALERT "bnx2i: unable to alloc SQ BD memory %d\n",
                                   ep->qp.sq_mem_size);
@@ -1106,8 +1106,8 @@ int bnx2i_alloc_qp_resc(struct bnx2i_hba *hba, struct bnx2i_endpoint *ep)
 
         /* Allocate memory area for actual CQ element */
         ep->qp.cq_virt =
-                dma_zalloc_coherent(&hba->pcidev->dev, ep->qp.cq_mem_size,
-                                        &ep->qp.cq_phys, GFP_KERNEL);
+                dma_alloc_coherent(&hba->pcidev->dev, ep->qp.cq_mem_size,
+                                   &ep->qp.cq_phys, GFP_KERNEL);
         if (!ep->qp.cq_virt) {
                 printk(KERN_ALERT "bnx2i: unable to alloc CQ BD memory %d\n",
                                   ep->qp.cq_mem_size);
diff --git a/drivers/scsi/csiostor/csio_attr.c b/drivers/scsi/csiostor/csio_attr.c
index 8a004036e3d7..9bd2bd8dc2be 100644
--- a/drivers/scsi/csiostor/csio_attr.c
+++ b/drivers/scsi/csiostor/csio_attr.c
@@ -594,12 +594,12 @@ csio_vport_create(struct fc_vport *fc_vport, bool disable)
         }
 
         fc_vport_set_state(fc_vport, FC_VPORT_INITIALIZING);
+        ln->fc_vport = fc_vport;
 
         if (csio_fcoe_alloc_vnp(hw, ln))
                 goto error;
 
         *(struct csio_lnode **)fc_vport->dd_data = ln;
-        ln->fc_vport = fc_vport;
         if (!fc_vport->node_name)
                 fc_vport->node_name = wwn_to_u64(csio_ln_wwnn(ln));
         if (!fc_vport->port_name)
diff --git a/drivers/scsi/csiostor/csio_wr.c b/drivers/scsi/csiostor/csio_wr.c
index dc12933533d5..66bbd21819ae 100644
--- a/drivers/scsi/csiostor/csio_wr.c
+++ b/drivers/scsi/csiostor/csio_wr.c
@@ -233,8 +233,8 @@ csio_wr_alloc_q(struct csio_hw *hw, uint32_t qsize, uint32_t wrsize,
 
         q = wrm->q_arr[free_idx];
 
-        q->vstart = dma_zalloc_coherent(&hw->pdev->dev, qsz, &q->pstart,
-                        GFP_KERNEL);
+        q->vstart = dma_alloc_coherent(&hw->pdev->dev, qsz, &q->pstart,
+                                       GFP_KERNEL);
         if (!q->vstart) {
                 csio_err(hw,
                          "Failed to allocate DMA memory for "
diff --git a/drivers/scsi/cxgbi/cxgb3i/cxgb3i.c b/drivers/scsi/cxgbi/cxgb3i/cxgb3i.c
index 8a20411699d9..75e1273a44b3 100644
--- a/drivers/scsi/cxgbi/cxgb3i/cxgb3i.c
+++ b/drivers/scsi/cxgbi/cxgb3i/cxgb3i.c
@@ -1144,7 +1144,7 @@ static void ddp_clear_map(struct cxgbi_device *cdev, struct cxgbi_ppm *ppm,
 }
 
 static int ddp_setup_conn_pgidx(struct cxgbi_sock *csk,
-                                       unsigned int tid, int pg_idx, bool reply)
+                                unsigned int tid, int pg_idx)
 {
         struct sk_buff *skb = alloc_wr(sizeof(struct cpl_set_tcb_field), 0,
                                         GFP_KERNEL);
@@ -1160,7 +1160,7 @@ static int ddp_setup_conn_pgidx(struct cxgbi_sock *csk,
         req = (struct cpl_set_tcb_field *)skb->head;
         req->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD));
         OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_SET_TCB_FIELD, tid));
-        req->reply = V_NO_REPLY(reply ? 0 : 1);
+        req->reply = V_NO_REPLY(1);
         req->cpu_idx = 0;
         req->word = htons(31);
         req->mask = cpu_to_be64(0xF0000000);
@@ -1177,11 +1177,10 @@ static int ddp_setup_conn_pgidx(struct cxgbi_sock *csk,
  * @tid: connection id
  * @hcrc: header digest enabled
  * @dcrc: data digest enabled
- * @reply: request reply from h/w
  * set up the iscsi digest settings for a connection identified by tid
  */
 static int ddp_setup_conn_digest(struct cxgbi_sock *csk, unsigned int tid,
-                             int hcrc, int dcrc, int reply)
+                                 int hcrc, int dcrc)
 {
         struct sk_buff *skb = alloc_wr(sizeof(struct cpl_set_tcb_field), 0,
                                         GFP_KERNEL);
@@ -1197,7 +1196,7 @@ static int ddp_setup_conn_digest(struct cxgbi_sock *csk, unsigned int tid,
         req = (struct cpl_set_tcb_field *)skb->head;
         req->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD));
         OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_SET_TCB_FIELD, tid));
-        req->reply = V_NO_REPLY(reply ? 0 : 1);
+        req->reply = V_NO_REPLY(1);
         req->cpu_idx = 0;
         req->word = htons(31);
         req->mask = cpu_to_be64(0x0F000000);
diff --git a/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c b/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c
index 49f8028ac524..d26f50af00ea 100644
--- a/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c
+++ b/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c
@@ -1548,16 +1548,22 @@ static void do_set_tcb_rpl(struct cxgbi_device *cdev, struct sk_buff *skb)
         struct cxgbi_sock *csk;
 
         csk = lookup_tid(t, tid);
-        if (!csk)
+        if (!csk) {
                 pr_err("can't find conn. for tid %u.\n", tid);
+                return;
+        }
 
         log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
                 "csk 0x%p,%u,%lx,%u, status 0x%x.\n",
                 csk, csk->state, csk->flags, csk->tid, rpl->status);
 
-        if (rpl->status != CPL_ERR_NONE)
+        if (rpl->status != CPL_ERR_NONE) {
                 pr_err("csk 0x%p,%u, SET_TCB_RPL status %u.\n",
                         csk, tid, rpl->status);
+                csk->err = -EINVAL;
+        }
+
+        complete(&csk->cmpl);
 
         __kfree_skb(skb);
 }
@@ -1983,7 +1989,7 @@ static int ddp_set_map(struct cxgbi_ppm *ppm, struct cxgbi_sock *csk,
 }
 
 static int ddp_setup_conn_pgidx(struct cxgbi_sock *csk, unsigned int tid,
-                                int pg_idx, bool reply)
+                                int pg_idx)
 {
         struct sk_buff *skb;
         struct cpl_set_tcb_field *req;
@@ -1999,7 +2005,7 @@ static int ddp_setup_conn_pgidx(struct cxgbi_sock *csk, unsigned int tid,
         req = (struct cpl_set_tcb_field *)skb->head;
         INIT_TP_WR(req, csk->tid);
         OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_SET_TCB_FIELD, csk->tid));
-        req->reply_ctrl = htons(NO_REPLY_V(reply) | QUEUENO_V(csk->rss_qid));
+        req->reply_ctrl = htons(NO_REPLY_V(0) | QUEUENO_V(csk->rss_qid));
         req->word_cookie = htons(0);
         req->mask = cpu_to_be64(0x3 << 8);
         req->val = cpu_to_be64(pg_idx << 8);
@@ -2008,12 +2014,15 @@ static int ddp_setup_conn_pgidx(struct cxgbi_sock *csk, unsigned int tid,
         log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
                 "csk 0x%p, tid 0x%x, pg_idx %u.\n", csk, csk->tid, pg_idx);
 
+        reinit_completion(&csk->cmpl);
         cxgb4_ofld_send(csk->cdev->ports[csk->port_id], skb);
-        return 0;
+        wait_for_completion(&csk->cmpl);
+
+        return csk->err;
 }
 
 static int ddp_setup_conn_digest(struct cxgbi_sock *csk, unsigned int tid,
-                                 int hcrc, int dcrc, int reply)
+                                 int hcrc, int dcrc)
 {
         struct sk_buff *skb;
         struct cpl_set_tcb_field *req;
@@ -2031,7 +2040,7 @@ static int ddp_setup_conn_digest(struct cxgbi_sock *csk, unsigned int tid,
         req = (struct cpl_set_tcb_field *)skb->head;
         INIT_TP_WR(req, tid);
         OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_SET_TCB_FIELD, tid));
-        req->reply_ctrl = htons(NO_REPLY_V(reply) | QUEUENO_V(csk->rss_qid));
+        req->reply_ctrl = htons(NO_REPLY_V(0) | QUEUENO_V(csk->rss_qid));
         req->word_cookie = htons(0);
         req->mask = cpu_to_be64(0x3 << 4);
         req->val = cpu_to_be64(((hcrc ? ULP_CRC_HEADER : 0) |
@@ -2041,8 +2050,11 @@ static int ddp_setup_conn_digest(struct cxgbi_sock *csk, unsigned int tid,
         log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
                 "csk 0x%p, tid 0x%x, crc %d,%d.\n", csk, csk->tid, hcrc, dcrc);
 
+        reinit_completion(&csk->cmpl);
         cxgb4_ofld_send(csk->cdev->ports[csk->port_id], skb);
-        return 0;
+        wait_for_completion(&csk->cmpl);
+
+        return csk->err;
 }
 
 static struct cxgbi_ppm *cdev2ppm(struct cxgbi_device *cdev)
diff --git a/drivers/scsi/cxgbi/libcxgbi.c b/drivers/scsi/cxgbi/libcxgbi.c
index 75f876409fb9..245742557c03 100644
--- a/drivers/scsi/cxgbi/libcxgbi.c
+++ b/drivers/scsi/cxgbi/libcxgbi.c
@@ -573,6 +573,7 @@ static struct cxgbi_sock *cxgbi_sock_create(struct cxgbi_device *cdev)
         skb_queue_head_init(&csk->receive_queue);
         skb_queue_head_init(&csk->write_queue);
         timer_setup(&csk->retry_timer, NULL, 0);
+        init_completion(&csk->cmpl);
         rwlock_init(&csk->callback_lock);
         csk->cdev = cdev;
         csk->flags = 0;
@@ -2251,14 +2252,14 @@ int cxgbi_set_conn_param(struct iscsi_cls_conn *cls_conn,
                 if (!err && conn->hdrdgst_en)
                         err = csk->cdev->csk_ddp_setup_digest(csk, csk->tid,
                                                         conn->hdrdgst_en,
-                                                        conn->datadgst_en, 0);
+                                                        conn->datadgst_en);
                 break;
         case ISCSI_PARAM_DATADGST_EN:
                 err = iscsi_set_param(cls_conn, param, buf, buflen);
                 if (!err && conn->datadgst_en)
                         err = csk->cdev->csk_ddp_setup_digest(csk, csk->tid,
                                                         conn->hdrdgst_en,
-                                                        conn->datadgst_en, 0);
+                                                        conn->datadgst_en);
                 break;
         case ISCSI_PARAM_MAX_R2T:
                 return iscsi_tcp_set_max_r2t(conn, buf);
@@ -2384,7 +2385,7 @@ int cxgbi_bind_conn(struct iscsi_cls_session *cls_session,
 
         ppm = csk->cdev->cdev2ppm(csk->cdev);
         err = csk->cdev->csk_ddp_setup_pgidx(csk, csk->tid,
-                                             ppm->tformat.pgsz_idx_dflt, 0);
+                                             ppm->tformat.pgsz_idx_dflt);
         if (err < 0)
                 return err;
 
diff --git a/drivers/scsi/cxgbi/libcxgbi.h b/drivers/scsi/cxgbi/libcxgbi.h
index 5d5d8b50d842..1917ff57651d 100644
--- a/drivers/scsi/cxgbi/libcxgbi.h
+++ b/drivers/scsi/cxgbi/libcxgbi.h
@@ -149,6 +149,7 @@ struct cxgbi_sock {
         struct sk_buff_head receive_queue;
         struct sk_buff_head write_queue;
         struct timer_list retry_timer;
+        struct completion cmpl;
         int err;
         rwlock_t callback_lock;
         void *user_data;
@@ -490,9 +491,9 @@ struct cxgbi_device {
                                   struct cxgbi_ppm *,
                                   struct cxgbi_task_tag_info *);
         int (*csk_ddp_setup_digest)(struct cxgbi_sock *,
-                                unsigned int, int, int, int);
+                                    unsigned int, int, int);
         int (*csk_ddp_setup_pgidx)(struct cxgbi_sock *,
-                                unsigned int, int, bool);
+                                   unsigned int, int);
 
         void (*csk_release_offload_resources)(struct cxgbi_sock *);
         int (*csk_rx_pdu_ready)(struct cxgbi_sock *, struct sk_buff *);
diff --git a/drivers/scsi/cxlflash/main.c b/drivers/scsi/cxlflash/main.c
index bfa13e3b191c..c8bad2c093b8 100644
--- a/drivers/scsi/cxlflash/main.c
+++ b/drivers/scsi/cxlflash/main.c
@@ -3687,6 +3687,7 @@ static int cxlflash_probe(struct pci_dev *pdev,
         host->max_cmd_len = CXLFLASH_MAX_CDB_LEN;
 
         cfg = shost_priv(host);
+        cfg->state = STATE_PROBING;
         cfg->host = host;
         rc = alloc_mem(cfg);
         if (rc) {
@@ -3775,6 +3776,7 @@ out:
         return rc;
 
 out_remove:
+        cfg->state = STATE_PROBED;
         cxlflash_remove(pdev);
         goto out;
 }
diff --git a/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c b/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c
index e2420a810e99..c92b3822c408 100644
--- a/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c
+++ b/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c
@@ -2507,6 +2507,12 @@ hisi_sas_v3_probe(struct pci_dev *pdev, const struct pci_device_id *id)
                 sha->sas_port[i] = &hisi_hba->port[i].sas_port;
         }
 
+        if (hisi_hba->prot_mask) {
+                dev_info(dev, "Registering for DIF/DIX prot_mask=0x%x\n",
+                         prot_mask);
+                scsi_host_set_prot(hisi_hba->shost, prot_mask);
+        }
+
         rc = scsi_add_host(shost, dev);
         if (rc)
                 goto err_out_ha;
@@ -2519,12 +2525,6 @@ hisi_sas_v3_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         if (rc)
                 goto err_out_register_ha;
 
-        if (hisi_hba->prot_mask) {
-                dev_info(dev, "Registering for DIF/DIX prot_mask=0x%x\n",
-                         prot_mask);
-                scsi_host_set_prot(hisi_hba->shost, prot_mask);
-        }
-
         scsi_scan_host(shost);
 
         return 0;
diff --git a/drivers/scsi/isci/init.c b/drivers/scsi/isci/init.c
index 68b90c4f79a3..1727d0c71b12 100644
--- a/drivers/scsi/isci/init.c
+++ b/drivers/scsi/isci/init.c
@@ -576,6 +576,13 @@ static struct isci_host *isci_host_alloc(struct pci_dev *pdev, int id)
         shost->max_lun = ~0;
         shost->max_cmd_len = MAX_COMMAND_SIZE;
 
+        /* turn on DIF support */
+        scsi_host_set_prot(shost,
+                           SHOST_DIF_TYPE1_PROTECTION |
+                           SHOST_DIF_TYPE2_PROTECTION |
+                           SHOST_DIF_TYPE3_PROTECTION);
+        scsi_host_set_guard(shost, SHOST_DIX_GUARD_CRC);
+
         err = scsi_add_host(shost, &pdev->dev);
         if (err)
                 goto err_shost;
@@ -663,13 +670,6 @@ static int isci_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
                         goto err_host_alloc;
                 }
                 pci_info->hosts[i] = h;
-
-                /* turn on DIF support */
-                scsi_host_set_prot(to_shost(h),
-                                   SHOST_DIF_TYPE1_PROTECTION |
-                                   SHOST_DIF_TYPE2_PROTECTION |
-                                   SHOST_DIF_TYPE3_PROTECTION);
-                scsi_host_set_guard(to_shost(h), SHOST_DIX_GUARD_CRC);
         }
 
         err = isci_setup_interrupts(pdev);
diff --git a/drivers/scsi/libfc/fc_lport.c b/drivers/scsi/libfc/fc_lport.c
index be83590ed955..ff943f477d6f 100644
--- a/drivers/scsi/libfc/fc_lport.c
+++ b/drivers/scsi/libfc/fc_lport.c
@@ -1726,14 +1726,14 @@ void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
             fc_frame_payload_op(fp) != ELS_LS_ACC) {
                 FC_LPORT_DBG(lport, "FLOGI not accepted or bad response\n");
                 fc_lport_error(lport, fp);
-                goto err;
+                goto out;
         }
 
         flp = fc_frame_payload_get(fp, sizeof(*flp));
         if (!flp) {
                 FC_LPORT_DBG(lport, "FLOGI bad response\n");
                 fc_lport_error(lport, fp);
-                goto err;
+                goto out;
         }
 
         mfs = ntohs(flp->fl_csp.sp_bb_data) &
@@ -1743,7 +1743,7 @@ void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
                 FC_LPORT_DBG(lport, "FLOGI bad mfs:%hu response, "
                              "lport->mfs:%hu\n", mfs, lport->mfs);
                 fc_lport_error(lport, fp);
-                goto err;
+                goto out;
         }
 
         if (mfs <= lport->mfs) {
diff --git a/drivers/scsi/libfc/fc_rport.c b/drivers/scsi/libfc/fc_rport.c
index 9192a1d9dec6..dfba4921b265 100644
--- a/drivers/scsi/libfc/fc_rport.c
+++ b/drivers/scsi/libfc/fc_rport.c
@@ -184,7 +184,6 @@ void fc_rport_destroy(struct kref *kref)
         struct fc_rport_priv *rdata;
 
         rdata = container_of(kref, struct fc_rport_priv, kref);
-        WARN_ON(!list_empty(&rdata->peers));
         kfree_rcu(rdata, rcu);
 }
 EXPORT_SYMBOL(fc_rport_destroy);
diff --git a/drivers/scsi/libiscsi.c b/drivers/scsi/libiscsi.c
index b8d325ce8754..120fc520f27a 100644
--- a/drivers/scsi/libiscsi.c
+++ b/drivers/scsi/libiscsi.c
@@ -1459,7 +1459,13 @@ static int iscsi_xmit_task(struct iscsi_conn *conn)
         if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx))
                 return -ENODATA;
 
+        spin_lock_bh(&conn->session->back_lock);
+        if (conn->task == NULL) {
+                spin_unlock_bh(&conn->session->back_lock);
+                return -ENODATA;
+        }
         __iscsi_get_task(task);
+        spin_unlock_bh(&conn->session->back_lock);
         spin_unlock_bh(&conn->session->frwd_lock);
         rc = conn->session->tt->xmit_task(task);
         spin_lock_bh(&conn->session->frwd_lock);
diff --git a/drivers/scsi/libsas/sas_expander.c b/drivers/scsi/libsas/sas_expander.c
index 17eb4185f29d..f21c93bbb35c 100644
--- a/drivers/scsi/libsas/sas_expander.c
+++ b/drivers/scsi/libsas/sas_expander.c
@@ -828,6 +828,7 @@ static struct domain_device *sas_ex_discover_end_dev(
                 rphy = sas_end_device_alloc(phy->port);
                 if (!rphy)
                         goto out_free;
+                rphy->identify.phy_identifier = phy_id;
 
                 child->rphy = rphy;
                 get_device(&rphy->dev);
@@ -854,6 +855,7 @@ static struct domain_device *sas_ex_discover_end_dev(
 
                 child->rphy = rphy;
                 get_device(&rphy->dev);
+                rphy->identify.phy_identifier = phy_id;
                 sas_fill_in_rphy(child, rphy);
 
                 list_add_tail(&child->disco_list_node, &parent->port->disco_list);
diff --git a/drivers/scsi/lpfc/lpfc_bsg.c b/drivers/scsi/lpfc/lpfc_bsg.c
index 8698af86485d..2dc564e59430 100644
--- a/drivers/scsi/lpfc/lpfc_bsg.c
+++ b/drivers/scsi/lpfc/lpfc_bsg.c
@@ -2730,8 +2730,8 @@ lpfc_bsg_dma_page_alloc(struct lpfc_hba *phba)
         INIT_LIST_HEAD(&dmabuf->list);
 
         /* now, allocate dma buffer */
-        dmabuf->virt = dma_zalloc_coherent(&pcidev->dev, BSG_MBOX_SIZE,
-                                           &(dmabuf->phys), GFP_KERNEL);
+        dmabuf->virt = dma_alloc_coherent(&pcidev->dev, BSG_MBOX_SIZE,
+                                          &(dmabuf->phys), GFP_KERNEL);
 
         if (!dmabuf->virt) {
                 kfree(dmabuf);
diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c
index c1c36812c3d2..bede11e16349 100644
--- a/drivers/scsi/lpfc/lpfc_init.c
+++ b/drivers/scsi/lpfc/lpfc_init.c
@@ -6973,9 +6973,9 @@ lpfc_sli4_create_rpi_hdr(struct lpfc_hba *phba)
         if (!dmabuf)
                 return NULL;
 
-        dmabuf->virt = dma_zalloc_coherent(&phba->pcidev->dev,
-                                           LPFC_HDR_TEMPLATE_SIZE,
-                                           &dmabuf->phys, GFP_KERNEL);
+        dmabuf->virt = dma_alloc_coherent(&phba->pcidev->dev,
+                                          LPFC_HDR_TEMPLATE_SIZE,
+                                          &dmabuf->phys, GFP_KERNEL);
         if (!dmabuf->virt) {
                 rpi_hdr = NULL;
                 goto err_free_dmabuf;
@@ -7397,8 +7397,8 @@ lpfc_sli_pci_mem_setup(struct lpfc_hba *phba)
         }
 
         /* Allocate memory for SLI-2 structures */
-        phba->slim2p.virt = dma_zalloc_coherent(&pdev->dev, SLI2_SLIM_SIZE,
-                                                &phba->slim2p.phys, GFP_KERNEL);
+        phba->slim2p.virt = dma_alloc_coherent(&pdev->dev, SLI2_SLIM_SIZE,
+                                               &phba->slim2p.phys, GFP_KERNEL);
         if (!phba->slim2p.virt)
                 goto out_iounmap;
 
@@ -7816,8 +7816,8 @@ lpfc_create_bootstrap_mbox(struct lpfc_hba *phba)
          * plus an alignment restriction of 16 bytes.
          */
         bmbx_size = sizeof(struct lpfc_bmbx_create) + (LPFC_ALIGN_16_BYTE - 1);
-        dmabuf->virt = dma_zalloc_coherent(&phba->pcidev->dev, bmbx_size,
-                                           &dmabuf->phys, GFP_KERNEL);
+        dmabuf->virt = dma_alloc_coherent(&phba->pcidev->dev, bmbx_size,
+                                          &dmabuf->phys, GFP_KERNEL);
         if (!dmabuf->virt) {
                 kfree(dmabuf);
                 return -ENOMEM;
diff --git a/drivers/scsi/lpfc/lpfc_mbox.c b/drivers/scsi/lpfc/lpfc_mbox.c
index f6a5083a621e..4d3b94317515 100644
--- a/drivers/scsi/lpfc/lpfc_mbox.c
+++ b/drivers/scsi/lpfc/lpfc_mbox.c
@@ -1827,9 +1827,9 @@ lpfc_sli4_config(struct lpfc_hba *phba, struct lpfcMboxq *mbox,
                  * page, this is used as a priori size of SLI4_PAGE_SIZE for
                  * the later DMA memory free.
                  */
-                viraddr = dma_zalloc_coherent(&phba->pcidev->dev,
-                                              SLI4_PAGE_SIZE, &phyaddr,
-                                              GFP_KERNEL);
+                viraddr = dma_alloc_coherent(&phba->pcidev->dev,
+                                             SLI4_PAGE_SIZE, &phyaddr,
+                                             GFP_KERNEL);
                 /* In case of malloc fails, proceed with whatever we have */
                 if (!viraddr)
                         break;
diff --git a/drivers/scsi/lpfc/lpfc_nvme.c b/drivers/scsi/lpfc/lpfc_nvme.c
index 4c66b19e6199..8c9f79042228 100644
--- a/drivers/scsi/lpfc/lpfc_nvme.c
+++ b/drivers/scsi/lpfc/lpfc_nvme.c
@@ -297,7 +297,8 @@ lpfc_nvme_localport_delete(struct nvme_fc_local_port *localport)
                          lport);
 
         /* release any threads waiting for the unreg to complete */
-        complete(&lport->lport_unreg_done);
+        if (lport->vport->localport)
+                complete(lport->lport_unreg_cmp);
 }
 
 /* lpfc_nvme_remoteport_delete
@@ -2545,7 +2546,8 @@ lpfc_nvme_create_localport(struct lpfc_vport *vport)
  */
 void
 lpfc_nvme_lport_unreg_wait(struct lpfc_vport *vport,
-                           struct lpfc_nvme_lport *lport)
+                           struct lpfc_nvme_lport *lport,
+                           struct completion *lport_unreg_cmp)
 {
 #if (IS_ENABLED(CONFIG_NVME_FC))
         u32 wait_tmo;
@@ -2557,8 +2559,7 @@ lpfc_nvme_lport_unreg_wait(struct lpfc_vport *vport,
          */
         wait_tmo = msecs_to_jiffies(LPFC_NVME_WAIT_TMO * 1000);
         while (true) {
-                ret = wait_for_completion_timeout(&lport->lport_unreg_done,
-                                                  wait_tmo);
+                ret = wait_for_completion_timeout(lport_unreg_cmp, wait_tmo);
                 if (unlikely(!ret)) {
                         lpfc_printf_vlog(vport, KERN_ERR, LOG_NVME_IOERR,
                                          "6176 Lport %p Localport %p wait "
@@ -2592,12 +2593,12 @@ lpfc_nvme_destroy_localport(struct lpfc_vport *vport)
         struct lpfc_nvme_lport *lport;
         struct lpfc_nvme_ctrl_stat *cstat;
         int ret;
+        DECLARE_COMPLETION_ONSTACK(lport_unreg_cmp);
 
         if (vport->nvmei_support == 0)
                 return;
 
         localport = vport->localport;
-        vport->localport = NULL;
         lport = (struct lpfc_nvme_lport *)localport->private;
         cstat = lport->cstat;
 
@@ -2608,13 +2609,14 @@ lpfc_nvme_destroy_localport(struct lpfc_vport *vport)
         /* lport's rport list is clear.  Unregister
          * lport and release resources.
          */
-        init_completion(&lport->lport_unreg_done);
+        lport->lport_unreg_cmp = &lport_unreg_cmp;
         ret = nvme_fc_unregister_localport(localport);
 
         /* Wait for completion.  This either blocks
          * indefinitely or succeeds
          */
-        lpfc_nvme_lport_unreg_wait(vport, lport);
+        lpfc_nvme_lport_unreg_wait(vport, lport, &lport_unreg_cmp);
+        vport->localport = NULL;
         kfree(cstat);
 
         /* Regardless of the unregister upcall response, clear
diff --git a/drivers/scsi/lpfc/lpfc_nvme.h b/drivers/scsi/lpfc/lpfc_nvme.h
index cfd4719be25c..b234d0298994 100644
--- a/drivers/scsi/lpfc/lpfc_nvme.h
+++ b/drivers/scsi/lpfc/lpfc_nvme.h
@@ -50,7 +50,7 @@ struct lpfc_nvme_ctrl_stat {
 /* Declare nvme-based local and remote port definitions. */
 struct lpfc_nvme_lport {
         struct lpfc_vport *vport;
-        struct completion lport_unreg_done;
+        struct completion *lport_unreg_cmp;
         /* Add stats counters here */
         struct lpfc_nvme_ctrl_stat *cstat;
         atomic_t fc4NvmeLsRequests;
diff --git a/drivers/scsi/lpfc/lpfc_nvmet.c b/drivers/scsi/lpfc/lpfc_nvmet.c
index 6245f442d784..95fee83090eb 100644
--- a/drivers/scsi/lpfc/lpfc_nvmet.c
+++ b/drivers/scsi/lpfc/lpfc_nvmet.c
@@ -1003,7 +1003,8 @@ lpfc_nvmet_targetport_delete(struct nvmet_fc_target_port *targetport)
         struct lpfc_nvmet_tgtport *tport = targetport->private;
 
         /* release any threads waiting for the unreg to complete */
-        complete(&tport->tport_unreg_done);
+        if (tport->phba->targetport)
+                complete(tport->tport_unreg_cmp);
 }
 
 static void
@@ -1692,6 +1693,7 @@ lpfc_nvmet_destroy_targetport(struct lpfc_hba *phba)
         struct lpfc_nvmet_tgtport *tgtp;
         struct lpfc_queue *wq;
         uint32_t qidx;
+        DECLARE_COMPLETION_ONSTACK(tport_unreg_cmp);
 
         if (phba->nvmet_support == 0)
                 return;
@@ -1701,9 +1703,9 @@ lpfc_nvmet_destroy_targetport(struct lpfc_hba *phba)
                         wq = phba->sli4_hba.nvme_wq[qidx];
                         lpfc_nvmet_wqfull_flush(phba, wq, NULL);
                 }
-                init_completion(&tgtp->tport_unreg_done);
+                tgtp->tport_unreg_cmp = &tport_unreg_cmp;
                 nvmet_fc_unregister_targetport(phba->targetport);
-                wait_for_completion_timeout(&tgtp->tport_unreg_done, 5);
+                wait_for_completion_timeout(&tport_unreg_cmp, 5);
                 lpfc_nvmet_cleanup_io_context(phba);
         }
         phba->targetport = NULL;
diff --git a/drivers/scsi/lpfc/lpfc_nvmet.h b/drivers/scsi/lpfc/lpfc_nvmet.h
index 1aaff63f1f41..0ec1082ce7ef 100644
--- a/drivers/scsi/lpfc/lpfc_nvmet.h
+++ b/drivers/scsi/lpfc/lpfc_nvmet.h
@@ -34,7 +34,7 @@
 /* Used for NVME Target */
 struct lpfc_nvmet_tgtport {
         struct lpfc_hba *phba;
-        struct completion tport_unreg_done;
+        struct completion *tport_unreg_cmp;
 
         /* Stats counters - lpfc_nvmet_unsol_ls_buffer */
         atomic_t rcv_ls_req_in;
diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c
index 30734caf77e1..2242e9b3ca12 100644
--- a/drivers/scsi/lpfc/lpfc_sli.c
+++ b/drivers/scsi/lpfc/lpfc_sli.c
@@ -5362,8 +5362,8 @@ lpfc_sli4_read_rev(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq,
          * mailbox command.
          */
         dma_size = *vpd_size;
-        dmabuf->virt = dma_zalloc_coherent(&phba->pcidev->dev, dma_size,
-                                           &dmabuf->phys, GFP_KERNEL);
+        dmabuf->virt = dma_alloc_coherent(&phba->pcidev->dev, dma_size,
+                                          &dmabuf->phys, GFP_KERNEL);
         if (!dmabuf->virt) {
                 kfree(dmabuf);
                 return -ENOMEM;
@@ -6300,10 +6300,9 @@ lpfc_sli4_ras_dma_alloc(struct lpfc_hba *phba,
                         goto free_mem;
                 }
 
-                dmabuf->virt = dma_zalloc_coherent(&phba->pcidev->dev,
+                dmabuf->virt = dma_alloc_coherent(&phba->pcidev->dev,
                                                   LPFC_RAS_MAX_ENTRY_SIZE,
-                                                  &dmabuf->phys,
-                                                  GFP_KERNEL);
+                                                  &dmabuf->phys, GFP_KERNEL);
                 if (!dmabuf->virt) {
                         kfree(dmabuf);
                         rc = -ENOMEM;
@@ -9408,6 +9407,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 cmnd = CMD_XMIT_SEQUENCE64_CR;
                 if (phba->link_flag & LS_LOOPBACK_MODE)
                         bf_set(wqe_xo, &wqe->xmit_sequence.wge_ctl, 1);
+                /* fall through */
         case CMD_XMIT_SEQUENCE64_CR:
                 /* word3 iocb=io_tag32 wqe=reserved */
                 wqe->xmit_sequence.rsvd3 = 0;
@@ -13529,6 +13529,7 @@ lpfc_sli4_sp_handle_rcqe(struct lpfc_hba *phba, struct lpfc_rcqe *rcqe)
         case FC_STATUS_RQ_BUF_LEN_EXCEEDED:
                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                 "2537 Receive Frame Truncated!!\n");
+                /* fall through */
         case FC_STATUS_RQ_SUCCESS:
                 spin_lock_irqsave(&phba->hbalock, iflags);
                 lpfc_sli4_rq_release(hrq, drq);
@@ -13938,7 +13939,7 @@ lpfc_sli4_nvmet_handle_rcqe(struct lpfc_hba *phba, struct lpfc_queue *cq,
         case FC_STATUS_RQ_BUF_LEN_EXCEEDED:
                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                 "6126 Receive Frame Truncated!!\n");
-                /* Drop thru */
+                /* fall through */
         case FC_STATUS_RQ_SUCCESS:
                 spin_lock_irqsave(&phba->hbalock, iflags);
                 lpfc_sli4_rq_release(hrq, drq);
@@ -14613,9 +14614,9 @@ lpfc_sli4_queue_alloc(struct lpfc_hba *phba, uint32_t page_size,
                 dmabuf = kzalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
                 if (!dmabuf)
                         goto out_fail;
-                dmabuf->virt = dma_zalloc_coherent(&phba->pcidev->dev,
-                                                   hw_page_size, &dmabuf->phys,
-                                                   GFP_KERNEL);
+                dmabuf->virt = dma_alloc_coherent(&phba->pcidev->dev,
+                                                  hw_page_size, &dmabuf->phys,
+                                                  GFP_KERNEL);
                 if (!dmabuf->virt) {
                         kfree(dmabuf);
                         goto out_fail;
@@ -14850,7 +14851,7 @@ lpfc_eq_create(struct lpfc_hba *phba, struct lpfc_queue *eq, uint32_t imax)
                                 eq->entry_count);
                 if (eq->entry_count < 256)
                         return -EINVAL;
-                /* otherwise default to smallest count (drop through) */
+                /* fall through - otherwise default to smallest count */
         case 256:
                 bf_set(lpfc_eq_context_count, &eq_create->u.request.context,
                        LPFC_EQ_CNT_256);
@@ -14981,7 +14982,7 @@ lpfc_cq_create(struct lpfc_hba *phba, struct lpfc_queue *cq,
                                LPFC_CQ_CNT_WORD7);
                         break;
                 }
-                /* Fall Thru */
+                /* fall through */
         default:
                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                 "0361 Unsupported CQ count: "
@@ -14992,7 +14993,7 @@ lpfc_cq_create(struct lpfc_hba *phba, struct lpfc_queue *cq,
                         status = -EINVAL;
                         goto out;
                 }
-                /* otherwise default to smallest count (drop through) */
+                /* fall through - otherwise default to smallest count */
         case 256:
                 bf_set(lpfc_cq_context_count, &cq_create->u.request.context,
                        LPFC_CQ_CNT_256);
@@ -15152,7 +15153,7 @@ lpfc_cq_create_set(struct lpfc_hba *phba, struct lpfc_queue **cqp,
                                                LPFC_CQ_CNT_WORD7);
                                         break;
                                 }
-                                /* Fall Thru */
+                                /* fall through */
                         default:
                                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                                 "3118 Bad CQ count. (%d)\n",
@@ -15161,7 +15162,7 @@ lpfc_cq_create_set(struct lpfc_hba *phba, struct lpfc_queue **cqp,
                                         status = -EINVAL;
                                         goto out;
                                 }
-                                /* otherwise default to smallest (drop thru) */
+                                /* fall through - otherwise default to smallest */
                         case 256:
                                 bf_set(lpfc_mbx_cq_create_set_cqe_cnt,
                                        &cq_set->u.request, LPFC_CQ_CNT_256);
@@ -15433,7 +15434,7 @@ lpfc_mq_create(struct lpfc_hba *phba, struct lpfc_queue *mq,
                         status = -EINVAL;
                         goto out;
                 }
-                /* otherwise default to smallest count (drop through) */
+                /* fall through - otherwise default to smallest count */
         case 16:
                 bf_set(lpfc_mq_context_ring_size,
                        &mq_create_ext->u.request.context,
@@ -15852,7 +15853,7 @@ lpfc_rq_create(struct lpfc_hba *phba, struct lpfc_queue *hrq,
                                 status = -EINVAL;
                                 goto out;
                         }
-                        /* otherwise default to smallest count (drop through) */
+                        /* fall through - otherwise default to smallest count */
                 case 512:
                         bf_set(lpfc_rq_context_rqe_count,
                                &rq_create->u.request.context,
@@ -15989,7 +15990,7 @@ lpfc_rq_create(struct lpfc_hba *phba, struct lpfc_queue *hrq,
                                 status = -EINVAL;
                                 goto out;
                         }
-                        /* otherwise default to smallest count (drop through) */
+                        /* fall through - otherwise default to smallest count */
                 case 512:
                         bf_set(lpfc_rq_context_rqe_count,
                                &rq_create->u.request.context,
diff --git a/drivers/scsi/megaraid/megaraid_mbox.c b/drivers/scsi/megaraid/megaraid_mbox.c
index e836392b75e8..f112458023ff 100644
--- a/drivers/scsi/megaraid/megaraid_mbox.c
+++ b/drivers/scsi/megaraid/megaraid_mbox.c
@@ -967,9 +967,10 @@ megaraid_alloc_cmd_packets(adapter_t *adapter)
          * Allocate the common 16-byte aligned memory for the handshake
          * mailbox.
          */
-        raid_dev->una_mbox64 = dma_zalloc_coherent(&adapter->pdev->dev,
-                        sizeof(mbox64_t), &raid_dev->una_mbox64_dma,
-                        GFP_KERNEL);
+        raid_dev->una_mbox64 = dma_alloc_coherent(&adapter->pdev->dev,
+                                                  sizeof(mbox64_t),
+                                                  &raid_dev->una_mbox64_dma,
+                                                  GFP_KERNEL);
 
         if (!raid_dev->una_mbox64) {
                 con_log(CL_ANN, (KERN_WARNING
@@ -995,8 +996,8 @@ megaraid_alloc_cmd_packets(adapter_t *adapter)
                         align;
 
         // Allocate memory for commands issued internally
-        adapter->ibuf = dma_zalloc_coherent(&pdev->dev, MBOX_IBUF_SIZE,
-                        &adapter->ibuf_dma_h, GFP_KERNEL);
+        adapter->ibuf = dma_alloc_coherent(&pdev->dev, MBOX_IBUF_SIZE,
+                                           &adapter->ibuf_dma_h, GFP_KERNEL);
         if (!adapter->ibuf) {
 
                 con_log(CL_ANN, (KERN_WARNING
@@ -2897,8 +2898,8 @@ megaraid_mbox_product_info(adapter_t *adapter)
          * Issue an ENQUIRY3 command to find out certain adapter parameters,
          * e.g., max channels, max commands etc.
          */
-        pinfo = dma_zalloc_coherent(&adapter->pdev->dev, sizeof(mraid_pinfo_t),
-                        &pinfo_dma_h, GFP_KERNEL);
+        pinfo = dma_alloc_coherent(&adapter->pdev->dev, sizeof(mraid_pinfo_t),
+                                   &pinfo_dma_h, GFP_KERNEL);
         if (pinfo == NULL) {
                 con_log(CL_ANN, (KERN_WARNING
                         "megaraid: out of memory, %s %d\n", __func__,
diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c b/drivers/scsi/megaraid/megaraid_sas_base.c
index f7bdd783360a..fcbff83c0097 100644
--- a/drivers/scsi/megaraid/megaraid_sas_base.c
+++ b/drivers/scsi/megaraid/megaraid_sas_base.c
@@ -2273,9 +2273,9 @@ static int megasas_get_ld_vf_affiliation_111(struct megasas_instance *instance,
                                sizeof(struct MR_LD_VF_AFFILIATION_111));
         else {
                 new_affiliation_111 =
-                        dma_zalloc_coherent(&instance->pdev->dev,
-                                              sizeof(struct MR_LD_VF_AFFILIATION_111),
-                                              &new_affiliation_111_h, GFP_KERNEL);
+                        dma_alloc_coherent(&instance->pdev->dev,
+                                           sizeof(struct MR_LD_VF_AFFILIATION_111),
+                                           &new_affiliation_111_h, GFP_KERNEL);
                 if (!new_affiliation_111) {
                         dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate "
                                "memory for new affiliation for scsi%d\n",
@@ -2380,10 +2380,9 @@ static int megasas_get_ld_vf_affiliation_12(struct megasas_instance *instance,
                        sizeof(struct MR_LD_VF_AFFILIATION));
         else {
                 new_affiliation =
-                        dma_zalloc_coherent(&instance->pdev->dev,
-                                              (MAX_LOGICAL_DRIVES + 1) *
-                                              sizeof(struct MR_LD_VF_AFFILIATION),
-                                              &new_affiliation_h, GFP_KERNEL);
+                        dma_alloc_coherent(&instance->pdev->dev,
+                                           (MAX_LOGICAL_DRIVES + 1) * sizeof(struct MR_LD_VF_AFFILIATION),
+                                           &new_affiliation_h, GFP_KERNEL);
                 if (!new_affiliation) {
                         dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate "
                                "memory for new affiliation for scsi%d\n",
@@ -2546,9 +2545,10 @@ int megasas_sriov_start_heartbeat(struct megasas_instance *instance,
 
         if (initial) {
                 instance->hb_host_mem =
-                        dma_zalloc_coherent(&instance->pdev->dev,
-                                              sizeof(struct MR_CTRL_HB_HOST_MEM),
-                                              &instance->hb_host_mem_h, GFP_KERNEL);
+                        dma_alloc_coherent(&instance->pdev->dev,
+                                           sizeof(struct MR_CTRL_HB_HOST_MEM),
+                                           &instance->hb_host_mem_h,
+                                           GFP_KERNEL);
                 if (!instance->hb_host_mem) {
                         dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate"
                                " memory for heartbeat host memory for scsi%d\n",
@@ -5816,9 +5816,9 @@ megasas_get_seq_num(struct megasas_instance *instance,
         }
 
         dcmd = &cmd->frame->dcmd;
-        el_info = dma_zalloc_coherent(&instance->pdev->dev,
-                        sizeof(struct megasas_evt_log_info), &el_info_h,
-                        GFP_KERNEL);
+        el_info = dma_alloc_coherent(&instance->pdev->dev,
+                                     sizeof(struct megasas_evt_log_info),
+                                     &el_info_h, GFP_KERNEL);
         if (!el_info) {
                 megasas_return_cmd(instance, cmd);
                 return -ENOMEM;
@@ -6236,7 +6236,7 @@ megasas_set_dma_mask(struct megasas_instance *instance)
                 instance->consistent_mask_64bit = true;
 
         dev_info(&pdev->dev, "%s bit DMA mask and %s bit consistent mask\n",
-                 ((*pdev->dev.dma_mask == DMA_BIT_MASK(64)) ? "63" : "32"),
+                 ((*pdev->dev.dma_mask == DMA_BIT_MASK(63)) ? "63" : "32"),
                  (instance->consistent_mask_64bit ? "63" : "32"));
 
         return 0;
diff --git a/drivers/scsi/megaraid/megaraid_sas_fusion.c b/drivers/scsi/megaraid/megaraid_sas_fusion.c
index 211c17c33aa0..647f48a28f85 100644
--- a/drivers/scsi/megaraid/megaraid_sas_fusion.c
+++ b/drivers/scsi/megaraid/megaraid_sas_fusion.c
@@ -175,7 +175,8 @@ megasas_clear_intr_fusion(struct megasas_instance *instance)
         /*
          * Check if it is our interrupt
          */
-        status = readl(&regs->outbound_intr_status);
+        status = megasas_readl(instance,
+                               &regs->outbound_intr_status);
 
         if (status & 1) {
                 writel(status, &regs->outbound_intr_status);
@@ -689,8 +690,9 @@ megasas_alloc_rdpq_fusion(struct megasas_instance *instance)
         array_size = sizeof(struct MPI2_IOC_INIT_RDPQ_ARRAY_ENTRY) *
                      MAX_MSIX_QUEUES_FUSION;
 
-        fusion->rdpq_virt = dma_zalloc_coherent(&instance->pdev->dev,
-                        array_size, &fusion->rdpq_phys, GFP_KERNEL);
+        fusion->rdpq_virt = dma_alloc_coherent(&instance->pdev->dev,
+                                               array_size, &fusion->rdpq_phys,
+                                               GFP_KERNEL);
         if (!fusion->rdpq_virt) {
                 dev_err(&instance->pdev->dev,
                         "Failed from %s %d\n",  __func__, __LINE__);
diff --git a/drivers/scsi/mesh.c b/drivers/scsi/mesh.c
index f3e182eb0970..c9dc7740e9e7 100644
--- a/drivers/scsi/mesh.c
+++ b/drivers/scsi/mesh.c
@@ -1915,8 +1915,9 @@ static int mesh_probe(struct macio_dev *mdev, const struct of_device_id *match)
         /* We use the PCI APIs for now until the generic one gets fixed
          * enough or until we get some macio-specific versions
          */
-        dma_cmd_space = dma_zalloc_coherent(&macio_get_pci_dev(mdev)->dev,
-                        ms->dma_cmd_size, &dma_cmd_bus, GFP_KERNEL);
+        dma_cmd_space = dma_alloc_coherent(&macio_get_pci_dev(mdev)->dev,
+                                           ms->dma_cmd_size, &dma_cmd_bus,
+                                           GFP_KERNEL);
         if (dma_cmd_space == NULL) {
                 printk(KERN_ERR "mesh: can't allocate DMA table\n");
                 goto out_unmap;
diff --git a/drivers/scsi/mvumi.c b/drivers/scsi/mvumi.c
index dbe753fba486..36f64205ecfa 100644
--- a/drivers/scsi/mvumi.c
+++ b/drivers/scsi/mvumi.c
@@ -143,8 +143,9 @@ static struct mvumi_res *mvumi_alloc_mem_resource(struct mvumi_hba *mhba,
 
         case RESOURCE_UNCACHED_MEMORY:
                 size = round_up(size, 8);
-                res->virt_addr = dma_zalloc_coherent(&mhba->pdev->dev, size,
-                                &res->bus_addr, GFP_KERNEL);
+                res->virt_addr = dma_alloc_coherent(&mhba->pdev->dev, size,
+                                                    &res->bus_addr,
+                                                    GFP_KERNEL);
                 if (!res->virt_addr) {
                         dev_err(&mhba->pdev->dev,
                                         "unable to allocate consistent mem,"
@@ -246,8 +247,8 @@ static int mvumi_internal_cmd_sgl(struct mvumi_hba *mhba, struct mvumi_cmd *cmd,
         if (size == 0)
                 return 0;
 
-        virt_addr = dma_zalloc_coherent(&mhba->pdev->dev, size, &phy_addr,
-                        GFP_KERNEL);
+        virt_addr = dma_alloc_coherent(&mhba->pdev->dev, size, &phy_addr,
+                                       GFP_KERNEL);
         if (!virt_addr)
                 return -1;
 
diff --git a/drivers/scsi/pm8001/pm8001_sas.c b/drivers/scsi/pm8001/pm8001_sas.c
index b3be49d41375..084f2fcced0a 100644
--- a/drivers/scsi/pm8001/pm8001_sas.c
+++ b/drivers/scsi/pm8001/pm8001_sas.c
@@ -116,8 +116,8 @@ int pm8001_mem_alloc(struct pci_dev *pdev, void **virt_addr,
         u64 align_offset = 0;
         if (align)
                 align_offset = (dma_addr_t)align - 1;
-        mem_virt_alloc = dma_zalloc_coherent(&pdev->dev, mem_size + align,
-                        &mem_dma_handle, GFP_KERNEL);
+        mem_virt_alloc = dma_alloc_coherent(&pdev->dev, mem_size + align,
+                                            &mem_dma_handle, GFP_KERNEL);
         if (!mem_virt_alloc) {
                 pm8001_printk("memory allocation error\n");
                 return -1;
@@ -657,7 +657,7 @@ static int pm8001_dev_found_notify(struct domain_device *dev)
                 if (dev->dev_type == SAS_SATA_DEV) {
                         pm8001_device->attached_phy =
                                 dev->rphy->identify.phy_identifier;
-                                flag = 1; /* directly sata*/
+                        flag = 1; /* directly sata */
                 }
         } /*register this device to HBA*/
         PM8001_DISC_DBG(pm8001_ha, pm8001_printk("Found device\n"));
diff --git a/drivers/scsi/qedf/qedf_main.c b/drivers/scsi/qedf/qedf_main.c
index edcaf4b0cb0b..9bbc19fc190b 100644
--- a/drivers/scsi/qedf/qedf_main.c
+++ b/drivers/scsi/qedf/qedf_main.c
@@ -1050,16 +1050,17 @@ static int qedf_alloc_sq(struct qedf_ctx *qedf, struct qedf_rport *fcport)
             sizeof(void *);
         fcport->sq_pbl_size = fcport->sq_pbl_size + QEDF_PAGE_SIZE;
 
-        fcport->sq = dma_zalloc_coherent(&qedf->pdev->dev,
-            fcport->sq_mem_size, &fcport->sq_dma, GFP_KERNEL);
+        fcport->sq = dma_alloc_coherent(&qedf->pdev->dev, fcport->sq_mem_size,
+                                        &fcport->sq_dma, GFP_KERNEL);
         if (!fcport->sq) {
                 QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate send queue.\n");
                 rval = 1;
                 goto out;
         }
 
-        fcport->sq_pbl = dma_zalloc_coherent(&qedf->pdev->dev,
-            fcport->sq_pbl_size, &fcport->sq_pbl_dma, GFP_KERNEL);
+        fcport->sq_pbl = dma_alloc_coherent(&qedf->pdev->dev,
+                                            fcport->sq_pbl_size,
+                                            &fcport->sq_pbl_dma, GFP_KERNEL);
         if (!fcport->sq_pbl) {
                 QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate send queue PBL.\n");
                 rval = 1;
@@ -2680,8 +2681,10 @@ static int qedf_alloc_bdq(struct qedf_ctx *qedf)
         }
 
         /* Allocate list of PBL pages */
-        qedf->bdq_pbl_list = dma_zalloc_coherent(&qedf->pdev->dev,
-            QEDF_PAGE_SIZE, &qedf->bdq_pbl_list_dma, GFP_KERNEL);
+        qedf->bdq_pbl_list = dma_alloc_coherent(&qedf->pdev->dev,
+                                                QEDF_PAGE_SIZE,
+                                                &qedf->bdq_pbl_list_dma,
+                                                GFP_KERNEL);
         if (!qedf->bdq_pbl_list) {
                 QEDF_ERR(&(qedf->dbg_ctx), "Could not allocate list of PBL pages.\n");
                 return -ENOMEM;
@@ -2770,9 +2773,10 @@ static int qedf_alloc_global_queues(struct qedf_ctx *qedf)
                     ALIGN(qedf->global_queues[i]->cq_pbl_size, QEDF_PAGE_SIZE);
 
                 qedf->global_queues[i]->cq =
-                    dma_zalloc_coherent(&qedf->pdev->dev,
-                        qedf->global_queues[i]->cq_mem_size,
-                        &qedf->global_queues[i]->cq_dma, GFP_KERNEL);
+                    dma_alloc_coherent(&qedf->pdev->dev,
+                                       qedf->global_queues[i]->cq_mem_size,
+                                       &qedf->global_queues[i]->cq_dma,
+                                       GFP_KERNEL);
 
                 if (!qedf->global_queues[i]->cq) {
                         QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate cq.\n");
@@ -2781,9 +2785,10 @@ static int qedf_alloc_global_queues(struct qedf_ctx *qedf)
                 }
 
                 qedf->global_queues[i]->cq_pbl =
-                    dma_zalloc_coherent(&qedf->pdev->dev,
-                        qedf->global_queues[i]->cq_pbl_size,
-                        &qedf->global_queues[i]->cq_pbl_dma, GFP_KERNEL);
+                    dma_alloc_coherent(&qedf->pdev->dev,
+                                       qedf->global_queues[i]->cq_pbl_size,
+                                       &qedf->global_queues[i]->cq_pbl_dma,
+                                       GFP_KERNEL);
 
                 if (!qedf->global_queues[i]->cq_pbl) {
                         QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate cq PBL.\n");
diff --git a/drivers/scsi/qedi/qedi_iscsi.c b/drivers/scsi/qedi/qedi_iscsi.c
index 4da660c1c431..6d6d6013e35b 100644
--- a/drivers/scsi/qedi/qedi_iscsi.c
+++ b/drivers/scsi/qedi/qedi_iscsi.c
@@ -953,6 +953,7 @@ static int qedi_ep_poll(struct iscsi_endpoint *ep, int timeout_ms)
 
         qedi_ep = ep->dd_data;
         if (qedi_ep->state == EP_STATE_IDLE ||
+            qedi_ep->state == EP_STATE_OFLDCONN_NONE ||
             qedi_ep->state == EP_STATE_OFLDCONN_FAILED)
                 return -1;
 
@@ -1035,6 +1036,7 @@ static void qedi_ep_disconnect(struct iscsi_endpoint *ep)
 
         switch (qedi_ep->state) {
         case EP_STATE_OFLDCONN_START:
+        case EP_STATE_OFLDCONN_NONE:
                 goto ep_release_conn;
         case EP_STATE_OFLDCONN_FAILED:
                         break;
@@ -1225,6 +1227,7 @@ static int qedi_set_path(struct Scsi_Host *shost, struct iscsi_path *path_data)
 
         if (!is_valid_ether_addr(&path_data->mac_addr[0])) {
                 QEDI_NOTICE(&qedi->dbg_ctx, "dst mac NOT VALID\n");
+                qedi_ep->state = EP_STATE_OFLDCONN_NONE;
                 ret = -EIO;
                 goto set_path_exit;
         }
diff --git a/drivers/scsi/qedi/qedi_iscsi.h b/drivers/scsi/qedi/qedi_iscsi.h
index 11260776212f..892d70d54553 100644
--- a/drivers/scsi/qedi/qedi_iscsi.h
+++ b/drivers/scsi/qedi/qedi_iscsi.h
@@ -59,6 +59,7 @@ enum {
         EP_STATE_OFLDCONN_FAILED        = 0x2000,
         EP_STATE_CONNECT_FAILED         = 0x4000,
         EP_STATE_DISCONN_TIMEDOUT       = 0x8000,
+        EP_STATE_OFLDCONN_NONE          = 0x10000,
 };
 
 struct qedi_conn;
diff --git a/drivers/scsi/qedi/qedi_main.c b/drivers/scsi/qedi/qedi_main.c
index 5c53409a8cea..e74a62448ba4 100644
--- a/drivers/scsi/qedi/qedi_main.c
+++ b/drivers/scsi/qedi/qedi_main.c
@@ -1394,10 +1394,9 @@ static int qedi_alloc_nvm_iscsi_cfg(struct qedi_ctx *qedi)
 {
         struct qedi_nvm_iscsi_image nvm_image;
 
-        qedi->iscsi_image = dma_zalloc_coherent(&qedi->pdev->dev,
-                                                sizeof(nvm_image),
-                                                &qedi->nvm_buf_dma,
-                                                GFP_KERNEL);
+        qedi->iscsi_image = dma_alloc_coherent(&qedi->pdev->dev,
+                                               sizeof(nvm_image),
+                                               &qedi->nvm_buf_dma, GFP_KERNEL);
         if (!qedi->iscsi_image) {
                 QEDI_ERR(&qedi->dbg_ctx, "Could not allocate NVM BUF.\n");
                 return -ENOMEM;
@@ -1510,10 +1509,10 @@ static int qedi_alloc_bdq(struct qedi_ctx *qedi)
         }
 
         /* Allocate list of PBL pages */
-        qedi->bdq_pbl_list = dma_zalloc_coherent(&qedi->pdev->dev,
-                                                 QEDI_PAGE_SIZE,
-                                                 &qedi->bdq_pbl_list_dma,
-                                                 GFP_KERNEL);
+        qedi->bdq_pbl_list = dma_alloc_coherent(&qedi->pdev->dev,
+                                                QEDI_PAGE_SIZE,
+                                                &qedi->bdq_pbl_list_dma,
+                                                GFP_KERNEL);
         if (!qedi->bdq_pbl_list) {
                 QEDI_ERR(&qedi->dbg_ctx,
                          "Could not allocate list of PBL pages.\n");
@@ -1609,10 +1608,10 @@ static int qedi_alloc_global_queues(struct qedi_ctx *qedi)
                     (qedi->global_queues[i]->cq_pbl_size +
                     (QEDI_PAGE_SIZE - 1));
 
-                qedi->global_queues[i]->cq = dma_zalloc_coherent(&qedi->pdev->dev,
-                                                                 qedi->global_queues[i]->cq_mem_size,
-                                                                 &qedi->global_queues[i]->cq_dma,
-                                                                 GFP_KERNEL);
+                qedi->global_queues[i]->cq = dma_alloc_coherent(&qedi->pdev->dev,
+                                                                qedi->global_queues[i]->cq_mem_size,
+                                                                &qedi->global_queues[i]->cq_dma,
+                                                                GFP_KERNEL);
 
                 if (!qedi->global_queues[i]->cq) {
                         QEDI_WARN(&qedi->dbg_ctx,
@@ -1620,10 +1619,10 @@ static int qedi_alloc_global_queues(struct qedi_ctx *qedi)
                         status = -ENOMEM;
                         goto mem_alloc_failure;
                 }
-                qedi->global_queues[i]->cq_pbl = dma_zalloc_coherent(&qedi->pdev->dev,
-                                                                     qedi->global_queues[i]->cq_pbl_size,
-                                                                     &qedi->global_queues[i]->cq_pbl_dma,
-                                                                     GFP_KERNEL);
+                qedi->global_queues[i]->cq_pbl = dma_alloc_coherent(&qedi->pdev->dev,
+                                                                    qedi->global_queues[i]->cq_pbl_size,
+                                                                    &qedi->global_queues[i]->cq_pbl_dma,
+                                                                    GFP_KERNEL);
 
                 if (!qedi->global_queues[i]->cq_pbl) {
                         QEDI_WARN(&qedi->dbg_ctx,
@@ -1691,16 +1690,16 @@ int qedi_alloc_sq(struct qedi_ctx *qedi, struct qedi_endpoint *ep)
         ep->sq_pbl_size = (ep->sq_mem_size / QEDI_PAGE_SIZE) * sizeof(void *);
         ep->sq_pbl_size = ep->sq_pbl_size + QEDI_PAGE_SIZE;
 
-        ep->sq = dma_zalloc_coherent(&qedi->pdev->dev, ep->sq_mem_size,
-                                     &ep->sq_dma, GFP_KERNEL);
+        ep->sq = dma_alloc_coherent(&qedi->pdev->dev, ep->sq_mem_size,
+                                    &ep->sq_dma, GFP_KERNEL);
         if (!ep->sq) {
                 QEDI_WARN(&qedi->dbg_ctx,
                           "Could not allocate send queue.\n");
                 rval = -ENOMEM;
                 goto out;
         }
-        ep->sq_pbl = dma_zalloc_coherent(&qedi->pdev->dev, ep->sq_pbl_size,
-                                         &ep->sq_pbl_dma, GFP_KERNEL);
+        ep->sq_pbl = dma_alloc_coherent(&qedi->pdev->dev, ep->sq_pbl_size,
+                                        &ep->sq_pbl_dma, GFP_KERNEL);
         if (!ep->sq_pbl) {
                 QEDI_WARN(&qedi->dbg_ctx,
                           "Could not allocate send queue PBL.\n");
diff --git a/drivers/scsi/qla1280.c b/drivers/scsi/qla1280.c
index a414f51302b7..6856dfdfa473 100644
--- a/drivers/scsi/qla1280.c
+++ b/drivers/scsi/qla1280.c
@@ -4248,7 +4248,7 @@ qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         ha->devnum = devnum;    /* specifies microcode load address */
 
 #ifdef QLA_64BIT_PTR
-        if (dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(64))) {
+        if (dma_set_mask_and_coherent(&ha->pdev->dev, DMA_BIT_MASK(64))) {
                 if (dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32))) {
                         printk(KERN_WARNING "scsi(%li): Unable to set a "
                                "suitable DMA mask - aborting\n", ha->host_no);
diff --git a/drivers/scsi/qla2xxx/qla_attr.c b/drivers/scsi/qla2xxx/qla_attr.c
index 00444dc79756..ac504a1ff0ff 100644
--- a/drivers/scsi/qla2xxx/qla_attr.c
+++ b/drivers/scsi/qla2xxx/qla_attr.c
@@ -2415,8 +2415,8 @@ qla2x00_get_fc_host_stats(struct Scsi_Host *shost)
         if (qla2x00_chip_is_down(vha))
                 goto done;
 
-        stats = dma_zalloc_coherent(&ha->pdev->dev, sizeof(*stats),
-                                    &stats_dma, GFP_KERNEL);
+        stats = dma_alloc_coherent(&ha->pdev->dev, sizeof(*stats), &stats_dma,
+                                   GFP_KERNEL);
         if (!stats) {
                 ql_log(ql_log_warn, vha, 0x707d,
                     "Failed to allocate memory for stats.\n");
diff --git a/drivers/scsi/qla2xxx/qla_bsg.c b/drivers/scsi/qla2xxx/qla_bsg.c
index 4a9fd8d944d6..17d42658ad9a 100644
--- a/drivers/scsi/qla2xxx/qla_bsg.c
+++ b/drivers/scsi/qla2xxx/qla_bsg.c
@@ -2312,8 +2312,8 @@ qla2x00_get_priv_stats(struct bsg_job *bsg_job)
         if (!IS_FWI2_CAPABLE(ha))
                 return -EPERM;
 
-        stats = dma_zalloc_coherent(&ha->pdev->dev, sizeof(*stats),
-                                    &stats_dma, GFP_KERNEL);
+        stats = dma_alloc_coherent(&ha->pdev->dev, sizeof(*stats), &stats_dma,
+                                   GFP_KERNEL);
         if (!stats) {
                 ql_log(ql_log_warn, vha, 0x70e2,
                     "Failed to allocate memory for stats.\n");
diff --git a/drivers/scsi/qla2xxx/qla_def.h b/drivers/scsi/qla2xxx/qla_def.h
index 26b93c563f92..d1fc4958222a 100644
--- a/drivers/scsi/qla2xxx/qla_def.h
+++ b/drivers/scsi/qla2xxx/qla_def.h
@@ -4394,6 +4394,8 @@ typedef struct scsi_qla_host {
         uint16_t        n2n_id;
         struct list_head gpnid_list;
         struct fab_scan scan;
+
+        unsigned int irq_offset;
 } scsi_qla_host_t;
 
 struct qla27xx_image_status {
diff --git a/drivers/scsi/qla2xxx/qla_gs.c b/drivers/scsi/qla2xxx/qla_gs.c
index 90cfa394f942..cbc3bc49d4d1 100644
--- a/drivers/scsi/qla2xxx/qla_gs.c
+++ b/drivers/scsi/qla2xxx/qla_gs.c
@@ -4147,9 +4147,10 @@ int qla24xx_async_gpnft(scsi_qla_host_t *vha, u8 fc4_type, srb_t *sp)
                         return rval;
                 }
 
-                sp->u.iocb_cmd.u.ctarg.req = dma_zalloc_coherent(
-                        &vha->hw->pdev->dev, sizeof(struct ct_sns_pkt),
-                        &sp->u.iocb_cmd.u.ctarg.req_dma, GFP_KERNEL);
+                sp->u.iocb_cmd.u.ctarg.req = dma_alloc_coherent(&vha->hw->pdev->dev,
+                                                                sizeof(struct ct_sns_pkt),
+                                                                &sp->u.iocb_cmd.u.ctarg.req_dma,
+                                                                GFP_KERNEL);
                 sp->u.iocb_cmd.u.ctarg.req_allocated_size = sizeof(struct ct_sns_pkt);
                 if (!sp->u.iocb_cmd.u.ctarg.req) {
                         ql_log(ql_log_warn, vha, 0xffff,
@@ -4165,9 +4166,10 @@ int qla24xx_async_gpnft(scsi_qla_host_t *vha, u8 fc4_type, srb_t *sp)
                         ((vha->hw->max_fibre_devices - 1) *
                             sizeof(struct ct_sns_gpn_ft_data));
 
-                sp->u.iocb_cmd.u.ctarg.rsp = dma_zalloc_coherent(
-                        &vha->hw->pdev->dev, rspsz,
-                        &sp->u.iocb_cmd.u.ctarg.rsp_dma, GFP_KERNEL);
+                sp->u.iocb_cmd.u.ctarg.rsp = dma_alloc_coherent(&vha->hw->pdev->dev,
+                                                                rspsz,
+                                                                &sp->u.iocb_cmd.u.ctarg.rsp_dma,
+                                                                GFP_KERNEL);
                 sp->u.iocb_cmd.u.ctarg.rsp_allocated_size = sizeof(struct ct_sns_pkt);
                 if (!sp->u.iocb_cmd.u.ctarg.rsp) {
                         ql_log(ql_log_warn, vha, 0xffff,
diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
index 364bb52ed2a6..8d1acc802a67 100644
--- a/drivers/scsi/qla2xxx/qla_init.c
+++ b/drivers/scsi/qla2xxx/qla_init.c
@@ -1785,13 +1785,13 @@ qla2x00_async_tm_cmd(fc_port_t *fcport, uint32_t flags, uint32_t lun,
 
                 /* Issue Marker IOCB */
                 qla2x00_marker(vha, vha->hw->req_q_map[0],
-                    vha->hw->rsp_q_map[0], sp->fcport->loop_id, lun,
+                    vha->hw->rsp_q_map[0], fcport->loop_id, lun,
                     flags == TCF_LUN_RESET ? MK_SYNC_ID_LUN : MK_SYNC_ID);
         }
 
 done_free_sp:
         sp->free(sp);
-        sp->fcport->flags &= ~FCF_ASYNC_SENT;
+        fcport->flags &= ~FCF_ASYNC_SENT;
 done:
         return rval;
 }
@@ -3099,8 +3099,8 @@ qla2x00_alloc_offload_mem(scsi_qla_host_t *vha)
                             FCE_SIZE, ha->fce, ha->fce_dma);
 
                 /* Allocate memory for Fibre Channel Event Buffer. */
-                tc = dma_zalloc_coherent(&ha->pdev->dev, FCE_SIZE, &tc_dma,
-                                         GFP_KERNEL);
+                tc = dma_alloc_coherent(&ha->pdev->dev, FCE_SIZE, &tc_dma,
+                                        GFP_KERNEL);
                 if (!tc) {
                         ql_log(ql_log_warn, vha, 0x00be,
                             "Unable to allocate (%d KB) for FCE.\n",
@@ -3131,8 +3131,8 @@ try_eft:
                             EFT_SIZE, ha->eft, ha->eft_dma);
 
                 /* Allocate memory for Extended Trace Buffer. */
-                tc = dma_zalloc_coherent(&ha->pdev->dev, EFT_SIZE, &tc_dma,
-                                         GFP_KERNEL);
+                tc = dma_alloc_coherent(&ha->pdev->dev, EFT_SIZE, &tc_dma,
+                                        GFP_KERNEL);
                 if (!tc) {
                         ql_log(ql_log_warn, vha, 0x00c1,
                             "Unable to allocate (%d KB) for EFT.\n",
diff --git a/drivers/scsi/qla2xxx/qla_isr.c b/drivers/scsi/qla2xxx/qla_isr.c
index 30d3090842f8..8507c43b918c 100644
--- a/drivers/scsi/qla2xxx/qla_isr.c
+++ b/drivers/scsi/qla2xxx/qla_isr.c
@@ -3446,6 +3446,7 @@ qla24xx_enable_msix(struct qla_hw_data *ha, struct rsp_que *rsp)
                             "Adjusted Max no of queues pairs: %d.\n", ha->max_qpairs);
                 }
         }
+        vha->irq_offset = desc.pre_vectors;
         ha->msix_entries = kcalloc(ha->msix_count,
                                    sizeof(struct qla_msix_entry),
                                    GFP_KERNEL);
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index ea69dafc9774..c6ef83d0d99b 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -6939,7 +6939,7 @@ static int qla2xxx_map_queues(struct Scsi_Host *shost)
         if (USER_CTRL_IRQ(vha->hw))
                 rc = blk_mq_map_queues(qmap);
         else
-                rc = blk_mq_pci_map_queues(qmap, vha->hw->pdev, 0);
+                rc = blk_mq_pci_map_queues(qmap, vha->hw->pdev, vha->irq_offset);
         return rc;
 }
 
diff --git a/drivers/scsi/qla4xxx/ql4_init.c b/drivers/scsi/qla4xxx/ql4_init.c
index 1ef74aa2d00a..2bf5e3e639e1 100644
--- a/drivers/scsi/qla4xxx/ql4_init.c
+++ b/drivers/scsi/qla4xxx/ql4_init.c
@@ -153,8 +153,8 @@ int qla4xxx_get_sys_info(struct scsi_qla_host *ha)
         dma_addr_t sys_info_dma;
         int status = QLA_ERROR;
 
-        sys_info = dma_zalloc_coherent(&ha->pdev->dev, sizeof(*sys_info),
-                                       &sys_info_dma, GFP_KERNEL);
+        sys_info = dma_alloc_coherent(&ha->pdev->dev, sizeof(*sys_info),
+                                      &sys_info_dma, GFP_KERNEL);
         if (sys_info == NULL) {
                 DEBUG2(printk("scsi%ld: %s: Unable to allocate dma buffer.\n",
                               ha->host_no, __func__));
diff --git a/drivers/scsi/qla4xxx/ql4_mbx.c b/drivers/scsi/qla4xxx/ql4_mbx.c
index 5d56904687b9..dac9a7013208 100644
--- a/drivers/scsi/qla4xxx/ql4_mbx.c
+++ b/drivers/scsi/qla4xxx/ql4_mbx.c
@@ -625,9 +625,9 @@ int qla4xxx_initialize_fw_cb(struct scsi_qla_host * ha)
         uint32_t mbox_sts[MBOX_REG_COUNT];
         int status = QLA_ERROR;
 
-        init_fw_cb = dma_zalloc_coherent(&ha->pdev->dev,
-                                         sizeof(struct addr_ctrl_blk),
-                                         &init_fw_cb_dma, GFP_KERNEL);
+        init_fw_cb = dma_alloc_coherent(&ha->pdev->dev,
+                                        sizeof(struct addr_ctrl_blk),
+                                        &init_fw_cb_dma, GFP_KERNEL);
         if (init_fw_cb == NULL) {
                 DEBUG2(printk("scsi%ld: %s: Unable to alloc init_cb\n",
                               ha->host_no, __func__));
@@ -709,9 +709,9 @@ int qla4xxx_get_dhcp_ip_address(struct scsi_qla_host * ha)
         uint32_t mbox_cmd[MBOX_REG_COUNT];
         uint32_t mbox_sts[MBOX_REG_COUNT];
 
-        init_fw_cb = dma_zalloc_coherent(&ha->pdev->dev,
-                                         sizeof(struct addr_ctrl_blk),
-                                         &init_fw_cb_dma, GFP_KERNEL);
+        init_fw_cb = dma_alloc_coherent(&ha->pdev->dev,
+                                        sizeof(struct addr_ctrl_blk),
+                                        &init_fw_cb_dma, GFP_KERNEL);
         if (init_fw_cb == NULL) {
                 printk("scsi%ld: %s: Unable to alloc init_cb\n", ha->host_no,
                        __func__);
@@ -1340,9 +1340,9 @@ int qla4xxx_about_firmware(struct scsi_qla_host *ha)
         uint32_t mbox_sts[MBOX_REG_COUNT];
         int status = QLA_ERROR;
 
-        about_fw = dma_zalloc_coherent(&ha->pdev->dev,
-                                       sizeof(struct about_fw_info),
-                                       &about_fw_dma, GFP_KERNEL);
+        about_fw = dma_alloc_coherent(&ha->pdev->dev,
+                                      sizeof(struct about_fw_info),
+                                      &about_fw_dma, GFP_KERNEL);
         if (!about_fw) {
                 DEBUG2(ql4_printk(KERN_ERR, ha, "%s: Unable to alloc memory "
                                   "for about_fw\n", __func__));
diff --git a/drivers/scsi/qla4xxx/ql4_nx.c b/drivers/scsi/qla4xxx/ql4_nx.c
index d2b333d629be..5a31877c9d04 100644
--- a/drivers/scsi/qla4xxx/ql4_nx.c
+++ b/drivers/scsi/qla4xxx/ql4_nx.c
@@ -4052,8 +4052,8 @@ int qla4_8xxx_get_sys_info(struct scsi_qla_host *ha)
         dma_addr_t sys_info_dma;
         int status = QLA_ERROR;
 
-        sys_info = dma_zalloc_coherent(&ha->pdev->dev, sizeof(*sys_info),
-                                       &sys_info_dma, GFP_KERNEL);
+        sys_info = dma_alloc_coherent(&ha->pdev->dev, sizeof(*sys_info),
+                                      &sys_info_dma, GFP_KERNEL);
         if (sys_info == NULL) {
                 DEBUG2(printk("scsi%ld: %s: Unable to allocate dma buffer.\n",
                     ha->host_no, __func__));
diff --git a/drivers/scsi/qla4xxx/ql4_os.c b/drivers/scsi/qla4xxx/ql4_os.c
index 949e186cc5d7..a77bfb224248 100644
--- a/drivers/scsi/qla4xxx/ql4_os.c
+++ b/drivers/scsi/qla4xxx/ql4_os.c
@@ -2704,9 +2704,9 @@ qla4xxx_iface_set_param(struct Scsi_Host *shost, void *data, uint32_t len)
         uint32_t rem = len;
         struct nlattr *attr;
 
-        init_fw_cb = dma_zalloc_coherent(&ha->pdev->dev,
-                                         sizeof(struct addr_ctrl_blk),
-                                         &init_fw_cb_dma, GFP_KERNEL);
+        init_fw_cb = dma_alloc_coherent(&ha->pdev->dev,
+                                        sizeof(struct addr_ctrl_blk),
+                                        &init_fw_cb_dma, GFP_KERNEL);
         if (!init_fw_cb) {
                 ql4_printk(KERN_ERR, ha, "%s: Unable to alloc init_cb\n",
                            __func__);
@@ -4206,8 +4206,8 @@ static int qla4xxx_mem_alloc(struct scsi_qla_host *ha)
                           sizeof(struct shadow_regs) +
                           MEM_ALIGN_VALUE +
                           (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
-        ha->queues = dma_zalloc_coherent(&ha->pdev->dev, ha->queues_len,
-                                         &ha->queues_dma, GFP_KERNEL);
+        ha->queues = dma_alloc_coherent(&ha->pdev->dev, ha->queues_len,
+                                        &ha->queues_dma, GFP_KERNEL);
         if (ha->queues == NULL) {
                 ql4_printk(KERN_WARNING, ha,
                     "Memory Allocation failed - queues.\n");
@@ -7232,6 +7232,8 @@ static int qla4xxx_sysfs_ddb_tgt_create(struct scsi_qla_host *ha,
 
         rc = qla4xxx_copy_from_fwddb_param(fnode_sess, fnode_conn,
                                            fw_ddb_entry);
+        if (rc)
+                goto free_sess;
 
         ql4_printk(KERN_INFO, ha, "%s: sysfs entry %s created\n",
                    __func__, fnode_sess->dev.kobj.name);
diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index 661512bec3ac..e27f4df24021 100644
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
@@ -62,7 +62,7 @@
 
 /* make sure inq_product_rev string corresponds to this version */
 #define SDEBUG_VERSION "0188"   /* format to fit INQUIRY revision field */
-static const char *sdebug_version_date = "20180128";
+static const char *sdebug_version_date = "20190125";
 
 #define MY_NAME "scsi_debug"
 
@@ -735,7 +735,7 @@ static inline bool scsi_debug_lbp(void)
                 (sdebug_lbpu || sdebug_lbpws || sdebug_lbpws10);
 }
 
-static void *fake_store(unsigned long long lba)
+static void *lba2fake_store(unsigned long long lba)
 {
         lba = do_div(lba, sdebug_store_sectors);
 
@@ -2514,8 +2514,8 @@ static int do_device_access(struct scsi_cmnd *scmd, u32 sg_skip, u64 lba,
         return ret;
 }
 
-/* If fake_store(lba,num) compares equal to arr(num), then copy top half of
- * arr into fake_store(lba,num) and return true. If comparison fails then
+/* If lba2fake_store(lba,num) compares equal to arr(num), then copy top half of
+ * arr into lba2fake_store(lba,num) and return true. If comparison fails then
  * return false. */
 static bool comp_write_worker(u64 lba, u32 num, const u8 *arr)
 {
@@ -2643,7 +2643,7 @@ static int prot_verify_read(struct scsi_cmnd *SCpnt, sector_t start_sec,
                 if (sdt->app_tag == cpu_to_be16(0xffff))
                         continue;
 
-                ret = dif_verify(sdt, fake_store(sector), sector, ei_lba);
+                ret = dif_verify(sdt, lba2fake_store(sector), sector, ei_lba);
                 if (ret) {
                         dif_errors++;
                         return ret;
@@ -3261,10 +3261,12 @@ err_out:
 static int resp_write_same(struct scsi_cmnd *scp, u64 lba, u32 num,
                            u32 ei_lba, bool unmap, bool ndob)
 {
+        int ret;
         unsigned long iflags;
         unsigned long long i;
-        int ret;
-        u64 lba_off;
+        u32 lb_size = sdebug_sector_size;
+        u64 block, lbaa;
+        u8 *fs1p;
 
         ret = check_device_access_params(scp, lba, num);
         if (ret)
@@ -3276,31 +3278,30 @@ static int resp_write_same(struct scsi_cmnd *scp, u64 lba, u32 num,
                 unmap_region(lba, num);
                 goto out;
         }
-
-        lba_off = lba * sdebug_sector_size;
+        lbaa = lba;
+        block = do_div(lbaa, sdebug_store_sectors);
         /* if ndob then zero 1 logical block, else fetch 1 logical block */
+        fs1p = fake_storep + (block * lb_size);
         if (ndob) {
-                memset(fake_storep + lba_off, 0, sdebug_sector_size);
+                memset(fs1p, 0, lb_size);
                 ret = 0;
         } else
-                ret = fetch_to_dev_buffer(scp, fake_storep + lba_off,
-                                          sdebug_sector_size);
+                ret = fetch_to_dev_buffer(scp, fs1p, lb_size);
 
         if (-1 == ret) {
                 write_unlock_irqrestore(&atomic_rw, iflags);
                 return DID_ERROR << 16;
-        } else if (sdebug_verbose && !ndob && (ret < sdebug_sector_size))
+        } else if (sdebug_verbose && !ndob && (ret < lb_size))
                 sdev_printk(KERN_INFO, scp->device,
                             "%s: %s: lb size=%u, IO sent=%d bytes\n",
-                            my_name, "write same",
-                            sdebug_sector_size, ret);
+                            my_name, "write same", lb_size, ret);
 
         /* Copy first sector to remaining blocks */
-        for (i = 1 ; i < num ; i++)
-                memcpy(fake_storep + ((lba + i) * sdebug_sector_size),
-                       fake_storep + lba_off,
-                       sdebug_sector_size);
-
+        for (i = 1 ; i < num ; i++) {
+                lbaa = lba + i;
+                block = do_div(lbaa, sdebug_store_sectors);
+                memmove(fake_storep + (block * lb_size), fs1p, lb_size);
+        }
         if (scsi_debug_lbp())
                 map_region(lba, num);
 out:
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index b13cc9288ba0..f8d51c3d5582 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -655,6 +655,7 @@ static blk_status_t scsi_result_to_blk_status(struct scsi_cmnd *cmd, int result)
                 set_host_byte(cmd, DID_OK);
                 return BLK_STS_TARGET;
         case DID_NEXUS_FAILURE:
+                set_host_byte(cmd, DID_OK);
                 return BLK_STS_NEXUS;
         case DID_ALLOC_FAILURE:
                 set_host_byte(cmd, DID_OK);
@@ -1842,8 +1843,8 @@ void __scsi_init_queue(struct Scsi_Host *shost, struct request_queue *q)
         blk_queue_segment_boundary(q, shost->dma_boundary);
         dma_set_seg_boundary(dev, shost->dma_boundary);
 
-        blk_queue_max_segment_size(q,
-                min(shost->max_segment_size, dma_get_max_seg_size(dev)));
+        blk_queue_max_segment_size(q, shost->max_segment_size);
+        dma_set_max_seg_size(dev, shost->max_segment_size);
 
         /*
          * Set a reasonable default alignment:  The larger of 32-byte (dword),
diff --git a/drivers/scsi/scsi_pm.c b/drivers/scsi/scsi_pm.c
index a2b4179bfdf7..7639df91b110 100644
--- a/drivers/scsi/scsi_pm.c
+++ b/drivers/scsi/scsi_pm.c
@@ -80,8 +80,22 @@ static int scsi_dev_type_resume(struct device *dev,
 
         if (err == 0) {
                 pm_runtime_disable(dev);
-                pm_runtime_set_active(dev);
+                err = pm_runtime_set_active(dev);
                 pm_runtime_enable(dev);
+
+                /*
+                 * Forcibly set runtime PM status of request queue to "active"
+                 * to make sure we can again get requests from the queue
+                 * (see also blk_pm_peek_request()).
+                 *
+                 * The resume hook will correct runtime PM status of the disk.
+                 */
+                if (!err && scsi_is_sdev_device(dev)) {
+                        struct scsi_device *sdev = to_scsi_device(dev);
+
+                        if (sdev->request_queue->dev)
+                                blk_set_runtime_active(sdev->request_queue);
+                }
         }
 
         return err;
@@ -140,16 +154,6 @@ static int scsi_bus_resume_common(struct device *dev,
         else
                 fn = NULL;
 
-        /*
-         * Forcibly set runtime PM status of request queue to "active" to
-         * make sure we can again get requests from the queue (see also
-         * blk_pm_peek_request()).
-         *
-         * The resume hook will correct runtime PM status of the disk.
-         */
-        if (scsi_is_sdev_device(dev) && pm_runtime_suspended(dev))
-                blk_set_runtime_active(to_scsi_device(dev)->request_queue);
-
         if (fn) {
                 async_schedule_domain(fn, dev, &scsi_sd_pm_domain);
 
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index a1a44f52e0e8..5464d467e23e 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -206,6 +206,12 @@ cache_type_store(struct device *dev, struct device_attribute *attr,
         sp = buffer_data[0] & 0x80 ? 1 : 0;
         buffer_data[0] &= ~0x80;
 
+        /*
+         * Ensure WP, DPOFUA, and RESERVED fields are cleared in
+         * received mode parameter buffer before doing MODE SELECT.
+         */
+        data.device_specific = 0;
+
         if (scsi_mode_select(sdp, 1, sp, 8, buffer_data, len, SD_TIMEOUT,
                              SD_MAX_RETRIES, &data, &sshdr)) {
                 if (scsi_sense_valid(&sshdr))
@@ -2945,9 +2951,6 @@ static void sd_read_block_characteristics(struct scsi_disk *sdkp)
         if (rot == 1) {
                 blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
                 blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, q);
-        } else {
-                blk_queue_flag_clear(QUEUE_FLAG_NONROT, q);
-                blk_queue_flag_set(QUEUE_FLAG_ADD_RANDOM, q);
         }
 
         if (sdkp->device->type == TYPE_ZBC) {
@@ -3084,6 +3087,15 @@ static int sd_revalidate_disk(struct gendisk *disk)
         if (sdkp->media_present) {
                 sd_read_capacity(sdkp, buffer);
 
+                /*
+                 * set the default to rotational.  All non-rotational devices
+                 * support the block characteristics VPD page, which will
+                 * cause this to be updated correctly and any device which
+                 * doesn't support it should be treated as rotational.
+                 */
+                blk_queue_flag_clear(QUEUE_FLAG_NONROT, q);
+                blk_queue_flag_set(QUEUE_FLAG_ADD_RANDOM, q);
+
                 if (scsi_device_supports_vpd(sdp)) {
                         sd_read_block_provisioning(sdkp);
                         sd_read_block_limits(sdkp);
diff --git a/drivers/scsi/sd_zbc.c b/drivers/scsi/sd_zbc.c
index 83365b29a4d8..a340af797a85 100644
--- a/drivers/scsi/sd_zbc.c
+++ b/drivers/scsi/sd_zbc.c
@@ -142,10 +142,12 @@ int sd_zbc_report_zones(struct gendisk *disk, sector_t sector,
                 return -EOPNOTSUPP;
 
         /*
-         * Get a reply buffer for the number of requested zones plus a header.
-         * For ATA, buffers must be aligned to 512B.
+         * Get a reply buffer for the number of requested zones plus a header,
+         * without exceeding the device maximum command size. For ATA disks,
+         * buffers must be aligned to 512B.
          */
-        buflen = roundup((nrz + 1) * 64, 512);
+        buflen = min(queue_max_hw_sectors(disk->queue) << 9,
+                     roundup((nrz + 1) * 64, 512));
         buf = kmalloc(buflen, gfp_mask);
         if (!buf)
                 return -ENOMEM;
@@ -462,12 +464,16 @@ int sd_zbc_read_zones(struct scsi_disk *sdkp, unsigned char *buf)
         sdkp->device->use_10_for_rw = 0;
 
         /*
-         * If something changed, revalidate the disk zone bitmaps once we have
-         * the capacity, that is on the second revalidate execution during disk
-         * scan and always during normal revalidate.
+         * Revalidate the disk zone bitmaps once the block device capacity is
+         * set on the second revalidate execution during disk scan and if
+         * something changed when executing a normal revalidate.
          */
-        if (sdkp->first_scan)
+        if (sdkp->first_scan) {
+                sdkp->zone_blocks = zone_blocks;
+                sdkp->nr_zones = nr_zones;
                 return 0;
+        }
+
         if (sdkp->zone_blocks != zone_blocks ||
             sdkp->nr_zones != nr_zones ||
             disk->queue->nr_zones != nr_zones) {
diff --git a/drivers/scsi/smartpqi/smartpqi_init.c b/drivers/scsi/smartpqi/smartpqi_init.c
index e2fa3f476227..f564af8949e8 100644
--- a/drivers/scsi/smartpqi/smartpqi_init.c
+++ b/drivers/scsi/smartpqi/smartpqi_init.c
@@ -323,7 +323,7 @@ static inline void pqi_device_remove_start(struct pqi_scsi_dev *device)
 static inline bool pqi_device_in_remove(struct pqi_ctrl_info *ctrl_info,
                                         struct pqi_scsi_dev *device)
 {
-        return device->in_remove & !ctrl_info->in_shutdown;
+        return device->in_remove && !ctrl_info->in_shutdown;
 }
 
 static inline void pqi_schedule_rescan_worker_with_delay(
@@ -3576,9 +3576,9 @@ static int pqi_alloc_operational_queues(struct pqi_ctrl_info *ctrl_info)
         alloc_length += PQI_EXTRA_SGL_MEMORY;
 
         ctrl_info->queue_memory_base =
-                dma_zalloc_coherent(&ctrl_info->pci_dev->dev,
-                        alloc_length,
-                        &ctrl_info->queue_memory_base_dma_handle, GFP_KERNEL);
+                dma_alloc_coherent(&ctrl_info->pci_dev->dev, alloc_length,
+                                   &ctrl_info->queue_memory_base_dma_handle,
+                                   GFP_KERNEL);
 
         if (!ctrl_info->queue_memory_base)
                 return -ENOMEM;
@@ -3715,10 +3715,9 @@ static int pqi_alloc_admin_queues(struct pqi_ctrl_info *ctrl_info)
                 PQI_QUEUE_ELEMENT_ARRAY_ALIGNMENT;
 
         ctrl_info->admin_queue_memory_base =
-                dma_zalloc_coherent(&ctrl_info->pci_dev->dev,
-                        alloc_length,
-                        &ctrl_info->admin_queue_memory_base_dma_handle,
-                        GFP_KERNEL);
+                dma_alloc_coherent(&ctrl_info->pci_dev->dev, alloc_length,
+                                   &ctrl_info->admin_queue_memory_base_dma_handle,
+                                   GFP_KERNEL);
 
         if (!ctrl_info->admin_queue_memory_base)
                 return -ENOMEM;
@@ -4602,9 +4601,10 @@ static void pqi_free_all_io_requests(struct pqi_ctrl_info *ctrl_info)
 
 static inline int pqi_alloc_error_buffer(struct pqi_ctrl_info *ctrl_info)
 {
-        ctrl_info->error_buffer = dma_zalloc_coherent(&ctrl_info->pci_dev->dev,
-                ctrl_info->error_buffer_length,
-                &ctrl_info->error_buffer_dma_handle, GFP_KERNEL);
+        ctrl_info->error_buffer = dma_alloc_coherent(&ctrl_info->pci_dev->dev,
+                                                     ctrl_info->error_buffer_length,
+                                                     &ctrl_info->error_buffer_dma_handle,
+                                                     GFP_KERNEL);
 
         if (!ctrl_info->error_buffer)
                 return -ENOMEM;
@@ -7487,8 +7487,8 @@ static int pqi_ofa_alloc_mem(struct pqi_ctrl_info *ctrl_info,
                 dma_addr_t dma_handle;
 
                 ctrl_info->pqi_ofa_chunk_virt_addr[i] =
-                        dma_zalloc_coherent(dev, chunk_size, &dma_handle,
-                                                GFP_KERNEL);
+                        dma_alloc_coherent(dev, chunk_size, &dma_handle,
+                                           GFP_KERNEL);
 
                 if (!ctrl_info->pqi_ofa_chunk_virt_addr[i])
                         break;
@@ -7545,10 +7545,10 @@ static void pqi_ofa_setup_host_buffer(struct pqi_ctrl_info *ctrl_info,
         struct device *dev;
 
         dev = &ctrl_info->pci_dev->dev;
-        pqi_ofa_memory = dma_zalloc_coherent(dev,
-                                PQI_OFA_MEMORY_DESCRIPTOR_LENGTH,
-                                &ctrl_info->pqi_ofa_mem_dma_handle,
-                                GFP_KERNEL);
+        pqi_ofa_memory = dma_alloc_coherent(dev,
+                                            PQI_OFA_MEMORY_DESCRIPTOR_LENGTH,
+                                            &ctrl_info->pqi_ofa_mem_dma_handle,
+                                            GFP_KERNEL);
 
         if (!pqi_ofa_memory)
                 return;
diff --git a/drivers/scsi/ufs/ufs.h b/drivers/scsi/ufs/ufs.h
index dd65fea07687..6d176815e6ce 100644
--- a/drivers/scsi/ufs/ufs.h
+++ b/drivers/scsi/ufs/ufs.h
@@ -195,7 +195,7 @@ enum ufs_desc_def_size {
         QUERY_DESC_CONFIGURATION_DEF_SIZE       = 0x90,
         QUERY_DESC_UNIT_DEF_SIZE                = 0x23,
         QUERY_DESC_INTERCONNECT_DEF_SIZE        = 0x06,
-        QUERY_DESC_GEOMETRY_DEF_SIZE            = 0x44,
+        QUERY_DESC_GEOMETRY_DEF_SIZE            = 0x48,
         QUERY_DESC_POWER_DEF_SIZE               = 0x62,
         QUERY_DESC_HEALTH_DEF_SIZE              = 0x25,
 };
diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
index 9ba7671b84f8..2ddf24466a62 100644
--- a/drivers/scsi/ufs/ufshcd.c
+++ b/drivers/scsi/ufs/ufshcd.c
@@ -108,13 +108,19 @@
 int ufshcd_dump_regs(struct ufs_hba *hba, size_t offset, size_t len,
                      const char *prefix)
 {
-        u8 *regs;
+        u32 *regs;
+        size_t pos;
+
+        if (offset % 4 != 0 || len % 4 != 0) /* keep readl happy */
+                return -EINVAL;
 
         regs = kzalloc(len, GFP_KERNEL);
         if (!regs)
                 return -ENOMEM;
 
-        memcpy_fromio(regs, hba->mmio_base + offset, len);
+        for (pos = 0; pos < len; pos += 4)
+                regs[pos / 4] = ufshcd_readl(hba, offset + pos);
+
         ufshcd_hex_dump(prefix, regs, len);
         kfree(regs);
 
@@ -8001,6 +8007,8 @@ out:
         trace_ufshcd_system_resume(dev_name(hba->dev), ret,
                 ktime_to_us(ktime_sub(ktime_get(), start)),
                 hba->curr_dev_pwr_mode, hba->uic_link_state);
+        if (!ret)
+                hba->is_sys_suspended = false;
         return ret;
 }
 EXPORT_SYMBOL(ufshcd_system_resume);