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
));
629 static void ide_cd_drain_data(ide_drive_t
*drive
, int nsects
)
632 static char dum
[SECTOR_SIZE
];
634 drive
->hwif
->atapi_input_bytes(drive
, dum
, sizeof(dum
));
640 * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
641 * buffer. Once the first sector is added, any subsequent sectors are
642 * assumed to be continuous (until the buffer is cleared). For the first
643 * sector added, SECTOR is its sector number. (SECTOR is then ignored until
644 * the buffer is cleared.)
646 static void cdrom_buffer_sectors (ide_drive_t
*drive
, unsigned long sector
,
647 int sectors_to_transfer
)
649 struct cdrom_info
*info
= drive
->driver_data
;
651 /* Number of sectors to read into the buffer. */
652 int sectors_to_buffer
= min_t(int, sectors_to_transfer
,
653 (SECTOR_BUFFER_SIZE
>> SECTOR_BITS
) -
654 info
->nsectors_buffered
);
658 /* If we couldn't get a buffer, don't try to buffer anything... */
659 if (info
->buffer
== NULL
)
660 sectors_to_buffer
= 0;
662 /* If this is the first sector in the buffer, remember its number. */
663 if (info
->nsectors_buffered
== 0)
664 info
->sector_buffered
= sector
;
666 /* Read the data into the buffer. */
667 dest
= info
->buffer
+ info
->nsectors_buffered
* SECTOR_SIZE
;
668 while (sectors_to_buffer
> 0) {
669 HWIF(drive
)->atapi_input_bytes(drive
, dest
, SECTOR_SIZE
);
671 --sectors_to_transfer
;
672 ++info
->nsectors_buffered
;
676 /* Throw away any remaining data. */
677 ide_cd_drain_data(drive
, sectors_to_transfer
);
681 * Check the contents of the interrupt reason register from the cdrom
682 * and attempt to recover if there are problems. Returns 0 if everything's
683 * ok; nonzero if the request has been terminated.
686 int cdrom_read_check_ireason (ide_drive_t
*drive
, int len
, int ireason
)
690 else if (ireason
== 0) {
691 ide_hwif_t
*hwif
= drive
->hwif
;
693 /* Whoops... The drive is expecting to receive data from us! */
694 printk(KERN_ERR
"%s: %s: wrong transfer direction!\n",
695 drive
->name
, __FUNCTION__
);
697 /* Throw some data at the drive so it doesn't hang
698 and quit this request. */
699 ide_cd_pad_transfer(drive
, hwif
->atapi_output_bytes
, len
);
700 } else if (ireason
== 1) {
701 /* Some drives (ASUS) seem to tell us that status
702 * info is available. just get it and ignore.
704 (void) HWIF(drive
)->INB(IDE_STATUS_REG
);
707 /* Drive wants a command packet, or invalid ireason... */
708 printk(KERN_ERR
"%s: %s: bad interrupt reason 0x%02x\n",
709 drive
->name
, __FUNCTION__
, ireason
);
712 cdrom_end_request(drive
, 0);
717 * Assume that the drive will always provide data in multiples of at least
718 * SECTOR_SIZE, as it gets hairy to keep track of the transfers otherwise.
720 static int ide_cd_check_transfer_size(ide_drive_t
*drive
, int len
)
722 struct cdrom_info
*cd
= drive
->driver_data
;
724 if ((len
% SECTOR_SIZE
) == 0)
727 printk(KERN_ERR
"%s: %s: Bad transfer size %d\n",
728 drive
->name
, __FUNCTION__
, len
);
730 if (cd
->cd_flags
& IDE_CD_FLAG_LIMIT_NFRAMES
)
731 printk(KERN_ERR
" This drive is not supported by "
732 "this version of the driver\n");
734 printk(KERN_ERR
" Trying to limit transfer sizes\n");
735 cd
->cd_flags
|= IDE_CD_FLAG_LIMIT_NFRAMES
;
742 * Try to satisfy some of the current read request from our cached data.
743 * Returns nonzero if the request has been completed, zero otherwise.
745 static int cdrom_read_from_buffer (ide_drive_t
*drive
)
747 struct cdrom_info
*info
= drive
->driver_data
;
748 struct request
*rq
= HWGROUP(drive
)->rq
;
749 unsigned short sectors_per_frame
;
751 sectors_per_frame
= queue_hardsect_size(drive
->queue
) >> SECTOR_BITS
;
753 /* Can't do anything if there's no buffer. */
754 if (info
->buffer
== NULL
) return 0;
756 /* Loop while this request needs data and the next block is present
758 while (rq
->nr_sectors
> 0 &&
759 rq
->sector
>= info
->sector_buffered
&&
760 rq
->sector
< info
->sector_buffered
+ info
->nsectors_buffered
) {
761 if (rq
->current_nr_sectors
== 0)
762 cdrom_end_request(drive
, 1);
766 (rq
->sector
- info
->sector_buffered
) * SECTOR_SIZE
,
768 rq
->buffer
+= SECTOR_SIZE
;
769 --rq
->current_nr_sectors
;
774 /* If we've satisfied the current request,
775 terminate it successfully. */
776 if (rq
->nr_sectors
== 0) {
777 cdrom_end_request(drive
, 1);
781 /* Move on to the next buffer if needed. */
782 if (rq
->current_nr_sectors
== 0)
783 cdrom_end_request(drive
, 1);
785 /* If this condition does not hold, then the kluge i use to
786 represent the number of sectors to skip at the start of a transfer
787 will fail. I think that this will never happen, but let's be
788 paranoid and check. */
789 if (rq
->current_nr_sectors
< bio_cur_sectors(rq
->bio
) &&
790 (rq
->sector
& (sectors_per_frame
- 1))) {
791 printk(KERN_ERR
"%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
792 drive
->name
, (long)rq
->sector
);
793 cdrom_end_request(drive
, 0);
800 static ide_startstop_t
cdrom_rw_intr(ide_drive_t
*);
803 * Routine to send a read/write packet command to the drive.
804 * This is usually called directly from cdrom_start_{read,write}().
805 * However, for drq_interrupt devices, it is called from an interrupt
806 * when the drive is ready to accept the command.
808 static ide_startstop_t
cdrom_start_rw_cont(ide_drive_t
*drive
)
810 struct request
*rq
= HWGROUP(drive
)->rq
;
812 if (rq_data_dir(rq
) == READ
) {
813 unsigned short sectors_per_frame
=
814 queue_hardsect_size(drive
->queue
) >> SECTOR_BITS
;
815 int nskip
= rq
->sector
& (sectors_per_frame
- 1);
818 * If the requested sector doesn't start on a frame boundary,
819 * we must adjust the start of the transfer so that it does,
820 * and remember to skip the first few sectors.
822 * If the rq->current_nr_sectors field is larger than the size
823 * of the buffer, it will mean that we're to skip a number of
824 * sectors equal to the amount by which rq->current_nr_sectors
825 * is larger than the buffer size.
828 /* Sanity check... */
829 if (rq
->current_nr_sectors
!=
830 bio_cur_sectors(rq
->bio
)) {
831 printk(KERN_ERR
"%s: %s: buffer botch (%u)\n",
832 drive
->name
, __FUNCTION__
,
833 rq
->current_nr_sectors
);
834 cdrom_end_request(drive
, 0);
837 rq
->current_nr_sectors
+= nskip
;
842 /* the immediate bit */
845 /* Set up the command */
846 rq
->timeout
= ATAPI_WAIT_PC
;
848 /* Send the command to the drive and return. */
849 return cdrom_transfer_packet_command(drive
, rq
, cdrom_rw_intr
);
852 #define IDECD_SEEK_THRESHOLD (1000) /* 1000 blocks */
853 #define IDECD_SEEK_TIMER (5 * WAIT_MIN_SLEEP) /* 100 ms */
854 #define IDECD_SEEK_TIMEOUT (2 * WAIT_CMD) /* 20 sec */
856 static ide_startstop_t
cdrom_seek_intr (ide_drive_t
*drive
)
858 struct cdrom_info
*info
= drive
->driver_data
;
860 static int retry
= 10;
862 if (cdrom_decode_status(drive
, 0, &stat
))
865 info
->cd_flags
|= IDE_CD_FLAG_SEEKING
;
867 if (retry
&& time_after(jiffies
, info
->start_seek
+ IDECD_SEEK_TIMER
)) {
870 * this condition is far too common, to bother
873 /* printk("%s: disabled DSC seek overlap\n", drive->name);*/
874 drive
->dsc_overlap
= 0;
880 static ide_startstop_t
cdrom_start_seek_continuation (ide_drive_t
*drive
)
882 struct request
*rq
= HWGROUP(drive
)->rq
;
883 sector_t frame
= rq
->sector
;
885 sector_div(frame
, queue_hardsect_size(drive
->queue
) >> SECTOR_BITS
);
887 memset(rq
->cmd
, 0, sizeof(rq
->cmd
));
888 rq
->cmd
[0] = GPCMD_SEEK
;
889 put_unaligned(cpu_to_be32(frame
), (unsigned int *) &rq
->cmd
[2]);
891 rq
->timeout
= ATAPI_WAIT_PC
;
892 return cdrom_transfer_packet_command(drive
, rq
, &cdrom_seek_intr
);
895 static ide_startstop_t
cdrom_start_seek (ide_drive_t
*drive
, unsigned int block
)
897 struct cdrom_info
*info
= drive
->driver_data
;
900 info
->start_seek
= jiffies
;
901 return cdrom_start_packet_command(drive
, 0, cdrom_start_seek_continuation
);
904 /* Fix up a possibly partially-processed request so that we can
905 start it over entirely, or even put it back on the request queue. */
906 static void restore_request (struct request
*rq
)
908 if (rq
->buffer
!= bio_data(rq
->bio
)) {
909 sector_t n
= (rq
->buffer
- (char *) bio_data(rq
->bio
)) / SECTOR_SIZE
;
911 rq
->buffer
= bio_data(rq
->bio
);
915 rq
->hard_cur_sectors
= rq
->current_nr_sectors
= bio_cur_sectors(rq
->bio
);
916 rq
->hard_nr_sectors
= rq
->nr_sectors
;
917 rq
->hard_sector
= rq
->sector
;
918 rq
->q
->prep_rq_fn(rq
->q
, rq
);
921 /****************************************************************************
922 * Execute all other packet commands.
925 static void ide_cd_request_sense_fixup(struct request
*rq
)
928 * Some of the trailing request sense fields are optional,
929 * and some drives don't send them. Sigh.
931 if (rq
->cmd
[0] == GPCMD_REQUEST_SENSE
&&
932 rq
->data_len
> 0 && rq
->data_len
<= 5)
933 while (rq
->data_len
> 0) {
934 *(u8
*)rq
->data
++ = 0;
939 int ide_cd_queue_pc(ide_drive_t
*drive
, struct request
*rq
)
941 struct request_sense sense
;
943 unsigned int flags
= rq
->cmd_flags
;
945 if (rq
->sense
== NULL
)
948 /* Start of retry loop. */
951 unsigned long time
= jiffies
;
952 rq
->cmd_flags
= flags
;
954 error
= ide_do_drive_cmd(drive
, rq
, ide_wait
);
955 time
= jiffies
- time
;
957 /* FIXME: we should probably abort/retry or something
958 * in case of failure */
959 if (rq
->cmd_flags
& REQ_FAILED
) {
960 /* The request failed. Retry if it was due to a unit
962 (usually means media was changed). */
963 struct request_sense
*reqbuf
= rq
->sense
;
965 if (reqbuf
->sense_key
== UNIT_ATTENTION
)
966 cdrom_saw_media_change(drive
);
967 else if (reqbuf
->sense_key
== NOT_READY
&&
968 reqbuf
->asc
== 4 && reqbuf
->ascq
!= 4) {
969 /* The drive is in the process of loading
970 a disk. Retry, but wait a little to give
971 the drive time to complete the load. */
974 /* Otherwise, don't retry. */
980 /* End of retry loop. */
981 } while ((rq
->cmd_flags
& REQ_FAILED
) && retries
>= 0);
983 /* Return an error if the command failed. */
984 return (rq
->cmd_flags
& REQ_FAILED
) ? -EIO
: 0;
990 static int cdrom_write_check_ireason(ide_drive_t
*drive
, int len
, int ireason
)
992 /* Two notes about IDE interrupt reason here - 0 means that
993 * the drive wants to receive data from us, 2 means that
994 * the drive is expecting to transfer data to us.
998 else if (ireason
== 2) {
999 ide_hwif_t
*hwif
= drive
->hwif
;
1001 /* Whoops... The drive wants to send data. */
1002 printk(KERN_ERR
"%s: %s: wrong transfer direction!\n",
1003 drive
->name
, __FUNCTION__
);
1005 ide_cd_pad_transfer(drive
, hwif
->atapi_input_bytes
, len
);
1007 /* Drive wants a command packet, or invalid ireason... */
1008 printk(KERN_ERR
"%s: %s: bad interrupt reason 0x%02x\n",
1009 drive
->name
, __FUNCTION__
, ireason
);
1012 cdrom_end_request(drive
, 0);
1017 * Called from blk_end_request_callback() after the data of the request
1018 * is completed and before the request is completed.
1019 * By returning value '1', blk_end_request_callback() returns immediately
1020 * without completing the request.
1022 static int cdrom_newpc_intr_dummy_cb(struct request
*rq
)
1028 * best way to deal with dma that is not sector aligned right now... note
1029 * that in this path we are not using ->data or ->buffer at all. this irs
1030 * can replace cdrom_rw_intr() in the future.
1032 static ide_startstop_t
cdrom_newpc_intr(ide_drive_t
*drive
)
1034 struct cdrom_info
*info
= drive
->driver_data
;
1035 struct request
*rq
= HWGROUP(drive
)->rq
;
1036 xfer_func_t
*xferfunc
;
1037 ide_expiry_t
*expiry
;
1038 int dma_error
= 0, dma
, stat
, ireason
, len
, thislen
, uptodate
= 0;
1039 int write
= (rq_data_dir(rq
) == WRITE
) ? 1 : 0;
1040 unsigned int timeout
;
1043 /* Check for errors. */
1047 dma_error
= HWIF(drive
)->ide_dma_end(drive
);
1049 printk(KERN_ERR
"%s: DMA %s error\n", drive
->name
,
1050 write
? "write" : "read");
1055 if (cdrom_decode_status(drive
, 0, &stat
))
1059 * using dma, transfer is complete now
1063 return ide_error(drive
, "dma error", stat
);
1068 * ok we fall to pio :/
1070 ireason
= HWIF(drive
)->INB(IDE_IREASON_REG
) & 0x3;
1071 lowcyl
= HWIF(drive
)->INB(IDE_BCOUNTL_REG
);
1072 highcyl
= HWIF(drive
)->INB(IDE_BCOUNTH_REG
);
1074 len
= lowcyl
+ (256 * highcyl
);
1075 thislen
= rq
->data_len
;
1080 * If DRQ is clear, the command has completed.
1082 if ((stat
& DRQ_STAT
) == 0) {
1083 if (!blk_pc_request(rq
)) {
1084 ide_cd_request_sense_fixup(rq
);
1085 /* Complain if we still have data left to transfer. */
1086 uptodate
= rq
->data_len
? 0 : 1;
1092 * check which way to transfer data
1094 if (blk_pc_request(rq
) && rq_data_dir(rq
) == WRITE
) {
1098 if (cdrom_write_check_ireason(drive
, len
, ireason
))
1100 } else if (blk_pc_request(rq
)) {
1104 if (cdrom_read_check_ireason(drive
, len
, ireason
))
1110 xferfunc
= HWIF(drive
)->atapi_output_bytes
;
1111 } else if (ireason
== 2 || (ireason
== 1 && blk_pc_request(rq
))) {
1113 xferfunc
= HWIF(drive
)->atapi_input_bytes
;
1115 printk(KERN_ERR
"%s: %s: The drive "
1116 "appears confused (ireason = 0x%02x). "
1117 "Trying to recover by ending request.\n",
1118 drive
->name
, __FUNCTION__
, ireason
);
1125 while (thislen
> 0) {
1127 int blen
= rq
->data_len
;
1133 ptr
= bio_data(rq
->bio
);
1134 blen
= bio_iovec(rq
->bio
)->bv_len
;
1138 printk(KERN_ERR
"%s: confused, missing data\n",
1140 blk_dump_rq_flags(rq
, rq_data_dir(rq
)
1141 ? "cdrom_newpc_intr, write"
1142 : "cdrom_newpc_intr, read");
1149 xferfunc(drive
, ptr
, blen
);
1153 rq
->data_len
-= blen
;
1157 * The request can't be completed until DRQ is cleared.
1158 * So complete the data, but don't complete the request
1159 * using the dummy function for the callback feature
1160 * of blk_end_request_callback().
1162 blk_end_request_callback(rq
, 0, blen
,
1163 cdrom_newpc_intr_dummy_cb
);
1168 if (write
&& blk_sense_request(rq
))
1169 rq
->sense_len
+= thislen
;
1175 ide_cd_pad_transfer(drive
, xferfunc
, len
);
1177 if (blk_pc_request(rq
)) {
1178 timeout
= rq
->timeout
;
1181 timeout
= ATAPI_WAIT_PC
;
1182 expiry
= cdrom_timer_expiry
;
1185 ide_set_handler(drive
, cdrom_newpc_intr
, timeout
, expiry
);
1189 if (blk_pc_request(rq
)) {
1190 unsigned long flags
;
1192 spin_lock_irqsave(&ide_lock
, flags
);
1193 if (__blk_end_request(rq
, 0, rq
->data_len
))
1195 HWGROUP(drive
)->rq
= NULL
;
1196 spin_unlock_irqrestore(&ide_lock
, flags
);
1199 rq
->cmd_flags
|= REQ_FAILED
;
1200 cdrom_end_request(drive
, uptodate
);
1205 static ide_startstop_t
cdrom_rw_intr(ide_drive_t
*drive
)
1207 struct cdrom_info
*info
= drive
->driver_data
;
1208 struct request
*rq
= HWGROUP(drive
)->rq
;
1209 xfer_func_t
*xferfunc
;
1210 int stat
, ireason
, len
, thislen
, uptodate
, nskip
;
1211 int dma_error
= 0, dma
= info
->dma
, write
= rq_data_dir(rq
) == WRITE
;
1212 u8 lowcyl
= 0, highcyl
= 0;
1214 /* Check for errors. */
1217 dma_error
= HWIF(drive
)->ide_dma_end(drive
);
1219 printk(KERN_ERR
"%s: DMA %s error\n", drive
->name
,
1220 write
? "write" : "read");
1225 if (cdrom_decode_status(drive
, 0, &stat
))
1229 * using dma, transfer is complete now
1233 return ide_error(drive
, "dma error", stat
);
1235 ide_end_request(drive
, 1, rq
->nr_sectors
);
1239 /* Read the interrupt reason and the transfer length. */
1240 ireason
= HWIF(drive
)->INB(IDE_IREASON_REG
) & 0x3;
1241 lowcyl
= HWIF(drive
)->INB(IDE_BCOUNTL_REG
);
1242 highcyl
= HWIF(drive
)->INB(IDE_BCOUNTH_REG
);
1244 len
= lowcyl
+ (256 * highcyl
);
1246 /* If DRQ is clear, the command has completed. */
1247 if ((stat
& DRQ_STAT
) == 0) {
1249 * If we're not done reading/writing, complain.
1250 * Otherwise, complete the command normally.
1253 if (rq
->current_nr_sectors
> 0) {
1254 printk(KERN_ERR
"%s: %s: data underrun (%d blocks)\n",
1255 drive
->name
, __FUNCTION__
,
1256 rq
->current_nr_sectors
);
1258 rq
->cmd_flags
|= REQ_FAILED
;
1261 cdrom_end_request(drive
, uptodate
);
1267 /* Check that the drive is expecting to do the same thing we are. */
1269 if (cdrom_write_check_ireason(drive
, len
, ireason
))
1272 xferfunc
= HWIF(drive
)->atapi_output_bytes
;
1274 if (cdrom_read_check_ireason(drive
, len
, ireason
))
1277 if (ide_cd_check_transfer_size(drive
, len
)) {
1278 cdrom_end_request(drive
, 0);
1283 * First, figure out if we need to bit-bucket
1284 * any of the leading sectors.
1286 nskip
= min_t(int, rq
->current_nr_sectors
1287 - bio_cur_sectors(rq
->bio
),
1291 ide_cd_drain_data(drive
, nskip
);
1292 rq
->current_nr_sectors
-= nskip
;
1293 thislen
-= (nskip
<< 9);
1296 xferfunc
= HWIF(drive
)->atapi_input_bytes
;
1300 * now loop and read/write the data
1302 while (thislen
> 0) {
1308 blen
= rq
->current_nr_sectors
<< 9;
1314 * If the buffers are full, cache the rest
1315 * of the data in our internal buffer.
1317 cdrom_buffer_sectors(drive
, rq
->sector
,
1320 printk(KERN_ERR
"%s: %s: confused, missing "
1322 drive
->name
, __FUNCTION__
);
1327 * Figure out how many sectors we can transfer
1332 xferfunc(drive
, ptr
, blen
);
1336 rq
->nr_sectors
-= (blen
>> 9);
1337 rq
->current_nr_sectors
-= (blen
>> 9);
1338 rq
->sector
+= (blen
>> 9);
1341 * current buffer complete, move on
1343 if (rq
->current_nr_sectors
== 0 && rq
->nr_sectors
)
1344 cdrom_end_request(drive
, 1);
1347 /* re-arm handler */
1348 ide_set_handler(drive
, cdrom_rw_intr
, ATAPI_WAIT_PC
, NULL
);
1352 static ide_startstop_t
cdrom_start_rw(ide_drive_t
*drive
, struct request
*rq
)
1354 struct cdrom_info
*cd
= drive
->driver_data
;
1355 int write
= rq_data_dir(rq
) == WRITE
;
1356 unsigned short sectors_per_frame
=
1357 queue_hardsect_size(drive
->queue
) >> SECTOR_BITS
;
1361 * disk has become write protected
1363 if (cd
->disk
->policy
) {
1364 cdrom_end_request(drive
, 0);
1369 * We may be retrying this request after an error. Fix up any
1370 * weirdness which might be present in the request packet.
1372 restore_request(rq
);
1374 /* Satisfy whatever we can of this request from our cache. */
1375 if (cdrom_read_from_buffer(drive
))
1380 * use DMA, if possible / writes *must* be hardware frame aligned
1382 if ((rq
->nr_sectors
& (sectors_per_frame
- 1)) ||
1383 (rq
->sector
& (sectors_per_frame
- 1))) {
1385 cdrom_end_request(drive
, 0);
1390 cd
->dma
= drive
->using_dma
;
1392 /* Clear the local sector buffer. */
1393 cd
->nsectors_buffered
= 0;
1396 cd
->devinfo
.media_written
= 1;
1398 /* Start sending the read/write request to the drive. */
1399 return cdrom_start_packet_command(drive
, 32768, cdrom_start_rw_cont
);
1402 static ide_startstop_t
cdrom_do_newpc_cont(ide_drive_t
*drive
)
1404 struct request
*rq
= HWGROUP(drive
)->rq
;
1407 rq
->timeout
= ATAPI_WAIT_PC
;
1409 return cdrom_transfer_packet_command(drive
, rq
, cdrom_newpc_intr
);
1412 static ide_startstop_t
cdrom_do_block_pc(ide_drive_t
*drive
, struct request
*rq
)
1414 struct cdrom_info
*info
= drive
->driver_data
;
1416 if (blk_pc_request(rq
))
1417 rq
->cmd_flags
|= REQ_QUIET
;
1419 rq
->cmd_flags
&= ~REQ_FAILED
;
1427 int mask
= drive
->queue
->dma_alignment
;
1428 unsigned long addr
= (unsigned long) page_address(bio_page(rq
->bio
));
1430 info
->dma
= drive
->using_dma
;
1433 * check if dma is safe
1435 * NOTE! The "len" and "addr" checks should possibly have
1438 if ((rq
->data_len
& 15) || (addr
& mask
))
1442 /* Start sending the command to the drive. */
1443 return cdrom_start_packet_command(drive
, rq
->data_len
, cdrom_do_newpc_cont
);
1446 /****************************************************************************
1447 * cdrom driver request routine.
1449 static ide_startstop_t
1450 ide_do_rw_cdrom (ide_drive_t
*drive
, struct request
*rq
, sector_t block
)
1452 ide_startstop_t action
;
1453 struct cdrom_info
*info
= drive
->driver_data
;
1455 if (blk_fs_request(rq
)) {
1456 if (info
->cd_flags
& IDE_CD_FLAG_SEEKING
) {
1457 unsigned long elapsed
= jiffies
- info
->start_seek
;
1458 int stat
= HWIF(drive
)->INB(IDE_STATUS_REG
);
1460 if ((stat
& SEEK_STAT
) != SEEK_STAT
) {
1461 if (elapsed
< IDECD_SEEK_TIMEOUT
) {
1462 ide_stall_queue(drive
, IDECD_SEEK_TIMER
);
1465 printk (KERN_ERR
"%s: DSC timeout\n", drive
->name
);
1467 info
->cd_flags
&= ~IDE_CD_FLAG_SEEKING
;
1469 if ((rq_data_dir(rq
) == READ
) && IDE_LARGE_SEEK(info
->last_block
, block
, IDECD_SEEK_THRESHOLD
) && drive
->dsc_overlap
) {
1470 action
= cdrom_start_seek(drive
, block
);
1472 action
= cdrom_start_rw(drive
, rq
);
1473 info
->last_block
= block
;
1475 } else if (blk_sense_request(rq
) || blk_pc_request(rq
) ||
1476 rq
->cmd_type
== REQ_TYPE_ATA_PC
) {
1477 return cdrom_do_block_pc(drive
, rq
);
1478 } else if (blk_special_request(rq
)) {
1480 * right now this can only be a reset...
1482 cdrom_end_request(drive
, 1);
1486 blk_dump_rq_flags(rq
, "ide-cd bad flags");
1487 cdrom_end_request(drive
, 0);
1493 /****************************************************************************
1496 * Routines which queue packet commands take as a final argument a pointer
1497 * to a request_sense struct. If execution of the command results
1498 * in an error with a CHECK CONDITION status, this structure will be filled
1499 * with the results of the subsequent request sense command. The pointer
1500 * can also be NULL, in which case no sense information is returned.
1504 void msf_from_bcd (struct atapi_msf
*msf
)
1506 msf
->minute
= BCD2BIN(msf
->minute
);
1507 msf
->second
= BCD2BIN(msf
->second
);
1508 msf
->frame
= BCD2BIN(msf
->frame
);
1511 static int cdrom_check_status(ide_drive_t
*drive
, struct request_sense
*sense
)
1514 struct cdrom_info
*info
= drive
->driver_data
;
1515 struct cdrom_device_info
*cdi
= &info
->devinfo
;
1517 ide_cd_init_rq(drive
, &req
);
1520 req
.cmd
[0] = GPCMD_TEST_UNIT_READY
;
1521 req
.cmd_flags
|= REQ_QUIET
;
1524 * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
1525 * switch CDs instead of supporting the LOAD_UNLOAD opcode.
1527 req
.cmd
[7] = cdi
->sanyo_slot
% 3;
1529 return ide_cd_queue_pc(drive
, &req
);
1532 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
1533 int ide_cd_lockdoor(ide_drive_t
*drive
, int lockflag
,
1534 struct request_sense
*sense
)
1536 struct cdrom_info
*cd
= drive
->driver_data
;
1537 struct request_sense my_sense
;
1544 /* If the drive cannot lock the door, just pretend. */
1545 if (cd
->cd_flags
& IDE_CD_FLAG_NO_DOORLOCK
) {
1548 ide_cd_init_rq(drive
, &req
);
1550 req
.cmd
[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL
;
1551 req
.cmd
[4] = lockflag
? 1 : 0;
1552 stat
= ide_cd_queue_pc(drive
, &req
);
1555 /* If we got an illegal field error, the drive
1556 probably cannot lock the door. */
1558 sense
->sense_key
== ILLEGAL_REQUEST
&&
1559 (sense
->asc
== 0x24 || sense
->asc
== 0x20)) {
1560 printk (KERN_ERR
"%s: door locking not supported\n",
1562 cd
->cd_flags
|= IDE_CD_FLAG_NO_DOORLOCK
;
1566 /* no medium, that's alright. */
1567 if (stat
!= 0 && sense
->sense_key
== NOT_READY
&& sense
->asc
== 0x3a)
1572 cd
->cd_flags
|= IDE_CD_FLAG_DOOR_LOCKED
;
1574 cd
->cd_flags
&= ~IDE_CD_FLAG_DOOR_LOCKED
;
1581 /* Eject the disk if EJECTFLAG is 0.
1582 If EJECTFLAG is 1, try to reload the disk. */
1583 static int cdrom_eject(ide_drive_t
*drive
, int ejectflag
,
1584 struct request_sense
*sense
)
1586 struct cdrom_info
*cd
= drive
->driver_data
;
1587 struct cdrom_device_info
*cdi
= &cd
->devinfo
;
1591 if ((cd
->cd_flags
& IDE_CD_FLAG_NO_EJECT
) && !ejectflag
)
1592 return -EDRIVE_CANT_DO_THIS
;
1594 /* reload fails on some drives, if the tray is locked */
1595 if ((cd
->cd_flags
& IDE_CD_FLAG_DOOR_LOCKED
) && ejectflag
)
1598 ide_cd_init_rq(drive
, &req
);
1600 /* only tell drive to close tray if open, if it can do that */
1601 if (ejectflag
&& (cdi
->mask
& CDC_CLOSE_TRAY
))
1605 req
.cmd
[0] = GPCMD_START_STOP_UNIT
;
1606 req
.cmd
[4] = loej
| (ejectflag
!= 0);
1608 return ide_cd_queue_pc(drive
, &req
);
1611 static int cdrom_read_capacity(ide_drive_t
*drive
, unsigned long *capacity
,
1612 unsigned long *sectors_per_frame
,
1613 struct request_sense
*sense
)
1623 ide_cd_init_rq(drive
, &req
);
1626 req
.cmd
[0] = GPCMD_READ_CDVD_CAPACITY
;
1627 req
.data
= (char *)&capbuf
;
1628 req
.data_len
= sizeof(capbuf
);
1629 req
.cmd_flags
|= REQ_QUIET
;
1631 stat
= ide_cd_queue_pc(drive
, &req
);
1633 *capacity
= 1 + be32_to_cpu(capbuf
.lba
);
1634 *sectors_per_frame
=
1635 be32_to_cpu(capbuf
.blocklen
) >> SECTOR_BITS
;
1641 static int cdrom_read_tocentry(ide_drive_t
*drive
, int trackno
, int msf_flag
,
1642 int format
, char *buf
, int buflen
,
1643 struct request_sense
*sense
)
1647 ide_cd_init_rq(drive
, &req
);
1651 req
.data_len
= buflen
;
1652 req
.cmd_flags
|= REQ_QUIET
;
1653 req
.cmd
[0] = GPCMD_READ_TOC_PMA_ATIP
;
1654 req
.cmd
[6] = trackno
;
1655 req
.cmd
[7] = (buflen
>> 8);
1656 req
.cmd
[8] = (buflen
& 0xff);
1657 req
.cmd
[9] = (format
<< 6);
1662 return ide_cd_queue_pc(drive
, &req
);
1665 /* Try to read the entire TOC for the disk into our internal buffer. */
1666 int ide_cd_read_toc(ide_drive_t
*drive
, struct request_sense
*sense
)
1668 int stat
, ntracks
, i
;
1669 struct cdrom_info
*info
= drive
->driver_data
;
1670 struct cdrom_device_info
*cdi
= &info
->devinfo
;
1671 struct atapi_toc
*toc
= info
->toc
;
1673 struct atapi_toc_header hdr
;
1674 struct atapi_toc_entry ent
;
1677 unsigned long sectors_per_frame
= SECTORS_PER_FRAME
;
1680 /* Try to allocate space. */
1681 toc
= kmalloc(sizeof(struct atapi_toc
), GFP_KERNEL
);
1683 printk (KERN_ERR
"%s: No cdrom TOC buffer!\n", drive
->name
);
1689 /* Check to see if the existing data is still valid.
1690 If it is, just return. */
1691 (void) cdrom_check_status(drive
, sense
);
1693 if (info
->cd_flags
& IDE_CD_FLAG_TOC_VALID
)
1696 /* Try to get the total cdrom capacity and sector size. */
1697 stat
= cdrom_read_capacity(drive
, &toc
->capacity
, §ors_per_frame
,
1700 toc
->capacity
= 0x1fffff;
1702 set_capacity(info
->disk
, toc
->capacity
* sectors_per_frame
);
1703 /* Save a private copy of te TOC capacity for error handling */
1704 drive
->probed_capacity
= toc
->capacity
* sectors_per_frame
;
1706 blk_queue_hardsect_size(drive
->queue
,
1707 sectors_per_frame
<< SECTOR_BITS
);
1709 /* First read just the header, so we know how long the TOC is. */
1710 stat
= cdrom_read_tocentry(drive
, 0, 1, 0, (char *) &toc
->hdr
,
1711 sizeof(struct atapi_toc_header
), sense
);
1715 if (info
->cd_flags
& IDE_CD_FLAG_TOCTRACKS_AS_BCD
) {
1716 toc
->hdr
.first_track
= BCD2BIN(toc
->hdr
.first_track
);
1717 toc
->hdr
.last_track
= BCD2BIN(toc
->hdr
.last_track
);
1720 ntracks
= toc
->hdr
.last_track
- toc
->hdr
.first_track
+ 1;
1723 if (ntracks
> MAX_TRACKS
)
1724 ntracks
= MAX_TRACKS
;
1726 /* Now read the whole schmeer. */
1727 stat
= cdrom_read_tocentry(drive
, toc
->hdr
.first_track
, 1, 0,
1729 sizeof(struct atapi_toc_header
) +
1731 sizeof(struct atapi_toc_entry
), sense
);
1733 if (stat
&& toc
->hdr
.first_track
> 1) {
1734 /* Cds with CDI tracks only don't have any TOC entries,
1735 despite of this the returned values are
1736 first_track == last_track = number of CDI tracks + 1,
1737 so that this case is indistinguishable from the same
1738 layout plus an additional audio track.
1739 If we get an error for the regular case, we assume
1740 a CDI without additional audio tracks. In this case
1741 the readable TOC is empty (CDI tracks are not included)
1742 and only holds the Leadout entry. Heiko Eißfeldt */
1744 stat
= cdrom_read_tocentry(drive
, CDROM_LEADOUT
, 1, 0,
1746 sizeof(struct atapi_toc_header
) +
1748 sizeof(struct atapi_toc_entry
),
1753 if (info
->cd_flags
& IDE_CD_FLAG_TOCTRACKS_AS_BCD
) {
1754 toc
->hdr
.first_track
= (u8
)BIN2BCD(CDROM_LEADOUT
);
1755 toc
->hdr
.last_track
= (u8
)BIN2BCD(CDROM_LEADOUT
);
1757 toc
->hdr
.first_track
= CDROM_LEADOUT
;
1758 toc
->hdr
.last_track
= CDROM_LEADOUT
;
1765 toc
->hdr
.toc_length
= ntohs (toc
->hdr
.toc_length
);
1767 if (info
->cd_flags
& IDE_CD_FLAG_TOCTRACKS_AS_BCD
) {
1768 toc
->hdr
.first_track
= BCD2BIN(toc
->hdr
.first_track
);
1769 toc
->hdr
.last_track
= BCD2BIN(toc
->hdr
.last_track
);
1772 for (i
= 0; i
<= ntracks
; i
++) {
1773 if (info
->cd_flags
& IDE_CD_FLAG_TOCADDR_AS_BCD
) {
1774 if (info
->cd_flags
& IDE_CD_FLAG_TOCTRACKS_AS_BCD
)
1775 toc
->ent
[i
].track
= BCD2BIN(toc
->ent
[i
].track
);
1776 msf_from_bcd(&toc
->ent
[i
].addr
.msf
);
1778 toc
->ent
[i
].addr
.lba
= msf_to_lba (toc
->ent
[i
].addr
.msf
.minute
,
1779 toc
->ent
[i
].addr
.msf
.second
,
1780 toc
->ent
[i
].addr
.msf
.frame
);
1783 /* Read the multisession information. */
1784 if (toc
->hdr
.first_track
!= CDROM_LEADOUT
) {
1785 /* Read the multisession information. */
1786 stat
= cdrom_read_tocentry(drive
, 0, 0, 1, (char *)&ms_tmp
,
1787 sizeof(ms_tmp
), sense
);
1791 toc
->last_session_lba
= be32_to_cpu(ms_tmp
.ent
.addr
.lba
);
1793 ms_tmp
.hdr
.first_track
= ms_tmp
.hdr
.last_track
= CDROM_LEADOUT
;
1794 toc
->last_session_lba
= msf_to_lba(0, 2, 0); /* 0m 2s 0f */
1797 if (info
->cd_flags
& IDE_CD_FLAG_TOCADDR_AS_BCD
) {
1798 /* Re-read multisession information using MSF format */
1799 stat
= cdrom_read_tocentry(drive
, 0, 1, 1, (char *)&ms_tmp
,
1800 sizeof(ms_tmp
), sense
);
1804 msf_from_bcd (&ms_tmp
.ent
.addr
.msf
);
1805 toc
->last_session_lba
= msf_to_lba(ms_tmp
.ent
.addr
.msf
.minute
,
1806 ms_tmp
.ent
.addr
.msf
.second
,
1807 ms_tmp
.ent
.addr
.msf
.frame
);
1810 toc
->xa_flag
= (ms_tmp
.hdr
.first_track
!= ms_tmp
.hdr
.last_track
);
1812 /* Now try to get the total cdrom capacity. */
1813 stat
= cdrom_get_last_written(cdi
, &last_written
);
1814 if (!stat
&& (last_written
> toc
->capacity
)) {
1815 toc
->capacity
= last_written
;
1816 set_capacity(info
->disk
, toc
->capacity
* sectors_per_frame
);
1817 drive
->probed_capacity
= toc
->capacity
* sectors_per_frame
;
1820 /* Remember that we've read this stuff. */
1821 info
->cd_flags
|= IDE_CD_FLAG_TOC_VALID
;
1826 /* the generic packet interface to cdrom.c */
1827 static int ide_cdrom_packet(struct cdrom_device_info
*cdi
,
1828 struct packet_command
*cgc
)
1831 ide_drive_t
*drive
= cdi
->handle
;
1833 if (cgc
->timeout
<= 0)
1834 cgc
->timeout
= ATAPI_WAIT_PC
;
1836 /* here we queue the commands from the uniform CD-ROM
1837 layer. the packet must be complete, as we do not
1839 ide_cd_init_rq(drive
, &req
);
1840 memcpy(req
.cmd
, cgc
->cmd
, CDROM_PACKET_SIZE
);
1842 memset(cgc
->sense
, 0, sizeof(struct request_sense
));
1843 req
.data
= cgc
->buffer
;
1844 req
.data_len
= cgc
->buflen
;
1845 req
.timeout
= cgc
->timeout
;
1848 req
.cmd_flags
|= REQ_QUIET
;
1850 req
.sense
= cgc
->sense
;
1851 cgc
->stat
= ide_cd_queue_pc(drive
, &req
);
1853 cgc
->buflen
-= req
.data_len
;
1858 int ide_cdrom_tray_move (struct cdrom_device_info
*cdi
, int position
)
1860 ide_drive_t
*drive
= cdi
->handle
;
1861 struct request_sense sense
;
1864 int stat
= ide_cd_lockdoor(drive
, 0, &sense
);
1870 return cdrom_eject(drive
, !position
, &sense
);
1873 int ide_cdrom_get_capabilities(ide_drive_t
*drive
, u8
*buf
)
1875 struct cdrom_info
*info
= drive
->driver_data
;
1876 struct cdrom_device_info
*cdi
= &info
->devinfo
;
1877 struct packet_command cgc
;
1878 int stat
, attempts
= 3, size
= ATAPI_CAPABILITIES_PAGE_SIZE
;
1880 if ((info
->cd_flags
& IDE_CD_FLAG_FULL_CAPS_PAGE
) == 0)
1881 size
-= ATAPI_CAPABILITIES_PAGE_PAD_SIZE
;
1883 init_cdrom_command(&cgc
, buf
, size
, CGC_DATA_UNKNOWN
);
1884 do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
1885 stat
= cdrom_mode_sense(cdi
, &cgc
, GPMODE_CAPABILITIES_PAGE
, 0);
1888 } while (--attempts
);
1892 void ide_cdrom_update_speed(ide_drive_t
*drive
, u8
*buf
)
1894 struct cdrom_info
*cd
= drive
->driver_data
;
1895 u16 curspeed
, maxspeed
;
1897 curspeed
= *(u16
*)&buf
[8 + 14];
1898 maxspeed
= *(u16
*)&buf
[8 + 8];
1900 if (cd
->cd_flags
& IDE_CD_FLAG_LE_SPEED_FIELDS
) {
1901 curspeed
= le16_to_cpu(curspeed
);
1902 maxspeed
= le16_to_cpu(maxspeed
);
1904 curspeed
= be16_to_cpu(curspeed
);
1905 maxspeed
= be16_to_cpu(maxspeed
);
1908 cd
->current_speed
= (curspeed
+ (176/2)) / 176;
1909 cd
->max_speed
= (maxspeed
+ (176/2)) / 176;
1913 * add logic to try GET_EVENT command first to check for media and tray
1914 * status. this should be supported by newer cd-r/w and all DVD etc
1918 int ide_cdrom_drive_status (struct cdrom_device_info
*cdi
, int slot_nr
)
1920 ide_drive_t
*drive
= cdi
->handle
;
1921 struct media_event_desc med
;
1922 struct request_sense sense
;
1925 if (slot_nr
!= CDSL_CURRENT
)
1928 stat
= cdrom_check_status(drive
, &sense
);
1929 if (!stat
|| sense
.sense_key
== UNIT_ATTENTION
)
1932 if (!cdrom_get_media_event(cdi
, &med
)) {
1933 if (med
.media_present
)
1935 else if (med
.door_open
)
1936 return CDS_TRAY_OPEN
;
1941 if (sense
.sense_key
== NOT_READY
&& sense
.asc
== 0x04 && sense
.ascq
== 0x04)
1945 * If not using Mt Fuji extended media tray reports,
1946 * just return TRAY_OPEN since ATAPI doesn't provide
1947 * any other way to detect this...
1949 if (sense
.sense_key
== NOT_READY
) {
1950 if (sense
.asc
== 0x3a && sense
.ascq
== 1)
1953 return CDS_TRAY_OPEN
;
1955 return CDS_DRIVE_NOT_READY
;
1958 /****************************************************************************
1959 * Other driver requests (open, close, check media change).
1963 int ide_cdrom_check_media_change_real (struct cdrom_device_info
*cdi
,
1966 ide_drive_t
*drive
= cdi
->handle
;
1967 struct cdrom_info
*cd
= drive
->driver_data
;
1970 if (slot_nr
== CDSL_CURRENT
) {
1971 (void) cdrom_check_status(drive
, NULL
);
1972 retval
= (cd
->cd_flags
& IDE_CD_FLAG_MEDIA_CHANGED
) ? 1 : 0;
1973 cd
->cd_flags
&= ~IDE_CD_FLAG_MEDIA_CHANGED
;
1982 int ide_cdrom_open_real (struct cdrom_device_info
*cdi
, int purpose
)
1988 * Close down the device. Invalidate all cached blocks.
1992 void ide_cdrom_release_real (struct cdrom_device_info
*cdi
)
1994 ide_drive_t
*drive
= cdi
->handle
;
1995 struct cdrom_info
*cd
= drive
->driver_data
;
1997 if (!cdi
->use_count
)
1998 cd
->cd_flags
&= ~IDE_CD_FLAG_TOC_VALID
;
2001 #define IDE_CD_CAPABILITIES \
2002 (CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | CDC_SELECT_SPEED | \
2003 CDC_SELECT_DISC | CDC_MULTI_SESSION | CDC_MCN | CDC_MEDIA_CHANGED | \
2004 CDC_PLAY_AUDIO | CDC_RESET | CDC_DRIVE_STATUS | CDC_CD_R | \
2005 CDC_CD_RW | CDC_DVD | CDC_DVD_R | CDC_DVD_RAM | CDC_GENERIC_PACKET | \
2006 CDC_MO_DRIVE | CDC_MRW | CDC_MRW_W | CDC_RAM)
2008 static struct cdrom_device_ops ide_cdrom_dops
= {
2009 .open
= ide_cdrom_open_real
,
2010 .release
= ide_cdrom_release_real
,
2011 .drive_status
= ide_cdrom_drive_status
,
2012 .media_changed
= ide_cdrom_check_media_change_real
,
2013 .tray_move
= ide_cdrom_tray_move
,
2014 .lock_door
= ide_cdrom_lock_door
,
2015 .select_speed
= ide_cdrom_select_speed
,
2016 .get_last_session
= ide_cdrom_get_last_session
,
2017 .get_mcn
= ide_cdrom_get_mcn
,
2018 .reset
= ide_cdrom_reset
,
2019 .audio_ioctl
= ide_cdrom_audio_ioctl
,
2020 .capability
= IDE_CD_CAPABILITIES
,
2021 .generic_packet
= ide_cdrom_packet
,
2024 static int ide_cdrom_register (ide_drive_t
*drive
, int nslots
)
2026 struct cdrom_info
*info
= drive
->driver_data
;
2027 struct cdrom_device_info
*devinfo
= &info
->devinfo
;
2029 devinfo
->ops
= &ide_cdrom_dops
;
2030 devinfo
->speed
= info
->current_speed
;
2031 devinfo
->capacity
= nslots
;
2032 devinfo
->handle
= drive
;
2033 strcpy(devinfo
->name
, drive
->name
);
2035 if (info
->cd_flags
& IDE_CD_FLAG_NO_SPEED_SELECT
)
2036 devinfo
->mask
|= CDC_SELECT_SPEED
;
2038 devinfo
->disk
= info
->disk
;
2039 return register_cdrom(devinfo
);
2043 int ide_cdrom_probe_capabilities (ide_drive_t
*drive
)
2045 struct cdrom_info
*cd
= drive
->driver_data
;
2046 struct cdrom_device_info
*cdi
= &cd
->devinfo
;
2047 u8 buf
[ATAPI_CAPABILITIES_PAGE_SIZE
];
2048 mechtype_t mechtype
;
2051 cdi
->mask
= (CDC_CD_R
| CDC_CD_RW
| CDC_DVD
| CDC_DVD_R
|
2052 CDC_DVD_RAM
| CDC_SELECT_DISC
| CDC_PLAY_AUDIO
|
2053 CDC_MO_DRIVE
| CDC_RAM
);
2055 if (drive
->media
== ide_optical
) {
2056 cdi
->mask
&= ~(CDC_MO_DRIVE
| CDC_RAM
);
2057 printk(KERN_ERR
"%s: ATAPI magneto-optical drive\n", drive
->name
);
2061 if (cd
->cd_flags
& IDE_CD_FLAG_PRE_ATAPI12
) {
2062 cd
->cd_flags
&= ~IDE_CD_FLAG_NO_EJECT
;
2063 cdi
->mask
&= ~CDC_PLAY_AUDIO
;
2068 * we have to cheat a little here. the packet will eventually
2069 * be queued with ide_cdrom_packet(), which extracts the
2070 * drive from cdi->handle. Since this device hasn't been
2071 * registered with the Uniform layer yet, it can't do this.
2072 * Same goes for cdi->ops.
2074 cdi
->handle
= drive
;
2075 cdi
->ops
= &ide_cdrom_dops
;
2077 if (ide_cdrom_get_capabilities(drive
, buf
))
2080 if ((buf
[8 + 6] & 0x01) == 0)
2081 cd
->cd_flags
|= IDE_CD_FLAG_NO_DOORLOCK
;
2082 if (buf
[8 + 6] & 0x08)
2083 cd
->cd_flags
&= ~IDE_CD_FLAG_NO_EJECT
;
2084 if (buf
[8 + 3] & 0x01)
2085 cdi
->mask
&= ~CDC_CD_R
;
2086 if (buf
[8 + 3] & 0x02)
2087 cdi
->mask
&= ~(CDC_CD_RW
| CDC_RAM
);
2088 if (buf
[8 + 2] & 0x38)
2089 cdi
->mask
&= ~CDC_DVD
;
2090 if (buf
[8 + 3] & 0x20)
2091 cdi
->mask
&= ~(CDC_DVD_RAM
| CDC_RAM
);
2092 if (buf
[8 + 3] & 0x10)
2093 cdi
->mask
&= ~CDC_DVD_R
;
2094 if ((buf
[8 + 4] & 0x01) || (cd
->cd_flags
& IDE_CD_FLAG_PLAY_AUDIO_OK
))
2095 cdi
->mask
&= ~CDC_PLAY_AUDIO
;
2097 mechtype
= buf
[8 + 6] >> 5;
2098 if (mechtype
== mechtype_caddy
|| mechtype
== mechtype_popup
)
2099 cdi
->mask
|= CDC_CLOSE_TRAY
;
2101 if (cdi
->sanyo_slot
> 0) {
2102 cdi
->mask
&= ~CDC_SELECT_DISC
;
2104 } else if (mechtype
== mechtype_individual_changer
||
2105 mechtype
== mechtype_cartridge_changer
) {
2106 nslots
= cdrom_number_of_slots(cdi
);
2108 cdi
->mask
&= ~CDC_SELECT_DISC
;
2111 ide_cdrom_update_speed(drive
, buf
);
2113 printk(KERN_INFO
"%s: ATAPI", drive
->name
);
2115 /* don't print speed if the drive reported 0 */
2117 printk(KERN_CONT
" %dX", cd
->max_speed
);
2119 printk(KERN_CONT
" %s", (cdi
->mask
& CDC_DVD
) ? "CD-ROM" : "DVD-ROM");
2121 if ((cdi
->mask
& CDC_DVD_R
) == 0 || (cdi
->mask
& CDC_DVD_RAM
) == 0)
2122 printk(KERN_CONT
" DVD%s%s",
2123 (cdi
->mask
& CDC_DVD_R
) ? "" : "-R",
2124 (cdi
->mask
& CDC_DVD_RAM
) ? "" : "-RAM");
2126 if ((cdi
->mask
& CDC_CD_R
) == 0 || (cdi
->mask
& CDC_CD_RW
) == 0)
2127 printk(KERN_CONT
" CD%s%s",
2128 (cdi
->mask
& CDC_CD_R
) ? "" : "-R",
2129 (cdi
->mask
& CDC_CD_RW
) ? "" : "/RW");
2131 if ((cdi
->mask
& CDC_SELECT_DISC
) == 0)
2132 printk(KERN_CONT
" changer w/%d slots", nslots
);
2134 printk(KERN_CONT
" drive");
2136 printk(KERN_CONT
", %dkB Cache\n", be16_to_cpu(*(u16
*)&buf
[8 + 12]));
2141 #ifdef CONFIG_IDE_PROC_FS
2142 static void ide_cdrom_add_settings(ide_drive_t
*drive
)
2144 ide_add_setting(drive
, "dsc_overlap", SETTING_RW
, TYPE_BYTE
, 0, 1, 1, 1, &drive
->dsc_overlap
, NULL
);
2147 static inline void ide_cdrom_add_settings(ide_drive_t
*drive
) { ; }
2151 * standard prep_rq_fn that builds 10 byte cmds
2153 static int ide_cdrom_prep_fs(struct request_queue
*q
, struct request
*rq
)
2155 int hard_sect
= queue_hardsect_size(q
);
2156 long block
= (long)rq
->hard_sector
/ (hard_sect
>> 9);
2157 unsigned long blocks
= rq
->hard_nr_sectors
/ (hard_sect
>> 9);
2159 memset(rq
->cmd
, 0, sizeof(rq
->cmd
));
2161 if (rq_data_dir(rq
) == READ
)
2162 rq
->cmd
[0] = GPCMD_READ_10
;
2164 rq
->cmd
[0] = GPCMD_WRITE_10
;
2169 rq
->cmd
[2] = (block
>> 24) & 0xff;
2170 rq
->cmd
[3] = (block
>> 16) & 0xff;
2171 rq
->cmd
[4] = (block
>> 8) & 0xff;
2172 rq
->cmd
[5] = block
& 0xff;
2175 * and transfer length
2177 rq
->cmd
[7] = (blocks
>> 8) & 0xff;
2178 rq
->cmd
[8] = blocks
& 0xff;
2184 * Most of the SCSI commands are supported directly by ATAPI devices.
2185 * This transform handles the few exceptions.
2187 static int ide_cdrom_prep_pc(struct request
*rq
)
2192 * Transform 6-byte read/write commands to the 10-byte version
2194 if (c
[0] == READ_6
|| c
[0] == WRITE_6
) {
2201 c
[0] += (READ_10
- READ_6
);
2207 * it's silly to pretend we understand 6-byte sense commands, just
2208 * reject with ILLEGAL_REQUEST and the caller should take the
2209 * appropriate action
2211 if (c
[0] == MODE_SENSE
|| c
[0] == MODE_SELECT
) {
2212 rq
->errors
= ILLEGAL_REQUEST
;
2213 return BLKPREP_KILL
;
2219 static int ide_cdrom_prep_fn(struct request_queue
*q
, struct request
*rq
)
2221 if (blk_fs_request(rq
))
2222 return ide_cdrom_prep_fs(q
, rq
);
2223 else if (blk_pc_request(rq
))
2224 return ide_cdrom_prep_pc(rq
);
2229 struct cd_list_entry
{
2230 const char *id_model
;
2231 const char *id_firmware
;
2232 unsigned int cd_flags
;
2235 static const struct cd_list_entry ide_cd_quirks_list
[] = {
2236 /* Limit transfer size per interrupt. */
2237 { "SAMSUNG CD-ROM SCR-2430", NULL
, IDE_CD_FLAG_LIMIT_NFRAMES
},
2238 { "SAMSUNG CD-ROM SCR-2432", NULL
, IDE_CD_FLAG_LIMIT_NFRAMES
},
2239 /* SCR-3231 doesn't support the SET_CD_SPEED command. */
2240 { "SAMSUNG CD-ROM SCR-3231", NULL
, IDE_CD_FLAG_NO_SPEED_SELECT
},
2241 /* Old NEC260 (not R) was released before ATAPI 1.2 spec. */
2242 { "NEC CD-ROM DRIVE:260", "1.01", IDE_CD_FLAG_TOCADDR_AS_BCD
|
2243 IDE_CD_FLAG_PRE_ATAPI12
, },
2244 /* Vertos 300, some versions of this drive like to talk BCD. */
2245 { "V003S0DS", NULL
, IDE_CD_FLAG_VERTOS_300_SSD
, },
2246 /* Vertos 600 ESD. */
2247 { "V006E0DS", NULL
, IDE_CD_FLAG_VERTOS_600_ESD
, },
2249 * Sanyo 3 CD changer uses a non-standard command for CD changing
2250 * (by default standard ATAPI support for CD changers is used).
2252 { "CD-ROM CDR-C3 G", NULL
, IDE_CD_FLAG_SANYO_3CD
},
2253 { "CD-ROM CDR-C3G", NULL
, IDE_CD_FLAG_SANYO_3CD
},
2254 { "CD-ROM CDR_C36", NULL
, IDE_CD_FLAG_SANYO_3CD
},
2255 /* Stingray 8X CD-ROM. */
2256 { "STINGRAY 8422 IDE 8X CD-ROM 7-27-95", NULL
, IDE_CD_FLAG_PRE_ATAPI12
},
2258 * ACER 50X CD-ROM and WPI 32X CD-ROM require the full spec length
2259 * mode sense page capabilities size, but older drives break.
2261 { "ATAPI CD ROM DRIVE 50X MAX", NULL
, IDE_CD_FLAG_FULL_CAPS_PAGE
},
2262 { "WPI CDS-32X", NULL
, IDE_CD_FLAG_FULL_CAPS_PAGE
},
2263 /* ACER/AOpen 24X CD-ROM has the speed fields byte-swapped. */
2264 { "", "241N", IDE_CD_FLAG_LE_SPEED_FIELDS
},
2266 * Some drives used by Apple don't advertise audio play
2267 * but they do support reading TOC & audio datas.
2269 { "MATSHITADVD-ROM SR-8187", NULL
, IDE_CD_FLAG_PLAY_AUDIO_OK
},
2270 { "MATSHITADVD-ROM SR-8186", NULL
, IDE_CD_FLAG_PLAY_AUDIO_OK
},
2271 { "MATSHITADVD-ROM SR-8176", NULL
, IDE_CD_FLAG_PLAY_AUDIO_OK
},
2272 { "MATSHITADVD-ROM SR-8174", NULL
, IDE_CD_FLAG_PLAY_AUDIO_OK
},
2276 static unsigned int ide_cd_flags(struct hd_driveid
*id
)
2278 const struct cd_list_entry
*cle
= ide_cd_quirks_list
;
2280 while (cle
->id_model
) {
2281 if (strcmp(cle
->id_model
, id
->model
) == 0 &&
2282 (cle
->id_firmware
== NULL
||
2283 strstr(id
->fw_rev
, cle
->id_firmware
)))
2284 return cle
->cd_flags
;
2292 int ide_cdrom_setup (ide_drive_t
*drive
)
2294 struct cdrom_info
*cd
= drive
->driver_data
;
2295 struct cdrom_device_info
*cdi
= &cd
->devinfo
;
2296 struct hd_driveid
*id
= drive
->id
;
2299 blk_queue_prep_rq(drive
->queue
, ide_cdrom_prep_fn
);
2300 blk_queue_dma_alignment(drive
->queue
, 31);
2301 drive
->queue
->unplug_delay
= (1 * HZ
) / 1000;
2302 if (!drive
->queue
->unplug_delay
)
2303 drive
->queue
->unplug_delay
= 1;
2305 drive
->special
.all
= 0;
2307 cd
->cd_flags
= IDE_CD_FLAG_MEDIA_CHANGED
| IDE_CD_FLAG_NO_EJECT
|
2310 if ((id
->config
& 0x0060) == 0x20)
2311 cd
->cd_flags
|= IDE_CD_FLAG_DRQ_INTERRUPT
;
2313 if ((cd
->cd_flags
& IDE_CD_FLAG_VERTOS_300_SSD
) &&
2314 id
->fw_rev
[4] == '1' && id
->fw_rev
[6] <= '2')
2315 cd
->cd_flags
|= (IDE_CD_FLAG_TOCTRACKS_AS_BCD
|
2316 IDE_CD_FLAG_TOCADDR_AS_BCD
);
2317 else if ((cd
->cd_flags
& IDE_CD_FLAG_VERTOS_600_ESD
) &&
2318 id
->fw_rev
[4] == '1' && id
->fw_rev
[6] <= '2')
2319 cd
->cd_flags
|= IDE_CD_FLAG_TOCTRACKS_AS_BCD
;
2320 else if (cd
->cd_flags
& IDE_CD_FLAG_SANYO_3CD
)
2321 cdi
->sanyo_slot
= 3; /* 3 => use CD in slot 0 */
2323 nslots
= ide_cdrom_probe_capabilities (drive
);
2326 * set correct block size
2328 blk_queue_hardsect_size(drive
->queue
, CD_FRAMESIZE
);
2330 if (drive
->autotune
== IDE_TUNE_DEFAULT
||
2331 drive
->autotune
== IDE_TUNE_AUTO
)
2332 drive
->dsc_overlap
= (drive
->next
!= drive
);
2334 if (ide_cdrom_register(drive
, nslots
)) {
2335 printk (KERN_ERR
"%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive
->name
);
2336 cd
->devinfo
.handle
= NULL
;
2339 ide_cdrom_add_settings(drive
);
2343 #ifdef CONFIG_IDE_PROC_FS
2345 sector_t
ide_cdrom_capacity (ide_drive_t
*drive
)
2347 unsigned long capacity
, sectors_per_frame
;
2349 if (cdrom_read_capacity(drive
, &capacity
, §ors_per_frame
, NULL
))
2352 return capacity
* sectors_per_frame
;
2356 static void ide_cd_remove(ide_drive_t
*drive
)
2358 struct cdrom_info
*info
= drive
->driver_data
;
2360 ide_proc_unregister_driver(drive
, info
->driver
);
2362 del_gendisk(info
->disk
);
2367 static void ide_cd_release(struct kref
*kref
)
2369 struct cdrom_info
*info
= to_ide_cd(kref
);
2370 struct cdrom_device_info
*devinfo
= &info
->devinfo
;
2371 ide_drive_t
*drive
= info
->drive
;
2372 struct gendisk
*g
= info
->disk
;
2374 kfree(info
->buffer
);
2376 if (devinfo
->handle
== drive
&& unregister_cdrom(devinfo
))
2377 printk(KERN_ERR
"%s: %s failed to unregister device from the cdrom "
2378 "driver.\n", __FUNCTION__
, drive
->name
);
2379 drive
->dsc_overlap
= 0;
2380 drive
->driver_data
= NULL
;
2381 blk_queue_prep_rq(drive
->queue
, NULL
);
2382 g
->private_data
= NULL
;
2387 static int ide_cd_probe(ide_drive_t
*);
2389 #ifdef CONFIG_IDE_PROC_FS
2390 static int proc_idecd_read_capacity
2391 (char *page
, char **start
, off_t off
, int count
, int *eof
, void *data
)
2393 ide_drive_t
*drive
= data
;
2396 len
= sprintf(page
,"%llu\n", (long long)ide_cdrom_capacity(drive
));
2397 PROC_IDE_READ_RETURN(page
,start
,off
,count
,eof
,len
);
2400 static ide_proc_entry_t idecd_proc
[] = {
2401 { "capacity", S_IFREG
|S_IRUGO
, proc_idecd_read_capacity
, NULL
},
2402 { NULL
, 0, NULL
, NULL
}
2406 static ide_driver_t ide_cdrom_driver
= {
2408 .owner
= THIS_MODULE
,
2409 .name
= "ide-cdrom",
2410 .bus
= &ide_bus_type
,
2412 .probe
= ide_cd_probe
,
2413 .remove
= ide_cd_remove
,
2414 .version
= IDECD_VERSION
,
2416 .supports_dsc_overlap
= 1,
2417 .do_request
= ide_do_rw_cdrom
,
2418 .end_request
= ide_end_request
,
2419 .error
= __ide_error
,
2420 .abort
= __ide_abort
,
2421 #ifdef CONFIG_IDE_PROC_FS
2426 static int idecd_open(struct inode
* inode
, struct file
* file
)
2428 struct gendisk
*disk
= inode
->i_bdev
->bd_disk
;
2429 struct cdrom_info
*info
;
2432 if (!(info
= ide_cd_get(disk
)))
2436 info
->buffer
= kmalloc(SECTOR_BUFFER_SIZE
, GFP_KERNEL
|__GFP_REPEAT
);
2439 rc
= cdrom_open(&info
->devinfo
, inode
, file
);
2447 static int idecd_release(struct inode
* inode
, struct file
* file
)
2449 struct gendisk
*disk
= inode
->i_bdev
->bd_disk
;
2450 struct cdrom_info
*info
= ide_cd_g(disk
);
2452 cdrom_release (&info
->devinfo
, file
);
2459 static int idecd_set_spindown(struct cdrom_device_info
*cdi
, unsigned long arg
)
2461 struct packet_command cgc
;
2466 if (copy_from_user(&spindown
, (void __user
*)arg
, sizeof(char)))
2469 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_UNKNOWN
);
2471 stat
= cdrom_mode_sense(cdi
, &cgc
, GPMODE_CDROM_PAGE
, 0);
2475 buffer
[11] = (buffer
[11] & 0xf0) | (spindown
& 0x0f);
2476 return cdrom_mode_select(cdi
, &cgc
);
2479 static int idecd_get_spindown(struct cdrom_device_info
*cdi
, unsigned long arg
)
2481 struct packet_command cgc
;
2486 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_UNKNOWN
);
2488 stat
= cdrom_mode_sense(cdi
, &cgc
, GPMODE_CDROM_PAGE
, 0);
2492 spindown
= buffer
[11] & 0x0f;
2493 if (copy_to_user((void __user
*)arg
, &spindown
, sizeof (char)))
2498 static int idecd_ioctl (struct inode
*inode
, struct file
*file
,
2499 unsigned int cmd
, unsigned long arg
)
2501 struct block_device
*bdev
= inode
->i_bdev
;
2502 struct cdrom_info
*info
= ide_cd_g(bdev
->bd_disk
);
2506 case CDROMSETSPINDOWN
:
2507 return idecd_set_spindown(&info
->devinfo
, arg
);
2508 case CDROMGETSPINDOWN
:
2509 return idecd_get_spindown(&info
->devinfo
, arg
);
2514 err
= generic_ide_ioctl(info
->drive
, file
, bdev
, cmd
, arg
);
2516 err
= cdrom_ioctl(file
, &info
->devinfo
, inode
, cmd
, arg
);
2521 static int idecd_media_changed(struct gendisk
*disk
)
2523 struct cdrom_info
*info
= ide_cd_g(disk
);
2524 return cdrom_media_changed(&info
->devinfo
);
2527 static int idecd_revalidate_disk(struct gendisk
*disk
)
2529 struct cdrom_info
*info
= ide_cd_g(disk
);
2530 struct request_sense sense
;
2532 ide_cd_read_toc(info
->drive
, &sense
);
2537 static struct block_device_operations idecd_ops
= {
2538 .owner
= THIS_MODULE
,
2540 .release
= idecd_release
,
2541 .ioctl
= idecd_ioctl
,
2542 .media_changed
= idecd_media_changed
,
2543 .revalidate_disk
= idecd_revalidate_disk
2547 static char *ignore
= NULL
;
2549 module_param(ignore
, charp
, 0400);
2550 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
2552 static int ide_cd_probe(ide_drive_t
*drive
)
2554 struct cdrom_info
*info
;
2556 struct request_sense sense
;
2558 if (!strstr("ide-cdrom", drive
->driver_req
))
2560 if (!drive
->present
)
2562 if (drive
->media
!= ide_cdrom
&& drive
->media
!= ide_optical
)
2564 /* skip drives that we were told to ignore */
2565 if (ignore
!= NULL
) {
2566 if (strstr(ignore
, drive
->name
)) {
2567 printk(KERN_INFO
"ide-cd: ignoring drive %s\n", drive
->name
);
2572 printk(KERN_INFO
"ide-cd: passing drive %s to ide-scsi emulation.\n", drive
->name
);
2575 info
= kzalloc(sizeof(struct cdrom_info
), GFP_KERNEL
);
2577 printk(KERN_ERR
"%s: Can't allocate a cdrom structure\n", drive
->name
);
2581 g
= alloc_disk(1 << PARTN_BITS
);
2585 ide_init_disk(g
, drive
);
2587 ide_proc_register_driver(drive
, &ide_cdrom_driver
);
2589 kref_init(&info
->kref
);
2591 info
->drive
= drive
;
2592 info
->driver
= &ide_cdrom_driver
;
2595 g
->private_data
= &info
->driver
;
2597 drive
->driver_data
= info
;
2600 g
->driverfs_dev
= &drive
->gendev
;
2601 g
->flags
= GENHD_FL_CD
| GENHD_FL_REMOVABLE
;
2602 if (ide_cdrom_setup(drive
)) {
2603 ide_proc_unregister_driver(drive
, &ide_cdrom_driver
);
2604 ide_cd_release(&info
->kref
);
2608 ide_cd_read_toc(drive
, &sense
);
2609 g
->fops
= &idecd_ops
;
2610 g
->flags
|= GENHD_FL_REMOVABLE
;
2620 static void __exit
ide_cdrom_exit(void)
2622 driver_unregister(&ide_cdrom_driver
.gen_driver
);
2625 static int __init
ide_cdrom_init(void)
2627 return driver_register(&ide_cdrom_driver
.gen_driver
);
2630 MODULE_ALIAS("ide:*m-cdrom*");
2631 MODULE_ALIAS("ide-cd");
2632 module_init(ide_cdrom_init
);
2633 module_exit(ide_cdrom_exit
);
2634 MODULE_LICENSE("GPL");