1 files changed, 198 insertions, 111 deletions

diff --git a/drivers/ide/ide-atapi.c b/drivers/ide/ide-atapi.c
index 7201b176d75b..eb2181a6a11c 100644
--- a/drivers/ide/ide-atapi.c
+++ b/drivers/ide/ide-atapi.c
@@ -10,6 +10,9 @@
 
 #include <scsi/scsi.h>
 
+#define DRV_NAME "ide-atapi"
+#define PFX DRV_NAME ": "
+
 #ifdef DEBUG
 #define debug_log(fmt, args...) \
         printk(KERN_INFO "ide: " fmt, ## args)
@@ -74,64 +77,36 @@ EXPORT_SYMBOL_GPL(ide_check_atapi_device);
 void ide_init_pc(struct ide_atapi_pc *pc)
 {
         memset(pc, 0, sizeof(*pc));
-        pc->buf = pc->pc_buf;
-        pc->buf_size = IDE_PC_BUFFER_SIZE;
 }
 EXPORT_SYMBOL_GPL(ide_init_pc);
 
 /*
- * Generate a new packet command request in front of the request queue, before
- * the current request, so that it will be processed immediately, on the next
- * pass through the driver.
- */
-static void ide_queue_pc_head(ide_drive_t *drive, struct gendisk *disk,
-                              struct ide_atapi_pc *pc, struct request *rq)
-{
-        blk_rq_init(NULL, rq);
-        rq->cmd_type = REQ_TYPE_SPECIAL;
-        rq->cmd_flags |= REQ_PREEMPT;
-        rq->buffer = (char *)pc;
-        rq->rq_disk = disk;
-
-        if (pc->req_xfer) {
-                rq->data = pc->buf;
-                rq->data_len = pc->req_xfer;
-        }
-
-        memcpy(rq->cmd, pc->c, 12);
-        if (drive->media == ide_tape)
-                rq->cmd[13] = REQ_IDETAPE_PC1;
-
-        drive->hwif->rq = NULL;
-
-        elv_add_request(drive->queue, rq, ELEVATOR_INSERT_FRONT, 0);
-}
-
-/*
  * Add a special packet command request to the tail of the request queue,
  * and wait for it to be serviced.
  */
 int ide_queue_pc_tail(ide_drive_t *drive, struct gendisk *disk,
-                      struct ide_atapi_pc *pc)
+                      struct ide_atapi_pc *pc, void *buf, unsigned int bufflen)
 {
         struct request *rq;
         int error;
 
         rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
         rq->cmd_type = REQ_TYPE_SPECIAL;
-        rq->buffer = (char *)pc;
+        rq->special = (char *)pc;
 
-        if (pc->req_xfer) {
-                rq->data = pc->buf;
-                rq->data_len = pc->req_xfer;
+        if (buf && bufflen) {
+                error = blk_rq_map_kern(drive->queue, rq, buf, bufflen,
+                                        GFP_NOIO);
+                if (error)
+                        goto put_req;
         }
 
         memcpy(rq->cmd, pc->c, 12);
         if (drive->media == ide_tape)
                 rq->cmd[13] = REQ_IDETAPE_PC1;
         error = blk_execute_rq(drive->queue, disk, rq, 0);
+put_req:
         blk_put_request(rq);
-
         return error;
 }
 EXPORT_SYMBOL_GPL(ide_queue_pc_tail);
@@ -143,7 +118,7 @@ int ide_do_test_unit_ready(ide_drive_t *drive, struct gendisk *disk)
         ide_init_pc(&pc);
         pc.c[0] = TEST_UNIT_READY;
 
-        return ide_queue_pc_tail(drive, disk, &pc);
+        return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
 }
 EXPORT_SYMBOL_GPL(ide_do_test_unit_ready);
 
@@ -158,7 +133,7 @@ int ide_do_start_stop(ide_drive_t *drive, struct gendisk *disk, int start)
         if (drive->media == ide_tape)
                 pc.flags |= PC_FLAG_WAIT_FOR_DSC;
 
-        return ide_queue_pc_tail(drive, disk, &pc);
+        return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
 }
 EXPORT_SYMBOL_GPL(ide_do_start_stop);
 
@@ -173,7 +148,7 @@ int ide_set_media_lock(ide_drive_t *drive, struct gendisk *disk, int on)
         pc.c[0] = ALLOW_MEDIUM_REMOVAL;
         pc.c[4] = on;
 
-        return ide_queue_pc_tail(drive, disk, &pc);
+        return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
 }
 EXPORT_SYMBOL_GPL(ide_set_media_lock);
 
@@ -191,20 +166,109 @@ void ide_create_request_sense_cmd(ide_drive_t *drive, struct ide_atapi_pc *pc)
 }
 EXPORT_SYMBOL_GPL(ide_create_request_sense_cmd);
 
+void ide_prep_sense(ide_drive_t *drive, struct request *rq)
+{
+        struct request_sense *sense = &drive->sense_data;
+        struct request *sense_rq = &drive->sense_rq;
+        unsigned int cmd_len, sense_len;
+        int err;
+
+        switch (drive->media) {
+        case ide_floppy:
+                cmd_len = 255;
+                sense_len = 18;
+                break;
+        case ide_tape:
+                cmd_len = 20;
+                sense_len = 20;
+                break;
+        default:
+                cmd_len = 18;
+                sense_len = 18;
+        }
+
+        BUG_ON(sense_len > sizeof(*sense));
+
+        if (blk_sense_request(rq) || drive->sense_rq_armed)
+                return;
+
+        memset(sense, 0, sizeof(*sense));
+
+        blk_rq_init(rq->q, sense_rq);
+
+        err = blk_rq_map_kern(drive->queue, sense_rq, sense, sense_len,
+                              GFP_NOIO);
+        if (unlikely(err)) {
+                if (printk_ratelimit())
+                        printk(KERN_WARNING PFX "%s: failed to map sense "
+                                            "buffer\n", drive->name);
+                return;
+        }
+
+        sense_rq->rq_disk = rq->rq_disk;
+        sense_rq->cmd[0] = GPCMD_REQUEST_SENSE;
+        sense_rq->cmd[4] = cmd_len;
+        sense_rq->cmd_type = REQ_TYPE_SENSE;
+        sense_rq->cmd_flags |= REQ_PREEMPT;
+
+        if (drive->media == ide_tape)
+                sense_rq->cmd[13] = REQ_IDETAPE_PC1;
+
+        drive->sense_rq_armed = true;
+}
+EXPORT_SYMBOL_GPL(ide_prep_sense);
+
+int ide_queue_sense_rq(ide_drive_t *drive, void *special)
+{
+        /* deferred failure from ide_prep_sense() */
+        if (!drive->sense_rq_armed) {
+                printk(KERN_WARNING PFX "%s: error queuing a sense request\n",
+                       drive->name);
+                return -ENOMEM;
+        }
+
+        drive->sense_rq.special = special;
+        drive->sense_rq_armed = false;
+
+        drive->hwif->rq = NULL;
+
+        elv_add_request(drive->queue, &drive->sense_rq,
+                        ELEVATOR_INSERT_FRONT, 0);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(ide_queue_sense_rq);
+
 /*
  * Called when an error was detected during the last packet command.
- * We queue a request sense packet command in the head of the request list.
+ * We queue a request sense packet command at the head of the request
+ * queue.
  */
-void ide_retry_pc(ide_drive_t *drive, struct gendisk *disk)
+void ide_retry_pc(ide_drive_t *drive)
 {
-        struct request *rq = &drive->request_sense_rq;
+        struct request *failed_rq = drive->hwif->rq;
+        struct request *sense_rq = &drive->sense_rq;
         struct ide_atapi_pc *pc = &drive->request_sense_pc;
 
         (void)ide_read_error(drive);
-        ide_create_request_sense_cmd(drive, pc);
+
+        /* init pc from sense_rq */
+        ide_init_pc(pc);
+        memcpy(pc->c, sense_rq->cmd, 12);
+
         if (drive->media == ide_tape)
-                set_bit(IDE_AFLAG_IGNORE_DSC, &drive->atapi_flags);
-        ide_queue_pc_head(drive, disk, pc, rq);
+                drive->atapi_flags |= IDE_AFLAG_IGNORE_DSC;
+
+        /*
+         * Push back the failed request and put request sense on top
+         * of it.  The failed command will be retried after sense data
+         * is acquired.
+         */
+        blk_requeue_request(failed_rq->q, failed_rq);
+        drive->hwif->rq = NULL;
+        if (ide_queue_sense_rq(drive, pc)) {
+                blk_start_request(failed_rq);
+                ide_complete_rq(drive, -EIO, blk_rq_bytes(failed_rq));
+        }
 }
 EXPORT_SYMBOL_GPL(ide_retry_pc);
 
@@ -231,7 +295,7 @@ int ide_cd_expiry(ide_drive_t *drive)
                 break;
         default:
                 if (!(rq->cmd_flags & REQ_QUIET))
-                        printk(KERN_INFO "cmd 0x%x timed out\n",
+                        printk(KERN_INFO PFX "cmd 0x%x timed out\n",
                                          rq->cmd[0]);
                 wait = 0;
                 break;
@@ -246,7 +310,7 @@ int ide_cd_get_xferlen(struct request *rq)
                 return 32768;
         else if (blk_sense_request(rq) || blk_pc_request(rq) ||
                          rq->cmd_type == REQ_TYPE_ATA_PC)
-                return rq->data_len;
+                return blk_rq_bytes(rq);
         else
                 return 0;
 }
@@ -265,6 +329,55 @@ void ide_read_bcount_and_ireason(ide_drive_t *drive, u16 *bcount, u8 *ireason)
 EXPORT_SYMBOL_GPL(ide_read_bcount_and_ireason);
 
 /*
+ * Check the contents of the interrupt reason register and attempt to recover if
+ * there are problems.
+ *
+ * Returns:
+ * - 0 if everything's ok
+ * - 1 if the request has to be terminated.
+ */
+int ide_check_ireason(ide_drive_t *drive, struct request *rq, int len,
+                      int ireason, int rw)
+{
+        ide_hwif_t *hwif = drive->hwif;
+
+        debug_log("ireason: 0x%x, rw: 0x%x\n", ireason, rw);
+
+        if (ireason == (!rw << 1))
+                return 0;
+        else if (ireason == (rw << 1)) {
+                printk(KERN_ERR PFX "%s: %s: wrong transfer direction!\n",
+                                drive->name, __func__);
+
+                if (dev_is_idecd(drive))
+                        ide_pad_transfer(drive, rw, len);
+        } else if (!rw && ireason == ATAPI_COD) {
+                if (dev_is_idecd(drive)) {
+                        /*
+                         * Some drives (ASUS) seem to tell us that status info
+                         * is available.  Just get it and ignore.
+                         */
+                        (void)hwif->tp_ops->read_status(hwif);
+                        return 0;
+                }
+        } else {
+                if (ireason & ATAPI_COD)
+                        printk(KERN_ERR PFX "%s: CoD != 0 in %s\n", drive->name,
+                                        __func__);
+
+                /* drive wants a command packet, or invalid ireason... */
+                printk(KERN_ERR PFX "%s: %s: bad interrupt reason 0x%02x\n",
+                                drive->name, __func__, ireason);
+        }
+
+        if (dev_is_idecd(drive) && rq->cmd_type == REQ_TYPE_ATA_PC)
+                rq->cmd_flags |= REQ_FAILED;
+
+        return 1;
+}
+EXPORT_SYMBOL_GPL(ide_check_ireason);
+
+/*
  * This is the usual interrupt handler which will be called during a packet
  * command.  We will transfer some of the data (as requested by the drive)
  * and will re-point interrupt handler to us.
@@ -276,7 +389,6 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
         struct ide_cmd *cmd = &hwif->cmd;
         struct request *rq = hwif->rq;
         const struct ide_tp_ops *tp_ops = hwif->tp_ops;
-        xfer_func_t *xferfunc;
         unsigned int timeout, done;
         u16 bcount;
         u8 stat, ireason, dsc = 0;
@@ -299,25 +411,21 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
 
                 if (rc || (drive->media == ide_tape && (stat & ATA_ERR))) {
                         if (drive->media == ide_floppy)
-                                printk(KERN_ERR "%s: DMA %s error\n",
+                                printk(KERN_ERR PFX "%s: DMA %s error\n",
                                         drive->name, rq_data_dir(pc->rq)
                                                      ? "write" : "read");
                         pc->flags |= PC_FLAG_DMA_ERROR;
-                } else {
-                        pc->xferred = pc->req_xfer;
-                        if (drive->pc_update_buffers)
-                                drive->pc_update_buffers(drive, pc);
-                }
+                } else
+                        rq->resid_len = 0;
                 debug_log("%s: DMA finished\n", drive->name);
         }
 
         /* No more interrupts */
         if ((stat & ATA_DRQ) == 0) {
                 int uptodate, error;
-                unsigned int done;
 
                 debug_log("Packet command completed, %d bytes transferred\n",
-                          pc->xferred);
+                          blk_rq_bytes(rq));
 
                 pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;
 
@@ -335,15 +443,15 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
                                 pc->rq->errors++;
 
                         if (rq->cmd[0] == REQUEST_SENSE) {
-                                printk(KERN_ERR "%s: I/O error in request sense"
-                                                " command\n", drive->name);
+                                printk(KERN_ERR PFX "%s: I/O error in request "
+                                                "sense command\n", drive->name);
                                 return ide_do_reset(drive);
                         }
 
                         debug_log("[cmd %x]: check condition\n", rq->cmd[0]);
 
                         /* Retry operation */
-                        ide_retry_pc(drive, rq->rq_disk);
+                        ide_retry_pc(drive);
 
                         /* queued, but not started */
                         return ide_stopped;
@@ -353,6 +461,12 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
                 if ((pc->flags & PC_FLAG_WAIT_FOR_DSC) && (stat & ATA_DSC) == 0)
                         dsc = 1;
 
+                /*
+                 * ->pc_callback() might change rq->data_len for
+                 * residual count, cache total length.
+                 */
+                done = blk_rq_bytes(rq);
+
                 /* Command finished - Call the callback function */
                 uptodate = drive->pc_callback(drive, dsc);
 
@@ -361,7 +475,6 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
 
                 if (blk_special_request(rq)) {
                         rq->errors = 0;
-                        done = blk_rq_bytes(rq);
                         error = 0;
                 } else {
 
@@ -370,22 +483,17 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
                                         rq->errors = -EIO;
                         }
 
-                        if (drive->media == ide_tape)
-                                done = ide_rq_bytes(rq); /* FIXME */
-                        else
-                                done = blk_rq_bytes(rq);
-
                         error = uptodate ? 0 : -EIO;
                 }
 
-                ide_complete_rq(drive, error, done);
+                ide_complete_rq(drive, error, blk_rq_bytes(rq));
                 return ide_stopped;
         }
 
         if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
                 pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;
-                printk(KERN_ERR "%s: The device wants to issue more interrupts "
-                                "in DMA mode\n", drive->name);
+                printk(KERN_ERR PFX "%s: The device wants to issue more "
+                                "interrupts in DMA mode\n", drive->name);
                 ide_dma_off(drive);
                 return ide_do_reset(drive);
         }
@@ -393,43 +501,22 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
         /* Get the number of bytes to transfer on this interrupt. */
         ide_read_bcount_and_ireason(drive, &bcount, &ireason);
 
-        if (ireason & ATAPI_COD) {
-                printk(KERN_ERR "%s: CoD != 0 in %s\n", drive->name, __func__);
+        if (ide_check_ireason(drive, rq, bcount, ireason, write))
                 return ide_do_reset(drive);
-        }
 
-        if (((ireason & ATAPI_IO) == ATAPI_IO) == write) {
-                /* Hopefully, we will never get here */
-                printk(KERN_ERR "%s: We wanted to %s, but the device wants us "
-                                "to %s!\n", drive->name,
-                                (ireason & ATAPI_IO) ? "Write" : "Read",
-                                (ireason & ATAPI_IO) ? "Read" : "Write");
-                return ide_do_reset(drive);
-        }
-
-        xferfunc = write ? tp_ops->output_data : tp_ops->input_data;
-
-        if (drive->media == ide_floppy && pc->buf == NULL) {
-                done = min_t(unsigned int, bcount, cmd->nleft);
-                ide_pio_bytes(drive, cmd, write, done);
-        } else if (drive->media == ide_tape && pc->bh) {
-                done = drive->pc_io_buffers(drive, pc, bcount, write);
-        } else {
-                done = min_t(unsigned int, bcount, pc->req_xfer - pc->xferred);
-                xferfunc(drive, NULL, pc->cur_pos, done);
-        }
+        done = min_t(unsigned int, bcount, cmd->nleft);
+        ide_pio_bytes(drive, cmd, write, done);
 
-        /* Update the current position */
-        pc->xferred += done;
-        pc->cur_pos += done;
+        /* Update transferred byte count */
+        rq->resid_len -= done;
 
         bcount -= done;
 
         if (bcount)
                 ide_pad_transfer(drive, write, bcount);
 
-        debug_log("[cmd %x] transferred %d bytes, padded %d bytes\n",
-                  rq->cmd[0], done, bcount);
+        debug_log("[cmd %x] transferred %d bytes, padded %d bytes, resid: %u\n",
+                  rq->cmd[0], done, bcount, rq->resid_len);
 
         /* And set the interrupt handler again */
         ide_set_handler(drive, ide_pc_intr, timeout);
@@ -463,13 +550,13 @@ static u8 ide_wait_ireason(ide_drive_t *drive, u8 ireason)
 
         while (retries-- && ((ireason & ATAPI_COD) == 0 ||
                 (ireason & ATAPI_IO))) {
-                printk(KERN_ERR "%s: (IO,CoD != (0,1) while issuing "
+                printk(KERN_ERR PFX "%s: (IO,CoD != (0,1) while issuing "
                                 "a packet command, retrying\n", drive->name);
                 udelay(100);
                 ireason = ide_read_ireason(drive);
                 if (retries == 0) {
-                        printk(KERN_ERR "%s: (IO,CoD != (0,1) while issuing "
-                                        "a packet command, ignoring\n",
+                        printk(KERN_ERR PFX "%s: (IO,CoD != (0,1) while issuing"
+                                        " a packet command, ignoring\n",
                                         drive->name);
                         ireason |= ATAPI_COD;
                         ireason &= ~ATAPI_IO;
@@ -500,7 +587,7 @@ static ide_startstop_t ide_transfer_pc(ide_drive_t *drive)
         u8 ireason;
 
         if (ide_wait_stat(&startstop, drive, ATA_DRQ, ATA_BUSY, WAIT_READY)) {
-                printk(KERN_ERR "%s: Strange, packet command initiated yet "
+                printk(KERN_ERR PFX "%s: Strange, packet command initiated yet "
                                 "DRQ isn't asserted\n", drive->name);
                 return startstop;
         }
@@ -525,7 +612,7 @@ static ide_startstop_t ide_transfer_pc(ide_drive_t *drive)
 
                 /*
                  * If necessary schedule the packet transfer to occur 'timeout'
-                 * miliseconds later in ide_delayed_transfer_pc() after the
+                 * milliseconds later in ide_delayed_transfer_pc() after the
                  * device says it's ready for a packet.
                  */
                 if (drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) {
@@ -542,8 +629,8 @@ static ide_startstop_t ide_transfer_pc(ide_drive_t *drive)
                         ireason = ide_wait_ireason(drive, ireason);
 
                 if ((ireason & ATAPI_COD) == 0 || (ireason & ATAPI_IO)) {
-                        printk(KERN_ERR "%s: (IO,CoD) != (0,1) while issuing "
-                                        "a packet command\n", drive->name);
+                        printk(KERN_ERR PFX "%s: (IO,CoD) != (0,1) while "
+                                "issuing a packet command\n", drive->name);
 
                         return ide_do_reset(drive);
                 }
@@ -581,7 +668,7 @@ ide_startstop_t ide_issue_pc(ide_drive_t *drive, struct ide_cmd *cmd)
         ide_hwif_t *hwif = drive->hwif;
         ide_expiry_t *expiry = NULL;
         struct request *rq = hwif->rq;
-        unsigned int timeout;
+        unsigned int timeout, bytes;
         u16 bcount;
         u8 valid_tf;
         u8 drq_int = !!(drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT);
@@ -597,14 +684,14 @@ ide_startstop_t ide_issue_pc(ide_drive_t *drive, struct ide_cmd *cmd)
         } else {
                 pc = drive->pc;
 
-                /* We haven't transferred any data yet */
-                pc->xferred = 0;
-                pc->cur_pos = pc->buf;
-
                 valid_tf = IDE_VALID_DEVICE;
-                bcount = ((drive->media == ide_tape) ?
-                                pc->req_xfer :
-                                min(pc->req_xfer, 63 * 1024));
+                bytes = blk_rq_bytes(rq);
+                bcount = ((drive->media == ide_tape) ? bytes
+                                                     : min_t(unsigned int,
+                                                             bytes, 63 * 1024));
+
+                /* We haven't transferred any data yet */
+                rq->resid_len = bcount;
 
                 if (pc->flags & PC_FLAG_DMA_ERROR) {
                         pc->flags &= ~PC_FLAG_DMA_ERROR;