ide-cd: revert DMA mask test change
[linux-2.6/kvm.git] / drivers / ide / ide-cd.c
blob78e3e7b24d7d62fb12bb2736f001d95894b1d42b
1 /*
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
18 * anonymous ftp from:
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 * ----------------------------------
27 * TO DO LIST:
28 * -Make it so that Pioneer CD DR-A24X and friends don't get screwed up on
29 * boot
31 * ----------------------------------
32 * 1.00 Oct 31, 1994 -- Initial version.
33 * 1.01 Nov 2, 1994 -- Fixed problem with starting request in
34 * cdrom_check_status.
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;
39 * add audio ioctls.
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
46 * when possible.
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
50 * single transaction.
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
60 * a failed command.
61 * Include an option to give textual descriptions
62 * of ATAPI errors.
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().
75 * Add door locking.
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,
111 * Vertos 300.
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
134 * <jeffml@pobox.com>
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
146 * regardless.
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
237 * same.
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
255 * do it cleanly.
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
268 * Uniform layer.
269 * - Added partition based multisession handling.
270 * - Mode sense and mode select moved to the
271 * Uniform layer.
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
296 * - Odd stuff
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 */
319 #include <asm/irq.h>
320 #include <asm/io.h>
321 #include <asm/byteorder.h>
322 #include <asm/uaccess.h>
323 #include <asm/unaligned.h>
325 #include "ide-cd.h"
327 static DECLARE_MUTEX(idecd_ref_sem);
329 #define to_ide_cd(obj) container_of(obj, struct cdrom_info, kref)
331 #define ide_cd_g(disk) \
332 container_of((disk)->private_data, struct cdrom_info, driver)
334 static struct cdrom_info *ide_cd_get(struct gendisk *disk)
336 struct cdrom_info *cd = NULL;
338 down(&idecd_ref_sem);
339 cd = ide_cd_g(disk);
340 if (cd)
341 kref_get(&cd->kref);
342 up(&idecd_ref_sem);
343 return cd;
346 static void ide_cd_release(struct kref *);
348 static void ide_cd_put(struct cdrom_info *cd)
350 down(&idecd_ref_sem);
351 kref_put(&cd->kref, ide_cd_release);
352 up(&idecd_ref_sem);
355 /****************************************************************************
356 * Generic packet command support and error handling routines.
359 /* Mark that we've seen a media change, and invalidate our internal
360 buffers. */
361 static void cdrom_saw_media_change (ide_drive_t *drive)
363 struct cdrom_info *info = drive->driver_data;
365 CDROM_STATE_FLAGS (drive)->media_changed = 1;
366 CDROM_STATE_FLAGS (drive)->toc_valid = 0;
367 info->nsectors_buffered = 0;
370 static int cdrom_log_sense(ide_drive_t *drive, struct request *rq,
371 struct request_sense *sense)
373 int log = 0;
375 if (!sense || !rq || (rq->flags & REQ_QUIET))
376 return 0;
378 switch (sense->sense_key) {
379 case NO_SENSE: case RECOVERED_ERROR:
380 break;
381 case NOT_READY:
383 * don't care about tray state messages for
384 * e.g. capacity commands or in-progress or
385 * becoming ready
387 if (sense->asc == 0x3a || sense->asc == 0x04)
388 break;
389 log = 1;
390 break;
391 case ILLEGAL_REQUEST:
393 * don't log START_STOP unit with LoEj set, since
394 * we cannot reliably check if drive can auto-close
396 if (rq->cmd[0] == GPCMD_START_STOP_UNIT && sense->asc == 0x24)
397 log = 0;
398 break;
399 case UNIT_ATTENTION:
401 * Make good and sure we've seen this potential media
402 * change. Some drives (i.e. Creative) fail to present
403 * the correct sense key in the error register.
405 cdrom_saw_media_change(drive);
406 break;
407 default:
408 log = 1;
409 break;
411 return log;
414 static
415 void cdrom_analyze_sense_data(ide_drive_t *drive,
416 struct request *failed_command,
417 struct request_sense *sense)
419 if (!cdrom_log_sense(drive, failed_command, sense))
420 return;
423 * If a read toc is executed for a CD-R or CD-RW medium where
424 * the first toc has not been recorded yet, it will fail with
425 * 05/24/00 (which is a confusing error)
427 if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP)
428 if (sense->sense_key == 0x05 && sense->asc == 0x24)
429 return;
431 #if VERBOSE_IDE_CD_ERRORS
433 int i;
434 const char *s;
435 char buf[80];
437 printk ("ATAPI device %s:\n", drive->name);
438 if (sense->error_code==0x70)
439 printk(" Error: ");
440 else if (sense->error_code==0x71)
441 printk(" Deferred Error: ");
442 else if (sense->error_code == 0x7f)
443 printk(" Vendor-specific Error: ");
444 else
445 printk(" Unknown Error Type: ");
447 if (sense->sense_key < ARY_LEN(sense_key_texts))
448 s = sense_key_texts[sense->sense_key];
449 else
450 s = "bad sense key!";
452 printk("%s -- (Sense key=0x%02x)\n", s, sense->sense_key);
454 if (sense->asc == 0x40) {
455 sprintf(buf, "Diagnostic failure on component 0x%02x",
456 sense->ascq);
457 s = buf;
458 } else {
459 int lo = 0, mid, hi = ARY_LEN(sense_data_texts);
460 unsigned long key = (sense->sense_key << 16);
461 key |= (sense->asc << 8);
462 if (!(sense->ascq >= 0x80 && sense->ascq <= 0xdd))
463 key |= sense->ascq;
464 s = NULL;
466 while (hi > lo) {
467 mid = (lo + hi) / 2;
468 if (sense_data_texts[mid].asc_ascq == key ||
469 sense_data_texts[mid].asc_ascq == (0xff0000|key)) {
470 s = sense_data_texts[mid].text;
471 break;
473 else if (sense_data_texts[mid].asc_ascq > key)
474 hi = mid;
475 else
476 lo = mid+1;
480 if (s == NULL) {
481 if (sense->asc > 0x80)
482 s = "(vendor-specific error)";
483 else
484 s = "(reserved error code)";
487 printk(KERN_ERR " %s -- (asc=0x%02x, ascq=0x%02x)\n",
488 s, sense->asc, sense->ascq);
490 if (failed_command != NULL) {
492 int lo=0, mid, hi= ARY_LEN (packet_command_texts);
493 s = NULL;
495 while (hi > lo) {
496 mid = (lo + hi) / 2;
497 if (packet_command_texts[mid].packet_command ==
498 failed_command->cmd[0]) {
499 s = packet_command_texts[mid].text;
500 break;
502 if (packet_command_texts[mid].packet_command >
503 failed_command->cmd[0])
504 hi = mid;
505 else
506 lo = mid+1;
509 printk (KERN_ERR " The failed \"%s\" packet command was: \n \"", s);
510 for (i=0; i<sizeof (failed_command->cmd); i++)
511 printk ("%02x ", failed_command->cmd[i]);
512 printk ("\"\n");
515 /* The SKSV bit specifies validity of the sense_key_specific
516 * in the next two commands. It is bit 7 of the first byte.
517 * In the case of NOT_READY, if SKSV is set the drive can
518 * give us nice ETA readings.
520 if (sense->sense_key == NOT_READY && (sense->sks[0] & 0x80)) {
521 int progress = (sense->sks[1] << 8 | sense->sks[2]) * 100;
522 printk(KERN_ERR " Command is %02d%% complete\n", progress / 0xffff);
526 if (sense->sense_key == ILLEGAL_REQUEST &&
527 (sense->sks[0] & 0x80) != 0) {
528 printk(KERN_ERR " Error in %s byte %d",
529 (sense->sks[0] & 0x40) != 0 ?
530 "command packet" : "command data",
531 (sense->sks[1] << 8) + sense->sks[2]);
533 if ((sense->sks[0] & 0x40) != 0)
534 printk (" bit %d", sense->sks[0] & 0x07);
536 printk ("\n");
540 #else /* not VERBOSE_IDE_CD_ERRORS */
542 /* Suppress printing unit attention and `in progress of becoming ready'
543 errors when we're not being verbose. */
545 if (sense->sense_key == UNIT_ATTENTION ||
546 (sense->sense_key == NOT_READY && (sense->asc == 4 ||
547 sense->asc == 0x3a)))
548 return;
550 printk(KERN_ERR "%s: error code: 0x%02x sense_key: 0x%02x asc: 0x%02x ascq: 0x%02x\n",
551 drive->name,
552 sense->error_code, sense->sense_key,
553 sense->asc, sense->ascq);
554 #endif /* not VERBOSE_IDE_CD_ERRORS */
558 * Initialize a ide-cd packet command request
560 static void cdrom_prepare_request(ide_drive_t *drive, struct request *rq)
562 struct cdrom_info *cd = drive->driver_data;
564 ide_init_drive_cmd(rq);
565 rq->flags = REQ_PC;
566 rq->rq_disk = cd->disk;
569 static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense,
570 struct request *failed_command)
572 struct cdrom_info *info = drive->driver_data;
573 struct request *rq = &info->request_sense_request;
575 if (sense == NULL)
576 sense = &info->sense_data;
578 /* stuff the sense request in front of our current request */
579 cdrom_prepare_request(drive, rq);
581 rq->data = sense;
582 rq->cmd[0] = GPCMD_REQUEST_SENSE;
583 rq->cmd[4] = rq->data_len = 18;
585 rq->flags = REQ_SENSE;
587 /* NOTE! Save the failed command in "rq->buffer" */
588 rq->buffer = (void *) failed_command;
590 (void) ide_do_drive_cmd(drive, rq, ide_preempt);
593 static void cdrom_end_request (ide_drive_t *drive, int uptodate)
595 struct request *rq = HWGROUP(drive)->rq;
596 int nsectors = rq->hard_cur_sectors;
598 if ((rq->flags & REQ_SENSE) && uptodate) {
600 * For REQ_SENSE, "rq->buffer" points to the original failed
601 * request
603 struct request *failed = (struct request *) rq->buffer;
604 struct cdrom_info *info = drive->driver_data;
605 void *sense = &info->sense_data;
606 unsigned long flags;
608 if (failed) {
609 if (failed->sense) {
610 sense = failed->sense;
611 failed->sense_len = rq->sense_len;
615 * now end failed request
617 spin_lock_irqsave(&ide_lock, flags);
618 end_that_request_chunk(failed, 0, failed->data_len);
619 end_that_request_last(failed);
620 spin_unlock_irqrestore(&ide_lock, flags);
623 cdrom_analyze_sense_data(drive, failed, sense);
626 if (!rq->current_nr_sectors && blk_fs_request(rq))
627 uptodate = 1;
628 /* make sure it's fully ended */
629 if (blk_pc_request(rq))
630 nsectors = (rq->data_len + 511) >> 9;
631 if (!nsectors)
632 nsectors = 1;
634 ide_end_request(drive, uptodate, nsectors);
637 /* Returns 0 if the request should be continued.
638 Returns 1 if the request was ended. */
639 static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
641 struct request *rq = HWGROUP(drive)->rq;
642 int stat, err, sense_key;
644 /* Check for errors. */
645 stat = HWIF(drive)->INB(IDE_STATUS_REG);
646 if (stat_ret)
647 *stat_ret = stat;
649 if (OK_STAT(stat, good_stat, BAD_R_STAT))
650 return 0;
652 /* Get the IDE error register. */
653 err = HWIF(drive)->INB(IDE_ERROR_REG);
654 sense_key = err >> 4;
656 if (rq == NULL) {
657 printk("%s: missing rq in cdrom_decode_status\n", drive->name);
658 return 1;
661 if (rq->flags & REQ_SENSE) {
662 /* We got an error trying to get sense info
663 from the drive (probably while trying
664 to recover from a former error). Just give up. */
666 rq->flags |= REQ_FAILED;
667 cdrom_end_request(drive, 0);
668 ide_error(drive, "request sense failure", stat);
669 return 1;
671 } else if (rq->flags & (REQ_PC | REQ_BLOCK_PC)) {
672 /* All other functions, except for READ. */
673 unsigned long flags;
676 * if we have an error, pass back CHECK_CONDITION as the
677 * scsi status byte
679 if ((rq->flags & REQ_BLOCK_PC) && !rq->errors)
680 rq->errors = SAM_STAT_CHECK_CONDITION;
682 /* Check for tray open. */
683 if (sense_key == NOT_READY) {
684 cdrom_saw_media_change (drive);
685 } else if (sense_key == UNIT_ATTENTION) {
686 /* Check for media change. */
687 cdrom_saw_media_change (drive);
688 /*printk("%s: media changed\n",drive->name);*/
689 return 0;
690 } else if (!(rq->flags & REQ_QUIET)) {
691 /* Otherwise, print an error. */
692 ide_dump_status(drive, "packet command error", stat);
695 rq->flags |= REQ_FAILED;
698 * instead of playing games with moving completions around,
699 * remove failed request completely and end it when the
700 * request sense has completed
702 if (stat & ERR_STAT) {
703 spin_lock_irqsave(&ide_lock, flags);
704 blkdev_dequeue_request(rq);
705 HWGROUP(drive)->rq = NULL;
706 spin_unlock_irqrestore(&ide_lock, flags);
708 cdrom_queue_request_sense(drive, rq->sense, rq);
709 } else
710 cdrom_end_request(drive, 0);
712 } else if (blk_fs_request(rq)) {
713 int do_end_request = 0;
715 /* Handle errors from READ and WRITE requests. */
717 if (blk_noretry_request(rq))
718 do_end_request = 1;
720 if (sense_key == NOT_READY) {
721 /* Tray open. */
722 if (rq_data_dir(rq) == READ) {
723 cdrom_saw_media_change (drive);
725 /* Fail the request. */
726 printk ("%s: tray open\n", drive->name);
727 do_end_request = 1;
728 } else {
729 struct cdrom_info *info = drive->driver_data;
731 /* allow the drive 5 seconds to recover, some
732 * devices will return this error while flushing
733 * data from cache */
734 if (!rq->errors)
735 info->write_timeout = jiffies + ATAPI_WAIT_WRITE_BUSY;
736 rq->errors = 1;
737 if (time_after(jiffies, info->write_timeout))
738 do_end_request = 1;
739 else {
740 unsigned long flags;
743 * take a breather relying on the
744 * unplug timer to kick us again
746 spin_lock_irqsave(&ide_lock, flags);
747 blk_plug_device(drive->queue);
748 spin_unlock_irqrestore(&ide_lock,flags);
749 return 1;
752 } else if (sense_key == UNIT_ATTENTION) {
753 /* Media change. */
754 cdrom_saw_media_change (drive);
756 /* Arrange to retry the request.
757 But be sure to give up if we've retried
758 too many times. */
759 if (++rq->errors > ERROR_MAX)
760 do_end_request = 1;
761 } else if (sense_key == ILLEGAL_REQUEST ||
762 sense_key == DATA_PROTECT) {
763 /* No point in retrying after an illegal
764 request or data protect error.*/
765 ide_dump_status (drive, "command error", stat);
766 do_end_request = 1;
767 } else if (sense_key == MEDIUM_ERROR) {
768 /* No point in re-trying a zillion times on a bad
769 * sector... If we got here the error is not correctable */
770 ide_dump_status (drive, "media error (bad sector)", stat);
771 do_end_request = 1;
772 } else if (sense_key == BLANK_CHECK) {
773 /* Disk appears blank ?? */
774 ide_dump_status (drive, "media error (blank)", stat);
775 do_end_request = 1;
776 } else if ((err & ~ABRT_ERR) != 0) {
777 /* Go to the default handler
778 for other errors. */
779 ide_error(drive, "cdrom_decode_status", stat);
780 return 1;
781 } else if ((++rq->errors > ERROR_MAX)) {
782 /* We've racked up too many retries. Abort. */
783 do_end_request = 1;
786 if (do_end_request)
787 cdrom_end_request(drive, 0);
789 /* If we got a CHECK_CONDITION status,
790 queue a request sense command. */
791 if ((stat & ERR_STAT) != 0)
792 cdrom_queue_request_sense(drive, NULL, NULL);
793 } else {
794 blk_dump_rq_flags(rq, "ide-cd: bad rq");
795 cdrom_end_request(drive, 0);
798 /* Retry, or handle the next request. */
799 return 1;
802 static int cdrom_timer_expiry(ide_drive_t *drive)
804 struct request *rq = HWGROUP(drive)->rq;
805 unsigned long wait = 0;
808 * Some commands are *slow* and normally take a long time to
809 * complete. Usually we can use the ATAPI "disconnect" to bypass
810 * this, but not all commands/drives support that. Let
811 * ide_timer_expiry keep polling us for these.
813 switch (rq->cmd[0]) {
814 case GPCMD_BLANK:
815 case GPCMD_FORMAT_UNIT:
816 case GPCMD_RESERVE_RZONE_TRACK:
817 case GPCMD_CLOSE_TRACK:
818 case GPCMD_FLUSH_CACHE:
819 wait = ATAPI_WAIT_PC;
820 break;
821 default:
822 if (!(rq->flags & REQ_QUIET))
823 printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n", rq->cmd[0]);
824 wait = 0;
825 break;
827 return wait;
830 /* Set up the device registers for transferring a packet command on DEV,
831 expecting to later transfer XFERLEN bytes. HANDLER is the routine
832 which actually transfers the command to the drive. If this is a
833 drq_interrupt device, this routine will arrange for HANDLER to be
834 called when the interrupt from the drive arrives. Otherwise, HANDLER
835 will be called immediately after the drive is prepared for the transfer. */
837 static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
838 int xferlen,
839 ide_handler_t *handler)
841 ide_startstop_t startstop;
842 struct cdrom_info *info = drive->driver_data;
843 ide_hwif_t *hwif = drive->hwif;
845 /* Wait for the controller to be idle. */
846 if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY))
847 return startstop;
849 if (info->dma)
850 info->dma = !hwif->dma_setup(drive);
852 /* Set up the controller registers. */
853 /* FIXME: for Virtual DMA we must check harder */
854 HWIF(drive)->OUTB(info->dma, IDE_FEATURE_REG);
855 HWIF(drive)->OUTB(0, IDE_IREASON_REG);
856 HWIF(drive)->OUTB(0, IDE_SECTOR_REG);
858 HWIF(drive)->OUTB(xferlen & 0xff, IDE_BCOUNTL_REG);
859 HWIF(drive)->OUTB(xferlen >> 8 , IDE_BCOUNTH_REG);
860 if (IDE_CONTROL_REG)
861 HWIF(drive)->OUTB(drive->ctl, IDE_CONTROL_REG);
863 if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt) {
864 /* packet command */
865 ide_execute_command(drive, WIN_PACKETCMD, handler, ATAPI_WAIT_PC, cdrom_timer_expiry);
866 return ide_started;
867 } else {
868 unsigned long flags;
870 /* packet command */
871 spin_lock_irqsave(&ide_lock, flags);
872 hwif->OUTBSYNC(drive, WIN_PACKETCMD, IDE_COMMAND_REG);
873 ndelay(400);
874 spin_unlock_irqrestore(&ide_lock, flags);
876 return (*handler) (drive);
880 /* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
881 The device registers must have already been prepared
882 by cdrom_start_packet_command.
883 HANDLER is the interrupt handler to call when the command completes
884 or there's data ready. */
886 * changed 5 parameters to 3 for dvd-ram
887 * struct packet_command *pc; now packet_command_t *pc;
889 #define ATAPI_MIN_CDB_BYTES 12
890 static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
891 struct request *rq,
892 ide_handler_t *handler)
894 ide_hwif_t *hwif = drive->hwif;
895 int cmd_len;
896 struct cdrom_info *info = drive->driver_data;
897 ide_startstop_t startstop;
899 if (CDROM_CONFIG_FLAGS(drive)->drq_interrupt) {
900 /* Here we should have been called after receiving an interrupt
901 from the device. DRQ should how be set. */
903 /* Check for errors. */
904 if (cdrom_decode_status(drive, DRQ_STAT, NULL))
905 return ide_stopped;
906 } else {
907 /* Otherwise, we must wait for DRQ to get set. */
908 if (ide_wait_stat(&startstop, drive, DRQ_STAT,
909 BUSY_STAT, WAIT_READY))
910 return startstop;
913 /* Arm the interrupt handler. */
914 ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);
916 /* ATAPI commands get padded out to 12 bytes minimum */
917 cmd_len = COMMAND_SIZE(rq->cmd[0]);
918 if (cmd_len < ATAPI_MIN_CDB_BYTES)
919 cmd_len = ATAPI_MIN_CDB_BYTES;
921 /* Send the command to the device. */
922 HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len);
924 /* Start the DMA if need be */
925 if (info->dma)
926 hwif->dma_start(drive);
928 return ide_started;
931 /****************************************************************************
932 * Block read functions.
936 * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
937 * buffer. Once the first sector is added, any subsequent sectors are
938 * assumed to be continuous (until the buffer is cleared). For the first
939 * sector added, SECTOR is its sector number. (SECTOR is then ignored until
940 * the buffer is cleared.)
942 static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
943 int sectors_to_transfer)
945 struct cdrom_info *info = drive->driver_data;
947 /* Number of sectors to read into the buffer. */
948 int sectors_to_buffer = min_t(int, sectors_to_transfer,
949 (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
950 info->nsectors_buffered);
952 char *dest;
954 /* If we couldn't get a buffer, don't try to buffer anything... */
955 if (info->buffer == NULL)
956 sectors_to_buffer = 0;
958 /* If this is the first sector in the buffer, remember its number. */
959 if (info->nsectors_buffered == 0)
960 info->sector_buffered = sector;
962 /* Read the data into the buffer. */
963 dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
964 while (sectors_to_buffer > 0) {
965 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
966 --sectors_to_buffer;
967 --sectors_to_transfer;
968 ++info->nsectors_buffered;
969 dest += SECTOR_SIZE;
972 /* Throw away any remaining data. */
973 while (sectors_to_transfer > 0) {
974 static char dum[SECTOR_SIZE];
975 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
976 --sectors_to_transfer;
981 * Check the contents of the interrupt reason register from the cdrom
982 * and attempt to recover if there are problems. Returns 0 if everything's
983 * ok; nonzero if the request has been terminated.
985 static inline
986 int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
988 if (ireason == 2)
989 return 0;
990 else if (ireason == 0) {
991 /* Whoops... The drive is expecting to receive data from us! */
992 printk(KERN_ERR "%s: read_intr: Drive wants to transfer data the "
993 "wrong way!\n", drive->name);
995 /* Throw some data at the drive so it doesn't hang
996 and quit this request. */
997 while (len > 0) {
998 int dum = 0;
999 HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof (dum));
1000 len -= sizeof (dum);
1002 } else if (ireason == 1) {
1003 /* Some drives (ASUS) seem to tell us that status
1004 * info is available. just get it and ignore.
1006 (void) HWIF(drive)->INB(IDE_STATUS_REG);
1007 return 0;
1008 } else {
1009 /* Drive wants a command packet, or invalid ireason... */
1010 printk(KERN_ERR "%s: read_intr: bad interrupt reason %x\n", drive->name,
1011 ireason);
1014 cdrom_end_request(drive, 0);
1015 return -1;
1019 * Interrupt routine. Called when a read request has completed.
1021 static ide_startstop_t cdrom_read_intr (ide_drive_t *drive)
1023 int stat;
1024 int ireason, len, sectors_to_transfer, nskip;
1025 struct cdrom_info *info = drive->driver_data;
1026 u8 lowcyl = 0, highcyl = 0;
1027 int dma = info->dma, dma_error = 0;
1029 struct request *rq = HWGROUP(drive)->rq;
1032 * handle dma case
1034 if (dma) {
1035 info->dma = 0;
1036 if ((dma_error = HWIF(drive)->ide_dma_end(drive)))
1037 __ide_dma_off(drive);
1040 if (cdrom_decode_status(drive, 0, &stat))
1041 return ide_stopped;
1043 if (dma) {
1044 if (!dma_error) {
1045 ide_end_request(drive, 1, rq->nr_sectors);
1046 return ide_stopped;
1047 } else
1048 return ide_error(drive, "dma error", stat);
1051 /* Read the interrupt reason and the transfer length. */
1052 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1053 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1054 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1056 len = lowcyl + (256 * highcyl);
1058 /* If DRQ is clear, the command has completed. */
1059 if ((stat & DRQ_STAT) == 0) {
1060 /* If we're not done filling the current buffer, complain.
1061 Otherwise, complete the command normally. */
1062 if (rq->current_nr_sectors > 0) {
1063 printk (KERN_ERR "%s: cdrom_read_intr: data underrun (%d blocks)\n",
1064 drive->name, rq->current_nr_sectors);
1065 rq->flags |= REQ_FAILED;
1066 cdrom_end_request(drive, 0);
1067 } else
1068 cdrom_end_request(drive, 1);
1069 return ide_stopped;
1072 /* Check that the drive is expecting to do the same thing we are. */
1073 if (cdrom_read_check_ireason (drive, len, ireason))
1074 return ide_stopped;
1076 /* Assume that the drive will always provide data in multiples
1077 of at least SECTOR_SIZE, as it gets hairy to keep track
1078 of the transfers otherwise. */
1079 if ((len % SECTOR_SIZE) != 0) {
1080 printk (KERN_ERR "%s: cdrom_read_intr: Bad transfer size %d\n",
1081 drive->name, len);
1082 if (CDROM_CONFIG_FLAGS(drive)->limit_nframes)
1083 printk (KERN_ERR " This drive is not supported by this version of the driver\n");
1084 else {
1085 printk (KERN_ERR " Trying to limit transfer sizes\n");
1086 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
1088 cdrom_end_request(drive, 0);
1089 return ide_stopped;
1092 /* The number of sectors we need to read from the drive. */
1093 sectors_to_transfer = len / SECTOR_SIZE;
1095 /* First, figure out if we need to bit-bucket
1096 any of the leading sectors. */
1097 nskip = min_t(int, rq->current_nr_sectors - bio_cur_sectors(rq->bio), sectors_to_transfer);
1099 while (nskip > 0) {
1100 /* We need to throw away a sector. */
1101 static char dum[SECTOR_SIZE];
1102 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1104 --rq->current_nr_sectors;
1105 --nskip;
1106 --sectors_to_transfer;
1109 /* Now loop while we still have data to read from the drive. */
1110 while (sectors_to_transfer > 0) {
1111 int this_transfer;
1113 /* If we've filled the present buffer but there's another
1114 chained buffer after it, move on. */
1115 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1116 cdrom_end_request(drive, 1);
1118 /* If the buffers are full, cache the rest of the data in our
1119 internal buffer. */
1120 if (rq->current_nr_sectors == 0) {
1121 cdrom_buffer_sectors(drive, rq->sector, sectors_to_transfer);
1122 sectors_to_transfer = 0;
1123 } else {
1124 /* Transfer data to the buffers.
1125 Figure out how many sectors we can transfer
1126 to the current buffer. */
1127 this_transfer = min_t(int, sectors_to_transfer,
1128 rq->current_nr_sectors);
1130 /* Read this_transfer sectors
1131 into the current buffer. */
1132 while (this_transfer > 0) {
1133 HWIF(drive)->atapi_input_bytes(drive, rq->buffer, SECTOR_SIZE);
1134 rq->buffer += SECTOR_SIZE;
1135 --rq->nr_sectors;
1136 --rq->current_nr_sectors;
1137 ++rq->sector;
1138 --this_transfer;
1139 --sectors_to_transfer;
1144 /* Done moving data! Wait for another interrupt. */
1145 ide_set_handler(drive, &cdrom_read_intr, ATAPI_WAIT_PC, NULL);
1146 return ide_started;
1150 * Try to satisfy some of the current read request from our cached data.
1151 * Returns nonzero if the request has been completed, zero otherwise.
1153 static int cdrom_read_from_buffer (ide_drive_t *drive)
1155 struct cdrom_info *info = drive->driver_data;
1156 struct request *rq = HWGROUP(drive)->rq;
1157 unsigned short sectors_per_frame;
1159 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1161 /* Can't do anything if there's no buffer. */
1162 if (info->buffer == NULL) return 0;
1164 /* Loop while this request needs data and the next block is present
1165 in our cache. */
1166 while (rq->nr_sectors > 0 &&
1167 rq->sector >= info->sector_buffered &&
1168 rq->sector < info->sector_buffered + info->nsectors_buffered) {
1169 if (rq->current_nr_sectors == 0)
1170 cdrom_end_request(drive, 1);
1172 memcpy (rq->buffer,
1173 info->buffer +
1174 (rq->sector - info->sector_buffered) * SECTOR_SIZE,
1175 SECTOR_SIZE);
1176 rq->buffer += SECTOR_SIZE;
1177 --rq->current_nr_sectors;
1178 --rq->nr_sectors;
1179 ++rq->sector;
1182 /* If we've satisfied the current request,
1183 terminate it successfully. */
1184 if (rq->nr_sectors == 0) {
1185 cdrom_end_request(drive, 1);
1186 return -1;
1189 /* Move on to the next buffer if needed. */
1190 if (rq->current_nr_sectors == 0)
1191 cdrom_end_request(drive, 1);
1193 /* If this condition does not hold, then the kluge i use to
1194 represent the number of sectors to skip at the start of a transfer
1195 will fail. I think that this will never happen, but let's be
1196 paranoid and check. */
1197 if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
1198 (rq->sector & (sectors_per_frame - 1))) {
1199 printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
1200 drive->name, (long)rq->sector);
1201 cdrom_end_request(drive, 0);
1202 return -1;
1205 return 0;
1209 * Routine to send a read packet command to the drive.
1210 * This is usually called directly from cdrom_start_read.
1211 * However, for drq_interrupt devices, it is called from an interrupt
1212 * when the drive is ready to accept the command.
1214 static ide_startstop_t cdrom_start_read_continuation (ide_drive_t *drive)
1216 struct request *rq = HWGROUP(drive)->rq;
1217 unsigned short sectors_per_frame;
1218 int nskip;
1220 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1222 /* If the requested sector doesn't start on a cdrom block boundary,
1223 we must adjust the start of the transfer so that it does,
1224 and remember to skip the first few sectors.
1225 If the CURRENT_NR_SECTORS field is larger than the size
1226 of the buffer, it will mean that we're to skip a number
1227 of sectors equal to the amount by which CURRENT_NR_SECTORS
1228 is larger than the buffer size. */
1229 nskip = rq->sector & (sectors_per_frame - 1);
1230 if (nskip > 0) {
1231 /* Sanity check... */
1232 if (rq->current_nr_sectors != bio_cur_sectors(rq->bio) &&
1233 (rq->sector & (sectors_per_frame - 1))) {
1234 printk(KERN_ERR "%s: cdrom_start_read_continuation: buffer botch (%u)\n",
1235 drive->name, rq->current_nr_sectors);
1236 cdrom_end_request(drive, 0);
1237 return ide_stopped;
1239 rq->current_nr_sectors += nskip;
1242 /* Set up the command */
1243 rq->timeout = ATAPI_WAIT_PC;
1245 /* Send the command to the drive and return. */
1246 return cdrom_transfer_packet_command(drive, rq, &cdrom_read_intr);
1250 #define IDECD_SEEK_THRESHOLD (1000) /* 1000 blocks */
1251 #define IDECD_SEEK_TIMER (5 * WAIT_MIN_SLEEP) /* 100 ms */
1252 #define IDECD_SEEK_TIMEOUT (2 * WAIT_CMD) /* 20 sec */
1254 static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
1256 struct cdrom_info *info = drive->driver_data;
1257 int stat;
1258 static int retry = 10;
1260 if (cdrom_decode_status(drive, 0, &stat))
1261 return ide_stopped;
1262 CDROM_CONFIG_FLAGS(drive)->seeking = 1;
1264 if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
1265 if (--retry == 0) {
1267 * this condition is far too common, to bother
1268 * users about it
1270 /* printk("%s: disabled DSC seek overlap\n", drive->name);*/
1271 drive->dsc_overlap = 0;
1274 return ide_stopped;
1277 static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
1279 struct request *rq = HWGROUP(drive)->rq;
1280 sector_t frame = rq->sector;
1282 sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
1284 memset(rq->cmd, 0, sizeof(rq->cmd));
1285 rq->cmd[0] = GPCMD_SEEK;
1286 put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
1288 rq->timeout = ATAPI_WAIT_PC;
1289 return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
1292 static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
1294 struct cdrom_info *info = drive->driver_data;
1296 info->dma = 0;
1297 info->cmd = 0;
1298 info->start_seek = jiffies;
1299 return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
1302 /* Fix up a possibly partially-processed request so that we can
1303 start it over entirely, or even put it back on the request queue. */
1304 static void restore_request (struct request *rq)
1306 if (rq->buffer != bio_data(rq->bio)) {
1307 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
1309 rq->buffer = bio_data(rq->bio);
1310 rq->nr_sectors += n;
1311 rq->sector -= n;
1313 rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
1314 rq->hard_nr_sectors = rq->nr_sectors;
1315 rq->hard_sector = rq->sector;
1316 rq->q->prep_rq_fn(rq->q, rq);
1320 * Start a read request from the CD-ROM.
1322 static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block)
1324 struct cdrom_info *info = drive->driver_data;
1325 struct request *rq = HWGROUP(drive)->rq;
1326 unsigned short sectors_per_frame;
1328 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1330 /* We may be retrying this request after an error. Fix up
1331 any weirdness which might be present in the request packet. */
1332 restore_request(rq);
1334 /* Satisfy whatever we can of this request from our cached sector. */
1335 if (cdrom_read_from_buffer(drive))
1336 return ide_stopped;
1338 blk_attempt_remerge(drive->queue, rq);
1340 /* Clear the local sector buffer. */
1341 info->nsectors_buffered = 0;
1343 /* use dma, if possible. */
1344 info->dma = drive->using_dma;
1345 if ((rq->sector & (sectors_per_frame - 1)) ||
1346 (rq->nr_sectors & (sectors_per_frame - 1)))
1347 info->dma = 0;
1349 info->cmd = READ;
1351 /* Start sending the read request to the drive. */
1352 return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
1355 /****************************************************************************
1356 * Execute all other packet commands.
1359 /* Interrupt routine for packet command completion. */
1360 static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
1362 int ireason, len, thislen;
1363 struct request *rq = HWGROUP(drive)->rq;
1364 u8 lowcyl = 0, highcyl = 0;
1365 int stat;
1367 /* Check for errors. */
1368 if (cdrom_decode_status(drive, 0, &stat))
1369 return ide_stopped;
1371 /* Read the interrupt reason and the transfer length. */
1372 ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1373 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1374 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1376 len = lowcyl + (256 * highcyl);
1378 /* If DRQ is clear, the command has completed.
1379 Complain if we still have data left to transfer. */
1380 if ((stat & DRQ_STAT) == 0) {
1381 /* Some of the trailing request sense fields are optional, and
1382 some drives don't send them. Sigh. */
1383 if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
1384 rq->data_len > 0 &&
1385 rq->data_len <= 5) {
1386 while (rq->data_len > 0) {
1387 *(unsigned char *)rq->data++ = 0;
1388 --rq->data_len;
1392 if (rq->data_len == 0)
1393 cdrom_end_request(drive, 1);
1394 else {
1395 /* Comment this out, because this always happens
1396 right after a reset occurs, and it is annoying to
1397 always print expected stuff. */
1399 printk ("%s: cdrom_pc_intr: data underrun %d\n",
1400 drive->name, pc->buflen);
1402 rq->flags |= REQ_FAILED;
1403 cdrom_end_request(drive, 0);
1405 return ide_stopped;
1408 /* Figure out how much data to transfer. */
1409 thislen = rq->data_len;
1410 if (thislen > len) thislen = len;
1412 /* The drive wants to be written to. */
1413 if ((ireason & 3) == 0) {
1414 if (!rq->data) {
1415 blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1416 goto confused;
1418 /* Transfer the data. */
1419 HWIF(drive)->atapi_output_bytes(drive, rq->data, thislen);
1421 /* If we haven't moved enough data to satisfy the drive,
1422 add some padding. */
1423 while (len > thislen) {
1424 int dum = 0;
1425 HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof(dum));
1426 len -= sizeof(dum);
1429 /* Keep count of how much data we've moved. */
1430 rq->data += thislen;
1431 rq->data_len -= thislen;
1434 /* Same drill for reading. */
1435 else if ((ireason & 3) == 2) {
1436 if (!rq->data) {
1437 blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1438 goto confused;
1440 /* Transfer the data. */
1441 HWIF(drive)->atapi_input_bytes(drive, rq->data, thislen);
1443 /* If we haven't moved enough data to satisfy the drive,
1444 add some padding. */
1445 while (len > thislen) {
1446 int dum = 0;
1447 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1448 len -= sizeof(dum);
1451 /* Keep count of how much data we've moved. */
1452 rq->data += thislen;
1453 rq->data_len -= thislen;
1455 if (rq->flags & REQ_SENSE)
1456 rq->sense_len += thislen;
1457 } else {
1458 confused:
1459 printk (KERN_ERR "%s: cdrom_pc_intr: The drive "
1460 "appears confused (ireason = 0x%02x)\n",
1461 drive->name, ireason);
1462 rq->flags |= REQ_FAILED;
1465 /* Now we wait for another interrupt. */
1466 ide_set_handler(drive, &cdrom_pc_intr, ATAPI_WAIT_PC, cdrom_timer_expiry);
1467 return ide_started;
1470 static ide_startstop_t cdrom_do_pc_continuation (ide_drive_t *drive)
1472 struct request *rq = HWGROUP(drive)->rq;
1474 if (!rq->timeout)
1475 rq->timeout = ATAPI_WAIT_PC;
1477 /* Send the command to the drive and return. */
1478 return cdrom_transfer_packet_command(drive, rq, &cdrom_pc_intr);
1482 static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
1484 int len;
1485 struct request *rq = HWGROUP(drive)->rq;
1486 struct cdrom_info *info = drive->driver_data;
1488 info->dma = 0;
1489 info->cmd = 0;
1490 rq->flags &= ~REQ_FAILED;
1491 len = rq->data_len;
1493 /* Start sending the command to the drive. */
1494 return cdrom_start_packet_command(drive, len, cdrom_do_pc_continuation);
1498 static
1499 int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
1501 struct request_sense sense;
1502 int retries = 10;
1503 unsigned int flags = rq->flags;
1505 if (rq->sense == NULL)
1506 rq->sense = &sense;
1508 /* Start of retry loop. */
1509 do {
1510 int error;
1511 unsigned long time = jiffies;
1512 rq->flags = flags;
1514 error = ide_do_drive_cmd(drive, rq, ide_wait);
1515 time = jiffies - time;
1517 /* FIXME: we should probably abort/retry or something
1518 * in case of failure */
1519 if (rq->flags & REQ_FAILED) {
1520 /* The request failed. Retry if it was due to a unit
1521 attention status
1522 (usually means media was changed). */
1523 struct request_sense *reqbuf = rq->sense;
1525 if (reqbuf->sense_key == UNIT_ATTENTION)
1526 cdrom_saw_media_change(drive);
1527 else if (reqbuf->sense_key == NOT_READY &&
1528 reqbuf->asc == 4 && reqbuf->ascq != 4) {
1529 /* The drive is in the process of loading
1530 a disk. Retry, but wait a little to give
1531 the drive time to complete the load. */
1532 ssleep(2);
1533 } else {
1534 /* Otherwise, don't retry. */
1535 retries = 0;
1537 --retries;
1540 /* End of retry loop. */
1541 } while ((rq->flags & REQ_FAILED) && retries >= 0);
1543 /* Return an error if the command failed. */
1544 return (rq->flags & REQ_FAILED) ? -EIO : 0;
1548 * Write handling
1550 static inline int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
1552 /* Two notes about IDE interrupt reason here - 0 means that
1553 * the drive wants to receive data from us, 2 means that
1554 * the drive is expecting to transfer data to us.
1556 if (ireason == 0)
1557 return 0;
1558 else if (ireason == 2) {
1559 /* Whoops... The drive wants to send data. */
1560 printk(KERN_ERR "%s: write_intr: wrong transfer direction!\n",
1561 drive->name);
1563 while (len > 0) {
1564 int dum = 0;
1565 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1566 len -= sizeof(dum);
1568 } else {
1569 /* Drive wants a command packet, or invalid ireason... */
1570 printk(KERN_ERR "%s: write_intr: bad interrupt reason %x\n",
1571 drive->name, ireason);
1574 cdrom_end_request(drive, 0);
1575 return 1;
1578 static void post_transform_command(struct request *req)
1580 u8 *c = req->cmd;
1581 char *ibuf;
1583 if (!blk_pc_request(req))
1584 return;
1586 if (req->bio)
1587 ibuf = bio_data(req->bio);
1588 else
1589 ibuf = req->data;
1591 if (!ibuf)
1592 return;
1595 * set ansi-revision and response data as atapi
1597 if (c[0] == GPCMD_INQUIRY) {
1598 ibuf[2] |= 2;
1599 ibuf[3] = (ibuf[3] & 0xf0) | 2;
1603 typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
1606 * best way to deal with dma that is not sector aligned right now... note
1607 * that in this path we are not using ->data or ->buffer at all. this irs
1608 * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the
1609 * future.
1611 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1613 struct cdrom_info *info = drive->driver_data;
1614 struct request *rq = HWGROUP(drive)->rq;
1615 int dma_error, dma, stat, ireason, len, thislen;
1616 u8 lowcyl, highcyl;
1617 xfer_func_t *xferfunc;
1618 unsigned long flags;
1620 /* Check for errors. */
1621 dma_error = 0;
1622 dma = info->dma;
1623 if (dma) {
1624 info->dma = 0;
1625 dma_error = HWIF(drive)->ide_dma_end(drive);
1628 if (cdrom_decode_status(drive, 0, &stat))
1629 return ide_stopped;
1632 * using dma, transfer is complete now
1634 if (dma) {
1635 if (dma_error) {
1636 printk(KERN_ERR "ide-cd: dma error\n");
1637 __ide_dma_off(drive);
1638 return ide_error(drive, "dma error", stat);
1641 end_that_request_chunk(rq, 1, rq->data_len);
1642 rq->data_len = 0;
1643 goto end_request;
1647 * ok we fall to pio :/
1649 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1650 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1651 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1653 len = lowcyl + (256 * highcyl);
1654 thislen = rq->data_len;
1655 if (thislen > len)
1656 thislen = len;
1659 * If DRQ is clear, the command has completed.
1661 if ((stat & DRQ_STAT) == 0)
1662 goto end_request;
1665 * check which way to transfer data
1667 if (rq_data_dir(rq) == WRITE) {
1669 * write to drive
1671 if (cdrom_write_check_ireason(drive, len, ireason))
1672 return ide_stopped;
1674 xferfunc = HWIF(drive)->atapi_output_bytes;
1675 } else {
1677 * read from drive
1679 if (cdrom_read_check_ireason(drive, len, ireason))
1680 return ide_stopped;
1682 xferfunc = HWIF(drive)->atapi_input_bytes;
1686 * transfer data
1688 while (thislen > 0) {
1689 int blen = blen = rq->data_len;
1690 char *ptr = rq->data;
1693 * bio backed?
1695 if (rq->bio) {
1696 ptr = bio_data(rq->bio);
1697 blen = bio_iovec(rq->bio)->bv_len;
1700 if (!ptr) {
1701 printk(KERN_ERR "%s: confused, missing data\n", drive->name);
1702 break;
1705 if (blen > thislen)
1706 blen = thislen;
1708 xferfunc(drive, ptr, blen);
1710 thislen -= blen;
1711 len -= blen;
1712 rq->data_len -= blen;
1714 if (rq->bio)
1715 end_that_request_chunk(rq, 1, blen);
1716 else
1717 rq->data += blen;
1721 * pad, if necessary
1723 if (len > 0) {
1724 while (len > 0) {
1725 int pad = 0;
1727 xferfunc(drive, &pad, sizeof(pad));
1728 len -= sizeof(pad);
1732 if (HWGROUP(drive)->handler != NULL)
1733 BUG();
1735 ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, NULL);
1736 return ide_started;
1738 end_request:
1739 if (!rq->data_len)
1740 post_transform_command(rq);
1742 spin_lock_irqsave(&ide_lock, flags);
1743 blkdev_dequeue_request(rq);
1744 end_that_request_last(rq);
1745 HWGROUP(drive)->rq = NULL;
1746 spin_unlock_irqrestore(&ide_lock, flags);
1747 return ide_stopped;
1750 static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
1752 int stat, ireason, len, sectors_to_transfer, uptodate;
1753 struct cdrom_info *info = drive->driver_data;
1754 int dma_error = 0, dma = info->dma;
1755 u8 lowcyl = 0, highcyl = 0;
1757 struct request *rq = HWGROUP(drive)->rq;
1759 /* Check for errors. */
1760 if (dma) {
1761 info->dma = 0;
1762 if ((dma_error = HWIF(drive)->ide_dma_end(drive))) {
1763 printk(KERN_ERR "ide-cd: write dma error\n");
1764 __ide_dma_off(drive);
1768 if (cdrom_decode_status(drive, 0, &stat))
1769 return ide_stopped;
1772 * using dma, transfer is complete now
1774 if (dma) {
1775 if (dma_error)
1776 return ide_error(drive, "dma error", stat);
1778 ide_end_request(drive, 1, rq->nr_sectors);
1779 return ide_stopped;
1782 /* Read the interrupt reason and the transfer length. */
1783 ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1784 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1785 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1787 len = lowcyl + (256 * highcyl);
1789 /* If DRQ is clear, the command has completed. */
1790 if ((stat & DRQ_STAT) == 0) {
1791 /* If we're not done writing, complain.
1792 * Otherwise, complete the command normally.
1794 uptodate = 1;
1795 if (rq->current_nr_sectors > 0) {
1796 printk(KERN_ERR "%s: write_intr: data underrun (%d blocks)\n",
1797 drive->name, rq->current_nr_sectors);
1798 uptodate = 0;
1800 cdrom_end_request(drive, uptodate);
1801 return ide_stopped;
1804 /* Check that the drive is expecting to do the same thing we are. */
1805 if (cdrom_write_check_ireason(drive, len, ireason))
1806 return ide_stopped;
1808 sectors_to_transfer = len / SECTOR_SIZE;
1811 * now loop and write out the data
1813 while (sectors_to_transfer > 0) {
1814 int this_transfer;
1816 if (!rq->current_nr_sectors) {
1817 printk(KERN_ERR "ide-cd: write_intr: oops\n");
1818 break;
1822 * Figure out how many sectors we can transfer
1824 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors);
1826 while (this_transfer > 0) {
1827 HWIF(drive)->atapi_output_bytes(drive, rq->buffer, SECTOR_SIZE);
1828 rq->buffer += SECTOR_SIZE;
1829 --rq->nr_sectors;
1830 --rq->current_nr_sectors;
1831 ++rq->sector;
1832 --this_transfer;
1833 --sectors_to_transfer;
1837 * current buffer complete, move on
1839 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1840 cdrom_end_request(drive, 1);
1843 /* re-arm handler */
1844 ide_set_handler(drive, &cdrom_write_intr, ATAPI_WAIT_PC, NULL);
1845 return ide_started;
1848 static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
1850 struct request *rq = HWGROUP(drive)->rq;
1852 #if 0 /* the immediate bit */
1853 rq->cmd[1] = 1 << 3;
1854 #endif
1855 rq->timeout = ATAPI_WAIT_PC;
1857 return cdrom_transfer_packet_command(drive, rq, cdrom_write_intr);
1860 static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
1862 struct cdrom_info *info = drive->driver_data;
1863 struct gendisk *g = info->disk;
1864 unsigned short sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1867 * writes *must* be hardware frame aligned
1869 if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1870 (rq->sector & (sectors_per_frame - 1))) {
1871 cdrom_end_request(drive, 0);
1872 return ide_stopped;
1876 * disk has become write protected
1878 if (g->policy) {
1879 cdrom_end_request(drive, 0);
1880 return ide_stopped;
1884 * for dvd-ram and such media, it's a really big deal to get
1885 * big writes all the time. so scour the queue and attempt to
1886 * remerge requests, often the plugging will not have had time
1887 * to do this properly
1889 blk_attempt_remerge(drive->queue, rq);
1891 info->nsectors_buffered = 0;
1893 /* use dma, if possible. we don't need to check more, since we
1894 * know that the transfer is always (at least!) frame aligned */
1895 info->dma = drive->using_dma ? 1 : 0;
1896 info->cmd = WRITE;
1898 info->devinfo.media_written = 1;
1900 /* Start sending the write request to the drive. */
1901 return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
1904 static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1906 struct request *rq = HWGROUP(drive)->rq;
1908 if (!rq->timeout)
1909 rq->timeout = ATAPI_WAIT_PC;
1911 return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1914 static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1916 struct cdrom_info *info = drive->driver_data;
1918 rq->flags |= REQ_QUIET;
1920 info->dma = 0;
1921 info->cmd = 0;
1924 * sg request
1926 if (rq->bio) {
1927 int mask = drive->queue->dma_alignment;
1928 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
1930 info->cmd = rq_data_dir(rq);
1931 info->dma = drive->using_dma;
1934 * check if dma is safe
1936 * NOTE! The "len" and "addr" checks should possibly have
1937 * separate masks.
1939 if ((rq->data_len & mask) || (addr & mask))
1940 info->dma = 0;
1943 /* Start sending the command to the drive. */
1944 return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1947 /****************************************************************************
1948 * cdrom driver request routine.
1950 static ide_startstop_t
1951 ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1953 ide_startstop_t action;
1954 struct cdrom_info *info = drive->driver_data;
1956 if (blk_fs_request(rq)) {
1957 if (CDROM_CONFIG_FLAGS(drive)->seeking) {
1958 unsigned long elapsed = jiffies - info->start_seek;
1959 int stat = HWIF(drive)->INB(IDE_STATUS_REG);
1961 if ((stat & SEEK_STAT) != SEEK_STAT) {
1962 if (elapsed < IDECD_SEEK_TIMEOUT) {
1963 ide_stall_queue(drive, IDECD_SEEK_TIMER);
1964 return ide_stopped;
1966 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
1968 CDROM_CONFIG_FLAGS(drive)->seeking = 0;
1970 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
1971 action = cdrom_start_seek(drive, block);
1972 } else {
1973 if (rq_data_dir(rq) == READ)
1974 action = cdrom_start_read(drive, block);
1975 else
1976 action = cdrom_start_write(drive, rq);
1978 info->last_block = block;
1979 return action;
1980 } else if (rq->flags & (REQ_PC | REQ_SENSE)) {
1981 return cdrom_do_packet_command(drive);
1982 } else if (rq->flags & REQ_BLOCK_PC) {
1983 return cdrom_do_block_pc(drive, rq);
1984 } else if (rq->flags & REQ_SPECIAL) {
1986 * right now this can only be a reset...
1988 cdrom_end_request(drive, 1);
1989 return ide_stopped;
1992 blk_dump_rq_flags(rq, "ide-cd bad flags");
1993 cdrom_end_request(drive, 0);
1994 return ide_stopped;
1999 /****************************************************************************
2000 * Ioctl handling.
2002 * Routines which queue packet commands take as a final argument a pointer
2003 * to a request_sense struct. If execution of the command results
2004 * in an error with a CHECK CONDITION status, this structure will be filled
2005 * with the results of the subsequent request sense command. The pointer
2006 * can also be NULL, in which case no sense information is returned.
2009 #if ! STANDARD_ATAPI
2010 static inline
2011 int bin2bcd (int x)
2013 return (x%10) | ((x/10) << 4);
2017 static inline
2018 int bcd2bin (int x)
2020 return (x >> 4) * 10 + (x & 0x0f);
2023 static
2024 void msf_from_bcd (struct atapi_msf *msf)
2026 msf->minute = bcd2bin (msf->minute);
2027 msf->second = bcd2bin (msf->second);
2028 msf->frame = bcd2bin (msf->frame);
2031 #endif /* not STANDARD_ATAPI */
2034 static inline
2035 void lba_to_msf (int lba, byte *m, byte *s, byte *f)
2037 lba += CD_MSF_OFFSET;
2038 lba &= 0xffffff; /* negative lbas use only 24 bits */
2039 *m = lba / (CD_SECS * CD_FRAMES);
2040 lba %= (CD_SECS * CD_FRAMES);
2041 *s = lba / CD_FRAMES;
2042 *f = lba % CD_FRAMES;
2046 static inline
2047 int msf_to_lba (byte m, byte s, byte f)
2049 return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
2052 static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
2054 struct request req;
2055 struct cdrom_info *info = drive->driver_data;
2056 struct cdrom_device_info *cdi = &info->devinfo;
2058 cdrom_prepare_request(drive, &req);
2060 req.sense = sense;
2061 req.cmd[0] = GPCMD_TEST_UNIT_READY;
2062 req.flags |= REQ_QUIET;
2064 #if ! STANDARD_ATAPI
2065 /* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
2066 switch CDs instead of supporting the LOAD_UNLOAD opcode */
2068 req.cmd[7] = cdi->sanyo_slot % 3;
2069 #endif /* not STANDARD_ATAPI */
2071 return cdrom_queue_packet_command(drive, &req);
2075 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
2076 static int
2077 cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
2079 struct request_sense my_sense;
2080 struct request req;
2081 int stat;
2083 if (sense == NULL)
2084 sense = &my_sense;
2086 /* If the drive cannot lock the door, just pretend. */
2087 if (CDROM_CONFIG_FLAGS(drive)->no_doorlock) {
2088 stat = 0;
2089 } else {
2090 cdrom_prepare_request(drive, &req);
2091 req.sense = sense;
2092 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
2093 req.cmd[4] = lockflag ? 1 : 0;
2094 stat = cdrom_queue_packet_command(drive, &req);
2097 /* If we got an illegal field error, the drive
2098 probably cannot lock the door. */
2099 if (stat != 0 &&
2100 sense->sense_key == ILLEGAL_REQUEST &&
2101 (sense->asc == 0x24 || sense->asc == 0x20)) {
2102 printk (KERN_ERR "%s: door locking not supported\n",
2103 drive->name);
2104 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2105 stat = 0;
2108 /* no medium, that's alright. */
2109 if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
2110 stat = 0;
2112 if (stat == 0)
2113 CDROM_STATE_FLAGS(drive)->door_locked = lockflag;
2115 return stat;
2119 /* Eject the disk if EJECTFLAG is 0.
2120 If EJECTFLAG is 1, try to reload the disk. */
2121 static int cdrom_eject(ide_drive_t *drive, int ejectflag,
2122 struct request_sense *sense)
2124 struct request req;
2125 char loej = 0x02;
2127 if (CDROM_CONFIG_FLAGS(drive)->no_eject && !ejectflag)
2128 return -EDRIVE_CANT_DO_THIS;
2130 /* reload fails on some drives, if the tray is locked */
2131 if (CDROM_STATE_FLAGS(drive)->door_locked && ejectflag)
2132 return 0;
2134 cdrom_prepare_request(drive, &req);
2136 /* only tell drive to close tray if open, if it can do that */
2137 if (ejectflag && !CDROM_CONFIG_FLAGS(drive)->close_tray)
2138 loej = 0;
2140 req.sense = sense;
2141 req.cmd[0] = GPCMD_START_STOP_UNIT;
2142 req.cmd[4] = loej | (ejectflag != 0);
2143 return cdrom_queue_packet_command(drive, &req);
2146 static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
2147 unsigned long *sectors_per_frame,
2148 struct request_sense *sense)
2150 struct {
2151 __u32 lba;
2152 __u32 blocklen;
2153 } capbuf;
2155 int stat;
2156 struct request req;
2158 cdrom_prepare_request(drive, &req);
2160 req.sense = sense;
2161 req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
2162 req.data = (char *)&capbuf;
2163 req.data_len = sizeof(capbuf);
2165 stat = cdrom_queue_packet_command(drive, &req);
2166 if (stat == 0) {
2167 *capacity = 1 + be32_to_cpu(capbuf.lba);
2168 *sectors_per_frame =
2169 be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
2172 return stat;
2175 static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
2176 int format, char *buf, int buflen,
2177 struct request_sense *sense)
2179 struct request req;
2181 cdrom_prepare_request(drive, &req);
2183 req.sense = sense;
2184 req.data = buf;
2185 req.data_len = buflen;
2186 req.flags |= REQ_QUIET;
2187 req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
2188 req.cmd[6] = trackno;
2189 req.cmd[7] = (buflen >> 8);
2190 req.cmd[8] = (buflen & 0xff);
2191 req.cmd[9] = (format << 6);
2193 if (msf_flag)
2194 req.cmd[1] = 2;
2196 return cdrom_queue_packet_command(drive, &req);
2200 /* Try to read the entire TOC for the disk into our internal buffer. */
2201 static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2203 int stat, ntracks, i;
2204 struct cdrom_info *info = drive->driver_data;
2205 struct cdrom_device_info *cdi = &info->devinfo;
2206 struct atapi_toc *toc = info->toc;
2207 struct {
2208 struct atapi_toc_header hdr;
2209 struct atapi_toc_entry ent;
2210 } ms_tmp;
2211 long last_written;
2212 unsigned long sectors_per_frame = SECTORS_PER_FRAME;
2214 if (toc == NULL) {
2215 /* Try to allocate space. */
2216 toc = (struct atapi_toc *) kmalloc (sizeof (struct atapi_toc),
2217 GFP_KERNEL);
2218 info->toc = toc;
2219 if (toc == NULL) {
2220 printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
2221 return -ENOMEM;
2225 /* Check to see if the existing data is still valid.
2226 If it is, just return. */
2227 (void) cdrom_check_status(drive, sense);
2229 if (CDROM_STATE_FLAGS(drive)->toc_valid)
2230 return 0;
2232 /* Try to get the total cdrom capacity and sector size. */
2233 stat = cdrom_read_capacity(drive, &toc->capacity, &sectors_per_frame,
2234 sense);
2235 if (stat)
2236 toc->capacity = 0x1fffff;
2238 set_capacity(info->disk, toc->capacity * sectors_per_frame);
2239 blk_queue_hardsect_size(drive->queue,
2240 sectors_per_frame << SECTOR_BITS);
2242 /* First read just the header, so we know how long the TOC is. */
2243 stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
2244 sizeof(struct atapi_toc_header), sense);
2245 if (stat) return stat;
2247 #if ! STANDARD_ATAPI
2248 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2249 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2250 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2252 #endif /* not STANDARD_ATAPI */
2254 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2255 if (ntracks <= 0)
2256 return -EIO;
2257 if (ntracks > MAX_TRACKS)
2258 ntracks = MAX_TRACKS;
2260 /* Now read the whole schmeer. */
2261 stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
2262 (char *)&toc->hdr,
2263 sizeof(struct atapi_toc_header) +
2264 (ntracks + 1) *
2265 sizeof(struct atapi_toc_entry), sense);
2267 if (stat && toc->hdr.first_track > 1) {
2268 /* Cds with CDI tracks only don't have any TOC entries,
2269 despite of this the returned values are
2270 first_track == last_track = number of CDI tracks + 1,
2271 so that this case is indistinguishable from the same
2272 layout plus an additional audio track.
2273 If we get an error for the regular case, we assume
2274 a CDI without additional audio tracks. In this case
2275 the readable TOC is empty (CDI tracks are not included)
2276 and only holds the Leadout entry. Heiko Eißfeldt */
2277 ntracks = 0;
2278 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
2279 (char *)&toc->hdr,
2280 sizeof(struct atapi_toc_header) +
2281 (ntracks + 1) *
2282 sizeof(struct atapi_toc_entry),
2283 sense);
2284 if (stat) {
2285 return stat;
2287 #if ! STANDARD_ATAPI
2288 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2289 toc->hdr.first_track = bin2bcd(CDROM_LEADOUT);
2290 toc->hdr.last_track = bin2bcd(CDROM_LEADOUT);
2291 } else
2292 #endif /* not STANDARD_ATAPI */
2294 toc->hdr.first_track = CDROM_LEADOUT;
2295 toc->hdr.last_track = CDROM_LEADOUT;
2299 if (stat)
2300 return stat;
2302 toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
2304 #if ! STANDARD_ATAPI
2305 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2306 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2307 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2309 #endif /* not STANDARD_ATAPI */
2311 for (i=0; i<=ntracks; i++) {
2312 #if ! STANDARD_ATAPI
2313 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2314 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd)
2315 toc->ent[i].track = bcd2bin(toc->ent[i].track);
2316 msf_from_bcd(&toc->ent[i].addr.msf);
2318 #endif /* not STANDARD_ATAPI */
2319 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
2320 toc->ent[i].addr.msf.second,
2321 toc->ent[i].addr.msf.frame);
2324 /* Read the multisession information. */
2325 if (toc->hdr.first_track != CDROM_LEADOUT) {
2326 /* Read the multisession information. */
2327 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
2328 sizeof(ms_tmp), sense);
2329 if (stat) return stat;
2331 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
2332 } else {
2333 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
2334 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
2337 #if ! STANDARD_ATAPI
2338 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2339 /* Re-read multisession information using MSF format */
2340 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
2341 sizeof(ms_tmp), sense);
2342 if (stat)
2343 return stat;
2345 msf_from_bcd (&ms_tmp.ent.addr.msf);
2346 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
2347 ms_tmp.ent.addr.msf.second,
2348 ms_tmp.ent.addr.msf.frame);
2350 #endif /* not STANDARD_ATAPI */
2352 toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
2354 /* Now try to get the total cdrom capacity. */
2355 stat = cdrom_get_last_written(cdi, &last_written);
2356 if (!stat && (last_written > toc->capacity)) {
2357 toc->capacity = last_written;
2358 set_capacity(info->disk, toc->capacity * sectors_per_frame);
2361 /* Remember that we've read this stuff. */
2362 CDROM_STATE_FLAGS(drive)->toc_valid = 1;
2364 return 0;
2368 static int cdrom_read_subchannel(ide_drive_t *drive, int format, char *buf,
2369 int buflen, struct request_sense *sense)
2371 struct request req;
2373 cdrom_prepare_request(drive, &req);
2375 req.sense = sense;
2376 req.data = buf;
2377 req.data_len = buflen;
2378 req.cmd[0] = GPCMD_READ_SUBCHANNEL;
2379 req.cmd[1] = 2; /* MSF addressing */
2380 req.cmd[2] = 0x40; /* request subQ data */
2381 req.cmd[3] = format;
2382 req.cmd[7] = (buflen >> 8);
2383 req.cmd[8] = (buflen & 0xff);
2384 return cdrom_queue_packet_command(drive, &req);
2387 /* ATAPI cdrom drives are free to select the speed you request or any slower
2388 rate :-( Requesting too fast a speed will _not_ produce an error. */
2389 static int cdrom_select_speed(ide_drive_t *drive, int speed,
2390 struct request_sense *sense)
2392 struct request req;
2393 cdrom_prepare_request(drive, &req);
2395 req.sense = sense;
2396 if (speed == 0)
2397 speed = 0xffff; /* set to max */
2398 else
2399 speed *= 177; /* Nx to kbytes/s */
2401 req.cmd[0] = GPCMD_SET_SPEED;
2402 /* Read Drive speed in kbytes/second MSB */
2403 req.cmd[2] = (speed >> 8) & 0xff;
2404 /* Read Drive speed in kbytes/second LSB */
2405 req.cmd[3] = speed & 0xff;
2406 if (CDROM_CONFIG_FLAGS(drive)->cd_r ||
2407 CDROM_CONFIG_FLAGS(drive)->cd_rw ||
2408 CDROM_CONFIG_FLAGS(drive)->dvd_r) {
2409 /* Write Drive speed in kbytes/second MSB */
2410 req.cmd[4] = (speed >> 8) & 0xff;
2411 /* Write Drive speed in kbytes/second LSB */
2412 req.cmd[5] = speed & 0xff;
2415 return cdrom_queue_packet_command(drive, &req);
2418 static int cdrom_play_audio(ide_drive_t *drive, int lba_start, int lba_end)
2420 struct request_sense sense;
2421 struct request req;
2423 cdrom_prepare_request(drive, &req);
2425 req.sense = &sense;
2426 req.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2427 lba_to_msf(lba_start, &req.cmd[3], &req.cmd[4], &req.cmd[5]);
2428 lba_to_msf(lba_end-1, &req.cmd[6], &req.cmd[7], &req.cmd[8]);
2430 return cdrom_queue_packet_command(drive, &req);
2433 static int cdrom_get_toc_entry(ide_drive_t *drive, int track,
2434 struct atapi_toc_entry **ent)
2436 struct cdrom_info *info = drive->driver_data;
2437 struct atapi_toc *toc = info->toc;
2438 int ntracks;
2441 * don't serve cached data, if the toc isn't valid
2443 if (!CDROM_STATE_FLAGS(drive)->toc_valid)
2444 return -EINVAL;
2446 /* Check validity of requested track number. */
2447 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2448 if (toc->hdr.first_track == CDROM_LEADOUT) ntracks = 0;
2449 if (track == CDROM_LEADOUT)
2450 *ent = &toc->ent[ntracks];
2451 else if (track < toc->hdr.first_track ||
2452 track > toc->hdr.last_track)
2453 return -EINVAL;
2454 else
2455 *ent = &toc->ent[track - toc->hdr.first_track];
2457 return 0;
2460 /* the generic packet interface to cdrom.c */
2461 static int ide_cdrom_packet(struct cdrom_device_info *cdi,
2462 struct packet_command *cgc)
2464 struct request req;
2465 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2467 if (cgc->timeout <= 0)
2468 cgc->timeout = ATAPI_WAIT_PC;
2470 /* here we queue the commands from the uniform CD-ROM
2471 layer. the packet must be complete, as we do not
2472 touch it at all. */
2473 cdrom_prepare_request(drive, &req);
2474 memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
2475 if (cgc->sense)
2476 memset(cgc->sense, 0, sizeof(struct request_sense));
2477 req.data = cgc->buffer;
2478 req.data_len = cgc->buflen;
2479 req.timeout = cgc->timeout;
2481 if (cgc->quiet)
2482 req.flags |= REQ_QUIET;
2484 req.sense = cgc->sense;
2485 cgc->stat = cdrom_queue_packet_command(drive, &req);
2486 if (!cgc->stat)
2487 cgc->buflen -= req.data_len;
2488 return cgc->stat;
2491 static
2492 int ide_cdrom_dev_ioctl (struct cdrom_device_info *cdi,
2493 unsigned int cmd, unsigned long arg)
2495 struct packet_command cgc;
2496 char buffer[16];
2497 int stat;
2499 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2501 /* These will be moved into the Uniform layer shortly... */
2502 switch (cmd) {
2503 case CDROMSETSPINDOWN: {
2504 char spindown;
2506 if (copy_from_user(&spindown, (void __user *) arg, sizeof(char)))
2507 return -EFAULT;
2509 if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0)))
2510 return stat;
2512 buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
2514 return cdrom_mode_select(cdi, &cgc);
2517 case CDROMGETSPINDOWN: {
2518 char spindown;
2520 if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0)))
2521 return stat;
2523 spindown = buffer[11] & 0x0f;
2525 if (copy_to_user((void __user *) arg, &spindown, sizeof (char)))
2526 return -EFAULT;
2528 return 0;
2531 default:
2532 return -EINVAL;
2537 static
2538 int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
2539 unsigned int cmd, void *arg)
2542 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2543 struct cdrom_info *info = drive->driver_data;
2544 int stat;
2546 switch (cmd) {
2548 * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
2549 * atapi doesn't support it
2551 case CDROMPLAYTRKIND: {
2552 unsigned long lba_start, lba_end;
2553 struct cdrom_ti *ti = (struct cdrom_ti *)arg;
2554 struct atapi_toc_entry *first_toc, *last_toc;
2556 stat = cdrom_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
2557 if (stat)
2558 return stat;
2560 stat = cdrom_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
2561 if (stat)
2562 return stat;
2564 if (ti->cdti_trk1 != CDROM_LEADOUT)
2565 ++last_toc;
2566 lba_start = first_toc->addr.lba;
2567 lba_end = last_toc->addr.lba;
2569 if (lba_end <= lba_start)
2570 return -EINVAL;
2572 return cdrom_play_audio(drive, lba_start, lba_end);
2575 case CDROMREADTOCHDR: {
2576 struct cdrom_tochdr *tochdr = (struct cdrom_tochdr *) arg;
2577 struct atapi_toc *toc;
2579 /* Make sure our saved TOC is valid. */
2580 stat = cdrom_read_toc(drive, NULL);
2581 if (stat) return stat;
2583 toc = info->toc;
2584 tochdr->cdth_trk0 = toc->hdr.first_track;
2585 tochdr->cdth_trk1 = toc->hdr.last_track;
2587 return 0;
2590 case CDROMREADTOCENTRY: {
2591 struct cdrom_tocentry *tocentry = (struct cdrom_tocentry*) arg;
2592 struct atapi_toc_entry *toce;
2594 stat = cdrom_get_toc_entry(drive, tocentry->cdte_track, &toce);
2595 if (stat) return stat;
2597 tocentry->cdte_ctrl = toce->control;
2598 tocentry->cdte_adr = toce->adr;
2599 if (tocentry->cdte_format == CDROM_MSF) {
2600 lba_to_msf (toce->addr.lba,
2601 &tocentry->cdte_addr.msf.minute,
2602 &tocentry->cdte_addr.msf.second,
2603 &tocentry->cdte_addr.msf.frame);
2604 } else
2605 tocentry->cdte_addr.lba = toce->addr.lba;
2607 return 0;
2610 default:
2611 return -EINVAL;
2615 static
2616 int ide_cdrom_reset (struct cdrom_device_info *cdi)
2618 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2619 struct request_sense sense;
2620 struct request req;
2621 int ret;
2623 cdrom_prepare_request(drive, &req);
2624 req.flags = REQ_SPECIAL | REQ_QUIET;
2625 ret = ide_do_drive_cmd(drive, &req, ide_wait);
2628 * A reset will unlock the door. If it was previously locked,
2629 * lock it again.
2631 if (CDROM_STATE_FLAGS(drive)->door_locked)
2632 (void) cdrom_lockdoor(drive, 1, &sense);
2634 return ret;
2638 static
2639 int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
2641 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2642 struct request_sense sense;
2644 if (position) {
2645 int stat = cdrom_lockdoor(drive, 0, &sense);
2646 if (stat) return stat;
2649 return cdrom_eject(drive, !position, &sense);
2652 static
2653 int ide_cdrom_lock_door (struct cdrom_device_info *cdi, int lock)
2655 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2656 return cdrom_lockdoor(drive, lock, NULL);
2659 static
2660 int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
2662 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2663 struct request_sense sense;
2664 int stat;
2666 if ((stat = cdrom_select_speed(drive, speed, &sense)) < 0)
2667 return stat;
2669 cdi->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2670 return 0;
2674 * add logic to try GET_EVENT command first to check for media and tray
2675 * status. this should be supported by newer cd-r/w and all DVD etc
2676 * drives
2678 static
2679 int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
2681 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2682 struct media_event_desc med;
2683 struct request_sense sense;
2684 int stat;
2686 if (slot_nr != CDSL_CURRENT)
2687 return -EINVAL;
2689 stat = cdrom_check_status(drive, &sense);
2690 if (!stat || sense.sense_key == UNIT_ATTENTION)
2691 return CDS_DISC_OK;
2693 if (!cdrom_get_media_event(cdi, &med)) {
2694 if (med.media_present)
2695 return CDS_DISC_OK;
2696 else if (med.door_open)
2697 return CDS_TRAY_OPEN;
2698 else
2699 return CDS_NO_DISC;
2702 if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
2703 return CDS_DISC_OK;
2706 * If not using Mt Fuji extended media tray reports,
2707 * just return TRAY_OPEN since ATAPI doesn't provide
2708 * any other way to detect this...
2710 if (sense.sense_key == NOT_READY) {
2711 if (sense.asc == 0x3a) {
2712 if (sense.ascq == 1)
2713 return CDS_NO_DISC;
2714 else if (sense.ascq == 0 || sense.ascq == 2)
2715 return CDS_TRAY_OPEN;
2719 return CDS_DRIVE_NOT_READY;
2722 static
2723 int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
2724 struct cdrom_multisession *ms_info)
2726 struct atapi_toc *toc;
2727 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2728 struct cdrom_info *info = drive->driver_data;
2729 struct request_sense sense;
2730 int ret;
2732 if (!CDROM_STATE_FLAGS(drive)->toc_valid || info->toc == NULL)
2733 if ((ret = cdrom_read_toc(drive, &sense)))
2734 return ret;
2736 toc = info->toc;
2737 ms_info->addr.lba = toc->last_session_lba;
2738 ms_info->xa_flag = toc->xa_flag;
2740 return 0;
2743 static
2744 int ide_cdrom_get_mcn (struct cdrom_device_info *cdi,
2745 struct cdrom_mcn *mcn_info)
2747 int stat;
2748 char mcnbuf[24];
2749 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2751 /* get MCN */
2752 if ((stat = cdrom_read_subchannel(drive, 2, mcnbuf, sizeof (mcnbuf), NULL)))
2753 return stat;
2755 memcpy (mcn_info->medium_catalog_number, mcnbuf+9,
2756 sizeof (mcn_info->medium_catalog_number)-1);
2757 mcn_info->medium_catalog_number[sizeof (mcn_info->medium_catalog_number)-1]
2758 = '\0';
2760 return 0;
2765 /****************************************************************************
2766 * Other driver requests (open, close, check media change).
2769 static
2770 int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
2771 int slot_nr)
2773 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2774 int retval;
2776 if (slot_nr == CDSL_CURRENT) {
2777 (void) cdrom_check_status(drive, NULL);
2778 retval = CDROM_STATE_FLAGS(drive)->media_changed;
2779 CDROM_STATE_FLAGS(drive)->media_changed = 0;
2780 return retval;
2781 } else {
2782 return -EINVAL;
2787 static
2788 int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
2790 return 0;
2794 * Close down the device. Invalidate all cached blocks.
2797 static
2798 void ide_cdrom_release_real (struct cdrom_device_info *cdi)
2800 ide_drive_t *drive = cdi->handle;
2802 if (!cdi->use_count)
2803 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
2808 /****************************************************************************
2809 * Device initialization.
2811 static struct cdrom_device_ops ide_cdrom_dops = {
2812 .open = ide_cdrom_open_real,
2813 .release = ide_cdrom_release_real,
2814 .drive_status = ide_cdrom_drive_status,
2815 .media_changed = ide_cdrom_check_media_change_real,
2816 .tray_move = ide_cdrom_tray_move,
2817 .lock_door = ide_cdrom_lock_door,
2818 .select_speed = ide_cdrom_select_speed,
2819 .get_last_session = ide_cdrom_get_last_session,
2820 .get_mcn = ide_cdrom_get_mcn,
2821 .reset = ide_cdrom_reset,
2822 .audio_ioctl = ide_cdrom_audio_ioctl,
2823 .dev_ioctl = ide_cdrom_dev_ioctl,
2824 .capability = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
2825 CDC_SELECT_SPEED | CDC_SELECT_DISC |
2826 CDC_MULTI_SESSION | CDC_MCN |
2827 CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO | CDC_RESET |
2828 CDC_IOCTLS | CDC_DRIVE_STATUS | CDC_CD_R |
2829 CDC_CD_RW | CDC_DVD | CDC_DVD_R| CDC_DVD_RAM |
2830 CDC_GENERIC_PACKET | CDC_MO_DRIVE | CDC_MRW |
2831 CDC_MRW_W | CDC_RAM,
2832 .generic_packet = ide_cdrom_packet,
2835 static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2837 struct cdrom_info *info = drive->driver_data;
2838 struct cdrom_device_info *devinfo = &info->devinfo;
2840 devinfo->ops = &ide_cdrom_dops;
2841 devinfo->mask = 0;
2842 devinfo->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2843 devinfo->capacity = nslots;
2844 devinfo->handle = (void *) drive;
2845 strcpy(devinfo->name, drive->name);
2847 /* set capability mask to match the probe. */
2848 if (!CDROM_CONFIG_FLAGS(drive)->cd_r)
2849 devinfo->mask |= CDC_CD_R;
2850 if (!CDROM_CONFIG_FLAGS(drive)->cd_rw)
2851 devinfo->mask |= CDC_CD_RW;
2852 if (!CDROM_CONFIG_FLAGS(drive)->dvd)
2853 devinfo->mask |= CDC_DVD;
2854 if (!CDROM_CONFIG_FLAGS(drive)->dvd_r)
2855 devinfo->mask |= CDC_DVD_R;
2856 if (!CDROM_CONFIG_FLAGS(drive)->dvd_ram)
2857 devinfo->mask |= CDC_DVD_RAM;
2858 if (!CDROM_CONFIG_FLAGS(drive)->is_changer)
2859 devinfo->mask |= CDC_SELECT_DISC;
2860 if (!CDROM_CONFIG_FLAGS(drive)->audio_play)
2861 devinfo->mask |= CDC_PLAY_AUDIO;
2862 if (!CDROM_CONFIG_FLAGS(drive)->close_tray)
2863 devinfo->mask |= CDC_CLOSE_TRAY;
2864 if (!CDROM_CONFIG_FLAGS(drive)->mo_drive)
2865 devinfo->mask |= CDC_MO_DRIVE;
2867 devinfo->disk = info->disk;
2868 return register_cdrom(devinfo);
2871 static
2872 int ide_cdrom_get_capabilities(ide_drive_t *drive, struct atapi_capabilities_page *cap)
2874 struct cdrom_info *info = drive->driver_data;
2875 struct cdrom_device_info *cdi = &info->devinfo;
2876 struct packet_command cgc;
2877 int stat, attempts = 3, size = sizeof(*cap);
2880 * ACER50 (and others?) require the full spec length mode sense
2881 * page capabilities size, but older drives break.
2883 if (!(!strcmp(drive->id->model, "ATAPI CD ROM DRIVE 50X MAX") ||
2884 !strcmp(drive->id->model, "WPI CDS-32X")))
2885 size -= sizeof(cap->pad);
2887 init_cdrom_command(&cgc, cap, size, CGC_DATA_UNKNOWN);
2888 do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2889 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
2890 if (!stat)
2891 break;
2892 } while (--attempts);
2893 return stat;
2896 static
2897 int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2899 struct cdrom_info *info = drive->driver_data;
2900 struct cdrom_device_info *cdi = &info->devinfo;
2901 struct atapi_capabilities_page cap;
2902 int nslots = 1;
2904 if (drive->media == ide_optical) {
2905 CDROM_CONFIG_FLAGS(drive)->mo_drive = 1;
2906 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2907 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
2908 return nslots;
2911 if (CDROM_CONFIG_FLAGS(drive)->nec260 ||
2912 !strcmp(drive->id->model,"STINGRAY 8422 IDE 8X CD-ROM 7-27-95")) {
2913 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2914 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2915 return nslots;
2919 * we have to cheat a little here. the packet will eventually
2920 * be queued with ide_cdrom_packet(), which extracts the
2921 * drive from cdi->handle. Since this device hasn't been
2922 * registered with the Uniform layer yet, it can't do this.
2923 * Same goes for cdi->ops.
2925 cdi->handle = (ide_drive_t *) drive;
2926 cdi->ops = &ide_cdrom_dops;
2928 if (ide_cdrom_get_capabilities(drive, &cap))
2929 return 0;
2931 if (cap.lock == 0)
2932 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2933 if (cap.eject)
2934 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2935 if (cap.cd_r_write)
2936 CDROM_CONFIG_FLAGS(drive)->cd_r = 1;
2937 if (cap.cd_rw_write) {
2938 CDROM_CONFIG_FLAGS(drive)->cd_rw = 1;
2939 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2941 if (cap.test_write)
2942 CDROM_CONFIG_FLAGS(drive)->test_write = 1;
2943 if (cap.dvd_ram_read || cap.dvd_r_read || cap.dvd_rom)
2944 CDROM_CONFIG_FLAGS(drive)->dvd = 1;
2945 if (cap.dvd_ram_write) {
2946 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 1;
2947 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2949 if (cap.dvd_r_write)
2950 CDROM_CONFIG_FLAGS(drive)->dvd_r = 1;
2951 if (cap.audio_play)
2952 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2953 if (cap.mechtype == mechtype_caddy || cap.mechtype == mechtype_popup)
2954 CDROM_CONFIG_FLAGS(drive)->close_tray = 0;
2956 /* Some drives used by Apple don't advertise audio play
2957 * but they do support reading TOC & audio datas
2959 if (strcmp(drive->id->model, "MATSHITADVD-ROM SR-8187") == 0 ||
2960 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8186") == 0 ||
2961 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8176") == 0 ||
2962 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8174") == 0)
2963 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2965 #if ! STANDARD_ATAPI
2966 if (cdi->sanyo_slot > 0) {
2967 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
2968 nslots = 3;
2971 else
2972 #endif /* not STANDARD_ATAPI */
2973 if (cap.mechtype == mechtype_individual_changer ||
2974 cap.mechtype == mechtype_cartridge_changer) {
2975 if ((nslots = cdrom_number_of_slots(cdi)) > 1) {
2976 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
2977 CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 1;
2981 /* The ACER/AOpen 24X cdrom has the speed fields byte-swapped */
2982 if (!drive->id->model[0] &&
2983 !strncmp(drive->id->fw_rev, "241N", 4)) {
2984 CDROM_STATE_FLAGS(drive)->current_speed =
2985 (((unsigned int)cap.curspeed) + (176/2)) / 176;
2986 CDROM_CONFIG_FLAGS(drive)->max_speed =
2987 (((unsigned int)cap.maxspeed) + (176/2)) / 176;
2988 } else {
2989 CDROM_STATE_FLAGS(drive)->current_speed =
2990 (ntohs(cap.curspeed) + (176/2)) / 176;
2991 CDROM_CONFIG_FLAGS(drive)->max_speed =
2992 (ntohs(cap.maxspeed) + (176/2)) / 176;
2995 /* don't print speed if the drive reported 0.
2997 printk(KERN_INFO "%s: ATAPI", drive->name);
2998 if (CDROM_CONFIG_FLAGS(drive)->max_speed)
2999 printk(" %dX", CDROM_CONFIG_FLAGS(drive)->max_speed);
3000 printk(" %s", CDROM_CONFIG_FLAGS(drive)->dvd ? "DVD-ROM" : "CD-ROM");
3002 if (CDROM_CONFIG_FLAGS(drive)->dvd_r|CDROM_CONFIG_FLAGS(drive)->dvd_ram)
3003 printk(" DVD%s%s",
3004 (CDROM_CONFIG_FLAGS(drive)->dvd_r)? "-R" : "",
3005 (CDROM_CONFIG_FLAGS(drive)->dvd_ram)? "-RAM" : "");
3007 if (CDROM_CONFIG_FLAGS(drive)->cd_r|CDROM_CONFIG_FLAGS(drive)->cd_rw)
3008 printk(" CD%s%s",
3009 (CDROM_CONFIG_FLAGS(drive)->cd_r)? "-R" : "",
3010 (CDROM_CONFIG_FLAGS(drive)->cd_rw)? "/RW" : "");
3012 if (CDROM_CONFIG_FLAGS(drive)->is_changer)
3013 printk(" changer w/%d slots", nslots);
3014 else
3015 printk(" drive");
3017 printk(", %dkB Cache", be16_to_cpu(cap.buffer_size));
3019 if (drive->using_dma)
3020 ide_dma_verbose(drive);
3022 printk("\n");
3024 return nslots;
3027 static void ide_cdrom_add_settings(ide_drive_t *drive)
3029 ide_add_setting(drive, "dsc_overlap", SETTING_RW, -1, -1, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
3033 * standard prep_rq_fn that builds 10 byte cmds
3035 static int ide_cdrom_prep_fs(request_queue_t *q, struct request *rq)
3037 int hard_sect = queue_hardsect_size(q);
3038 long block = (long)rq->hard_sector / (hard_sect >> 9);
3039 unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
3041 memset(rq->cmd, 0, sizeof(rq->cmd));
3043 if (rq_data_dir(rq) == READ)
3044 rq->cmd[0] = GPCMD_READ_10;
3045 else
3046 rq->cmd[0] = GPCMD_WRITE_10;
3049 * fill in lba
3051 rq->cmd[2] = (block >> 24) & 0xff;
3052 rq->cmd[3] = (block >> 16) & 0xff;
3053 rq->cmd[4] = (block >> 8) & 0xff;
3054 rq->cmd[5] = block & 0xff;
3057 * and transfer length
3059 rq->cmd[7] = (blocks >> 8) & 0xff;
3060 rq->cmd[8] = blocks & 0xff;
3061 rq->cmd_len = 10;
3062 return BLKPREP_OK;
3066 * Most of the SCSI commands are supported directly by ATAPI devices.
3067 * This transform handles the few exceptions.
3069 static int ide_cdrom_prep_pc(struct request *rq)
3071 u8 *c = rq->cmd;
3074 * Transform 6-byte read/write commands to the 10-byte version
3076 if (c[0] == READ_6 || c[0] == WRITE_6) {
3077 c[8] = c[4];
3078 c[5] = c[3];
3079 c[4] = c[2];
3080 c[3] = c[1] & 0x1f;
3081 c[2] = 0;
3082 c[1] &= 0xe0;
3083 c[0] += (READ_10 - READ_6);
3084 rq->cmd_len = 10;
3085 return BLKPREP_OK;
3089 * it's silly to pretend we understand 6-byte sense commands, just
3090 * reject with ILLEGAL_REQUEST and the caller should take the
3091 * appropriate action
3093 if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
3094 rq->errors = ILLEGAL_REQUEST;
3095 return BLKPREP_KILL;
3098 return BLKPREP_OK;
3101 static int ide_cdrom_prep_fn(request_queue_t *q, struct request *rq)
3103 if (rq->flags & REQ_CMD)
3104 return ide_cdrom_prep_fs(q, rq);
3105 else if (rq->flags & REQ_BLOCK_PC)
3106 return ide_cdrom_prep_pc(rq);
3108 return 0;
3111 static
3112 int ide_cdrom_setup (ide_drive_t *drive)
3114 struct cdrom_info *info = drive->driver_data;
3115 struct cdrom_device_info *cdi = &info->devinfo;
3116 int nslots;
3118 blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
3119 blk_queue_dma_alignment(drive->queue, 31);
3120 drive->queue->unplug_delay = (1 * HZ) / 1000;
3121 if (!drive->queue->unplug_delay)
3122 drive->queue->unplug_delay = 1;
3124 drive->special.all = 0;
3126 CDROM_STATE_FLAGS(drive)->media_changed = 1;
3127 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
3128 CDROM_STATE_FLAGS(drive)->door_locked = 0;
3130 #if NO_DOOR_LOCKING
3131 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
3132 #else
3133 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 0;
3134 #endif
3136 CDROM_CONFIG_FLAGS(drive)->drq_interrupt = ((drive->id->config & 0x0060) == 0x20);
3137 CDROM_CONFIG_FLAGS(drive)->is_changer = 0;
3138 CDROM_CONFIG_FLAGS(drive)->cd_r = 0;
3139 CDROM_CONFIG_FLAGS(drive)->cd_rw = 0;
3140 CDROM_CONFIG_FLAGS(drive)->test_write = 0;
3141 CDROM_CONFIG_FLAGS(drive)->dvd = 0;
3142 CDROM_CONFIG_FLAGS(drive)->dvd_r = 0;
3143 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 0;
3144 CDROM_CONFIG_FLAGS(drive)->no_eject = 1;
3145 CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 0;
3146 CDROM_CONFIG_FLAGS(drive)->audio_play = 0;
3147 CDROM_CONFIG_FLAGS(drive)->close_tray = 1;
3149 /* limit transfer size per interrupt. */
3150 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 0;
3151 /* a testament to the nice quality of Samsung drives... */
3152 if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2430"))
3153 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3154 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2432"))
3155 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3156 /* the 3231 model does not support the SET_CD_SPEED command */
3157 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-3231"))
3158 cdi->mask |= CDC_SELECT_SPEED;
3160 #if ! STANDARD_ATAPI
3161 /* by default Sanyo 3 CD changer support is turned off and
3162 ATAPI Rev 2.2+ standard support for CD changers is used */
3163 cdi->sanyo_slot = 0;
3165 CDROM_CONFIG_FLAGS(drive)->nec260 = 0;
3166 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 0;
3167 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 0;
3168 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 0;
3169 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 0;
3171 if (strcmp (drive->id->model, "V003S0DS") == 0 &&
3172 drive->id->fw_rev[4] == '1' &&
3173 drive->id->fw_rev[6] <= '2') {
3174 /* Vertos 300.
3175 Some versions of this drive like to talk BCD. */
3176 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3177 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3178 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3179 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3182 else if (strcmp (drive->id->model, "V006E0DS") == 0 &&
3183 drive->id->fw_rev[4] == '1' &&
3184 drive->id->fw_rev[6] <= '2') {
3185 /* Vertos 600 ESD. */
3186 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3188 else if (strcmp(drive->id->model, "NEC CD-ROM DRIVE:260") == 0 &&
3189 strncmp(drive->id->fw_rev, "1.01", 4) == 0) { /* FIXME */
3190 /* Old NEC260 (not R).
3191 This drive was released before the 1.2 version
3192 of the spec. */
3193 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3194 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3195 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3196 CDROM_CONFIG_FLAGS(drive)->nec260 = 1;
3198 else if (strcmp(drive->id->model, "WEARNES CDD-120") == 0 &&
3199 strncmp(drive->id->fw_rev, "A1.1", 4) == 0) { /* FIXME */
3200 /* Wearnes */
3201 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3202 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3204 /* Sanyo 3 CD changer uses a non-standard command
3205 for CD changing */
3206 else if ((strcmp(drive->id->model, "CD-ROM CDR-C3 G") == 0) ||
3207 (strcmp(drive->id->model, "CD-ROM CDR-C3G") == 0) ||
3208 (strcmp(drive->id->model, "CD-ROM CDR_C36") == 0)) {
3209 /* uses CD in slot 0 when value is set to 3 */
3210 cdi->sanyo_slot = 3;
3212 #endif /* not STANDARD_ATAPI */
3214 info->toc = NULL;
3215 info->buffer = NULL;
3216 info->sector_buffered = 0;
3217 info->nsectors_buffered = 0;
3218 info->changer_info = NULL;
3219 info->last_block = 0;
3220 info->start_seek = 0;
3222 nslots = ide_cdrom_probe_capabilities (drive);
3225 * set correct block size
3227 blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
3229 if (drive->autotune == IDE_TUNE_DEFAULT ||
3230 drive->autotune == IDE_TUNE_AUTO)
3231 drive->dsc_overlap = (drive->next != drive);
3232 #if 0
3233 drive->dsc_overlap = (HWIF(drive)->no_dsc) ? 0 : 1;
3234 if (HWIF(drive)->no_dsc) {
3235 printk(KERN_INFO "ide-cd: %s: disabling DSC overlap\n",
3236 drive->name);
3237 drive->dsc_overlap = 0;
3239 #endif
3241 if (ide_cdrom_register(drive, nslots)) {
3242 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
3243 info->devinfo.handle = NULL;
3244 return 1;
3246 ide_cdrom_add_settings(drive);
3247 return 0;
3250 static
3251 sector_t ide_cdrom_capacity (ide_drive_t *drive)
3253 unsigned long capacity, sectors_per_frame;
3255 if (cdrom_read_capacity(drive, &capacity, &sectors_per_frame, NULL))
3256 return 0;
3258 return capacity * sectors_per_frame;
3261 static int ide_cd_remove(struct device *dev)
3263 ide_drive_t *drive = to_ide_device(dev);
3264 struct cdrom_info *info = drive->driver_data;
3266 ide_unregister_subdriver(drive, info->driver);
3268 del_gendisk(info->disk);
3270 ide_cd_put(info);
3272 return 0;
3275 static void ide_cd_release(struct kref *kref)
3277 struct cdrom_info *info = to_ide_cd(kref);
3278 struct cdrom_device_info *devinfo = &info->devinfo;
3279 ide_drive_t *drive = info->drive;
3280 struct gendisk *g = info->disk;
3282 if (info->buffer != NULL)
3283 kfree(info->buffer);
3284 if (info->toc != NULL)
3285 kfree(info->toc);
3286 if (info->changer_info != NULL)
3287 kfree(info->changer_info);
3288 if (devinfo->handle == drive && unregister_cdrom(devinfo))
3289 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom "
3290 "driver.\n", __FUNCTION__, drive->name);
3291 drive->dsc_overlap = 0;
3292 drive->driver_data = NULL;
3293 blk_queue_prep_rq(drive->queue, NULL);
3294 g->private_data = NULL;
3295 put_disk(g);
3296 kfree(info);
3299 static int ide_cd_probe(struct device *);
3301 #ifdef CONFIG_PROC_FS
3302 static int proc_idecd_read_capacity
3303 (char *page, char **start, off_t off, int count, int *eof, void *data)
3305 ide_drive_t*drive = (ide_drive_t *)data;
3306 int len;
3308 len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
3309 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
3312 static ide_proc_entry_t idecd_proc[] = {
3313 { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
3314 { NULL, 0, NULL, NULL }
3316 #else
3317 # define idecd_proc NULL
3318 #endif
3320 static ide_driver_t ide_cdrom_driver = {
3321 .owner = THIS_MODULE,
3322 .gen_driver = {
3323 .name = "ide-cdrom",
3324 .bus = &ide_bus_type,
3325 .probe = ide_cd_probe,
3326 .remove = ide_cd_remove,
3328 .version = IDECD_VERSION,
3329 .media = ide_cdrom,
3330 .supports_dsc_overlap = 1,
3331 .do_request = ide_do_rw_cdrom,
3332 .end_request = ide_end_request,
3333 .error = __ide_error,
3334 .abort = __ide_abort,
3335 .proc = idecd_proc,
3338 static int idecd_open(struct inode * inode, struct file * file)
3340 struct gendisk *disk = inode->i_bdev->bd_disk;
3341 struct cdrom_info *info;
3342 ide_drive_t *drive;
3343 int rc = -ENOMEM;
3345 if (!(info = ide_cd_get(disk)))
3346 return -ENXIO;
3348 drive = info->drive;
3350 drive->usage++;
3352 if (!info->buffer)
3353 info->buffer = kmalloc(SECTOR_BUFFER_SIZE,
3354 GFP_KERNEL|__GFP_REPEAT);
3355 if (!info->buffer || (rc = cdrom_open(&info->devinfo, inode, file)))
3356 drive->usage--;
3358 if (rc < 0)
3359 ide_cd_put(info);
3361 return rc;
3364 static int idecd_release(struct inode * inode, struct file * file)
3366 struct gendisk *disk = inode->i_bdev->bd_disk;
3367 struct cdrom_info *info = ide_cd_g(disk);
3368 ide_drive_t *drive = info->drive;
3370 cdrom_release (&info->devinfo, file);
3371 drive->usage--;
3373 ide_cd_put(info);
3375 return 0;
3378 static int idecd_ioctl (struct inode *inode, struct file *file,
3379 unsigned int cmd, unsigned long arg)
3381 struct block_device *bdev = inode->i_bdev;
3382 struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
3383 int err;
3385 err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
3386 if (err == -EINVAL)
3387 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
3389 return err;
3392 static int idecd_media_changed(struct gendisk *disk)
3394 struct cdrom_info *info = ide_cd_g(disk);
3395 return cdrom_media_changed(&info->devinfo);
3398 static int idecd_revalidate_disk(struct gendisk *disk)
3400 struct cdrom_info *info = ide_cd_g(disk);
3401 struct request_sense sense;
3402 cdrom_read_toc(info->drive, &sense);
3403 return 0;
3406 static struct block_device_operations idecd_ops = {
3407 .owner = THIS_MODULE,
3408 .open = idecd_open,
3409 .release = idecd_release,
3410 .ioctl = idecd_ioctl,
3411 .media_changed = idecd_media_changed,
3412 .revalidate_disk= idecd_revalidate_disk
3415 /* options */
3416 static char *ignore = NULL;
3418 module_param(ignore, charp, 0400);
3419 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
3421 static int ide_cd_probe(struct device *dev)
3423 ide_drive_t *drive = to_ide_device(dev);
3424 struct cdrom_info *info;
3425 struct gendisk *g;
3426 struct request_sense sense;
3428 if (!strstr("ide-cdrom", drive->driver_req))
3429 goto failed;
3430 if (!drive->present)
3431 goto failed;
3432 if (drive->media != ide_cdrom && drive->media != ide_optical)
3433 goto failed;
3434 /* skip drives that we were told to ignore */
3435 if (ignore != NULL) {
3436 if (strstr(ignore, drive->name)) {
3437 printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
3438 goto failed;
3441 if (drive->scsi) {
3442 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
3443 goto failed;
3445 info = (struct cdrom_info *) kmalloc (sizeof (struct cdrom_info), GFP_KERNEL);
3446 if (info == NULL) {
3447 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
3448 goto failed;
3451 g = alloc_disk(1 << PARTN_BITS);
3452 if (!g)
3453 goto out_free_cd;
3455 ide_init_disk(g, drive);
3457 ide_register_subdriver(drive, &ide_cdrom_driver);
3459 memset(info, 0, sizeof (struct cdrom_info));
3461 kref_init(&info->kref);
3463 info->drive = drive;
3464 info->driver = &ide_cdrom_driver;
3465 info->disk = g;
3467 g->private_data = &info->driver;
3469 drive->driver_data = info;
3471 g->minors = 1;
3472 snprintf(g->devfs_name, sizeof(g->devfs_name),
3473 "%s/cd", drive->devfs_name);
3474 g->driverfs_dev = &drive->gendev;
3475 g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
3476 if (ide_cdrom_setup(drive)) {
3477 struct cdrom_device_info *devinfo = &info->devinfo;
3478 ide_unregister_subdriver(drive, &ide_cdrom_driver);
3479 if (info->buffer != NULL)
3480 kfree(info->buffer);
3481 if (info->toc != NULL)
3482 kfree(info->toc);
3483 if (info->changer_info != NULL)
3484 kfree(info->changer_info);
3485 if (devinfo->handle == drive && unregister_cdrom(devinfo))
3486 printk (KERN_ERR "%s: ide_cdrom_cleanup failed to unregister device from the cdrom driver.\n", drive->name);
3487 kfree(info);
3488 drive->driver_data = NULL;
3489 goto failed;
3492 cdrom_read_toc(drive, &sense);
3493 g->fops = &idecd_ops;
3494 g->flags |= GENHD_FL_REMOVABLE;
3495 add_disk(g);
3496 return 0;
3498 out_free_cd:
3499 kfree(info);
3500 failed:
3501 return -ENODEV;
3504 static void __exit ide_cdrom_exit(void)
3506 driver_unregister(&ide_cdrom_driver.gen_driver);
3509 static int ide_cdrom_init(void)
3511 return driver_register(&ide_cdrom_driver.gen_driver);
3514 module_init(ide_cdrom_init);
3515 module_exit(ide_cdrom_exit);
3516 MODULE_LICENSE("GPL");