28 files changed, 263 insertions, 139 deletions

diff --git a/drivers/scsi/aacraid/aachba.c b/drivers/scsi/aacraid/aachba.c
index 2a889853a106..7e26ebc26661 100644
--- a/drivers/scsi/aacraid/aachba.c
+++ b/drivers/scsi/aacraid/aachba.c
@@ -293,7 +293,10 @@ int aac_get_config_status(struct aac_dev *dev, int commit_flag)
                         status = -EINVAL;
                 }
         }
-        aac_fib_complete(fibptr);
+        /* Do not set XferState to zero unless receives a response from F/W */
+        if (status >= 0)
+                aac_fib_complete(fibptr);
+
         /* Send a CT_COMMIT_CONFIG to enable discovery of devices */
         if (status >= 0) {
                 if ((aac_commit == 1) || commit_flag) {
@@ -310,13 +313,18 @@ int aac_get_config_status(struct aac_dev *dev, int commit_flag)
                                     FsaNormal,
                                     1, 1,
                                     NULL, NULL);
-                        aac_fib_complete(fibptr);
+                        /* Do not set XferState to zero unless
+                         * receives a response from F/W */
+                        if (status >= 0)
+                                aac_fib_complete(fibptr);
                 } else if (aac_commit == 0) {
                         printk(KERN_WARNING
                           "aac_get_config_status: Foreign device configurations are being ignored\n");
                 }
         }
-        aac_fib_free(fibptr);
+        /* FIB should be freed only after getting the response from the F/W */
+        if (status != -ERESTARTSYS)
+                aac_fib_free(fibptr);
         return status;
 }
 
@@ -355,7 +363,9 @@ int aac_get_containers(struct aac_dev *dev)
                 maximum_num_containers = le32_to_cpu(dresp->ContainerSwitchEntries);
                 aac_fib_complete(fibptr);
         }
-        aac_fib_free(fibptr);
+        /* FIB should be freed only after getting the response from the F/W */
+        if (status != -ERESTARTSYS)
+                aac_fib_free(fibptr);
 
         if (maximum_num_containers < MAXIMUM_NUM_CONTAINERS)
                 maximum_num_containers = MAXIMUM_NUM_CONTAINERS;
@@ -1245,8 +1255,12 @@ int aac_get_adapter_info(struct aac_dev* dev)
                          NULL);
 
         if (rcode < 0) {
-                aac_fib_complete(fibptr);
-                aac_fib_free(fibptr);
+                /* FIB should be freed only after
+                 * getting the response from the F/W */
+                if (rcode != -ERESTARTSYS) {
+                        aac_fib_complete(fibptr);
+                        aac_fib_free(fibptr);
+                }
                 return rcode;
         }
         memcpy(&dev->adapter_info, info, sizeof(*info));
@@ -1270,6 +1284,12 @@ int aac_get_adapter_info(struct aac_dev* dev)
 
                 if (rcode >= 0)
                         memcpy(&dev->supplement_adapter_info, sinfo, sizeof(*sinfo));
+                if (rcode == -ERESTARTSYS) {
+                        fibptr = aac_fib_alloc(dev);
+                        if (!fibptr)
+                                return -ENOMEM;
+                }
+
         }
 
 
@@ -1470,9 +1490,11 @@ int aac_get_adapter_info(struct aac_dev* dev)
                           (dev->scsi_host_ptr->sg_tablesize * 8) + 112;
                 }
         }
-
-        aac_fib_complete(fibptr);
-        aac_fib_free(fibptr);
+        /* FIB should be freed only after getting the response from the F/W */
+        if (rcode != -ERESTARTSYS) {
+                aac_fib_complete(fibptr);
+                aac_fib_free(fibptr);
+        }
 
         return rcode;
 }
@@ -1633,6 +1655,7 @@ static int aac_read(struct scsi_cmnd * scsicmd)
          *      Alocate and initialize a Fib
          */
         if (!(cmd_fibcontext = aac_fib_alloc(dev))) {
+                printk(KERN_WARNING "aac_read: fib allocation failed\n");
                 return -1;
         }
 
@@ -1712,9 +1735,14 @@ static int aac_write(struct scsi_cmnd * scsicmd)
          *      Allocate and initialize a Fib then setup a BlockWrite command
          */
         if (!(cmd_fibcontext = aac_fib_alloc(dev))) {
-                scsicmd->result = DID_ERROR << 16;
-                scsicmd->scsi_done(scsicmd);
-                return 0;
+                /* FIB temporarily unavailable,not catastrophic failure */
+
+                /* scsicmd->result = DID_ERROR << 16;
+                 * scsicmd->scsi_done(scsicmd);
+                 * return 0;
+                 */
+                printk(KERN_WARNING "aac_write: fib allocation failed\n");
+                return -1;
         }
 
         status = aac_adapter_write(cmd_fibcontext, scsicmd, lba, count, fua);
diff --git a/drivers/scsi/aacraid/aacraid.h b/drivers/scsi/aacraid/aacraid.h
index 83986ed86556..619c02d9c862 100644
--- a/drivers/scsi/aacraid/aacraid.h
+++ b/drivers/scsi/aacraid/aacraid.h
@@ -12,7 +12,7 @@
  *----------------------------------------------------------------------------*/
 
 #ifndef AAC_DRIVER_BUILD
-# define AAC_DRIVER_BUILD 2461
+# define AAC_DRIVER_BUILD 24702
 # define AAC_DRIVER_BRANCH "-ms"
 #endif
 #define MAXIMUM_NUM_CONTAINERS  32
@@ -1036,6 +1036,9 @@ struct aac_dev
         u8                      printf_enabled;
         u8                      in_reset;
         u8                      msi;
+        int                     management_fib_count;
+        spinlock_t              manage_lock;
+
 };
 
 #define aac_adapter_interrupt(dev) \
diff --git a/drivers/scsi/aacraid/commctrl.c b/drivers/scsi/aacraid/commctrl.c
index 0391d759dfdb..9c0c91178538 100644
--- a/drivers/scsi/aacraid/commctrl.c
+++ b/drivers/scsi/aacraid/commctrl.c
@@ -153,7 +153,7 @@ cleanup:
                 fibptr->hw_fib_pa = hw_fib_pa;
                 fibptr->hw_fib_va = hw_fib;
         }
-        if (retval != -EINTR)
+        if (retval != -ERESTARTSYS)
                 aac_fib_free(fibptr);
         return retval;
 }
@@ -322,7 +322,7 @@ return_fib:
                 }
                 if (f.wait) {
                         if(down_interruptible(&fibctx->wait_sem) < 0) {
-                                status = -EINTR;
+                                status = -ERESTARTSYS;
                         } else {
                                 /* Lock again and retry */
                                 spin_lock_irqsave(&dev->fib_lock, flags);
@@ -593,10 +593,10 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
                                 u64 addr;
                                 void* p;
                                 if (upsg->sg[i].count >
-                                    (dev->adapter_info.options &
+                                    ((dev->adapter_info.options &
                                      AAC_OPT_NEW_COMM) ?
                                       (dev->scsi_host_ptr->max_sectors << 9) :
-                                      65536) {
+                                      65536)) {
                                         rcode = -EINVAL;
                                         goto cleanup;
                                 }
@@ -645,10 +645,10 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
                                 u64 addr;
                                 void* p;
                                 if (usg->sg[i].count >
-                                    (dev->adapter_info.options &
+                                    ((dev->adapter_info.options &
                                      AAC_OPT_NEW_COMM) ?
                                       (dev->scsi_host_ptr->max_sectors << 9) :
-                                      65536) {
+                                      65536)) {
                                         rcode = -EINVAL;
                                         goto cleanup;
                                 }
@@ -695,10 +695,10 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
                                 uintptr_t addr;
                                 void* p;
                                 if (usg->sg[i].count >
-                                    (dev->adapter_info.options &
+                                    ((dev->adapter_info.options &
                                      AAC_OPT_NEW_COMM) ?
                                       (dev->scsi_host_ptr->max_sectors << 9) :
-                                      65536) {
+                                      65536)) {
                                         rcode = -EINVAL;
                                         goto cleanup;
                                 }
@@ -734,10 +734,10 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
                                 dma_addr_t addr;
                                 void* p;
                                 if (upsg->sg[i].count >
-                                    (dev->adapter_info.options &
+                                    ((dev->adapter_info.options &
                                      AAC_OPT_NEW_COMM) ?
                                       (dev->scsi_host_ptr->max_sectors << 9) :
-                                      65536) {
+                                      65536)) {
                                         rcode = -EINVAL;
                                         goto cleanup;
                                 }
@@ -772,8 +772,8 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
                 psg->count = cpu_to_le32(sg_indx+1);
                 status = aac_fib_send(ScsiPortCommand, srbfib, actual_fibsize, FsaNormal, 1, 1, NULL, NULL);
         }
-        if (status == -EINTR) {
-                rcode = -EINTR;
+        if (status == -ERESTARTSYS) {
+                rcode = -ERESTARTSYS;
                 goto cleanup;
         }
 
@@ -810,7 +810,7 @@ cleanup:
         for(i=0; i <= sg_indx; i++){
                 kfree(sg_list[i]);
         }
-        if (rcode != -EINTR) {
+        if (rcode != -ERESTARTSYS) {
                 aac_fib_complete(srbfib);
                 aac_fib_free(srbfib);
         }
@@ -848,7 +848,7 @@ int aac_do_ioctl(struct aac_dev * dev, int cmd, void __user *arg)
          */
 
         status = aac_dev_ioctl(dev, cmd, arg);
-        if(status != -ENOTTY)
+        if (status != -ENOTTY)
                 return status;
 
         switch (cmd) {
diff --git a/drivers/scsi/aacraid/comminit.c b/drivers/scsi/aacraid/comminit.c
index 666d5151d628..a7261486ccd4 100644
--- a/drivers/scsi/aacraid/comminit.c
+++ b/drivers/scsi/aacraid/comminit.c
@@ -194,7 +194,9 @@ int aac_send_shutdown(struct aac_dev * dev)
 
         if (status >= 0)
                 aac_fib_complete(fibctx);
-        aac_fib_free(fibctx);
+        /* FIB should be freed only after getting the response from the F/W */
+        if (status != -ERESTARTSYS)
+                aac_fib_free(fibctx);
         return status;
 }
 
@@ -304,6 +306,8 @@ struct aac_dev *aac_init_adapter(struct aac_dev *dev)
         /*
          *      Check the preferred comm settings, defaults from template.
          */
+        dev->management_fib_count = 0;
+        spin_lock_init(&dev->manage_lock);
         dev->max_fib_size = sizeof(struct hw_fib);
         dev->sg_tablesize = host->sg_tablesize = (dev->max_fib_size
                 - sizeof(struct aac_fibhdr)
diff --git a/drivers/scsi/aacraid/commsup.c b/drivers/scsi/aacraid/commsup.c
index 956261f25181..94d2954d79ae 100644
--- a/drivers/scsi/aacraid/commsup.c
+++ b/drivers/scsi/aacraid/commsup.c
@@ -189,7 +189,14 @@ struct fib *aac_fib_alloc(struct aac_dev *dev)
 
 void aac_fib_free(struct fib *fibptr)
 {
-        unsigned long flags;
+        unsigned long flags, flagsv;
+
+        spin_lock_irqsave(&fibptr->event_lock, flagsv);
+        if (fibptr->done == 2) {
+                spin_unlock_irqrestore(&fibptr->event_lock, flagsv);
+                return;
+        }
+        spin_unlock_irqrestore(&fibptr->event_lock, flagsv);
 
         spin_lock_irqsave(&fibptr->dev->fib_lock, flags);
         if (unlikely(fibptr->flags & FIB_CONTEXT_FLAG_TIMED_OUT))
@@ -390,6 +397,8 @@ int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
         struct hw_fib * hw_fib = fibptr->hw_fib_va;
         unsigned long flags = 0;
         unsigned long qflags;
+        unsigned long mflags = 0;
+
 
         if (!(hw_fib->header.XferState & cpu_to_le32(HostOwned)))
                 return -EBUSY;
@@ -471,9 +480,31 @@ int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
         if (!dev->queues)
                 return -EBUSY;
 
-        if(wait)
+        if (wait) {
+
+                spin_lock_irqsave(&dev->manage_lock, mflags);
+                if (dev->management_fib_count >= AAC_NUM_MGT_FIB) {
+                        printk(KERN_INFO "No management Fibs Available:%d\n",
+                                                dev->management_fib_count);
+                        spin_unlock_irqrestore(&dev->manage_lock, mflags);
+                        return -EBUSY;
+                }
+                dev->management_fib_count++;
+                spin_unlock_irqrestore(&dev->manage_lock, mflags);
                 spin_lock_irqsave(&fibptr->event_lock, flags);
-        aac_adapter_deliver(fibptr);
+        }
+
+        if (aac_adapter_deliver(fibptr) != 0) {
+                printk(KERN_ERR "aac_fib_send: returned -EBUSY\n");
+                if (wait) {
+                        spin_unlock_irqrestore(&fibptr->event_lock, flags);
+                        spin_lock_irqsave(&dev->manage_lock, mflags);
+                        dev->management_fib_count--;
+                        spin_unlock_irqrestore(&dev->manage_lock, mflags);
+                }
+                return -EBUSY;
+        }
+
 
         /*
          *      If the caller wanted us to wait for response wait now.
@@ -516,14 +547,15 @@ int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
                                 udelay(5);
                         }
                 } else if (down_interruptible(&fibptr->event_wait)) {
-                        fibptr->done = 2;
-                        up(&fibptr->event_wait);
+                        /* Do nothing ... satisfy
+                         * down_interruptible must_check */
                 }
+
                 spin_lock_irqsave(&fibptr->event_lock, flags);
-                if ((fibptr->done == 0) || (fibptr->done == 2)) {
+                if (fibptr->done == 0) {
                         fibptr->done = 2; /* Tell interrupt we aborted */
                         spin_unlock_irqrestore(&fibptr->event_lock, flags);
-                        return -EINTR;
+                        return -ERESTARTSYS;
                 }
                 spin_unlock_irqrestore(&fibptr->event_lock, flags);
                 BUG_ON(fibptr->done == 0);
@@ -689,6 +721,7 @@ int aac_fib_adapter_complete(struct fib *fibptr, unsigned short size)
 
 int aac_fib_complete(struct fib *fibptr)
 {
+        unsigned long flags;
         struct hw_fib * hw_fib = fibptr->hw_fib_va;
 
         /*
@@ -709,6 +742,13 @@ int aac_fib_complete(struct fib *fibptr)
          *      command is complete that we had sent to the adapter and this
          *      cdb could be reused.
          */
+        spin_lock_irqsave(&fibptr->event_lock, flags);
+        if (fibptr->done == 2) {
+                spin_unlock_irqrestore(&fibptr->event_lock, flags);
+                return 0;
+        }
+        spin_unlock_irqrestore(&fibptr->event_lock, flags);
+
         if((hw_fib->header.XferState & cpu_to_le32(SentFromHost)) &&
                 (hw_fib->header.XferState & cpu_to_le32(AdapterProcessed)))
         {
@@ -1355,7 +1395,10 @@ int aac_reset_adapter(struct aac_dev * aac, int forced)
 
                         if (status >= 0)
                                 aac_fib_complete(fibctx);
-                        aac_fib_free(fibctx);
+                        /* FIB should be freed only after getting
+                         * the response from the F/W */
+                        if (status != -ERESTARTSYS)
+                                aac_fib_free(fibctx);
                 }
         }
 
@@ -1759,6 +1802,7 @@ int aac_command_thread(void *data)
                                 struct fib *fibptr;
 
                                 if ((fibptr = aac_fib_alloc(dev))) {
+                                        int status;
                                         __le32 *info;
 
                                         aac_fib_init(fibptr);
@@ -1769,15 +1813,21 @@ int aac_command_thread(void *data)
 
                                         *info = cpu_to_le32(now.tv_sec);
 
-                                        (void)aac_fib_send(SendHostTime,
+                                        status = aac_fib_send(SendHostTime,
                                                 fibptr,
                                                 sizeof(*info),
                                                 FsaNormal,
                                                 1, 1,
                                                 NULL,
                                                 NULL);
-                                        aac_fib_complete(fibptr);
-                                        aac_fib_free(fibptr);
+                                        /* Do not set XferState to zero unless
+                                         * receives a response from F/W */
+                                        if (status >= 0)
+                                                aac_fib_complete(fibptr);
+                                        /* FIB should be freed only after
+                                         * getting the response from the F/W */
+                                        if (status != -ERESTARTSYS)
+                                                aac_fib_free(fibptr);
                                 }
                                 difference = (long)(unsigned)update_interval*HZ;
                         } else {
diff --git a/drivers/scsi/aacraid/dpcsup.c b/drivers/scsi/aacraid/dpcsup.c
index abc9ef5d1b10..9c7408fe8c7d 100644
--- a/drivers/scsi/aacraid/dpcsup.c
+++ b/drivers/scsi/aacraid/dpcsup.c
@@ -57,9 +57,9 @@ unsigned int aac_response_normal(struct aac_queue * q)
         struct hw_fib * hwfib;
         struct fib * fib;
         int consumed = 0;
-        unsigned long flags;
+        unsigned long flags, mflags;
 
-        spin_lock_irqsave(q->lock, flags);      
+        spin_lock_irqsave(q->lock, flags);
         /*
          *      Keep pulling response QEs off the response queue and waking
          *      up the waiters until there are no more QEs. We then return
@@ -125,12 +125,21 @@ unsigned int aac_response_normal(struct aac_queue * q)
                 } else {
                         unsigned long flagv;
                         spin_lock_irqsave(&fib->event_lock, flagv);
-                        if (!fib->done)
+                        if (!fib->done) {
                                 fib->done = 1;
-                        up(&fib->event_wait);
+                                up(&fib->event_wait);
+                        }
                         spin_unlock_irqrestore(&fib->event_lock, flagv);
+
+                        spin_lock_irqsave(&dev->manage_lock, mflags);
+                        dev->management_fib_count--;
+                        spin_unlock_irqrestore(&dev->manage_lock, mflags);
+
                         FIB_COUNTER_INCREMENT(aac_config.NormalRecved);
                         if (fib->done == 2) {
+                                spin_lock_irqsave(&fib->event_lock, flagv);
+                                fib->done = 0;
+                                spin_unlock_irqrestore(&fib->event_lock, flagv);
                                 aac_fib_complete(fib);
                                 aac_fib_free(fib);
                         }
@@ -232,6 +241,7 @@ unsigned int aac_command_normal(struct aac_queue *q)
 
 unsigned int aac_intr_normal(struct aac_dev * dev, u32 index)
 {
+        unsigned long mflags;
         dprintk((KERN_INFO "aac_intr_normal(%p,%x)\n", dev, index));
         if ((index & 0x00000002L)) {
                 struct hw_fib * hw_fib;
@@ -320,11 +330,25 @@ unsigned int aac_intr_normal(struct aac_dev * dev, u32 index)
                         unsigned long flagv;
                         dprintk((KERN_INFO "event_wait up\n"));
                         spin_lock_irqsave(&fib->event_lock, flagv);
-                        if (!fib->done)
+                        if (!fib->done) {
                                 fib->done = 1;
-                        up(&fib->event_wait);
+                                up(&fib->event_wait);
+                        }
                         spin_unlock_irqrestore(&fib->event_lock, flagv);
+
+                        spin_lock_irqsave(&dev->manage_lock, mflags);
+                        dev->management_fib_count--;
+                        spin_unlock_irqrestore(&dev->manage_lock, mflags);
+
                         FIB_COUNTER_INCREMENT(aac_config.NormalRecved);
+                        if (fib->done == 2) {
+                                spin_lock_irqsave(&fib->event_lock, flagv);
+                                fib->done = 0;
+                                spin_unlock_irqrestore(&fib->event_lock, flagv);
+                                aac_fib_complete(fib);
+                                aac_fib_free(fib);
+                        }
+
                 }
                 return 0;
         }
diff --git a/drivers/scsi/aic7xxx/aic79xx_core.c b/drivers/scsi/aic7xxx/aic79xx_core.c
index 4d419c155ce9..78971db5b60e 100644
--- a/drivers/scsi/aic7xxx/aic79xx_core.c
+++ b/drivers/scsi/aic7xxx/aic79xx_core.c
@@ -3171,13 +3171,16 @@ ahd_handle_nonpkt_busfree(struct ahd_softc *ahd)
                                 tinfo->curr.transport_version = 2;
                                 tinfo->goal.transport_version = 2;
                                 tinfo->goal.ppr_options = 0;
-                                /*
-                                 * Remove any SCBs in the waiting for selection
-                                 * queue that may also be for this target so
-                                 * that command ordering is preserved.
-                                 */
-                                ahd_freeze_devq(ahd, scb);
-                                ahd_qinfifo_requeue_tail(ahd, scb);
+                                if (scb != NULL) {
+                                        /*
+                                         * Remove any SCBs in the waiting
+                                         * for selection queue that may
+                                         * also be for this target so that
+                                         * command ordering is preserved.
+                                         */
+                                        ahd_freeze_devq(ahd, scb);
+                                        ahd_qinfifo_requeue_tail(ahd, scb);
+                                }
                                 printerror = 0;
                         }
                 } else if (ahd_sent_msg(ahd, AHDMSG_EXT, MSG_EXT_WDTR, FALSE)
@@ -3194,13 +3197,16 @@ ahd_handle_nonpkt_busfree(struct ahd_softc *ahd)
                                       MSG_EXT_WDTR_BUS_8_BIT,
                                       AHD_TRANS_CUR|AHD_TRANS_GOAL,
                                       /*paused*/TRUE);
-                        /*
-                         * Remove any SCBs in the waiting for selection
-                         * queue that may also be for this target so that
-                         * command ordering is preserved.
-                         */
-                        ahd_freeze_devq(ahd, scb);
-                        ahd_qinfifo_requeue_tail(ahd, scb);
+                        if (scb != NULL) {
+                                /*
+                                 * Remove any SCBs in the waiting for
+                                 * selection queue that may also be for
+                                 * this target so that command ordering
+                                 * is preserved.
+                                 */
+                                ahd_freeze_devq(ahd, scb);
+                                ahd_qinfifo_requeue_tail(ahd, scb);
+                        }
                         printerror = 0;
                 } else if (ahd_sent_msg(ahd, AHDMSG_EXT, MSG_EXT_SDTR, FALSE)
                         && ppr_busfree == 0) {
@@ -3217,13 +3223,16 @@ ahd_handle_nonpkt_busfree(struct ahd_softc *ahd)
                                         /*ppr_options*/0,
                                         AHD_TRANS_CUR|AHD_TRANS_GOAL,
                                         /*paused*/TRUE);
-                        /*
-                         * Remove any SCBs in the waiting for selection
-                         * queue that may also be for this target so that
-                         * command ordering is preserved.
-                         */
-                        ahd_freeze_devq(ahd, scb);
-                        ahd_qinfifo_requeue_tail(ahd, scb);
+                        if (scb != NULL) {
+                                /*
+                                 * Remove any SCBs in the waiting for
+                                 * selection queue that may also be for
+                                 * this target so that command ordering
+                                 * is preserved.
+                                 */
+                                ahd_freeze_devq(ahd, scb);
+                                ahd_qinfifo_requeue_tail(ahd, scb);
+                        }
                         printerror = 0;
                 } else if ((ahd->msg_flags & MSG_FLAG_EXPECT_IDE_BUSFREE) != 0
                         && ahd_sent_msg(ahd, AHDMSG_1B,
@@ -3251,7 +3260,7 @@ ahd_handle_nonpkt_busfree(struct ahd_softc *ahd)
          * the message phases.  We check it last in case we
          * had to send some other message that caused a busfree.
          */
-        if (printerror != 0
+        if (scb != NULL && printerror != 0
          && (lastphase == P_MESGIN || lastphase == P_MESGOUT)
          && ((ahd->msg_flags & MSG_FLAG_EXPECT_PPR_BUSFREE) != 0)) {
 
diff --git a/drivers/scsi/arm/fas216.c b/drivers/scsi/arm/fas216.c
index 477542602284..9e71ac611146 100644
--- a/drivers/scsi/arm/fas216.c
+++ b/drivers/scsi/arm/fas216.c
@@ -2516,7 +2516,7 @@ int fas216_eh_device_reset(struct scsi_cmnd *SCpnt)
                 if (info->scsi.phase == PHASE_IDLE)
                         fas216_kick(info);
 
-                mod_timer(&info->eh_timer, 30 * HZ);
+                mod_timer(&info->eh_timer, jiffies + 30 * HZ);
                 spin_unlock_irqrestore(&info->host_lock, flags);
 
                 /*
diff --git a/drivers/scsi/fcoe/fcoe.c b/drivers/scsi/fcoe/fcoe.c
index 10be9f36a4cc..2f47ae7cce91 100644
--- a/drivers/scsi/fcoe/fcoe.c
+++ b/drivers/scsi/fcoe/fcoe.c
@@ -2009,6 +2009,8 @@ static int fcoe_destroy(const char *buffer, struct kernel_param *kp)
         fcoe_interface_cleanup(fcoe);
         rtnl_unlock();
         fcoe_if_destroy(fcoe->ctlr.lp);
+        module_put(THIS_MODULE);
+
 out_putdev:
         dev_put(netdev);
 out_nodev:
@@ -2059,6 +2061,11 @@ static int fcoe_create(const char *buffer, struct kernel_param *kp)
         }
 #endif
 
+        if (!try_module_get(THIS_MODULE)) {
+                rc = -EINVAL;
+                goto out_nomod;
+        }
+
         rtnl_lock();
         netdev = fcoe_if_to_netdev(buffer);
         if (!netdev) {
@@ -2099,17 +2106,24 @@ static int fcoe_create(const char *buffer, struct kernel_param *kp)
         if (!fcoe_link_ok(lport))
                 fcoe_ctlr_link_up(&fcoe->ctlr);
 
-        rc = 0;
-out_free:
         /*
          * Release from init in fcoe_interface_create(), on success lport
          * should be holding a reference taken in fcoe_if_create().
          */
         fcoe_interface_put(fcoe);
+        dev_put(netdev);
+        rtnl_unlock();
+        mutex_unlock(&fcoe_config_mutex);
+
+        return 0;
+out_free:
+        fcoe_interface_put(fcoe);
 out_putdev:
         dev_put(netdev);
 out_nodev:
         rtnl_unlock();
+        module_put(THIS_MODULE);
+out_nomod:
         mutex_unlock(&fcoe_config_mutex);
         return rc;
 }
diff --git a/drivers/scsi/fcoe/libfcoe.c b/drivers/scsi/fcoe/libfcoe.c
index 9823291395ad..511cb6b371ee 100644
--- a/drivers/scsi/fcoe/libfcoe.c
+++ b/drivers/scsi/fcoe/libfcoe.c
@@ -1187,7 +1187,7 @@ static void fcoe_ctlr_timeout(unsigned long arg)
                         next_timer = fip->ctlr_ka_time;
 
                 if (time_after_eq(jiffies, fip->port_ka_time)) {
-                        fip->port_ka_time += jiffies +
+                        fip->port_ka_time = jiffies +
                                 msecs_to_jiffies(FIP_VN_KA_PERIOD);
                         fip->send_port_ka = 1;
                 }
diff --git a/drivers/scsi/libfc/fc_exch.c b/drivers/scsi/libfc/fc_exch.c
index 19d711cb938c..7f4364770e4a 100644
--- a/drivers/scsi/libfc/fc_exch.c
+++ b/drivers/scsi/libfc/fc_exch.c
@@ -1890,7 +1890,7 @@ static struct fc_seq *fc_exch_seq_send(struct fc_lport *lport,
         fc_exch_setup_hdr(ep, fp, ep->f_ctl);
         sp->cnt++;
 
-        if (ep->xid <= lport->lro_xid)
+        if (ep->xid <= lport->lro_xid && fh->fh_r_ctl == FC_RCTL_DD_UNSOL_CMD)
                 fc_fcp_ddp_setup(fr_fsp(fp), ep->xid);
 
         if (unlikely(lport->tt.frame_send(lport, fp)))
diff --git a/drivers/scsi/libfc/fc_fcp.c b/drivers/scsi/libfc/fc_fcp.c
index 881d5dfe8c74..6fde2fabfd9b 100644
--- a/drivers/scsi/libfc/fc_fcp.c
+++ b/drivers/scsi/libfc/fc_fcp.c
@@ -298,9 +298,6 @@ void fc_fcp_ddp_setup(struct fc_fcp_pkt *fsp, u16 xid)
 {
         struct fc_lport *lport;
 
-        if (!fsp)
-                return;
-
         lport = fsp->lp;
         if ((fsp->req_flags & FC_SRB_READ) &&
             (lport->lro_enabled) && (lport->tt.ddp_setup)) {
diff --git a/drivers/scsi/libfc/fc_lport.c b/drivers/scsi/libfc/fc_lport.c
index 0b165024a219..7ec8ce75007c 100644
--- a/drivers/scsi/libfc/fc_lport.c
+++ b/drivers/scsi/libfc/fc_lport.c
@@ -1800,7 +1800,8 @@ int fc_lport_bsg_request(struct fc_bsg_job *job)
         u32 did;
 
         job->reply->reply_payload_rcv_len = 0;
-        rsp->resid_len = job->reply_payload.payload_len;
+        if (rsp)
+                rsp->resid_len = job->reply_payload.payload_len;
 
         mutex_lock(&lport->lp_mutex);
 
diff --git a/drivers/scsi/libfc/fc_rport.c b/drivers/scsi/libfc/fc_rport.c
index 02300523b234..97923bb07765 100644
--- a/drivers/scsi/libfc/fc_rport.c
+++ b/drivers/scsi/libfc/fc_rport.c
@@ -623,7 +623,7 @@ static void fc_rport_plogi_resp(struct fc_seq *sp, struct fc_frame *fp,
 
                 tov = ntohl(plp->fl_csp.sp_e_d_tov);
                 if (ntohs(plp->fl_csp.sp_features) & FC_SP_FT_EDTR)
-                        tov /= 1000;
+                        tov /= 1000000;
                 if (tov > rdata->e_d_tov)
                         rdata->e_d_tov = tov;
                 csp_seq = ntohs(plp->fl_csp.sp_tot_seq);
diff --git a/drivers/scsi/libiscsi_tcp.c b/drivers/scsi/libiscsi_tcp.c
index db6856c138fc..4ad87fd74ddd 100644
--- a/drivers/scsi/libiscsi_tcp.c
+++ b/drivers/scsi/libiscsi_tcp.c
@@ -992,12 +992,10 @@ static struct iscsi_r2t_info *iscsi_tcp_get_curr_r2t(struct iscsi_task *task)
                 if (r2t == NULL) {
                         if (kfifo_out(&tcp_task->r2tqueue,
                             (void *)&tcp_task->r2t, sizeof(void *)) !=
-                            sizeof(void *)) {
-                                WARN_ONCE(1, "unexpected fifo state");
+                            sizeof(void *))
                                 r2t = NULL;
-                        }
-
-                        r2t = tcp_task->r2t;
+                        else
+                                r2t = tcp_task->r2t;
                 }
                 spin_unlock_bh(&session->lock);
         }
diff --git a/drivers/scsi/lpfc/lpfc_hbadisc.c b/drivers/scsi/lpfc/lpfc_hbadisc.c
index 2445e399fd60..2445e399fd60 100755..100644
--- a/drivers/scsi/lpfc/lpfc_hbadisc.c
+++ b/drivers/scsi/lpfc/lpfc_hbadisc.c
diff --git a/drivers/scsi/lpfc/lpfc_hw4.h b/drivers/scsi/lpfc/lpfc_hw4.h
index 8a2a1c5935c6..8a2a1c5935c6 100755..100644
--- a/drivers/scsi/lpfc/lpfc_hw4.h
+++ b/drivers/scsi/lpfc/lpfc_hw4.h
diff --git a/drivers/scsi/megaraid/megaraid_sas.c b/drivers/scsi/megaraid/megaraid_sas.c
index 708ea3157b60..d9b8ca5116bc 100644
--- a/drivers/scsi/megaraid/megaraid_sas.c
+++ b/drivers/scsi/megaraid/megaraid_sas.c
@@ -3781,6 +3781,7 @@ static int megasas_mgmt_compat_ioctl_fw(struct file *file, unsigned long arg)
             compat_alloc_user_space(sizeof(struct megasas_iocpacket));
         int i;
         int error = 0;
+        compat_uptr_t ptr;
 
         if (clear_user(ioc, sizeof(*ioc)))
                 return -EFAULT;
@@ -3793,9 +3794,22 @@ static int megasas_mgmt_compat_ioctl_fw(struct file *file, unsigned long arg)
             copy_in_user(&ioc->sge_count, &cioc->sge_count, sizeof(u32)))
                 return -EFAULT;
 
-        for (i = 0; i < MAX_IOCTL_SGE; i++) {
-                compat_uptr_t ptr;
+        /*
+         * The sense_ptr is used in megasas_mgmt_fw_ioctl only when
+         * sense_len is not null, so prepare the 64bit value under
+         * the same condition.
+         */
+        if (ioc->sense_len) {
+                void __user **sense_ioc_ptr =
+                        (void __user **)(ioc->frame.raw + ioc->sense_off);
+                compat_uptr_t *sense_cioc_ptr =
+                        (compat_uptr_t *)(cioc->frame.raw + cioc->sense_off);
+                if (get_user(ptr, sense_cioc_ptr) ||
+                    put_user(compat_ptr(ptr), sense_ioc_ptr))
+                        return -EFAULT;
+        }
 
+        for (i = 0; i < MAX_IOCTL_SGE; i++) {
                 if (get_user(ptr, &cioc->sgl[i].iov_base) ||
                     put_user(compat_ptr(ptr), &ioc->sgl[i].iov_base) ||
                     copy_in_user(&ioc->sgl[i].iov_len,
diff --git a/drivers/scsi/qla2xxx/qla_def.h b/drivers/scsi/qla2xxx/qla_def.h
index 608e675f68c8..1263d9796e89 100644
--- a/drivers/scsi/qla2xxx/qla_def.h
+++ b/drivers/scsi/qla2xxx/qla_def.h
@@ -1586,8 +1586,7 @@ typedef struct fc_port {
  */
 #define FCF_FABRIC_DEVICE       BIT_0
 #define FCF_LOGIN_NEEDED        BIT_1
-#define FCF_TAPE_PRESENT        BIT_2
-#define FCF_FCP2_DEVICE         BIT_3
+#define FCF_FCP2_DEVICE         BIT_2
 
 /* No loop ID flag. */
 #define FC_NO_LOOP_ID           0x1000
diff --git a/drivers/scsi/qla2xxx/qla_gbl.h b/drivers/scsi/qla2xxx/qla_gbl.h
index f61fb8d01330..8bc6f53691e9 100644
--- a/drivers/scsi/qla2xxx/qla_gbl.h
+++ b/drivers/scsi/qla2xxx/qla_gbl.h
@@ -453,6 +453,5 @@ extern void qla24xx_wrt_req_reg(struct qla_hw_data *, uint16_t, uint16_t);
 extern void qla25xx_wrt_req_reg(struct qla_hw_data *, uint16_t, uint16_t);
 extern void qla25xx_wrt_rsp_reg(struct qla_hw_data *, uint16_t, uint16_t);
 extern void qla24xx_wrt_rsp_reg(struct qla_hw_data *, uint16_t, uint16_t);
-extern struct scsi_qla_host * qla25xx_get_host(struct rsp_que *);
 
 #endif /* _QLA_GBL_H */
diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
index b4a0eac8f96d..3f8e8495b743 100644
--- a/drivers/scsi/qla2xxx/qla_init.c
+++ b/drivers/scsi/qla2xxx/qla_init.c
@@ -205,7 +205,7 @@ qla2x00_async_login_done(struct scsi_qla_host *vha, fc_port_t *fcport,
 
         switch (data[0]) {
         case MBS_COMMAND_COMPLETE:
-                if (fcport->flags & FCF_TAPE_PRESENT)
+                if (fcport->flags & FCF_FCP2_DEVICE)
                         opts |= BIT_1;
                 rval = qla2x00_get_port_database(vha, fcport, opts);
                 if (rval != QLA_SUCCESS)
@@ -2726,7 +2726,7 @@ qla2x00_configure_fabric(scsi_qla_host_t *vha)
 
                 /*
                  * Logout all previous fabric devices marked lost, except
-                 * tape devices.
+                 * FCP2 devices.
                  */
                 list_for_each_entry(fcport, &vha->vp_fcports, list) {
                         if (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags))
@@ -2739,7 +2739,7 @@ qla2x00_configure_fabric(scsi_qla_host_t *vha)
                                 qla2x00_mark_device_lost(vha, fcport,
                                     ql2xplogiabsentdevice, 0);
                                 if (fcport->loop_id != FC_NO_LOOP_ID &&
-                                    (fcport->flags & FCF_TAPE_PRESENT) == 0 &&
+                                    (fcport->flags & FCF_FCP2_DEVICE) == 0 &&
                                     fcport->port_type != FCT_INITIATOR &&
                                     fcport->port_type != FCT_BROADCAST) {
                                         ha->isp_ops->fabric_logout(vha,
@@ -3018,7 +3018,7 @@ qla2x00_find_all_fabric_devs(scsi_qla_host_t *vha,
                         fcport->d_id.b24 = new_fcport->d_id.b24;
                         fcport->flags |= FCF_LOGIN_NEEDED;
                         if (fcport->loop_id != FC_NO_LOOP_ID &&
-                            (fcport->flags & FCF_TAPE_PRESENT) == 0 &&
+                            (fcport->flags & FCF_FCP2_DEVICE) == 0 &&
                             fcport->port_type != FCT_INITIATOR &&
                             fcport->port_type != FCT_BROADCAST) {
                                 ha->isp_ops->fabric_logout(vha, fcport->loop_id,
@@ -3272,9 +3272,9 @@ qla2x00_fabric_dev_login(scsi_qla_host_t *vha, fc_port_t *fcport,
 
         rval = qla2x00_fabric_login(vha, fcport, next_loopid);
         if (rval == QLA_SUCCESS) {
-                /* Send an ADISC to tape devices.*/
+                /* Send an ADISC to FCP2 devices.*/
                 opts = 0;
-                if (fcport->flags & FCF_TAPE_PRESENT)
+                if (fcport->flags & FCF_FCP2_DEVICE)
                         opts |= BIT_1;
                 rval = qla2x00_get_port_database(vha, fcport, opts);
                 if (rval != QLA_SUCCESS) {
diff --git a/drivers/scsi/qla2xxx/qla_isr.c b/drivers/scsi/qla2xxx/qla_isr.c
index ffd0efdff40e..6fc63b98818c 100644
--- a/drivers/scsi/qla2xxx/qla_isr.c
+++ b/drivers/scsi/qla2xxx/qla_isr.c
@@ -1917,6 +1917,7 @@ qla24xx_msix_rsp_q(int irq, void *dev_id)
         struct rsp_que *rsp;
         struct device_reg_24xx __iomem *reg;
         struct scsi_qla_host *vha;
+        unsigned long flags;
 
         rsp = (struct rsp_que *) dev_id;
         if (!rsp) {
@@ -1927,15 +1928,15 @@ qla24xx_msix_rsp_q(int irq, void *dev_id)
         ha = rsp->hw;
         reg = &ha->iobase->isp24;
 
-        spin_lock_irq(&ha->hardware_lock);
+        spin_lock_irqsave(&ha->hardware_lock, flags);
 
-        vha = qla25xx_get_host(rsp);
+        vha = pci_get_drvdata(ha->pdev);
         qla24xx_process_response_queue(vha, rsp);
         if (!ha->flags.disable_msix_handshake) {
                 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
                 RD_REG_DWORD_RELAXED(&reg->hccr);
         }
-        spin_unlock_irq(&ha->hardware_lock);
+        spin_unlock_irqrestore(&ha->hardware_lock, flags);
 
         return IRQ_HANDLED;
 }
@@ -1946,6 +1947,7 @@ qla25xx_msix_rsp_q(int irq, void *dev_id)
         struct qla_hw_data *ha;
         struct rsp_que *rsp;
         struct device_reg_24xx __iomem *reg;
+        unsigned long flags;
 
         rsp = (struct rsp_que *) dev_id;
         if (!rsp) {
@@ -1958,10 +1960,10 @@ qla25xx_msix_rsp_q(int irq, void *dev_id)
         /* Clear the interrupt, if enabled, for this response queue */
         if (rsp->options & ~BIT_6) {
                 reg = &ha->iobase->isp24;
-                spin_lock_irq(&ha->hardware_lock);
+                spin_lock_irqsave(&ha->hardware_lock, flags);
                 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
                 RD_REG_DWORD_RELAXED(&reg->hccr);
-                spin_unlock_irq(&ha->hardware_lock);
+                spin_unlock_irqrestore(&ha->hardware_lock, flags);
         }
         queue_work_on((int) (rsp->id - 1), ha->wq, &rsp->q_work);
 
@@ -1979,6 +1981,7 @@ qla24xx_msix_default(int irq, void *dev_id)
         uint32_t        stat;
         uint32_t        hccr;
         uint16_t        mb[4];
+        unsigned long flags;
 
         rsp = (struct rsp_que *) dev_id;
         if (!rsp) {
@@ -1990,7 +1993,7 @@ qla24xx_msix_default(int irq, void *dev_id)
         reg = &ha->iobase->isp24;
         status = 0;
 
-        spin_lock_irq(&ha->hardware_lock);
+        spin_lock_irqsave(&ha->hardware_lock, flags);
         vha = pci_get_drvdata(ha->pdev);
         do {
                 stat = RD_REG_DWORD(&reg->host_status);
@@ -2039,7 +2042,7 @@ qla24xx_msix_default(int irq, void *dev_id)
                 }
                 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
         } while (0);
-        spin_unlock_irq(&ha->hardware_lock);
+        spin_unlock_irqrestore(&ha->hardware_lock, flags);
 
         if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
             (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
@@ -2277,30 +2280,3 @@ int qla25xx_request_irq(struct rsp_que *rsp)
         msix->rsp = rsp;
         return ret;
 }
-
-struct scsi_qla_host *
-qla25xx_get_host(struct rsp_que *rsp)
-{
-        srb_t *sp;
-        struct qla_hw_data *ha = rsp->hw;
-        struct scsi_qla_host *vha = NULL;
-        struct sts_entry_24xx *pkt;
-        struct req_que *req;
-        uint16_t que;
-        uint32_t handle;
-
-        pkt = (struct sts_entry_24xx *) rsp->ring_ptr;
-        que = MSW(pkt->handle);
-        handle = (uint32_t) LSW(pkt->handle);
-        req = ha->req_q_map[que];
-        if (handle < MAX_OUTSTANDING_COMMANDS) {
-                sp = req->outstanding_cmds[handle];
-                if (sp)
-                        return  sp->fcport->vha;
-                else
-                        goto base_que;
-        }
-base_que:
-        vha = pci_get_drvdata(ha->pdev);
-        return vha;
-}
diff --git a/drivers/scsi/qla2xxx/qla_mid.c b/drivers/scsi/qla2xxx/qla_mid.c
index b901aa267e7d..ff17dee28613 100644
--- a/drivers/scsi/qla2xxx/qla_mid.c
+++ b/drivers/scsi/qla2xxx/qla_mid.c
@@ -636,13 +636,15 @@ failed:
 
 static void qla_do_work(struct work_struct *work)
 {
+        unsigned long flags;
         struct rsp_que *rsp = container_of(work, struct rsp_que, q_work);
         struct scsi_qla_host *vha;
+        struct qla_hw_data *ha = rsp->hw;
 
-        spin_lock_irq(&rsp->hw->hardware_lock);
-        vha = qla25xx_get_host(rsp);
+        spin_lock_irqsave(&rsp->hw->hardware_lock, flags);
+        vha = pci_get_drvdata(ha->pdev);
         qla24xx_process_response_queue(vha, rsp);
-        spin_unlock_irq(&rsp->hw->hardware_lock);
+        spin_unlock_irqrestore(&rsp->hw->hardware_lock, flags);
 }
 
 /* create response queue */
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index 209f50e788a1..8529eb1f3cd4 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -1188,7 +1188,6 @@ qla2xxx_slave_configure(struct scsi_device *sdev)
         scsi_qla_host_t *vha = shost_priv(sdev->host);
         struct qla_hw_data *ha = vha->hw;
         struct fc_rport *rport = starget_to_rport(sdev->sdev_target);
-        fc_port_t *fcport = *(fc_port_t **)rport->dd_data;
         struct req_que *req = vha->req;
 
         if (sdev->tagged_supported)
@@ -1197,8 +1196,6 @@ qla2xxx_slave_configure(struct scsi_device *sdev)
                 scsi_deactivate_tcq(sdev, req->max_q_depth);
 
         rport->dev_loss_tmo = ha->port_down_retry_count;
-        if (sdev->type == TYPE_TAPE)
-                fcport->flags |= FCF_TAPE_PRESENT;
 
         return 0;
 }
@@ -2805,7 +2802,7 @@ void qla2x00_relogin(struct scsi_qla_host *vha)
 
                         fcport->login_retry--;
                         if (fcport->flags & FCF_FABRIC_DEVICE) {
-                                if (fcport->flags & FCF_TAPE_PRESENT)
+                                if (fcport->flags & FCF_FCP2_DEVICE)
                                         ha->isp_ops->fabric_logout(vha,
                                                         fcport->loop_id,
                                                         fcport->d_id.b.domain,
@@ -3141,7 +3138,10 @@ qla2x00_timer(scsi_qla_host_t *vha)
                         if (!IS_QLA2100(ha) && vha->link_down_timeout)
                                 atomic_set(&vha->loop_state, LOOP_DEAD);
 
-                        /* Schedule an ISP abort to return any tape commands. */
+                        /*
+                         * Schedule an ISP abort to return any FCP2-device
+                         * commands.
+                         */
                         /* NPIV - scan physical port only */
                         if (!vha->vp_idx) {
                                 spin_lock_irqsave(&ha->hardware_lock,
@@ -3158,7 +3158,7 @@ qla2x00_timer(scsi_qla_host_t *vha)
                                         if (sp->ctx)
                                                 continue;
                                         sfcp = sp->fcport;
-                                        if (!(sfcp->flags & FCF_TAPE_PRESENT))
+                                        if (!(sfcp->flags & FCF_FCP2_DEVICE))
                                                 continue;
 
                                         set_bit(ISP_ABORT_NEEDED,
diff --git a/drivers/scsi/qla2xxx/qla_sup.c b/drivers/scsi/qla2xxx/qla_sup.c
index 010e69b29afe..371dc895972a 100644
--- a/drivers/scsi/qla2xxx/qla_sup.c
+++ b/drivers/scsi/qla2xxx/qla_sup.c
@@ -2292,11 +2292,14 @@ qla25xx_read_optrom_data(struct scsi_qla_host *vha, uint8_t *buf,
         uint32_t faddr, left, burst;
         struct qla_hw_data *ha = vha->hw;
 
+        if (IS_QLA25XX(ha) || IS_QLA81XX(ha))
+                goto try_fast;
         if (offset & 0xfff)
                 goto slow_read;
         if (length < OPTROM_BURST_SIZE)
                 goto slow_read;
 
+try_fast:
         optrom = dma_alloc_coherent(&ha->pdev->dev, OPTROM_BURST_SIZE,
             &optrom_dma, GFP_KERNEL);
         if (!optrom) {
diff --git a/drivers/scsi/qla2xxx/qla_version.h b/drivers/scsi/qla2xxx/qla_version.h
index a65dd95507c6..ed36279a33c1 100644
--- a/drivers/scsi/qla2xxx/qla_version.h
+++ b/drivers/scsi/qla2xxx/qla_version.h
@@ -7,7 +7,7 @@
 /*
  * Driver version
  */
-#define QLA2XXX_VERSION      "8.03.01-k9"
+#define QLA2XXX_VERSION      "8.03.01-k10"
 
 #define QLA_DRIVER_MAJOR_VER    8
 #define QLA_DRIVER_MINOR_VER    3
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index d8927681ec88..c6642423cc67 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -749,9 +749,9 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
                          */
                         req->next_rq->resid_len = scsi_in(cmd)->resid;
 
+                        scsi_release_buffers(cmd);
                         blk_end_request_all(req, 0);
 
-                        scsi_release_buffers(cmd);
                         scsi_next_command(cmd);
                         return;
                 }
diff --git a/drivers/scsi/scsi_transport_fc.c b/drivers/scsi/scsi_transport_fc.c
index ddfcecd5099f..653f22a8deb9 100644
--- a/drivers/scsi/scsi_transport_fc.c
+++ b/drivers/scsi/scsi_transport_fc.c
@@ -3527,7 +3527,10 @@ fc_bsg_job_timeout(struct request *req)
         if (!done && i->f->bsg_timeout) {
                 /* call LLDD to abort the i/o as it has timed out */
                 err = i->f->bsg_timeout(job);
-                if (err)
+                if (err == -EAGAIN) {
+                        job->ref_cnt--;
+                        return BLK_EH_RESET_TIMER;
+                } else if (err)
                         printk(KERN_ERR "ERROR: FC BSG request timeout - LLD "
                                 "abort failed with status %d\n", err);
         }