scsi: don't set tagging state from scsi_adjust_queue_depth

Remove the tagged argument from scsi_adjust_queue_depth, and just let it
handle the queue depth.  For most drivers those two are fairly separate,
given that most modern drivers don't care about the SCSI "tagged" status
of a command at all, and many old drivers allow queuing of multiple
untagged commands in the driver.

Instead we start out with the ->simple_tags flag set before calling
->slave_configure, which is how all drivers actually looking at
->simple_tags except for one worke anyway.  The one other case looks
broken, but I've kept the behavior as-is for now.

Except for that we only change ->simple_tags from the ->change_queue_type,
and when rejecting a tag message in a single driver, so keeping this
churn out of scsi_adjust_queue_depth is a clear win.

Now that the usage of scsi_adjust_queue_depth is more obvious we can
also remove all the trivial instances in ->slave_alloc or ->slave_configure
that just set it to the cmd_per_lun default.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Mike Christie <michaelc@cs.wisc.edu>
Reviewed-by: Hannes Reinecke <hare@suse.de>
Reviewed-by: Martin K. Petersen <martin.petersen@oracle.com>

55 files changed, 115 insertions, 251 deletions

diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index 0586f66d70fa..c8bb6abbf12c 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -1164,7 +1164,7 @@ static int ata_scsi_dev_config(struct scsi_device *sdev,
 
                 depth = min(sdev->host->can_queue, ata_id_queue_depth(dev->id));
                 depth = min(ATA_MAX_QUEUE - 1, depth);
-                scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
+                scsi_adjust_queue_depth(sdev, depth);
         }
 
         blk_queue_flush_queueable(q, false);
@@ -1282,7 +1282,7 @@ int __ata_change_queue_depth(struct ata_port *ap, struct scsi_device *sdev,
         if (sdev->queue_depth == queue_depth)
                 return -EINVAL;
 
-        scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, queue_depth);
+        scsi_adjust_queue_depth(sdev, queue_depth);
         return queue_depth;
 }
 
diff --git a/drivers/infiniband/ulp/srp/ib_srp.c b/drivers/infiniband/ulp/srp/ib_srp.c
index 51670d75ab78..023a66f5ca14 100644
--- a/drivers/infiniband/ulp/srp/ib_srp.c
+++ b/drivers/infiniband/ulp/srp/ib_srp.c
@@ -2278,7 +2278,7 @@ srp_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
                         max_depth = 1;
                 if (qdepth > max_depth)
                         qdepth = max_depth;
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
+                scsi_adjust_queue_depth(sdev, qdepth);
         } else if (reason == SCSI_QDEPTH_QFULL)
                 scsi_track_queue_full(sdev, qdepth);
         else
diff --git a/drivers/message/fusion/mptscsih.c b/drivers/message/fusion/mptscsih.c
index c0d84a09db9a..dee06d6f0b68 100644
--- a/drivers/message/fusion/mptscsih.c
+++ b/drivers/message/fusion/mptscsih.c
@@ -2347,7 +2347,7 @@ mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
         if (qdepth > max_depth)
                 qdepth = max_depth;
 
-        scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
+        scsi_adjust_queue_depth(sdev, qdepth);
         return sdev->queue_depth;
 }
 
diff --git a/drivers/s390/scsi/zfcp_scsi.c b/drivers/s390/scsi/zfcp_scsi.c
index 7b353647cb90..b5dfa51f396f 100644
--- a/drivers/s390/scsi/zfcp_scsi.c
+++ b/drivers/s390/scsi/zfcp_scsi.c
@@ -37,13 +37,13 @@ static int zfcp_scsi_change_queue_depth(struct scsi_device *sdev, int depth,
 {
         switch (reason) {
         case SCSI_QDEPTH_DEFAULT:
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
+                scsi_adjust_queue_depth(sdev, depth);
                 break;
         case SCSI_QDEPTH_QFULL:
                 scsi_track_queue_full(sdev, depth);
                 break;
         case SCSI_QDEPTH_RAMP_UP:
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
+                scsi_adjust_queue_depth(sdev, depth);
                 break;
         default:
                 return -EOPNOTSUPP;
@@ -66,9 +66,7 @@ static void zfcp_scsi_slave_destroy(struct scsi_device *sdev)
 static int zfcp_scsi_slave_configure(struct scsi_device *sdp)
 {
         if (sdp->tagged_supported)
-                scsi_adjust_queue_depth(sdp, MSG_SIMPLE_TAG, default_depth);
-        else
-                scsi_adjust_queue_depth(sdp, 0, 1);
+                scsi_adjust_queue_depth(sdp, default_depth);
         return 0;
 }
 
diff --git a/drivers/scsi/3w-9xxx.c b/drivers/scsi/3w-9xxx.c
index 0a7325361d29..02021f5ca866 100644
--- a/drivers/scsi/3w-9xxx.c
+++ b/drivers/scsi/3w-9xxx.c
@@ -198,7 +198,7 @@ static int twa_change_queue_depth(struct scsi_device *sdev, int queue_depth,
 
         if (queue_depth > TW_Q_LENGTH-2)
                 queue_depth = TW_Q_LENGTH-2;
-        scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
+        scsi_adjust_queue_depth(sdev, queue_depth);
         return queue_depth;
 } /* End twa_change_queue_depth() */
 
diff --git a/drivers/scsi/3w-sas.c b/drivers/scsi/3w-sas.c
index 6da6cec9a651..ac0c2544a470 100644
--- a/drivers/scsi/3w-sas.c
+++ b/drivers/scsi/3w-sas.c
@@ -200,7 +200,7 @@ static int twl_change_queue_depth(struct scsi_device *sdev, int queue_depth,
 
         if (queue_depth > TW_Q_LENGTH-2)
                 queue_depth = TW_Q_LENGTH-2;
-        scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
+        scsi_adjust_queue_depth(sdev, queue_depth);
         return queue_depth;
 } /* End twl_change_queue_depth() */
 
diff --git a/drivers/scsi/3w-xxxx.c b/drivers/scsi/3w-xxxx.c
index 752624e6bc00..1ec9ad92b6c3 100644
--- a/drivers/scsi/3w-xxxx.c
+++ b/drivers/scsi/3w-xxxx.c
@@ -532,7 +532,7 @@ static int tw_change_queue_depth(struct scsi_device *sdev, int queue_depth,
 
         if (queue_depth > TW_Q_LENGTH-2)
                 queue_depth = TW_Q_LENGTH-2;
-        scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
+        scsi_adjust_queue_depth(sdev, queue_depth);
         return queue_depth;
 } /* End tw_change_queue_depth() */
 
diff --git a/drivers/scsi/53c700.c b/drivers/scsi/53c700.c
index 497cbb1efd4b..d7557b932113 100644
--- a/drivers/scsi/53c700.c
+++ b/drivers/scsi/53c700.c
@@ -902,8 +902,10 @@ process_message(struct Scsi_Host *host,	struct NCR_700_Host_Parameters *hostdata
                         /* we're done negotiating */
                         NCR_700_set_tag_neg_state(SCp->device, NCR_700_FINISHED_TAG_NEGOTIATION);
                         hostdata->tag_negotiated &= ~(1<<scmd_id(SCp));
+
                         SCp->device->tagged_supported = 0;
-                        scsi_adjust_queue_depth(SCp->device, 0, host->cmd_per_lun);
+                        scsi_adjust_queue_depth(SCp->device, host->cmd_per_lun);
+                        scsi_set_tag_type(SCp->device, 0);
                 } else {
                         shost_printk(KERN_WARNING, host,
                                 "(%d:%d) Unexpected REJECT Message %s\n",
@@ -2050,12 +2052,10 @@ NCR_700_slave_configure(struct scsi_device *SDp)
 
         /* to do here: allocate memory; build a queue_full list */
         if(SDp->tagged_supported) {
-                scsi_adjust_queue_depth(SDp, MSG_ORDERED_TAG, NCR_700_DEFAULT_TAGS);
+                scsi_adjust_queue_depth(SDp, NCR_700_DEFAULT_TAGS);
                 NCR_700_set_tag_neg_state(SDp, NCR_700_START_TAG_NEGOTIATION);
-        } else {
-                /* initialise to default depth */
-                scsi_adjust_queue_depth(SDp, 0, SDp->host->cmd_per_lun);
         }
+
         if(hostdata->fast) {
                 /* Find the correct offset and period via domain validation */
                 if (!spi_initial_dv(SDp->sdev_target))
@@ -2083,7 +2083,7 @@ NCR_700_change_queue_depth(struct scsi_device *SDp, int depth, int reason)
         if (depth > NCR_700_MAX_TAGS)
                 depth = NCR_700_MAX_TAGS;
 
-        scsi_adjust_queue_depth(SDp, scsi_get_tag_type(SDp), depth);
+        scsi_adjust_queue_depth(SDp, depth);
         return depth;
 }
 
@@ -2101,15 +2101,16 @@ static int NCR_700_change_queue_type(struct scsi_device *SDp, int tag_type)
         if (change_tag)
                 scsi_target_quiesce(SDp->sdev_target);
 
+        scsi_set_tag_type(SDp, tag_type);
         if (!tag_type) {
                 /* shift back to the default unqueued number of commands
                  * (the user can still raise this) */
-                scsi_adjust_queue_depth(SDp, 0, SDp->host->cmd_per_lun);
+                scsi_adjust_queue_depth(SDp, SDp->host->cmd_per_lun);
                 hostdata->tag_negotiated &= ~(1 << sdev_id(SDp));
         } else {
                 /* Here, we cleared the negotiation flag above, so this
                  * will force the driver to renegotiate */
-                scsi_adjust_queue_depth(SDp, tag_type, SDp->queue_depth);
+                scsi_adjust_queue_depth(SDp, SDp->queue_depth);
                 if (change_tag)
                         NCR_700_set_tag_neg_state(SDp, NCR_700_START_TAG_NEGOTIATION);
         }
diff --git a/drivers/scsi/BusLogic.c b/drivers/scsi/BusLogic.c
index 64c75143c89a..5aa476b6b8a8 100644
--- a/drivers/scsi/BusLogic.c
+++ b/drivers/scsi/BusLogic.c
@@ -2327,12 +2327,12 @@ static int blogic_slaveconfig(struct scsi_device *dev)
                 if (qdepth == 0)
                         qdepth = BLOGIC_MAX_AUTO_TAG_DEPTH;
                 adapter->qdepth[tgt_id] = qdepth;
-                scsi_adjust_queue_depth(dev, MSG_SIMPLE_TAG, qdepth);
+                scsi_adjust_queue_depth(dev, qdepth);
         } else {
                 adapter->tagq_ok &= ~(1 << tgt_id);
                 qdepth = adapter->untag_qdepth;
                 adapter->qdepth[tgt_id] = qdepth;
-                scsi_adjust_queue_depth(dev, 0, qdepth);
+                scsi_adjust_queue_depth(dev, qdepth);
         }
         qdepth = 0;
         for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++)
diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c
index a759cb2d4b15..41b9c68bca67 100644
--- a/drivers/scsi/aacraid/linit.c
+++ b/drivers/scsi/aacraid/linit.c
@@ -462,9 +462,9 @@ static int aac_slave_configure(struct scsi_device *sdev)
                         depth = 256;
                 else if (depth < 2)
                         depth = 2;
-                scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
+                scsi_adjust_queue_depth(sdev, depth);
         } else
-                scsi_adjust_queue_depth(sdev, 0, 1);
+                scsi_adjust_queue_depth(sdev, 1);
 
         return 0;
 }
@@ -504,9 +504,9 @@ static int aac_change_queue_depth(struct scsi_device *sdev, int depth,
                         depth = 256;
                 else if (depth < 2)
                         depth = 2;
-                scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
+                scsi_adjust_queue_depth(sdev, depth);
         } else
-                scsi_adjust_queue_depth(sdev, 0, 1);
+                scsi_adjust_queue_depth(sdev, 1);
         return sdev->queue_depth;
 }
 
diff --git a/drivers/scsi/advansys.c b/drivers/scsi/advansys.c
index 43761c1c46f0..ae4840e4c1c5 100644
--- a/drivers/scsi/advansys.c
+++ b/drivers/scsi/advansys.c
@@ -7706,7 +7706,7 @@ advansys_narrow_slave_configure(struct scsi_device *sdev, ASC_DVC_VAR *asc_dvc)
                                 asc_dvc->cfg->can_tagged_qng |= tid_bit;
                                 asc_dvc->use_tagged_qng |= tid_bit;
                         }
-                        scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG,
+                        scsi_adjust_queue_depth(sdev, 
                                                 asc_dvc->max_dvc_qng[sdev->id]);
                 }
         } else {
@@ -7714,7 +7714,6 @@ advansys_narrow_slave_configure(struct scsi_device *sdev, ASC_DVC_VAR *asc_dvc)
                         asc_dvc->cfg->can_tagged_qng &= ~tid_bit;
                         asc_dvc->use_tagged_qng &= ~tid_bit;
                 }
-                scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
         }
 
         if ((sdev->lun == 0) &&
@@ -7849,10 +7848,8 @@ advansys_wide_slave_configure(struct scsi_device *sdev, ADV_DVC_VAR *adv_dvc)
         }
 
         if ((adv_dvc->tagqng_able & tidmask) && sdev->tagged_supported) {
-                scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG,
+                scsi_adjust_queue_depth(sdev,
                                         adv_dvc->max_dvc_qng);
-        } else {
-                scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
         }
 }
 
diff --git a/drivers/scsi/aic7xxx/aic79xx_osm.c b/drivers/scsi/aic7xxx/aic79xx_osm.c
index 9fd6b5618b25..80cb4fd7caaa 100644
--- a/drivers/scsi/aic7xxx/aic79xx_osm.c
+++ b/drivers/scsi/aic7xxx/aic79xx_osm.c
@@ -1469,11 +1469,8 @@ ahd_platform_set_tags(struct ahd_softc *ahd, struct scsi_device *sdev,
 
         switch ((dev->flags & (AHD_DEV_Q_BASIC|AHD_DEV_Q_TAGGED))) {
         case AHD_DEV_Q_BASIC:
-                scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TASK,
-                                dev->openings + dev->active);
-                break;
         case AHD_DEV_Q_TAGGED:
-                scsi_adjust_queue_depth(sdev, MSG_ORDERED_TASK,
+                scsi_adjust_queue_depth(sdev,
                                 dev->openings + dev->active);
                 break;
         default:
@@ -1483,7 +1480,7 @@ ahd_platform_set_tags(struct ahd_softc *ahd, struct scsi_device *sdev,
                  * serially on the controller/device.  This should
                  * remove some latency.
                  */
-                scsi_adjust_queue_depth(sdev, 0, 1);
+                scsi_adjust_queue_depth(sdev, 1);
                 break;
         }
 }
diff --git a/drivers/scsi/aic7xxx/aic7xxx_osm.c b/drivers/scsi/aic7xxx/aic7xxx_osm.c
index f18b6d69d3fb..a6a27d5398dd 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_osm.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_osm.c
@@ -1335,13 +1335,9 @@ ahc_platform_set_tags(struct ahc_softc *ahc, struct scsi_device *sdev,
         }
         switch ((dev->flags & (AHC_DEV_Q_BASIC|AHC_DEV_Q_TAGGED))) {
         case AHC_DEV_Q_BASIC:
-                scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TASK,
-                                dev->openings + dev->active);
-                break;
         case AHC_DEV_Q_TAGGED:
-                scsi_adjust_queue_depth(sdev, MSG_ORDERED_TASK,
+                scsi_adjust_queue_depth(sdev,
                                 dev->openings + dev->active);
-                break;
         default:
                 /*
                  * We allow the OS to queue 2 untagged transactions to
@@ -1349,7 +1345,7 @@ ahc_platform_set_tags(struct ahc_softc *ahc, struct scsi_device *sdev,
                  * serially on the controller/device.  This should
                  * remove some latency.
                  */
-                scsi_adjust_queue_depth(sdev, 0, 2);
+                scsi_adjust_queue_depth(sdev, 2);
                 break;
         }
 }
diff --git a/drivers/scsi/arcmsr/arcmsr_hba.c b/drivers/scsi/arcmsr/arcmsr_hba.c
index 0b44fb5ee485..209f77162d06 100644
--- a/drivers/scsi/arcmsr/arcmsr_hba.c
+++ b/drivers/scsi/arcmsr/arcmsr_hba.c
@@ -122,7 +122,7 @@ static int arcmsr_adjust_disk_queue_depth(struct scsi_device *sdev,
 
         if (queue_depth > ARCMSR_MAX_CMD_PERLUN)
                 queue_depth = ARCMSR_MAX_CMD_PERLUN;
-        scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
+        scsi_adjust_queue_depth(sdev, queue_depth);
         return queue_depth;
 }
 
diff --git a/drivers/scsi/bfa/bfad_im.c b/drivers/scsi/bfa/bfad_im.c
index d8e43c81d19b..87b09cd232cc 100644
--- a/drivers/scsi/bfa/bfad_im.c
+++ b/drivers/scsi/bfa/bfad_im.c
@@ -776,7 +776,7 @@ bfad_thread_workq(struct bfad_s *bfad)
 static int
 bfad_im_slave_configure(struct scsi_device *sdev)
 {
-        scsi_adjust_queue_depth(sdev, 0, bfa_lun_queue_depth);
+        scsi_adjust_queue_depth(sdev, bfa_lun_queue_depth);
         return 0;
 }
 
@@ -867,7 +867,6 @@ bfad_ramp_up_qdepth(struct bfad_itnim_s *itnim, struct scsi_device *sdev)
                                 if (tmp_sdev->id != sdev->id)
                                         continue;
                                 scsi_adjust_queue_depth(tmp_sdev,
-                                        MSG_SIMPLE_TAG,
                                         tmp_sdev->queue_depth + 1);
 
                                 itnim->last_ramp_up_time = jiffies;
diff --git a/drivers/scsi/csiostor/csio_scsi.c b/drivers/scsi/csiostor/csio_scsi.c
index f73155db80a3..44a8cc51428f 100644
--- a/drivers/scsi/csiostor/csio_scsi.c
+++ b/drivers/scsi/csiostor/csio_scsi.c
@@ -2241,7 +2241,7 @@ csio_slave_alloc(struct scsi_device *sdev)
 static int
 csio_slave_configure(struct scsi_device *sdev)
 {
-        scsi_adjust_queue_depth(sdev, 0, csio_lun_qdepth);
+        scsi_adjust_queue_depth(sdev, csio_lun_qdepth);
         return 0;
 }
 
diff --git a/drivers/scsi/dpt_i2o.c b/drivers/scsi/dpt_i2o.c
index 072f0ec2851e..1af8d54bcded 100644
--- a/drivers/scsi/dpt_i2o.c
+++ b/drivers/scsi/dpt_i2o.c
@@ -415,10 +415,8 @@ static int adpt_slave_configure(struct scsi_device * device)
         pHba = (adpt_hba *) host->hostdata[0];
 
         if (host->can_queue && device->tagged_supported) {
-                scsi_adjust_queue_depth(device, MSG_SIMPLE_TAG,
+                scsi_adjust_queue_depth(device,
                                 host->can_queue - 1);
-        } else {
-                scsi_adjust_queue_depth(device, 0, 1);
         }
         return 0;
 }
diff --git a/drivers/scsi/eata.c b/drivers/scsi/eata.c
index 943ad3a19661..bc0f918f1729 100644
--- a/drivers/scsi/eata.c
+++ b/drivers/scsi/eata.c
@@ -946,20 +946,18 @@ static int eata2x_slave_configure(struct scsi_device *dev)
 
         if (TLDEV(dev->type) && dev->tagged_supported) {
                 if (tag_mode == TAG_SIMPLE) {
-                        scsi_adjust_queue_depth(dev, MSG_SIMPLE_TAG, tqd);
                         tag_suffix = ", simple tags";
                 } else if (tag_mode == TAG_ORDERED) {
-                        scsi_adjust_queue_depth(dev, MSG_ORDERED_TAG, tqd);
                         tag_suffix = ", ordered tags";
                 } else {
-                        scsi_adjust_queue_depth(dev, 0, tqd);
                         tag_suffix = ", no tags";
                 }
+                scsi_adjust_queue_depth(dev, tqd);
         } else if (TLDEV(dev->type) && linked_comm) {
-                scsi_adjust_queue_depth(dev, 0, tqd);
+                scsi_adjust_queue_depth(dev, tqd);
                 tag_suffix = ", untagged";
         } else {
-                scsi_adjust_queue_depth(dev, 0, utqd);
+                scsi_adjust_queue_depth(dev, utqd);
                 tag_suffix = "";
         }
 
diff --git a/drivers/scsi/esas2r/esas2r.h b/drivers/scsi/esas2r/esas2r.h
index 20ab211983f2..1941d837f6f2 100644
--- a/drivers/scsi/esas2r/esas2r.h
+++ b/drivers/scsi/esas2r/esas2r.h
@@ -972,9 +972,6 @@ u8 handle_hba_ioctl(struct esas2r_adapter *a,
                     struct atto_ioctl *ioctl_hba);
 int esas2r_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd);
 int esas2r_show_info(struct seq_file *m, struct Scsi_Host *sh);
-int esas2r_slave_alloc(struct scsi_device *dev);
-int esas2r_slave_configure(struct scsi_device *dev);
-void esas2r_slave_destroy(struct scsi_device *dev);
 int esas2r_change_queue_depth(struct scsi_device *dev, int depth, int reason);
 long esas2r_proc_ioctl(struct file *fp, unsigned int cmd, unsigned long arg);
 
diff --git a/drivers/scsi/esas2r/esas2r_main.c b/drivers/scsi/esas2r/esas2r_main.c
index a020b09ba347..30fce64faf75 100644
--- a/drivers/scsi/esas2r/esas2r_main.c
+++ b/drivers/scsi/esas2r/esas2r_main.c
@@ -254,9 +254,6 @@ static struct scsi_host_template driver_template = {
         .use_clustering                 = ENABLE_CLUSTERING,
         .emulated                       = 0,
         .proc_name                      = ESAS2R_DRVR_NAME,
-        .slave_configure                = esas2r_slave_configure,
-        .slave_alloc                    = esas2r_slave_alloc,
-        .slave_destroy                  = esas2r_slave_destroy,
         .change_queue_depth             = esas2r_change_queue_depth,
         .change_queue_type              = scsi_change_queue_type,
         .max_sectors                    = 0xFFFF,
@@ -1264,35 +1261,11 @@ int esas2r_change_queue_depth(struct scsi_device *dev, int depth, int reason)
 {
         esas2r_log(ESAS2R_LOG_INFO, "change_queue_depth %p, %d", dev, depth);
 
-        scsi_adjust_queue_depth(dev, scsi_get_tag_type(dev), depth);
+        scsi_adjust_queue_depth(dev, depth);
 
         return dev->queue_depth;
 }
 
-int esas2r_slave_alloc(struct scsi_device *dev)
-{
-        return 0;
-}
-
-int esas2r_slave_configure(struct scsi_device *dev)
-{
-        esas2r_log_dev(ESAS2R_LOG_INFO, &(dev->sdev_gendev),
-                       "esas2r_slave_configure()");
-
-        if (dev->tagged_supported)
-                scsi_adjust_queue_depth(dev, MSG_SIMPLE_TAG, cmd_per_lun);
-        else
-                scsi_adjust_queue_depth(dev, 0, cmd_per_lun);
-
-        return 0;
-}
-
-void esas2r_slave_destroy(struct scsi_device *dev)
-{
-        esas2r_log_dev(ESAS2R_LOG_INFO, &(dev->sdev_gendev),
-                       "esas2r_slave_destroy()");
-}
-
 void esas2r_log_request_failure(struct esas2r_adapter *a,
                                 struct esas2r_request *rq)
 {
diff --git a/drivers/scsi/esp_scsi.c b/drivers/scsi/esp_scsi.c
index 66b6ce10b259..38c23e0b73af 100644
--- a/drivers/scsi/esp_scsi.c
+++ b/drivers/scsi/esp_scsi.c
@@ -2402,27 +2402,14 @@ static int esp_slave_configure(struct scsi_device *dev)
 {
         struct esp *esp = shost_priv(dev->host);
         struct esp_target_data *tp = &esp->target[dev->id];
-        int goal_tags, queue_depth;
-
-        goal_tags = 0;
 
         if (dev->tagged_supported) {
                 /* XXX make this configurable somehow XXX */
-                goal_tags = ESP_DEFAULT_TAGS;
+                int goal_tags = min(ESP_DEFAULT_TAGS, ESP_MAX_TAG);
 
-                if (goal_tags > ESP_MAX_TAG)
-                        goal_tags = ESP_MAX_TAG;
+                scsi_adjust_queue_depth(dev, goal_tags);
         }
 
-        queue_depth = goal_tags;
-        if (queue_depth < dev->host->cmd_per_lun)
-                queue_depth = dev->host->cmd_per_lun;
-
-        if (goal_tags) {
-                scsi_adjust_queue_depth(dev, MSG_ORDERED_TAG, queue_depth);
-        } else {
-                scsi_adjust_queue_depth(dev, 0, queue_depth);
-        }
         tp->flags |= ESP_TGT_DISCONNECT;
 
         if (!spi_initial_dv(dev->sdev_target))
diff --git a/drivers/scsi/fnic/fnic_main.c b/drivers/scsi/fnic/fnic_main.c
index 2a6c98b7d4db..0f29e3f89b26 100644
--- a/drivers/scsi/fnic/fnic_main.c
+++ b/drivers/scsi/fnic/fnic_main.c
@@ -100,7 +100,7 @@ static int fnic_slave_alloc(struct scsi_device *sdev)
         if (!rport || fc_remote_port_chkready(rport))
                 return -ENXIO;
 
-        scsi_adjust_queue_depth(sdev, 0, fnic_max_qdepth);
+        scsi_adjust_queue_depth(sdev, fnic_max_qdepth);
         return 0;
 }
 
diff --git a/drivers/scsi/gdth.c b/drivers/scsi/gdth.c
index 0f1ae13ce7c7..4ebbeae161e2 100644
--- a/drivers/scsi/gdth.c
+++ b/drivers/scsi/gdth.c
@@ -4661,7 +4661,6 @@ static void gdth_flush(gdth_ha_str *ha)
 /* configure lun */
 static int gdth_slave_configure(struct scsi_device *sdev)
 {
-    scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
     sdev->skip_ms_page_3f = 1;
     sdev->skip_ms_page_8 = 1;
     return 0;
diff --git a/drivers/scsi/hpsa.c b/drivers/scsi/hpsa.c
index cef5d49b59cd..18ea2e16e34f 100644
--- a/drivers/scsi/hpsa.c
+++ b/drivers/scsi/hpsa.c
@@ -4165,7 +4165,7 @@ static int hpsa_change_queue_depth(struct scsi_device *sdev,
         else
                 if (qdepth > h->nr_cmds)
                         qdepth = h->nr_cmds;
-        scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
+        scsi_adjust_queue_depth(sdev, qdepth);
         return sdev->queue_depth;
 }
 
diff --git a/drivers/scsi/hptiop.c b/drivers/scsi/hptiop.c
index dedb62c21b29..151893148abd 100644
--- a/drivers/scsi/hptiop.c
+++ b/drivers/scsi/hptiop.c
@@ -1127,7 +1127,7 @@ static int hptiop_adjust_disk_queue_depth(struct scsi_device *sdev,
 
         if (queue_depth > hba->max_requests)
                 queue_depth = hba->max_requests;
-        scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
+        scsi_adjust_queue_depth(sdev, queue_depth);
         return queue_depth;
 }
 
diff --git a/drivers/scsi/ibmvscsi/ibmvfc.c b/drivers/scsi/ibmvscsi/ibmvfc.c
index 4723d89df5ac..147b80e07b00 100644
--- a/drivers/scsi/ibmvscsi/ibmvfc.c
+++ b/drivers/scsi/ibmvscsi/ibmvfc.c
@@ -2887,12 +2887,6 @@ static int ibmvfc_slave_configure(struct scsi_device *sdev)
         spin_lock_irqsave(shost->host_lock, flags);
         if (sdev->type == TYPE_DISK)
                 sdev->allow_restart = 1;
-
-        if (sdev->tagged_supported)
-                scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG,
-                                sdev->queue_depth);
-        else
-                scsi_adjust_queue_depth(sdev, 0, sdev->queue_depth);
         spin_unlock_irqrestore(shost->host_lock, flags);
         return 0;
 }
@@ -2915,7 +2909,7 @@ static int ibmvfc_change_queue_depth(struct scsi_device *sdev, int qdepth,
         if (qdepth > IBMVFC_MAX_CMDS_PER_LUN)
                 qdepth = IBMVFC_MAX_CMDS_PER_LUN;
 
-        scsi_adjust_queue_depth(sdev, 0, qdepth);
+        scsi_adjust_queue_depth(sdev, qdepth);
         return sdev->queue_depth;
 }
 
diff --git a/drivers/scsi/ibmvscsi/ibmvscsi.c b/drivers/scsi/ibmvscsi/ibmvscsi.c
index 7b23f21f22f1..e8c3cdf0d03b 100644
--- a/drivers/scsi/ibmvscsi/ibmvscsi.c
+++ b/drivers/scsi/ibmvscsi/ibmvscsi.c
@@ -1929,7 +1929,6 @@ static int ibmvscsi_slave_configure(struct scsi_device *sdev)
                 blk_queue_rq_timeout(sdev->request_queue, 120 * HZ);
         }
         spin_unlock_irqrestore(shost->host_lock, lock_flags);
-        scsi_adjust_queue_depth(sdev, 0, shost->cmd_per_lun);
         return 0;
 }
 
@@ -1951,7 +1950,7 @@ static int ibmvscsi_change_queue_depth(struct scsi_device *sdev, int qdepth,
         if (qdepth > IBMVSCSI_MAX_CMDS_PER_LUN)
                 qdepth = IBMVSCSI_MAX_CMDS_PER_LUN;
 
-        scsi_adjust_queue_depth(sdev, 0, qdepth);
+        scsi_adjust_queue_depth(sdev, qdepth);
         return sdev->queue_depth;
 }
 
diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index f84fcb9a6ed7..256ef98f5c29 100644
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -4344,7 +4344,7 @@ static int ipr_change_queue_depth(struct scsi_device *sdev, int qdepth,
                 qdepth = IPR_MAX_CMD_PER_ATA_LUN;
         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
 
-        scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
+        scsi_adjust_queue_depth(sdev, qdepth);
         return sdev->queue_depth;
 }
 
@@ -4751,10 +4751,10 @@ static int ipr_slave_configure(struct scsi_device *sdev)
                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
 
                 if (ap) {
-                        scsi_adjust_queue_depth(sdev, 0, IPR_MAX_CMD_PER_ATA_LUN);
+                        scsi_adjust_queue_depth(sdev, IPR_MAX_CMD_PER_ATA_LUN);
                         ata_sas_slave_configure(sdev, ap);
-                } else
-                        scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
+                }
+
                 if (ioa_cfg->sis64)
                         sdev_printk(KERN_INFO, sdev, "Resource path: %s\n",
                                     ipr_format_res_path(ioa_cfg,
diff --git a/drivers/scsi/ips.c b/drivers/scsi/ips.c
index e5afc3884d74..454741a8da45 100644
--- a/drivers/scsi/ips.c
+++ b/drivers/scsi/ips.c
@@ -1210,7 +1210,7 @@ ips_slave_configure(struct scsi_device * SDptr)
                 min = ha->max_cmds / 2;
                 if (ha->enq->ucLogDriveCount <= 2)
                         min = ha->max_cmds - 1;
-                scsi_adjust_queue_depth(SDptr, MSG_ORDERED_TAG, min);
+                scsi_adjust_queue_depth(SDptr, min);
         }
 
         SDptr->skip_ms_page_8 = 1;
diff --git a/drivers/scsi/libfc/fc_fcp.c b/drivers/scsi/libfc/fc_fcp.c
index d4bb642f2681..bf954ee050f8 100644
--- a/drivers/scsi/libfc/fc_fcp.c
+++ b/drivers/scsi/libfc/fc_fcp.c
@@ -2160,7 +2160,7 @@ int fc_slave_alloc(struct scsi_device *sdev)
         if (!rport || fc_remote_port_chkready(rport))
                 return -ENXIO;
 
-        scsi_adjust_queue_depth(sdev, 0, FC_FCP_DFLT_QUEUE_DEPTH);
+        scsi_adjust_queue_depth(sdev, FC_FCP_DFLT_QUEUE_DEPTH);
         return 0;
 }
 EXPORT_SYMBOL(fc_slave_alloc);
@@ -2175,13 +2175,13 @@ int fc_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
 {
         switch (reason) {
         case SCSI_QDEPTH_DEFAULT:
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
+                scsi_adjust_queue_depth(sdev, qdepth);
                 break;
         case SCSI_QDEPTH_QFULL:
                 scsi_track_queue_full(sdev, qdepth);
                 break;
         case SCSI_QDEPTH_RAMP_UP:
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
+                scsi_adjust_queue_depth(sdev, qdepth);
                 break;
         default:
                 return -EOPNOTSUPP;
diff --git a/drivers/scsi/libiscsi.c b/drivers/scsi/libiscsi.c
index 0d8bc6c66650..d521624dedfb 100644
--- a/drivers/scsi/libiscsi.c
+++ b/drivers/scsi/libiscsi.c
@@ -1775,13 +1775,13 @@ int iscsi_change_queue_depth(struct scsi_device *sdev, int depth, int reason)
 {
         switch (reason) {
         case SCSI_QDEPTH_DEFAULT:
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
+                scsi_adjust_queue_depth(sdev, depth);
                 break;
         case SCSI_QDEPTH_QFULL:
                 scsi_track_queue_full(sdev, depth);
                 break;
         case SCSI_QDEPTH_RAMP_UP:
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
+                scsi_adjust_queue_depth(sdev, depth);
                 break;
         default:
                 return -EOPNOTSUPP;
diff --git a/drivers/scsi/libsas/sas_scsi_host.c b/drivers/scsi/libsas/sas_scsi_host.c
index eee21a060d93..56d698af073d 100644
--- a/drivers/scsi/libsas/sas_scsi_host.c
+++ b/drivers/scsi/libsas/sas_scsi_host.c
@@ -940,13 +940,13 @@ int sas_slave_configure(struct scsi_device *scsi_dev)
         sas_read_port_mode_page(scsi_dev);
 
         if (scsi_dev->tagged_supported) {
-                scsi_adjust_queue_depth(scsi_dev, MSG_SIMPLE_TAG, SAS_DEF_QD);
+                scsi_adjust_queue_depth(scsi_dev, SAS_DEF_QD);
         } else {
                 SAS_DPRINTK("device %llx, LUN %llx doesn't support "
                             "TCQ\n", SAS_ADDR(dev->sas_addr),
                             scsi_dev->lun);
                 scsi_dev->tagged_supported = 0;
-                scsi_adjust_queue_depth(scsi_dev, 0, 1);
+                scsi_adjust_queue_depth(scsi_dev, 1);
         }
 
         scsi_dev->allow_restart = 1;
@@ -967,7 +967,7 @@ int sas_change_queue_depth(struct scsi_device *sdev, int depth, int reason)
         case SCSI_QDEPTH_RAMP_UP:
                 if (!sdev->tagged_supported)
                         depth = 1;
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
+                scsi_adjust_queue_depth(sdev, depth);
                 break;
         case SCSI_QDEPTH_QFULL:
                 scsi_track_queue_full(sdev, depth);
@@ -979,19 +979,11 @@ int sas_change_queue_depth(struct scsi_device *sdev, int depth, int reason)
         return depth;
 }
 
-int sas_change_queue_type(struct scsi_device *scsi_dev, int qt)
+int sas_change_queue_type(struct scsi_device *scsi_dev, int type)
 {
-        struct domain_device *dev = sdev_to_domain_dev(scsi_dev);
-
-        if (dev_is_sata(dev))
+        if (dev_is_sata(sdev_to_domain_dev(scsi_dev)))
                 return -EINVAL;
-
-        if (!scsi_dev->tagged_supported)
-                return 0;
-
-        scsi_adjust_queue_depth(scsi_dev, qt, scsi_dev->queue_depth);
-
-        return qt;
+        return scsi_change_queue_type(scsi_dev, type);
 }
 
 int sas_bios_param(struct scsi_device *scsi_dev,
diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
index a24106a70968..8533ee9b818d 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.c
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -320,7 +320,7 @@ lpfc_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
         case SCSI_QDEPTH_DEFAULT:
                 /* change request from sysfs, fall through */
         case SCSI_QDEPTH_RAMP_UP:
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
+                scsi_adjust_queue_depth(sdev, qdepth);
                 break;
         case SCSI_QDEPTH_QFULL:
                 if (scsi_track_queue_full(sdev, qdepth) == 0)
@@ -5598,7 +5598,7 @@ lpfc_slave_configure(struct scsi_device *sdev)
         struct lpfc_vport *vport = (struct lpfc_vport *) sdev->host->hostdata;
         struct lpfc_hba   *phba = vport->phba;
 
-        scsi_adjust_queue_depth(sdev, 0, vport->cfg_lun_queue_depth);
+        scsi_adjust_queue_depth(sdev, vport->cfg_lun_queue_depth);
 
         if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
                 lpfc_sli_handle_fast_ring_event(phba,
diff --git a/drivers/scsi/megaraid/megaraid_mbox.c b/drivers/scsi/megaraid/megaraid_mbox.c
index 531dce419c18..6b077d839f2b 100644
--- a/drivers/scsi/megaraid/megaraid_mbox.c
+++ b/drivers/scsi/megaraid/megaraid_mbox.c
@@ -349,7 +349,7 @@ static int megaraid_change_queue_depth(struct scsi_device *sdev, int qdepth,
 
         if (qdepth > MBOX_MAX_SCSI_CMDS)
                 qdepth = MBOX_MAX_SCSI_CMDS;
-        scsi_adjust_queue_depth(sdev, 0, qdepth);
+        scsi_adjust_queue_depth(sdev, qdepth);
         return sdev->queue_depth;
 }
 
diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c b/drivers/scsi/megaraid/megaraid_sas_base.c
index 5640ad1c8214..107244cebd22 100644
--- a/drivers/scsi/megaraid/megaraid_sas_base.c
+++ b/drivers/scsi/megaraid/megaraid_sas_base.c
@@ -2594,8 +2594,7 @@ static int megasas_change_queue_depth(struct scsi_device *sdev,
 
         if (queue_depth > sdev->host->can_queue)
                 queue_depth = sdev->host->can_queue;
-        scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev),
-                                queue_depth);
+        scsi_adjust_queue_depth(sdev, queue_depth);
 
         return queue_depth;
 }
diff --git a/drivers/scsi/mpt2sas/mpt2sas_scsih.c b/drivers/scsi/mpt2sas/mpt2sas_scsih.c
index 69dc166b52bc..42fef914d441 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_scsih.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_scsih.c
@@ -1222,7 +1222,7 @@ _scsih_adjust_queue_depth(struct scsi_device *sdev, int qdepth)
                 max_depth = 1;
         if (qdepth > max_depth)
                 qdepth = max_depth;
-        scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
+        scsi_adjust_queue_depth(sdev, qdepth);
 }
 
 /**
diff --git a/drivers/scsi/mpt3sas/mpt3sas_scsih.c b/drivers/scsi/mpt3sas/mpt3sas_scsih.c
index d3abf254341d..b23c2e7588e5 100644
--- a/drivers/scsi/mpt3sas/mpt3sas_scsih.c
+++ b/drivers/scsi/mpt3sas/mpt3sas_scsih.c
@@ -1090,7 +1090,7 @@ _scsih_adjust_queue_depth(struct scsi_device *sdev, int qdepth)
                 max_depth = 1;
         if (qdepth > max_depth)
                 qdepth = max_depth;
-        scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
+        scsi_adjust_queue_depth(sdev, qdepth);
 }
 
 /**
diff --git a/drivers/scsi/ncr53c8xx.c b/drivers/scsi/ncr53c8xx.c
index a7305ffc359d..9c331b7bfdcd 100644
--- a/drivers/scsi/ncr53c8xx.c
+++ b/drivers/scsi/ncr53c8xx.c
@@ -7997,10 +7997,7 @@ static int ncr53c8xx_slave_configure(struct scsi_device *device)
         if (depth_to_use > MAX_TAGS)
                 depth_to_use = MAX_TAGS;
 
-        scsi_adjust_queue_depth(device,
-                                (device->tagged_supported ?
-                                 MSG_SIMPLE_TAG : 0),
-                                depth_to_use);
+        scsi_adjust_queue_depth(device, depth_to_use);
 
         /*
         **      Since the queue depth is not tunable under Linux,
diff --git a/drivers/scsi/pmcraid.c b/drivers/scsi/pmcraid.c
index 71f9f59b13c6..d8b9ba251fbd 100644
--- a/drivers/scsi/pmcraid.c
+++ b/drivers/scsi/pmcraid.c
@@ -249,14 +249,11 @@ static int pmcraid_slave_configure(struct scsi_device *scsi_dev)
                                       PMCRAID_VSET_MAX_SECTORS);
         }
 
-        if (scsi_dev->tagged_supported &&
-            (RES_IS_GSCSI(res->cfg_entry) || RES_IS_VSET(res->cfg_entry))) {
-                scsi_adjust_queue_depth(scsi_dev, MSG_SIMPLE_TAG,
-                                        scsi_dev->host->cmd_per_lun);
-        } else {
-                scsi_adjust_queue_depth(scsi_dev, 0,
-                                        scsi_dev->host->cmd_per_lun);
-        }
+        /*
+         * We never want to report TCQ support for these types of devices.
+         */
+        if (!RES_IS_GSCSI(res->cfg_entry) && !RES_IS_VSET(res->cfg_entry))
+                scsi_dev->tagged_supported = 0;
 
         return 0;
 }
@@ -302,35 +299,12 @@ static int pmcraid_change_queue_depth(struct scsi_device *scsi_dev, int depth,
         if (depth > PMCRAID_MAX_CMD_PER_LUN)
                 depth = PMCRAID_MAX_CMD_PER_LUN;
 
-        scsi_adjust_queue_depth(scsi_dev, scsi_get_tag_type(scsi_dev), depth);
+        scsi_adjust_queue_depth(scsi_dev, depth);
 
         return scsi_dev->queue_depth;
 }
 
 /**
- * pmcraid_change_queue_type - Change the device's queue type
- * @scsi_dev: scsi device struct
- * @tag: type of tags to use
- *
- * Return value:
- *      actual queue type set
- */
-static int pmcraid_change_queue_type(struct scsi_device *scsi_dev, int tag)
-{
-        struct pmcraid_resource_entry *res;
-
-        res = (struct pmcraid_resource_entry *)scsi_dev->hostdata;
-        if (res && scsi_dev->tagged_supported &&
-            (RES_IS_GSCSI(res->cfg_entry) || RES_IS_VSET(res->cfg_entry)))
-                tag = scsi_change_queue_type(scsi_dev, tag);
-        else
-                tag = 0;
-
-        return tag;
-}
-
-
-/**
  * pmcraid_init_cmdblk - initializes a command block
  *
  * @cmd: pointer to struct pmcraid_cmd to be initialized
@@ -4285,7 +4259,7 @@ static struct scsi_host_template pmcraid_host_template = {
         .slave_configure = pmcraid_slave_configure,
         .slave_destroy = pmcraid_slave_destroy,
         .change_queue_depth = pmcraid_change_queue_depth,
-        .change_queue_type  = pmcraid_change_queue_type,
+        .change_queue_type  = scsi_change_queue_type,
         .can_queue = PMCRAID_MAX_IO_CMD,
         .this_id = -1,
         .sg_tablesize = PMCRAID_MAX_IOADLS,
diff --git a/drivers/scsi/qla1280.c b/drivers/scsi/qla1280.c
index 158020522dfb..adedb6ef8eec 100644
--- a/drivers/scsi/qla1280.c
+++ b/drivers/scsi/qla1280.c
@@ -1224,10 +1224,9 @@ qla1280_slave_configure(struct scsi_device *device)
 
         if (device->tagged_supported &&
             (ha->bus_settings[bus].qtag_enables & (BIT_0 << target))) {
-                scsi_adjust_queue_depth(device, MSG_ORDERED_TAG,
-                                        ha->bus_settings[bus].hiwat);
+                scsi_adjust_queue_depth(device, ha->bus_settings[bus].hiwat);
         } else {
-                scsi_adjust_queue_depth(device, 0, default_depth);
+                scsi_adjust_queue_depth(device, default_depth);
         }
 
         nv->bus[bus].target[target].parameter.enable_sync = device->sdtr;
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index eb0465305f8d..33166ebec7d8 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -1405,7 +1405,7 @@ qla2xxx_slave_configure(struct scsi_device *sdev)
         if (IS_T10_PI_CAPABLE(vha->hw))
                 blk_queue_update_dma_alignment(sdev->request_queue, 0x7);
 
-        scsi_adjust_queue_depth(sdev, 0, req->max_q_depth);
+        scsi_adjust_queue_depth(sdev, req->max_q_depth);
         return 0;
 }
 
@@ -1440,7 +1440,7 @@ static void qla2x00_adjust_sdev_qdepth_up(struct scsi_device *sdev, int qdepth)
         if (req->max_q_depth <= sdev->queue_depth || req->max_q_depth < qdepth)
                 return;
 
-        scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, qdepth);
+        scsi_adjust_queue_depth(sdev, qdepth);
 
         ql_dbg(ql_dbg_io, vha, 0x302a,
             "Queue depth adjusted-up to %d for nexus=%ld:%d:%llu.\n",
@@ -1452,7 +1452,7 @@ qla2x00_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
 {
         switch (reason) {
         case SCSI_QDEPTH_DEFAULT:
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
+                scsi_adjust_queue_depth(sdev, qdepth);
                 break;
         case SCSI_QDEPTH_QFULL:
                 qla2x00_handle_queue_full(sdev, qdepth);
diff --git a/drivers/scsi/qla4xxx/ql4_os.c b/drivers/scsi/qla4xxx/ql4_os.c
index f3119c144e29..784f59e55510 100644
--- a/drivers/scsi/qla4xxx/ql4_os.c
+++ b/drivers/scsi/qla4xxx/ql4_os.c
@@ -9064,7 +9064,7 @@ static int qla4xxx_slave_alloc(struct scsi_device *sdev)
         if (ql4xmaxqdepth != 0 && ql4xmaxqdepth <= 0xffffU)
                 queue_depth = ql4xmaxqdepth;
 
-        scsi_adjust_queue_depth(sdev, 0, queue_depth);
+        scsi_adjust_queue_depth(sdev, queue_depth);
         return 0;
 }
 
diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index a3426f1bf0dd..106fa2f886d2 100644
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -744,8 +744,6 @@ void scsi_finish_command(struct scsi_cmnd *cmd)
 /**
  * scsi_adjust_queue_depth - Let low level drivers change a device's queue depth
  * @sdev: SCSI Device in question
- * @tagged: Do we use tagged queueing (non-0) or do we treat
- *          this device as an untagged device (0)
  * @tags: Number of tags allowed if tagged queueing enabled,
  *        or number of commands the low level driver can
  *        queue up in non-tagged mode (as per cmd_per_lun).
@@ -759,7 +757,7 @@ void scsi_finish_command(struct scsi_cmnd *cmd)
  *              currently active and whether or not it even has the
  *              command blocks built yet.
  */
-void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags)
+void scsi_adjust_queue_depth(struct scsi_device *sdev, int tags)
 {
         unsigned long flags;
 
@@ -787,20 +785,6 @@ void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags)
         }
 
         sdev->queue_depth = tags;
-        switch (tagged) {
-                case 0:
-                        sdev->simple_tags = 0;
-                        break;
-                case MSG_ORDERED_TAG:
-                case MSG_SIMPLE_TAG:
-                        sdev->simple_tags = 1;
-                        break;
-                default:
-                        sdev->simple_tags = 0;
-                        sdev_printk(KERN_WARNING, sdev,
-                                    "scsi_adjust_queue_depth, bad queue type, "
-                                    "disabled\n");
-        }
  out:
         spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
 }
@@ -848,11 +832,12 @@ int scsi_track_queue_full(struct scsi_device *sdev, int depth)
                 return 0;
         if (sdev->last_queue_full_depth < 8) {
                 /* Drop back to untagged */
-                scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
+                scsi_set_tag_type(sdev, 0);
+                scsi_adjust_queue_depth(sdev, sdev->host->cmd_per_lun);
                 return -1;
         }
 
-        scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
+        scsi_adjust_queue_depth(sdev, depth);
         return depth;
 }
 EXPORT_SYMBOL(scsi_track_queue_full);
@@ -867,7 +852,7 @@ int scsi_change_queue_type(struct scsi_device *sdev, int tag_type)
         if (!sdev->tagged_supported)
                 return 0;
 
-        scsi_adjust_queue_depth(sdev, tag_type, sdev->queue_depth);
+        scsi_set_tag_type(sdev, tag_type);
         return tag_type;
 
 }
diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index 7bcace2cdd53..fce4e47becc7 100644
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
@@ -2700,11 +2700,8 @@ static int scsi_debug_slave_configure(struct scsi_device *sdp)
         devip = devInfoReg(sdp);
         if (NULL == devip)
                 return 1;       /* no resources, will be marked offline */
-        sdp->hostdata = devip;
         sdp->tagged_supported = 1;
-        if (sdp->host->cmd_per_lun)
-                scsi_adjust_queue_depth(sdp, DEF_TAGGED_QUEUING,
-                                        DEF_CMD_PER_LUN);
+        sdp->hostdata = devip;
         blk_queue_max_segment_size(sdp->request_queue, -1U);
         if (scsi_debug_no_uld)
                 sdp->no_uld_attach = 1;
@@ -4494,7 +4491,7 @@ sdebug_change_qdepth(struct scsi_device *sdev, int qdepth, int reason)
                 /* allow to exceed max host queued_arr elements for testing */
                 if (qdepth > SCSI_DEBUG_CANQUEUE + 10)
                         qdepth = SCSI_DEBUG_CANQUEUE + 10;
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
+                scsi_adjust_queue_depth(sdev, qdepth);
         } else if (reason == SCSI_QDEPTH_QFULL)
                 scsi_track_queue_full(sdev, qdepth);
         else
diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index 408891cb14ff..d97597e6337e 100644
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -292,7 +292,7 @@ static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,
                 blk_queue_init_tags(sdev->request_queue,
                                     sdev->host->cmd_per_lun, shost->bqt);
         }
-        scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
+        scsi_adjust_queue_depth(sdev, sdev->host->cmd_per_lun);
 
         scsi_sysfs_device_initialize(sdev);
 
@@ -880,8 +880,10 @@ static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result,
                         (inq_result[3] & 0x0f) == 1 ? " CCS" : "");
 
         if ((sdev->scsi_level >= SCSI_2) && (inq_result[7] & 2) &&
-            !(*bflags & BLIST_NOTQ))
+            !(*bflags & BLIST_NOTQ)) {
                 sdev->tagged_supported = 1;
+                sdev->simple_tags = 1;
+        }
 
         /*
          * Some devices (Texel CD ROM drives) have handshaking problems
diff --git a/drivers/scsi/stex.c b/drivers/scsi/stex.c
index b5eae4f6ba46..2bb8a9e74dac 100644
--- a/drivers/scsi/stex.c
+++ b/drivers/scsi/stex.c
@@ -549,8 +549,6 @@ stex_slave_alloc(struct scsi_device *sdev)
         /* Cheat: usually extracted from Inquiry data */
         sdev->tagged_supported = 1;
 
-        scsi_adjust_queue_depth(sdev, 0, sdev->host->can_queue);
-
         return 0;
 }
 
diff --git a/drivers/scsi/storvsc_drv.c b/drivers/scsi/storvsc_drv.c
index 37f5fd8ed765..ff8befbdf17c 100644
--- a/drivers/scsi/storvsc_drv.c
+++ b/drivers/scsi/storvsc_drv.c
@@ -1429,8 +1429,7 @@ static void storvsc_device_destroy(struct scsi_device *sdevice)
 
 static int storvsc_device_configure(struct scsi_device *sdevice)
 {
-        scsi_adjust_queue_depth(sdevice, MSG_SIMPLE_TAG,
-                                STORVSC_MAX_IO_REQUESTS);
+        scsi_adjust_queue_depth(sdevice, STORVSC_MAX_IO_REQUESTS);
 
         blk_queue_max_segment_size(sdevice->request_queue, PAGE_SIZE);
 
diff --git a/drivers/scsi/sym53c8xx_2/sym_glue.c b/drivers/scsi/sym53c8xx_2/sym_glue.c
index e59e6f96b725..3557b385251a 100644
--- a/drivers/scsi/sym53c8xx_2/sym_glue.c
+++ b/drivers/scsi/sym53c8xx_2/sym_glue.c
@@ -820,9 +820,7 @@ static int sym53c8xx_slave_configure(struct scsi_device *sdev)
         if (reqtags > SYM_CONF_MAX_TAG)
                 reqtags = SYM_CONF_MAX_TAG;
         depth_to_use = reqtags ? reqtags : 1;
-        scsi_adjust_queue_depth(sdev,
-                                sdev->tagged_supported ? MSG_SIMPLE_TAG : 0,
-                                depth_to_use);
+        scsi_adjust_queue_depth(sdev, depth_to_use);
         lp->s.scdev_depth = depth_to_use;
         sym_tune_dev_queuing(tp, sdev->lun, reqtags);
 
diff --git a/drivers/scsi/tmscsim.c b/drivers/scsi/tmscsim.c
index 6369f9a282f1..844c9a048c00 100644
--- a/drivers/scsi/tmscsim.c
+++ b/drivers/scsi/tmscsim.c
@@ -2185,9 +2185,16 @@ static int dc390_slave_configure(struct scsi_device *sdev)
         struct dc390_dcb *dcb = (struct dc390_dcb *)sdev->hostdata;
 
         acb->scan_devices = 0;
+
+        /*
+         * XXX: Note that while this driver used to called scsi_activate_tcq,
+         * it never actually set a tag type, so emulate the old behavior.
+         */
+        scsi_set_tag_type(sdev, 0);
+
         if (sdev->tagged_supported && (dcb->DevMode & TAG_QUEUEING_)) {
                 dcb->SyncMode |= EN_TAG_QUEUEING;
-                scsi_adjust_queue_depth(sdev, 0, acb->TagMaxNum);
+                scsi_adjust_queue_depth(sdev, acb->TagMaxNum);
         }
 
         return 0;
diff --git a/drivers/scsi/u14-34f.c b/drivers/scsi/u14-34f.c
index d8dcf36aed11..aa0f4035afaf 100644
--- a/drivers/scsi/u14-34f.c
+++ b/drivers/scsi/u14-34f.c
@@ -696,25 +696,25 @@ static int u14_34f_slave_configure(struct scsi_device *dev) {
    if (TLDEV(dev->type) && dev->tagged_supported)
 
       if (tag_mode == TAG_SIMPLE) {
-         scsi_adjust_queue_depth(dev, MSG_SIMPLE_TAG, tqd);
+         scsi_adjust_queue_depth(dev, tqd);
          tag_suffix = ", simple tags";
          }
       else if (tag_mode == TAG_ORDERED) {
-         scsi_adjust_queue_depth(dev, MSG_ORDERED_TAG, tqd);
+         scsi_adjust_queue_depth(dev, tqd);
          tag_suffix = ", ordered tags";
          }
       else {
-         scsi_adjust_queue_depth(dev, 0, tqd);
+         scsi_adjust_queue_depth(dev, tqd);
          tag_suffix = ", no tags";
          }
 
    else if (TLDEV(dev->type) && linked_comm) {
-      scsi_adjust_queue_depth(dev, 0, tqd);
+      scsi_adjust_queue_depth(dev, tqd);
       tag_suffix = ", untagged";
       }
 
    else {
-      scsi_adjust_queue_depth(dev, 0, utqd);
+      scsi_adjust_queue_depth(dev, utqd);
       tag_suffix = "";
       }
 
diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
index 48c7f9e8f256..5eb4931e2adc 100644
--- a/drivers/scsi/ufs/ufshcd.c
+++ b/drivers/scsi/ufs/ufshcd.c
@@ -2696,7 +2696,7 @@ static void ufshcd_set_queue_depth(struct scsi_device *sdev)
         dev_dbg(hba->dev, "%s: activate tcq with queue depth %d\n",
                         __func__, lun_qdepth);
         if (sdev->tagged_supported)
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), lun_qdepth);
+                scsi_adjust_queue_depth(sdev, lun_qdepth);
 }
 
 /*
@@ -2808,7 +2808,7 @@ static int ufshcd_change_queue_depth(struct scsi_device *sdev,
         case SCSI_QDEPTH_RAMP_UP:
                 if (!sdev->tagged_supported)
                         depth = 1;
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
+                scsi_adjust_queue_depth(sdev, depth);
                 break;
         case SCSI_QDEPTH_QFULL:
                 scsi_track_queue_full(sdev, depth);
diff --git a/drivers/scsi/virtio_scsi.c b/drivers/scsi/virtio_scsi.c
index b83846fc7859..355afbc7fde1 100644
--- a/drivers/scsi/virtio_scsi.c
+++ b/drivers/scsi/virtio_scsi.c
@@ -683,9 +683,7 @@ static int virtscsi_change_queue_depth(struct scsi_device *sdev,
                 break;
         case SCSI_QDEPTH_RAMP_UP: /* Raise qdepth after BUSY state resolved */
         case SCSI_QDEPTH_DEFAULT: /* Manual change via sysfs */
-                scsi_adjust_queue_depth(sdev,
-                                        scsi_get_tag_type(sdev),
-                                        min(max_depth, qdepth));
+                scsi_adjust_queue_depth(sdev, min(max_depth, qdepth));
                 break;
         default:
                 return -EOPNOTSUPP;
diff --git a/drivers/scsi/vmw_pvscsi.c b/drivers/scsi/vmw_pvscsi.c
index 53a3eb6c0634..c3b4f8b3a3a5 100644
--- a/drivers/scsi/vmw_pvscsi.c
+++ b/drivers/scsi/vmw_pvscsi.c
@@ -522,7 +522,7 @@ static int pvscsi_change_queue_depth(struct scsi_device *sdev,
                 max_depth = 1;
         if (qdepth > max_depth)
                 qdepth = max_depth;
-        scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
+        scsi_adjust_queue_depth(sdev, qdepth);
 
         if (sdev->inquiry_len > 7)
                 sdev_printk(KERN_INFO, sdev,
diff --git a/drivers/target/loopback/tcm_loop.c b/drivers/target/loopback/tcm_loop.c
index 120a851df0d7..0ed96644ec94 100644
--- a/drivers/target/loopback/tcm_loop.c
+++ b/drivers/target/loopback/tcm_loop.c
@@ -121,13 +121,13 @@ static int tcm_loop_change_queue_depth(
 {
         switch (reason) {
         case SCSI_QDEPTH_DEFAULT:
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
+                scsi_adjust_queue_depth(sdev, depth);
                 break;
         case SCSI_QDEPTH_QFULL:
                 scsi_track_queue_full(sdev, depth);
                 break;
         case SCSI_QDEPTH_RAMP_UP:
-                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
+                scsi_adjust_queue_depth(sdev, depth);
                 break;
         default:
                 return -EOPNOTSUPP;
@@ -404,19 +404,6 @@ static int tcm_loop_slave_alloc(struct scsi_device *sd)
         return 0;
 }
 
-static int tcm_loop_slave_configure(struct scsi_device *sd)
-{
-        if (sd->tagged_supported) {
-                scsi_adjust_queue_depth(sd, MSG_SIMPLE_TAG,
-                                        sd->host->cmd_per_lun);
-        } else {
-                scsi_adjust_queue_depth(sd, 0,
-                                        sd->host->cmd_per_lun);
-        }
-
-        return 0;
-}
-
 static struct scsi_host_template tcm_loop_driver_template = {
         .show_info              = tcm_loop_show_info,
         .proc_name              = "tcm_loopback",
@@ -434,7 +421,6 @@ static struct scsi_host_template tcm_loop_driver_template = {
         .max_sectors            = 0xFFFF,
         .use_clustering         = DISABLE_CLUSTERING,
         .slave_alloc            = tcm_loop_slave_alloc,
-        .slave_configure        = tcm_loop_slave_configure,
         .module                 = THIS_MODULE,
         .use_blk_tags           = 1,
 };
diff --git a/drivers/usb/storage/uas.c b/drivers/usb/storage/uas.c
index ee69b82fc7d1..33f211b56a42 100644
--- a/drivers/usb/storage/uas.c
+++ b/drivers/usb/storage/uas.c
@@ -799,7 +799,7 @@ static int uas_slave_configure(struct scsi_device *sdev)
         if (devinfo->flags & US_FL_NO_REPORT_OPCODES)
                 sdev->no_report_opcodes = 1;
 
-        scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, devinfo->qdepth - 2);
+        scsi_adjust_queue_depth(sdev, devinfo->qdepth - 2);
         return 0;
 }