5 #include <linux/kernel.h>
6 #include <linux/cdrom.h>
7 #include <linux/delay.h>
8 #include <linux/export.h>
10 #include <linux/scatterlist.h>
11 #include <linux/gfp.h>
13 #include <scsi/scsi.h>
15 #define DRV_NAME "ide-atapi"
16 #define PFX DRV_NAME ": "
19 #define debug_log(fmt, args...) \
20 printk(KERN_INFO "ide: " fmt, ## args)
22 #define debug_log(fmt, args...) do {} while (0)
25 #define ATAPI_MIN_CDB_BYTES 12
27 static inline int dev_is_idecd(ide_drive_t
*drive
)
29 return drive
->media
== ide_cdrom
|| drive
->media
== ide_optical
;
33 * Check whether we can support a device,
34 * based on the ATAPI IDENTIFY command results.
36 int ide_check_atapi_device(ide_drive_t
*drive
, const char *s
)
39 u8 gcw
[2], protocol
, device_type
, removable
, drq_type
, packet_size
;
41 *((u16
*)&gcw
) = id
[ATA_ID_CONFIG
];
43 protocol
= (gcw
[1] & 0xC0) >> 6;
44 device_type
= gcw
[1] & 0x1F;
45 removable
= (gcw
[0] & 0x80) >> 7;
46 drq_type
= (gcw
[0] & 0x60) >> 5;
47 packet_size
= gcw
[0] & 0x03;
50 /* kludge for Apple PowerBook internal zip */
51 if (drive
->media
== ide_floppy
&& device_type
== 5 &&
52 !strstr((char *)&id
[ATA_ID_PROD
], "CD-ROM") &&
53 strstr((char *)&id
[ATA_ID_PROD
], "ZIP"))
58 printk(KERN_ERR
"%s: %s: protocol (0x%02x) is not ATAPI\n",
59 s
, drive
->name
, protocol
);
60 else if ((drive
->media
== ide_floppy
&& device_type
!= 0) ||
61 (drive
->media
== ide_tape
&& device_type
!= 1))
62 printk(KERN_ERR
"%s: %s: invalid device type (0x%02x)\n",
63 s
, drive
->name
, device_type
);
64 else if (removable
== 0)
65 printk(KERN_ERR
"%s: %s: the removable flag is not set\n",
67 else if (drive
->media
== ide_floppy
&& drq_type
== 3)
68 printk(KERN_ERR
"%s: %s: sorry, DRQ type (0x%02x) not "
69 "supported\n", s
, drive
->name
, drq_type
);
70 else if (packet_size
!= 0)
71 printk(KERN_ERR
"%s: %s: packet size (0x%02x) is not 12 "
72 "bytes\n", s
, drive
->name
, packet_size
);
77 EXPORT_SYMBOL_GPL(ide_check_atapi_device
);
79 void ide_init_pc(struct ide_atapi_pc
*pc
)
81 memset(pc
, 0, sizeof(*pc
));
83 EXPORT_SYMBOL_GPL(ide_init_pc
);
86 * Add a special packet command request to the tail of the request queue,
87 * and wait for it to be serviced.
89 int ide_queue_pc_tail(ide_drive_t
*drive
, struct gendisk
*disk
,
90 struct ide_atapi_pc
*pc
, void *buf
, unsigned int bufflen
)
95 rq
= blk_get_request(drive
->queue
, REQ_OP_DRV_IN
, 0);
96 ide_req(rq
)->type
= ATA_PRIV_MISC
;
97 ide_req(rq
)->special
= pc
;
100 error
= blk_rq_map_kern(drive
->queue
, rq
, buf
, bufflen
,
106 memcpy(scsi_req(rq
)->cmd
, pc
->c
, 12);
107 if (drive
->media
== ide_tape
)
108 scsi_req(rq
)->cmd
[13] = REQ_IDETAPE_PC1
;
109 blk_execute_rq(drive
->queue
, disk
, rq
, 0);
110 error
= scsi_req(rq
)->result
? -EIO
: 0;
115 EXPORT_SYMBOL_GPL(ide_queue_pc_tail
);
117 int ide_do_test_unit_ready(ide_drive_t
*drive
, struct gendisk
*disk
)
119 struct ide_atapi_pc pc
;
122 pc
.c
[0] = TEST_UNIT_READY
;
124 return ide_queue_pc_tail(drive
, disk
, &pc
, NULL
, 0);
126 EXPORT_SYMBOL_GPL(ide_do_test_unit_ready
);
128 int ide_do_start_stop(ide_drive_t
*drive
, struct gendisk
*disk
, int start
)
130 struct ide_atapi_pc pc
;
133 pc
.c
[0] = START_STOP
;
136 if (drive
->media
== ide_tape
)
137 pc
.flags
|= PC_FLAG_WAIT_FOR_DSC
;
139 return ide_queue_pc_tail(drive
, disk
, &pc
, NULL
, 0);
141 EXPORT_SYMBOL_GPL(ide_do_start_stop
);
143 int ide_set_media_lock(ide_drive_t
*drive
, struct gendisk
*disk
, int on
)
145 struct ide_atapi_pc pc
;
147 if ((drive
->dev_flags
& IDE_DFLAG_DOORLOCKING
) == 0)
151 pc
.c
[0] = ALLOW_MEDIUM_REMOVAL
;
154 return ide_queue_pc_tail(drive
, disk
, &pc
, NULL
, 0);
156 EXPORT_SYMBOL_GPL(ide_set_media_lock
);
158 void ide_create_request_sense_cmd(ide_drive_t
*drive
, struct ide_atapi_pc
*pc
)
161 pc
->c
[0] = REQUEST_SENSE
;
162 if (drive
->media
== ide_floppy
) {
170 EXPORT_SYMBOL_GPL(ide_create_request_sense_cmd
);
172 void ide_prep_sense(ide_drive_t
*drive
, struct request
*rq
)
174 struct request_sense
*sense
= &drive
->sense_data
;
175 struct request
*sense_rq
;
176 struct scsi_request
*req
;
177 unsigned int cmd_len
, sense_len
;
180 switch (drive
->media
) {
194 BUG_ON(sense_len
> sizeof(*sense
));
196 if (ata_sense_request(rq
) || drive
->sense_rq_armed
)
199 sense_rq
= drive
->sense_rq
;
201 sense_rq
= blk_mq_alloc_request(drive
->queue
, REQ_OP_DRV_IN
,
202 BLK_MQ_REQ_RESERVED
| BLK_MQ_REQ_NOWAIT
);
203 drive
->sense_rq
= sense_rq
;
205 req
= scsi_req(sense_rq
);
207 memset(sense
, 0, sizeof(*sense
));
211 err
= blk_rq_map_kern(drive
->queue
, sense_rq
, sense
, sense_len
,
214 if (printk_ratelimit())
215 printk(KERN_WARNING PFX
"%s: failed to map sense "
216 "buffer\n", drive
->name
);
217 blk_mq_free_request(sense_rq
);
218 drive
->sense_rq
= NULL
;
222 sense_rq
->rq_disk
= rq
->rq_disk
;
223 sense_rq
->cmd_flags
= REQ_OP_DRV_IN
;
224 ide_req(sense_rq
)->type
= ATA_PRIV_SENSE
;
225 sense_rq
->rq_flags
|= RQF_PREEMPT
;
227 req
->cmd
[0] = GPCMD_REQUEST_SENSE
;
228 req
->cmd
[4] = cmd_len
;
229 if (drive
->media
== ide_tape
)
230 req
->cmd
[13] = REQ_IDETAPE_PC1
;
232 drive
->sense_rq_armed
= true;
234 EXPORT_SYMBOL_GPL(ide_prep_sense
);
236 int ide_queue_sense_rq(ide_drive_t
*drive
, void *special
)
238 struct request
*sense_rq
= drive
->sense_rq
;
240 /* deferred failure from ide_prep_sense() */
241 if (!drive
->sense_rq_armed
) {
242 printk(KERN_WARNING PFX
"%s: error queuing a sense request\n",
247 ide_req(sense_rq
)->special
= special
;
248 drive
->sense_rq_armed
= false;
250 drive
->hwif
->rq
= NULL
;
252 ide_insert_request_head(drive
, sense_rq
);
255 EXPORT_SYMBOL_GPL(ide_queue_sense_rq
);
258 * Called when an error was detected during the last packet command.
259 * We queue a request sense packet command at the head of the request
262 void ide_retry_pc(ide_drive_t
*drive
)
264 struct request
*failed_rq
= drive
->hwif
->rq
;
265 struct request
*sense_rq
= drive
->sense_rq
;
266 struct ide_atapi_pc
*pc
= &drive
->request_sense_pc
;
268 (void)ide_read_error(drive
);
270 /* init pc from sense_rq */
272 memcpy(pc
->c
, scsi_req(sense_rq
)->cmd
, 12);
274 if (drive
->media
== ide_tape
)
275 drive
->atapi_flags
|= IDE_AFLAG_IGNORE_DSC
;
278 * Push back the failed request and put request sense on top
279 * of it. The failed command will be retried after sense data
282 drive
->hwif
->rq
= NULL
;
283 ide_requeue_and_plug(drive
, failed_rq
);
284 if (ide_queue_sense_rq(drive
, pc
))
285 ide_complete_rq(drive
, BLK_STS_IOERR
, blk_rq_bytes(failed_rq
));
287 EXPORT_SYMBOL_GPL(ide_retry_pc
);
289 int ide_cd_expiry(ide_drive_t
*drive
)
291 struct request
*rq
= drive
->hwif
->rq
;
292 unsigned long wait
= 0;
294 debug_log("%s: scsi_req(rq)->cmd[0]: 0x%x\n", __func__
, scsi_req(rq
)->cmd
[0]);
297 * Some commands are *slow* and normally take a long time to complete.
298 * Usually we can use the ATAPI "disconnect" to bypass this, but not all
299 * commands/drives support that. Let ide_timer_expiry keep polling us
302 switch (scsi_req(rq
)->cmd
[0]) {
304 case GPCMD_FORMAT_UNIT
:
305 case GPCMD_RESERVE_RZONE_TRACK
:
306 case GPCMD_CLOSE_TRACK
:
307 case GPCMD_FLUSH_CACHE
:
308 wait
= ATAPI_WAIT_PC
;
311 if (!(rq
->rq_flags
& RQF_QUIET
))
312 printk(KERN_INFO PFX
"cmd 0x%x timed out\n",
313 scsi_req(rq
)->cmd
[0]);
319 EXPORT_SYMBOL_GPL(ide_cd_expiry
);
321 int ide_cd_get_xferlen(struct request
*rq
)
323 switch (req_op(rq
)) {
327 case REQ_OP_SCSI_OUT
:
328 return blk_rq_bytes(rq
);
331 switch (ide_req(rq
)->type
) {
334 return blk_rq_bytes(rq
);
340 EXPORT_SYMBOL_GPL(ide_cd_get_xferlen
);
342 void ide_read_bcount_and_ireason(ide_drive_t
*drive
, u16
*bcount
, u8
*ireason
)
344 struct ide_taskfile tf
;
346 drive
->hwif
->tp_ops
->tf_read(drive
, &tf
, IDE_VALID_NSECT
|
347 IDE_VALID_LBAM
| IDE_VALID_LBAH
);
349 *bcount
= (tf
.lbah
<< 8) | tf
.lbam
;
350 *ireason
= tf
.nsect
& 3;
352 EXPORT_SYMBOL_GPL(ide_read_bcount_and_ireason
);
355 * Check the contents of the interrupt reason register and attempt to recover if
356 * there are problems.
359 * - 0 if everything's ok
360 * - 1 if the request has to be terminated.
362 int ide_check_ireason(ide_drive_t
*drive
, struct request
*rq
, int len
,
365 ide_hwif_t
*hwif
= drive
->hwif
;
367 debug_log("ireason: 0x%x, rw: 0x%x\n", ireason
, rw
);
369 if (ireason
== (!rw
<< 1))
371 else if (ireason
== (rw
<< 1)) {
372 printk(KERN_ERR PFX
"%s: %s: wrong transfer direction!\n",
373 drive
->name
, __func__
);
375 if (dev_is_idecd(drive
))
376 ide_pad_transfer(drive
, rw
, len
);
377 } else if (!rw
&& ireason
== ATAPI_COD
) {
378 if (dev_is_idecd(drive
)) {
380 * Some drives (ASUS) seem to tell us that status info
381 * is available. Just get it and ignore.
383 (void)hwif
->tp_ops
->read_status(hwif
);
387 if (ireason
& ATAPI_COD
)
388 printk(KERN_ERR PFX
"%s: CoD != 0 in %s\n", drive
->name
,
391 /* drive wants a command packet, or invalid ireason... */
392 printk(KERN_ERR PFX
"%s: %s: bad interrupt reason 0x%02x\n",
393 drive
->name
, __func__
, ireason
);
396 if (dev_is_idecd(drive
) && ata_pc_request(rq
))
397 rq
->rq_flags
|= RQF_FAILED
;
401 EXPORT_SYMBOL_GPL(ide_check_ireason
);
404 * This is the usual interrupt handler which will be called during a packet
405 * command. We will transfer some of the data (as requested by the drive)
406 * and will re-point interrupt handler to us.
408 static ide_startstop_t
ide_pc_intr(ide_drive_t
*drive
)
410 struct ide_atapi_pc
*pc
= drive
->pc
;
411 ide_hwif_t
*hwif
= drive
->hwif
;
412 struct ide_cmd
*cmd
= &hwif
->cmd
;
413 struct request
*rq
= hwif
->rq
;
414 const struct ide_tp_ops
*tp_ops
= hwif
->tp_ops
;
415 unsigned int timeout
, done
;
417 u8 stat
, ireason
, dsc
= 0;
418 u8 write
= !!(pc
->flags
& PC_FLAG_WRITING
);
420 debug_log("Enter %s - interrupt handler\n", __func__
);
422 timeout
= (drive
->media
== ide_floppy
) ? WAIT_FLOPPY_CMD
425 /* Clear the interrupt */
426 stat
= tp_ops
->read_status(hwif
);
428 if (pc
->flags
& PC_FLAG_DMA_IN_PROGRESS
) {
431 drive
->waiting_for_dma
= 0;
432 rc
= hwif
->dma_ops
->dma_end(drive
);
433 ide_dma_unmap_sg(drive
, cmd
);
435 if (rc
|| (drive
->media
== ide_tape
&& (stat
& ATA_ERR
))) {
436 if (drive
->media
== ide_floppy
)
437 printk(KERN_ERR PFX
"%s: DMA %s error\n",
438 drive
->name
, rq_data_dir(pc
->rq
)
440 pc
->flags
|= PC_FLAG_DMA_ERROR
;
442 scsi_req(rq
)->resid_len
= 0;
443 debug_log("%s: DMA finished\n", drive
->name
);
446 /* No more interrupts */
447 if ((stat
& ATA_DRQ
) == 0) {
451 debug_log("Packet command completed, %d bytes transferred\n",
454 pc
->flags
&= ~PC_FLAG_DMA_IN_PROGRESS
;
456 local_irq_enable_in_hardirq();
458 if (drive
->media
== ide_tape
&&
459 (stat
& ATA_ERR
) && scsi_req(rq
)->cmd
[0] == REQUEST_SENSE
)
462 if ((stat
& ATA_ERR
) || (pc
->flags
& PC_FLAG_DMA_ERROR
)) {
464 debug_log("%s: I/O error\n", drive
->name
);
466 if (drive
->media
!= ide_tape
)
467 scsi_req(pc
->rq
)->result
++;
469 if (scsi_req(rq
)->cmd
[0] == REQUEST_SENSE
) {
470 printk(KERN_ERR PFX
"%s: I/O error in request "
471 "sense command\n", drive
->name
);
472 return ide_do_reset(drive
);
475 debug_log("[cmd %x]: check condition\n", scsi_req(rq
)->cmd
[0]);
477 /* Retry operation */
480 /* queued, but not started */
485 if ((pc
->flags
& PC_FLAG_WAIT_FOR_DSC
) && (stat
& ATA_DSC
) == 0)
489 * ->pc_callback() might change rq->data_len for
490 * residual count, cache total length.
492 done
= blk_rq_bytes(rq
);
494 /* Command finished - Call the callback function */
495 uptodate
= drive
->pc_callback(drive
, dsc
);
498 drive
->failed_pc
= NULL
;
500 if (ata_misc_request(rq
)) {
501 scsi_req(rq
)->result
= 0;
505 if (blk_rq_is_passthrough(rq
) && uptodate
<= 0) {
506 if (scsi_req(rq
)->result
== 0)
507 scsi_req(rq
)->result
= -EIO
;
510 error
= uptodate
? BLK_STS_OK
: BLK_STS_IOERR
;
513 ide_complete_rq(drive
, error
, blk_rq_bytes(rq
));
517 if (pc
->flags
& PC_FLAG_DMA_IN_PROGRESS
) {
518 pc
->flags
&= ~PC_FLAG_DMA_IN_PROGRESS
;
519 printk(KERN_ERR PFX
"%s: The device wants to issue more "
520 "interrupts in DMA mode\n", drive
->name
);
522 return ide_do_reset(drive
);
525 /* Get the number of bytes to transfer on this interrupt. */
526 ide_read_bcount_and_ireason(drive
, &bcount
, &ireason
);
528 if (ide_check_ireason(drive
, rq
, bcount
, ireason
, write
))
529 return ide_do_reset(drive
);
531 done
= min_t(unsigned int, bcount
, cmd
->nleft
);
532 ide_pio_bytes(drive
, cmd
, write
, done
);
534 /* Update transferred byte count */
535 scsi_req(rq
)->resid_len
-= done
;
540 ide_pad_transfer(drive
, write
, bcount
);
542 debug_log("[cmd %x] transferred %d bytes, padded %d bytes, resid: %u\n",
543 scsi_req(rq
)->cmd
[0], done
, bcount
, scsi_req(rq
)->resid_len
);
545 /* And set the interrupt handler again */
546 ide_set_handler(drive
, ide_pc_intr
, timeout
);
550 static void ide_init_packet_cmd(struct ide_cmd
*cmd
, u8 valid_tf
,
553 cmd
->protocol
= dma
? ATAPI_PROT_DMA
: ATAPI_PROT_PIO
;
554 cmd
->valid
.out
.tf
= IDE_VALID_LBAH
| IDE_VALID_LBAM
|
555 IDE_VALID_FEATURE
| valid_tf
;
556 cmd
->tf
.command
= ATA_CMD_PACKET
;
557 cmd
->tf
.feature
= dma
; /* Use PIO/DMA */
558 cmd
->tf
.lbam
= bcount
& 0xff;
559 cmd
->tf
.lbah
= (bcount
>> 8) & 0xff;
562 static u8
ide_read_ireason(ide_drive_t
*drive
)
564 struct ide_taskfile tf
;
566 drive
->hwif
->tp_ops
->tf_read(drive
, &tf
, IDE_VALID_NSECT
);
571 static u8
ide_wait_ireason(ide_drive_t
*drive
, u8 ireason
)
575 while (retries
-- && ((ireason
& ATAPI_COD
) == 0 ||
576 (ireason
& ATAPI_IO
))) {
577 printk(KERN_ERR PFX
"%s: (IO,CoD != (0,1) while issuing "
578 "a packet command, retrying\n", drive
->name
);
580 ireason
= ide_read_ireason(drive
);
582 printk(KERN_ERR PFX
"%s: (IO,CoD != (0,1) while issuing"
583 " a packet command, ignoring\n",
585 ireason
|= ATAPI_COD
;
586 ireason
&= ~ATAPI_IO
;
593 static int ide_delayed_transfer_pc(ide_drive_t
*drive
)
595 /* Send the actual packet */
596 drive
->hwif
->tp_ops
->output_data(drive
, NULL
, drive
->pc
->c
, 12);
598 /* Timeout for the packet command */
599 return WAIT_FLOPPY_CMD
;
602 static ide_startstop_t
ide_transfer_pc(ide_drive_t
*drive
)
604 struct ide_atapi_pc
*uninitialized_var(pc
);
605 ide_hwif_t
*hwif
= drive
->hwif
;
606 struct request
*rq
= hwif
->rq
;
607 ide_expiry_t
*expiry
;
608 unsigned int timeout
;
610 ide_startstop_t startstop
;
613 if (ide_wait_stat(&startstop
, drive
, ATA_DRQ
, ATA_BUSY
, WAIT_READY
)) {
614 printk(KERN_ERR PFX
"%s: Strange, packet command initiated yet "
615 "DRQ isn't asserted\n", drive
->name
);
619 if (drive
->atapi_flags
& IDE_AFLAG_DRQ_INTERRUPT
) {
621 drive
->waiting_for_dma
= 1;
624 if (dev_is_idecd(drive
)) {
625 /* ATAPI commands get padded out to 12 bytes minimum */
626 cmd_len
= COMMAND_SIZE(scsi_req(rq
)->cmd
[0]);
627 if (cmd_len
< ATAPI_MIN_CDB_BYTES
)
628 cmd_len
= ATAPI_MIN_CDB_BYTES
;
630 timeout
= rq
->timeout
;
631 expiry
= ide_cd_expiry
;
635 cmd_len
= ATAPI_MIN_CDB_BYTES
;
638 * If necessary schedule the packet transfer to occur 'timeout'
639 * milliseconds later in ide_delayed_transfer_pc() after the
640 * device says it's ready for a packet.
642 if (drive
->atapi_flags
& IDE_AFLAG_ZIP_DRIVE
) {
643 timeout
= drive
->pc_delay
;
644 expiry
= &ide_delayed_transfer_pc
;
646 timeout
= (drive
->media
== ide_floppy
) ? WAIT_FLOPPY_CMD
651 ireason
= ide_read_ireason(drive
);
652 if (drive
->media
== ide_tape
)
653 ireason
= ide_wait_ireason(drive
, ireason
);
655 if ((ireason
& ATAPI_COD
) == 0 || (ireason
& ATAPI_IO
)) {
656 printk(KERN_ERR PFX
"%s: (IO,CoD) != (0,1) while "
657 "issuing a packet command\n", drive
->name
);
659 return ide_do_reset(drive
);
663 hwif
->expiry
= expiry
;
665 /* Set the interrupt routine */
666 ide_set_handler(drive
,
667 (dev_is_idecd(drive
) ? drive
->irq_handler
671 /* Send the actual packet */
672 if ((drive
->atapi_flags
& IDE_AFLAG_ZIP_DRIVE
) == 0)
673 hwif
->tp_ops
->output_data(drive
, NULL
, scsi_req(rq
)->cmd
, cmd_len
);
675 /* Begin DMA, if necessary */
676 if (dev_is_idecd(drive
)) {
678 hwif
->dma_ops
->dma_start(drive
);
680 if (pc
->flags
& PC_FLAG_DMA_OK
) {
681 pc
->flags
|= PC_FLAG_DMA_IN_PROGRESS
;
682 hwif
->dma_ops
->dma_start(drive
);
689 ide_startstop_t
ide_issue_pc(ide_drive_t
*drive
, struct ide_cmd
*cmd
)
691 struct ide_atapi_pc
*pc
;
692 ide_hwif_t
*hwif
= drive
->hwif
;
693 ide_expiry_t
*expiry
= NULL
;
694 struct request
*rq
= hwif
->rq
;
695 unsigned int timeout
, bytes
;
698 u8 drq_int
= !!(drive
->atapi_flags
& IDE_AFLAG_DRQ_INTERRUPT
);
700 if (dev_is_idecd(drive
)) {
701 valid_tf
= IDE_VALID_NSECT
| IDE_VALID_LBAL
;
702 bcount
= ide_cd_get_xferlen(rq
);
703 expiry
= ide_cd_expiry
;
704 timeout
= ATAPI_WAIT_PC
;
707 drive
->dma
= !ide_dma_prepare(drive
, cmd
);
711 valid_tf
= IDE_VALID_DEVICE
;
712 bytes
= blk_rq_bytes(rq
);
713 bcount
= ((drive
->media
== ide_tape
) ? bytes
714 : min_t(unsigned int,
717 /* We haven't transferred any data yet */
718 scsi_req(rq
)->resid_len
= bcount
;
720 if (pc
->flags
& PC_FLAG_DMA_ERROR
) {
721 pc
->flags
&= ~PC_FLAG_DMA_ERROR
;
725 if (pc
->flags
& PC_FLAG_DMA_OK
)
726 drive
->dma
= !ide_dma_prepare(drive
, cmd
);
729 pc
->flags
&= ~PC_FLAG_DMA_OK
;
731 timeout
= (drive
->media
== ide_floppy
) ? WAIT_FLOPPY_CMD
735 ide_init_packet_cmd(cmd
, valid_tf
, bcount
, drive
->dma
);
737 (void)do_rw_taskfile(drive
, cmd
);
741 drive
->waiting_for_dma
= 0;
742 hwif
->expiry
= expiry
;
745 ide_execute_command(drive
, cmd
, ide_transfer_pc
, timeout
);
747 return drq_int
? ide_started
: ide_transfer_pc(drive
);
749 EXPORT_SYMBOL_GPL(ide_issue_pc
);