Merge branch 'upstream'

17 files changed, 115 insertions, 114 deletions

diff --git a/drivers/scsi/ahci.c b/drivers/scsi/ahci.c
index 24a54a5a91b8..1c2ab3dede71 100644
--- a/drivers/scsi/ahci.c
+++ b/drivers/scsi/ahci.c
@@ -211,7 +211,6 @@ static struct scsi_host_template ahci_sht = {
         .can_queue              = ATA_DEF_QUEUE,
         .this_id                = ATA_SHT_THIS_ID,
         .sg_tablesize           = AHCI_MAX_SG,
-        .max_sectors            = ATA_MAX_SECTORS,
         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
         .emulated               = ATA_SHT_EMULATED,
         .use_clustering         = AHCI_USE_CLUSTERING,
@@ -617,7 +616,8 @@ static void ahci_qc_prep(struct ata_queued_cmd *qc)
         ata_tf_to_fis(&qc->tf, pp->cmd_tbl, 0);
         if (is_atapi) {
                 memset(pp->cmd_tbl + AHCI_CMD_TBL_CDB, 0, 32);
-                memcpy(pp->cmd_tbl + AHCI_CMD_TBL_CDB, qc->cdb, ap->cdb_len);
+                memcpy(pp->cmd_tbl + AHCI_CMD_TBL_CDB, qc->cdb,
+                       qc->dev->cdb_len);
         }
 
         n_elem = 0;
diff --git a/drivers/scsi/ata_piix.c b/drivers/scsi/ata_piix.c
index 4933ba284885..4cc1108f721a 100644
--- a/drivers/scsi/ata_piix.c
+++ b/drivers/scsi/ata_piix.c
@@ -185,7 +185,6 @@ static struct scsi_host_template piix_sht = {
         .can_queue              = ATA_DEF_QUEUE,
         .this_id                = ATA_SHT_THIS_ID,
         .sg_tablesize           = LIBATA_MAX_PRD,
-        .max_sectors            = ATA_MAX_SECTORS,
         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
         .emulated               = ATA_SHT_EMULATED,
         .use_clustering         = ATA_SHT_USE_CLUSTERING,
@@ -415,9 +414,6 @@ static int piix_sata_probe (struct ata_port *ap)
         int orig_mask, mask, i;
         u8 pcs;
 
-        mask = (PIIX_PORT_PRESENT << ap->hard_port_no) |
-               (PIIX_PORT_ENABLED << ap->hard_port_no);
-
         pci_read_config_byte(pdev, ICH5_PCS, &pcs);
         orig_mask = (int) pcs & 0xff;
 
diff --git a/drivers/scsi/libata-core.c b/drivers/scsi/libata-core.c
index bfe0a00b1135..5ab220e9907c 100644
--- a/drivers/scsi/libata-core.c
+++ b/drivers/scsi/libata-core.c
@@ -520,6 +520,49 @@ void ata_dev_id_string(const u16 *id, unsigned char *s,
         }
 }
 
+/**
+ *      ata_dev_id_c_string - Convert IDENTIFY DEVICE page into C string
+ *      @id: IDENTIFY DEVICE results we will examine
+ *      @s: string into which data is output
+ *      @ofs: offset into identify device page
+ *      @len: length of string to return. must be an odd number.
+ *
+ *      This function is identical to ata_dev_id_string except that it
+ *      trims trailing spaces and terminates the resulting string with
+ *      null.  @len must be actual maximum length (even number) + 1.
+ *
+ *      LOCKING:
+ *      caller.
+ */
+void ata_dev_id_c_string(const u16 *id, unsigned char *s,
+                         unsigned int ofs, unsigned int len)
+{
+        unsigned char *p;
+
+        WARN_ON(!(len & 1));
+
+        ata_dev_id_string(id, s, ofs, len - 1);
+
+        p = s + strnlen(s, len - 1);
+        while (p > s && p[-1] == ' ')
+                p--;
+        *p = '\0';
+}
+
+static u64 ata_id_n_sectors(const u16 *id)
+{
+        if (ata_id_has_lba(id)) {
+                if (ata_id_has_lba48(id))
+                        return ata_id_u64(id, 100);
+                else
+                        return ata_id_u32(id, 60);
+        } else {
+                if (ata_id_current_chs_valid(id))
+                        return ata_id_u32(id, 57);
+                else
+                        return id[1] * id[3] * id[6];
+        }
+}
 
 /**
  *      ata_noop_dev_select - Select device 0/1 on ATA bus
@@ -609,41 +652,41 @@ void ata_dev_select(struct ata_port *ap, unsigned int device,
 
 /**
  *      ata_dump_id - IDENTIFY DEVICE info debugging output
- *      @dev: Device whose IDENTIFY DEVICE page we will dump
+ *      @id: IDENTIFY DEVICE page to dump
  *
- *      Dump selected 16-bit words from a detected device's
- *      IDENTIFY PAGE page.
+ *      Dump selected 16-bit words from the given IDENTIFY DEVICE
+ *      page.
  *
  *      LOCKING:
  *      caller.
  */
 
-static inline void ata_dump_id(const struct ata_device *dev)
+static inline void ata_dump_id(const u16 *id)
 {
         DPRINTK("49==0x%04x  "
                 "53==0x%04x  "
                 "63==0x%04x  "
                 "64==0x%04x  "
                 "75==0x%04x  \n",
-                dev->id[49],
-                dev->id[53],
-                dev->id[63],
-                dev->id[64],
-                dev->id[75]);
+                id[49],
+                id[53],
+                id[63],
+                id[64],
+                id[75]);
         DPRINTK("80==0x%04x  "
                 "81==0x%04x  "
                 "82==0x%04x  "
                 "83==0x%04x  "
                 "84==0x%04x  \n",
-                dev->id[80],
-                dev->id[81],
-                dev->id[82],
-                dev->id[83],
-                dev->id[84]);
+                id[80],
+                id[81],
+                id[82],
+                id[83],
+                id[84]);
         DPRINTK("88==0x%04x  "
                 "93==0x%04x\n",
-                dev->id[88],
-                dev->id[93]);
+                id[88],
+                id[93]);
 }
 
 /*
@@ -877,12 +920,11 @@ static void ata_dev_identify(struct ata_port *ap, unsigned int device)
 {
         struct ata_device *dev = &ap->device[device];
         unsigned int major_version;
-        u16 tmp;
         unsigned long xfer_modes;
         unsigned int using_edd;
         struct ata_taskfile tf;
         unsigned int err_mask;
-        int rc;
+        int i, rc;
 
         if (!ata_dev_present(dev)) {
                 DPRINTK("ENTER/EXIT (host %u, dev %u) -- nodev\n",
@@ -890,7 +932,8 @@ static void ata_dev_identify(struct ata_port *ap, unsigned int device)
                 return;
         }
 
-        if (ap->flags & (ATA_FLAG_SRST | ATA_FLAG_SATA_RESET))
+        if (ap->ops->probe_reset ||
+            ap->flags & (ATA_FLAG_SRST | ATA_FLAG_SATA_RESET))
                 using_edd = 0;
         else
                 using_edd = 1;
@@ -970,18 +1013,17 @@ retry:
         if (!xfer_modes)
                 xfer_modes = ata_pio_modes(dev);
 
-        ata_dump_id(dev);
+        ata_dump_id(dev->id);
 
         /* ATA-specific feature tests */
         if (dev->class == ATA_DEV_ATA) {
+                dev->n_sectors = ata_id_n_sectors(dev->id);
+
                 if (!ata_id_is_ata(dev->id))    /* sanity check */
                         goto err_out_nosup;
 
                 /* get major version */
-                tmp = dev->id[ATA_ID_MAJOR_VER];
-                for (major_version = 14; major_version >= 1; major_version--)
-                        if (tmp & (1 << major_version))
-                                break;
+                major_version = ata_id_major_version(dev->id);
 
                 /*
                  * The exact sequence expected by certain pre-ATA4 drives is:
@@ -1003,12 +1045,8 @@ retry:
                 if (ata_id_has_lba(dev->id)) {
                         dev->flags |= ATA_DFLAG_LBA;
 
-                        if (ata_id_has_lba48(dev->id)) {
+                        if (ata_id_has_lba48(dev->id))
                                 dev->flags |= ATA_DFLAG_LBA48;
-                                dev->n_sectors = ata_id_u64(dev->id, 100);
-                        } else {
-                                dev->n_sectors = ata_id_u32(dev->id, 60);
-                        }
 
                         /* print device info to dmesg */
                         printk(KERN_INFO "ata%u: dev %u ATA-%d, max %s, %Lu sectors:%s\n",
@@ -1024,15 +1062,12 @@ retry:
                         dev->cylinders  = dev->id[1];
                         dev->heads      = dev->id[3];
                         dev->sectors    = dev->id[6];
-                        dev->n_sectors  = dev->cylinders * dev->heads * dev->sectors;
 
                         if (ata_id_current_chs_valid(dev->id)) {
                                 /* Current CHS translation is valid. */
                                 dev->cylinders = dev->id[54];
                                 dev->heads     = dev->id[55];
                                 dev->sectors   = dev->id[56];
-                                
-                                dev->n_sectors = ata_id_u32(dev->id, 57);
                         }
 
                         /* print device info to dmesg */
@@ -1051,7 +1086,6 @@ retry:
                                 ap->id, device, dev->multi_count);
                 }
 
-                ap->host->max_cmd_len = 16;
         }
 
         /* ATAPI-specific feature tests */
@@ -1064,8 +1098,7 @@ retry:
                         printk(KERN_WARNING "ata%u: unsupported CDB len\n", ap->id);
                         goto err_out_nosup;
                 }
-                ap->cdb_len = (unsigned int) rc;
-                ap->host->max_cmd_len = (unsigned char) ap->cdb_len;
+                dev->cdb_len = (unsigned int) rc;
 
                 if (ata_id_cdb_intr(dev->id))
                         dev->flags |= ATA_DFLAG_CDB_INTR;
@@ -1076,6 +1109,12 @@ retry:
                        ata_mode_string(xfer_modes));
         }
 
+        ap->host->max_cmd_len = 0;
+        for (i = 0; i < ATA_MAX_DEVICES; i++)
+                ap->host->max_cmd_len = max_t(unsigned int,
+                                              ap->host->max_cmd_len,
+                                              ap->device[i].cdb_len);
+
         DPRINTK("EXIT, drv_stat = 0x%x\n", ata_chk_status(ap));
         return;
 
@@ -1088,9 +1127,10 @@ err_out:
 }
 
 
-static inline u8 ata_dev_knobble(const struct ata_port *ap)
+static inline u8 ata_dev_knobble(const struct ata_port *ap,
+                                 struct ata_device *dev)
 {
-        return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(ap->device->id)));
+        return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
 }
 
 /**
@@ -1104,13 +1144,11 @@ static inline u8 ata_dev_knobble(const struct ata_port *ap)
 void ata_dev_config(struct ata_port *ap, unsigned int i)
 {
         /* limit bridge transfers to udma5, 200 sectors */
-        if (ata_dev_knobble(ap)) {
+        if (ata_dev_knobble(ap, &ap->device[i])) {
                 printk(KERN_INFO "ata%u(%u): applying bridge limits\n",
-                        ap->id, ap->device->devno);
+                       ap->id, i);
                 ap->udma_mask &= ATA_UDMA5;
-                ap->host->max_sectors = ATA_MAX_SECTORS;
-                ap->host->hostt->max_sectors = ATA_MAX_SECTORS;
-                ap->device[i].flags |= ATA_DFLAG_LOCK_SECTORS;
+                ap->device[i].max_sectors = ATA_MAX_SECTORS;
         }
 
         if (ap->ops->dev_config)
@@ -1144,8 +1182,11 @@ static int ata_bus_probe(struct ata_port *ap)
 
                 rc = ap->ops->probe_reset(ap, classes);
                 if (rc == 0) {
-                        for (i = 0; i < ATA_MAX_DEVICES; i++)
+                        for (i = 0; i < ATA_MAX_DEVICES; i++) {
+                                if (classes[i] == ATA_DEV_UNKNOWN)
+                                        classes[i] = ATA_DEV_NONE;
                                 ap->device[i].class = classes[i];
+                        }
                 } else {
                         printk(KERN_ERR "ata%u: probe reset failed, "
                                "disabling port\n", ap->id);
@@ -2272,24 +2313,14 @@ static const char * const ata_dma_blacklist [] = {
 
 static int ata_dma_blacklisted(const struct ata_device *dev)
 {
-        unsigned char model_num[40];
-        char *s;
-        unsigned int len;
+        unsigned char model_num[41];
         int i;
 
-        ata_dev_id_string(dev->id, model_num, ATA_ID_PROD_OFS,
-                          sizeof(model_num));
-        s = &model_num[0];
-        len = strnlen(s, sizeof(model_num));
-
-        /* ATAPI specifies that empty space is blank-filled; remove blanks */
-        while ((len > 0) && (s[len - 1] == ' ')) {
-                len--;
-                s[len] = 0;
-        }
+        ata_dev_id_c_string(dev->id, model_num, ATA_ID_PROD_OFS,
+                            sizeof(model_num));
 
         for (i = 0; i < ARRAY_SIZE(ata_dma_blacklist); i++)
-                if (!strncmp(ata_dma_blacklist[i], s, len))
+                if (!strcmp(ata_dma_blacklist[i], model_num))
                         return 1;
 
         return 0;
@@ -2485,7 +2516,7 @@ static void ata_dev_reread_id(struct ata_port *ap, struct ata_device *dev)
 
         swap_buf_le16(dev->id, ATA_ID_WORDS);
 
-        ata_dump_id(dev);
+        ata_dump_id(dev->id);
 
         DPRINTK("EXIT\n");
 
@@ -5179,6 +5210,7 @@ EXPORT_SYMBOL_GPL(ata_scsi_release);
 EXPORT_SYMBOL_GPL(ata_host_intr);
 EXPORT_SYMBOL_GPL(ata_dev_classify);
 EXPORT_SYMBOL_GPL(ata_dev_id_string);
+EXPORT_SYMBOL_GPL(ata_dev_id_c_string);
 EXPORT_SYMBOL_GPL(ata_dev_config);
 EXPORT_SYMBOL_GPL(ata_scsi_simulate);
 EXPORT_SYMBOL_GPL(ata_eh_qc_complete);
diff --git a/drivers/scsi/libata-scsi.c b/drivers/scsi/libata-scsi.c
index 26f07a2617f9..86da46502b3e 100644
--- a/drivers/scsi/libata-scsi.c
+++ b/drivers/scsi/libata-scsi.c
@@ -684,23 +684,23 @@ int ata_scsi_slave_config(struct scsi_device *sdev)
         if (sdev->id < ATA_MAX_DEVICES) {
                 struct ata_port *ap;
                 struct ata_device *dev;
+                unsigned int max_sectors;
 
                 ap = (struct ata_port *) &sdev->host->hostdata[0];
                 dev = &ap->device[sdev->id];
 
-                /* TODO: 1024 is an arbitrary number, not the
+                /* TODO: 2048 is an arbitrary number, not the
                  * hardware maximum.  This should be increased to
                  * 65534 when Jens Axboe's patch for dynamically
                  * determining max_sectors is merged.
                  */
-                if ((dev->flags & ATA_DFLAG_LBA48) &&
-                    ((dev->flags & ATA_DFLAG_LOCK_SECTORS) == 0)) {
-                        /*
-                         * do not overwrite sdev->host->max_sectors, since
-                         * other drives on this host may not support LBA48
-                         */
-                        blk_queue_max_sectors(sdev->request_queue, 2048);
-                }
+                max_sectors = ATA_MAX_SECTORS;
+                if (dev->flags & ATA_DFLAG_LBA48)
+                        max_sectors = 2048;
+                if (dev->max_sectors)
+                        max_sectors = dev->max_sectors;
+
+                blk_queue_max_sectors(sdev->request_queue, max_sectors);
 
                 /*
                  * SATA DMA transfers must be multiples of 4 byte, so
@@ -1806,15 +1806,12 @@ static int ata_dev_supports_fua(u16 *id)
         if (!ata_id_has_fua(id))
                 return 0;
 
-        model[40] = '\0';
-        fw[8] = '\0';
-
-        ata_dev_id_string(id, model, ATA_ID_PROD_OFS, sizeof(model) - 1);
-        ata_dev_id_string(id, fw, ATA_ID_FW_REV_OFS, sizeof(fw) - 1);
+        ata_dev_id_c_string(id, model, ATA_ID_PROD_OFS, sizeof(model));
+        ata_dev_id_c_string(id, fw, ATA_ID_FW_REV_OFS, sizeof(fw));
 
-        if (strncmp(model, "Maxtor", 6))
+        if (strcmp(model, "Maxtor"))
                 return 1;
-        if (strncmp(fw, "BANC1G10", 8))
+        if (strcmp(fw, "BANC1G10"))
                 return 1;
 
         return 0; /* blacklisted */
@@ -2149,7 +2146,7 @@ static void atapi_request_sense(struct ata_queued_cmd *qc)
         ata_sg_init_one(qc, cmd->sense_buffer, sizeof(cmd->sense_buffer));
         qc->dma_dir = DMA_FROM_DEVICE;
 
-        memset(&qc->cdb, 0, ap->cdb_len);
+        memset(&qc->cdb, 0, qc->dev->cdb_len);
         qc->cdb[0] = REQUEST_SENSE;
         qc->cdb[4] = SCSI_SENSE_BUFFERSIZE;
 
@@ -2251,7 +2248,7 @@ static unsigned int atapi_xlat(struct ata_queued_cmd *qc, const u8 *scsicmd)
                 if (ata_check_atapi_dma(qc))
                         using_pio = 1;
 
-        memcpy(&qc->cdb, scsicmd, qc->ap->cdb_len);
+        memcpy(&qc->cdb, scsicmd, dev->cdb_len);
 
         qc->complete_fn = atapi_qc_complete;
 
diff --git a/drivers/scsi/pdc_adma.c b/drivers/scsi/pdc_adma.c
index 0f7e45a39fd9..f32af5dc58c4 100644
--- a/drivers/scsi/pdc_adma.c
+++ b/drivers/scsi/pdc_adma.c
@@ -148,7 +148,6 @@ static struct scsi_host_template adma_ata_sht = {
         .can_queue              = ATA_DEF_QUEUE,
         .this_id                = ATA_SHT_THIS_ID,
         .sg_tablesize           = LIBATA_MAX_PRD,
-        .max_sectors            = ATA_MAX_SECTORS,
         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
         .emulated               = ATA_SHT_EMULATED,
         .use_clustering         = ENABLE_CLUSTERING,
diff --git a/drivers/scsi/sata_mv.c b/drivers/scsi/sata_mv.c
index d35460ff5275..e05751e7aad4 100644
--- a/drivers/scsi/sata_mv.c
+++ b/drivers/scsi/sata_mv.c
@@ -383,7 +383,6 @@ static struct scsi_host_template mv_sht = {
         .can_queue              = MV_USE_Q_DEPTH,
         .this_id                = ATA_SHT_THIS_ID,
         .sg_tablesize           = MV_MAX_SG_CT / 2,
-        .max_sectors            = ATA_MAX_SECTORS,
         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
         .emulated               = ATA_SHT_EMULATED,
         .use_clustering         = ATA_SHT_USE_CLUSTERING,
diff --git a/drivers/scsi/sata_nv.c b/drivers/scsi/sata_nv.c
index 94dc2e1a8f30..5168db981dde 100644
--- a/drivers/scsi/sata_nv.c
+++ b/drivers/scsi/sata_nv.c
@@ -234,7 +234,6 @@ static struct scsi_host_template nv_sht = {
         .can_queue              = ATA_DEF_QUEUE,
         .this_id                = ATA_SHT_THIS_ID,
         .sg_tablesize           = LIBATA_MAX_PRD,
-        .max_sectors            = ATA_MAX_SECTORS,
         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
         .emulated               = ATA_SHT_EMULATED,
         .use_clustering         = ATA_SHT_USE_CLUSTERING,
diff --git a/drivers/scsi/sata_promise.c b/drivers/scsi/sata_promise.c
index a88b563ebcc4..7fa807d7d9e1 100644
--- a/drivers/scsi/sata_promise.c
+++ b/drivers/scsi/sata_promise.c
@@ -117,7 +117,6 @@ static struct scsi_host_template pdc_ata_sht = {
         .can_queue              = ATA_DEF_QUEUE,
         .this_id                = ATA_SHT_THIS_ID,
         .sg_tablesize           = LIBATA_MAX_PRD,
-        .max_sectors            = ATA_MAX_SECTORS,
         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
         .emulated               = ATA_SHT_EMULATED,
         .use_clustering         = ATA_SHT_USE_CLUSTERING,
diff --git a/drivers/scsi/sata_qstor.c b/drivers/scsi/sata_qstor.c
index 5730167d2e74..bfc1dc8e7779 100644
--- a/drivers/scsi/sata_qstor.c
+++ b/drivers/scsi/sata_qstor.c
@@ -137,7 +137,6 @@ static struct scsi_host_template qs_ata_sht = {
         .can_queue              = ATA_DEF_QUEUE,
         .this_id                = ATA_SHT_THIS_ID,
         .sg_tablesize           = QS_MAX_PRD,
-        .max_sectors            = ATA_MAX_SECTORS,
         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
         .emulated               = ATA_SHT_EMULATED,
         //FIXME .use_clustering         = ATA_SHT_USE_CLUSTERING,
diff --git a/drivers/scsi/sata_sil.c b/drivers/scsi/sata_sil.c
index bd2887741d78..15346888faf2 100644
--- a/drivers/scsi/sata_sil.c
+++ b/drivers/scsi/sata_sil.c
@@ -140,7 +140,6 @@ static struct scsi_host_template sil_sht = {
         .can_queue              = ATA_DEF_QUEUE,
         .this_id                = ATA_SHT_THIS_ID,
         .sg_tablesize           = LIBATA_MAX_PRD,
-        .max_sectors            = ATA_MAX_SECTORS,
         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
         .emulated               = ATA_SHT_EMULATED,
         .use_clustering         = ATA_SHT_USE_CLUSTERING,
@@ -337,22 +336,13 @@ static void sil_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
 static void sil_dev_config(struct ata_port *ap, struct ata_device *dev)
 {
         unsigned int n, quirks = 0;
-        unsigned char model_num[40];
-        const char *s;
-        unsigned int len;
+        unsigned char model_num[41];
 
-        ata_dev_id_string(dev->id, model_num, ATA_ID_PROD_OFS,
-                          sizeof(model_num));
-        s = &model_num[0];
-        len = strnlen(s, sizeof(model_num));
-
-        /* ATAPI specifies that empty space is blank-filled; remove blanks */
-        while ((len > 0) && (s[len - 1] == ' '))
-                len--;
+        ata_dev_id_c_string(dev->id, model_num, ATA_ID_PROD_OFS,
+                            sizeof(model_num));
 
         for (n = 0; sil_blacklist[n].product; n++)
-                if (!memcmp(sil_blacklist[n].product, s,
-                            strlen(sil_blacklist[n].product))) {
+                if (!strcmp(sil_blacklist[n].product, model_num)) {
                         quirks = sil_blacklist[n].quirk;
                         break;
                 }
@@ -363,16 +353,14 @@ static void sil_dev_config(struct ata_port *ap, struct ata_device *dev)
              (quirks & SIL_QUIRK_MOD15WRITE))) {
                 printk(KERN_INFO "ata%u(%u): applying Seagate errata fix (mod15write workaround)\n",
                        ap->id, dev->devno);
-                ap->host->max_sectors = 15;
-                ap->host->hostt->max_sectors = 15;
-                dev->flags |= ATA_DFLAG_LOCK_SECTORS;
+                dev->max_sectors = 15;
                 return;
         }
 
         /* limit to udma5 */
         if (quirks & SIL_QUIRK_UDMA5MAX) {
                 printk(KERN_INFO "ata%u(%u): applying Maxtor errata fix %s\n",
-                       ap->id, dev->devno, s);
+                       ap->id, dev->devno, model_num);
                 ap->udma_mask &= ATA_UDMA5;
                 return;
         }
diff --git a/drivers/scsi/sata_sil24.c b/drivers/scsi/sata_sil24.c
index 228a7fabffff..a0e35a262156 100644
--- a/drivers/scsi/sata_sil24.c
+++ b/drivers/scsi/sata_sil24.c
@@ -285,7 +285,6 @@ static struct scsi_host_template sil24_sht = {
         .can_queue              = ATA_DEF_QUEUE,
         .this_id                = ATA_SHT_THIS_ID,
         .sg_tablesize           = LIBATA_MAX_PRD,
-        .max_sectors            = ATA_MAX_SECTORS,
         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
         .emulated               = ATA_SHT_EMULATED,
         .use_clustering         = ATA_SHT_USE_CLUSTERING,
@@ -371,7 +370,7 @@ static void sil24_dev_config(struct ata_port *ap, struct ata_device *dev)
 {
         void __iomem *port = (void __iomem *)ap->ioaddr.cmd_addr;
 
-        if (ap->cdb_len == 16)
+        if (dev->cdb_len == 16)
                 writel(PORT_CS_CDB16, port + PORT_CTRL_STAT);
         else
                 writel(PORT_CS_CDB16, port + PORT_CTRL_CLR);
@@ -543,7 +542,7 @@ static void sil24_qc_prep(struct ata_queued_cmd *qc)
                 prb = &cb->atapi.prb;
                 sge = cb->atapi.sge;
                 memset(cb->atapi.cdb, 0, 32);
-                memcpy(cb->atapi.cdb, qc->cdb, ap->cdb_len);
+                memcpy(cb->atapi.cdb, qc->cdb, qc->dev->cdb_len);
 
                 if (qc->tf.protocol != ATA_PROT_ATAPI_NODATA) {
                         if (qc->tf.flags & ATA_TFLAG_WRITE)
diff --git a/drivers/scsi/sata_sis.c b/drivers/scsi/sata_sis.c
index 2f1815715705..7fd45f86de99 100644
--- a/drivers/scsi/sata_sis.c
+++ b/drivers/scsi/sata_sis.c
@@ -92,7 +92,6 @@ static struct scsi_host_template sis_sht = {
         .can_queue              = ATA_DEF_QUEUE,
         .this_id                = ATA_SHT_THIS_ID,
         .sg_tablesize           = ATA_MAX_PRD,
-        .max_sectors            = ATA_MAX_SECTORS,
         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
         .emulated               = ATA_SHT_EMULATED,
         .use_clustering         = ATA_SHT_USE_CLUSTERING,
diff --git a/drivers/scsi/sata_svw.c b/drivers/scsi/sata_svw.c
index f369c3003adf..4aaccd53e736 100644
--- a/drivers/scsi/sata_svw.c
+++ b/drivers/scsi/sata_svw.c
@@ -293,7 +293,6 @@ static struct scsi_host_template k2_sata_sht = {
         .can_queue              = ATA_DEF_QUEUE,
         .this_id                = ATA_SHT_THIS_ID,
         .sg_tablesize           = LIBATA_MAX_PRD,
-        .max_sectors            = ATA_MAX_SECTORS,
         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
         .emulated               = ATA_SHT_EMULATED,
         .use_clustering         = ATA_SHT_USE_CLUSTERING,
diff --git a/drivers/scsi/sata_sx4.c b/drivers/scsi/sata_sx4.c
index 04465fb86e1d..60ebe5ce32c4 100644
--- a/drivers/scsi/sata_sx4.c
+++ b/drivers/scsi/sata_sx4.c
@@ -187,7 +187,6 @@ static struct scsi_host_template pdc_sata_sht = {
         .can_queue              = ATA_DEF_QUEUE,
         .this_id                = ATA_SHT_THIS_ID,
         .sg_tablesize           = LIBATA_MAX_PRD,
-        .max_sectors            = ATA_MAX_SECTORS,
         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
         .emulated               = ATA_SHT_EMULATED,
         .use_clustering         = ATA_SHT_USE_CLUSTERING,
diff --git a/drivers/scsi/sata_uli.c b/drivers/scsi/sata_uli.c
index c500f2490902..37a487b7d655 100644
--- a/drivers/scsi/sata_uli.c
+++ b/drivers/scsi/sata_uli.c
@@ -80,7 +80,6 @@ static struct scsi_host_template uli_sht = {
         .can_queue              = ATA_DEF_QUEUE,
         .this_id                = ATA_SHT_THIS_ID,
         .sg_tablesize           = LIBATA_MAX_PRD,
-        .max_sectors            = ATA_MAX_SECTORS,
         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
         .emulated               = ATA_SHT_EMULATED,
         .use_clustering         = ATA_SHT_USE_CLUSTERING,
diff --git a/drivers/scsi/sata_via.c b/drivers/scsi/sata_via.c
index 2e20887dc88f..ff65a0b0457f 100644
--- a/drivers/scsi/sata_via.c
+++ b/drivers/scsi/sata_via.c
@@ -99,7 +99,6 @@ static struct scsi_host_template svia_sht = {
         .can_queue              = ATA_DEF_QUEUE,
         .this_id                = ATA_SHT_THIS_ID,
         .sg_tablesize           = LIBATA_MAX_PRD,
-        .max_sectors            = ATA_MAX_SECTORS,
         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
         .emulated               = ATA_SHT_EMULATED,
         .use_clustering         = ATA_SHT_USE_CLUSTERING,
diff --git a/drivers/scsi/sata_vsc.c b/drivers/scsi/sata_vsc.c
index 4cfc03018ca3..976a6b124af9 100644
--- a/drivers/scsi/sata_vsc.c
+++ b/drivers/scsi/sata_vsc.c
@@ -228,7 +228,6 @@ static struct scsi_host_template vsc_sata_sht = {
         .can_queue              = ATA_DEF_QUEUE,
         .this_id                = ATA_SHT_THIS_ID,
         .sg_tablesize           = LIBATA_MAX_PRD,
-        .max_sectors            = ATA_MAX_SECTORS,
         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
         .emulated               = ATA_SHT_EMULATED,
         .use_clustering         = ATA_SHT_USE_CLUSTERING,