2 * linux/drivers/ide/ide-taskfile.c Version 0.38 March 05, 2003
4 * Copyright (C) 2000-2002 Michael Cornwell <cornwell@acm.org>
5 * Copyright (C) 2000-2002 Andre Hedrick <andre@linux-ide.org>
6 * Copyright (C) 2001-2002 Klaus Smolin
7 * IBM Storage Technology Division
8 * Copyright (C) 2003-2004 Bartlomiej Zolnierkiewicz
10 * The big the bad and the ugly.
12 * Problems to be fixed because of BH interface or the lack therefore.
14 * Fill me in stupid !!!
17 * General refers to the Controller and Driver "pair".
19 * Under the context of Linux it generally refers to an interrupt handler.
20 * However, it correctly describes the 'HOST'
22 * The amount of data needed to be transfered as predefined in the
23 * setup of the device.
25 * The 'DATA BLOCK' associated to the 'DATA HANDLER', and can be as
26 * small as a single sector or as large as the entire command block
30 #include <linux/config.h>
31 #include <linux/module.h>
32 #include <linux/types.h>
33 #include <linux/string.h>
34 #include <linux/kernel.h>
35 #include <linux/timer.h>
37 #include <linux/interrupt.h>
38 #include <linux/major.h>
39 #include <linux/errno.h>
40 #include <linux/genhd.h>
41 #include <linux/blkpg.h>
42 #include <linux/slab.h>
43 #include <linux/pci.h>
44 #include <linux/delay.h>
45 #include <linux/hdreg.h>
46 #include <linux/ide.h>
47 #include <linux/bitops.h>
49 #include <asm/byteorder.h>
51 #include <asm/uaccess.h>
54 #define DEBUG_TASKFILE 0 /* unset when fixed */
56 static void ata_bswap_data (void *buffer
, int wcount
)
61 *p
= *p
<< 8 | *p
>> 8; p
++;
62 *p
= *p
<< 8 | *p
>> 8; p
++;
66 static void taskfile_input_data(ide_drive_t
*drive
, void *buffer
, u32 wcount
)
68 HWIF(drive
)->ata_input_data(drive
, buffer
, wcount
);
70 ata_bswap_data(buffer
, wcount
);
73 static void taskfile_output_data(ide_drive_t
*drive
, void *buffer
, u32 wcount
)
76 ata_bswap_data(buffer
, wcount
);
77 HWIF(drive
)->ata_output_data(drive
, buffer
, wcount
);
78 ata_bswap_data(buffer
, wcount
);
80 HWIF(drive
)->ata_output_data(drive
, buffer
, wcount
);
84 int taskfile_lib_get_identify (ide_drive_t
*drive
, u8
*buf
)
87 memset(&args
, 0, sizeof(ide_task_t
));
88 args
.tfRegister
[IDE_NSECTOR_OFFSET
] = 0x01;
89 if (drive
->media
== ide_disk
)
90 args
.tfRegister
[IDE_COMMAND_OFFSET
] = WIN_IDENTIFY
;
92 args
.tfRegister
[IDE_COMMAND_OFFSET
] = WIN_PIDENTIFY
;
93 args
.command_type
= IDE_DRIVE_TASK_IN
;
94 args
.data_phase
= TASKFILE_IN
;
95 args
.handler
= &task_in_intr
;
96 return ide_raw_taskfile(drive
, &args
, buf
);
99 ide_startstop_t
do_rw_taskfile (ide_drive_t
*drive
, ide_task_t
*task
)
101 ide_hwif_t
*hwif
= HWIF(drive
);
102 task_struct_t
*taskfile
= (task_struct_t
*) task
->tfRegister
;
103 hob_struct_t
*hobfile
= (hob_struct_t
*) task
->hobRegister
;
104 u8 HIHI
= (drive
->addressing
== 1) ? 0xE0 : 0xEF;
106 /* ALL Command Block Executions SHALL clear nIEN, unless otherwise */
107 if (IDE_CONTROL_REG
) {
109 hwif
->OUTB(drive
->ctl
, IDE_CONTROL_REG
);
111 SELECT_MASK(drive
, 0);
113 if (drive
->addressing
== 1) {
114 hwif
->OUTB(hobfile
->feature
, IDE_FEATURE_REG
);
115 hwif
->OUTB(hobfile
->sector_count
, IDE_NSECTOR_REG
);
116 hwif
->OUTB(hobfile
->sector_number
, IDE_SECTOR_REG
);
117 hwif
->OUTB(hobfile
->low_cylinder
, IDE_LCYL_REG
);
118 hwif
->OUTB(hobfile
->high_cylinder
, IDE_HCYL_REG
);
121 hwif
->OUTB(taskfile
->feature
, IDE_FEATURE_REG
);
122 hwif
->OUTB(taskfile
->sector_count
, IDE_NSECTOR_REG
);
123 hwif
->OUTB(taskfile
->sector_number
, IDE_SECTOR_REG
);
124 hwif
->OUTB(taskfile
->low_cylinder
, IDE_LCYL_REG
);
125 hwif
->OUTB(taskfile
->high_cylinder
, IDE_HCYL_REG
);
127 hwif
->OUTB((taskfile
->device_head
& HIHI
) | drive
->select
.all
, IDE_SELECT_REG
);
129 if (task
->handler
!= NULL
) {
130 if (task
->prehandler
!= NULL
) {
131 hwif
->OUTBSYNC(drive
, taskfile
->command
, IDE_COMMAND_REG
);
132 ndelay(400); /* FIXME */
133 return task
->prehandler(drive
, task
->rq
);
135 ide_execute_command(drive
, taskfile
->command
, task
->handler
, WAIT_WORSTCASE
, NULL
);
139 if (!drive
->using_dma
)
142 switch (taskfile
->command
) {
143 case WIN_WRITEDMA_ONCE
:
145 case WIN_WRITEDMA_EXT
:
146 case WIN_READDMA_ONCE
:
148 case WIN_READDMA_EXT
:
149 case WIN_IDENTIFY_DMA
:
150 if (!hwif
->dma_setup(drive
)) {
151 hwif
->dma_exec_cmd(drive
, taskfile
->command
);
152 hwif
->dma_start(drive
);
157 if (task
->handler
== NULL
)
165 * set_multmode_intr() is invoked on completion of a WIN_SETMULT cmd.
167 ide_startstop_t
set_multmode_intr (ide_drive_t
*drive
)
169 ide_hwif_t
*hwif
= HWIF(drive
);
172 if (OK_STAT(stat
= hwif
->INB(IDE_STATUS_REG
),READY_STAT
,BAD_STAT
)) {
173 drive
->mult_count
= drive
->mult_req
;
175 drive
->mult_req
= drive
->mult_count
= 0;
176 drive
->special
.b
.recalibrate
= 1;
177 (void) ide_dump_status(drive
, "set_multmode", stat
);
183 * set_geometry_intr() is invoked on completion of a WIN_SPECIFY cmd.
185 ide_startstop_t
set_geometry_intr (ide_drive_t
*drive
)
187 ide_hwif_t
*hwif
= HWIF(drive
);
191 while (((stat
= hwif
->INB(IDE_STATUS_REG
)) & BUSY_STAT
) && retries
--)
194 if (OK_STAT(stat
, READY_STAT
, BAD_STAT
))
197 if (stat
& (ERR_STAT
|DRQ_STAT
))
198 return ide_error(drive
, "set_geometry_intr", stat
);
200 if (HWGROUP(drive
)->handler
!= NULL
)
202 ide_set_handler(drive
, &set_geometry_intr
, WAIT_WORSTCASE
, NULL
);
207 * recal_intr() is invoked on completion of a WIN_RESTORE (recalibrate) cmd.
209 ide_startstop_t
recal_intr (ide_drive_t
*drive
)
211 ide_hwif_t
*hwif
= HWIF(drive
);
214 if (!OK_STAT(stat
= hwif
->INB(IDE_STATUS_REG
), READY_STAT
, BAD_STAT
))
215 return ide_error(drive
, "recal_intr", stat
);
220 * Handler for commands without a data phase
222 ide_startstop_t
task_no_data_intr (ide_drive_t
*drive
)
224 ide_task_t
*args
= HWGROUP(drive
)->rq
->special
;
225 ide_hwif_t
*hwif
= HWIF(drive
);
229 if (!OK_STAT(stat
= hwif
->INB(IDE_STATUS_REG
),READY_STAT
,BAD_STAT
)) {
230 return ide_error(drive
, "task_no_data_intr", stat
);
231 /* calls ide_end_drive_cmd */
234 ide_end_drive_cmd(drive
, stat
, hwif
->INB(IDE_ERROR_REG
));
239 EXPORT_SYMBOL(task_no_data_intr
);
241 static u8
wait_drive_not_busy(ide_drive_t
*drive
)
243 ide_hwif_t
*hwif
= HWIF(drive
);
248 * Last sector was transfered, wait until drive is ready.
249 * This can take up to 10 usec, but we will wait max 1 ms
250 * (drive_cmd_intr() waits that long).
252 while (((stat
= hwif
->INB(IDE_STATUS_REG
)) & BUSY_STAT
) && retries
--)
256 printk(KERN_ERR
"%s: drive still BUSY!\n", drive
->name
);
261 static void ide_pio_sector(ide_drive_t
*drive
, unsigned int write
)
263 ide_hwif_t
*hwif
= drive
->hwif
;
264 struct scatterlist
*sg
= hwif
->sg_table
;
266 #ifdef CONFIG_HIGHMEM
272 page
= sg
[hwif
->cursg
].page
;
273 offset
= sg
[hwif
->cursg
].offset
+ hwif
->cursg_ofs
* SECTOR_SIZE
;
275 /* get the current page and offset */
276 page
= nth_page(page
, (offset
>> PAGE_SHIFT
));
279 #ifdef CONFIG_HIGHMEM
280 local_irq_save(flags
);
282 buf
= kmap_atomic(page
, KM_BIO_SRC_IRQ
) + offset
;
287 if ((hwif
->cursg_ofs
* SECTOR_SIZE
) == sg
[hwif
->cursg
].length
) {
292 /* do the actual data transfer */
294 taskfile_output_data(drive
, buf
, SECTOR_WORDS
);
296 taskfile_input_data(drive
, buf
, SECTOR_WORDS
);
298 kunmap_atomic(buf
, KM_BIO_SRC_IRQ
);
299 #ifdef CONFIG_HIGHMEM
300 local_irq_restore(flags
);
304 static void ide_pio_multi(ide_drive_t
*drive
, unsigned int write
)
308 nsect
= min_t(unsigned int, drive
->hwif
->nleft
, drive
->mult_count
);
310 ide_pio_sector(drive
, write
);
313 static inline void ide_pio_datablock(ide_drive_t
*drive
, struct request
*rq
,
316 if (rq
->bio
) /* fs request */
319 switch (drive
->hwif
->data_phase
) {
320 case TASKFILE_MULTI_IN
:
321 case TASKFILE_MULTI_OUT
:
322 ide_pio_multi(drive
, write
);
325 ide_pio_sector(drive
, write
);
330 static ide_startstop_t
task_error(ide_drive_t
*drive
, struct request
*rq
,
331 const char *s
, u8 stat
)
334 ide_hwif_t
*hwif
= drive
->hwif
;
335 int sectors
= hwif
->nsect
- hwif
->nleft
;
337 switch (hwif
->data_phase
) {
345 case TASKFILE_MULTI_IN
:
349 case TASKFILE_MULTI_OUT
:
350 sectors
-= drive
->mult_count
;
358 drv
= *(ide_driver_t
**)rq
->rq_disk
->private_data
;
359 drv
->end_request(drive
, 1, sectors
);
362 return ide_error(drive
, s
, stat
);
365 static void task_end_request(ide_drive_t
*drive
, struct request
*rq
, u8 stat
)
367 if (rq
->flags
& REQ_DRIVE_TASKFILE
) {
368 ide_task_t
*task
= rq
->special
;
370 if (task
->tf_out_flags
.all
) {
371 u8 err
= drive
->hwif
->INB(IDE_ERROR_REG
);
372 ide_end_drive_cmd(drive
, stat
, err
);
377 ide_end_request(drive
, 1, rq
->hard_nr_sectors
);
381 * Handler for command with PIO data-in phase (Read/Read Multiple).
383 ide_startstop_t
task_in_intr (ide_drive_t
*drive
)
385 ide_hwif_t
*hwif
= drive
->hwif
;
386 struct request
*rq
= HWGROUP(drive
)->rq
;
387 u8 stat
= hwif
->INB(IDE_STATUS_REG
);
389 /* new way for dealing with premature shared PCI interrupts */
390 if (!OK_STAT(stat
, DATA_READY
, BAD_R_STAT
)) {
391 if (stat
& (ERR_STAT
| DRQ_STAT
))
392 return task_error(drive
, rq
, __FUNCTION__
, stat
);
393 /* No data yet, so wait for another IRQ. */
394 ide_set_handler(drive
, &task_in_intr
, WAIT_WORSTCASE
, NULL
);
398 ide_pio_datablock(drive
, rq
, 0);
400 /* If it was the last datablock check status and finish transfer. */
402 stat
= wait_drive_not_busy(drive
);
403 if (!OK_STAT(stat
, 0, BAD_R_STAT
))
404 return task_error(drive
, rq
, __FUNCTION__
, stat
);
405 task_end_request(drive
, rq
, stat
);
409 /* Still data left to transfer. */
410 ide_set_handler(drive
, &task_in_intr
, WAIT_WORSTCASE
, NULL
);
414 EXPORT_SYMBOL(task_in_intr
);
417 * Handler for command with PIO data-out phase (Write/Write Multiple).
419 static ide_startstop_t
task_out_intr (ide_drive_t
*drive
)
421 ide_hwif_t
*hwif
= drive
->hwif
;
422 struct request
*rq
= HWGROUP(drive
)->rq
;
423 u8 stat
= hwif
->INB(IDE_STATUS_REG
);
425 if (!OK_STAT(stat
, DRIVE_READY
, drive
->bad_wstat
))
426 return task_error(drive
, rq
, __FUNCTION__
, stat
);
428 /* Deal with unexpected ATA data phase. */
429 if (((stat
& DRQ_STAT
) == 0) ^ !hwif
->nleft
)
430 return task_error(drive
, rq
, __FUNCTION__
, stat
);
433 task_end_request(drive
, rq
, stat
);
437 /* Still data left to transfer. */
438 ide_pio_datablock(drive
, rq
, 1);
439 ide_set_handler(drive
, &task_out_intr
, WAIT_WORSTCASE
, NULL
);
444 ide_startstop_t
pre_task_out_intr (ide_drive_t
*drive
, struct request
*rq
)
446 ide_startstop_t startstop
;
448 if (ide_wait_stat(&startstop
, drive
, DATA_READY
,
449 drive
->bad_wstat
, WAIT_DRQ
)) {
450 printk(KERN_ERR
"%s: no DRQ after issuing %sWRITE%s\n",
452 drive
->hwif
->data_phase
? "MULT" : "",
453 drive
->addressing
? "_EXT" : "");
460 ide_set_handler(drive
, &task_out_intr
, WAIT_WORSTCASE
, NULL
);
461 ide_pio_datablock(drive
, rq
, 1);
465 EXPORT_SYMBOL(pre_task_out_intr
);
467 static int ide_diag_taskfile(ide_drive_t
*drive
, ide_task_t
*args
, unsigned long data_size
, u8
*buf
)
471 memset(&rq
, 0, sizeof(rq
));
472 rq
.flags
= REQ_DRIVE_TASKFILE
;
476 * (ks) We transfer currently only whole sectors.
477 * This is suffient for now. But, it would be great,
478 * if we would find a solution to transfer any size.
479 * To support special commands like READ LONG.
481 if (args
->command_type
!= IDE_DRIVE_TASK_NO_DATA
) {
483 rq
.nr_sectors
= (args
->hobRegister
[IDE_NSECTOR_OFFSET
] << 8) | args
->tfRegister
[IDE_NSECTOR_OFFSET
];
485 rq
.nr_sectors
= data_size
/ SECTOR_SIZE
;
487 if (!rq
.nr_sectors
) {
488 printk(KERN_ERR
"%s: in/out command without data\n",
493 rq
.hard_nr_sectors
= rq
.nr_sectors
;
494 rq
.hard_cur_sectors
= rq
.current_nr_sectors
= rq
.nr_sectors
;
496 if (args
->command_type
== IDE_DRIVE_TASK_RAW_WRITE
)
502 return ide_do_drive_cmd(drive
, &rq
, ide_wait
);
505 int ide_raw_taskfile (ide_drive_t
*drive
, ide_task_t
*args
, u8
*buf
)
507 return ide_diag_taskfile(drive
, args
, 0, buf
);
510 EXPORT_SYMBOL(ide_raw_taskfile
);
512 int ide_taskfile_ioctl (ide_drive_t
*drive
, unsigned int cmd
, unsigned long arg
)
514 ide_task_request_t
*req_task
;
518 task_ioreg_t
*argsptr
= args
.tfRegister
;
519 task_ioreg_t
*hobsptr
= args
.hobRegister
;
521 int tasksize
= sizeof(struct ide_task_request_s
);
524 u8 io_32bit
= drive
->io_32bit
;
525 char __user
*buf
= (char __user
*)arg
;
527 // printk("IDE Taskfile ...\n");
529 req_task
= kzalloc(tasksize
, GFP_KERNEL
);
530 if (req_task
== NULL
) return -ENOMEM
;
531 if (copy_from_user(req_task
, buf
, tasksize
)) {
536 taskout
= (int) req_task
->out_size
;
537 taskin
= (int) req_task
->in_size
;
540 int outtotal
= tasksize
;
541 outbuf
= kzalloc(taskout
, GFP_KERNEL
);
542 if (outbuf
== NULL
) {
546 if (copy_from_user(outbuf
, buf
+ outtotal
, taskout
)) {
553 int intotal
= tasksize
+ taskout
;
554 inbuf
= kzalloc(taskin
, GFP_KERNEL
);
559 if (copy_from_user(inbuf
, buf
+ intotal
, taskin
)) {
565 memset(&args
, 0, sizeof(ide_task_t
));
566 memcpy(argsptr
, req_task
->io_ports
, HDIO_DRIVE_TASK_HDR_SIZE
);
567 memcpy(hobsptr
, req_task
->hob_ports
, HDIO_DRIVE_HOB_HDR_SIZE
);
569 args
.tf_in_flags
= req_task
->in_flags
;
570 args
.tf_out_flags
= req_task
->out_flags
;
571 args
.data_phase
= req_task
->data_phase
;
572 args
.command_type
= req_task
->req_cmd
;
575 switch(req_task
->data_phase
) {
576 case TASKFILE_OUT_DMAQ
:
577 case TASKFILE_OUT_DMA
:
578 err
= ide_diag_taskfile(drive
, &args
, taskout
, outbuf
);
580 case TASKFILE_IN_DMAQ
:
581 case TASKFILE_IN_DMA
:
582 err
= ide_diag_taskfile(drive
, &args
, taskin
, inbuf
);
584 case TASKFILE_MULTI_OUT
:
585 if (!drive
->mult_count
) {
586 /* (hs): give up if multcount is not set */
587 printk(KERN_ERR
"%s: %s Multimode Write " \
588 "multcount is not set\n",
589 drive
->name
, __FUNCTION__
);
595 args
.prehandler
= &pre_task_out_intr
;
596 args
.handler
= &task_out_intr
;
597 err
= ide_diag_taskfile(drive
, &args
, taskout
, outbuf
);
599 case TASKFILE_MULTI_IN
:
600 if (!drive
->mult_count
) {
601 /* (hs): give up if multcount is not set */
602 printk(KERN_ERR
"%s: %s Multimode Read failure " \
603 "multcount is not set\n",
604 drive
->name
, __FUNCTION__
);
610 args
.handler
= &task_in_intr
;
611 err
= ide_diag_taskfile(drive
, &args
, taskin
, inbuf
);
613 case TASKFILE_NO_DATA
:
614 args
.handler
= &task_no_data_intr
;
615 err
= ide_diag_taskfile(drive
, &args
, 0, NULL
);
622 memcpy(req_task
->io_ports
, &(args
.tfRegister
), HDIO_DRIVE_TASK_HDR_SIZE
);
623 memcpy(req_task
->hob_ports
, &(args
.hobRegister
), HDIO_DRIVE_HOB_HDR_SIZE
);
624 req_task
->in_flags
= args
.tf_in_flags
;
625 req_task
->out_flags
= args
.tf_out_flags
;
627 if (copy_to_user(buf
, req_task
, tasksize
)) {
632 int outtotal
= tasksize
;
633 if (copy_to_user(buf
+ outtotal
, outbuf
, taskout
)) {
639 int intotal
= tasksize
+ taskout
;
640 if (copy_to_user(buf
+ intotal
, inbuf
, taskin
)) {
650 // printk("IDE Taskfile ioctl ended. rc = %i\n", err);
652 drive
->io_32bit
= io_32bit
;
657 int ide_wait_cmd (ide_drive_t
*drive
, u8 cmd
, u8 nsect
, u8 feature
, u8 sectors
, u8
*buf
)
664 memset(buf
, 0, 4 + SECTOR_WORDS
* 4 * sectors
);
665 ide_init_drive_cmd(&rq
);
671 return ide_do_drive_cmd(drive
, &rq
, ide_wait
);
675 * FIXME : this needs to map into at taskfile. <andre@linux-ide.org>
677 int ide_cmd_ioctl (ide_drive_t
*drive
, unsigned int cmd
, unsigned long arg
)
680 u8 args
[4], *argbuf
= args
;
685 if (NULL
== (void *) arg
) {
687 ide_init_drive_cmd(&rq
);
688 return ide_do_drive_cmd(drive
, &rq
, ide_wait
);
691 if (copy_from_user(args
, (void __user
*)arg
, 4))
694 memset(&tfargs
, 0, sizeof(ide_task_t
));
695 tfargs
.tfRegister
[IDE_FEATURE_OFFSET
] = args
[2];
696 tfargs
.tfRegister
[IDE_NSECTOR_OFFSET
] = args
[3];
697 tfargs
.tfRegister
[IDE_SECTOR_OFFSET
] = args
[1];
698 tfargs
.tfRegister
[IDE_LCYL_OFFSET
] = 0x00;
699 tfargs
.tfRegister
[IDE_HCYL_OFFSET
] = 0x00;
700 tfargs
.tfRegister
[IDE_SELECT_OFFSET
] = 0x00;
701 tfargs
.tfRegister
[IDE_COMMAND_OFFSET
] = args
[0];
704 argsize
= 4 + (SECTOR_WORDS
* 4 * args
[3]);
705 argbuf
= kzalloc(argsize
, GFP_KERNEL
);
709 if (set_transfer(drive
, &tfargs
)) {
711 if (ide_ata66_check(drive
, &tfargs
))
715 err
= ide_wait_cmd(drive
, args
[0], args
[1], args
[2], args
[3], argbuf
);
717 if (!err
&& xfer_rate
) {
718 /* active-retuning-calls future */
719 ide_set_xfer_rate(drive
, xfer_rate
);
720 ide_driveid_update(drive
);
723 if (copy_to_user((void __user
*)arg
, argbuf
, argsize
))
730 static int ide_wait_cmd_task(ide_drive_t
*drive
, u8
*buf
)
734 ide_init_drive_cmd(&rq
);
735 rq
.flags
= REQ_DRIVE_TASK
;
737 return ide_do_drive_cmd(drive
, &rq
, ide_wait
);
741 * FIXME : this needs to map into at taskfile. <andre@linux-ide.org>
743 int ide_task_ioctl (ide_drive_t
*drive
, unsigned int cmd
, unsigned long arg
)
745 void __user
*p
= (void __user
*)arg
;
747 u8 args
[7], *argbuf
= args
;
750 if (copy_from_user(args
, p
, 7))
752 err
= ide_wait_cmd_task(drive
, argbuf
);
753 if (copy_to_user(p
, argbuf
, argsize
))
759 * NOTICE: This is additions from IBM to provide a discrete interface,
760 * for selective taskregister access operations. Nice JOB Klaus!!!
761 * Glad to be able to work and co-develop this with you and IBM.
763 ide_startstop_t
flagged_taskfile (ide_drive_t
*drive
, ide_task_t
*task
)
765 ide_hwif_t
*hwif
= HWIF(drive
);
766 task_struct_t
*taskfile
= (task_struct_t
*) task
->tfRegister
;
767 hob_struct_t
*hobfile
= (hob_struct_t
*) task
->hobRegister
;
772 if (task
->data_phase
== TASKFILE_MULTI_IN
||
773 task
->data_phase
== TASKFILE_MULTI_OUT
) {
774 if (!drive
->mult_count
) {
775 printk(KERN_ERR
"%s: multimode not set!\n", drive
->name
);
781 * (ks) Check taskfile in/out flags.
782 * If set, then execute as it is defined.
783 * If not set, then define default settings.
784 * The default values are:
785 * write and read all taskfile registers (except data)
786 * write and read the hob registers (sector,nsector,lcyl,hcyl)
788 if (task
->tf_out_flags
.all
== 0) {
789 task
->tf_out_flags
.all
= IDE_TASKFILE_STD_OUT_FLAGS
;
790 if (drive
->addressing
== 1)
791 task
->tf_out_flags
.all
|= (IDE_HOB_STD_OUT_FLAGS
<< 8);
794 if (task
->tf_in_flags
.all
== 0) {
795 task
->tf_in_flags
.all
= IDE_TASKFILE_STD_IN_FLAGS
;
796 if (drive
->addressing
== 1)
797 task
->tf_in_flags
.all
|= (IDE_HOB_STD_IN_FLAGS
<< 8);
800 /* ALL Command Block Executions SHALL clear nIEN, unless otherwise */
803 hwif
->OUTB(drive
->ctl
, IDE_CONTROL_REG
);
804 SELECT_MASK(drive
, 0);
807 status
= hwif
->INB(IDE_STATUS_REG
);
809 printk("flagged_taskfile -> Bad status. Status = %02x. wait 100 usec ...\n", status
);
811 status
= hwif
->INB(IDE_STATUS_REG
);
812 printk("flagged_taskfile -> Status = %02x\n", status
);
816 if (task
->tf_out_flags
.b
.data
) {
817 u16 data
= taskfile
->data
+ (hobfile
->data
<< 8);
818 hwif
->OUTW(data
, IDE_DATA_REG
);
821 /* (ks) send hob registers first */
822 if (task
->tf_out_flags
.b
.nsector_hob
)
823 hwif
->OUTB(hobfile
->sector_count
, IDE_NSECTOR_REG
);
824 if (task
->tf_out_flags
.b
.sector_hob
)
825 hwif
->OUTB(hobfile
->sector_number
, IDE_SECTOR_REG
);
826 if (task
->tf_out_flags
.b
.lcyl_hob
)
827 hwif
->OUTB(hobfile
->low_cylinder
, IDE_LCYL_REG
);
828 if (task
->tf_out_flags
.b
.hcyl_hob
)
829 hwif
->OUTB(hobfile
->high_cylinder
, IDE_HCYL_REG
);
831 /* (ks) Send now the standard registers */
832 if (task
->tf_out_flags
.b
.error_feature
)
833 hwif
->OUTB(taskfile
->feature
, IDE_FEATURE_REG
);
834 /* refers to number of sectors to transfer */
835 if (task
->tf_out_flags
.b
.nsector
)
836 hwif
->OUTB(taskfile
->sector_count
, IDE_NSECTOR_REG
);
837 /* refers to sector offset or start sector */
838 if (task
->tf_out_flags
.b
.sector
)
839 hwif
->OUTB(taskfile
->sector_number
, IDE_SECTOR_REG
);
840 if (task
->tf_out_flags
.b
.lcyl
)
841 hwif
->OUTB(taskfile
->low_cylinder
, IDE_LCYL_REG
);
842 if (task
->tf_out_flags
.b
.hcyl
)
843 hwif
->OUTB(taskfile
->high_cylinder
, IDE_HCYL_REG
);
846 * (ks) In the flagged taskfile approch, we will use all specified
847 * registers and the register value will not be changed, except the
848 * select bit (master/slave) in the drive_head register. We must make
849 * sure that the desired drive is selected.
851 hwif
->OUTB(taskfile
->device_head
| drive
->select
.all
, IDE_SELECT_REG
);
852 switch(task
->data_phase
) {
854 case TASKFILE_OUT_DMAQ
:
855 case TASKFILE_OUT_DMA
:
856 case TASKFILE_IN_DMAQ
:
857 case TASKFILE_IN_DMA
:
858 hwif
->dma_setup(drive
);
859 hwif
->dma_exec_cmd(drive
, taskfile
->command
);
860 hwif
->dma_start(drive
);
864 if (task
->handler
== NULL
)
867 /* Issue the command */
868 if (task
->prehandler
) {
869 hwif
->OUTBSYNC(drive
, taskfile
->command
, IDE_COMMAND_REG
);
870 ndelay(400); /* FIXME */
871 return task
->prehandler(drive
, task
->rq
);
873 ide_execute_command(drive
, taskfile
->command
, task
->handler
, WAIT_WORSTCASE
, NULL
);