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 packet command to the drive.
804 * This is usually called directly from cdrom_start_read.
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_read_continuation (ide_drive_t *drive)
810 struct request *rq = HWGROUP(drive)->rq;
811 unsigned short sectors_per_frame;
814 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
816 /* If the requested sector doesn't start on a cdrom block boundary,
817 we must adjust the start of the transfer so that it does,
818 and remember to skip the first few sectors.
819 If the CURRENT_NR_SECTORS field is larger than the size
820 of the buffer, it will mean that we're to skip a number
821 of sectors equal to the amount by which CURRENT_NR_SECTORS
822 is larger than the buffer size. */
823 nskip = rq->sector & (sectors_per_frame - 1);
825 /* Sanity check... */
826 if (rq->current_nr_sectors != bio_cur_sectors(rq->bio) &&
827 (rq->sector & (sectors_per_frame - 1))) {
828 printk(KERN_ERR "%s: cdrom_start_read_continuation: buffer botch (%u)\n",
829 drive->name, rq->current_nr_sectors);
830 cdrom_end_request(drive, 0);
833 rq->current_nr_sectors += nskip;
836 /* Set up the command */
837 rq->timeout = ATAPI_WAIT_PC;
839 /* Send the command to the drive and return. */
840 return cdrom_transfer_packet_command(drive, rq, cdrom_rw_intr);
844 #define IDECD_SEEK_THRESHOLD (1000) /* 1000 blocks */
845 #define IDECD_SEEK_TIMER (5 * WAIT_MIN_SLEEP) /* 100 ms */
846 #define IDECD_SEEK_TIMEOUT (2 * WAIT_CMD) /* 20 sec */
848 static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
850 struct cdrom_info *info = drive->driver_data;
852 static int retry = 10;
854 if (cdrom_decode_status(drive, 0, &stat))
857 info->cd_flags |= IDE_CD_FLAG_SEEKING;
859 if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
862 * this condition is far too common, to bother
865 /* printk("%s: disabled DSC seek overlap\n", drive->name);*/
866 drive->dsc_overlap = 0;
872 static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
874 struct request *rq = HWGROUP(drive)->rq;
875 sector_t frame = rq->sector;
877 sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
879 memset(rq->cmd, 0, sizeof(rq->cmd));
880 rq->cmd[0] = GPCMD_SEEK;
881 put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
883 rq->timeout = ATAPI_WAIT_PC;
884 return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
887 static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
889 struct cdrom_info *info = drive->driver_data;
892 info->start_seek = jiffies;
893 return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
896 /* Fix up a possibly partially-processed request so that we can
897 start it over entirely, or even put it back on the request queue. */
898 static void restore_request (struct request *rq)
900 if (rq->buffer != bio_data(rq->bio)) {
901 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
903 rq->buffer = bio_data(rq->bio);
907 rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
908 rq->hard_nr_sectors = rq->nr_sectors;
909 rq->hard_sector = rq->sector;
910 rq->q->prep_rq_fn(rq->q, rq);
914 * Start a read request from the CD-ROM.
916 static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block)
918 struct cdrom_info *info = drive->driver_data;
919 struct request *rq = HWGROUP(drive)->rq;
920 unsigned short sectors_per_frame;
922 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
924 /* We may be retrying this request after an error. Fix up
925 any weirdness which might be present in the request packet. */
928 /* Satisfy whatever we can of this request from our cached sector. */
929 if (cdrom_read_from_buffer(drive))
932 /* Clear the local sector buffer. */
933 info->nsectors_buffered = 0;
935 /* use dma, if possible. */
936 info->dma = drive->using_dma;
937 if ((rq->sector & (sectors_per_frame - 1)) ||
938 (rq->nr_sectors & (sectors_per_frame - 1)))
941 /* Start sending the read request to the drive. */
942 return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
945 /****************************************************************************
946 * Execute all other packet commands.
949 static void ide_cd_request_sense_fixup(struct request *rq)
952 * Some of the trailing request sense fields are optional,
953 * and some drives don't send them. Sigh.
955 if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
956 rq->data_len > 0 && rq->data_len <= 5)
957 while (rq->data_len > 0) {
958 *(u8 *)rq->data++ = 0;
963 int ide_cd_queue_pc(ide_drive_t *drive, struct request *rq)
965 struct request_sense sense;
967 unsigned int flags = rq->cmd_flags;
969 if (rq->sense == NULL)
972 /* Start of retry loop. */
975 unsigned long time = jiffies;
976 rq->cmd_flags = flags;
978 error = ide_do_drive_cmd(drive, rq, ide_wait);
979 time = jiffies - time;
981 /* FIXME: we should probably abort/retry or something
982 * in case of failure */
983 if (rq->cmd_flags & REQ_FAILED) {
984 /* The request failed. Retry if it was due to a unit
986 (usually means media was changed). */
987 struct request_sense *reqbuf = rq->sense;
989 if (reqbuf->sense_key == UNIT_ATTENTION)
990 cdrom_saw_media_change(drive);
991 else if (reqbuf->sense_key == NOT_READY &&
992 reqbuf->asc == 4 && reqbuf->ascq != 4) {
993 /* The drive is in the process of loading
994 a disk. Retry, but wait a little to give
995 the drive time to complete the load. */
998 /* Otherwise, don't retry. */
1004 /* End of retry loop. */
1005 } while ((rq->cmd_flags & REQ_FAILED) && retries >= 0);
1007 /* Return an error if the command failed. */
1008 return (rq->cmd_flags & REQ_FAILED) ? -EIO : 0;
1014 static int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
1016 /* Two notes about IDE interrupt reason here - 0 means that
1017 * the drive wants to receive data from us, 2 means that
1018 * the drive is expecting to transfer data to us.
1022 else if (ireason == 2) {
1023 ide_hwif_t *hwif = drive->hwif;
1025 /* Whoops... The drive wants to send data. */
1026 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
1027 drive->name, __FUNCTION__);
1029 ide_cd_pad_transfer(drive, hwif->atapi_input_bytes, len);
1031 /* Drive wants a command packet, or invalid ireason... */
1032 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
1033 drive->name, __FUNCTION__, ireason);
1036 cdrom_end_request(drive, 0);
1041 * Called from blk_end_request_callback() after the data of the request
1042 * is completed and before the request is completed.
1043 * By returning value '1', blk_end_request_callback() returns immediately
1044 * without completing the request.
1046 static int cdrom_newpc_intr_dummy_cb(struct request *rq)
1052 * best way to deal with dma that is not sector aligned right now... note
1053 * that in this path we are not using ->data or ->buffer at all. this irs
1054 * can replace cdrom_rw_intr() in the future.
1056 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1058 struct cdrom_info *info = drive->driver_data;
1059 struct request *rq = HWGROUP(drive)->rq;
1060 xfer_func_t *xferfunc;
1061 ide_expiry_t *expiry;
1062 int dma_error = 0, dma, stat, ireason, len, thislen, uptodate = 0;
1063 int write = (rq_data_dir(rq) == WRITE) ? 1 : 0;
1064 unsigned int timeout;
1067 /* Check for errors. */
1071 dma_error = HWIF(drive)->ide_dma_end(drive);
1073 printk(KERN_ERR "%s: DMA %s error\n", drive->name,
1074 write ? "write" : "read");
1079 if (cdrom_decode_status(drive, 0, &stat))
1083 * using dma, transfer is complete now
1087 return ide_error(drive, "dma error", stat);
1092 * ok we fall to pio :/
1094 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1095 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1096 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1098 len = lowcyl + (256 * highcyl);
1099 thislen = rq->data_len;
1104 * If DRQ is clear, the command has completed.
1106 if ((stat & DRQ_STAT) == 0) {
1107 if (!blk_pc_request(rq)) {
1108 ide_cd_request_sense_fixup(rq);
1109 /* Complain if we still have data left to transfer. */
1110 uptodate = rq->data_len ? 0 : 1;
1116 * check which way to transfer data
1118 if (blk_pc_request(rq) && rq_data_dir(rq) == WRITE) {
1122 if (cdrom_write_check_ireason(drive, len, ireason))
1124 } else if (blk_pc_request(rq)) {
1128 if (cdrom_read_check_ireason(drive, len, ireason))
1134 xferfunc = HWIF(drive)->atapi_output_bytes;
1135 } else if (ireason == 2 || (ireason == 1 && blk_pc_request(rq))) {
1137 xferfunc = HWIF(drive)->atapi_input_bytes;
1139 printk(KERN_ERR "%s: %s: The drive "
1140 "appears confused (ireason = 0x%02x). "
1141 "Trying to recover by ending request.\n",
1142 drive->name, __FUNCTION__, ireason);
1149 while (thislen > 0) {
1150 int blen = blen = rq->data_len;
1151 char *ptr = rq->data;
1157 ptr = bio_data(rq->bio);
1158 blen = bio_iovec(rq->bio)->bv_len;
1162 printk(KERN_ERR "%s: confused, missing data\n",
1164 blk_dump_rq_flags(rq, rq_data_dir(rq)
1165 ? "cdrom_newpc_intr, write"
1166 : "cdrom_newpc_intr, read");
1173 xferfunc(drive, ptr, blen);
1177 rq->data_len -= blen;
1181 * The request can't be completed until DRQ is cleared.
1182 * So complete the data, but don't complete the request
1183 * using the dummy function for the callback feature
1184 * of blk_end_request_callback().
1186 blk_end_request_callback(rq, 0, blen,
1187 cdrom_newpc_intr_dummy_cb);
1192 if (write && blk_sense_request(rq))
1193 rq->sense_len += thislen;
1199 ide_cd_pad_transfer(drive, xferfunc, len);
1201 if (blk_pc_request(rq)) {
1202 timeout = rq->timeout;
1205 timeout = ATAPI_WAIT_PC;
1206 expiry = cdrom_timer_expiry;
1209 ide_set_handler(drive, cdrom_newpc_intr, timeout, expiry);
1213 if (blk_pc_request(rq)) {
1214 unsigned long flags;
1216 spin_lock_irqsave(&ide_lock, flags);
1217 if (__blk_end_request(rq, 0, rq->data_len))
1219 HWGROUP(drive)->rq = NULL;
1220 spin_unlock_irqrestore(&ide_lock, flags);
1223 rq->cmd_flags |= REQ_FAILED;
1224 cdrom_end_request(drive, uptodate);
1229 static ide_startstop_t cdrom_rw_intr(ide_drive_t *drive)
1231 struct cdrom_info *info = drive->driver_data;
1232 struct request *rq = HWGROUP(drive)->rq;
1233 xfer_func_t *xferfunc;
1234 int stat, ireason, len, sectors_to_transfer, uptodate, nskip;
1235 int dma_error = 0, dma = info->dma, write = rq_data_dir(rq) == WRITE;
1236 u8 lowcyl = 0, highcyl = 0;
1238 /* Check for errors. */
1241 dma_error = HWIF(drive)->ide_dma_end(drive);
1243 printk(KERN_ERR "%s: DMA %s error\n", drive->name,
1244 write ? "write" : "read");
1249 if (cdrom_decode_status(drive, 0, &stat))
1253 * using dma, transfer is complete now
1257 return ide_error(drive, "dma error", stat);
1259 ide_end_request(drive, 1, rq->nr_sectors);
1263 /* Read the interrupt reason and the transfer length. */
1264 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1265 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1266 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1268 len = lowcyl + (256 * highcyl);
1270 /* If DRQ is clear, the command has completed. */
1271 if ((stat & DRQ_STAT) == 0) {
1273 * If we're not done reading/writing, complain.
1274 * Otherwise, complete the command normally.
1277 if (rq->current_nr_sectors > 0) {
1278 printk(KERN_ERR "%s: %s: data underrun (%d blocks)\n",
1279 drive->name, __FUNCTION__,
1280 rq->current_nr_sectors);
1282 rq->cmd_flags |= REQ_FAILED;
1285 cdrom_end_request(drive, uptodate);
1289 sectors_to_transfer = len / SECTOR_SIZE;
1291 /* Check that the drive is expecting to do the same thing we are. */
1293 if (cdrom_write_check_ireason(drive, len, ireason))
1296 xferfunc = HWIF(drive)->atapi_output_bytes;
1298 if (cdrom_read_check_ireason(drive, len, ireason))
1301 if (ide_cd_check_transfer_size(drive, len)) {
1302 cdrom_end_request(drive, 0);
1307 * First, figure out if we need to bit-bucket
1308 * any of the leading sectors.
1310 nskip = min_t(int, rq->current_nr_sectors
1311 - bio_cur_sectors(rq->bio),
1312 sectors_to_transfer);
1315 ide_cd_drain_data(drive, nskip);
1316 rq->current_nr_sectors -= nskip;
1317 sectors_to_transfer -= nskip;
1320 xferfunc = HWIF(drive)->atapi_input_bytes;
1324 * now loop and read/write the data
1326 while (sectors_to_transfer > 0) {
1330 * If we've filled the present buffer but there's another
1331 * chained buffer after it, move on.
1333 if (!write && rq->current_nr_sectors == 0 && rq->nr_sectors)
1334 cdrom_end_request(drive, 1);
1336 if (!rq->current_nr_sectors) {
1339 * If the buffers are full, cache the rest
1340 * of the data in our internal buffer.
1342 cdrom_buffer_sectors(drive, rq->sector,
1343 sectors_to_transfer);
1345 printk(KERN_ERR "%s: %s: confused, missing "
1347 drive->name, __FUNCTION__);
1352 * Figure out how many sectors we can transfer
1354 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors);
1356 while (this_transfer > 0) {
1357 xferfunc(drive, rq->buffer, SECTOR_SIZE);
1358 rq->buffer += SECTOR_SIZE;
1360 --rq->current_nr_sectors;
1363 --sectors_to_transfer;
1367 * current buffer complete, move on
1369 if (write && rq->current_nr_sectors == 0 && rq->nr_sectors)
1370 cdrom_end_request(drive, 1);
1373 /* re-arm handler */
1374 ide_set_handler(drive, cdrom_rw_intr, ATAPI_WAIT_PC, NULL);
1378 static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
1380 struct request *rq = HWGROUP(drive)->rq;
1382 #if 0 /* the immediate bit */
1383 rq->cmd[1] = 1 << 3;
1385 rq->timeout = ATAPI_WAIT_PC;
1387 return cdrom_transfer_packet_command(drive, rq, cdrom_rw_intr);
1390 static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
1392 struct cdrom_info *info = drive->driver_data;
1393 struct gendisk *g = info->disk;
1394 unsigned short sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1397 * writes *must* be hardware frame aligned
1399 if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1400 (rq->sector & (sectors_per_frame - 1))) {
1401 cdrom_end_request(drive, 0);
1406 * disk has become write protected
1409 cdrom_end_request(drive, 0);
1413 info->nsectors_buffered = 0;
1415 /* use dma, if possible. we don't need to check more, since we
1416 * know that the transfer is always (at least!) frame aligned */
1417 info->dma = drive->using_dma ? 1 : 0;
1419 info->devinfo.media_written = 1;
1421 /* Start sending the write request to the drive. */
1422 return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
1425 static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1427 struct request *rq = HWGROUP(drive)->rq;
1430 rq->timeout = ATAPI_WAIT_PC;
1432 return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1435 static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1437 struct cdrom_info *info = drive->driver_data;
1439 if (blk_pc_request(rq))
1440 rq->cmd_flags |= REQ_QUIET;
1442 rq->cmd_flags &= ~REQ_FAILED;
1450 int mask = drive->queue->dma_alignment;
1451 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
1453 info->dma = drive->using_dma;
1456 * check if dma is safe
1458 * NOTE! The "len" and "addr" checks should possibly have
1461 if ((rq->data_len & 15) || (addr & mask))
1465 /* Start sending the command to the drive. */
1466 return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1469 /****************************************************************************
1470 * cdrom driver request routine.
1472 static ide_startstop_t
1473 ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1475 ide_startstop_t action;
1476 struct cdrom_info *info = drive->driver_data;
1478 if (blk_fs_request(rq)) {
1479 if (info->cd_flags & IDE_CD_FLAG_SEEKING) {
1480 unsigned long elapsed = jiffies - info->start_seek;
1481 int stat = HWIF(drive)->INB(IDE_STATUS_REG);
1483 if ((stat & SEEK_STAT) != SEEK_STAT) {
1484 if (elapsed < IDECD_SEEK_TIMEOUT) {
1485 ide_stall_queue(drive, IDECD_SEEK_TIMER);
1488 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
1490 info->cd_flags &= ~IDE_CD_FLAG_SEEKING;
1492 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
1493 action = cdrom_start_seek(drive, block);
1495 if (rq_data_dir(rq) == READ)
1496 action = cdrom_start_read(drive, block);
1498 action = cdrom_start_write(drive, rq);
1500 info->last_block = block;
1502 } else if (blk_sense_request(rq) || blk_pc_request(rq) ||
1503 rq->cmd_type == REQ_TYPE_ATA_PC) {
1504 return cdrom_do_block_pc(drive, rq);
1505 } else if (blk_special_request(rq)) {
1507 * right now this can only be a reset...
1509 cdrom_end_request(drive, 1);
1513 blk_dump_rq_flags(rq, "ide-cd bad flags");
1514 cdrom_end_request(drive, 0);
1520 /****************************************************************************
1523 * Routines which queue packet commands take as a final argument a pointer
1524 * to a request_sense struct. If execution of the command results
1525 * in an error with a CHECK CONDITION status, this structure will be filled
1526 * with the results of the subsequent request sense command. The pointer
1527 * can also be NULL, in which case no sense information is returned.
1531 void msf_from_bcd (struct atapi_msf *msf)
1533 msf->minute = BCD2BIN(msf->minute);
1534 msf->second = BCD2BIN(msf->second);
1535 msf->frame = BCD2BIN(msf->frame);
1538 static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
1541 struct cdrom_info *info = drive->driver_data;
1542 struct cdrom_device_info *cdi = &info->devinfo;
1544 ide_cd_init_rq(drive, &req);
1547 req.cmd[0] = GPCMD_TEST_UNIT_READY;
1548 req.cmd_flags |= REQ_QUIET;
1551 * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
1552 * switch CDs instead of supporting the LOAD_UNLOAD opcode.
1554 req.cmd[7] = cdi->sanyo_slot % 3;
1556 return ide_cd_queue_pc(drive, &req);
1559 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
1560 int ide_cd_lockdoor(ide_drive_t *drive, int lockflag,
1561 struct request_sense *sense)
1563 struct cdrom_info *cd = drive->driver_data;
1564 struct request_sense my_sense;
1571 /* If the drive cannot lock the door, just pretend. */
1572 if (cd->cd_flags & IDE_CD_FLAG_NO_DOORLOCK) {
1575 ide_cd_init_rq(drive, &req);
1577 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
1578 req.cmd[4] = lockflag ? 1 : 0;
1579 stat = ide_cd_queue_pc(drive, &req);
1582 /* If we got an illegal field error, the drive
1583 probably cannot lock the door. */
1585 sense->sense_key == ILLEGAL_REQUEST &&
1586 (sense->asc == 0x24 || sense->asc == 0x20)) {
1587 printk (KERN_ERR "%s: door locking not supported\n",
1589 cd->cd_flags |= IDE_CD_FLAG_NO_DOORLOCK;
1593 /* no medium, that's alright. */
1594 if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
1599 cd->cd_flags |= IDE_CD_FLAG_DOOR_LOCKED;
1601 cd->cd_flags &= ~IDE_CD_FLAG_DOOR_LOCKED;
1608 /* Eject the disk if EJECTFLAG is 0.
1609 If EJECTFLAG is 1, try to reload the disk. */
1610 static int cdrom_eject(ide_drive_t *drive, int ejectflag,
1611 struct request_sense *sense)
1613 struct cdrom_info *cd = drive->driver_data;
1614 struct cdrom_device_info *cdi = &cd->devinfo;
1618 if ((cd->cd_flags & IDE_CD_FLAG_NO_EJECT) && !ejectflag)
1619 return -EDRIVE_CANT_DO_THIS;
1621 /* reload fails on some drives, if the tray is locked */
1622 if ((cd->cd_flags & IDE_CD_FLAG_DOOR_LOCKED) && ejectflag)
1625 ide_cd_init_rq(drive, &req);
1627 /* only tell drive to close tray if open, if it can do that */
1628 if (ejectflag && (cdi->mask & CDC_CLOSE_TRAY))
1632 req.cmd[0] = GPCMD_START_STOP_UNIT;
1633 req.cmd[4] = loej | (ejectflag != 0);
1635 return ide_cd_queue_pc(drive, &req);
1638 static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
1639 unsigned long *sectors_per_frame,
1640 struct request_sense *sense)
1650 ide_cd_init_rq(drive, &req);
1653 req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
1654 req.data = (char *)&capbuf;
1655 req.data_len = sizeof(capbuf);
1656 req.cmd_flags |= REQ_QUIET;
1658 stat = ide_cd_queue_pc(drive, &req);
1660 *capacity = 1 + be32_to_cpu(capbuf.lba);
1661 *sectors_per_frame =
1662 be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
1668 static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
1669 int format, char *buf, int buflen,
1670 struct request_sense *sense)
1674 ide_cd_init_rq(drive, &req);
1678 req.data_len = buflen;
1679 req.cmd_flags |= REQ_QUIET;
1680 req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
1681 req.cmd[6] = trackno;
1682 req.cmd[7] = (buflen >> 8);
1683 req.cmd[8] = (buflen & 0xff);
1684 req.cmd[9] = (format << 6);
1689 return ide_cd_queue_pc(drive, &req);
1692 /* Try to read the entire TOC for the disk into our internal buffer. */
1693 int ide_cd_read_toc(ide_drive_t *drive, struct request_sense *sense)
1695 int stat, ntracks, i;
1696 struct cdrom_info *info = drive->driver_data;
1697 struct cdrom_device_info *cdi = &info->devinfo;
1698 struct atapi_toc *toc = info->toc;
1700 struct atapi_toc_header hdr;
1701 struct atapi_toc_entry ent;
1704 unsigned long sectors_per_frame = SECTORS_PER_FRAME;
1707 /* Try to allocate space. */
1708 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
1710 printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
1716 /* Check to see if the existing data is still valid.
1717 If it is, just return. */
1718 (void) cdrom_check_status(drive, sense);
1720 if (info->cd_flags & IDE_CD_FLAG_TOC_VALID)
1723 /* Try to get the total cdrom capacity and sector size. */
1724 stat = cdrom_read_capacity(drive, &toc->capacity, §ors_per_frame,
1727 toc->capacity = 0x1fffff;
1729 set_capacity(info->disk, toc->capacity * sectors_per_frame);
1730 /* Save a private copy of te TOC capacity for error handling */
1731 drive->probed_capacity = toc->capacity * sectors_per_frame;
1733 blk_queue_hardsect_size(drive->queue,
1734 sectors_per_frame << SECTOR_BITS);
1736 /* First read just the header, so we know how long the TOC is. */
1737 stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
1738 sizeof(struct atapi_toc_header), sense);
1742 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1743 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
1744 toc->hdr.last_track = BCD2BIN(toc->hdr.last_track);
1747 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
1750 if (ntracks > MAX_TRACKS)
1751 ntracks = MAX_TRACKS;
1753 /* Now read the whole schmeer. */
1754 stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
1756 sizeof(struct atapi_toc_header) +
1758 sizeof(struct atapi_toc_entry), sense);
1760 if (stat && toc->hdr.first_track > 1) {
1761 /* Cds with CDI tracks only don't have any TOC entries,
1762 despite of this the returned values are
1763 first_track == last_track = number of CDI tracks + 1,
1764 so that this case is indistinguishable from the same
1765 layout plus an additional audio track.
1766 If we get an error for the regular case, we assume
1767 a CDI without additional audio tracks. In this case
1768 the readable TOC is empty (CDI tracks are not included)
1769 and only holds the Leadout entry. Heiko Eißfeldt */
1771 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
1773 sizeof(struct atapi_toc_header) +
1775 sizeof(struct atapi_toc_entry),
1780 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1781 toc->hdr.first_track = (u8)BIN2BCD(CDROM_LEADOUT);
1782 toc->hdr.last_track = (u8)BIN2BCD(CDROM_LEADOUT);
1784 toc->hdr.first_track = CDROM_LEADOUT;
1785 toc->hdr.last_track = CDROM_LEADOUT;
1792 toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
1794 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1795 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
1796 toc->hdr.last_track = BCD2BIN(toc->hdr.last_track);
1799 for (i = 0; i <= ntracks; i++) {
1800 if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
1801 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD)
1802 toc->ent[i].track = BCD2BIN(toc->ent[i].track);
1803 msf_from_bcd(&toc->ent[i].addr.msf);
1805 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
1806 toc->ent[i].addr.msf.second,
1807 toc->ent[i].addr.msf.frame);
1810 /* Read the multisession information. */
1811 if (toc->hdr.first_track != CDROM_LEADOUT) {
1812 /* Read the multisession information. */
1813 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
1814 sizeof(ms_tmp), sense);
1818 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
1820 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
1821 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
1824 if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
1825 /* Re-read multisession information using MSF format */
1826 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
1827 sizeof(ms_tmp), sense);
1831 msf_from_bcd (&ms_tmp.ent.addr.msf);
1832 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
1833 ms_tmp.ent.addr.msf.second,
1834 ms_tmp.ent.addr.msf.frame);
1837 toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
1839 /* Now try to get the total cdrom capacity. */
1840 stat = cdrom_get_last_written(cdi, &last_written);
1841 if (!stat && (last_written > toc->capacity)) {
1842 toc->capacity = last_written;
1843 set_capacity(info->disk, toc->capacity * sectors_per_frame);
1844 drive->probed_capacity = toc->capacity * sectors_per_frame;
1847 /* Remember that we've read this stuff. */
1848 info->cd_flags |= IDE_CD_FLAG_TOC_VALID;
1853 /* the generic packet interface to cdrom.c */
1854 static int ide_cdrom_packet(struct cdrom_device_info *cdi,
1855 struct packet_command *cgc)
1858 ide_drive_t *drive = cdi->handle;
1860 if (cgc->timeout <= 0)
1861 cgc->timeout = ATAPI_WAIT_PC;
1863 /* here we queue the commands from the uniform CD-ROM
1864 layer. the packet must be complete, as we do not
1866 ide_cd_init_rq(drive, &req);
1867 memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
1869 memset(cgc->sense, 0, sizeof(struct request_sense));
1870 req.data = cgc->buffer;
1871 req.data_len = cgc->buflen;
1872 req.timeout = cgc->timeout;
1875 req.cmd_flags |= REQ_QUIET;
1877 req.sense = cgc->sense;
1878 cgc->stat = ide_cd_queue_pc(drive, &req);
1880 cgc->buflen -= req.data_len;
1885 int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
1887 ide_drive_t *drive = cdi->handle;
1888 struct request_sense sense;
1891 int stat = ide_cd_lockdoor(drive, 0, &sense);
1897 return cdrom_eject(drive, !position, &sense);
1900 int ide_cdrom_get_capabilities(ide_drive_t *drive, u8 *buf)
1902 struct cdrom_info *info = drive->driver_data;
1903 struct cdrom_device_info *cdi = &info->devinfo;
1904 struct packet_command cgc;
1905 int stat, attempts = 3, size = ATAPI_CAPABILITIES_PAGE_SIZE;
1907 if ((info->cd_flags & IDE_CD_FLAG_FULL_CAPS_PAGE) == 0)
1908 size -= ATAPI_CAPABILITIES_PAGE_PAD_SIZE;
1910 init_cdrom_command(&cgc, buf, size, CGC_DATA_UNKNOWN);
1911 do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
1912 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
1915 } while (--attempts);
1919 void ide_cdrom_update_speed(ide_drive_t *drive, u8 *buf)
1921 struct cdrom_info *cd = drive->driver_data;
1922 u16 curspeed, maxspeed;
1924 curspeed = *(u16 *)&buf[8 + 14];
1925 maxspeed = *(u16 *)&buf[8 + 8];
1927 if (cd->cd_flags & IDE_CD_FLAG_LE_SPEED_FIELDS) {
1928 curspeed = le16_to_cpu(curspeed);
1929 maxspeed = le16_to_cpu(maxspeed);
1931 curspeed = be16_to_cpu(curspeed);
1932 maxspeed = be16_to_cpu(maxspeed);
1935 cd->current_speed = (curspeed + (176/2)) / 176;
1936 cd->max_speed = (maxspeed + (176/2)) / 176;
1940 * add logic to try GET_EVENT command first to check for media and tray
1941 * status. this should be supported by newer cd-r/w and all DVD etc
1945 int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
1947 ide_drive_t *drive = cdi->handle;
1948 struct media_event_desc med;
1949 struct request_sense sense;
1952 if (slot_nr != CDSL_CURRENT)
1955 stat = cdrom_check_status(drive, &sense);
1956 if (!stat || sense.sense_key == UNIT_ATTENTION)
1959 if (!cdrom_get_media_event(cdi, &med)) {
1960 if (med.media_present)
1962 else if (med.door_open)
1963 return CDS_TRAY_OPEN;
1968 if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
1972 * If not using Mt Fuji extended media tray reports,
1973 * just return TRAY_OPEN since ATAPI doesn't provide
1974 * any other way to detect this...
1976 if (sense.sense_key == NOT_READY) {
1977 if (sense.asc == 0x3a && sense.ascq == 1)
1980 return CDS_TRAY_OPEN;
1982 return CDS_DRIVE_NOT_READY;
1985 /****************************************************************************
1986 * Other driver requests (open, close, check media change).
1990 int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
1993 ide_drive_t *drive = cdi->handle;
1994 struct cdrom_info *cd = drive->driver_data;
1997 if (slot_nr == CDSL_CURRENT) {
1998 (void) cdrom_check_status(drive, NULL);
1999 retval = (cd->cd_flags & IDE_CD_FLAG_MEDIA_CHANGED) ? 1 : 0;
2000 cd->cd_flags &= ~IDE_CD_FLAG_MEDIA_CHANGED;
2009 int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
2015 * Close down the device. Invalidate all cached blocks.
2019 void ide_cdrom_release_real (struct cdrom_device_info *cdi)
2021 ide_drive_t *drive = cdi->handle;
2022 struct cdrom_info *cd = drive->driver_data;
2024 if (!cdi->use_count)
2025 cd->cd_flags &= ~IDE_CD_FLAG_TOC_VALID;
2028 #define IDE_CD_CAPABILITIES \
2029 (CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | CDC_SELECT_SPEED | \
2030 CDC_SELECT_DISC | CDC_MULTI_SESSION | CDC_MCN | CDC_MEDIA_CHANGED | \
2031 CDC_PLAY_AUDIO | CDC_RESET | CDC_DRIVE_STATUS | CDC_CD_R | \
2032 CDC_CD_RW | CDC_DVD | CDC_DVD_R | CDC_DVD_RAM | CDC_GENERIC_PACKET | \
2033 CDC_MO_DRIVE | CDC_MRW | CDC_MRW_W | CDC_RAM)
2035 static struct cdrom_device_ops ide_cdrom_dops = {
2036 .open = ide_cdrom_open_real,
2037 .release = ide_cdrom_release_real,
2038 .drive_status = ide_cdrom_drive_status,
2039 .media_changed = ide_cdrom_check_media_change_real,
2040 .tray_move = ide_cdrom_tray_move,
2041 .lock_door = ide_cdrom_lock_door,
2042 .select_speed = ide_cdrom_select_speed,
2043 .get_last_session = ide_cdrom_get_last_session,
2044 .get_mcn = ide_cdrom_get_mcn,
2045 .reset = ide_cdrom_reset,
2046 .audio_ioctl = ide_cdrom_audio_ioctl,
2047 .capability = IDE_CD_CAPABILITIES,
2048 .generic_packet = ide_cdrom_packet,
2051 static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2053 struct cdrom_info *info = drive->driver_data;
2054 struct cdrom_device_info *devinfo = &info->devinfo;
2056 devinfo->ops = &ide_cdrom_dops;
2057 devinfo->speed = info->current_speed;
2058 devinfo->capacity = nslots;
2059 devinfo->handle = drive;
2060 strcpy(devinfo->name, drive->name);
2062 if (info->cd_flags & IDE_CD_FLAG_NO_SPEED_SELECT)
2063 devinfo->mask |= CDC_SELECT_SPEED;
2065 devinfo->disk = info->disk;
2066 return register_cdrom(devinfo);
2070 int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2072 struct cdrom_info *cd = drive->driver_data;
2073 struct cdrom_device_info *cdi = &cd->devinfo;
2074 u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
2075 mechtype_t mechtype;
2078 cdi->mask = (CDC_CD_R | CDC_CD_RW | CDC_DVD | CDC_DVD_R |
2079 CDC_DVD_RAM | CDC_SELECT_DISC | CDC_PLAY_AUDIO |
2080 CDC_MO_DRIVE | CDC_RAM);
2082 if (drive->media == ide_optical) {
2083 cdi->mask &= ~(CDC_MO_DRIVE | CDC_RAM);
2084 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
2088 if (cd->cd_flags & IDE_CD_FLAG_PRE_ATAPI12) {
2089 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
2090 cdi->mask &= ~CDC_PLAY_AUDIO;
2095 * we have to cheat a little here. the packet will eventually
2096 * be queued with ide_cdrom_packet(), which extracts the
2097 * drive from cdi->handle. Since this device hasn't been
2098 * registered with the Uniform layer yet, it can't do this.
2099 * Same goes for cdi->ops.
2101 cdi->handle = drive;
2102 cdi->ops = &ide_cdrom_dops;
2104 if (ide_cdrom_get_capabilities(drive, buf))
2107 if ((buf[8 + 6] & 0x01) == 0)
2108 cd->cd_flags |= IDE_CD_FLAG_NO_DOORLOCK;
2109 if (buf[8 + 6] & 0x08)
2110 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
2111 if (buf[8 + 3] & 0x01)
2112 cdi->mask &= ~CDC_CD_R;
2113 if (buf[8 + 3] & 0x02)
2114 cdi->mask &= ~(CDC_CD_RW | CDC_RAM);
2115 if (buf[8 + 2] & 0x38)
2116 cdi->mask &= ~CDC_DVD;
2117 if (buf[8 + 3] & 0x20)
2118 cdi->mask &= ~(CDC_DVD_RAM | CDC_RAM);
2119 if (buf[8 + 3] & 0x10)
2120 cdi->mask &= ~CDC_DVD_R;
2121 if ((buf[8 + 4] & 0x01) || (cd->cd_flags & IDE_CD_FLAG_PLAY_AUDIO_OK))
2122 cdi->mask &= ~CDC_PLAY_AUDIO;
2124 mechtype = buf[8 + 6] >> 5;
2125 if (mechtype == mechtype_caddy || mechtype == mechtype_popup)
2126 cdi->mask |= CDC_CLOSE_TRAY;
2128 if (cdi->sanyo_slot > 0) {
2129 cdi->mask &= ~CDC_SELECT_DISC;
2131 } else if (mechtype == mechtype_individual_changer ||
2132 mechtype == mechtype_cartridge_changer) {
2133 nslots = cdrom_number_of_slots(cdi);
2135 cdi->mask &= ~CDC_SELECT_DISC;
2138 ide_cdrom_update_speed(drive, buf);
2140 printk(KERN_INFO "%s: ATAPI", drive->name);
2142 /* don't print speed if the drive reported 0 */
2144 printk(KERN_CONT " %dX", cd->max_speed);
2146 printk(KERN_CONT " %s", (cdi->mask & CDC_DVD) ? "CD-ROM" : "DVD-ROM");
2148 if ((cdi->mask & CDC_DVD_R) == 0 || (cdi->mask & CDC_DVD_RAM) == 0)
2149 printk(KERN_CONT " DVD%s%s",
2150 (cdi->mask & CDC_DVD_R) ? "" : "-R",
2151 (cdi->mask & CDC_DVD_RAM) ? "" : "-RAM");
2153 if ((cdi->mask & CDC_CD_R) == 0 || (cdi->mask & CDC_CD_RW) == 0)
2154 printk(KERN_CONT " CD%s%s",
2155 (cdi->mask & CDC_CD_R) ? "" : "-R",
2156 (cdi->mask & CDC_CD_RW) ? "" : "/RW");
2158 if ((cdi->mask & CDC_SELECT_DISC) == 0)
2159 printk(KERN_CONT " changer w/%d slots", nslots);
2161 printk(KERN_CONT " drive");
2163 printk(KERN_CONT ", %dkB Cache\n", be16_to_cpu(*(u16 *)&buf[8 + 12]));
2168 #ifdef CONFIG_IDE_PROC_FS
2169 static void ide_cdrom_add_settings(ide_drive_t *drive)
2171 ide_add_setting(drive, "dsc_overlap", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
2174 static inline void ide_cdrom_add_settings(ide_drive_t *drive) { ; }
2178 * standard prep_rq_fn that builds 10 byte cmds
2180 static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
2182 int hard_sect = queue_hardsect_size(q);
2183 long block = (long)rq->hard_sector / (hard_sect >> 9);
2184 unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
2186 memset(rq->cmd, 0, sizeof(rq->cmd));
2188 if (rq_data_dir(rq) == READ)
2189 rq->cmd[0] = GPCMD_READ_10;
2191 rq->cmd[0] = GPCMD_WRITE_10;
2196 rq->cmd[2] = (block >> 24) & 0xff;
2197 rq->cmd[3] = (block >> 16) & 0xff;
2198 rq->cmd[4] = (block >> 8) & 0xff;
2199 rq->cmd[5] = block & 0xff;
2202 * and transfer length
2204 rq->cmd[7] = (blocks >> 8) & 0xff;
2205 rq->cmd[8] = blocks & 0xff;
2211 * Most of the SCSI commands are supported directly by ATAPI devices.
2212 * This transform handles the few exceptions.
2214 static int ide_cdrom_prep_pc(struct request *rq)
2219 * Transform 6-byte read/write commands to the 10-byte version
2221 if (c[0] == READ_6 || c[0] == WRITE_6) {
2228 c[0] += (READ_10 - READ_6);
2234 * it's silly to pretend we understand 6-byte sense commands, just
2235 * reject with ILLEGAL_REQUEST and the caller should take the
2236 * appropriate action
2238 if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
2239 rq->errors = ILLEGAL_REQUEST;
2240 return BLKPREP_KILL;
2246 static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
2248 if (blk_fs_request(rq))
2249 return ide_cdrom_prep_fs(q, rq);
2250 else if (blk_pc_request(rq))
2251 return ide_cdrom_prep_pc(rq);
2256 struct cd_list_entry {
2257 const char *id_model;
2258 const char *id_firmware;
2259 unsigned int cd_flags;
2262 static const struct cd_list_entry ide_cd_quirks_list[] = {
2263 /* Limit transfer size per interrupt. */
2264 { "SAMSUNG CD-ROM SCR-2430", NULL, IDE_CD_FLAG_LIMIT_NFRAMES },
2265 { "SAMSUNG CD-ROM SCR-2432", NULL, IDE_CD_FLAG_LIMIT_NFRAMES },
2266 /* SCR-3231 doesn't support the SET_CD_SPEED command. */
2267 { "SAMSUNG CD-ROM SCR-3231", NULL, IDE_CD_FLAG_NO_SPEED_SELECT },
2268 /* Old NEC260 (not R) was released before ATAPI 1.2 spec. */
2269 { "NEC CD-ROM DRIVE:260", "1.01", IDE_CD_FLAG_TOCADDR_AS_BCD |
2270 IDE_CD_FLAG_PRE_ATAPI12, },
2271 /* Vertos 300, some versions of this drive like to talk BCD. */
2272 { "V003S0DS", NULL, IDE_CD_FLAG_VERTOS_300_SSD, },
2273 /* Vertos 600 ESD. */
2274 { "V006E0DS", NULL, IDE_CD_FLAG_VERTOS_600_ESD, },
2276 * Sanyo 3 CD changer uses a non-standard command for CD changing
2277 * (by default standard ATAPI support for CD changers is used).
2279 { "CD-ROM CDR-C3 G", NULL, IDE_CD_FLAG_SANYO_3CD },
2280 { "CD-ROM CDR-C3G", NULL, IDE_CD_FLAG_SANYO_3CD },
2281 { "CD-ROM CDR_C36", NULL, IDE_CD_FLAG_SANYO_3CD },
2282 /* Stingray 8X CD-ROM. */
2283 { "STINGRAY 8422 IDE 8X CD-ROM 7-27-95", NULL, IDE_CD_FLAG_PRE_ATAPI12},
2285 * ACER 50X CD-ROM and WPI 32X CD-ROM require the full spec length
2286 * mode sense page capabilities size, but older drives break.
2288 { "ATAPI CD ROM DRIVE 50X MAX", NULL, IDE_CD_FLAG_FULL_CAPS_PAGE },
2289 { "WPI CDS-32X", NULL, IDE_CD_FLAG_FULL_CAPS_PAGE },
2290 /* ACER/AOpen 24X CD-ROM has the speed fields byte-swapped. */
2291 { "", "241N", IDE_CD_FLAG_LE_SPEED_FIELDS },
2293 * Some drives used by Apple don't advertise audio play
2294 * but they do support reading TOC & audio datas.
2296 { "MATSHITADVD-ROM SR-8187", NULL, IDE_CD_FLAG_PLAY_AUDIO_OK },
2297 { "MATSHITADVD-ROM SR-8186", NULL, IDE_CD_FLAG_PLAY_AUDIO_OK },
2298 { "MATSHITADVD-ROM SR-8176", NULL, IDE_CD_FLAG_PLAY_AUDIO_OK },
2299 { "MATSHITADVD-ROM SR-8174", NULL, IDE_CD_FLAG_PLAY_AUDIO_OK },
2303 static unsigned int ide_cd_flags(struct hd_driveid *id)
2305 const struct cd_list_entry *cle = ide_cd_quirks_list;
2307 while (cle->id_model) {
2308 if (strcmp(cle->id_model, id->model) == 0 &&
2309 (cle->id_firmware == NULL ||
2310 strstr(id->fw_rev, cle->id_firmware)))
2311 return cle->cd_flags;
2319 int ide_cdrom_setup (ide_drive_t *drive)
2321 struct cdrom_info *cd = drive->driver_data;
2322 struct cdrom_device_info *cdi = &cd->devinfo;
2323 struct hd_driveid *id = drive->id;
2326 blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
2327 blk_queue_dma_alignment(drive->queue, 31);
2328 drive->queue->unplug_delay = (1 * HZ) / 1000;
2329 if (!drive->queue->unplug_delay)
2330 drive->queue->unplug_delay = 1;
2332 drive->special.all = 0;
2334 cd->cd_flags = IDE_CD_FLAG_MEDIA_CHANGED | IDE_CD_FLAG_NO_EJECT |
2337 if ((id->config & 0x0060) == 0x20)
2338 cd->cd_flags |= IDE_CD_FLAG_DRQ_INTERRUPT;
2340 if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_300_SSD) &&
2341 id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
2342 cd->cd_flags |= (IDE_CD_FLAG_TOCTRACKS_AS_BCD |
2343 IDE_CD_FLAG_TOCADDR_AS_BCD);
2344 else if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_600_ESD) &&
2345 id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
2346 cd->cd_flags |= IDE_CD_FLAG_TOCTRACKS_AS_BCD;
2347 else if (cd->cd_flags & IDE_CD_FLAG_SANYO_3CD)
2348 cdi->sanyo_slot = 3; /* 3 => use CD in slot 0 */
2350 nslots = ide_cdrom_probe_capabilities (drive);
2353 * set correct block size
2355 blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
2357 if (drive->autotune == IDE_TUNE_DEFAULT ||
2358 drive->autotune == IDE_TUNE_AUTO)
2359 drive->dsc_overlap = (drive->next != drive);
2361 if (ide_cdrom_register(drive, nslots)) {
2362 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
2363 cd->devinfo.handle = NULL;
2366 ide_cdrom_add_settings(drive);
2370 #ifdef CONFIG_IDE_PROC_FS
2372 sector_t ide_cdrom_capacity (ide_drive_t *drive)
2374 unsigned long capacity, sectors_per_frame;
2376 if (cdrom_read_capacity(drive, &capacity, §ors_per_frame, NULL))
2379 return capacity * sectors_per_frame;
2383 static void ide_cd_remove(ide_drive_t *drive)
2385 struct cdrom_info *info = drive->driver_data;
2387 ide_proc_unregister_driver(drive, info->driver);
2389 del_gendisk(info->disk);
2394 static void ide_cd_release(struct kref *kref)
2396 struct cdrom_info *info = to_ide_cd(kref);
2397 struct cdrom_device_info *devinfo = &info->devinfo;
2398 ide_drive_t *drive = info->drive;
2399 struct gendisk *g = info->disk;
2401 kfree(info->buffer);
2403 if (devinfo->handle == drive && unregister_cdrom(devinfo))
2404 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom "
2405 "driver.\n", __FUNCTION__, drive->name);
2406 drive->dsc_overlap = 0;
2407 drive->driver_data = NULL;
2408 blk_queue_prep_rq(drive->queue, NULL);
2409 g->private_data = NULL;
2414 static int ide_cd_probe(ide_drive_t *);
2416 #ifdef CONFIG_IDE_PROC_FS
2417 static int proc_idecd_read_capacity
2418 (char *page, char **start, off_t off, int count, int *eof, void *data)
2420 ide_drive_t *drive = data;
2423 len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
2424 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
2427 static ide_proc_entry_t idecd_proc[] = {
2428 { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
2429 { NULL, 0, NULL, NULL }
2433 static ide_driver_t ide_cdrom_driver = {
2435 .owner = THIS_MODULE,
2436 .name = "ide-cdrom",
2437 .bus = &ide_bus_type,
2439 .probe = ide_cd_probe,
2440 .remove = ide_cd_remove,
2441 .version = IDECD_VERSION,
2443 .supports_dsc_overlap = 1,
2444 .do_request = ide_do_rw_cdrom,
2445 .end_request = ide_end_request,
2446 .error = __ide_error,
2447 .abort = __ide_abort,
2448 #ifdef CONFIG_IDE_PROC_FS
2453 static int idecd_open(struct inode * inode, struct file * file)
2455 struct gendisk *disk = inode->i_bdev->bd_disk;
2456 struct cdrom_info *info;
2459 if (!(info = ide_cd_get(disk)))
2463 info->buffer = kmalloc(SECTOR_BUFFER_SIZE, GFP_KERNEL|__GFP_REPEAT);
2466 rc = cdrom_open(&info->devinfo, inode, file);
2474 static int idecd_release(struct inode * inode, struct file * file)
2476 struct gendisk *disk = inode->i_bdev->bd_disk;
2477 struct cdrom_info *info = ide_cd_g(disk);
2479 cdrom_release (&info->devinfo, file);
2486 static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg)
2488 struct packet_command cgc;
2493 if (copy_from_user(&spindown, (void __user *)arg, sizeof(char)))
2496 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2498 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
2502 buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
2503 return cdrom_mode_select(cdi, &cgc);
2506 static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
2508 struct packet_command cgc;
2513 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2515 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
2519 spindown = buffer[11] & 0x0f;
2520 if (copy_to_user((void __user *)arg, &spindown, sizeof (char)))
2525 static int idecd_ioctl (struct inode *inode, struct file *file,
2526 unsigned int cmd, unsigned long arg)
2528 struct block_device *bdev = inode->i_bdev;
2529 struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
2533 case CDROMSETSPINDOWN:
2534 return idecd_set_spindown(&info->devinfo, arg);
2535 case CDROMGETSPINDOWN:
2536 return idecd_get_spindown(&info->devinfo, arg);
2541 err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
2543 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
2548 static int idecd_media_changed(struct gendisk *disk)
2550 struct cdrom_info *info = ide_cd_g(disk);
2551 return cdrom_media_changed(&info->devinfo);
2554 static int idecd_revalidate_disk(struct gendisk *disk)
2556 struct cdrom_info *info = ide_cd_g(disk);
2557 struct request_sense sense;
2559 ide_cd_read_toc(info->drive, &sense);
2564 static struct block_device_operations idecd_ops = {
2565 .owner = THIS_MODULE,
2567 .release = idecd_release,
2568 .ioctl = idecd_ioctl,
2569 .media_changed = idecd_media_changed,
2570 .revalidate_disk= idecd_revalidate_disk
2574 static char *ignore = NULL;
2576 module_param(ignore, charp, 0400);
2577 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
2579 static int ide_cd_probe(ide_drive_t *drive)
2581 struct cdrom_info *info;
2583 struct request_sense sense;
2585 if (!strstr("ide-cdrom", drive->driver_req))
2587 if (!drive->present)
2589 if (drive->media != ide_cdrom && drive->media != ide_optical)
2591 /* skip drives that we were told to ignore */
2592 if (ignore != NULL) {
2593 if (strstr(ignore, drive->name)) {
2594 printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
2599 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
2602 info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
2604 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
2608 g = alloc_disk(1 << PARTN_BITS);
2612 ide_init_disk(g, drive);
2614 ide_proc_register_driver(drive, &ide_cdrom_driver);
2616 kref_init(&info->kref);
2618 info->drive = drive;
2619 info->driver = &ide_cdrom_driver;
2622 g->private_data = &info->driver;
2624 drive->driver_data = info;
2627 g->driverfs_dev = &drive->gendev;
2628 g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
2629 if (ide_cdrom_setup(drive)) {
2630 ide_proc_unregister_driver(drive, &ide_cdrom_driver);
2631 ide_cd_release(&info->kref);
2635 ide_cd_read_toc(drive, &sense);
2636 g->fops = &idecd_ops;
2637 g->flags |= GENHD_FL_REMOVABLE;
2647 static void __exit ide_cdrom_exit(void)
2649 driver_unregister(&ide_cdrom_driver.gen_driver);
2652 static int __init ide_cdrom_init(void)
2654 return driver_register(&ide_cdrom_driver.gen_driver);
2657 MODULE_ALIAS("ide:*m-cdrom*");
2658 MODULE_ALIAS("ide-cd");
2659 module_init(ide_cdrom_init);
2660 module_exit(ide_cdrom_exit);
2661 MODULE_LICENSE("GPL");