5 #include <linux/kernel.h>
6 #include <linux/cdrom.h>
7 #include <linux/delay.h>
9 #include <linux/scatterlist.h>
11 #include <scsi/scsi.h>
14 #define debug_log(fmt, args...) \
15 printk(KERN_INFO "ide: " fmt, ## args)
17 #define debug_log(fmt, args...) do {} while (0)
20 #define ATAPI_MIN_CDB_BYTES 12
22 static inline int dev_is_idecd(ide_drive_t
*drive
)
24 return drive
->media
== ide_cdrom
|| drive
->media
== ide_optical
;
28 * Check whether we can support a device,
29 * based on the ATAPI IDENTIFY command results.
31 int ide_check_atapi_device(ide_drive_t
*drive
, const char *s
)
34 u8 gcw
[2], protocol
, device_type
, removable
, drq_type
, packet_size
;
36 *((u16
*)&gcw
) = id
[ATA_ID_CONFIG
];
38 protocol
= (gcw
[1] & 0xC0) >> 6;
39 device_type
= gcw
[1] & 0x1F;
40 removable
= (gcw
[0] & 0x80) >> 7;
41 drq_type
= (gcw
[0] & 0x60) >> 5;
42 packet_size
= gcw
[0] & 0x03;
45 /* kludge for Apple PowerBook internal zip */
46 if (drive
->media
== ide_floppy
&& device_type
== 5 &&
47 !strstr((char *)&id
[ATA_ID_PROD
], "CD-ROM") &&
48 strstr((char *)&id
[ATA_ID_PROD
], "ZIP"))
53 printk(KERN_ERR
"%s: %s: protocol (0x%02x) is not ATAPI\n",
54 s
, drive
->name
, protocol
);
55 else if ((drive
->media
== ide_floppy
&& device_type
!= 0) ||
56 (drive
->media
== ide_tape
&& device_type
!= 1))
57 printk(KERN_ERR
"%s: %s: invalid device type (0x%02x)\n",
58 s
, drive
->name
, device_type
);
59 else if (removable
== 0)
60 printk(KERN_ERR
"%s: %s: the removable flag is not set\n",
62 else if (drive
->media
== ide_floppy
&& drq_type
== 3)
63 printk(KERN_ERR
"%s: %s: sorry, DRQ type (0x%02x) not "
64 "supported\n", s
, drive
->name
, drq_type
);
65 else if (packet_size
!= 0)
66 printk(KERN_ERR
"%s: %s: packet size (0x%02x) is not 12 "
67 "bytes\n", s
, drive
->name
, packet_size
);
72 EXPORT_SYMBOL_GPL(ide_check_atapi_device
);
74 void ide_init_pc(struct ide_atapi_pc
*pc
)
76 memset(pc
, 0, sizeof(*pc
));
78 EXPORT_SYMBOL_GPL(ide_init_pc
);
81 * Add a special packet command request to the tail of the request queue,
82 * and wait for it to be serviced.
84 int ide_queue_pc_tail(ide_drive_t
*drive
, struct gendisk
*disk
,
85 struct ide_atapi_pc
*pc
, void *buf
, unsigned int bufflen
)
90 rq
= blk_get_request(drive
->queue
, READ
, __GFP_WAIT
);
91 rq
->cmd_type
= REQ_TYPE_SPECIAL
;
92 rq
->special
= (char *)pc
;
95 error
= blk_rq_map_kern(drive
->queue
, rq
, buf
, bufflen
,
101 memcpy(rq
->cmd
, pc
->c
, 12);
102 if (drive
->media
== ide_tape
)
103 rq
->cmd
[13] = REQ_IDETAPE_PC1
;
104 error
= blk_execute_rq(drive
->queue
, disk
, rq
, 0);
109 EXPORT_SYMBOL_GPL(ide_queue_pc_tail
);
111 int ide_do_test_unit_ready(ide_drive_t
*drive
, struct gendisk
*disk
)
113 struct ide_atapi_pc pc
;
116 pc
.c
[0] = TEST_UNIT_READY
;
118 return ide_queue_pc_tail(drive
, disk
, &pc
, NULL
, 0);
120 EXPORT_SYMBOL_GPL(ide_do_test_unit_ready
);
122 int ide_do_start_stop(ide_drive_t
*drive
, struct gendisk
*disk
, int start
)
124 struct ide_atapi_pc pc
;
127 pc
.c
[0] = START_STOP
;
130 if (drive
->media
== ide_tape
)
131 pc
.flags
|= PC_FLAG_WAIT_FOR_DSC
;
133 return ide_queue_pc_tail(drive
, disk
, &pc
, NULL
, 0);
135 EXPORT_SYMBOL_GPL(ide_do_start_stop
);
137 int ide_set_media_lock(ide_drive_t
*drive
, struct gendisk
*disk
, int on
)
139 struct ide_atapi_pc pc
;
141 if ((drive
->dev_flags
& IDE_DFLAG_DOORLOCKING
) == 0)
145 pc
.c
[0] = ALLOW_MEDIUM_REMOVAL
;
148 return ide_queue_pc_tail(drive
, disk
, &pc
, NULL
, 0);
150 EXPORT_SYMBOL_GPL(ide_set_media_lock
);
152 void ide_create_request_sense_cmd(ide_drive_t
*drive
, struct ide_atapi_pc
*pc
)
155 pc
->c
[0] = REQUEST_SENSE
;
156 if (drive
->media
== ide_floppy
) {
164 EXPORT_SYMBOL_GPL(ide_create_request_sense_cmd
);
166 void ide_prep_sense(ide_drive_t
*drive
, struct request
*rq
)
168 struct request_sense
*sense
= &drive
->sense_data
;
169 struct request
*sense_rq
= &drive
->sense_rq
;
170 unsigned int cmd_len
, sense_len
;
173 switch (drive
->media
) {
187 BUG_ON(sense_len
> sizeof(*sense
));
189 if (blk_sense_request(rq
) || drive
->sense_rq_armed
)
192 memset(sense
, 0, sizeof(*sense
));
194 blk_rq_init(rq
->q
, sense_rq
);
196 err
= blk_rq_map_kern(drive
->queue
, sense_rq
, sense
, sense_len
,
199 if (printk_ratelimit())
200 printk(KERN_WARNING
"%s: failed to map sense buffer\n",
205 sense_rq
->rq_disk
= rq
->rq_disk
;
206 sense_rq
->cmd
[0] = GPCMD_REQUEST_SENSE
;
207 sense_rq
->cmd
[4] = cmd_len
;
208 sense_rq
->cmd_type
= REQ_TYPE_SENSE
;
209 sense_rq
->cmd_flags
|= REQ_PREEMPT
;
211 if (drive
->media
== ide_tape
)
212 sense_rq
->cmd
[13] = REQ_IDETAPE_PC1
;
214 drive
->sense_rq_armed
= true;
216 EXPORT_SYMBOL_GPL(ide_prep_sense
);
218 int ide_queue_sense_rq(ide_drive_t
*drive
, void *special
)
220 /* deferred failure from ide_prep_sense() */
221 if (!drive
->sense_rq_armed
) {
222 printk(KERN_WARNING
"%s: failed queue sense request\n",
227 drive
->sense_rq
.special
= special
;
228 drive
->sense_rq_armed
= false;
230 drive
->hwif
->rq
= NULL
;
232 elv_add_request(drive
->queue
, &drive
->sense_rq
,
233 ELEVATOR_INSERT_FRONT
, 0);
236 EXPORT_SYMBOL_GPL(ide_queue_sense_rq
);
239 * Called when an error was detected during the last packet command.
240 * We queue a request sense packet command at the head of the request
243 void ide_retry_pc(ide_drive_t
*drive
)
245 struct request
*failed_rq
= drive
->hwif
->rq
;
246 struct request
*sense_rq
= &drive
->sense_rq
;
247 struct ide_atapi_pc
*pc
= &drive
->request_sense_pc
;
249 (void)ide_read_error(drive
);
251 /* init pc from sense_rq */
253 memcpy(pc
->c
, sense_rq
->cmd
, 12);
255 if (drive
->media
== ide_tape
)
256 set_bit(IDE_AFLAG_IGNORE_DSC
, &drive
->atapi_flags
);
259 * Push back the failed request and put request sense on top
260 * of it. The failed command will be retried after sense data
263 blk_requeue_request(failed_rq
->q
, failed_rq
);
264 drive
->hwif
->rq
= NULL
;
265 if (ide_queue_sense_rq(drive
, pc
)) {
266 blk_start_request(failed_rq
);
267 ide_complete_rq(drive
, -EIO
, blk_rq_bytes(failed_rq
));
270 EXPORT_SYMBOL_GPL(ide_retry_pc
);
272 int ide_cd_expiry(ide_drive_t
*drive
)
274 struct request
*rq
= drive
->hwif
->rq
;
275 unsigned long wait
= 0;
277 debug_log("%s: rq->cmd[0]: 0x%x\n", __func__
, rq
->cmd
[0]);
280 * Some commands are *slow* and normally take a long time to complete.
281 * Usually we can use the ATAPI "disconnect" to bypass this, but not all
282 * commands/drives support that. Let ide_timer_expiry keep polling us
285 switch (rq
->cmd
[0]) {
287 case GPCMD_FORMAT_UNIT
:
288 case GPCMD_RESERVE_RZONE_TRACK
:
289 case GPCMD_CLOSE_TRACK
:
290 case GPCMD_FLUSH_CACHE
:
291 wait
= ATAPI_WAIT_PC
;
294 if (!(rq
->cmd_flags
& REQ_QUIET
))
295 printk(KERN_INFO
"cmd 0x%x timed out\n",
302 EXPORT_SYMBOL_GPL(ide_cd_expiry
);
304 int ide_cd_get_xferlen(struct request
*rq
)
306 if (blk_fs_request(rq
))
308 else if (blk_sense_request(rq
) || blk_pc_request(rq
) ||
309 rq
->cmd_type
== REQ_TYPE_ATA_PC
)
310 return blk_rq_bytes(rq
);
314 EXPORT_SYMBOL_GPL(ide_cd_get_xferlen
);
316 void ide_read_bcount_and_ireason(ide_drive_t
*drive
, u16
*bcount
, u8
*ireason
)
318 struct ide_taskfile tf
;
320 drive
->hwif
->tp_ops
->tf_read(drive
, &tf
, IDE_VALID_NSECT
|
321 IDE_VALID_LBAM
| IDE_VALID_LBAH
);
323 *bcount
= (tf
.lbah
<< 8) | tf
.lbam
;
324 *ireason
= tf
.nsect
& 3;
326 EXPORT_SYMBOL_GPL(ide_read_bcount_and_ireason
);
329 * This is the usual interrupt handler which will be called during a packet
330 * command. We will transfer some of the data (as requested by the drive)
331 * and will re-point interrupt handler to us.
333 static ide_startstop_t
ide_pc_intr(ide_drive_t
*drive
)
335 struct ide_atapi_pc
*pc
= drive
->pc
;
336 ide_hwif_t
*hwif
= drive
->hwif
;
337 struct ide_cmd
*cmd
= &hwif
->cmd
;
338 struct request
*rq
= hwif
->rq
;
339 const struct ide_tp_ops
*tp_ops
= hwif
->tp_ops
;
340 unsigned int timeout
, done
;
342 u8 stat
, ireason
, dsc
= 0;
343 u8 write
= !!(pc
->flags
& PC_FLAG_WRITING
);
345 debug_log("Enter %s - interrupt handler\n", __func__
);
347 timeout
= (drive
->media
== ide_floppy
) ? WAIT_FLOPPY_CMD
350 /* Clear the interrupt */
351 stat
= tp_ops
->read_status(hwif
);
353 if (pc
->flags
& PC_FLAG_DMA_IN_PROGRESS
) {
356 drive
->waiting_for_dma
= 0;
357 rc
= hwif
->dma_ops
->dma_end(drive
);
358 ide_dma_unmap_sg(drive
, cmd
);
360 if (rc
|| (drive
->media
== ide_tape
&& (stat
& ATA_ERR
))) {
361 if (drive
->media
== ide_floppy
)
362 printk(KERN_ERR
"%s: DMA %s error\n",
363 drive
->name
, rq_data_dir(pc
->rq
)
365 pc
->flags
|= PC_FLAG_DMA_ERROR
;
368 debug_log("%s: DMA finished\n", drive
->name
);
371 /* No more interrupts */
372 if ((stat
& ATA_DRQ
) == 0) {
375 debug_log("Packet command completed, %d bytes transferred\n",
378 pc
->flags
&= ~PC_FLAG_DMA_IN_PROGRESS
;
380 local_irq_enable_in_hardirq();
382 if (drive
->media
== ide_tape
&&
383 (stat
& ATA_ERR
) && rq
->cmd
[0] == REQUEST_SENSE
)
386 if ((stat
& ATA_ERR
) || (pc
->flags
& PC_FLAG_DMA_ERROR
)) {
388 debug_log("%s: I/O error\n", drive
->name
);
390 if (drive
->media
!= ide_tape
)
393 if (rq
->cmd
[0] == REQUEST_SENSE
) {
394 printk(KERN_ERR
"%s: I/O error in request sense"
395 " command\n", drive
->name
);
396 return ide_do_reset(drive
);
399 debug_log("[cmd %x]: check condition\n", rq
->cmd
[0]);
401 /* Retry operation */
404 /* queued, but not started */
409 if ((pc
->flags
& PC_FLAG_WAIT_FOR_DSC
) && (stat
& ATA_DSC
) == 0)
412 /* Command finished - Call the callback function */
413 uptodate
= drive
->pc_callback(drive
, dsc
);
416 drive
->failed_pc
= NULL
;
418 if (blk_special_request(rq
)) {
423 if (blk_fs_request(rq
) == 0 && uptodate
<= 0) {
428 error
= uptodate
? 0 : -EIO
;
431 ide_complete_rq(drive
, error
, blk_rq_bytes(rq
));
435 if (pc
->flags
& PC_FLAG_DMA_IN_PROGRESS
) {
436 pc
->flags
&= ~PC_FLAG_DMA_IN_PROGRESS
;
437 printk(KERN_ERR
"%s: The device wants to issue more interrupts "
438 "in DMA mode\n", drive
->name
);
440 return ide_do_reset(drive
);
443 /* Get the number of bytes to transfer on this interrupt. */
444 ide_read_bcount_and_ireason(drive
, &bcount
, &ireason
);
446 if (ireason
& ATAPI_COD
) {
447 printk(KERN_ERR
"%s: CoD != 0 in %s\n", drive
->name
, __func__
);
448 return ide_do_reset(drive
);
451 if (((ireason
& ATAPI_IO
) == ATAPI_IO
) == write
) {
452 /* Hopefully, we will never get here */
453 printk(KERN_ERR
"%s: We wanted to %s, but the device wants us "
454 "to %s!\n", drive
->name
,
455 (ireason
& ATAPI_IO
) ? "Write" : "Read",
456 (ireason
& ATAPI_IO
) ? "Read" : "Write");
457 return ide_do_reset(drive
);
460 done
= min_t(unsigned int, bcount
, cmd
->nleft
);
461 ide_pio_bytes(drive
, cmd
, write
, done
);
463 /* Update transferred byte count */
464 rq
->resid_len
-= done
;
469 ide_pad_transfer(drive
, write
, bcount
);
471 debug_log("[cmd %x] transferred %d bytes, padded %d bytes, resid: %u\n",
472 rq
->cmd
[0], done
, bcount
, rq
->resid_len
);
474 /* And set the interrupt handler again */
475 ide_set_handler(drive
, ide_pc_intr
, timeout
);
479 static void ide_init_packet_cmd(struct ide_cmd
*cmd
, u8 valid_tf
,
482 cmd
->protocol
= dma
? ATAPI_PROT_DMA
: ATAPI_PROT_PIO
;
483 cmd
->valid
.out
.tf
= IDE_VALID_LBAH
| IDE_VALID_LBAM
|
484 IDE_VALID_FEATURE
| valid_tf
;
485 cmd
->tf
.command
= ATA_CMD_PACKET
;
486 cmd
->tf
.feature
= dma
; /* Use PIO/DMA */
487 cmd
->tf
.lbam
= bcount
& 0xff;
488 cmd
->tf
.lbah
= (bcount
>> 8) & 0xff;
491 static u8
ide_read_ireason(ide_drive_t
*drive
)
493 struct ide_taskfile tf
;
495 drive
->hwif
->tp_ops
->tf_read(drive
, &tf
, IDE_VALID_NSECT
);
500 static u8
ide_wait_ireason(ide_drive_t
*drive
, u8 ireason
)
504 while (retries
-- && ((ireason
& ATAPI_COD
) == 0 ||
505 (ireason
& ATAPI_IO
))) {
506 printk(KERN_ERR
"%s: (IO,CoD != (0,1) while issuing "
507 "a packet command, retrying\n", drive
->name
);
509 ireason
= ide_read_ireason(drive
);
511 printk(KERN_ERR
"%s: (IO,CoD != (0,1) while issuing "
512 "a packet command, ignoring\n",
514 ireason
|= ATAPI_COD
;
515 ireason
&= ~ATAPI_IO
;
522 static int ide_delayed_transfer_pc(ide_drive_t
*drive
)
524 /* Send the actual packet */
525 drive
->hwif
->tp_ops
->output_data(drive
, NULL
, drive
->pc
->c
, 12);
527 /* Timeout for the packet command */
528 return WAIT_FLOPPY_CMD
;
531 static ide_startstop_t
ide_transfer_pc(ide_drive_t
*drive
)
533 struct ide_atapi_pc
*uninitialized_var(pc
);
534 ide_hwif_t
*hwif
= drive
->hwif
;
535 struct request
*rq
= hwif
->rq
;
536 ide_expiry_t
*expiry
;
537 unsigned int timeout
;
539 ide_startstop_t startstop
;
542 if (ide_wait_stat(&startstop
, drive
, ATA_DRQ
, ATA_BUSY
, WAIT_READY
)) {
543 printk(KERN_ERR
"%s: Strange, packet command initiated yet "
544 "DRQ isn't asserted\n", drive
->name
);
548 if (drive
->atapi_flags
& IDE_AFLAG_DRQ_INTERRUPT
) {
550 drive
->waiting_for_dma
= 1;
553 if (dev_is_idecd(drive
)) {
554 /* ATAPI commands get padded out to 12 bytes minimum */
555 cmd_len
= COMMAND_SIZE(rq
->cmd
[0]);
556 if (cmd_len
< ATAPI_MIN_CDB_BYTES
)
557 cmd_len
= ATAPI_MIN_CDB_BYTES
;
559 timeout
= rq
->timeout
;
560 expiry
= ide_cd_expiry
;
564 cmd_len
= ATAPI_MIN_CDB_BYTES
;
567 * If necessary schedule the packet transfer to occur 'timeout'
568 * miliseconds later in ide_delayed_transfer_pc() after the
569 * device says it's ready for a packet.
571 if (drive
->atapi_flags
& IDE_AFLAG_ZIP_DRIVE
) {
572 timeout
= drive
->pc_delay
;
573 expiry
= &ide_delayed_transfer_pc
;
575 timeout
= (drive
->media
== ide_floppy
) ? WAIT_FLOPPY_CMD
580 ireason
= ide_read_ireason(drive
);
581 if (drive
->media
== ide_tape
)
582 ireason
= ide_wait_ireason(drive
, ireason
);
584 if ((ireason
& ATAPI_COD
) == 0 || (ireason
& ATAPI_IO
)) {
585 printk(KERN_ERR
"%s: (IO,CoD) != (0,1) while issuing "
586 "a packet command\n", drive
->name
);
588 return ide_do_reset(drive
);
592 hwif
->expiry
= expiry
;
594 /* Set the interrupt routine */
595 ide_set_handler(drive
,
596 (dev_is_idecd(drive
) ? drive
->irq_handler
600 /* Send the actual packet */
601 if ((drive
->atapi_flags
& IDE_AFLAG_ZIP_DRIVE
) == 0)
602 hwif
->tp_ops
->output_data(drive
, NULL
, rq
->cmd
, cmd_len
);
604 /* Begin DMA, if necessary */
605 if (dev_is_idecd(drive
)) {
607 hwif
->dma_ops
->dma_start(drive
);
609 if (pc
->flags
& PC_FLAG_DMA_OK
) {
610 pc
->flags
|= PC_FLAG_DMA_IN_PROGRESS
;
611 hwif
->dma_ops
->dma_start(drive
);
618 ide_startstop_t
ide_issue_pc(ide_drive_t
*drive
, struct ide_cmd
*cmd
)
620 struct ide_atapi_pc
*pc
;
621 ide_hwif_t
*hwif
= drive
->hwif
;
622 ide_expiry_t
*expiry
= NULL
;
623 struct request
*rq
= hwif
->rq
;
624 unsigned int timeout
, bytes
;
627 u8 drq_int
= !!(drive
->atapi_flags
& IDE_AFLAG_DRQ_INTERRUPT
);
629 if (dev_is_idecd(drive
)) {
630 valid_tf
= IDE_VALID_NSECT
| IDE_VALID_LBAL
;
631 bcount
= ide_cd_get_xferlen(rq
);
632 expiry
= ide_cd_expiry
;
633 timeout
= ATAPI_WAIT_PC
;
636 drive
->dma
= !ide_dma_prepare(drive
, cmd
);
640 valid_tf
= IDE_VALID_DEVICE
;
641 bytes
= blk_rq_bytes(rq
);
642 bcount
= ((drive
->media
== ide_tape
) ? bytes
643 : min_t(unsigned int,
646 /* We haven't transferred any data yet */
647 rq
->resid_len
= bcount
;
649 if (pc
->flags
& PC_FLAG_DMA_ERROR
) {
650 pc
->flags
&= ~PC_FLAG_DMA_ERROR
;
654 if (pc
->flags
& PC_FLAG_DMA_OK
)
655 drive
->dma
= !ide_dma_prepare(drive
, cmd
);
658 pc
->flags
&= ~PC_FLAG_DMA_OK
;
660 timeout
= (drive
->media
== ide_floppy
) ? WAIT_FLOPPY_CMD
664 ide_init_packet_cmd(cmd
, valid_tf
, bcount
, drive
->dma
);
666 (void)do_rw_taskfile(drive
, cmd
);
670 drive
->waiting_for_dma
= 0;
671 hwif
->expiry
= expiry
;
674 ide_execute_command(drive
, cmd
, ide_transfer_pc
, timeout
);
676 return drq_int
? ide_started
: ide_transfer_pc(drive
);
678 EXPORT_SYMBOL_GPL(ide_issue_pc
);