2 * Copyright (C) 2000-2002 Michael Cornwell <cornwell@acm.org>
3 * Copyright (C) 2000-2002 Andre Hedrick <andre@linux-ide.org>
4 * Copyright (C) 2001-2002 Klaus Smolin
5 * IBM Storage Technology Division
6 * Copyright (C) 2003-2004, 2007 Bartlomiej Zolnierkiewicz
8 * The big the bad and the ugly.
11 #include <linux/types.h>
12 #include <linux/string.h>
13 #include <linux/kernel.h>
14 #include <linux/sched.h>
15 #include <linux/interrupt.h>
16 #include <linux/errno.h>
17 #include <linux/slab.h>
18 #include <linux/delay.h>
19 #include <linux/hdreg.h>
20 #include <linux/ide.h>
21 #include <linux/scatterlist.h>
22 #include <linux/uaccess.h>
26 void ide_tf_readback(ide_drive_t
*drive
, struct ide_cmd
*cmd
)
28 ide_hwif_t
*hwif
= drive
->hwif
;
29 const struct ide_tp_ops
*tp_ops
= hwif
->tp_ops
;
31 /* Be sure we're looking at the low order bytes */
32 tp_ops
->write_devctl(hwif
, ATA_DEVCTL_OBS
);
34 tp_ops
->tf_read(drive
, &cmd
->tf
, cmd
->valid
.in
.tf
);
36 if (cmd
->tf_flags
& IDE_TFLAG_LBA48
) {
37 tp_ops
->write_devctl(hwif
, ATA_HOB
| ATA_DEVCTL_OBS
);
39 tp_ops
->tf_read(drive
, &cmd
->hob
, cmd
->valid
.in
.hob
);
43 void ide_tf_dump(const char *s
, struct ide_cmd
*cmd
)
46 printk("%s: tf: feat 0x%02x nsect 0x%02x lbal 0x%02x "
47 "lbam 0x%02x lbah 0x%02x dev 0x%02x cmd 0x%02x\n",
48 s
, cmd
->tf
.feature
, cmd
->tf
.nsect
,
49 cmd
->tf
.lbal
, cmd
->tf
.lbam
, cmd
->tf
.lbah
,
50 cmd
->tf
.device
, cmd
->tf
.command
);
51 printk("%s: hob: nsect 0x%02x lbal 0x%02x lbam 0x%02x lbah 0x%02x\n",
52 s
, cmd
->hob
.nsect
, cmd
->hob
.lbal
, cmd
->hob
.lbam
, cmd
->hob
.lbah
);
56 int taskfile_lib_get_identify(ide_drive_t
*drive
, u8
*buf
)
60 memset(&cmd
, 0, sizeof(cmd
));
62 if (drive
->media
== ide_disk
)
63 cmd
.tf
.command
= ATA_CMD_ID_ATA
;
65 cmd
.tf
.command
= ATA_CMD_ID_ATAPI
;
66 cmd
.valid
.out
.tf
= IDE_VALID_OUT_TF
| IDE_VALID_DEVICE
;
67 cmd
.valid
.in
.tf
= IDE_VALID_IN_TF
| IDE_VALID_DEVICE
;
68 cmd
.protocol
= ATA_PROT_PIO
;
70 return ide_raw_taskfile(drive
, &cmd
, buf
, 1);
73 static ide_startstop_t
task_no_data_intr(ide_drive_t
*);
74 static ide_startstop_t
pre_task_out_intr(ide_drive_t
*, struct ide_cmd
*);
75 static ide_startstop_t
task_pio_intr(ide_drive_t
*);
77 ide_startstop_t
do_rw_taskfile(ide_drive_t
*drive
, struct ide_cmd
*orig_cmd
)
79 ide_hwif_t
*hwif
= drive
->hwif
;
80 struct ide_cmd
*cmd
= &hwif
->cmd
;
81 struct ide_taskfile
*tf
= &cmd
->tf
;
82 ide_handler_t
*handler
= NULL
;
83 const struct ide_tp_ops
*tp_ops
= hwif
->tp_ops
;
84 const struct ide_dma_ops
*dma_ops
= hwif
->dma_ops
;
86 if (orig_cmd
->protocol
== ATA_PROT_PIO
&&
87 (orig_cmd
->tf_flags
& IDE_TFLAG_MULTI_PIO
) &&
88 drive
->mult_count
== 0) {
89 pr_err("%s: multimode not set!\n", drive
->name
);
93 if (orig_cmd
->ftf_flags
& IDE_FTFLAG_FLAGGED
)
94 orig_cmd
->ftf_flags
|= IDE_FTFLAG_SET_IN_FLAGS
;
96 memcpy(cmd
, orig_cmd
, sizeof(*cmd
));
98 if ((cmd
->tf_flags
& IDE_TFLAG_DMA_PIO_FALLBACK
) == 0) {
99 ide_tf_dump(drive
->name
, cmd
);
100 tp_ops
->write_devctl(hwif
, ATA_DEVCTL_OBS
);
102 if (cmd
->ftf_flags
& IDE_FTFLAG_OUT_DATA
) {
103 u8 data
[2] = { cmd
->tf
.data
, cmd
->hob
.data
};
105 tp_ops
->output_data(drive
, cmd
, data
, 2);
108 if (cmd
->valid
.out
.tf
& IDE_VALID_DEVICE
) {
109 u8 HIHI
= (cmd
->tf_flags
& IDE_TFLAG_LBA48
) ?
112 if (!(cmd
->ftf_flags
& IDE_FTFLAG_FLAGGED
))
113 cmd
->tf
.device
&= HIHI
;
114 cmd
->tf
.device
|= drive
->select
;
117 tp_ops
->tf_load(drive
, &cmd
->hob
, cmd
->valid
.out
.hob
);
118 tp_ops
->tf_load(drive
, &cmd
->tf
, cmd
->valid
.out
.tf
);
121 switch (cmd
->protocol
) {
123 if (cmd
->tf_flags
& IDE_TFLAG_WRITE
) {
124 tp_ops
->exec_command(hwif
, tf
->command
);
125 ndelay(400); /* FIXME */
126 return pre_task_out_intr(drive
, cmd
);
128 handler
= task_pio_intr
;
130 case ATA_PROT_NODATA
:
132 handler
= task_no_data_intr
;
133 ide_execute_command(drive
, cmd
, handler
, WAIT_WORSTCASE
);
136 if (ide_dma_prepare(drive
, cmd
))
138 hwif
->expiry
= dma_ops
->dma_timer_expiry
;
139 ide_execute_command(drive
, cmd
, ide_dma_intr
, 2 * WAIT_CMD
);
140 dma_ops
->dma_start(drive
);
145 EXPORT_SYMBOL_GPL(do_rw_taskfile
);
147 static ide_startstop_t
task_no_data_intr(ide_drive_t
*drive
)
149 ide_hwif_t
*hwif
= drive
->hwif
;
150 struct ide_cmd
*cmd
= &hwif
->cmd
;
151 struct ide_taskfile
*tf
= &cmd
->tf
;
152 int custom
= (cmd
->tf_flags
& IDE_TFLAG_CUSTOM_HANDLER
) ? 1 : 0;
153 int retries
= (custom
&& tf
->command
== ATA_CMD_INIT_DEV_PARAMS
) ? 5 : 1;
156 local_irq_enable_in_hardirq();
159 stat
= hwif
->tp_ops
->read_status(hwif
);
160 if ((stat
& ATA_BUSY
) == 0 || retries
-- == 0)
165 if (!OK_STAT(stat
, ATA_DRDY
, BAD_STAT
)) {
166 if (custom
&& tf
->command
== ATA_CMD_SET_MULTI
) {
167 drive
->mult_req
= drive
->mult_count
= 0;
168 drive
->special_flags
|= IDE_SFLAG_RECALIBRATE
;
169 (void)ide_dump_status(drive
, __func__
, stat
);
171 } else if (custom
&& tf
->command
== ATA_CMD_INIT_DEV_PARAMS
) {
172 if ((stat
& (ATA_ERR
| ATA_DRQ
)) == 0) {
173 ide_set_handler(drive
, &task_no_data_intr
,
178 return ide_error(drive
, "task_no_data_intr", stat
);
181 if (custom
&& tf
->command
== ATA_CMD_SET_MULTI
)
182 drive
->mult_count
= drive
->mult_req
;
184 if (custom
== 0 || tf
->command
== ATA_CMD_IDLEIMMEDIATE
||
185 tf
->command
== ATA_CMD_CHK_POWER
) {
186 struct request
*rq
= hwif
->rq
;
188 if (blk_pm_request(rq
))
189 ide_complete_pm_rq(drive
, rq
);
191 ide_finish_cmd(drive
, cmd
, stat
);
197 static u8
wait_drive_not_busy(ide_drive_t
*drive
)
199 ide_hwif_t
*hwif
= drive
->hwif
;
204 * Last sector was transfered, wait until device is ready. This can
205 * take up to 6 ms on some ATAPI devices, so we will wait max 10 ms.
207 for (retries
= 0; retries
< 1000; retries
++) {
208 stat
= hwif
->tp_ops
->read_status(hwif
);
217 pr_err("%s: drive still BUSY!\n", drive
->name
);
222 void ide_pio_bytes(ide_drive_t
*drive
, struct ide_cmd
*cmd
,
223 unsigned int write
, unsigned int len
)
225 ide_hwif_t
*hwif
= drive
->hwif
;
226 struct scatterlist
*sg
= hwif
->sg_table
;
227 struct scatterlist
*cursg
= cmd
->cursg
;
228 unsigned long uninitialized_var(flags
);
235 cursg
= cmd
->cursg
= sg
;
238 unsigned nr_bytes
= min(len
, cursg
->length
- cmd
->cursg_ofs
);
241 if (nr_bytes
> PAGE_SIZE
)
242 nr_bytes
= PAGE_SIZE
;
244 page
= sg_page(cursg
);
245 offset
= cursg
->offset
+ cmd
->cursg_ofs
;
247 /* get the current page and offset */
248 page
= nth_page(page
, (offset
>> PAGE_SHIFT
));
251 page_is_high
= PageHighMem(page
);
253 local_irq_save(flags
);
255 buf
= kmap_atomic(page
, KM_BIO_SRC_IRQ
) + offset
;
257 cmd
->nleft
-= nr_bytes
;
258 cmd
->cursg_ofs
+= nr_bytes
;
260 if (cmd
->cursg_ofs
== cursg
->length
) {
261 cursg
= cmd
->cursg
= sg_next(cmd
->cursg
);
265 /* do the actual data transfer */
267 hwif
->tp_ops
->output_data(drive
, cmd
, buf
, nr_bytes
);
269 hwif
->tp_ops
->input_data(drive
, cmd
, buf
, nr_bytes
);
271 kunmap_atomic(buf
, KM_BIO_SRC_IRQ
);
274 local_irq_restore(flags
);
279 EXPORT_SYMBOL_GPL(ide_pio_bytes
);
281 static void ide_pio_datablock(ide_drive_t
*drive
, struct ide_cmd
*cmd
,
284 unsigned int nr_bytes
;
286 u8 saved_io_32bit
= drive
->io_32bit
;
288 if (cmd
->tf_flags
& IDE_TFLAG_FS
)
291 if (cmd
->tf_flags
& IDE_TFLAG_IO_16BIT
)
294 touch_softlockup_watchdog();
296 if (cmd
->tf_flags
& IDE_TFLAG_MULTI_PIO
)
297 nr_bytes
= min_t(unsigned, cmd
->nleft
, drive
->mult_count
<< 9);
299 nr_bytes
= SECTOR_SIZE
;
301 ide_pio_bytes(drive
, cmd
, write
, nr_bytes
);
303 drive
->io_32bit
= saved_io_32bit
;
306 static void ide_error_cmd(ide_drive_t
*drive
, struct ide_cmd
*cmd
)
308 if (cmd
->tf_flags
& IDE_TFLAG_FS
) {
309 int nr_bytes
= cmd
->nbytes
- cmd
->nleft
;
311 if (cmd
->protocol
== ATA_PROT_PIO
&&
312 ((cmd
->tf_flags
& IDE_TFLAG_WRITE
) || cmd
->nleft
== 0)) {
313 if (cmd
->tf_flags
& IDE_TFLAG_MULTI_PIO
)
314 nr_bytes
-= drive
->mult_count
<< 9;
316 nr_bytes
-= SECTOR_SIZE
;
320 ide_complete_rq(drive
, 0, nr_bytes
);
324 void ide_finish_cmd(ide_drive_t
*drive
, struct ide_cmd
*cmd
, u8 stat
)
326 struct request
*rq
= drive
->hwif
->rq
;
327 u8 err
= ide_read_error(drive
);
329 ide_complete_cmd(drive
, cmd
, stat
, err
);
331 ide_complete_rq(drive
, err
? -EIO
: 0, blk_rq_bytes(rq
));
335 * Handler for command with PIO data phase.
337 static ide_startstop_t
task_pio_intr(ide_drive_t
*drive
)
339 ide_hwif_t
*hwif
= drive
->hwif
;
340 struct ide_cmd
*cmd
= &drive
->hwif
->cmd
;
341 u8 stat
= hwif
->tp_ops
->read_status(hwif
);
342 u8 write
= !!(cmd
->tf_flags
& IDE_TFLAG_WRITE
);
349 /* Didn't want any data? Odd. */
350 if ((stat
& ATA_DRQ
) == 0) {
351 /* Command all done? */
352 if (OK_STAT(stat
, ATA_DRDY
, ATA_BUSY
))
355 /* Assume it was a spurious irq */
359 if (!OK_STAT(stat
, DRIVE_READY
, drive
->bad_wstat
))
362 /* Deal with unexpected ATA data phase. */
363 if (((stat
& ATA_DRQ
) == 0) ^ (cmd
->nleft
== 0))
367 if (write
&& cmd
->nleft
== 0)
370 /* Still data left to transfer. */
371 ide_pio_datablock(drive
, cmd
, write
);
373 /* Are we done? Check status and finish transfer. */
374 if (write
== 0 && cmd
->nleft
== 0) {
375 stat
= wait_drive_not_busy(drive
);
376 if (!OK_STAT(stat
, 0, BAD_STAT
))
382 /* Still data left to transfer. */
383 ide_set_handler(drive
, &task_pio_intr
, WAIT_WORSTCASE
);
386 if ((cmd
->tf_flags
& IDE_TFLAG_FS
) == 0)
387 ide_finish_cmd(drive
, cmd
, stat
);
389 ide_complete_rq(drive
, 0, blk_rq_sectors(cmd
->rq
) << 9);
392 ide_error_cmd(drive
, cmd
);
393 return ide_error(drive
, __func__
, stat
);
396 static ide_startstop_t
pre_task_out_intr(ide_drive_t
*drive
,
399 ide_startstop_t startstop
;
401 if (ide_wait_stat(&startstop
, drive
, ATA_DRQ
,
402 drive
->bad_wstat
, WAIT_DRQ
)) {
403 pr_err("%s: no DRQ after issuing %sWRITE%s\n", drive
->name
,
404 (cmd
->tf_flags
& IDE_TFLAG_MULTI_PIO
) ? "MULT" : "",
405 (drive
->dev_flags
& IDE_DFLAG_LBA48
) ? "_EXT" : "");
409 if ((drive
->dev_flags
& IDE_DFLAG_UNMASK
) == 0)
412 ide_set_handler(drive
, &task_pio_intr
, WAIT_WORSTCASE
);
414 ide_pio_datablock(drive
, cmd
, 1);
419 int ide_raw_taskfile(ide_drive_t
*drive
, struct ide_cmd
*cmd
, u8
*buf
,
425 rq
= blk_get_request(drive
->queue
, READ
, __GFP_WAIT
);
426 rq
->cmd_type
= REQ_TYPE_ATA_TASKFILE
;
428 if (cmd
->tf_flags
& IDE_TFLAG_WRITE
)
429 rq
->cmd_flags
|= REQ_RW
;
432 * (ks) We transfer currently only whole sectors.
433 * This is suffient for now. But, it would be great,
434 * if we would find a solution to transfer any size.
435 * To support special commands like READ LONG.
438 error
= blk_rq_map_kern(drive
->queue
, rq
, buf
,
439 nsect
* SECTOR_SIZE
, __GFP_WAIT
);
447 error
= blk_execute_rq(drive
->queue
, NULL
, rq
, 0);
453 EXPORT_SYMBOL(ide_raw_taskfile
);
455 int ide_no_data_taskfile(ide_drive_t
*drive
, struct ide_cmd
*cmd
)
457 cmd
->protocol
= ATA_PROT_NODATA
;
459 return ide_raw_taskfile(drive
, cmd
, NULL
, 0);
461 EXPORT_SYMBOL_GPL(ide_no_data_taskfile
);
463 #ifdef CONFIG_IDE_TASK_IOCTL
464 int ide_taskfile_ioctl(ide_drive_t
*drive
, unsigned long arg
)
466 ide_task_request_t
*req_task
;
472 int tasksize
= sizeof(struct ide_task_request_s
);
473 unsigned int taskin
= 0;
474 unsigned int taskout
= 0;
476 char __user
*buf
= (char __user
*)arg
;
478 req_task
= kzalloc(tasksize
, GFP_KERNEL
);
479 if (req_task
== NULL
)
481 if (copy_from_user(req_task
, buf
, tasksize
)) {
486 taskout
= req_task
->out_size
;
487 taskin
= req_task
->in_size
;
489 if (taskin
> 65536 || taskout
> 65536) {
495 int outtotal
= tasksize
;
496 outbuf
= kzalloc(taskout
, GFP_KERNEL
);
497 if (outbuf
== NULL
) {
501 if (copy_from_user(outbuf
, buf
+ outtotal
, taskout
)) {
508 int intotal
= tasksize
+ taskout
;
509 inbuf
= kzalloc(taskin
, GFP_KERNEL
);
514 if (copy_from_user(inbuf
, buf
+ intotal
, taskin
)) {
520 memset(&cmd
, 0, sizeof(cmd
));
522 memcpy(&cmd
.hob
, req_task
->hob_ports
, HDIO_DRIVE_HOB_HDR_SIZE
- 2);
523 memcpy(&cmd
.tf
, req_task
->io_ports
, HDIO_DRIVE_TASK_HDR_SIZE
);
525 cmd
.valid
.out
.tf
= IDE_VALID_DEVICE
;
526 cmd
.valid
.in
.tf
= IDE_VALID_DEVICE
| IDE_VALID_IN_TF
;
527 cmd
.tf_flags
= IDE_TFLAG_IO_16BIT
;
529 if (drive
->dev_flags
& IDE_DFLAG_LBA48
) {
530 cmd
.tf_flags
|= IDE_TFLAG_LBA48
;
531 cmd
.valid
.in
.hob
= IDE_VALID_IN_HOB
;
534 if (req_task
->out_flags
.all
) {
535 cmd
.ftf_flags
|= IDE_FTFLAG_FLAGGED
;
537 if (req_task
->out_flags
.b
.data
)
538 cmd
.ftf_flags
|= IDE_FTFLAG_OUT_DATA
;
540 if (req_task
->out_flags
.b
.nsector_hob
)
541 cmd
.valid
.out
.hob
|= IDE_VALID_NSECT
;
542 if (req_task
->out_flags
.b
.sector_hob
)
543 cmd
.valid
.out
.hob
|= IDE_VALID_LBAL
;
544 if (req_task
->out_flags
.b
.lcyl_hob
)
545 cmd
.valid
.out
.hob
|= IDE_VALID_LBAM
;
546 if (req_task
->out_flags
.b
.hcyl_hob
)
547 cmd
.valid
.out
.hob
|= IDE_VALID_LBAH
;
549 if (req_task
->out_flags
.b
.error_feature
)
550 cmd
.valid
.out
.tf
|= IDE_VALID_FEATURE
;
551 if (req_task
->out_flags
.b
.nsector
)
552 cmd
.valid
.out
.tf
|= IDE_VALID_NSECT
;
553 if (req_task
->out_flags
.b
.sector
)
554 cmd
.valid
.out
.tf
|= IDE_VALID_LBAL
;
555 if (req_task
->out_flags
.b
.lcyl
)
556 cmd
.valid
.out
.tf
|= IDE_VALID_LBAM
;
557 if (req_task
->out_flags
.b
.hcyl
)
558 cmd
.valid
.out
.tf
|= IDE_VALID_LBAH
;
560 cmd
.valid
.out
.tf
|= IDE_VALID_OUT_TF
;
561 if (cmd
.tf_flags
& IDE_TFLAG_LBA48
)
562 cmd
.valid
.out
.hob
|= IDE_VALID_OUT_HOB
;
565 if (req_task
->in_flags
.b
.data
)
566 cmd
.ftf_flags
|= IDE_FTFLAG_IN_DATA
;
568 if (req_task
->req_cmd
== IDE_DRIVE_TASK_RAW_WRITE
) {
569 /* fixup data phase if needed */
570 if (req_task
->data_phase
== TASKFILE_IN_DMAQ
||
571 req_task
->data_phase
== TASKFILE_IN_DMA
)
572 cmd
.tf_flags
|= IDE_TFLAG_WRITE
;
575 cmd
.protocol
= ATA_PROT_DMA
;
577 switch (req_task
->data_phase
) {
578 case TASKFILE_MULTI_OUT
:
579 if (!drive
->mult_count
) {
580 /* (hs): give up if multcount is not set */
581 pr_err("%s: %s Multimode Write multcount is not set\n",
582 drive
->name
, __func__
);
586 cmd
.tf_flags
|= IDE_TFLAG_MULTI_PIO
;
589 cmd
.protocol
= ATA_PROT_PIO
;
591 case TASKFILE_OUT_DMAQ
:
592 case TASKFILE_OUT_DMA
:
593 cmd
.tf_flags
|= IDE_TFLAG_WRITE
;
594 nsect
= taskout
/ SECTOR_SIZE
;
597 case TASKFILE_MULTI_IN
:
598 if (!drive
->mult_count
) {
599 /* (hs): give up if multcount is not set */
600 pr_err("%s: %s Multimode Read multcount is not set\n",
601 drive
->name
, __func__
);
605 cmd
.tf_flags
|= IDE_TFLAG_MULTI_PIO
;
608 cmd
.protocol
= ATA_PROT_PIO
;
610 case TASKFILE_IN_DMAQ
:
611 case TASKFILE_IN_DMA
:
612 nsect
= taskin
/ SECTOR_SIZE
;
615 case TASKFILE_NO_DATA
:
616 cmd
.protocol
= ATA_PROT_NODATA
;
623 if (req_task
->req_cmd
== IDE_DRIVE_TASK_NO_DATA
)
626 nsect
= (cmd
.hob
.nsect
<< 8) | cmd
.tf
.nsect
;
629 pr_err("%s: in/out command without data\n",
636 err
= ide_raw_taskfile(drive
, &cmd
, data_buf
, nsect
);
638 memcpy(req_task
->hob_ports
, &cmd
.hob
, HDIO_DRIVE_HOB_HDR_SIZE
- 2);
639 memcpy(req_task
->io_ports
, &cmd
.tf
, HDIO_DRIVE_TASK_HDR_SIZE
);
641 if ((cmd
.ftf_flags
& IDE_FTFLAG_SET_IN_FLAGS
) &&
642 req_task
->in_flags
.all
== 0) {
643 req_task
->in_flags
.all
= IDE_TASKFILE_STD_IN_FLAGS
;
644 if (drive
->dev_flags
& IDE_DFLAG_LBA48
)
645 req_task
->in_flags
.all
|= (IDE_HOB_STD_IN_FLAGS
<< 8);
648 if (copy_to_user(buf
, req_task
, tasksize
)) {
653 int outtotal
= tasksize
;
654 if (copy_to_user(buf
+ outtotal
, outbuf
, taskout
)) {
660 int intotal
= tasksize
+ taskout
;
661 if (copy_to_user(buf
+ intotal
, inbuf
, taskin
)) {