1 files changed, 75 insertions, 71 deletions

diff --git a/drivers/scsi/libata-scsi.c b/drivers/scsi/libata-scsi.c
index bb30fcdc9297..2282c04fee46 100644
--- a/drivers/scsi/libata-scsi.c
+++ b/drivers/scsi/libata-scsi.c
@@ -38,6 +38,7 @@
 #include <linux/spinlock.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_host.h>
+#include <scsi/scsi_eh.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_request.h>
 #include <linux/libata.h>
@@ -147,7 +148,8 @@ int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg)
         u8 scsi_cmd[MAX_COMMAND_SIZE];
         u8 args[4], *argbuf = NULL;
         int argsize = 0;
-        struct scsi_request *sreq;
+        struct scsi_sense_hdr sshdr;
+        enum dma_data_direction data_dir;
 
         if (NULL == (void *)arg)
                 return -EINVAL;
@@ -155,10 +157,6 @@ int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg)
         if (copy_from_user(args, arg, sizeof(args)))
                 return -EFAULT;
 
-        sreq = scsi_allocate_request(scsidev, GFP_KERNEL);
-        if (!sreq)
-                return -EINTR;
-
         memset(scsi_cmd, 0, sizeof(scsi_cmd));
 
         if (args[3]) {
@@ -172,11 +170,11 @@ int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg)
                 scsi_cmd[1]  = (4 << 1); /* PIO Data-in */
                 scsi_cmd[2]  = 0x0e;     /* no off.line or cc, read from dev,
                                             block count in sector count field */
-                sreq->sr_data_direction = DMA_FROM_DEVICE;
+                data_dir = DMA_FROM_DEVICE;
         } else {
                 scsi_cmd[1]  = (3 << 1); /* Non-data */
                 /* scsi_cmd[2] is already 0 -- no off.line, cc, or data xfer */
-                sreq->sr_data_direction = DMA_NONE;
+                data_dir = DMA_NONE;
         }
 
         scsi_cmd[0] = ATA_16;
@@ -194,9 +192,8 @@ int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg)
 
         /* Good values for timeout and retries?  Values below
            from scsi_ioctl_send_command() for default case... */
-        scsi_wait_req(sreq, scsi_cmd, argbuf, argsize, (10*HZ), 5);
-
-        if (sreq->sr_result) {
+        if (scsi_execute_req(scsidev, scsi_cmd, data_dir, argbuf, argsize,
+                             &sshdr, (10*HZ), 5)) {
                 rc = -EIO;
                 goto error;
         }
@@ -207,8 +204,6 @@ int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg)
          && copy_to_user((void *)(arg + sizeof(args)), argbuf, argsize))
                 rc = -EFAULT;
 error:
-        scsi_release_request(sreq);
-
         if (argbuf)
                 kfree(argbuf);
 
@@ -231,7 +226,7 @@ int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
         int rc = 0;
         u8 scsi_cmd[MAX_COMMAND_SIZE];
         u8 args[7];
-        struct scsi_request *sreq;
+        struct scsi_sense_hdr sshdr;
 
         if (NULL == (void *)arg)
                 return -EINVAL;
@@ -250,26 +245,13 @@ int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
         scsi_cmd[12] = args[5];
         scsi_cmd[14] = args[0];
 
-        sreq = scsi_allocate_request(scsidev, GFP_KERNEL);
-        if (!sreq) {
-                rc = -EINTR;
-                goto error;
-        }
-
-        sreq->sr_data_direction = DMA_NONE;
         /* Good values for timeout and retries?  Values below
-           from scsi_ioctl_send_command() for default case... */
-        scsi_wait_req(sreq, scsi_cmd, NULL, 0, (10*HZ), 5);
-
-        if (sreq->sr_result) {
+           from scsi_ioctl_send_command() for default case... */        
+        if (scsi_execute_req(scsidev, scsi_cmd, DMA_NONE, NULL, 0, &sshdr,
+                             (10*HZ), 5))
                 rc = -EIO;
-                goto error;
-        }
 
         /* Need code to retrieve data from check condition? */
-
-error:
-        scsi_release_request(sreq);
         return rc;
 }
 
@@ -1129,6 +1111,8 @@ static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, const u8 *scsicm
                  * length 0 means transfer 0 block of data.
                  * However, for ATA R/W commands, sector count 0 means
                  * 256 or 65536 sectors, not 0 sectors as in SCSI.
+                 *
+                 * WARNING: one or two older ATA drives treat 0 as 0...
                  */
                 goto nothing_to_do;
 
@@ -1971,22 +1955,44 @@ void ata_scsi_badcmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *), u8
         done(cmd);
 }
 
-void atapi_request_sense(struct ata_port *ap, struct ata_device *dev,
-                         struct scsi_cmnd *cmd)
+static int atapi_sense_complete(struct ata_queued_cmd *qc,unsigned int err_mask)
 {
-        DECLARE_COMPLETION(wait);
-        struct ata_queued_cmd *qc;
-        unsigned long flags;
-        int rc;
+        if (err_mask && ((err_mask & AC_ERR_DEV) == 0))
+                /* FIXME: not quite right; we don't want the
+                 * translation of taskfile registers into
+                 * a sense descriptors, since that's only
+                 * correct for ATA, not ATAPI
+                 */
+                ata_gen_ata_desc_sense(qc);
 
-        DPRINTK("ATAPI request sense\n");
+        qc->scsidone(qc->scsicmd);
+        return 0;
+}
 
-        qc = ata_qc_new_init(ap, dev);
-        BUG_ON(qc == NULL);
+/* is it pointless to prefer PIO for "safety reasons"? */
+static inline int ata_pio_use_silly(struct ata_port *ap)
+{
+        return (ap->flags & ATA_FLAG_PIO_DMA);
+}
+
+static void atapi_request_sense(struct ata_queued_cmd *qc)
+{
+        struct ata_port *ap = qc->ap;
+        struct scsi_cmnd *cmd = qc->scsicmd;
+
+        DPRINTK("ATAPI request sense\n");
 
         /* FIXME: is this needed? */
         memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
 
+        ap->ops->tf_read(ap, &qc->tf);
+
+        /* fill these in, for the case where they are -not- overwritten */
+        cmd->sense_buffer[0] = 0x70;
+        cmd->sense_buffer[2] = qc->tf.feature >> 4;
+
+        ata_qc_reinit(qc);
+
         ata_sg_init_one(qc, cmd->sense_buffer, sizeof(cmd->sense_buffer));
         qc->dma_dir = DMA_FROM_DEVICE;
 
@@ -1997,22 +2003,20 @@ void atapi_request_sense(struct ata_port *ap, struct ata_device *dev,
         qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
         qc->tf.command = ATA_CMD_PACKET;
 
-        qc->tf.protocol = ATA_PROT_ATAPI;
-        qc->tf.lbam = (8 * 1024) & 0xff;
-        qc->tf.lbah = (8 * 1024) >> 8;
+        if (ata_pio_use_silly(ap)) {
+                qc->tf.protocol = ATA_PROT_ATAPI_DMA;
+                qc->tf.feature |= ATAPI_PKT_DMA;
+        } else {
+                qc->tf.protocol = ATA_PROT_ATAPI;
+                qc->tf.lbam = (8 * 1024) & 0xff;
+                qc->tf.lbah = (8 * 1024) >> 8;
+        }
         qc->nbytes = SCSI_SENSE_BUFFERSIZE;
 
-        qc->waiting = &wait;
-        qc->complete_fn = ata_qc_complete_noop;
-
-        spin_lock_irqsave(&ap->host_set->lock, flags);
-        rc = ata_qc_issue(qc);
-        spin_unlock_irqrestore(&ap->host_set->lock, flags);
+        qc->complete_fn = atapi_sense_complete;
 
-        if (rc)
-                ata_port_disable(ap);
-        else
-                wait_for_completion(&wait);
+        if (ata_qc_issue(qc))
+                ata_qc_complete(qc, AC_ERR_OTHER);
 
         DPRINTK("EXIT\n");
 }
@@ -2024,19 +2028,8 @@ static int atapi_qc_complete(struct ata_queued_cmd *qc, unsigned int err_mask)
         VPRINTK("ENTER, err_mask 0x%X\n", err_mask);
 
         if (unlikely(err_mask & AC_ERR_DEV)) {
-                DPRINTK("request check condition\n");
-
-                /* FIXME: command completion with check condition
-                 * but no sense causes the error handler to run,
-                 * which then issues REQUEST SENSE, fills in the sense 
-                 * buffer, and completes the command (for the second
-                 * time).  We need to issue REQUEST SENSE some other
-                 * way, to avoid completing the command twice.
-                 */
                 cmd->result = SAM_STAT_CHECK_CONDITION;
-
-                qc->scsidone(cmd);
-
+                atapi_request_sense(qc);
                 return 1;
         }
 
@@ -2051,7 +2044,7 @@ static int atapi_qc_complete(struct ata_queued_cmd *qc, unsigned int err_mask)
         else {
                 u8 *scsicmd = cmd->cmnd;
 
-                if (scsicmd[0] == INQUIRY) {
+                if ((scsicmd[0] == INQUIRY) && ((scsicmd[1] & 0x03) == 0)) {
                         u8 *buf = NULL;
                         unsigned int buflen;
 
@@ -2065,9 +2058,6 @@ static int atapi_qc_complete(struct ata_queued_cmd *qc, unsigned int err_mask)
          * device.  2) Ensure response data format / ATAPI information
          * are always correct.
          */
-        /* FIXME: do we ever override EVPD pages and the like, with
-         * this code?
-         */
                         if (buf[2] == 0) {
                                 buf[2] = 0x5;
                                 buf[3] = 0x32;
@@ -2180,9 +2170,12 @@ ata_scsi_find_dev(struct ata_port *ap, const struct scsi_device *scsidev)
         if (unlikely(!ata_dev_present(dev)))
                 return NULL;
 
-        if (!atapi_enabled) {
-                if (unlikely(dev->class == ATA_DEV_ATAPI))
+        if (!atapi_enabled || (ap->flags & ATA_FLAG_NO_ATAPI)) {
+                if (unlikely(dev->class == ATA_DEV_ATAPI)) {
+                        printk(KERN_WARNING "ata%u(%u): WARNING: ATAPI is %s, device ignored.\n",
+                               ap->id, dev->devno, atapi_enabled ? "not supported with this driver" : "disabled");
                         return NULL;
+                }
         }
 
         return dev;
@@ -2246,7 +2239,7 @@ ata_scsi_pass_thru(struct ata_queued_cmd *qc, const u8 *scsicmd)
         struct scsi_cmnd *cmd = qc->scsicmd;
 
         if ((tf->protocol = ata_scsi_map_proto(scsicmd[1])) == ATA_PROT_UNKNOWN)
-                return 1;
+                goto invalid_fld;
 
         /*
          * 12 and 16 byte CDBs use different offsets to
@@ -2292,6 +2285,12 @@ ata_scsi_pass_thru(struct ata_queued_cmd *qc, const u8 *scsicmd)
                 tf->device = scsicmd[8];
                 tf->command = scsicmd[9];
         }
+        /*
+         * If slave is possible, enforce correct master/slave bit
+        */
+        if (qc->ap->flags & ATA_FLAG_SLAVE_POSS)
+                tf->device = qc->dev->devno ?
+                        tf->device | ATA_DEV1 : tf->device & ~ATA_DEV1;
 
         /*
          * Filter SET_FEATURES - XFER MODE command -- otherwise,
@@ -2302,7 +2301,7 @@ ata_scsi_pass_thru(struct ata_queued_cmd *qc, const u8 *scsicmd)
          */
         if ((tf->command == ATA_CMD_SET_FEATURES)
          && (tf->feature == SETFEATURES_XFER))
-                return 1;
+                goto invalid_fld;
 
         /*
          * Set flags so that all registers will be written,
@@ -2323,6 +2322,11 @@ ata_scsi_pass_thru(struct ata_queued_cmd *qc, const u8 *scsicmd)
         qc->nsect = cmd->bufflen / ATA_SECT_SIZE;
 
         return 0;
+
+ invalid_fld:
+        ata_scsi_set_sense(qc->scsicmd, ILLEGAL_REQUEST, 0x24, 0x00);
+        /* "Invalid field in cdb" */
+        return 1;
 }
 
 /**