4 * Copyright (C) 1994-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>
7 * Copyright (C) 2005, 2007 Bartlomiej Zolnierkiewicz
9 * May be copied or modified under the terms of the GNU General Public
10 * License. See linux/COPYING for more information.
12 * See Documentation/cdrom/ide-cd for usage information.
14 * Suggestions are welcome. Patches that work are more welcome though. ;-)
17 * Mt. Fuji (SFF8090 version 4) and ATAPI (SFF-8020i rev 2.6) standards.
19 * For historical changelog please see:
20 * Documentation/ide/ChangeLog.ide-cd.1994-2004
23 #define DRV_NAME "ide-cd"
24 #define PFX DRV_NAME ": "
26 #define IDECD_VERSION "5.00"
28 #include <linux/module.h>
29 #include <linux/types.h>
30 #include <linux/kernel.h>
31 #include <linux/delay.h>
32 #include <linux/timer.h>
33 #include <linux/slab.h>
34 #include <linux/interrupt.h>
35 #include <linux/errno.h>
36 #include <linux/cdrom.h>
37 #include <linux/ide.h>
38 #include <linux/completion.h>
39 #include <linux/mutex.h>
40 #include <linux/bcd.h>
42 /* For SCSI -> ATAPI command conversion */
43 #include <scsi/scsi.h>
45 #include <linux/irq.h>
47 #include <asm/byteorder.h>
48 #include <linux/uaccess.h>
49 #include <asm/unaligned.h>
53 static DEFINE_MUTEX(idecd_ref_mutex
);
55 static void ide_cd_release(struct device
*);
57 static struct cdrom_info
*ide_cd_get(struct gendisk
*disk
)
59 struct cdrom_info
*cd
= NULL
;
61 mutex_lock(&idecd_ref_mutex
);
62 cd
= ide_drv_g(disk
, cdrom_info
);
64 if (ide_device_get(cd
->drive
))
70 mutex_unlock(&idecd_ref_mutex
);
74 static void ide_cd_put(struct cdrom_info
*cd
)
76 ide_drive_t
*drive
= cd
->drive
;
78 mutex_lock(&idecd_ref_mutex
);
80 ide_device_put(drive
);
81 mutex_unlock(&idecd_ref_mutex
);
85 * Generic packet command support and error handling routines.
88 /* Mark that we've seen a media change and invalidate our internal buffers. */
89 static void cdrom_saw_media_change(ide_drive_t
*drive
)
91 drive
->dev_flags
|= IDE_DFLAG_MEDIA_CHANGED
;
92 drive
->atapi_flags
&= ~IDE_AFLAG_TOC_VALID
;
95 static int cdrom_log_sense(ide_drive_t
*drive
, struct request
*rq
,
96 struct request_sense
*sense
)
100 ide_debug_log(IDE_DBG_SENSE
, "sense_key: 0x%x", sense
->sense_key
);
102 if (!sense
|| !rq
|| (rq
->cmd_flags
& REQ_QUIET
))
105 switch (sense
->sense_key
) {
107 case RECOVERED_ERROR
:
111 * don't care about tray state messages for e.g. capacity
112 * commands or in-progress or becoming ready
114 if (sense
->asc
== 0x3a || sense
->asc
== 0x04)
118 case ILLEGAL_REQUEST
:
120 * don't log START_STOP unit with LoEj set, since we cannot
121 * reliably check if drive can auto-close
123 if (rq
->cmd
[0] == GPCMD_START_STOP_UNIT
&& sense
->asc
== 0x24)
129 * Make good and sure we've seen this potential media change.
130 * Some drives (i.e. Creative) fail to present the correct sense
131 * key in the error register.
133 cdrom_saw_media_change(drive
);
142 static void cdrom_analyze_sense_data(ide_drive_t
*drive
,
143 struct request
*failed_command
,
144 struct request_sense
*sense
)
146 unsigned long sector
;
147 unsigned long bio_sectors
;
148 struct cdrom_info
*info
= drive
->driver_data
;
150 ide_debug_log(IDE_DBG_SENSE
, "error_code: 0x%x, sense_key: 0x%x",
151 sense
->error_code
, sense
->sense_key
);
154 ide_debug_log(IDE_DBG_SENSE
, "failed cmd: 0x%x",
155 failed_command
->cmd
[0]);
157 if (!cdrom_log_sense(drive
, failed_command
, sense
))
161 * If a read toc is executed for a CD-R or CD-RW medium where the first
162 * toc has not been recorded yet, it will fail with 05/24/00 (which is a
165 if (failed_command
&& failed_command
->cmd
[0] == GPCMD_READ_TOC_PMA_ATIP
)
166 if (sense
->sense_key
== 0x05 && sense
->asc
== 0x24)
170 if (sense
->error_code
== 0x70) {
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 if (drive
->queue
->hardsect_size
== 2048)
186 /* device sector size is 2K */
189 bio_sectors
= max(bio_sectors(failed_command
->bio
), 4U);
190 sector
&= ~(bio_sectors
- 1);
193 * The SCSI specification allows for the value
194 * returned by READ CAPACITY to be up to 75 2K
195 * sectors past the last readable block.
196 * Therefore, if we hit a medium error within the
197 * last 75 2K sectors, we decrease the saved size
200 if (sector
< get_capacity(info
->disk
) &&
201 drive
->probed_capacity
- sector
< 4 * 75)
202 set_capacity(info
->disk
, sector
);
206 ide_cd_log_error(drive
->name
, failed_command
, sense
);
209 static void cdrom_queue_request_sense(ide_drive_t
*drive
, void *sense
,
210 struct request
*failed_command
)
212 struct cdrom_info
*info
= drive
->driver_data
;
213 struct request
*rq
= &drive
->request_sense_rq
;
215 ide_debug_log(IDE_DBG_SENSE
, "enter");
218 sense
= &info
->sense_data
;
220 /* stuff the sense request in front of our current request */
221 blk_rq_init(NULL
, rq
);
222 rq
->cmd_type
= REQ_TYPE_ATA_PC
;
223 rq
->rq_disk
= info
->disk
;
226 rq
->cmd
[0] = GPCMD_REQUEST_SENSE
;
230 rq
->cmd_type
= REQ_TYPE_SENSE
;
231 rq
->cmd_flags
|= REQ_PREEMPT
;
233 /* NOTE! Save the failed command in "rq->buffer" */
234 rq
->buffer
= (void *) failed_command
;
237 ide_debug_log(IDE_DBG_SENSE
, "failed_cmd: 0x%x",
238 failed_command
->cmd
[0]);
240 drive
->hwif
->rq
= NULL
;
242 elv_add_request(drive
->queue
, rq
, ELEVATOR_INSERT_FRONT
, 0);
245 static void cdrom_end_request(ide_drive_t
*drive
, int uptodate
)
247 struct request
*rq
= drive
->hwif
->rq
;
248 int nsectors
= rq
->hard_cur_sectors
;
250 ide_debug_log(IDE_DBG_FUNC
, "cmd: 0x%x, uptodate: 0x%x, nsectors: %d",
251 rq
->cmd
[0], uptodate
, nsectors
);
253 if (blk_sense_request(rq
) && uptodate
) {
255 * For REQ_TYPE_SENSE, "rq->buffer" points to the original
258 struct request
*failed
= (struct request
*) rq
->buffer
;
259 struct cdrom_info
*info
= drive
->driver_data
;
260 void *sense
= &info
->sense_data
;
264 sense
= failed
->sense
;
265 failed
->sense_len
= rq
->sense_len
;
267 cdrom_analyze_sense_data(drive
, failed
, sense
);
269 if (ide_end_rq(drive
, failed
, -EIO
,
270 blk_rq_bytes(failed
)))
273 cdrom_analyze_sense_data(drive
, NULL
, sense
);
276 if (!rq
->current_nr_sectors
&& blk_fs_request(rq
))
278 /* make sure it's fully ended */
279 if (blk_pc_request(rq
))
280 nsectors
= (rq
->data_len
+ 511) >> 9;
284 ide_debug_log(IDE_DBG_FUNC
, "uptodate: 0x%x, nsectors: %d",
287 if (blk_fs_request(rq
) == 0 && uptodate
<= 0 && rq
->errors
== 0)
290 ide_complete_rq(drive
, uptodate
? 0 : -EIO
, nsectors
<< 9);
293 static void ide_dump_status_no_sense(ide_drive_t
*drive
, const char *msg
, u8 st
)
297 ide_dump_status(drive
, msg
, st
);
302 * 0: if the request should be continued.
303 * 1: if the request was ended.
305 static int cdrom_decode_status(ide_drive_t
*drive
, int good_stat
, int *stat_ret
)
307 ide_hwif_t
*hwif
= drive
->hwif
;
308 struct request
*rq
= hwif
->rq
;
309 int stat
, err
, sense_key
;
311 /* check for errors */
312 stat
= hwif
->tp_ops
->read_status(hwif
);
317 if (OK_STAT(stat
, good_stat
, BAD_R_STAT
))
320 /* get the IDE error register */
321 err
= ide_read_error(drive
);
322 sense_key
= err
>> 4;
324 ide_debug_log(IDE_DBG_RQ
, "stat: 0x%x, good_stat: 0x%x, cmd[0]: 0x%x, "
325 "rq->cmd_type: 0x%x, err: 0x%x",
326 stat
, good_stat
, rq
->cmd
[0], rq
->cmd_type
,
329 if (blk_sense_request(rq
)) {
331 * We got an error trying to get sense info from the drive
332 * (probably while trying to recover from a former error).
335 rq
->cmd_flags
|= REQ_FAILED
;
336 cdrom_end_request(drive
, 0);
337 ide_error(drive
, "request sense failure", stat
);
340 } else if (blk_pc_request(rq
) || rq
->cmd_type
== REQ_TYPE_ATA_PC
) {
341 /* All other functions, except for READ. */
344 * if we have an error, pass back CHECK_CONDITION as the
347 if (blk_pc_request(rq
) && !rq
->errors
)
348 rq
->errors
= SAM_STAT_CHECK_CONDITION
;
350 /* check for tray open */
351 if (sense_key
== NOT_READY
) {
352 cdrom_saw_media_change(drive
);
353 } else if (sense_key
== UNIT_ATTENTION
) {
354 /* check for media change */
355 cdrom_saw_media_change(drive
);
357 } else if (sense_key
== ILLEGAL_REQUEST
&&
358 rq
->cmd
[0] == GPCMD_START_STOP_UNIT
) {
360 * Don't print error message for this condition--
361 * SFF8090i indicates that 5/24/00 is the correct
362 * response to a request to close the tray if the
363 * drive doesn't have that capability.
364 * cdrom_log_sense() knows this!
366 } else if (!(rq
->cmd_flags
& REQ_QUIET
)) {
367 /* otherwise, print an error */
368 ide_dump_status(drive
, "packet command error", stat
);
371 rq
->cmd_flags
|= REQ_FAILED
;
374 * instead of playing games with moving completions around,
375 * remove failed request completely and end it when the
376 * request sense has completed
380 } else if (blk_fs_request(rq
)) {
381 int do_end_request
= 0;
383 /* handle errors from READ and WRITE requests */
385 if (blk_noretry_request(rq
))
388 if (sense_key
== NOT_READY
) {
390 if (rq_data_dir(rq
) == READ
) {
391 cdrom_saw_media_change(drive
);
393 /* fail the request */
394 printk(KERN_ERR PFX
"%s: tray open\n",
398 struct cdrom_info
*info
= drive
->driver_data
;
401 * Allow the drive 5 seconds to recover, some
402 * devices will return this error while flushing
406 info
->write_timeout
= jiffies
+
407 ATAPI_WAIT_WRITE_BUSY
;
409 if (time_after(jiffies
, info
->write_timeout
))
412 struct request_queue
*q
= drive
->queue
;
416 * take a breather relying on the unplug
417 * timer to kick us again
419 spin_lock_irqsave(q
->queue_lock
, flags
);
421 spin_unlock_irqrestore(q
->queue_lock
, flags
);
426 } else if (sense_key
== UNIT_ATTENTION
) {
428 cdrom_saw_media_change(drive
);
431 * Arrange to retry the request but be sure to give up
432 * if we've retried too many times.
434 if (++rq
->errors
> ERROR_MAX
)
436 } else if (sense_key
== ILLEGAL_REQUEST
||
437 sense_key
== DATA_PROTECT
) {
439 * No point in retrying after an illegal request or data
442 ide_dump_status_no_sense(drive
, "command error", stat
);
444 } else if (sense_key
== MEDIUM_ERROR
) {
446 * No point in re-trying a zillion times on a bad
447 * sector. If we got here the error is not correctable.
449 ide_dump_status_no_sense(drive
,
450 "media error (bad sector)",
453 } else if (sense_key
== BLANK_CHECK
) {
454 /* disk appears blank ?? */
455 ide_dump_status_no_sense(drive
, "media error (blank)",
458 } else if ((err
& ~ATA_ABORTED
) != 0) {
459 /* go to the default handler for other errors */
460 ide_error(drive
, "cdrom_decode_status", stat
);
462 } else if ((++rq
->errors
> ERROR_MAX
)) {
463 /* we've racked up too many retries, abort */
468 * End a request through request sense analysis when we have
469 * sense data. We need this in order to perform end of media
476 * If we got a CHECK_CONDITION status, queue
477 * a request sense command.
480 cdrom_queue_request_sense(drive
, NULL
, NULL
);
482 blk_dump_rq_flags(rq
, PFX
"bad rq");
483 cdrom_end_request(drive
, 0);
486 /* retry, or handle the next request */
490 if (stat
& ATA_ERR
) {
491 struct request_queue
*q
= drive
->queue
;
494 spin_lock_irqsave(q
->queue_lock
, flags
);
495 blkdev_dequeue_request(rq
);
496 spin_unlock_irqrestore(q
->queue_lock
, flags
);
500 cdrom_queue_request_sense(drive
, rq
->sense
, rq
);
502 cdrom_end_request(drive
, 0);
508 * Check the contents of the interrupt reason register from the cdrom
509 * and attempt to recover if there are problems. Returns 0 if everything's
510 * ok; nonzero if the request has been terminated.
512 static int ide_cd_check_ireason(ide_drive_t
*drive
, struct request
*rq
,
513 int len
, int ireason
, int rw
)
515 ide_hwif_t
*hwif
= drive
->hwif
;
517 ide_debug_log(IDE_DBG_FUNC
, "ireason: 0x%x, rw: 0x%x", ireason
, rw
);
520 * ireason == 0: the drive wants to receive data from us
521 * ireason == 2: the drive is expecting to transfer data to us
523 if (ireason
== (!rw
<< 1))
525 else if (ireason
== (rw
<< 1)) {
528 printk(KERN_ERR PFX
"%s: %s: wrong transfer direction!\n",
529 drive
->name
, __func__
);
531 ide_pad_transfer(drive
, rw
, len
);
532 } else if (rw
== 0 && ireason
== 1) {
534 * Some drives (ASUS) seem to tell us that status info is
535 * available. Just get it and ignore.
537 (void)hwif
->tp_ops
->read_status(hwif
);
540 /* drive wants a command packet, or invalid ireason... */
541 printk(KERN_ERR PFX
"%s: %s: bad interrupt reason 0x%02x\n",
542 drive
->name
, __func__
, ireason
);
545 if (rq
->cmd_type
== REQ_TYPE_ATA_PC
)
546 rq
->cmd_flags
|= REQ_FAILED
;
548 cdrom_end_request(drive
, 0);
553 * Assume that the drive will always provide data in multiples of at least
554 * SECTOR_SIZE, as it gets hairy to keep track of the transfers otherwise.
556 static int ide_cd_check_transfer_size(ide_drive_t
*drive
, int len
)
558 ide_debug_log(IDE_DBG_FUNC
, "len: %d", len
);
560 if ((len
% SECTOR_SIZE
) == 0)
563 printk(KERN_ERR PFX
"%s: %s: Bad transfer size %d\n", drive
->name
,
566 if (drive
->atapi_flags
& IDE_AFLAG_LIMIT_NFRAMES
)
567 printk(KERN_ERR PFX
"This drive is not supported by this "
568 "version of the driver\n");
570 printk(KERN_ERR PFX
"Trying to limit transfer sizes\n");
571 drive
->atapi_flags
|= IDE_AFLAG_LIMIT_NFRAMES
;
577 static ide_startstop_t
ide_cd_prepare_rw_request(ide_drive_t
*drive
,
580 ide_debug_log(IDE_DBG_RQ
, "rq->cmd_flags: 0x%x", rq
->cmd_flags
);
582 if (rq_data_dir(rq
) == READ
) {
583 unsigned short sectors_per_frame
=
584 queue_hardsect_size(drive
->queue
) >> SECTOR_BITS
;
585 int nskip
= rq
->sector
& (sectors_per_frame
- 1);
588 * If the requested sector doesn't start on a frame boundary,
589 * we must adjust the start of the transfer so that it does,
590 * and remember to skip the first few sectors.
592 * If the rq->current_nr_sectors field is larger than the size
593 * of the buffer, it will mean that we're to skip a number of
594 * sectors equal to the amount by which rq->current_nr_sectors
595 * is larger than the buffer size.
598 /* sanity check... */
599 if (rq
->current_nr_sectors
!=
600 bio_cur_sectors(rq
->bio
)) {
601 printk(KERN_ERR PFX
"%s: %s: buffer botch (%u)\n",
602 drive
->name
, __func__
,
603 rq
->current_nr_sectors
);
604 cdrom_end_request(drive
, 0);
607 rq
->current_nr_sectors
+= nskip
;
611 /* set up the command */
612 rq
->timeout
= ATAPI_WAIT_PC
;
618 * Fix up a possibly partially-processed request so that we can start it over
619 * entirely, or even put it back on the request queue.
621 static void ide_cd_restore_request(ide_drive_t
*drive
, struct request
*rq
)
624 ide_debug_log(IDE_DBG_FUNC
, "enter");
626 if (rq
->buffer
!= bio_data(rq
->bio
)) {
628 (rq
->buffer
- (char *)bio_data(rq
->bio
)) / SECTOR_SIZE
;
630 rq
->buffer
= bio_data(rq
->bio
);
634 rq
->current_nr_sectors
= bio_cur_sectors(rq
->bio
);
635 rq
->hard_cur_sectors
= rq
->current_nr_sectors
;
636 rq
->hard_nr_sectors
= rq
->nr_sectors
;
637 rq
->hard_sector
= rq
->sector
;
638 rq
->q
->prep_rq_fn(rq
->q
, rq
);
641 static void ide_cd_request_sense_fixup(ide_drive_t
*drive
, struct request
*rq
)
643 ide_debug_log(IDE_DBG_FUNC
, "rq->cmd[0]: 0x%x", rq
->cmd
[0]);
646 * Some of the trailing request sense fields are optional,
647 * and some drives don't send them. Sigh.
649 if (rq
->cmd
[0] == GPCMD_REQUEST_SENSE
&&
650 rq
->data_len
> 0 && rq
->data_len
<= 5)
651 while (rq
->data_len
> 0) {
652 *(u8
*)rq
->data
++ = 0;
657 int ide_cd_queue_pc(ide_drive_t
*drive
, const unsigned char *cmd
,
658 int write
, void *buffer
, unsigned *bufflen
,
659 struct request_sense
*sense
, int timeout
,
660 unsigned int cmd_flags
)
662 struct cdrom_info
*info
= drive
->driver_data
;
663 struct request_sense local_sense
;
665 unsigned int flags
= 0;
668 sense
= &local_sense
;
670 ide_debug_log(IDE_DBG_PC
, "cmd[0]: 0x%x, write: 0x%x, timeout: %d, "
672 cmd
[0], write
, timeout
, cmd_flags
);
674 /* start of retry loop */
679 rq
= blk_get_request(drive
->queue
, write
, __GFP_WAIT
);
681 memcpy(rq
->cmd
, cmd
, BLK_MAX_CDB
);
682 rq
->cmd_type
= REQ_TYPE_ATA_PC
;
684 rq
->cmd_flags
|= cmd_flags
;
685 rq
->timeout
= timeout
;
688 rq
->data_len
= *bufflen
;
691 error
= blk_execute_rq(drive
->queue
, info
->disk
, rq
, 0);
694 *bufflen
= rq
->data_len
;
696 flags
= rq
->cmd_flags
;
700 * FIXME: we should probably abort/retry or something in case of
703 if (flags
& REQ_FAILED
) {
705 * The request failed. Retry if it was due to a unit
706 * attention status (usually means media was changed).
708 struct request_sense
*reqbuf
= sense
;
710 if (reqbuf
->sense_key
== UNIT_ATTENTION
)
711 cdrom_saw_media_change(drive
);
712 else if (reqbuf
->sense_key
== NOT_READY
&&
713 reqbuf
->asc
== 4 && reqbuf
->ascq
!= 4) {
715 * The drive is in the process of loading
716 * a disk. Retry, but wait a little to give
717 * the drive time to complete the load.
721 /* otherwise, don't retry */
727 /* end of retry loop */
728 } while ((flags
& REQ_FAILED
) && retries
>= 0);
730 /* return an error if the command failed */
731 return (flags
& REQ_FAILED
) ? -EIO
: 0;
735 * Called from blk_end_request_callback() after the data of the request is
736 * completed and before the request itself is completed. By returning value '1',
737 * blk_end_request_callback() returns immediately without completing it.
739 static int cdrom_newpc_intr_dummy_cb(struct request
*rq
)
744 static ide_startstop_t
cdrom_newpc_intr(ide_drive_t
*drive
)
746 ide_hwif_t
*hwif
= drive
->hwif
;
747 struct request
*rq
= hwif
->rq
;
748 xfer_func_t
*xferfunc
;
749 ide_expiry_t
*expiry
= NULL
;
750 int dma_error
= 0, dma
, stat
, thislen
, uptodate
= 0;
751 int write
= (rq_data_dir(rq
) == WRITE
) ? 1 : 0;
752 unsigned int timeout
;
756 ide_debug_log(IDE_DBG_PC
, "cmd[0]: 0x%x, write: 0x%x",
759 /* check for errors */
763 dma_error
= hwif
->dma_ops
->dma_end(drive
);
765 printk(KERN_ERR PFX
"%s: DMA %s error\n", drive
->name
,
766 write
? "write" : "read");
771 if (cdrom_decode_status(drive
, 0, &stat
))
774 /* using dma, transfer is complete now */
777 return ide_error(drive
, "dma error", stat
);
778 if (blk_fs_request(rq
)) {
779 ide_complete_rq(drive
, 0, rq
->nr_sectors
780 ? (rq
->nr_sectors
<< 9) : ide_rq_bytes(rq
));
782 } else if (rq
->cmd_type
== REQ_TYPE_ATA_PC
&& !rq
->bio
) {
783 ide_complete_rq(drive
, 0, 512);
789 ide_read_bcount_and_ireason(drive
, &len
, &ireason
);
791 thislen
= blk_fs_request(rq
) ? len
: rq
->data_len
;
795 ide_debug_log(IDE_DBG_PC
, "DRQ: stat: 0x%x, thislen: %d",
798 /* If DRQ is clear, the command has completed. */
799 if ((stat
& ATA_DRQ
) == 0) {
800 if (blk_fs_request(rq
)) {
802 * If we're not done reading/writing, complain.
803 * Otherwise, complete the command normally.
806 if (rq
->current_nr_sectors
> 0) {
807 printk(KERN_ERR PFX
"%s: %s: data underrun "
809 drive
->name
, __func__
,
810 rq
->current_nr_sectors
);
812 rq
->cmd_flags
|= REQ_FAILED
;
815 cdrom_end_request(drive
, uptodate
);
817 } else if (!blk_pc_request(rq
)) {
818 ide_cd_request_sense_fixup(drive
, rq
);
819 /* complain if we still have data left to transfer */
820 uptodate
= rq
->data_len
? 0 : 1;
825 /* check which way to transfer data */
826 if (ide_cd_check_ireason(drive
, rq
, len
, ireason
, write
))
829 if (blk_fs_request(rq
)) {
833 if (ide_cd_check_transfer_size(drive
, len
)) {
834 cdrom_end_request(drive
, 0);
839 * First, figure out if we need to bit-bucket
840 * any of the leading sectors.
842 nskip
= min_t(int, rq
->current_nr_sectors
843 - bio_cur_sectors(rq
->bio
),
846 ide_pad_transfer(drive
, write
, nskip
<< 9);
847 rq
->current_nr_sectors
-= nskip
;
848 thislen
-= (nskip
<< 9);
855 xferfunc
= hwif
->tp_ops
->output_data
;
858 xferfunc
= hwif
->tp_ops
->input_data
;
861 ide_debug_log(IDE_DBG_PC
, "data transfer, rq->cmd_type: 0x%x, "
863 rq
->cmd_type
, ireason
);
866 while (thislen
> 0) {
867 u8
*ptr
= blk_fs_request(rq
) ? NULL
: rq
->data
;
868 int blen
= rq
->data_len
;
872 if (blk_fs_request(rq
)) {
874 blen
= rq
->current_nr_sectors
<< 9;
876 ptr
= bio_data(rq
->bio
);
877 blen
= bio_iovec(rq
->bio
)->bv_len
;
882 if (blk_fs_request(rq
) && !write
)
884 * If the buffers are full, pipe the rest into
887 ide_pad_transfer(drive
, 0, thislen
);
889 printk(KERN_ERR PFX
"%s: confused, missing data\n",
891 blk_dump_rq_flags(rq
, rq_data_dir(rq
)
892 ? "cdrom_newpc_intr, write"
893 : "cdrom_newpc_intr, read");
901 xferfunc(drive
, NULL
, ptr
, blen
);
906 if (blk_fs_request(rq
)) {
908 rq
->nr_sectors
-= (blen
>> 9);
909 rq
->current_nr_sectors
-= (blen
>> 9);
910 rq
->sector
+= (blen
>> 9);
912 if (rq
->current_nr_sectors
== 0 && rq
->nr_sectors
)
913 cdrom_end_request(drive
, 1);
915 rq
->data_len
-= blen
;
918 * The request can't be completed until DRQ is cleared.
919 * So complete the data, but don't complete the request
920 * using the dummy function for the callback feature
921 * of blk_end_request_callback().
924 blk_end_request_callback(rq
, 0, blen
,
925 cdrom_newpc_intr_dummy_cb
);
929 if (!write
&& blk_sense_request(rq
))
930 rq
->sense_len
+= blen
;
933 /* pad, if necessary */
934 if (!blk_fs_request(rq
) && len
> 0)
935 ide_pad_transfer(drive
, write
, len
);
937 if (blk_pc_request(rq
)) {
938 timeout
= rq
->timeout
;
940 timeout
= ATAPI_WAIT_PC
;
941 if (!blk_fs_request(rq
))
942 expiry
= ide_cd_expiry
;
945 hwif
->expiry
= expiry
;
946 ide_set_handler(drive
, cdrom_newpc_intr
, timeout
);
950 if (blk_pc_request(rq
)) {
951 unsigned int dlen
= rq
->data_len
;
956 if (blk_end_request(rq
, 0, dlen
))
962 rq
->cmd_flags
|= REQ_FAILED
;
963 cdrom_end_request(drive
, uptodate
);
968 static ide_startstop_t
cdrom_start_rw(ide_drive_t
*drive
, struct request
*rq
)
970 struct cdrom_info
*cd
= drive
->driver_data
;
971 int write
= rq_data_dir(rq
) == WRITE
;
972 unsigned short sectors_per_frame
=
973 queue_hardsect_size(drive
->queue
) >> SECTOR_BITS
;
975 ide_debug_log(IDE_DBG_RQ
, "rq->cmd[0]: 0x%x, write: 0x%x, "
976 "secs_per_frame: %u",
977 rq
->cmd
[0], write
, sectors_per_frame
);
980 /* disk has become write protected */
981 if (get_disk_ro(cd
->disk
)) {
982 cdrom_end_request(drive
, 0);
987 * We may be retrying this request after an error. Fix up any
988 * weirdness which might be present in the request packet.
990 ide_cd_restore_request(drive
, rq
);
993 /* use DMA, if possible / writes *must* be hardware frame aligned */
994 if ((rq
->nr_sectors
& (sectors_per_frame
- 1)) ||
995 (rq
->sector
& (sectors_per_frame
- 1))) {
997 cdrom_end_request(drive
, 0);
1002 drive
->dma
= !!(drive
->dev_flags
& IDE_DFLAG_USING_DMA
);
1005 cd
->devinfo
.media_written
= 1;
1010 static void cdrom_do_block_pc(ide_drive_t
*drive
, struct request
*rq
)
1013 ide_debug_log(IDE_DBG_PC
, "rq->cmd[0]: 0x%x, rq->cmd_type: 0x%x",
1014 rq
->cmd
[0], rq
->cmd_type
);
1016 if (blk_pc_request(rq
))
1017 rq
->cmd_flags
|= REQ_QUIET
;
1019 rq
->cmd_flags
&= ~REQ_FAILED
;
1024 if (rq
->bio
|| ((rq
->cmd_type
== REQ_TYPE_ATA_PC
) && rq
->data_len
)) {
1025 struct request_queue
*q
= drive
->queue
;
1026 unsigned int alignment
;
1030 buf
= bio_data(rq
->bio
);
1034 drive
->dma
= !!(drive
->dev_flags
& IDE_DFLAG_USING_DMA
);
1037 * check if dma is safe
1039 * NOTE! The "len" and "addr" checks should possibly have
1042 alignment
= queue_dma_alignment(q
) | q
->dma_pad_mask
;
1043 if ((unsigned long)buf
& alignment
1044 || rq
->data_len
& q
->dma_pad_mask
1045 || object_is_on_stack(buf
))
1050 static ide_startstop_t
ide_cd_do_request(ide_drive_t
*drive
, struct request
*rq
,
1055 ide_debug_log(IDE_DBG_RQ
, "cmd: 0x%x, block: %llu",
1056 rq
->cmd
[0], (unsigned long long)block
);
1058 if (drive
->debug_mask
& IDE_DBG_RQ
)
1059 blk_dump_rq_flags(rq
, "ide_cd_do_request");
1061 if (blk_fs_request(rq
)) {
1062 if (cdrom_start_rw(drive
, rq
) == ide_stopped
)
1065 if (ide_cd_prepare_rw_request(drive
, rq
) == ide_stopped
)
1067 } else if (blk_sense_request(rq
) || blk_pc_request(rq
) ||
1068 rq
->cmd_type
== REQ_TYPE_ATA_PC
) {
1070 rq
->timeout
= ATAPI_WAIT_PC
;
1072 cdrom_do_block_pc(drive
, rq
);
1073 } else if (blk_special_request(rq
)) {
1074 /* right now this can only be a reset... */
1075 cdrom_end_request(drive
, 1);
1078 blk_dump_rq_flags(rq
, DRV_NAME
" bad flags");
1079 cdrom_end_request(drive
, 0);
1083 memset(&cmd
, 0, sizeof(cmd
));
1085 if (rq_data_dir(rq
))
1086 cmd
.tf_flags
|= IDE_TFLAG_WRITE
;
1090 return ide_issue_pc(drive
, &cmd
);
1096 * Routines which queue packet commands take as a final argument a pointer to a
1097 * request_sense struct. If execution of the command results in an error with a
1098 * CHECK CONDITION status, this structure will be filled with the results of the
1099 * subsequent request sense command. The pointer can also be NULL, in which case
1100 * no sense information is returned.
1102 static void msf_from_bcd(struct atapi_msf
*msf
)
1104 msf
->minute
= bcd2bin(msf
->minute
);
1105 msf
->second
= bcd2bin(msf
->second
);
1106 msf
->frame
= bcd2bin(msf
->frame
);
1109 int cdrom_check_status(ide_drive_t
*drive
, struct request_sense
*sense
)
1111 struct cdrom_info
*info
= drive
->driver_data
;
1112 struct cdrom_device_info
*cdi
= &info
->devinfo
;
1113 unsigned char cmd
[BLK_MAX_CDB
];
1115 ide_debug_log(IDE_DBG_FUNC
, "enter");
1117 memset(cmd
, 0, BLK_MAX_CDB
);
1118 cmd
[0] = GPCMD_TEST_UNIT_READY
;
1121 * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to switch CDs
1122 * instead of supporting the LOAD_UNLOAD opcode.
1124 cmd
[7] = cdi
->sanyo_slot
% 3;
1126 return ide_cd_queue_pc(drive
, cmd
, 0, NULL
, NULL
, sense
, 0, REQ_QUIET
);
1129 static int cdrom_read_capacity(ide_drive_t
*drive
, unsigned long *capacity
,
1130 unsigned long *sectors_per_frame
,
1131 struct request_sense
*sense
)
1139 unsigned char cmd
[BLK_MAX_CDB
];
1140 unsigned len
= sizeof(capbuf
);
1143 ide_debug_log(IDE_DBG_FUNC
, "enter");
1145 memset(cmd
, 0, BLK_MAX_CDB
);
1146 cmd
[0] = GPCMD_READ_CDVD_CAPACITY
;
1148 stat
= ide_cd_queue_pc(drive
, cmd
, 0, &capbuf
, &len
, sense
, 0,
1154 * Sanity check the given block size
1156 blocklen
= be32_to_cpu(capbuf
.blocklen
);
1164 printk(KERN_ERR PFX
"%s: weird block size %u\n",
1165 drive
->name
, blocklen
);
1166 printk(KERN_ERR PFX
"%s: default to 2kb block size\n",
1172 *capacity
= 1 + be32_to_cpu(capbuf
.lba
);
1173 *sectors_per_frame
= blocklen
>> SECTOR_BITS
;
1175 ide_debug_log(IDE_DBG_PROBE
, "cap: %lu, sectors_per_frame: %lu",
1176 *capacity
, *sectors_per_frame
);
1181 static int cdrom_read_tocentry(ide_drive_t
*drive
, int trackno
, int msf_flag
,
1182 int format
, char *buf
, int buflen
,
1183 struct request_sense
*sense
)
1185 unsigned char cmd
[BLK_MAX_CDB
];
1187 ide_debug_log(IDE_DBG_FUNC
, "enter");
1189 memset(cmd
, 0, BLK_MAX_CDB
);
1191 cmd
[0] = GPCMD_READ_TOC_PMA_ATIP
;
1193 cmd
[7] = (buflen
>> 8);
1194 cmd
[8] = (buflen
& 0xff);
1195 cmd
[9] = (format
<< 6);
1200 return ide_cd_queue_pc(drive
, cmd
, 0, buf
, &buflen
, sense
, 0, REQ_QUIET
);
1203 /* Try to read the entire TOC for the disk into our internal buffer. */
1204 int ide_cd_read_toc(ide_drive_t
*drive
, struct request_sense
*sense
)
1206 int stat
, ntracks
, i
;
1207 struct cdrom_info
*info
= drive
->driver_data
;
1208 struct cdrom_device_info
*cdi
= &info
->devinfo
;
1209 struct atapi_toc
*toc
= info
->toc
;
1211 struct atapi_toc_header hdr
;
1212 struct atapi_toc_entry ent
;
1215 unsigned long sectors_per_frame
= SECTORS_PER_FRAME
;
1217 ide_debug_log(IDE_DBG_FUNC
, "enter");
1220 /* try to allocate space */
1221 toc
= kmalloc(sizeof(struct atapi_toc
), GFP_KERNEL
);
1223 printk(KERN_ERR PFX
"%s: No cdrom TOC buffer!\n",
1231 * Check to see if the existing data is still valid. If it is,
1234 (void) cdrom_check_status(drive
, sense
);
1236 if (drive
->atapi_flags
& IDE_AFLAG_TOC_VALID
)
1239 /* try to get the total cdrom capacity and sector size */
1240 stat
= cdrom_read_capacity(drive
, &toc
->capacity
, §ors_per_frame
,
1243 toc
->capacity
= 0x1fffff;
1245 set_capacity(info
->disk
, toc
->capacity
* sectors_per_frame
);
1246 /* save a private copy of the TOC capacity for error handling */
1247 drive
->probed_capacity
= toc
->capacity
* sectors_per_frame
;
1249 blk_queue_hardsect_size(drive
->queue
,
1250 sectors_per_frame
<< SECTOR_BITS
);
1252 /* first read just the header, so we know how long the TOC is */
1253 stat
= cdrom_read_tocentry(drive
, 0, 1, 0, (char *) &toc
->hdr
,
1254 sizeof(struct atapi_toc_header
), sense
);
1258 if (drive
->atapi_flags
& IDE_AFLAG_TOCTRACKS_AS_BCD
) {
1259 toc
->hdr
.first_track
= bcd2bin(toc
->hdr
.first_track
);
1260 toc
->hdr
.last_track
= bcd2bin(toc
->hdr
.last_track
);
1263 ntracks
= toc
->hdr
.last_track
- toc
->hdr
.first_track
+ 1;
1266 if (ntracks
> MAX_TRACKS
)
1267 ntracks
= MAX_TRACKS
;
1269 /* now read the whole schmeer */
1270 stat
= cdrom_read_tocentry(drive
, toc
->hdr
.first_track
, 1, 0,
1272 sizeof(struct atapi_toc_header
) +
1274 sizeof(struct atapi_toc_entry
), sense
);
1276 if (stat
&& toc
->hdr
.first_track
> 1) {
1278 * Cds with CDI tracks only don't have any TOC entries, despite
1279 * of this the returned values are
1280 * first_track == last_track = number of CDI tracks + 1,
1281 * so that this case is indistinguishable from the same layout
1282 * plus an additional audio track. If we get an error for the
1283 * regular case, we assume a CDI without additional audio
1284 * tracks. In this case the readable TOC is empty (CDI tracks
1285 * are not included) and only holds the Leadout entry.
1290 stat
= cdrom_read_tocentry(drive
, CDROM_LEADOUT
, 1, 0,
1292 sizeof(struct atapi_toc_header
) +
1294 sizeof(struct atapi_toc_entry
),
1299 if (drive
->atapi_flags
& IDE_AFLAG_TOCTRACKS_AS_BCD
) {
1300 toc
->hdr
.first_track
= (u8
)bin2bcd(CDROM_LEADOUT
);
1301 toc
->hdr
.last_track
= (u8
)bin2bcd(CDROM_LEADOUT
);
1303 toc
->hdr
.first_track
= CDROM_LEADOUT
;
1304 toc
->hdr
.last_track
= CDROM_LEADOUT
;
1311 toc
->hdr
.toc_length
= be16_to_cpu(toc
->hdr
.toc_length
);
1313 if (drive
->atapi_flags
& IDE_AFLAG_TOCTRACKS_AS_BCD
) {
1314 toc
->hdr
.first_track
= bcd2bin(toc
->hdr
.first_track
);
1315 toc
->hdr
.last_track
= bcd2bin(toc
->hdr
.last_track
);
1318 for (i
= 0; i
<= ntracks
; i
++) {
1319 if (drive
->atapi_flags
& IDE_AFLAG_TOCADDR_AS_BCD
) {
1320 if (drive
->atapi_flags
& IDE_AFLAG_TOCTRACKS_AS_BCD
)
1321 toc
->ent
[i
].track
= bcd2bin(toc
->ent
[i
].track
);
1322 msf_from_bcd(&toc
->ent
[i
].addr
.msf
);
1324 toc
->ent
[i
].addr
.lba
= msf_to_lba(toc
->ent
[i
].addr
.msf
.minute
,
1325 toc
->ent
[i
].addr
.msf
.second
,
1326 toc
->ent
[i
].addr
.msf
.frame
);
1329 if (toc
->hdr
.first_track
!= CDROM_LEADOUT
) {
1330 /* read the multisession information */
1331 stat
= cdrom_read_tocentry(drive
, 0, 0, 1, (char *)&ms_tmp
,
1332 sizeof(ms_tmp
), sense
);
1336 toc
->last_session_lba
= be32_to_cpu(ms_tmp
.ent
.addr
.lba
);
1338 ms_tmp
.hdr
.last_track
= CDROM_LEADOUT
;
1339 ms_tmp
.hdr
.first_track
= ms_tmp
.hdr
.last_track
;
1340 toc
->last_session_lba
= msf_to_lba(0, 2, 0); /* 0m 2s 0f */
1343 if (drive
->atapi_flags
& IDE_AFLAG_TOCADDR_AS_BCD
) {
1344 /* re-read multisession information using MSF format */
1345 stat
= cdrom_read_tocentry(drive
, 0, 1, 1, (char *)&ms_tmp
,
1346 sizeof(ms_tmp
), sense
);
1350 msf_from_bcd(&ms_tmp
.ent
.addr
.msf
);
1351 toc
->last_session_lba
= msf_to_lba(ms_tmp
.ent
.addr
.msf
.minute
,
1352 ms_tmp
.ent
.addr
.msf
.second
,
1353 ms_tmp
.ent
.addr
.msf
.frame
);
1356 toc
->xa_flag
= (ms_tmp
.hdr
.first_track
!= ms_tmp
.hdr
.last_track
);
1358 /* now try to get the total cdrom capacity */
1359 stat
= cdrom_get_last_written(cdi
, &last_written
);
1360 if (!stat
&& (last_written
> toc
->capacity
)) {
1361 toc
->capacity
= last_written
;
1362 set_capacity(info
->disk
, toc
->capacity
* sectors_per_frame
);
1363 drive
->probed_capacity
= toc
->capacity
* sectors_per_frame
;
1366 /* Remember that we've read this stuff. */
1367 drive
->atapi_flags
|= IDE_AFLAG_TOC_VALID
;
1372 int ide_cdrom_get_capabilities(ide_drive_t
*drive
, u8
*buf
)
1374 struct cdrom_info
*info
= drive
->driver_data
;
1375 struct cdrom_device_info
*cdi
= &info
->devinfo
;
1376 struct packet_command cgc
;
1377 int stat
, attempts
= 3, size
= ATAPI_CAPABILITIES_PAGE_SIZE
;
1379 ide_debug_log(IDE_DBG_FUNC
, "enter");
1381 if ((drive
->atapi_flags
& IDE_AFLAG_FULL_CAPS_PAGE
) == 0)
1382 size
-= ATAPI_CAPABILITIES_PAGE_PAD_SIZE
;
1384 init_cdrom_command(&cgc
, buf
, size
, CGC_DATA_UNKNOWN
);
1386 /* we seem to get stat=0x01,err=0x00 the first time (??) */
1387 stat
= cdrom_mode_sense(cdi
, &cgc
, GPMODE_CAPABILITIES_PAGE
, 0);
1390 } while (--attempts
);
1394 void ide_cdrom_update_speed(ide_drive_t
*drive
, u8
*buf
)
1396 struct cdrom_info
*cd
= drive
->driver_data
;
1397 u16 curspeed
, maxspeed
;
1399 ide_debug_log(IDE_DBG_FUNC
, "enter");
1401 if (drive
->atapi_flags
& IDE_AFLAG_LE_SPEED_FIELDS
) {
1402 curspeed
= le16_to_cpup((__le16
*)&buf
[8 + 14]);
1403 maxspeed
= le16_to_cpup((__le16
*)&buf
[8 + 8]);
1405 curspeed
= be16_to_cpup((__be16
*)&buf
[8 + 14]);
1406 maxspeed
= be16_to_cpup((__be16
*)&buf
[8 + 8]);
1409 ide_debug_log(IDE_DBG_PROBE
, "curspeed: %u, maxspeed: %u",
1410 curspeed
, maxspeed
);
1412 cd
->current_speed
= (curspeed
+ (176/2)) / 176;
1413 cd
->max_speed
= (maxspeed
+ (176/2)) / 176;
1416 #define IDE_CD_CAPABILITIES \
1417 (CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | CDC_SELECT_SPEED | \
1418 CDC_SELECT_DISC | CDC_MULTI_SESSION | CDC_MCN | CDC_MEDIA_CHANGED | \
1419 CDC_PLAY_AUDIO | CDC_RESET | CDC_DRIVE_STATUS | CDC_CD_R | \
1420 CDC_CD_RW | CDC_DVD | CDC_DVD_R | CDC_DVD_RAM | CDC_GENERIC_PACKET | \
1421 CDC_MO_DRIVE | CDC_MRW | CDC_MRW_W | CDC_RAM)
1423 static struct cdrom_device_ops ide_cdrom_dops
= {
1424 .open
= ide_cdrom_open_real
,
1425 .release
= ide_cdrom_release_real
,
1426 .drive_status
= ide_cdrom_drive_status
,
1427 .media_changed
= ide_cdrom_check_media_change_real
,
1428 .tray_move
= ide_cdrom_tray_move
,
1429 .lock_door
= ide_cdrom_lock_door
,
1430 .select_speed
= ide_cdrom_select_speed
,
1431 .get_last_session
= ide_cdrom_get_last_session
,
1432 .get_mcn
= ide_cdrom_get_mcn
,
1433 .reset
= ide_cdrom_reset
,
1434 .audio_ioctl
= ide_cdrom_audio_ioctl
,
1435 .capability
= IDE_CD_CAPABILITIES
,
1436 .generic_packet
= ide_cdrom_packet
,
1439 static int ide_cdrom_register(ide_drive_t
*drive
, int nslots
)
1441 struct cdrom_info
*info
= drive
->driver_data
;
1442 struct cdrom_device_info
*devinfo
= &info
->devinfo
;
1444 ide_debug_log(IDE_DBG_PROBE
, "nslots: %d", nslots
);
1446 devinfo
->ops
= &ide_cdrom_dops
;
1447 devinfo
->speed
= info
->current_speed
;
1448 devinfo
->capacity
= nslots
;
1449 devinfo
->handle
= drive
;
1450 strcpy(devinfo
->name
, drive
->name
);
1452 if (drive
->atapi_flags
& IDE_AFLAG_NO_SPEED_SELECT
)
1453 devinfo
->mask
|= CDC_SELECT_SPEED
;
1455 devinfo
->disk
= info
->disk
;
1456 return register_cdrom(devinfo
);
1459 static int ide_cdrom_probe_capabilities(ide_drive_t
*drive
)
1461 struct cdrom_info
*cd
= drive
->driver_data
;
1462 struct cdrom_device_info
*cdi
= &cd
->devinfo
;
1463 u8 buf
[ATAPI_CAPABILITIES_PAGE_SIZE
];
1464 mechtype_t mechtype
;
1467 ide_debug_log(IDE_DBG_PROBE
, "media: 0x%x, atapi_flags: 0x%lx",
1468 drive
->media
, drive
->atapi_flags
);
1470 cdi
->mask
= (CDC_CD_R
| CDC_CD_RW
| CDC_DVD
| CDC_DVD_R
|
1471 CDC_DVD_RAM
| CDC_SELECT_DISC
| CDC_PLAY_AUDIO
|
1472 CDC_MO_DRIVE
| CDC_RAM
);
1474 if (drive
->media
== ide_optical
) {
1475 cdi
->mask
&= ~(CDC_MO_DRIVE
| CDC_RAM
);
1476 printk(KERN_ERR PFX
"%s: ATAPI magneto-optical drive\n",
1481 if (drive
->atapi_flags
& IDE_AFLAG_PRE_ATAPI12
) {
1482 drive
->atapi_flags
&= ~IDE_AFLAG_NO_EJECT
;
1483 cdi
->mask
&= ~CDC_PLAY_AUDIO
;
1488 * We have to cheat a little here. the packet will eventually be queued
1489 * with ide_cdrom_packet(), which extracts the drive from cdi->handle.
1490 * Since this device hasn't been registered with the Uniform layer yet,
1491 * it can't do this. Same goes for cdi->ops.
1493 cdi
->handle
= drive
;
1494 cdi
->ops
= &ide_cdrom_dops
;
1496 if (ide_cdrom_get_capabilities(drive
, buf
))
1499 if ((buf
[8 + 6] & 0x01) == 0)
1500 drive
->dev_flags
&= ~IDE_DFLAG_DOORLOCKING
;
1501 if (buf
[8 + 6] & 0x08)
1502 drive
->atapi_flags
&= ~IDE_AFLAG_NO_EJECT
;
1503 if (buf
[8 + 3] & 0x01)
1504 cdi
->mask
&= ~CDC_CD_R
;
1505 if (buf
[8 + 3] & 0x02)
1506 cdi
->mask
&= ~(CDC_CD_RW
| CDC_RAM
);
1507 if (buf
[8 + 2] & 0x38)
1508 cdi
->mask
&= ~CDC_DVD
;
1509 if (buf
[8 + 3] & 0x20)
1510 cdi
->mask
&= ~(CDC_DVD_RAM
| CDC_RAM
);
1511 if (buf
[8 + 3] & 0x10)
1512 cdi
->mask
&= ~CDC_DVD_R
;
1513 if ((buf
[8 + 4] & 0x01) || (drive
->atapi_flags
& IDE_AFLAG_PLAY_AUDIO_OK
))
1514 cdi
->mask
&= ~CDC_PLAY_AUDIO
;
1516 mechtype
= buf
[8 + 6] >> 5;
1517 if (mechtype
== mechtype_caddy
||
1518 mechtype
== mechtype_popup
||
1519 (drive
->atapi_flags
& IDE_AFLAG_NO_AUTOCLOSE
))
1520 cdi
->mask
|= CDC_CLOSE_TRAY
;
1522 if (cdi
->sanyo_slot
> 0) {
1523 cdi
->mask
&= ~CDC_SELECT_DISC
;
1525 } else if (mechtype
== mechtype_individual_changer
||
1526 mechtype
== mechtype_cartridge_changer
) {
1527 nslots
= cdrom_number_of_slots(cdi
);
1529 cdi
->mask
&= ~CDC_SELECT_DISC
;
1532 ide_cdrom_update_speed(drive
, buf
);
1534 printk(KERN_INFO PFX
"%s: ATAPI", drive
->name
);
1536 /* don't print speed if the drive reported 0 */
1538 printk(KERN_CONT
" %dX", cd
->max_speed
);
1540 printk(KERN_CONT
" %s", (cdi
->mask
& CDC_DVD
) ? "CD-ROM" : "DVD-ROM");
1542 if ((cdi
->mask
& CDC_DVD_R
) == 0 || (cdi
->mask
& CDC_DVD_RAM
) == 0)
1543 printk(KERN_CONT
" DVD%s%s",
1544 (cdi
->mask
& CDC_DVD_R
) ? "" : "-R",
1545 (cdi
->mask
& CDC_DVD_RAM
) ? "" : "/RAM");
1547 if ((cdi
->mask
& CDC_CD_R
) == 0 || (cdi
->mask
& CDC_CD_RW
) == 0)
1548 printk(KERN_CONT
" CD%s%s",
1549 (cdi
->mask
& CDC_CD_R
) ? "" : "-R",
1550 (cdi
->mask
& CDC_CD_RW
) ? "" : "/RW");
1552 if ((cdi
->mask
& CDC_SELECT_DISC
) == 0)
1553 printk(KERN_CONT
" changer w/%d slots", nslots
);
1555 printk(KERN_CONT
" drive");
1557 printk(KERN_CONT
", %dkB Cache\n",
1558 be16_to_cpup((__be16
*)&buf
[8 + 12]));
1563 /* standard prep_rq_fn that builds 10 byte cmds */
1564 static int ide_cdrom_prep_fs(struct request_queue
*q
, struct request
*rq
)
1566 int hard_sect
= queue_hardsect_size(q
);
1567 long block
= (long)rq
->hard_sector
/ (hard_sect
>> 9);
1568 unsigned long blocks
= rq
->hard_nr_sectors
/ (hard_sect
>> 9);
1570 memset(rq
->cmd
, 0, BLK_MAX_CDB
);
1572 if (rq_data_dir(rq
) == READ
)
1573 rq
->cmd
[0] = GPCMD_READ_10
;
1575 rq
->cmd
[0] = GPCMD_WRITE_10
;
1580 rq
->cmd
[2] = (block
>> 24) & 0xff;
1581 rq
->cmd
[3] = (block
>> 16) & 0xff;
1582 rq
->cmd
[4] = (block
>> 8) & 0xff;
1583 rq
->cmd
[5] = block
& 0xff;
1586 * and transfer length
1588 rq
->cmd
[7] = (blocks
>> 8) & 0xff;
1589 rq
->cmd
[8] = blocks
& 0xff;
1595 * Most of the SCSI commands are supported directly by ATAPI devices.
1596 * This transform handles the few exceptions.
1598 static int ide_cdrom_prep_pc(struct request
*rq
)
1602 /* transform 6-byte read/write commands to the 10-byte version */
1603 if (c
[0] == READ_6
|| c
[0] == WRITE_6
) {
1610 c
[0] += (READ_10
- READ_6
);
1616 * it's silly to pretend we understand 6-byte sense commands, just
1617 * reject with ILLEGAL_REQUEST and the caller should take the
1618 * appropriate action
1620 if (c
[0] == MODE_SENSE
|| c
[0] == MODE_SELECT
) {
1621 rq
->errors
= ILLEGAL_REQUEST
;
1622 return BLKPREP_KILL
;
1628 static int ide_cdrom_prep_fn(struct request_queue
*q
, struct request
*rq
)
1630 if (blk_fs_request(rq
))
1631 return ide_cdrom_prep_fs(q
, rq
);
1632 else if (blk_pc_request(rq
))
1633 return ide_cdrom_prep_pc(rq
);
1638 struct cd_list_entry
{
1639 const char *id_model
;
1640 const char *id_firmware
;
1641 unsigned int cd_flags
;
1644 #ifdef CONFIG_IDE_PROC_FS
1645 static sector_t
ide_cdrom_capacity(ide_drive_t
*drive
)
1647 unsigned long capacity
, sectors_per_frame
;
1649 if (cdrom_read_capacity(drive
, &capacity
, §ors_per_frame
, NULL
))
1652 return capacity
* sectors_per_frame
;
1655 static int proc_idecd_read_capacity(char *page
, char **start
, off_t off
,
1656 int count
, int *eof
, void *data
)
1658 ide_drive_t
*drive
= data
;
1661 len
= sprintf(page
, "%llu\n", (long long)ide_cdrom_capacity(drive
));
1662 PROC_IDE_READ_RETURN(page
, start
, off
, count
, eof
, len
);
1665 static ide_proc_entry_t idecd_proc
[] = {
1666 { "capacity", S_IFREG
|S_IRUGO
, proc_idecd_read_capacity
, NULL
},
1667 { NULL
, 0, NULL
, NULL
}
1670 static ide_proc_entry_t
*ide_cd_proc_entries(ide_drive_t
*drive
)
1675 static const struct ide_proc_devset
*ide_cd_proc_devsets(ide_drive_t
*drive
)
1681 static const struct cd_list_entry ide_cd_quirks_list
[] = {
1682 /* Limit transfer size per interrupt. */
1683 { "SAMSUNG CD-ROM SCR-2430", NULL
, IDE_AFLAG_LIMIT_NFRAMES
},
1684 { "SAMSUNG CD-ROM SCR-2432", NULL
, IDE_AFLAG_LIMIT_NFRAMES
},
1685 /* SCR-3231 doesn't support the SET_CD_SPEED command. */
1686 { "SAMSUNG CD-ROM SCR-3231", NULL
, IDE_AFLAG_NO_SPEED_SELECT
},
1687 /* Old NEC260 (not R) was released before ATAPI 1.2 spec. */
1688 { "NEC CD-ROM DRIVE:260", "1.01", IDE_AFLAG_TOCADDR_AS_BCD
|
1689 IDE_AFLAG_PRE_ATAPI12
, },
1690 /* Vertos 300, some versions of this drive like to talk BCD. */
1691 { "V003S0DS", NULL
, IDE_AFLAG_VERTOS_300_SSD
, },
1692 /* Vertos 600 ESD. */
1693 { "V006E0DS", NULL
, IDE_AFLAG_VERTOS_600_ESD
, },
1695 * Sanyo 3 CD changer uses a non-standard command for CD changing
1696 * (by default standard ATAPI support for CD changers is used).
1698 { "CD-ROM CDR-C3 G", NULL
, IDE_AFLAG_SANYO_3CD
},
1699 { "CD-ROM CDR-C3G", NULL
, IDE_AFLAG_SANYO_3CD
},
1700 { "CD-ROM CDR_C36", NULL
, IDE_AFLAG_SANYO_3CD
},
1701 /* Stingray 8X CD-ROM. */
1702 { "STINGRAY 8422 IDE 8X CD-ROM 7-27-95", NULL
, IDE_AFLAG_PRE_ATAPI12
},
1704 * ACER 50X CD-ROM and WPI 32X CD-ROM require the full spec length
1705 * mode sense page capabilities size, but older drives break.
1707 { "ATAPI CD ROM DRIVE 50X MAX", NULL
, IDE_AFLAG_FULL_CAPS_PAGE
},
1708 { "WPI CDS-32X", NULL
, IDE_AFLAG_FULL_CAPS_PAGE
},
1709 /* ACER/AOpen 24X CD-ROM has the speed fields byte-swapped. */
1710 { "", "241N", IDE_AFLAG_LE_SPEED_FIELDS
},
1712 * Some drives used by Apple don't advertise audio play
1713 * but they do support reading TOC & audio datas.
1715 { "MATSHITADVD-ROM SR-8187", NULL
, IDE_AFLAG_PLAY_AUDIO_OK
},
1716 { "MATSHITADVD-ROM SR-8186", NULL
, IDE_AFLAG_PLAY_AUDIO_OK
},
1717 { "MATSHITADVD-ROM SR-8176", NULL
, IDE_AFLAG_PLAY_AUDIO_OK
},
1718 { "MATSHITADVD-ROM SR-8174", NULL
, IDE_AFLAG_PLAY_AUDIO_OK
},
1719 { "Optiarc DVD RW AD-5200A", NULL
, IDE_AFLAG_PLAY_AUDIO_OK
},
1720 { "Optiarc DVD RW AD-7200A", NULL
, IDE_AFLAG_PLAY_AUDIO_OK
},
1721 { "Optiarc DVD RW AD-7543A", NULL
, IDE_AFLAG_NO_AUTOCLOSE
},
1722 { "TEAC CD-ROM CD-224E", NULL
, IDE_AFLAG_NO_AUTOCLOSE
},
1726 static unsigned int ide_cd_flags(u16
*id
)
1728 const struct cd_list_entry
*cle
= ide_cd_quirks_list
;
1730 while (cle
->id_model
) {
1731 if (strcmp(cle
->id_model
, (char *)&id
[ATA_ID_PROD
]) == 0 &&
1732 (cle
->id_firmware
== NULL
||
1733 strstr((char *)&id
[ATA_ID_FW_REV
], cle
->id_firmware
)))
1734 return cle
->cd_flags
;
1741 static int ide_cdrom_setup(ide_drive_t
*drive
)
1743 struct cdrom_info
*cd
= drive
->driver_data
;
1744 struct cdrom_device_info
*cdi
= &cd
->devinfo
;
1745 u16
*id
= drive
->id
;
1746 char *fw_rev
= (char *)&id
[ATA_ID_FW_REV
];
1749 ide_debug_log(IDE_DBG_PROBE
, "enter");
1751 blk_queue_prep_rq(drive
->queue
, ide_cdrom_prep_fn
);
1752 blk_queue_dma_alignment(drive
->queue
, 31);
1753 blk_queue_update_dma_pad(drive
->queue
, 15);
1754 drive
->queue
->unplug_delay
= (1 * HZ
) / 1000;
1755 if (!drive
->queue
->unplug_delay
)
1756 drive
->queue
->unplug_delay
= 1;
1758 drive
->dev_flags
|= IDE_DFLAG_MEDIA_CHANGED
;
1759 drive
->atapi_flags
= IDE_AFLAG_NO_EJECT
| ide_cd_flags(id
);
1761 if ((drive
->atapi_flags
& IDE_AFLAG_VERTOS_300_SSD
) &&
1762 fw_rev
[4] == '1' && fw_rev
[6] <= '2')
1763 drive
->atapi_flags
|= (IDE_AFLAG_TOCTRACKS_AS_BCD
|
1764 IDE_AFLAG_TOCADDR_AS_BCD
);
1765 else if ((drive
->atapi_flags
& IDE_AFLAG_VERTOS_600_ESD
) &&
1766 fw_rev
[4] == '1' && fw_rev
[6] <= '2')
1767 drive
->atapi_flags
|= IDE_AFLAG_TOCTRACKS_AS_BCD
;
1768 else if (drive
->atapi_flags
& IDE_AFLAG_SANYO_3CD
)
1769 /* 3 => use CD in slot 0 */
1770 cdi
->sanyo_slot
= 3;
1772 nslots
= ide_cdrom_probe_capabilities(drive
);
1774 /* set correct block size */
1775 blk_queue_hardsect_size(drive
->queue
, CD_FRAMESIZE
);
1777 if (ide_cdrom_register(drive
, nslots
)) {
1778 printk(KERN_ERR PFX
"%s: %s failed to register device with the"
1779 " cdrom driver.\n", drive
->name
, __func__
);
1780 cd
->devinfo
.handle
= NULL
;
1784 ide_proc_register_driver(drive
, cd
->driver
);
1788 static void ide_cd_remove(ide_drive_t
*drive
)
1790 struct cdrom_info
*info
= drive
->driver_data
;
1792 ide_debug_log(IDE_DBG_FUNC
, "enter");
1794 ide_proc_unregister_driver(drive
, info
->driver
);
1795 device_del(&info
->dev
);
1796 del_gendisk(info
->disk
);
1798 mutex_lock(&idecd_ref_mutex
);
1799 put_device(&info
->dev
);
1800 mutex_unlock(&idecd_ref_mutex
);
1803 static void ide_cd_release(struct device
*dev
)
1805 struct cdrom_info
*info
= to_ide_drv(dev
, cdrom_info
);
1806 struct cdrom_device_info
*devinfo
= &info
->devinfo
;
1807 ide_drive_t
*drive
= info
->drive
;
1808 struct gendisk
*g
= info
->disk
;
1810 ide_debug_log(IDE_DBG_FUNC
, "enter");
1813 if (devinfo
->handle
== drive
)
1814 unregister_cdrom(devinfo
);
1815 drive
->driver_data
= NULL
;
1816 blk_queue_prep_rq(drive
->queue
, NULL
);
1817 g
->private_data
= NULL
;
1822 static int ide_cd_probe(ide_drive_t
*);
1824 static struct ide_driver ide_cdrom_driver
= {
1826 .owner
= THIS_MODULE
,
1827 .name
= "ide-cdrom",
1828 .bus
= &ide_bus_type
,
1830 .probe
= ide_cd_probe
,
1831 .remove
= ide_cd_remove
,
1832 .version
= IDECD_VERSION
,
1833 .do_request
= ide_cd_do_request
,
1834 #ifdef CONFIG_IDE_PROC_FS
1835 .proc_entries
= ide_cd_proc_entries
,
1836 .proc_devsets
= ide_cd_proc_devsets
,
1840 static int idecd_open(struct block_device
*bdev
, fmode_t mode
)
1842 struct cdrom_info
*info
= ide_cd_get(bdev
->bd_disk
);
1848 rc
= cdrom_open(&info
->devinfo
, bdev
, mode
);
1856 static int idecd_release(struct gendisk
*disk
, fmode_t mode
)
1858 struct cdrom_info
*info
= ide_drv_g(disk
, cdrom_info
);
1860 cdrom_release(&info
->devinfo
, mode
);
1867 static int idecd_set_spindown(struct cdrom_device_info
*cdi
, unsigned long arg
)
1869 struct packet_command cgc
;
1874 if (copy_from_user(&spindown
, (void __user
*)arg
, sizeof(char)))
1877 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_UNKNOWN
);
1879 stat
= cdrom_mode_sense(cdi
, &cgc
, GPMODE_CDROM_PAGE
, 0);
1883 buffer
[11] = (buffer
[11] & 0xf0) | (spindown
& 0x0f);
1884 return cdrom_mode_select(cdi
, &cgc
);
1887 static int idecd_get_spindown(struct cdrom_device_info
*cdi
, unsigned long arg
)
1889 struct packet_command cgc
;
1894 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_UNKNOWN
);
1896 stat
= cdrom_mode_sense(cdi
, &cgc
, GPMODE_CDROM_PAGE
, 0);
1900 spindown
= buffer
[11] & 0x0f;
1901 if (copy_to_user((void __user
*)arg
, &spindown
, sizeof(char)))
1906 static int idecd_ioctl(struct block_device
*bdev
, fmode_t mode
,
1907 unsigned int cmd
, unsigned long arg
)
1909 struct cdrom_info
*info
= ide_drv_g(bdev
->bd_disk
, cdrom_info
);
1913 case CDROMSETSPINDOWN
:
1914 return idecd_set_spindown(&info
->devinfo
, arg
);
1915 case CDROMGETSPINDOWN
:
1916 return idecd_get_spindown(&info
->devinfo
, arg
);
1921 err
= generic_ide_ioctl(info
->drive
, bdev
, cmd
, arg
);
1923 err
= cdrom_ioctl(&info
->devinfo
, bdev
, mode
, cmd
, arg
);
1928 static int idecd_media_changed(struct gendisk
*disk
)
1930 struct cdrom_info
*info
= ide_drv_g(disk
, cdrom_info
);
1931 return cdrom_media_changed(&info
->devinfo
);
1934 static int idecd_revalidate_disk(struct gendisk
*disk
)
1936 struct cdrom_info
*info
= ide_drv_g(disk
, cdrom_info
);
1937 struct request_sense sense
;
1939 ide_cd_read_toc(info
->drive
, &sense
);
1944 static struct block_device_operations idecd_ops
= {
1945 .owner
= THIS_MODULE
,
1947 .release
= idecd_release
,
1948 .locked_ioctl
= idecd_ioctl
,
1949 .media_changed
= idecd_media_changed
,
1950 .revalidate_disk
= idecd_revalidate_disk
1953 /* module options */
1954 static char *ignore
;
1955 module_param(ignore
, charp
, 0400);
1957 static unsigned long debug_mask
;
1958 module_param(debug_mask
, ulong
, 0644);
1960 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
1962 static int ide_cd_probe(ide_drive_t
*drive
)
1964 struct cdrom_info
*info
;
1966 struct request_sense sense
;
1968 ide_debug_log(IDE_DBG_PROBE
, "driver_req: %s, media: 0x%x",
1969 drive
->driver_req
, drive
->media
);
1971 if (!strstr("ide-cdrom", drive
->driver_req
))
1974 if (drive
->media
!= ide_cdrom
&& drive
->media
!= ide_optical
)
1977 /* skip drives that we were told to ignore */
1978 if (ignore
!= NULL
) {
1979 if (strstr(ignore
, drive
->name
)) {
1980 printk(KERN_INFO PFX
"ignoring drive %s\n",
1986 drive
->debug_mask
= debug_mask
;
1987 drive
->irq_handler
= cdrom_newpc_intr
;
1989 info
= kzalloc(sizeof(struct cdrom_info
), GFP_KERNEL
);
1991 printk(KERN_ERR PFX
"%s: Can't allocate a cdrom structure\n",
1996 g
= alloc_disk(1 << PARTN_BITS
);
2000 ide_init_disk(g
, drive
);
2002 info
->dev
.parent
= &drive
->gendev
;
2003 info
->dev
.release
= ide_cd_release
;
2004 dev_set_name(&info
->dev
, dev_name(&drive
->gendev
));
2006 if (device_register(&info
->dev
))
2009 info
->drive
= drive
;
2010 info
->driver
= &ide_cdrom_driver
;
2013 g
->private_data
= &info
->driver
;
2015 drive
->driver_data
= info
;
2018 g
->driverfs_dev
= &drive
->gendev
;
2019 g
->flags
= GENHD_FL_CD
| GENHD_FL_REMOVABLE
;
2020 if (ide_cdrom_setup(drive
)) {
2021 put_device(&info
->dev
);
2025 ide_cd_read_toc(drive
, &sense
);
2026 g
->fops
= &idecd_ops
;
2027 g
->flags
|= GENHD_FL_REMOVABLE
;
2039 static void __exit
ide_cdrom_exit(void)
2041 driver_unregister(&ide_cdrom_driver
.gen_driver
);
2044 static int __init
ide_cdrom_init(void)
2046 printk(KERN_INFO DRV_NAME
" driver " IDECD_VERSION
"\n");
2047 return driver_register(&ide_cdrom_driver
.gen_driver
);
2050 MODULE_ALIAS("ide:*m-cdrom*");
2051 MODULE_ALIAS("ide-cd");
2052 module_init(ide_cdrom_init
);
2053 module_exit(ide_cdrom_exit
);
2054 MODULE_LICENSE("GPL");