#undef REALLY_SLOW_IO /* most systems can safely undef this */
+//#define DEBUG
+
#include <linux/config.h>
#include <linux/module.h>
#include <linux/types.h>
return 0; /* lba_capacity value may be bad */
}
-static int idedisk_start_tag(ide_drive_t *drive, struct request *rq)
-{
- unsigned long flags;
- int ret = 1;
-
- spin_lock_irqsave(&ide_lock, flags);
-
- if (ata_pending_commands(drive) < drive->queue_depth)
- ret = blk_queue_start_tag(drive->queue, rq);
-
- spin_unlock_irqrestore(&ide_lock, flags);
- return ret;
-}
-
#ifndef CONFIG_IDE_TASKFILE_IO
/*
ide_startstop_t __ide_do_rw_disk (ide_drive_t *drive, struct request *rq, sector_t block)
{
ide_hwif_t *hwif = HWIF(drive);
+ unsigned int dma = drive->using_dma;
u8 lba48 = (drive->addressing == 1) ? 1 : 0;
task_ioreg_t command = WIN_NOP;
ata_nsector_t nsectors;
nsectors.all = (u16) rq->nr_sectors;
- if (drive->using_tcq && idedisk_start_tag(drive, rq)) {
- if (!ata_pending_commands(drive))
- BUG();
-
- return ide_started;
+ if (hwif->no_lba48_dma && lba48 && dma) {
+ if (rq->sector + rq->nr_sectors > 1ULL << 28)
+ dma = 0;
}
if (IDE_CONTROL_REG)
if (drive->addressing == 1) {
task_ioreg_t tasklets[10];
- if (blk_rq_tagged(rq)) {
- tasklets[0] = nsectors.b.low;
- tasklets[1] = nsectors.b.high;
- tasklets[2] = rq->tag << 3;
- tasklets[3] = 0;
- } else {
- tasklets[0] = 0;
- tasklets[1] = 0;
- tasklets[2] = nsectors.b.low;
- tasklets[3] = nsectors.b.high;
- }
+ pr_debug("%s: LBA=0x%012llx\n", drive->name, block);
+ tasklets[0] = 0;
+ tasklets[1] = 0;
+ tasklets[2] = nsectors.b.low;
+ tasklets[3] = nsectors.b.high;
tasklets[4] = (task_ioreg_t) block;
tasklets[5] = (task_ioreg_t) (block>>8);
tasklets[6] = (task_ioreg_t) (block>>16);
tasklets[9] = (task_ioreg_t)((u64)block >> 40);
}
#ifdef DEBUG
- printk("%s: %sing: LBAsect=%lu, sectors=%ld, "
- "buffer=0x%08lx, LBAsect=0x%012lx\n",
- drive->name,
- rq_data_dir(rq)==READ?"read":"writ",
- block,
- rq->nr_sectors,
- (unsigned long) rq->buffer,
- block);
printk("%s: 0x%02x%02x 0x%02x%02x%02x%02x%02x%02x\n",
drive->name, tasklets[3], tasklets[2],
tasklets[9], tasklets[8], tasklets[7],
hwif->OUTB(tasklets[6], IDE_HCYL_REG);
hwif->OUTB(0x00|drive->select.all,IDE_SELECT_REG);
} else {
-#ifdef DEBUG
- printk("%s: %sing: LBAsect=%llu, sectors=%ld, "
- "buffer=0x%08lx\n",
- drive->name,
- rq_data_dir(rq)==READ?"read":"writ",
- (unsigned long long)block, rq->nr_sectors,
- (unsigned long) rq->buffer);
-#endif
- if (blk_rq_tagged(rq)) {
- hwif->OUTB(nsectors.b.low, IDE_FEATURE_REG);
- hwif->OUTB(rq->tag << 3, IDE_NSECTOR_REG);
- } else {
- hwif->OUTB(0x00, IDE_FEATURE_REG);
- hwif->OUTB(nsectors.b.low, IDE_NSECTOR_REG);
- }
-
+ hwif->OUTB(0x00, IDE_FEATURE_REG);
+ hwif->OUTB(nsectors.b.low, IDE_NSECTOR_REG);
hwif->OUTB(block, IDE_SECTOR_REG);
hwif->OUTB(block>>=8, IDE_LCYL_REG);
hwif->OUTB(block>>=8, IDE_HCYL_REG);
head = track % drive->head;
cyl = track / drive->head;
- if (blk_rq_tagged(rq)) {
- hwif->OUTB(nsectors.b.low, IDE_FEATURE_REG);
- hwif->OUTB(rq->tag << 3, IDE_NSECTOR_REG);
- } else {
- hwif->OUTB(0x00, IDE_FEATURE_REG);
- hwif->OUTB(nsectors.b.low, IDE_NSECTOR_REG);
- }
+ pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
+ hwif->OUTB(0x00, IDE_FEATURE_REG);
+ hwif->OUTB(nsectors.b.low, IDE_NSECTOR_REG);
hwif->OUTB(cyl, IDE_LCYL_REG);
hwif->OUTB(cyl>>8, IDE_HCYL_REG);
hwif->OUTB(head|drive->select.all,IDE_SELECT_REG);
-#ifdef DEBUG
- printk("%s: %sing: CHS=%d/%d/%d, sectors=%ld, buffer=0x%08lx\n",
- drive->name, rq_data_dir(rq)==READ?"read":"writ", cyl,
- head, sect, rq->nr_sectors, (unsigned long) rq->buffer);
-#endif
}
if (rq_data_dir(rq) == READ) {
-#ifdef CONFIG_BLK_DEV_IDE_TCQ
- if (blk_rq_tagged(rq))
- return __ide_dma_queued_read(drive);
-#endif
- if (drive->using_dma && !hwif->ide_dma_read(drive))
+ if (dma && !hwif->ide_dma_read(drive))
return ide_started;
command = ((drive->mult_count) ?
((lba48) ? WIN_READ_EXT : WIN_READ));
ide_execute_command(drive, command, &read_intr, WAIT_CMD, NULL);
return ide_started;
- } else if (rq_data_dir(rq) == WRITE) {
+ } else {
ide_startstop_t startstop;
-#ifdef CONFIG_BLK_DEV_IDE_TCQ
- if (blk_rq_tagged(rq))
- return __ide_dma_queued_write(drive);
-#endif
- if (drive->using_dma && !(HWIF(drive)->ide_dma_write(drive)))
+
+ if (dma && !hwif->ide_dma_write(drive))
return ide_started;
command = ((drive->mult_count) ?
}
return ide_started;
}
- blk_dump_rq_flags(rq, "__ide_do_rw_disk - bad command");
- ide_end_request(drive, 0, 0);
- return ide_stopped;
}
EXPORT_SYMBOL_GPL(__ide_do_rw_disk);
*/
ide_startstop_t __ide_do_rw_disk (ide_drive_t *drive, struct request *rq, sector_t block)
{
- BUG_ON(drive->blocked);
- if (!blk_fs_request(rq)) {
- blk_dump_rq_flags(rq, "__ide_do_rw_disk - bad command");
- ide_end_request(drive, 0, 0);
- return ide_stopped;
- }
-
/*
* 268435455 == 137439 MB or 28bit limit
*
* need to add split taskfile operations based on 28bit threshold.
*/
-
- if (drive->using_tcq && idedisk_start_tag(drive, rq)) {
- if (!ata_pending_commands(drive))
- BUG();
-
- return ide_started;
- }
-
if (drive->addressing == 1) /* 48-bit LBA */
return lba_48_rw_disk(drive, rq, (unsigned long long) block);
if (drive->select.b.lba) /* 28-bit LBA */
}
EXPORT_SYMBOL_GPL(__ide_do_rw_disk);
-static u8 get_command(ide_drive_t *drive, int cmd, ide_task_t *task)
+static u8 get_command(ide_drive_t *drive, struct request *rq, ide_task_t *task)
{
unsigned int lba48 = (drive->addressing == 1) ? 1 : 0;
+ unsigned int dma = drive->using_dma;
- if (cmd == READ) {
+ if (drive->hwif->no_lba48_dma && lba48 && dma) {
+ if (rq->sector + rq->nr_sectors > 1ULL << 28)
+ dma = 0;
+ }
+
+ if (rq_data_dir(rq) == READ) {
task->command_type = IDE_DRIVE_TASK_IN;
- if (drive->using_tcq)
- return lba48 ? WIN_READDMA_QUEUED_EXT : WIN_READDMA_QUEUED;
- if (drive->using_dma)
+ if (dma)
return lba48 ? WIN_READDMA_EXT : WIN_READDMA;
+ task->handler = &task_in_intr;
if (drive->mult_count) {
- task->handler = &task_mulin_intr;
+ task->data_phase = TASKFILE_MULTI_IN;
return lba48 ? WIN_MULTREAD_EXT : WIN_MULTREAD;
}
- task->handler = &task_in_intr;
+ task->data_phase = TASKFILE_IN;
return lba48 ? WIN_READ_EXT : WIN_READ;
} else {
task->command_type = IDE_DRIVE_TASK_RAW_WRITE;
- if (drive->using_tcq)
- return lba48 ? WIN_WRITEDMA_QUEUED_EXT : WIN_WRITEDMA_QUEUED;
- if (drive->using_dma)
+ if (dma)
return lba48 ? WIN_WRITEDMA_EXT : WIN_WRITEDMA;
+ task->prehandler = &pre_task_out_intr;
+ task->handler = &task_out_intr;
if (drive->mult_count) {
- task->prehandler = &pre_task_mulout_intr;
- task->handler = &task_mulout_intr;
+ task->data_phase = TASKFILE_MULTI_OUT;
return lba48 ? WIN_MULTWRITE_EXT : WIN_MULTWRITE;
}
- task->prehandler = &pre_task_out_intr;
- task->handler = &task_out_intr;
+ task->data_phase = TASKFILE_OUT;
return lba48 ? WIN_WRITE_EXT : WIN_WRITE;
}
}
nsectors.all = (u16) rq->nr_sectors;
-#ifdef DEBUG
- printk("%s: %sing: ", drive->name, (rq_data_dir(rq)==READ) ? "read" : "writ");
- printk("CHS=%d/%d/%d, ", cyl, head, sect);
- printk("sectors=%ld, ", rq->nr_sectors);
- printk("buffer=0x%08lx\n", (unsigned long) rq->buffer);
-#endif
+ pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
memset(&args, 0, sizeof(ide_task_t));
sectors = (rq->nr_sectors == 256) ? 0x00 : rq->nr_sectors;
- if (blk_rq_tagged(rq)) {
- args.tfRegister[IDE_FEATURE_OFFSET] = sectors;
- args.tfRegister[IDE_NSECTOR_OFFSET] = rq->tag << 3;
- } else
- args.tfRegister[IDE_NSECTOR_OFFSET] = sectors;
-
+ args.tfRegister[IDE_NSECTOR_OFFSET] = sectors;
args.tfRegister[IDE_SECTOR_OFFSET] = sect;
args.tfRegister[IDE_LCYL_OFFSET] = cyl;
args.tfRegister[IDE_HCYL_OFFSET] = (cyl>>8);
args.tfRegister[IDE_SELECT_OFFSET] = head;
args.tfRegister[IDE_SELECT_OFFSET] |= drive->select.all;
- args.tfRegister[IDE_COMMAND_OFFSET] = get_command(drive, rq_data_dir(rq), &args);
+ args.tfRegister[IDE_COMMAND_OFFSET] = get_command(drive, rq, &args);
args.rq = (struct request *) rq;
rq->special = (ide_task_t *)&args;
+ drive->hwif->data_phase = args.data_phase;
return do_rw_taskfile(drive, &args);
}
nsectors.all = (u16) rq->nr_sectors;
-#ifdef DEBUG
- printk("%s: %sing: ", drive->name, (rq_data_dir(rq)==READ) ? "read" : "writ");
- printk("LBAsect=%lld, ", block);
- printk("sectors=%ld, ", rq->nr_sectors);
- printk("buffer=0x%08lx\n", (unsigned long) rq->buffer);
-#endif
-
memset(&args, 0, sizeof(ide_task_t));
sectors = (rq->nr_sectors == 256) ? 0x00 : rq->nr_sectors;
- if (blk_rq_tagged(rq)) {
- args.tfRegister[IDE_FEATURE_OFFSET] = sectors;
- args.tfRegister[IDE_NSECTOR_OFFSET] = rq->tag << 3;
- } else
- args.tfRegister[IDE_NSECTOR_OFFSET] = sectors;
-
+ args.tfRegister[IDE_NSECTOR_OFFSET] = sectors;
args.tfRegister[IDE_SECTOR_OFFSET] = block;
args.tfRegister[IDE_LCYL_OFFSET] = (block>>=8);
args.tfRegister[IDE_HCYL_OFFSET] = (block>>=8);
args.tfRegister[IDE_SELECT_OFFSET] = ((block>>8)&0x0f);
args.tfRegister[IDE_SELECT_OFFSET] |= drive->select.all;
- args.tfRegister[IDE_COMMAND_OFFSET] = get_command(drive, rq_data_dir(rq), &args);
+ args.tfRegister[IDE_COMMAND_OFFSET] = get_command(drive, rq, &args);
args.rq = (struct request *) rq;
rq->special = (ide_task_t *)&args;
+ drive->hwif->data_phase = args.data_phase;
return do_rw_taskfile(drive, &args);
}
nsectors.all = (u16) rq->nr_sectors;
-#ifdef DEBUG
- printk("%s: %sing: ", drive->name, (rq_data_dir(rq)==READ) ? "read" : "writ");
- printk("LBAsect=%lld, ", block);
- printk("sectors=%ld, ", rq->nr_sectors);
- printk("buffer=0x%08lx\n", (unsigned long) rq->buffer);
-#endif
-
memset(&args, 0, sizeof(ide_task_t));
sectors = (rq->nr_sectors == 65536) ? 0 : rq->nr_sectors;
- if (blk_rq_tagged(rq)) {
- args.tfRegister[IDE_FEATURE_OFFSET] = sectors;
- args.tfRegister[IDE_NSECTOR_OFFSET] = rq->tag << 3;
- args.hobRegister[IDE_FEATURE_OFFSET] = sectors >> 8;
- args.hobRegister[IDE_NSECTOR_OFFSET] = 0;
- } else {
- args.tfRegister[IDE_NSECTOR_OFFSET] = sectors;
- args.hobRegister[IDE_NSECTOR_OFFSET] = sectors >> 8;
- }
-
+ args.tfRegister[IDE_NSECTOR_OFFSET] = sectors;
+ args.hobRegister[IDE_NSECTOR_OFFSET] = sectors >> 8;
args.tfRegister[IDE_SECTOR_OFFSET] = block; /* low lba */
args.tfRegister[IDE_LCYL_OFFSET] = (block>>=8); /* mid lba */
args.tfRegister[IDE_HCYL_OFFSET] = (block>>=8); /* hi lba */
args.tfRegister[IDE_SELECT_OFFSET] = drive->select.all;
- args.tfRegister[IDE_COMMAND_OFFSET] = get_command(drive, rq_data_dir(rq), &args);
+ args.tfRegister[IDE_COMMAND_OFFSET] = get_command(drive, rq, &args);
args.hobRegister[IDE_SECTOR_OFFSET] = (block>>=8); /* low lba */
args.hobRegister[IDE_LCYL_OFFSET] = (block>>=8); /* mid lba */
args.hobRegister[IDE_HCYL_OFFSET] = (block>>=8); /* hi lba */
args.hobRegister[IDE_CONTROL_OFFSET_HOB]= (drive->ctl|0x80);
args.rq = (struct request *) rq;
rq->special = (ide_task_t *)&args;
+ drive->hwif->data_phase = args.data_phase;
return do_rw_taskfile(drive, &args);
}
{
ide_hwif_t *hwif = HWIF(drive);
+ BUG_ON(drive->blocked);
+
+ if (!blk_fs_request(rq)) {
+ blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
+ ide_end_request(drive, 0, 0);
+ return ide_stopped;
+ }
+
+ pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
+ drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
+ block, rq->nr_sectors, (unsigned long)rq->buffer);
+
if (hwif->rw_disk)
return hwif->rw_disk(drive, rq, block);
else
return __ide_do_rw_disk(drive, rq, block);
}
-static int do_idedisk_flushcache(ide_drive_t *drive);
-
static u8 idedisk_dump_status (ide_drive_t *drive, const char *msg, u8 stat)
{
ide_hwif_t *hwif = HWIF(drive);
local_irq_set(flags);
printk("%s: %s: status=0x%02x", drive->name, msg, stat);
-#if FANCY_STATUS_DUMPS
printk(" { ");
if (stat & BUSY_STAT)
printk("Busy ");
if (stat & ERR_STAT) printk("Error ");
}
printk("}");
-#endif /* FANCY_STATUS_DUMPS */
printk("\n");
if ((stat & (BUSY_STAT|ERR_STAT)) == ERR_STAT) {
err = hwif->INB(IDE_ERROR_REG);
printk("%s: %s: error=0x%02x", drive->name, msg, err);
-#if FANCY_STATUS_DUMPS
printk(" { ");
if (err & ABRT_ERR) printk("DriveStatusError ");
if (err & ICRC_ERR)
(unsigned long long)HWGROUP(drive)->rq->sector);
}
}
-#endif /* FANCY_STATUS_DUMPS */
printk("\n");
+ {
+ struct request *rq;
+ unsigned char opcode = 0;
+ int found = 0;
+
+ spin_lock(&ide_lock);
+ rq = HWGROUP(drive)->rq;
+ spin_unlock(&ide_lock);
+ if (!rq)
+ goto out;
+ if (rq->flags & (REQ_DRIVE_CMD | REQ_DRIVE_TASK)) {
+ char *args = rq->buffer;
+ if (args) {
+ opcode = args[0];
+ found = 1;
+ }
+ } else if (rq->flags & REQ_DRIVE_TASKFILE) {
+ ide_task_t *args = rq->special;
+ if (args) {
+ task_struct_t *tf = (task_struct_t *) args->tfRegister;
+ opcode = tf->command;
+ found = 1;
+ }
+ }
+ printk("ide: failed opcode was: ");
+ if (!found)
+ printk("unknown\n");
+ else
+ printk("0x%02x\n", opcode);
+ }
+out:
local_irq_restore(flags);
return err;
}
ide_hwif_t *hwif;
struct request *rq;
u8 err;
- int i = (drive->mult_count ? drive->mult_count : 1) * SECTOR_WORDS;
err = idedisk_dump_status(drive, msg, stat);
rq->errors |= ERROR_RECAL;
}
}
- if ((stat & DRQ_STAT) && rq_data_dir(rq) == READ) {
- /*
- * try_to_flush_leftover_data() is invoked in response to
- * a drive unexpectedly having its DRQ_STAT bit set. As
- * an alternative to resetting the drive, this routine
- * tries to clear the condition by read a sector's worth
- * of data from the drive. Of course, this may not help
- * if the drive is *waiting* for data from *us*.
- */
- while (i > 0) {
- u32 buffer[16];
- unsigned int wcount = (i > 16) ? 16 : i;
- i -= wcount;
- taskfile_input_data(drive, buffer, wcount);
- }
- }
+ if ((stat & DRQ_STAT) && rq_data_dir(rq) == READ)
+ try_to_flush_leftover_data(drive);
if (hwif->INB(IDE_STATUS_REG) & (BUSY_STAT|DRQ_STAT)) {
/* force an abort */
hwif->OUTB(WIN_IDLEIMMEDIATE,IDE_COMMAND_REG);
return addr;
}
-#ifdef CONFIG_IDEDISK_STROKE
/*
* Sets maximum virtual LBA address of the drive.
* Returns new maximum virtual LBA address (> 0) or 0 on failure.
return addr_set;
}
-#endif /* CONFIG_IDEDISK_STROKE */
-
static unsigned long long sectors_to_MB(unsigned long long n)
{
n <<= 9; /* make it bytes */
drive->name,
capacity, sectors_to_MB(capacity),
set_max, sectors_to_MB(set_max));
-#ifdef CONFIG_IDEDISK_STROKE
+
+ if (!drive->stroke)
+ return;
+
if (lba48)
set_max = idedisk_set_max_address_ext(drive, set_max);
else
printk(KERN_INFO "%s: Host Protected Area disabled.\n",
drive->name);
}
-#endif
}
/*
args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS;
args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART;
args.command_type = IDE_DRIVE_TASK_IN;
+ args.data_phase = TASKFILE_IN;
args.handler = &task_in_intr;
(void) smart_enable(drive);
return ide_raw_taskfile(drive, &args, buf);
#endif /* CONFIG_PROC_FS */
+static int idedisk_issue_flush(request_queue_t *q, struct gendisk *disk,
+ sector_t *error_sector)
+{
+ ide_drive_t *drive = q->queuedata;
+ struct request *rq;
+ int ret;
+
+ if (!drive->wcache)
+ return 0;
+
+ rq = blk_get_request(q, WRITE, __GFP_WAIT);
+
+ memset(rq->cmd, 0, sizeof(rq->cmd));
+
+ if (ide_id_has_flush_cache_ext(drive->id) &&
+ (drive->capacity64 >= (1UL << 28)))
+ rq->cmd[0] = WIN_FLUSH_CACHE_EXT;
+ else
+ rq->cmd[0] = WIN_FLUSH_CACHE;
+
+
+ rq->flags |= REQ_DRIVE_TASK | REQ_SOFTBARRIER;
+ rq->buffer = rq->cmd;
+
+ ret = blk_execute_rq(q, disk, rq);
+
+ /*
+ * if we failed and caller wants error offset, get it
+ */
+ if (ret && error_sector)
+ *error_sector = ide_get_error_location(drive, rq->cmd);
+
+ blk_put_request(rq);
+ return ret;
+}
+
/*
* This is tightly woven into the driver->do_special can not touch.
* DON'T do it again until a total personality rewrite is committed.
return 0;
}
-static int write_cache (ide_drive_t *drive, int arg)
+static int write_cache(ide_drive_t *drive, int arg)
{
ide_task_t args;
+ int err;
- if (!(drive->id->cfs_enable_2 & 0x3000))
+ if (!ide_id_has_flush_cache(drive->id))
return 1;
memset(&args, 0, sizeof(ide_task_t));
args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SETFEATURES;
args.command_type = IDE_DRIVE_TASK_NO_DATA;
args.handler = &task_no_data_intr;
- (void) ide_raw_taskfile(drive, &args, NULL);
+
+ err = ide_raw_taskfile(drive, &args, NULL);
+ if (err)
+ return err;
drive->wcache = arg;
return 0;
ide_task_t args;
memset(&args, 0, sizeof(ide_task_t));
- if (drive->id->cfs_enable_2 & 0x2400)
+ if (ide_id_has_flush_cache_ext(drive->id))
args.tfRegister[IDE_COMMAND_OFFSET] = WIN_FLUSH_CACHE_EXT;
else
args.tfRegister[IDE_COMMAND_OFFSET] = WIN_FLUSH_CACHE;
return 0;
}
-#ifdef CONFIG_BLK_DEV_IDE_TCQ
-static int set_using_tcq(ide_drive_t *drive, int arg)
-{
- int ret;
-
- if (!drive->driver)
- return -EPERM;
- if (arg == drive->queue_depth && drive->using_tcq)
- return 0;
-
- /*
- * set depth, but check also id for max supported depth
- */
- drive->queue_depth = arg ? arg : 1;
- if (drive->id) {
- if (drive->queue_depth > drive->id->queue_depth + 1)
- drive->queue_depth = drive->id->queue_depth + 1;
- }
-
- if (arg)
- ret = __ide_dma_queued_on(drive);
- else
- ret = __ide_dma_queued_off(drive);
-
- return ret ? -EIO : 0;
-}
-#endif
-
/*
* drive->addressing:
* 0: 28-bit
ide_add_setting(drive, "acoustic", SETTING_RW, HDIO_GET_ACOUSTIC, HDIO_SET_ACOUSTIC, TYPE_BYTE, 0, 254, 1, 1, &drive->acoustic, set_acoustic);
ide_add_setting(drive, "failures", SETTING_RW, -1, -1, TYPE_INT, 0, 65535, 1, 1, &drive->failures, NULL);
ide_add_setting(drive, "max_failures", SETTING_RW, -1, -1, TYPE_INT, 0, 65535, 1, 1, &drive->max_failures, NULL);
-#ifdef CONFIG_BLK_DEV_IDE_TCQ
- ide_add_setting(drive, "using_tcq", SETTING_RW, HDIO_GET_QDMA, HDIO_SET_QDMA, TYPE_BYTE, 0, IDE_MAX_TAG, 1, 1, &drive->using_tcq, set_using_tcq);
-#endif
}
/*
idedisk_pm_flush_cache = ide_pm_state_start_suspend,
idedisk_pm_standby,
- idedisk_pm_restore_dma = ide_pm_state_start_resume,
+ idedisk_pm_idle = ide_pm_state_start_resume,
+ idedisk_pm_restore_dma,
};
static void idedisk_complete_power_step (ide_drive_t *drive, struct request *rq, u8 stat, u8 error)
case idedisk_pm_standby: /* Suspend step 2 (standby) complete */
rq->pm->pm_step = ide_pm_state_completed;
break;
+ case idedisk_pm_idle: /* Resume step 1 (idle) complete */
+ rq->pm->pm_step = idedisk_pm_restore_dma;
+ break;
}
}
switch (rq->pm->pm_step) {
case idedisk_pm_flush_cache: /* Suspend step 1 (flush cache) */
/* Not supported? Switch to next step now. */
- if (!drive->wcache) {
+ if (!drive->wcache || !ide_id_has_flush_cache(drive->id)) {
idedisk_complete_power_step(drive, rq, 0, 0);
return ide_stopped;
}
- if (drive->id->cfs_enable_2 & 0x2400)
+ if (ide_id_has_flush_cache_ext(drive->id))
args->tfRegister[IDE_COMMAND_OFFSET] = WIN_FLUSH_CACHE_EXT;
else
args->tfRegister[IDE_COMMAND_OFFSET] = WIN_FLUSH_CACHE;
args->command_type = IDE_DRIVE_TASK_NO_DATA;
args->handler = &task_no_data_intr;
return do_rw_taskfile(drive, args);
+
case idedisk_pm_standby: /* Suspend step 2 (standby) */
args->tfRegister[IDE_COMMAND_OFFSET] = WIN_STANDBYNOW1;
args->command_type = IDE_DRIVE_TASK_NO_DATA;
args->handler = &task_no_data_intr;
return do_rw_taskfile(drive, args);
- case idedisk_pm_restore_dma: /* Resume step 1 (restore DMA) */
+ case idedisk_pm_idle: /* Resume step 1 (idle) */
+ args->tfRegister[IDE_COMMAND_OFFSET] = WIN_IDLEIMMEDIATE;
+ args->command_type = IDE_DRIVE_TASK_NO_DATA;
+ args->handler = task_no_data_intr;
+ return do_rw_taskfile(drive, args);
+
+ case idedisk_pm_restore_dma: /* Resume step 2 (restore DMA) */
/*
* Right now, all we do is call hwif->ide_dma_check(drive),
* we could be smarter and check for current xfer_speed
{
struct hd_driveid *id = drive->id;
unsigned long long capacity;
+ int barrier;
idedisk_add_settings(drive);
blk_queue_max_sectors(drive->queue, max_s);
}
- printk("%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2);
+ printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2);
/* Extract geometry if we did not already have one for the drive */
if (!drive->cyl || !drive->head || !drive->sect) {
/* limit drive capacity to 137GB if LBA48 cannot be used */
if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
- printk("%s: cannot use LBA48 - full capacity "
+ printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
"%llu sectors (%llu MB)\n",
drive->name, (unsigned long long)drive->capacity64,
sectors_to_MB(drive->capacity64));
drive->capacity64 = 1ULL << 28;
}
+ if (drive->hwif->no_lba48_dma && drive->addressing) {
+ if (drive->capacity64 > 1ULL << 28) {
+ printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode will"
+ " be used for accessing sectors > %u\n",
+ drive->name, 1 << 28);
+ } else
+ drive->addressing = 0;
+ }
+
/*
* if possible, give fdisk access to more of the drive,
* by correcting bios_cyls:
#endif /* CONFIG_IDEDISK_MULTI_MODE */
}
drive->no_io_32bit = id->dword_io ? 1 : 0;
- if (drive->id->cfs_enable_2 & 0x3000)
- write_cache(drive, (id->cfs_enable_2 & 0x3000));
-#ifdef CONFIG_BLK_DEV_IDE_TCQ_DEFAULT
- if (drive->using_dma)
- __ide_dma_queued_on(drive);
-#endif
+ /* write cache enabled? */
+ if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5)))
+ drive->wcache = 1;
+
+ write_cache(drive, 1);
+
+ /*
+ * We must avoid issuing commands a drive does not understand
+ * or we may crash it. We check flush cache is supported. We also
+ * check we have the LBA48 flush cache if the drive capacity is
+ * too large. By this time we have trimmed the drive capacity if
+ * LBA48 is not available so we don't need to recheck that.
+ */
+ barrier = 0;
+ if (ide_id_has_flush_cache(id))
+ barrier = 1;
+ if (drive->addressing == 1) {
+ /* Can't issue the correct flush ? */
+ if (capacity > (1ULL << 28) && !ide_id_has_flush_cache_ext(id))
+ barrier = 0;
+ }
+
+ printk(KERN_DEBUG "%s: cache flushes %ssupported\n",
+ drive->name, barrier ? "" : "not ");
+ if (barrier) {
+ blk_queue_ordered(drive->queue, 1);
+ blk_queue_issue_flush_fn(drive->queue, idedisk_issue_flush);
+ }
+}
+
+static void ide_cacheflush_p(ide_drive_t *drive)
+{
+ if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
+ return;
+
+ if (do_idedisk_flushcache(drive))
+ printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
}
static int idedisk_cleanup (ide_drive_t *drive)
{
- static int ide_cacheflush_p(ide_drive_t *drive);
struct gendisk *g = drive->disk;
ide_cacheflush_p(drive);
if (ide_unregister_subdriver(drive))
{
ide_drive_t *drive = container_of(dev, ide_drive_t, gendev);
+#ifdef CONFIG_ALPHA
+ /* On Alpha, halt(8) doesn't actually turn the machine off,
+ it puts you into the sort of firmware monitor. Typically,
+ it's used to boot another kernel image, so it's not much
+ different from reboot(8). Therefore, we don't need to
+ spin down the disk in this case, especially since Alpha
+ firmware doesn't handle disks in standby mode properly.
+ On the other hand, it's reasonably safe to turn the power
+ off when the shutdown process reaches the firmware prompt,
+ as the firmware initialization takes rather long time -
+ at least 10 seconds, which should be sufficient for
+ the disk to expire its write cache. */
+ if (system_state != SYSTEM_POWER_OFF) {
+#else
+ if (system_state == SYSTEM_RESTART) {
+#endif
+ ide_cacheflush_p(drive);
+ return;
+ }
+
printk("Shutdown: %s\n", drive->name);
dev->bus->suspend(dev, PM_SUSPEND_STANDBY);
}
static int idedisk_open(struct inode *inode, struct file *filp)
{
- u8 cf;
ide_drive_t *drive = inode->i_bdev->bd_disk->private_data;
drive->usage++;
if (drive->removable && drive->usage == 1) {
if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
drive->doorlocking = 0;
}
- drive->wcache = 0;
- /* Cache enabled? */
- if (drive->id->csfo & 1)
- drive->wcache = 1;
- /* Cache command set available? */
- if (drive->id->cfs_enable_1 & (1 << 5))
- drive->wcache = 1;
- /* ATA6 cache extended commands */
- cf = drive->id->command_set_2 >> 24;
- if ((cf & 0xC0) == 0x40 && (cf & 0x30) != 0)
- drive->wcache = 1;
- return 0;
-}
-
-static int ide_cacheflush_p(ide_drive_t *drive)
-{
- if (!(drive->id->cfs_enable_2 & 0x3000))
- return 0;
-
- if(drive->wcache)
- {
- if (do_idedisk_flushcache(drive))
- {
- printk (KERN_INFO "%s: Write Cache FAILED Flushing!\n",
- drive->name);
- return -EIO;
- }
- return 1;
- }
return 0;
}
unsigned int cmd, unsigned long arg)
{
struct block_device *bdev = inode->i_bdev;
- return generic_ide_ioctl(bdev, cmd, arg);
+ return generic_ide_ioctl(file, bdev, cmd, arg);
}
static int idedisk_media_changed(struct gendisk *disk)
if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
drive->name, drive->head);
- if ((drive->id->cfs_enable_2 & 0x3000) && drive->wcache)
- if (do_idedisk_flushcache(drive))
- printk (KERN_INFO "%s: Write Cache FAILED Flushing!\n",
- drive->name);
- ide_unregister_subdriver(drive);
- DRIVER(drive)->busy--;
- goto failed;
- }
+ drive->attach = 0;
+ } else
+ drive->attach = 1;
DRIVER(drive)->busy--;
g->minors = 1 << PARTN_BITS;
strcpy(g->devfs_name, drive->devfs_name);
g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
set_capacity(g, current_capacity(drive));
g->fops = &idedisk_ops;
- drive->attach = 1;
add_disk(g);
return 0;
failed:
git://git.onelab.eu / linux-2.6.git / blobdiff