2 * linux/drivers/ide/ide-cd.c
4 * Copyright (C) 1994, 1995, 1996 scott snyder <snyder@fnald0.fnal.gov>
5 * Copyright (C) 1996-1998 Erik Andersen <andersee@debian.org>
6 * Copyright (C) 1998-2000 Jens Axboe <axboe@suse.de>
8 * May be copied or modified under the terms of the GNU General Public
9 * License. See linux/COPYING for more information.
11 * ATAPI CD-ROM driver. To be used with ide.c.
12 * See Documentation/cdrom/ide-cd for usage information.
14 * Suggestions are welcome. Patches that work are more welcome though. ;-)
15 * For those wishing to work on this driver, please be sure you download
16 * and comply with the latest Mt. Fuji (SFF8090 version 4) and ATAPI
17 * (SFF-8020i rev 2.6) standards. These documents can be obtained by
19 * ftp://fission.dt.wdc.com/pub/standards/SFF_atapi/spec/SFF8020-r2.6/PS/8020r26.ps
20 * ftp://ftp.avc-pioneer.com/Mtfuji4/Spec/Fuji4r10.pdf
22 * Drives that deviate from these standards will be accommodated as much
23 * as possible via compile time or command-line options. Since I only have
24 * a few drives, you generally need to send me patches...
26 * ----------------------------------
28 * -Make it so that Pioneer CD DR-A24X and friends don't get screwed up on
31 * For historical changelog please see:
32 * Documentation/ide/ChangeLog.ide-cd.1994-2004
35 #define IDECD_VERSION "4.61"
37 #include <linux/module.h>
38 #include <linux/types.h>
39 #include <linux/kernel.h>
40 #include <linux/delay.h>
41 #include <linux/timer.h>
42 #include <linux/slab.h>
43 #include <linux/interrupt.h>
44 #include <linux/errno.h>
45 #include <linux/cdrom.h>
46 #include <linux/ide.h>
47 #include <linux/completion.h>
48 #include <linux/mutex.h>
49 #include <linux/bcd.h>
51 #include <scsi/scsi.h> /* For SCSI -> ATAPI command conversion */
55 #include <asm/byteorder.h>
56 #include <asm/uaccess.h>
57 #include <asm/unaligned.h>
61 static DEFINE_MUTEX(idecd_ref_mutex
);
63 #define to_ide_cd(obj) container_of(obj, struct cdrom_info, kref)
65 #define ide_cd_g(disk) \
66 container_of((disk)->private_data, struct cdrom_info, driver)
68 static struct cdrom_info
*ide_cd_get(struct gendisk
*disk
)
70 struct cdrom_info
*cd
= NULL
;
72 mutex_lock(&idecd_ref_mutex
);
76 mutex_unlock(&idecd_ref_mutex
);
80 static void ide_cd_release(struct kref
*);
82 static void ide_cd_put(struct cdrom_info
*cd
)
84 mutex_lock(&idecd_ref_mutex
);
85 kref_put(&cd
->kref
, ide_cd_release
);
86 mutex_unlock(&idecd_ref_mutex
);
89 /****************************************************************************
90 * Generic packet command support and error handling routines.
93 /* Mark that we've seen a media change, and invalidate our internal
95 static void cdrom_saw_media_change (ide_drive_t
*drive
)
97 struct cdrom_info
*cd
= drive
->driver_data
;
99 cd
->cd_flags
|= IDE_CD_FLAG_MEDIA_CHANGED
;
100 cd
->cd_flags
&= ~IDE_CD_FLAG_TOC_VALID
;
101 cd
->nsectors_buffered
= 0;
104 static int cdrom_log_sense(ide_drive_t
*drive
, struct request
*rq
,
105 struct request_sense
*sense
)
109 if (!sense
|| !rq
|| (rq
->cmd_flags
& REQ_QUIET
))
112 switch (sense
->sense_key
) {
113 case NO_SENSE
: case RECOVERED_ERROR
:
117 * don't care about tray state messages for
118 * e.g. capacity commands or in-progress or
121 if (sense
->asc
== 0x3a || sense
->asc
== 0x04)
125 case ILLEGAL_REQUEST
:
127 * don't log START_STOP unit with LoEj set, since
128 * we cannot reliably check if drive can auto-close
130 if (rq
->cmd
[0] == GPCMD_START_STOP_UNIT
&& sense
->asc
== 0x24)
136 * Make good and sure we've seen this potential media
137 * change. Some drives (i.e. Creative) fail to present
138 * the correct sense key in the error register.
140 cdrom_saw_media_change(drive
);
150 void cdrom_analyze_sense_data(ide_drive_t
*drive
,
151 struct request
*failed_command
,
152 struct request_sense
*sense
)
154 unsigned long sector
;
155 unsigned long bio_sectors
;
157 struct cdrom_info
*info
= drive
->driver_data
;
159 if (!cdrom_log_sense(drive
, failed_command
, sense
))
163 * If a read toc is executed for a CD-R or CD-RW medium where
164 * the first toc has not been recorded yet, it will fail with
165 * 05/24/00 (which is a confusing error)
167 if (failed_command
&& failed_command
->cmd
[0] == GPCMD_READ_TOC_PMA_ATIP
)
168 if (sense
->sense_key
== 0x05 && sense
->asc
== 0x24)
171 if (sense
->error_code
== 0x70) { /* Current Error */
172 switch(sense
->sense_key
) {
174 case VOLUME_OVERFLOW
:
175 case ILLEGAL_REQUEST
:
178 if (failed_command
== NULL
||
179 !blk_fs_request(failed_command
))
181 sector
= (sense
->information
[0] << 24) |
182 (sense
->information
[1] << 16) |
183 (sense
->information
[2] << 8) |
184 (sense
->information
[3]);
186 bio_sectors
= bio_sectors(failed_command
->bio
);
189 if (drive
->queue
->hardsect_size
== 2048)
190 sector
<<= 2; /* Device sector size is 2K */
191 sector
&= ~(bio_sectors
-1);
192 valid
= (sector
- failed_command
->sector
) << 9;
196 if (sector
< get_capacity(info
->disk
) &&
197 drive
->probed_capacity
- sector
< 4 * 75) {
198 set_capacity(info
->disk
, sector
);
203 ide_cd_log_error(drive
->name
, failed_command
, sense
);
207 * Initialize a ide-cd packet command request
209 void ide_cd_init_rq(ide_drive_t
*drive
, struct request
*rq
)
211 struct cdrom_info
*cd
= drive
->driver_data
;
213 ide_init_drive_cmd(rq
);
214 rq
->cmd_type
= REQ_TYPE_ATA_PC
;
215 rq
->rq_disk
= cd
->disk
;
218 static void cdrom_queue_request_sense(ide_drive_t
*drive
, void *sense
,
219 struct request
*failed_command
)
221 struct cdrom_info
*info
= drive
->driver_data
;
222 struct request
*rq
= &info
->request_sense_request
;
225 sense
= &info
->sense_data
;
227 /* stuff the sense request in front of our current request */
228 ide_cd_init_rq(drive
, rq
);
231 rq
->cmd
[0] = GPCMD_REQUEST_SENSE
;
232 rq
->cmd
[4] = rq
->data_len
= 18;
234 rq
->cmd_type
= REQ_TYPE_SENSE
;
236 /* NOTE! Save the failed command in "rq->buffer" */
237 rq
->buffer
= (void *) failed_command
;
239 (void) ide_do_drive_cmd(drive
, rq
, ide_preempt
);
242 static void cdrom_end_request (ide_drive_t
*drive
, int uptodate
)
244 struct request
*rq
= HWGROUP(drive
)->rq
;
245 int nsectors
= rq
->hard_cur_sectors
;
247 if (blk_sense_request(rq
) && uptodate
) {
249 * For REQ_TYPE_SENSE, "rq->buffer" points to the original
252 struct request
*failed
= (struct request
*) rq
->buffer
;
253 struct cdrom_info
*info
= drive
->driver_data
;
254 void *sense
= &info
->sense_data
;
259 sense
= failed
->sense
;
260 failed
->sense_len
= rq
->sense_len
;
262 cdrom_analyze_sense_data(drive
, failed
, sense
);
264 * now end failed request
266 if (blk_fs_request(failed
)) {
267 if (ide_end_dequeued_request(drive
, failed
, 0,
268 failed
->hard_nr_sectors
))
271 spin_lock_irqsave(&ide_lock
, flags
);
272 if (__blk_end_request(failed
, -EIO
,
275 spin_unlock_irqrestore(&ide_lock
, flags
);
278 cdrom_analyze_sense_data(drive
, NULL
, sense
);
281 if (!rq
->current_nr_sectors
&& blk_fs_request(rq
))
283 /* make sure it's fully ended */
284 if (blk_pc_request(rq
))
285 nsectors
= (rq
->data_len
+ 511) >> 9;
289 ide_end_request(drive
, uptodate
, nsectors
);
292 static void ide_dump_status_no_sense(ide_drive_t
*drive
, const char *msg
, u8 stat
)
296 ide_dump_status(drive
, msg
, stat
);
299 /* Returns 0 if the request should be continued.
300 Returns 1 if the request was ended. */
301 static int cdrom_decode_status(ide_drive_t
*drive
, int good_stat
, int *stat_ret
)
303 struct request
*rq
= HWGROUP(drive
)->rq
;
304 int stat
, err
, sense_key
;
306 /* Check for errors. */
307 stat
= HWIF(drive
)->INB(IDE_STATUS_REG
);
311 if (OK_STAT(stat
, good_stat
, BAD_R_STAT
))
314 /* Get the IDE error register. */
315 err
= HWIF(drive
)->INB(IDE_ERROR_REG
);
316 sense_key
= err
>> 4;
319 printk("%s: missing rq in cdrom_decode_status\n", drive
->name
);
323 if (blk_sense_request(rq
)) {
324 /* We got an error trying to get sense info
325 from the drive (probably while trying
326 to recover from a former error). Just give up. */
328 rq
->cmd_flags
|= REQ_FAILED
;
329 cdrom_end_request(drive
, 0);
330 ide_error(drive
, "request sense failure", stat
);
333 } else if (blk_pc_request(rq
) || rq
->cmd_type
== REQ_TYPE_ATA_PC
) {
334 /* All other functions, except for READ. */
338 * if we have an error, pass back CHECK_CONDITION as the
341 if (blk_pc_request(rq
) && !rq
->errors
)
342 rq
->errors
= SAM_STAT_CHECK_CONDITION
;
344 /* Check for tray open. */
345 if (sense_key
== NOT_READY
) {
346 cdrom_saw_media_change (drive
);
347 } else if (sense_key
== UNIT_ATTENTION
) {
348 /* Check for media change. */
349 cdrom_saw_media_change (drive
);
350 /*printk("%s: media changed\n",drive->name);*/
352 } else if ((sense_key
== ILLEGAL_REQUEST
) &&
353 (rq
->cmd
[0] == GPCMD_START_STOP_UNIT
)) {
355 * Don't print error message for this condition--
356 * SFF8090i indicates that 5/24/00 is the correct
357 * response to a request to close the tray if the
358 * drive doesn't have that capability.
359 * cdrom_log_sense() knows this!
361 } else if (!(rq
->cmd_flags
& REQ_QUIET
)) {
362 /* Otherwise, print an error. */
363 ide_dump_status(drive
, "packet command error", stat
);
366 rq
->cmd_flags
|= REQ_FAILED
;
369 * instead of playing games with moving completions around,
370 * remove failed request completely and end it when the
371 * request sense has completed
373 if (stat
& ERR_STAT
) {
374 spin_lock_irqsave(&ide_lock
, flags
);
375 blkdev_dequeue_request(rq
);
376 HWGROUP(drive
)->rq
= NULL
;
377 spin_unlock_irqrestore(&ide_lock
, flags
);
379 cdrom_queue_request_sense(drive
, rq
->sense
, rq
);
381 cdrom_end_request(drive
, 0);
383 } else if (blk_fs_request(rq
)) {
384 int do_end_request
= 0;
386 /* Handle errors from READ and WRITE requests. */
388 if (blk_noretry_request(rq
))
391 if (sense_key
== NOT_READY
) {
393 if (rq_data_dir(rq
) == READ
) {
394 cdrom_saw_media_change (drive
);
396 /* Fail the request. */
397 printk ("%s: tray open\n", drive
->name
);
400 struct cdrom_info
*info
= drive
->driver_data
;
402 /* allow the drive 5 seconds to recover, some
403 * devices will return this error while flushing
406 info
->write_timeout
= jiffies
+ ATAPI_WAIT_WRITE_BUSY
;
408 if (time_after(jiffies
, info
->write_timeout
))
414 * take a breather relying on the
415 * unplug timer to kick us again
417 spin_lock_irqsave(&ide_lock
, flags
);
418 blk_plug_device(drive
->queue
);
419 spin_unlock_irqrestore(&ide_lock
,flags
);
423 } else if (sense_key
== UNIT_ATTENTION
) {
425 cdrom_saw_media_change (drive
);
427 /* Arrange to retry the request.
428 But be sure to give up if we've retried
430 if (++rq
->errors
> ERROR_MAX
)
432 } else if (sense_key
== ILLEGAL_REQUEST
||
433 sense_key
== DATA_PROTECT
) {
434 /* No point in retrying after an illegal
435 request or data protect error.*/
436 ide_dump_status_no_sense (drive
, "command error", stat
);
438 } else if (sense_key
== MEDIUM_ERROR
) {
439 /* No point in re-trying a zillion times on a bad
440 * sector... If we got here the error is not correctable */
441 ide_dump_status_no_sense (drive
, "media error (bad sector)", stat
);
443 } else if (sense_key
== BLANK_CHECK
) {
444 /* Disk appears blank ?? */
445 ide_dump_status_no_sense (drive
, "media error (blank)", stat
);
447 } else if ((err
& ~ABRT_ERR
) != 0) {
448 /* Go to the default handler
450 ide_error(drive
, "cdrom_decode_status", stat
);
452 } else if ((++rq
->errors
> ERROR_MAX
)) {
453 /* We've racked up too many retries. Abort. */
457 /* End a request through request sense analysis when we have
458 sense data. We need this in order to perform end of media
461 if (do_end_request
) {
462 if (stat
& ERR_STAT
) {
464 spin_lock_irqsave(&ide_lock
, flags
);
465 blkdev_dequeue_request(rq
);
466 HWGROUP(drive
)->rq
= NULL
;
467 spin_unlock_irqrestore(&ide_lock
, flags
);
469 cdrom_queue_request_sense(drive
, rq
->sense
, rq
);
471 cdrom_end_request(drive
, 0);
473 /* If we got a CHECK_CONDITION status,
474 queue a request sense command. */
476 cdrom_queue_request_sense(drive
, NULL
, NULL
);
479 blk_dump_rq_flags(rq
, "ide-cd: bad rq");
480 cdrom_end_request(drive
, 0);
483 /* Retry, or handle the next request. */
487 static int cdrom_timer_expiry(ide_drive_t
*drive
)
489 struct request
*rq
= HWGROUP(drive
)->rq
;
490 unsigned long wait
= 0;
493 * Some commands are *slow* and normally take a long time to
494 * complete. Usually we can use the ATAPI "disconnect" to bypass
495 * this, but not all commands/drives support that. Let
496 * ide_timer_expiry keep polling us for these.
498 switch (rq
->cmd
[0]) {
500 case GPCMD_FORMAT_UNIT
:
501 case GPCMD_RESERVE_RZONE_TRACK
:
502 case GPCMD_CLOSE_TRACK
:
503 case GPCMD_FLUSH_CACHE
:
504 wait
= ATAPI_WAIT_PC
;
507 if (!(rq
->cmd_flags
& REQ_QUIET
))
508 printk(KERN_INFO
"ide-cd: cmd 0x%x timed out\n", rq
->cmd
[0]);
515 /* Set up the device registers for transferring a packet command on DEV,
516 expecting to later transfer XFERLEN bytes. HANDLER is the routine
517 which actually transfers the command to the drive. If this is a
518 drq_interrupt device, this routine will arrange for HANDLER to be
519 called when the interrupt from the drive arrives. Otherwise, HANDLER
520 will be called immediately after the drive is prepared for the transfer. */
522 static ide_startstop_t
cdrom_start_packet_command(ide_drive_t
*drive
,
524 ide_handler_t
*handler
)
526 ide_startstop_t startstop
;
527 struct cdrom_info
*info
= drive
->driver_data
;
528 ide_hwif_t
*hwif
= drive
->hwif
;
530 /* Wait for the controller to be idle. */
531 if (ide_wait_stat(&startstop
, drive
, 0, BUSY_STAT
, WAIT_READY
))
534 /* FIXME: for Virtual DMA we must check harder */
536 info
->dma
= !hwif
->dma_setup(drive
);
538 /* Set up the controller registers. */
539 ide_pktcmd_tf_load(drive
, IDE_TFLAG_OUT_NSECT
| IDE_TFLAG_OUT_LBAL
|
540 IDE_TFLAG_NO_SELECT_MASK
, xferlen
, info
->dma
);
542 if (info
->cd_flags
& IDE_CD_FLAG_DRQ_INTERRUPT
) {
543 /* waiting for CDB interrupt, not DMA yet. */
545 drive
->waiting_for_dma
= 0;
548 ide_execute_command(drive
, WIN_PACKETCMD
, handler
, ATAPI_WAIT_PC
, cdrom_timer_expiry
);
554 spin_lock_irqsave(&ide_lock
, flags
);
555 hwif
->OUTBSYNC(drive
, WIN_PACKETCMD
, IDE_COMMAND_REG
);
557 spin_unlock_irqrestore(&ide_lock
, flags
);
559 return (*handler
) (drive
);
563 /* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
564 The device registers must have already been prepared
565 by cdrom_start_packet_command.
566 HANDLER is the interrupt handler to call when the command completes
567 or there's data ready. */
568 #define ATAPI_MIN_CDB_BYTES 12
569 static ide_startstop_t
cdrom_transfer_packet_command (ide_drive_t
*drive
,
571 ide_handler_t
*handler
)
573 ide_hwif_t
*hwif
= drive
->hwif
;
575 struct cdrom_info
*info
= drive
->driver_data
;
576 ide_startstop_t startstop
;
578 if (info
->cd_flags
& IDE_CD_FLAG_DRQ_INTERRUPT
) {
579 /* Here we should have been called after receiving an interrupt
580 from the device. DRQ should how be set. */
582 /* Check for errors. */
583 if (cdrom_decode_status(drive
, DRQ_STAT
, NULL
))
586 /* Ok, next interrupt will be DMA interrupt. */
588 drive
->waiting_for_dma
= 1;
590 /* Otherwise, we must wait for DRQ to get set. */
591 if (ide_wait_stat(&startstop
, drive
, DRQ_STAT
,
592 BUSY_STAT
, WAIT_READY
))
596 /* Arm the interrupt handler. */
597 ide_set_handler(drive
, handler
, rq
->timeout
, cdrom_timer_expiry
);
599 /* ATAPI commands get padded out to 12 bytes minimum */
600 cmd_len
= COMMAND_SIZE(rq
->cmd
[0]);
601 if (cmd_len
< ATAPI_MIN_CDB_BYTES
)
602 cmd_len
= ATAPI_MIN_CDB_BYTES
;
604 /* Send the command to the device. */
605 HWIF(drive
)->atapi_output_bytes(drive
, rq
->cmd
, cmd_len
);
607 /* Start the DMA if need be */
609 hwif
->dma_start(drive
);
614 /****************************************************************************
615 * Block read functions.
618 typedef void (xfer_func_t
)(ide_drive_t
*, void *, u32
);
620 static void ide_cd_pad_transfer(ide_drive_t
*drive
, xfer_func_t
*xf
, int len
)
624 xf(drive
, &dum
, sizeof(dum
));
630 * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
631 * buffer. Once the first sector is added, any subsequent sectors are
632 * assumed to be continuous (until the buffer is cleared). For the first
633 * sector added, SECTOR is its sector number. (SECTOR is then ignored until
634 * the buffer is cleared.)
636 static void cdrom_buffer_sectors (ide_drive_t
*drive
, unsigned long sector
,
637 int sectors_to_transfer
)
639 struct cdrom_info
*info
= drive
->driver_data
;
641 /* Number of sectors to read into the buffer. */
642 int sectors_to_buffer
= min_t(int, sectors_to_transfer
,
643 (SECTOR_BUFFER_SIZE
>> SECTOR_BITS
) -
644 info
->nsectors_buffered
);
648 /* If we couldn't get a buffer, don't try to buffer anything... */
649 if (info
->buffer
== NULL
)
650 sectors_to_buffer
= 0;
652 /* If this is the first sector in the buffer, remember its number. */
653 if (info
->nsectors_buffered
== 0)
654 info
->sector_buffered
= sector
;
656 /* Read the data into the buffer. */
657 dest
= info
->buffer
+ info
->nsectors_buffered
* SECTOR_SIZE
;
658 while (sectors_to_buffer
> 0) {
659 HWIF(drive
)->atapi_input_bytes(drive
, dest
, SECTOR_SIZE
);
661 --sectors_to_transfer
;
662 ++info
->nsectors_buffered
;
666 /* Throw away any remaining data. */
667 while (sectors_to_transfer
> 0) {
668 static char dum
[SECTOR_SIZE
];
669 HWIF(drive
)->atapi_input_bytes(drive
, dum
, sizeof (dum
));
670 --sectors_to_transfer
;
675 * Check the contents of the interrupt reason register from the cdrom
676 * and attempt to recover if there are problems. Returns 0 if everything's
677 * ok; nonzero if the request has been terminated.
680 int cdrom_read_check_ireason (ide_drive_t
*drive
, int len
, int ireason
)
684 else if (ireason
== 0) {
685 ide_hwif_t
*hwif
= drive
->hwif
;
687 /* Whoops... The drive is expecting to receive data from us! */
688 printk(KERN_ERR
"%s: %s: wrong transfer direction!\n",
689 drive
->name
, __FUNCTION__
);
691 /* Throw some data at the drive so it doesn't hang
692 and quit this request. */
693 ide_cd_pad_transfer(drive
, hwif
->atapi_output_bytes
, len
);
694 } else if (ireason
== 1) {
695 /* Some drives (ASUS) seem to tell us that status
696 * info is available. just get it and ignore.
698 (void) HWIF(drive
)->INB(IDE_STATUS_REG
);
701 /* Drive wants a command packet, or invalid ireason... */
702 printk(KERN_ERR
"%s: %s: bad interrupt reason 0x%02x\n",
703 drive
->name
, __FUNCTION__
, ireason
);
706 cdrom_end_request(drive
, 0);
711 * Interrupt routine. Called when a read request has completed.
713 static ide_startstop_t
cdrom_read_intr (ide_drive_t
*drive
)
716 int ireason
, len
, sectors_to_transfer
, nskip
;
717 struct cdrom_info
*info
= drive
->driver_data
;
718 u8 lowcyl
= 0, highcyl
= 0;
719 int dma
= info
->dma
, dma_error
= 0;
721 struct request
*rq
= HWGROUP(drive
)->rq
;
728 dma_error
= HWIF(drive
)->ide_dma_end(drive
);
730 printk(KERN_ERR
"%s: DMA read error\n", drive
->name
);
735 if (cdrom_decode_status(drive
, 0, &stat
))
740 ide_end_request(drive
, 1, rq
->nr_sectors
);
743 return ide_error(drive
, "dma error", stat
);
746 /* Read the interrupt reason and the transfer length. */
747 ireason
= HWIF(drive
)->INB(IDE_IREASON_REG
) & 0x3;
748 lowcyl
= HWIF(drive
)->INB(IDE_BCOUNTL_REG
);
749 highcyl
= HWIF(drive
)->INB(IDE_BCOUNTH_REG
);
751 len
= lowcyl
+ (256 * highcyl
);
753 /* If DRQ is clear, the command has completed. */
754 if ((stat
& DRQ_STAT
) == 0) {
755 /* If we're not done filling the current buffer, complain.
756 Otherwise, complete the command normally. */
757 if (rq
->current_nr_sectors
> 0) {
758 printk (KERN_ERR
"%s: cdrom_read_intr: data underrun (%d blocks)\n",
759 drive
->name
, rq
->current_nr_sectors
);
760 rq
->cmd_flags
|= REQ_FAILED
;
761 cdrom_end_request(drive
, 0);
763 cdrom_end_request(drive
, 1);
767 /* Check that the drive is expecting to do the same thing we are. */
768 if (cdrom_read_check_ireason (drive
, len
, ireason
))
771 /* Assume that the drive will always provide data in multiples
772 of at least SECTOR_SIZE, as it gets hairy to keep track
773 of the transfers otherwise. */
774 if ((len
% SECTOR_SIZE
) != 0) {
775 printk (KERN_ERR
"%s: cdrom_read_intr: Bad transfer size %d\n",
777 if (info
->cd_flags
& IDE_CD_FLAG_LIMIT_NFRAMES
)
778 printk (KERN_ERR
" This drive is not supported by this version of the driver\n");
780 printk (KERN_ERR
" Trying to limit transfer sizes\n");
781 info
->cd_flags
|= IDE_CD_FLAG_LIMIT_NFRAMES
;
783 cdrom_end_request(drive
, 0);
787 /* The number of sectors we need to read from the drive. */
788 sectors_to_transfer
= len
/ SECTOR_SIZE
;
790 /* First, figure out if we need to bit-bucket
791 any of the leading sectors. */
792 nskip
= min_t(int, rq
->current_nr_sectors
- bio_cur_sectors(rq
->bio
), sectors_to_transfer
);
795 /* We need to throw away a sector. */
796 static char dum
[SECTOR_SIZE
];
797 HWIF(drive
)->atapi_input_bytes(drive
, dum
, sizeof (dum
));
799 --rq
->current_nr_sectors
;
801 --sectors_to_transfer
;
804 /* Now loop while we still have data to read from the drive. */
805 while (sectors_to_transfer
> 0) {
808 /* If we've filled the present buffer but there's another
809 chained buffer after it, move on. */
810 if (rq
->current_nr_sectors
== 0 && rq
->nr_sectors
)
811 cdrom_end_request(drive
, 1);
813 /* If the buffers are full, cache the rest of the data in our
815 if (rq
->current_nr_sectors
== 0) {
816 cdrom_buffer_sectors(drive
, rq
->sector
, sectors_to_transfer
);
817 sectors_to_transfer
= 0;
819 /* Transfer data to the buffers.
820 Figure out how many sectors we can transfer
821 to the current buffer. */
822 this_transfer
= min_t(int, sectors_to_transfer
,
823 rq
->current_nr_sectors
);
825 /* Read this_transfer sectors
826 into the current buffer. */
827 while (this_transfer
> 0) {
828 HWIF(drive
)->atapi_input_bytes(drive
, rq
->buffer
, SECTOR_SIZE
);
829 rq
->buffer
+= SECTOR_SIZE
;
831 --rq
->current_nr_sectors
;
834 --sectors_to_transfer
;
839 /* Done moving data! Wait for another interrupt. */
840 ide_set_handler(drive
, &cdrom_read_intr
, ATAPI_WAIT_PC
, NULL
);
845 * Try to satisfy some of the current read request from our cached data.
846 * Returns nonzero if the request has been completed, zero otherwise.
848 static int cdrom_read_from_buffer (ide_drive_t
*drive
)
850 struct cdrom_info
*info
= drive
->driver_data
;
851 struct request
*rq
= HWGROUP(drive
)->rq
;
852 unsigned short sectors_per_frame
;
854 sectors_per_frame
= queue_hardsect_size(drive
->queue
) >> SECTOR_BITS
;
856 /* Can't do anything if there's no buffer. */
857 if (info
->buffer
== NULL
) return 0;
859 /* Loop while this request needs data and the next block is present
861 while (rq
->nr_sectors
> 0 &&
862 rq
->sector
>= info
->sector_buffered
&&
863 rq
->sector
< info
->sector_buffered
+ info
->nsectors_buffered
) {
864 if (rq
->current_nr_sectors
== 0)
865 cdrom_end_request(drive
, 1);
869 (rq
->sector
- info
->sector_buffered
) * SECTOR_SIZE
,
871 rq
->buffer
+= SECTOR_SIZE
;
872 --rq
->current_nr_sectors
;
877 /* If we've satisfied the current request,
878 terminate it successfully. */
879 if (rq
->nr_sectors
== 0) {
880 cdrom_end_request(drive
, 1);
884 /* Move on to the next buffer if needed. */
885 if (rq
->current_nr_sectors
== 0)
886 cdrom_end_request(drive
, 1);
888 /* If this condition does not hold, then the kluge i use to
889 represent the number of sectors to skip at the start of a transfer
890 will fail. I think that this will never happen, but let's be
891 paranoid and check. */
892 if (rq
->current_nr_sectors
< bio_cur_sectors(rq
->bio
) &&
893 (rq
->sector
& (sectors_per_frame
- 1))) {
894 printk(KERN_ERR
"%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
895 drive
->name
, (long)rq
->sector
);
896 cdrom_end_request(drive
, 0);
904 * Routine to send a read packet command to the drive.
905 * This is usually called directly from cdrom_start_read.
906 * However, for drq_interrupt devices, it is called from an interrupt
907 * when the drive is ready to accept the command.
909 static ide_startstop_t
cdrom_start_read_continuation (ide_drive_t
*drive
)
911 struct request
*rq
= HWGROUP(drive
)->rq
;
912 unsigned short sectors_per_frame
;
915 sectors_per_frame
= queue_hardsect_size(drive
->queue
) >> SECTOR_BITS
;
917 /* If the requested sector doesn't start on a cdrom block boundary,
918 we must adjust the start of the transfer so that it does,
919 and remember to skip the first few sectors.
920 If the CURRENT_NR_SECTORS field is larger than the size
921 of the buffer, it will mean that we're to skip a number
922 of sectors equal to the amount by which CURRENT_NR_SECTORS
923 is larger than the buffer size. */
924 nskip
= rq
->sector
& (sectors_per_frame
- 1);
926 /* Sanity check... */
927 if (rq
->current_nr_sectors
!= bio_cur_sectors(rq
->bio
) &&
928 (rq
->sector
& (sectors_per_frame
- 1))) {
929 printk(KERN_ERR
"%s: cdrom_start_read_continuation: buffer botch (%u)\n",
930 drive
->name
, rq
->current_nr_sectors
);
931 cdrom_end_request(drive
, 0);
934 rq
->current_nr_sectors
+= nskip
;
937 /* Set up the command */
938 rq
->timeout
= ATAPI_WAIT_PC
;
940 /* Send the command to the drive and return. */
941 return cdrom_transfer_packet_command(drive
, rq
, &cdrom_read_intr
);
945 #define IDECD_SEEK_THRESHOLD (1000) /* 1000 blocks */
946 #define IDECD_SEEK_TIMER (5 * WAIT_MIN_SLEEP) /* 100 ms */
947 #define IDECD_SEEK_TIMEOUT (2 * WAIT_CMD) /* 20 sec */
949 static ide_startstop_t
cdrom_seek_intr (ide_drive_t
*drive
)
951 struct cdrom_info
*info
= drive
->driver_data
;
953 static int retry
= 10;
955 if (cdrom_decode_status(drive
, 0, &stat
))
958 info
->cd_flags
|= IDE_CD_FLAG_SEEKING
;
960 if (retry
&& time_after(jiffies
, info
->start_seek
+ IDECD_SEEK_TIMER
)) {
963 * this condition is far too common, to bother
966 /* printk("%s: disabled DSC seek overlap\n", drive->name);*/
967 drive
->dsc_overlap
= 0;
973 static ide_startstop_t
cdrom_start_seek_continuation (ide_drive_t
*drive
)
975 struct request
*rq
= HWGROUP(drive
)->rq
;
976 sector_t frame
= rq
->sector
;
978 sector_div(frame
, queue_hardsect_size(drive
->queue
) >> SECTOR_BITS
);
980 memset(rq
->cmd
, 0, sizeof(rq
->cmd
));
981 rq
->cmd
[0] = GPCMD_SEEK
;
982 put_unaligned(cpu_to_be32(frame
), (unsigned int *) &rq
->cmd
[2]);
984 rq
->timeout
= ATAPI_WAIT_PC
;
985 return cdrom_transfer_packet_command(drive
, rq
, &cdrom_seek_intr
);
988 static ide_startstop_t
cdrom_start_seek (ide_drive_t
*drive
, unsigned int block
)
990 struct cdrom_info
*info
= drive
->driver_data
;
993 info
->start_seek
= jiffies
;
994 return cdrom_start_packet_command(drive
, 0, cdrom_start_seek_continuation
);
997 /* Fix up a possibly partially-processed request so that we can
998 start it over entirely, or even put it back on the request queue. */
999 static void restore_request (struct request
*rq
)
1001 if (rq
->buffer
!= bio_data(rq
->bio
)) {
1002 sector_t n
= (rq
->buffer
- (char *) bio_data(rq
->bio
)) / SECTOR_SIZE
;
1004 rq
->buffer
= bio_data(rq
->bio
);
1005 rq
->nr_sectors
+= n
;
1008 rq
->hard_cur_sectors
= rq
->current_nr_sectors
= bio_cur_sectors(rq
->bio
);
1009 rq
->hard_nr_sectors
= rq
->nr_sectors
;
1010 rq
->hard_sector
= rq
->sector
;
1011 rq
->q
->prep_rq_fn(rq
->q
, rq
);
1015 * Start a read request from the CD-ROM.
1017 static ide_startstop_t
cdrom_start_read (ide_drive_t
*drive
, unsigned int block
)
1019 struct cdrom_info
*info
= drive
->driver_data
;
1020 struct request
*rq
= HWGROUP(drive
)->rq
;
1021 unsigned short sectors_per_frame
;
1023 sectors_per_frame
= queue_hardsect_size(drive
->queue
) >> SECTOR_BITS
;
1025 /* We may be retrying this request after an error. Fix up
1026 any weirdness which might be present in the request packet. */
1027 restore_request(rq
);
1029 /* Satisfy whatever we can of this request from our cached sector. */
1030 if (cdrom_read_from_buffer(drive
))
1033 /* Clear the local sector buffer. */
1034 info
->nsectors_buffered
= 0;
1036 /* use dma, if possible. */
1037 info
->dma
= drive
->using_dma
;
1038 if ((rq
->sector
& (sectors_per_frame
- 1)) ||
1039 (rq
->nr_sectors
& (sectors_per_frame
- 1)))
1042 /* Start sending the read request to the drive. */
1043 return cdrom_start_packet_command(drive
, 32768, cdrom_start_read_continuation
);
1046 /****************************************************************************
1047 * Execute all other packet commands.
1050 /* Interrupt routine for packet command completion. */
1051 static ide_startstop_t
cdrom_pc_intr (ide_drive_t
*drive
)
1053 struct request
*rq
= HWGROUP(drive
)->rq
;
1054 xfer_func_t
*xferfunc
= NULL
;
1055 int stat
, ireason
, len
, thislen
, write
;
1056 u8 lowcyl
= 0, highcyl
= 0;
1058 /* Check for errors. */
1059 if (cdrom_decode_status(drive
, 0, &stat
))
1062 /* Read the interrupt reason and the transfer length. */
1063 ireason
= HWIF(drive
)->INB(IDE_IREASON_REG
) & 0x3;
1064 lowcyl
= HWIF(drive
)->INB(IDE_BCOUNTL_REG
);
1065 highcyl
= HWIF(drive
)->INB(IDE_BCOUNTH_REG
);
1067 len
= lowcyl
+ (256 * highcyl
);
1069 /* If DRQ is clear, the command has completed.
1070 Complain if we still have data left to transfer. */
1071 if ((stat
& DRQ_STAT
) == 0) {
1072 /* Some of the trailing request sense fields are optional, and
1073 some drives don't send them. Sigh. */
1074 if (rq
->cmd
[0] == GPCMD_REQUEST_SENSE
&&
1076 rq
->data_len
<= 5) {
1077 while (rq
->data_len
> 0) {
1078 *(unsigned char *)rq
->data
++ = 0;
1083 if (rq
->data_len
== 0)
1084 cdrom_end_request(drive
, 1);
1086 rq
->cmd_flags
|= REQ_FAILED
;
1087 cdrom_end_request(drive
, 0);
1092 /* Figure out how much data to transfer. */
1093 thislen
= rq
->data_len
;
1099 xferfunc
= HWIF(drive
)->atapi_output_bytes
;
1100 } else if (ireason
== 2) {
1102 xferfunc
= HWIF(drive
)->atapi_input_bytes
;
1107 printk(KERN_ERR
"%s: confused, missing data\n",
1109 blk_dump_rq_flags(rq
, write
? "cdrom_pc_intr, write"
1110 : "cdrom_pc_intr, read");
1113 /* Transfer the data. */
1114 xferfunc(drive
, rq
->data
, thislen
);
1116 /* Keep count of how much data we've moved. */
1118 rq
->data
+= thislen
;
1119 rq
->data_len
-= thislen
;
1121 if (write
&& blk_sense_request(rq
))
1122 rq
->sense_len
+= thislen
;
1124 printk (KERN_ERR
"%s: cdrom_pc_intr: The drive "
1125 "appears confused (ireason = 0x%02x). "
1126 "Trying to recover by ending request.\n",
1127 drive
->name
, ireason
);
1128 rq
->cmd_flags
|= REQ_FAILED
;
1129 cdrom_end_request(drive
, 0);
1134 * If we haven't moved enough data to satisfy the drive,
1138 ide_cd_pad_transfer(drive
, xferfunc
, len
);
1140 /* Now we wait for another interrupt. */
1141 ide_set_handler(drive
, &cdrom_pc_intr
, ATAPI_WAIT_PC
, cdrom_timer_expiry
);
1145 static ide_startstop_t
cdrom_do_pc_continuation (ide_drive_t
*drive
)
1147 struct request
*rq
= HWGROUP(drive
)->rq
;
1150 rq
->timeout
= ATAPI_WAIT_PC
;
1152 /* Send the command to the drive and return. */
1153 return cdrom_transfer_packet_command(drive
, rq
, &cdrom_pc_intr
);
1157 static ide_startstop_t
cdrom_do_packet_command (ide_drive_t
*drive
)
1160 struct request
*rq
= HWGROUP(drive
)->rq
;
1161 struct cdrom_info
*info
= drive
->driver_data
;
1164 rq
->cmd_flags
&= ~REQ_FAILED
;
1167 /* Start sending the command to the drive. */
1168 return cdrom_start_packet_command(drive
, len
, cdrom_do_pc_continuation
);
1171 int ide_cd_queue_pc(ide_drive_t
*drive
, struct request
*rq
)
1173 struct request_sense sense
;
1175 unsigned int flags
= rq
->cmd_flags
;
1177 if (rq
->sense
== NULL
)
1180 /* Start of retry loop. */
1183 unsigned long time
= jiffies
;
1184 rq
->cmd_flags
= flags
;
1186 error
= ide_do_drive_cmd(drive
, rq
, ide_wait
);
1187 time
= jiffies
- time
;
1189 /* FIXME: we should probably abort/retry or something
1190 * in case of failure */
1191 if (rq
->cmd_flags
& REQ_FAILED
) {
1192 /* The request failed. Retry if it was due to a unit
1194 (usually means media was changed). */
1195 struct request_sense
*reqbuf
= rq
->sense
;
1197 if (reqbuf
->sense_key
== UNIT_ATTENTION
)
1198 cdrom_saw_media_change(drive
);
1199 else if (reqbuf
->sense_key
== NOT_READY
&&
1200 reqbuf
->asc
== 4 && reqbuf
->ascq
!= 4) {
1201 /* The drive is in the process of loading
1202 a disk. Retry, but wait a little to give
1203 the drive time to complete the load. */
1206 /* Otherwise, don't retry. */
1212 /* End of retry loop. */
1213 } while ((rq
->cmd_flags
& REQ_FAILED
) && retries
>= 0);
1215 /* Return an error if the command failed. */
1216 return (rq
->cmd_flags
& REQ_FAILED
) ? -EIO
: 0;
1222 static int cdrom_write_check_ireason(ide_drive_t
*drive
, int len
, int ireason
)
1224 /* Two notes about IDE interrupt reason here - 0 means that
1225 * the drive wants to receive data from us, 2 means that
1226 * the drive is expecting to transfer data to us.
1230 else if (ireason
== 2) {
1231 ide_hwif_t
*hwif
= drive
->hwif
;
1233 /* Whoops... The drive wants to send data. */
1234 printk(KERN_ERR
"%s: %s: wrong transfer direction!\n",
1235 drive
->name
, __FUNCTION__
);
1237 ide_cd_pad_transfer(drive
, hwif
->atapi_input_bytes
, len
);
1239 /* Drive wants a command packet, or invalid ireason... */
1240 printk(KERN_ERR
"%s: %s: bad interrupt reason 0x%02x\n",
1241 drive
->name
, __FUNCTION__
, ireason
);
1244 cdrom_end_request(drive
, 0);
1249 * Called from blk_end_request_callback() after the data of the request
1250 * is completed and before the request is completed.
1251 * By returning value '1', blk_end_request_callback() returns immediately
1252 * without completing the request.
1254 static int cdrom_newpc_intr_dummy_cb(struct request
*rq
)
1260 * best way to deal with dma that is not sector aligned right now... note
1261 * that in this path we are not using ->data or ->buffer at all. this irs
1262 * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the
1265 static ide_startstop_t
cdrom_newpc_intr(ide_drive_t
*drive
)
1267 struct cdrom_info
*info
= drive
->driver_data
;
1268 struct request
*rq
= HWGROUP(drive
)->rq
;
1269 int dma_error
, dma
, stat
, ireason
, len
, thislen
;
1271 xfer_func_t
*xferfunc
;
1272 unsigned long flags
;
1274 /* Check for errors. */
1279 dma_error
= HWIF(drive
)->ide_dma_end(drive
);
1281 printk(KERN_ERR
"%s: DMA %s error\n", drive
->name
,
1282 rq_data_dir(rq
) ? "write" : "read");
1287 if (cdrom_decode_status(drive
, 0, &stat
))
1291 * using dma, transfer is complete now
1295 return ide_error(drive
, "dma error", stat
);
1297 spin_lock_irqsave(&ide_lock
, flags
);
1298 if (__blk_end_request(rq
, 0, rq
->data_len
))
1300 HWGROUP(drive
)->rq
= NULL
;
1301 spin_unlock_irqrestore(&ide_lock
, flags
);
1307 * ok we fall to pio :/
1309 ireason
= HWIF(drive
)->INB(IDE_IREASON_REG
) & 0x3;
1310 lowcyl
= HWIF(drive
)->INB(IDE_BCOUNTL_REG
);
1311 highcyl
= HWIF(drive
)->INB(IDE_BCOUNTH_REG
);
1313 len
= lowcyl
+ (256 * highcyl
);
1314 thislen
= rq
->data_len
;
1319 * If DRQ is clear, the command has completed.
1321 if ((stat
& DRQ_STAT
) == 0) {
1322 spin_lock_irqsave(&ide_lock
, flags
);
1323 if (__blk_end_request(rq
, 0, rq
->data_len
))
1325 HWGROUP(drive
)->rq
= NULL
;
1326 spin_unlock_irqrestore(&ide_lock
, flags
);
1332 * check which way to transfer data
1334 if (rq_data_dir(rq
) == WRITE
) {
1338 if (cdrom_write_check_ireason(drive
, len
, ireason
))
1341 xferfunc
= HWIF(drive
)->atapi_output_bytes
;
1346 if (cdrom_read_check_ireason(drive
, len
, ireason
))
1349 xferfunc
= HWIF(drive
)->atapi_input_bytes
;
1355 while (thislen
> 0) {
1356 int blen
= blen
= rq
->data_len
;
1357 char *ptr
= rq
->data
;
1363 ptr
= bio_data(rq
->bio
);
1364 blen
= bio_iovec(rq
->bio
)->bv_len
;
1368 printk(KERN_ERR
"%s: confused, missing data\n",
1370 blk_dump_rq_flags(rq
, rq_data_dir(rq
)
1371 ? "cdrom_newpc_intr, write"
1372 : "cdrom_newpc_intr, read");
1379 xferfunc(drive
, ptr
, blen
);
1383 rq
->data_len
-= blen
;
1387 * The request can't be completed until DRQ is cleared.
1388 * So complete the data, but don't complete the request
1389 * using the dummy function for the callback feature
1390 * of blk_end_request_callback().
1392 blk_end_request_callback(rq
, 0, blen
,
1393 cdrom_newpc_intr_dummy_cb
);
1402 ide_cd_pad_transfer(drive
, xferfunc
, len
);
1404 ide_set_handler(drive
, cdrom_newpc_intr
, rq
->timeout
, NULL
);
1408 static ide_startstop_t
cdrom_write_intr(ide_drive_t
*drive
)
1410 int stat
, ireason
, len
, sectors_to_transfer
, uptodate
;
1411 struct cdrom_info
*info
= drive
->driver_data
;
1412 int dma_error
= 0, dma
= info
->dma
;
1413 u8 lowcyl
= 0, highcyl
= 0;
1415 struct request
*rq
= HWGROUP(drive
)->rq
;
1417 /* Check for errors. */
1420 dma_error
= HWIF(drive
)->ide_dma_end(drive
);
1422 printk(KERN_ERR
"%s: DMA write error\n", drive
->name
);
1427 if (cdrom_decode_status(drive
, 0, &stat
))
1431 * using dma, transfer is complete now
1435 return ide_error(drive
, "dma error", stat
);
1437 ide_end_request(drive
, 1, rq
->nr_sectors
);
1441 /* Read the interrupt reason and the transfer length. */
1442 ireason
= HWIF(drive
)->INB(IDE_IREASON_REG
) & 0x3;
1443 lowcyl
= HWIF(drive
)->INB(IDE_BCOUNTL_REG
);
1444 highcyl
= HWIF(drive
)->INB(IDE_BCOUNTH_REG
);
1446 len
= lowcyl
+ (256 * highcyl
);
1448 /* If DRQ is clear, the command has completed. */
1449 if ((stat
& DRQ_STAT
) == 0) {
1450 /* If we're not done writing, complain.
1451 * Otherwise, complete the command normally.
1454 if (rq
->current_nr_sectors
> 0) {
1455 printk(KERN_ERR
"%s: %s: data underrun (%d blocks)\n",
1456 drive
->name
, __FUNCTION__
,
1457 rq
->current_nr_sectors
);
1460 cdrom_end_request(drive
, uptodate
);
1464 /* Check that the drive is expecting to do the same thing we are. */
1465 if (cdrom_write_check_ireason(drive
, len
, ireason
))
1468 sectors_to_transfer
= len
/ SECTOR_SIZE
;
1471 * now loop and write out the data
1473 while (sectors_to_transfer
> 0) {
1476 if (!rq
->current_nr_sectors
) {
1477 printk(KERN_ERR
"%s: %s: confused, missing data\n",
1478 drive
->name
, __FUNCTION__
);
1483 * Figure out how many sectors we can transfer
1485 this_transfer
= min_t(int, sectors_to_transfer
, rq
->current_nr_sectors
);
1487 while (this_transfer
> 0) {
1488 HWIF(drive
)->atapi_output_bytes(drive
, rq
->buffer
, SECTOR_SIZE
);
1489 rq
->buffer
+= SECTOR_SIZE
;
1491 --rq
->current_nr_sectors
;
1494 --sectors_to_transfer
;
1498 * current buffer complete, move on
1500 if (rq
->current_nr_sectors
== 0 && rq
->nr_sectors
)
1501 cdrom_end_request(drive
, 1);
1504 /* re-arm handler */
1505 ide_set_handler(drive
, &cdrom_write_intr
, ATAPI_WAIT_PC
, NULL
);
1509 static ide_startstop_t
cdrom_start_write_cont(ide_drive_t
*drive
)
1511 struct request
*rq
= HWGROUP(drive
)->rq
;
1513 #if 0 /* the immediate bit */
1514 rq
->cmd
[1] = 1 << 3;
1516 rq
->timeout
= ATAPI_WAIT_PC
;
1518 return cdrom_transfer_packet_command(drive
, rq
, cdrom_write_intr
);
1521 static ide_startstop_t
cdrom_start_write(ide_drive_t
*drive
, struct request
*rq
)
1523 struct cdrom_info
*info
= drive
->driver_data
;
1524 struct gendisk
*g
= info
->disk
;
1525 unsigned short sectors_per_frame
= queue_hardsect_size(drive
->queue
) >> SECTOR_BITS
;
1528 * writes *must* be hardware frame aligned
1530 if ((rq
->nr_sectors
& (sectors_per_frame
- 1)) ||
1531 (rq
->sector
& (sectors_per_frame
- 1))) {
1532 cdrom_end_request(drive
, 0);
1537 * disk has become write protected
1540 cdrom_end_request(drive
, 0);
1544 info
->nsectors_buffered
= 0;
1546 /* use dma, if possible. we don't need to check more, since we
1547 * know that the transfer is always (at least!) frame aligned */
1548 info
->dma
= drive
->using_dma
? 1 : 0;
1550 info
->devinfo
.media_written
= 1;
1552 /* Start sending the write request to the drive. */
1553 return cdrom_start_packet_command(drive
, 32768, cdrom_start_write_cont
);
1556 static ide_startstop_t
cdrom_do_newpc_cont(ide_drive_t
*drive
)
1558 struct request
*rq
= HWGROUP(drive
)->rq
;
1561 rq
->timeout
= ATAPI_WAIT_PC
;
1563 return cdrom_transfer_packet_command(drive
, rq
, cdrom_newpc_intr
);
1566 static ide_startstop_t
cdrom_do_block_pc(ide_drive_t
*drive
, struct request
*rq
)
1568 struct cdrom_info
*info
= drive
->driver_data
;
1570 rq
->cmd_flags
|= REQ_QUIET
;
1578 int mask
= drive
->queue
->dma_alignment
;
1579 unsigned long addr
= (unsigned long) page_address(bio_page(rq
->bio
));
1581 info
->dma
= drive
->using_dma
;
1584 * check if dma is safe
1586 * NOTE! The "len" and "addr" checks should possibly have
1589 if ((rq
->data_len
& 15) || (addr
& mask
))
1593 /* Start sending the command to the drive. */
1594 return cdrom_start_packet_command(drive
, rq
->data_len
, cdrom_do_newpc_cont
);
1597 /****************************************************************************
1598 * cdrom driver request routine.
1600 static ide_startstop_t
1601 ide_do_rw_cdrom (ide_drive_t
*drive
, struct request
*rq
, sector_t block
)
1603 ide_startstop_t action
;
1604 struct cdrom_info
*info
= drive
->driver_data
;
1606 if (blk_fs_request(rq
)) {
1607 if (info
->cd_flags
& IDE_CD_FLAG_SEEKING
) {
1608 unsigned long elapsed
= jiffies
- info
->start_seek
;
1609 int stat
= HWIF(drive
)->INB(IDE_STATUS_REG
);
1611 if ((stat
& SEEK_STAT
) != SEEK_STAT
) {
1612 if (elapsed
< IDECD_SEEK_TIMEOUT
) {
1613 ide_stall_queue(drive
, IDECD_SEEK_TIMER
);
1616 printk (KERN_ERR
"%s: DSC timeout\n", drive
->name
);
1618 info
->cd_flags
&= ~IDE_CD_FLAG_SEEKING
;
1620 if ((rq_data_dir(rq
) == READ
) && IDE_LARGE_SEEK(info
->last_block
, block
, IDECD_SEEK_THRESHOLD
) && drive
->dsc_overlap
) {
1621 action
= cdrom_start_seek(drive
, block
);
1623 if (rq_data_dir(rq
) == READ
)
1624 action
= cdrom_start_read(drive
, block
);
1626 action
= cdrom_start_write(drive
, rq
);
1628 info
->last_block
= block
;
1630 } else if (rq
->cmd_type
== REQ_TYPE_SENSE
||
1631 rq
->cmd_type
== REQ_TYPE_ATA_PC
) {
1632 return cdrom_do_packet_command(drive
);
1633 } else if (blk_pc_request(rq
)) {
1634 return cdrom_do_block_pc(drive
, rq
);
1635 } else if (blk_special_request(rq
)) {
1637 * right now this can only be a reset...
1639 cdrom_end_request(drive
, 1);
1643 blk_dump_rq_flags(rq
, "ide-cd bad flags");
1644 cdrom_end_request(drive
, 0);
1650 /****************************************************************************
1653 * Routines which queue packet commands take as a final argument a pointer
1654 * to a request_sense struct. If execution of the command results
1655 * in an error with a CHECK CONDITION status, this structure will be filled
1656 * with the results of the subsequent request sense command. The pointer
1657 * can also be NULL, in which case no sense information is returned.
1661 void msf_from_bcd (struct atapi_msf
*msf
)
1663 msf
->minute
= BCD2BIN(msf
->minute
);
1664 msf
->second
= BCD2BIN(msf
->second
);
1665 msf
->frame
= BCD2BIN(msf
->frame
);
1668 static int cdrom_check_status(ide_drive_t
*drive
, struct request_sense
*sense
)
1671 struct cdrom_info
*info
= drive
->driver_data
;
1672 struct cdrom_device_info
*cdi
= &info
->devinfo
;
1674 ide_cd_init_rq(drive
, &req
);
1677 req
.cmd
[0] = GPCMD_TEST_UNIT_READY
;
1678 req
.cmd_flags
|= REQ_QUIET
;
1681 * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
1682 * switch CDs instead of supporting the LOAD_UNLOAD opcode.
1684 req
.cmd
[7] = cdi
->sanyo_slot
% 3;
1686 return ide_cd_queue_pc(drive
, &req
);
1689 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
1690 int ide_cd_lockdoor(ide_drive_t
*drive
, int lockflag
,
1691 struct request_sense
*sense
)
1693 struct cdrom_info
*cd
= drive
->driver_data
;
1694 struct request_sense my_sense
;
1701 /* If the drive cannot lock the door, just pretend. */
1702 if (cd
->cd_flags
& IDE_CD_FLAG_NO_DOORLOCK
) {
1705 ide_cd_init_rq(drive
, &req
);
1707 req
.cmd
[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL
;
1708 req
.cmd
[4] = lockflag
? 1 : 0;
1709 stat
= ide_cd_queue_pc(drive
, &req
);
1712 /* If we got an illegal field error, the drive
1713 probably cannot lock the door. */
1715 sense
->sense_key
== ILLEGAL_REQUEST
&&
1716 (sense
->asc
== 0x24 || sense
->asc
== 0x20)) {
1717 printk (KERN_ERR
"%s: door locking not supported\n",
1719 cd
->cd_flags
|= IDE_CD_FLAG_NO_DOORLOCK
;
1723 /* no medium, that's alright. */
1724 if (stat
!= 0 && sense
->sense_key
== NOT_READY
&& sense
->asc
== 0x3a)
1729 cd
->cd_flags
|= IDE_CD_FLAG_DOOR_LOCKED
;
1731 cd
->cd_flags
&= ~IDE_CD_FLAG_DOOR_LOCKED
;
1738 /* Eject the disk if EJECTFLAG is 0.
1739 If EJECTFLAG is 1, try to reload the disk. */
1740 static int cdrom_eject(ide_drive_t
*drive
, int ejectflag
,
1741 struct request_sense
*sense
)
1743 struct cdrom_info
*cd
= drive
->driver_data
;
1744 struct cdrom_device_info
*cdi
= &cd
->devinfo
;
1748 if ((cd
->cd_flags
& IDE_CD_FLAG_NO_EJECT
) && !ejectflag
)
1749 return -EDRIVE_CANT_DO_THIS
;
1751 /* reload fails on some drives, if the tray is locked */
1752 if ((cd
->cd_flags
& IDE_CD_FLAG_DOOR_LOCKED
) && ejectflag
)
1755 ide_cd_init_rq(drive
, &req
);
1757 /* only tell drive to close tray if open, if it can do that */
1758 if (ejectflag
&& (cdi
->mask
& CDC_CLOSE_TRAY
))
1762 req
.cmd
[0] = GPCMD_START_STOP_UNIT
;
1763 req
.cmd
[4] = loej
| (ejectflag
!= 0);
1765 return ide_cd_queue_pc(drive
, &req
);
1768 static int cdrom_read_capacity(ide_drive_t
*drive
, unsigned long *capacity
,
1769 unsigned long *sectors_per_frame
,
1770 struct request_sense
*sense
)
1780 ide_cd_init_rq(drive
, &req
);
1783 req
.cmd
[0] = GPCMD_READ_CDVD_CAPACITY
;
1784 req
.data
= (char *)&capbuf
;
1785 req
.data_len
= sizeof(capbuf
);
1786 req
.cmd_flags
|= REQ_QUIET
;
1788 stat
= ide_cd_queue_pc(drive
, &req
);
1790 *capacity
= 1 + be32_to_cpu(capbuf
.lba
);
1791 *sectors_per_frame
=
1792 be32_to_cpu(capbuf
.blocklen
) >> SECTOR_BITS
;
1798 static int cdrom_read_tocentry(ide_drive_t
*drive
, int trackno
, int msf_flag
,
1799 int format
, char *buf
, int buflen
,
1800 struct request_sense
*sense
)
1804 ide_cd_init_rq(drive
, &req
);
1808 req
.data_len
= buflen
;
1809 req
.cmd_flags
|= REQ_QUIET
;
1810 req
.cmd
[0] = GPCMD_READ_TOC_PMA_ATIP
;
1811 req
.cmd
[6] = trackno
;
1812 req
.cmd
[7] = (buflen
>> 8);
1813 req
.cmd
[8] = (buflen
& 0xff);
1814 req
.cmd
[9] = (format
<< 6);
1819 return ide_cd_queue_pc(drive
, &req
);
1822 /* Try to read the entire TOC for the disk into our internal buffer. */
1823 int ide_cd_read_toc(ide_drive_t
*drive
, struct request_sense
*sense
)
1825 int stat
, ntracks
, i
;
1826 struct cdrom_info
*info
= drive
->driver_data
;
1827 struct cdrom_device_info
*cdi
= &info
->devinfo
;
1828 struct atapi_toc
*toc
= info
->toc
;
1830 struct atapi_toc_header hdr
;
1831 struct atapi_toc_entry ent
;
1834 unsigned long sectors_per_frame
= SECTORS_PER_FRAME
;
1837 /* Try to allocate space. */
1838 toc
= kmalloc(sizeof(struct atapi_toc
), GFP_KERNEL
);
1840 printk (KERN_ERR
"%s: No cdrom TOC buffer!\n", drive
->name
);
1846 /* Check to see if the existing data is still valid.
1847 If it is, just return. */
1848 (void) cdrom_check_status(drive
, sense
);
1850 if (info
->cd_flags
& IDE_CD_FLAG_TOC_VALID
)
1853 /* Try to get the total cdrom capacity and sector size. */
1854 stat
= cdrom_read_capacity(drive
, &toc
->capacity
, §ors_per_frame
,
1857 toc
->capacity
= 0x1fffff;
1859 set_capacity(info
->disk
, toc
->capacity
* sectors_per_frame
);
1860 /* Save a private copy of te TOC capacity for error handling */
1861 drive
->probed_capacity
= toc
->capacity
* sectors_per_frame
;
1863 blk_queue_hardsect_size(drive
->queue
,
1864 sectors_per_frame
<< SECTOR_BITS
);
1866 /* First read just the header, so we know how long the TOC is. */
1867 stat
= cdrom_read_tocentry(drive
, 0, 1, 0, (char *) &toc
->hdr
,
1868 sizeof(struct atapi_toc_header
), sense
);
1872 if (info
->cd_flags
& IDE_CD_FLAG_TOCTRACKS_AS_BCD
) {
1873 toc
->hdr
.first_track
= BCD2BIN(toc
->hdr
.first_track
);
1874 toc
->hdr
.last_track
= BCD2BIN(toc
->hdr
.last_track
);
1877 ntracks
= toc
->hdr
.last_track
- toc
->hdr
.first_track
+ 1;
1880 if (ntracks
> MAX_TRACKS
)
1881 ntracks
= MAX_TRACKS
;
1883 /* Now read the whole schmeer. */
1884 stat
= cdrom_read_tocentry(drive
, toc
->hdr
.first_track
, 1, 0,
1886 sizeof(struct atapi_toc_header
) +
1888 sizeof(struct atapi_toc_entry
), sense
);
1890 if (stat
&& toc
->hdr
.first_track
> 1) {
1891 /* Cds with CDI tracks only don't have any TOC entries,
1892 despite of this the returned values are
1893 first_track == last_track = number of CDI tracks + 1,
1894 so that this case is indistinguishable from the same
1895 layout plus an additional audio track.
1896 If we get an error for the regular case, we assume
1897 a CDI without additional audio tracks. In this case
1898 the readable TOC is empty (CDI tracks are not included)
1899 and only holds the Leadout entry. Heiko Eißfeldt */
1901 stat
= cdrom_read_tocentry(drive
, CDROM_LEADOUT
, 1, 0,
1903 sizeof(struct atapi_toc_header
) +
1905 sizeof(struct atapi_toc_entry
),
1910 if (info
->cd_flags
& IDE_CD_FLAG_TOCTRACKS_AS_BCD
) {
1911 toc
->hdr
.first_track
= (u8
)BIN2BCD(CDROM_LEADOUT
);
1912 toc
->hdr
.last_track
= (u8
)BIN2BCD(CDROM_LEADOUT
);
1914 toc
->hdr
.first_track
= CDROM_LEADOUT
;
1915 toc
->hdr
.last_track
= CDROM_LEADOUT
;
1922 toc
->hdr
.toc_length
= ntohs (toc
->hdr
.toc_length
);
1924 if (info
->cd_flags
& IDE_CD_FLAG_TOCTRACKS_AS_BCD
) {
1925 toc
->hdr
.first_track
= BCD2BIN(toc
->hdr
.first_track
);
1926 toc
->hdr
.last_track
= BCD2BIN(toc
->hdr
.last_track
);
1929 for (i
= 0; i
<= ntracks
; i
++) {
1930 if (info
->cd_flags
& IDE_CD_FLAG_TOCADDR_AS_BCD
) {
1931 if (info
->cd_flags
& IDE_CD_FLAG_TOCTRACKS_AS_BCD
)
1932 toc
->ent
[i
].track
= BCD2BIN(toc
->ent
[i
].track
);
1933 msf_from_bcd(&toc
->ent
[i
].addr
.msf
);
1935 toc
->ent
[i
].addr
.lba
= msf_to_lba (toc
->ent
[i
].addr
.msf
.minute
,
1936 toc
->ent
[i
].addr
.msf
.second
,
1937 toc
->ent
[i
].addr
.msf
.frame
);
1940 /* Read the multisession information. */
1941 if (toc
->hdr
.first_track
!= CDROM_LEADOUT
) {
1942 /* Read the multisession information. */
1943 stat
= cdrom_read_tocentry(drive
, 0, 0, 1, (char *)&ms_tmp
,
1944 sizeof(ms_tmp
), sense
);
1948 toc
->last_session_lba
= be32_to_cpu(ms_tmp
.ent
.addr
.lba
);
1950 ms_tmp
.hdr
.first_track
= ms_tmp
.hdr
.last_track
= CDROM_LEADOUT
;
1951 toc
->last_session_lba
= msf_to_lba(0, 2, 0); /* 0m 2s 0f */
1954 if (info
->cd_flags
& IDE_CD_FLAG_TOCADDR_AS_BCD
) {
1955 /* Re-read multisession information using MSF format */
1956 stat
= cdrom_read_tocentry(drive
, 0, 1, 1, (char *)&ms_tmp
,
1957 sizeof(ms_tmp
), sense
);
1961 msf_from_bcd (&ms_tmp
.ent
.addr
.msf
);
1962 toc
->last_session_lba
= msf_to_lba(ms_tmp
.ent
.addr
.msf
.minute
,
1963 ms_tmp
.ent
.addr
.msf
.second
,
1964 ms_tmp
.ent
.addr
.msf
.frame
);
1967 toc
->xa_flag
= (ms_tmp
.hdr
.first_track
!= ms_tmp
.hdr
.last_track
);
1969 /* Now try to get the total cdrom capacity. */
1970 stat
= cdrom_get_last_written(cdi
, &last_written
);
1971 if (!stat
&& (last_written
> toc
->capacity
)) {
1972 toc
->capacity
= last_written
;
1973 set_capacity(info
->disk
, toc
->capacity
* sectors_per_frame
);
1974 drive
->probed_capacity
= toc
->capacity
* sectors_per_frame
;
1977 /* Remember that we've read this stuff. */
1978 info
->cd_flags
|= IDE_CD_FLAG_TOC_VALID
;
1983 /* the generic packet interface to cdrom.c */
1984 static int ide_cdrom_packet(struct cdrom_device_info
*cdi
,
1985 struct packet_command
*cgc
)
1988 ide_drive_t
*drive
= cdi
->handle
;
1990 if (cgc
->timeout
<= 0)
1991 cgc
->timeout
= ATAPI_WAIT_PC
;
1993 /* here we queue the commands from the uniform CD-ROM
1994 layer. the packet must be complete, as we do not
1996 ide_cd_init_rq(drive
, &req
);
1997 memcpy(req
.cmd
, cgc
->cmd
, CDROM_PACKET_SIZE
);
1999 memset(cgc
->sense
, 0, sizeof(struct request_sense
));
2000 req
.data
= cgc
->buffer
;
2001 req
.data_len
= cgc
->buflen
;
2002 req
.timeout
= cgc
->timeout
;
2005 req
.cmd_flags
|= REQ_QUIET
;
2007 req
.sense
= cgc
->sense
;
2008 cgc
->stat
= ide_cd_queue_pc(drive
, &req
);
2010 cgc
->buflen
-= req
.data_len
;
2015 int ide_cdrom_tray_move (struct cdrom_device_info
*cdi
, int position
)
2017 ide_drive_t
*drive
= cdi
->handle
;
2018 struct request_sense sense
;
2021 int stat
= ide_cd_lockdoor(drive
, 0, &sense
);
2027 return cdrom_eject(drive
, !position
, &sense
);
2030 int ide_cdrom_get_capabilities(ide_drive_t
*drive
, u8
*buf
)
2032 struct cdrom_info
*info
= drive
->driver_data
;
2033 struct cdrom_device_info
*cdi
= &info
->devinfo
;
2034 struct packet_command cgc
;
2035 int stat
, attempts
= 3, size
= ATAPI_CAPABILITIES_PAGE_SIZE
;
2037 if ((info
->cd_flags
& IDE_CD_FLAG_FULL_CAPS_PAGE
) == 0)
2038 size
-= ATAPI_CAPABILITIES_PAGE_PAD_SIZE
;
2040 init_cdrom_command(&cgc
, buf
, size
, CGC_DATA_UNKNOWN
);
2041 do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2042 stat
= cdrom_mode_sense(cdi
, &cgc
, GPMODE_CAPABILITIES_PAGE
, 0);
2045 } while (--attempts
);
2049 void ide_cdrom_update_speed(ide_drive_t
*drive
, u8
*buf
)
2051 struct cdrom_info
*cd
= drive
->driver_data
;
2052 u16 curspeed
, maxspeed
;
2054 curspeed
= *(u16
*)&buf
[8 + 14];
2055 maxspeed
= *(u16
*)&buf
[8 + 8];
2057 if (cd
->cd_flags
& IDE_CD_FLAG_LE_SPEED_FIELDS
) {
2058 curspeed
= le16_to_cpu(curspeed
);
2059 maxspeed
= le16_to_cpu(maxspeed
);
2061 curspeed
= be16_to_cpu(curspeed
);
2062 maxspeed
= be16_to_cpu(maxspeed
);
2065 cd
->current_speed
= (curspeed
+ (176/2)) / 176;
2066 cd
->max_speed
= (maxspeed
+ (176/2)) / 176;
2070 * add logic to try GET_EVENT command first to check for media and tray
2071 * status. this should be supported by newer cd-r/w and all DVD etc
2075 int ide_cdrom_drive_status (struct cdrom_device_info
*cdi
, int slot_nr
)
2077 ide_drive_t
*drive
= cdi
->handle
;
2078 struct media_event_desc med
;
2079 struct request_sense sense
;
2082 if (slot_nr
!= CDSL_CURRENT
)
2085 stat
= cdrom_check_status(drive
, &sense
);
2086 if (!stat
|| sense
.sense_key
== UNIT_ATTENTION
)
2089 if (!cdrom_get_media_event(cdi
, &med
)) {
2090 if (med
.media_present
)
2092 else if (med
.door_open
)
2093 return CDS_TRAY_OPEN
;
2098 if (sense
.sense_key
== NOT_READY
&& sense
.asc
== 0x04 && sense
.ascq
== 0x04)
2102 * If not using Mt Fuji extended media tray reports,
2103 * just return TRAY_OPEN since ATAPI doesn't provide
2104 * any other way to detect this...
2106 if (sense
.sense_key
== NOT_READY
) {
2107 if (sense
.asc
== 0x3a && sense
.ascq
== 1)
2110 return CDS_TRAY_OPEN
;
2112 return CDS_DRIVE_NOT_READY
;
2115 /****************************************************************************
2116 * Other driver requests (open, close, check media change).
2120 int ide_cdrom_check_media_change_real (struct cdrom_device_info
*cdi
,
2123 ide_drive_t
*drive
= cdi
->handle
;
2124 struct cdrom_info
*cd
= drive
->driver_data
;
2127 if (slot_nr
== CDSL_CURRENT
) {
2128 (void) cdrom_check_status(drive
, NULL
);
2129 retval
= (cd
->cd_flags
& IDE_CD_FLAG_MEDIA_CHANGED
) ? 1 : 0;
2130 cd
->cd_flags
&= ~IDE_CD_FLAG_MEDIA_CHANGED
;
2139 int ide_cdrom_open_real (struct cdrom_device_info
*cdi
, int purpose
)
2145 * Close down the device. Invalidate all cached blocks.
2149 void ide_cdrom_release_real (struct cdrom_device_info
*cdi
)
2151 ide_drive_t
*drive
= cdi
->handle
;
2152 struct cdrom_info
*cd
= drive
->driver_data
;
2154 if (!cdi
->use_count
)
2155 cd
->cd_flags
&= ~IDE_CD_FLAG_TOC_VALID
;
2158 #define IDE_CD_CAPABILITIES \
2159 (CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | CDC_SELECT_SPEED | \
2160 CDC_SELECT_DISC | CDC_MULTI_SESSION | CDC_MCN | CDC_MEDIA_CHANGED | \
2161 CDC_PLAY_AUDIO | CDC_RESET | CDC_DRIVE_STATUS | CDC_CD_R | \
2162 CDC_CD_RW | CDC_DVD | CDC_DVD_R | CDC_DVD_RAM | CDC_GENERIC_PACKET | \
2163 CDC_MO_DRIVE | CDC_MRW | CDC_MRW_W | CDC_RAM)
2165 static struct cdrom_device_ops ide_cdrom_dops
= {
2166 .open
= ide_cdrom_open_real
,
2167 .release
= ide_cdrom_release_real
,
2168 .drive_status
= ide_cdrom_drive_status
,
2169 .media_changed
= ide_cdrom_check_media_change_real
,
2170 .tray_move
= ide_cdrom_tray_move
,
2171 .lock_door
= ide_cdrom_lock_door
,
2172 .select_speed
= ide_cdrom_select_speed
,
2173 .get_last_session
= ide_cdrom_get_last_session
,
2174 .get_mcn
= ide_cdrom_get_mcn
,
2175 .reset
= ide_cdrom_reset
,
2176 .audio_ioctl
= ide_cdrom_audio_ioctl
,
2177 .capability
= IDE_CD_CAPABILITIES
,
2178 .generic_packet
= ide_cdrom_packet
,
2181 static int ide_cdrom_register (ide_drive_t
*drive
, int nslots
)
2183 struct cdrom_info
*info
= drive
->driver_data
;
2184 struct cdrom_device_info
*devinfo
= &info
->devinfo
;
2186 devinfo
->ops
= &ide_cdrom_dops
;
2187 devinfo
->speed
= info
->current_speed
;
2188 devinfo
->capacity
= nslots
;
2189 devinfo
->handle
= drive
;
2190 strcpy(devinfo
->name
, drive
->name
);
2192 if (info
->cd_flags
& IDE_CD_FLAG_NO_SPEED_SELECT
)
2193 devinfo
->mask
|= CDC_SELECT_SPEED
;
2195 devinfo
->disk
= info
->disk
;
2196 return register_cdrom(devinfo
);
2200 int ide_cdrom_probe_capabilities (ide_drive_t
*drive
)
2202 struct cdrom_info
*cd
= drive
->driver_data
;
2203 struct cdrom_device_info
*cdi
= &cd
->devinfo
;
2204 u8 buf
[ATAPI_CAPABILITIES_PAGE_SIZE
];
2205 mechtype_t mechtype
;
2208 cdi
->mask
= (CDC_CD_R
| CDC_CD_RW
| CDC_DVD
| CDC_DVD_R
|
2209 CDC_DVD_RAM
| CDC_SELECT_DISC
| CDC_PLAY_AUDIO
|
2210 CDC_MO_DRIVE
| CDC_RAM
);
2212 if (drive
->media
== ide_optical
) {
2213 cdi
->mask
&= ~(CDC_MO_DRIVE
| CDC_RAM
);
2214 printk(KERN_ERR
"%s: ATAPI magneto-optical drive\n", drive
->name
);
2218 if (cd
->cd_flags
& IDE_CD_FLAG_PRE_ATAPI12
) {
2219 cd
->cd_flags
&= ~IDE_CD_FLAG_NO_EJECT
;
2220 cdi
->mask
&= ~CDC_PLAY_AUDIO
;
2225 * we have to cheat a little here. the packet will eventually
2226 * be queued with ide_cdrom_packet(), which extracts the
2227 * drive from cdi->handle. Since this device hasn't been
2228 * registered with the Uniform layer yet, it can't do this.
2229 * Same goes for cdi->ops.
2231 cdi
->handle
= drive
;
2232 cdi
->ops
= &ide_cdrom_dops
;
2234 if (ide_cdrom_get_capabilities(drive
, buf
))
2237 if ((buf
[8 + 6] & 0x01) == 0)
2238 cd
->cd_flags
|= IDE_CD_FLAG_NO_DOORLOCK
;
2239 if (buf
[8 + 6] & 0x08)
2240 cd
->cd_flags
&= ~IDE_CD_FLAG_NO_EJECT
;
2241 if (buf
[8 + 3] & 0x01)
2242 cdi
->mask
&= ~CDC_CD_R
;
2243 if (buf
[8 + 3] & 0x02)
2244 cdi
->mask
&= ~(CDC_CD_RW
| CDC_RAM
);
2245 if (buf
[8 + 2] & 0x38)
2246 cdi
->mask
&= ~CDC_DVD
;
2247 if (buf
[8 + 3] & 0x20)
2248 cdi
->mask
&= ~(CDC_DVD_RAM
| CDC_RAM
);
2249 if (buf
[8 + 3] & 0x10)
2250 cdi
->mask
&= ~CDC_DVD_R
;
2251 if ((buf
[8 + 4] & 0x01) || (cd
->cd_flags
& IDE_CD_FLAG_PLAY_AUDIO_OK
))
2252 cdi
->mask
&= ~CDC_PLAY_AUDIO
;
2254 mechtype
= buf
[8 + 6] >> 5;
2255 if (mechtype
== mechtype_caddy
|| mechtype
== mechtype_popup
)
2256 cdi
->mask
|= CDC_CLOSE_TRAY
;
2258 if (cdi
->sanyo_slot
> 0) {
2259 cdi
->mask
&= ~CDC_SELECT_DISC
;
2261 } else if (mechtype
== mechtype_individual_changer
||
2262 mechtype
== mechtype_cartridge_changer
) {
2263 nslots
= cdrom_number_of_slots(cdi
);
2265 cdi
->mask
&= ~CDC_SELECT_DISC
;
2268 ide_cdrom_update_speed(drive
, buf
);
2270 printk(KERN_INFO
"%s: ATAPI", drive
->name
);
2272 /* don't print speed if the drive reported 0 */
2274 printk(KERN_CONT
" %dX", cd
->max_speed
);
2276 printk(KERN_CONT
" %s", (cdi
->mask
& CDC_DVD
) ? "CD-ROM" : "DVD-ROM");
2278 if ((cdi
->mask
& CDC_DVD_R
) == 0 || (cdi
->mask
& CDC_DVD_RAM
) == 0)
2279 printk(KERN_CONT
" DVD%s%s",
2280 (cdi
->mask
& CDC_DVD_R
) ? "" : "-R",
2281 (cdi
->mask
& CDC_DVD_RAM
) ? "" : "-RAM");
2283 if ((cdi
->mask
& CDC_CD_R
) == 0 || (cdi
->mask
& CDC_CD_RW
) == 0)
2284 printk(KERN_CONT
" CD%s%s",
2285 (cdi
->mask
& CDC_CD_R
) ? "" : "-R",
2286 (cdi
->mask
& CDC_CD_RW
) ? "" : "/RW");
2288 if ((cdi
->mask
& CDC_SELECT_DISC
) == 0)
2289 printk(KERN_CONT
" changer w/%d slots", nslots
);
2291 printk(KERN_CONT
" drive");
2293 printk(KERN_CONT
", %dkB Cache\n", be16_to_cpu(*(u16
*)&buf
[8 + 12]));
2298 #ifdef CONFIG_IDE_PROC_FS
2299 static void ide_cdrom_add_settings(ide_drive_t
*drive
)
2301 ide_add_setting(drive
, "dsc_overlap", SETTING_RW
, TYPE_BYTE
, 0, 1, 1, 1, &drive
->dsc_overlap
, NULL
);
2304 static inline void ide_cdrom_add_settings(ide_drive_t
*drive
) { ; }
2308 * standard prep_rq_fn that builds 10 byte cmds
2310 static int ide_cdrom_prep_fs(struct request_queue
*q
, struct request
*rq
)
2312 int hard_sect
= queue_hardsect_size(q
);
2313 long block
= (long)rq
->hard_sector
/ (hard_sect
>> 9);
2314 unsigned long blocks
= rq
->hard_nr_sectors
/ (hard_sect
>> 9);
2316 memset(rq
->cmd
, 0, sizeof(rq
->cmd
));
2318 if (rq_data_dir(rq
) == READ
)
2319 rq
->cmd
[0] = GPCMD_READ_10
;
2321 rq
->cmd
[0] = GPCMD_WRITE_10
;
2326 rq
->cmd
[2] = (block
>> 24) & 0xff;
2327 rq
->cmd
[3] = (block
>> 16) & 0xff;
2328 rq
->cmd
[4] = (block
>> 8) & 0xff;
2329 rq
->cmd
[5] = block
& 0xff;
2332 * and transfer length
2334 rq
->cmd
[7] = (blocks
>> 8) & 0xff;
2335 rq
->cmd
[8] = blocks
& 0xff;
2341 * Most of the SCSI commands are supported directly by ATAPI devices.
2342 * This transform handles the few exceptions.
2344 static int ide_cdrom_prep_pc(struct request
*rq
)
2349 * Transform 6-byte read/write commands to the 10-byte version
2351 if (c
[0] == READ_6
|| c
[0] == WRITE_6
) {
2358 c
[0] += (READ_10
- READ_6
);
2364 * it's silly to pretend we understand 6-byte sense commands, just
2365 * reject with ILLEGAL_REQUEST and the caller should take the
2366 * appropriate action
2368 if (c
[0] == MODE_SENSE
|| c
[0] == MODE_SELECT
) {
2369 rq
->errors
= ILLEGAL_REQUEST
;
2370 return BLKPREP_KILL
;
2376 static int ide_cdrom_prep_fn(struct request_queue
*q
, struct request
*rq
)
2378 if (blk_fs_request(rq
))
2379 return ide_cdrom_prep_fs(q
, rq
);
2380 else if (blk_pc_request(rq
))
2381 return ide_cdrom_prep_pc(rq
);
2386 struct cd_list_entry
{
2387 const char *id_model
;
2388 const char *id_firmware
;
2389 unsigned int cd_flags
;
2392 static const struct cd_list_entry ide_cd_quirks_list
[] = {
2393 /* Limit transfer size per interrupt. */
2394 { "SAMSUNG CD-ROM SCR-2430", NULL
, IDE_CD_FLAG_LIMIT_NFRAMES
},
2395 { "SAMSUNG CD-ROM SCR-2432", NULL
, IDE_CD_FLAG_LIMIT_NFRAMES
},
2396 /* SCR-3231 doesn't support the SET_CD_SPEED command. */
2397 { "SAMSUNG CD-ROM SCR-3231", NULL
, IDE_CD_FLAG_NO_SPEED_SELECT
},
2398 /* Old NEC260 (not R) was released before ATAPI 1.2 spec. */
2399 { "NEC CD-ROM DRIVE:260", "1.01", IDE_CD_FLAG_TOCADDR_AS_BCD
|
2400 IDE_CD_FLAG_PRE_ATAPI12
, },
2401 /* Vertos 300, some versions of this drive like to talk BCD. */
2402 { "V003S0DS", NULL
, IDE_CD_FLAG_VERTOS_300_SSD
, },
2403 /* Vertos 600 ESD. */
2404 { "V006E0DS", NULL
, IDE_CD_FLAG_VERTOS_600_ESD
, },
2406 * Sanyo 3 CD changer uses a non-standard command for CD changing
2407 * (by default standard ATAPI support for CD changers is used).
2409 { "CD-ROM CDR-C3 G", NULL
, IDE_CD_FLAG_SANYO_3CD
},
2410 { "CD-ROM CDR-C3G", NULL
, IDE_CD_FLAG_SANYO_3CD
},
2411 { "CD-ROM CDR_C36", NULL
, IDE_CD_FLAG_SANYO_3CD
},
2412 /* Stingray 8X CD-ROM. */
2413 { "STINGRAY 8422 IDE 8X CD-ROM 7-27-95", NULL
, IDE_CD_FLAG_PRE_ATAPI12
},
2415 * ACER 50X CD-ROM and WPI 32X CD-ROM require the full spec length
2416 * mode sense page capabilities size, but older drives break.
2418 { "ATAPI CD ROM DRIVE 50X MAX", NULL
, IDE_CD_FLAG_FULL_CAPS_PAGE
},
2419 { "WPI CDS-32X", NULL
, IDE_CD_FLAG_FULL_CAPS_PAGE
},
2420 /* ACER/AOpen 24X CD-ROM has the speed fields byte-swapped. */
2421 { "", "241N", IDE_CD_FLAG_LE_SPEED_FIELDS
},
2423 * Some drives used by Apple don't advertise audio play
2424 * but they do support reading TOC & audio datas.
2426 { "MATSHITADVD-ROM SR-8187", NULL
, IDE_CD_FLAG_PLAY_AUDIO_OK
},
2427 { "MATSHITADVD-ROM SR-8186", NULL
, IDE_CD_FLAG_PLAY_AUDIO_OK
},
2428 { "MATSHITADVD-ROM SR-8176", NULL
, IDE_CD_FLAG_PLAY_AUDIO_OK
},
2429 { "MATSHITADVD-ROM SR-8174", NULL
, IDE_CD_FLAG_PLAY_AUDIO_OK
},
2433 static unsigned int ide_cd_flags(struct hd_driveid
*id
)
2435 const struct cd_list_entry
*cle
= ide_cd_quirks_list
;
2437 while (cle
->id_model
) {
2438 if (strcmp(cle
->id_model
, id
->model
) == 0 &&
2439 (cle
->id_firmware
== NULL
||
2440 strstr(id
->fw_rev
, cle
->id_firmware
)))
2441 return cle
->cd_flags
;
2449 int ide_cdrom_setup (ide_drive_t
*drive
)
2451 struct cdrom_info
*cd
= drive
->driver_data
;
2452 struct cdrom_device_info
*cdi
= &cd
->devinfo
;
2453 struct hd_driveid
*id
= drive
->id
;
2456 blk_queue_prep_rq(drive
->queue
, ide_cdrom_prep_fn
);
2457 blk_queue_dma_alignment(drive
->queue
, 31);
2458 drive
->queue
->unplug_delay
= (1 * HZ
) / 1000;
2459 if (!drive
->queue
->unplug_delay
)
2460 drive
->queue
->unplug_delay
= 1;
2462 drive
->special
.all
= 0;
2464 cd
->cd_flags
= IDE_CD_FLAG_MEDIA_CHANGED
| IDE_CD_FLAG_NO_EJECT
|
2467 if ((id
->config
& 0x0060) == 0x20)
2468 cd
->cd_flags
|= IDE_CD_FLAG_DRQ_INTERRUPT
;
2470 if ((cd
->cd_flags
& IDE_CD_FLAG_VERTOS_300_SSD
) &&
2471 id
->fw_rev
[4] == '1' && id
->fw_rev
[6] <= '2')
2472 cd
->cd_flags
|= (IDE_CD_FLAG_TOCTRACKS_AS_BCD
|
2473 IDE_CD_FLAG_TOCADDR_AS_BCD
);
2474 else if ((cd
->cd_flags
& IDE_CD_FLAG_VERTOS_600_ESD
) &&
2475 id
->fw_rev
[4] == '1' && id
->fw_rev
[6] <= '2')
2476 cd
->cd_flags
|= IDE_CD_FLAG_TOCTRACKS_AS_BCD
;
2477 else if (cd
->cd_flags
& IDE_CD_FLAG_SANYO_3CD
)
2478 cdi
->sanyo_slot
= 3; /* 3 => use CD in slot 0 */
2480 nslots
= ide_cdrom_probe_capabilities (drive
);
2483 * set correct block size
2485 blk_queue_hardsect_size(drive
->queue
, CD_FRAMESIZE
);
2487 if (drive
->autotune
== IDE_TUNE_DEFAULT
||
2488 drive
->autotune
== IDE_TUNE_AUTO
)
2489 drive
->dsc_overlap
= (drive
->next
!= drive
);
2491 if (ide_cdrom_register(drive
, nslots
)) {
2492 printk (KERN_ERR
"%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive
->name
);
2493 cd
->devinfo
.handle
= NULL
;
2496 ide_cdrom_add_settings(drive
);
2500 #ifdef CONFIG_IDE_PROC_FS
2502 sector_t
ide_cdrom_capacity (ide_drive_t
*drive
)
2504 unsigned long capacity
, sectors_per_frame
;
2506 if (cdrom_read_capacity(drive
, &capacity
, §ors_per_frame
, NULL
))
2509 return capacity
* sectors_per_frame
;
2513 static void ide_cd_remove(ide_drive_t
*drive
)
2515 struct cdrom_info
*info
= drive
->driver_data
;
2517 ide_proc_unregister_driver(drive
, info
->driver
);
2519 del_gendisk(info
->disk
);
2524 static void ide_cd_release(struct kref
*kref
)
2526 struct cdrom_info
*info
= to_ide_cd(kref
);
2527 struct cdrom_device_info
*devinfo
= &info
->devinfo
;
2528 ide_drive_t
*drive
= info
->drive
;
2529 struct gendisk
*g
= info
->disk
;
2531 kfree(info
->buffer
);
2533 if (devinfo
->handle
== drive
&& unregister_cdrom(devinfo
))
2534 printk(KERN_ERR
"%s: %s failed to unregister device from the cdrom "
2535 "driver.\n", __FUNCTION__
, drive
->name
);
2536 drive
->dsc_overlap
= 0;
2537 drive
->driver_data
= NULL
;
2538 blk_queue_prep_rq(drive
->queue
, NULL
);
2539 g
->private_data
= NULL
;
2544 static int ide_cd_probe(ide_drive_t
*);
2546 #ifdef CONFIG_IDE_PROC_FS
2547 static int proc_idecd_read_capacity
2548 (char *page
, char **start
, off_t off
, int count
, int *eof
, void *data
)
2550 ide_drive_t
*drive
= data
;
2553 len
= sprintf(page
,"%llu\n", (long long)ide_cdrom_capacity(drive
));
2554 PROC_IDE_READ_RETURN(page
,start
,off
,count
,eof
,len
);
2557 static ide_proc_entry_t idecd_proc
[] = {
2558 { "capacity", S_IFREG
|S_IRUGO
, proc_idecd_read_capacity
, NULL
},
2559 { NULL
, 0, NULL
, NULL
}
2563 static ide_driver_t ide_cdrom_driver
= {
2565 .owner
= THIS_MODULE
,
2566 .name
= "ide-cdrom",
2567 .bus
= &ide_bus_type
,
2569 .probe
= ide_cd_probe
,
2570 .remove
= ide_cd_remove
,
2571 .version
= IDECD_VERSION
,
2573 .supports_dsc_overlap
= 1,
2574 .do_request
= ide_do_rw_cdrom
,
2575 .end_request
= ide_end_request
,
2576 .error
= __ide_error
,
2577 .abort
= __ide_abort
,
2578 #ifdef CONFIG_IDE_PROC_FS
2583 static int idecd_open(struct inode
* inode
, struct file
* file
)
2585 struct gendisk
*disk
= inode
->i_bdev
->bd_disk
;
2586 struct cdrom_info
*info
;
2589 if (!(info
= ide_cd_get(disk
)))
2593 info
->buffer
= kmalloc(SECTOR_BUFFER_SIZE
, GFP_KERNEL
|__GFP_REPEAT
);
2596 rc
= cdrom_open(&info
->devinfo
, inode
, file
);
2604 static int idecd_release(struct inode
* inode
, struct file
* file
)
2606 struct gendisk
*disk
= inode
->i_bdev
->bd_disk
;
2607 struct cdrom_info
*info
= ide_cd_g(disk
);
2609 cdrom_release (&info
->devinfo
, file
);
2616 static int idecd_set_spindown(struct cdrom_device_info
*cdi
, unsigned long arg
)
2618 struct packet_command cgc
;
2623 if (copy_from_user(&spindown
, (void __user
*)arg
, sizeof(char)))
2626 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_UNKNOWN
);
2628 stat
= cdrom_mode_sense(cdi
, &cgc
, GPMODE_CDROM_PAGE
, 0);
2632 buffer
[11] = (buffer
[11] & 0xf0) | (spindown
& 0x0f);
2633 return cdrom_mode_select(cdi
, &cgc
);
2636 static int idecd_get_spindown(struct cdrom_device_info
*cdi
, unsigned long arg
)
2638 struct packet_command cgc
;
2643 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_UNKNOWN
);
2645 stat
= cdrom_mode_sense(cdi
, &cgc
, GPMODE_CDROM_PAGE
, 0);
2649 spindown
= buffer
[11] & 0x0f;
2650 if (copy_to_user((void __user
*)arg
, &spindown
, sizeof (char)))
2655 static int idecd_ioctl (struct inode
*inode
, struct file
*file
,
2656 unsigned int cmd
, unsigned long arg
)
2658 struct block_device
*bdev
= inode
->i_bdev
;
2659 struct cdrom_info
*info
= ide_cd_g(bdev
->bd_disk
);
2663 case CDROMSETSPINDOWN
:
2664 return idecd_set_spindown(&info
->devinfo
, arg
);
2665 case CDROMGETSPINDOWN
:
2666 return idecd_get_spindown(&info
->devinfo
, arg
);
2671 err
= generic_ide_ioctl(info
->drive
, file
, bdev
, cmd
, arg
);
2673 err
= cdrom_ioctl(file
, &info
->devinfo
, inode
, cmd
, arg
);
2678 static int idecd_media_changed(struct gendisk
*disk
)
2680 struct cdrom_info
*info
= ide_cd_g(disk
);
2681 return cdrom_media_changed(&info
->devinfo
);
2684 static int idecd_revalidate_disk(struct gendisk
*disk
)
2686 struct cdrom_info
*info
= ide_cd_g(disk
);
2687 struct request_sense sense
;
2689 ide_cd_read_toc(info
->drive
, &sense
);
2694 static struct block_device_operations idecd_ops
= {
2695 .owner
= THIS_MODULE
,
2697 .release
= idecd_release
,
2698 .ioctl
= idecd_ioctl
,
2699 .media_changed
= idecd_media_changed
,
2700 .revalidate_disk
= idecd_revalidate_disk
2704 static char *ignore
= NULL
;
2706 module_param(ignore
, charp
, 0400);
2707 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
2709 static int ide_cd_probe(ide_drive_t
*drive
)
2711 struct cdrom_info
*info
;
2713 struct request_sense sense
;
2715 if (!strstr("ide-cdrom", drive
->driver_req
))
2717 if (!drive
->present
)
2719 if (drive
->media
!= ide_cdrom
&& drive
->media
!= ide_optical
)
2721 /* skip drives that we were told to ignore */
2722 if (ignore
!= NULL
) {
2723 if (strstr(ignore
, drive
->name
)) {
2724 printk(KERN_INFO
"ide-cd: ignoring drive %s\n", drive
->name
);
2729 printk(KERN_INFO
"ide-cd: passing drive %s to ide-scsi emulation.\n", drive
->name
);
2732 info
= kzalloc(sizeof(struct cdrom_info
), GFP_KERNEL
);
2734 printk(KERN_ERR
"%s: Can't allocate a cdrom structure\n", drive
->name
);
2738 g
= alloc_disk(1 << PARTN_BITS
);
2742 ide_init_disk(g
, drive
);
2744 ide_proc_register_driver(drive
, &ide_cdrom_driver
);
2746 kref_init(&info
->kref
);
2748 info
->drive
= drive
;
2749 info
->driver
= &ide_cdrom_driver
;
2752 g
->private_data
= &info
->driver
;
2754 drive
->driver_data
= info
;
2757 g
->driverfs_dev
= &drive
->gendev
;
2758 g
->flags
= GENHD_FL_CD
| GENHD_FL_REMOVABLE
;
2759 if (ide_cdrom_setup(drive
)) {
2760 ide_proc_unregister_driver(drive
, &ide_cdrom_driver
);
2761 ide_cd_release(&info
->kref
);
2765 ide_cd_read_toc(drive
, &sense
);
2766 g
->fops
= &idecd_ops
;
2767 g
->flags
|= GENHD_FL_REMOVABLE
;
2777 static void __exit
ide_cdrom_exit(void)
2779 driver_unregister(&ide_cdrom_driver
.gen_driver
);
2782 static int __init
ide_cdrom_init(void)
2784 return driver_register(&ide_cdrom_driver
.gen_driver
);
2787 MODULE_ALIAS("ide:*m-cdrom*");
2788 MODULE_ALIAS("ide-cd");
2789 module_init(ide_cdrom_init
);
2790 module_exit(ide_cdrom_exit
);
2791 MODULE_LICENSE("GPL");