patch-2.4.21 linux-2.4.21/drivers/ide/ide-taskfile.c
Next file: linux-2.4.21/drivers/ide/ide.c
Previous file: linux-2.4.21/drivers/ide/ide-tape.c
Back to the patch index
Back to the overall index
- Lines: 2906
- Date:
2003-06-13 07:51:33.000000000 -0700
- Orig file:
linux-2.4.20/drivers/ide/ide-taskfile.c
- Orig date:
2002-08-02 17:39:44.000000000 -0700
diff -urN linux-2.4.20/drivers/ide/ide-taskfile.c linux-2.4.21/drivers/ide/ide-taskfile.c
@@ -1,12 +1,29 @@
/*
- * linux/drivers/ide/ide-taskfile.c Version 0.20 Oct 11, 2000
+ * linux/drivers/ide/ide-taskfile.c Version 0.38 March 05, 2003
*
- * Copyright (C) 2000 Michael Cornwell <cornwell@acm.org>
- * Copyright (C) 2000 Andre Hedrick <andre@linux-ide.org>
+ * Copyright (C) 2000-2002 Michael Cornwell <cornwell@acm.org>
+ * Copyright (C) 2000-2002 Andre Hedrick <andre@linux-ide.org>
+ * Copyright (C) 2001-2002 Klaus Smolin
+ * IBM Storage Technology Division
*
- * May be copied or modified under the terms of the GNU General Public License
+ * The big the bad and the ugly.
*
- * IDE_DEBUG(__LINE__);
+ * Problems to be fixed because of BH interface or the lack therefore.
+ *
+ * Fill me in stupid !!!
+ *
+ * HOST:
+ * General refers to the Controller and Driver "pair".
+ * DATA HANDLER:
+ * Under the context of Linux it generally refers to an interrupt handler.
+ * However, it correctly describes the 'HOST'
+ * DATA BLOCK:
+ * The amount of data needed to be transfered as predefined in the
+ * setup of the device.
+ * STORAGE ATOMIC:
+ * The 'DATA BLOCK' associated to the 'DATA HANDLER', and can be as
+ * small as a single sector or as large as the entire command block
+ * request.
*/
#include <linux/config.h>
@@ -34,27 +51,50 @@
#include <asm/io.h>
#include <asm/bitops.h>
-#ifdef CONFIG_IDE_TASKFILE_IO
-# define __TASKFILE__IO
-#else /* CONFIG_IDE_TASKFILE_IO */
-# undef __TASKFILE__IO
-#endif /* CONFIG_IDE_TASKFILE_IO */
-
#define DEBUG_TASKFILE 0 /* unset when fixed */
#if DEBUG_TASKFILE
-#define DTF(x...) printk(##x)
+#define DTF(x...) printk(x)
#else
#define DTF(x...)
#endif
+/*
+ *
+ */
+#define task_rq_offset(rq) \
+ (((rq)->nr_sectors - (rq)->current_nr_sectors) * SECTOR_SIZE)
+
+/*
+ * for now, taskfile requests are special :/
+ *
+ * However, upon the creation of the atapi version of packet_command
+ * data-phase ISR plus it own diagnostics and extensions for direct access
+ * (ioctl,read,write,rip,stream -- atapi), the kmap/kunmap for PIO will
+ * come localized.
+ */
+inline char *task_map_rq (struct request *rq, unsigned long *flags)
+{
+ if (rq->bh)
+ return ide_map_buffer(rq, flags);
+ return rq->buffer + task_rq_offset(rq);
+}
+
+inline void task_unmap_rq (struct request *rq, char *buf, unsigned long *flags)
+{
+ if (rq->bh)
+ ide_unmap_buffer(buf, flags);
+}
+
inline u32 task_read_24 (ide_drive_t *drive)
{
- return (IN_BYTE(IDE_HCYL_REG)<<16) |
- (IN_BYTE(IDE_LCYL_REG)<<8) |
- IN_BYTE(IDE_SECTOR_REG);
+ return (HWIF(drive)->INB(IDE_HCYL_REG)<<16) |
+ (HWIF(drive)->INB(IDE_LCYL_REG)<<8) |
+ HWIF(drive)->INB(IDE_SECTOR_REG);
}
+EXPORT_SYMBOL(task_read_24);
+
static void ata_bswap_data (void *buffer, int wcount)
{
u16 *p = buffer;
@@ -65,381 +105,177 @@
}
}
-#if SUPPORT_VLB_SYNC
-/*
- * Some localbus EIDE interfaces require a special access sequence
- * when using 32-bit I/O instructions to transfer data. We call this
- * the "vlb_sync" sequence, which consists of three successive reads
- * of the sector count register location, with interrupts disabled
- * to ensure that the reads all happen together.
- */
-static inline void task_vlb_sync (ide_ioreg_t port) {
- (void) inb (port);
- (void) inb (port);
- (void) inb (port);
-}
-#endif /* SUPPORT_VLB_SYNC */
-
-/*
- * This is used for most PIO data transfers *from* the IDE interface
- */
-void ata_input_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
-{
- byte io_32bit = drive->io_32bit;
-
- if (io_32bit) {
-#if SUPPORT_VLB_SYNC
- if (io_32bit & 2) {
- unsigned long flags;
- __save_flags(flags); /* local CPU only */
- __cli(); /* local CPU only */
- task_vlb_sync(IDE_NSECTOR_REG);
- insl(IDE_DATA_REG, buffer, wcount);
- __restore_flags(flags); /* local CPU only */
- } else
-#endif /* SUPPORT_VLB_SYNC */
- insl(IDE_DATA_REG, buffer, wcount);
- } else {
-#if SUPPORT_SLOW_DATA_PORTS
- if (drive->slow) {
- unsigned short *ptr = (unsigned short *) buffer;
- while (wcount--) {
- *ptr++ = inw_p(IDE_DATA_REG);
- *ptr++ = inw_p(IDE_DATA_REG);
- }
- } else
-#endif /* SUPPORT_SLOW_DATA_PORTS */
- insw(IDE_DATA_REG, buffer, wcount<<1);
- }
-}
-
-/*
- * This is used for most PIO data transfers *to* the IDE interface
- */
-void ata_output_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
-{
- byte io_32bit = drive->io_32bit;
-
- if (io_32bit) {
-#if SUPPORT_VLB_SYNC
- if (io_32bit & 2) {
- unsigned long flags;
- __save_flags(flags); /* local CPU only */
- __cli(); /* local CPU only */
- task_vlb_sync(IDE_NSECTOR_REG);
- outsl(IDE_DATA_REG, buffer, wcount);
- __restore_flags(flags); /* local CPU only */
- } else
-#endif /* SUPPORT_VLB_SYNC */
- outsl(IDE_DATA_REG, buffer, wcount);
- } else {
-#if SUPPORT_SLOW_DATA_PORTS
- if (drive->slow) {
- unsigned short *ptr = (unsigned short *) buffer;
- while (wcount--) {
- outw_p(*ptr++, IDE_DATA_REG);
- outw_p(*ptr++, IDE_DATA_REG);
- }
- } else
-#endif /* SUPPORT_SLOW_DATA_PORTS */
- outsw(IDE_DATA_REG, buffer, wcount<<1);
- }
-}
-
-static inline void taskfile_input_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
+void taskfile_input_data (ide_drive_t *drive, void *buffer, u32 wcount)
{
- ata_input_data(drive, buffer, wcount);
+ HWIF(drive)->ata_input_data(drive, buffer, wcount);
if (drive->bswap)
ata_bswap_data(buffer, wcount);
}
-static inline void taskfile_output_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
+EXPORT_SYMBOL(taskfile_input_data);
+
+void taskfile_output_data (ide_drive_t *drive, void *buffer, u32 wcount)
{
if (drive->bswap) {
ata_bswap_data(buffer, wcount);
- ata_output_data(drive, buffer, wcount);
+ HWIF(drive)->ata_output_data(drive, buffer, wcount);
ata_bswap_data(buffer, wcount);
} else {
- ata_output_data(drive, buffer, wcount);
+ HWIF(drive)->ata_output_data(drive, buffer, wcount);
}
}
-ide_startstop_t do_rw_taskfile (ide_drive_t *drive, ide_task_t *task)
-{
- task_struct_t *taskfile = (task_struct_t *) task->tfRegister;
- hob_struct_t *hobfile = (hob_struct_t *) task->hobRegister;
- struct hd_driveid *id = drive->id;
- byte HIHI = (drive->addressing) ? 0xE0 : 0xEF;
-
- /* (ks/hs): Moved to start, do not use for multiple out commands */
- if (task->handler != task_mulout_intr) {
- if (IDE_CONTROL_REG)
- OUT_BYTE(drive->ctl, IDE_CONTROL_REG); /* clear nIEN */
- SELECT_MASK(HWIF(drive), drive, 0);
- }
-
- if ((id->command_set_2 & 0x0400) &&
- (id->cfs_enable_2 & 0x0400) &&
- (drive->addressing == 1)) {
- OUT_BYTE(hobfile->feature, IDE_FEATURE_REG);
- OUT_BYTE(hobfile->sector_count, IDE_NSECTOR_REG);
- OUT_BYTE(hobfile->sector_number, IDE_SECTOR_REG);
- OUT_BYTE(hobfile->low_cylinder, IDE_LCYL_REG);
- OUT_BYTE(hobfile->high_cylinder, IDE_HCYL_REG);
- }
-
- OUT_BYTE(taskfile->feature, IDE_FEATURE_REG);
- OUT_BYTE(taskfile->sector_count, IDE_NSECTOR_REG);
- /* refers to number of sectors to transfer */
- OUT_BYTE(taskfile->sector_number, IDE_SECTOR_REG);
- /* refers to sector offset or start sector */
- OUT_BYTE(taskfile->low_cylinder, IDE_LCYL_REG);
- OUT_BYTE(taskfile->high_cylinder, IDE_HCYL_REG);
-
- OUT_BYTE((taskfile->device_head & HIHI) | drive->select.all, IDE_SELECT_REG);
- if (task->handler != NULL) {
-#if 0
- ide_set_handler (drive, task->handler, WAIT_CMD, NULL);
- OUT_BYTE(taskfile->command, IDE_COMMAND_REG);
- /*
- * warning check for race between handler and prehandler for
- * writing first block of data. however since we are well
- * inside the boundaries of the seek, we should be okay.
- */
- if (task->prehandler != NULL) {
- return task->prehandler(drive, task->rq);
- }
-#else
- ide_startstop_t startstop;
-
- ide_set_handler (drive, task->handler, WAIT_CMD, NULL);
- OUT_BYTE(taskfile->command, IDE_COMMAND_REG);
-
- if (ide_wait_stat(&startstop, drive, DATA_READY, drive->bad_wstat, WAIT_DRQ)) {
- printk(KERN_ERR "%s: no DRQ after issuing %s\n",
- drive->name,
- drive->mult_count ? "MULTWRITE" : "WRITE");
- return startstop;
- }
- /* (ks/hs): Fixed Multi Write */
- if ((taskfile->command != WIN_MULTWRITE) &&
- (taskfile->command != WIN_MULTWRITE_EXT)) {
- struct request *rq = HWGROUP(drive)->rq;
- /* For Write_sectors we need to stuff the first sector */
- taskfile_output_data(drive, rq->buffer, SECTOR_WORDS);
- rq->current_nr_sectors--;
- } else {
- /* Stuff first sector(s) by implicitly calling the handler */
- if (!(drive_is_ready(drive))) {
- /* FIXME: Replace hard-coded 100, error handling? */
- int i;
- for (i=0; i<100; i++) {
- if (drive_is_ready(drive))
- break;
- }
- }
- return task->handler(drive);
- }
-#endif
- } else {
- /* for dma commands we down set the handler */
- if (drive->using_dma && !(HWIF(drive)->dmaproc(((taskfile->command == WIN_WRITEDMA) || (taskfile->command == WIN_WRITEDMA_EXT)) ? ide_dma_write : ide_dma_read, drive)));
- }
-
- return ide_started;
-}
+EXPORT_SYMBOL(taskfile_output_data);
-void do_taskfile (ide_drive_t *drive, struct hd_drive_task_hdr *taskfile, struct hd_drive_hob_hdr *hobfile, ide_handler_t *handler)
+int taskfile_lib_get_identify (ide_drive_t *drive, u8 *buf)
{
- struct hd_driveid *id = drive->id;
- byte HIHI = (drive->addressing) ? 0xE0 : 0xEF;
-
- /* (ks/hs): Moved to start, do not use for multiple out commands */
- if (*handler != task_mulout_intr) {
- if (IDE_CONTROL_REG)
- OUT_BYTE(drive->ctl, IDE_CONTROL_REG); /* clear nIEN */
- SELECT_MASK(HWIF(drive), drive, 0);
- }
-
- if ((id->command_set_2 & 0x0400) &&
- (id->cfs_enable_2 & 0x0400) &&
- (drive->addressing == 1)) {
- OUT_BYTE(hobfile->feature, IDE_FEATURE_REG);
- OUT_BYTE(hobfile->sector_count, IDE_NSECTOR_REG);
- OUT_BYTE(hobfile->sector_number, IDE_SECTOR_REG);
- OUT_BYTE(hobfile->low_cylinder, IDE_LCYL_REG);
- OUT_BYTE(hobfile->high_cylinder, IDE_HCYL_REG);
- }
+ ide_task_t args;
+ memset(&args, 0, sizeof(ide_task_t));
+ args.tfRegister[IDE_NSECTOR_OFFSET] = 0x01;
+ if (drive->media == ide_disk)
+ args.tfRegister[IDE_COMMAND_OFFSET] = WIN_IDENTIFY;
+ else
+ args.tfRegister[IDE_COMMAND_OFFSET] = WIN_PIDENTIFY;
+ args.command_type = ide_cmd_type_parser(&args);
+ return ide_raw_taskfile(drive, &args, buf);
+}
- OUT_BYTE(taskfile->feature, IDE_FEATURE_REG);
- OUT_BYTE(taskfile->sector_count, IDE_NSECTOR_REG);
- /* refers to number of sectors to transfer */
- OUT_BYTE(taskfile->sector_number, IDE_SECTOR_REG);
- /* refers to sector offset or start sector */
- OUT_BYTE(taskfile->low_cylinder, IDE_LCYL_REG);
- OUT_BYTE(taskfile->high_cylinder, IDE_HCYL_REG);
+EXPORT_SYMBOL(taskfile_lib_get_identify);
- OUT_BYTE((taskfile->device_head & HIHI) | drive->select.all, IDE_SELECT_REG);
- if (handler != NULL) {
- ide_set_handler (drive, handler, WAIT_CMD, NULL);
- OUT_BYTE(taskfile->command, IDE_COMMAND_REG);
- } else {
- /* for dma commands we down set the handler */
- if (drive->using_dma && !(HWIF(drive)->dmaproc(((taskfile->command == WIN_WRITEDMA) || (taskfile->command == WIN_WRITEDMA_EXT)) ? ide_dma_write : ide_dma_read, drive)));
- }
+#ifdef CONFIG_IDE_TASK_IOCTL_DEBUG
+void debug_taskfile (ide_drive_t *drive, ide_task_t *args)
+{
+ printk(KERN_INFO "%s: ", drive->name);
+// printk("TF.0=x%02x ", args->tfRegister[IDE_DATA_OFFSET]);
+ printk("TF.1=x%02x ", args->tfRegister[IDE_FEATURE_OFFSET]);
+ printk("TF.2=x%02x ", args->tfRegister[IDE_NSECTOR_OFFSET]);
+ printk("TF.3=x%02x ", args->tfRegister[IDE_SECTOR_OFFSET]);
+ printk("TF.4=x%02x ", args->tfRegister[IDE_LCYL_OFFSET]);
+ printk("TF.5=x%02x ", args->tfRegister[IDE_HCYL_OFFSET]);
+ printk("TF.6=x%02x ", args->tfRegister[IDE_SELECT_OFFSET]);
+ printk("TF.7=x%02x\n", args->tfRegister[IDE_COMMAND_OFFSET]);
+ printk(KERN_INFO "%s: ", drive->name);
+// printk("HTF.0=x%02x ", args->hobRegister[IDE_DATA_OFFSET_HOB]);
+ printk("HTF.1=x%02x ", args->hobRegister[IDE_FEATURE_OFFSET_HOB]);
+ printk("HTF.2=x%02x ", args->hobRegister[IDE_NSECTOR_OFFSET_HOB]);
+ printk("HTF.3=x%02x ", args->hobRegister[IDE_SECTOR_OFFSET_HOB]);
+ printk("HTF.4=x%02x ", args->hobRegister[IDE_LCYL_OFFSET_HOB]);
+ printk("HTF.5=x%02x ", args->hobRegister[IDE_HCYL_OFFSET_HOB]);
+ printk("HTF.6=x%02x ", args->hobRegister[IDE_SELECT_OFFSET_HOB]);
+ printk("HTF.7=x%02x\n", args->hobRegister[IDE_CONTROL_OFFSET_HOB]);
}
+#endif /* CONFIG_IDE_TASK_IOCTL_DEBUG */
-#if 0
-ide_startstop_t flagged_taskfile (ide_drive_t *drive, ide_task_t *task)
+ide_startstop_t do_rw_taskfile (ide_drive_t *drive, ide_task_t *task)
{
- task_struct_t *taskfile = (task_struct_t *) task->tfRegister;
- hob_struct_t *hobfile = (hob_struct_t *) task->hobRegister;
- struct hd_driveid *id = drive->id;
-
- /*
- * (KS) Check taskfile in/out flags.
- * If set, then execute as it is defined.
- * If not set, then define default settings.
- * The default values are:
- * write and read all taskfile registers (except data)
- * write and read the hob registers (sector,nsector,lcyl,hcyl)
- */
- if (task->tf_out_flags.all == 0) {
- task->tf_out_flags.all = IDE_TASKFILE_STD_OUT_FLAGS;
- if ((id->command_set_2 & 0x0400) &&
- (id->cfs_enable_2 & 0x0400) &&
- (drive->addressing == 1)) {
- task->tf_out_flags.all != (IDE_HOB_STD_OUT_FLAGS << 8);
- }
- }
-
- if (task->tf_in_flags.all == 0) {
- task->tf_in_flags.all = IDE_TASKFILE_STD_IN_FLAGS;
- if ((id->command_set_2 & 0x0400) &&
- (id->cfs_enable_2 & 0x0400) &&
- (drive->addressing == 1)) {
- task->tf_in_flags.all != (IDE_HOB_STD_IN_FLAGS << 8);
- }
- }
-
- if (IDE_CONTROL_REG)
- OUT_BYTE(drive->ctl, IDE_CONTROL_REG); /* clear nIEN */
- SELECT_MASK(HWIF(drive), drive, 0);
-
- if (task->tf_out_flags.b.data) {
- unsigned short data = taskfile->data + (hobfile->data << 8);
- OUT_WORD (data, IDE_DATA_REG);
- }
-
- /* (KS) send hob registers first */
- if (task->tf_out_flags.b.nsector_hob)
- OUT_BYTE(hobfile->sector_count, IDE_NSECTOR_REG);
- if (task->tf_out_flags.b.sector_hob)
- OUT_BYTE(hobfile->sector_number, IDE_SECTOR_REG);
- if (task->tf_out_flags.b.lcyl_hob)
- OUT_BYTE(hobfile->low_cylinder, IDE_LCYL_REG);
- if (task->tf_out_flags.b.hcyl_hob)
- OUT_BYTE(hobfile->high_cylinder, IDE_HCYL_REG);
+ ide_hwif_t *hwif = HWIF(drive);
+ task_struct_t *taskfile = (task_struct_t *) task->tfRegister;
+ hob_struct_t *hobfile = (hob_struct_t *) task->hobRegister;
+ u8 HIHI = (drive->addressing == 1) ? 0xE0 : 0xEF;
+#ifdef CONFIG_IDE_TASK_IOCTL_DEBUG
+ void debug_taskfile(drive, task);
+#endif /* CONFIG_IDE_TASK_IOCTL_DEBUG */
- /* (KS) Send now the standard registers */
- if (task->tf_out_flags.b.error_feature)
- OUT_BYTE(taskfile->feature, IDE_FEATURE_REG);
- /* refers to number of sectors to transfer */
- if (task->tf_out_flags.b.nsector)
- OUT_BYTE(taskfile->sector_count, IDE_NSECTOR_REG);
- /* refers to sector offset or start sector */
- if (task->tf_out_flags.b.sector)
- OUT_BYTE(taskfile->sector_number, IDE_SECTOR_REG);
- if (task->tf_out_flags.b.lcyl)
- OUT_BYTE(taskfile->low_cylinder, IDE_LCYL_REG);
- if (task->tf_out_flags.b.hcyl)
- OUT_BYTE(taskfile->high_cylinder, IDE_HCYL_REG);
+ /* 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);
+
+ if (drive->addressing == 1) {
+ hwif->OUTB(hobfile->feature, IDE_FEATURE_REG);
+ hwif->OUTB(hobfile->sector_count, IDE_NSECTOR_REG);
+ hwif->OUTB(hobfile->sector_number, IDE_SECTOR_REG);
+ hwif->OUTB(hobfile->low_cylinder, IDE_LCYL_REG);
+ hwif->OUTB(hobfile->high_cylinder, IDE_HCYL_REG);
+ }
+
+ hwif->OUTB(taskfile->feature, IDE_FEATURE_REG);
+ hwif->OUTB(taskfile->sector_count, IDE_NSECTOR_REG);
+ hwif->OUTB(taskfile->sector_number, IDE_SECTOR_REG);
+ hwif->OUTB(taskfile->low_cylinder, IDE_LCYL_REG);
+ hwif->OUTB(taskfile->high_cylinder, IDE_HCYL_REG);
- /*
- * (KS) Do not modify the specified taskfile. We want to have a
- * universal pass through, so we must execute ALL specified values.
- *
- * (KS) The drive head register is mandatory.
- * Don't care about the out flags !
- */
- OUT_BYTE(taskfile->device_head | drive->select.all, IDE_SELECT_REG);
+ hwif->OUTB((taskfile->device_head & HIHI) | drive->select.all, IDE_SELECT_REG);
if (task->handler != NULL) {
-#if 0
- ide_set_handler (drive, task->handler, WAIT_CMD, NULL);
- OUT_BYTE(taskfile->command, IDE_COMMAND_REG);
- /*
- * warning check for race between handler and prehandler for
- * writing first block of data. however since we are well
- * inside the boundaries of the seek, we should be okay.
- */
- if (task->prehandler != NULL) {
+ ide_execute_command(drive, taskfile->command, task->handler, WAIT_WORSTCASE, NULL);
+ if (task->prehandler != NULL)
return task->prehandler(drive, task->rq);
- }
-#else
- ide_startstop_t startstop;
-
- ide_set_handler (drive, task->handler, WAIT_CMD, NULL);
-
- /*
- * (KS) The drive command register is also mandatory.
- * Don't care about the out flags !
- */
- OUT_BYTE(taskfile->command, IDE_COMMAND_REG);
-
- if (ide_wait_stat(&startstop, drive, DATA_READY, drive->bad_wstat, WAIT_DRQ)) {
- printk(KERN_ERR "%s: no DRQ after issuing %s\n",
- drive->name,
- drive->mult_count ? "MULTWRITE" : "WRITE");
- return startstop;
- }
- /* (ks/hs): Fixed Multi Write */
- if ((taskfile->command != WIN_MULTWRITE) &&
- (taskfile->command != WIN_MULTWRITE_EXT)) {
- struct request *rq = HWGROUP(drive)->rq;
- /* For Write_sectors we need to stuff the first sector */
- taskfile_output_data(drive, rq->buffer, SECTOR_WORDS);
- rq->current_nr_sectors--;
+ return ide_started;
+ }
+ /* for dma commands we down set the handler */
+#if 0
+ if (blk_fs_request(task->rq) && drive->using_dma) {
+ if (rq_data_dir(task->rq) == READ) {
+ if (hwif->ide_dma_read(drive))
+ return ide_stopped;
} else {
- /* Stuff first sector(s) by implicitly calling the handler */
- if (!(drive_is_ready(drive))) {
- /* FIXME: Replace hard-coded 100, error handling? */
- int i;
- for (i=0; i<100; i++) {
- if (drive_is_ready(drive))
- break;
- }
- }
- return task->handler(drive);
+ if (hwif->ide_dma_write(drive))
+ return ide_stopped;
}
-#endif
} else {
- /* for dma commands we down set the handler */
- if (drive->using_dma && !(HWIF(drive)->dmaproc(((taskfile->command == WIN_WRITEDMA) || (taskfile->command == WIN_WRITEDMA_EXT)) ? ide_dma_write : ide_dma_read, drive)));
- }
+ if (!drive->using_dma && (task->handler == NULL))
+ return ide_stopped;
+ switch(taskfile->command) {
+ case WIN_WRITEDMA_ONCE:
+ case WIN_WRITEDMA:
+ case WIN_WRITEDMA_EXT:
+ hwif->ide_dma_write(drive);
+ break;
+ case WIN_READDMA_ONCE:
+ case WIN_READDMA:
+ case WIN_READDMA_EXT:
+ case WIN_IDENTIFY_DMA:
+ hwif->ide_dma_read(drive);
+ break;
+ default:
+ if (task->handler == NULL)
+ return ide_stopped;
+ }
+ }
return ide_started;
-}
+#else
+ switch(taskfile->command) {
+ case WIN_WRITEDMA_ONCE:
+ case WIN_WRITEDMA:
+ case WIN_WRITEDMA_EXT:
+ if (drive->using_dma && !(hwif->ide_dma_write(drive)))
+ return ide_started;
+ case WIN_READDMA_ONCE:
+ case WIN_READDMA:
+ case WIN_READDMA_EXT:
+ case WIN_IDENTIFY_DMA:
+ if (drive->using_dma && !(hwif->ide_dma_read(drive)))
+ return ide_started;
+ default:
+ break;
+ }
+ return ide_stopped;
#endif
+}
+
+EXPORT_SYMBOL(do_rw_taskfile);
-#if 0
/*
* Error reporting, in human readable form (luxurious, but a memory hog).
*/
-byte taskfile_dump_status (ide_drive_t *drive, const char *msg, byte stat)
+u8 taskfile_dump_status (ide_drive_t *drive, const char *msg, u8 stat)
{
+ ide_hwif_t *hwif = HWIF(drive);
unsigned long flags;
- byte err = 0;
+ u8 err = 0;
- __save_flags (flags); /* local CPU only */
- ide__sti(); /* local CPU only */
+ local_irq_set(flags);
printk("%s: %s: status=0x%02x", drive->name, msg, stat);
#if FANCY_STATUS_DUMPS
printk(" { ");
- if (stat & BUSY_STAT)
+ if (stat & BUSY_STAT) {
printk("Busy ");
- else {
+ } else {
if (stat & READY_STAT) printk("DriveReady ");
if (stat & WRERR_STAT) printk("DeviceFault ");
if (stat & SEEK_STAT) printk("SeekComplete ");
@@ -452,61 +288,66 @@
#endif /* FANCY_STATUS_DUMPS */
printk("\n");
if ((stat & (BUSY_STAT|ERR_STAT)) == ERR_STAT) {
- err = GET_ERR();
+ err = hwif->INB(IDE_ERROR_REG);
printk("%s: %s: error=0x%02x", drive->name, msg, err);
#if FANCY_STATUS_DUMPS
- if (drive->media == ide_disk) {
- printk(" { ");
- if (err & ABRT_ERR) printk("DriveStatusError ");
- if (err & ICRC_ERR) printk("%s", (err & ABRT_ERR) ? "BadCRC " : "BadSector ");
- if (err & ECC_ERR) printk("UncorrectableError ");
- if (err & ID_ERR) printk("SectorIdNotFound ");
- if (err & TRK0_ERR) printk("TrackZeroNotFound ");
- if (err & MARK_ERR) printk("AddrMarkNotFound ");
- printk("}");
- if ((err & (BBD_ERR | ABRT_ERR)) == BBD_ERR || (err & (ECC_ERR|ID_ERR|MARK_ERR))) {
- if ((drive->id->command_set_2 & 0x0400) &&
- (drive->id->cfs_enable_2 & 0x0400) &&
- (drive->addressing == 1)) {
- __u64 sectors = 0;
- u32 low = 0, high = 0;
- low = task_read_24(drive);
- OUT_BYTE(0x80, IDE_CONTROL_REG);
- high = task_read_24(drive);
- sectors = ((__u64)high << 24) | low;
- printk(", LBAsect=%lld", sectors);
+ if (drive->media == ide_disk)
+ goto media_out;
+
+ printk(" { ");
+ if (err & ABRT_ERR) printk("DriveStatusError ");
+ if (err & ICRC_ERR) printk("Bad%s", (err & ABRT_ERR) ? "CRC " : "Sector ");
+ if (err & ECC_ERR) printk("UncorrectableError ");
+ if (err & ID_ERR) printk("SectorIdNotFound ");
+ if (err & TRK0_ERR) printk("TrackZeroNotFound ");
+ if (err & MARK_ERR) printk("AddrMarkNotFound ");
+ printk("}");
+ if ((err & (BBD_ERR | ABRT_ERR)) == BBD_ERR ||
+ (err & (ECC_ERR|ID_ERR|MARK_ERR))) {
+ if (drive->addressing == 1) {
+ u64 sectors = 0;
+ u32 high = 0;
+ u32 low = task_read_24(drive);
+ hwif->OUTB(0x80, IDE_CONTROL_REG);
+ high = task_read_24(drive);
+ sectors = ((u64)high << 24) | low;
+ printk(", LBAsect=%lld", sectors);
+ } else {
+ u8 cur = hwif->INB(IDE_SELECT_REG);
+ u8 low = hwif->INB(IDE_LCYL_REG);
+ u8 high = hwif->INB(IDE_HCYL_REG);
+ u8 sect = hwif->INB(IDE_SECTOR_REG);
+ /* using LBA? */
+ if (cur & 0x40) {
+ printk(", LBAsect=%d", (u32)
+ ((cur&0xf)<<24)|(high<<16)|
+ (low<<8)|sect);
} else {
- byte cur = IN_BYTE(IDE_SELECT_REG);
- if (cur & 0x40) { /* using LBA? */
- printk(", LBAsect=%ld", (unsigned long)
- ((cur&0xf)<<24)
- |(IN_BYTE(IDE_HCYL_REG)<<16)
- |(IN_BYTE(IDE_LCYL_REG)<<8)
- | IN_BYTE(IDE_SECTOR_REG));
- } else {
- printk(", CHS=%d/%d/%d",
- (IN_BYTE(IDE_HCYL_REG)<<8) +
- IN_BYTE(IDE_LCYL_REG),
- cur & 0xf,
- IN_BYTE(IDE_SECTOR_REG));
- }
+ printk(", CHS=%d/%d/%d",
+ ((high<<8) + low),
+ (cur & 0xf), sect);
}
- if (HWGROUP(drive)->rq)
- printk(", sector=%llu", (__u64) HWGROUP(drive)->rq->sector);
}
+ if (HWGROUP(drive)->rq)
+ printk(", sector=%lu",
+ HWGROUP(drive)->rq->sector);
}
+media_out:
#endif /* FANCY_STATUS_DUMPS */
printk("\n");
}
- __restore_flags (flags); /* local CPU only */
+ local_irq_restore(flags);
return err;
}
+EXPORT_SYMBOL(taskfile_dump_status);
+
/*
* Clean up after success/failure of an explicit taskfile operation.
*/
-void ide_end_taskfile (ide_drive_t *drive, byte stat, byte err)
+void ide_end_taskfile (ide_drive_t *drive, u8 stat, u8 err)
{
+ ide_hwif_t *hwif = HWIF(drive);
unsigned long flags;
struct request *rq;
ide_task_t *args;
@@ -519,28 +360,39 @@
command = args->tfRegister[IDE_COMMAND_OFFSET];
- rq->errors = !OK_STAT(stat,READY_STAT,BAD_STAT);
+ if (rq->errors == 0)
+ rq->errors = !OK_STAT(stat,READY_STAT,BAD_STAT);
+ if (args->tf_in_flags.b.data) {
+ u16 data = hwif->INW(IDE_DATA_REG);
+ args->tfRegister[IDE_DATA_OFFSET] = (data) & 0xFF;
+ args->hobRegister[IDE_DATA_OFFSET_HOB] = (data >> 8) & 0xFF;
+ }
args->tfRegister[IDE_ERROR_OFFSET] = err;
- args->tfRegister[IDE_NSECTOR_OFFSET] = IN_BYTE(IDE_NSECTOR_REG);
- args->tfRegister[IDE_SECTOR_OFFSET] = IN_BYTE(IDE_SECTOR_REG);
- args->tfRegister[IDE_LCYL_OFFSET] = IN_BYTE(IDE_LCYL_REG);
- args->tfRegister[IDE_HCYL_OFFSET] = IN_BYTE(IDE_HCYL_REG);
- args->tfRegister[IDE_SELECT_OFFSET] = IN_BYTE(IDE_SELECT_REG);
+ args->tfRegister[IDE_NSECTOR_OFFSET] = hwif->INB(IDE_NSECTOR_REG);
+ args->tfRegister[IDE_SECTOR_OFFSET] = hwif->INB(IDE_SECTOR_REG);
+ args->tfRegister[IDE_LCYL_OFFSET] = hwif->INB(IDE_LCYL_REG);
+ args->tfRegister[IDE_HCYL_OFFSET] = hwif->INB(IDE_HCYL_REG);
+ args->tfRegister[IDE_SELECT_OFFSET] = hwif->INB(IDE_SELECT_REG);
args->tfRegister[IDE_STATUS_OFFSET] = stat;
if ((drive->id->command_set_2 & 0x0400) &&
(drive->id->cfs_enable_2 & 0x0400) &&
(drive->addressing == 1)) {
- OUT_BYTE(drive->ctl|0x80, IDE_CONTROL_REG_HOB);
- args->hobRegister[IDE_FEATURE_OFFSET_HOB] = IN_BYTE(IDE_FEATURE_REG);
- args->hobRegister[IDE_NSECTOR_OFFSET_HOB] = IN_BYTE(IDE_NSECTOR_REG);
- args->hobRegister[IDE_SECTOR_OFFSET_HOB] = IN_BYTE(IDE_SECTOR_REG);
- args->hobRegister[IDE_LCYL_OFFSET_HOB] = IN_BYTE(IDE_LCYL_REG);
- args->hobRegister[IDE_HCYL_OFFSET_HOB] = IN_BYTE(IDE_HCYL_REG);
+ hwif->OUTB(drive->ctl|0x80, IDE_CONTROL_REG_HOB);
+ args->hobRegister[IDE_FEATURE_OFFSET_HOB] = hwif->INB(IDE_FEATURE_REG);
+ args->hobRegister[IDE_NSECTOR_OFFSET_HOB] = hwif->INB(IDE_NSECTOR_REG);
+ args->hobRegister[IDE_SECTOR_OFFSET_HOB] = hwif->INB(IDE_SECTOR_REG);
+ args->hobRegister[IDE_LCYL_OFFSET_HOB] = hwif->INB(IDE_LCYL_REG);
+ args->hobRegister[IDE_HCYL_OFFSET_HOB] = hwif->INB(IDE_HCYL_REG);
}
+#if 0
/* taskfile_settings_update(drive, args, command); */
+ if (args->posthandler != NULL)
+ args->posthandler(drive, args);
+#endif
+
spin_lock_irqsave(&io_request_lock, flags);
blkdev_dequeue_request(rq);
HWGROUP(drive)->rq = NULL;
@@ -548,6 +400,8 @@
spin_unlock_irqrestore(&io_request_lock, flags);
}
+EXPORT_SYMBOL(ide_end_taskfile);
+
/*
* try_to_flush_leftover_data() is invoked in response to a drive
* unexpectedly having its DRQ_STAT bit set. As an alternative to
@@ -565,53 +419,68 @@
u32 buffer[16];
unsigned int wcount = (i > 16) ? 16 : i;
i -= wcount;
- taskfile_input_data (drive, buffer, wcount);
+ taskfile_input_data(drive, buffer, wcount);
}
}
+EXPORT_SYMBOL(task_try_to_flush_leftover_data);
+
/*
* taskfile_error() takes action based on the error returned by the drive.
*/
-ide_startstop_t taskfile_error (ide_drive_t *drive, const char *msg, byte stat)
+ide_startstop_t taskfile_error (ide_drive_t *drive, const char *msg, u8 stat)
{
+ ide_hwif_t *hwif;
struct request *rq;
- byte err;
+ u8 err;
err = taskfile_dump_status(drive, msg, stat);
if (drive == NULL || (rq = HWGROUP(drive)->rq) == NULL)
return ide_stopped;
+
+ hwif = HWIF(drive);
/* retry only "normal" I/O: */
if (rq->cmd == IDE_DRIVE_TASKFILE) {
rq->errors = 1;
ide_end_taskfile(drive, stat, err);
return ide_stopped;
}
- if (stat & BUSY_STAT || ((stat & WRERR_STAT) && !drive->nowerr)) { /* other bits are useless when BUSY */
+ if (stat & BUSY_STAT || ((stat & WRERR_STAT) && !drive->nowerr)) {
+ /* other bits are useless when BUSY */
rq->errors |= ERROR_RESET;
} else {
- if (drive->media == ide_disk && (stat & ERR_STAT)) {
+ if (drive->media != ide_disk)
+ goto media_out;
+ if (stat & ERR_STAT) {
/* err has different meaning on cdrom and tape */
if (err == ABRT_ERR) {
- if (drive->select.b.lba && IN_BYTE(IDE_COMMAND_REG) == WIN_SPECIFY)
- return ide_stopped; /* some newer drives don't support WIN_SPECIFY */
- } else if ((err & (ABRT_ERR | ICRC_ERR)) == (ABRT_ERR | ICRC_ERR)) {
- drive->crc_count++; /* UDMA crc error -- just retry the operation */
- } else if (err & (BBD_ERR | ECC_ERR)) /* retries won't help these */
+ if (drive->select.b.lba &&
+ (hwif->INB(IDE_COMMAND_REG) == WIN_SPECIFY))
+ /* some newer drives don't
+ * support WIN_SPECIFY
+ */
+ return ide_stopped;
+ } else if ((err & BAD_CRC) == BAD_CRC) {
+ /* UDMA crc error -- just retry the operation */
+ drive->crc_count++;
+ } else if (err & (BBD_ERR | ECC_ERR)) {
+ /* retries won't help these */
rq->errors = ERROR_MAX;
- else if (err & TRK0_ERR) /* help it find track zero */
- rq->errors |= ERROR_RECAL;
+ } else if (err & TRK0_ERR) {
+ /* help it find track zero */
+ rq->errors |= ERROR_RECAL;
+ }
}
- if ((stat & DRQ_STAT) && rq->cmd != WRITE)
+media_out:
+ if ((stat & DRQ_STAT) && rq_data_dir(rq) != WRITE)
task_try_to_flush_leftover_data(drive);
}
- if (GET_STAT() & (BUSY_STAT|DRQ_STAT))
- OUT_BYTE(WIN_IDLEIMMEDIATE,IDE_COMMAND_REG); /* force an abort */
-
+ if (hwif->INB(IDE_STATUS_REG) & (BUSY_STAT|DRQ_STAT)) {
+ /* force an abort */
+ hwif->OUTB(WIN_IDLEIMMEDIATE, IDE_COMMAND_REG);
+ }
if (rq->errors >= ERROR_MAX) {
- if (drive->driver != NULL)
- DRIVER(drive)->end_request(0, HWGROUP(drive));
- else
- ide_end_request(0, HWGROUP(drive));
+ DRIVER(drive)->end_request(drive, 0);
} else {
if ((rq->errors & ERROR_RESET) == ERROR_RESET) {
++rq->errors;
@@ -623,20 +492,18 @@
}
return ide_stopped;
}
-#endif
-/*
- * Handler for special commands without a data phase from ide-disk
- */
+EXPORT_SYMBOL(taskfile_error);
/*
* set_multmode_intr() is invoked on completion of a WIN_SETMULT cmd.
*/
ide_startstop_t set_multmode_intr (ide_drive_t *drive)
{
- byte stat;
+ ide_hwif_t *hwif = HWIF(drive);
+ u8 stat;
- if (OK_STAT(stat=GET_STAT(),READY_STAT,BAD_STAT)) {
+ if (OK_STAT(stat = hwif->INB(IDE_STATUS_REG),READY_STAT,BAD_STAT)) {
drive->mult_count = drive->mult_req;
} else {
drive->mult_req = drive->mult_count = 0;
@@ -646,282 +513,368 @@
return ide_stopped;
}
+EXPORT_SYMBOL(set_multmode_intr);
+
/*
* set_geometry_intr() is invoked on completion of a WIN_SPECIFY cmd.
*/
ide_startstop_t set_geometry_intr (ide_drive_t *drive)
{
- byte stat;
+ ide_hwif_t *hwif = HWIF(drive);
+ int retries = 5;
+ u8 stat;
+
+ while (((stat = hwif->INB(IDE_STATUS_REG)) & BUSY_STAT) && retries--)
+ udelay(10);
- if (OK_STAT(stat=GET_STAT(),READY_STAT,BAD_STAT))
+ if (OK_STAT(stat, READY_STAT, BAD_STAT))
return ide_stopped;
if (stat & (ERR_STAT|DRQ_STAT))
- return ide_error(drive, "set_geometry_intr", stat);
+ return DRIVER(drive)->error(drive, "set_geometry_intr", stat);
- ide_set_handler(drive, &set_geometry_intr, WAIT_CMD, NULL);
+ if (HWGROUP(drive)->handler != NULL)
+ BUG();
+ ide_set_handler(drive, &set_geometry_intr, WAIT_WORSTCASE, NULL);
return ide_started;
}
+EXPORT_SYMBOL(set_geometry_intr);
+
/*
* recal_intr() is invoked on completion of a WIN_RESTORE (recalibrate) cmd.
*/
ide_startstop_t recal_intr (ide_drive_t *drive)
{
- byte stat = GET_STAT();
+ ide_hwif_t *hwif = HWIF(drive);
+ u8 stat;
- if (!OK_STAT(stat,READY_STAT,BAD_STAT))
- return ide_error(drive, "recal_intr", stat);
+ if (!OK_STAT(stat = hwif->INB(IDE_STATUS_REG), READY_STAT, BAD_STAT))
+ return DRIVER(drive)->error(drive, "recal_intr", stat);
return ide_stopped;
}
+EXPORT_SYMBOL(recal_intr);
+
/*
* Handler for commands without a data phase
*/
ide_startstop_t task_no_data_intr (ide_drive_t *drive)
{
ide_task_t *args = HWGROUP(drive)->rq->special;
- byte stat = GET_STAT();
-
- ide__sti(); /* local CPU only */
-
- if (!OK_STAT(stat, READY_STAT, BAD_STAT))
- return ide_error(drive, "task_no_data_intr", stat); /* calls ide_end_drive_cmd */
+ ide_hwif_t *hwif = HWIF(drive);
+ u8 stat;
+ local_irq_enable();
+ if (!OK_STAT(stat = hwif->INB(IDE_STATUS_REG),READY_STAT,BAD_STAT)) {
+ DTF("%s: command opcode 0x%02x\n", drive->name,
+ args->tfRegister[IDE_COMMAND_OFFSET]);
+ return DRIVER(drive)->error(drive, "task_no_data_intr", stat);
+ /* calls ide_end_drive_cmd */
+ }
if (args)
- ide_end_drive_cmd (drive, stat, GET_ERR());
+ ide_end_drive_cmd(drive, stat, hwif->INB(IDE_ERROR_REG));
return ide_stopped;
}
+EXPORT_SYMBOL(task_no_data_intr);
+
/*
- * Handler for command with PIO data-in phase
+ * Handler for command with PIO data-in phase, READ
+ */
+/*
+ * FIXME before 2.4 enable ...
+ * DATA integrity issue upon error. <andre@linux-ide.org>
*/
ide_startstop_t task_in_intr (ide_drive_t *drive)
{
- byte stat = GET_STAT();
- byte io_32bit = drive->io_32bit;
struct request *rq = HWGROUP(drive)->rq;
+ ide_hwif_t *hwif = HWIF(drive);
char *pBuf = NULL;
+ u8 stat;
+ unsigned long flags;
- if (!OK_STAT(stat,DATA_READY,BAD_R_STAT)) {
+ if (!OK_STAT(stat = hwif->INB(IDE_STATUS_REG),DATA_READY,BAD_R_STAT)) {
if (stat & (ERR_STAT|DRQ_STAT)) {
- return ide_error(drive, "task_in_intr", stat);
+#if 0
+ DTF("%s: attempting to recover last " \
+ "sector counter status=0x%02x\n",
+ drive->name, stat);
+ /*
+ * Expect a BUG BOMB if we attempt to rewind the
+ * offset in the BH aka PAGE in the current BLOCK
+ * segment. This is different than the HOST segment.
+ */
+#endif
+ if (!rq->bh)
+ rq->current_nr_sectors++;
+ return DRIVER(drive)->error(drive, "task_in_intr", stat);
}
if (!(stat & BUSY_STAT)) {
DTF("task_in_intr to Soon wait for next interrupt\n");
- ide_set_handler(drive, &task_in_intr, WAIT_CMD, NULL);
+ if (HWGROUP(drive)->handler == NULL)
+ ide_set_handler(drive, &task_in_intr, WAIT_WORSTCASE, NULL);
return ide_started;
}
}
- DTF("stat: %02x\n", stat);
- pBuf = rq->buffer + ((rq->nr_sectors - rq->current_nr_sectors) * SECTOR_SIZE);
- DTF("Read: %p, rq->current_nr_sectors: %d\n", pBuf, (int) rq->current_nr_sectors);
-
- drive->io_32bit = 0;
- taskfile_input_data(drive, pBuf, SECTOR_WORDS);
- drive->io_32bit = io_32bit;
-
- if (--rq->current_nr_sectors <= 0) {
- /* (hs): swapped next 2 lines */
- DTF("Request Ended stat: %02x\n", GET_STAT());
- ide_end_request(1, HWGROUP(drive));
- } else {
- ide_set_handler(drive, &task_in_intr, WAIT_CMD, NULL);
- return ide_started;
- }
- return ide_stopped;
-}
+#if 0
-#undef ALTSTAT_SCREW_UP
+ /*
+ * Holding point for a brain dump of a thought :-/
+ */
-#ifdef ALTSTAT_SCREW_UP
-/*
- * (ks/hs): Poll Alternate Status Register to ensure
- * that drive is not busy.
- */
-byte altstat_multi_busy (ide_drive_t *drive, byte stat, const char *msg)
-{
- int i;
+ if (!OK_STAT(stat,DRIVE_READY,drive->bad_wstat)) {
+ DTF("%s: READ attempting to recover last " \
+ "sector counter status=0x%02x\n",
+ drive->name, stat);
+ rq->current_nr_sectors++;
+ return DRIVER(drive)->error(drive, "task_in_intr", stat);
+ }
+ if (!rq->current_nr_sectors)
+ if (!DRIVER(drive)->end_request(drive, 1))
+ return ide_stopped;
+
+ if (--rq->current_nr_sectors <= 0)
+ if (!DRIVER(drive)->end_request(drive, 1))
+ return ide_stopped;
+#endif
- DTF("multi%s: ASR = %x\n", msg, stat);
- if (stat & BUSY_STAT) {
- /* (ks/hs): FIXME: Replace hard-coded 100, error handling? */
- for (i=0; i<100; i++) {
- stat = GET_ALTSTAT();
- if ((stat & BUSY_STAT) == 0)
- break;
- }
- }
+ pBuf = task_map_rq(rq, &flags);
+ DTF("Read: %p, rq->current_nr_sectors: %d, stat: %02x\n",
+ pBuf, (int) rq->current_nr_sectors, stat);
+ taskfile_input_data(drive, pBuf, SECTOR_WORDS);
+ task_unmap_rq(rq, pBuf, &flags);
+ /*
+ * FIXME :: We really can not legally get a new page/bh
+ * regardless, if this is the end of our segment.
+ * BH walking or segment can only be updated after we have a good
+ * hwif->INB(IDE_STATUS_REG); return.
+ */
+ if (--rq->current_nr_sectors <= 0)
+ if (!DRIVER(drive)->end_request(drive, 1))
+ return ide_stopped;
/*
- * (ks/hs): Read Status AFTER Alternate Status Register
+ * ERM, it is techincally legal to leave/exit here but it makes
+ * a mess of the code ...
*/
- return(GET_STAT());
+ if (HWGROUP(drive)->handler == NULL)
+ ide_set_handler(drive, &task_in_intr, WAIT_WORSTCASE, NULL);
+ return ide_started;
}
-/*
- * (ks/hs): Poll Alternate status register to wait for drive
- * to become ready for next transfer
- */
-byte altstat_multi_poll (ide_drive_t *drive, byte stat, const char *msg)
-{
- /* (ks/hs): FIXME: Error handling, time-out? */
- while (stat & BUSY_STAT)
- stat = GET_ALTSTAT();
- DTF("multi%s: nsect=1, ASR = %x\n", msg, stat);
- return(GET_STAT()); /* (ks/hs): Clear pending IRQ */
-}
-#endif /* ALTSTAT_SCREW_UP */
+EXPORT_SYMBOL(task_in_intr);
/*
* Handler for command with Read Multiple
*/
ide_startstop_t task_mulin_intr (ide_drive_t *drive)
{
- unsigned int msect, nsect;
-
-#ifdef ALTSTAT_SCREW_UP
- byte stat = altstat_multi_busy(drive, GET_ALTSTAT(), "read");
-#else
- byte stat = GET_STAT();
-#endif /* ALTSTAT_SCREW_UP */
-
- byte io_32bit = drive->io_32bit;
+ ide_hwif_t *hwif = HWIF(drive);
struct request *rq = HWGROUP(drive)->rq;
char *pBuf = NULL;
+ unsigned int msect = drive->mult_count;
+ unsigned int nsect;
+ unsigned long flags;
+ u8 stat;
- if (!OK_STAT(stat,DATA_READY,BAD_R_STAT)) {
+ if (!OK_STAT(stat = hwif->INB(IDE_STATUS_REG),DATA_READY,BAD_R_STAT)) {
if (stat & (ERR_STAT|DRQ_STAT)) {
- return ide_error(drive, "task_mulin_intr", stat);
+ if (!rq->bh) {
+ rq->current_nr_sectors += drive->mult_count;
+ /*
+ * NOTE: could rewind beyond beginning :-/
+ */
+ } else {
+ printk("%s: MULTI-READ assume all data " \
+ "transfered is bad status=0x%02x\n",
+ drive->name, stat);
+ }
+ return DRIVER(drive)->error(drive, "task_mulin_intr", stat);
}
/* no data yet, so wait for another interrupt */
- ide_set_handler(drive, &task_mulin_intr, WAIT_CMD, NULL);
+ if (HWGROUP(drive)->handler == NULL)
+ ide_set_handler(drive, &task_mulin_intr, WAIT_WORSTCASE, NULL);
return ide_started;
}
- /* (ks/hs): Fixed Multi-Sector transfer */
- msect = drive->mult_count;
-
-#ifdef ALTSTAT_SCREW_UP
- /*
- * Screw the request we do not support bad data-phase setups!
- * Either read and learn the ATA standard or crash yourself!
- */
- if (!msect) {
+ do {
+ nsect = rq->current_nr_sectors;
+ if (nsect > msect)
+ nsect = msect;
+ pBuf = task_map_rq(rq, &flags);
+ DTF("Multiread: %p, nsect: %d, msect: %d, " \
+ " rq->current_nr_sectors: %d\n",
+ pBuf, nsect, msect, rq->current_nr_sectors);
+ taskfile_input_data(drive, pBuf, nsect * SECTOR_WORDS);
+ task_unmap_rq(rq, pBuf, &flags);
+ rq->errors = 0;
+ rq->current_nr_sectors -= nsect;
+ msect -= nsect;
/*
- * (ks/hs): Drive supports multi-sector transfer,
- * drive->mult_count was not set
+ * FIXME :: We really can not legally get a new page/bh
+ * regardless, if this is the end of our segment.
+ * BH walking or segment can only be updated after we have a
+ * good hwif->INB(IDE_STATUS_REG); return.
*/
- nsect = 1;
- while (rq->current_nr_sectors) {
- pBuf = rq->buffer + ((rq->nr_sectors - rq->current_nr_sectors) * SECTOR_SIZE);
- DTF("Multiread: %p, nsect: %d, rq->current_nr_sectors: %ld\n", pBuf, nsect, rq->current_nr_sectors);
- drive->io_32bit = 0;
- taskfile_input_data(drive, pBuf, nsect * SECTOR_WORDS);
- drive->io_32bit = io_32bit;
- rq->errors = 0;
- rq->current_nr_sectors -= nsect;
- stat = altstat_multi_poll(drive, GET_ALTSTAT(), "read");
- }
- ide_end_request(1, HWGROUP(drive));
- return ide_stopped;
- }
-#endif /* ALTSTAT_SCREW_UP */
+ if (!rq->current_nr_sectors) {
+ if (!DRIVER(drive)->end_request(drive, 1))
+ return ide_stopped;
+ }
+ } while (msect);
+ if (HWGROUP(drive)->handler == NULL)
+ ide_set_handler(drive, &task_mulin_intr, WAIT_WORSTCASE, NULL);
+ return ide_started;
+}
- nsect = (rq->current_nr_sectors > msect) ? msect : rq->current_nr_sectors;
- pBuf = rq->buffer + ((rq->nr_sectors - rq->current_nr_sectors) * SECTOR_SIZE);
-
- DTF("Multiread: %p, nsect: %d , rq->current_nr_sectors: %ld\n",
- pBuf, nsect, rq->current_nr_sectors);
- drive->io_32bit = 0;
- taskfile_input_data(drive, pBuf, nsect * SECTOR_WORDS);
- drive->io_32bit = io_32bit;
- rq->errors = 0;
- rq->current_nr_sectors -= nsect;
- if (rq->current_nr_sectors != 0) {
- ide_set_handler(drive, &task_mulin_intr, WAIT_CMD, NULL);
- return ide_started;
- }
- ide_end_request(1, HWGROUP(drive));
- return ide_stopped;
-}
+EXPORT_SYMBOL(task_mulin_intr);
+/*
+ * VERIFY ME before 2.4 ... unexpected race is possible based on details
+ * RMK with 74LS245/373/374 TTL buffer logic because of passthrough.
+ */
ide_startstop_t pre_task_out_intr (ide_drive_t *drive, struct request *rq)
{
- ide_task_t *args = rq->special;
+ char *pBuf = NULL;
+ unsigned long flags;
ide_startstop_t startstop;
- if (ide_wait_stat(&startstop, drive, DATA_READY, drive->bad_wstat, WAIT_DRQ)) {
- printk(KERN_ERR "%s: no DRQ after issuing %s\n", drive->name, drive->mult_count ? "MULTWRITE" : "WRITE");
+ if (ide_wait_stat(&startstop, drive, DATA_READY,
+ drive->bad_wstat, WAIT_DRQ)) {
+ printk(KERN_ERR "%s: no DRQ after issuing WRITE%s\n",
+ drive->name,
+ drive->addressing ? "_EXT" : "");
return startstop;
}
-
- /* (ks/hs): Fixed Multi Write */
- if ((args->tfRegister[IDE_COMMAND_OFFSET] != WIN_MULTWRITE) &&
- (args->tfRegister[IDE_COMMAND_OFFSET] != WIN_MULTWRITE_EXT)) {
- /* For Write_sectors we need to stuff the first sector */
- taskfile_output_data(drive, rq->buffer, SECTOR_WORDS);
- rq->current_nr_sectors--;
- return ide_started;
- } else {
- /*
- * (ks/hs): Stuff the first sector(s)
- * by implicitly calling the handler
- */
- if (!(drive_is_ready(drive))) {
- int i;
- /*
- * (ks/hs): FIXME: Replace hard-coded
- * 100, error handling?
- */
- for (i=0; i<100; i++) {
- if (drive_is_ready(drive))
- break;
- }
- }
- return args->handler(drive);
- }
+ /* For Write_sectors we need to stuff the first sector */
+ pBuf = task_map_rq(rq, &flags);
+ taskfile_output_data(drive, pBuf, SECTOR_WORDS);
+ rq->current_nr_sectors--;
+ task_unmap_rq(rq, pBuf, &flags);
return ide_started;
}
+EXPORT_SYMBOL(pre_task_out_intr);
+
/*
- * Handler for command with PIO data-out phase
+ * Handler for command with PIO data-out phase WRITE
+ *
+ * WOOHOO this is a CORRECT STATE DIAGRAM NOW, <andre@linux-ide.org>
*/
ide_startstop_t task_out_intr (ide_drive_t *drive)
{
- byte stat = GET_STAT();
- byte io_32bit = drive->io_32bit;
+ ide_hwif_t *hwif = HWIF(drive);
struct request *rq = HWGROUP(drive)->rq;
char *pBuf = NULL;
+ unsigned long flags;
+ u8 stat;
- if (!rq->current_nr_sectors) {
- ide_end_request(1, HWGROUP(drive));
- return ide_stopped;
- }
-
- if (!OK_STAT(stat,DRIVE_READY,drive->bad_wstat)) {
- return ide_error(drive, "task_out_intr", stat);
+ if (!OK_STAT(stat = hwif->INB(IDE_STATUS_REG), DRIVE_READY, drive->bad_wstat)) {
+ DTF("%s: WRITE attempting to recover last " \
+ "sector counter status=0x%02x\n",
+ drive->name, stat);
+ rq->current_nr_sectors++;
+ return DRIVER(drive)->error(drive, "task_out_intr", stat);
}
+ /*
+ * Safe to update request for partial completions.
+ * We have a good STATUS CHECK!!!
+ */
+ if (!rq->current_nr_sectors)
+ if (!DRIVER(drive)->end_request(drive, 1))
+ return ide_stopped;
if ((rq->current_nr_sectors==1) ^ (stat & DRQ_STAT)) {
rq = HWGROUP(drive)->rq;
- pBuf = rq->buffer + ((rq->nr_sectors - rq->current_nr_sectors) * SECTOR_SIZE);
- DTF("write: %p, rq->current_nr_sectors: %d\n", pBuf, (int) rq->current_nr_sectors);
- drive->io_32bit = 0;
+ pBuf = task_map_rq(rq, &flags);
+ DTF("write: %p, rq->current_nr_sectors: %d\n",
+ pBuf, (int) rq->current_nr_sectors);
taskfile_output_data(drive, pBuf, SECTOR_WORDS);
- drive->io_32bit = io_32bit;
+ task_unmap_rq(rq, pBuf, &flags);
rq->errors = 0;
rq->current_nr_sectors--;
}
+ if (HWGROUP(drive)->handler == NULL)
+ ide_set_handler(drive, &task_out_intr, WAIT_WORSTCASE, NULL);
+ return ide_started;
+}
- if (rq->current_nr_sectors <= 0) {
- ide_end_request(1, HWGROUP(drive));
- } else {
- ide_set_handler(drive, &task_out_intr, WAIT_CMD, NULL);
- return ide_started;
+EXPORT_SYMBOL(task_out_intr);
+
+#undef ALTERNATE_STATE_DIAGRAM_MULTI_OUT
+
+ide_startstop_t pre_task_mulout_intr (ide_drive_t *drive, struct request *rq)
+{
+#ifdef ALTERNATE_STATE_DIAGRAM_MULTI_OUT
+ ide_hwif_t *hwif = HWIF(drive);
+ char *pBuf = NULL;
+ unsigned int nsect = 0, msect = drive->mult_count;
+ u8 stat;
+ unsigned long flags;
+#endif /* ALTERNATE_STATE_DIAGRAM_MULTI_OUT */
+
+ ide_task_t *args = rq->special;
+ ide_startstop_t startstop;
+
+#if 0
+ /*
+ * assign private copy for multi-write
+ */
+ memcpy(&HWGROUP(drive)->wrq, rq, sizeof(struct request));
+#endif
+
+ if (ide_wait_stat(&startstop, drive, DATA_READY,
+ drive->bad_wstat, WAIT_DRQ)) {
+ printk(KERN_ERR "%s: no DRQ after issuing %s\n",
+ drive->name,
+ drive->addressing ? "MULTWRITE_EXT" : "MULTWRITE");
+ return startstop;
}
- return ide_stopped;
+#ifdef ALTERNATE_STATE_DIAGRAM_MULTI_OUT
+
+ do {
+ nsect = rq->current_nr_sectors;
+ if (nsect > msect)
+ nsect = msect;
+ pBuf = task_map_rq(rq, &flags);
+ DTF("Pre-Multiwrite: %p, nsect: %d, msect: %d, " \
+ "rq->current_nr_sectors: %ld\n",
+ pBuf, nsect, msect, rq->current_nr_sectors);
+ msect -= nsect;
+ taskfile_output_data(drive, pBuf, nsect * SECTOR_WORDS);
+ task_unmap_rq(rq, pBuf, &flags);
+ rq->current_nr_sectors -= nsect;
+ if (!rq->current_nr_sectors) {
+ if (!DRIVER(drive)->end_request(drive, 1))
+ if (!rq->bh) {
+ stat = hwif->INB(IDE_STATUS_REG);
+ return ide_stopped;
+ }
+ }
+ } while (msect);
+ rq->errors = 0;
+ return ide_started;
+#else /* ! ALTERNATE_STATE_DIAGRAM_MULTI_OUT */
+ if (!(drive_is_ready(drive))) {
+ int i;
+ for (i=0; i<100; i++) {
+ if (drive_is_ready(drive))
+ break;
+ }
+ }
+
+ /*
+ * WARNING :: if the drive as not acked good status we may not
+ * move the DATA-TRANSFER T-Bar as BSY != 0. <andre@linux-ide.org>
+ */
+ return args->handler(drive);
+#endif /* ALTERNATE_STATE_DIAGRAM_MULTI_OUT */
}
+EXPORT_SYMBOL(pre_task_mulout_intr);
+
+/*
+ * FIXME before enabling in 2.4 ... DATA integrity issue upon error.
+ */
/*
* Handler for command write multiple
* Called directly from execute_drive_cmd for the first bunch of sectors,
@@ -929,93 +882,119 @@
*/
ide_startstop_t task_mulout_intr (ide_drive_t *drive)
{
- unsigned int msect, nsect;
-
-#ifdef ALTSTAT_SCREW_UP
- byte stat = altstat_multi_busy(drive, GET_ALTSTAT(), "write");
-#else
- byte stat = GET_STAT();
-#endif /* ALTSTAT_SCREW_UP */
-
- byte io_32bit = drive->io_32bit;
- struct request *rq = HWGROUP(drive)->rq;
- ide_hwgroup_t *hwgroup = HWGROUP(drive);
- char *pBuf = NULL;
+ ide_hwif_t *hwif = HWIF(drive);
+ u8 stat = hwif->INB(IDE_STATUS_REG);
+ struct request *rq = HWGROUP(drive)->rq;
+ char *pBuf = NULL;
+ ide_startstop_t startstop = ide_stopped;
+ unsigned int msect = drive->mult_count;
+ unsigned int nsect;
+ unsigned long flags;
/*
* (ks/hs): Handle last IRQ on multi-sector transfer,
- * occurs after all data was sent
+ * occurs after all data was sent in this chunk
*/
if (rq->current_nr_sectors == 0) {
- if (stat & (ERR_STAT|DRQ_STAT))
- return ide_error(drive, "task_mulout_intr", stat);
- ide_end_request(1, HWGROUP(drive));
- return ide_stopped;
+ if (stat & (ERR_STAT|DRQ_STAT)) {
+ if (!rq->bh) {
+ rq->current_nr_sectors += drive->mult_count;
+ /*
+ * NOTE: could rewind beyond beginning :-/
+ */
+ } else {
+ printk(KERN_ERR "%s: MULTI-WRITE assume all data " \
+ "transfered is bad status=0x%02x\n",
+ drive->name, stat);
+ }
+ return DRIVER(drive)->error(drive, "task_mulout_intr", stat);
+ }
+ if (!rq->bh)
+ DRIVER(drive)->end_request(drive, 1);
+ return startstop;
}
-
+ /*
+ * DON'T be lazy code the above and below togather !!!
+ */
if (!OK_STAT(stat,DATA_READY,BAD_R_STAT)) {
if (stat & (ERR_STAT|DRQ_STAT)) {
- return ide_error(drive, "task_mulout_intr", stat);
+ if (!rq->bh) {
+ rq->current_nr_sectors += drive->mult_count;
+ /*
+ * NOTE: could rewind beyond beginning :-/
+ */
+ } else {
+ printk(KERN_ERR "%s: MULTI-WRITE assume all data " \
+ "transfered is bad status=0x%02x\n",
+ drive->name, stat);
+ }
+ return DRIVER(drive)->error(drive, "task_mulout_intr", stat);
}
/* no data yet, so wait for another interrupt */
- if (hwgroup->handler == NULL)
- ide_set_handler(drive, &task_mulout_intr, WAIT_CMD, NULL);
+ if (HWGROUP(drive)->handler == NULL)
+ ide_set_handler(drive, &task_mulout_intr, WAIT_WORSTCASE, NULL);
return ide_started;
}
- /* (ks/hs): See task_mulin_intr */
- msect = drive->mult_count;
-
-#ifdef ALTSTAT_SCREW_UP
- /*
- * Screw the request we do not support bad data-phase setups!
- * Either read and learn the ATA standard or crash yourself!
- */
- if (!msect) {
- nsect = 1;
- while (rq->current_nr_sectors) {
- pBuf = rq->buffer + ((rq->nr_sectors - rq->current_nr_sectors) * SECTOR_SIZE);
- DTF("Multiwrite: %p, nsect: %d, rq->current_nr_sectors: %ld\n", pBuf, nsect, rq->current_nr_sectors);
- drive->io_32bit = 0;
- taskfile_output_data(drive, pBuf, nsect * SECTOR_WORDS);
- drive->io_32bit = io_32bit;
- rq->errors = 0;
- rq->current_nr_sectors -= nsect;
- stat = altstat_multi_poll(drive, GET_ALTSTAT(), "write");
+#ifndef ALTERNATE_STATE_DIAGRAM_MULTI_OUT
+ if (HWGROUP(drive)->handler != NULL) {
+ unsigned long lflags;
+ spin_lock_irqsave(&io_request_lock, lflags);
+ HWGROUP(drive)->handler = NULL;
+ del_timer(&HWGROUP(drive)->timer);
+ spin_unlock_irqrestore(&io_request_lock, lflags);
+ }
+#endif /* ALTERNATE_STATE_DIAGRAM_MULTI_OUT */
+
+ do {
+ nsect = rq->current_nr_sectors;
+ if (nsect > msect)
+ nsect = msect;
+ pBuf = task_map_rq(rq, &flags);
+ DTF("Multiwrite: %p, nsect: %d, msect: %d, " \
+ "rq->current_nr_sectors: %ld\n",
+ pBuf, nsect, msect, rq->current_nr_sectors);
+ msect -= nsect;
+ taskfile_output_data(drive, pBuf, nsect * SECTOR_WORDS);
+ task_unmap_rq(rq, pBuf, &flags);
+ rq->current_nr_sectors -= nsect;
+ /*
+ * FIXME :: We really can not legally get a new page/bh
+ * regardless, if this is the end of our segment.
+ * BH walking or segment can only be updated after we
+ * have a good hwif->INB(IDE_STATUS_REG); return.
+ */
+ if (!rq->current_nr_sectors) {
+ if (!DRIVER(drive)->end_request(drive, 1))
+ if (!rq->bh)
+ return ide_stopped;
}
- ide_end_request(1, HWGROUP(drive));
- return ide_stopped;
- }
-#endif /* ALTSTAT_SCREW_UP */
-
- nsect = (rq->current_nr_sectors > msect) ? msect : rq->current_nr_sectors;
- pBuf = rq->buffer + ((rq->nr_sectors - rq->current_nr_sectors) * SECTOR_SIZE);
- DTF("Multiwrite: %p, nsect: %d , rq->current_nr_sectors: %ld\n",
- pBuf, nsect, rq->current_nr_sectors);
- drive->io_32bit = 0;
- taskfile_output_data(drive, pBuf, nsect * SECTOR_WORDS);
- drive->io_32bit = io_32bit;
+ } while (msect);
rq->errors = 0;
- rq->current_nr_sectors -= nsect;
- if (hwgroup->handler == NULL)
- ide_set_handler(drive, &task_mulout_intr, WAIT_CMD, NULL);
+ if (HWGROUP(drive)->handler == NULL)
+ ide_set_handler(drive, &task_mulout_intr, WAIT_WORSTCASE, NULL);
return ide_started;
}
+EXPORT_SYMBOL(task_mulout_intr);
+
/* Called by internal to feature out type of command being called */
+//ide_pre_handler_t * ide_pre_handler_parser (task_struct_t *taskfile, hob_struct_t *hobfile)
ide_pre_handler_t * ide_pre_handler_parser (struct hd_drive_task_hdr *taskfile, struct hd_drive_hob_hdr *hobfile)
{
switch(taskfile->command) {
/* IDE_DRIVE_TASK_RAW_WRITE */
case CFA_WRITE_MULTI_WO_ERASE:
+ // case WIN_WRITE_LONG:
+ // case WIN_WRITE_LONG_ONCE:
case WIN_MULTWRITE:
case WIN_MULTWRITE_EXT:
-// case WIN_WRITEDMA:
-// case WIN_WRITEDMA_QUEUED:
-// case WIN_WRITEDMA_EXT:
-// case WIN_WRITEDMA_QUEUED_EXT:
+ return &pre_task_mulout_intr;
+
/* IDE_DRIVE_TASK_OUT */
case WIN_WRITE:
+ // case WIN_WRITE_ONCE:
+ case WIN_WRITE_EXT:
case WIN_WRITE_VERIFY:
case WIN_WRITE_BUFFER:
case CFA_WRITE_SECT_WO_ERASE:
@@ -1025,13 +1004,22 @@
case WIN_SMART:
if (taskfile->feature == SMART_WRITE_LOG_SECTOR)
return &pre_task_out_intr;
+ case WIN_WRITEDMA:
+ // case WIN_WRITEDMA_ONCE:
+ case WIN_WRITEDMA_QUEUED:
+ case WIN_WRITEDMA_EXT:
+ case WIN_WRITEDMA_QUEUED_EXT:
+ /* IDE_DRIVE_TASK_OUT */
default:
break;
}
return(NULL);
}
+EXPORT_SYMBOL(ide_pre_handler_parser);
+
/* Called by internal to feature out type of command being called */
+//ide_handler_t * ide_handler_parser (task_struct_t *taskfile, hob_struct_t *hobfile)
ide_handler_t * ide_handler_parser (struct hd_drive_task_hdr *taskfile, struct hd_drive_hob_hdr *hobfile)
{
switch(taskfile->command) {
@@ -1040,6 +1028,7 @@
case CFA_TRANSLATE_SECTOR:
case WIN_READ_BUFFER:
case WIN_READ:
+ // case WIN_READ_ONCE:
case WIN_READ_EXT:
return &task_in_intr;
case WIN_SECURITY_DISABLE:
@@ -1051,11 +1040,16 @@
case WIN_WRITE_BUFFER:
case WIN_WRITE_VERIFY:
case WIN_WRITE:
+ // case WIN_WRITE_ONCE:
case WIN_WRITE_EXT:
return &task_out_intr;
+ // case WIN_READ_LONG:
+ // case WIN_READ_LONG_ONCE:
case WIN_MULTREAD:
case WIN_MULTREAD_EXT:
return &task_mulin_intr;
+ // case WIN_WRITE_LONG:
+ // case WIN_WRITE_LONG_ONCE:
case CFA_WRITE_MULTI_WO_ERASE:
case WIN_MULTWRITE:
case WIN_MULTWRITE_EXT:
@@ -1074,13 +1068,16 @@
case CFA_REQ_EXT_ERROR_CODE:
case CFA_ERASE_SECTORS:
case WIN_VERIFY:
+ // case WIN_VERIFY_ONCE:
case WIN_VERIFY_EXT:
case WIN_SEEK:
return &task_no_data_intr;
case WIN_SPECIFY:
return &set_geometry_intr;
- case WIN_RESTORE:
+ case WIN_RECAL:
+ // case WIN_RESTORE:
return &recal_intr;
+ case WIN_NOP:
case WIN_DIAGNOSE:
case WIN_FLUSH_CACHE:
case WIN_FLUSH_CACHE_EXT:
@@ -1111,11 +1108,13 @@
return &task_no_data_intr;
#ifdef CONFIG_BLK_DEV_IDEDMA
case WIN_READDMA:
+ // case WIN_READDMA_ONCE:
case WIN_IDENTIFY_DMA:
case WIN_READDMA_QUEUED:
case WIN_READDMA_EXT:
case WIN_READDMA_QUEUED_EXT:
case WIN_WRITEDMA:
+ // case WIN_WRITEDMA_ONCE:
case WIN_WRITEDMA_QUEUED:
case WIN_WRITEDMA_EXT:
case WIN_WRITEDMA_QUEUED_EXT:
@@ -1130,14 +1129,31 @@
}
}
+EXPORT_SYMBOL(ide_handler_parser);
+
+ide_post_handler_t * ide_post_handler_parser (struct hd_drive_task_hdr *taskfile, struct hd_drive_hob_hdr *hobfile)
+{
+ switch(taskfile->command) {
+ case WIN_SPECIFY: /* set_geometry_intr */
+ case WIN_RESTORE: /* recal_intr */
+ case WIN_SETMULT: /* set_multmode_intr */
+ default:
+ return(NULL);
+ }
+}
+
+EXPORT_SYMBOL(ide_post_handler_parser);
+
/* Called by ioctl to feature out type of command being called */
int ide_cmd_type_parser (ide_task_t *args)
{
- struct hd_drive_task_hdr *taskfile = (struct hd_drive_task_hdr *) args->tfRegister;
- struct hd_drive_hob_hdr *hobfile = (struct hd_drive_hob_hdr *) args->hobRegister;
- args->prehandler = ide_pre_handler_parser(taskfile, hobfile);
- args->handler = ide_handler_parser(taskfile, hobfile);
+ task_struct_t *taskfile = (task_struct_t *) args->tfRegister;
+ hob_struct_t *hobfile = (hob_struct_t *) args->hobRegister;
+
+ args->prehandler = ide_pre_handler_parser(taskfile, hobfile);
+ args->handler = ide_handler_parser(taskfile, hobfile);
+ args->posthandler = ide_post_handler_parser(taskfile, hobfile);
switch(args->tfRegister[IDE_COMMAND_OFFSET]) {
case WIN_IDENTIFY:
@@ -1145,18 +1161,28 @@
return IDE_DRIVE_TASK_IN;
case CFA_TRANSLATE_SECTOR:
case WIN_READ:
+ // case WIN_READ_ONCE:
+ case WIN_READ_EXT:
case WIN_READ_BUFFER:
return IDE_DRIVE_TASK_IN;
case WIN_WRITE:
+ // case WIN_WRITE_ONCE:
+ case WIN_WRITE_EXT:
case WIN_WRITE_VERIFY:
case WIN_WRITE_BUFFER:
case CFA_WRITE_SECT_WO_ERASE:
case WIN_DOWNLOAD_MICROCODE:
return IDE_DRIVE_TASK_RAW_WRITE;
+ // case WIN_READ_LONG:
+ // case WIN_READ_LONG_ONCE:
case WIN_MULTREAD:
+ case WIN_MULTREAD_EXT:
return IDE_DRIVE_TASK_IN;
+ // case WIN_WRITE_LONG:
+ // case WIN_WRITE_LONG_ONCE:
case CFA_WRITE_MULTI_WO_ERASE:
case WIN_MULTWRITE:
+ case WIN_MULTWRITE_EXT:
return IDE_DRIVE_TASK_RAW_WRITE;
case WIN_SECURITY_DISABLE:
case WIN_SECURITY_ERASE_UNIT:
@@ -1178,12 +1204,14 @@
}
#ifdef CONFIG_BLK_DEV_IDEDMA
case WIN_READDMA:
+ // case WIN_READDMA_ONCE:
case WIN_IDENTIFY_DMA:
case WIN_READDMA_QUEUED:
case WIN_READDMA_EXT:
case WIN_READDMA_QUEUED_EXT:
return IDE_DRIVE_TASK_IN;
case WIN_WRITEDMA:
+ // case WIN_WRITEDMA_ONCE:
case WIN_WRITEDMA_QUEUED:
case WIN_WRITEDMA_EXT:
case WIN_WRITEDMA_QUEUED_EXT:
@@ -1191,20 +1219,32 @@
#endif
case WIN_SETFEATURES:
switch(args->tfRegister[IDE_FEATURE_OFFSET]) {
+ case SETFEATURES_EN_8BIT:
+ case SETFEATURES_EN_WCACHE:
+ return IDE_DRIVE_TASK_NO_DATA;
case SETFEATURES_XFER:
return IDE_DRIVE_TASK_SET_XFER;
case SETFEATURES_DIS_DEFECT:
case SETFEATURES_EN_APM:
case SETFEATURES_DIS_MSN:
+ case SETFEATURES_DIS_RETRY:
+ case SETFEATURES_EN_AAM:
+ case SETFEATURES_RW_LONG:
+ case SETFEATURES_SET_CACHE:
+ case SETFEATURES_DIS_RLA:
case SETFEATURES_EN_RI:
case SETFEATURES_EN_SI:
case SETFEATURES_DIS_RPOD:
case SETFEATURES_DIS_WCACHE:
case SETFEATURES_EN_DEFECT:
case SETFEATURES_DIS_APM:
+ case SETFEATURES_EN_ECC:
case SETFEATURES_EN_MSN:
+ case SETFEATURES_EN_RETRY:
case SETFEATURES_EN_RLA:
case SETFEATURES_PREFETCH:
+ case SETFEATURES_4B_RW_LONG:
+ case SETFEATURES_DIS_AAM:
case SETFEATURES_EN_RPOD:
case SETFEATURES_DIS_RI:
case SETFEATURES_DIS_SI:
@@ -1215,6 +1255,7 @@
case CFA_REQ_EXT_ERROR_CODE:
case CFA_ERASE_SECTORS:
case WIN_VERIFY:
+ // case WIN_VERIFY_ONCE:
case WIN_VERIFY_EXT:
case WIN_SEEK:
case WIN_SPECIFY:
@@ -1253,6 +1294,8 @@
}
}
+EXPORT_SYMBOL(ide_cmd_type_parser);
+
/*
* This function is intended to be used prior to invoking ide_do_drive_cmd().
*/
@@ -1262,127 +1305,158 @@
rq->cmd = IDE_DRIVE_TASK_NO_DATA;
}
-/*
- * This is kept for internal use only !!!
- * This is an internal call and nobody in user-space has a damn
- * reason to call this taskfile.
- *
- * ide_raw_taskfile is the one that user-space executes.
- */
-int ide_wait_taskfile (ide_drive_t *drive, struct hd_drive_task_hdr *taskfile, struct hd_drive_hob_hdr *hobfile, byte *buf)
-{
- struct request rq;
- ide_task_t args;
+EXPORT_SYMBOL(ide_init_drive_taskfile);
- memset(&args, 0, sizeof(ide_task_t));
+#if 1
- args.tfRegister[IDE_DATA_OFFSET] = taskfile->data;
- args.tfRegister[IDE_FEATURE_OFFSET] = taskfile->feature;
- args.tfRegister[IDE_NSECTOR_OFFSET] = taskfile->sector_count;
- args.tfRegister[IDE_SECTOR_OFFSET] = taskfile->sector_number;
- args.tfRegister[IDE_LCYL_OFFSET] = taskfile->low_cylinder;
- args.tfRegister[IDE_HCYL_OFFSET] = taskfile->high_cylinder;
- args.tfRegister[IDE_SELECT_OFFSET] = taskfile->device_head;
- args.tfRegister[IDE_COMMAND_OFFSET] = taskfile->command;
-
- args.hobRegister[IDE_DATA_OFFSET_HOB] = hobfile->data;
- args.hobRegister[IDE_FEATURE_OFFSET_HOB] = hobfile->feature;
- args.hobRegister[IDE_NSECTOR_OFFSET_HOB] = hobfile->sector_count;
- args.hobRegister[IDE_SECTOR_OFFSET_HOB] = hobfile->sector_number;
- args.hobRegister[IDE_LCYL_OFFSET_HOB] = hobfile->low_cylinder;
- args.hobRegister[IDE_HCYL_OFFSET_HOB] = hobfile->high_cylinder;
- args.hobRegister[IDE_SELECT_OFFSET_HOB] = hobfile->device_head;
- args.hobRegister[IDE_CONTROL_OFFSET_HOB] = hobfile->control;
+int ide_diag_taskfile (ide_drive_t *drive, ide_task_t *args, unsigned long data_size, u8 *buf)
+{
+ struct request rq;
ide_init_drive_taskfile(&rq);
- /* This is kept for internal use only !!! */
- args.command_type = ide_cmd_type_parser (&args);
- if (args.command_type != IDE_DRIVE_TASK_NO_DATA)
- rq.current_nr_sectors = rq.nr_sectors = (hobfile->sector_count << 8) | taskfile->sector_count;
-
rq.cmd = IDE_DRIVE_TASKFILE;
rq.buffer = buf;
- rq.special = &args;
+
+ /*
+ * (ks) We transfer currently only whole sectors.
+ * This is suffient for now. But, it would be great,
+ * if we would find a solution to transfer any size.
+ * To support special commands like READ LONG.
+ */
+ if (args->command_type != IDE_DRIVE_TASK_NO_DATA) {
+ if (data_size == 0)
+ rq.current_nr_sectors = rq.nr_sectors = (args->hobRegister[IDE_NSECTOR_OFFSET_HOB] << 8) | args->tfRegister[IDE_NSECTOR_OFFSET];
+ /* rq.hard_cur_sectors */
+ else
+ rq.current_nr_sectors = rq.nr_sectors = data_size / SECTOR_SIZE;
+ /* rq.hard_cur_sectors */
+ }
+
+ if (args->tf_out_flags.all == 0) {
+ /*
+ * clean up kernel settings for driver sanity, regardless.
+ * except for discrete diag services.
+ */
+ args->posthandler = ide_post_handler_parser(
+ (struct hd_drive_task_hdr *) args->tfRegister,
+ (struct hd_drive_hob_hdr *) args->hobRegister);
+
+ }
+ rq.special = args;
return ide_do_drive_cmd(drive, &rq, ide_wait);
}
-int ide_raw_taskfile (ide_drive_t *drive, ide_task_t *args, byte *buf)
+#else
+
+int ide_diag_taskfile (ide_drive_t *drive, ide_task_t *args, unsigned long data_size, u8 *buf)
{
- struct request rq;
- ide_init_drive_taskfile(&rq);
- rq.cmd = IDE_DRIVE_TASKFILE;
- rq.buffer = buf;
+ struct request *rq;
+ unsigned long flags;
+ ide_hwgroup_t *hwgroup = HWGROUP(drive);
+ unsigned int major = HWIF(drive)->major;
+ struct list_head *queue_head = &drive->queue.queue_head;
+ DECLARE_COMPLETION(wait);
- if (args->command_type != IDE_DRIVE_TASK_NO_DATA)
- rq.current_nr_sectors = rq.nr_sectors = (args->hobRegister[IDE_NSECTOR_OFFSET_HOB] << 8) | args->tfRegister[IDE_NSECTOR_OFFSET];
+ if (HWIF(drive)->chipset == ide_pdc4030 && buf != NULL)
+ return -ENOSYS; /* special drive cmds not supported */
- rq.special = args;
- return ide_do_drive_cmd(drive, &rq, ide_wait);
+ memset(rq, 0, sizeof(*rq));
+ rq->cmd = IDE_DRIVE_TASKFILE;
+ rq->buffer = buf;
+
+ /*
+ * (ks) We transfer currently only whole sectors.
+ * This is suffient for now. But, it would be great,
+ * if we would find a solution to transfer any size.
+ * To support special commands like READ LONG.
+ */
+ if (args->command_type != IDE_DRIVE_TASK_NO_DATA) {
+ if (data_size == 0) {
+ ata_nsector_t nsector;
+ nsector.b.low = args->hobRegister[IDE_NSECTOR_OFFSET_HOB];
+ nsector.b.high = args->tfRegister[IDE_NSECTOR_OFFSET];
+ rq.nr_sectors = nsector.all;
+ } else {
+ rq.nr_sectors = data_size / SECTOR_SIZE;
+ }
+ rq.current_nr_sectors = rq.nr_sectors;
+ // rq.hard_cur_sectors = rq.nr_sectors;
+ }
+
+ if (args->tf_out_flags.all == 0) {
+ /*
+ * clean up kernel settings for driver sanity, regardless.
+ * except for discrete diag services.
+ */
+ args->posthandler = ide_post_handler_parser(
+ (struct hd_drive_task_hdr *) args->tfRegister,
+ (struct hd_drive_hob_hdr *) args->hobRegister);
+ }
+ rq->special = args;
+ rq->errors = 0;
+ rq->rq_status = RQ_ACTIVE;
+ rq->rq_dev = MKDEV(major,(drive->select.b.unit)<<PARTN_BITS);
+ rq->waiting = &wait;
+
+ spin_lock_irqsave(&io_request_lock, flags);
+ queue_head = queue_head->prev;
+ list_add(&rq->queue, queue_head);
+ ide_do_request(hwgroup, 0);
+ spin_unlock_irqrestore(&io_request_lock, flags);
+
+ wait_for_completion(&wait); /* wait for it to be serviced */
+ return rq->errors ? -EIO : 0; /* return -EIO if errors */
}
+#endif
+
+EXPORT_SYMBOL(ide_diag_taskfile);
+
+int ide_raw_taskfile (ide_drive_t *drive, ide_task_t *args, u8 *buf)
+{
+ return ide_diag_taskfile(drive, args, 0, buf);
+}
+EXPORT_SYMBOL(ide_raw_taskfile);
+
#ifdef CONFIG_IDE_TASK_IOCTL_DEBUG
char * ide_ioctl_verbose (unsigned int cmd)
{
return("unknown");
}
-char * ide_task_cmd_verbose (byte task)
+char * ide_task_cmd_verbose (u8 task)
{
return("unknown");
}
#endif /* CONFIG_IDE_TASK_IOCTL_DEBUG */
-/*
- * The taskfile glue table
- *
- * reqtask.data_phase reqtask.req_cmd
- * args.command_type args.handler
- *
- * TASKFILE_P_OUT_DMAQ ?? ??
- * TASKFILE_P_IN_DMAQ ?? ??
- * TASKFILE_P_OUT_DMA ?? ??
- * TASKFILE_P_IN_DMA ?? ??
- * TASKFILE_P_OUT ?? ??
- * TASKFILE_P_IN ?? ??
- *
- * TASKFILE_OUT_DMAQ IDE_DRIVE_TASK_RAW_WRITE NULL
- * TASKFILE_IN_DMAQ IDE_DRIVE_TASK_IN NULL
- *
- * TASKFILE_OUT_DMA IDE_DRIVE_TASK_RAW_WRITE NULL
- * TASKFILE_IN_DMA IDE_DRIVE_TASK_IN NULL
- *
- * TASKFILE_IN_OUT ?? ??
- *
- * TASKFILE_MULTI_OUT IDE_DRIVE_TASK_RAW_WRITE task_mulout_intr
- * TASKFILE_MULTI_IN IDE_DRIVE_TASK_IN task_mulin_intr
- *
- * TASKFILE_OUT IDE_DRIVE_TASK_RAW_WRITE task_out_intr
- * TASKFILE_OUT IDE_DRIVE_TASK_OUT task_out_intr
- *
- * TASKFILE_IN IDE_DRIVE_TASK_IN task_in_intr
- * TASKFILE_NO_DATA IDE_DRIVE_TASK_NO_DATA task_no_data_intr
- *
- * IDE_DRIVE_TASK_SET_XFER task_no_data_intr
- * IDE_DRIVE_TASK_INVALID
- *
- */
-
#define MAX_DMA (256*SECTOR_WORDS)
+ide_startstop_t flagged_taskfile(ide_drive_t *, ide_task_t *);
+ide_startstop_t flagged_task_no_data_intr(ide_drive_t *);
+ide_startstop_t flagged_task_in_intr(ide_drive_t *);
+ide_startstop_t flagged_task_mulin_intr(ide_drive_t *);
+ide_startstop_t flagged_pre_task_out_intr(ide_drive_t *, struct request *);
+ide_startstop_t flagged_task_out_intr(ide_drive_t *);
+ide_startstop_t flagged_pre_task_mulout_intr(ide_drive_t *, struct request *);
+ide_startstop_t flagged_task_mulout_intr(ide_drive_t *);
+
int ide_taskfile_ioctl (ide_drive_t *drive, struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
ide_task_request_t *req_task;
ide_task_t args;
-
- byte *outbuf = NULL;
- byte *inbuf = NULL;
+ u8 *outbuf = NULL;
+ u8 *inbuf = NULL;
task_ioreg_t *argsptr = args.tfRegister;
task_ioreg_t *hobsptr = args.hobRegister;
int err = 0;
int tasksize = sizeof(struct ide_task_request_s);
int taskin = 0;
int taskout = 0;
+ u8 io_32bit = drive->io_32bit;
+
+// printk("IDE Taskfile ...\n");
req_task = kmalloc(tasksize, GFP_KERNEL);
if (req_task == NULL) return -ENOMEM;
@@ -1423,8 +1497,7 @@
}
}
- memset(argsptr, 0, HDIO_DRIVE_TASK_HDR_SIZE);
- memset(hobsptr, 0, HDIO_DRIVE_HOB_HDR_SIZE);
+ memset(&args, 0, sizeof(ide_task_t));
memcpy(argsptr, req_task->io_ports, HDIO_DRIVE_TASK_HDR_SIZE);
memcpy(hobsptr, req_task->hob_ports, HDIO_DRIVE_HOB_HDR_SIZE);
@@ -1440,88 +1513,92 @@
ide_task_cmd_verbose(args.tfRegister[IDE_COMMAND_OFFSET]));
#endif /* CONFIG_IDE_TASK_IOCTL_DEBUG */
+ drive->io_32bit = 0;
switch(req_task->data_phase) {
case TASKFILE_OUT_DMAQ:
case TASKFILE_OUT_DMA:
- args.prehandler = NULL;
- args.handler = NULL;
- args.posthandler = NULL;
- err = ide_raw_taskfile(drive, &args, outbuf);
+ err = ide_diag_taskfile(drive, &args, taskout, outbuf);
break;
case TASKFILE_IN_DMAQ:
case TASKFILE_IN_DMA:
- args.prehandler = NULL;
- args.handler = NULL;
- args.posthandler = NULL;
- err = ide_raw_taskfile(drive, &args, inbuf);
+ err = ide_diag_taskfile(drive, &args, taskin, inbuf);
break;
case TASKFILE_IN_OUT:
#if 0
args.prehandler = &pre_task_out_intr;
args.handler = &task_out_intr;
args.posthandler = NULL;
- err = ide_raw_taskfile(drive, &args, outbuf);
+ err = ide_diag_taskfile(drive, &args, taskout, outbuf);
args.prehandler = NULL;
args.handler = &task_in_intr;
args.posthandler = NULL;
- err = ide_raw_taskfile(drive, &args, inbuf);
+ err = ide_diag_taskfile(drive, &args, taskin, inbuf);
break;
#else
err = -EFAULT;
goto abort;
#endif
case TASKFILE_MULTI_OUT:
- if (drive->mult_count) {
- args.prehandler = &pre_task_out_intr;
- args.handler = &task_mulout_intr;
- args.posthandler = NULL;
- err = ide_raw_taskfile(drive, &args, outbuf);
- } else {
+ if (!drive->mult_count) {
/* (hs): give up if multcount is not set */
- printk("%s: %s Multimode Write " \
+ printk(KERN_ERR "%s: %s Multimode Write " \
"multcount is not set\n",
- drive->name, __FUNCTION__);
+ drive->name, __FUNCTION__);
err = -EPERM;
goto abort;
}
+ if (args.tf_out_flags.all != 0) {
+ args.prehandler = &flagged_pre_task_mulout_intr;
+ args.handler = &flagged_task_mulout_intr;
+ } else {
+ args.prehandler = &pre_task_mulout_intr;
+ args.handler = &task_mulout_intr;
+ }
+ err = ide_diag_taskfile(drive, &args, taskout, outbuf);
break;
case TASKFILE_OUT:
- args.prehandler = &pre_task_out_intr;
- args.handler = &task_out_intr;
- args.posthandler = NULL;
- err = ide_raw_taskfile(drive, &args, outbuf);
+ if (args.tf_out_flags.all != 0) {
+ args.prehandler = &flagged_pre_task_out_intr;
+ args.handler = &flagged_task_out_intr;
+ } else {
+ args.prehandler = &pre_task_out_intr;
+ args.handler = &task_out_intr;
+ }
+ err = ide_diag_taskfile(drive, &args, taskout, outbuf);
break;
case TASKFILE_MULTI_IN:
- if (drive->mult_count) {
- args.prehandler = NULL;
- args.handler = &task_mulin_intr;
- args.posthandler = NULL;
- err = ide_raw_taskfile(drive, &args, inbuf);
- } else {
+ if (!drive->mult_count) {
/* (hs): give up if multcount is not set */
- printk("%s: %s Multimode Read failure " \
+ printk(KERN_ERR "%s: %s Multimode Read failure " \
"multcount is not set\n",
drive->name, __FUNCTION__);
err = -EPERM;
goto abort;
}
+ if (args.tf_out_flags.all != 0) {
+ args.handler = &flagged_task_mulin_intr;
+ } else {
+ args.handler = &task_mulin_intr;
+ }
+ err = ide_diag_taskfile(drive, &args, taskin, inbuf);
break;
case TASKFILE_IN:
- args.prehandler = NULL;
- args.handler = &task_in_intr;
- args.posthandler = NULL;
- err = ide_raw_taskfile(drive, &args, inbuf);
+ if (args.tf_out_flags.all != 0) {
+ args.handler = &flagged_task_in_intr;
+ } else {
+ args.handler = &task_in_intr;
+ }
+ err = ide_diag_taskfile(drive, &args, taskin, inbuf);
break;
case TASKFILE_NO_DATA:
- args.prehandler = NULL;
- args.handler = &task_no_data_intr;
- args.posthandler = NULL;
- err = ide_raw_taskfile(drive, &args, NULL);
+ if (args.tf_out_flags.all != 0) {
+ args.handler = &flagged_task_no_data_intr;
+ } else {
+ args.handler = &task_no_data_intr;
+ }
+ err = ide_diag_taskfile(drive, &args, 0, NULL);
break;
default:
- args.prehandler = NULL;
- args.handler = NULL;
- args.posthandler = NULL;
err = -EFAULT;
goto abort;
}
@@ -1555,153 +1632,593 @@
kfree(outbuf);
if (inbuf != NULL)
kfree(inbuf);
+
+// printk("IDE Taskfile ioctl ended. rc = %i\n", err);
+
+ drive->io_32bit = io_32bit;
+
return err;
}
-EXPORT_SYMBOL(task_read_24);
-EXPORT_SYMBOL(do_rw_taskfile);
-EXPORT_SYMBOL(do_taskfile);
-// EXPORT_SYMBOL(flagged_taskfile);
+EXPORT_SYMBOL(ide_taskfile_ioctl);
-//EXPORT_SYMBOL(ide_end_taskfile);
+int ide_wait_cmd (ide_drive_t *drive, u8 cmd, u8 nsect, u8 feature, u8 sectors, u8 *buf)
+{
+ struct request rq;
+ u8 buffer[4];
-EXPORT_SYMBOL(set_multmode_intr);
-EXPORT_SYMBOL(set_geometry_intr);
-EXPORT_SYMBOL(recal_intr);
+ if (!buf)
+ buf = buffer;
+ memset(buf, 0, 4 + SECTOR_WORDS * 4 * sectors);
+ ide_init_drive_cmd(&rq);
+ rq.buffer = buf;
+ *buf++ = cmd;
+ *buf++ = nsect;
+ *buf++ = feature;
+ *buf++ = sectors;
+ return ide_do_drive_cmd(drive, &rq, ide_wait);
+}
-EXPORT_SYMBOL(task_no_data_intr);
-EXPORT_SYMBOL(task_in_intr);
-EXPORT_SYMBOL(task_mulin_intr);
-EXPORT_SYMBOL(pre_task_out_intr);
-EXPORT_SYMBOL(task_out_intr);
-EXPORT_SYMBOL(task_mulout_intr);
+EXPORT_SYMBOL(ide_wait_cmd);
-EXPORT_SYMBOL(ide_init_drive_taskfile);
-EXPORT_SYMBOL(ide_wait_taskfile);
-EXPORT_SYMBOL(ide_raw_taskfile);
-EXPORT_SYMBOL(ide_pre_handler_parser);
-EXPORT_SYMBOL(ide_handler_parser);
-EXPORT_SYMBOL(ide_cmd_type_parser);
-EXPORT_SYMBOL(ide_taskfile_ioctl);
+/*
+ * FIXME : this needs to map into at taskfile. <andre@linux-ide.org>
+ */
+int ide_cmd_ioctl (ide_drive_t *drive, struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
+{
+#if 1
+ int err = -EIO;
+ u8 args[4], *argbuf = args;
+ u8 xfer_rate = 0;
+ int argsize = 4;
+ ide_task_t tfargs;
-#ifdef CONFIG_PKT_TASK_IOCTL
+ if (NULL == (void *) arg) {
+ struct request rq;
+ ide_init_drive_cmd(&rq);
+ return ide_do_drive_cmd(drive, &rq, ide_wait);
+ }
-#if 0
+ if (copy_from_user(args, (void *)arg, 4))
+ return -EFAULT;
+
+ memset(&tfargs, 0, sizeof(ide_task_t));
+ tfargs.tfRegister[IDE_FEATURE_OFFSET] = args[2];
+ tfargs.tfRegister[IDE_NSECTOR_OFFSET] = args[3];
+ tfargs.tfRegister[IDE_SECTOR_OFFSET] = args[1];
+ tfargs.tfRegister[IDE_LCYL_OFFSET] = 0x00;
+ tfargs.tfRegister[IDE_HCYL_OFFSET] = 0x00;
+ tfargs.tfRegister[IDE_SELECT_OFFSET] = 0x00;
+ tfargs.tfRegister[IDE_COMMAND_OFFSET] = args[0];
+
+ if (args[3]) {
+ argsize = 4 + (SECTOR_WORDS * 4 * args[3]);
+ argbuf = kmalloc(argsize, GFP_KERNEL);
+ if (argbuf == NULL)
+ return -ENOMEM;
+ memcpy(argbuf, args, 4);
+ }
+ if (set_transfer(drive, &tfargs)) {
+ xfer_rate = args[1];
+ if (ide_ata66_check(drive, &tfargs))
+ goto abort;
+ }
+
+ err = ide_wait_cmd(drive, args[0], args[1], args[2], args[3], argbuf);
+
+ if (!err && xfer_rate) {
+ /* active-retuning-calls future */
+ ide_set_xfer_rate(drive, xfer_rate);
+ ide_driveid_update(drive);
+ }
+abort:
+ if (copy_to_user((void *)arg, argbuf, argsize))
+ err = -EFAULT;
+ if (argsize > 4)
+ kfree(argbuf);
+ return err;
+
+#else
+
+ int err = 0;
+ u8 args[4], *argbuf = args;
+ u8 xfer_rate = 0;
+ int argsize = 0;
+ ide_task_t tfargs;
+
+ if (NULL == (void *) arg) {
+ struct request rq;
+ ide_init_drive_cmd(&rq);
+ return ide_do_drive_cmd(drive, &rq, ide_wait);
+ }
+
+ if (copy_from_user(args, (void *)arg, 4))
+ return -EFAULT;
+
+ memset(&tfargs, 0, sizeof(ide_task_t));
+ tfargs.tfRegister[IDE_FEATURE_OFFSET] = args[2];
+ tfargs.tfRegister[IDE_NSECTOR_OFFSET] = args[3];
+ tfargs.tfRegister[IDE_SECTOR_OFFSET] = args[1];
+ tfargs.tfRegister[IDE_LCYL_OFFSET] = 0x00;
+ tfargs.tfRegister[IDE_HCYL_OFFSET] = 0x00;
+ tfargs.tfRegister[IDE_SELECT_OFFSET] = 0x00;
+ tfargs.tfRegister[IDE_COMMAND_OFFSET] = args[0];
+
+ if (args[3]) {
+ argsize = (SECTOR_WORDS * 4 * args[3]);
+ argbuf = kmalloc(argsize, GFP_KERNEL);
+ if (argbuf == NULL)
+ return -ENOMEM;
+ }
+
+ if (set_transfer(drive, &tfargs)) {
+ xfer_rate = args[1];
+ if (ide_ata66_check(drive, &tfargs))
+ goto abort;
+ }
+
+ tfargs.command_type = ide_cmd_type_parser(&tfargs);
+ err = ide_raw_taskfile(drive, &tfargs, argbuf);
+
+ if (!err && xfer_rate) {
+ /* active-retuning-calls future */
+ ide_set_xfer_rate(drive, xfer_rate);
+ ide_driveid_update(drive);
+ }
+abort:
+ args[0] = tfargs.tfRegister[IDE_COMMAND_OFFSET];
+ args[1] = tfargs.tfRegister[IDE_FEATURE_OFFSET];
+ args[2] = tfargs.tfRegister[IDE_NSECTOR_OFFSET];
+ args[3] = 0;
+
+ if (copy_to_user((void *)arg, argbuf, 4))
+ err = -EFAULT;
+ if (argbuf != NULL) {
+ if (copy_to_user((void *)arg, argbuf + 4, argsize))
+ err = -EFAULT;
+ kfree(argbuf);
+ }
+ return err;
+
+#endif
+}
+
+EXPORT_SYMBOL(ide_cmd_ioctl);
+
+int ide_wait_cmd_task (ide_drive_t *drive, u8 *buf)
{
+ struct request rq;
-{ /* start cdrom */
+ ide_init_drive_cmd(&rq);
+ rq.cmd = IDE_DRIVE_TASK;
+ rq.buffer = buf;
+ return ide_do_drive_cmd(drive, &rq, ide_wait);
+}
- struct cdrom_info *info = drive->driver_data;
+EXPORT_SYMBOL(ide_wait_cmd_task);
- if (info->dma) {
- if (info->cmd == READ) {
- info->dma = !HWIF(drive)->dmaproc(ide_dma_read, drive);
- } else if (info->cmd == WRITE) {
- info->dma = !HWIF(drive)->dmaproc(ide_dma_write, drive);
- } else {
- printk("ide-cd: DMA set, but not allowed\n");
+/*
+ * FIXME : this needs to map into at taskfile. <andre@linux-ide.org>
+ */
+int ide_task_ioctl (ide_drive_t *drive, struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
+{
+ int err = 0;
+ u8 args[7], *argbuf = args;
+ int argsize = 7;
+
+ if (copy_from_user(args, (void *)arg, 7))
+ return -EFAULT;
+ err = ide_wait_cmd_task(drive, argbuf);
+ if (copy_to_user((void *)arg, argbuf, argsize))
+ err = -EFAULT;
+ return err;
+}
+
+EXPORT_SYMBOL(ide_task_ioctl);
+
+/*
+ * 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);
+ task_struct_t *taskfile = (task_struct_t *) task->tfRegister;
+ hob_struct_t *hobfile = (hob_struct_t *) task->hobRegister;
+#if DEBUG_TASKFILE
+ u8 status;
+#endif
+
+
+#ifdef CONFIG_IDE_TASK_IOCTL_DEBUG
+ void debug_taskfile(drive, task);
+#endif /* CONFIG_IDE_TASK_IOCTL_DEBUG */
+
+ /*
+ * (ks) Check taskfile in/out flags.
+ * If set, then execute as it is defined.
+ * If not set, then define default settings.
+ * The default values are:
+ * write and read all taskfile registers (except data)
+ * write and read the hob registers (sector,nsector,lcyl,hcyl)
+ */
+ if (task->tf_out_flags.all == 0) {
+ task->tf_out_flags.all = IDE_TASKFILE_STD_OUT_FLAGS;
+ if (drive->addressing == 1)
+ task->tf_out_flags.all |= (IDE_HOB_STD_OUT_FLAGS << 8);
+ }
+
+ if (task->tf_in_flags.all == 0) {
+ task->tf_in_flags.all = IDE_TASKFILE_STD_IN_FLAGS;
+ if (drive->addressing == 1)
+ task->tf_in_flags.all |= (IDE_HOB_STD_IN_FLAGS << 8);
+ }
+
+ /* 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);
+
+#if DEBUG_TASKFILE
+ status = hwif->INB(IDE_STATUS_REG);
+ if (status & 0x80) {
+ printk("flagged_taskfile -> Bad status. Status = %02x. wait 100 usec ...\n", status);
+ udelay(100);
+ status = hwif->INB(IDE_STATUS_REG);
+ printk("flagged_taskfile -> Status = %02x\n", status);
+ }
+#endif
+
+ if (task->tf_out_flags.b.data) {
+ u16 data = taskfile->data + (hobfile->data << 8);
+ hwif->OUTW(data, IDE_DATA_REG);
+ }
+
+ /* (ks) send hob registers first */
+ if (task->tf_out_flags.b.nsector_hob)
+ hwif->OUTB(hobfile->sector_count, IDE_NSECTOR_REG);
+ if (task->tf_out_flags.b.sector_hob)
+ hwif->OUTB(hobfile->sector_number, IDE_SECTOR_REG);
+ if (task->tf_out_flags.b.lcyl_hob)
+ hwif->OUTB(hobfile->low_cylinder, IDE_LCYL_REG);
+ if (task->tf_out_flags.b.hcyl_hob)
+ hwif->OUTB(hobfile->high_cylinder, IDE_HCYL_REG);
+
+ /* (ks) Send now the standard registers */
+ if (task->tf_out_flags.b.error_feature)
+ hwif->OUTB(taskfile->feature, IDE_FEATURE_REG);
+ /* refers to number of sectors to transfer */
+ if (task->tf_out_flags.b.nsector)
+ hwif->OUTB(taskfile->sector_count, IDE_NSECTOR_REG);
+ /* refers to sector offset or start sector */
+ if (task->tf_out_flags.b.sector)
+ hwif->OUTB(taskfile->sector_number, IDE_SECTOR_REG);
+ if (task->tf_out_flags.b.lcyl)
+ hwif->OUTB(taskfile->low_cylinder, IDE_LCYL_REG);
+ if (task->tf_out_flags.b.hcyl)
+ hwif->OUTB(taskfile->high_cylinder, IDE_HCYL_REG);
+
+ /*
+ * (ks) In the flagged taskfile approch, we will used all specified
+ * registers and the register value will not be changed. Except the
+ * select bit (master/slave) in the drive_head register. We must make
+ * sure that the desired drive is selected.
+ */
+ hwif->OUTB(taskfile->device_head | drive->select.all, IDE_SELECT_REG);
+ switch(task->data_phase) {
+
+ case TASKFILE_OUT_DMAQ:
+ case TASKFILE_OUT_DMA:
+ hwif->ide_dma_write(drive);
+ break;
+
+ case TASKFILE_IN_DMAQ:
+ case TASKFILE_IN_DMA:
+ hwif->ide_dma_read(drive);
+ break;
+
+ default:
+ if (task->handler == NULL)
+ return ide_stopped;
+
+ /* Issue the command */
+ ide_execute_command(drive, taskfile->command, task->handler, WAIT_WORSTCASE, NULL);
+ if (task->prehandler != NULL)
+ return task->prehandler(drive, HWGROUP(drive)->rq);
+ }
+
+ return ide_started;
+}
+
+EXPORT_SYMBOL(flagged_taskfile);
+
+ide_startstop_t flagged_task_no_data_intr (ide_drive_t *drive)
+{
+ ide_hwif_t *hwif = HWIF(drive);
+ u8 stat;
+
+ local_irq_enable();
+
+ if (!OK_STAT(stat = hwif->INB(IDE_STATUS_REG), READY_STAT, BAD_STAT)) {
+ if (stat & ERR_STAT) {
+ return DRIVER(drive)->error(drive, "flagged_task_no_data_intr", stat);
}
+ /*
+ * (ks) Unexpected ATA data phase detected.
+ * This should not happen. But, it can !
+ * I am not sure, which function is best to clean up
+ * this situation. I choose: ide_error(...)
+ */
+ return DRIVER(drive)->error(drive, "flagged_task_no_data_intr (unexpected phase)", stat);
}
- /* Set up the controller registers. */
- OUT_BYTE (info->dma, IDE_FEATURE_REG);
- OUT_BYTE (0, IDE_NSECTOR_REG);
- OUT_BYTE (0, IDE_SECTOR_REG);
+ ide_end_drive_cmd(drive, stat, hwif->INB(IDE_ERROR_REG));
- OUT_BYTE (xferlen & 0xff, IDE_LCYL_REG);
- OUT_BYTE (xferlen >> 8 , IDE_HCYL_REG);
- if (IDE_CONTROL_REG)
- OUT_BYTE (drive->ctl, IDE_CONTROL_REG);
+ return ide_stopped;
+}
- if (info->dma)
- (void) (HWIF(drive)->dmaproc(ide_dma_begin, drive));
+/*
+ * Handler for command with PIO data-in phase
+ */
+ide_startstop_t flagged_task_in_intr (ide_drive_t *drive)
+{
+ ide_hwif_t *hwif = HWIF(drive);
+ u8 stat = hwif->INB(IDE_STATUS_REG);
+ struct request *rq = HWGROUP(drive)->rq;
+ char *pBuf = NULL;
+ int retries = 5;
+
+ if (rq->current_nr_sectors == 0)
+ return DRIVER(drive)->error(drive, "flagged_task_in_intr (no data requested)", stat);
- if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt) {
- ide_set_handler (drive, handler, WAIT_CMD, cdrom_timer_expiry);
- OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG); /* packet command */
+ if (!OK_STAT(stat, DATA_READY, BAD_R_STAT)) {
+ if (stat & ERR_STAT) {
+ return DRIVER(drive)->error(drive, "flagged_task_in_intr", stat);
+ }
+ /*
+ * (ks) Unexpected ATA data phase detected.
+ * This should not happen. But, it can !
+ * I am not sure, which function is best to clean up
+ * this situation. I choose: ide_error(...)
+ */
+ return DRIVER(drive)->error(drive, "flagged_task_in_intr (unexpected data phase)", stat);
+ }
+
+ pBuf = rq->buffer + ((rq->nr_sectors - rq->current_nr_sectors) * SECTOR_SIZE);
+ DTF("Read - rq->current_nr_sectors: %d, status: %02x\n", (int) rq->current_nr_sectors, stat);
+
+ taskfile_input_data(drive, pBuf, SECTOR_WORDS);
+
+ if (--rq->current_nr_sectors != 0) {
+ /*
+ * (ks) We don't know which command was executed.
+ * So, we wait the 'WORSTCASE' value.
+ */
+ ide_set_handler(drive, &flagged_task_in_intr, WAIT_WORSTCASE, NULL);
return ide_started;
- } else {
- OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG); /* packet command */
- return (*handler) (drive);
}
+ /*
+ * (ks) Last sector was transfered, wait until drive is ready.
+ * This can take up to 10 usec. We willl wait max 50 us.
+ */
+ while (((stat = hwif->INB(IDE_STATUS_REG)) & BUSY_STAT) && retries--)
+ udelay(10);
+ ide_end_drive_cmd (drive, stat, hwif->INB(IDE_ERROR_REG));
-} /* end cdrom */
+ return ide_stopped;
+}
-{ /* start floppy */
+ide_startstop_t flagged_task_mulin_intr (ide_drive_t *drive)
+{
+ ide_hwif_t *hwif = HWIF(drive);
+ u8 stat = hwif->INB(IDE_STATUS_REG);
+ struct request *rq = HWGROUP(drive)->rq;
+ char *pBuf = NULL;
+ int retries = 5;
+ unsigned int msect, nsect;
- idefloppy_floppy_t *floppy = drive->driver_data;
- idefloppy_bcount_reg_t bcount;
- int dma_ok = 0;
+ if (rq->current_nr_sectors == 0)
+ return DRIVER(drive)->error(drive, "flagged_task_mulin_intr (no data requested)", stat);
- floppy->pc=pc; /* Set the current packet command */
+ msect = drive->mult_count;
+ if (msect == 0)
+ return DRIVER(drive)->error(drive, "flagged_task_mulin_intr (multimode not set)", stat);
- pc->retries++;
- pc->actually_transferred=0; /* We haven't transferred any data yet */
- pc->current_position=pc->buffer;
- bcount.all = IDE_MIN(pc->request_transfer, 63 * 1024);
+ if (!OK_STAT(stat, DATA_READY, BAD_R_STAT)) {
+ if (stat & ERR_STAT) {
+ return DRIVER(drive)->error(drive, "flagged_task_mulin_intr", stat);
+ }
+ /*
+ * (ks) Unexpected ATA data phase detected.
+ * This should not happen. But, it can !
+ * I am not sure, which function is best to clean up
+ * this situation. I choose: ide_error(...)
+ */
+ return DRIVER(drive)->error(drive, "flagged_task_mulin_intr (unexpected data phase)", stat);
+ }
-#ifdef CONFIG_BLK_DEV_IDEDMA
- if (test_and_clear_bit (PC_DMA_ERROR, &pc->flags)) {
- (void) HWIF(drive)->dmaproc(ide_dma_off, drive);
+ nsect = (rq->current_nr_sectors > msect) ? msect : rq->current_nr_sectors;
+ pBuf = rq->buffer + ((rq->nr_sectors - rq->current_nr_sectors) * SECTOR_SIZE);
+
+ DTF("Multiread: %p, nsect: %d , rq->current_nr_sectors: %ld\n",
+ pBuf, nsect, rq->current_nr_sectors);
+
+ taskfile_input_data(drive, pBuf, nsect * SECTOR_WORDS);
+
+ rq->current_nr_sectors -= nsect;
+ if (rq->current_nr_sectors != 0) {
+ /*
+ * (ks) We don't know which command was executed.
+ * So, we wait the 'WORSTCASE' value.
+ */
+ ide_set_handler(drive, &flagged_task_mulin_intr, WAIT_WORSTCASE, NULL);
+ return ide_started;
}
- if (test_bit (PC_DMA_RECOMMENDED, &pc->flags) && drive->using_dma)
- dma_ok=!HWIF(drive)->dmaproc(test_bit (PC_WRITING, &pc->flags) ? ide_dma_write : ide_dma_read, drive);
-#endif /* CONFIG_BLK_DEV_IDEDMA */
- if (IDE_CONTROL_REG)
- OUT_BYTE (drive->ctl,IDE_CONTROL_REG);
- OUT_BYTE (dma_ok ? 1:0,IDE_FEATURE_REG); /* Use PIO/DMA */
- OUT_BYTE (bcount.b.high,IDE_BCOUNTH_REG);
- OUT_BYTE (bcount.b.low,IDE_BCOUNTL_REG);
- OUT_BYTE (drive->select.all,IDE_SELECT_REG);
+ /*
+ * (ks) Last sector was transfered, wait until drive is ready.
+ * This can take up to 10 usec. We willl wait max 50 us.
+ */
+ while (((stat = hwif->INB(IDE_STATUS_REG)) & BUSY_STAT) && retries--)
+ udelay(10);
+ ide_end_drive_cmd (drive, stat, hwif->INB(IDE_ERROR_REG));
-#ifdef CONFIG_BLK_DEV_IDEDMA
- if (dma_ok) { /* Begin DMA, if necessary */
- set_bit (PC_DMA_IN_PROGRESS, &pc->flags);
- (void) (HWIF(drive)->dmaproc(ide_dma_begin, drive));
+ return ide_stopped;
+}
+
+/*
+ * Pre handler for command with PIO data-out phase
+ */
+ide_startstop_t flagged_pre_task_out_intr (ide_drive_t *drive, struct request *rq)
+{
+ ide_hwif_t *hwif = HWIF(drive);
+ u8 stat = hwif->INB(IDE_STATUS_REG);
+ ide_startstop_t startstop;
+
+ if (!rq->current_nr_sectors) {
+ return DRIVER(drive)->error(drive, "flagged_pre_task_out_intr (write data not specified)", stat);
}
-#endif /* CONFIG_BLK_DEV_IDEDMA */
-} /* end floppy */
+ if (ide_wait_stat(&startstop, drive, DATA_READY,
+ BAD_W_STAT, WAIT_DRQ)) {
+ printk(KERN_ERR "%s: No DRQ bit after issuing write command.\n", drive->name);
+ return startstop;
+ }
-{ /* start tape */
+ taskfile_output_data(drive, rq->buffer, SECTOR_WORDS);
+ --rq->current_nr_sectors;
- idetape_tape_t *tape = drive->driver_data;
+ return ide_started;
+}
-#ifdef CONFIG_BLK_DEV_IDEDMA
- if (test_and_clear_bit (PC_DMA_ERROR, &pc->flags)) {
- printk (KERN_WARNING "ide-tape: DMA disabled, reverting to PIO\n");
- (void) HWIF(drive)->dmaproc(ide_dma_off, drive);
- }
- if (test_bit (PC_DMA_RECOMMENDED, &pc->flags) && drive->using_dma)
- dma_ok=!HWIF(drive)->dmaproc(test_bit (PC_WRITING, &pc->flags) ? ide_dma_write : ide_dma_read, drive);
-#endif /* CONFIG_BLK_DEV_IDEDMA */
+ide_startstop_t flagged_task_out_intr (ide_drive_t *drive)
+{
+ ide_hwif_t *hwif = HWIF(drive);
+ u8 stat = hwif->INB(IDE_STATUS_REG);
+ struct request *rq = HWGROUP(drive)->rq;
+ char *pBuf = NULL;
- if (IDE_CONTROL_REG)
- OUT_BYTE (drive->ctl,IDE_CONTROL_REG);
- OUT_BYTE (dma_ok ? 1:0,IDE_FEATURE_REG); /* Use PIO/DMA */
- OUT_BYTE (bcount.b.high,IDE_BCOUNTH_REG);
- OUT_BYTE (bcount.b.low,IDE_BCOUNTL_REG);
- OUT_BYTE (drive->select.all,IDE_SELECT_REG);
-#ifdef CONFIG_BLK_DEV_IDEDMA
- if (dma_ok) { /* Begin DMA, if necessary */
- set_bit (PC_DMA_IN_PROGRESS, &pc->flags);
- (void) (HWIF(drive)->dmaproc(ide_dma_begin, drive));
- }
-#endif /* CONFIG_BLK_DEV_IDEDMA */
- if (test_bit(IDETAPE_DRQ_INTERRUPT, &tape->flags)) {
- ide_set_handler(drive, &idetape_transfer_pc, IDETAPE_WAIT_CMD, NULL);
- OUT_BYTE(WIN_PACKETCMD, IDE_COMMAND_REG);
- return ide_started;
- } else {
- OUT_BYTE(WIN_PACKETCMD, IDE_COMMAND_REG);
- return idetape_transfer_pc(drive);
+ if (!OK_STAT(stat, DRIVE_READY, BAD_W_STAT))
+ return DRIVER(drive)->error(drive, "flagged_task_out_intr", stat);
+
+ if (!rq->current_nr_sectors) {
+ ide_end_drive_cmd (drive, stat, hwif->INB(IDE_ERROR_REG));
+ return ide_stopped;
}
-} /* end tape */
+ if (!OK_STAT(stat, DATA_READY, BAD_W_STAT)) {
+ /*
+ * (ks) Unexpected ATA data phase detected.
+ * This should not happen. But, it can !
+ * I am not sure, which function is best to clean up
+ * this situation. I choose: ide_error(...)
+ */
+ return DRIVER(drive)->error(drive, "flagged_task_out_intr (unexpected data phase)", stat);
+ }
+ pBuf = rq->buffer + ((rq->nr_sectors - rq->current_nr_sectors) * SECTOR_SIZE);
+ DTF("Write - rq->current_nr_sectors: %d, status: %02x\n",
+ (int) rq->current_nr_sectors, stat);
+
+ taskfile_output_data(drive, pBuf, SECTOR_WORDS);
+ --rq->current_nr_sectors;
+
+ /*
+ * (ks) We don't know which command was executed.
+ * So, we wait the 'WORSTCASE' value.
+ */
+ ide_set_handler(drive, &flagged_task_out_intr, WAIT_WORSTCASE, NULL);
+
+ return ide_started;
}
-#endif
+
+ide_startstop_t flagged_pre_task_mulout_intr (ide_drive_t *drive, struct request *rq)
+{
+ ide_hwif_t *hwif = HWIF(drive);
+ u8 stat = hwif->INB(IDE_STATUS_REG);
+ char *pBuf = NULL;
+ ide_startstop_t startstop;
+ unsigned int msect, nsect;
+
+ if (!rq->current_nr_sectors)
+ return DRIVER(drive)->error(drive, "flagged_pre_task_mulout_intr (write data not specified)", stat);
+
+ msect = drive->mult_count;
+ if (msect == 0)
+ return DRIVER(drive)->error(drive, "flagged_pre_task_mulout_intr (multimode not set)", stat);
+
+ if (ide_wait_stat(&startstop, drive, DATA_READY,
+ BAD_W_STAT, WAIT_DRQ)) {
+ printk(KERN_ERR "%s: No DRQ bit after issuing write command.\n", drive->name);
+ return startstop;
+ }
+
+ nsect = (rq->current_nr_sectors > msect) ? msect : rq->current_nr_sectors;
+ pBuf = rq->buffer + ((rq->nr_sectors - rq->current_nr_sectors) * SECTOR_SIZE);
+ DTF("Multiwrite: %p, nsect: %d , rq->current_nr_sectors: %ld\n",
+ pBuf, nsect, rq->current_nr_sectors);
+
+ taskfile_output_data(drive, pBuf, nsect * SECTOR_WORDS);
+
+ rq->current_nr_sectors -= nsect;
+
+ return ide_started;
+}
+
+ide_startstop_t flagged_task_mulout_intr (ide_drive_t *drive)
+{
+ ide_hwif_t *hwif = HWIF(drive);
+ u8 stat = hwif->INB(IDE_STATUS_REG);
+ struct request *rq = HWGROUP(drive)->rq;
+ char *pBuf = NULL;
+ unsigned int msect, nsect;
+
+ msect = drive->mult_count;
+ if (msect == 0)
+ return DRIVER(drive)->error(drive, "flagged_task_mulout_intr (multimode not set)", stat);
+
+ if (!OK_STAT(stat, DRIVE_READY, BAD_W_STAT))
+ return DRIVER(drive)->error(drive, "flagged_task_mulout_intr", stat);
+
+ if (!rq->current_nr_sectors) {
+ ide_end_drive_cmd (drive, stat, hwif->INB(IDE_ERROR_REG));
+ return ide_stopped;
+ }
+
+ if (!OK_STAT(stat, DATA_READY, BAD_W_STAT)) {
+ /*
+ * (ks) Unexpected ATA data phase detected.
+ * This should not happen. But, it can !
+ * I am not sure, which function is best to clean up
+ * this situation. I choose: ide_error(...)
+ */
+ return DRIVER(drive)->error(drive, "flagged_task_mulout_intr (unexpected data phase)", stat);
+ }
+
+ nsect = (rq->current_nr_sectors > msect) ? msect : rq->current_nr_sectors;
+ pBuf = rq->buffer + ((rq->nr_sectors - rq->current_nr_sectors) * SECTOR_SIZE);
+ DTF("Multiwrite: %p, nsect: %d , rq->current_nr_sectors: %ld\n",
+ pBuf, nsect, rq->current_nr_sectors);
+
+ taskfile_output_data(drive, pBuf, nsect * SECTOR_WORDS);
+ rq->current_nr_sectors -= nsect;
+
+ /*
+ * (ks) We don't know which command was executed.
+ * So, we wait the 'WORSTCASE' value.
+ */
+ ide_set_handler(drive, &flagged_task_mulout_intr, WAIT_WORSTCASE, NULL);
+
+ return ide_started;
+}
+
+/*
+ * Beginning of Taskfile OPCODE Library and feature sets.
+ */
+
+#ifdef CONFIG_PKT_TASK_IOCTL
int pkt_taskfile_ioctl (ide_drive_t *drive, struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen (who was at: slshen@lbl.gov)