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)
374 * Make good and sure we've seen this potential media
375 * change. Some drives (i.e. Creative) fail to present
376 * the correct sense key in the error register.
378 cdrom_saw_media_change(drive);
388 void cdrom_analyze_sense_data(ide_drive_t *drive,
389 struct request *failed_command,
390 struct request_sense *sense)
392 unsigned long sector;
393 unsigned long bio_sectors;
396 if (!cdrom_log_sense(drive, failed_command, sense))
400 * If a read toc is executed for a CD-R or CD-RW medium where
401 * the first toc has not been recorded yet, it will fail with
402 * 05/24/00 (which is a confusing error)
404 if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP)
405 if (sense->sense_key == 0x05 && sense->asc == 0x24)
408 if (sense->error_code == 0x70) { /* Current Error */
409 switch(sense->sense_key) {
411 case VOLUME_OVERFLOW:
412 case ILLEGAL_REQUEST:
415 if(failed_command == NULL || !blk_fs_request(failed_command))
417 sector = (sense->information[0] << 24) |
418 (sense->information[1] << 16) |
419 (sense->information[2] << 8) |
420 (sense->information[3]);
422 bio_sectors = bio_sectors(failed_command->bio);
425 if(drive->queue->hardsect_size == 2048)
426 sector <<= 2; /* Device sector size is 2K */
427 sector &= ~(bio_sectors -1);
428 valid = (sector - failed_command->sector) << 9;
432 if(sector < get_capacity(drive->disk) &&
433 drive->probed_capacity - sector < 4 * 75) {
434 set_capacity(drive->disk, sector);
438 #if VERBOSE_IDE_CD_ERRORS
444 printk (KERN_ERR "ATAPI device %s:\n", drive->name);
445 if (sense->error_code==0x70)
447 else if (sense->error_code==0x71)
448 printk(" Deferred Error: ");
449 else if (sense->error_code == 0x7f)
450 printk(" Vendor-specific Error: ");
452 printk(" Unknown Error Type: ");
454 if (sense->sense_key < ARY_LEN(sense_key_texts))
455 s = sense_key_texts[sense->sense_key];
457 s = "bad sense key!";
459 printk("%s -- (Sense key=0x%02x)\n", s, sense->sense_key);
461 if (sense->asc == 0x40) {
462 sprintf(buf, "Diagnostic failure on component 0x%02x",
466 int lo = 0, mid, hi = ARY_LEN(sense_data_texts);
467 unsigned long key = (sense->sense_key << 16);
468 key |= (sense->asc << 8);
469 if (!(sense->ascq >= 0x80 && sense->ascq <= 0xdd))
475 if (sense_data_texts[mid].asc_ascq == key ||
476 sense_data_texts[mid].asc_ascq == (0xff0000|key)) {
477 s = sense_data_texts[mid].text;
480 else if (sense_data_texts[mid].asc_ascq > key)
488 if (sense->asc > 0x80)
489 s = "(vendor-specific error)";
491 s = "(reserved error code)";
494 printk(KERN_ERR " %s -- (asc=0x%02x, ascq=0x%02x)\n",
495 s, sense->asc, sense->ascq);
497 if (failed_command != NULL) {
499 int lo=0, mid, hi= ARY_LEN (packet_command_texts);
504 if (packet_command_texts[mid].packet_command ==
505 failed_command->cmd[0]) {
506 s = packet_command_texts[mid].text;
509 if (packet_command_texts[mid].packet_command >
510 failed_command->cmd[0])
516 printk (KERN_ERR " The failed \"%s\" packet command was: \n \"", s);
517 for (i=0; i<sizeof (failed_command->cmd); i++)
518 printk ("%02x ", failed_command->cmd[i]);
522 /* The SKSV bit specifies validity of the sense_key_specific
523 * in the next two commands. It is bit 7 of the first byte.
524 * In the case of NOT_READY, if SKSV is set the drive can
525 * give us nice ETA readings.
527 if (sense->sense_key == NOT_READY && (sense->sks[0] & 0x80)) {
528 int progress = (sense->sks[1] << 8 | sense->sks[2]) * 100;
529 printk(KERN_ERR " Command is %02d%% complete\n", progress / 0xffff);
533 if (sense->sense_key == ILLEGAL_REQUEST &&
534 (sense->sks[0] & 0x80) != 0) {
535 printk(KERN_ERR " Error in %s byte %d",
536 (sense->sks[0] & 0x40) != 0 ?
537 "command packet" : "command data",
538 (sense->sks[1] << 8) + sense->sks[2]);
540 if ((sense->sks[0] & 0x40) != 0)
541 printk (" bit %d", sense->sks[0] & 0x07);
547 #else /* not VERBOSE_IDE_CD_ERRORS */
549 /* Suppress printing unit attention and `in progress of becoming ready'
550 errors when we're not being verbose. */
552 if (sense->sense_key == UNIT_ATTENTION ||
553 (sense->sense_key == NOT_READY && (sense->asc == 4 ||
554 sense->asc == 0x3a)))
557 printk(KERN_ERR "%s: error code: 0x%02x sense_key: 0x%02x asc: 0x%02x ascq: 0x%02x\n",
559 sense->error_code, sense->sense_key,
560 sense->asc, sense->ascq);
561 #endif /* not VERBOSE_IDE_CD_ERRORS */
565 * Initialize a ide-cd packet command request
567 static void cdrom_prepare_request(struct request *rq)
569 ide_init_drive_cmd(rq);
573 static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense,
574 struct request *failed_command)
576 struct cdrom_info *info = drive->driver_data;
577 struct request *rq = &info->request_sense_request;
580 sense = &info->sense_data;
582 /* stuff the sense request in front of our current request */
583 cdrom_prepare_request(rq);
586 rq->cmd[0] = GPCMD_REQUEST_SENSE;
587 rq->cmd[4] = rq->data_len = 18;
589 rq->flags = REQ_SENSE;
591 /* NOTE! Save the failed command in "rq->buffer" */
592 rq->buffer = (void *) failed_command;
594 (void) ide_do_drive_cmd(drive, rq, ide_preempt);
598 * ide_error() takes action based on the error returned by the drive.
600 ide_startstop_t ide_cdrom_error (ide_drive_t *drive, const char *msg, byte stat)
605 err = ide_dump_atapi_status(drive, msg, stat);
606 if (drive == NULL || (rq = HWGROUP(drive)->rq) == NULL)
608 /* retry only "normal" I/O: */
609 if (rq->flags & (REQ_DRIVE_CMD | REQ_DRIVE_TASK | REQ_DRIVE_TASKFILE)) {
611 ide_end_drive_cmd(drive, stat, err);
615 if (stat & BUSY_STAT || ((stat & WRERR_STAT) && !drive->nowerr)) {
616 /* other bits are useless when BUSY */
617 rq->errors |= ERROR_RESET;
619 /* add decoding error stuff */
621 if (HWIF(drive)->INB(IDE_STATUS_REG) & (BUSY_STAT|DRQ_STAT))
623 HWIF(drive)->OUTB(WIN_IDLEIMMEDIATE,IDE_COMMAND_REG);
624 if (rq->errors >= ERROR_MAX) {
625 DRIVER(drive)->end_request(drive, 0, 0);
627 if ((rq->errors & ERROR_RESET) == ERROR_RESET) {
629 return ide_do_reset(drive);
636 ide_startstop_t ide_cdrom_abort (ide_drive_t *drive, const char *msg)
640 if (drive == NULL || (rq = HWGROUP(drive)->rq) == NULL)
642 /* retry only "normal" I/O: */
643 if (rq->flags & (REQ_DRIVE_CMD | REQ_DRIVE_TASK | REQ_DRIVE_TASKFILE)) {
645 ide_end_drive_cmd(drive, BUSY_STAT, 0);
648 rq->errors |= ERROR_RESET;
649 DRIVER(drive)->end_request(drive, 0, 0);
653 static void cdrom_end_request (ide_drive_t *drive, int uptodate)
655 struct request *rq = HWGROUP(drive)->rq;
656 int nsectors = rq->hard_cur_sectors;
658 if ((rq->flags & REQ_SENSE) && uptodate) {
660 * For REQ_SENSE, "rq->buffer" points to the original failed
663 struct request *failed = (struct request *) rq->buffer;
664 struct cdrom_info *info = drive->driver_data;
665 void *sense = &info->sense_data;
670 sense = failed->sense;
671 failed->sense_len = rq->sense_len;
673 cdrom_analyze_sense_data(drive, failed, sense);
675 * now end failed request
677 if(blk_fs_request(failed)) {
678 if(ide_end_dequeued_request(drive, failed, 0, failed->hard_nr_sectors))
681 spin_lock_irqsave(&ide_lock, flags);
682 end_that_request_chunk(failed, 0, failed->data_len);
683 end_that_request_last(failed);
684 spin_unlock_irqrestore(&ide_lock, flags);
688 cdrom_analyze_sense_data(drive, NULL , sense);
691 if (!rq->current_nr_sectors && blk_fs_request(rq))
693 /* make sure it's fully ended */
694 if (blk_pc_request(rq))
695 nsectors = (rq->data_len + 511) >> 9;
699 ide_end_request(drive, uptodate, nsectors);
702 static void ide_dump_status_no_sense(ide_drive_t *drive, const char *msg, u8 stat)
706 ide_dump_status(drive, msg, stat);
709 /* Returns 0 if the request should be continued.
710 Returns 1 if the request was ended. */
711 static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
713 struct request *rq = HWGROUP(drive)->rq;
714 int stat, err, sense_key;
716 /* Check for errors. */
717 stat = HWIF(drive)->INB(IDE_STATUS_REG);
721 if (OK_STAT(stat, good_stat, BAD_R_STAT))
724 /* Get the IDE error register. */
725 err = HWIF(drive)->INB(IDE_ERROR_REG);
726 sense_key = err >> 4;
729 printk("%s: missing rq in cdrom_decode_status\n", drive->name);
733 if (rq->flags & REQ_SENSE) {
734 /* We got an error trying to get sense info
735 from the drive (probably while trying
736 to recover from a former error). Just give up. */
738 rq->flags |= REQ_FAILED;
739 cdrom_end_request(drive, 0);
740 DRIVER(drive)->error(drive, "request sense failure", stat);
743 } else if (rq->flags & (REQ_PC | REQ_BLOCK_PC)) {
744 /* All other functions, except for READ. */
748 * if we have an error, pass back CHECK_CONDITION as the
751 if ((rq->flags & REQ_BLOCK_PC) && !rq->errors)
752 rq->errors = SAM_STAT_CHECK_CONDITION;
754 /* Check for tray open. */
755 if (sense_key == NOT_READY) {
756 cdrom_saw_media_change (drive);
757 } else if (sense_key == UNIT_ATTENTION) {
758 /* Check for media change. */
759 cdrom_saw_media_change (drive);
760 /*printk("%s: media changed\n",drive->name);*/
762 } else if (!(rq->flags & REQ_QUIET)) {
763 /* Otherwise, print an error. */
764 ide_dump_status(drive, "packet command error", stat);
767 rq->flags |= REQ_FAILED;
770 * instead of playing games with moving completions around,
771 * remove failed request completely and end it when the
772 * request sense has completed
774 if (stat & ERR_STAT) {
775 spin_lock_irqsave(&ide_lock, flags);
776 blkdev_dequeue_request(rq);
777 HWGROUP(drive)->rq = NULL;
778 spin_unlock_irqrestore(&ide_lock, flags);
780 cdrom_queue_request_sense(drive, rq->sense, rq);
782 cdrom_end_request(drive, 0);
784 } else if (blk_fs_request(rq)) {
785 int do_end_request = 0;
787 /* Handle errors from READ and WRITE requests. */
789 if (blk_noretry_request(rq))
792 if (sense_key == NOT_READY) {
794 if (rq_data_dir(rq) == READ) {
795 cdrom_saw_media_change (drive);
797 /* Fail the request. */
798 printk ("%s: tray open\n", drive->name);
801 struct cdrom_info *info = drive->driver_data;
803 /* allow the drive 5 seconds to recover, some
804 * devices will return this error while flushing
807 info->write_timeout = jiffies + ATAPI_WAIT_WRITE_BUSY;
809 if (time_after(jiffies, info->write_timeout))
815 * take a breather relying on the
816 * unplug timer to kick us again
818 spin_lock_irqsave(&ide_lock, flags);
819 blk_plug_device(drive->queue);
820 spin_unlock_irqrestore(&ide_lock,flags);
824 } else if (sense_key == UNIT_ATTENTION) {
826 cdrom_saw_media_change (drive);
828 /* Arrange to retry the request.
829 But be sure to give up if we've retried
831 if (++rq->errors > ERROR_MAX)
833 } else if (sense_key == ILLEGAL_REQUEST ||
834 sense_key == DATA_PROTECT) {
835 /* No point in retrying after an illegal
836 request or data protect error.*/
837 ide_dump_status_no_sense (drive, "command error", stat);
839 } else if (sense_key == MEDIUM_ERROR) {
840 /* No point in re-trying a zillion times on a bad
841 * sector... If we got here the error is not correctable */
842 ide_dump_status_no_sense (drive, "media error (bad sector)", stat);
844 } else if (sense_key == BLANK_CHECK) {
845 /* Disk appears blank ?? */
846 ide_dump_status_no_sense (drive, "media error (blank)", stat);
848 } else if ((err & ~ABRT_ERR) != 0) {
849 /* Go to the default handler
851 DRIVER(drive)->error(drive, "cdrom_decode_status",stat);
853 } else if ((++rq->errors > ERROR_MAX)) {
854 /* We've racked up too many retries. Abort. */
858 /* End a request through request sense analysis when we have
859 sense data. We need this in order to perform end of media
862 if (do_end_request) {
863 if (stat & ERR_STAT) {
865 spin_lock_irqsave(&ide_lock, flags);
866 blkdev_dequeue_request(rq);
867 HWGROUP(drive)->rq = NULL;
868 spin_unlock_irqrestore(&ide_lock, flags);
870 cdrom_queue_request_sense(drive, rq->sense, rq);
872 else cdrom_end_request(drive, 0);
874 /* If we got a CHECK_CONDITION status,
875 queue a request sense command. */
877 cdrom_queue_request_sense(drive, NULL, NULL);
880 blk_dump_rq_flags(rq, "ide-cd: bad rq");
881 cdrom_end_request(drive, 0);
884 /* Retry, or handle the next request. */
888 static int cdrom_timer_expiry(ide_drive_t *drive)
890 struct request *rq = HWGROUP(drive)->rq;
891 unsigned long wait = 0;
894 * Some commands are *slow* and normally take a long time to
895 * complete. Usually we can use the ATAPI "disconnect" to bypass
896 * this, but not all commands/drives support that. Let
897 * ide_timer_expiry keep polling us for these.
899 switch (rq->cmd[0]) {
901 case GPCMD_FORMAT_UNIT:
902 case GPCMD_RESERVE_RZONE_TRACK:
903 case GPCMD_CLOSE_TRACK:
904 case GPCMD_FLUSH_CACHE:
905 wait = ATAPI_WAIT_PC;
908 if (!(rq->flags & REQ_QUIET))
909 printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n", rq->cmd[0]);
916 /* Set up the device registers for transferring a packet command on DEV,
917 expecting to later transfer XFERLEN bytes. HANDLER is the routine
918 which actually transfers the command to the drive. If this is a
919 drq_interrupt device, this routine will arrange for HANDLER to be
920 called when the interrupt from the drive arrives. Otherwise, HANDLER
921 will be called immediately after the drive is prepared for the transfer. */
923 static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
925 ide_handler_t *handler)
927 ide_startstop_t startstop;
928 struct cdrom_info *info = drive->driver_data;
930 /* Wait for the controller to be idle. */
931 if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY))
935 if (info->cmd == READ) {
936 info->dma = !HWIF(drive)->ide_dma_read(drive);
937 } else if (info->cmd == WRITE) {
938 info->dma = !HWIF(drive)->ide_dma_write(drive);
940 printk(KERN_WARNING "ide-cd: DMA set, but not allowed\n");
944 /* Set up the controller registers. */
945 /* FIXME: for Virtual DMA we must check harder */
946 HWIF(drive)->OUTB(info->dma, IDE_FEATURE_REG);
947 HWIF(drive)->OUTB(0, IDE_IREASON_REG);
948 HWIF(drive)->OUTB(0, IDE_SECTOR_REG);
950 HWIF(drive)->OUTB(xferlen & 0xff, IDE_BCOUNTL_REG);
951 HWIF(drive)->OUTB(xferlen >> 8 , IDE_BCOUNTH_REG);
953 HWIF(drive)->OUTB(drive->ctl, IDE_CONTROL_REG);
955 if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt) {
957 ide_execute_command(drive, WIN_PACKETCMD, handler, ATAPI_WAIT_PC, cdrom_timer_expiry);
962 spin_lock_irqsave(&ide_lock, flags);
963 HWIF(drive)->OUTBSYNC(drive, WIN_PACKETCMD, IDE_COMMAND_REG);
965 spin_unlock_irqrestore(&ide_lock, flags);
966 return (*handler) (drive);
970 /* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
971 The device registers must have already been prepared
972 by cdrom_start_packet_command.
973 HANDLER is the interrupt handler to call when the command completes
974 or there's data ready. */
976 * changed 5 parameters to 3 for dvd-ram
977 * struct packet_command *pc; now packet_command_t *pc;
979 #define ATAPI_MIN_CDB_BYTES 12
980 static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
982 ide_handler_t *handler)
985 struct cdrom_info *info = drive->driver_data;
986 ide_startstop_t startstop;
988 if (CDROM_CONFIG_FLAGS(drive)->drq_interrupt) {
989 /* Here we should have been called after receiving an interrupt
990 from the device. DRQ should how be set. */
992 /* Check for errors. */
993 if (cdrom_decode_status(drive, DRQ_STAT, NULL))
996 /* Otherwise, we must wait for DRQ to get set. */
997 if (ide_wait_stat(&startstop, drive, DRQ_STAT,
998 BUSY_STAT, WAIT_READY))
1002 /* Arm the interrupt handler. */
1003 ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);
1005 /* ATAPI commands get padded out to 12 bytes minimum */
1006 cmd_len = COMMAND_SIZE(rq->cmd[0]);
1007 if (cmd_len < ATAPI_MIN_CDB_BYTES)
1008 cmd_len = ATAPI_MIN_CDB_BYTES;
1010 /* Send the command to the device. */
1011 HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len);
1013 /* Start the DMA if need be */
1015 (void) HWIF(drive)->ide_dma_begin(drive);
1020 /****************************************************************************
1021 * Block read functions.
1025 * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
1026 * buffer. Once the first sector is added, any subsequent sectors are
1027 * assumed to be continuous (until the buffer is cleared). For the first
1028 * sector added, SECTOR is its sector number. (SECTOR is then ignored until
1029 * the buffer is cleared.)
1031 static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
1032 int sectors_to_transfer)
1034 struct cdrom_info *info = drive->driver_data;
1036 /* Number of sectors to read into the buffer. */
1037 int sectors_to_buffer = min_t(int, sectors_to_transfer,
1038 (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
1039 info->nsectors_buffered);
1043 /* If we couldn't get a buffer, don't try to buffer anything... */
1044 if (info->buffer == NULL)
1045 sectors_to_buffer = 0;
1047 /* If this is the first sector in the buffer, remember its number. */
1048 if (info->nsectors_buffered == 0)
1049 info->sector_buffered = sector;
1051 /* Read the data into the buffer. */
1052 dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
1053 while (sectors_to_buffer > 0) {
1054 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
1055 --sectors_to_buffer;
1056 --sectors_to_transfer;
1057 ++info->nsectors_buffered;
1058 dest += SECTOR_SIZE;
1061 /* Throw away any remaining data. */
1062 while (sectors_to_transfer > 0) {
1063 static char dum[SECTOR_SIZE];
1064 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1065 --sectors_to_transfer;
1070 * Check the contents of the interrupt reason register from the cdrom
1071 * and attempt to recover if there are problems. Returns 0 if everything's
1072 * ok; nonzero if the request has been terminated.
1075 int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
1079 else if (ireason == 0) {
1080 /* Whoops... The drive is expecting to receive data from us! */
1081 printk(KERN_ERR "%s: read_intr: Drive wants to transfer data the "
1082 "wrong way!\n", drive->name);
1084 /* Throw some data at the drive so it doesn't hang
1085 and quit this request. */
1088 HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof (dum));
1089 len -= sizeof (dum);
1091 } else if (ireason == 1) {
1092 /* Some drives (ASUS) seem to tell us that status
1093 * info is available. just get it and ignore.
1095 (void) HWIF(drive)->INB(IDE_STATUS_REG);
1098 /* Drive wants a command packet, or invalid ireason... */
1099 printk(KERN_ERR "%s: read_intr: bad interrupt reason %x\n", drive->name,
1103 cdrom_end_request(drive, 0);
1108 * Interrupt routine. Called when a read request has completed.
1110 static ide_startstop_t cdrom_read_intr (ide_drive_t *drive)
1113 int ireason, len, sectors_to_transfer, nskip;
1114 struct cdrom_info *info = drive->driver_data;
1115 u8 lowcyl = 0, highcyl = 0;
1116 int dma = info->dma, dma_error = 0;
1118 struct request *rq = HWGROUP(drive)->rq;
1125 if ((dma_error = HWIF(drive)->ide_dma_end(drive)))
1126 __ide_dma_off(drive);
1129 if (cdrom_decode_status(drive, 0, &stat))
1134 ide_end_request(drive, 1, rq->nr_sectors);
1137 return DRIVER(drive)->error(drive, "dma error", stat);
1140 /* Read the interrupt reason and the transfer length. */
1141 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1142 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1143 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1145 len = lowcyl + (256 * highcyl);
1147 /* If DRQ is clear, the command has completed. */
1148 if ((stat & DRQ_STAT) == 0) {
1149 /* If we're not done filling the current buffer, complain.
1150 Otherwise, complete the command normally. */
1151 if (rq->current_nr_sectors > 0) {
1152 printk (KERN_ERR "%s: cdrom_read_intr: data underrun (%d blocks)\n",
1153 drive->name, rq->current_nr_sectors);
1154 rq->flags |= REQ_FAILED;
1155 cdrom_end_request(drive, 0);
1157 cdrom_end_request(drive, 1);
1161 /* Check that the drive is expecting to do the same thing we are. */
1162 if (cdrom_read_check_ireason (drive, len, ireason))
1165 /* Assume that the drive will always provide data in multiples
1166 of at least SECTOR_SIZE, as it gets hairy to keep track
1167 of the transfers otherwise. */
1168 if ((len % SECTOR_SIZE) != 0) {
1169 printk (KERN_ERR "%s: cdrom_read_intr: Bad transfer size %d\n",
1171 if (CDROM_CONFIG_FLAGS(drive)->limit_nframes)
1172 printk (KERN_ERR " This drive is not supported by this version of the driver\n");
1174 printk (KERN_ERR " Trying to limit transfer sizes\n");
1175 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
1177 cdrom_end_request(drive, 0);
1181 /* The number of sectors we need to read from the drive. */
1182 sectors_to_transfer = len / SECTOR_SIZE;
1184 /* First, figure out if we need to bit-bucket
1185 any of the leading sectors. */
1186 nskip = min_t(int, rq->current_nr_sectors - bio_cur_sectors(rq->bio), sectors_to_transfer);
1189 /* We need to throw away a sector. */
1190 static char dum[SECTOR_SIZE];
1191 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1193 --rq->current_nr_sectors;
1195 --sectors_to_transfer;
1198 /* Now loop while we still have data to read from the drive. */
1199 while (sectors_to_transfer > 0) {
1202 /* If we've filled the present buffer but there's another
1203 chained buffer after it, move on. */
1204 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1205 cdrom_end_request(drive, 1);
1207 /* If the buffers are full, cache the rest of the data in our
1209 if (rq->current_nr_sectors == 0) {
1210 cdrom_buffer_sectors(drive, rq->sector, sectors_to_transfer);
1211 sectors_to_transfer = 0;
1213 /* Transfer data to the buffers.
1214 Figure out how many sectors we can transfer
1215 to the current buffer. */
1216 this_transfer = min_t(int, sectors_to_transfer,
1217 rq->current_nr_sectors);
1219 /* Read this_transfer sectors
1220 into the current buffer. */
1221 while (this_transfer > 0) {
1222 HWIF(drive)->atapi_input_bytes(drive, rq->buffer, SECTOR_SIZE);
1223 rq->buffer += SECTOR_SIZE;
1225 --rq->current_nr_sectors;
1228 --sectors_to_transfer;
1233 /* Done moving data! Wait for another interrupt. */
1234 ide_set_handler(drive, &cdrom_read_intr, ATAPI_WAIT_PC, NULL);
1239 * Try to satisfy some of the current read request from our cached data.
1240 * Returns nonzero if the request has been completed, zero otherwise.
1242 static int cdrom_read_from_buffer (ide_drive_t *drive)
1244 struct cdrom_info *info = drive->driver_data;
1245 struct request *rq = HWGROUP(drive)->rq;
1246 unsigned short sectors_per_frame;
1248 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1250 /* Can't do anything if there's no buffer. */
1251 if (info->buffer == NULL) return 0;
1253 /* Loop while this request needs data and the next block is present
1255 while (rq->nr_sectors > 0 &&
1256 rq->sector >= info->sector_buffered &&
1257 rq->sector < info->sector_buffered + info->nsectors_buffered) {
1258 if (rq->current_nr_sectors == 0)
1259 cdrom_end_request(drive, 1);
1263 (rq->sector - info->sector_buffered) * SECTOR_SIZE,
1265 rq->buffer += SECTOR_SIZE;
1266 --rq->current_nr_sectors;
1271 /* If we've satisfied the current request,
1272 terminate it successfully. */
1273 if (rq->nr_sectors == 0) {
1274 cdrom_end_request(drive, 1);
1278 /* Move on to the next buffer if needed. */
1279 if (rq->current_nr_sectors == 0)
1280 cdrom_end_request(drive, 1);
1282 /* If this condition does not hold, then the kluge i use to
1283 represent the number of sectors to skip at the start of a transfer
1284 will fail. I think that this will never happen, but let's be
1285 paranoid and check. */
1286 if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
1287 (rq->sector & (sectors_per_frame - 1))) {
1288 printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
1289 drive->name, (long)rq->sector);
1290 cdrom_end_request(drive, 0);
1298 * Routine to send a read packet command to the drive.
1299 * This is usually called directly from cdrom_start_read.
1300 * However, for drq_interrupt devices, it is called from an interrupt
1301 * when the drive is ready to accept the command.
1303 static ide_startstop_t cdrom_start_read_continuation (ide_drive_t *drive)
1305 struct request *rq = HWGROUP(drive)->rq;
1306 unsigned short sectors_per_frame;
1309 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1311 /* If the requested sector doesn't start on a cdrom block boundary,
1312 we must adjust the start of the transfer so that it does,
1313 and remember to skip the first few sectors.
1314 If the CURRENT_NR_SECTORS field is larger than the size
1315 of the buffer, it will mean that we're to skip a number
1316 of sectors equal to the amount by which CURRENT_NR_SECTORS
1317 is larger than the buffer size. */
1318 nskip = rq->sector & (sectors_per_frame - 1);
1320 /* Sanity check... */
1321 if (rq->current_nr_sectors != bio_cur_sectors(rq->bio) &&
1322 (rq->sector & (sectors_per_frame - 1))) {
1323 printk(KERN_ERR "%s: cdrom_start_read_continuation: buffer botch (%u)\n",
1324 drive->name, rq->current_nr_sectors);
1325 cdrom_end_request(drive, 0);
1328 rq->current_nr_sectors += nskip;
1331 /* Set up the command */
1332 rq->timeout = ATAPI_WAIT_PC;
1334 /* Send the command to the drive and return. */
1335 return cdrom_transfer_packet_command(drive, rq, &cdrom_read_intr);
1339 #define IDECD_SEEK_THRESHOLD (1000) /* 1000 blocks */
1340 #define IDECD_SEEK_TIMER (5 * WAIT_MIN_SLEEP) /* 100 ms */
1341 #define IDECD_SEEK_TIMEOUT (2 * WAIT_CMD) /* 20 sec */
1343 static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
1345 struct cdrom_info *info = drive->driver_data;
1347 static int retry = 10;
1349 if (cdrom_decode_status(drive, 0, &stat))
1351 CDROM_CONFIG_FLAGS(drive)->seeking = 1;
1353 if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
1356 * this condition is far too common, to bother
1359 /* printk("%s: disabled DSC seek overlap\n", drive->name);*/
1360 drive->dsc_overlap = 0;
1366 static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
1368 struct request *rq = HWGROUP(drive)->rq;
1369 sector_t frame = rq->sector;
1371 sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
1373 memset(rq->cmd, 0, sizeof(rq->cmd));
1374 rq->cmd[0] = GPCMD_SEEK;
1375 put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
1377 rq->timeout = ATAPI_WAIT_PC;
1378 return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
1381 static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
1383 struct cdrom_info *info = drive->driver_data;
1387 info->start_seek = jiffies;
1388 return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
1391 /* Fix up a possibly partially-processed request so that we can
1392 start it over entirely, or even put it back on the request queue. */
1393 static void restore_request (struct request *rq)
1395 if (rq->buffer != bio_data(rq->bio)) {
1396 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
1398 rq->buffer = bio_data(rq->bio);
1399 rq->nr_sectors += n;
1402 rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
1403 rq->hard_nr_sectors = rq->nr_sectors;
1404 rq->hard_sector = rq->sector;
1405 rq->q->prep_rq_fn(rq->q, rq);
1409 * Start a read request from the CD-ROM.
1411 static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block)
1413 struct cdrom_info *info = drive->driver_data;
1414 struct request *rq = HWGROUP(drive)->rq;
1415 unsigned short sectors_per_frame;
1417 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1419 /* We may be retrying this request after an error. Fix up
1420 any weirdness which might be present in the request packet. */
1421 restore_request(rq);
1423 /* Satisfy whatever we can of this request from our cached sector. */
1424 if (cdrom_read_from_buffer(drive))
1427 blk_attempt_remerge(drive->queue, rq);
1429 /* Clear the local sector buffer. */
1430 info->nsectors_buffered = 0;
1432 /* use dma, if possible. */
1433 info->dma = drive->using_dma;
1434 if ((rq->sector & (sectors_per_frame - 1)) ||
1435 (rq->nr_sectors & (sectors_per_frame - 1)))
1440 /* Start sending the read request to the drive. */
1441 return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
1444 /****************************************************************************
1445 * Execute all other packet commands.
1448 /* Interrupt routine for packet command completion. */
1449 static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
1451 int ireason, len, thislen;
1452 struct request *rq = HWGROUP(drive)->rq;
1453 u8 lowcyl = 0, highcyl = 0;
1456 /* Check for errors. */
1457 if (cdrom_decode_status(drive, 0, &stat))
1460 /* Read the interrupt reason and the transfer length. */
1461 ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1462 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1463 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1465 len = lowcyl + (256 * highcyl);
1467 /* If DRQ is clear, the command has completed.
1468 Complain if we still have data left to transfer. */
1469 if ((stat & DRQ_STAT) == 0) {
1470 /* Some of the trailing request sense fields are optional, and
1471 some drives don't send them. Sigh. */
1472 if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
1474 rq->data_len <= 5) {
1475 while (rq->data_len > 0) {
1476 *(unsigned char *)rq->data++ = 0;
1481 if (rq->data_len == 0)
1482 cdrom_end_request(drive, 1);
1484 /* Comment this out, because this always happens
1485 right after a reset occurs, and it is annoying to
1486 always print expected stuff. */
1488 printk ("%s: cdrom_pc_intr: data underrun %d\n",
1489 drive->name, pc->buflen);
1491 rq->flags |= REQ_FAILED;
1492 cdrom_end_request(drive, 0);
1497 /* Figure out how much data to transfer. */
1498 thislen = rq->data_len;
1499 if (thislen > len) thislen = len;
1501 /* The drive wants to be written to. */
1502 if ((ireason & 3) == 0) {
1504 blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1507 /* Transfer the data. */
1508 HWIF(drive)->atapi_output_bytes(drive, rq->data, thislen);
1510 /* If we haven't moved enough data to satisfy the drive,
1511 add some padding. */
1512 while (len > thislen) {
1514 HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof(dum));
1518 /* Keep count of how much data we've moved. */
1519 rq->data += thislen;
1520 rq->data_len -= thislen;
1523 /* Same drill for reading. */
1524 else if ((ireason & 3) == 2) {
1526 blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1529 /* Transfer the data. */
1530 HWIF(drive)->atapi_input_bytes(drive, rq->data, thislen);
1532 /* If we haven't moved enough data to satisfy the drive,
1533 add some padding. */
1534 while (len > thislen) {
1536 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1540 /* Keep count of how much data we've moved. */
1541 rq->data += thislen;
1542 rq->data_len -= thislen;
1544 if (rq->flags & REQ_SENSE)
1545 rq->sense_len += thislen;
1548 printk (KERN_ERR "%s: cdrom_pc_intr: The drive "
1549 "appears confused (ireason = 0x%02x)\n",
1550 drive->name, ireason);
1551 rq->flags |= REQ_FAILED;
1554 /* Now we wait for another interrupt. */
1555 ide_set_handler(drive, &cdrom_pc_intr, ATAPI_WAIT_PC, cdrom_timer_expiry);
1559 static ide_startstop_t cdrom_do_pc_continuation (ide_drive_t *drive)
1561 struct request *rq = HWGROUP(drive)->rq;
1564 rq->timeout = ATAPI_WAIT_PC;
1566 /* Send the command to the drive and return. */
1567 return cdrom_transfer_packet_command(drive, rq, &cdrom_pc_intr);
1571 static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
1574 struct request *rq = HWGROUP(drive)->rq;
1575 struct cdrom_info *info = drive->driver_data;
1579 rq->flags &= ~REQ_FAILED;
1582 /* Start sending the command to the drive. */
1583 return cdrom_start_packet_command(drive, len, cdrom_do_pc_continuation);
1587 /* Sleep for TIME jiffies.
1588 Not to be called from an interrupt handler. */
1590 void cdrom_sleep (int time)
1595 set_current_state(TASK_INTERRUPTIBLE);
1596 sleep = schedule_timeout(sleep);
1601 int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
1603 struct request_sense sense;
1605 unsigned int flags = rq->flags;
1607 if (rq->sense == NULL)
1610 /* Start of retry loop. */
1613 unsigned long time = jiffies;
1616 error = ide_do_drive_cmd(drive, rq, ide_wait);
1617 time = jiffies - time;
1619 /* FIXME: we should probably abort/retry or something
1620 * in case of failure */
1621 if (rq->flags & REQ_FAILED) {
1622 /* The request failed. Retry if it was due to a unit
1624 (usually means media was changed). */
1625 struct request_sense *reqbuf = rq->sense;
1627 if (reqbuf->sense_key == UNIT_ATTENTION)
1628 cdrom_saw_media_change(drive);
1629 else if (reqbuf->sense_key == NOT_READY &&
1630 reqbuf->asc == 4 && reqbuf->ascq != 4) {
1631 /* The drive is in the process of loading
1632 a disk. Retry, but wait a little to give
1633 the drive time to complete the load. */
1634 cdrom_sleep(2 * HZ);
1636 /* Otherwise, don't retry. */
1642 /* End of retry loop. */
1643 } while ((rq->flags & REQ_FAILED) && retries >= 0);
1645 /* Return an error if the command failed. */
1646 return (rq->flags & REQ_FAILED) ? -EIO : 0;
1652 static inline int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
1654 /* Two notes about IDE interrupt reason here - 0 means that
1655 * the drive wants to receive data from us, 2 means that
1656 * the drive is expecting to transfer data to us.
1660 else if (ireason == 2) {
1661 /* Whoops... The drive wants to send data. */
1662 printk(KERN_ERR "%s: write_intr: wrong transfer direction!\n",
1667 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1671 /* Drive wants a command packet, or invalid ireason... */
1672 printk(KERN_ERR "%s: write_intr: bad interrupt reason %x\n",
1673 drive->name, ireason);
1676 cdrom_end_request(drive, 0);
1680 static void post_transform_command(struct request *req)
1685 if (!blk_pc_request(req))
1689 ibuf = bio_data(req->bio);
1697 * set ansi-revision and response data as atapi
1699 if (c[0] == GPCMD_INQUIRY) {
1701 ibuf[3] = (ibuf[3] & 0xf0) | 2;
1705 typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
1708 * best way to deal with dma that is not sector aligned right now... note
1709 * that in this path we are not using ->data or ->buffer at all. this irs
1710 * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the
1713 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1715 struct cdrom_info *info = drive->driver_data;
1716 struct request *rq = HWGROUP(drive)->rq;
1717 int dma_error, dma, stat, ireason, len, thislen;
1719 xfer_func_t *xferfunc;
1720 unsigned long flags;
1722 /* Check for errors. */
1727 dma_error = HWIF(drive)->ide_dma_end(drive);
1730 if (cdrom_decode_status(drive, 0, &stat))
1734 * using dma, transfer is complete now
1738 printk(KERN_ERR "ide-cd: dma error\n");
1739 __ide_dma_off(drive);
1740 return DRIVER(drive)->error(drive, "dma error", stat);
1743 end_that_request_chunk(rq, 1, rq->data_len);
1749 * ok we fall to pio :/
1751 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1752 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1753 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1755 len = lowcyl + (256 * highcyl);
1756 thislen = rq->data_len;
1761 * If DRQ is clear, the command has completed.
1763 if ((stat & DRQ_STAT) == 0)
1767 * check which way to transfer data
1769 if (rq_data_dir(rq) == WRITE) {
1773 if (cdrom_write_check_ireason(drive, len, ireason))
1776 xferfunc = HWIF(drive)->atapi_output_bytes;
1781 if (cdrom_read_check_ireason(drive, len, ireason))
1784 xferfunc = HWIF(drive)->atapi_input_bytes;
1790 while (thislen > 0) {
1791 int blen = blen = rq->data_len;
1792 char *ptr = rq->data;
1798 ptr = bio_data(rq->bio);
1799 blen = bio_iovec(rq->bio)->bv_len;
1803 printk(KERN_ERR "%s: confused, missing data\n", drive->name);
1810 xferfunc(drive, ptr, blen);
1814 rq->data_len -= blen;
1817 end_that_request_chunk(rq, 1, blen);
1829 xferfunc(drive, &pad, sizeof(pad));
1834 if (HWGROUP(drive)->handler != NULL)
1837 ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, NULL);
1842 post_transform_command(rq);
1844 spin_lock_irqsave(&ide_lock, flags);
1845 blkdev_dequeue_request(rq);
1846 end_that_request_last(rq);
1847 HWGROUP(drive)->rq = NULL;
1848 spin_unlock_irqrestore(&ide_lock, flags);
1852 static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
1854 int stat, ireason, len, sectors_to_transfer, uptodate;
1855 struct cdrom_info *info = drive->driver_data;
1856 int dma_error = 0, dma = info->dma;
1857 u8 lowcyl = 0, highcyl = 0;
1859 struct request *rq = HWGROUP(drive)->rq;
1861 /* Check for errors. */
1864 if ((dma_error = HWIF(drive)->ide_dma_end(drive))) {
1865 printk(KERN_ERR "ide-cd: write dma error\n");
1866 __ide_dma_off(drive);
1870 if (cdrom_decode_status(drive, 0, &stat))
1874 * using dma, transfer is complete now
1878 return DRIVER(drive)->error(drive, "dma error", stat);
1880 ide_end_request(drive, 1, rq->nr_sectors);
1884 /* Read the interrupt reason and the transfer length. */
1885 ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1886 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1887 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1889 len = lowcyl + (256 * highcyl);
1891 /* If DRQ is clear, the command has completed. */
1892 if ((stat & DRQ_STAT) == 0) {
1893 /* If we're not done writing, complain.
1894 * Otherwise, complete the command normally.
1897 if (rq->current_nr_sectors > 0) {
1898 printk(KERN_ERR "%s: write_intr: data underrun (%d blocks)\n",
1899 drive->name, rq->current_nr_sectors);
1902 cdrom_end_request(drive, uptodate);
1906 /* Check that the drive is expecting to do the same thing we are. */
1907 if (cdrom_write_check_ireason(drive, len, ireason))
1910 sectors_to_transfer = len / SECTOR_SIZE;
1913 * now loop and write out the data
1915 while (sectors_to_transfer > 0) {
1918 if (!rq->current_nr_sectors) {
1919 printk(KERN_ERR "ide-cd: write_intr: oops\n");
1924 * Figure out how many sectors we can transfer
1926 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors);
1928 while (this_transfer > 0) {
1929 HWIF(drive)->atapi_output_bytes(drive, rq->buffer, SECTOR_SIZE);
1930 rq->buffer += SECTOR_SIZE;
1932 --rq->current_nr_sectors;
1935 --sectors_to_transfer;
1939 * current buffer complete, move on
1941 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1942 cdrom_end_request(drive, 1);
1945 /* re-arm handler */
1946 ide_set_handler(drive, &cdrom_write_intr, ATAPI_WAIT_PC, NULL);
1950 static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
1952 struct request *rq = HWGROUP(drive)->rq;
1954 #if 0 /* the immediate bit */
1955 rq->cmd[1] = 1 << 3;
1957 rq->timeout = ATAPI_WAIT_PC;
1959 return cdrom_transfer_packet_command(drive, rq, cdrom_write_intr);
1962 static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
1964 struct cdrom_info *info = drive->driver_data;
1965 struct gendisk *g = drive->disk;
1966 unsigned short sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1969 * writes *must* be hardware frame aligned
1971 if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1972 (rq->sector & (sectors_per_frame - 1))) {
1973 cdrom_end_request(drive, 0);
1978 * disk has become write protected
1981 cdrom_end_request(drive, 0);
1986 * for dvd-ram and such media, it's a really big deal to get
1987 * big writes all the time. so scour the queue and attempt to
1988 * remerge requests, often the plugging will not have had time
1989 * to do this properly
1991 blk_attempt_remerge(drive->queue, rq);
1993 info->nsectors_buffered = 0;
1995 /* use dma, if possible. we don't need to check more, since we
1996 * know that the transfer is always (at least!) frame aligned */
1997 info->dma = drive->using_dma ? 1 : 0;
2000 /* Start sending the write request to the drive. */
2001 return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
2004 static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
2006 struct request *rq = HWGROUP(drive)->rq;
2009 rq->timeout = ATAPI_WAIT_PC;
2011 return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
2014 static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
2016 struct cdrom_info *info = drive->driver_data;
2018 rq->flags |= REQ_QUIET;
2027 int mask = drive->queue->dma_alignment;
2028 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
2030 info->cmd = rq_data_dir(rq);
2031 info->dma = drive->using_dma;
2034 * check if dma is safe
2036 if ((rq->data_len & mask) || (addr & mask))
2040 /* Start sending the command to the drive. */
2041 return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
2044 /****************************************************************************
2045 * cdrom driver request routine.
2047 static ide_startstop_t
2048 ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
2050 ide_startstop_t action;
2051 struct cdrom_info *info = drive->driver_data;
2053 if (blk_fs_request(rq)) {
2054 if (CDROM_CONFIG_FLAGS(drive)->seeking) {
2055 unsigned long elapsed = jiffies - info->start_seek;
2056 int stat = HWIF(drive)->INB(IDE_STATUS_REG);
2058 if ((stat & SEEK_STAT) != SEEK_STAT) {
2059 if (elapsed < IDECD_SEEK_TIMEOUT) {
2060 ide_stall_queue(drive, IDECD_SEEK_TIMER);
2063 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
2065 CDROM_CONFIG_FLAGS(drive)->seeking = 0;
2067 if (IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
2068 action = cdrom_start_seek(drive, block);
2070 if (rq_data_dir(rq) == READ)
2071 action = cdrom_start_read(drive, block);
2073 action = cdrom_start_write(drive, rq);
2075 info->last_block = block;
2077 } else if (rq->flags & (REQ_PC | REQ_SENSE)) {
2078 return cdrom_do_packet_command(drive);
2079 } else if (rq->flags & REQ_BLOCK_PC) {
2080 return cdrom_do_block_pc(drive, rq);
2081 } else if (rq->flags & REQ_SPECIAL) {
2083 * right now this can only be a reset...
2085 cdrom_end_request(drive, 1);
2089 blk_dump_rq_flags(rq, "ide-cd bad flags");
2090 cdrom_end_request(drive, 0);
2096 /****************************************************************************
2099 * Routines which queue packet commands take as a final argument a pointer
2100 * to a request_sense struct. If execution of the command results
2101 * in an error with a CHECK CONDITION status, this structure will be filled
2102 * with the results of the subsequent request sense command. The pointer
2103 * can also be NULL, in which case no sense information is returned.
2106 #if ! STANDARD_ATAPI
2110 return (x%10) | ((x/10) << 4);
2117 return (x >> 4) * 10 + (x & 0x0f);
2121 void msf_from_bcd (struct atapi_msf *msf)
2123 msf->minute = bcd2bin (msf->minute);
2124 msf->second = bcd2bin (msf->second);
2125 msf->frame = bcd2bin (msf->frame);
2128 #endif /* not STANDARD_ATAPI */
2132 void lba_to_msf (int lba, byte *m, byte *s, byte *f)
2134 lba += CD_MSF_OFFSET;
2135 lba &= 0xffffff; /* negative lbas use only 24 bits */
2136 *m = lba / (CD_SECS * CD_FRAMES);
2137 lba %= (CD_SECS * CD_FRAMES);
2138 *s = lba / CD_FRAMES;
2139 *f = lba % CD_FRAMES;
2144 int msf_to_lba (byte m, byte s, byte f)
2146 return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
2149 static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
2152 struct cdrom_info *info = drive->driver_data;
2153 struct cdrom_device_info *cdi = &info->devinfo;
2155 cdrom_prepare_request(&req);
2158 req.cmd[0] = GPCMD_TEST_UNIT_READY;
2159 req.flags |= REQ_QUIET;
2161 #if ! STANDARD_ATAPI
2162 /* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
2163 switch CDs instead of supporting the LOAD_UNLOAD opcode */
2165 req.cmd[7] = cdi->sanyo_slot % 3;
2166 #endif /* not STANDARD_ATAPI */
2168 return cdrom_queue_packet_command(drive, &req);
2172 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
2174 cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
2176 struct request_sense my_sense;
2183 /* If the drive cannot lock the door, just pretend. */
2184 if (CDROM_CONFIG_FLAGS(drive)->no_doorlock) {
2187 cdrom_prepare_request(&req);
2189 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
2190 req.cmd[4] = lockflag ? 1 : 0;
2191 stat = cdrom_queue_packet_command(drive, &req);
2194 /* If we got an illegal field error, the drive
2195 probably cannot lock the door. */
2197 sense->sense_key == ILLEGAL_REQUEST &&
2198 (sense->asc == 0x24 || sense->asc == 0x20)) {
2199 printk (KERN_ERR "%s: door locking not supported\n",
2201 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2205 /* no medium, that's alright. */
2206 if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
2210 CDROM_STATE_FLAGS(drive)->door_locked = lockflag;
2216 /* Eject the disk if EJECTFLAG is 0.
2217 If EJECTFLAG is 1, try to reload the disk. */
2218 static int cdrom_eject(ide_drive_t *drive, int ejectflag,
2219 struct request_sense *sense)
2224 if (CDROM_CONFIG_FLAGS(drive)->no_eject && !ejectflag)
2225 return -EDRIVE_CANT_DO_THIS;
2227 /* reload fails on some drives, if the tray is locked */
2228 if (CDROM_STATE_FLAGS(drive)->door_locked && ejectflag)
2231 cdrom_prepare_request(&req);
2233 /* only tell drive to close tray if open, if it can do that */
2234 if (ejectflag && !CDROM_CONFIG_FLAGS(drive)->close_tray)
2238 req.cmd[0] = GPCMD_START_STOP_UNIT;
2239 req.cmd[4] = loej | (ejectflag != 0);
2240 return cdrom_queue_packet_command(drive, &req);
2243 static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
2244 unsigned long *sectors_per_frame,
2245 struct request_sense *sense)
2255 cdrom_prepare_request(&req);
2258 req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
2259 req.data = (char *)&capbuf;
2260 req.data_len = sizeof(capbuf);
2262 stat = cdrom_queue_packet_command(drive, &req);
2264 *capacity = 1 + be32_to_cpu(capbuf.lba);
2265 *sectors_per_frame =
2266 be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
2272 static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
2273 int format, char *buf, int buflen,
2274 struct request_sense *sense)
2278 cdrom_prepare_request(&req);
2282 req.data_len = buflen;
2283 req.flags |= REQ_QUIET;
2284 req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
2285 req.cmd[6] = trackno;
2286 req.cmd[7] = (buflen >> 8);
2287 req.cmd[8] = (buflen & 0xff);
2288 req.cmd[9] = (format << 6);
2293 return cdrom_queue_packet_command(drive, &req);
2297 /* Try to read the entire TOC for the disk into our internal buffer. */
2298 static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2300 int stat, ntracks, i;
2301 struct cdrom_info *info = drive->driver_data;
2302 struct cdrom_device_info *cdi = &info->devinfo;
2303 struct atapi_toc *toc = info->toc;
2305 struct atapi_toc_header hdr;
2306 struct atapi_toc_entry ent;
2309 unsigned long sectors_per_frame = SECTORS_PER_FRAME;
2312 /* Try to allocate space. */
2313 toc = (struct atapi_toc *) kmalloc (sizeof (struct atapi_toc),
2317 printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
2322 /* Check to see if the existing data is still valid.
2323 If it is, just return. */
2324 (void) cdrom_check_status(drive, sense);
2326 if (CDROM_STATE_FLAGS(drive)->toc_valid)
2329 /* Try to get the total cdrom capacity and sector size. */
2330 stat = cdrom_read_capacity(drive, &toc->capacity, §ors_per_frame,
2333 toc->capacity = 0x1fffff;
2335 set_capacity(drive->disk, toc->capacity * sectors_per_frame);
2336 /* Save a private copy of te TOC capacity for error handling */
2337 drive->probed_capacity = toc->capacity * sectors_per_frame;
2339 blk_queue_hardsect_size(drive->queue,
2340 sectors_per_frame << SECTOR_BITS);
2342 /* First read just the header, so we know how long the TOC is. */
2343 stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
2344 sizeof(struct atapi_toc_header), sense);
2345 if (stat) return stat;
2347 #if ! STANDARD_ATAPI
2348 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2349 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2350 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2352 #endif /* not STANDARD_ATAPI */
2354 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2357 if (ntracks > MAX_TRACKS)
2358 ntracks = MAX_TRACKS;
2360 /* Now read the whole schmeer. */
2361 stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
2363 sizeof(struct atapi_toc_header) +
2365 sizeof(struct atapi_toc_entry), sense);
2367 if (stat && toc->hdr.first_track > 1) {
2368 /* Cds with CDI tracks only don't have any TOC entries,
2369 despite of this the returned values are
2370 first_track == last_track = number of CDI tracks + 1,
2371 so that this case is indistinguishable from the same
2372 layout plus an additional audio track.
2373 If we get an error for the regular case, we assume
2374 a CDI without additional audio tracks. In this case
2375 the readable TOC is empty (CDI tracks are not included)
2376 and only holds the Leadout entry. Heiko Eißfeldt */
2378 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
2380 sizeof(struct atapi_toc_header) +
2382 sizeof(struct atapi_toc_entry),
2387 #if ! STANDARD_ATAPI
2388 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2389 toc->hdr.first_track = bin2bcd(CDROM_LEADOUT);
2390 toc->hdr.last_track = bin2bcd(CDROM_LEADOUT);
2392 #endif /* not STANDARD_ATAPI */
2394 toc->hdr.first_track = CDROM_LEADOUT;
2395 toc->hdr.last_track = CDROM_LEADOUT;
2402 toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
2404 #if ! STANDARD_ATAPI
2405 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2406 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2407 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2409 #endif /* not STANDARD_ATAPI */
2411 for (i=0; i<=ntracks; i++) {
2412 #if ! STANDARD_ATAPI
2413 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2414 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd)
2415 toc->ent[i].track = bcd2bin(toc->ent[i].track);
2416 msf_from_bcd(&toc->ent[i].addr.msf);
2418 #endif /* not STANDARD_ATAPI */
2419 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
2420 toc->ent[i].addr.msf.second,
2421 toc->ent[i].addr.msf.frame);
2424 /* Read the multisession information. */
2425 if (toc->hdr.first_track != CDROM_LEADOUT) {
2426 /* Read the multisession information. */
2427 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
2428 sizeof(ms_tmp), sense);
2429 if (stat) return stat;
2431 ms_tmp.ent.addr.msf.minute = 0;
2432 ms_tmp.ent.addr.msf.second = 2;
2433 ms_tmp.ent.addr.msf.frame = 0;
2434 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
2437 #if ! STANDARD_ATAPI
2438 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd)
2439 msf_from_bcd (&ms_tmp.ent.addr.msf);
2440 #endif /* not STANDARD_ATAPI */
2442 toc->last_session_lba = msf_to_lba (ms_tmp.ent.addr.msf.minute,
2443 ms_tmp.ent.addr.msf.second,
2444 ms_tmp.ent.addr.msf.frame);
2446 toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
2448 /* Now try to get the total cdrom capacity. */
2449 stat = cdrom_get_last_written(cdi, &last_written);
2450 if (!stat && (last_written > toc->capacity)) {
2451 toc->capacity = last_written;
2452 set_capacity(drive->disk, toc->capacity * sectors_per_frame);
2453 drive->probed_capacity = toc->capacity * sectors_per_frame;
2456 /* Remember that we've read this stuff. */
2457 CDROM_STATE_FLAGS(drive)->toc_valid = 1;
2463 static int cdrom_read_subchannel(ide_drive_t *drive, int format, char *buf,
2464 int buflen, struct request_sense *sense)
2468 cdrom_prepare_request(&req);
2472 req.data_len = buflen;
2473 req.cmd[0] = GPCMD_READ_SUBCHANNEL;
2474 req.cmd[1] = 2; /* MSF addressing */
2475 req.cmd[2] = 0x40; /* request subQ data */
2476 req.cmd[3] = format;
2477 req.cmd[7] = (buflen >> 8);
2478 req.cmd[8] = (buflen & 0xff);
2479 return cdrom_queue_packet_command(drive, &req);
2482 /* ATAPI cdrom drives are free to select the speed you request or any slower
2483 rate :-( Requesting too fast a speed will _not_ produce an error. */
2484 static int cdrom_select_speed(ide_drive_t *drive, int speed,
2485 struct request_sense *sense)
2488 cdrom_prepare_request(&req);
2492 speed = 0xffff; /* set to max */
2494 speed *= 177; /* Nx to kbytes/s */
2496 req.cmd[0] = GPCMD_SET_SPEED;
2497 /* Read Drive speed in kbytes/second MSB */
2498 req.cmd[2] = (speed >> 8) & 0xff;
2499 /* Read Drive speed in kbytes/second LSB */
2500 req.cmd[3] = speed & 0xff;
2501 if (CDROM_CONFIG_FLAGS(drive)->cd_r ||
2502 CDROM_CONFIG_FLAGS(drive)->cd_rw ||
2503 CDROM_CONFIG_FLAGS(drive)->dvd_r) {
2504 /* Write Drive speed in kbytes/second MSB */
2505 req.cmd[4] = (speed >> 8) & 0xff;
2506 /* Write Drive speed in kbytes/second LSB */
2507 req.cmd[5] = speed & 0xff;
2510 return cdrom_queue_packet_command(drive, &req);
2513 static int cdrom_play_audio(ide_drive_t *drive, int lba_start, int lba_end)
2515 struct request_sense sense;
2518 cdrom_prepare_request(&req);
2521 req.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2522 lba_to_msf(lba_start, &req.cmd[3], &req.cmd[4], &req.cmd[5]);
2523 lba_to_msf(lba_end-1, &req.cmd[6], &req.cmd[7], &req.cmd[8]);
2525 return cdrom_queue_packet_command(drive, &req);
2528 static int cdrom_get_toc_entry(ide_drive_t *drive, int track,
2529 struct atapi_toc_entry **ent)
2531 struct cdrom_info *info = drive->driver_data;
2532 struct atapi_toc *toc = info->toc;
2536 * don't serve cached data, if the toc isn't valid
2538 if (!CDROM_STATE_FLAGS(drive)->toc_valid)
2541 /* Check validity of requested track number. */
2542 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2543 if (toc->hdr.first_track == CDROM_LEADOUT) ntracks = 0;
2544 if (track == CDROM_LEADOUT)
2545 *ent = &toc->ent[ntracks];
2546 else if (track < toc->hdr.first_track ||
2547 track > toc->hdr.last_track)
2550 *ent = &toc->ent[track - toc->hdr.first_track];
2555 /* the generic packet interface to cdrom.c */
2556 static int ide_cdrom_packet(struct cdrom_device_info *cdi,
2557 struct packet_command *cgc)
2560 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2562 if (cgc->timeout <= 0)
2563 cgc->timeout = ATAPI_WAIT_PC;
2565 /* here we queue the commands from the uniform CD-ROM
2566 layer. the packet must be complete, as we do not
2568 cdrom_prepare_request(&req);
2569 memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
2571 memset(cgc->sense, 0, sizeof(struct request_sense));
2572 req.data = cgc->buffer;
2573 req.data_len = cgc->buflen;
2574 req.timeout = cgc->timeout;
2577 req.flags |= REQ_QUIET;
2579 req.sense = cgc->sense;
2580 cgc->stat = cdrom_queue_packet_command(drive, &req);
2582 cgc->buflen -= req.data_len;
2587 int ide_cdrom_dev_ioctl (struct cdrom_device_info *cdi,
2588 unsigned int cmd, unsigned long arg)
2590 struct packet_command cgc;
2594 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2596 /* These will be moved into the Uniform layer shortly... */
2598 case CDROMSETSPINDOWN: {
2601 if (copy_from_user(&spindown, (void __user *) arg, sizeof(char)))
2604 if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0)))
2607 buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
2609 return cdrom_mode_select(cdi, &cgc);
2612 case CDROMGETSPINDOWN: {
2615 if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0)))
2618 spindown = buffer[11] & 0x0f;
2620 if (copy_to_user((void __user *) arg, &spindown, sizeof (char)))
2633 int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
2634 unsigned int cmd, void *arg)
2637 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2638 struct cdrom_info *info = drive->driver_data;
2643 * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
2644 * atapi doesn't support it
2646 case CDROMPLAYTRKIND: {
2647 unsigned long lba_start, lba_end;
2648 struct cdrom_ti *ti = (struct cdrom_ti *)arg;
2649 struct atapi_toc_entry *first_toc, *last_toc;
2651 stat = cdrom_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
2655 stat = cdrom_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
2659 if (ti->cdti_trk1 != CDROM_LEADOUT)
2661 lba_start = first_toc->addr.lba;
2662 lba_end = last_toc->addr.lba;
2664 if (lba_end <= lba_start)
2667 return cdrom_play_audio(drive, lba_start, lba_end);
2670 case CDROMREADTOCHDR: {
2671 struct cdrom_tochdr *tochdr = (struct cdrom_tochdr *) arg;
2672 struct atapi_toc *toc;
2674 /* Make sure our saved TOC is valid. */
2675 stat = cdrom_read_toc(drive, NULL);
2676 if (stat) return stat;
2679 tochdr->cdth_trk0 = toc->hdr.first_track;
2680 tochdr->cdth_trk1 = toc->hdr.last_track;
2685 case CDROMREADTOCENTRY: {
2686 struct cdrom_tocentry *tocentry = (struct cdrom_tocentry*) arg;
2687 struct atapi_toc_entry *toce;
2689 stat = cdrom_get_toc_entry(drive, tocentry->cdte_track, &toce);
2690 if (stat) return stat;
2692 tocentry->cdte_ctrl = toce->control;
2693 tocentry->cdte_adr = toce->adr;
2694 if (tocentry->cdte_format == CDROM_MSF) {
2695 lba_to_msf (toce->addr.lba,
2696 &tocentry->cdte_addr.msf.minute,
2697 &tocentry->cdte_addr.msf.second,
2698 &tocentry->cdte_addr.msf.frame);
2700 tocentry->cdte_addr.lba = toce->addr.lba;
2711 int ide_cdrom_reset (struct cdrom_device_info *cdi)
2713 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2714 struct request_sense sense;
2718 cdrom_prepare_request(&req);
2719 req.flags = REQ_SPECIAL | REQ_QUIET;
2720 ret = ide_do_drive_cmd(drive, &req, ide_wait);
2723 * A reset will unlock the door. If it was previously locked,
2726 if (CDROM_STATE_FLAGS(drive)->door_locked)
2727 (void) cdrom_lockdoor(drive, 1, &sense);
2734 int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
2736 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2737 struct request_sense sense;
2740 int stat = cdrom_lockdoor(drive, 0, &sense);
2741 if (stat) return stat;
2744 return cdrom_eject(drive, !position, &sense);
2748 int ide_cdrom_lock_door (struct cdrom_device_info *cdi, int lock)
2750 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2751 return cdrom_lockdoor(drive, lock, NULL);
2755 int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
2757 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2758 struct request_sense sense;
2761 if ((stat = cdrom_select_speed(drive, speed, &sense)) < 0)
2764 cdi->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2769 * add logic to try GET_EVENT command first to check for media and tray
2770 * status. this should be supported by newer cd-r/w and all DVD etc
2774 int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
2776 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2777 struct media_event_desc med;
2778 struct request_sense sense;
2781 if (slot_nr != CDSL_CURRENT)
2784 stat = cdrom_check_status(drive, &sense);
2785 if (!stat || sense.sense_key == UNIT_ATTENTION)
2788 if (!cdrom_get_media_event(cdi, &med)) {
2789 if (med.media_present)
2791 else if (med.door_open)
2792 return CDS_TRAY_OPEN;
2797 if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
2801 * If not using Mt Fuji extended media tray reports,
2802 * just return TRAY_OPEN since ATAPI doesn't provide
2803 * any other way to detect this...
2805 if (sense.sense_key == NOT_READY) {
2806 if (sense.asc == 0x3a) {
2807 if (sense.ascq == 0 || sense.ascq == 1)
2809 else if (sense.ascq == 2)
2810 return CDS_TRAY_OPEN;
2814 return CDS_DRIVE_NOT_READY;
2818 int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
2819 struct cdrom_multisession *ms_info)
2821 struct atapi_toc *toc;
2822 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2823 struct cdrom_info *info = drive->driver_data;
2824 struct request_sense sense;
2827 if (!CDROM_STATE_FLAGS(drive)->toc_valid || info->toc == NULL)
2828 if ((ret = cdrom_read_toc(drive, &sense)))
2832 ms_info->addr.lba = toc->last_session_lba;
2833 ms_info->xa_flag = toc->xa_flag;
2839 int ide_cdrom_get_mcn (struct cdrom_device_info *cdi,
2840 struct cdrom_mcn *mcn_info)
2844 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2847 if ((stat = cdrom_read_subchannel(drive, 2, mcnbuf, sizeof (mcnbuf), NULL)))
2850 memcpy (mcn_info->medium_catalog_number, mcnbuf+9,
2851 sizeof (mcn_info->medium_catalog_number)-1);
2852 mcn_info->medium_catalog_number[sizeof (mcn_info->medium_catalog_number)-1]
2860 /****************************************************************************
2861 * Other driver requests (open, close, check media change).
2865 int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
2868 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2871 if (slot_nr == CDSL_CURRENT) {
2872 (void) cdrom_check_status(drive, NULL);
2873 retval = CDROM_STATE_FLAGS(drive)->media_changed;
2874 CDROM_STATE_FLAGS(drive)->media_changed = 0;
2883 int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
2889 * Close down the device. Invalidate all cached blocks.
2893 void ide_cdrom_release_real (struct cdrom_device_info *cdi)
2895 ide_drive_t *drive = cdi->handle;
2897 if (!cdi->use_count)
2898 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
2903 /****************************************************************************
2904 * Device initialization.
2906 static struct cdrom_device_ops ide_cdrom_dops = {
2907 .open = ide_cdrom_open_real,
2908 .release = ide_cdrom_release_real,
2909 .drive_status = ide_cdrom_drive_status,
2910 .media_changed = ide_cdrom_check_media_change_real,
2911 .tray_move = ide_cdrom_tray_move,
2912 .lock_door = ide_cdrom_lock_door,
2913 .select_speed = ide_cdrom_select_speed,
2914 .get_last_session = ide_cdrom_get_last_session,
2915 .get_mcn = ide_cdrom_get_mcn,
2916 .reset = ide_cdrom_reset,
2917 .audio_ioctl = ide_cdrom_audio_ioctl,
2918 .dev_ioctl = ide_cdrom_dev_ioctl,
2919 .capability = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
2920 CDC_SELECT_SPEED | CDC_SELECT_DISC |
2921 CDC_MULTI_SESSION | CDC_MCN |
2922 CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO | CDC_RESET |
2923 CDC_IOCTLS | CDC_DRIVE_STATUS | CDC_CD_R |
2924 CDC_CD_RW | CDC_DVD | CDC_DVD_R| CDC_DVD_RAM |
2925 CDC_GENERIC_PACKET | CDC_MO_DRIVE | CDC_MRW |
2926 CDC_MRW_W | CDC_RAM,
2927 .generic_packet = ide_cdrom_packet,
2930 static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2932 struct cdrom_info *info = drive->driver_data;
2933 struct cdrom_device_info *devinfo = &info->devinfo;
2935 devinfo->ops = &ide_cdrom_dops;
2937 devinfo->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2938 devinfo->capacity = nslots;
2939 devinfo->handle = (void *) drive;
2940 strcpy(devinfo->name, drive->name);
2942 /* set capability mask to match the probe. */
2943 if (!CDROM_CONFIG_FLAGS(drive)->cd_r)
2944 devinfo->mask |= CDC_CD_R;
2945 if (!CDROM_CONFIG_FLAGS(drive)->cd_rw)
2946 devinfo->mask |= CDC_CD_RW;
2947 if (!CDROM_CONFIG_FLAGS(drive)->dvd)
2948 devinfo->mask |= CDC_DVD;
2949 if (!CDROM_CONFIG_FLAGS(drive)->dvd_r)
2950 devinfo->mask |= CDC_DVD_R;
2951 if (!CDROM_CONFIG_FLAGS(drive)->dvd_ram)
2952 devinfo->mask |= CDC_DVD_RAM;
2953 if (!CDROM_CONFIG_FLAGS(drive)->is_changer)
2954 devinfo->mask |= CDC_SELECT_DISC;
2955 if (!CDROM_CONFIG_FLAGS(drive)->audio_play)
2956 devinfo->mask |= CDC_PLAY_AUDIO;
2957 if (!CDROM_CONFIG_FLAGS(drive)->close_tray)
2958 devinfo->mask |= CDC_CLOSE_TRAY;
2959 if (!CDROM_CONFIG_FLAGS(drive)->mo_drive)
2960 devinfo->mask |= CDC_MO_DRIVE;
2962 devinfo->disk = drive->disk;
2963 return register_cdrom(devinfo);
2967 int ide_cdrom_get_capabilities(ide_drive_t *drive, struct atapi_capabilities_page *cap)
2969 struct cdrom_info *info = drive->driver_data;
2970 struct cdrom_device_info *cdi = &info->devinfo;
2971 struct packet_command cgc;
2972 int stat, attempts = 3, size = sizeof(*cap);
2975 * ACER50 (and others?) require the full spec length mode sense
2976 * page capabilities size, but older drives break.
2978 if (!(!strcmp(drive->id->model, "ATAPI CD ROM DRIVE 50X MAX") ||
2979 !strcmp(drive->id->model, "WPI CDS-32X")))
2980 size -= sizeof(cap->pad);
2982 init_cdrom_command(&cgc, cap, size, CGC_DATA_UNKNOWN);
2983 do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2984 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
2987 } while (--attempts);
2992 int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2994 struct cdrom_info *info = drive->driver_data;
2995 struct cdrom_device_info *cdi = &info->devinfo;
2996 struct atapi_capabilities_page cap;
2999 if (drive->media == ide_optical) {
3000 CDROM_CONFIG_FLAGS(drive)->mo_drive = 1;
3001 CDROM_CONFIG_FLAGS(drive)->ram = 1;
3002 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
3006 if (CDROM_CONFIG_FLAGS(drive)->nec260 ||
3007 !strcmp(drive->id->model,"STINGRAY 8422 IDE 8X CD-ROM 7-27-95")) {
3008 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
3009 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
3014 * we have to cheat a little here. the packet will eventually
3015 * be queued with ide_cdrom_packet(), which extracts the
3016 * drive from cdi->handle. Since this device hasn't been
3017 * registered with the Uniform layer yet, it can't do this.
3018 * Same goes for cdi->ops.
3020 cdi->handle = (ide_drive_t *) drive;
3021 cdi->ops = &ide_cdrom_dops;
3023 if (ide_cdrom_get_capabilities(drive, &cap))
3027 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
3029 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
3031 CDROM_CONFIG_FLAGS(drive)->cd_r = 1;
3032 if (cap.cd_rw_write)
3033 CDROM_CONFIG_FLAGS(drive)->cd_rw = 1;
3035 CDROM_CONFIG_FLAGS(drive)->test_write = 1;
3036 if (cap.dvd_ram_read || cap.dvd_r_read || cap.dvd_rom)
3037 CDROM_CONFIG_FLAGS(drive)->dvd = 1;
3038 if (cap.dvd_ram_write) {
3039 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 1;
3040 CDROM_CONFIG_FLAGS(drive)->ram = 1;
3042 if (cap.dvd_r_write)
3043 CDROM_CONFIG_FLAGS(drive)->dvd_r = 1;
3045 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
3046 if (cap.mechtype == mechtype_caddy || cap.mechtype == mechtype_popup)
3047 CDROM_CONFIG_FLAGS(drive)->close_tray = 0;
3049 /* Some drives used by Apple don't advertise audio play
3050 * but they do support reading TOC & audio datas
3052 if (strcmp(drive->id->model, "MATSHITADVD-ROM SR-8187") == 0 ||
3053 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8186") == 0 ||
3054 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8176") == 0 ||
3055 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8174") == 0)
3056 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
3058 #if ! STANDARD_ATAPI
3059 if (cdi->sanyo_slot > 0) {
3060 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
3065 #endif /* not STANDARD_ATAPI */
3066 if (cap.mechtype == mechtype_individual_changer ||
3067 cap.mechtype == mechtype_cartridge_changer) {
3068 if ((nslots = cdrom_number_of_slots(cdi)) > 1) {
3069 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
3070 CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 1;
3074 /* The ACER/AOpen 24X cdrom has the speed fields byte-swapped */
3075 if (!drive->id->model[0] &&
3076 !strncmp(drive->id->fw_rev, "241N", 4)) {
3077 CDROM_STATE_FLAGS(drive)->current_speed =
3078 (((unsigned int)cap.curspeed) + (176/2)) / 176;
3079 CDROM_CONFIG_FLAGS(drive)->max_speed =
3080 (((unsigned int)cap.maxspeed) + (176/2)) / 176;
3082 CDROM_STATE_FLAGS(drive)->current_speed =
3083 (ntohs(cap.curspeed) + (176/2)) / 176;
3084 CDROM_CONFIG_FLAGS(drive)->max_speed =
3085 (ntohs(cap.maxspeed) + (176/2)) / 176;
3088 /* don't print speed if the drive reported 0.
3090 printk(KERN_INFO "%s: ATAPI", drive->name);
3091 if (CDROM_CONFIG_FLAGS(drive)->max_speed)
3092 printk(" %dX", CDROM_CONFIG_FLAGS(drive)->max_speed);
3093 printk(" %s", CDROM_CONFIG_FLAGS(drive)->dvd ? "DVD-ROM" : "CD-ROM");
3095 if (CDROM_CONFIG_FLAGS(drive)->dvd_r|CDROM_CONFIG_FLAGS(drive)->dvd_ram)
3097 (CDROM_CONFIG_FLAGS(drive)->dvd_r)? "-R" : "",
3098 (CDROM_CONFIG_FLAGS(drive)->dvd_ram)? "-RAM" : "");
3100 if (CDROM_CONFIG_FLAGS(drive)->cd_r|CDROM_CONFIG_FLAGS(drive)->cd_rw)
3102 (CDROM_CONFIG_FLAGS(drive)->cd_r)? "-R" : "",
3103 (CDROM_CONFIG_FLAGS(drive)->cd_rw)? "/RW" : "");
3105 if (CDROM_CONFIG_FLAGS(drive)->is_changer)
3106 printk(" changer w/%d slots", nslots);
3110 printk(", %dkB Cache", be16_to_cpu(cap.buffer_size));
3112 #ifdef CONFIG_BLK_DEV_IDEDMA
3113 if (drive->using_dma)
3114 (void) HWIF(drive)->ide_dma_verbose(drive);
3115 #endif /* CONFIG_BLK_DEV_IDEDMA */
3121 static void ide_cdrom_add_settings(ide_drive_t *drive)
3123 ide_add_setting(drive, "dsc_overlap", SETTING_RW, -1, -1, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
3127 * standard prep_rq_fn that builds 10 byte cmds
3129 static int ide_cdrom_prep_fs(request_queue_t *q, struct request *rq)
3131 int hard_sect = queue_hardsect_size(q);
3132 long block = (long)rq->hard_sector / (hard_sect >> 9);
3133 unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
3135 memset(rq->cmd, 0, sizeof(rq->cmd));
3137 if (rq_data_dir(rq) == READ)
3138 rq->cmd[0] = GPCMD_READ_10;
3140 rq->cmd[0] = GPCMD_WRITE_10;
3145 rq->cmd[2] = (block >> 24) & 0xff;
3146 rq->cmd[3] = (block >> 16) & 0xff;
3147 rq->cmd[4] = (block >> 8) & 0xff;
3148 rq->cmd[5] = block & 0xff;
3151 * and transfer length
3153 rq->cmd[7] = (blocks >> 8) & 0xff;
3154 rq->cmd[8] = blocks & 0xff;
3160 * Most of the SCSI commands are supported directly by ATAPI devices.
3161 * This transform handles the few exceptions.
3163 static int ide_cdrom_prep_pc(struct request *rq)
3168 * Transform 6-byte read/write commands to the 10-byte version
3170 if (c[0] == READ_6 || c[0] == WRITE_6) {
3177 c[0] += (READ_10 - READ_6);
3183 * it's silly to pretend we understand 6-byte sense commands, just
3184 * reject with ILLEGAL_REQUEST and the caller should take the
3185 * appropriate action
3187 if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
3188 rq->errors = ILLEGAL_REQUEST;
3189 return BLKPREP_KILL;
3195 static int ide_cdrom_prep_fn(request_queue_t *q, struct request *rq)
3197 if (rq->flags & REQ_CMD)
3198 return ide_cdrom_prep_fs(q, rq);
3199 else if (rq->flags & REQ_BLOCK_PC)
3200 return ide_cdrom_prep_pc(rq);
3206 int ide_cdrom_setup (ide_drive_t *drive)
3208 struct cdrom_info *info = drive->driver_data;
3209 struct cdrom_device_info *cdi = &info->devinfo;
3212 blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
3213 blk_queue_dma_alignment(drive->queue, 31);
3214 drive->queue->unplug_delay = (1 * HZ) / 1000;
3215 if (!drive->queue->unplug_delay)
3216 drive->queue->unplug_delay = 1;
3218 drive->special.all = 0;
3219 drive->ready_stat = 0;
3221 CDROM_STATE_FLAGS(drive)->media_changed = 1;
3222 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
3223 CDROM_STATE_FLAGS(drive)->door_locked = 0;
3226 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
3228 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 0;
3231 CDROM_CONFIG_FLAGS(drive)->drq_interrupt = ((drive->id->config & 0x0060) == 0x20);
3232 CDROM_CONFIG_FLAGS(drive)->is_changer = 0;
3233 CDROM_CONFIG_FLAGS(drive)->cd_r = 0;
3234 CDROM_CONFIG_FLAGS(drive)->cd_rw = 0;
3235 CDROM_CONFIG_FLAGS(drive)->test_write = 0;
3236 CDROM_CONFIG_FLAGS(drive)->dvd = 0;
3237 CDROM_CONFIG_FLAGS(drive)->dvd_r = 0;
3238 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 0;
3239 CDROM_CONFIG_FLAGS(drive)->no_eject = 1;
3240 CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 0;
3241 CDROM_CONFIG_FLAGS(drive)->audio_play = 0;
3242 CDROM_CONFIG_FLAGS(drive)->close_tray = 1;
3244 /* limit transfer size per interrupt. */
3245 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 0;
3246 /* a testament to the nice quality of Samsung drives... */
3247 if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2430"))
3248 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3249 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2432"))
3250 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3251 /* the 3231 model does not support the SET_CD_SPEED command */
3252 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-3231"))
3253 cdi->mask |= CDC_SELECT_SPEED;
3255 #if ! STANDARD_ATAPI
3256 /* by default Sanyo 3 CD changer support is turned off and
3257 ATAPI Rev 2.2+ standard support for CD changers is used */
3258 cdi->sanyo_slot = 0;
3260 CDROM_CONFIG_FLAGS(drive)->nec260 = 0;
3261 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 0;
3262 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 0;
3263 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 0;
3264 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 0;
3266 if (strcmp (drive->id->model, "V003S0DS") == 0 &&
3267 drive->id->fw_rev[4] == '1' &&
3268 drive->id->fw_rev[6] <= '2') {
3270 Some versions of this drive like to talk BCD. */
3271 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3272 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3273 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3274 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3277 else if (strcmp (drive->id->model, "V006E0DS") == 0 &&
3278 drive->id->fw_rev[4] == '1' &&
3279 drive->id->fw_rev[6] <= '2') {
3280 /* Vertos 600 ESD. */
3281 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3283 else if (strcmp(drive->id->model, "NEC CD-ROM DRIVE:260") == 0 &&
3284 strncmp(drive->id->fw_rev, "1.01", 4) == 0) { /* FIXME */
3285 /* Old NEC260 (not R).
3286 This drive was released before the 1.2 version
3288 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3289 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3290 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3291 CDROM_CONFIG_FLAGS(drive)->nec260 = 1;
3293 else if (strcmp(drive->id->model, "WEARNES CDD-120") == 0 &&
3294 strncmp(drive->id->fw_rev, "A1.1", 4) == 0) { /* FIXME */
3296 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3297 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3299 /* Sanyo 3 CD changer uses a non-standard command
3301 else if ((strcmp(drive->id->model, "CD-ROM CDR-C3 G") == 0) ||
3302 (strcmp(drive->id->model, "CD-ROM CDR-C3G") == 0) ||
3303 (strcmp(drive->id->model, "CD-ROM CDR_C36") == 0)) {
3304 /* uses CD in slot 0 when value is set to 3 */
3305 cdi->sanyo_slot = 3;
3307 #endif /* not STANDARD_ATAPI */
3310 info->buffer = NULL;
3311 info->sector_buffered = 0;
3312 info->nsectors_buffered = 0;
3313 info->changer_info = NULL;
3314 info->last_block = 0;
3315 info->start_seek = 0;
3317 nslots = ide_cdrom_probe_capabilities (drive);
3320 * set correct block size
3322 blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
3325 drive->dsc_overlap = (HWIF(drive)->no_dsc) ? 0 : 1;
3326 if (HWIF(drive)->no_dsc) {
3327 printk(KERN_INFO "ide-cd: %s: disabling DSC overlap\n",
3329 drive->dsc_overlap = 0;
3333 if (ide_cdrom_register(drive, nslots)) {
3334 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
3335 info->devinfo.handle = NULL;
3338 ide_cdrom_add_settings(drive);
3343 sector_t ide_cdrom_capacity (ide_drive_t *drive)
3345 unsigned long capacity, sectors_per_frame;
3347 if (cdrom_read_capacity(drive, &capacity, §ors_per_frame, NULL))
3350 return capacity * sectors_per_frame;
3354 int ide_cdrom_cleanup(ide_drive_t *drive)
3356 struct cdrom_info *info = drive->driver_data;
3357 struct cdrom_device_info *devinfo = &info->devinfo;
3358 struct gendisk *g = drive->disk;
3360 if (ide_unregister_subdriver(drive)) {
3361 printk(KERN_ERR "%s: %s: failed to ide_unregister_subdriver\n",
3362 __FUNCTION__, drive->name);
3365 if (info->buffer != NULL)
3366 kfree(info->buffer);
3367 if (info->toc != NULL)
3369 if (info->changer_info != NULL)
3370 kfree(info->changer_info);
3371 if (devinfo->handle == drive && unregister_cdrom(devinfo))
3372 printk(KERN_ERR "%s: ide_cdrom_cleanup failed to unregister device from the cdrom driver.\n", drive->name);
3374 drive->driver_data = NULL;
3375 blk_queue_prep_rq(drive->queue, NULL);
3381 static int ide_cdrom_attach (ide_drive_t *drive);
3384 * Power Management state machine.
3386 * We don't do much for CDs right now.
3389 static void ide_cdrom_complete_power_step (ide_drive_t *drive, struct request *rq, u8 stat, u8 error)
3393 static ide_startstop_t ide_cdrom_start_power_step (ide_drive_t *drive, struct request *rq)
3395 ide_task_t *args = rq->special;
3397 memset(args, 0, sizeof(*args));
3399 switch (rq->pm->pm_step) {
3400 case ide_pm_state_start_suspend:
3403 case ide_pm_state_start_resume: /* Resume step 1 (restore DMA) */
3405 * Right now, all we do is call hwif->ide_dma_check(drive),
3406 * we could be smarter and check for current xfer_speed
3407 * in struct drive etc...
3408 * Also, this step could be implemented as a generic helper
3409 * as most subdrivers will use it.
3411 if ((drive->id->capability & 1) == 0)
3413 if (HWIF(drive)->ide_dma_check == NULL)
3415 HWIF(drive)->ide_dma_check(drive);
3418 rq->pm->pm_step = ide_pm_state_completed;
3422 static ide_driver_t ide_cdrom_driver = {
3423 .owner = THIS_MODULE,
3424 .name = "ide-cdrom",
3425 .version = IDECD_VERSION,
3428 .supports_dsc_overlap = 1,
3429 .cleanup = ide_cdrom_cleanup,
3430 .do_request = ide_do_rw_cdrom,
3431 .sense = ide_dump_atapi_status,
3432 .error = ide_cdrom_error,
3433 .abort = ide_cdrom_abort,
3434 .capacity = ide_cdrom_capacity,
3435 .attach = ide_cdrom_attach,
3436 .drives = LIST_HEAD_INIT(ide_cdrom_driver.drives),
3437 .start_power_step = ide_cdrom_start_power_step,
3438 .complete_power_step = ide_cdrom_complete_power_step,
3441 static int idecd_open(struct inode * inode, struct file * file)
3443 ide_drive_t *drive = inode->i_bdev->bd_disk->private_data;
3444 struct cdrom_info *info = drive->driver_data;
3449 info->buffer = kmalloc(SECTOR_BUFFER_SIZE,
3450 GFP_KERNEL|__GFP_REPEAT);
3451 if (!info->buffer || (rc = cdrom_open(&info->devinfo, inode, file)))
3456 static int idecd_release(struct inode * inode, struct file * file)
3458 ide_drive_t *drive = inode->i_bdev->bd_disk->private_data;
3459 struct cdrom_info *info = drive->driver_data;
3461 cdrom_release (&info->devinfo, file);
3466 static int idecd_ioctl (struct inode *inode, struct file *file,
3467 unsigned int cmd, unsigned long arg)
3469 struct block_device *bdev = inode->i_bdev;
3470 ide_drive_t *drive = bdev->bd_disk->private_data;
3471 int err = generic_ide_ioctl(file, bdev, cmd, arg);
3472 if (err == -EINVAL) {
3473 struct cdrom_info *info = drive->driver_data;
3474 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
3479 static int idecd_media_changed(struct gendisk *disk)
3481 ide_drive_t *drive = disk->private_data;
3482 struct cdrom_info *info = drive->driver_data;
3483 return cdrom_media_changed(&info->devinfo);
3486 static int idecd_revalidate_disk(struct gendisk *disk)
3488 ide_drive_t *drive = disk->private_data;
3489 struct request_sense sense;
3490 cdrom_read_toc(drive, &sense);
3494 static struct block_device_operations idecd_ops = {
3495 .owner = THIS_MODULE,
3497 .release = idecd_release,
3498 .ioctl = idecd_ioctl,
3499 .media_changed = idecd_media_changed,
3500 .revalidate_disk= idecd_revalidate_disk
3504 char *ignore = NULL;
3506 MODULE_PARM(ignore, "s");
3507 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
3509 static int ide_cdrom_attach (ide_drive_t *drive)
3511 struct cdrom_info *info;
3512 struct gendisk *g = drive->disk;
3513 struct request_sense sense;
3515 if (!strstr("ide-cdrom", drive->driver_req))
3517 if (!drive->present)
3519 if (drive->media != ide_cdrom && drive->media != ide_optical)
3521 /* skip drives that we were told to ignore */
3522 if (ignore != NULL) {
3523 if (strstr(ignore, drive->name)) {
3524 printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
3529 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
3532 info = (struct cdrom_info *) kmalloc (sizeof (struct cdrom_info), GFP_KERNEL);
3534 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
3537 if (ide_register_subdriver(drive, &ide_cdrom_driver)) {
3538 printk(KERN_ERR "%s: Failed to register the driver with ide.c\n",
3543 memset(info, 0, sizeof (struct cdrom_info));
3544 drive->driver_data = info;
3545 DRIVER(drive)->busy++;
3547 snprintf(g->devfs_name, sizeof(g->devfs_name),
3548 "%s/cd", drive->devfs_name);
3549 g->driverfs_dev = &drive->gendev;
3550 g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
3551 if (ide_cdrom_setup(drive)) {
3552 struct cdrom_device_info *devinfo = &info->devinfo;
3553 DRIVER(drive)->busy--;
3554 ide_unregister_subdriver(drive);
3555 if (info->buffer != NULL)
3556 kfree(info->buffer);
3557 if (info->toc != NULL)
3559 if (info->changer_info != NULL)
3560 kfree(info->changer_info);
3561 if (devinfo->handle == drive && unregister_cdrom(devinfo))
3562 printk (KERN_ERR "%s: ide_cdrom_cleanup failed to unregister device from the cdrom driver.\n", drive->name);
3564 drive->driver_data = NULL;
3567 DRIVER(drive)->busy--;
3569 cdrom_read_toc(drive, &sense);
3570 g->fops = &idecd_ops;
3571 g->flags |= GENHD_FL_REMOVABLE;
3578 static void __exit ide_cdrom_exit(void)
3580 ide_unregister_driver(&ide_cdrom_driver);
3583 static int ide_cdrom_init(void)
3585 ide_register_driver(&ide_cdrom_driver);
3589 module_init(ide_cdrom_init);
3590 module_exit(ide_cdrom_exit);
3591 MODULE_LICENSE("GPL");