lkml.org 
[lkml]   [2005]   [Mar]   [4]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    SubjectRe: [PATCH 2.6.11-rc3 03/08] ide: remove flagged_taskfile() and unify taskfile paths
    From
    Date

    03_ide_remove_flagged_taskfile.patch

    This patch removes flagged_taskfile(). All taskfile command
    issuing goes through do_rw_taskfile(). do_rw_taskfile()
    doesn't modify mangle with load flags anymore. It's now
    caller's responsibility to set appropriate flags. Likewise,
    ide_end_drive_cmd() is modified not to mangle with read flags,
    and ide_dma_intr() now also finishes commands with
    task_end_request(). Above changes make taskfile path unified
    & generic.

    As all ioctl subtleties are now responsibility of respective
    ioctl functions. TASKFILE and TASK ioctl functions are
    updated to set flags according to old behaviors. The
    following two behavior changes occur.

    * TASKFILE ioctl: taskfile registers are read back whether or
    not the command fails. As copying back to user doesn't
    happen in cases where reading back didn't occur before, this
    change isn't user-visible. Defining & using a flag like
    ATA_TFLAG_READ_ON_ERROR will remove this issue.
    * TASK ioctl: drive->select.all & ~ATA_LBA is OR'd to device
    value. Previously, only ATA_DEV bit was OR'd.

    Also, all ide_{raw|diag}_taskfile(), do_rw_taskfile() users
    are converted to use the new individual OUT/IN flags. As
    results, the following behavior changes occur.

    * idedisk_read_native_max_address(): ADDR/LBA48 regs are not
    loaded. LBA48/DEVICE registers are not read back unless
    necessary.
    * idedisk_set_max_address(): DEVICE register is not read
    unless necessary.
    * smart_enable(): DEVICE register is not loaded. Registers
    are not read back.
    * smart_disable(): ditto
    * get_smart_threshold(): DEVICE register is not loaded.
    * ide_task_init_flush(): ADDR/LBA48/DEVICE registers are not
    loaded.
    * ide_init_specify_cmd(): Register aren't read back.
    * ide_init_restore_cmd(): DEVICE register not loaded. No read back.
    * ide_init_setmult_cmd(): ditto

    Signed-off-by: Tejun Heo <htejun@gmail.com>

    drivers/ide/ide-disk.c | 31 ++---
    drivers/ide/ide-dma.c | 16 --
    drivers/ide/ide-io.c | 21 +--
    drivers/ide/ide-taskfile.c | 263 +++++++++++++++++----------------------------
    include/linux/ata.h | 6 -
    include/linux/ide.h | 6 -
    6 files changed, 136 insertions(+), 207 deletions(-)

    Index: linux-taskfile-ng/drivers/ide/ide-disk.c
    ===================================================================
    --- linux-taskfile-ng.orig/drivers/ide/ide-disk.c 2005-03-05 10:46:58.762007508 +0900
    +++ linux-taskfile-ng/drivers/ide/ide-disk.c 2005-03-05 10:46:59.081957489 +0900
    @@ -301,21 +301,22 @@ static u64 idedisk_read_native_max_addre
    /* Create IDE/ATA command request structure */
    memset(&args, 0, sizeof(ide_task_t));

    - tf->device = 0x40;
    + tf->flags = ATA_TFLAG_OUT_DEVICE | ATA_TFLAG_IN_ADDR;
    + tf->device = ATA_LBA;
    if (lba48) {
    + tf->flags |= ATA_TFLAG_IN_LBA48;
    tf->command = WIN_READ_NATIVE_MAX_EXT;
    - tf->flags |= ATA_TFLAG_IDE_LBA48;
    - } else
    + } else {
    + tf->flags |= ATA_TFLAG_IN_DEVICE;
    tf->command = WIN_READ_NATIVE_MAX;
    + }

    args.command_type = IDE_DRIVE_TASK_NO_DATA;
    args.handler = &task_no_data_intr;

    /* submit command request */
    - ide_raw_taskfile(drive, &args, NULL);
    -
    - /* if OK, compute maximum address value */
    - if ((tf->command & 1) == 0) {
    + if (ide_raw_taskfile(drive, &args, NULL) == 0) {
    + /* if OK, compute maximum address value */
    addr = ide_tf_get_address(drive, tf);
    addr++; /* since the return value is (maxlba - 1), we add 1 */
    }
    @@ -336,19 +337,20 @@ static u64 idedisk_set_max_address(ide_d
    /* Create IDE/ATA command request structure */
    memset(&args, 0, sizeof(ide_task_t));

    + tf->flags = ATA_TFLAG_OUT_DEVICE | ATA_TFLAG_ISADDR;
    + tf->device = ATA_LBA;
    tf->lbal = addr_req;
    tf->lbam = addr_req >> 8;
    tf->lbah = addr_req >> 16;
    if (lba48) {
    + tf->flags |= ATA_TFLAG_LBA48;
    tf->hob_lbal = addr_req >> 24;
    tf->hob_lbam = addr_req >> 32;
    tf->hob_lbah = addr_req >> 40;
    - tf->device = 0x40;
    tf->command = WIN_SET_MAX_EXT;
    -
    - tf->flags |= ATA_TFLAG_IDE_LBA48;
    } else {
    - tf->device = ((addr_req >> 24) & 0xf) | 0x40;
    + tf->flags |= ATA_TFLAG_IN_DEVICE;
    + tf->device |= (addr_req >> 24) & 0xf;
    tf->command = WIN_SET_MAX;
    }

    @@ -356,9 +358,7 @@ static u64 idedisk_set_max_address(ide_d
    args.handler = &task_no_data_intr;

    /* submit command request */
    - ide_raw_taskfile(drive, &args, NULL);
    - /* if OK, compute maximum address value */
    - if ((tf->command & 1) == 0) {
    + if (ide_raw_taskfile(drive, &args, NULL) == 0) {
    addr_set = ide_tf_get_address(drive, tf);
    addr_set++;
    }
    @@ -474,6 +474,7 @@ static int smart_enable(ide_drive_t *dri

    memset(&args, 0, sizeof(ide_task_t));

    + tf->flags = ATA_TFLAG_OUT_ADDR;
    tf->feature = SMART_ENABLE;
    tf->lbam = SMART_LCYL_PASS;
    tf->lbah = SMART_HCYL_PASS;
    @@ -491,6 +492,7 @@ static int get_smart_values(ide_drive_t

    memset(&args, 0, sizeof(ide_task_t));

    + tf->flags = ATA_TFLAG_OUT_ADDR;
    tf->feature = SMART_READ_VALUES;
    tf->nsect = 1;
    tf->lbam = SMART_LCYL_PASS;
    @@ -511,6 +513,7 @@ static int get_smart_thresholds(ide_driv

    memset(&args, 0, sizeof(ide_task_t));

    + tf->flags = ATA_TFLAG_OUT_ADDR;
    tf->feature = SMART_READ_THRESHOLDS;
    tf->nsect = 1;
    tf->lbam = SMART_LCYL_PASS;
    Index: linux-taskfile-ng/drivers/ide/ide-dma.c
    ===================================================================
    --- linux-taskfile-ng.orig/drivers/ide/ide-dma.c 2005-03-05 10:46:58.188097228 +0900
    +++ linux-taskfile-ng/drivers/ide/ide-dma.c 2005-03-05 10:46:59.082957333 +0900
    @@ -168,21 +168,15 @@ static int in_drive_list(struct hd_drive

    ide_startstop_t ide_dma_intr (ide_drive_t *drive)
    {
    - u8 stat = 0, dma_stat = 0;
    + u8 stat, dma_stat;

    + stat = HWIF(drive)->INB(IDE_STATUS_REG);
    dma_stat = HWIF(drive)->ide_dma_end(drive);
    - stat = HWIF(drive)->INB(IDE_STATUS_REG); /* get drive status */
    - if (OK_STAT(stat,DRIVE_READY,drive->bad_wstat|DRQ_STAT)) {
    +
    + if (OK_STAT(stat, DRIVE_READY, drive->bad_wstat|DRQ_STAT)) {
    if (!dma_stat) {
    struct request *rq = HWGROUP(drive)->rq;
    -
    - if (rq->rq_disk) {
    - ide_driver_t *drv;
    -
    - drv = *(ide_driver_t **)rq->rq_disk->private_data;;
    - drv->end_request(drive, 1, rq->nr_sectors);
    - } else
    - ide_end_request(drive, 1, rq->nr_sectors);
    + task_end_request(drive, rq, stat);
    return ide_stopped;
    }
    printk(KERN_ERR "%s: dma_intr: bad DMA status (dma_stat=%x)\n",
    Index: linux-taskfile-ng/drivers/ide/ide-io.c
    ===================================================================
    --- linux-taskfile-ng.orig/drivers/ide/ide-io.c 2005-03-05 10:46:58.307078627 +0900
    +++ linux-taskfile-ng/drivers/ide/ide-io.c 2005-03-05 10:46:59.084957020 +0900
    @@ -61,10 +61,12 @@ void ide_task_init_flush(ide_drive_t *dr

    memset(task, 0, sizeof(*task));

    + tf->flags = ATA_TFLAG_IN_ADDR | ATA_TFLAG_IN_DEVICE;
    +
    if (ide_id_has_flush_cache_ext(drive->id) &&
    (drive->capacity64 >= (1UL << 28))) {
    tf->command = WIN_FLUSH_CACHE_EXT;
    - tf->flags |= ATA_TFLAG_IDE_LBA48;
    + tf->flags |= ATA_TFLAG_IN_LBA48;
    } else
    tf->command = WIN_FLUSH_CACHE;

    @@ -322,7 +324,7 @@ u64 ide_tf_get_address(ide_drive_t *driv
    {
    u32 high, low;

    - if (tf->flags & ATA_TFLAG_IDE_LBA48) {
    + if (tf->flags & ATA_TFLAG_IN_LBA48) {
    high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) | tf->hob_lbal;
    low = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
    } else {
    @@ -455,14 +457,8 @@ void ide_end_drive_cmd (ide_drive_t *dri
    ide_task_t *args = (ide_task_t *) rq->special;
    if (rq->errors == 0)
    rq->errors = !OK_STAT(stat,READY_STAT,BAD_STAT);
    -
    - if (args) {
    - struct ata_taskfile *tf = &args->tf;
    - tf->flags |= ATA_TFLAG_IN_ADDR | ATA_TFLAG_IN_DEVICE;
    - if (tf->flags & ATA_TFLAG_IDE_LBA48)
    - tf->flags |= ATA_TFLAG_IN_LBA48;
    + if (args)
    ide_read_taskfile(drive, args, stat, err);
    - }
    } else if (blk_pm_request(rq)) {
    #ifdef DEBUG_PM
    printk("%s: complete_power_step(step: %d, stat: %x, err: %x)\n",
    @@ -759,11 +755,12 @@ static void ide_init_specify_cmd(ide_dri
    {
    struct ata_taskfile *tf = &task->tf;

    + tf->flags = ATA_TFLAG_OUT_ADDR | ATA_TFLAG_OUT_DEVICE;
    tf->nsect = drive->sect;
    tf->lbal = drive->sect;
    tf->lbam = drive->cyl;
    tf->lbah = drive->cyl >> 8;
    - tf->device = ((drive->head - 1) | drive->select.all) & 0xBF;
    + tf->device = drive->head - 1;
    tf->command = WIN_SPECIFY;

    task->handler = &set_geometry_intr;
    @@ -773,6 +770,7 @@ static void ide_init_restore_cmd(ide_dri
    {
    struct ata_taskfile *tf = &task->tf;

    + tf->flags = ATA_TFLAG_OUT_ADDR;
    tf->nsect = drive->sect;
    tf->command = WIN_RESTORE;

    @@ -783,6 +781,7 @@ static void ide_init_setmult_cmd(ide_dri
    {
    struct ata_taskfile *tf = &task->tf;

    + tf->flags = ATA_TFLAG_OUT_ADDR;
    tf->nsect = drive->mult_req;
    tf->command = WIN_SETMULT;

    @@ -914,8 +913,6 @@ static ide_startstop_t execute_drive_cmd
    break;
    }

    - if (args->tf.flags & ATA_TFLAG_IDE_FLAGGED)
    - return flagged_taskfile(drive, args);
    return do_rw_taskfile(drive, args);
    } else if (rq->flags & REQ_DRIVE_CMD) {
    u8 *args = rq->buffer;
    Index: linux-taskfile-ng/drivers/ide/ide-taskfile.c
    ===================================================================
    --- linux-taskfile-ng.orig/drivers/ide/ide-taskfile.c 2005-03-05 10:46:58.315077377 +0900
    +++ linux-taskfile-ng/drivers/ide/ide-taskfile.c 2005-03-05 10:46:59.092955770 +0900
    @@ -186,25 +186,28 @@ int taskfile_lib_get_identify (ide_drive
    return ide_raw_taskfile(drive, &args, buf);
    }

    -ide_startstop_t do_rw_taskfile (ide_drive_t *drive, ide_task_t *task)
    +ide_startstop_t do_rw_taskfile(ide_drive_t *drive, ide_task_t *task)
    {
    - ide_hwif_t *hwif = HWIF(drive);
    + ide_hwif_t *hwif = drive->hwif;
    struct ata_taskfile *tf = &task->tf;
    - u8 HIHI = (tf->flags & ATA_TFLAG_IDE_LBA48) ? 0xE0 : 0xEF;

    - /* ALL Command Block Executions SHALL clear nIEN, unless otherwise */
    - if (IDE_CONTROL_REG) {
    - /* clear nIEN */
    - hwif->OUTB(drive->ctl, IDE_CONTROL_REG);
    + /* We check this in ide_taskfile_ioctl(), but the setting could
    + have been changed inbetween. */
    + if ((task->data_phase == TASKFILE_MULTI_IN ||
    + task->data_phase == TASKFILE_MULTI_OUT) && !drive->mult_count) {
    + printk(KERN_ERR "%s: multimode not set!\n",
    + drive->name);
    + /* FIXME: this path is an infinite loop. */
    + return ide_stopped;
    }
    - SELECT_MASK(drive, 0);

    - if (tf->flags & ATA_TFLAG_IDE_LBA48)
    - tf->flags |= ATA_TFLAG_OUT_LBA48;
    - tf->flags |= ATA_TFLAG_OUT_ADDR;
    - tf->flags |= ATA_TFLAG_OUT_DEVICE;
    - tf->device = (tf->device & HIHI) | (drive->select.all & 0xBF);
    + /* ALL Command Block Executions SHALL clear nIEN. */
    + if (IDE_CONTROL_REG)
    + hwif->OUTB(drive->ctl, IDE_CONTROL_REG);
    + SELECT_MASK(drive, 0);

    + if (tf->flags & ATA_TFLAG_OUT_DEVICE)
    + tf->device |= drive->select.all & ~ATA_LBA;
    ide_load_taskfile(drive, task);

    if (task->handler != NULL) {
    @@ -213,33 +216,25 @@ ide_startstop_t do_rw_taskfile (ide_driv
    ndelay(400); /* FIXME */
    return task->prehandler(drive, task->rq);
    }
    - ide_execute_command(drive, tf->command, task->handler, WAIT_WORSTCASE, NULL);
    + ide_execute_command(drive, tf->command, task->handler,
    + WAIT_WORSTCASE, NULL);
    return ide_started;
    }

    - if (!drive->using_dma)
    + switch (task->data_phase) {
    + case TASKFILE_OUT_DMAQ:
    + case TASKFILE_OUT_DMA:
    + case TASKFILE_IN_DMAQ:
    + case TASKFILE_IN_DMA:
    + if (!hwif->dma_setup(drive)) {
    + hwif->dma_exec_cmd(drive, tf->command);
    + hwif->dma_start(drive);
    + return ide_started;
    + }
    + return ide_stopped;
    + default:
    return ide_stopped;
    -
    - switch (tf->command) {
    - case WIN_WRITEDMA_ONCE:
    - case WIN_WRITEDMA:
    - case WIN_WRITEDMA_EXT:
    - case WIN_READDMA_ONCE:
    - case WIN_READDMA:
    - case WIN_READDMA_EXT:
    - case WIN_IDENTIFY_DMA:
    - if (!hwif->dma_setup(drive)) {
    - hwif->dma_exec_cmd(drive, tf->command);
    - hwif->dma_start(drive);
    - return ide_started;
    - }
    - break;
    - default:
    - if (task->handler == NULL)
    - return ide_stopped;
    }
    -
    - return ide_stopped;
    }

    EXPORT_SYMBOL(do_rw_taskfile);
    @@ -302,7 +297,7 @@ ide_startstop_t recal_intr (ide_drive_t
    /*
    * Handler for commands without a data phase
    */
    -ide_startstop_t task_no_data_intr (ide_drive_t *drive)
    +ide_startstop_t task_no_data_intr(ide_drive_t *drive)
    {
    ide_task_t *args = HWGROUP(drive)->rq->special;
    ide_hwif_t *hwif = HWIF(drive);
    @@ -456,19 +451,16 @@ static ide_startstop_t task_error(ide_dr
    return ide_error(drive, s, stat);
    }

    -static void task_end_request(ide_drive_t *drive, struct request *rq, u8 stat)
    +void task_end_request(ide_drive_t *drive, struct request *rq, u8 stat)
    {
    if (rq->flags & REQ_DRIVE_TASKFILE) {
    - ide_task_t *task = rq->special;
    -
    - if (task->tf.flags & ATA_TFLAG_IDE_FLAGGED) {
    - u8 err = drive->hwif->INB(IDE_ERROR_REG);
    - ide_end_drive_cmd(drive, stat, err);
    - return;
    - }
    + u8 err = drive->hwif->INB(IDE_ERROR_REG);
    + ide_end_drive_cmd(drive, stat, err);
    + return;
    + } else {
    + ide_driver_t *drv = *(ide_driver_t **)rq->rq_disk->private_data;;
    + drv->end_request(drive, 1, rq->hard_nr_sectors);
    }
    -
    - ide_end_request(drive, 1, rq->hard_nr_sectors);
    }

    /*
    @@ -674,49 +666,58 @@ int ide_taskfile_ioctl (ide_drive_t *dri
    tf->device = req_task->io_ports[6];
    tf->command = req_task->io_ports[7];

    - /* Translate out/in flags. */
    - if (req_task->out_flags.all)
    - tf->flags |= ATA_TFLAG_IDE_FLAGGED;
    -
    - if (req_task->out_flags.b.error_feature_hob)
    - tf->flags |= ATA_TFLAG_OUT_HOB_FEATURE;
    - if (req_task->out_flags.b.nsector_hob)
    - tf->flags |= ATA_TFLAG_OUT_HOB_NSECT;
    - if (req_task->out_flags.b.sector_hob)
    - tf->flags |= ATA_TFLAG_OUT_HOB_LBAL;
    - if (req_task->out_flags.b.lcyl_hob)
    - tf->flags |= ATA_TFLAG_OUT_HOB_LBAM;
    - if (req_task->out_flags.b.hcyl_hob)
    - tf->flags |= ATA_TFLAG_OUT_HOB_LBAH;
    -
    - if (req_task->out_flags.b.error_feature)
    - tf->flags |= ATA_TFLAG_OUT_FEATURE;
    - if (req_task->out_flags.b.nsector)
    - tf->flags |= ATA_TFLAG_OUT_NSECT;
    - if (req_task->out_flags.b.sector)
    - tf->flags |= ATA_TFLAG_OUT_LBAL;
    - if (req_task->out_flags.b.lcyl)
    - tf->flags |= ATA_TFLAG_OUT_LBAM;
    - if (req_task->out_flags.b.hcyl)
    - tf->flags |= ATA_TFLAG_OUT_LBAH;
    + /* Translate & adjust flags */
    + tf->flags |= ATA_TFLAG_OUT_DEVICE;
    + tf->flags |= ATA_TFLAG_IN_ADDR | ATA_TFLAG_IN_DEVICE;
    +
    + if (drive->addressing == 1)
    + tf->flags |= ATA_TFLAG_IN_LBA48;
    +
    + if (req_task->out_flags.all) {
    + /* out_flags.b.error_feature_hob is ignored */
    + if (req_task->out_flags.b.nsector_hob)
    + tf->flags |= ATA_TFLAG_OUT_HOB_NSECT;
    + if (req_task->out_flags.b.sector_hob)
    + tf->flags |= ATA_TFLAG_OUT_HOB_LBAL;
    + if (req_task->out_flags.b.lcyl_hob)
    + tf->flags |= ATA_TFLAG_OUT_HOB_LBAM;
    + if (req_task->out_flags.b.hcyl_hob)
    + tf->flags |= ATA_TFLAG_OUT_HOB_LBAH;
    +
    + if (req_task->out_flags.b.error_feature)
    + tf->flags |= ATA_TFLAG_OUT_FEATURE;
    + if (req_task->out_flags.b.nsector)
    + tf->flags |= ATA_TFLAG_OUT_NSECT;
    + if (req_task->out_flags.b.sector)
    + tf->flags |= ATA_TFLAG_OUT_LBAL;
    + if (req_task->out_flags.b.lcyl)
    + tf->flags |= ATA_TFLAG_OUT_LBAM;
    + if (req_task->out_flags.b.hcyl)
    + tf->flags |= ATA_TFLAG_OUT_LBAH;
    +
    + /* FIXME: tf->device isn't filtered to keep the old
    + behavior, so TASKFILE ioctl can issue commands to
    + slave with permissions to master. */
    + } else {
    + tf->flags |= ATA_TFLAG_OUT_ADDR;
    + if (drive->addressing == 1)
    + tf->flags |= ATA_TFLAG_OUT_LBA48;
    +
    + /* FIXME: The DEV bit is filtered when no out_flags is
    + set, but other drives still can be selected on
    + four-drive-per-port chipsets. */
    + tf->device &= drive->addressing == 1 ? 0xE0 : 0xEF;
    + }

    - if (req_task->out_flags.b.select)
    - tf->flags |= ATA_TFLAG_OUT_DEVICE;
    if (req_task->out_flags.b.data)
    args.load_data = 1;
    -
    if (req_task->in_flags.b.data)
    args.read_data = 1;

    - args.data_phase = req_task->data_phase;
    - args.command_type = req_task->req_cmd;
    -
    tf->flags |= ATA_TFLAG_IO_16BIT;
    - if (drive->addressing == 1)
    - tf->flags |= ATA_TFLAG_IDE_LBA48;

    - if (drive->select.b.lba)
    - tf->device |= ATA_LBA;
    + args.data_phase = req_task->data_phase;
    + args.command_type = req_task->req_cmd;

    switch(req_task->data_phase) {
    case TASKFILE_OUT_DMAQ:
    @@ -765,22 +766,25 @@ int ide_taskfile_ioctl (ide_drive_t *dri
    goto abort;
    }

    - req_task->io_ports[0] = args.data;
    - req_task->hob_ports[0] = args.data << 8;
    -
    - req_task->hob_ports[1] = tf->hob_feature;
    - req_task->hob_ports[2] = tf->hob_nsect;
    - req_task->hob_ports[3] = tf->hob_lbal;
    - req_task->hob_ports[4] = tf->hob_lbam;
    - req_task->hob_ports[5] = tf->hob_lbah;
    -
    - req_task->io_ports[1] = tf->feature;
    - req_task->io_ports[2] = tf->nsect;
    - req_task->io_ports[3] = tf->lbal;
    - req_task->io_ports[4] = tf->lbam;
    - req_task->io_ports[5] = tf->lbah;
    - req_task->io_ports[6] = tf->device;
    - req_task->io_ports[7] = tf->command;
    + if (req_task->data_phase == TASKFILE_NO_DATA ||
    + req_task->out_flags.all || err) {
    + req_task->io_ports[0] = args.data;
    + req_task->hob_ports[0] = args.data << 8;
    +
    + req_task->hob_ports[1] = tf->hob_feature;
    + req_task->hob_ports[2] = tf->hob_nsect;
    + req_task->hob_ports[3] = tf->hob_lbal;
    + req_task->hob_ports[4] = tf->hob_lbam;
    + req_task->hob_ports[5] = tf->hob_lbah;
    +
    + req_task->io_ports[1] = tf->feature;
    + req_task->io_ports[2] = tf->nsect;
    + req_task->io_ports[3] = tf->lbal;
    + req_task->io_ports[4] = tf->lbam;
    + req_task->io_ports[5] = tf->lbah;
    + req_task->io_ports[6] = tf->device;
    + req_task->io_ports[7] = tf->command;
    + }

    if (copy_to_user(buf, req_task, tasksize)) {
    err = -EFAULT;
    @@ -897,13 +901,15 @@ int ide_task_ioctl(ide_drive_t *drive, u

    memset(&task, 0, sizeof(task));

    + tf->flags = ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
    +
    tf->command = args[0];
    tf->feature = args[1];
    tf->nsect = args[2];
    tf->lbal = args[3];
    tf->lbam = args[4];
    tf->lbah = args[5];
    - tf->device = args[6];
    + tf->device = args[6] & ~ATA_DEV1;

    task.command_type = IDE_DRIVE_TASK_NO_DATA;
    task.data_phase = TASKFILE_NO_DATA;
    @@ -923,64 +929,3 @@ int ide_task_ioctl(ide_drive_t *drive, u
    err = -EFAULT;
    return err;
    }
    -
    -/*
    - * NOTICE: This is additions from IBM to provide a discrete interface,
    - * for selective taskregister access operations. Nice JOB Klaus!!!
    - * Glad to be able to work and co-develop this with you and IBM.
    - */
    -ide_startstop_t flagged_taskfile (ide_drive_t *drive, ide_task_t *task)
    -{
    - ide_hwif_t *hwif = HWIF(drive);
    - struct ata_taskfile *tf = &task->tf;
    -#if DEBUG_TASKFILE
    - u8 status;
    -#endif
    -
    - if (task->data_phase == TASKFILE_MULTI_IN ||
    - task->data_phase == TASKFILE_MULTI_OUT) {
    - if (!drive->mult_count) {
    - printk(KERN_ERR "%s: multimode not set!\n", drive->name);
    - return ide_stopped;
    - }
    - }
    -
    - /* ALL Command Block Executions SHALL clear nIEN, unless otherwise */
    - if (IDE_CONTROL_REG)
    - /* clear nIEN */
    - hwif->OUTB(drive->ctl, IDE_CONTROL_REG);
    - SELECT_MASK(drive, 0);
    -
    - /* Adjust task. */
    - tf->flags &= ~ATA_TFLAG_OUT_HOB_FEATURE;
    - tf->flags |= ATA_TFLAG_OUT_DEVICE;
    - tf->device |= drive->select.all & 0xBF;
    -
    - ide_load_taskfile(drive, task);
    -
    - switch(task->data_phase) {
    -
    - case TASKFILE_OUT_DMAQ:
    - case TASKFILE_OUT_DMA:
    - case TASKFILE_IN_DMAQ:
    - case TASKFILE_IN_DMA:
    - hwif->dma_setup(drive);
    - hwif->dma_exec_cmd(drive, tf->command);
    - hwif->dma_start(drive);
    - break;
    -
    - default:
    - if (task->handler == NULL)
    - return ide_stopped;
    -
    - /* Issue the command */
    - if (task->prehandler) {
    - hwif->OUTBSYNC(drive, tf->command, IDE_COMMAND_REG);
    - ndelay(400); /* FIXME */
    - return task->prehandler(drive, task->rq);
    - }
    - ide_execute_command(drive, tf->command, task->handler, WAIT_WORSTCASE, NULL);
    - }
    -
    - return ide_started;
    -}
    Index: linux-taskfile-ng/include/linux/ata.h
    ===================================================================
    --- linux-taskfile-ng.orig/include/linux/ata.h 2005-03-05 10:46:58.316077220 +0900
    +++ linux-taskfile-ng/include/linux/ata.h 2005-03-05 10:46:59.093955614 +0900
    @@ -223,12 +223,6 @@ enum {

    ATA_TFLAG_WRITE = (1 << 22), /* data dir */
    ATA_TFLAG_IO_16BIT = (1 << 23), /* force 16bit PIO (IDE) */
    -
    - /* Following two flags are just to ease migration to the new
    - taskfile implementation. They will go away as soon as the
    - transition is complete. */
    - ATA_TFLAG_IDE_FLAGGED = (1 << 24),
    - ATA_TFLAG_IDE_LBA48 = (1 << 25),
    };

    enum ata_tf_protocols {
    Index: linux-taskfile-ng/include/linux/ide.h
    ===================================================================
    --- linux-taskfile-ng.orig/include/linux/ide.h 2005-03-05 10:46:58.318076908 +0900
    +++ linux-taskfile-ng/include/linux/ide.h 2005-03-05 10:46:59.095955301 +0900
    @@ -1285,11 +1285,7 @@ void ide_read_taskfile(ide_drive_t *driv
    * taskfile io for disks for now...and builds request from ide_ioctl
    */
    extern ide_startstop_t do_rw_taskfile(ide_drive_t *, ide_task_t *);
    -
    -/*
    - * Special Flagged Register Validation Caller
    - */
    -extern ide_startstop_t flagged_taskfile(ide_drive_t *, ide_task_t *);
    +void task_end_request(ide_drive_t *drive, struct request *rq, u8 stat);

    extern ide_startstop_t set_multmode_intr(ide_drive_t *);
    extern ide_startstop_t set_geometry_intr(ide_drive_t *);
    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/
    \
     
     \ /
      Last update: 2005-03-22 14:10    [W:0.073 / U:60.304 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site