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>
295 *************************************************************************/
297 #define IDECD_VERSION "4.59-ac1"
299 #include <linux/config.h>
300 #include <linux/module.h>
301 #include <linux/types.h>
302 #include <linux/kernel.h>
303 #include <linux/delay.h>
304 #include <linux/timer.h>
305 #include <linux/slab.h>
306 #include <linux/interrupt.h>
307 #include <linux/errno.h>
308 #include <linux/cdrom.h>
309 #include <linux/ide.h>
310 #include <linux/completion.h>
312 #include <scsi/scsi.h> /* For SCSI -> ATAPI command conversion */
316 #include <asm/byteorder.h>
317 #include <asm/uaccess.h>
318 #include <asm/unaligned.h>
322 /****************************************************************************
323 * Generic packet command support and error handling routines.
326 /* Mark that we've seen a media change, and invalidate our internal
328 static void cdrom_saw_media_change (ide_drive_t *drive)
330 struct cdrom_info *info = drive->driver_data;
332 CDROM_STATE_FLAGS (drive)->media_changed = 1;
333 CDROM_STATE_FLAGS (drive)->toc_valid = 0;
334 info->nsectors_buffered = 0;
337 static int cdrom_log_sense(ide_drive_t *drive, struct request *rq,
338 struct request_sense *sense)
342 if (!sense || !rq || (rq->flags & REQ_QUIET))
345 switch (sense->sense_key) {
346 case NO_SENSE: case RECOVERED_ERROR:
350 * don't care about tray state messages for
351 * e.g. capacity commands or in-progress or
354 if (sense->asc == 0x3a || sense->asc == 0x04)
360 * Make good and sure we've seen this potential media
361 * change. Some drives (i.e. Creative) fail to present
362 * the correct sense key in the error register.
364 cdrom_saw_media_change(drive);
374 void cdrom_analyze_sense_data(ide_drive_t *drive,
375 struct request *failed_command,
376 struct request_sense *sense)
378 if (!cdrom_log_sense(drive, failed_command, sense))
382 * If a read toc is executed for a CD-R or CD-RW medium where
383 * the first toc has not been recorded yet, it will fail with
384 * 05/24/00 (which is a confusing error)
386 if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP)
387 if (sense->sense_key == 0x05 && sense->asc == 0x24)
390 #if VERBOSE_IDE_CD_ERRORS
396 printk ("ATAPI device %s:\n", drive->name);
397 if (sense->error_code==0x70)
399 else if (sense->error_code==0x71)
400 printk(" Deferred Error: ");
401 else if (sense->error_code == 0x7f)
402 printk(" Vendor-specific Error: ");
404 printk(" Unknown Error Type: ");
406 if (sense->sense_key < ARY_LEN(sense_key_texts))
407 s = sense_key_texts[sense->sense_key];
409 s = "bad sense key!";
411 printk("%s -- (Sense key=0x%02x)\n", s, sense->sense_key);
413 if (sense->asc == 0x40) {
414 sprintf(buf, "Diagnostic failure on component 0x%02x",
418 int lo = 0, mid, hi = ARY_LEN(sense_data_texts);
419 unsigned long key = (sense->sense_key << 16);
420 key |= (sense->asc << 8);
421 if (!(sense->ascq >= 0x80 && sense->ascq <= 0xdd))
427 if (sense_data_texts[mid].asc_ascq == key ||
428 sense_data_texts[mid].asc_ascq == (0xff0000|key)) {
429 s = sense_data_texts[mid].text;
432 else if (sense_data_texts[mid].asc_ascq > key)
440 if (sense->asc > 0x80)
441 s = "(vendor-specific error)";
443 s = "(reserved error code)";
446 printk(" %s -- (asc=0x%02x, ascq=0x%02x)\n",
447 s, sense->asc, sense->ascq);
449 if (failed_command != NULL) {
451 int lo=0, mid, hi= ARY_LEN (packet_command_texts);
456 if (packet_command_texts[mid].packet_command ==
457 failed_command->cmd[0]) {
458 s = packet_command_texts[mid].text;
461 if (packet_command_texts[mid].packet_command >
462 failed_command->cmd[0])
468 printk (" The failed \"%s\" packet command was: \n \"", s);
469 for (i=0; i<sizeof (failed_command->cmd); i++)
470 printk ("%02x ", failed_command->cmd[i]);
474 /* The SKSV bit specifies validity of the sense_key_specific
475 * in the next two commands. It is bit 7 of the first byte.
476 * In the case of NOT_READY, if SKSV is set the drive can
477 * give us nice ETA readings.
479 if (sense->sense_key == NOT_READY && (sense->sks[0] & 0x80)) {
480 int progress = (sense->sks[1] << 8 | sense->sks[2]) * 100;
481 printk(" Command is %02d%% complete\n", progress / 0xffff);
485 if (sense->sense_key == ILLEGAL_REQUEST &&
486 (sense->sks[0] & 0x80) != 0) {
487 printk(" Error in %s byte %d",
488 (sense->sks[0] & 0x40) != 0 ?
489 "command packet" : "command data",
490 (sense->sks[1] << 8) + sense->sks[2]);
492 if ((sense->sks[0] & 0x40) != 0)
493 printk (" bit %d", sense->sks[0] & 0x07);
499 #else /* not VERBOSE_IDE_CD_ERRORS */
501 /* Suppress printing unit attention and `in progress of becoming ready'
502 errors when we're not being verbose. */
504 if (sense->sense_key == UNIT_ATTENTION ||
505 (sense->sense_key == NOT_READY && (sense->asc == 4 ||
506 sense->asc == 0x3a)))
509 printk("%s: error code: 0x%02x sense_key: 0x%02x asc: 0x%02x ascq: 0x%02x\n",
511 sense->error_code, sense->sense_key,
512 sense->asc, sense->ascq);
513 #endif /* not VERBOSE_IDE_CD_ERRORS */
517 * Initialize a ide-cd packet command request
519 static void cdrom_prepare_request(struct request *rq)
521 ide_init_drive_cmd(rq);
525 static void cdrom_queue_request_sense(ide_drive_t *drive,
526 struct completion *wait,
528 struct request *failed_command)
530 struct cdrom_info *info = drive->driver_data;
531 struct request *rq = &info->request_sense_request;
534 sense = &info->sense_data;
536 /* stuff the sense request in front of our current request */
537 cdrom_prepare_request(rq);
540 rq->cmd[0] = GPCMD_REQUEST_SENSE;
541 rq->cmd[4] = rq->data_len = 18;
543 rq->flags = REQ_SENSE;
546 /* NOTE! Save the failed command in "rq->buffer" */
547 rq->buffer = (void *) failed_command;
549 (void) ide_do_drive_cmd(drive, rq, ide_preempt);
554 * Error reporting, in human readable form (luxurious, but a memory hog).
556 byte ide_cdrom_dump_status (ide_drive_t *drive, const char *msg, byte stat)
560 atapi_status_t status;
564 local_irq_set(flags);
565 printk("%s: %s: status=0x%02x", drive->name, msg, stat);
566 #if FANCY_STATUS_DUMPS
571 if (status.b.drdy) printk("DriveReady ");
572 if (status.b.df) printk("DeviceFault ");
573 if (status.b.dsc) printk("SeekComplete ");
574 if (status.b.drq) printk("DataRequest ");
575 if (status.b.corr) printk("CorrectedError ");
576 if (status.b.idx) printk("Index ");
577 if (status.b.check) printk("Error ");
580 #endif /* FANCY_STATUS_DUMPS */
582 if ((status.all & (status.b.bsy|status.b.check)) == status.b.check) {
583 error.all = HWIF(drive)->INB(IDE_ERROR_REG);
584 printk("%s: %s: error=0x%02x", drive->name, msg, error.all);
585 #if FANCY_STATUS_DUMPS
586 if (error.b.ili) printk("IllegalLengthIndication ");
587 if (error.b.eom) printk("EndOfMedia ");
588 if (error.b.abrt) printk("Aborted Command ");
589 if (error.b.mcr) printk("MediaChangeRequested ");
590 if (error.b.sense_key) printk("LastFailedSense 0x%02x ",
592 #endif /* FANCY_STATUS_DUMPS */
595 local_irq_restore(flags);
600 * ide_error() takes action based on the error returned by the drive.
602 ide_startstop_t ide_cdrom_error (ide_drive_t *drive, const char *msg, byte stat)
607 err = ide_cdrom_dump_status(drive, msg, stat);
608 if (drive == NULL || (rq = HWGROUP(drive)->rq) == NULL)
610 /* retry only "normal" I/O: */
611 if (rq->flags & (REQ_DRIVE_CMD | REQ_DRIVE_TASK)) {
613 ide_end_drive_cmd(drive, stat, err);
617 if (stat & BUSY_STAT || ((stat & WRERR_STAT) && !drive->nowerr)) {
618 /* other bits are useless when BUSY */
619 rq->errors |= ERROR_RESET;
621 /* add decoding error stuff */
623 if (HWIF(drive)->INB(IDE_STATUS_REG) & (BUSY_STAT|DRQ_STAT))
625 HWIF(drive)->OUTB(WIN_IDLEIMMEDIATE,IDE_COMMAND_REG);
626 if (rq->errors >= ERROR_MAX) {
627 DRIVER(drive)->end_request(drive, 0, 0);
629 if ((rq->errors & ERROR_RESET) == ERROR_RESET) {
631 return ide_do_reset(drive);
638 ide_startstop_t ide_cdrom_abort (ide_drive_t *drive, const char *msg)
642 if (drive == NULL || (rq = HWGROUP(drive)->rq) == NULL)
644 /* retry only "normal" I/O: */
645 if (rq->flags & (REQ_DRIVE_CMD | REQ_DRIVE_TASK)) {
647 ide_end_drive_cmd(drive, BUSY_STAT, 0);
650 rq->errors |= ERROR_RESET;
651 DRIVER(drive)->end_request(drive, 0, 0);
655 static void cdrom_end_request (ide_drive_t *drive, int uptodate)
657 struct request *rq = HWGROUP(drive)->rq;
658 int nsectors = rq->hard_cur_sectors;
660 if ((rq->flags & REQ_SENSE) && uptodate) {
662 * For REQ_SENSE, "rq->buffer" points to the original failed
665 struct request *failed = (struct request *) rq->buffer;
666 struct cdrom_info *info = drive->driver_data;
667 void *sense = &info->sense_data;
669 if (failed && failed->sense) {
670 sense = failed->sense;
671 failed->sense_len = rq->sense_len;
674 cdrom_analyze_sense_data(drive, failed, sense);
677 if (!rq->current_nr_sectors && blk_fs_request(rq))
682 ide_end_request(drive, uptodate, nsectors);
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 (rq->flags & REQ_SENSE) {
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->flags |= REQ_FAILED;
715 cdrom_end_request(drive, 0);
716 DRIVER(drive)->error(drive, "request sense failure", stat);
719 } else if (rq->flags & (REQ_PC | REQ_BLOCK_PC)) {
720 /* All other functions, except for READ. */
721 struct completion *wait = NULL;
724 * if we have an error, pass back CHECK_CONDITION as the
727 if ((rq->flags & REQ_BLOCK_PC) && !rq->errors)
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->flags & REQ_QUIET)) {
739 /* Otherwise, print an error. */
740 ide_dump_status(drive, "packet command error", stat);
743 /* Set the error flag and complete the request.
744 Then, if we have a CHECK CONDITION status,
745 queue a request sense command. We must be careful,
746 though: we don't want the thread in
747 cdrom_queue_packet_command to wake up until
748 the request sense has completed. We do this
749 by transferring the semaphore from the packet
750 command request to the request sense request. */
752 rq->flags |= REQ_FAILED;
753 if ((stat & ERR_STAT) != 0) {
756 if ((rq->flags & REQ_BLOCK_PC) != 0) {
757 cdrom_queue_request_sense(drive, wait,
759 return 1; /* REQ_BLOCK_PC self-cares */
763 cdrom_end_request(drive, 0);
765 if ((stat & ERR_STAT) != 0)
766 cdrom_queue_request_sense(drive, wait, rq->sense, rq);
767 } else if (blk_fs_request(rq)) {
768 /* Handle errors from READ and WRITE requests. */
770 if (blk_noretry_request(rq))
771 cdrom_end_request(drive, 0);
773 if (sense_key == NOT_READY) {
775 cdrom_saw_media_change (drive);
777 /* Fail the request. */
778 printk ("%s: tray open\n", drive->name);
779 cdrom_end_request(drive, 0);
780 } else if (sense_key == UNIT_ATTENTION) {
782 cdrom_saw_media_change (drive);
784 /* Arrange to retry the request.
785 But be sure to give up if we've retried
787 if (++rq->errors > ERROR_MAX)
788 cdrom_end_request(drive, 0);
789 } else if (sense_key == ILLEGAL_REQUEST ||
790 sense_key == DATA_PROTECT) {
791 /* No point in retrying after an illegal
792 request or data protect error.*/
793 ide_dump_status (drive, "command error", stat);
794 cdrom_end_request(drive, 0);
795 } else if ((err & ~ABRT_ERR) != 0) {
796 /* Go to the default handler
798 DRIVER(drive)->error(drive, "cdrom_decode_status",stat);
800 } else if (sense_key == MEDIUM_ERROR) {
801 /* No point in re-trying a zillion times on a bad
802 * sector... If we got here the error is not correctable */
803 ide_dump_status (drive, "media error (bad sector)", stat);
804 cdrom_end_request(drive, 0);
805 } else if ((++rq->errors > ERROR_MAX)) {
806 /* We've racked up too many retries. Abort. */
807 cdrom_end_request(drive, 0);
810 /* If we got a CHECK_CONDITION status,
811 queue a request sense command. */
812 if ((stat & ERR_STAT) != 0)
813 cdrom_queue_request_sense(drive, NULL, NULL, NULL);
815 blk_dump_rq_flags(rq, "ide-cd: bad rq");
816 cdrom_end_request(drive, 0);
819 /* Retry, or handle the next request. */
823 static int cdrom_timer_expiry(ide_drive_t *drive)
825 struct request *rq = HWGROUP(drive)->rq;
826 unsigned long wait = 0;
829 * Some commands are *slow* and normally take a long time to
830 * complete. Usually we can use the ATAPI "disconnect" to bypass
831 * this, but not all commands/drives support that. Let
832 * ide_timer_expiry keep polling us for these.
834 switch (rq->cmd[0]) {
836 case GPCMD_FORMAT_UNIT:
837 case GPCMD_RESERVE_RZONE_TRACK:
847 /* Set up the device registers for transferring a packet command on DEV,
848 expecting to later transfer XFERLEN bytes. HANDLER is the routine
849 which actually transfers the command to the drive. If this is a
850 drq_interrupt device, this routine will arrange for HANDLER to be
851 called when the interrupt from the drive arrives. Otherwise, HANDLER
852 will be called immediately after the drive is prepared for the transfer. */
854 static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
856 ide_handler_t *handler)
858 ide_startstop_t startstop;
859 struct cdrom_info *info = drive->driver_data;
861 /* Wait for the controller to be idle. */
862 if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY))
866 if (info->cmd == READ) {
867 info->dma = !HWIF(drive)->ide_dma_read(drive);
868 } else if (info->cmd == WRITE) {
869 info->dma = !HWIF(drive)->ide_dma_write(drive);
871 printk("ide-cd: DMA set, but not allowed\n");
875 /* Set up the controller registers. */
876 /* FIXME: for Virtual DMA we must check harder */
877 HWIF(drive)->OUTB(info->dma, IDE_FEATURE_REG);
878 HWIF(drive)->OUTB(0, IDE_IREASON_REG);
879 HWIF(drive)->OUTB(0, IDE_SECTOR_REG);
881 HWIF(drive)->OUTB(xferlen & 0xff, IDE_BCOUNTL_REG);
882 HWIF(drive)->OUTB(xferlen >> 8 , IDE_BCOUNTH_REG);
884 HWIF(drive)->OUTB(drive->ctl, IDE_CONTROL_REG);
886 if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt) {
888 ide_execute_command(drive, WIN_PACKETCMD, handler, WAIT_CMD, cdrom_timer_expiry);
892 HWIF(drive)->OUTB(WIN_PACKETCMD, IDE_COMMAND_REG);
893 return (*handler) (drive);
897 /* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
898 The device registers must have already been prepared
899 by cdrom_start_packet_command.
900 HANDLER is the interrupt handler to call when the command completes
901 or there's data ready. */
903 * changed 5 parameters to 3 for dvd-ram
904 * struct packet_command *pc; now packet_command_t *pc;
906 #define ATAPI_MIN_CDB_BYTES 12
907 static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
909 ide_handler_t *handler)
912 struct cdrom_info *info = drive->driver_data;
913 ide_startstop_t startstop;
915 if (CDROM_CONFIG_FLAGS(drive)->drq_interrupt) {
916 /* Here we should have been called after receiving an interrupt
917 from the device. DRQ should how be set. */
919 /* Check for errors. */
920 if (cdrom_decode_status(drive, DRQ_STAT, NULL))
923 /* Otherwise, we must wait for DRQ to get set. */
924 if (ide_wait_stat(&startstop, drive, DRQ_STAT,
925 BUSY_STAT, WAIT_READY))
929 /* Arm the interrupt handler. */
930 ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);
932 /* ATAPI commands get padded out to 12 bytes minimum */
933 cmd_len = COMMAND_SIZE(rq->cmd[0]);
934 if (cmd_len < ATAPI_MIN_CDB_BYTES)
935 cmd_len = ATAPI_MIN_CDB_BYTES;
937 /* Send the command to the device. */
938 HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len);
940 /* Start the DMA if need be */
942 (void) HWIF(drive)->ide_dma_begin(drive);
947 /****************************************************************************
948 * Block read functions.
952 * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
953 * buffer. Once the first sector is added, any subsequent sectors are
954 * assumed to be continuous (until the buffer is cleared). For the first
955 * sector added, SECTOR is its sector number. (SECTOR is then ignored until
956 * the buffer is cleared.)
958 static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
959 int sectors_to_transfer)
961 struct cdrom_info *info = drive->driver_data;
963 /* Number of sectors to read into the buffer. */
964 int sectors_to_buffer = MIN (sectors_to_transfer,
965 (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
966 info->nsectors_buffered);
970 /* If we couldn't get a buffer, don't try to buffer anything... */
971 if (info->buffer == NULL)
972 sectors_to_buffer = 0;
974 /* If this is the first sector in the buffer, remember its number. */
975 if (info->nsectors_buffered == 0)
976 info->sector_buffered = sector;
978 /* Read the data into the buffer. */
979 dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
980 while (sectors_to_buffer > 0) {
981 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
983 --sectors_to_transfer;
984 ++info->nsectors_buffered;
988 /* Throw away any remaining data. */
989 while (sectors_to_transfer > 0) {
990 char dum[SECTOR_SIZE];
991 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
992 --sectors_to_transfer;
997 * Check the contents of the interrupt reason register from the cdrom
998 * and attempt to recover if there are problems. Returns 0 if everything's
999 * ok; nonzero if the request has been terminated.
1002 int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
1006 else if (ireason == 0) {
1007 /* Whoops... The drive is expecting to receive data from us! */
1008 printk("%s: read_intr: Drive wants to transfer data the "
1009 "wrong way!\n", drive->name);
1011 /* Throw some data at the drive so it doesn't hang
1012 and quit this request. */
1015 HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof (dum));
1016 len -= sizeof (dum);
1018 } else if (ireason == 1) {
1019 /* Some drives (ASUS) seem to tell us that status
1020 * info is available. just get it and ignore.
1022 (void) HWIF(drive)->INB(IDE_STATUS_REG);
1025 /* Drive wants a command packet, or invalid ireason... */
1026 printk("%s: read_intr: bad interrupt reason %x\n", drive->name,
1030 cdrom_end_request(drive, 0);
1035 * Interrupt routine. Called when a read request has completed.
1037 static ide_startstop_t cdrom_read_intr (ide_drive_t *drive)
1040 int ireason, len, sectors_to_transfer, nskip;
1041 struct cdrom_info *info = drive->driver_data;
1042 u8 lowcyl = 0, highcyl = 0;
1043 int dma = info->dma, dma_error = 0;
1045 struct request *rq = HWGROUP(drive)->rq;
1052 if ((dma_error = HWIF(drive)->ide_dma_end(drive)))
1053 HWIF(drive)->ide_dma_off(drive);
1056 if (cdrom_decode_status(drive, 0, &stat))
1061 ide_end_request(drive, 1, rq->nr_sectors);
1064 return DRIVER(drive)->error(drive, "dma error", stat);
1067 /* Read the interrupt reason and the transfer length. */
1068 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1069 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1070 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1072 len = lowcyl + (256 * highcyl);
1074 /* If DRQ is clear, the command has completed. */
1075 if ((stat & DRQ_STAT) == 0) {
1076 /* If we're not done filling the current buffer, complain.
1077 Otherwise, complete the command normally. */
1078 if (rq->current_nr_sectors > 0) {
1079 printk ("%s: cdrom_read_intr: data underrun (%d blocks)\n",
1080 drive->name, rq->current_nr_sectors);
1081 rq->flags |= REQ_FAILED;
1082 cdrom_end_request(drive, 0);
1084 cdrom_end_request(drive, 1);
1088 /* Check that the drive is expecting to do the same thing we are. */
1089 if (cdrom_read_check_ireason (drive, len, ireason))
1092 /* Assume that the drive will always provide data in multiples
1093 of at least SECTOR_SIZE, as it gets hairy to keep track
1094 of the transfers otherwise. */
1095 if ((len % SECTOR_SIZE) != 0) {
1096 printk ("%s: cdrom_read_intr: Bad transfer size %d\n",
1098 if (CDROM_CONFIG_FLAGS(drive)->limit_nframes)
1099 printk (" This drive is not supported by this version of the driver\n");
1101 printk (" Trying to limit transfer sizes\n");
1102 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
1104 cdrom_end_request(drive, 0);
1108 /* The number of sectors we need to read from the drive. */
1109 sectors_to_transfer = len / SECTOR_SIZE;
1111 /* First, figure out if we need to bit-bucket
1112 any of the leading sectors. */
1113 nskip = MIN((int)(rq->current_nr_sectors - bio_cur_sectors(rq->bio)), sectors_to_transfer);
1116 /* We need to throw away a sector. */
1117 char dum[SECTOR_SIZE];
1118 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1120 --rq->current_nr_sectors;
1122 --sectors_to_transfer;
1125 /* Now loop while we still have data to read from the drive. */
1126 while (sectors_to_transfer > 0) {
1129 /* If we've filled the present buffer but there's another
1130 chained buffer after it, move on. */
1131 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1132 cdrom_end_request(drive, 1);
1134 /* If the buffers are full, cache the rest of the data in our
1136 if (rq->current_nr_sectors == 0) {
1137 cdrom_buffer_sectors(drive, rq->sector, sectors_to_transfer);
1138 sectors_to_transfer = 0;
1140 /* Transfer data to the buffers.
1141 Figure out how many sectors we can transfer
1142 to the current buffer. */
1143 this_transfer = MIN (sectors_to_transfer,
1144 rq->current_nr_sectors);
1146 /* Read this_transfer sectors
1147 into the current buffer. */
1148 while (this_transfer > 0) {
1149 HWIF(drive)->atapi_input_bytes(drive, rq->buffer, SECTOR_SIZE);
1150 rq->buffer += SECTOR_SIZE;
1152 --rq->current_nr_sectors;
1155 --sectors_to_transfer;
1160 /* Done moving data! Wait for another interrupt. */
1161 ide_set_handler(drive, &cdrom_read_intr, WAIT_CMD, NULL);
1166 * Try to satisfy some of the current read request from our cached data.
1167 * Returns nonzero if the request has been completed, zero otherwise.
1169 static int cdrom_read_from_buffer (ide_drive_t *drive)
1171 struct cdrom_info *info = drive->driver_data;
1172 struct request *rq = HWGROUP(drive)->rq;
1174 /* Can't do anything if there's no buffer. */
1175 if (info->buffer == NULL) return 0;
1177 /* Loop while this request needs data and the next block is present
1179 while (rq->nr_sectors > 0 &&
1180 rq->sector >= info->sector_buffered &&
1181 rq->sector < info->sector_buffered + info->nsectors_buffered) {
1182 if (rq->current_nr_sectors == 0)
1183 cdrom_end_request(drive, 1);
1187 (rq->sector - info->sector_buffered) * SECTOR_SIZE,
1189 rq->buffer += SECTOR_SIZE;
1190 --rq->current_nr_sectors;
1195 /* If we've satisfied the current request,
1196 terminate it successfully. */
1197 if (rq->nr_sectors == 0) {
1198 cdrom_end_request(drive, 1);
1202 /* Move on to the next buffer if needed. */
1203 if (rq->current_nr_sectors == 0)
1204 cdrom_end_request(drive, 1);
1206 /* If this condition does not hold, then the kluge i use to
1207 represent the number of sectors to skip at the start of a transfer
1208 will fail. I think that this will never happen, but let's be
1209 paranoid and check. */
1210 if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
1211 (rq->sector % SECTORS_PER_FRAME) != 0) {
1212 printk("%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
1213 drive->name, (long)rq->sector);
1214 cdrom_end_request(drive, 0);
1222 * Routine to send a read packet command to the drive.
1223 * This is usually called directly from cdrom_start_read.
1224 * However, for drq_interrupt devices, it is called from an interrupt
1225 * when the drive is ready to accept the command.
1227 static ide_startstop_t cdrom_start_read_continuation (ide_drive_t *drive)
1229 struct request *rq = HWGROUP(drive)->rq;
1230 int nsect, sector, nframes, frame, nskip;
1232 /* Number of sectors to transfer. */
1233 nsect = rq->nr_sectors;
1235 /* Starting sector. */
1236 sector = rq->sector;
1238 /* If the requested sector doesn't start on a cdrom block boundary,
1239 we must adjust the start of the transfer so that it does,
1240 and remember to skip the first few sectors.
1241 If the CURRENT_NR_SECTORS field is larger than the size
1242 of the buffer, it will mean that we're to skip a number
1243 of sectors equal to the amount by which CURRENT_NR_SECTORS
1244 is larger than the buffer size. */
1245 nskip = (sector % SECTORS_PER_FRAME);
1247 /* Sanity check... */
1248 if (rq->current_nr_sectors != bio_cur_sectors(rq->bio) &&
1249 (rq->sector % CD_FRAMESIZE != 0)) {
1250 printk ("%s: cdrom_start_read_continuation: buffer botch (%u)\n",
1251 drive->name, rq->current_nr_sectors);
1252 cdrom_end_request(drive, 0);
1257 rq->current_nr_sectors += nskip;
1260 /* Convert from sectors to cdrom blocks, rounding up the transfer
1261 length if needed. */
1262 nframes = (nsect + SECTORS_PER_FRAME-1) / SECTORS_PER_FRAME;
1263 frame = sector / SECTORS_PER_FRAME;
1265 /* Largest number of frames was can transfer at once is 64k-1. For
1266 some drives we need to limit this even more. */
1267 nframes = MIN (nframes, (CDROM_CONFIG_FLAGS (drive)->limit_nframes) ?
1268 (65534 / CD_FRAMESIZE) : 65535);
1270 /* Set up the command */
1271 rq->timeout = WAIT_CMD;
1273 /* Send the command to the drive and return. */
1274 return cdrom_transfer_packet_command(drive, rq, &cdrom_read_intr);
1278 #define IDECD_SEEK_THRESHOLD (1000) /* 1000 blocks */
1279 #define IDECD_SEEK_TIMER (5 * WAIT_MIN_SLEEP) /* 100 ms */
1280 #define IDECD_SEEK_TIMEOUT WAIT_CMD /* 10 sec */
1282 static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
1284 struct cdrom_info *info = drive->driver_data;
1286 static int retry = 10;
1288 if (cdrom_decode_status(drive, 0, &stat))
1290 CDROM_CONFIG_FLAGS(drive)->seeking = 1;
1292 if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
1295 * this condition is far too common, to bother
1298 /* printk("%s: disabled DSC seek overlap\n", drive->name);*/
1299 drive->dsc_overlap = 0;
1305 static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
1307 struct request *rq = HWGROUP(drive)->rq;
1308 int sector, frame, nskip;
1310 sector = rq->sector;
1311 nskip = (sector % SECTORS_PER_FRAME);
1314 frame = sector / SECTORS_PER_FRAME;
1316 memset(rq->cmd, 0, sizeof(rq->cmd));
1317 rq->cmd[0] = GPCMD_SEEK;
1318 put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
1320 rq->timeout = WAIT_CMD;
1321 return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
1324 static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
1326 struct cdrom_info *info = drive->driver_data;
1330 info->start_seek = jiffies;
1331 return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
1334 /* Fix up a possibly partially-processed request so that we can
1335 start it over entirely, or even put it back on the request queue. */
1336 static void restore_request (struct request *rq)
1338 if (rq->buffer != bio_data(rq->bio)) {
1339 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
1341 rq->buffer = bio_data(rq->bio);
1342 rq->nr_sectors += n;
1345 rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
1346 rq->hard_nr_sectors = rq->nr_sectors;
1347 rq->hard_sector = rq->sector;
1348 rq->q->prep_rq_fn(rq->q, rq);
1352 * Start a read request from the CD-ROM.
1354 static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block)
1356 struct cdrom_info *info = drive->driver_data;
1357 struct request *rq = HWGROUP(drive)->rq;
1359 /* We may be retrying this request after an error. Fix up
1360 any weirdness which might be present in the request packet. */
1361 restore_request(rq);
1363 /* Satisfy whatever we can of this request from our cached sector. */
1364 if (cdrom_read_from_buffer(drive))
1367 blk_attempt_remerge(&drive->queue, rq);
1369 /* Clear the local sector buffer. */
1370 info->nsectors_buffered = 0;
1372 /* use dma, if possible. */
1373 if (drive->using_dma && (rq->sector % SECTORS_PER_FRAME == 0) &&
1374 (rq->nr_sectors % SECTORS_PER_FRAME == 0))
1381 /* Start sending the read request to the drive. */
1382 return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
1385 /****************************************************************************
1386 * Execute all other packet commands.
1389 /* Interrupt routine for packet command completion. */
1390 static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
1392 int ireason, len, thislen;
1393 struct request *rq = HWGROUP(drive)->rq;
1394 u8 lowcyl = 0, highcyl = 0;
1397 /* Check for errors. */
1398 if (cdrom_decode_status(drive, 0, &stat))
1401 /* Read the interrupt reason and the transfer length. */
1402 ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1403 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1404 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1406 len = lowcyl + (256 * highcyl);
1408 /* If DRQ is clear, the command has completed.
1409 Complain if we still have data left to transfer. */
1410 if ((stat & DRQ_STAT) == 0) {
1411 /* Some of the trailing request sense fields are optional, and
1412 some drives don't send them. Sigh. */
1413 if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
1415 rq->data_len <= 5) {
1416 while (rq->data_len > 0) {
1417 *(unsigned char *)rq->data++ = 0;
1422 if (rq->data_len == 0)
1423 cdrom_end_request(drive, 1);
1425 /* Comment this out, because this always happens
1426 right after a reset occurs, and it is annoying to
1427 always print expected stuff. */
1429 printk ("%s: cdrom_pc_intr: data underrun %d\n",
1430 drive->name, pc->buflen);
1432 rq->flags |= REQ_FAILED;
1433 cdrom_end_request(drive, 0);
1438 /* Figure out how much data to transfer. */
1439 thislen = rq->data_len;
1440 if (thislen > len) thislen = len;
1442 /* The drive wants to be written to. */
1443 if ((ireason & 3) == 0) {
1445 blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1448 /* Transfer the data. */
1449 HWIF(drive)->atapi_output_bytes(drive, rq->data, thislen);
1451 /* If we haven't moved enough data to satisfy the drive,
1452 add some padding. */
1453 while (len > thislen) {
1455 HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof(dum));
1459 /* Keep count of how much data we've moved. */
1460 rq->data += thislen;
1461 rq->data_len -= thislen;
1464 /* Same drill for reading. */
1465 else if ((ireason & 3) == 2) {
1467 blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1470 /* Transfer the data. */
1471 HWIF(drive)->atapi_input_bytes(drive, rq->data, thislen);
1473 /* If we haven't moved enough data to satisfy the drive,
1474 add some padding. */
1475 while (len > thislen) {
1477 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1481 /* Keep count of how much data we've moved. */
1482 rq->data += thislen;
1483 rq->data_len -= thislen;
1485 if (rq->flags & REQ_SENSE)
1486 rq->sense_len += thislen;
1489 printk ("%s: cdrom_pc_intr: The drive "
1490 "appears confused (ireason = 0x%02x)\n",
1491 drive->name, ireason);
1492 rq->flags |= REQ_FAILED;
1495 /* Now we wait for another interrupt. */
1496 ide_set_handler(drive, &cdrom_pc_intr, WAIT_CMD, cdrom_timer_expiry);
1500 static ide_startstop_t cdrom_do_pc_continuation (ide_drive_t *drive)
1502 struct request *rq = HWGROUP(drive)->rq;
1505 rq->timeout = WAIT_CMD;
1507 /* Send the command to the drive and return. */
1508 return cdrom_transfer_packet_command(drive, rq, &cdrom_pc_intr);
1512 static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
1515 struct request *rq = HWGROUP(drive)->rq;
1516 struct cdrom_info *info = drive->driver_data;
1520 rq->flags &= ~REQ_FAILED;
1523 /* Start sending the command to the drive. */
1524 return cdrom_start_packet_command(drive, len, cdrom_do_pc_continuation);
1528 /* Sleep for TIME jiffies.
1529 Not to be called from an interrupt handler. */
1531 void cdrom_sleep (int time)
1536 set_current_state(TASK_INTERRUPTIBLE);
1537 sleep = schedule_timeout(sleep);
1542 int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
1544 struct request_sense sense;
1546 unsigned int flags = rq->flags;
1548 if (rq->sense == NULL)
1551 /* Start of retry loop. */
1554 unsigned long time = jiffies;
1557 error = ide_do_drive_cmd(drive, rq, ide_wait);
1558 time = jiffies - time;
1560 /* FIXME: we should probably abort/retry or something
1561 * in case of failure */
1562 if (rq->flags & REQ_FAILED) {
1563 /* The request failed. Retry if it was due to a unit
1565 (usually means media was changed). */
1566 struct request_sense *reqbuf = rq->sense;
1568 if (reqbuf->sense_key == UNIT_ATTENTION)
1569 cdrom_saw_media_change(drive);
1570 else if (reqbuf->sense_key == NOT_READY &&
1571 reqbuf->asc == 4 && reqbuf->ascq != 4) {
1572 /* The drive is in the process of loading
1573 a disk. Retry, but wait a little to give
1574 the drive time to complete the load. */
1575 cdrom_sleep(2 * HZ);
1577 /* Otherwise, don't retry. */
1583 /* End of retry loop. */
1584 } while ((rq->flags & REQ_FAILED) && retries >= 0);
1586 /* Return an error if the command failed. */
1587 return (rq->flags & REQ_FAILED) ? -EIO : 0;
1593 static inline int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
1595 /* Two notes about IDE interrupt reason here - 0 means that
1596 * the drive wants to receive data from us, 2 means that
1597 * the drive is expecting to transfer data to us.
1601 else if (ireason == 2) {
1602 /* Whoops... The drive wants to send data. */
1603 printk("%s: write_intr: wrong transfer direction!\n",
1608 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1612 /* Drive wants a command packet, or invalid ireason... */
1613 printk("%s: write_intr: bad interrupt reason %x\n",
1614 drive->name, ireason);
1617 cdrom_end_request(drive, 0);
1621 static void post_transform_command(struct request *req)
1626 if (!blk_pc_request(req))
1630 ibuf = bio_data(req->bio);
1638 * set ansi-revision and response data as atapi
1640 if (c[0] == GPCMD_INQUIRY) {
1642 ibuf[3] = (ibuf[3] & 0xf0) | 2;
1646 typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
1649 * best way to deal with dma that is not sector aligned right now... note
1650 * that in this path we are not using ->data or ->buffer at all. this irs
1651 * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the
1654 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1656 struct cdrom_info *info = drive->driver_data;
1657 struct request *rq = HWGROUP(drive)->rq;
1658 int dma_error, dma, stat, ireason, len, thislen;
1660 xfer_func_t *xferfunc;
1661 unsigned long flags;
1663 /* Check for errors. */
1668 dma_error = HWIF(drive)->ide_dma_end(drive);
1671 if (cdrom_decode_status(drive, 0, &stat)) {
1672 if ((stat & ERR_STAT) != 0) {
1673 end_that_request_chunk(rq, 0, rq->data_len);
1674 goto end_request; /* purge the whole thing... */
1676 end_that_request_chunk(rq, 1, rq->data_len);
1681 * using dma, transfer is complete now
1685 printk("ide-cd: dma error\n");
1686 HWIF(drive)->ide_dma_off(drive);
1687 return DRIVER(drive)->error(drive, "dma error", stat);
1690 end_that_request_chunk(rq, 1, rq->data_len);
1696 * ok we fall to pio :/
1698 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1699 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1700 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1702 len = lowcyl + (256 * highcyl);
1703 thislen = rq->data_len;
1708 * If DRQ is clear, the command has completed.
1710 if ((stat & DRQ_STAT) == 0) {
1712 printk("%s: %u residual after xfer\n", __FUNCTION__, rq->data_len);
1717 * check which way to transfer data
1719 if (rq_data_dir(rq) == WRITE) {
1723 if (cdrom_write_check_ireason(drive, len, ireason))
1726 xferfunc = HWIF(drive)->atapi_output_bytes;
1731 if (cdrom_read_check_ireason(drive, len, ireason))
1734 xferfunc = HWIF(drive)->atapi_input_bytes;
1740 while (thislen > 0) {
1741 int blen = blen = rq->data_len;
1742 char *ptr = rq->data;
1748 ptr = bio_data(rq->bio);
1749 blen = bio_iovec(rq->bio)->bv_len;
1753 printk("%s: confused, missing data\n", drive->name);
1760 xferfunc(drive, ptr, blen);
1764 rq->data_len -= blen;
1767 end_that_request_chunk(rq, 1, blen);
1779 xferfunc(drive, &pad, sizeof(pad));
1784 if (HWGROUP(drive)->handler != NULL)
1787 ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, NULL);
1792 post_transform_command(rq);
1794 spin_lock_irqsave(&ide_lock, flags);
1795 blkdev_dequeue_request(rq);
1796 end_that_request_last(rq);
1797 HWGROUP(drive)->rq = NULL;
1798 spin_unlock_irqrestore(&ide_lock, flags);
1802 static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
1804 int stat, ireason, len, sectors_to_transfer, uptodate;
1805 struct cdrom_info *info = drive->driver_data;
1806 int dma_error = 0, dma = info->dma;
1807 u8 lowcyl = 0, highcyl = 0;
1809 struct request *rq = HWGROUP(drive)->rq;
1811 /* Check for errors. */
1814 if ((dma_error = HWIF(drive)->ide_dma_end(drive))) {
1815 printk("ide-cd: write dma error\n");
1816 HWIF(drive)->ide_dma_off(drive);
1820 if (cdrom_decode_status(drive, 0, &stat)) {
1821 printk("ide-cd: write_intr decode_status bad\n");
1826 * using dma, transfer is complete now
1830 return DRIVER(drive)->error(drive, "dma error", stat);
1832 ide_end_request(drive, 1, rq->nr_sectors);
1836 /* Read the interrupt reason and the transfer length. */
1837 ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1838 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1839 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1841 len = lowcyl + (256 * highcyl);
1843 /* If DRQ is clear, the command has completed. */
1844 if ((stat & DRQ_STAT) == 0) {
1845 /* If we're not done writing, complain.
1846 * Otherwise, complete the command normally.
1849 if (rq->current_nr_sectors > 0) {
1850 printk("%s: write_intr: data underrun (%d blocks)\n",
1851 drive->name, rq->current_nr_sectors);
1854 cdrom_end_request(drive, uptodate);
1858 /* Check that the drive is expecting to do the same thing we are. */
1859 if (cdrom_write_check_ireason(drive, len, ireason))
1862 sectors_to_transfer = len / SECTOR_SIZE;
1865 * now loop and write out the data
1867 while (sectors_to_transfer > 0) {
1870 if (!rq->current_nr_sectors) {
1871 printk("ide-cd: write_intr: oops\n");
1876 * Figure out how many sectors we can transfer
1878 this_transfer = MIN(sectors_to_transfer,rq->current_nr_sectors);
1880 while (this_transfer > 0) {
1881 HWIF(drive)->atapi_output_bytes(drive, rq->buffer, SECTOR_SIZE);
1882 rq->buffer += SECTOR_SIZE;
1884 --rq->current_nr_sectors;
1887 --sectors_to_transfer;
1891 * current buffer complete, move on
1893 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1894 cdrom_end_request(drive, 1);
1897 /* re-arm handler */
1898 ide_set_handler(drive, &cdrom_write_intr, 5 * WAIT_CMD, NULL);
1902 static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
1904 struct request *rq = HWGROUP(drive)->rq;
1906 #if 0 /* the immediate bit */
1907 rq->cmd[1] = 1 << 3;
1909 rq->timeout = 2 * WAIT_CMD;
1911 return cdrom_transfer_packet_command(drive, rq, cdrom_write_intr);
1914 static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
1916 struct cdrom_info *info = drive->driver_data;
1919 * writes *must* be 2kB frame aligned
1921 if ((rq->nr_sectors & 3) || (rq->sector & 3)) {
1922 cdrom_end_request(drive, 0);
1927 * for dvd-ram and such media, it's a really big deal to get
1928 * big writes all the time. so scour the queue and attempt to
1929 * remerge requests, often the plugging will not have had time
1930 * to do this properly
1932 blk_attempt_remerge(&drive->queue, rq);
1934 info->nsectors_buffered = 0;
1936 /* use dma, if possible. we don't need to check more, since we
1937 * know that the transfer is always (at least!) 2KB aligned */
1938 info->dma = drive->using_dma ? 1 : 0;
1941 /* Start sending the read request to the drive. */
1942 return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
1945 static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1947 struct request *rq = HWGROUP(drive)->rq;
1950 rq->timeout = WAIT_CMD;
1952 return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1955 static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1957 struct cdrom_info *info = drive->driver_data;
1959 rq->flags |= REQ_QUIET;
1968 if (rq->data_len & 3) {
1969 printk("%s: block pc not aligned, len=%d\n", drive->name, rq->data_len);
1970 cdrom_end_request(drive, 0);
1973 info->dma = drive->using_dma;
1974 info->cmd = rq_data_dir(rq);
1977 /* Start sending the command to the drive. */
1978 return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1981 /****************************************************************************
1982 * cdrom driver request routine.
1984 static ide_startstop_t
1985 ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1987 ide_startstop_t action;
1988 struct cdrom_info *info = drive->driver_data;
1990 if (blk_fs_request(rq)) {
1991 if (CDROM_CONFIG_FLAGS(drive)->seeking) {
1992 unsigned long elapsed = jiffies - info->start_seek;
1993 int stat = HWIF(drive)->INB(IDE_STATUS_REG);
1995 if ((stat & SEEK_STAT) != SEEK_STAT) {
1996 if (elapsed < IDECD_SEEK_TIMEOUT) {
1997 ide_stall_queue(drive, IDECD_SEEK_TIMER);
2000 printk ("%s: DSC timeout\n", drive->name);
2002 CDROM_CONFIG_FLAGS(drive)->seeking = 0;
2004 if (IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
2005 action = cdrom_start_seek(drive, block);
2007 if (rq_data_dir(rq) == READ)
2008 action = cdrom_start_read(drive, block);
2010 action = cdrom_start_write(drive, rq);
2012 info->last_block = block;
2014 } else if (rq->flags & (REQ_PC | REQ_SENSE)) {
2015 return cdrom_do_packet_command(drive);
2016 } else if (rq->flags & REQ_BLOCK_PC) {
2017 return cdrom_do_block_pc(drive, rq);
2018 } else if (rq->flags & REQ_SPECIAL) {
2020 * right now this can only be a reset...
2022 cdrom_end_request(drive, 1);
2026 blk_dump_rq_flags(rq, "ide-cd bad flags");
2027 cdrom_end_request(drive, 0);
2033 /****************************************************************************
2036 * Routines which queue packet commands take as a final argument a pointer
2037 * to a request_sense struct. If execution of the command results
2038 * in an error with a CHECK CONDITION status, this structure will be filled
2039 * with the results of the subsequent request sense command. The pointer
2040 * can also be NULL, in which case no sense information is returned.
2043 #if ! STANDARD_ATAPI
2047 return (x%10) | ((x/10) << 4);
2054 return (x >> 4) * 10 + (x & 0x0f);
2058 void msf_from_bcd (struct atapi_msf *msf)
2060 msf->minute = bcd2bin (msf->minute);
2061 msf->second = bcd2bin (msf->second);
2062 msf->frame = bcd2bin (msf->frame);
2065 #endif /* not STANDARD_ATAPI */
2069 void lba_to_msf (int lba, byte *m, byte *s, byte *f)
2071 lba += CD_MSF_OFFSET;
2072 lba &= 0xffffff; /* negative lbas use only 24 bits */
2073 *m = lba / (CD_SECS * CD_FRAMES);
2074 lba %= (CD_SECS * CD_FRAMES);
2075 *s = lba / CD_FRAMES;
2076 *f = lba % CD_FRAMES;
2081 int msf_to_lba (byte m, byte s, byte f)
2083 return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
2086 static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
2089 struct cdrom_info *info = drive->driver_data;
2090 struct cdrom_device_info *cdi = &info->devinfo;
2092 cdrom_prepare_request(&req);
2095 req.cmd[0] = GPCMD_TEST_UNIT_READY;
2096 req.flags |= REQ_QUIET;
2098 #if ! STANDARD_ATAPI
2099 /* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
2100 switch CDs instead of supporting the LOAD_UNLOAD opcode */
2102 req.cmd[7] = cdi->sanyo_slot % 3;
2103 #endif /* not STANDARD_ATAPI */
2105 return cdrom_queue_packet_command(drive, &req);
2109 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
2111 cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
2113 struct request_sense my_sense;
2120 /* If the drive cannot lock the door, just pretend. */
2121 if (CDROM_CONFIG_FLAGS(drive)->no_doorlock) {
2124 cdrom_prepare_request(&req);
2126 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
2127 req.cmd[4] = lockflag ? 1 : 0;
2128 stat = cdrom_queue_packet_command(drive, &req);
2131 /* If we got an illegal field error, the drive
2132 probably cannot lock the door. */
2134 sense->sense_key == ILLEGAL_REQUEST &&
2135 (sense->asc == 0x24 || sense->asc == 0x20)) {
2136 printk ("%s: door locking not supported\n",
2138 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2142 /* no medium, that's alright. */
2143 if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
2147 CDROM_STATE_FLAGS(drive)->door_locked = lockflag;
2153 /* Eject the disk if EJECTFLAG is 0.
2154 If EJECTFLAG is 1, try to reload the disk. */
2155 static int cdrom_eject(ide_drive_t *drive, int ejectflag,
2156 struct request_sense *sense)
2160 if (CDROM_CONFIG_FLAGS(drive)->no_eject && !ejectflag)
2161 return -EDRIVE_CANT_DO_THIS;
2163 /* reload fails on some drives, if the tray is locked */
2164 if (CDROM_STATE_FLAGS(drive)->door_locked && ejectflag)
2167 cdrom_prepare_request(&req);
2170 req.cmd[0] = GPCMD_START_STOP_UNIT;
2171 req.cmd[4] = 0x02 + (ejectflag != 0);
2172 return cdrom_queue_packet_command(drive, &req);
2175 static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
2176 struct request_sense *sense)
2186 cdrom_prepare_request(&req);
2189 req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
2190 req.data = (char *)&capbuf;
2191 req.data_len = sizeof(capbuf);
2193 stat = cdrom_queue_packet_command(drive, &req);
2195 *capacity = 1 + be32_to_cpu(capbuf.lba);
2200 static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
2201 int format, char *buf, int buflen,
2202 struct request_sense *sense)
2206 cdrom_prepare_request(&req);
2210 req.data_len = buflen;
2211 req.flags |= REQ_QUIET;
2212 req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
2213 req.cmd[6] = trackno;
2214 req.cmd[7] = (buflen >> 8);
2215 req.cmd[8] = (buflen & 0xff);
2216 req.cmd[9] = (format << 6);
2221 return cdrom_queue_packet_command(drive, &req);
2225 /* Try to read the entire TOC for the disk into our internal buffer. */
2226 static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2228 int stat, ntracks, i;
2229 struct cdrom_info *info = drive->driver_data;
2230 struct cdrom_device_info *cdi = &info->devinfo;
2231 struct atapi_toc *toc = info->toc;
2233 struct atapi_toc_header hdr;
2234 struct atapi_toc_entry ent;
2238 /* Try to allocate space. */
2239 toc = (struct atapi_toc *) kmalloc (sizeof (struct atapi_toc),
2243 printk ("%s: No cdrom TOC buffer!\n", drive->name);
2248 /* Check to see if the existing data is still valid.
2249 If it is, just return. */
2250 (void) cdrom_check_status(drive, sense);
2252 if (CDROM_STATE_FLAGS(drive)->toc_valid)
2255 /* First read just the header, so we know how long the TOC is. */
2256 stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
2257 sizeof(struct atapi_toc_header), sense);
2258 if (stat) return stat;
2260 #if ! STANDARD_ATAPI
2261 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2262 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2263 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2265 #endif /* not STANDARD_ATAPI */
2267 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2270 if (ntracks > MAX_TRACKS)
2271 ntracks = MAX_TRACKS;
2273 /* Now read the whole schmeer. */
2274 stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
2276 sizeof(struct atapi_toc_header) +
2278 sizeof(struct atapi_toc_entry), sense);
2280 if (stat && toc->hdr.first_track > 1) {
2281 /* Cds with CDI tracks only don't have any TOC entries,
2282 despite of this the returned values are
2283 first_track == last_track = number of CDI tracks + 1,
2284 so that this case is indistinguishable from the same
2285 layout plus an additional audio track.
2286 If we get an error for the regular case, we assume
2287 a CDI without additional audio tracks. In this case
2288 the readable TOC is empty (CDI tracks are not included)
2289 and only holds the Leadout entry. Heiko Eißfeldt */
2291 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
2293 sizeof(struct atapi_toc_header) +
2295 sizeof(struct atapi_toc_entry),
2300 #if ! STANDARD_ATAPI
2301 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2302 toc->hdr.first_track = bin2bcd(CDROM_LEADOUT);
2303 toc->hdr.last_track = bin2bcd(CDROM_LEADOUT);
2305 #endif /* not STANDARD_ATAPI */
2307 toc->hdr.first_track = CDROM_LEADOUT;
2308 toc->hdr.last_track = CDROM_LEADOUT;
2315 toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
2317 #if ! STANDARD_ATAPI
2318 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2319 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2320 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2322 #endif /* not STANDARD_ATAPI */
2324 for (i=0; i<=ntracks; i++) {
2325 #if ! STANDARD_ATAPI
2326 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2327 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd)
2328 toc->ent[i].track = bcd2bin(toc->ent[i].track);
2329 msf_from_bcd(&toc->ent[i].addr.msf);
2331 #endif /* not STANDARD_ATAPI */
2332 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
2333 toc->ent[i].addr.msf.second,
2334 toc->ent[i].addr.msf.frame);
2337 /* Read the multisession information. */
2338 if (toc->hdr.first_track != CDROM_LEADOUT) {
2339 /* Read the multisession information. */
2340 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
2341 sizeof(ms_tmp), sense);
2342 if (stat) return stat;
2344 ms_tmp.ent.addr.msf.minute = 0;
2345 ms_tmp.ent.addr.msf.second = 2;
2346 ms_tmp.ent.addr.msf.frame = 0;
2347 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
2350 #if ! STANDARD_ATAPI
2351 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd)
2352 msf_from_bcd (&ms_tmp.ent.addr.msf);
2353 #endif /* not STANDARD_ATAPI */
2355 toc->last_session_lba = msf_to_lba (ms_tmp.ent.addr.msf.minute,
2356 ms_tmp.ent.addr.msf.second,
2357 ms_tmp.ent.addr.msf.frame);
2359 toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
2361 /* Now try to get the total cdrom capacity. */
2362 stat = cdrom_get_last_written(cdi, (long *) &toc->capacity);
2364 stat = cdrom_read_capacity(drive, &toc->capacity, sense);
2366 toc->capacity = 0x1fffff;
2368 set_capacity(drive->disk, toc->capacity * SECTORS_PER_FRAME);
2370 /* Remember that we've read this stuff. */
2371 CDROM_STATE_FLAGS(drive)->toc_valid = 1;
2377 static int cdrom_read_subchannel(ide_drive_t *drive, int format, char *buf,
2378 int buflen, struct request_sense *sense)
2382 cdrom_prepare_request(&req);
2386 req.data_len = buflen;
2387 req.cmd[0] = GPCMD_READ_SUBCHANNEL;
2388 req.cmd[1] = 2; /* MSF addressing */
2389 req.cmd[2] = 0x40; /* request subQ data */
2390 req.cmd[3] = format;
2391 req.cmd[7] = (buflen >> 8);
2392 req.cmd[8] = (buflen & 0xff);
2393 return cdrom_queue_packet_command(drive, &req);
2396 /* ATAPI cdrom drives are free to select the speed you request or any slower
2397 rate :-( Requesting too fast a speed will _not_ produce an error. */
2398 static int cdrom_select_speed(ide_drive_t *drive, int speed,
2399 struct request_sense *sense)
2402 cdrom_prepare_request(&req);
2406 speed = 0xffff; /* set to max */
2408 speed *= 177; /* Nx to kbytes/s */
2410 req.cmd[0] = GPCMD_SET_SPEED;
2411 /* Read Drive speed in kbytes/second MSB */
2412 req.cmd[2] = (speed >> 8) & 0xff;
2413 /* Read Drive speed in kbytes/second LSB */
2414 req.cmd[3] = speed & 0xff;
2415 if (CDROM_CONFIG_FLAGS(drive)->cd_r ||
2416 CDROM_CONFIG_FLAGS(drive)->cd_rw ||
2417 CDROM_CONFIG_FLAGS(drive)->dvd_r) {
2418 /* Write Drive speed in kbytes/second MSB */
2419 req.cmd[4] = (speed >> 8) & 0xff;
2420 /* Write Drive speed in kbytes/second LSB */
2421 req.cmd[5] = speed & 0xff;
2424 return cdrom_queue_packet_command(drive, &req);
2427 static int cdrom_play_audio(ide_drive_t *drive, int lba_start, int lba_end)
2429 struct request_sense sense;
2432 cdrom_prepare_request(&req);
2435 req.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2436 lba_to_msf(lba_start, &req.cmd[3], &req.cmd[4], &req.cmd[5]);
2437 lba_to_msf(lba_end-1, &req.cmd[6], &req.cmd[7], &req.cmd[8]);
2439 return cdrom_queue_packet_command(drive, &req);
2442 static int cdrom_get_toc_entry(ide_drive_t *drive, int track,
2443 struct atapi_toc_entry **ent)
2445 struct cdrom_info *info = drive->driver_data;
2446 struct atapi_toc *toc = info->toc;
2450 * don't serve cached data, if the toc isn't valid
2452 if (!CDROM_STATE_FLAGS(drive)->toc_valid)
2455 /* Check validity of requested track number. */
2456 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2457 if (toc->hdr.first_track == CDROM_LEADOUT) ntracks = 0;
2458 if (track == CDROM_LEADOUT)
2459 *ent = &toc->ent[ntracks];
2460 else if (track < toc->hdr.first_track ||
2461 track > toc->hdr.last_track)
2464 *ent = &toc->ent[track - toc->hdr.first_track];
2469 /* the generic packet interface to cdrom.c */
2470 static int ide_cdrom_packet(struct cdrom_device_info *cdi,
2471 struct cdrom_generic_command *cgc)
2474 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2476 if (cgc->timeout <= 0)
2477 cgc->timeout = WAIT_CMD;
2479 /* here we queue the commands from the uniform CD-ROM
2480 layer. the packet must be complete, as we do not
2482 cdrom_prepare_request(&req);
2483 memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
2485 memset(cgc->sense, 0, sizeof(struct request_sense));
2486 req.data = cgc->buffer;
2487 req.data_len = cgc->buflen;
2488 req.timeout = cgc->timeout;
2491 req.flags |= REQ_QUIET;
2493 req.sense = cgc->sense;
2494 cgc->stat = cdrom_queue_packet_command(drive, &req);
2496 cgc->buflen = req.data_len;
2501 int ide_cdrom_dev_ioctl (struct cdrom_device_info *cdi,
2502 unsigned int cmd, unsigned long arg)
2504 struct cdrom_generic_command cgc;
2508 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2510 /* These will be moved into the Uniform layer shortly... */
2512 case CDROMSETSPINDOWN: {
2515 if (copy_from_user(&spindown, (void *) arg, sizeof(char)))
2518 if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0)))
2521 buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
2523 return cdrom_mode_select(cdi, &cgc);
2526 case CDROMGETSPINDOWN: {
2529 if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0)))
2532 spindown = buffer[11] & 0x0f;
2534 if (copy_to_user((void *) arg, &spindown, sizeof (char)))
2547 int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
2548 unsigned int cmd, void *arg)
2551 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2552 struct cdrom_info *info = drive->driver_data;
2557 * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
2558 * atapi doesn't support it
2560 case CDROMPLAYTRKIND: {
2561 unsigned long lba_start, lba_end;
2562 struct cdrom_ti *ti = (struct cdrom_ti *)arg;
2563 struct atapi_toc_entry *first_toc, *last_toc;
2565 stat = cdrom_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
2569 stat = cdrom_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
2573 if (ti->cdti_trk1 != CDROM_LEADOUT)
2575 lba_start = first_toc->addr.lba;
2576 lba_end = last_toc->addr.lba;
2578 if (lba_end <= lba_start)
2581 return cdrom_play_audio(drive, lba_start, lba_end);
2584 case CDROMREADTOCHDR: {
2585 struct cdrom_tochdr *tochdr = (struct cdrom_tochdr *) arg;
2586 struct atapi_toc *toc;
2588 /* Make sure our saved TOC is valid. */
2589 stat = cdrom_read_toc(drive, NULL);
2590 if (stat) return stat;
2593 tochdr->cdth_trk0 = toc->hdr.first_track;
2594 tochdr->cdth_trk1 = toc->hdr.last_track;
2599 case CDROMREADTOCENTRY: {
2600 struct cdrom_tocentry *tocentry = (struct cdrom_tocentry*) arg;
2601 struct atapi_toc_entry *toce;
2603 stat = cdrom_get_toc_entry(drive, tocentry->cdte_track, &toce);
2604 if (stat) return stat;
2606 tocentry->cdte_ctrl = toce->control;
2607 tocentry->cdte_adr = toce->adr;
2608 if (tocentry->cdte_format == CDROM_MSF) {
2609 lba_to_msf (toce->addr.lba,
2610 &tocentry->cdte_addr.msf.minute,
2611 &tocentry->cdte_addr.msf.second,
2612 &tocentry->cdte_addr.msf.frame);
2614 tocentry->cdte_addr.lba = toce->addr.lba;
2625 int ide_cdrom_reset (struct cdrom_device_info *cdi)
2627 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2628 struct request_sense sense;
2632 cdrom_prepare_request(&req);
2633 req.flags = REQ_SPECIAL | 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 = (ide_drive_t*) cdi->handle;
2651 struct request_sense sense;
2654 int stat = cdrom_lockdoor(drive, 0, &sense);
2655 if (stat) return stat;
2658 return cdrom_eject(drive, !position, &sense);
2662 int ide_cdrom_lock_door (struct cdrom_device_info *cdi, int lock)
2664 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2665 return cdrom_lockdoor(drive, lock, NULL);
2669 int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
2671 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2672 struct request_sense sense;
2675 if ((stat = cdrom_select_speed(drive, speed, &sense)) < 0)
2678 cdi->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2683 int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
2685 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2687 if (slot_nr == CDSL_CURRENT) {
2688 struct request_sense sense;
2689 int stat = cdrom_check_status(drive, &sense);
2690 if (stat == 0 || sense.sense_key == UNIT_ATTENTION)
2693 if (sense.sense_key == NOT_READY && sense.asc == 0x04 &&
2699 * If not using Mt Fuji extended media tray reports,
2700 * just return TRAY_OPEN since ATAPI doesn't provide
2701 * any other way to detect this...
2703 if (sense.sense_key == NOT_READY) {
2704 if (sense.asc == 0x3a && sense.ascq == 1)
2707 return CDS_TRAY_OPEN;
2710 return CDS_DRIVE_NOT_READY;
2716 int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
2717 struct cdrom_multisession *ms_info)
2719 struct atapi_toc *toc;
2720 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2721 struct cdrom_info *info = drive->driver_data;
2722 struct request_sense sense;
2725 if (!CDROM_STATE_FLAGS(drive)->toc_valid || info->toc == NULL)
2726 if ((ret = cdrom_read_toc(drive, &sense)))
2730 ms_info->addr.lba = toc->last_session_lba;
2731 ms_info->xa_flag = toc->xa_flag;
2737 int ide_cdrom_get_mcn (struct cdrom_device_info *cdi,
2738 struct cdrom_mcn *mcn_info)
2742 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2745 if ((stat = cdrom_read_subchannel(drive, 2, mcnbuf, sizeof (mcnbuf), NULL)))
2748 memcpy (mcn_info->medium_catalog_number, mcnbuf+9,
2749 sizeof (mcn_info->medium_catalog_number)-1);
2750 mcn_info->medium_catalog_number[sizeof (mcn_info->medium_catalog_number)-1]
2758 /****************************************************************************
2759 * Other driver requests (open, close, check media change).
2763 int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
2766 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2769 if (slot_nr == CDSL_CURRENT) {
2770 (void) cdrom_check_status(drive, NULL);
2771 retval = CDROM_STATE_FLAGS(drive)->media_changed;
2772 CDROM_STATE_FLAGS(drive)->media_changed = 0;
2781 int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
2788 * Close down the device. Invalidate all cached blocks.
2792 void ide_cdrom_release_real (struct cdrom_device_info *cdi)
2798 /****************************************************************************
2799 * Device initialization.
2801 static struct cdrom_device_ops ide_cdrom_dops = {
2802 .open = ide_cdrom_open_real,
2803 .release = ide_cdrom_release_real,
2804 .drive_status = ide_cdrom_drive_status,
2805 .media_changed = ide_cdrom_check_media_change_real,
2806 .tray_move = ide_cdrom_tray_move,
2807 .lock_door = ide_cdrom_lock_door,
2808 .select_speed = ide_cdrom_select_speed,
2809 .get_last_session = ide_cdrom_get_last_session,
2810 .get_mcn = ide_cdrom_get_mcn,
2811 .reset = ide_cdrom_reset,
2812 .audio_ioctl = ide_cdrom_audio_ioctl,
2813 .dev_ioctl = ide_cdrom_dev_ioctl,
2814 .capability = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
2815 CDC_SELECT_SPEED | CDC_SELECT_DISC |
2816 CDC_MULTI_SESSION | CDC_MCN |
2817 CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO | CDC_RESET |
2818 CDC_IOCTLS | CDC_DRIVE_STATUS | CDC_CD_R |
2819 CDC_CD_RW | CDC_DVD | CDC_DVD_R| CDC_DVD_RAM |
2820 CDC_GENERIC_PACKET | CDC_MO_DRIVE,
2821 .generic_packet = ide_cdrom_packet,
2824 static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2826 struct cdrom_info *info = drive->driver_data;
2827 struct cdrom_device_info *devinfo = &info->devinfo;
2829 devinfo->ops = &ide_cdrom_dops;
2831 devinfo->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2832 devinfo->capacity = nslots;
2833 devinfo->handle = (void *) drive;
2834 strcpy(devinfo->name, drive->name);
2836 /* set capability mask to match the probe. */
2837 if (!CDROM_CONFIG_FLAGS(drive)->cd_r)
2838 devinfo->mask |= CDC_CD_R;
2839 if (!CDROM_CONFIG_FLAGS(drive)->cd_rw)
2840 devinfo->mask |= CDC_CD_RW;
2841 if (!CDROM_CONFIG_FLAGS(drive)->dvd)
2842 devinfo->mask |= CDC_DVD;
2843 if (!CDROM_CONFIG_FLAGS(drive)->dvd_r)
2844 devinfo->mask |= CDC_DVD_R;
2845 if (!CDROM_CONFIG_FLAGS(drive)->dvd_ram)
2846 devinfo->mask |= CDC_DVD_RAM;
2847 if (!CDROM_CONFIG_FLAGS(drive)->is_changer)
2848 devinfo->mask |= CDC_SELECT_DISC;
2849 if (!CDROM_CONFIG_FLAGS(drive)->audio_play)
2850 devinfo->mask |= CDC_PLAY_AUDIO;
2851 if (!CDROM_CONFIG_FLAGS(drive)->close_tray)
2852 devinfo->mask |= CDC_CLOSE_TRAY;
2853 if (!CDROM_CONFIG_FLAGS(drive)->mo_drive)
2854 devinfo->mask |= CDC_MO_DRIVE;
2856 return register_cdrom(devinfo);
2860 int ide_cdrom_get_capabilities(ide_drive_t *drive, struct atapi_capabilities_page *cap)
2862 struct cdrom_info *info = drive->driver_data;
2863 struct cdrom_device_info *cdi = &info->devinfo;
2864 struct cdrom_generic_command cgc;
2865 int stat, attempts = 3, size = sizeof(*cap);
2868 * ACER50 (and others?) require the full spec length mode sense
2869 * page capabilities size, but older drives break.
2871 if (!(!strcmp(drive->id->model, "ATAPI CD ROM DRIVE 50X MAX") ||
2872 !strcmp(drive->id->model, "WPI CDS-32X")))
2873 size -= sizeof(cap->pad);
2875 /* we have to cheat a little here. the packet will eventually
2876 * be queued with ide_cdrom_packet(), which extracts the
2877 * drive from cdi->handle. Since this device hasn't been
2878 * registered with the Uniform layer yet, it can't do this.
2879 * Same goes for cdi->ops.
2881 cdi->handle = (ide_drive_t *) drive;
2882 cdi->ops = &ide_cdrom_dops;
2883 init_cdrom_command(&cgc, cap, size, CGC_DATA_UNKNOWN);
2884 do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2885 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
2888 } while (--attempts);
2893 int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2895 struct cdrom_info *info = drive->driver_data;
2896 struct cdrom_device_info *cdi = &info->devinfo;
2897 struct atapi_capabilities_page cap;
2900 if (drive->media == ide_optical) {
2901 CDROM_CONFIG_FLAGS(drive)->mo_drive = 1;
2902 printk("%s: ATAPI magneto-optical drive\n", drive->name);
2906 if (CDROM_CONFIG_FLAGS(drive)->nec260) {
2907 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2908 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2912 if (ide_cdrom_get_capabilities(drive, &cap))
2916 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2918 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2920 CDROM_CONFIG_FLAGS(drive)->cd_r = 1;
2921 if (cap.cd_rw_write)
2922 CDROM_CONFIG_FLAGS(drive)->cd_rw = 1;
2924 CDROM_CONFIG_FLAGS(drive)->test_write = 1;
2925 if (cap.dvd_ram_read || cap.dvd_r_read || cap.dvd_rom)
2926 CDROM_CONFIG_FLAGS(drive)->dvd = 1;
2927 if (cap.dvd_ram_write)
2928 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 1;
2929 if (cap.dvd_r_write)
2930 CDROM_CONFIG_FLAGS(drive)->dvd_r = 1;
2932 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2933 if (cap.mechtype == mechtype_caddy || cap.mechtype == mechtype_popup)
2934 CDROM_CONFIG_FLAGS(drive)->close_tray = 0;
2936 /* Some drives used by Apple don't advertise audio play
2937 * but they do support reading TOC & audio datas
2939 if (strcmp(drive->id->model, "MATSHITADVD-ROM SR-8187") == 0 ||
2940 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8186") == 0 ||
2941 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8176") == 0 ||
2942 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8174") == 0)
2943 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2945 #if ! STANDARD_ATAPI
2946 if (cdi->sanyo_slot > 0) {
2947 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
2952 #endif /* not STANDARD_ATAPI */
2953 if (cap.mechtype == mechtype_individual_changer ||
2954 cap.mechtype == mechtype_cartridge_changer) {
2955 if ((nslots = cdrom_number_of_slots(cdi)) > 1) {
2956 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
2957 CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 1;
2961 /* The ACER/AOpen 24X cdrom has the speed fields byte-swapped */
2962 if (!drive->id->model[0] &&
2963 !strncmp(drive->id->fw_rev, "241N", 4)) {
2964 CDROM_STATE_FLAGS(drive)->current_speed =
2965 (((unsigned int)cap.curspeed) + (176/2)) / 176;
2966 CDROM_CONFIG_FLAGS(drive)->max_speed =
2967 (((unsigned int)cap.maxspeed) + (176/2)) / 176;
2969 CDROM_STATE_FLAGS(drive)->current_speed =
2970 (ntohs(cap.curspeed) + (176/2)) / 176;
2971 CDROM_CONFIG_FLAGS(drive)->max_speed =
2972 (ntohs(cap.maxspeed) + (176/2)) / 176;
2975 /* don't print speed if the drive reported 0.
2977 printk("%s: ATAPI", drive->name);
2978 if (CDROM_CONFIG_FLAGS(drive)->max_speed)
2979 printk(" %dX", CDROM_CONFIG_FLAGS(drive)->max_speed);
2980 printk(" %s", CDROM_CONFIG_FLAGS(drive)->dvd ? "DVD-ROM" : "CD-ROM");
2982 if (CDROM_CONFIG_FLAGS(drive)->dvd_r|CDROM_CONFIG_FLAGS(drive)->dvd_ram)
2984 (CDROM_CONFIG_FLAGS(drive)->dvd_r)? "-R" : "",
2985 (CDROM_CONFIG_FLAGS(drive)->dvd_ram)? "-RAM" : "");
2987 if (CDROM_CONFIG_FLAGS(drive)->cd_r|CDROM_CONFIG_FLAGS(drive)->cd_rw)
2989 (CDROM_CONFIG_FLAGS(drive)->cd_r)? "-R" : "",
2990 (CDROM_CONFIG_FLAGS(drive)->cd_rw)? "/RW" : "");
2992 if (CDROM_CONFIG_FLAGS(drive)->is_changer)
2993 printk(" changer w/%d slots", nslots);
2997 printk(", %dkB Cache", be16_to_cpu(cap.buffer_size));
2999 #ifdef CONFIG_BLK_DEV_IDEDMA
3000 if (drive->using_dma)
3001 (void) HWIF(drive)->ide_dma_verbose(drive);
3002 #endif /* CONFIG_BLK_DEV_IDEDMA */
3008 static void ide_cdrom_add_settings(ide_drive_t *drive)
3010 ide_add_setting(drive, "dsc_overlap", SETTING_RW, -1, -1, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
3014 * standard prep_rq_fn that builds 10 byte cmds
3016 static int ide_cdrom_prep_fs(request_queue_t *q, struct request *rq)
3018 int hard_sect = queue_hardsect_size(q);
3019 long block = (long)rq->hard_sector / (hard_sect >> 9);
3020 unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
3022 memset(rq->cmd, 0, sizeof(rq->cmd));
3024 if (rq_data_dir(rq) == READ)
3025 rq->cmd[0] = GPCMD_READ_10;
3027 rq->cmd[0] = GPCMD_WRITE_10;
3032 rq->cmd[2] = (block >> 24) & 0xff;
3033 rq->cmd[3] = (block >> 16) & 0xff;
3034 rq->cmd[4] = (block >> 8) & 0xff;
3035 rq->cmd[5] = block & 0xff;
3038 * and transfer length
3040 rq->cmd[7] = (blocks >> 8) & 0xff;
3041 rq->cmd[8] = blocks & 0xff;
3047 * Most of the SCSI commands are supported directly by ATAPI devices.
3048 * This transform handles the few exceptions.
3050 static int ide_cdrom_prep_pc(struct request *rq)
3055 * Transform 6-byte read/write commands to the 10-byte version
3057 if (c[0] == READ_6 || c[0] == WRITE_6) {
3064 c[0] += (READ_10 - READ_6);
3070 * it's silly to pretend we understand 6-byte sense commands, just
3071 * reject with ILLEGAL_REQUEST and the caller should take the
3072 * appropriate action
3074 if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
3075 rq->errors = ILLEGAL_REQUEST;
3076 return BLKPREP_KILL;
3082 static int ide_cdrom_prep_fn(request_queue_t *q, struct request *rq)
3084 if (rq->flags & REQ_CMD)
3085 return ide_cdrom_prep_fs(q, rq);
3086 else if (rq->flags & REQ_BLOCK_PC)
3087 return ide_cdrom_prep_pc(rq);
3093 int ide_cdrom_setup (ide_drive_t *drive)
3095 struct cdrom_info *info = drive->driver_data;
3096 struct cdrom_device_info *cdi = &info->devinfo;
3100 * default to read-only always and fix latter at the bottom
3102 set_disk_ro(drive->disk, 1);
3103 blk_queue_hardsect_size(&drive->queue, CD_FRAMESIZE);
3105 blk_queue_prep_rq(&drive->queue, ide_cdrom_prep_fn);
3106 blk_queue_dma_alignment(&drive->queue, 3);
3108 drive->special.all = 0;
3109 drive->ready_stat = 0;
3111 CDROM_STATE_FLAGS(drive)->media_changed = 1;
3112 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
3113 CDROM_STATE_FLAGS(drive)->door_locked = 0;
3116 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
3118 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 0;
3121 CDROM_CONFIG_FLAGS(drive)->drq_interrupt = ((drive->id->config & 0x0060) == 0x20);
3122 CDROM_CONFIG_FLAGS(drive)->is_changer = 0;
3123 CDROM_CONFIG_FLAGS(drive)->cd_r = 0;
3124 CDROM_CONFIG_FLAGS(drive)->cd_rw = 0;
3125 CDROM_CONFIG_FLAGS(drive)->test_write = 0;
3126 CDROM_CONFIG_FLAGS(drive)->dvd = 0;
3127 CDROM_CONFIG_FLAGS(drive)->dvd_r = 0;
3128 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 0;
3129 CDROM_CONFIG_FLAGS(drive)->no_eject = 1;
3130 CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 0;
3131 CDROM_CONFIG_FLAGS(drive)->audio_play = 0;
3132 CDROM_CONFIG_FLAGS(drive)->close_tray = 1;
3134 /* limit transfer size per interrupt. */
3135 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 0;
3136 /* a testament to the nice quality of Samsung drives... */
3137 if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2430"))
3138 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3139 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2432"))
3140 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3141 /* the 3231 model does not support the SET_CD_SPEED command */
3142 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-3231"))
3143 cdi->mask |= CDC_SELECT_SPEED;
3145 #if ! STANDARD_ATAPI
3146 /* by default Sanyo 3 CD changer support is turned off and
3147 ATAPI Rev 2.2+ standard support for CD changers is used */
3148 cdi->sanyo_slot = 0;
3150 CDROM_CONFIG_FLAGS(drive)->nec260 = 0;
3151 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 0;
3152 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 0;
3153 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 0;
3154 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 0;
3156 if (strcmp (drive->id->model, "V003S0DS") == 0 &&
3157 drive->id->fw_rev[4] == '1' &&
3158 drive->id->fw_rev[6] <= '2') {
3160 Some versions of this drive like to talk BCD. */
3161 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3162 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3163 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3164 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3167 else if (strcmp (drive->id->model, "V006E0DS") == 0 &&
3168 drive->id->fw_rev[4] == '1' &&
3169 drive->id->fw_rev[6] <= '2') {
3170 /* Vertos 600 ESD. */
3171 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3173 else if (strcmp(drive->id->model, "NEC CD-ROM DRIVE:260") == 0 &&
3174 strncmp(drive->id->fw_rev, "1.01", 4) == 0) { /* FIXME */
3175 /* Old NEC260 (not R).
3176 This drive was released before the 1.2 version
3178 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3179 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3180 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3181 CDROM_CONFIG_FLAGS(drive)->nec260 = 1;
3183 else if (strcmp(drive->id->model, "WEARNES CDD-120") == 0 &&
3184 strncmp(drive->id->fw_rev, "A1.1", 4) == 0) { /* FIXME */
3186 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3187 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3189 /* Sanyo 3 CD changer uses a non-standard command
3191 else if ((strcmp(drive->id->model, "CD-ROM CDR-C3 G") == 0) ||
3192 (strcmp(drive->id->model, "CD-ROM CDR-C3G") == 0) ||
3193 (strcmp(drive->id->model, "CD-ROM CDR_C36") == 0)) {
3194 /* uses CD in slot 0 when value is set to 3 */
3195 cdi->sanyo_slot = 3;
3197 #endif /* not STANDARD_ATAPI */
3200 info->buffer = NULL;
3201 info->sector_buffered = 0;
3202 info->nsectors_buffered = 0;
3203 info->changer_info = NULL;
3204 info->last_block = 0;
3205 info->start_seek = 0;
3207 nslots = ide_cdrom_probe_capabilities (drive);
3209 if (CDROM_CONFIG_FLAGS(drive)->dvd_ram)
3210 set_disk_ro(drive->disk, 0);
3213 drive->dsc_overlap = (HWIF(drive)->no_dsc) ? 0 : 1;
3214 if (HWIF(drive)->no_dsc) {
3215 printk(KERN_INFO "ide-cd: %s: disabling DSC overlap\n",
3217 drive->dsc_overlap = 0;
3221 if (ide_cdrom_register(drive, nslots)) {
3222 printk ("%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
3223 info->devinfo.handle = NULL;
3226 ide_cdrom_add_settings(drive);
3231 unsigned long ide_cdrom_capacity (ide_drive_t *drive)
3233 unsigned long capacity;
3235 if (cdrom_read_capacity(drive, &capacity, NULL))
3238 return capacity * SECTORS_PER_FRAME;
3242 int ide_cdrom_cleanup(ide_drive_t *drive)
3244 struct cdrom_info *info = drive->driver_data;
3245 struct cdrom_device_info *devinfo = &info->devinfo;
3246 struct gendisk *g = drive->disk;
3248 if (ide_unregister_subdriver(drive)) {
3249 printk("%s: %s: failed to ide_unregister_subdriver\n",
3250 __FUNCTION__, drive->name);
3253 if (info->buffer != NULL)
3254 kfree(info->buffer);
3255 if (info->toc != NULL)
3257 if (info->changer_info != NULL)
3258 kfree(info->changer_info);
3259 if (devinfo->handle == drive && unregister_cdrom(devinfo))
3260 printk("%s: ide_cdrom_cleanup failed to unregister device from the cdrom driver.\n", drive->name);
3262 drive->driver_data = NULL;
3263 blk_queue_prep_rq(&drive->queue, NULL);
3269 static int ide_cdrom_attach (ide_drive_t *drive);
3272 * Power Management state machine.
3274 * We don't do much for CDs right now.
3277 static void ide_cdrom_complete_power_step (ide_drive_t *drive, struct request *rq, u8 stat, u8 error)
3281 static ide_startstop_t ide_cdrom_start_power_step (ide_drive_t *drive, struct request *rq)
3283 ide_task_t *args = rq->special;
3285 memset(args, 0, sizeof(*args));
3287 switch (rq->pm->pm_step) {
3288 case ide_pm_state_start_suspend:
3291 case ide_pm_state_start_resume: /* Resume step 1 (restore DMA) */
3293 * Right now, all we do is call hwif->ide_dma_check(drive),
3294 * we could be smarter and check for current xfer_speed
3295 * in struct drive etc...
3296 * Also, this step could be implemented as a generic helper
3297 * as most subdrivers will use it.
3299 if ((drive->id->capability & 1) == 0)
3301 if (HWIF(drive)->ide_dma_check == NULL)
3303 HWIF(drive)->ide_dma_check(drive);
3306 rq->pm->pm_step = ide_pm_state_completed;
3310 static ide_driver_t ide_cdrom_driver = {
3311 .owner = THIS_MODULE,
3312 .name = "ide-cdrom",
3313 .version = IDECD_VERSION,
3317 .supports_dsc_overlap = 1,
3318 .cleanup = ide_cdrom_cleanup,
3319 .do_request = ide_do_rw_cdrom,
3320 .sense = ide_cdrom_dump_status,
3321 .error = ide_cdrom_error,
3322 .abort = ide_cdrom_abort,
3323 .capacity = ide_cdrom_capacity,
3324 .attach = ide_cdrom_attach,
3325 .drives = LIST_HEAD_INIT(ide_cdrom_driver.drives),
3326 .start_power_step = ide_cdrom_start_power_step,
3327 .complete_power_step = ide_cdrom_complete_power_step,
3329 .suspend = generic_ide_suspend,
3330 .resume = generic_ide_resume,
3334 static int idecd_open(struct inode * inode, struct file * file)
3336 ide_drive_t *drive = inode->i_bdev->bd_disk->private_data;
3337 struct cdrom_info *info = drive->driver_data;
3342 info->buffer = (char *) kmalloc(SECTOR_BUFFER_SIZE, GFP_KERNEL);
3343 if (!info->buffer || (rc = cdrom_open(&info->devinfo, inode, file)))
3348 static int idecd_release(struct inode * inode, struct file * file)
3350 ide_drive_t *drive = inode->i_bdev->bd_disk->private_data;
3351 struct cdrom_info *info = drive->driver_data;
3353 cdrom_release (&info->devinfo, file);
3358 static int idecd_ioctl (struct inode *inode, struct file *file,
3359 unsigned int cmd, unsigned long arg)
3361 struct block_device *bdev = inode->i_bdev;
3362 ide_drive_t *drive = bdev->bd_disk->private_data;
3363 int err = generic_ide_ioctl(bdev, cmd, arg);
3364 if (err == -EINVAL) {
3365 struct cdrom_info *info = drive->driver_data;
3366 err = cdrom_ioctl(&info->devinfo, inode, cmd, arg);
3371 static int idecd_media_changed(struct gendisk *disk)
3373 ide_drive_t *drive = disk->private_data;
3374 struct cdrom_info *info = drive->driver_data;
3375 return cdrom_media_changed(&info->devinfo);
3378 static int idecd_revalidate_disk(struct gendisk *disk)
3380 ide_drive_t *drive = disk->private_data;
3381 struct request_sense sense;
3382 cdrom_read_toc(drive, &sense);
3386 static struct block_device_operations idecd_ops = {
3387 .owner = THIS_MODULE,
3389 .release = idecd_release,
3390 .ioctl = idecd_ioctl,
3391 .media_changed = idecd_media_changed,
3392 .revalidate_disk= idecd_revalidate_disk
3396 char *ignore = NULL;
3398 MODULE_PARM(ignore, "s");
3399 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
3401 static int ide_cdrom_attach (ide_drive_t *drive)
3403 struct cdrom_info *info;
3404 struct gendisk *g = drive->disk;
3405 struct request_sense sense;
3407 if (!strstr("ide-cdrom", drive->driver_req))
3409 if (!drive->present)
3411 if (drive->media != ide_cdrom && drive->media != ide_optical)
3413 /* skip drives that we were told to ignore */
3414 if (ignore != NULL) {
3415 if (strstr(ignore, drive->name)) {
3416 printk("ide-cd: ignoring drive %s\n", drive->name);
3421 printk("ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
3424 info = (struct cdrom_info *) kmalloc (sizeof (struct cdrom_info), GFP_KERNEL);
3426 printk("%s: Can't allocate a cdrom structure\n", drive->name);
3429 if (ide_register_subdriver(drive, &ide_cdrom_driver, IDE_SUBDRIVER_VERSION)) {
3430 printk("%s: Failed to register the driver with ide.c\n",
3435 memset(info, 0, sizeof (struct cdrom_info));
3436 drive->driver_data = info;
3437 DRIVER(drive)->busy++;
3439 snprintf(g->devfs_name, sizeof(g->devfs_name),
3440 "%s/cd", drive->devfs_name);
3441 g->driverfs_dev = &drive->gendev;
3442 g->flags = GENHD_FL_CD;
3443 if (ide_cdrom_setup(drive)) {
3444 struct cdrom_device_info *devinfo = &info->devinfo;
3445 DRIVER(drive)->busy--;
3446 ide_unregister_subdriver(drive);
3447 if (info->buffer != NULL)
3448 kfree(info->buffer);
3449 if (info->toc != NULL)
3451 if (info->changer_info != NULL)
3452 kfree(info->changer_info);
3453 if (devinfo->handle == drive && unregister_cdrom(devinfo))
3454 printk ("%s: ide_cdrom_cleanup failed to unregister device from the cdrom driver.\n", drive->name);
3456 drive->driver_data = NULL;
3459 DRIVER(drive)->busy--;
3461 cdrom_read_toc(drive, &sense);
3462 g->fops = &idecd_ops;
3469 static void __exit ide_cdrom_exit(void)
3471 ide_unregister_driver(&ide_cdrom_driver);
3474 static int ide_cdrom_init(void)
3476 ide_register_driver(&ide_cdrom_driver);
3480 module_init(ide_cdrom_init);
3481 module_exit(ide_cdrom_exit);
3482 MODULE_LICENSE("GPL");