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 * ----------------------------------
32 * 1.00 Oct 31, 1994 -- Initial version.
33 * 1.01 Nov 2, 1994 -- Fixed problem with starting request in
35 * 1.03 Nov 25, 1994 -- leaving unmask_intr[] as a user-setting (as for disks)
36 * (from mlord) -- minor changes to cdrom_setup()
37 * -- renamed ide_dev_s to ide_drive_t, enable irq on command
38 * 2.00 Nov 27, 1994 -- Generalize packet command interface;
40 * 2.01 Dec 3, 1994 -- Rework packet command interface to handle devices
41 * which send an interrupt when ready for a command.
42 * 2.02 Dec 11, 1994 -- Cache the TOC in the driver.
43 * Don't use SCMD_PLAYAUDIO_TI; it's not included
44 * in the current version of ATAPI.
45 * Try to use LBA instead of track or MSF addressing
47 * Don't wait for READY_STAT.
48 * 2.03 Jan 10, 1995 -- Rewrite block read routines to handle block sizes
49 * other than 2k and to move multiple sectors in a
51 * 2.04 Apr 21, 1995 -- Add work-around for Creative Labs CD220E drives.
52 * Thanks to Nick Saw <cwsaw@pts7.pts.mot.com> for
53 * help in figuring this out. Ditto for Acer and
54 * Aztech drives, which seem to have the same problem.
55 * 2.04b May 30, 1995 -- Fix to match changes in ide.c version 3.16 -ml
56 * 2.05 Jun 8, 1995 -- Don't attempt to retry after an illegal request
57 * or data protect error.
58 * Use HWIF and DEV_HWIF macros as in ide.c.
59 * Always try to do a request_sense after
61 * Include an option to give textual descriptions
63 * Fix a bug in handling the sector cache which
64 * showed up if the drive returned data in 512 byte
65 * blocks (like Pioneer drives). Thanks to
66 * Richard Hirst <srh@gpt.co.uk> for diagnosing this.
67 * Properly supply the page number field in the
68 * MODE_SELECT command.
69 * PLAYAUDIO12 is broken on the Aztech; work around it.
70 * 2.05x Aug 11, 1995 -- lots of data structure renaming/restructuring in ide.c
71 * (my apologies to Scott, but now ide-cd.c is independent)
72 * 3.00 Aug 22, 1995 -- Implement CDROMMULTISESSION ioctl.
73 * Implement CDROMREADAUDIO ioctl (UNTESTED).
74 * Use input_ide_data() and output_ide_data().
76 * Fix usage count leak in cdrom_open, which happened
77 * when a read-write mount was attempted.
78 * Try to load the disk on open.
79 * Implement CDROMEJECT_SW ioctl (off by default).
80 * Read total cdrom capacity during open.
81 * Rearrange logic in cdrom_decode_status. Issue
82 * request sense commands for failed packet commands
83 * from here instead of from cdrom_queue_packet_command.
84 * Fix a race condition in retrieving error information.
85 * Suppress printing normal unit attention errors and
86 * some drive not ready errors.
87 * Implement CDROMVOLREAD ioctl.
88 * Implement CDROMREADMODE1/2 ioctls.
89 * Fix race condition in setting up interrupt handlers
90 * when the `serialize' option is used.
91 * 3.01 Sep 2, 1995 -- Fix ordering of reenabling interrupts in
92 * cdrom_queue_request.
93 * Another try at using ide_[input,output]_data.
94 * 3.02 Sep 16, 1995 -- Stick total disk capacity in partition table as well.
95 * Make VERBOSE_IDE_CD_ERRORS dump failed command again.
96 * Dump out more information for ILLEGAL REQUEST errs.
97 * Fix handling of errors occurring before the
98 * packet command is transferred.
99 * Fix transfers with odd bytelengths.
100 * 3.03 Oct 27, 1995 -- Some Creative drives have an id of just `CD'.
101 * `DCI-2S10' drives are broken too.
102 * 3.04 Nov 20, 1995 -- So are Vertos drives.
103 * 3.05 Dec 1, 1995 -- Changes to go with overhaul of ide.c and ide-tape.c
104 * 3.06 Dec 16, 1995 -- Add support needed for partitions.
105 * More workarounds for Vertos bugs (based on patches
106 * from Holger Dietze <dietze@aix520.informatik.uni-leipzig.de>).
107 * Try to eliminate byteorder assumptions.
108 * Use atapi_cdrom_subchnl struct definition.
109 * Add STANDARD_ATAPI compilation option.
110 * 3.07 Jan 29, 1996 -- More twiddling for broken drives: Sony 55D,
112 * Add NO_DOOR_LOCKING configuration option.
113 * Handle drive_cmd requests w/NULL args (for hdparm -t).
114 * Work around sporadic Sony55e audio play problem.
115 * 3.07a Feb 11, 1996 -- check drive->id for NULL before dereferencing, to fix
116 * problem with "hde=cdrom" with no drive present. -ml
117 * 3.08 Mar 6, 1996 -- More Vertos workarounds.
118 * 3.09 Apr 5, 1996 -- Add CDROMCLOSETRAY ioctl.
119 * Switch to using MSF addressing for audio commands.
120 * Reformat to match kernel tabbing style.
121 * Add CDROM_GET_UPC ioctl.
122 * 3.10 Apr 10, 1996 -- Fix compilation error with STANDARD_ATAPI.
123 * 3.11 Apr 29, 1996 -- Patch from Heiko Eissfeldt <heiko@colossus.escape.de>
124 * to remove redundant verify_area calls.
125 * 3.12 May 7, 1996 -- Rudimentary changer support. Based on patches
126 * from Gerhard Zuber <zuber@berlin.snafu.de>.
127 * Let open succeed even if there's no loaded disc.
128 * 3.13 May 19, 1996 -- Fixes for changer code.
129 * 3.14 May 29, 1996 -- Add work-around for Vertos 600.
130 * (From Hennus Bergman <hennus@sky.ow.nl>.)
131 * 3.15 July 2, 1996 -- Added support for Sanyo 3 CD changers
132 * from Ben Galliart <bgallia@luc.edu> with
133 * special help from Jeff Lightfoot
135 * 3.15a July 9, 1996 -- Improved Sanyo 3 CD changer identification
136 * 3.16 Jul 28, 1996 -- Fix from Gadi to reduce kernel stack usage for ioctl.
137 * 3.17 Sep 17, 1996 -- Tweak audio reads for some drives.
138 * Start changing CDROMLOADFROMSLOT to CDROM_SELECT_DISC.
139 * 3.18 Oct 31, 1996 -- Added module and DMA support.
142 * 4.00 Nov 5, 1996 -- New ide-cd maintainer,
143 * Erik B. Andersen <andersee@debian.org>
144 * -- Newer Creative drives don't always set the error
145 * register correctly. Make sure we see media changes
147 * -- Integrate with generic cdrom driver.
148 * -- CDROMGETSPINDOWN and CDROMSETSPINDOWN ioctls, based on
149 * a patch from Ciro Cattuto <>.
150 * -- Call set_device_ro.
151 * -- Implement CDROMMECHANISMSTATUS and CDROMSLOTTABLE
152 * ioctls, based on patch by Erik Andersen
153 * -- Add some probes of drive capability during setup.
155 * 4.01 Nov 11, 1996 -- Split into ide-cd.c and ide-cd.h
156 * -- Removed CDROMMECHANISMSTATUS and CDROMSLOTTABLE
157 * ioctls in favor of a generalized approach
158 * using the generic cdrom driver.
159 * -- Fully integrated with the 2.1.X kernel.
160 * -- Other stuff that I forgot (lots of changes)
162 * 4.02 Dec 01, 1996 -- Applied patch from Gadi Oxman <gadio@netvision.net.il>
163 * to fix the drive door locking problems.
165 * 4.03 Dec 04, 1996 -- Added DSC overlap support.
166 * 4.04 Dec 29, 1996 -- Added CDROMREADRAW ioclt based on patch
167 * by Ales Makarov (xmakarov@sun.felk.cvut.cz)
169 * 4.05 Nov 20, 1997 -- Modified to print more drive info on init
170 * Minor other changes
171 * Fix errors on CDROMSTOP (If you have a "Dolphin",
172 * you must define IHAVEADOLPHIN)
173 * Added identifier so new Sanyo CD-changer works
174 * Better detection if door locking isn't supported
176 * 4.06 Dec 17, 1997 -- fixed endless "tray open" messages -ml
177 * 4.07 Dec 17, 1997 -- fallback to set pc->stat on "tray open"
178 * 4.08 Dec 18, 1997 -- spew less noise when tray is empty
179 * -- fix speed display for ACER 24X, 18X
180 * 4.09 Jan 04, 1998 -- fix handling of the last block so we return
181 * an end of file instead of an I/O error (Gadi)
182 * 4.10 Jan 24, 1998 -- fixed a bug so now changers can change to a new
183 * slot when there is no disc in the current slot.
184 * -- Fixed a memory leak where info->changer_info was
185 * malloc'ed but never free'd when closing the device.
186 * -- Cleaned up the global namespace a bit by making more
187 * functions static that should already have been.
188 * 4.11 Mar 12, 1998 -- Added support for the CDROM_SELECT_SPEED ioctl
189 * based on a patch for 2.0.33 by Jelle Foks
190 * <jelle@scintilla.utwente.nl>, a patch for 2.0.33
191 * by Toni Giorgino <toni@pcape2.pi.infn.it>, the SCSI
192 * version, and my own efforts. -erik
193 * -- Fixed a stupid bug which egcs was kind enough to
194 * inform me of where "Illegal mode for this track"
195 * was never returned due to a comparison on data
196 * types of limited range.
197 * 4.12 Mar 29, 1998 -- Fixed bug in CDROM_SELECT_SPEED so write speed is
198 * now set ionly for CD-R and CD-RW drives. I had
199 * removed this support because it produced errors.
200 * It produced errors _only_ for non-writers. duh.
201 * 4.13 May 05, 1998 -- Suppress useless "in progress of becoming ready"
202 * messages, since this is not an error.
203 * -- Change error messages to be const
204 * -- Remove a "\t" which looks ugly in the syslogs
205 * 4.14 July 17, 1998 -- Change to pointing to .ps version of ATAPI spec
206 * since the .pdf version doesn't seem to work...
207 * -- Updated the TODO list to something more current.
209 * 4.15 Aug 25, 1998 -- Updated ide-cd.h to respect mechine endianess,
210 * patch thanks to "Eddie C. Dost" <ecd@skynet.be>
212 * 4.50 Oct 19, 1998 -- New maintainers!
213 * Jens Axboe <axboe@image.dk>
214 * Chris Zwilling <chris@cloudnet.com>
216 * 4.51 Dec 23, 1998 -- Jens Axboe <axboe@image.dk>
217 * - ide_cdrom_reset enabled since the ide subsystem
218 * handles resets fine now. <axboe@image.dk>
219 * - Transfer size fix for Samsung CD-ROMs, thanks to
220 * "Ville Hallik" <ville.hallik@mail.ee>.
221 * - other minor stuff.
223 * 4.52 Jan 19, 1999 -- Jens Axboe <axboe@image.dk>
224 * - Detect DVD-ROM/RAM drives
226 * 4.53 Feb 22, 1999 - Include other model Samsung and one Goldstar
227 * drive in transfer size limit.
228 * - Fix the I/O error when doing eject without a medium
229 * loaded on some drives.
230 * - CDROMREADMODE2 is now implemented through
231 * CDROMREADRAW, since many drives don't support
232 * MODE2 (even though ATAPI 2.6 says they must).
233 * - Added ignore parameter to ide-cd (as a module), eg
234 * insmod ide-cd ignore='hda hdb'
235 * Useful when using ide-cd in conjunction with
236 * ide-scsi. TODO: non-modular way of doing the
239 * 4.54 Aug 5, 1999 - Support for MMC2 class commands through the generic
240 * packet interface to cdrom.c.
241 * - Unified audio ioctl support, most of it.
242 * - cleaned up various deprecated verify_area().
243 * - Added ide_cdrom_packet() as the interface for
244 * the Uniform generic_packet().
245 * - bunch of other stuff, will fill in logs later.
246 * - report 1 slot for non-changers, like the other
247 * cd-rom drivers. don't report select disc for
248 * non-changers as well.
249 * - mask out audio playing, if the device can't do it.
251 * 4.55 Sep 1, 1999 - Eliminated the rest of the audio ioctls, except
252 * for CDROMREADTOC[ENTRY|HEADER]. Some of the drivers
253 * use this independently of the actual audio handling.
254 * They will disappear later when I get the time to
256 * - Minimize the TOC reading - only do it when we
257 * know a media change has occurred.
258 * - Moved all the CDROMREADx ioctls to the Uniform layer.
259 * - Heiko Eissfeldt <heiko@colossus.escape.de> supplied
260 * some fixes for CDI.
261 * - CD-ROM leaving door locked fix from Andries
262 * Brouwer <Andries.Brouwer@cwi.nl>
263 * - Erik Andersen <andersen@xmission.com> unified
264 * commands across the various drivers and how
265 * sense errors are handled.
267 * 4.56 Sep 12, 1999 - Removed changer support - it is now in the
269 * - Added partition based multisession handling.
270 * - Mode sense and mode select moved to the
272 * - Fixed a problem with WPI CDS-32X drive - it
273 * failed the capabilities
275 * 4.57 Apr 7, 2000 - Fixed sense reporting.
276 * - Fixed possible oops in ide_cdrom_get_last_session()
277 * - Fix locking mania and make ide_cdrom_reset relock
278 * - Stop spewing errors to log when magicdev polls with
279 * TEST_UNIT_READY on some drives.
280 * - Various fixes from Tobias Ringstrom:
281 * tray if it was locked prior to the reset.
282 * - cdrom_read_capacity returns one frame too little.
283 * - Fix real capacity reporting.
285 * 4.58 May 1, 2000 - Clean up ACER50 stuff.
286 * - Fix small problem with ide_cdrom_capacity
288 * 4.59 Aug 11, 2000 - Fix changer problem in cdrom_read_toc, we weren't
289 * correctly sensing a disc change.
290 * - Rearranged some code
291 * - Use extended sense on drives that support it for
292 * correctly reporting tray status -- from
293 * Michael D Johnson <johnsom@orst.edu>
294 * 4.60 Dec 17, 2003 - Add mt rainier support
295 * - Bump timeout for packet commands, matches sr
297 * 4.61 Jan 22, 2004 - support hardware sector sizes other than 2kB,
298 * Pascal Schmidt <der.eremit@email.de>
300 *************************************************************************/
302 #define IDECD_VERSION "4.61"
304 #include <linux/module.h>
305 #include <linux/types.h>
306 #include <linux/kernel.h>
307 #include <linux/delay.h>
308 #include <linux/timer.h>
309 #include <linux/slab.h>
310 #include <linux/interrupt.h>
311 #include <linux/errno.h>
312 #include <linux/cdrom.h>
313 #include <linux/ide.h>
314 #include <linux/completion.h>
315 #include <linux/mutex.h>
317 #include <scsi/scsi.h> /* For SCSI -> ATAPI command conversion */
321 #include <asm/byteorder.h>
322 #include <asm/uaccess.h>
323 #include <asm/unaligned.h>
327 static DEFINE_MUTEX(idecd_ref_mutex);
329 #define to_ide_cd(obj) container_of(obj, struct cdrom_info, kref)
331 #define ide_cd_g(disk) \
332 container_of((disk)->private_data, struct cdrom_info, driver)
334 static struct cdrom_info *ide_cd_get(struct gendisk *disk)
336 struct cdrom_info *cd = NULL;
338 mutex_lock(&idecd_ref_mutex);
342 mutex_unlock(&idecd_ref_mutex);
346 static void ide_cd_release(struct kref *);
348 static void ide_cd_put(struct cdrom_info *cd)
350 mutex_lock(&idecd_ref_mutex);
351 kref_put(&cd->kref, ide_cd_release);
352 mutex_unlock(&idecd_ref_mutex);
355 /****************************************************************************
356 * Generic packet command support and error handling routines.
359 /* Mark that we've seen a media change, and invalidate our internal
361 static void cdrom_saw_media_change (ide_drive_t *drive)
363 struct cdrom_info *info = drive->driver_data;
365 CDROM_STATE_FLAGS (drive)->media_changed = 1;
366 CDROM_STATE_FLAGS (drive)->toc_valid = 0;
367 info->nsectors_buffered = 0;
370 static int cdrom_log_sense(ide_drive_t *drive, struct request *rq,
371 struct request_sense *sense)
375 if (!sense || !rq || (rq->cmd_flags & REQ_QUIET))
378 switch (sense->sense_key) {
379 case NO_SENSE: case RECOVERED_ERROR:
383 * don't care about tray state messages for
384 * e.g. capacity commands or in-progress or
387 if (sense->asc == 0x3a || sense->asc == 0x04)
391 case ILLEGAL_REQUEST:
393 * don't log START_STOP unit with LoEj set, since
394 * we cannot reliably check if drive can auto-close
396 if (rq->cmd[0] == GPCMD_START_STOP_UNIT && sense->asc == 0x24)
402 * Make good and sure we've seen this potential media
403 * change. Some drives (i.e. Creative) fail to present
404 * the correct sense key in the error register.
406 cdrom_saw_media_change(drive);
416 void cdrom_analyze_sense_data(ide_drive_t *drive,
417 struct request *failed_command,
418 struct request_sense *sense)
420 unsigned long sector;
421 unsigned long bio_sectors;
423 struct cdrom_info *info = drive->driver_data;
425 if (!cdrom_log_sense(drive, failed_command, sense))
429 * If a read toc is executed for a CD-R or CD-RW medium where
430 * the first toc has not been recorded yet, it will fail with
431 * 05/24/00 (which is a confusing error)
433 if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP)
434 if (sense->sense_key == 0x05 && sense->asc == 0x24)
437 if (sense->error_code == 0x70) { /* Current Error */
438 switch(sense->sense_key) {
440 case VOLUME_OVERFLOW:
441 case ILLEGAL_REQUEST:
444 if (failed_command == NULL ||
445 !blk_fs_request(failed_command))
447 sector = (sense->information[0] << 24) |
448 (sense->information[1] << 16) |
449 (sense->information[2] << 8) |
450 (sense->information[3]);
452 bio_sectors = bio_sectors(failed_command->bio);
455 if (drive->queue->hardsect_size == 2048)
456 sector <<= 2; /* Device sector size is 2K */
457 sector &= ~(bio_sectors -1);
458 valid = (sector - failed_command->sector) << 9;
462 if (sector < get_capacity(info->disk) &&
463 drive->probed_capacity - sector < 4 * 75) {
464 set_capacity(info->disk, sector);
468 #if VERBOSE_IDE_CD_ERRORS
471 const char *s = "bad sense key!";
474 printk ("ATAPI device %s:\n", drive->name);
475 if (sense->error_code==0x70)
477 else if (sense->error_code==0x71)
478 printk(" Deferred Error: ");
479 else if (sense->error_code == 0x7f)
480 printk(" Vendor-specific Error: ");
482 printk(" Unknown Error Type: ");
484 if (sense->sense_key < ARY_LEN(sense_key_texts))
485 s = sense_key_texts[sense->sense_key];
487 printk("%s -- (Sense key=0x%02x)\n", s, sense->sense_key);
489 if (sense->asc == 0x40) {
490 sprintf(buf, "Diagnostic failure on component 0x%02x",
494 int lo = 0, mid, hi = ARY_LEN(sense_data_texts);
495 unsigned long key = (sense->sense_key << 16);
496 key |= (sense->asc << 8);
497 if (!(sense->ascq >= 0x80 && sense->ascq <= 0xdd))
503 if (sense_data_texts[mid].asc_ascq == key ||
504 sense_data_texts[mid].asc_ascq == (0xff0000|key)) {
505 s = sense_data_texts[mid].text;
508 else if (sense_data_texts[mid].asc_ascq > key)
516 if (sense->asc > 0x80)
517 s = "(vendor-specific error)";
519 s = "(reserved error code)";
522 printk(KERN_ERR " %s -- (asc=0x%02x, ascq=0x%02x)\n",
523 s, sense->asc, sense->ascq);
525 if (failed_command != NULL) {
527 int lo=0, mid, hi= ARY_LEN (packet_command_texts);
532 if (packet_command_texts[mid].packet_command ==
533 failed_command->cmd[0]) {
534 s = packet_command_texts[mid].text;
537 if (packet_command_texts[mid].packet_command >
538 failed_command->cmd[0])
544 printk (KERN_ERR " The failed \"%s\" packet command was: \n \"", s);
545 for (i=0; i<sizeof (failed_command->cmd); i++)
546 printk ("%02x ", failed_command->cmd[i]);
550 /* The SKSV bit specifies validity of the sense_key_specific
551 * in the next two commands. It is bit 7 of the first byte.
552 * In the case of NOT_READY, if SKSV is set the drive can
553 * give us nice ETA readings.
555 if (sense->sense_key == NOT_READY && (sense->sks[0] & 0x80)) {
556 int progress = (sense->sks[1] << 8 | sense->sks[2]) * 100;
557 printk(KERN_ERR " Command is %02d%% complete\n", progress / 0xffff);
561 if (sense->sense_key == ILLEGAL_REQUEST &&
562 (sense->sks[0] & 0x80) != 0) {
563 printk(KERN_ERR " Error in %s byte %d",
564 (sense->sks[0] & 0x40) != 0 ?
565 "command packet" : "command data",
566 (sense->sks[1] << 8) + sense->sks[2]);
568 if ((sense->sks[0] & 0x40) != 0)
569 printk (" bit %d", sense->sks[0] & 0x07);
575 #else /* not VERBOSE_IDE_CD_ERRORS */
577 /* Suppress printing unit attention and `in progress of becoming ready'
578 errors when we're not being verbose. */
580 if (sense->sense_key == UNIT_ATTENTION ||
581 (sense->sense_key == NOT_READY && (sense->asc == 4 ||
582 sense->asc == 0x3a)))
585 printk(KERN_ERR "%s: error code: 0x%02x sense_key: 0x%02x asc: 0x%02x ascq: 0x%02x\n",
587 sense->error_code, sense->sense_key,
588 sense->asc, sense->ascq);
589 #endif /* not VERBOSE_IDE_CD_ERRORS */
593 * Initialize a ide-cd packet command request
595 static void cdrom_prepare_request(ide_drive_t *drive, struct request *rq)
597 struct cdrom_info *cd = drive->driver_data;
599 ide_init_drive_cmd(rq);
600 rq->cmd_type = REQ_TYPE_BLOCK_PC;
601 rq->rq_disk = cd->disk;
604 static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense,
605 struct request *failed_command)
607 struct cdrom_info *info = drive->driver_data;
608 struct request *rq = &info->request_sense_request;
611 sense = &info->sense_data;
613 /* stuff the sense request in front of our current request */
614 cdrom_prepare_request(drive, rq);
617 rq->cmd[0] = GPCMD_REQUEST_SENSE;
618 rq->cmd[4] = rq->data_len = 18;
620 rq->cmd_type = REQ_TYPE_SENSE;
622 /* NOTE! Save the failed command in "rq->buffer" */
623 rq->buffer = (void *) failed_command;
625 (void) ide_do_drive_cmd(drive, rq, ide_preempt);
628 static void cdrom_end_request (ide_drive_t *drive, int uptodate)
630 struct request *rq = HWGROUP(drive)->rq;
631 int nsectors = rq->hard_cur_sectors;
633 if (blk_sense_request(rq) && uptodate) {
635 * For REQ_TYPE_SENSE, "rq->buffer" points to the original
638 struct request *failed = (struct request *) rq->buffer;
639 struct cdrom_info *info = drive->driver_data;
640 void *sense = &info->sense_data;
645 sense = failed->sense;
646 failed->sense_len = rq->sense_len;
648 cdrom_analyze_sense_data(drive, failed, sense);
650 * now end failed request
652 if (blk_fs_request(failed)) {
653 if (ide_end_dequeued_request(drive, failed, 0,
654 failed->hard_nr_sectors))
657 spin_lock_irqsave(&ide_lock, flags);
658 end_that_request_chunk(failed, 0,
660 end_that_request_last(failed, 0);
661 spin_unlock_irqrestore(&ide_lock, flags);
664 cdrom_analyze_sense_data(drive, NULL, sense);
667 if (!rq->current_nr_sectors && blk_fs_request(rq))
669 /* make sure it's fully ended */
670 if (blk_pc_request(rq))
671 nsectors = (rq->data_len + 511) >> 9;
675 ide_end_request(drive, uptodate, nsectors);
678 static void ide_dump_status_no_sense(ide_drive_t *drive, const char *msg, u8 stat)
682 ide_dump_status(drive, msg, stat);
685 /* Returns 0 if the request should be continued.
686 Returns 1 if the request was ended. */
687 static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
689 struct request *rq = HWGROUP(drive)->rq;
690 int stat, err, sense_key;
692 /* Check for errors. */
693 stat = HWIF(drive)->INB(IDE_STATUS_REG);
697 if (OK_STAT(stat, good_stat, BAD_R_STAT))
700 /* Get the IDE error register. */
701 err = HWIF(drive)->INB(IDE_ERROR_REG);
702 sense_key = err >> 4;
705 printk("%s: missing rq in cdrom_decode_status\n", drive->name);
709 if (blk_sense_request(rq)) {
710 /* We got an error trying to get sense info
711 from the drive (probably while trying
712 to recover from a former error). Just give up. */
714 rq->cmd_flags |= REQ_FAILED;
715 cdrom_end_request(drive, 0);
716 ide_error(drive, "request sense failure", stat);
719 } else if (blk_pc_request(rq)) {
720 /* All other functions, except for READ. */
724 * if we have an error, pass back CHECK_CONDITION as the
728 rq->errors = SAM_STAT_CHECK_CONDITION;
730 /* Check for tray open. */
731 if (sense_key == NOT_READY) {
732 cdrom_saw_media_change (drive);
733 } else if (sense_key == UNIT_ATTENTION) {
734 /* Check for media change. */
735 cdrom_saw_media_change (drive);
736 /*printk("%s: media changed\n",drive->name);*/
738 } else if (!(rq->cmd_flags & REQ_QUIET)) {
739 /* Otherwise, print an error. */
740 ide_dump_status(drive, "packet command error", stat);
743 rq->cmd_flags |= REQ_FAILED;
746 * instead of playing games with moving completions around,
747 * remove failed request completely and end it when the
748 * request sense has completed
750 if (stat & ERR_STAT) {
751 spin_lock_irqsave(&ide_lock, flags);
752 blkdev_dequeue_request(rq);
753 HWGROUP(drive)->rq = NULL;
754 spin_unlock_irqrestore(&ide_lock, flags);
756 cdrom_queue_request_sense(drive, rq->sense, rq);
758 cdrom_end_request(drive, 0);
760 } else if (blk_fs_request(rq)) {
761 int do_end_request = 0;
763 /* Handle errors from READ and WRITE requests. */
765 if (blk_noretry_request(rq))
768 if (sense_key == NOT_READY) {
770 if (rq_data_dir(rq) == READ) {
771 cdrom_saw_media_change (drive);
773 /* Fail the request. */
774 printk ("%s: tray open\n", drive->name);
777 struct cdrom_info *info = drive->driver_data;
779 /* allow the drive 5 seconds to recover, some
780 * devices will return this error while flushing
783 info->write_timeout = jiffies + ATAPI_WAIT_WRITE_BUSY;
785 if (time_after(jiffies, info->write_timeout))
791 * take a breather relying on the
792 * unplug timer to kick us again
794 spin_lock_irqsave(&ide_lock, flags);
795 blk_plug_device(drive->queue);
796 spin_unlock_irqrestore(&ide_lock,flags);
800 } else if (sense_key == UNIT_ATTENTION) {
802 cdrom_saw_media_change (drive);
804 /* Arrange to retry the request.
805 But be sure to give up if we've retried
807 if (++rq->errors > ERROR_MAX)
809 } else if (sense_key == ILLEGAL_REQUEST ||
810 sense_key == DATA_PROTECT) {
811 /* No point in retrying after an illegal
812 request or data protect error.*/
813 ide_dump_status_no_sense (drive, "command error", stat);
815 } else if (sense_key == MEDIUM_ERROR) {
816 /* No point in re-trying a zillion times on a bad
817 * sector... If we got here the error is not correctable */
818 ide_dump_status_no_sense (drive, "media error (bad sector)", stat);
820 } else if (sense_key == BLANK_CHECK) {
821 /* Disk appears blank ?? */
822 ide_dump_status_no_sense (drive, "media error (blank)", stat);
824 } else if ((err & ~ABRT_ERR) != 0) {
825 /* Go to the default handler
827 ide_error(drive, "cdrom_decode_status", stat);
829 } else if ((++rq->errors > ERROR_MAX)) {
830 /* We've racked up too many retries. Abort. */
834 /* End a request through request sense analysis when we have
835 sense data. We need this in order to perform end of media
838 if (do_end_request) {
839 if (stat & ERR_STAT) {
841 spin_lock_irqsave(&ide_lock, flags);
842 blkdev_dequeue_request(rq);
843 HWGROUP(drive)->rq = NULL;
844 spin_unlock_irqrestore(&ide_lock, flags);
846 cdrom_queue_request_sense(drive, rq->sense, rq);
848 cdrom_end_request(drive, 0);
850 /* If we got a CHECK_CONDITION status,
851 queue a request sense command. */
853 cdrom_queue_request_sense(drive, NULL, NULL);
856 blk_dump_rq_flags(rq, "ide-cd: bad rq");
857 cdrom_end_request(drive, 0);
860 /* Retry, or handle the next request. */
864 static int cdrom_timer_expiry(ide_drive_t *drive)
866 struct request *rq = HWGROUP(drive)->rq;
867 unsigned long wait = 0;
870 * Some commands are *slow* and normally take a long time to
871 * complete. Usually we can use the ATAPI "disconnect" to bypass
872 * this, but not all commands/drives support that. Let
873 * ide_timer_expiry keep polling us for these.
875 switch (rq->cmd[0]) {
877 case GPCMD_FORMAT_UNIT:
878 case GPCMD_RESERVE_RZONE_TRACK:
879 case GPCMD_CLOSE_TRACK:
880 case GPCMD_FLUSH_CACHE:
881 wait = ATAPI_WAIT_PC;
884 if (!(rq->cmd_flags & REQ_QUIET))
885 printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n", rq->cmd[0]);
892 /* Set up the device registers for transferring a packet command on DEV,
893 expecting to later transfer XFERLEN bytes. HANDLER is the routine
894 which actually transfers the command to the drive. If this is a
895 drq_interrupt device, this routine will arrange for HANDLER to be
896 called when the interrupt from the drive arrives. Otherwise, HANDLER
897 will be called immediately after the drive is prepared for the transfer. */
899 static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
901 ide_handler_t *handler)
903 ide_startstop_t startstop;
904 struct cdrom_info *info = drive->driver_data;
905 ide_hwif_t *hwif = drive->hwif;
907 /* Wait for the controller to be idle. */
908 if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY))
912 info->dma = !hwif->dma_setup(drive);
914 /* Set up the controller registers. */
915 /* FIXME: for Virtual DMA we must check harder */
916 HWIF(drive)->OUTB(info->dma, IDE_FEATURE_REG);
917 HWIF(drive)->OUTB(0, IDE_IREASON_REG);
918 HWIF(drive)->OUTB(0, IDE_SECTOR_REG);
920 HWIF(drive)->OUTB(xferlen & 0xff, IDE_BCOUNTL_REG);
921 HWIF(drive)->OUTB(xferlen >> 8 , IDE_BCOUNTH_REG);
923 HWIF(drive)->OUTB(drive->ctl, IDE_CONTROL_REG);
925 if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt) {
927 ide_execute_command(drive, WIN_PACKETCMD, handler, ATAPI_WAIT_PC, cdrom_timer_expiry);
933 spin_lock_irqsave(&ide_lock, flags);
934 hwif->OUTBSYNC(drive, WIN_PACKETCMD, IDE_COMMAND_REG);
936 spin_unlock_irqrestore(&ide_lock, flags);
938 return (*handler) (drive);
942 /* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
943 The device registers must have already been prepared
944 by cdrom_start_packet_command.
945 HANDLER is the interrupt handler to call when the command completes
946 or there's data ready. */
948 * changed 5 parameters to 3 for dvd-ram
949 * struct packet_command *pc; now packet_command_t *pc;
951 #define ATAPI_MIN_CDB_BYTES 12
952 static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
954 ide_handler_t *handler)
956 ide_hwif_t *hwif = drive->hwif;
958 struct cdrom_info *info = drive->driver_data;
959 ide_startstop_t startstop;
961 if (CDROM_CONFIG_FLAGS(drive)->drq_interrupt) {
962 /* Here we should have been called after receiving an interrupt
963 from the device. DRQ should how be set. */
965 /* Check for errors. */
966 if (cdrom_decode_status(drive, DRQ_STAT, NULL))
969 /* Otherwise, we must wait for DRQ to get set. */
970 if (ide_wait_stat(&startstop, drive, DRQ_STAT,
971 BUSY_STAT, WAIT_READY))
975 /* Arm the interrupt handler. */
976 ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);
978 /* ATAPI commands get padded out to 12 bytes minimum */
979 cmd_len = COMMAND_SIZE(rq->cmd[0]);
980 if (cmd_len < ATAPI_MIN_CDB_BYTES)
981 cmd_len = ATAPI_MIN_CDB_BYTES;
983 /* Send the command to the device. */
984 HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len);
986 /* Start the DMA if need be */
988 hwif->dma_start(drive);
993 /****************************************************************************
994 * Block read functions.
998 * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
999 * buffer. Once the first sector is added, any subsequent sectors are
1000 * assumed to be continuous (until the buffer is cleared). For the first
1001 * sector added, SECTOR is its sector number. (SECTOR is then ignored until
1002 * the buffer is cleared.)
1004 static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
1005 int sectors_to_transfer)
1007 struct cdrom_info *info = drive->driver_data;
1009 /* Number of sectors to read into the buffer. */
1010 int sectors_to_buffer = min_t(int, sectors_to_transfer,
1011 (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
1012 info->nsectors_buffered);
1016 /* If we couldn't get a buffer, don't try to buffer anything... */
1017 if (info->buffer == NULL)
1018 sectors_to_buffer = 0;
1020 /* If this is the first sector in the buffer, remember its number. */
1021 if (info->nsectors_buffered == 0)
1022 info->sector_buffered = sector;
1024 /* Read the data into the buffer. */
1025 dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
1026 while (sectors_to_buffer > 0) {
1027 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
1028 --sectors_to_buffer;
1029 --sectors_to_transfer;
1030 ++info->nsectors_buffered;
1031 dest += SECTOR_SIZE;
1034 /* Throw away any remaining data. */
1035 while (sectors_to_transfer > 0) {
1036 static char dum[SECTOR_SIZE];
1037 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1038 --sectors_to_transfer;
1043 * Check the contents of the interrupt reason register from the cdrom
1044 * and attempt to recover if there are problems. Returns 0 if everything's
1045 * ok; nonzero if the request has been terminated.
1048 int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
1052 else if (ireason == 0) {
1053 /* Whoops... The drive is expecting to receive data from us! */
1054 printk(KERN_ERR "%s: read_intr: Drive wants to transfer data the "
1055 "wrong way!\n", drive->name);
1057 /* Throw some data at the drive so it doesn't hang
1058 and quit this request. */
1061 HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof (dum));
1062 len -= sizeof (dum);
1064 } else if (ireason == 1) {
1065 /* Some drives (ASUS) seem to tell us that status
1066 * info is available. just get it and ignore.
1068 (void) HWIF(drive)->INB(IDE_STATUS_REG);
1071 /* Drive wants a command packet, or invalid ireason... */
1072 printk(KERN_ERR "%s: read_intr: bad interrupt reason %x\n", drive->name,
1076 cdrom_end_request(drive, 0);
1081 * Interrupt routine. Called when a read request has completed.
1083 static ide_startstop_t cdrom_read_intr (ide_drive_t *drive)
1086 int ireason, len, sectors_to_transfer, nskip;
1087 struct cdrom_info *info = drive->driver_data;
1088 u8 lowcyl = 0, highcyl = 0;
1089 int dma = info->dma, dma_error = 0;
1091 struct request *rq = HWGROUP(drive)->rq;
1098 if ((dma_error = HWIF(drive)->ide_dma_end(drive)))
1099 __ide_dma_off(drive);
1102 if (cdrom_decode_status(drive, 0, &stat))
1107 ide_end_request(drive, 1, rq->nr_sectors);
1110 return ide_error(drive, "dma error", stat);
1113 /* Read the interrupt reason and the transfer length. */
1114 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1115 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1116 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1118 len = lowcyl + (256 * highcyl);
1120 /* If DRQ is clear, the command has completed. */
1121 if ((stat & DRQ_STAT) == 0) {
1122 /* If we're not done filling the current buffer, complain.
1123 Otherwise, complete the command normally. */
1124 if (rq->current_nr_sectors > 0) {
1125 printk (KERN_ERR "%s: cdrom_read_intr: data underrun (%d blocks)\n",
1126 drive->name, rq->current_nr_sectors);
1127 rq->cmd_flags |= REQ_FAILED;
1128 cdrom_end_request(drive, 0);
1130 cdrom_end_request(drive, 1);
1134 /* Check that the drive is expecting to do the same thing we are. */
1135 if (cdrom_read_check_ireason (drive, len, ireason))
1138 /* Assume that the drive will always provide data in multiples
1139 of at least SECTOR_SIZE, as it gets hairy to keep track
1140 of the transfers otherwise. */
1141 if ((len % SECTOR_SIZE) != 0) {
1142 printk (KERN_ERR "%s: cdrom_read_intr: Bad transfer size %d\n",
1144 if (CDROM_CONFIG_FLAGS(drive)->limit_nframes)
1145 printk (KERN_ERR " This drive is not supported by this version of the driver\n");
1147 printk (KERN_ERR " Trying to limit transfer sizes\n");
1148 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
1150 cdrom_end_request(drive, 0);
1154 /* The number of sectors we need to read from the drive. */
1155 sectors_to_transfer = len / SECTOR_SIZE;
1157 /* First, figure out if we need to bit-bucket
1158 any of the leading sectors. */
1159 nskip = min_t(int, rq->current_nr_sectors - bio_cur_sectors(rq->bio), sectors_to_transfer);
1162 /* We need to throw away a sector. */
1163 static char dum[SECTOR_SIZE];
1164 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1166 --rq->current_nr_sectors;
1168 --sectors_to_transfer;
1171 /* Now loop while we still have data to read from the drive. */
1172 while (sectors_to_transfer > 0) {
1175 /* If we've filled the present buffer but there's another
1176 chained buffer after it, move on. */
1177 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1178 cdrom_end_request(drive, 1);
1180 /* If the buffers are full, cache the rest of the data in our
1182 if (rq->current_nr_sectors == 0) {
1183 cdrom_buffer_sectors(drive, rq->sector, sectors_to_transfer);
1184 sectors_to_transfer = 0;
1186 /* Transfer data to the buffers.
1187 Figure out how many sectors we can transfer
1188 to the current buffer. */
1189 this_transfer = min_t(int, sectors_to_transfer,
1190 rq->current_nr_sectors);
1192 /* Read this_transfer sectors
1193 into the current buffer. */
1194 while (this_transfer > 0) {
1195 HWIF(drive)->atapi_input_bytes(drive, rq->buffer, SECTOR_SIZE);
1196 rq->buffer += SECTOR_SIZE;
1198 --rq->current_nr_sectors;
1201 --sectors_to_transfer;
1206 /* Done moving data! Wait for another interrupt. */
1207 ide_set_handler(drive, &cdrom_read_intr, ATAPI_WAIT_PC, NULL);
1212 * Try to satisfy some of the current read request from our cached data.
1213 * Returns nonzero if the request has been completed, zero otherwise.
1215 static int cdrom_read_from_buffer (ide_drive_t *drive)
1217 struct cdrom_info *info = drive->driver_data;
1218 struct request *rq = HWGROUP(drive)->rq;
1219 unsigned short sectors_per_frame;
1221 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1223 /* Can't do anything if there's no buffer. */
1224 if (info->buffer == NULL) return 0;
1226 /* Loop while this request needs data and the next block is present
1228 while (rq->nr_sectors > 0 &&
1229 rq->sector >= info->sector_buffered &&
1230 rq->sector < info->sector_buffered + info->nsectors_buffered) {
1231 if (rq->current_nr_sectors == 0)
1232 cdrom_end_request(drive, 1);
1236 (rq->sector - info->sector_buffered) * SECTOR_SIZE,
1238 rq->buffer += SECTOR_SIZE;
1239 --rq->current_nr_sectors;
1244 /* If we've satisfied the current request,
1245 terminate it successfully. */
1246 if (rq->nr_sectors == 0) {
1247 cdrom_end_request(drive, 1);
1251 /* Move on to the next buffer if needed. */
1252 if (rq->current_nr_sectors == 0)
1253 cdrom_end_request(drive, 1);
1255 /* If this condition does not hold, then the kluge i use to
1256 represent the number of sectors to skip at the start of a transfer
1257 will fail. I think that this will never happen, but let's be
1258 paranoid and check. */
1259 if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
1260 (rq->sector & (sectors_per_frame - 1))) {
1261 printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
1262 drive->name, (long)rq->sector);
1263 cdrom_end_request(drive, 0);
1271 * Routine to send a read packet command to the drive.
1272 * This is usually called directly from cdrom_start_read.
1273 * However, for drq_interrupt devices, it is called from an interrupt
1274 * when the drive is ready to accept the command.
1276 static ide_startstop_t cdrom_start_read_continuation (ide_drive_t *drive)
1278 struct request *rq = HWGROUP(drive)->rq;
1279 unsigned short sectors_per_frame;
1282 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1284 /* If the requested sector doesn't start on a cdrom block boundary,
1285 we must adjust the start of the transfer so that it does,
1286 and remember to skip the first few sectors.
1287 If the CURRENT_NR_SECTORS field is larger than the size
1288 of the buffer, it will mean that we're to skip a number
1289 of sectors equal to the amount by which CURRENT_NR_SECTORS
1290 is larger than the buffer size. */
1291 nskip = rq->sector & (sectors_per_frame - 1);
1293 /* Sanity check... */
1294 if (rq->current_nr_sectors != bio_cur_sectors(rq->bio) &&
1295 (rq->sector & (sectors_per_frame - 1))) {
1296 printk(KERN_ERR "%s: cdrom_start_read_continuation: buffer botch (%u)\n",
1297 drive->name, rq->current_nr_sectors);
1298 cdrom_end_request(drive, 0);
1301 rq->current_nr_sectors += nskip;
1304 /* Set up the command */
1305 rq->timeout = ATAPI_WAIT_PC;
1307 /* Send the command to the drive and return. */
1308 return cdrom_transfer_packet_command(drive, rq, &cdrom_read_intr);
1312 #define IDECD_SEEK_THRESHOLD (1000) /* 1000 blocks */
1313 #define IDECD_SEEK_TIMER (5 * WAIT_MIN_SLEEP) /* 100 ms */
1314 #define IDECD_SEEK_TIMEOUT (2 * WAIT_CMD) /* 20 sec */
1316 static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
1318 struct cdrom_info *info = drive->driver_data;
1320 static int retry = 10;
1322 if (cdrom_decode_status(drive, 0, &stat))
1324 CDROM_CONFIG_FLAGS(drive)->seeking = 1;
1326 if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
1329 * this condition is far too common, to bother
1332 /* printk("%s: disabled DSC seek overlap\n", drive->name);*/
1333 drive->dsc_overlap = 0;
1339 static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
1341 struct request *rq = HWGROUP(drive)->rq;
1342 sector_t frame = rq->sector;
1344 sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
1346 memset(rq->cmd, 0, sizeof(rq->cmd));
1347 rq->cmd[0] = GPCMD_SEEK;
1348 put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
1350 rq->timeout = ATAPI_WAIT_PC;
1351 return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
1354 static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
1356 struct cdrom_info *info = drive->driver_data;
1359 info->start_seek = jiffies;
1360 return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
1363 /* Fix up a possibly partially-processed request so that we can
1364 start it over entirely, or even put it back on the request queue. */
1365 static void restore_request (struct request *rq)
1367 if (rq->buffer != bio_data(rq->bio)) {
1368 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
1370 rq->buffer = bio_data(rq->bio);
1371 rq->nr_sectors += n;
1374 rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
1375 rq->hard_nr_sectors = rq->nr_sectors;
1376 rq->hard_sector = rq->sector;
1377 rq->q->prep_rq_fn(rq->q, rq);
1381 * Start a read request from the CD-ROM.
1383 static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block)
1385 struct cdrom_info *info = drive->driver_data;
1386 struct request *rq = HWGROUP(drive)->rq;
1387 unsigned short sectors_per_frame;
1389 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1391 /* We may be retrying this request after an error. Fix up
1392 any weirdness which might be present in the request packet. */
1393 restore_request(rq);
1395 /* Satisfy whatever we can of this request from our cached sector. */
1396 if (cdrom_read_from_buffer(drive))
1399 /* Clear the local sector buffer. */
1400 info->nsectors_buffered = 0;
1402 /* use dma, if possible. */
1403 info->dma = drive->using_dma;
1404 if ((rq->sector & (sectors_per_frame - 1)) ||
1405 (rq->nr_sectors & (sectors_per_frame - 1)))
1408 /* Start sending the read request to the drive. */
1409 return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
1412 /****************************************************************************
1413 * Execute all other packet commands.
1416 /* Interrupt routine for packet command completion. */
1417 static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
1419 int ireason, len, thislen;
1420 struct request *rq = HWGROUP(drive)->rq;
1421 u8 lowcyl = 0, highcyl = 0;
1424 /* Check for errors. */
1425 if (cdrom_decode_status(drive, 0, &stat))
1428 /* Read the interrupt reason and the transfer length. */
1429 ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1430 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1431 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1433 len = lowcyl + (256 * highcyl);
1435 /* If DRQ is clear, the command has completed.
1436 Complain if we still have data left to transfer. */
1437 if ((stat & DRQ_STAT) == 0) {
1438 /* Some of the trailing request sense fields are optional, and
1439 some drives don't send them. Sigh. */
1440 if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
1442 rq->data_len <= 5) {
1443 while (rq->data_len > 0) {
1444 *(unsigned char *)rq->data++ = 0;
1449 if (rq->data_len == 0)
1450 cdrom_end_request(drive, 1);
1452 /* Comment this out, because this always happens
1453 right after a reset occurs, and it is annoying to
1454 always print expected stuff. */
1456 printk ("%s: cdrom_pc_intr: data underrun %d\n",
1457 drive->name, pc->buflen);
1459 rq->cmd_flags |= REQ_FAILED;
1460 cdrom_end_request(drive, 0);
1465 /* Figure out how much data to transfer. */
1466 thislen = rq->data_len;
1467 if (thislen > len) thislen = len;
1469 /* The drive wants to be written to. */
1470 if ((ireason & 3) == 0) {
1472 blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1475 /* Transfer the data. */
1476 HWIF(drive)->atapi_output_bytes(drive, rq->data, thislen);
1478 /* If we haven't moved enough data to satisfy the drive,
1479 add some padding. */
1480 while (len > thislen) {
1482 HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof(dum));
1486 /* Keep count of how much data we've moved. */
1487 rq->data += thislen;
1488 rq->data_len -= thislen;
1491 /* Same drill for reading. */
1492 else if ((ireason & 3) == 2) {
1494 blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1497 /* Transfer the data. */
1498 HWIF(drive)->atapi_input_bytes(drive, rq->data, thislen);
1500 /* If we haven't moved enough data to satisfy the drive,
1501 add some padding. */
1502 while (len > thislen) {
1504 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1508 /* Keep count of how much data we've moved. */
1509 rq->data += thislen;
1510 rq->data_len -= thislen;
1512 if (blk_sense_request(rq))
1513 rq->sense_len += thislen;
1516 printk (KERN_ERR "%s: cdrom_pc_intr: The drive "
1517 "appears confused (ireason = 0x%02x). "
1518 "Trying to recover by ending request.\n",
1519 drive->name, ireason);
1520 rq->cmd_flags |= REQ_FAILED;
1521 cdrom_end_request(drive, 0);
1525 /* Now we wait for another interrupt. */
1526 ide_set_handler(drive, &cdrom_pc_intr, ATAPI_WAIT_PC, cdrom_timer_expiry);
1530 static ide_startstop_t cdrom_do_pc_continuation (ide_drive_t *drive)
1532 struct request *rq = HWGROUP(drive)->rq;
1535 rq->timeout = ATAPI_WAIT_PC;
1537 /* Send the command to the drive and return. */
1538 return cdrom_transfer_packet_command(drive, rq, &cdrom_pc_intr);
1542 static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
1545 struct request *rq = HWGROUP(drive)->rq;
1546 struct cdrom_info *info = drive->driver_data;
1549 rq->cmd_flags &= ~REQ_FAILED;
1552 /* Start sending the command to the drive. */
1553 return cdrom_start_packet_command(drive, len, cdrom_do_pc_continuation);
1557 static int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
1559 struct request_sense sense;
1561 unsigned int flags = rq->cmd_flags;
1563 if (rq->sense == NULL)
1566 /* Start of retry loop. */
1569 unsigned long time = jiffies;
1570 rq->cmd_flags = flags;
1572 error = ide_do_drive_cmd(drive, rq, ide_wait);
1573 time = jiffies - time;
1575 /* FIXME: we should probably abort/retry or something
1576 * in case of failure */
1577 if (rq->cmd_flags & REQ_FAILED) {
1578 /* The request failed. Retry if it was due to a unit
1580 (usually means media was changed). */
1581 struct request_sense *reqbuf = rq->sense;
1583 if (reqbuf->sense_key == UNIT_ATTENTION)
1584 cdrom_saw_media_change(drive);
1585 else if (reqbuf->sense_key == NOT_READY &&
1586 reqbuf->asc == 4 && reqbuf->ascq != 4) {
1587 /* The drive is in the process of loading
1588 a disk. Retry, but wait a little to give
1589 the drive time to complete the load. */
1592 /* Otherwise, don't retry. */
1598 /* End of retry loop. */
1599 } while ((rq->cmd_flags & REQ_FAILED) && retries >= 0);
1601 /* Return an error if the command failed. */
1602 return (rq->cmd_flags & REQ_FAILED) ? -EIO : 0;
1608 static int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
1610 /* Two notes about IDE interrupt reason here - 0 means that
1611 * the drive wants to receive data from us, 2 means that
1612 * the drive is expecting to transfer data to us.
1616 else if (ireason == 2) {
1617 /* Whoops... The drive wants to send data. */
1618 printk(KERN_ERR "%s: write_intr: wrong transfer direction!\n",
1623 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1627 /* Drive wants a command packet, or invalid ireason... */
1628 printk(KERN_ERR "%s: write_intr: bad interrupt reason %x\n",
1629 drive->name, ireason);
1632 cdrom_end_request(drive, 0);
1636 static void post_transform_command(struct request *req)
1641 if (!blk_pc_request(req))
1645 ibuf = bio_data(req->bio);
1653 * set ansi-revision and response data as atapi
1655 if (c[0] == GPCMD_INQUIRY) {
1657 ibuf[3] = (ibuf[3] & 0xf0) | 2;
1661 typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
1664 * best way to deal with dma that is not sector aligned right now... note
1665 * that in this path we are not using ->data or ->buffer at all. this irs
1666 * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the
1669 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1671 struct cdrom_info *info = drive->driver_data;
1672 struct request *rq = HWGROUP(drive)->rq;
1673 int dma_error, dma, stat, ireason, len, thislen;
1675 xfer_func_t *xferfunc;
1676 unsigned long flags;
1678 /* Check for errors. */
1683 dma_error = HWIF(drive)->ide_dma_end(drive);
1686 if (cdrom_decode_status(drive, 0, &stat))
1690 * using dma, transfer is complete now
1694 printk(KERN_ERR "ide-cd: dma error\n");
1695 __ide_dma_off(drive);
1696 return ide_error(drive, "dma error", stat);
1699 end_that_request_chunk(rq, 1, rq->data_len);
1705 * ok we fall to pio :/
1707 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1708 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1709 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1711 len = lowcyl + (256 * highcyl);
1712 thislen = rq->data_len;
1717 * If DRQ is clear, the command has completed.
1719 if ((stat & DRQ_STAT) == 0)
1723 * check which way to transfer data
1725 if (rq_data_dir(rq) == WRITE) {
1729 if (cdrom_write_check_ireason(drive, len, ireason))
1732 xferfunc = HWIF(drive)->atapi_output_bytes;
1737 if (cdrom_read_check_ireason(drive, len, ireason))
1740 xferfunc = HWIF(drive)->atapi_input_bytes;
1746 while (thislen > 0) {
1747 int blen = blen = rq->data_len;
1748 char *ptr = rq->data;
1754 ptr = bio_data(rq->bio);
1755 blen = bio_iovec(rq->bio)->bv_len;
1759 printk(KERN_ERR "%s: confused, missing data\n", drive->name);
1766 xferfunc(drive, ptr, blen);
1770 rq->data_len -= blen;
1773 end_that_request_chunk(rq, 1, blen);
1785 xferfunc(drive, &pad, sizeof(pad));
1790 BUG_ON(HWGROUP(drive)->handler != NULL);
1792 ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, NULL);
1797 post_transform_command(rq);
1799 spin_lock_irqsave(&ide_lock, flags);
1800 blkdev_dequeue_request(rq);
1801 end_that_request_last(rq, 1);
1802 HWGROUP(drive)->rq = NULL;
1803 spin_unlock_irqrestore(&ide_lock, flags);
1807 static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
1809 int stat, ireason, len, sectors_to_transfer, uptodate;
1810 struct cdrom_info *info = drive->driver_data;
1811 int dma_error = 0, dma = info->dma;
1812 u8 lowcyl = 0, highcyl = 0;
1814 struct request *rq = HWGROUP(drive)->rq;
1816 /* Check for errors. */
1819 if ((dma_error = HWIF(drive)->ide_dma_end(drive))) {
1820 printk(KERN_ERR "ide-cd: write dma error\n");
1821 __ide_dma_off(drive);
1825 if (cdrom_decode_status(drive, 0, &stat))
1829 * using dma, transfer is complete now
1833 return ide_error(drive, "dma error", stat);
1835 ide_end_request(drive, 1, rq->nr_sectors);
1839 /* Read the interrupt reason and the transfer length. */
1840 ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1841 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1842 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1844 len = lowcyl + (256 * highcyl);
1846 /* If DRQ is clear, the command has completed. */
1847 if ((stat & DRQ_STAT) == 0) {
1848 /* If we're not done writing, complain.
1849 * Otherwise, complete the command normally.
1852 if (rq->current_nr_sectors > 0) {
1853 printk(KERN_ERR "%s: write_intr: data underrun (%d blocks)\n",
1854 drive->name, rq->current_nr_sectors);
1857 cdrom_end_request(drive, uptodate);
1861 /* Check that the drive is expecting to do the same thing we are. */
1862 if (cdrom_write_check_ireason(drive, len, ireason))
1865 sectors_to_transfer = len / SECTOR_SIZE;
1868 * now loop and write out the data
1870 while (sectors_to_transfer > 0) {
1873 if (!rq->current_nr_sectors) {
1874 printk(KERN_ERR "ide-cd: write_intr: oops\n");
1879 * Figure out how many sectors we can transfer
1881 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors);
1883 while (this_transfer > 0) {
1884 HWIF(drive)->atapi_output_bytes(drive, rq->buffer, SECTOR_SIZE);
1885 rq->buffer += SECTOR_SIZE;
1887 --rq->current_nr_sectors;
1890 --sectors_to_transfer;
1894 * current buffer complete, move on
1896 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1897 cdrom_end_request(drive, 1);
1900 /* re-arm handler */
1901 ide_set_handler(drive, &cdrom_write_intr, ATAPI_WAIT_PC, NULL);
1905 static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
1907 struct request *rq = HWGROUP(drive)->rq;
1909 #if 0 /* the immediate bit */
1910 rq->cmd[1] = 1 << 3;
1912 rq->timeout = ATAPI_WAIT_PC;
1914 return cdrom_transfer_packet_command(drive, rq, cdrom_write_intr);
1917 static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
1919 struct cdrom_info *info = drive->driver_data;
1920 struct gendisk *g = info->disk;
1921 unsigned short sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1924 * writes *must* be hardware frame aligned
1926 if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1927 (rq->sector & (sectors_per_frame - 1))) {
1928 cdrom_end_request(drive, 0);
1933 * disk has become write protected
1936 cdrom_end_request(drive, 0);
1940 info->nsectors_buffered = 0;
1942 /* use dma, if possible. we don't need to check more, since we
1943 * know that the transfer is always (at least!) frame aligned */
1944 info->dma = drive->using_dma ? 1 : 0;
1946 info->devinfo.media_written = 1;
1948 /* Start sending the write request to the drive. */
1949 return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
1952 static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1954 struct request *rq = HWGROUP(drive)->rq;
1957 rq->timeout = ATAPI_WAIT_PC;
1959 return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1962 static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1964 struct cdrom_info *info = drive->driver_data;
1966 rq->cmd_flags |= REQ_QUIET;
1974 int mask = drive->queue->dma_alignment;
1975 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
1977 info->dma = drive->using_dma;
1980 * check if dma is safe
1982 * NOTE! The "len" and "addr" checks should possibly have
1985 if ((rq->data_len & 15) || (addr & mask))
1989 /* Start sending the command to the drive. */
1990 return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1993 /****************************************************************************
1994 * cdrom driver request routine.
1996 static ide_startstop_t
1997 ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1999 ide_startstop_t action;
2000 struct cdrom_info *info = drive->driver_data;
2002 if (blk_fs_request(rq)) {
2003 if (CDROM_CONFIG_FLAGS(drive)->seeking) {
2004 unsigned long elapsed = jiffies - info->start_seek;
2005 int stat = HWIF(drive)->INB(IDE_STATUS_REG);
2007 if ((stat & SEEK_STAT) != SEEK_STAT) {
2008 if (elapsed < IDECD_SEEK_TIMEOUT) {
2009 ide_stall_queue(drive, IDECD_SEEK_TIMER);
2012 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
2014 CDROM_CONFIG_FLAGS(drive)->seeking = 0;
2016 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
2017 action = cdrom_start_seek(drive, block);
2019 if (rq_data_dir(rq) == READ)
2020 action = cdrom_start_read(drive, block);
2022 action = cdrom_start_write(drive, rq);
2024 info->last_block = block;
2026 } else if (rq->cmd_type == REQ_TYPE_SENSE) {
2027 return cdrom_do_packet_command(drive);
2028 } else if (blk_pc_request(rq)) {
2029 return cdrom_do_block_pc(drive, rq);
2030 } else if (blk_special_request(rq)) {
2032 * right now this can only be a reset...
2034 cdrom_end_request(drive, 1);
2038 blk_dump_rq_flags(rq, "ide-cd bad flags");
2039 cdrom_end_request(drive, 0);
2045 /****************************************************************************
2048 * Routines which queue packet commands take as a final argument a pointer
2049 * to a request_sense struct. If execution of the command results
2050 * in an error with a CHECK CONDITION status, this structure will be filled
2051 * with the results of the subsequent request sense command. The pointer
2052 * can also be NULL, in which case no sense information is returned.
2055 #if ! STANDARD_ATAPI
2059 return (x%10) | ((x/10) << 4);
2066 return (x >> 4) * 10 + (x & 0x0f);
2070 void msf_from_bcd (struct atapi_msf *msf)
2072 msf->minute = bcd2bin (msf->minute);
2073 msf->second = bcd2bin (msf->second);
2074 msf->frame = bcd2bin (msf->frame);
2077 #endif /* not STANDARD_ATAPI */
2081 void lba_to_msf (int lba, byte *m, byte *s, byte *f)
2083 lba += CD_MSF_OFFSET;
2084 lba &= 0xffffff; /* negative lbas use only 24 bits */
2085 *m = lba / (CD_SECS * CD_FRAMES);
2086 lba %= (CD_SECS * CD_FRAMES);
2087 *s = lba / CD_FRAMES;
2088 *f = lba % CD_FRAMES;
2093 int msf_to_lba (byte m, byte s, byte f)
2095 return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
2098 static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
2101 struct cdrom_info *info = drive->driver_data;
2102 struct cdrom_device_info *cdi = &info->devinfo;
2104 cdrom_prepare_request(drive, &req);
2107 req.cmd[0] = GPCMD_TEST_UNIT_READY;
2108 req.cmd_flags |= REQ_QUIET;
2110 #if ! STANDARD_ATAPI
2111 /* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
2112 switch CDs instead of supporting the LOAD_UNLOAD opcode */
2114 req.cmd[7] = cdi->sanyo_slot % 3;
2115 #endif /* not STANDARD_ATAPI */
2117 return cdrom_queue_packet_command(drive, &req);
2121 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
2123 cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
2125 struct request_sense my_sense;
2132 /* If the drive cannot lock the door, just pretend. */
2133 if (CDROM_CONFIG_FLAGS(drive)->no_doorlock) {
2136 cdrom_prepare_request(drive, &req);
2138 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
2139 req.cmd[4] = lockflag ? 1 : 0;
2140 stat = cdrom_queue_packet_command(drive, &req);
2143 /* If we got an illegal field error, the drive
2144 probably cannot lock the door. */
2146 sense->sense_key == ILLEGAL_REQUEST &&
2147 (sense->asc == 0x24 || sense->asc == 0x20)) {
2148 printk (KERN_ERR "%s: door locking not supported\n",
2150 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2154 /* no medium, that's alright. */
2155 if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
2159 CDROM_STATE_FLAGS(drive)->door_locked = lockflag;
2165 /* Eject the disk if EJECTFLAG is 0.
2166 If EJECTFLAG is 1, try to reload the disk. */
2167 static int cdrom_eject(ide_drive_t *drive, int ejectflag,
2168 struct request_sense *sense)
2173 if (CDROM_CONFIG_FLAGS(drive)->no_eject && !ejectflag)
2174 return -EDRIVE_CANT_DO_THIS;
2176 /* reload fails on some drives, if the tray is locked */
2177 if (CDROM_STATE_FLAGS(drive)->door_locked && ejectflag)
2180 cdrom_prepare_request(drive, &req);
2182 /* only tell drive to close tray if open, if it can do that */
2183 if (ejectflag && !CDROM_CONFIG_FLAGS(drive)->close_tray)
2187 req.cmd[0] = GPCMD_START_STOP_UNIT;
2188 req.cmd[4] = loej | (ejectflag != 0);
2189 return cdrom_queue_packet_command(drive, &req);
2192 static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
2193 unsigned long *sectors_per_frame,
2194 struct request_sense *sense)
2204 cdrom_prepare_request(drive, &req);
2207 req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
2208 req.data = (char *)&capbuf;
2209 req.data_len = sizeof(capbuf);
2210 req.cmd_flags |= REQ_QUIET;
2212 stat = cdrom_queue_packet_command(drive, &req);
2214 *capacity = 1 + be32_to_cpu(capbuf.lba);
2215 *sectors_per_frame =
2216 be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
2222 static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
2223 int format, char *buf, int buflen,
2224 struct request_sense *sense)
2228 cdrom_prepare_request(drive, &req);
2232 req.data_len = buflen;
2233 req.cmd_flags |= REQ_QUIET;
2234 req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
2235 req.cmd[6] = trackno;
2236 req.cmd[7] = (buflen >> 8);
2237 req.cmd[8] = (buflen & 0xff);
2238 req.cmd[9] = (format << 6);
2243 return cdrom_queue_packet_command(drive, &req);
2247 /* Try to read the entire TOC for the disk into our internal buffer. */
2248 static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2250 int stat, ntracks, i;
2251 struct cdrom_info *info = drive->driver_data;
2252 struct cdrom_device_info *cdi = &info->devinfo;
2253 struct atapi_toc *toc = info->toc;
2255 struct atapi_toc_header hdr;
2256 struct atapi_toc_entry ent;
2259 unsigned long sectors_per_frame = SECTORS_PER_FRAME;
2262 /* Try to allocate space. */
2263 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
2265 printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
2271 /* Check to see if the existing data is still valid.
2272 If it is, just return. */
2273 (void) cdrom_check_status(drive, sense);
2275 if (CDROM_STATE_FLAGS(drive)->toc_valid)
2278 /* Try to get the total cdrom capacity and sector size. */
2279 stat = cdrom_read_capacity(drive, &toc->capacity, §ors_per_frame,
2282 toc->capacity = 0x1fffff;
2284 set_capacity(info->disk, toc->capacity * sectors_per_frame);
2285 /* Save a private copy of te TOC capacity for error handling */
2286 drive->probed_capacity = toc->capacity * sectors_per_frame;
2288 blk_queue_hardsect_size(drive->queue,
2289 sectors_per_frame << SECTOR_BITS);
2291 /* First read just the header, so we know how long the TOC is. */
2292 stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
2293 sizeof(struct atapi_toc_header), sense);
2297 #if ! STANDARD_ATAPI
2298 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2299 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2300 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2302 #endif /* not STANDARD_ATAPI */
2304 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2307 if (ntracks > MAX_TRACKS)
2308 ntracks = MAX_TRACKS;
2310 /* Now read the whole schmeer. */
2311 stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
2313 sizeof(struct atapi_toc_header) +
2315 sizeof(struct atapi_toc_entry), sense);
2317 if (stat && toc->hdr.first_track > 1) {
2318 /* Cds with CDI tracks only don't have any TOC entries,
2319 despite of this the returned values are
2320 first_track == last_track = number of CDI tracks + 1,
2321 so that this case is indistinguishable from the same
2322 layout plus an additional audio track.
2323 If we get an error for the regular case, we assume
2324 a CDI without additional audio tracks. In this case
2325 the readable TOC is empty (CDI tracks are not included)
2326 and only holds the Leadout entry. Heiko Eißfeldt */
2328 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
2330 sizeof(struct atapi_toc_header) +
2332 sizeof(struct atapi_toc_entry),
2337 #if ! STANDARD_ATAPI
2338 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2339 toc->hdr.first_track = bin2bcd(CDROM_LEADOUT);
2340 toc->hdr.last_track = bin2bcd(CDROM_LEADOUT);
2342 #endif /* not STANDARD_ATAPI */
2344 toc->hdr.first_track = CDROM_LEADOUT;
2345 toc->hdr.last_track = CDROM_LEADOUT;
2352 toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
2354 #if ! STANDARD_ATAPI
2355 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2356 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2357 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2359 #endif /* not STANDARD_ATAPI */
2361 for (i=0; i<=ntracks; i++) {
2362 #if ! STANDARD_ATAPI
2363 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2364 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd)
2365 toc->ent[i].track = bcd2bin(toc->ent[i].track);
2366 msf_from_bcd(&toc->ent[i].addr.msf);
2368 #endif /* not STANDARD_ATAPI */
2369 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
2370 toc->ent[i].addr.msf.second,
2371 toc->ent[i].addr.msf.frame);
2374 /* Read the multisession information. */
2375 if (toc->hdr.first_track != CDROM_LEADOUT) {
2376 /* Read the multisession information. */
2377 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
2378 sizeof(ms_tmp), sense);
2382 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
2384 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
2385 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
2388 #if ! STANDARD_ATAPI
2389 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2390 /* Re-read multisession information using MSF format */
2391 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
2392 sizeof(ms_tmp), sense);
2396 msf_from_bcd (&ms_tmp.ent.addr.msf);
2397 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
2398 ms_tmp.ent.addr.msf.second,
2399 ms_tmp.ent.addr.msf.frame);
2401 #endif /* not STANDARD_ATAPI */
2403 toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
2405 /* Now try to get the total cdrom capacity. */
2406 stat = cdrom_get_last_written(cdi, &last_written);
2407 if (!stat && (last_written > toc->capacity)) {
2408 toc->capacity = last_written;
2409 set_capacity(info->disk, toc->capacity * sectors_per_frame);
2410 drive->probed_capacity = toc->capacity * sectors_per_frame;
2413 /* Remember that we've read this stuff. */
2414 CDROM_STATE_FLAGS(drive)->toc_valid = 1;
2420 static int cdrom_read_subchannel(ide_drive_t *drive, int format, char *buf,
2421 int buflen, struct request_sense *sense)
2425 cdrom_prepare_request(drive, &req);
2429 req.data_len = buflen;
2430 req.cmd[0] = GPCMD_READ_SUBCHANNEL;
2431 req.cmd[1] = 2; /* MSF addressing */
2432 req.cmd[2] = 0x40; /* request subQ data */
2433 req.cmd[3] = format;
2434 req.cmd[7] = (buflen >> 8);
2435 req.cmd[8] = (buflen & 0xff);
2436 return cdrom_queue_packet_command(drive, &req);
2439 /* ATAPI cdrom drives are free to select the speed you request or any slower
2440 rate :-( Requesting too fast a speed will _not_ produce an error. */
2441 static int cdrom_select_speed(ide_drive_t *drive, int speed,
2442 struct request_sense *sense)
2445 cdrom_prepare_request(drive, &req);
2449 speed = 0xffff; /* set to max */
2451 speed *= 177; /* Nx to kbytes/s */
2453 req.cmd[0] = GPCMD_SET_SPEED;
2454 /* Read Drive speed in kbytes/second MSB */
2455 req.cmd[2] = (speed >> 8) & 0xff;
2456 /* Read Drive speed in kbytes/second LSB */
2457 req.cmd[3] = speed & 0xff;
2458 if (CDROM_CONFIG_FLAGS(drive)->cd_r ||
2459 CDROM_CONFIG_FLAGS(drive)->cd_rw ||
2460 CDROM_CONFIG_FLAGS(drive)->dvd_r) {
2461 /* Write Drive speed in kbytes/second MSB */
2462 req.cmd[4] = (speed >> 8) & 0xff;
2463 /* Write Drive speed in kbytes/second LSB */
2464 req.cmd[5] = speed & 0xff;
2467 return cdrom_queue_packet_command(drive, &req);
2470 static int cdrom_play_audio(ide_drive_t *drive, int lba_start, int lba_end)
2472 struct request_sense sense;
2475 cdrom_prepare_request(drive, &req);
2478 req.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2479 lba_to_msf(lba_start, &req.cmd[3], &req.cmd[4], &req.cmd[5]);
2480 lba_to_msf(lba_end-1, &req.cmd[6], &req.cmd[7], &req.cmd[8]);
2482 return cdrom_queue_packet_command(drive, &req);
2485 static int cdrom_get_toc_entry(ide_drive_t *drive, int track,
2486 struct atapi_toc_entry **ent)
2488 struct cdrom_info *info = drive->driver_data;
2489 struct atapi_toc *toc = info->toc;
2493 * don't serve cached data, if the toc isn't valid
2495 if (!CDROM_STATE_FLAGS(drive)->toc_valid)
2498 /* Check validity of requested track number. */
2499 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2500 if (toc->hdr.first_track == CDROM_LEADOUT) ntracks = 0;
2501 if (track == CDROM_LEADOUT)
2502 *ent = &toc->ent[ntracks];
2503 else if (track < toc->hdr.first_track ||
2504 track > toc->hdr.last_track)
2507 *ent = &toc->ent[track - toc->hdr.first_track];
2512 /* the generic packet interface to cdrom.c */
2513 static int ide_cdrom_packet(struct cdrom_device_info *cdi,
2514 struct packet_command *cgc)
2517 ide_drive_t *drive = cdi->handle;
2519 if (cgc->timeout <= 0)
2520 cgc->timeout = ATAPI_WAIT_PC;
2522 /* here we queue the commands from the uniform CD-ROM
2523 layer. the packet must be complete, as we do not
2525 cdrom_prepare_request(drive, &req);
2526 memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
2528 memset(cgc->sense, 0, sizeof(struct request_sense));
2529 req.data = cgc->buffer;
2530 req.data_len = cgc->buflen;
2531 req.timeout = cgc->timeout;
2534 req.cmd_flags |= REQ_QUIET;
2536 req.sense = cgc->sense;
2537 cgc->stat = cdrom_queue_packet_command(drive, &req);
2539 cgc->buflen -= req.data_len;
2544 int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
2545 unsigned int cmd, void *arg)
2548 ide_drive_t *drive = cdi->handle;
2549 struct cdrom_info *info = drive->driver_data;
2554 * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
2555 * atapi doesn't support it
2557 case CDROMPLAYTRKIND: {
2558 unsigned long lba_start, lba_end;
2559 struct cdrom_ti *ti = arg;
2560 struct atapi_toc_entry *first_toc, *last_toc;
2562 stat = cdrom_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
2566 stat = cdrom_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
2570 if (ti->cdti_trk1 != CDROM_LEADOUT)
2572 lba_start = first_toc->addr.lba;
2573 lba_end = last_toc->addr.lba;
2575 if (lba_end <= lba_start)
2578 return cdrom_play_audio(drive, lba_start, lba_end);
2581 case CDROMREADTOCHDR: {
2582 struct cdrom_tochdr *tochdr = arg;
2583 struct atapi_toc *toc;
2585 /* Make sure our saved TOC is valid. */
2586 stat = cdrom_read_toc(drive, NULL);
2591 tochdr->cdth_trk0 = toc->hdr.first_track;
2592 tochdr->cdth_trk1 = toc->hdr.last_track;
2597 case CDROMREADTOCENTRY: {
2598 struct cdrom_tocentry *tocentry = arg;
2599 struct atapi_toc_entry *toce;
2601 stat = cdrom_get_toc_entry(drive, tocentry->cdte_track, &toce);
2605 tocentry->cdte_ctrl = toce->control;
2606 tocentry->cdte_adr = toce->adr;
2607 if (tocentry->cdte_format == CDROM_MSF) {
2608 lba_to_msf (toce->addr.lba,
2609 &tocentry->cdte_addr.msf.minute,
2610 &tocentry->cdte_addr.msf.second,
2611 &tocentry->cdte_addr.msf.frame);
2613 tocentry->cdte_addr.lba = toce->addr.lba;
2624 int ide_cdrom_reset (struct cdrom_device_info *cdi)
2626 ide_drive_t *drive = cdi->handle;
2627 struct request_sense sense;
2631 cdrom_prepare_request(drive, &req);
2632 req.cmd_type = REQ_TYPE_SPECIAL;
2633 req.cmd_flags = REQ_QUIET;
2634 ret = ide_do_drive_cmd(drive, &req, ide_wait);
2637 * A reset will unlock the door. If it was previously locked,
2640 if (CDROM_STATE_FLAGS(drive)->door_locked)
2641 (void) cdrom_lockdoor(drive, 1, &sense);
2648 int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
2650 ide_drive_t *drive = cdi->handle;
2651 struct request_sense sense;
2654 int stat = cdrom_lockdoor(drive, 0, &sense);
2659 return cdrom_eject(drive, !position, &sense);
2663 int ide_cdrom_lock_door (struct cdrom_device_info *cdi, int lock)
2665 ide_drive_t *drive = cdi->handle;
2666 return cdrom_lockdoor(drive, lock, NULL);
2670 int ide_cdrom_get_capabilities(ide_drive_t *drive, struct atapi_capabilities_page *cap)
2672 struct cdrom_info *info = drive->driver_data;
2673 struct cdrom_device_info *cdi = &info->devinfo;
2674 struct packet_command cgc;
2675 int stat, attempts = 3, size = sizeof(*cap);
2678 * ACER50 (and others?) require the full spec length mode sense
2679 * page capabilities size, but older drives break.
2681 if (!(!strcmp(drive->id->model, "ATAPI CD ROM DRIVE 50X MAX") ||
2682 !strcmp(drive->id->model, "WPI CDS-32X")))
2683 size -= sizeof(cap->pad);
2685 init_cdrom_command(&cgc, cap, size, CGC_DATA_UNKNOWN);
2686 do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2687 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
2690 } while (--attempts);
2695 void ide_cdrom_update_speed (ide_drive_t *drive, struct atapi_capabilities_page *cap)
2697 /* The ACER/AOpen 24X cdrom has the speed fields byte-swapped */
2698 if (!drive->id->model[0] &&
2699 !strncmp(drive->id->fw_rev, "241N", 4)) {
2700 CDROM_STATE_FLAGS(drive)->current_speed =
2701 (((unsigned int)cap->curspeed) + (176/2)) / 176;
2702 CDROM_CONFIG_FLAGS(drive)->max_speed =
2703 (((unsigned int)cap->maxspeed) + (176/2)) / 176;
2705 CDROM_STATE_FLAGS(drive)->current_speed =
2706 (ntohs(cap->curspeed) + (176/2)) / 176;
2707 CDROM_CONFIG_FLAGS(drive)->max_speed =
2708 (ntohs(cap->maxspeed) + (176/2)) / 176;
2713 int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
2715 ide_drive_t *drive = cdi->handle;
2716 struct request_sense sense;
2717 struct atapi_capabilities_page cap;
2720 if ((stat = cdrom_select_speed(drive, speed, &sense)) < 0)
2723 if (!ide_cdrom_get_capabilities(drive, &cap)) {
2724 ide_cdrom_update_speed(drive, &cap);
2725 cdi->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2731 * add logic to try GET_EVENT command first to check for media and tray
2732 * status. this should be supported by newer cd-r/w and all DVD etc
2736 int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
2738 ide_drive_t *drive = cdi->handle;
2739 struct media_event_desc med;
2740 struct request_sense sense;
2743 if (slot_nr != CDSL_CURRENT)
2746 stat = cdrom_check_status(drive, &sense);
2747 if (!stat || sense.sense_key == UNIT_ATTENTION)
2750 if (!cdrom_get_media_event(cdi, &med)) {
2751 if (med.media_present)
2753 else if (med.door_open)
2754 return CDS_TRAY_OPEN;
2759 if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
2763 * If not using Mt Fuji extended media tray reports,
2764 * just return TRAY_OPEN since ATAPI doesn't provide
2765 * any other way to detect this...
2767 if (sense.sense_key == NOT_READY) {
2768 if (sense.asc == 0x3a && sense.ascq == 1)
2771 return CDS_TRAY_OPEN;
2773 return CDS_DRIVE_NOT_READY;
2777 int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
2778 struct cdrom_multisession *ms_info)
2780 struct atapi_toc *toc;
2781 ide_drive_t *drive = cdi->handle;
2782 struct cdrom_info *info = drive->driver_data;
2783 struct request_sense sense;
2786 if (!CDROM_STATE_FLAGS(drive)->toc_valid || info->toc == NULL)
2787 if ((ret = cdrom_read_toc(drive, &sense)))
2791 ms_info->addr.lba = toc->last_session_lba;
2792 ms_info->xa_flag = toc->xa_flag;
2798 int ide_cdrom_get_mcn (struct cdrom_device_info *cdi,
2799 struct cdrom_mcn *mcn_info)
2803 ide_drive_t *drive = cdi->handle;
2806 if ((stat = cdrom_read_subchannel(drive, 2, mcnbuf, sizeof (mcnbuf), NULL)))
2809 memcpy (mcn_info->medium_catalog_number, mcnbuf+9,
2810 sizeof (mcn_info->medium_catalog_number)-1);
2811 mcn_info->medium_catalog_number[sizeof (mcn_info->medium_catalog_number)-1]
2819 /****************************************************************************
2820 * Other driver requests (open, close, check media change).
2824 int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
2827 ide_drive_t *drive = cdi->handle;
2830 if (slot_nr == CDSL_CURRENT) {
2831 (void) cdrom_check_status(drive, NULL);
2832 retval = CDROM_STATE_FLAGS(drive)->media_changed;
2833 CDROM_STATE_FLAGS(drive)->media_changed = 0;
2842 int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
2848 * Close down the device. Invalidate all cached blocks.
2852 void ide_cdrom_release_real (struct cdrom_device_info *cdi)
2854 ide_drive_t *drive = cdi->handle;
2856 if (!cdi->use_count)
2857 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
2862 /****************************************************************************
2863 * Device initialization.
2865 static struct cdrom_device_ops ide_cdrom_dops = {
2866 .open = ide_cdrom_open_real,
2867 .release = ide_cdrom_release_real,
2868 .drive_status = ide_cdrom_drive_status,
2869 .media_changed = ide_cdrom_check_media_change_real,
2870 .tray_move = ide_cdrom_tray_move,
2871 .lock_door = ide_cdrom_lock_door,
2872 .select_speed = ide_cdrom_select_speed,
2873 .get_last_session = ide_cdrom_get_last_session,
2874 .get_mcn = ide_cdrom_get_mcn,
2875 .reset = ide_cdrom_reset,
2876 .audio_ioctl = ide_cdrom_audio_ioctl,
2877 .capability = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
2878 CDC_SELECT_SPEED | CDC_SELECT_DISC |
2879 CDC_MULTI_SESSION | CDC_MCN |
2880 CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO | CDC_RESET |
2881 CDC_DRIVE_STATUS | CDC_CD_R |
2882 CDC_CD_RW | CDC_DVD | CDC_DVD_R| CDC_DVD_RAM |
2883 CDC_GENERIC_PACKET | CDC_MO_DRIVE | CDC_MRW |
2884 CDC_MRW_W | CDC_RAM,
2885 .generic_packet = ide_cdrom_packet,
2888 static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2890 struct cdrom_info *info = drive->driver_data;
2891 struct cdrom_device_info *devinfo = &info->devinfo;
2893 devinfo->ops = &ide_cdrom_dops;
2895 devinfo->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2896 devinfo->capacity = nslots;
2897 devinfo->handle = drive;
2898 strcpy(devinfo->name, drive->name);
2900 /* set capability mask to match the probe. */
2901 if (!CDROM_CONFIG_FLAGS(drive)->cd_r)
2902 devinfo->mask |= CDC_CD_R;
2903 if (!CDROM_CONFIG_FLAGS(drive)->cd_rw)
2904 devinfo->mask |= CDC_CD_RW;
2905 if (!CDROM_CONFIG_FLAGS(drive)->dvd)
2906 devinfo->mask |= CDC_DVD;
2907 if (!CDROM_CONFIG_FLAGS(drive)->dvd_r)
2908 devinfo->mask |= CDC_DVD_R;
2909 if (!CDROM_CONFIG_FLAGS(drive)->dvd_ram)
2910 devinfo->mask |= CDC_DVD_RAM;
2911 if (!CDROM_CONFIG_FLAGS(drive)->is_changer)
2912 devinfo->mask |= CDC_SELECT_DISC;
2913 if (!CDROM_CONFIG_FLAGS(drive)->audio_play)
2914 devinfo->mask |= CDC_PLAY_AUDIO;
2915 if (!CDROM_CONFIG_FLAGS(drive)->close_tray)
2916 devinfo->mask |= CDC_CLOSE_TRAY;
2917 if (!CDROM_CONFIG_FLAGS(drive)->mo_drive)
2918 devinfo->mask |= CDC_MO_DRIVE;
2919 if (!CDROM_CONFIG_FLAGS(drive)->ram)
2920 devinfo->mask |= CDC_RAM;
2922 devinfo->disk = info->disk;
2923 return register_cdrom(devinfo);
2927 int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2929 struct cdrom_info *info = drive->driver_data;
2930 struct cdrom_device_info *cdi = &info->devinfo;
2931 struct atapi_capabilities_page cap;
2934 if (drive->media == ide_optical) {
2935 CDROM_CONFIG_FLAGS(drive)->mo_drive = 1;
2936 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2937 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
2941 if (CDROM_CONFIG_FLAGS(drive)->nec260 ||
2942 !strcmp(drive->id->model,"STINGRAY 8422 IDE 8X CD-ROM 7-27-95")) {
2943 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2944 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2949 * we have to cheat a little here. the packet will eventually
2950 * be queued with ide_cdrom_packet(), which extracts the
2951 * drive from cdi->handle. Since this device hasn't been
2952 * registered with the Uniform layer yet, it can't do this.
2953 * Same goes for cdi->ops.
2955 cdi->handle = drive;
2956 cdi->ops = &ide_cdrom_dops;
2958 if (ide_cdrom_get_capabilities(drive, &cap))
2962 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2964 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2966 CDROM_CONFIG_FLAGS(drive)->cd_r = 1;
2967 if (cap.cd_rw_write) {
2968 CDROM_CONFIG_FLAGS(drive)->cd_rw = 1;
2969 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2972 CDROM_CONFIG_FLAGS(drive)->test_write = 1;
2973 if (cap.dvd_ram_read || cap.dvd_r_read || cap.dvd_rom)
2974 CDROM_CONFIG_FLAGS(drive)->dvd = 1;
2975 if (cap.dvd_ram_write) {
2976 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 1;
2977 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2979 if (cap.dvd_r_write)
2980 CDROM_CONFIG_FLAGS(drive)->dvd_r = 1;
2982 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2983 if (cap.mechtype == mechtype_caddy || cap.mechtype == mechtype_popup)
2984 CDROM_CONFIG_FLAGS(drive)->close_tray = 0;
2986 /* Some drives used by Apple don't advertise audio play
2987 * but they do support reading TOC & audio datas
2989 if (strcmp(drive->id->model, "MATSHITADVD-ROM SR-8187") == 0 ||
2990 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8186") == 0 ||
2991 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8176") == 0 ||
2992 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8174") == 0)
2993 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2995 #if ! STANDARD_ATAPI
2996 if (cdi->sanyo_slot > 0) {
2997 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
3002 #endif /* not STANDARD_ATAPI */
3003 if (cap.mechtype == mechtype_individual_changer ||
3004 cap.mechtype == mechtype_cartridge_changer) {
3005 if ((nslots = cdrom_number_of_slots(cdi)) > 1) {
3006 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
3007 CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 1;
3011 ide_cdrom_update_speed(drive, &cap);
3012 /* don't print speed if the drive reported 0.
3014 printk(KERN_INFO "%s: ATAPI", drive->name);
3015 if (CDROM_CONFIG_FLAGS(drive)->max_speed)
3016 printk(" %dX", CDROM_CONFIG_FLAGS(drive)->max_speed);
3017 printk(" %s", CDROM_CONFIG_FLAGS(drive)->dvd ? "DVD-ROM" : "CD-ROM");
3019 if (CDROM_CONFIG_FLAGS(drive)->dvd_r|CDROM_CONFIG_FLAGS(drive)->dvd_ram)
3021 (CDROM_CONFIG_FLAGS(drive)->dvd_r)? "-R" : "",
3022 (CDROM_CONFIG_FLAGS(drive)->dvd_ram)? "-RAM" : "");
3024 if (CDROM_CONFIG_FLAGS(drive)->cd_r|CDROM_CONFIG_FLAGS(drive)->cd_rw)
3026 (CDROM_CONFIG_FLAGS(drive)->cd_r)? "-R" : "",
3027 (CDROM_CONFIG_FLAGS(drive)->cd_rw)? "/RW" : "");
3029 if (CDROM_CONFIG_FLAGS(drive)->is_changer)
3030 printk(" changer w/%d slots", nslots);
3034 printk(", %dkB Cache", be16_to_cpu(cap.buffer_size));
3036 if (drive->using_dma)
3037 ide_dma_verbose(drive);
3044 static void ide_cdrom_add_settings(ide_drive_t *drive)
3046 ide_add_setting(drive, "dsc_overlap", SETTING_RW, -1, -1, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
3050 * standard prep_rq_fn that builds 10 byte cmds
3052 static int ide_cdrom_prep_fs(request_queue_t *q, struct request *rq)
3054 int hard_sect = queue_hardsect_size(q);
3055 long block = (long)rq->hard_sector / (hard_sect >> 9);
3056 unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
3058 memset(rq->cmd, 0, sizeof(rq->cmd));
3060 if (rq_data_dir(rq) == READ)
3061 rq->cmd[0] = GPCMD_READ_10;
3063 rq->cmd[0] = GPCMD_WRITE_10;
3068 rq->cmd[2] = (block >> 24) & 0xff;
3069 rq->cmd[3] = (block >> 16) & 0xff;
3070 rq->cmd[4] = (block >> 8) & 0xff;
3071 rq->cmd[5] = block & 0xff;
3074 * and transfer length
3076 rq->cmd[7] = (blocks >> 8) & 0xff;
3077 rq->cmd[8] = blocks & 0xff;
3083 * Most of the SCSI commands are supported directly by ATAPI devices.
3084 * This transform handles the few exceptions.
3086 static int ide_cdrom_prep_pc(struct request *rq)
3091 * Transform 6-byte read/write commands to the 10-byte version
3093 if (c[0] == READ_6 || c[0] == WRITE_6) {
3100 c[0] += (READ_10 - READ_6);
3106 * it's silly to pretend we understand 6-byte sense commands, just
3107 * reject with ILLEGAL_REQUEST and the caller should take the
3108 * appropriate action
3110 if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
3111 rq->errors = ILLEGAL_REQUEST;
3112 return BLKPREP_KILL;
3118 static int ide_cdrom_prep_fn(request_queue_t *q, struct request *rq)
3120 if (blk_fs_request(rq))
3121 return ide_cdrom_prep_fs(q, rq);
3122 else if (blk_pc_request(rq))
3123 return ide_cdrom_prep_pc(rq);
3129 int ide_cdrom_setup (ide_drive_t *drive)
3131 struct cdrom_info *info = drive->driver_data;
3132 struct cdrom_device_info *cdi = &info->devinfo;
3135 blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
3136 blk_queue_dma_alignment(drive->queue, 31);
3137 drive->queue->unplug_delay = (1 * HZ) / 1000;
3138 if (!drive->queue->unplug_delay)
3139 drive->queue->unplug_delay = 1;
3141 drive->special.all = 0;
3143 CDROM_STATE_FLAGS(drive)->media_changed = 1;
3144 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
3145 CDROM_STATE_FLAGS(drive)->door_locked = 0;
3148 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
3150 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 0;
3153 CDROM_CONFIG_FLAGS(drive)->drq_interrupt = ((drive->id->config & 0x0060) == 0x20);
3154 CDROM_CONFIG_FLAGS(drive)->is_changer = 0;
3155 CDROM_CONFIG_FLAGS(drive)->cd_r = 0;
3156 CDROM_CONFIG_FLAGS(drive)->cd_rw = 0;
3157 CDROM_CONFIG_FLAGS(drive)->test_write = 0;
3158 CDROM_CONFIG_FLAGS(drive)->dvd = 0;
3159 CDROM_CONFIG_FLAGS(drive)->dvd_r = 0;
3160 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 0;
3161 CDROM_CONFIG_FLAGS(drive)->no_eject = 1;
3162 CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 0;
3163 CDROM_CONFIG_FLAGS(drive)->audio_play = 0;
3164 CDROM_CONFIG_FLAGS(drive)->close_tray = 1;
3166 /* limit transfer size per interrupt. */
3167 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 0;
3168 /* a testament to the nice quality of Samsung drives... */
3169 if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2430"))
3170 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3171 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2432"))
3172 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3173 /* the 3231 model does not support the SET_CD_SPEED command */
3174 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-3231"))
3175 cdi->mask |= CDC_SELECT_SPEED;
3177 #if ! STANDARD_ATAPI
3178 /* by default Sanyo 3 CD changer support is turned off and
3179 ATAPI Rev 2.2+ standard support for CD changers is used */
3180 cdi->sanyo_slot = 0;
3182 CDROM_CONFIG_FLAGS(drive)->nec260 = 0;
3183 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 0;
3184 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 0;
3185 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 0;
3186 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 0;
3188 if (strcmp (drive->id->model, "V003S0DS") == 0 &&
3189 drive->id->fw_rev[4] == '1' &&
3190 drive->id->fw_rev[6] <= '2') {
3192 Some versions of this drive like to talk BCD. */
3193 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3194 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3195 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3196 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3199 else if (strcmp (drive->id->model, "V006E0DS") == 0 &&
3200 drive->id->fw_rev[4] == '1' &&
3201 drive->id->fw_rev[6] <= '2') {
3202 /* Vertos 600 ESD. */
3203 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3205 else if (strcmp(drive->id->model, "NEC CD-ROM DRIVE:260") == 0 &&
3206 strncmp(drive->id->fw_rev, "1.01", 4) == 0) { /* FIXME */
3207 /* Old NEC260 (not R).
3208 This drive was released before the 1.2 version
3210 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3211 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3212 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3213 CDROM_CONFIG_FLAGS(drive)->nec260 = 1;
3215 else if (strcmp(drive->id->model, "WEARNES CDD-120") == 0 &&
3216 strncmp(drive->id->fw_rev, "A1.1", 4) == 0) { /* FIXME */
3218 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3219 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3221 /* Sanyo 3 CD changer uses a non-standard command
3223 else if ((strcmp(drive->id->model, "CD-ROM CDR-C3 G") == 0) ||
3224 (strcmp(drive->id->model, "CD-ROM CDR-C3G") == 0) ||
3225 (strcmp(drive->id->model, "CD-ROM CDR_C36") == 0)) {
3226 /* uses CD in slot 0 when value is set to 3 */
3227 cdi->sanyo_slot = 3;
3229 #endif /* not STANDARD_ATAPI */
3232 info->buffer = NULL;
3233 info->sector_buffered = 0;
3234 info->nsectors_buffered = 0;
3235 info->changer_info = NULL;
3236 info->last_block = 0;
3237 info->start_seek = 0;
3239 nslots = ide_cdrom_probe_capabilities (drive);
3242 * set correct block size
3244 blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
3246 if (drive->autotune == IDE_TUNE_DEFAULT ||
3247 drive->autotune == IDE_TUNE_AUTO)
3248 drive->dsc_overlap = (drive->next != drive);
3250 drive->dsc_overlap = (HWIF(drive)->no_dsc) ? 0 : 1;
3251 if (HWIF(drive)->no_dsc) {
3252 printk(KERN_INFO "ide-cd: %s: disabling DSC overlap\n",
3254 drive->dsc_overlap = 0;
3258 if (ide_cdrom_register(drive, nslots)) {
3259 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
3260 info->devinfo.handle = NULL;
3263 ide_cdrom_add_settings(drive);
3267 #ifdef CONFIG_PROC_FS
3269 sector_t ide_cdrom_capacity (ide_drive_t *drive)
3271 unsigned long capacity, sectors_per_frame;
3273 if (cdrom_read_capacity(drive, &capacity, §ors_per_frame, NULL))
3276 return capacity * sectors_per_frame;
3280 static void ide_cd_remove(ide_drive_t *drive)
3282 struct cdrom_info *info = drive->driver_data;
3284 ide_unregister_subdriver(drive, info->driver);
3286 del_gendisk(info->disk);
3291 static void ide_cd_release(struct kref *kref)
3293 struct cdrom_info *info = to_ide_cd(kref);
3294 struct cdrom_device_info *devinfo = &info->devinfo;
3295 ide_drive_t *drive = info->drive;
3296 struct gendisk *g = info->disk;
3298 kfree(info->buffer);
3300 kfree(info->changer_info);
3301 if (devinfo->handle == drive && unregister_cdrom(devinfo))
3302 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom "
3303 "driver.\n", __FUNCTION__, drive->name);
3304 drive->dsc_overlap = 0;
3305 drive->driver_data = NULL;
3306 blk_queue_prep_rq(drive->queue, NULL);
3307 g->private_data = NULL;
3312 static int ide_cd_probe(ide_drive_t *);
3314 #ifdef CONFIG_PROC_FS
3315 static int proc_idecd_read_capacity
3316 (char *page, char **start, off_t off, int count, int *eof, void *data)
3318 ide_drive_t *drive = data;
3321 len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
3322 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
3325 static ide_proc_entry_t idecd_proc[] = {
3326 { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
3327 { NULL, 0, NULL, NULL }
3330 # define idecd_proc NULL
3333 static ide_driver_t ide_cdrom_driver = {
3335 .owner = THIS_MODULE,
3336 .name = "ide-cdrom",
3337 .bus = &ide_bus_type,
3339 .probe = ide_cd_probe,
3340 .remove = ide_cd_remove,
3341 .version = IDECD_VERSION,
3343 .supports_dsc_overlap = 1,
3344 .do_request = ide_do_rw_cdrom,
3345 .end_request = ide_end_request,
3346 .error = __ide_error,
3347 .abort = __ide_abort,
3351 static int idecd_open(struct inode * inode, struct file * file)
3353 struct gendisk *disk = inode->i_bdev->bd_disk;
3354 struct cdrom_info *info;
3358 if (!(info = ide_cd_get(disk)))
3361 drive = info->drive;
3366 info->buffer = kmalloc(SECTOR_BUFFER_SIZE,
3367 GFP_KERNEL|__GFP_REPEAT);
3368 if (!info->buffer || (rc = cdrom_open(&info->devinfo, inode, file)))
3377 static int idecd_release(struct inode * inode, struct file * file)
3379 struct gendisk *disk = inode->i_bdev->bd_disk;
3380 struct cdrom_info *info = ide_cd_g(disk);
3381 ide_drive_t *drive = info->drive;
3383 cdrom_release (&info->devinfo, file);
3391 static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg)
3393 struct packet_command cgc;
3398 if (copy_from_user(&spindown, (void __user *)arg, sizeof(char)))
3401 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
3403 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
3407 buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
3408 return cdrom_mode_select(cdi, &cgc);
3411 static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
3413 struct packet_command cgc;
3418 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
3420 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
3424 spindown = buffer[11] & 0x0f;
3425 if (copy_to_user((void __user *)arg, &spindown, sizeof (char)))
3430 static int idecd_ioctl (struct inode *inode, struct file *file,
3431 unsigned int cmd, unsigned long arg)
3433 struct block_device *bdev = inode->i_bdev;
3434 struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
3438 case CDROMSETSPINDOWN:
3439 return idecd_set_spindown(&info->devinfo, arg);
3440 case CDROMGETSPINDOWN:
3441 return idecd_get_spindown(&info->devinfo, arg);
3446 err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
3448 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
3453 static int idecd_media_changed(struct gendisk *disk)
3455 struct cdrom_info *info = ide_cd_g(disk);
3456 return cdrom_media_changed(&info->devinfo);
3459 static int idecd_revalidate_disk(struct gendisk *disk)
3461 struct cdrom_info *info = ide_cd_g(disk);
3462 struct request_sense sense;
3463 cdrom_read_toc(info->drive, &sense);
3467 static struct block_device_operations idecd_ops = {
3468 .owner = THIS_MODULE,
3470 .release = idecd_release,
3471 .ioctl = idecd_ioctl,
3472 .media_changed = idecd_media_changed,
3473 .revalidate_disk= idecd_revalidate_disk
3477 static char *ignore = NULL;
3479 module_param(ignore, charp, 0400);
3480 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
3482 static int ide_cd_probe(ide_drive_t *drive)
3484 struct cdrom_info *info;
3486 struct request_sense sense;
3488 if (!strstr("ide-cdrom", drive->driver_req))
3490 if (!drive->present)
3492 if (drive->media != ide_cdrom && drive->media != ide_optical)
3494 /* skip drives that we were told to ignore */
3495 if (ignore != NULL) {
3496 if (strstr(ignore, drive->name)) {
3497 printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
3502 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
3505 info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
3507 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
3511 g = alloc_disk(1 << PARTN_BITS);
3515 ide_init_disk(g, drive);
3517 ide_register_subdriver(drive, &ide_cdrom_driver);
3519 kref_init(&info->kref);
3521 info->drive = drive;
3522 info->driver = &ide_cdrom_driver;
3525 g->private_data = &info->driver;
3527 drive->driver_data = info;
3530 g->driverfs_dev = &drive->gendev;
3531 g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
3532 if (ide_cdrom_setup(drive)) {
3533 struct cdrom_device_info *devinfo = &info->devinfo;
3534 ide_unregister_subdriver(drive, &ide_cdrom_driver);
3535 kfree(info->buffer);
3537 kfree(info->changer_info);
3538 if (devinfo->handle == drive && unregister_cdrom(devinfo))
3539 printk (KERN_ERR "%s: ide_cdrom_cleanup failed to unregister device from the cdrom driver.\n", drive->name);
3541 drive->driver_data = NULL;
3545 cdrom_read_toc(drive, &sense);
3546 g->fops = &idecd_ops;
3547 g->flags |= GENHD_FL_REMOVABLE;
3557 static void __exit ide_cdrom_exit(void)
3559 driver_unregister(&ide_cdrom_driver.gen_driver);
3562 static int __init ide_cdrom_init(void)
3564 return driver_register(&ide_cdrom_driver.gen_driver);
3567 MODULE_ALIAS("ide:*m-cdrom*");
3568 module_init(ide_cdrom_init);
3569 module_exit(ide_cdrom_exit);
3570 MODULE_LICENSE("GPL");