ide: add support for arbitrary transfer lengths to ide_pio_bytes()

[mirror_ubuntu-artful-kernel.git] / drivers / ide / ide-taskfile.c

diff --git a/drivers/ide/ide-taskfile.c b/drivers/ide/ide-taskfile.c
index f99a6aaad9eb4d42b07c9420b66a2d4999245882..8d7e87d04b3b550e5327d037c0c6e0f54d2d96a2 100644 (file)
--- a/drivers/ide/ide-taskfile.c
+++ b/drivers/ide/ide-taskfile.c
@@ -97,16 +97,17 @@ ide_startstop_t do_rw_taskfile(ide_drive_t *drive, struct ide_cmd *orig_cmd)
        case ATA_PROT_NODATA:
                if (handler == NULL)
                        handler = task_no_data_intr;
-               ide_execute_command(drive, tf->command, handler,
-                                   WAIT_WORSTCASE, NULL);
+               ide_execute_command(drive, cmd, handler, WAIT_WORSTCASE);
                return ide_started;
-       default:
+       case ATA_PROT_DMA:
                if ((drive->dev_flags & IDE_DFLAG_USING_DMA) == 0 ||
-                   ide_build_sglist(drive, hwif->rq) == 0 ||
-                   dma_ops->dma_setup(drive))
+                   ide_build_sglist(drive, cmd) == 0 ||
+                   dma_ops->dma_setup(drive, cmd))
                        return ide_stopped;
-               dma_ops->dma_exec_cmd(drive, tf->command);
+               hwif->expiry = dma_ops->dma_timer_expiry;
+               ide_execute_command(drive, cmd, ide_dma_intr, 2 * WAIT_CMD);
                dma_ops->dma_start(drive);
+       default:
                return ide_started;
        }
 }
@@ -139,7 +140,7 @@ static ide_startstop_t task_no_data_intr(ide_drive_t *drive)
                } else if (custom && tf->command == ATA_CMD_INIT_DEV_PARAMS) {
                        if ((stat & (ATA_ERR | ATA_DRQ)) == 0) {
                                ide_set_handler(drive, &task_no_data_intr,
-                                               WAIT_WORSTCASE, NULL);
+                                               WAIT_WORSTCASE);
                                return ide_started;
                        }
                }
@@ -187,8 +188,8 @@ static u8 wait_drive_not_busy(ide_drive_t *drive)
        return stat;
 }
 
-static void ide_pio_sector(ide_drive_t *drive, struct ide_cmd *cmd,
-                          unsigned int write)
+static void ide_pio_bytes(ide_drive_t *drive, struct ide_cmd *cmd,
+                         unsigned int write, unsigned int len)
 {
        ide_hwif_t *hwif = drive->hwif;
        struct scatterlist *sg = hwif->sg_table;
@@ -201,56 +202,55 @@ static void ide_pio_sector(ide_drive_t *drive, struct ide_cmd *cmd,
        u8 *buf;
 
        cursg = cmd->cursg;
-       if (!cursg) {
-               cursg = sg;
-               cmd->cursg = sg;
-       }
+       if (cursg == NULL)
+               cursg = cmd->cursg = sg;
+
+       while (len) {
+               unsigned nr_bytes = min(len, cursg->length - cmd->cursg_ofs);
 
-       page = sg_page(cursg);
-       offset = cursg->offset + cmd->cursg_ofs * SECTOR_SIZE;
+               if (nr_bytes > PAGE_SIZE)
+                       nr_bytes = PAGE_SIZE;
 
-       /* get the current page and offset */
-       page = nth_page(page, (offset >> PAGE_SHIFT));
-       offset %= PAGE_SIZE;
+               page = sg_page(cursg);
+               offset = cursg->offset + cmd->cursg_ofs;
+
+               /* get the current page and offset */
+               page = nth_page(page, (offset >> PAGE_SHIFT));
+               offset %= PAGE_SIZE;
 
 #ifdef CONFIG_HIGHMEM
-       local_irq_save(flags);
+               local_irq_save(flags);
 #endif
-       buf = kmap_atomic(page, KM_BIO_SRC_IRQ) + offset;
+               buf = kmap_atomic(page, KM_BIO_SRC_IRQ) + offset;
 
-       cmd->nleft--;
-       cmd->cursg_ofs++;
+               cmd->nleft -= nr_bytes;
+               cmd->cursg_ofs += nr_bytes;
 
-       if ((cmd->cursg_ofs * SECTOR_SIZE) == cursg->length) {
-               cmd->cursg = sg_next(cmd->cursg);
-               cmd->cursg_ofs = 0;
-       }
+               if (cmd->cursg_ofs == cursg->length) {
+                       cursg = cmd->cursg = sg_next(cmd->cursg);
+                       cmd->cursg_ofs = 0;
+               }
 
-       /* do the actual data transfer */
-       if (write)
-               hwif->tp_ops->output_data(drive, cmd, buf, SECTOR_SIZE);
-       else
-               hwif->tp_ops->input_data(drive, cmd, buf, SECTOR_SIZE);
+               /* do the actual data transfer */
+               if (write)
+                       hwif->tp_ops->output_data(drive, cmd, buf, nr_bytes);
+               else
+                       hwif->tp_ops->input_data(drive, cmd, buf, nr_bytes);
 
-       kunmap_atomic(buf, KM_BIO_SRC_IRQ);
+               kunmap_atomic(buf, KM_BIO_SRC_IRQ);
 #ifdef CONFIG_HIGHMEM
-       local_irq_restore(flags);
+               local_irq_restore(flags);
 #endif
-}
-
-static void ide_pio_multi(ide_drive_t *drive, struct ide_cmd *cmd,
-                         unsigned int write)
-{
-       unsigned int nsect;
 
-       nsect = min_t(unsigned int, cmd->nleft, drive->mult_count);
-       while (nsect--)
-               ide_pio_sector(drive, cmd, write);
+               len -= nr_bytes;
+       }
 }
 
 static void ide_pio_datablock(ide_drive_t *drive, struct ide_cmd *cmd,
                              unsigned int write)
 {
+       unsigned int nr_bytes;
+
        u8 saved_io_32bit = drive->io_32bit;
 
        if (cmd->tf_flags & IDE_TFLAG_FS)
@@ -262,9 +262,11 @@ static void ide_pio_datablock(ide_drive_t *drive, struct ide_cmd *cmd,
        touch_softlockup_watchdog();
 
        if (cmd->tf_flags & IDE_TFLAG_MULTI_PIO)
-               ide_pio_multi(drive, cmd, write);
+               nr_bytes = min_t(unsigned, cmd->nleft, drive->mult_count << 9);
        else
-               ide_pio_sector(drive, cmd, write);
+               nr_bytes = SECTOR_SIZE;
+
+       ide_pio_bytes(drive, cmd, write, nr_bytes);
 
        drive->io_32bit = saved_io_32bit;
 }
@@ -272,27 +274,29 @@ static void ide_pio_datablock(ide_drive_t *drive, struct ide_cmd *cmd,
 static void ide_error_cmd(ide_drive_t *drive, struct ide_cmd *cmd)
 {
        if (cmd->tf_flags & IDE_TFLAG_FS) {
-               int sectors = cmd->nsect - cmd->nleft;
+               int nr_bytes = cmd->nbytes - cmd->nleft;
 
                if (cmd->protocol == ATA_PROT_PIO &&
                    ((cmd->tf_flags & IDE_TFLAG_WRITE) || cmd->nleft == 0)) {
                        if (cmd->tf_flags & IDE_TFLAG_MULTI_PIO)
-                               sectors -= drive->mult_count;
+                               nr_bytes -= drive->mult_count << 9;
                        else
-                               sectors--;
+                               nr_bytes -= SECTOR_SIZE;
                }
 
-               if (sectors > 0)
-                       ide_end_request(drive, 1, sectors);
+               if (nr_bytes > 0)
+                       ide_complete_rq(drive, 0, nr_bytes);
        }
 }
 
 void ide_finish_cmd(ide_drive_t *drive, struct ide_cmd *cmd, u8 stat)
 {
+       struct request *rq = drive->hwif->rq;
        u8 err = ide_read_error(drive);
 
        ide_complete_cmd(drive, cmd, stat, err);
-       ide_complete_rq(drive, err);
+       rq->errors = err;
+       ide_complete_rq(drive, err ? -EIO : 0, blk_rq_bytes(rq));
 }
 
 /*
@@ -344,13 +348,13 @@ static ide_startstop_t task_pio_intr(ide_drive_t *drive)
        }
 out_wait:
        /* Still data left to transfer. */
-       ide_set_handler(drive, &task_pio_intr, WAIT_WORSTCASE, NULL);
+       ide_set_handler(drive, &task_pio_intr, WAIT_WORSTCASE);
        return ide_started;
 out_end:
        if ((cmd->tf_flags & IDE_TFLAG_FS) == 0)
                ide_finish_cmd(drive, cmd, stat);
        else
-               ide_end_request(drive, 1, cmd->rq->nr_sectors);
+               ide_complete_rq(drive, 0, cmd->rq->nr_sectors << 9);
        return ide_stopped;
 out_err:
        ide_error_cmd(drive, cmd);
@@ -374,7 +378,7 @@ static ide_startstop_t pre_task_out_intr(ide_drive_t *drive,
        if ((drive->dev_flags & IDE_DFLAG_UNMASK) == 0)
                local_irq_disable();
 
-       ide_set_handler(drive, &task_pio_intr, WAIT_WORSTCASE, NULL);
+       ide_set_handler(drive, &task_pio_intr, WAIT_WORSTCASE);
 
        ide_pio_datablock(drive, cmd, 1);