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>
50 #include <scsi/scsi.h> /* For SCSI -> ATAPI command conversion */
54 #include <asm/byteorder.h>
55 #include <asm/uaccess.h>
56 #include <asm/unaligned.h>
60 static DEFINE_MUTEX(idecd_ref_mutex);
62 #define to_ide_cd(obj) container_of(obj, struct cdrom_info, kref)
64 #define ide_cd_g(disk) \
65 container_of((disk)->private_data, struct cdrom_info, driver)
67 static struct cdrom_info *ide_cd_get(struct gendisk *disk)
69 struct cdrom_info *cd = NULL;
71 mutex_lock(&idecd_ref_mutex);
75 mutex_unlock(&idecd_ref_mutex);
79 static void ide_cd_release(struct kref *);
81 static void ide_cd_put(struct cdrom_info *cd)
83 mutex_lock(&idecd_ref_mutex);
84 kref_put(&cd->kref, ide_cd_release);
85 mutex_unlock(&idecd_ref_mutex);
88 /****************************************************************************
89 * Generic packet command support and error handling routines.
92 /* Mark that we've seen a media change, and invalidate our internal
94 static void cdrom_saw_media_change (ide_drive_t *drive)
96 struct cdrom_info *cd = drive->driver_data;
98 cd->cd_flags |= IDE_CD_FLAG_MEDIA_CHANGED;
99 cd->cd_flags &= ~IDE_CD_FLAG_TOC_VALID;
100 cd->nsectors_buffered = 0;
103 static int cdrom_log_sense(ide_drive_t *drive, struct request *rq,
104 struct request_sense *sense)
108 if (!sense || !rq || (rq->cmd_flags & REQ_QUIET))
111 switch (sense->sense_key) {
112 case NO_SENSE: case RECOVERED_ERROR:
116 * don't care about tray state messages for
117 * e.g. capacity commands or in-progress or
120 if (sense->asc == 0x3a || sense->asc == 0x04)
124 case ILLEGAL_REQUEST:
126 * don't log START_STOP unit with LoEj set, since
127 * we cannot reliably check if drive can auto-close
129 if (rq->cmd[0] == GPCMD_START_STOP_UNIT && sense->asc == 0x24)
135 * Make good and sure we've seen this potential media
136 * change. Some drives (i.e. Creative) fail to present
137 * the correct sense key in the error register.
139 cdrom_saw_media_change(drive);
149 void cdrom_analyze_sense_data(ide_drive_t *drive,
150 struct request *failed_command,
151 struct request_sense *sense)
153 unsigned long sector;
154 unsigned long bio_sectors;
156 struct cdrom_info *info = drive->driver_data;
158 if (!cdrom_log_sense(drive, failed_command, sense))
162 * If a read toc is executed for a CD-R or CD-RW medium where
163 * the first toc has not been recorded yet, it will fail with
164 * 05/24/00 (which is a confusing error)
166 if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP)
167 if (sense->sense_key == 0x05 && sense->asc == 0x24)
170 if (sense->error_code == 0x70) { /* Current Error */
171 switch(sense->sense_key) {
173 case VOLUME_OVERFLOW:
174 case ILLEGAL_REQUEST:
177 if (failed_command == NULL ||
178 !blk_fs_request(failed_command))
180 sector = (sense->information[0] << 24) |
181 (sense->information[1] << 16) |
182 (sense->information[2] << 8) |
183 (sense->information[3]);
185 bio_sectors = bio_sectors(failed_command->bio);
188 if (drive->queue->hardsect_size == 2048)
189 sector <<= 2; /* Device sector size is 2K */
190 sector &= ~(bio_sectors -1);
191 valid = (sector - failed_command->sector) << 9;
195 if (sector < get_capacity(info->disk) &&
196 drive->probed_capacity - sector < 4 * 75) {
197 set_capacity(info->disk, sector);
201 #if VERBOSE_IDE_CD_ERRORS
204 const char *s = "bad sense key!";
207 printk ("ATAPI device %s:\n", drive->name);
208 if (sense->error_code==0x70)
210 else if (sense->error_code==0x71)
211 printk(" Deferred Error: ");
212 else if (sense->error_code == 0x7f)
213 printk(" Vendor-specific Error: ");
215 printk(" Unknown Error Type: ");
217 if (sense->sense_key < ARRAY_SIZE(sense_key_texts))
218 s = sense_key_texts[sense->sense_key];
220 printk("%s -- (Sense key=0x%02x)\n", s, sense->sense_key);
222 if (sense->asc == 0x40) {
223 sprintf(buf, "Diagnostic failure on component 0x%02x",
227 int lo = 0, mid, hi = ARRAY_SIZE(sense_data_texts);
228 unsigned long key = (sense->sense_key << 16);
229 key |= (sense->asc << 8);
230 if (!(sense->ascq >= 0x80 && sense->ascq <= 0xdd))
236 if (sense_data_texts[mid].asc_ascq == key ||
237 sense_data_texts[mid].asc_ascq == (0xff0000|key)) {
238 s = sense_data_texts[mid].text;
241 else if (sense_data_texts[mid].asc_ascq > key)
249 if (sense->asc > 0x80)
250 s = "(vendor-specific error)";
252 s = "(reserved error code)";
255 printk(KERN_ERR " %s -- (asc=0x%02x, ascq=0x%02x)\n",
256 s, sense->asc, sense->ascq);
258 if (failed_command != NULL) {
260 int lo=0, mid, hi= ARRAY_SIZE(packet_command_texts);
265 if (packet_command_texts[mid].packet_command ==
266 failed_command->cmd[0]) {
267 s = packet_command_texts[mid].text;
270 if (packet_command_texts[mid].packet_command >
271 failed_command->cmd[0])
277 printk (KERN_ERR " The failed \"%s\" packet command was: \n \"", s);
278 for (i=0; i<sizeof (failed_command->cmd); i++)
279 printk ("%02x ", failed_command->cmd[i]);
283 /* The SKSV bit specifies validity of the sense_key_specific
284 * in the next two commands. It is bit 7 of the first byte.
285 * In the case of NOT_READY, if SKSV is set the drive can
286 * give us nice ETA readings.
288 if (sense->sense_key == NOT_READY && (sense->sks[0] & 0x80)) {
289 int progress = (sense->sks[1] << 8 | sense->sks[2]) * 100;
290 printk(KERN_ERR " Command is %02d%% complete\n", progress / 0xffff);
294 if (sense->sense_key == ILLEGAL_REQUEST &&
295 (sense->sks[0] & 0x80) != 0) {
296 printk(KERN_ERR " Error in %s byte %d",
297 (sense->sks[0] & 0x40) != 0 ?
298 "command packet" : "command data",
299 (sense->sks[1] << 8) + sense->sks[2]);
301 if ((sense->sks[0] & 0x40) != 0)
302 printk (" bit %d", sense->sks[0] & 0x07);
308 #else /* not VERBOSE_IDE_CD_ERRORS */
310 /* Suppress printing unit attention and `in progress of becoming ready'
311 errors when we're not being verbose. */
313 if (sense->sense_key == UNIT_ATTENTION ||
314 (sense->sense_key == NOT_READY && (sense->asc == 4 ||
315 sense->asc == 0x3a)))
318 printk(KERN_ERR "%s: error code: 0x%02x sense_key: 0x%02x asc: 0x%02x ascq: 0x%02x\n",
320 sense->error_code, sense->sense_key,
321 sense->asc, sense->ascq);
322 #endif /* not VERBOSE_IDE_CD_ERRORS */
326 * Initialize a ide-cd packet command request
328 static void cdrom_prepare_request(ide_drive_t *drive, struct request *rq)
330 struct cdrom_info *cd = drive->driver_data;
332 ide_init_drive_cmd(rq);
333 rq->cmd_type = REQ_TYPE_ATA_PC;
334 rq->rq_disk = cd->disk;
337 static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense,
338 struct request *failed_command)
340 struct cdrom_info *info = drive->driver_data;
341 struct request *rq = &info->request_sense_request;
344 sense = &info->sense_data;
346 /* stuff the sense request in front of our current request */
347 cdrom_prepare_request(drive, rq);
350 rq->cmd[0] = GPCMD_REQUEST_SENSE;
351 rq->cmd[4] = rq->data_len = 18;
353 rq->cmd_type = REQ_TYPE_SENSE;
355 /* NOTE! Save the failed command in "rq->buffer" */
356 rq->buffer = (void *) failed_command;
358 (void) ide_do_drive_cmd(drive, rq, ide_preempt);
361 static void cdrom_end_request (ide_drive_t *drive, int uptodate)
363 struct request *rq = HWGROUP(drive)->rq;
364 int nsectors = rq->hard_cur_sectors;
366 if (blk_sense_request(rq) && uptodate) {
368 * For REQ_TYPE_SENSE, "rq->buffer" points to the original
371 struct request *failed = (struct request *) rq->buffer;
372 struct cdrom_info *info = drive->driver_data;
373 void *sense = &info->sense_data;
378 sense = failed->sense;
379 failed->sense_len = rq->sense_len;
381 cdrom_analyze_sense_data(drive, failed, sense);
383 * now end failed request
385 if (blk_fs_request(failed)) {
386 if (ide_end_dequeued_request(drive, failed, 0,
387 failed->hard_nr_sectors))
390 spin_lock_irqsave(&ide_lock, flags);
391 if (__blk_end_request(failed, -EIO,
394 spin_unlock_irqrestore(&ide_lock, flags);
397 cdrom_analyze_sense_data(drive, NULL, sense);
400 if (!rq->current_nr_sectors && blk_fs_request(rq))
402 /* make sure it's fully ended */
403 if (blk_pc_request(rq))
404 nsectors = (rq->data_len + 511) >> 9;
408 ide_end_request(drive, uptodate, nsectors);
411 static void ide_dump_status_no_sense(ide_drive_t *drive, const char *msg, u8 stat)
415 ide_dump_status(drive, msg, stat);
418 /* Returns 0 if the request should be continued.
419 Returns 1 if the request was ended. */
420 static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
422 struct request *rq = HWGROUP(drive)->rq;
423 int stat, err, sense_key;
425 /* Check for errors. */
426 stat = HWIF(drive)->INB(IDE_STATUS_REG);
430 if (OK_STAT(stat, good_stat, BAD_R_STAT))
433 /* Get the IDE error register. */
434 err = HWIF(drive)->INB(IDE_ERROR_REG);
435 sense_key = err >> 4;
438 printk("%s: missing rq in cdrom_decode_status\n", drive->name);
442 if (blk_sense_request(rq)) {
443 /* We got an error trying to get sense info
444 from the drive (probably while trying
445 to recover from a former error). Just give up. */
447 rq->cmd_flags |= REQ_FAILED;
448 cdrom_end_request(drive, 0);
449 ide_error(drive, "request sense failure", stat);
452 } else if (blk_pc_request(rq) || rq->cmd_type == REQ_TYPE_ATA_PC) {
453 /* All other functions, except for READ. */
457 * if we have an error, pass back CHECK_CONDITION as the
460 if (blk_pc_request(rq) && !rq->errors)
461 rq->errors = SAM_STAT_CHECK_CONDITION;
463 /* Check for tray open. */
464 if (sense_key == NOT_READY) {
465 cdrom_saw_media_change (drive);
466 } else if (sense_key == UNIT_ATTENTION) {
467 /* Check for media change. */
468 cdrom_saw_media_change (drive);
469 /*printk("%s: media changed\n",drive->name);*/
471 } else if ((sense_key == ILLEGAL_REQUEST) &&
472 (rq->cmd[0] == GPCMD_START_STOP_UNIT)) {
474 * Don't print error message for this condition--
475 * SFF8090i indicates that 5/24/00 is the correct
476 * response to a request to close the tray if the
477 * drive doesn't have that capability.
478 * cdrom_log_sense() knows this!
480 } else if (!(rq->cmd_flags & REQ_QUIET)) {
481 /* Otherwise, print an error. */
482 ide_dump_status(drive, "packet command error", stat);
485 rq->cmd_flags |= REQ_FAILED;
488 * instead of playing games with moving completions around,
489 * remove failed request completely and end it when the
490 * request sense has completed
492 if (stat & ERR_STAT) {
493 spin_lock_irqsave(&ide_lock, flags);
494 blkdev_dequeue_request(rq);
495 HWGROUP(drive)->rq = NULL;
496 spin_unlock_irqrestore(&ide_lock, flags);
498 cdrom_queue_request_sense(drive, rq->sense, rq);
500 cdrom_end_request(drive, 0);
502 } else if (blk_fs_request(rq)) {
503 int do_end_request = 0;
505 /* Handle errors from READ and WRITE requests. */
507 if (blk_noretry_request(rq))
510 if (sense_key == NOT_READY) {
512 if (rq_data_dir(rq) == READ) {
513 cdrom_saw_media_change (drive);
515 /* Fail the request. */
516 printk ("%s: tray open\n", drive->name);
519 struct cdrom_info *info = drive->driver_data;
521 /* allow the drive 5 seconds to recover, some
522 * devices will return this error while flushing
525 info->write_timeout = jiffies + ATAPI_WAIT_WRITE_BUSY;
527 if (time_after(jiffies, info->write_timeout))
533 * take a breather relying on the
534 * unplug timer to kick us again
536 spin_lock_irqsave(&ide_lock, flags);
537 blk_plug_device(drive->queue);
538 spin_unlock_irqrestore(&ide_lock,flags);
542 } else if (sense_key == UNIT_ATTENTION) {
544 cdrom_saw_media_change (drive);
546 /* Arrange to retry the request.
547 But be sure to give up if we've retried
549 if (++rq->errors > ERROR_MAX)
551 } else if (sense_key == ILLEGAL_REQUEST ||
552 sense_key == DATA_PROTECT) {
553 /* No point in retrying after an illegal
554 request or data protect error.*/
555 ide_dump_status_no_sense (drive, "command error", stat);
557 } else if (sense_key == MEDIUM_ERROR) {
558 /* No point in re-trying a zillion times on a bad
559 * sector... If we got here the error is not correctable */
560 ide_dump_status_no_sense (drive, "media error (bad sector)", stat);
562 } else if (sense_key == BLANK_CHECK) {
563 /* Disk appears blank ?? */
564 ide_dump_status_no_sense (drive, "media error (blank)", stat);
566 } else if ((err & ~ABRT_ERR) != 0) {
567 /* Go to the default handler
569 ide_error(drive, "cdrom_decode_status", stat);
571 } else if ((++rq->errors > ERROR_MAX)) {
572 /* We've racked up too many retries. Abort. */
576 /* End a request through request sense analysis when we have
577 sense data. We need this in order to perform end of media
580 if (do_end_request) {
581 if (stat & ERR_STAT) {
583 spin_lock_irqsave(&ide_lock, flags);
584 blkdev_dequeue_request(rq);
585 HWGROUP(drive)->rq = NULL;
586 spin_unlock_irqrestore(&ide_lock, flags);
588 cdrom_queue_request_sense(drive, rq->sense, rq);
590 cdrom_end_request(drive, 0);
592 /* If we got a CHECK_CONDITION status,
593 queue a request sense command. */
595 cdrom_queue_request_sense(drive, NULL, NULL);
598 blk_dump_rq_flags(rq, "ide-cd: bad rq");
599 cdrom_end_request(drive, 0);
602 /* Retry, or handle the next request. */
606 static int cdrom_timer_expiry(ide_drive_t *drive)
608 struct request *rq = HWGROUP(drive)->rq;
609 unsigned long wait = 0;
612 * Some commands are *slow* and normally take a long time to
613 * complete. Usually we can use the ATAPI "disconnect" to bypass
614 * this, but not all commands/drives support that. Let
615 * ide_timer_expiry keep polling us for these.
617 switch (rq->cmd[0]) {
619 case GPCMD_FORMAT_UNIT:
620 case GPCMD_RESERVE_RZONE_TRACK:
621 case GPCMD_CLOSE_TRACK:
622 case GPCMD_FLUSH_CACHE:
623 wait = ATAPI_WAIT_PC;
626 if (!(rq->cmd_flags & REQ_QUIET))
627 printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n", rq->cmd[0]);
634 /* Set up the device registers for transferring a packet command on DEV,
635 expecting to later transfer XFERLEN bytes. HANDLER is the routine
636 which actually transfers the command to the drive. If this is a
637 drq_interrupt device, this routine will arrange for HANDLER to be
638 called when the interrupt from the drive arrives. Otherwise, HANDLER
639 will be called immediately after the drive is prepared for the transfer. */
641 static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
643 ide_handler_t *handler)
645 ide_startstop_t startstop;
646 struct cdrom_info *info = drive->driver_data;
647 ide_hwif_t *hwif = drive->hwif;
649 /* Wait for the controller to be idle. */
650 if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY))
653 /* FIXME: for Virtual DMA we must check harder */
655 info->dma = !hwif->dma_setup(drive);
657 /* Set up the controller registers. */
658 ide_pktcmd_tf_load(drive, IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL |
659 IDE_TFLAG_NO_SELECT_MASK, xferlen, info->dma);
661 if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) {
662 /* waiting for CDB interrupt, not DMA yet. */
664 drive->waiting_for_dma = 0;
667 ide_execute_command(drive, WIN_PACKETCMD, handler, ATAPI_WAIT_PC, cdrom_timer_expiry);
673 spin_lock_irqsave(&ide_lock, flags);
674 hwif->OUTBSYNC(drive, WIN_PACKETCMD, IDE_COMMAND_REG);
676 spin_unlock_irqrestore(&ide_lock, flags);
678 return (*handler) (drive);
682 /* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
683 The device registers must have already been prepared
684 by cdrom_start_packet_command.
685 HANDLER is the interrupt handler to call when the command completes
686 or there's data ready. */
687 #define ATAPI_MIN_CDB_BYTES 12
688 static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
690 ide_handler_t *handler)
692 ide_hwif_t *hwif = drive->hwif;
694 struct cdrom_info *info = drive->driver_data;
695 ide_startstop_t startstop;
697 if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) {
698 /* Here we should have been called after receiving an interrupt
699 from the device. DRQ should how be set. */
701 /* Check for errors. */
702 if (cdrom_decode_status(drive, DRQ_STAT, NULL))
705 /* Ok, next interrupt will be DMA interrupt. */
707 drive->waiting_for_dma = 1;
709 /* Otherwise, we must wait for DRQ to get set. */
710 if (ide_wait_stat(&startstop, drive, DRQ_STAT,
711 BUSY_STAT, WAIT_READY))
715 /* Arm the interrupt handler. */
716 ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);
718 /* ATAPI commands get padded out to 12 bytes minimum */
719 cmd_len = COMMAND_SIZE(rq->cmd[0]);
720 if (cmd_len < ATAPI_MIN_CDB_BYTES)
721 cmd_len = ATAPI_MIN_CDB_BYTES;
723 /* Send the command to the device. */
724 HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len);
726 /* Start the DMA if need be */
728 hwif->dma_start(drive);
733 /****************************************************************************
734 * Block read functions.
737 typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
739 static void ide_cd_pad_transfer(ide_drive_t *drive, xfer_func_t *xf, int len)
743 xf(drive, &dum, sizeof(dum));
749 * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
750 * buffer. Once the first sector is added, any subsequent sectors are
751 * assumed to be continuous (until the buffer is cleared). For the first
752 * sector added, SECTOR is its sector number. (SECTOR is then ignored until
753 * the buffer is cleared.)
755 static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
756 int sectors_to_transfer)
758 struct cdrom_info *info = drive->driver_data;
760 /* Number of sectors to read into the buffer. */
761 int sectors_to_buffer = min_t(int, sectors_to_transfer,
762 (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
763 info->nsectors_buffered);
767 /* If we couldn't get a buffer, don't try to buffer anything... */
768 if (info->buffer == NULL)
769 sectors_to_buffer = 0;
771 /* If this is the first sector in the buffer, remember its number. */
772 if (info->nsectors_buffered == 0)
773 info->sector_buffered = sector;
775 /* Read the data into the buffer. */
776 dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
777 while (sectors_to_buffer > 0) {
778 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
780 --sectors_to_transfer;
781 ++info->nsectors_buffered;
785 /* Throw away any remaining data. */
786 while (sectors_to_transfer > 0) {
787 static char dum[SECTOR_SIZE];
788 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
789 --sectors_to_transfer;
794 * Check the contents of the interrupt reason register from the cdrom
795 * and attempt to recover if there are problems. Returns 0 if everything's
796 * ok; nonzero if the request has been terminated.
799 int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
803 else if (ireason == 0) {
804 ide_hwif_t *hwif = drive->hwif;
806 /* Whoops... The drive is expecting to receive data from us! */
807 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
808 drive->name, __FUNCTION__);
810 /* Throw some data at the drive so it doesn't hang
811 and quit this request. */
812 ide_cd_pad_transfer(drive, hwif->atapi_output_bytes, len);
813 } else if (ireason == 1) {
814 /* Some drives (ASUS) seem to tell us that status
815 * info is available. just get it and ignore.
817 (void) HWIF(drive)->INB(IDE_STATUS_REG);
820 /* Drive wants a command packet, or invalid ireason... */
821 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
822 drive->name, __FUNCTION__, ireason);
825 cdrom_end_request(drive, 0);
830 * Interrupt routine. Called when a read request has completed.
832 static ide_startstop_t cdrom_read_intr (ide_drive_t *drive)
835 int ireason, len, sectors_to_transfer, nskip;
836 struct cdrom_info *info = drive->driver_data;
837 u8 lowcyl = 0, highcyl = 0;
838 int dma = info->dma, dma_error = 0;
840 struct request *rq = HWGROUP(drive)->rq;
847 dma_error = HWIF(drive)->ide_dma_end(drive);
849 printk(KERN_ERR "%s: DMA read error\n", drive->name);
854 if (cdrom_decode_status(drive, 0, &stat))
859 ide_end_request(drive, 1, rq->nr_sectors);
862 return ide_error(drive, "dma error", stat);
865 /* Read the interrupt reason and the transfer length. */
866 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
867 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
868 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
870 len = lowcyl + (256 * highcyl);
872 /* If DRQ is clear, the command has completed. */
873 if ((stat & DRQ_STAT) == 0) {
874 /* If we're not done filling the current buffer, complain.
875 Otherwise, complete the command normally. */
876 if (rq->current_nr_sectors > 0) {
877 printk (KERN_ERR "%s: cdrom_read_intr: data underrun (%d blocks)\n",
878 drive->name, rq->current_nr_sectors);
879 rq->cmd_flags |= REQ_FAILED;
880 cdrom_end_request(drive, 0);
882 cdrom_end_request(drive, 1);
886 /* Check that the drive is expecting to do the same thing we are. */
887 if (cdrom_read_check_ireason (drive, len, ireason))
890 /* Assume that the drive will always provide data in multiples
891 of at least SECTOR_SIZE, as it gets hairy to keep track
892 of the transfers otherwise. */
893 if ((len % SECTOR_SIZE) != 0) {
894 printk (KERN_ERR "%s: cdrom_read_intr: Bad transfer size %d\n",
896 if (info->cd_flags & IDE_CD_FLAG_LIMIT_NFRAMES)
897 printk (KERN_ERR " This drive is not supported by this version of the driver\n");
899 printk (KERN_ERR " Trying to limit transfer sizes\n");
900 info->cd_flags |= IDE_CD_FLAG_LIMIT_NFRAMES;
902 cdrom_end_request(drive, 0);
906 /* The number of sectors we need to read from the drive. */
907 sectors_to_transfer = len / SECTOR_SIZE;
909 /* First, figure out if we need to bit-bucket
910 any of the leading sectors. */
911 nskip = min_t(int, rq->current_nr_sectors - bio_cur_sectors(rq->bio), sectors_to_transfer);
914 /* We need to throw away a sector. */
915 static char dum[SECTOR_SIZE];
916 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
918 --rq->current_nr_sectors;
920 --sectors_to_transfer;
923 /* Now loop while we still have data to read from the drive. */
924 while (sectors_to_transfer > 0) {
927 /* If we've filled the present buffer but there's another
928 chained buffer after it, move on. */
929 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
930 cdrom_end_request(drive, 1);
932 /* If the buffers are full, cache the rest of the data in our
934 if (rq->current_nr_sectors == 0) {
935 cdrom_buffer_sectors(drive, rq->sector, sectors_to_transfer);
936 sectors_to_transfer = 0;
938 /* Transfer data to the buffers.
939 Figure out how many sectors we can transfer
940 to the current buffer. */
941 this_transfer = min_t(int, sectors_to_transfer,
942 rq->current_nr_sectors);
944 /* Read this_transfer sectors
945 into the current buffer. */
946 while (this_transfer > 0) {
947 HWIF(drive)->atapi_input_bytes(drive, rq->buffer, SECTOR_SIZE);
948 rq->buffer += SECTOR_SIZE;
950 --rq->current_nr_sectors;
953 --sectors_to_transfer;
958 /* Done moving data! Wait for another interrupt. */
959 ide_set_handler(drive, &cdrom_read_intr, ATAPI_WAIT_PC, NULL);
964 * Try to satisfy some of the current read request from our cached data.
965 * Returns nonzero if the request has been completed, zero otherwise.
967 static int cdrom_read_from_buffer (ide_drive_t *drive)
969 struct cdrom_info *info = drive->driver_data;
970 struct request *rq = HWGROUP(drive)->rq;
971 unsigned short sectors_per_frame;
973 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
975 /* Can't do anything if there's no buffer. */
976 if (info->buffer == NULL) return 0;
978 /* Loop while this request needs data and the next block is present
980 while (rq->nr_sectors > 0 &&
981 rq->sector >= info->sector_buffered &&
982 rq->sector < info->sector_buffered + info->nsectors_buffered) {
983 if (rq->current_nr_sectors == 0)
984 cdrom_end_request(drive, 1);
988 (rq->sector - info->sector_buffered) * SECTOR_SIZE,
990 rq->buffer += SECTOR_SIZE;
991 --rq->current_nr_sectors;
996 /* If we've satisfied the current request,
997 terminate it successfully. */
998 if (rq->nr_sectors == 0) {
999 cdrom_end_request(drive, 1);
1003 /* Move on to the next buffer if needed. */
1004 if (rq->current_nr_sectors == 0)
1005 cdrom_end_request(drive, 1);
1007 /* If this condition does not hold, then the kluge i use to
1008 represent the number of sectors to skip at the start of a transfer
1009 will fail. I think that this will never happen, but let's be
1010 paranoid and check. */
1011 if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
1012 (rq->sector & (sectors_per_frame - 1))) {
1013 printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
1014 drive->name, (long)rq->sector);
1015 cdrom_end_request(drive, 0);
1023 * Routine to send a read packet command to the drive.
1024 * This is usually called directly from cdrom_start_read.
1025 * However, for drq_interrupt devices, it is called from an interrupt
1026 * when the drive is ready to accept the command.
1028 static ide_startstop_t cdrom_start_read_continuation (ide_drive_t *drive)
1030 struct request *rq = HWGROUP(drive)->rq;
1031 unsigned short sectors_per_frame;
1034 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1036 /* If the requested sector doesn't start on a cdrom block boundary,
1037 we must adjust the start of the transfer so that it does,
1038 and remember to skip the first few sectors.
1039 If the CURRENT_NR_SECTORS field is larger than the size
1040 of the buffer, it will mean that we're to skip a number
1041 of sectors equal to the amount by which CURRENT_NR_SECTORS
1042 is larger than the buffer size. */
1043 nskip = rq->sector & (sectors_per_frame - 1);
1045 /* Sanity check... */
1046 if (rq->current_nr_sectors != bio_cur_sectors(rq->bio) &&
1047 (rq->sector & (sectors_per_frame - 1))) {
1048 printk(KERN_ERR "%s: cdrom_start_read_continuation: buffer botch (%u)\n",
1049 drive->name, rq->current_nr_sectors);
1050 cdrom_end_request(drive, 0);
1053 rq->current_nr_sectors += nskip;
1056 /* Set up the command */
1057 rq->timeout = ATAPI_WAIT_PC;
1059 /* Send the command to the drive and return. */
1060 return cdrom_transfer_packet_command(drive, rq, &cdrom_read_intr);
1064 #define IDECD_SEEK_THRESHOLD (1000) /* 1000 blocks */
1065 #define IDECD_SEEK_TIMER (5 * WAIT_MIN_SLEEP) /* 100 ms */
1066 #define IDECD_SEEK_TIMEOUT (2 * WAIT_CMD) /* 20 sec */
1068 static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
1070 struct cdrom_info *info = drive->driver_data;
1072 static int retry = 10;
1074 if (cdrom_decode_status(drive, 0, &stat))
1077 info->cd_flags |= IDE_CD_FLAG_SEEKING;
1079 if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
1082 * this condition is far too common, to bother
1085 /* printk("%s: disabled DSC seek overlap\n", drive->name);*/
1086 drive->dsc_overlap = 0;
1092 static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
1094 struct request *rq = HWGROUP(drive)->rq;
1095 sector_t frame = rq->sector;
1097 sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
1099 memset(rq->cmd, 0, sizeof(rq->cmd));
1100 rq->cmd[0] = GPCMD_SEEK;
1101 put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
1103 rq->timeout = ATAPI_WAIT_PC;
1104 return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
1107 static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
1109 struct cdrom_info *info = drive->driver_data;
1112 info->start_seek = jiffies;
1113 return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
1116 /* Fix up a possibly partially-processed request so that we can
1117 start it over entirely, or even put it back on the request queue. */
1118 static void restore_request (struct request *rq)
1120 if (rq->buffer != bio_data(rq->bio)) {
1121 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
1123 rq->buffer = bio_data(rq->bio);
1124 rq->nr_sectors += n;
1127 rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
1128 rq->hard_nr_sectors = rq->nr_sectors;
1129 rq->hard_sector = rq->sector;
1130 rq->q->prep_rq_fn(rq->q, rq);
1134 * Start a read request from the CD-ROM.
1136 static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block)
1138 struct cdrom_info *info = drive->driver_data;
1139 struct request *rq = HWGROUP(drive)->rq;
1140 unsigned short sectors_per_frame;
1142 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1144 /* We may be retrying this request after an error. Fix up
1145 any weirdness which might be present in the request packet. */
1146 restore_request(rq);
1148 /* Satisfy whatever we can of this request from our cached sector. */
1149 if (cdrom_read_from_buffer(drive))
1152 /* Clear the local sector buffer. */
1153 info->nsectors_buffered = 0;
1155 /* use dma, if possible. */
1156 info->dma = drive->using_dma;
1157 if ((rq->sector & (sectors_per_frame - 1)) ||
1158 (rq->nr_sectors & (sectors_per_frame - 1)))
1161 /* Start sending the read request to the drive. */
1162 return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
1165 /****************************************************************************
1166 * Execute all other packet commands.
1169 /* Interrupt routine for packet command completion. */
1170 static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
1172 struct request *rq = HWGROUP(drive)->rq;
1173 xfer_func_t *xferfunc = NULL;
1174 int stat, ireason, len, thislen, write;
1175 u8 lowcyl = 0, highcyl = 0;
1177 /* Check for errors. */
1178 if (cdrom_decode_status(drive, 0, &stat))
1181 /* Read the interrupt reason and the transfer length. */
1182 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1183 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1184 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1186 len = lowcyl + (256 * highcyl);
1188 /* If DRQ is clear, the command has completed.
1189 Complain if we still have data left to transfer. */
1190 if ((stat & DRQ_STAT) == 0) {
1191 /* Some of the trailing request sense fields are optional, and
1192 some drives don't send them. Sigh. */
1193 if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
1195 rq->data_len <= 5) {
1196 while (rq->data_len > 0) {
1197 *(unsigned char *)rq->data++ = 0;
1202 if (rq->data_len == 0)
1203 cdrom_end_request(drive, 1);
1205 rq->cmd_flags |= REQ_FAILED;
1206 cdrom_end_request(drive, 0);
1211 /* Figure out how much data to transfer. */
1212 thislen = rq->data_len;
1218 xferfunc = HWIF(drive)->atapi_output_bytes;
1219 } else if (ireason == 2) {
1221 xferfunc = HWIF(drive)->atapi_input_bytes;
1226 printk(KERN_ERR "%s: confused, missing data\n",
1228 blk_dump_rq_flags(rq, write ? "cdrom_pc_intr, write"
1229 : "cdrom_pc_intr, read");
1232 /* Transfer the data. */
1233 xferfunc(drive, rq->data, thislen);
1235 /* Keep count of how much data we've moved. */
1237 rq->data += thislen;
1238 rq->data_len -= thislen;
1240 if (write && blk_sense_request(rq))
1241 rq->sense_len += thislen;
1243 printk (KERN_ERR "%s: cdrom_pc_intr: The drive "
1244 "appears confused (ireason = 0x%02x). "
1245 "Trying to recover by ending request.\n",
1246 drive->name, ireason);
1247 rq->cmd_flags |= REQ_FAILED;
1248 cdrom_end_request(drive, 0);
1253 * If we haven't moved enough data to satisfy the drive,
1257 ide_cd_pad_transfer(drive, xferfunc, len);
1259 /* Now we wait for another interrupt. */
1260 ide_set_handler(drive, &cdrom_pc_intr, ATAPI_WAIT_PC, cdrom_timer_expiry);
1264 static ide_startstop_t cdrom_do_pc_continuation (ide_drive_t *drive)
1266 struct request *rq = HWGROUP(drive)->rq;
1269 rq->timeout = ATAPI_WAIT_PC;
1271 /* Send the command to the drive and return. */
1272 return cdrom_transfer_packet_command(drive, rq, &cdrom_pc_intr);
1276 static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
1279 struct request *rq = HWGROUP(drive)->rq;
1280 struct cdrom_info *info = drive->driver_data;
1283 rq->cmd_flags &= ~REQ_FAILED;
1286 /* Start sending the command to the drive. */
1287 return cdrom_start_packet_command(drive, len, cdrom_do_pc_continuation);
1291 static int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
1293 struct request_sense sense;
1295 unsigned int flags = rq->cmd_flags;
1297 if (rq->sense == NULL)
1300 /* Start of retry loop. */
1303 unsigned long time = jiffies;
1304 rq->cmd_flags = flags;
1306 error = ide_do_drive_cmd(drive, rq, ide_wait);
1307 time = jiffies - time;
1309 /* FIXME: we should probably abort/retry or something
1310 * in case of failure */
1311 if (rq->cmd_flags & REQ_FAILED) {
1312 /* The request failed. Retry if it was due to a unit
1314 (usually means media was changed). */
1315 struct request_sense *reqbuf = rq->sense;
1317 if (reqbuf->sense_key == UNIT_ATTENTION)
1318 cdrom_saw_media_change(drive);
1319 else if (reqbuf->sense_key == NOT_READY &&
1320 reqbuf->asc == 4 && reqbuf->ascq != 4) {
1321 /* The drive is in the process of loading
1322 a disk. Retry, but wait a little to give
1323 the drive time to complete the load. */
1326 /* Otherwise, don't retry. */
1332 /* End of retry loop. */
1333 } while ((rq->cmd_flags & REQ_FAILED) && retries >= 0);
1335 /* Return an error if the command failed. */
1336 return (rq->cmd_flags & REQ_FAILED) ? -EIO : 0;
1342 static int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
1344 /* Two notes about IDE interrupt reason here - 0 means that
1345 * the drive wants to receive data from us, 2 means that
1346 * the drive is expecting to transfer data to us.
1350 else if (ireason == 2) {
1351 ide_hwif_t *hwif = drive->hwif;
1353 /* Whoops... The drive wants to send data. */
1354 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
1355 drive->name, __FUNCTION__);
1357 ide_cd_pad_transfer(drive, hwif->atapi_input_bytes, len);
1359 /* Drive wants a command packet, or invalid ireason... */
1360 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
1361 drive->name, __FUNCTION__, ireason);
1364 cdrom_end_request(drive, 0);
1369 * Called from blk_end_request_callback() after the data of the request
1370 * is completed and before the request is completed.
1371 * By returning value '1', blk_end_request_callback() returns immediately
1372 * without completing the request.
1374 static int cdrom_newpc_intr_dummy_cb(struct request *rq)
1380 * best way to deal with dma that is not sector aligned right now... note
1381 * that in this path we are not using ->data or ->buffer at all. this irs
1382 * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the
1385 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1387 struct cdrom_info *info = drive->driver_data;
1388 struct request *rq = HWGROUP(drive)->rq;
1389 int dma_error, dma, stat, ireason, len, thislen;
1391 xfer_func_t *xferfunc;
1392 unsigned long flags;
1394 /* Check for errors. */
1399 dma_error = HWIF(drive)->ide_dma_end(drive);
1401 printk(KERN_ERR "%s: DMA %s error\n", drive->name,
1402 rq_data_dir(rq) ? "write" : "read");
1407 if (cdrom_decode_status(drive, 0, &stat))
1411 * using dma, transfer is complete now
1415 return ide_error(drive, "dma error", stat);
1417 spin_lock_irqsave(&ide_lock, flags);
1418 if (__blk_end_request(rq, 0, rq->data_len))
1420 HWGROUP(drive)->rq = NULL;
1421 spin_unlock_irqrestore(&ide_lock, flags);
1427 * ok we fall to pio :/
1429 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1430 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1431 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1433 len = lowcyl + (256 * highcyl);
1434 thislen = rq->data_len;
1439 * If DRQ is clear, the command has completed.
1441 if ((stat & DRQ_STAT) == 0) {
1442 spin_lock_irqsave(&ide_lock, flags);
1443 if (__blk_end_request(rq, 0, rq->data_len))
1445 HWGROUP(drive)->rq = NULL;
1446 spin_unlock_irqrestore(&ide_lock, flags);
1452 * check which way to transfer data
1454 if (rq_data_dir(rq) == WRITE) {
1458 if (cdrom_write_check_ireason(drive, len, ireason))
1461 xferfunc = HWIF(drive)->atapi_output_bytes;
1466 if (cdrom_read_check_ireason(drive, len, ireason))
1469 xferfunc = HWIF(drive)->atapi_input_bytes;
1475 while (thislen > 0) {
1476 int blen = blen = rq->data_len;
1477 char *ptr = rq->data;
1483 ptr = bio_data(rq->bio);
1484 blen = bio_iovec(rq->bio)->bv_len;
1488 printk(KERN_ERR "%s: confused, missing data\n", drive->name);
1495 xferfunc(drive, ptr, blen);
1499 rq->data_len -= blen;
1503 * The request can't be completed until DRQ is cleared.
1504 * So complete the data, but don't complete the request
1505 * using the dummy function for the callback feature
1506 * of blk_end_request_callback().
1508 blk_end_request_callback(rq, 0, blen,
1509 cdrom_newpc_intr_dummy_cb);
1518 ide_cd_pad_transfer(drive, xferfunc, len);
1520 BUG_ON(HWGROUP(drive)->handler != NULL);
1522 ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, NULL);
1526 static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
1528 int stat, ireason, len, sectors_to_transfer, uptodate;
1529 struct cdrom_info *info = drive->driver_data;
1530 int dma_error = 0, dma = info->dma;
1531 u8 lowcyl = 0, highcyl = 0;
1533 struct request *rq = HWGROUP(drive)->rq;
1535 /* Check for errors. */
1538 dma_error = HWIF(drive)->ide_dma_end(drive);
1540 printk(KERN_ERR "%s: DMA write error\n", drive->name);
1545 if (cdrom_decode_status(drive, 0, &stat))
1549 * using dma, transfer is complete now
1553 return ide_error(drive, "dma error", stat);
1555 ide_end_request(drive, 1, rq->nr_sectors);
1559 /* Read the interrupt reason and the transfer length. */
1560 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1561 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1562 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1564 len = lowcyl + (256 * highcyl);
1566 /* If DRQ is clear, the command has completed. */
1567 if ((stat & DRQ_STAT) == 0) {
1568 /* If we're not done writing, complain.
1569 * Otherwise, complete the command normally.
1572 if (rq->current_nr_sectors > 0) {
1573 printk(KERN_ERR "%s: %s: data underrun (%d blocks)\n",
1574 drive->name, __FUNCTION__,
1575 rq->current_nr_sectors);
1578 cdrom_end_request(drive, uptodate);
1582 /* Check that the drive is expecting to do the same thing we are. */
1583 if (cdrom_write_check_ireason(drive, len, ireason))
1586 sectors_to_transfer = len / SECTOR_SIZE;
1589 * now loop and write out the data
1591 while (sectors_to_transfer > 0) {
1594 if (!rq->current_nr_sectors) {
1595 printk(KERN_ERR "%s: %s: confused, missing data\n",
1596 drive->name, __FUNCTION__);
1601 * Figure out how many sectors we can transfer
1603 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors);
1605 while (this_transfer > 0) {
1606 HWIF(drive)->atapi_output_bytes(drive, rq->buffer, SECTOR_SIZE);
1607 rq->buffer += SECTOR_SIZE;
1609 --rq->current_nr_sectors;
1612 --sectors_to_transfer;
1616 * current buffer complete, move on
1618 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1619 cdrom_end_request(drive, 1);
1622 /* re-arm handler */
1623 ide_set_handler(drive, &cdrom_write_intr, ATAPI_WAIT_PC, NULL);
1627 static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
1629 struct request *rq = HWGROUP(drive)->rq;
1631 #if 0 /* the immediate bit */
1632 rq->cmd[1] = 1 << 3;
1634 rq->timeout = ATAPI_WAIT_PC;
1636 return cdrom_transfer_packet_command(drive, rq, cdrom_write_intr);
1639 static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
1641 struct cdrom_info *info = drive->driver_data;
1642 struct gendisk *g = info->disk;
1643 unsigned short sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1646 * writes *must* be hardware frame aligned
1648 if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1649 (rq->sector & (sectors_per_frame - 1))) {
1650 cdrom_end_request(drive, 0);
1655 * disk has become write protected
1658 cdrom_end_request(drive, 0);
1662 info->nsectors_buffered = 0;
1664 /* use dma, if possible. we don't need to check more, since we
1665 * know that the transfer is always (at least!) frame aligned */
1666 info->dma = drive->using_dma ? 1 : 0;
1668 info->devinfo.media_written = 1;
1670 /* Start sending the write request to the drive. */
1671 return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
1674 static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1676 struct request *rq = HWGROUP(drive)->rq;
1679 rq->timeout = ATAPI_WAIT_PC;
1681 return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1684 static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1686 struct cdrom_info *info = drive->driver_data;
1688 rq->cmd_flags |= REQ_QUIET;
1696 int mask = drive->queue->dma_alignment;
1697 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
1699 info->dma = drive->using_dma;
1702 * check if dma is safe
1704 * NOTE! The "len" and "addr" checks should possibly have
1707 if ((rq->data_len & 15) || (addr & mask))
1711 /* Start sending the command to the drive. */
1712 return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1715 /****************************************************************************
1716 * cdrom driver request routine.
1718 static ide_startstop_t
1719 ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1721 ide_startstop_t action;
1722 struct cdrom_info *info = drive->driver_data;
1724 if (blk_fs_request(rq)) {
1725 if (info->cd_flags & IDE_CD_FLAG_SEEKING) {
1726 unsigned long elapsed = jiffies - info->start_seek;
1727 int stat = HWIF(drive)->INB(IDE_STATUS_REG);
1729 if ((stat & SEEK_STAT) != SEEK_STAT) {
1730 if (elapsed < IDECD_SEEK_TIMEOUT) {
1731 ide_stall_queue(drive, IDECD_SEEK_TIMER);
1734 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
1736 info->cd_flags &= ~IDE_CD_FLAG_SEEKING;
1738 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
1739 action = cdrom_start_seek(drive, block);
1741 if (rq_data_dir(rq) == READ)
1742 action = cdrom_start_read(drive, block);
1744 action = cdrom_start_write(drive, rq);
1746 info->last_block = block;
1748 } else if (rq->cmd_type == REQ_TYPE_SENSE ||
1749 rq->cmd_type == REQ_TYPE_ATA_PC) {
1750 return cdrom_do_packet_command(drive);
1751 } else if (blk_pc_request(rq)) {
1752 return cdrom_do_block_pc(drive, rq);
1753 } else if (blk_special_request(rq)) {
1755 * right now this can only be a reset...
1757 cdrom_end_request(drive, 1);
1761 blk_dump_rq_flags(rq, "ide-cd bad flags");
1762 cdrom_end_request(drive, 0);
1768 /****************************************************************************
1771 * Routines which queue packet commands take as a final argument a pointer
1772 * to a request_sense struct. If execution of the command results
1773 * in an error with a CHECK CONDITION status, this structure will be filled
1774 * with the results of the subsequent request sense command. The pointer
1775 * can also be NULL, in which case no sense information is returned.
1781 return (x%10) | ((x/10) << 4);
1788 return (x >> 4) * 10 + (x & 0x0f);
1792 void msf_from_bcd (struct atapi_msf *msf)
1794 msf->minute = bcd2bin (msf->minute);
1795 msf->second = bcd2bin (msf->second);
1796 msf->frame = bcd2bin (msf->frame);
1800 void lba_to_msf (int lba, byte *m, byte *s, byte *f)
1802 lba += CD_MSF_OFFSET;
1803 lba &= 0xffffff; /* negative lbas use only 24 bits */
1804 *m = lba / (CD_SECS * CD_FRAMES);
1805 lba %= (CD_SECS * CD_FRAMES);
1806 *s = lba / CD_FRAMES;
1807 *f = lba % CD_FRAMES;
1812 int msf_to_lba (byte m, byte s, byte f)
1814 return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
1817 static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
1820 struct cdrom_info *info = drive->driver_data;
1821 struct cdrom_device_info *cdi = &info->devinfo;
1823 cdrom_prepare_request(drive, &req);
1826 req.cmd[0] = GPCMD_TEST_UNIT_READY;
1827 req.cmd_flags |= REQ_QUIET;
1830 * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
1831 * switch CDs instead of supporting the LOAD_UNLOAD opcode.
1833 req.cmd[7] = cdi->sanyo_slot % 3;
1835 return cdrom_queue_packet_command(drive, &req);
1839 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
1841 cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
1843 struct cdrom_info *cd = drive->driver_data;
1844 struct request_sense my_sense;
1851 /* If the drive cannot lock the door, just pretend. */
1852 if (cd->cd_flags & IDE_CD_FLAG_NO_DOORLOCK) {
1855 cdrom_prepare_request(drive, &req);
1857 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
1858 req.cmd[4] = lockflag ? 1 : 0;
1859 stat = cdrom_queue_packet_command(drive, &req);
1862 /* If we got an illegal field error, the drive
1863 probably cannot lock the door. */
1865 sense->sense_key == ILLEGAL_REQUEST &&
1866 (sense->asc == 0x24 || sense->asc == 0x20)) {
1867 printk (KERN_ERR "%s: door locking not supported\n",
1869 cd->cd_flags |= IDE_CD_FLAG_NO_DOORLOCK;
1873 /* no medium, that's alright. */
1874 if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
1879 cd->cd_flags |= IDE_CD_FLAG_DOOR_LOCKED;
1881 cd->cd_flags &= ~IDE_CD_FLAG_DOOR_LOCKED;
1888 /* Eject the disk if EJECTFLAG is 0.
1889 If EJECTFLAG is 1, try to reload the disk. */
1890 static int cdrom_eject(ide_drive_t *drive, int ejectflag,
1891 struct request_sense *sense)
1893 struct cdrom_info *cd = drive->driver_data;
1894 struct cdrom_device_info *cdi = &cd->devinfo;
1898 if ((cd->cd_flags & IDE_CD_FLAG_NO_EJECT) && !ejectflag)
1899 return -EDRIVE_CANT_DO_THIS;
1901 /* reload fails on some drives, if the tray is locked */
1902 if ((cd->cd_flags & IDE_CD_FLAG_DOOR_LOCKED) && ejectflag)
1905 cdrom_prepare_request(drive, &req);
1907 /* only tell drive to close tray if open, if it can do that */
1908 if (ejectflag && (cdi->mask & CDC_CLOSE_TRAY))
1912 req.cmd[0] = GPCMD_START_STOP_UNIT;
1913 req.cmd[4] = loej | (ejectflag != 0);
1914 return cdrom_queue_packet_command(drive, &req);
1917 static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
1918 unsigned long *sectors_per_frame,
1919 struct request_sense *sense)
1929 cdrom_prepare_request(drive, &req);
1932 req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
1933 req.data = (char *)&capbuf;
1934 req.data_len = sizeof(capbuf);
1935 req.cmd_flags |= REQ_QUIET;
1937 stat = cdrom_queue_packet_command(drive, &req);
1939 *capacity = 1 + be32_to_cpu(capbuf.lba);
1940 *sectors_per_frame =
1941 be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
1947 static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
1948 int format, char *buf, int buflen,
1949 struct request_sense *sense)
1953 cdrom_prepare_request(drive, &req);
1957 req.data_len = buflen;
1958 req.cmd_flags |= REQ_QUIET;
1959 req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
1960 req.cmd[6] = trackno;
1961 req.cmd[7] = (buflen >> 8);
1962 req.cmd[8] = (buflen & 0xff);
1963 req.cmd[9] = (format << 6);
1968 return cdrom_queue_packet_command(drive, &req);
1972 /* Try to read the entire TOC for the disk into our internal buffer. */
1973 static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
1975 int stat, ntracks, i;
1976 struct cdrom_info *info = drive->driver_data;
1977 struct cdrom_device_info *cdi = &info->devinfo;
1978 struct atapi_toc *toc = info->toc;
1980 struct atapi_toc_header hdr;
1981 struct atapi_toc_entry ent;
1984 unsigned long sectors_per_frame = SECTORS_PER_FRAME;
1987 /* Try to allocate space. */
1988 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
1990 printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
1996 /* Check to see if the existing data is still valid.
1997 If it is, just return. */
1998 (void) cdrom_check_status(drive, sense);
2000 if (info->cd_flags & IDE_CD_FLAG_TOC_VALID)
2003 /* Try to get the total cdrom capacity and sector size. */
2004 stat = cdrom_read_capacity(drive, &toc->capacity, §ors_per_frame,
2007 toc->capacity = 0x1fffff;
2009 set_capacity(info->disk, toc->capacity * sectors_per_frame);
2010 /* Save a private copy of te TOC capacity for error handling */
2011 drive->probed_capacity = toc->capacity * sectors_per_frame;
2013 blk_queue_hardsect_size(drive->queue,
2014 sectors_per_frame << SECTOR_BITS);
2016 /* First read just the header, so we know how long the TOC is. */
2017 stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
2018 sizeof(struct atapi_toc_header), sense);
2022 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
2023 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2024 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2027 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2030 if (ntracks > MAX_TRACKS)
2031 ntracks = MAX_TRACKS;
2033 /* Now read the whole schmeer. */
2034 stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
2036 sizeof(struct atapi_toc_header) +
2038 sizeof(struct atapi_toc_entry), sense);
2040 if (stat && toc->hdr.first_track > 1) {
2041 /* Cds with CDI tracks only don't have any TOC entries,
2042 despite of this the returned values are
2043 first_track == last_track = number of CDI tracks + 1,
2044 so that this case is indistinguishable from the same
2045 layout plus an additional audio track.
2046 If we get an error for the regular case, we assume
2047 a CDI without additional audio tracks. In this case
2048 the readable TOC is empty (CDI tracks are not included)
2049 and only holds the Leadout entry. Heiko Eißfeldt */
2051 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
2053 sizeof(struct atapi_toc_header) +
2055 sizeof(struct atapi_toc_entry),
2060 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
2061 toc->hdr.first_track = bin2bcd(CDROM_LEADOUT);
2062 toc->hdr.last_track = bin2bcd(CDROM_LEADOUT);
2064 toc->hdr.first_track = CDROM_LEADOUT;
2065 toc->hdr.last_track = CDROM_LEADOUT;
2072 toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
2074 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
2075 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2076 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2079 for (i = 0; i <= ntracks; i++) {
2080 if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
2081 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD)
2082 toc->ent[i].track = bcd2bin(toc->ent[i].track);
2083 msf_from_bcd(&toc->ent[i].addr.msf);
2085 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
2086 toc->ent[i].addr.msf.second,
2087 toc->ent[i].addr.msf.frame);
2090 /* Read the multisession information. */
2091 if (toc->hdr.first_track != CDROM_LEADOUT) {
2092 /* Read the multisession information. */
2093 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
2094 sizeof(ms_tmp), sense);
2098 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
2100 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
2101 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
2104 if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
2105 /* Re-read multisession information using MSF format */
2106 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
2107 sizeof(ms_tmp), sense);
2111 msf_from_bcd (&ms_tmp.ent.addr.msf);
2112 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
2113 ms_tmp.ent.addr.msf.second,
2114 ms_tmp.ent.addr.msf.frame);
2117 toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
2119 /* Now try to get the total cdrom capacity. */
2120 stat = cdrom_get_last_written(cdi, &last_written);
2121 if (!stat && (last_written > toc->capacity)) {
2122 toc->capacity = last_written;
2123 set_capacity(info->disk, toc->capacity * sectors_per_frame);
2124 drive->probed_capacity = toc->capacity * sectors_per_frame;
2127 /* Remember that we've read this stuff. */
2128 info->cd_flags |= IDE_CD_FLAG_TOC_VALID;
2134 static int cdrom_read_subchannel(ide_drive_t *drive, int format, char *buf,
2135 int buflen, struct request_sense *sense)
2139 cdrom_prepare_request(drive, &req);
2143 req.data_len = buflen;
2144 req.cmd[0] = GPCMD_READ_SUBCHANNEL;
2145 req.cmd[1] = 2; /* MSF addressing */
2146 req.cmd[2] = 0x40; /* request subQ data */
2147 req.cmd[3] = format;
2148 req.cmd[7] = (buflen >> 8);
2149 req.cmd[8] = (buflen & 0xff);
2150 return cdrom_queue_packet_command(drive, &req);
2153 /* ATAPI cdrom drives are free to select the speed you request or any slower
2154 rate :-( Requesting too fast a speed will _not_ produce an error. */
2155 static int cdrom_select_speed(ide_drive_t *drive, int speed,
2156 struct request_sense *sense)
2158 struct cdrom_info *cd = drive->driver_data;
2159 struct cdrom_device_info *cdi = &cd->devinfo;
2161 cdrom_prepare_request(drive, &req);
2165 speed = 0xffff; /* set to max */
2167 speed *= 177; /* Nx to kbytes/s */
2169 req.cmd[0] = GPCMD_SET_SPEED;
2170 /* Read Drive speed in kbytes/second MSB */
2171 req.cmd[2] = (speed >> 8) & 0xff;
2172 /* Read Drive speed in kbytes/second LSB */
2173 req.cmd[3] = speed & 0xff;
2174 if ((cdi->mask & (CDC_CD_R | CDC_CD_RW | CDC_DVD_R)) !=
2175 (CDC_CD_R | CDC_CD_RW | CDC_DVD_R)) {
2176 /* Write Drive speed in kbytes/second MSB */
2177 req.cmd[4] = (speed >> 8) & 0xff;
2178 /* Write Drive speed in kbytes/second LSB */
2179 req.cmd[5] = speed & 0xff;
2182 return cdrom_queue_packet_command(drive, &req);
2185 static int cdrom_play_audio(ide_drive_t *drive, int lba_start, int lba_end)
2187 struct request_sense sense;
2190 cdrom_prepare_request(drive, &req);
2193 req.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2194 lba_to_msf(lba_start, &req.cmd[3], &req.cmd[4], &req.cmd[5]);
2195 lba_to_msf(lba_end-1, &req.cmd[6], &req.cmd[7], &req.cmd[8]);
2197 return cdrom_queue_packet_command(drive, &req);
2200 static int cdrom_get_toc_entry(ide_drive_t *drive, int track,
2201 struct atapi_toc_entry **ent)
2203 struct cdrom_info *info = drive->driver_data;
2204 struct atapi_toc *toc = info->toc;
2208 * don't serve cached data, if the toc isn't valid
2210 if ((info->cd_flags & IDE_CD_FLAG_TOC_VALID) == 0)
2213 /* Check validity of requested track number. */
2214 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2215 if (toc->hdr.first_track == CDROM_LEADOUT) ntracks = 0;
2216 if (track == CDROM_LEADOUT)
2217 *ent = &toc->ent[ntracks];
2218 else if (track < toc->hdr.first_track ||
2219 track > toc->hdr.last_track)
2222 *ent = &toc->ent[track - toc->hdr.first_track];
2227 /* the generic packet interface to cdrom.c */
2228 static int ide_cdrom_packet(struct cdrom_device_info *cdi,
2229 struct packet_command *cgc)
2232 ide_drive_t *drive = cdi->handle;
2234 if (cgc->timeout <= 0)
2235 cgc->timeout = ATAPI_WAIT_PC;
2237 /* here we queue the commands from the uniform CD-ROM
2238 layer. the packet must be complete, as we do not
2240 cdrom_prepare_request(drive, &req);
2241 memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
2243 memset(cgc->sense, 0, sizeof(struct request_sense));
2244 req.data = cgc->buffer;
2245 req.data_len = cgc->buflen;
2246 req.timeout = cgc->timeout;
2249 req.cmd_flags |= REQ_QUIET;
2251 req.sense = cgc->sense;
2252 cgc->stat = cdrom_queue_packet_command(drive, &req);
2254 cgc->buflen -= req.data_len;
2259 int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
2260 unsigned int cmd, void *arg)
2263 ide_drive_t *drive = cdi->handle;
2264 struct cdrom_info *info = drive->driver_data;
2269 * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
2270 * atapi doesn't support it
2272 case CDROMPLAYTRKIND: {
2273 unsigned long lba_start, lba_end;
2274 struct cdrom_ti *ti = arg;
2275 struct atapi_toc_entry *first_toc, *last_toc;
2277 stat = cdrom_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
2281 stat = cdrom_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
2285 if (ti->cdti_trk1 != CDROM_LEADOUT)
2287 lba_start = first_toc->addr.lba;
2288 lba_end = last_toc->addr.lba;
2290 if (lba_end <= lba_start)
2293 return cdrom_play_audio(drive, lba_start, lba_end);
2296 case CDROMREADTOCHDR: {
2297 struct cdrom_tochdr *tochdr = arg;
2298 struct atapi_toc *toc;
2300 /* Make sure our saved TOC is valid. */
2301 stat = cdrom_read_toc(drive, NULL);
2306 tochdr->cdth_trk0 = toc->hdr.first_track;
2307 tochdr->cdth_trk1 = toc->hdr.last_track;
2312 case CDROMREADTOCENTRY: {
2313 struct cdrom_tocentry *tocentry = arg;
2314 struct atapi_toc_entry *toce;
2316 stat = cdrom_get_toc_entry(drive, tocentry->cdte_track, &toce);
2320 tocentry->cdte_ctrl = toce->control;
2321 tocentry->cdte_adr = toce->adr;
2322 if (tocentry->cdte_format == CDROM_MSF) {
2323 lba_to_msf (toce->addr.lba,
2324 &tocentry->cdte_addr.msf.minute,
2325 &tocentry->cdte_addr.msf.second,
2326 &tocentry->cdte_addr.msf.frame);
2328 tocentry->cdte_addr.lba = toce->addr.lba;
2339 int ide_cdrom_reset (struct cdrom_device_info *cdi)
2341 ide_drive_t *drive = cdi->handle;
2342 struct cdrom_info *cd = drive->driver_data;
2343 struct request_sense sense;
2347 cdrom_prepare_request(drive, &req);
2348 req.cmd_type = REQ_TYPE_SPECIAL;
2349 req.cmd_flags = REQ_QUIET;
2350 ret = ide_do_drive_cmd(drive, &req, ide_wait);
2353 * A reset will unlock the door. If it was previously locked,
2356 if (cd->cd_flags & IDE_CD_FLAG_DOOR_LOCKED)
2357 (void) cdrom_lockdoor(drive, 1, &sense);
2364 int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
2366 ide_drive_t *drive = cdi->handle;
2367 struct request_sense sense;
2370 int stat = cdrom_lockdoor(drive, 0, &sense);
2375 return cdrom_eject(drive, !position, &sense);
2379 int ide_cdrom_lock_door (struct cdrom_device_info *cdi, int lock)
2381 ide_drive_t *drive = cdi->handle;
2382 return cdrom_lockdoor(drive, lock, NULL);
2385 static int ide_cdrom_get_capabilities(ide_drive_t *drive, u8 *buf)
2387 struct cdrom_info *info = drive->driver_data;
2388 struct cdrom_device_info *cdi = &info->devinfo;
2389 struct packet_command cgc;
2390 int stat, attempts = 3, size = ATAPI_CAPABILITIES_PAGE_SIZE;
2393 * ACER50 (and others?) require the full spec length mode sense
2394 * page capabilities size, but older drives break.
2396 if (!(!strcmp(drive->id->model, "ATAPI CD ROM DRIVE 50X MAX") ||
2397 !strcmp(drive->id->model, "WPI CDS-32X")))
2398 size -= ATAPI_CAPABILITIES_PAGE_PAD_SIZE;
2400 init_cdrom_command(&cgc, buf, size, CGC_DATA_UNKNOWN);
2401 do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2402 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
2405 } while (--attempts);
2409 static void ide_cdrom_update_speed(ide_drive_t *drive, u8 *buf)
2411 struct cdrom_info *cd = drive->driver_data;
2412 u16 curspeed, maxspeed;
2414 curspeed = *(u16 *)&buf[8 + 14];
2415 maxspeed = *(u16 *)&buf[8 + 8];
2417 /* The ACER/AOpen 24X cdrom has the speed fields byte-swapped */
2418 if (!drive->id->model[0] &&
2419 !strncmp(drive->id->fw_rev, "241N", 4)) {
2420 curspeed = le16_to_cpu(curspeed);
2421 maxspeed = le16_to_cpu(maxspeed);
2423 curspeed = be16_to_cpu(curspeed);
2424 maxspeed = be16_to_cpu(maxspeed);
2427 cd->current_speed = (curspeed + (176/2)) / 176;
2428 cd->max_speed = (maxspeed + (176/2)) / 176;
2432 int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
2434 ide_drive_t *drive = cdi->handle;
2435 struct cdrom_info *cd = drive->driver_data;
2436 struct request_sense sense;
2437 u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
2440 if ((stat = cdrom_select_speed(drive, speed, &sense)) < 0)
2443 if (!ide_cdrom_get_capabilities(drive, buf)) {
2444 ide_cdrom_update_speed(drive, buf);
2445 cdi->speed = cd->current_speed;
2451 * add logic to try GET_EVENT command first to check for media and tray
2452 * status. this should be supported by newer cd-r/w and all DVD etc
2456 int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
2458 ide_drive_t *drive = cdi->handle;
2459 struct media_event_desc med;
2460 struct request_sense sense;
2463 if (slot_nr != CDSL_CURRENT)
2466 stat = cdrom_check_status(drive, &sense);
2467 if (!stat || sense.sense_key == UNIT_ATTENTION)
2470 if (!cdrom_get_media_event(cdi, &med)) {
2471 if (med.media_present)
2473 else if (med.door_open)
2474 return CDS_TRAY_OPEN;
2479 if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
2483 * If not using Mt Fuji extended media tray reports,
2484 * just return TRAY_OPEN since ATAPI doesn't provide
2485 * any other way to detect this...
2487 if (sense.sense_key == NOT_READY) {
2488 if (sense.asc == 0x3a && sense.ascq == 1)
2491 return CDS_TRAY_OPEN;
2493 return CDS_DRIVE_NOT_READY;
2497 int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
2498 struct cdrom_multisession *ms_info)
2500 struct atapi_toc *toc;
2501 ide_drive_t *drive = cdi->handle;
2502 struct cdrom_info *info = drive->driver_data;
2503 struct request_sense sense;
2506 if ((info->cd_flags & IDE_CD_FLAG_TOC_VALID) == 0 || info->toc == NULL)
2507 if ((ret = cdrom_read_toc(drive, &sense)))
2511 ms_info->addr.lba = toc->last_session_lba;
2512 ms_info->xa_flag = toc->xa_flag;
2518 int ide_cdrom_get_mcn (struct cdrom_device_info *cdi,
2519 struct cdrom_mcn *mcn_info)
2523 ide_drive_t *drive = cdi->handle;
2526 if ((stat = cdrom_read_subchannel(drive, 2, mcnbuf, sizeof (mcnbuf), NULL)))
2529 memcpy (mcn_info->medium_catalog_number, mcnbuf+9,
2530 sizeof (mcn_info->medium_catalog_number)-1);
2531 mcn_info->medium_catalog_number[sizeof (mcn_info->medium_catalog_number)-1]
2539 /****************************************************************************
2540 * Other driver requests (open, close, check media change).
2544 int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
2547 ide_drive_t *drive = cdi->handle;
2548 struct cdrom_info *cd = drive->driver_data;
2551 if (slot_nr == CDSL_CURRENT) {
2552 (void) cdrom_check_status(drive, NULL);
2553 retval = (cd->cd_flags & IDE_CD_FLAG_MEDIA_CHANGED) ? 1 : 0;
2554 cd->cd_flags &= ~IDE_CD_FLAG_MEDIA_CHANGED;
2563 int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
2569 * Close down the device. Invalidate all cached blocks.
2573 void ide_cdrom_release_real (struct cdrom_device_info *cdi)
2575 ide_drive_t *drive = cdi->handle;
2576 struct cdrom_info *cd = drive->driver_data;
2578 if (!cdi->use_count)
2579 cd->cd_flags &= ~IDE_CD_FLAG_TOC_VALID;
2582 #define IDE_CD_CAPABILITIES \
2583 (CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | CDC_SELECT_SPEED | \
2584 CDC_SELECT_DISC | CDC_MULTI_SESSION | CDC_MCN | CDC_MEDIA_CHANGED | \
2585 CDC_PLAY_AUDIO | CDC_RESET | CDC_DRIVE_STATUS | CDC_CD_R | \
2586 CDC_CD_RW | CDC_DVD | CDC_DVD_R | CDC_DVD_RAM | CDC_GENERIC_PACKET | \
2587 CDC_MO_DRIVE | CDC_MRW | CDC_MRW_W | CDC_RAM)
2589 static struct cdrom_device_ops ide_cdrom_dops = {
2590 .open = ide_cdrom_open_real,
2591 .release = ide_cdrom_release_real,
2592 .drive_status = ide_cdrom_drive_status,
2593 .media_changed = ide_cdrom_check_media_change_real,
2594 .tray_move = ide_cdrom_tray_move,
2595 .lock_door = ide_cdrom_lock_door,
2596 .select_speed = ide_cdrom_select_speed,
2597 .get_last_session = ide_cdrom_get_last_session,
2598 .get_mcn = ide_cdrom_get_mcn,
2599 .reset = ide_cdrom_reset,
2600 .audio_ioctl = ide_cdrom_audio_ioctl,
2601 .capability = IDE_CD_CAPABILITIES,
2602 .generic_packet = ide_cdrom_packet,
2605 static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2607 struct cdrom_info *info = drive->driver_data;
2608 struct cdrom_device_info *devinfo = &info->devinfo;
2610 devinfo->ops = &ide_cdrom_dops;
2611 devinfo->speed = info->current_speed;
2612 devinfo->capacity = nslots;
2613 devinfo->handle = drive;
2614 strcpy(devinfo->name, drive->name);
2616 if (info->cd_flags & IDE_CD_FLAG_NO_SPEED_SELECT)
2617 devinfo->mask |= CDC_SELECT_SPEED;
2619 devinfo->disk = info->disk;
2620 return register_cdrom(devinfo);
2624 int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2626 struct cdrom_info *cd = drive->driver_data;
2627 struct cdrom_device_info *cdi = &cd->devinfo;
2628 u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
2629 mechtype_t mechtype;
2632 cdi->mask = (CDC_CD_R | CDC_CD_RW | CDC_DVD | CDC_DVD_R |
2633 CDC_DVD_RAM | CDC_SELECT_DISC | CDC_PLAY_AUDIO |
2634 CDC_MO_DRIVE | CDC_RAM);
2636 if (drive->media == ide_optical) {
2637 cdi->mask &= ~(CDC_MO_DRIVE | CDC_RAM);
2638 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
2642 if ((cd->cd_flags & IDE_CD_FLAG_NEC260) ||
2643 !strcmp(drive->id->model,"STINGRAY 8422 IDE 8X CD-ROM 7-27-95")) {
2644 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
2645 cdi->mask &= ~CDC_PLAY_AUDIO;
2650 * we have to cheat a little here. the packet will eventually
2651 * be queued with ide_cdrom_packet(), which extracts the
2652 * drive from cdi->handle. Since this device hasn't been
2653 * registered with the Uniform layer yet, it can't do this.
2654 * Same goes for cdi->ops.
2656 cdi->handle = drive;
2657 cdi->ops = &ide_cdrom_dops;
2659 if (ide_cdrom_get_capabilities(drive, buf))
2662 if ((buf[8 + 6] & 0x01) == 0)
2663 cd->cd_flags |= IDE_CD_FLAG_NO_DOORLOCK;
2664 if (buf[8 + 6] & 0x08)
2665 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
2666 if (buf[8 + 3] & 0x01)
2667 cdi->mask &= ~CDC_CD_R;
2668 if (buf[8 + 3] & 0x02)
2669 cdi->mask &= ~(CDC_CD_RW | CDC_RAM);
2670 if (buf[8 + 2] & 0x38)
2671 cdi->mask &= ~CDC_DVD;
2672 if (buf[8 + 3] & 0x20)
2673 cdi->mask &= ~(CDC_DVD_RAM | CDC_RAM);
2674 if (buf[8 + 3] & 0x10)
2675 cdi->mask &= ~CDC_DVD_R;
2676 if (buf[8 + 4] & 0x01)
2677 cdi->mask &= ~CDC_PLAY_AUDIO;
2679 mechtype = buf[8 + 6] >> 5;
2680 if (mechtype == mechtype_caddy || mechtype == mechtype_popup)
2681 cdi->mask |= CDC_CLOSE_TRAY;
2683 /* Some drives used by Apple don't advertise audio play
2684 * but they do support reading TOC & audio datas
2686 if (strcmp(drive->id->model, "MATSHITADVD-ROM SR-8187") == 0 ||
2687 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8186") == 0 ||
2688 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8176") == 0 ||
2689 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8174") == 0)
2690 cdi->mask &= ~CDC_PLAY_AUDIO;
2692 if (cdi->sanyo_slot > 0) {
2693 cdi->mask &= ~CDC_SELECT_DISC;
2695 } else if (mechtype == mechtype_individual_changer ||
2696 mechtype == mechtype_cartridge_changer) {
2697 nslots = cdrom_number_of_slots(cdi);
2699 cdi->mask &= ~CDC_SELECT_DISC;
2702 ide_cdrom_update_speed(drive, buf);
2704 printk(KERN_INFO "%s: ATAPI", drive->name);
2706 /* don't print speed if the drive reported 0 */
2708 printk(KERN_CONT " %dX", cd->max_speed);
2710 printk(KERN_CONT " %s", (cdi->mask & CDC_DVD) ? "CD-ROM" : "DVD-ROM");
2712 if ((cdi->mask & CDC_DVD_R) == 0 || (cdi->mask & CDC_DVD_RAM) == 0)
2713 printk(KERN_CONT " DVD%s%s",
2714 (cdi->mask & CDC_DVD_R) ? "" : "-R",
2715 (cdi->mask & CDC_DVD_RAM) ? "" : "-RAM");
2717 if ((cdi->mask & CDC_CD_R) == 0 || (cdi->mask & CDC_CD_RW) == 0)
2718 printk(KERN_CONT " CD%s%s",
2719 (cdi->mask & CDC_CD_R) ? "" : "-R",
2720 (cdi->mask & CDC_CD_RW) ? "" : "/RW");
2722 if ((cdi->mask & CDC_SELECT_DISC) == 0)
2723 printk(KERN_CONT " changer w/%d slots", nslots);
2725 printk(KERN_CONT " drive");
2727 printk(KERN_CONT ", %dkB Cache\n", be16_to_cpu(*(u16 *)&buf[8 + 12]));
2732 #ifdef CONFIG_IDE_PROC_FS
2733 static void ide_cdrom_add_settings(ide_drive_t *drive)
2735 ide_add_setting(drive, "dsc_overlap", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
2738 static inline void ide_cdrom_add_settings(ide_drive_t *drive) { ; }
2742 * standard prep_rq_fn that builds 10 byte cmds
2744 static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
2746 int hard_sect = queue_hardsect_size(q);
2747 long block = (long)rq->hard_sector / (hard_sect >> 9);
2748 unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
2750 memset(rq->cmd, 0, sizeof(rq->cmd));
2752 if (rq_data_dir(rq) == READ)
2753 rq->cmd[0] = GPCMD_READ_10;
2755 rq->cmd[0] = GPCMD_WRITE_10;
2760 rq->cmd[2] = (block >> 24) & 0xff;
2761 rq->cmd[3] = (block >> 16) & 0xff;
2762 rq->cmd[4] = (block >> 8) & 0xff;
2763 rq->cmd[5] = block & 0xff;
2766 * and transfer length
2768 rq->cmd[7] = (blocks >> 8) & 0xff;
2769 rq->cmd[8] = blocks & 0xff;
2775 * Most of the SCSI commands are supported directly by ATAPI devices.
2776 * This transform handles the few exceptions.
2778 static int ide_cdrom_prep_pc(struct request *rq)
2783 * Transform 6-byte read/write commands to the 10-byte version
2785 if (c[0] == READ_6 || c[0] == WRITE_6) {
2792 c[0] += (READ_10 - READ_6);
2798 * it's silly to pretend we understand 6-byte sense commands, just
2799 * reject with ILLEGAL_REQUEST and the caller should take the
2800 * appropriate action
2802 if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
2803 rq->errors = ILLEGAL_REQUEST;
2804 return BLKPREP_KILL;
2810 static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
2812 if (blk_fs_request(rq))
2813 return ide_cdrom_prep_fs(q, rq);
2814 else if (blk_pc_request(rq))
2815 return ide_cdrom_prep_pc(rq);
2821 int ide_cdrom_setup (ide_drive_t *drive)
2823 struct cdrom_info *cd = drive->driver_data;
2824 struct cdrom_device_info *cdi = &cd->devinfo;
2827 blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
2828 blk_queue_dma_alignment(drive->queue, 31);
2829 drive->queue->unplug_delay = (1 * HZ) / 1000;
2830 if (!drive->queue->unplug_delay)
2831 drive->queue->unplug_delay = 1;
2833 drive->special.all = 0;
2835 cd->cd_flags |= IDE_CD_FLAG_MEDIA_CHANGED;
2837 if ((drive->id->config & 0x0060) == 0x20)
2838 cd->cd_flags |= IDE_CD_FLAG_DRQ_INTERRUPT;
2839 cd->cd_flags |= IDE_CD_FLAG_NO_EJECT;
2841 /* limit transfer size per interrupt. */
2842 /* a testament to the nice quality of Samsung drives... */
2843 if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2430") ||
2844 !strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2432"))
2845 cd->cd_flags |= IDE_CD_FLAG_LIMIT_NFRAMES;
2846 /* the 3231 model does not support the SET_CD_SPEED command */
2847 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-3231"))
2848 cd->cd_flags |= IDE_CD_FLAG_NO_SPEED_SELECT;
2850 if (strcmp (drive->id->model, "V003S0DS") == 0 &&
2851 drive->id->fw_rev[4] == '1' &&
2852 drive->id->fw_rev[6] <= '2') {
2854 Some versions of this drive like to talk BCD. */
2855 cd->cd_flags |= (IDE_CD_FLAG_TOCTRACKS_AS_BCD |
2856 IDE_CD_FLAG_TOCADDR_AS_BCD);
2858 else if (strcmp (drive->id->model, "V006E0DS") == 0 &&
2859 drive->id->fw_rev[4] == '1' &&
2860 drive->id->fw_rev[6] <= '2') {
2861 /* Vertos 600 ESD. */
2862 cd->cd_flags |= IDE_CD_FLAG_TOCTRACKS_AS_BCD;
2864 else if (strcmp(drive->id->model, "NEC CD-ROM DRIVE:260") == 0 &&
2865 strncmp(drive->id->fw_rev, "1.01", 4) == 0) { /* FIXME */
2866 /* Old NEC260 (not R).
2867 This drive was released before the 1.2 version
2869 cd->cd_flags |= (IDE_CD_FLAG_TOCADDR_AS_BCD |
2870 IDE_CD_FLAG_NEC260);
2873 * Sanyo 3 CD changer uses a non-standard command for CD changing
2874 * (by default standard ATAPI support for CD changers is used).
2876 else if ((strcmp(drive->id->model, "CD-ROM CDR-C3 G") == 0) ||
2877 (strcmp(drive->id->model, "CD-ROM CDR-C3G") == 0) ||
2878 (strcmp(drive->id->model, "CD-ROM CDR_C36") == 0)) {
2879 /* uses CD in slot 0 when value is set to 3 */
2880 cdi->sanyo_slot = 3;
2883 nslots = ide_cdrom_probe_capabilities (drive);
2886 * set correct block size
2888 blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
2890 if (drive->autotune == IDE_TUNE_DEFAULT ||
2891 drive->autotune == IDE_TUNE_AUTO)
2892 drive->dsc_overlap = (drive->next != drive);
2894 if (ide_cdrom_register(drive, nslots)) {
2895 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
2896 cd->devinfo.handle = NULL;
2899 ide_cdrom_add_settings(drive);
2903 #ifdef CONFIG_IDE_PROC_FS
2905 sector_t ide_cdrom_capacity (ide_drive_t *drive)
2907 unsigned long capacity, sectors_per_frame;
2909 if (cdrom_read_capacity(drive, &capacity, §ors_per_frame, NULL))
2912 return capacity * sectors_per_frame;
2916 static void ide_cd_remove(ide_drive_t *drive)
2918 struct cdrom_info *info = drive->driver_data;
2920 ide_proc_unregister_driver(drive, info->driver);
2922 del_gendisk(info->disk);
2927 static void ide_cd_release(struct kref *kref)
2929 struct cdrom_info *info = to_ide_cd(kref);
2930 struct cdrom_device_info *devinfo = &info->devinfo;
2931 ide_drive_t *drive = info->drive;
2932 struct gendisk *g = info->disk;
2934 kfree(info->buffer);
2936 if (devinfo->handle == drive && unregister_cdrom(devinfo))
2937 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom "
2938 "driver.\n", __FUNCTION__, drive->name);
2939 drive->dsc_overlap = 0;
2940 drive->driver_data = NULL;
2941 blk_queue_prep_rq(drive->queue, NULL);
2942 g->private_data = NULL;
2947 static int ide_cd_probe(ide_drive_t *);
2949 #ifdef CONFIG_IDE_PROC_FS
2950 static int proc_idecd_read_capacity
2951 (char *page, char **start, off_t off, int count, int *eof, void *data)
2953 ide_drive_t *drive = data;
2956 len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
2957 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
2960 static ide_proc_entry_t idecd_proc[] = {
2961 { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
2962 { NULL, 0, NULL, NULL }
2966 static ide_driver_t ide_cdrom_driver = {
2968 .owner = THIS_MODULE,
2969 .name = "ide-cdrom",
2970 .bus = &ide_bus_type,
2972 .probe = ide_cd_probe,
2973 .remove = ide_cd_remove,
2974 .version = IDECD_VERSION,
2976 .supports_dsc_overlap = 1,
2977 .do_request = ide_do_rw_cdrom,
2978 .end_request = ide_end_request,
2979 .error = __ide_error,
2980 .abort = __ide_abort,
2981 #ifdef CONFIG_IDE_PROC_FS
2986 static int idecd_open(struct inode * inode, struct file * file)
2988 struct gendisk *disk = inode->i_bdev->bd_disk;
2989 struct cdrom_info *info;
2992 if (!(info = ide_cd_get(disk)))
2996 info->buffer = kmalloc(SECTOR_BUFFER_SIZE, GFP_KERNEL|__GFP_REPEAT);
2999 rc = cdrom_open(&info->devinfo, inode, file);
3007 static int idecd_release(struct inode * inode, struct file * file)
3009 struct gendisk *disk = inode->i_bdev->bd_disk;
3010 struct cdrom_info *info = ide_cd_g(disk);
3012 cdrom_release (&info->devinfo, file);
3019 static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg)
3021 struct packet_command cgc;
3026 if (copy_from_user(&spindown, (void __user *)arg, sizeof(char)))
3029 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
3031 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
3035 buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
3036 return cdrom_mode_select(cdi, &cgc);
3039 static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
3041 struct packet_command cgc;
3046 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
3048 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
3052 spindown = buffer[11] & 0x0f;
3053 if (copy_to_user((void __user *)arg, &spindown, sizeof (char)))
3058 static int idecd_ioctl (struct inode *inode, struct file *file,
3059 unsigned int cmd, unsigned long arg)
3061 struct block_device *bdev = inode->i_bdev;
3062 struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
3066 case CDROMSETSPINDOWN:
3067 return idecd_set_spindown(&info->devinfo, arg);
3068 case CDROMGETSPINDOWN:
3069 return idecd_get_spindown(&info->devinfo, arg);
3074 err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
3076 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
3081 static int idecd_media_changed(struct gendisk *disk)
3083 struct cdrom_info *info = ide_cd_g(disk);
3084 return cdrom_media_changed(&info->devinfo);
3087 static int idecd_revalidate_disk(struct gendisk *disk)
3089 struct cdrom_info *info = ide_cd_g(disk);
3090 struct request_sense sense;
3091 cdrom_read_toc(info->drive, &sense);
3095 static struct block_device_operations idecd_ops = {
3096 .owner = THIS_MODULE,
3098 .release = idecd_release,
3099 .ioctl = idecd_ioctl,
3100 .media_changed = idecd_media_changed,
3101 .revalidate_disk= idecd_revalidate_disk
3105 static char *ignore = NULL;
3107 module_param(ignore, charp, 0400);
3108 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
3110 static int ide_cd_probe(ide_drive_t *drive)
3112 struct cdrom_info *info;
3114 struct request_sense sense;
3116 if (!strstr("ide-cdrom", drive->driver_req))
3118 if (!drive->present)
3120 if (drive->media != ide_cdrom && drive->media != ide_optical)
3122 /* skip drives that we were told to ignore */
3123 if (ignore != NULL) {
3124 if (strstr(ignore, drive->name)) {
3125 printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
3130 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
3133 info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
3135 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
3139 g = alloc_disk(1 << PARTN_BITS);
3143 ide_init_disk(g, drive);
3145 ide_proc_register_driver(drive, &ide_cdrom_driver);
3147 kref_init(&info->kref);
3149 info->drive = drive;
3150 info->driver = &ide_cdrom_driver;
3153 g->private_data = &info->driver;
3155 drive->driver_data = info;
3158 g->driverfs_dev = &drive->gendev;
3159 g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
3160 if (ide_cdrom_setup(drive)) {
3161 ide_proc_unregister_driver(drive, &ide_cdrom_driver);
3162 ide_cd_release(&info->kref);
3166 cdrom_read_toc(drive, &sense);
3167 g->fops = &idecd_ops;
3168 g->flags |= GENHD_FL_REMOVABLE;
3178 static void __exit ide_cdrom_exit(void)
3180 driver_unregister(&ide_cdrom_driver.gen_driver);
3183 static int __init ide_cdrom_init(void)
3185 return driver_register(&ide_cdrom_driver.gen_driver);
3188 MODULE_ALIAS("ide:*m-cdrom*");
3189 module_init(ide_cdrom_init);
3190 module_exit(ide_cdrom_exit);
3191 MODULE_LICENSE("GPL");