2 * linux/drivers/ide/ide-cd.c
4 * Copyright (C) 1994, 1995, 1996 scott snyder <snyder@fnald0.fnal.gov>
5 * Copyright (C) 1996-1998 Erik Andersen <andersee@debian.org>
6 * Copyright (C) 1998-2000 Jens Axboe <axboe@suse.de>
8 * May be copied or modified under the terms of the GNU General Public
9 * License. See linux/COPYING for more information.
11 * ATAPI CD-ROM driver. To be used with ide.c.
12 * See Documentation/cdrom/ide-cd for usage information.
14 * Suggestions are welcome. Patches that work are more welcome though. ;-)
15 * For those wishing to work on this driver, please be sure you download
16 * and comply with the latest Mt. Fuji (SFF8090 version 4) and ATAPI
17 * (SFF-8020i rev 2.6) standards. These documents can be obtained by
19 * ftp://fission.dt.wdc.com/pub/standards/SFF_atapi/spec/SFF8020-r2.6/PS/8020r26.ps
20 * ftp://ftp.avc-pioneer.com/Mtfuji4/Spec/Fuji4r10.pdf
22 * Drives that deviate from these standards will be accommodated as much
23 * as possible via compile time or command-line options. Since I only have
24 * a few drives, you generally need to send me patches...
26 * ----------------------------------
28 * -Make it so that Pioneer CD DR-A24X and friends don't get screwed up on
31 * ----------------------------------
32 * 1.00 Oct 31, 1994 -- Initial version.
33 * 1.01 Nov 2, 1994 -- Fixed problem with starting request in
35 * 1.03 Nov 25, 1994 -- leaving unmask_intr[] as a user-setting (as for disks)
36 * (from mlord) -- minor changes to cdrom_setup()
37 * -- renamed ide_dev_s to ide_drive_t, enable irq on command
38 * 2.00 Nov 27, 1994 -- Generalize packet command interface;
40 * 2.01 Dec 3, 1994 -- Rework packet command interface to handle devices
41 * which send an interrupt when ready for a command.
42 * 2.02 Dec 11, 1994 -- Cache the TOC in the driver.
43 * Don't use SCMD_PLAYAUDIO_TI; it's not included
44 * in the current version of ATAPI.
45 * Try to use LBA instead of track or MSF addressing
47 * Don't wait for READY_STAT.
48 * 2.03 Jan 10, 1995 -- Rewrite block read routines to handle block sizes
49 * other than 2k and to move multiple sectors in a
51 * 2.04 Apr 21, 1995 -- Add work-around for Creative Labs CD220E drives.
52 * Thanks to Nick Saw <cwsaw@pts7.pts.mot.com> for
53 * help in figuring this out. Ditto for Acer and
54 * Aztech drives, which seem to have the same problem.
55 * 2.04b May 30, 1995 -- Fix to match changes in ide.c version 3.16 -ml
56 * 2.05 Jun 8, 1995 -- Don't attempt to retry after an illegal request
57 * or data protect error.
58 * Use HWIF and DEV_HWIF macros as in ide.c.
59 * Always try to do a request_sense after
61 * Include an option to give textual descriptions
63 * Fix a bug in handling the sector cache which
64 * showed up if the drive returned data in 512 byte
65 * blocks (like Pioneer drives). Thanks to
66 * Richard Hirst <srh@gpt.co.uk> for diagnosing this.
67 * Properly supply the page number field in the
68 * MODE_SELECT command.
69 * PLAYAUDIO12 is broken on the Aztech; work around it.
70 * 2.05x Aug 11, 1995 -- lots of data structure renaming/restructuring in ide.c
71 * (my apologies to Scott, but now ide-cd.c is independent)
72 * 3.00 Aug 22, 1995 -- Implement CDROMMULTISESSION ioctl.
73 * Implement CDROMREADAUDIO ioctl (UNTESTED).
74 * Use input_ide_data() and output_ide_data().
76 * Fix usage count leak in cdrom_open, which happened
77 * when a read-write mount was attempted.
78 * Try to load the disk on open.
79 * Implement CDROMEJECT_SW ioctl (off by default).
80 * Read total cdrom capacity during open.
81 * Rearrange logic in cdrom_decode_status. Issue
82 * request sense commands for failed packet commands
83 * from here instead of from cdrom_queue_packet_command.
84 * Fix a race condition in retrieving error information.
85 * Suppress printing normal unit attention errors and
86 * some drive not ready errors.
87 * Implement CDROMVOLREAD ioctl.
88 * Implement CDROMREADMODE1/2 ioctls.
89 * Fix race condition in setting up interrupt handlers
90 * when the `serialize' option is used.
91 * 3.01 Sep 2, 1995 -- Fix ordering of reenabling interrupts in
92 * cdrom_queue_request.
93 * Another try at using ide_[input,output]_data.
94 * 3.02 Sep 16, 1995 -- Stick total disk capacity in partition table as well.
95 * Make VERBOSE_IDE_CD_ERRORS dump failed command again.
96 * Dump out more information for ILLEGAL REQUEST errs.
97 * Fix handling of errors occurring before the
98 * packet command is transferred.
99 * Fix transfers with odd bytelengths.
100 * 3.03 Oct 27, 1995 -- Some Creative drives have an id of just `CD'.
101 * `DCI-2S10' drives are broken too.
102 * 3.04 Nov 20, 1995 -- So are Vertos drives.
103 * 3.05 Dec 1, 1995 -- Changes to go with overhaul of ide.c and ide-tape.c
104 * 3.06 Dec 16, 1995 -- Add support needed for partitions.
105 * More workarounds for Vertos bugs (based on patches
106 * from Holger Dietze <dietze@aix520.informatik.uni-leipzig.de>).
107 * Try to eliminate byteorder assumptions.
108 * Use atapi_cdrom_subchnl struct definition.
109 * Add STANDARD_ATAPI compilation option.
110 * 3.07 Jan 29, 1996 -- More twiddling for broken drives: Sony 55D,
112 * Add NO_DOOR_LOCKING configuration option.
113 * Handle drive_cmd requests w/NULL args (for hdparm -t).
114 * Work around sporadic Sony55e audio play problem.
115 * 3.07a Feb 11, 1996 -- check drive->id for NULL before dereferencing, to fix
116 * problem with "hde=cdrom" with no drive present. -ml
117 * 3.08 Mar 6, 1996 -- More Vertos workarounds.
118 * 3.09 Apr 5, 1996 -- Add CDROMCLOSETRAY ioctl.
119 * Switch to using MSF addressing for audio commands.
120 * Reformat to match kernel tabbing style.
121 * Add CDROM_GET_UPC ioctl.
122 * 3.10 Apr 10, 1996 -- Fix compilation error with STANDARD_ATAPI.
123 * 3.11 Apr 29, 1996 -- Patch from Heiko Eissfeldt <heiko@colossus.escape.de>
124 * to remove redundant verify_area calls.
125 * 3.12 May 7, 1996 -- Rudimentary changer support. Based on patches
126 * from Gerhard Zuber <zuber@berlin.snafu.de>.
127 * Let open succeed even if there's no loaded disc.
128 * 3.13 May 19, 1996 -- Fixes for changer code.
129 * 3.14 May 29, 1996 -- Add work-around for Vertos 600.
130 * (From Hennus Bergman <hennus@sky.ow.nl>.)
131 * 3.15 July 2, 1996 -- Added support for Sanyo 3 CD changers
132 * from Ben Galliart <bgallia@luc.edu> with
133 * special help from Jeff Lightfoot
135 * 3.15a July 9, 1996 -- Improved Sanyo 3 CD changer identification
136 * 3.16 Jul 28, 1996 -- Fix from Gadi to reduce kernel stack usage for ioctl.
137 * 3.17 Sep 17, 1996 -- Tweak audio reads for some drives.
138 * Start changing CDROMLOADFROMSLOT to CDROM_SELECT_DISC.
139 * 3.18 Oct 31, 1996 -- Added module and DMA support.
142 * 4.00 Nov 5, 1996 -- New ide-cd maintainer,
143 * Erik B. Andersen <andersee@debian.org>
144 * -- Newer Creative drives don't always set the error
145 * register correctly. Make sure we see media changes
147 * -- Integrate with generic cdrom driver.
148 * -- CDROMGETSPINDOWN and CDROMSETSPINDOWN ioctls, based on
149 * a patch from Ciro Cattuto <>.
150 * -- Call set_device_ro.
151 * -- Implement CDROMMECHANISMSTATUS and CDROMSLOTTABLE
152 * ioctls, based on patch by Erik Andersen
153 * -- Add some probes of drive capability during setup.
155 * 4.01 Nov 11, 1996 -- Split into ide-cd.c and ide-cd.h
156 * -- Removed CDROMMECHANISMSTATUS and CDROMSLOTTABLE
157 * ioctls in favor of a generalized approach
158 * using the generic cdrom driver.
159 * -- Fully integrated with the 2.1.X kernel.
160 * -- Other stuff that I forgot (lots of changes)
162 * 4.02 Dec 01, 1996 -- Applied patch from Gadi Oxman <gadio@netvision.net.il>
163 * to fix the drive door locking problems.
165 * 4.03 Dec 04, 1996 -- Added DSC overlap support.
166 * 4.04 Dec 29, 1996 -- Added CDROMREADRAW ioclt based on patch
167 * by Ales Makarov (xmakarov@sun.felk.cvut.cz)
169 * 4.05 Nov 20, 1997 -- Modified to print more drive info on init
170 * Minor other changes
171 * Fix errors on CDROMSTOP (If you have a "Dolphin",
172 * you must define IHAVEADOLPHIN)
173 * Added identifier so new Sanyo CD-changer works
174 * Better detection if door locking isn't supported
176 * 4.06 Dec 17, 1997 -- fixed endless "tray open" messages -ml
177 * 4.07 Dec 17, 1997 -- fallback to set pc->stat on "tray open"
178 * 4.08 Dec 18, 1997 -- spew less noise when tray is empty
179 * -- fix speed display for ACER 24X, 18X
180 * 4.09 Jan 04, 1998 -- fix handling of the last block so we return
181 * an end of file instead of an I/O error (Gadi)
182 * 4.10 Jan 24, 1998 -- fixed a bug so now changers can change to a new
183 * slot when there is no disc in the current slot.
184 * -- Fixed a memory leak where info->changer_info was
185 * malloc'ed but never free'd when closing the device.
186 * -- Cleaned up the global namespace a bit by making more
187 * functions static that should already have been.
188 * 4.11 Mar 12, 1998 -- Added support for the CDROM_SELECT_SPEED ioctl
189 * based on a patch for 2.0.33 by Jelle Foks
190 * <jelle@scintilla.utwente.nl>, a patch for 2.0.33
191 * by Toni Giorgino <toni@pcape2.pi.infn.it>, the SCSI
192 * version, and my own efforts. -erik
193 * -- Fixed a stupid bug which egcs was kind enough to
194 * inform me of where "Illegal mode for this track"
195 * was never returned due to a comparison on data
196 * types of limited range.
197 * 4.12 Mar 29, 1998 -- Fixed bug in CDROM_SELECT_SPEED so write speed is
198 * now set ionly for CD-R and CD-RW drives. I had
199 * removed this support because it produced errors.
200 * It produced errors _only_ for non-writers. duh.
201 * 4.13 May 05, 1998 -- Suppress useless "in progress of becoming ready"
202 * messages, since this is not an error.
203 * -- Change error messages to be const
204 * -- Remove a "\t" which looks ugly in the syslogs
205 * 4.14 July 17, 1998 -- Change to pointing to .ps version of ATAPI spec
206 * since the .pdf version doesn't seem to work...
207 * -- Updated the TODO list to something more current.
209 * 4.15 Aug 25, 1998 -- Updated ide-cd.h to respect mechine endianess,
210 * patch thanks to "Eddie C. Dost" <ecd@skynet.be>
212 * 4.50 Oct 19, 1998 -- New maintainers!
213 * Jens Axboe <axboe@image.dk>
214 * Chris Zwilling <chris@cloudnet.com>
216 * 4.51 Dec 23, 1998 -- Jens Axboe <axboe@image.dk>
217 * - ide_cdrom_reset enabled since the ide subsystem
218 * handles resets fine now. <axboe@image.dk>
219 * - Transfer size fix for Samsung CD-ROMs, thanks to
220 * "Ville Hallik" <ville.hallik@mail.ee>.
221 * - other minor stuff.
223 * 4.52 Jan 19, 1999 -- Jens Axboe <axboe@image.dk>
224 * - Detect DVD-ROM/RAM drives
226 * 4.53 Feb 22, 1999 - Include other model Samsung and one Goldstar
227 * drive in transfer size limit.
228 * - Fix the I/O error when doing eject without a medium
229 * loaded on some drives.
230 * - CDROMREADMODE2 is now implemented through
231 * CDROMREADRAW, since many drives don't support
232 * MODE2 (even though ATAPI 2.6 says they must).
233 * - Added ignore parameter to ide-cd (as a module), eg
234 * insmod ide-cd ignore='hda hdb'
235 * Useful when using ide-cd in conjunction with
236 * ide-scsi. TODO: non-modular way of doing the
239 * 4.54 Aug 5, 1999 - Support for MMC2 class commands through the generic
240 * packet interface to cdrom.c.
241 * - Unified audio ioctl support, most of it.
242 * - cleaned up various deprecated verify_area().
243 * - Added ide_cdrom_packet() as the interface for
244 * the Uniform generic_packet().
245 * - bunch of other stuff, will fill in logs later.
246 * - report 1 slot for non-changers, like the other
247 * cd-rom drivers. don't report select disc for
248 * non-changers as well.
249 * - mask out audio playing, if the device can't do it.
251 * 4.55 Sep 1, 1999 - Eliminated the rest of the audio ioctls, except
252 * for CDROMREADTOC[ENTRY|HEADER]. Some of the drivers
253 * use this independently of the actual audio handling.
254 * They will disappear later when I get the time to
256 * - Minimize the TOC reading - only do it when we
257 * know a media change has occurred.
258 * - Moved all the CDROMREADx ioctls to the Uniform layer.
259 * - Heiko Eissfeldt <heiko@colossus.escape.de> supplied
260 * some fixes for CDI.
261 * - CD-ROM leaving door locked fix from Andries
262 * Brouwer <Andries.Brouwer@cwi.nl>
263 * - Erik Andersen <andersen@xmission.com> unified
264 * commands across the various drivers and how
265 * sense errors are handled.
267 * 4.56 Sep 12, 1999 - Removed changer support - it is now in the
269 * - Added partition based multisession handling.
270 * - Mode sense and mode select moved to the
272 * - Fixed a problem with WPI CDS-32X drive - it
273 * failed the capabilities
275 * 4.57 Apr 7, 2000 - Fixed sense reporting.
276 * - Fixed possible oops in ide_cdrom_get_last_session()
277 * - Fix locking mania and make ide_cdrom_reset relock
278 * - Stop spewing errors to log when magicdev polls with
279 * TEST_UNIT_READY on some drives.
280 * - Various fixes from Tobias Ringstrom:
281 * tray if it was locked prior to the reset.
282 * - cdrom_read_capacity returns one frame too little.
283 * - Fix real capacity reporting.
285 * 4.58 May 1, 2000 - Clean up ACER50 stuff.
286 * - Fix small problem with ide_cdrom_capacity
288 * 4.59 Aug 11, 2000 - Fix changer problem in cdrom_read_toc, we weren't
289 * correctly sensing a disc change.
290 * - Rearranged some code
291 * - Use extended sense on drives that support it for
292 * correctly reporting tray status -- from
293 * Michael D Johnson <johnsom@orst.edu>
294 * 4.60 Dec 17, 2003 - Add mt rainier support
295 * - Bump timeout for packet commands, matches sr
297 * 4.61 Jan 22, 2004 - support hardware sector sizes other than 2kB,
298 * Pascal Schmidt <der.eremit@email.de>
300 *************************************************************************/
302 #define IDECD_VERSION "4.61"
304 #include <linux/config.h>
305 #include <linux/module.h>
306 #include <linux/types.h>
307 #include <linux/kernel.h>
308 #include <linux/delay.h>
309 #include <linux/timer.h>
310 #include <linux/slab.h>
311 #include <linux/interrupt.h>
312 #include <linux/errno.h>
313 #include <linux/cdrom.h>
314 #include <linux/ide.h>
315 #include <linux/completion.h>
317 #include <scsi/scsi.h> /* For SCSI -> ATAPI command conversion */
321 #include <asm/byteorder.h>
322 #include <asm/uaccess.h>
323 #include <asm/unaligned.h>
327 /****************************************************************************
328 * Generic packet command support and error handling routines.
331 /* Mark that we've seen a media change, and invalidate our internal
333 static void cdrom_saw_media_change (ide_drive_t *drive)
335 struct cdrom_info *info = drive->driver_data;
337 CDROM_STATE_FLAGS (drive)->media_changed = 1;
338 CDROM_STATE_FLAGS (drive)->toc_valid = 0;
339 info->nsectors_buffered = 0;
342 static int cdrom_log_sense(ide_drive_t *drive, struct request *rq,
343 struct request_sense *sense)
347 if (!sense || !rq || (rq->flags & REQ_QUIET))
350 switch (sense->sense_key) {
351 case NO_SENSE: case RECOVERED_ERROR:
355 * don't care about tray state messages for
356 * e.g. capacity commands or in-progress or
359 if (sense->asc == 0x3a || sense->asc == 0x04)
363 case ILLEGAL_REQUEST:
365 * don't log START_STOP unit with LoEj set, since
366 * we cannot reliably check if drive can auto-close
368 if (rq->cmd[0] == GPCMD_START_STOP_UNIT && sense->asc == 0x24)
373 * Make good and sure we've seen this potential media
374 * change. Some drives (i.e. Creative) fail to present
375 * the correct sense key in the error register.
377 cdrom_saw_media_change(drive);
387 void cdrom_analyze_sense_data(ide_drive_t *drive,
388 struct request *failed_command,
389 struct request_sense *sense)
391 if (!cdrom_log_sense(drive, failed_command, sense))
395 * If a read toc is executed for a CD-R or CD-RW medium where
396 * the first toc has not been recorded yet, it will fail with
397 * 05/24/00 (which is a confusing error)
399 if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP)
400 if (sense->sense_key == 0x05 && sense->asc == 0x24)
403 #if VERBOSE_IDE_CD_ERRORS
409 printk ("ATAPI device %s:\n", drive->name);
410 if (sense->error_code==0x70)
412 else if (sense->error_code==0x71)
413 printk(" Deferred Error: ");
414 else if (sense->error_code == 0x7f)
415 printk(" Vendor-specific Error: ");
417 printk(" Unknown Error Type: ");
419 if (sense->sense_key < ARY_LEN(sense_key_texts))
420 s = sense_key_texts[sense->sense_key];
422 s = "bad sense key!";
424 printk("%s -- (Sense key=0x%02x)\n", s, sense->sense_key);
426 if (sense->asc == 0x40) {
427 sprintf(buf, "Diagnostic failure on component 0x%02x",
431 int lo = 0, mid, hi = ARY_LEN(sense_data_texts);
432 unsigned long key = (sense->sense_key << 16);
433 key |= (sense->asc << 8);
434 if (!(sense->ascq >= 0x80 && sense->ascq <= 0xdd))
440 if (sense_data_texts[mid].asc_ascq == key ||
441 sense_data_texts[mid].asc_ascq == (0xff0000|key)) {
442 s = sense_data_texts[mid].text;
445 else if (sense_data_texts[mid].asc_ascq > key)
453 if (sense->asc > 0x80)
454 s = "(vendor-specific error)";
456 s = "(reserved error code)";
459 printk(" %s -- (asc=0x%02x, ascq=0x%02x)\n",
460 s, sense->asc, sense->ascq);
462 if (failed_command != NULL) {
464 int lo=0, mid, hi= ARY_LEN (packet_command_texts);
469 if (packet_command_texts[mid].packet_command ==
470 failed_command->cmd[0]) {
471 s = packet_command_texts[mid].text;
474 if (packet_command_texts[mid].packet_command >
475 failed_command->cmd[0])
481 printk (" The failed \"%s\" packet command was: \n \"", s);
482 for (i=0; i<sizeof (failed_command->cmd); i++)
483 printk ("%02x ", failed_command->cmd[i]);
487 /* The SKSV bit specifies validity of the sense_key_specific
488 * in the next two commands. It is bit 7 of the first byte.
489 * In the case of NOT_READY, if SKSV is set the drive can
490 * give us nice ETA readings.
492 if (sense->sense_key == NOT_READY && (sense->sks[0] & 0x80)) {
493 int progress = (sense->sks[1] << 8 | sense->sks[2]) * 100;
494 printk(" Command is %02d%% complete\n", progress / 0xffff);
498 if (sense->sense_key == ILLEGAL_REQUEST &&
499 (sense->sks[0] & 0x80) != 0) {
500 printk(" Error in %s byte %d",
501 (sense->sks[0] & 0x40) != 0 ?
502 "command packet" : "command data",
503 (sense->sks[1] << 8) + sense->sks[2]);
505 if ((sense->sks[0] & 0x40) != 0)
506 printk (" bit %d", sense->sks[0] & 0x07);
512 #else /* not VERBOSE_IDE_CD_ERRORS */
514 /* Suppress printing unit attention and `in progress of becoming ready'
515 errors when we're not being verbose. */
517 if (sense->sense_key == UNIT_ATTENTION ||
518 (sense->sense_key == NOT_READY && (sense->asc == 4 ||
519 sense->asc == 0x3a)))
522 printk("%s: error code: 0x%02x sense_key: 0x%02x asc: 0x%02x ascq: 0x%02x\n",
524 sense->error_code, sense->sense_key,
525 sense->asc, sense->ascq);
526 #endif /* not VERBOSE_IDE_CD_ERRORS */
530 * Initialize a ide-cd packet command request
532 static void cdrom_prepare_request(struct request *rq)
534 ide_init_drive_cmd(rq);
538 static void cdrom_queue_request_sense(ide_drive_t *drive,
539 struct completion *wait,
541 struct request *failed_command)
543 struct cdrom_info *info = drive->driver_data;
544 struct request *rq = &info->request_sense_request;
547 sense = &info->sense_data;
549 /* stuff the sense request in front of our current request */
550 cdrom_prepare_request(rq);
553 rq->cmd[0] = GPCMD_REQUEST_SENSE;
554 rq->cmd[4] = rq->data_len = 18;
556 rq->flags = REQ_SENSE;
559 /* NOTE! Save the failed command in "rq->buffer" */
560 rq->buffer = (void *) failed_command;
562 (void) ide_do_drive_cmd(drive, rq, ide_preempt);
566 * ide_error() takes action based on the error returned by the drive.
568 ide_startstop_t ide_cdrom_error (ide_drive_t *drive, const char *msg, byte stat)
573 err = ide_dump_atapi_status(drive, msg, stat);
574 if (drive == NULL || (rq = HWGROUP(drive)->rq) == NULL)
576 /* retry only "normal" I/O: */
577 if (rq->flags & (REQ_DRIVE_CMD | REQ_DRIVE_TASK)) {
579 ide_end_drive_cmd(drive, stat, err);
583 if (stat & BUSY_STAT || ((stat & WRERR_STAT) && !drive->nowerr)) {
584 /* other bits are useless when BUSY */
585 rq->errors |= ERROR_RESET;
587 /* add decoding error stuff */
589 if (HWIF(drive)->INB(IDE_STATUS_REG) & (BUSY_STAT|DRQ_STAT))
591 HWIF(drive)->OUTB(WIN_IDLEIMMEDIATE,IDE_COMMAND_REG);
592 if (rq->errors >= ERROR_MAX) {
593 DRIVER(drive)->end_request(drive, 0, 0);
595 if ((rq->errors & ERROR_RESET) == ERROR_RESET) {
597 return ide_do_reset(drive);
604 ide_startstop_t ide_cdrom_abort (ide_drive_t *drive, const char *msg)
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, BUSY_STAT, 0);
616 rq->errors |= ERROR_RESET;
617 DRIVER(drive)->end_request(drive, 0, 0);
621 static void cdrom_end_request (ide_drive_t *drive, int uptodate)
623 struct request *rq = HWGROUP(drive)->rq;
624 int nsectors = rq->hard_cur_sectors;
626 if ((rq->flags & REQ_SENSE) && uptodate) {
628 * For REQ_SENSE, "rq->buffer" points to the original failed
631 struct request *failed = (struct request *) rq->buffer;
632 struct cdrom_info *info = drive->driver_data;
633 void *sense = &info->sense_data;
635 if (failed && failed->sense) {
636 sense = failed->sense;
637 failed->sense_len = rq->sense_len;
640 cdrom_analyze_sense_data(drive, failed, sense);
643 if (!rq->current_nr_sectors && blk_fs_request(rq))
648 ide_end_request(drive, uptodate, nsectors);
651 /* Returns 0 if the request should be continued.
652 Returns 1 if the request was ended. */
653 static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
655 struct request *rq = HWGROUP(drive)->rq;
656 int stat, err, sense_key;
658 /* Check for errors. */
659 stat = HWIF(drive)->INB(IDE_STATUS_REG);
663 if (OK_STAT(stat, good_stat, BAD_R_STAT))
666 /* Get the IDE error register. */
667 err = HWIF(drive)->INB(IDE_ERROR_REG);
668 sense_key = err >> 4;
671 printk("%s: missing rq in cdrom_decode_status\n", drive->name);
675 if (rq->flags & REQ_SENSE) {
676 /* We got an error trying to get sense info
677 from the drive (probably while trying
678 to recover from a former error). Just give up. */
680 rq->flags |= REQ_FAILED;
681 cdrom_end_request(drive, 0);
682 DRIVER(drive)->error(drive, "request sense failure", stat);
685 } else if (rq->flags & (REQ_PC | REQ_BLOCK_PC)) {
686 /* All other functions, except for READ. */
687 struct completion *wait = NULL;
690 * if we have an error, pass back CHECK_CONDITION as the
693 if ((rq->flags & REQ_BLOCK_PC) && !rq->errors)
694 rq->errors = SAM_STAT_CHECK_CONDITION;
696 /* Check for tray open. */
697 if (sense_key == NOT_READY) {
698 cdrom_saw_media_change (drive);
699 } else if (sense_key == UNIT_ATTENTION) {
700 /* Check for media change. */
701 cdrom_saw_media_change (drive);
702 /*printk("%s: media changed\n",drive->name);*/
704 } else if (!(rq->flags & REQ_QUIET)) {
705 /* Otherwise, print an error. */
706 ide_dump_status(drive, "packet command error", stat);
709 /* Set the error flag and complete the request.
710 Then, if we have a CHECK CONDITION status,
711 queue a request sense command. We must be careful,
712 though: we don't want the thread in
713 cdrom_queue_packet_command to wake up until
714 the request sense has completed. We do this
715 by transferring the semaphore from the packet
716 command request to the request sense request. */
718 rq->flags |= REQ_FAILED;
719 if ((stat & ERR_STAT) != 0) {
722 if ((rq->flags & REQ_BLOCK_PC) != 0) {
723 cdrom_queue_request_sense(drive, wait,
725 return 1; /* REQ_BLOCK_PC self-cares */
729 cdrom_end_request(drive, 0);
731 if ((stat & ERR_STAT) != 0)
732 cdrom_queue_request_sense(drive, wait, rq->sense, rq);
733 } else if (blk_fs_request(rq)) {
734 int do_end_request = 0;
736 /* Handle errors from READ and WRITE requests. */
738 if (blk_noretry_request(rq))
741 if (sense_key == NOT_READY) {
743 if (rq_data_dir(rq) == READ) {
744 cdrom_saw_media_change (drive);
746 /* Fail the request. */
747 printk ("%s: tray open\n", drive->name);
750 struct cdrom_info *info = drive->driver_data;
752 /* allow the drive 5 seconds to recover, some
753 * devices will return this error while flushing
756 info->write_timeout = jiffies + ATAPI_WAIT_WRITE_BUSY;
758 if (time_after(jiffies, info->write_timeout))
764 * take a breather relying on the
765 * unplug timer to kick us again
767 spin_lock_irqsave(&ide_lock, flags);
768 blk_plug_device(drive->queue);
769 spin_unlock_irqrestore(&ide_lock,flags);
773 } else if (sense_key == UNIT_ATTENTION) {
775 cdrom_saw_media_change (drive);
777 /* Arrange to retry the request.
778 But be sure to give up if we've retried
780 if (++rq->errors > ERROR_MAX)
782 } else if (sense_key == ILLEGAL_REQUEST ||
783 sense_key == DATA_PROTECT) {
785 * check if this was a write protected media
787 if (rq_data_dir(rq) == WRITE) {
788 printk("ide-cd: media marked write protected\n");
789 set_disk_ro(drive->disk, 1);
792 /* No point in retrying after an illegal
793 request or data protect error.*/
794 ide_dump_status (drive, "command error", stat);
796 } else if (sense_key == MEDIUM_ERROR) {
797 /* No point in re-trying a zillion times on a bad
798 * sector... If we got here the error is not correctable */
799 ide_dump_status (drive, "media error (bad sector)", stat);
801 } else if (sense_key == BLANK_CHECK) {
802 /* Disk appears blank ?? */
803 ide_dump_status (drive, "media error (blank)", stat);
805 } else if ((err & ~ABRT_ERR) != 0) {
806 /* Go to the default handler
808 DRIVER(drive)->error(drive, "cdrom_decode_status",stat);
810 } else if ((++rq->errors > ERROR_MAX)) {
811 /* We've racked up too many retries. Abort. */
816 cdrom_end_request(drive, 0);
818 /* If we got a CHECK_CONDITION status,
819 queue a request sense command. */
820 if ((stat & ERR_STAT) != 0)
821 cdrom_queue_request_sense(drive, NULL, NULL, NULL);
823 blk_dump_rq_flags(rq, "ide-cd: bad rq");
824 cdrom_end_request(drive, 0);
827 /* Retry, or handle the next request. */
831 static int cdrom_timer_expiry(ide_drive_t *drive)
833 struct request *rq = HWGROUP(drive)->rq;
834 unsigned long wait = 0;
837 * Some commands are *slow* and normally take a long time to
838 * complete. Usually we can use the ATAPI "disconnect" to bypass
839 * this, but not all commands/drives support that. Let
840 * ide_timer_expiry keep polling us for these.
842 switch (rq->cmd[0]) {
844 case GPCMD_FORMAT_UNIT:
845 case GPCMD_RESERVE_RZONE_TRACK:
846 case GPCMD_CLOSE_TRACK:
847 case GPCMD_FLUSH_CACHE:
848 wait = ATAPI_WAIT_PC;
851 if (!(rq->flags & REQ_QUIET))
852 printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n", rq->cmd[0]);
859 /* Set up the device registers for transferring a packet command on DEV,
860 expecting to later transfer XFERLEN bytes. HANDLER is the routine
861 which actually transfers the command to the drive. If this is a
862 drq_interrupt device, this routine will arrange for HANDLER to be
863 called when the interrupt from the drive arrives. Otherwise, HANDLER
864 will be called immediately after the drive is prepared for the transfer. */
866 static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
868 ide_handler_t *handler)
870 ide_startstop_t startstop;
871 struct cdrom_info *info = drive->driver_data;
873 /* Wait for the controller to be idle. */
874 if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY))
878 if (info->cmd == READ) {
879 info->dma = !HWIF(drive)->ide_dma_read(drive);
880 } else if (info->cmd == WRITE) {
881 info->dma = !HWIF(drive)->ide_dma_write(drive);
883 printk("ide-cd: DMA set, but not allowed\n");
887 /* Set up the controller registers. */
888 /* FIXME: for Virtual DMA we must check harder */
889 HWIF(drive)->OUTB(info->dma, IDE_FEATURE_REG);
890 HWIF(drive)->OUTB(0, IDE_IREASON_REG);
891 HWIF(drive)->OUTB(0, IDE_SECTOR_REG);
893 HWIF(drive)->OUTB(xferlen & 0xff, IDE_BCOUNTL_REG);
894 HWIF(drive)->OUTB(xferlen >> 8 , IDE_BCOUNTH_REG);
896 HWIF(drive)->OUTB(drive->ctl, IDE_CONTROL_REG);
898 if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt) {
900 ide_execute_command(drive, WIN_PACKETCMD, handler, ATAPI_WAIT_PC, cdrom_timer_expiry);
904 HWIF(drive)->OUTB(WIN_PACKETCMD, IDE_COMMAND_REG);
905 return (*handler) (drive);
909 /* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
910 The device registers must have already been prepared
911 by cdrom_start_packet_command.
912 HANDLER is the interrupt handler to call when the command completes
913 or there's data ready. */
915 * changed 5 parameters to 3 for dvd-ram
916 * struct packet_command *pc; now packet_command_t *pc;
918 #define ATAPI_MIN_CDB_BYTES 12
919 static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
921 ide_handler_t *handler)
924 struct cdrom_info *info = drive->driver_data;
925 ide_startstop_t startstop;
927 if (CDROM_CONFIG_FLAGS(drive)->drq_interrupt) {
928 /* Here we should have been called after receiving an interrupt
929 from the device. DRQ should how be set. */
931 /* Check for errors. */
932 if (cdrom_decode_status(drive, DRQ_STAT, NULL))
935 /* Otherwise, we must wait for DRQ to get set. */
936 if (ide_wait_stat(&startstop, drive, DRQ_STAT,
937 BUSY_STAT, WAIT_READY))
941 /* Arm the interrupt handler. */
942 ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);
944 /* ATAPI commands get padded out to 12 bytes minimum */
945 cmd_len = COMMAND_SIZE(rq->cmd[0]);
946 if (cmd_len < ATAPI_MIN_CDB_BYTES)
947 cmd_len = ATAPI_MIN_CDB_BYTES;
949 /* Send the command to the device. */
950 HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len);
952 /* Start the DMA if need be */
954 (void) HWIF(drive)->ide_dma_begin(drive);
959 /****************************************************************************
960 * Block read functions.
964 * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
965 * buffer. Once the first sector is added, any subsequent sectors are
966 * assumed to be continuous (until the buffer is cleared). For the first
967 * sector added, SECTOR is its sector number. (SECTOR is then ignored until
968 * the buffer is cleared.)
970 static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
971 int sectors_to_transfer)
973 struct cdrom_info *info = drive->driver_data;
975 /* Number of sectors to read into the buffer. */
976 int sectors_to_buffer = min_t(int, sectors_to_transfer,
977 (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
978 info->nsectors_buffered);
982 /* If we couldn't get a buffer, don't try to buffer anything... */
983 if (info->buffer == NULL)
984 sectors_to_buffer = 0;
986 /* If this is the first sector in the buffer, remember its number. */
987 if (info->nsectors_buffered == 0)
988 info->sector_buffered = sector;
990 /* Read the data into the buffer. */
991 dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
992 while (sectors_to_buffer > 0) {
993 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
995 --sectors_to_transfer;
996 ++info->nsectors_buffered;
1000 /* Throw away any remaining data. */
1001 while (sectors_to_transfer > 0) {
1002 static char dum[SECTOR_SIZE];
1003 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1004 --sectors_to_transfer;
1009 * Check the contents of the interrupt reason register from the cdrom
1010 * and attempt to recover if there are problems. Returns 0 if everything's
1011 * ok; nonzero if the request has been terminated.
1014 int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
1018 else if (ireason == 0) {
1019 /* Whoops... The drive is expecting to receive data from us! */
1020 printk("%s: read_intr: Drive wants to transfer data the "
1021 "wrong way!\n", drive->name);
1023 /* Throw some data at the drive so it doesn't hang
1024 and quit this request. */
1027 HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof (dum));
1028 len -= sizeof (dum);
1030 } else if (ireason == 1) {
1031 /* Some drives (ASUS) seem to tell us that status
1032 * info is available. just get it and ignore.
1034 (void) HWIF(drive)->INB(IDE_STATUS_REG);
1037 /* Drive wants a command packet, or invalid ireason... */
1038 printk("%s: read_intr: bad interrupt reason %x\n", drive->name,
1042 cdrom_end_request(drive, 0);
1047 * Interrupt routine. Called when a read request has completed.
1049 static ide_startstop_t cdrom_read_intr (ide_drive_t *drive)
1052 int ireason, len, sectors_to_transfer, nskip;
1053 struct cdrom_info *info = drive->driver_data;
1054 u8 lowcyl = 0, highcyl = 0;
1055 int dma = info->dma, dma_error = 0;
1057 struct request *rq = HWGROUP(drive)->rq;
1064 if ((dma_error = HWIF(drive)->ide_dma_end(drive)))
1065 __ide_dma_off(drive);
1068 if (cdrom_decode_status(drive, 0, &stat))
1073 ide_end_request(drive, 1, rq->nr_sectors);
1076 return DRIVER(drive)->error(drive, "dma error", stat);
1079 /* Read the interrupt reason and the transfer length. */
1080 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1081 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1082 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1084 len = lowcyl + (256 * highcyl);
1086 /* If DRQ is clear, the command has completed. */
1087 if ((stat & DRQ_STAT) == 0) {
1088 /* If we're not done filling the current buffer, complain.
1089 Otherwise, complete the command normally. */
1090 if (rq->current_nr_sectors > 0) {
1091 printk ("%s: cdrom_read_intr: data underrun (%d blocks)\n",
1092 drive->name, rq->current_nr_sectors);
1093 rq->flags |= REQ_FAILED;
1094 cdrom_end_request(drive, 0);
1096 cdrom_end_request(drive, 1);
1100 /* Check that the drive is expecting to do the same thing we are. */
1101 if (cdrom_read_check_ireason (drive, len, ireason))
1104 /* Assume that the drive will always provide data in multiples
1105 of at least SECTOR_SIZE, as it gets hairy to keep track
1106 of the transfers otherwise. */
1107 if ((len % SECTOR_SIZE) != 0) {
1108 printk ("%s: cdrom_read_intr: Bad transfer size %d\n",
1110 if (CDROM_CONFIG_FLAGS(drive)->limit_nframes)
1111 printk (" This drive is not supported by this version of the driver\n");
1113 printk (" Trying to limit transfer sizes\n");
1114 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
1116 cdrom_end_request(drive, 0);
1120 /* The number of sectors we need to read from the drive. */
1121 sectors_to_transfer = len / SECTOR_SIZE;
1123 /* First, figure out if we need to bit-bucket
1124 any of the leading sectors. */
1125 nskip = min_t(int, rq->current_nr_sectors - bio_cur_sectors(rq->bio), sectors_to_transfer);
1128 /* We need to throw away a sector. */
1129 static char dum[SECTOR_SIZE];
1130 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1132 --rq->current_nr_sectors;
1134 --sectors_to_transfer;
1137 /* Now loop while we still have data to read from the drive. */
1138 while (sectors_to_transfer > 0) {
1141 /* If we've filled the present buffer but there's another
1142 chained buffer after it, move on. */
1143 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1144 cdrom_end_request(drive, 1);
1146 /* If the buffers are full, cache the rest of the data in our
1148 if (rq->current_nr_sectors == 0) {
1149 cdrom_buffer_sectors(drive, rq->sector, sectors_to_transfer);
1150 sectors_to_transfer = 0;
1152 /* Transfer data to the buffers.
1153 Figure out how many sectors we can transfer
1154 to the current buffer. */
1155 this_transfer = min_t(int, sectors_to_transfer,
1156 rq->current_nr_sectors);
1158 /* Read this_transfer sectors
1159 into the current buffer. */
1160 while (this_transfer > 0) {
1161 HWIF(drive)->atapi_input_bytes(drive, rq->buffer, SECTOR_SIZE);
1162 rq->buffer += SECTOR_SIZE;
1164 --rq->current_nr_sectors;
1167 --sectors_to_transfer;
1172 /* Done moving data! Wait for another interrupt. */
1173 ide_set_handler(drive, &cdrom_read_intr, ATAPI_WAIT_PC, NULL);
1178 * Try to satisfy some of the current read request from our cached data.
1179 * Returns nonzero if the request has been completed, zero otherwise.
1181 static int cdrom_read_from_buffer (ide_drive_t *drive)
1183 struct cdrom_info *info = drive->driver_data;
1184 struct request *rq = HWGROUP(drive)->rq;
1185 unsigned short sectors_per_frame;
1187 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1189 /* Can't do anything if there's no buffer. */
1190 if (info->buffer == NULL) return 0;
1192 /* Loop while this request needs data and the next block is present
1194 while (rq->nr_sectors > 0 &&
1195 rq->sector >= info->sector_buffered &&
1196 rq->sector < info->sector_buffered + info->nsectors_buffered) {
1197 if (rq->current_nr_sectors == 0)
1198 cdrom_end_request(drive, 1);
1202 (rq->sector - info->sector_buffered) * SECTOR_SIZE,
1204 rq->buffer += SECTOR_SIZE;
1205 --rq->current_nr_sectors;
1210 /* If we've satisfied the current request,
1211 terminate it successfully. */
1212 if (rq->nr_sectors == 0) {
1213 cdrom_end_request(drive, 1);
1217 /* Move on to the next buffer if needed. */
1218 if (rq->current_nr_sectors == 0)
1219 cdrom_end_request(drive, 1);
1221 /* If this condition does not hold, then the kluge i use to
1222 represent the number of sectors to skip at the start of a transfer
1223 will fail. I think that this will never happen, but let's be
1224 paranoid and check. */
1225 if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
1226 (rq->sector & (sectors_per_frame - 1))) {
1227 printk("%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
1228 drive->name, (long)rq->sector);
1229 cdrom_end_request(drive, 0);
1237 * Routine to send a read packet command to the drive.
1238 * This is usually called directly from cdrom_start_read.
1239 * However, for drq_interrupt devices, it is called from an interrupt
1240 * when the drive is ready to accept the command.
1242 static ide_startstop_t cdrom_start_read_continuation (ide_drive_t *drive)
1244 struct request *rq = HWGROUP(drive)->rq;
1245 unsigned short sectors_per_frame;
1248 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1250 /* If the requested sector doesn't start on a cdrom block boundary,
1251 we must adjust the start of the transfer so that it does,
1252 and remember to skip the first few sectors.
1253 If the CURRENT_NR_SECTORS field is larger than the size
1254 of the buffer, it will mean that we're to skip a number
1255 of sectors equal to the amount by which CURRENT_NR_SECTORS
1256 is larger than the buffer size. */
1257 nskip = rq->sector & (sectors_per_frame - 1);
1259 /* Sanity check... */
1260 if (rq->current_nr_sectors != bio_cur_sectors(rq->bio) &&
1261 (rq->sector & (sectors_per_frame - 1))) {
1262 printk ("%s: cdrom_start_read_continuation: buffer botch (%u)\n",
1263 drive->name, rq->current_nr_sectors);
1264 cdrom_end_request(drive, 0);
1267 rq->current_nr_sectors += nskip;
1270 /* Set up the command */
1271 rq->timeout = ATAPI_WAIT_PC;
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 (2 * WAIT_CMD) /* 20 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 sector_t frame = rq->sector;
1310 sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
1312 memset(rq->cmd, 0, sizeof(rq->cmd));
1313 rq->cmd[0] = GPCMD_SEEK;
1314 put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
1316 rq->timeout = ATAPI_WAIT_PC;
1317 return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
1320 static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
1322 struct cdrom_info *info = drive->driver_data;
1326 info->start_seek = jiffies;
1327 return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
1330 /* Fix up a possibly partially-processed request so that we can
1331 start it over entirely, or even put it back on the request queue. */
1332 static void restore_request (struct request *rq)
1334 if (rq->buffer != bio_data(rq->bio)) {
1335 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
1337 rq->buffer = bio_data(rq->bio);
1338 rq->nr_sectors += n;
1341 rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
1342 rq->hard_nr_sectors = rq->nr_sectors;
1343 rq->hard_sector = rq->sector;
1344 rq->q->prep_rq_fn(rq->q, rq);
1348 * Start a read request from the CD-ROM.
1350 static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block)
1352 struct cdrom_info *info = drive->driver_data;
1353 struct request *rq = HWGROUP(drive)->rq;
1354 unsigned short sectors_per_frame;
1356 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1358 /* We may be retrying this request after an error. Fix up
1359 any weirdness which might be present in the request packet. */
1360 restore_request(rq);
1362 /* Satisfy whatever we can of this request from our cached sector. */
1363 if (cdrom_read_from_buffer(drive))
1366 blk_attempt_remerge(drive->queue, rq);
1368 /* Clear the local sector buffer. */
1369 info->nsectors_buffered = 0;
1371 /* use dma, if possible. */
1372 info->dma = drive->using_dma;
1373 if ((rq->sector & (sectors_per_frame - 1)) ||
1374 (rq->nr_sectors & (sectors_per_frame - 1)))
1379 /* Start sending the read request to the drive. */
1380 return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
1383 /****************************************************************************
1384 * Execute all other packet commands.
1387 /* Interrupt routine for packet command completion. */
1388 static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
1390 int ireason, len, thislen;
1391 struct request *rq = HWGROUP(drive)->rq;
1392 u8 lowcyl = 0, highcyl = 0;
1395 /* Check for errors. */
1396 if (cdrom_decode_status(drive, 0, &stat))
1399 /* Read the interrupt reason and the transfer length. */
1400 ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1401 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1402 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1404 len = lowcyl + (256 * highcyl);
1406 /* If DRQ is clear, the command has completed.
1407 Complain if we still have data left to transfer. */
1408 if ((stat & DRQ_STAT) == 0) {
1409 /* Some of the trailing request sense fields are optional, and
1410 some drives don't send them. Sigh. */
1411 if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
1413 rq->data_len <= 5) {
1414 while (rq->data_len > 0) {
1415 *(unsigned char *)rq->data++ = 0;
1420 if (rq->data_len == 0)
1421 cdrom_end_request(drive, 1);
1423 /* Comment this out, because this always happens
1424 right after a reset occurs, and it is annoying to
1425 always print expected stuff. */
1427 printk ("%s: cdrom_pc_intr: data underrun %d\n",
1428 drive->name, pc->buflen);
1430 rq->flags |= REQ_FAILED;
1431 cdrom_end_request(drive, 0);
1436 /* Figure out how much data to transfer. */
1437 thislen = rq->data_len;
1438 if (thislen > len) thislen = len;
1440 /* The drive wants to be written to. */
1441 if ((ireason & 3) == 0) {
1443 blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1446 /* Transfer the data. */
1447 HWIF(drive)->atapi_output_bytes(drive, rq->data, thislen);
1449 /* If we haven't moved enough data to satisfy the drive,
1450 add some padding. */
1451 while (len > thislen) {
1453 HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof(dum));
1457 /* Keep count of how much data we've moved. */
1458 rq->data += thislen;
1459 rq->data_len -= thislen;
1462 /* Same drill for reading. */
1463 else if ((ireason & 3) == 2) {
1465 blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1468 /* Transfer the data. */
1469 HWIF(drive)->atapi_input_bytes(drive, rq->data, thislen);
1471 /* If we haven't moved enough data to satisfy the drive,
1472 add some padding. */
1473 while (len > thislen) {
1475 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1479 /* Keep count of how much data we've moved. */
1480 rq->data += thislen;
1481 rq->data_len -= thislen;
1483 if (rq->flags & REQ_SENSE)
1484 rq->sense_len += thislen;
1487 printk ("%s: cdrom_pc_intr: The drive "
1488 "appears confused (ireason = 0x%02x)\n",
1489 drive->name, ireason);
1490 rq->flags |= REQ_FAILED;
1493 /* Now we wait for another interrupt. */
1494 ide_set_handler(drive, &cdrom_pc_intr, ATAPI_WAIT_PC, cdrom_timer_expiry);
1498 static ide_startstop_t cdrom_do_pc_continuation (ide_drive_t *drive)
1500 struct request *rq = HWGROUP(drive)->rq;
1503 rq->timeout = ATAPI_WAIT_PC;
1505 /* Send the command to the drive and return. */
1506 return cdrom_transfer_packet_command(drive, rq, &cdrom_pc_intr);
1510 static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
1513 struct request *rq = HWGROUP(drive)->rq;
1514 struct cdrom_info *info = drive->driver_data;
1518 rq->flags &= ~REQ_FAILED;
1521 /* Start sending the command to the drive. */
1522 return cdrom_start_packet_command(drive, len, cdrom_do_pc_continuation);
1526 /* Sleep for TIME jiffies.
1527 Not to be called from an interrupt handler. */
1529 void cdrom_sleep (int time)
1534 set_current_state(TASK_INTERRUPTIBLE);
1535 sleep = schedule_timeout(sleep);
1540 int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
1542 struct request_sense sense;
1544 unsigned int flags = rq->flags;
1546 if (rq->sense == NULL)
1549 /* Start of retry loop. */
1552 unsigned long time = jiffies;
1555 error = ide_do_drive_cmd(drive, rq, ide_wait);
1556 time = jiffies - time;
1558 /* FIXME: we should probably abort/retry or something
1559 * in case of failure */
1560 if (rq->flags & REQ_FAILED) {
1561 /* The request failed. Retry if it was due to a unit
1563 (usually means media was changed). */
1564 struct request_sense *reqbuf = rq->sense;
1566 if (reqbuf->sense_key == UNIT_ATTENTION)
1567 cdrom_saw_media_change(drive);
1568 else if (reqbuf->sense_key == NOT_READY &&
1569 reqbuf->asc == 4 && reqbuf->ascq != 4) {
1570 /* The drive is in the process of loading
1571 a disk. Retry, but wait a little to give
1572 the drive time to complete the load. */
1573 cdrom_sleep(2 * HZ);
1575 /* Otherwise, don't retry. */
1581 /* End of retry loop. */
1582 } while ((rq->flags & REQ_FAILED) && retries >= 0);
1584 /* Return an error if the command failed. */
1585 return (rq->flags & REQ_FAILED) ? -EIO : 0;
1591 static inline int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
1593 /* Two notes about IDE interrupt reason here - 0 means that
1594 * the drive wants to receive data from us, 2 means that
1595 * the drive is expecting to transfer data to us.
1599 else if (ireason == 2) {
1600 /* Whoops... The drive wants to send data. */
1601 printk("%s: write_intr: wrong transfer direction!\n",
1606 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1610 /* Drive wants a command packet, or invalid ireason... */
1611 printk("%s: write_intr: bad interrupt reason %x\n",
1612 drive->name, ireason);
1615 cdrom_end_request(drive, 0);
1619 static void post_transform_command(struct request *req)
1624 if (!blk_pc_request(req))
1628 ibuf = bio_data(req->bio);
1636 * set ansi-revision and response data as atapi
1638 if (c[0] == GPCMD_INQUIRY) {
1640 ibuf[3] = (ibuf[3] & 0xf0) | 2;
1644 typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
1647 * best way to deal with dma that is not sector aligned right now... note
1648 * that in this path we are not using ->data or ->buffer at all. this irs
1649 * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the
1652 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1654 struct cdrom_info *info = drive->driver_data;
1655 struct request *rq = HWGROUP(drive)->rq;
1656 int dma_error, dma, stat, ireason, len, thislen;
1658 xfer_func_t *xferfunc;
1659 unsigned long flags;
1661 /* Check for errors. */
1666 dma_error = HWIF(drive)->ide_dma_end(drive);
1669 if (cdrom_decode_status(drive, 0, &stat)) {
1670 if ((stat & ERR_STAT) != 0) {
1671 end_that_request_chunk(rq, 0, rq->data_len);
1672 goto end_request; /* purge the whole thing... */
1674 end_that_request_chunk(rq, 1, rq->data_len);
1679 * using dma, transfer is complete now
1683 printk("ide-cd: dma error\n");
1684 __ide_dma_off(drive);
1685 return DRIVER(drive)->error(drive, "dma error", stat);
1688 end_that_request_chunk(rq, 1, rq->data_len);
1694 * ok we fall to pio :/
1696 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1697 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1698 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1700 len = lowcyl + (256 * highcyl);
1701 thislen = rq->data_len;
1706 * If DRQ is clear, the command has completed.
1708 if ((stat & DRQ_STAT) == 0)
1712 * check which way to transfer data
1714 if (rq_data_dir(rq) == WRITE) {
1718 if (cdrom_write_check_ireason(drive, len, ireason))
1721 xferfunc = HWIF(drive)->atapi_output_bytes;
1726 if (cdrom_read_check_ireason(drive, len, ireason))
1729 xferfunc = HWIF(drive)->atapi_input_bytes;
1735 while (thislen > 0) {
1736 int blen = blen = rq->data_len;
1737 char *ptr = rq->data;
1743 ptr = bio_data(rq->bio);
1744 blen = bio_iovec(rq->bio)->bv_len;
1748 printk("%s: confused, missing data\n", drive->name);
1755 xferfunc(drive, ptr, blen);
1759 rq->data_len -= blen;
1762 end_that_request_chunk(rq, 1, blen);
1774 xferfunc(drive, &pad, sizeof(pad));
1779 if (HWGROUP(drive)->handler != NULL)
1782 ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, NULL);
1787 post_transform_command(rq);
1789 spin_lock_irqsave(&ide_lock, flags);
1790 blkdev_dequeue_request(rq);
1791 end_that_request_last(rq);
1792 HWGROUP(drive)->rq = NULL;
1793 spin_unlock_irqrestore(&ide_lock, flags);
1797 static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
1799 int stat, ireason, len, sectors_to_transfer, uptodate;
1800 struct cdrom_info *info = drive->driver_data;
1801 int dma_error = 0, dma = info->dma;
1802 u8 lowcyl = 0, highcyl = 0;
1804 struct request *rq = HWGROUP(drive)->rq;
1806 /* Check for errors. */
1809 if ((dma_error = HWIF(drive)->ide_dma_end(drive))) {
1810 printk("ide-cd: write dma error\n");
1811 __ide_dma_off(drive);
1815 if (cdrom_decode_status(drive, 0, &stat))
1819 * using dma, transfer is complete now
1823 return DRIVER(drive)->error(drive, "dma error", stat);
1825 ide_end_request(drive, 1, rq->nr_sectors);
1829 /* Read the interrupt reason and the transfer length. */
1830 ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1831 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1832 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1834 len = lowcyl + (256 * highcyl);
1836 /* If DRQ is clear, the command has completed. */
1837 if ((stat & DRQ_STAT) == 0) {
1838 /* If we're not done writing, complain.
1839 * Otherwise, complete the command normally.
1842 if (rq->current_nr_sectors > 0) {
1843 printk("%s: write_intr: data underrun (%d blocks)\n",
1844 drive->name, rq->current_nr_sectors);
1847 cdrom_end_request(drive, uptodate);
1851 /* Check that the drive is expecting to do the same thing we are. */
1852 if (cdrom_write_check_ireason(drive, len, ireason))
1855 sectors_to_transfer = len / SECTOR_SIZE;
1858 * now loop and write out the data
1860 while (sectors_to_transfer > 0) {
1863 if (!rq->current_nr_sectors) {
1864 printk("ide-cd: write_intr: oops\n");
1869 * Figure out how many sectors we can transfer
1871 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors);
1873 while (this_transfer > 0) {
1874 HWIF(drive)->atapi_output_bytes(drive, rq->buffer, SECTOR_SIZE);
1875 rq->buffer += SECTOR_SIZE;
1877 --rq->current_nr_sectors;
1880 --sectors_to_transfer;
1884 * current buffer complete, move on
1886 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1887 cdrom_end_request(drive, 1);
1890 /* re-arm handler */
1891 ide_set_handler(drive, &cdrom_write_intr, ATAPI_WAIT_PC, NULL);
1895 static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
1897 struct request *rq = HWGROUP(drive)->rq;
1899 #if 0 /* the immediate bit */
1900 rq->cmd[1] = 1 << 3;
1902 rq->timeout = ATAPI_WAIT_PC;
1904 return cdrom_transfer_packet_command(drive, rq, cdrom_write_intr);
1907 static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
1909 struct cdrom_info *info = drive->driver_data;
1910 struct gendisk *g = drive->disk;
1911 unsigned short sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1914 * writes *must* be hardware frame aligned
1916 if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1917 (rq->sector & (sectors_per_frame - 1))) {
1918 cdrom_end_request(drive, 0);
1923 * disk has become write protected
1926 cdrom_end_request(drive, 0);
1931 * for dvd-ram and such media, it's a really big deal to get
1932 * big writes all the time. so scour the queue and attempt to
1933 * remerge requests, often the plugging will not have had time
1934 * to do this properly
1936 blk_attempt_remerge(drive->queue, rq);
1938 info->nsectors_buffered = 0;
1940 /* use dma, if possible. we don't need to check more, since we
1941 * know that the transfer is always (at least!) frame aligned */
1942 info->dma = drive->using_dma ? 1 : 0;
1945 /* Start sending the write request to the drive. */
1946 return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
1949 static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1951 struct request *rq = HWGROUP(drive)->rq;
1954 rq->timeout = ATAPI_WAIT_PC;
1956 return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1959 static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1961 struct cdrom_info *info = drive->driver_data;
1963 rq->flags |= REQ_QUIET;
1972 if (rq->data_len & 3) {
1973 printk("%s: block pc not aligned, len=%d\n", drive->name, rq->data_len);
1974 cdrom_end_request(drive, 0);
1977 info->dma = drive->using_dma;
1978 info->cmd = rq_data_dir(rq);
1981 /* Start sending the command to the drive. */
1982 return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1985 /****************************************************************************
1986 * cdrom driver request routine.
1988 static ide_startstop_t
1989 ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1991 ide_startstop_t action;
1992 struct cdrom_info *info = drive->driver_data;
1994 if (blk_fs_request(rq)) {
1995 if (CDROM_CONFIG_FLAGS(drive)->seeking) {
1996 unsigned long elapsed = jiffies - info->start_seek;
1997 int stat = HWIF(drive)->INB(IDE_STATUS_REG);
1999 if ((stat & SEEK_STAT) != SEEK_STAT) {
2000 if (elapsed < IDECD_SEEK_TIMEOUT) {
2001 ide_stall_queue(drive, IDECD_SEEK_TIMER);
2004 printk ("%s: DSC timeout\n", drive->name);
2006 CDROM_CONFIG_FLAGS(drive)->seeking = 0;
2008 if (IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
2009 action = cdrom_start_seek(drive, block);
2011 if (rq_data_dir(rq) == READ)
2012 action = cdrom_start_read(drive, block);
2014 action = cdrom_start_write(drive, rq);
2016 info->last_block = block;
2018 } else if (rq->flags & (REQ_PC | REQ_SENSE)) {
2019 return cdrom_do_packet_command(drive);
2020 } else if (rq->flags & REQ_BLOCK_PC) {
2021 return cdrom_do_block_pc(drive, rq);
2022 } else if (rq->flags & REQ_SPECIAL) {
2024 * right now this can only be a reset...
2026 cdrom_end_request(drive, 1);
2030 blk_dump_rq_flags(rq, "ide-cd bad flags");
2031 cdrom_end_request(drive, 0);
2037 /****************************************************************************
2040 * Routines which queue packet commands take as a final argument a pointer
2041 * to a request_sense struct. If execution of the command results
2042 * in an error with a CHECK CONDITION status, this structure will be filled
2043 * with the results of the subsequent request sense command. The pointer
2044 * can also be NULL, in which case no sense information is returned.
2047 #if ! STANDARD_ATAPI
2051 return (x%10) | ((x/10) << 4);
2058 return (x >> 4) * 10 + (x & 0x0f);
2062 void msf_from_bcd (struct atapi_msf *msf)
2064 msf->minute = bcd2bin (msf->minute);
2065 msf->second = bcd2bin (msf->second);
2066 msf->frame = bcd2bin (msf->frame);
2069 #endif /* not STANDARD_ATAPI */
2073 void lba_to_msf (int lba, byte *m, byte *s, byte *f)
2075 lba += CD_MSF_OFFSET;
2076 lba &= 0xffffff; /* negative lbas use only 24 bits */
2077 *m = lba / (CD_SECS * CD_FRAMES);
2078 lba %= (CD_SECS * CD_FRAMES);
2079 *s = lba / CD_FRAMES;
2080 *f = lba % CD_FRAMES;
2085 int msf_to_lba (byte m, byte s, byte f)
2087 return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
2090 static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
2093 struct cdrom_info *info = drive->driver_data;
2094 struct cdrom_device_info *cdi = &info->devinfo;
2096 cdrom_prepare_request(&req);
2099 req.cmd[0] = GPCMD_TEST_UNIT_READY;
2100 req.flags |= REQ_QUIET;
2102 #if ! STANDARD_ATAPI
2103 /* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
2104 switch CDs instead of supporting the LOAD_UNLOAD opcode */
2106 req.cmd[7] = cdi->sanyo_slot % 3;
2107 #endif /* not STANDARD_ATAPI */
2109 return cdrom_queue_packet_command(drive, &req);
2113 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
2115 cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
2117 struct request_sense my_sense;
2124 /* If the drive cannot lock the door, just pretend. */
2125 if (CDROM_CONFIG_FLAGS(drive)->no_doorlock) {
2128 cdrom_prepare_request(&req);
2130 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
2131 req.cmd[4] = lockflag ? 1 : 0;
2132 stat = cdrom_queue_packet_command(drive, &req);
2135 /* If we got an illegal field error, the drive
2136 probably cannot lock the door. */
2138 sense->sense_key == ILLEGAL_REQUEST &&
2139 (sense->asc == 0x24 || sense->asc == 0x20)) {
2140 printk ("%s: door locking not supported\n",
2142 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2146 /* no medium, that's alright. */
2147 if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
2151 CDROM_STATE_FLAGS(drive)->door_locked = lockflag;
2157 /* Eject the disk if EJECTFLAG is 0.
2158 If EJECTFLAG is 1, try to reload the disk. */
2159 static int cdrom_eject(ide_drive_t *drive, int ejectflag,
2160 struct request_sense *sense)
2165 if (CDROM_CONFIG_FLAGS(drive)->no_eject && !ejectflag)
2166 return -EDRIVE_CANT_DO_THIS;
2168 /* reload fails on some drives, if the tray is locked */
2169 if (CDROM_STATE_FLAGS(drive)->door_locked && ejectflag)
2172 cdrom_prepare_request(&req);
2174 /* only tell drive to close tray if open, if it can do that */
2175 if (ejectflag && !CDROM_CONFIG_FLAGS(drive)->close_tray)
2179 req.cmd[0] = GPCMD_START_STOP_UNIT;
2180 req.cmd[4] = loej | (ejectflag != 0);
2181 return cdrom_queue_packet_command(drive, &req);
2184 static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
2185 unsigned long *sectors_per_frame,
2186 struct request_sense *sense)
2196 cdrom_prepare_request(&req);
2199 req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
2200 req.data = (char *)&capbuf;
2201 req.data_len = sizeof(capbuf);
2203 stat = cdrom_queue_packet_command(drive, &req);
2205 *capacity = 1 + be32_to_cpu(capbuf.lba);
2206 *sectors_per_frame =
2207 be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
2213 static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
2214 int format, char *buf, int buflen,
2215 struct request_sense *sense)
2219 cdrom_prepare_request(&req);
2223 req.data_len = buflen;
2224 req.flags |= REQ_QUIET;
2225 req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
2226 req.cmd[6] = trackno;
2227 req.cmd[7] = (buflen >> 8);
2228 req.cmd[8] = (buflen & 0xff);
2229 req.cmd[9] = (format << 6);
2234 return cdrom_queue_packet_command(drive, &req);
2238 /* Try to read the entire TOC for the disk into our internal buffer. */
2239 static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2241 int stat, ntracks, i;
2242 struct cdrom_info *info = drive->driver_data;
2243 struct cdrom_device_info *cdi = &info->devinfo;
2244 struct atapi_toc *toc = info->toc;
2246 struct atapi_toc_header hdr;
2247 struct atapi_toc_entry ent;
2250 unsigned long sectors_per_frame = SECTORS_PER_FRAME;
2253 /* Try to allocate space. */
2254 toc = (struct atapi_toc *) kmalloc (sizeof (struct atapi_toc),
2258 printk ("%s: No cdrom TOC buffer!\n", drive->name);
2263 /* Check to see if the existing data is still valid.
2264 If it is, just return. */
2265 (void) cdrom_check_status(drive, sense);
2267 if (CDROM_STATE_FLAGS(drive)->toc_valid)
2270 /* Try to get the total cdrom capacity and sector size. */
2271 stat = cdrom_read_capacity(drive, &toc->capacity, §ors_per_frame,
2274 toc->capacity = 0x1fffff;
2276 set_capacity(drive->disk, toc->capacity * sectors_per_frame);
2277 blk_queue_hardsect_size(drive->queue,
2278 sectors_per_frame << SECTOR_BITS);
2280 /* First read just the header, so we know how long the TOC is. */
2281 stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
2282 sizeof(struct atapi_toc_header), sense);
2283 if (stat) return stat;
2285 #if ! STANDARD_ATAPI
2286 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2287 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2288 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2290 #endif /* not STANDARD_ATAPI */
2292 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2295 if (ntracks > MAX_TRACKS)
2296 ntracks = MAX_TRACKS;
2298 /* Now read the whole schmeer. */
2299 stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
2301 sizeof(struct atapi_toc_header) +
2303 sizeof(struct atapi_toc_entry), sense);
2305 if (stat && toc->hdr.first_track > 1) {
2306 /* Cds with CDI tracks only don't have any TOC entries,
2307 despite of this the returned values are
2308 first_track == last_track = number of CDI tracks + 1,
2309 so that this case is indistinguishable from the same
2310 layout plus an additional audio track.
2311 If we get an error for the regular case, we assume
2312 a CDI without additional audio tracks. In this case
2313 the readable TOC is empty (CDI tracks are not included)
2314 and only holds the Leadout entry. Heiko Eißfeldt */
2316 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
2318 sizeof(struct atapi_toc_header) +
2320 sizeof(struct atapi_toc_entry),
2325 #if ! STANDARD_ATAPI
2326 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2327 toc->hdr.first_track = bin2bcd(CDROM_LEADOUT);
2328 toc->hdr.last_track = bin2bcd(CDROM_LEADOUT);
2330 #endif /* not STANDARD_ATAPI */
2332 toc->hdr.first_track = CDROM_LEADOUT;
2333 toc->hdr.last_track = CDROM_LEADOUT;
2340 toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
2342 #if ! STANDARD_ATAPI
2343 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2344 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2345 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2347 #endif /* not STANDARD_ATAPI */
2349 for (i=0; i<=ntracks; i++) {
2350 #if ! STANDARD_ATAPI
2351 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2352 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd)
2353 toc->ent[i].track = bcd2bin(toc->ent[i].track);
2354 msf_from_bcd(&toc->ent[i].addr.msf);
2356 #endif /* not STANDARD_ATAPI */
2357 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
2358 toc->ent[i].addr.msf.second,
2359 toc->ent[i].addr.msf.frame);
2362 /* Read the multisession information. */
2363 if (toc->hdr.first_track != CDROM_LEADOUT) {
2364 /* Read the multisession information. */
2365 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
2366 sizeof(ms_tmp), sense);
2367 if (stat) return stat;
2369 ms_tmp.ent.addr.msf.minute = 0;
2370 ms_tmp.ent.addr.msf.second = 2;
2371 ms_tmp.ent.addr.msf.frame = 0;
2372 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
2375 #if ! STANDARD_ATAPI
2376 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd)
2377 msf_from_bcd (&ms_tmp.ent.addr.msf);
2378 #endif /* not STANDARD_ATAPI */
2380 toc->last_session_lba = msf_to_lba (ms_tmp.ent.addr.msf.minute,
2381 ms_tmp.ent.addr.msf.second,
2382 ms_tmp.ent.addr.msf.frame);
2384 toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
2386 /* Now try to get the total cdrom capacity. */
2387 stat = cdrom_get_last_written(cdi, &last_written);
2388 if (!stat && (last_written > toc->capacity)) {
2389 toc->capacity = last_written;
2390 set_capacity(drive->disk, toc->capacity * sectors_per_frame);
2393 /* Remember that we've read this stuff. */
2394 CDROM_STATE_FLAGS(drive)->toc_valid = 1;
2400 static int cdrom_read_subchannel(ide_drive_t *drive, int format, char *buf,
2401 int buflen, struct request_sense *sense)
2405 cdrom_prepare_request(&req);
2409 req.data_len = buflen;
2410 req.cmd[0] = GPCMD_READ_SUBCHANNEL;
2411 req.cmd[1] = 2; /* MSF addressing */
2412 req.cmd[2] = 0x40; /* request subQ data */
2413 req.cmd[3] = format;
2414 req.cmd[7] = (buflen >> 8);
2415 req.cmd[8] = (buflen & 0xff);
2416 return cdrom_queue_packet_command(drive, &req);
2419 /* ATAPI cdrom drives are free to select the speed you request or any slower
2420 rate :-( Requesting too fast a speed will _not_ produce an error. */
2421 static int cdrom_select_speed(ide_drive_t *drive, int speed,
2422 struct request_sense *sense)
2425 cdrom_prepare_request(&req);
2429 speed = 0xffff; /* set to max */
2431 speed *= 177; /* Nx to kbytes/s */
2433 req.cmd[0] = GPCMD_SET_SPEED;
2434 /* Read Drive speed in kbytes/second MSB */
2435 req.cmd[2] = (speed >> 8) & 0xff;
2436 /* Read Drive speed in kbytes/second LSB */
2437 req.cmd[3] = speed & 0xff;
2438 if (CDROM_CONFIG_FLAGS(drive)->cd_r ||
2439 CDROM_CONFIG_FLAGS(drive)->cd_rw ||
2440 CDROM_CONFIG_FLAGS(drive)->dvd_r) {
2441 /* Write Drive speed in kbytes/second MSB */
2442 req.cmd[4] = (speed >> 8) & 0xff;
2443 /* Write Drive speed in kbytes/second LSB */
2444 req.cmd[5] = speed & 0xff;
2447 return cdrom_queue_packet_command(drive, &req);
2450 static int cdrom_play_audio(ide_drive_t *drive, int lba_start, int lba_end)
2452 struct request_sense sense;
2455 cdrom_prepare_request(&req);
2458 req.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2459 lba_to_msf(lba_start, &req.cmd[3], &req.cmd[4], &req.cmd[5]);
2460 lba_to_msf(lba_end-1, &req.cmd[6], &req.cmd[7], &req.cmd[8]);
2462 return cdrom_queue_packet_command(drive, &req);
2465 static int cdrom_get_toc_entry(ide_drive_t *drive, int track,
2466 struct atapi_toc_entry **ent)
2468 struct cdrom_info *info = drive->driver_data;
2469 struct atapi_toc *toc = info->toc;
2473 * don't serve cached data, if the toc isn't valid
2475 if (!CDROM_STATE_FLAGS(drive)->toc_valid)
2478 /* Check validity of requested track number. */
2479 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2480 if (toc->hdr.first_track == CDROM_LEADOUT) ntracks = 0;
2481 if (track == CDROM_LEADOUT)
2482 *ent = &toc->ent[ntracks];
2483 else if (track < toc->hdr.first_track ||
2484 track > toc->hdr.last_track)
2487 *ent = &toc->ent[track - toc->hdr.first_track];
2492 /* the generic packet interface to cdrom.c */
2493 static int ide_cdrom_packet(struct cdrom_device_info *cdi,
2494 struct cdrom_generic_command *cgc)
2497 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2499 if (cgc->timeout <= 0)
2500 cgc->timeout = ATAPI_WAIT_PC;
2502 /* here we queue the commands from the uniform CD-ROM
2503 layer. the packet must be complete, as we do not
2505 cdrom_prepare_request(&req);
2506 memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
2508 memset(cgc->sense, 0, sizeof(struct request_sense));
2509 req.data = cgc->buffer;
2510 req.data_len = cgc->buflen;
2511 req.timeout = cgc->timeout;
2514 req.flags |= REQ_QUIET;
2516 req.sense = cgc->sense;
2517 cgc->stat = cdrom_queue_packet_command(drive, &req);
2519 cgc->buflen -= req.data_len;
2524 int ide_cdrom_dev_ioctl (struct cdrom_device_info *cdi,
2525 unsigned int cmd, unsigned long arg)
2527 struct cdrom_generic_command cgc;
2531 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2533 /* These will be moved into the Uniform layer shortly... */
2535 case CDROMSETSPINDOWN: {
2538 if (copy_from_user(&spindown, (void *) arg, sizeof(char)))
2541 if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0)))
2544 buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
2546 return cdrom_mode_select(cdi, &cgc);
2549 case CDROMGETSPINDOWN: {
2552 if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0)))
2555 spindown = buffer[11] & 0x0f;
2557 if (copy_to_user((void *) arg, &spindown, sizeof (char)))
2570 int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
2571 unsigned int cmd, void *arg)
2574 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2575 struct cdrom_info *info = drive->driver_data;
2580 * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
2581 * atapi doesn't support it
2583 case CDROMPLAYTRKIND: {
2584 unsigned long lba_start, lba_end;
2585 struct cdrom_ti *ti = (struct cdrom_ti *)arg;
2586 struct atapi_toc_entry *first_toc, *last_toc;
2588 stat = cdrom_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
2592 stat = cdrom_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
2596 if (ti->cdti_trk1 != CDROM_LEADOUT)
2598 lba_start = first_toc->addr.lba;
2599 lba_end = last_toc->addr.lba;
2601 if (lba_end <= lba_start)
2604 return cdrom_play_audio(drive, lba_start, lba_end);
2607 case CDROMREADTOCHDR: {
2608 struct cdrom_tochdr *tochdr = (struct cdrom_tochdr *) arg;
2609 struct atapi_toc *toc;
2611 /* Make sure our saved TOC is valid. */
2612 stat = cdrom_read_toc(drive, NULL);
2613 if (stat) return stat;
2616 tochdr->cdth_trk0 = toc->hdr.first_track;
2617 tochdr->cdth_trk1 = toc->hdr.last_track;
2622 case CDROMREADTOCENTRY: {
2623 struct cdrom_tocentry *tocentry = (struct cdrom_tocentry*) arg;
2624 struct atapi_toc_entry *toce;
2626 stat = cdrom_get_toc_entry(drive, tocentry->cdte_track, &toce);
2627 if (stat) return stat;
2629 tocentry->cdte_ctrl = toce->control;
2630 tocentry->cdte_adr = toce->adr;
2631 if (tocentry->cdte_format == CDROM_MSF) {
2632 lba_to_msf (toce->addr.lba,
2633 &tocentry->cdte_addr.msf.minute,
2634 &tocentry->cdte_addr.msf.second,
2635 &tocentry->cdte_addr.msf.frame);
2637 tocentry->cdte_addr.lba = toce->addr.lba;
2648 int ide_cdrom_reset (struct cdrom_device_info *cdi)
2650 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2651 struct request_sense sense;
2655 cdrom_prepare_request(&req);
2656 req.flags = REQ_SPECIAL | REQ_QUIET;
2657 ret = ide_do_drive_cmd(drive, &req, ide_wait);
2660 * A reset will unlock the door. If it was previously locked,
2663 if (CDROM_STATE_FLAGS(drive)->door_locked)
2664 (void) cdrom_lockdoor(drive, 1, &sense);
2671 int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
2673 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2674 struct request_sense sense;
2677 int stat = cdrom_lockdoor(drive, 0, &sense);
2678 if (stat) return stat;
2681 return cdrom_eject(drive, !position, &sense);
2685 int ide_cdrom_lock_door (struct cdrom_device_info *cdi, int lock)
2687 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2688 return cdrom_lockdoor(drive, lock, NULL);
2692 int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
2694 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2695 struct request_sense sense;
2698 if ((stat = cdrom_select_speed(drive, speed, &sense)) < 0)
2701 cdi->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2706 * add logic to try GET_EVENT command first to check for media and tray
2707 * status. this should be supported by newer cd-r/w and all DVD etc
2711 int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
2713 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2714 struct media_event_desc med;
2715 struct request_sense sense;
2718 if (slot_nr != CDSL_CURRENT)
2721 stat = cdrom_check_status(drive, &sense);
2722 if (!stat || sense.sense_key == UNIT_ATTENTION)
2725 if (!cdrom_get_media_event(cdi, &med)) {
2726 if (med.media_present)
2729 return CDS_TRAY_OPEN;
2732 if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
2736 * If not using Mt Fuji extended media tray reports,
2737 * just return TRAY_OPEN since ATAPI doesn't provide
2738 * any other way to detect this...
2740 if (sense.sense_key == NOT_READY) {
2741 if (sense.asc == 0x3a && sense.ascq == 1)
2744 return CDS_TRAY_OPEN;
2747 return CDS_DRIVE_NOT_READY;
2751 int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
2752 struct cdrom_multisession *ms_info)
2754 struct atapi_toc *toc;
2755 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2756 struct cdrom_info *info = drive->driver_data;
2757 struct request_sense sense;
2760 if (!CDROM_STATE_FLAGS(drive)->toc_valid || info->toc == NULL)
2761 if ((ret = cdrom_read_toc(drive, &sense)))
2765 ms_info->addr.lba = toc->last_session_lba;
2766 ms_info->xa_flag = toc->xa_flag;
2772 int ide_cdrom_get_mcn (struct cdrom_device_info *cdi,
2773 struct cdrom_mcn *mcn_info)
2777 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2780 if ((stat = cdrom_read_subchannel(drive, 2, mcnbuf, sizeof (mcnbuf), NULL)))
2783 memcpy (mcn_info->medium_catalog_number, mcnbuf+9,
2784 sizeof (mcn_info->medium_catalog_number)-1);
2785 mcn_info->medium_catalog_number[sizeof (mcn_info->medium_catalog_number)-1]
2793 /****************************************************************************
2794 * Other driver requests (open, close, check media change).
2798 int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
2801 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2804 if (slot_nr == CDSL_CURRENT) {
2805 (void) cdrom_check_status(drive, NULL);
2806 retval = CDROM_STATE_FLAGS(drive)->media_changed;
2807 CDROM_STATE_FLAGS(drive)->media_changed = 0;
2816 int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
2823 * Close down the device. Invalidate all cached blocks.
2827 void ide_cdrom_release_real (struct cdrom_device_info *cdi)
2829 ide_drive_t *drive = cdi->handle;
2831 if (!cdi->use_count)
2832 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
2837 /****************************************************************************
2838 * Device initialization.
2840 static struct cdrom_device_ops ide_cdrom_dops = {
2841 .open = ide_cdrom_open_real,
2842 .release = ide_cdrom_release_real,
2843 .drive_status = ide_cdrom_drive_status,
2844 .media_changed = ide_cdrom_check_media_change_real,
2845 .tray_move = ide_cdrom_tray_move,
2846 .lock_door = ide_cdrom_lock_door,
2847 .select_speed = ide_cdrom_select_speed,
2848 .get_last_session = ide_cdrom_get_last_session,
2849 .get_mcn = ide_cdrom_get_mcn,
2850 .reset = ide_cdrom_reset,
2851 .audio_ioctl = ide_cdrom_audio_ioctl,
2852 .dev_ioctl = ide_cdrom_dev_ioctl,
2853 .capability = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
2854 CDC_SELECT_SPEED | CDC_SELECT_DISC |
2855 CDC_MULTI_SESSION | CDC_MCN |
2856 CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO | CDC_RESET |
2857 CDC_IOCTLS | CDC_DRIVE_STATUS | CDC_CD_R |
2858 CDC_CD_RW | CDC_DVD | CDC_DVD_R| CDC_DVD_RAM |
2859 CDC_GENERIC_PACKET | CDC_MO_DRIVE | CDC_MRW |
2860 CDC_MRW_W | CDC_RAM,
2861 .generic_packet = ide_cdrom_packet,
2864 static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2866 struct cdrom_info *info = drive->driver_data;
2867 struct cdrom_device_info *devinfo = &info->devinfo;
2869 devinfo->ops = &ide_cdrom_dops;
2871 devinfo->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2872 devinfo->capacity = nslots;
2873 devinfo->handle = (void *) drive;
2874 strcpy(devinfo->name, drive->name);
2876 /* set capability mask to match the probe. */
2877 if (!CDROM_CONFIG_FLAGS(drive)->cd_r)
2878 devinfo->mask |= CDC_CD_R;
2879 if (!CDROM_CONFIG_FLAGS(drive)->cd_rw)
2880 devinfo->mask |= CDC_CD_RW;
2881 if (!CDROM_CONFIG_FLAGS(drive)->dvd)
2882 devinfo->mask |= CDC_DVD;
2883 if (!CDROM_CONFIG_FLAGS(drive)->dvd_r)
2884 devinfo->mask |= CDC_DVD_R;
2885 if (!CDROM_CONFIG_FLAGS(drive)->dvd_ram)
2886 devinfo->mask |= CDC_DVD_RAM;
2887 if (!CDROM_CONFIG_FLAGS(drive)->is_changer)
2888 devinfo->mask |= CDC_SELECT_DISC;
2889 if (!CDROM_CONFIG_FLAGS(drive)->audio_play)
2890 devinfo->mask |= CDC_PLAY_AUDIO;
2891 if (!CDROM_CONFIG_FLAGS(drive)->close_tray)
2892 devinfo->mask |= CDC_CLOSE_TRAY;
2893 if (!CDROM_CONFIG_FLAGS(drive)->mo_drive)
2894 devinfo->mask |= CDC_MO_DRIVE;
2895 if (!CDROM_CONFIG_FLAGS(drive)->mrw)
2896 devinfo->mask |= CDC_MRW;
2897 if (!CDROM_CONFIG_FLAGS(drive)->mrw_w)
2898 devinfo->mask |= CDC_MRW_W;
2899 if (!CDROM_CONFIG_FLAGS(drive)->ram)
2900 devinfo->mask |= CDC_RAM;
2902 devinfo->disk = drive->disk;
2903 return register_cdrom(devinfo);
2907 int ide_cdrom_get_capabilities(ide_drive_t *drive, struct atapi_capabilities_page *cap)
2909 struct cdrom_info *info = drive->driver_data;
2910 struct cdrom_device_info *cdi = &info->devinfo;
2911 struct cdrom_generic_command cgc;
2912 int stat, attempts = 3, size = sizeof(*cap);
2915 * ACER50 (and others?) require the full spec length mode sense
2916 * page capabilities size, but older drives break.
2918 if (!(!strcmp(drive->id->model, "ATAPI CD ROM DRIVE 50X MAX") ||
2919 !strcmp(drive->id->model, "WPI CDS-32X")))
2920 size -= sizeof(cap->pad);
2922 init_cdrom_command(&cgc, cap, size, CGC_DATA_UNKNOWN);
2923 do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2924 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
2927 } while (--attempts);
2932 int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2934 struct cdrom_info *info = drive->driver_data;
2935 struct cdrom_device_info *cdi = &info->devinfo;
2936 struct atapi_capabilities_page cap;
2937 int nslots = 1, mrw_write = 0, ram_write = 0;
2939 if (drive->media == ide_optical) {
2940 CDROM_CONFIG_FLAGS(drive)->mo_drive = 1;
2941 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2942 printk("%s: ATAPI magneto-optical drive\n", drive->name);
2946 if (CDROM_CONFIG_FLAGS(drive)->nec260 ||
2947 !strcmp(drive->id->model,"STINGRAY 8422 IDE 8X CD-ROM 7-27-95")) {
2948 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2949 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2954 * we have to cheat a little here. the packet will eventually
2955 * be queued with ide_cdrom_packet(), which extracts the
2956 * drive from cdi->handle. Since this device hasn't been
2957 * registered with the Uniform layer yet, it can't do this.
2958 * Same goes for cdi->ops.
2960 cdi->handle = (ide_drive_t *) drive;
2961 cdi->ops = &ide_cdrom_dops;
2963 if (ide_cdrom_get_capabilities(drive, &cap))
2966 if (!cdrom_is_mrw(cdi, &mrw_write)) {
2967 CDROM_CONFIG_FLAGS(drive)->mrw = 1;
2969 CDROM_CONFIG_FLAGS(drive)->mrw_w = 1;
2970 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2973 if (!cdrom_is_random_writable(cdi, &ram_write))
2975 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2978 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2980 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2982 CDROM_CONFIG_FLAGS(drive)->cd_r = 1;
2983 if (cap.cd_rw_write)
2984 CDROM_CONFIG_FLAGS(drive)->cd_rw = 1;
2986 CDROM_CONFIG_FLAGS(drive)->test_write = 1;
2987 if (cap.dvd_ram_read || cap.dvd_r_read || cap.dvd_rom)
2988 CDROM_CONFIG_FLAGS(drive)->dvd = 1;
2989 if (cap.dvd_ram_write) {
2990 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 1;
2991 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2993 if (cap.dvd_r_write)
2994 CDROM_CONFIG_FLAGS(drive)->dvd_r = 1;
2996 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2997 if (cap.mechtype == mechtype_caddy || cap.mechtype == mechtype_popup)
2998 CDROM_CONFIG_FLAGS(drive)->close_tray = 0;
3000 /* Some drives used by Apple don't advertise audio play
3001 * but they do support reading TOC & audio datas
3003 if (strcmp(drive->id->model, "MATSHITADVD-ROM SR-8187") == 0 ||
3004 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8186") == 0 ||
3005 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8176") == 0 ||
3006 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8174") == 0)
3007 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
3009 #if ! STANDARD_ATAPI
3010 if (cdi->sanyo_slot > 0) {
3011 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
3016 #endif /* not STANDARD_ATAPI */
3017 if (cap.mechtype == mechtype_individual_changer ||
3018 cap.mechtype == mechtype_cartridge_changer) {
3019 if ((nslots = cdrom_number_of_slots(cdi)) > 1) {
3020 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
3021 CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 1;
3025 /* The ACER/AOpen 24X cdrom has the speed fields byte-swapped */
3026 if (!drive->id->model[0] &&
3027 !strncmp(drive->id->fw_rev, "241N", 4)) {
3028 CDROM_STATE_FLAGS(drive)->current_speed =
3029 (((unsigned int)cap.curspeed) + (176/2)) / 176;
3030 CDROM_CONFIG_FLAGS(drive)->max_speed =
3031 (((unsigned int)cap.maxspeed) + (176/2)) / 176;
3033 CDROM_STATE_FLAGS(drive)->current_speed =
3034 (ntohs(cap.curspeed) + (176/2)) / 176;
3035 CDROM_CONFIG_FLAGS(drive)->max_speed =
3036 (ntohs(cap.maxspeed) + (176/2)) / 176;
3039 /* don't print speed if the drive reported 0.
3041 printk("%s: ATAPI", drive->name);
3042 if (CDROM_CONFIG_FLAGS(drive)->max_speed)
3043 printk(" %dX", CDROM_CONFIG_FLAGS(drive)->max_speed);
3044 printk(" %s", CDROM_CONFIG_FLAGS(drive)->dvd ? "DVD-ROM" : "CD-ROM");
3046 if (CDROM_CONFIG_FLAGS(drive)->dvd_r|CDROM_CONFIG_FLAGS(drive)->dvd_ram)
3048 (CDROM_CONFIG_FLAGS(drive)->dvd_r)? "-R" : "",
3049 (CDROM_CONFIG_FLAGS(drive)->dvd_ram)? "-RAM" : "");
3051 if (CDROM_CONFIG_FLAGS(drive)->cd_r|CDROM_CONFIG_FLAGS(drive)->cd_rw)
3053 (CDROM_CONFIG_FLAGS(drive)->cd_r)? "-R" : "",
3054 (CDROM_CONFIG_FLAGS(drive)->cd_rw)? "/RW" : "");
3056 if (CDROM_CONFIG_FLAGS(drive)->mrw || CDROM_CONFIG_FLAGS(drive)->mrw_w)
3057 printk(" CD-MR%s", CDROM_CONFIG_FLAGS(drive)->mrw_w ? "W" : "");
3059 if (CDROM_CONFIG_FLAGS(drive)->is_changer)
3060 printk(" changer w/%d slots", nslots);
3064 printk(", %dkB Cache", be16_to_cpu(cap.buffer_size));
3066 #ifdef CONFIG_BLK_DEV_IDEDMA
3067 if (drive->using_dma)
3068 (void) HWIF(drive)->ide_dma_verbose(drive);
3069 #endif /* CONFIG_BLK_DEV_IDEDMA */
3075 static void ide_cdrom_add_settings(ide_drive_t *drive)
3077 ide_add_setting(drive, "dsc_overlap", SETTING_RW, -1, -1, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
3081 * standard prep_rq_fn that builds 10 byte cmds
3083 static int ide_cdrom_prep_fs(request_queue_t *q, struct request *rq)
3085 int hard_sect = queue_hardsect_size(q);
3086 long block = (long)rq->hard_sector / (hard_sect >> 9);
3087 unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
3089 memset(rq->cmd, 0, sizeof(rq->cmd));
3091 if (rq_data_dir(rq) == READ)
3092 rq->cmd[0] = GPCMD_READ_10;
3094 rq->cmd[0] = GPCMD_WRITE_10;
3099 rq->cmd[2] = (block >> 24) & 0xff;
3100 rq->cmd[3] = (block >> 16) & 0xff;
3101 rq->cmd[4] = (block >> 8) & 0xff;
3102 rq->cmd[5] = block & 0xff;
3105 * and transfer length
3107 rq->cmd[7] = (blocks >> 8) & 0xff;
3108 rq->cmd[8] = blocks & 0xff;
3114 * Most of the SCSI commands are supported directly by ATAPI devices.
3115 * This transform handles the few exceptions.
3117 static int ide_cdrom_prep_pc(struct request *rq)
3122 * Transform 6-byte read/write commands to the 10-byte version
3124 if (c[0] == READ_6 || c[0] == WRITE_6) {
3131 c[0] += (READ_10 - READ_6);
3137 * it's silly to pretend we understand 6-byte sense commands, just
3138 * reject with ILLEGAL_REQUEST and the caller should take the
3139 * appropriate action
3141 if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
3142 rq->errors = ILLEGAL_REQUEST;
3143 return BLKPREP_KILL;
3149 static int ide_cdrom_prep_fn(request_queue_t *q, struct request *rq)
3151 if (rq->flags & REQ_CMD)
3152 return ide_cdrom_prep_fs(q, rq);
3153 else if (rq->flags & REQ_BLOCK_PC)
3154 return ide_cdrom_prep_pc(rq);
3160 int ide_cdrom_setup (ide_drive_t *drive)
3162 struct cdrom_info *info = drive->driver_data;
3163 struct cdrom_device_info *cdi = &info->devinfo;
3166 blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
3167 blk_queue_dma_alignment(drive->queue, 3);
3168 drive->queue->unplug_delay = (1 * HZ) / 1000;
3169 if (!drive->queue->unplug_delay)
3170 drive->queue->unplug_delay = 1;
3172 drive->special.all = 0;
3173 drive->ready_stat = 0;
3175 CDROM_STATE_FLAGS(drive)->media_changed = 1;
3176 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
3177 CDROM_STATE_FLAGS(drive)->door_locked = 0;
3180 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
3182 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 0;
3185 CDROM_CONFIG_FLAGS(drive)->drq_interrupt = ((drive->id->config & 0x0060) == 0x20);
3186 CDROM_CONFIG_FLAGS(drive)->is_changer = 0;
3187 CDROM_CONFIG_FLAGS(drive)->cd_r = 0;
3188 CDROM_CONFIG_FLAGS(drive)->cd_rw = 0;
3189 CDROM_CONFIG_FLAGS(drive)->test_write = 0;
3190 CDROM_CONFIG_FLAGS(drive)->dvd = 0;
3191 CDROM_CONFIG_FLAGS(drive)->dvd_r = 0;
3192 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 0;
3193 CDROM_CONFIG_FLAGS(drive)->no_eject = 1;
3194 CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 0;
3195 CDROM_CONFIG_FLAGS(drive)->audio_play = 0;
3196 CDROM_CONFIG_FLAGS(drive)->close_tray = 1;
3198 /* limit transfer size per interrupt. */
3199 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 0;
3200 /* a testament to the nice quality of Samsung drives... */
3201 if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2430"))
3202 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3203 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2432"))
3204 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3205 /* the 3231 model does not support the SET_CD_SPEED command */
3206 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-3231"))
3207 cdi->mask |= CDC_SELECT_SPEED;
3209 #if ! STANDARD_ATAPI
3210 /* by default Sanyo 3 CD changer support is turned off and
3211 ATAPI Rev 2.2+ standard support for CD changers is used */
3212 cdi->sanyo_slot = 0;
3214 CDROM_CONFIG_FLAGS(drive)->nec260 = 0;
3215 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 0;
3216 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 0;
3217 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 0;
3218 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 0;
3220 if (strcmp (drive->id->model, "V003S0DS") == 0 &&
3221 drive->id->fw_rev[4] == '1' &&
3222 drive->id->fw_rev[6] <= '2') {
3224 Some versions of this drive like to talk BCD. */
3225 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3226 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3227 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3228 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3231 else if (strcmp (drive->id->model, "V006E0DS") == 0 &&
3232 drive->id->fw_rev[4] == '1' &&
3233 drive->id->fw_rev[6] <= '2') {
3234 /* Vertos 600 ESD. */
3235 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3237 else if (strcmp(drive->id->model, "NEC CD-ROM DRIVE:260") == 0 &&
3238 strncmp(drive->id->fw_rev, "1.01", 4) == 0) { /* FIXME */
3239 /* Old NEC260 (not R).
3240 This drive was released before the 1.2 version
3242 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3243 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3244 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3245 CDROM_CONFIG_FLAGS(drive)->nec260 = 1;
3247 else if (strcmp(drive->id->model, "WEARNES CDD-120") == 0 &&
3248 strncmp(drive->id->fw_rev, "A1.1", 4) == 0) { /* FIXME */
3250 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3251 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3253 /* Sanyo 3 CD changer uses a non-standard command
3255 else if ((strcmp(drive->id->model, "CD-ROM CDR-C3 G") == 0) ||
3256 (strcmp(drive->id->model, "CD-ROM CDR-C3G") == 0) ||
3257 (strcmp(drive->id->model, "CD-ROM CDR_C36") == 0)) {
3258 /* uses CD in slot 0 when value is set to 3 */
3259 cdi->sanyo_slot = 3;
3261 #endif /* not STANDARD_ATAPI */
3264 info->buffer = NULL;
3265 info->sector_buffered = 0;
3266 info->nsectors_buffered = 0;
3267 info->changer_info = NULL;
3268 info->last_block = 0;
3269 info->start_seek = 0;
3271 nslots = ide_cdrom_probe_capabilities (drive);
3274 * set correct block size and read-only for non-ram media
3276 set_disk_ro(drive->disk, !CDROM_CONFIG_FLAGS(drive)->ram);
3277 blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
3280 drive->dsc_overlap = (HWIF(drive)->no_dsc) ? 0 : 1;
3281 if (HWIF(drive)->no_dsc) {
3282 printk(KERN_INFO "ide-cd: %s: disabling DSC overlap\n",
3284 drive->dsc_overlap = 0;
3288 if (ide_cdrom_register(drive, nslots)) {
3289 printk ("%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
3290 info->devinfo.handle = NULL;
3293 ide_cdrom_add_settings(drive);
3298 sector_t ide_cdrom_capacity (ide_drive_t *drive)
3300 unsigned long capacity, sectors_per_frame;
3302 if (cdrom_read_capacity(drive, &capacity, §ors_per_frame, NULL))
3305 return capacity * sectors_per_frame;
3309 int ide_cdrom_cleanup(ide_drive_t *drive)
3311 struct cdrom_info *info = drive->driver_data;
3312 struct cdrom_device_info *devinfo = &info->devinfo;
3313 struct gendisk *g = drive->disk;
3315 if (ide_unregister_subdriver(drive)) {
3316 printk("%s: %s: failed to ide_unregister_subdriver\n",
3317 __FUNCTION__, drive->name);
3320 if (info->buffer != NULL)
3321 kfree(info->buffer);
3322 if (info->toc != NULL)
3324 if (info->changer_info != NULL)
3325 kfree(info->changer_info);
3326 if (devinfo->handle == drive && unregister_cdrom(devinfo))
3327 printk("%s: ide_cdrom_cleanup failed to unregister device from the cdrom driver.\n", drive->name);
3329 drive->driver_data = NULL;
3330 blk_queue_prep_rq(drive->queue, NULL);
3336 static int ide_cdrom_attach (ide_drive_t *drive);
3339 * Power Management state machine.
3341 * We don't do much for CDs right now.
3344 static void ide_cdrom_complete_power_step (ide_drive_t *drive, struct request *rq, u8 stat, u8 error)
3348 static ide_startstop_t ide_cdrom_start_power_step (ide_drive_t *drive, struct request *rq)
3350 ide_task_t *args = rq->special;
3352 memset(args, 0, sizeof(*args));
3354 switch (rq->pm->pm_step) {
3355 case ide_pm_state_start_suspend:
3358 case ide_pm_state_start_resume: /* Resume step 1 (restore DMA) */
3360 * Right now, all we do is call hwif->ide_dma_check(drive),
3361 * we could be smarter and check for current xfer_speed
3362 * in struct drive etc...
3363 * Also, this step could be implemented as a generic helper
3364 * as most subdrivers will use it.
3366 if ((drive->id->capability & 1) == 0)
3368 if (HWIF(drive)->ide_dma_check == NULL)
3370 HWIF(drive)->ide_dma_check(drive);
3373 rq->pm->pm_step = ide_pm_state_completed;
3377 static ide_driver_t ide_cdrom_driver = {
3378 .owner = THIS_MODULE,
3379 .name = "ide-cdrom",
3380 .version = IDECD_VERSION,
3383 .supports_dsc_overlap = 1,
3384 .cleanup = ide_cdrom_cleanup,
3385 .do_request = ide_do_rw_cdrom,
3386 .sense = ide_dump_atapi_status,
3387 .error = ide_cdrom_error,
3388 .abort = ide_cdrom_abort,
3389 .capacity = ide_cdrom_capacity,
3390 .attach = ide_cdrom_attach,
3391 .drives = LIST_HEAD_INIT(ide_cdrom_driver.drives),
3392 .start_power_step = ide_cdrom_start_power_step,
3393 .complete_power_step = ide_cdrom_complete_power_step,
3396 static int idecd_open(struct inode * inode, struct file * file)
3398 ide_drive_t *drive = inode->i_bdev->bd_disk->private_data;
3399 struct cdrom_info *info = drive->driver_data;
3404 info->buffer = kmalloc(SECTOR_BUFFER_SIZE,
3405 GFP_KERNEL|__GFP_REPEAT);
3406 if (!info->buffer || (rc = cdrom_open(&info->devinfo, inode, file)))
3411 static int idecd_release(struct inode * inode, struct file * file)
3413 ide_drive_t *drive = inode->i_bdev->bd_disk->private_data;
3414 struct cdrom_info *info = drive->driver_data;
3416 cdrom_release (&info->devinfo, file);
3421 static int idecd_ioctl (struct inode *inode, struct file *file,
3422 unsigned int cmd, unsigned long arg)
3424 struct block_device *bdev = inode->i_bdev;
3425 ide_drive_t *drive = bdev->bd_disk->private_data;
3426 int err = generic_ide_ioctl(bdev, cmd, arg);
3427 if (err == -EINVAL) {
3428 struct cdrom_info *info = drive->driver_data;
3429 err = cdrom_ioctl(&info->devinfo, inode, cmd, arg);
3434 static int idecd_media_changed(struct gendisk *disk)
3436 ide_drive_t *drive = disk->private_data;
3437 struct cdrom_info *info = drive->driver_data;
3438 return cdrom_media_changed(&info->devinfo);
3441 static int idecd_revalidate_disk(struct gendisk *disk)
3443 ide_drive_t *drive = disk->private_data;
3444 struct request_sense sense;
3445 cdrom_read_toc(drive, &sense);
3449 static struct block_device_operations idecd_ops = {
3450 .owner = THIS_MODULE,
3452 .release = idecd_release,
3453 .ioctl = idecd_ioctl,
3454 .media_changed = idecd_media_changed,
3455 .revalidate_disk= idecd_revalidate_disk
3459 char *ignore = NULL;
3461 MODULE_PARM(ignore, "s");
3462 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
3464 static int ide_cdrom_attach (ide_drive_t *drive)
3466 struct cdrom_info *info;
3467 struct gendisk *g = drive->disk;
3468 struct request_sense sense;
3470 if (!strstr("ide-cdrom", drive->driver_req))
3472 if (!drive->present)
3474 if (drive->media != ide_cdrom && drive->media != ide_optical)
3476 /* skip drives that we were told to ignore */
3477 if (ignore != NULL) {
3478 if (strstr(ignore, drive->name)) {
3479 printk("ide-cd: ignoring drive %s\n", drive->name);
3484 printk("ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
3487 info = (struct cdrom_info *) kmalloc (sizeof (struct cdrom_info), GFP_KERNEL);
3489 printk("%s: Can't allocate a cdrom structure\n", drive->name);
3492 if (ide_register_subdriver(drive, &ide_cdrom_driver)) {
3493 printk("%s: Failed to register the driver with ide.c\n",
3498 memset(info, 0, sizeof (struct cdrom_info));
3499 drive->driver_data = info;
3500 DRIVER(drive)->busy++;
3502 snprintf(g->devfs_name, sizeof(g->devfs_name),
3503 "%s/cd", drive->devfs_name);
3504 g->driverfs_dev = &drive->gendev;
3505 g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
3506 if (ide_cdrom_setup(drive)) {
3507 struct cdrom_device_info *devinfo = &info->devinfo;
3508 DRIVER(drive)->busy--;
3509 ide_unregister_subdriver(drive);
3510 if (info->buffer != NULL)
3511 kfree(info->buffer);
3512 if (info->toc != NULL)
3514 if (info->changer_info != NULL)
3515 kfree(info->changer_info);
3516 if (devinfo->handle == drive && unregister_cdrom(devinfo))
3517 printk ("%s: ide_cdrom_cleanup failed to unregister device from the cdrom driver.\n", drive->name);
3519 drive->driver_data = NULL;
3522 DRIVER(drive)->busy--;
3524 cdrom_read_toc(drive, &sense);
3525 g->fops = &idecd_ops;
3526 g->flags |= GENHD_FL_REMOVABLE;
3533 static void __exit ide_cdrom_exit(void)
3535 ide_unregister_driver(&ide_cdrom_driver);
3538 static int ide_cdrom_init(void)
3540 ide_register_driver(&ide_cdrom_driver);
3544 module_init(ide_cdrom_init);
3545 module_exit(ide_cdrom_exit);
3546 MODULE_LICENSE("GPL");