2 * linux/drivers/ide/ide-cd.c
4 * Copyright (C) 1994, 1995, 1996 scott snyder <snyder@fnald0.fnal.gov>
5 * Copyright (C) 1996-1998 Erik Andersen <andersee@debian.org>
6 * Copyright (C) 1998-2000 Jens Axboe <axboe@suse.de>
8 * May be copied or modified under the terms of the GNU General Public
9 * License. See linux/COPYING for more information.
11 * ATAPI CD-ROM driver. To be used with ide.c.
12 * See Documentation/cdrom/ide-cd for usage information.
14 * Suggestions are welcome. Patches that work are more welcome though. ;-)
15 * For those wishing to work on this driver, please be sure you download
16 * and comply with the latest Mt. Fuji (SFF8090 version 4) and ATAPI
17 * (SFF-8020i rev 2.6) standards. These documents can be obtained by
19 * ftp://fission.dt.wdc.com/pub/standards/SFF_atapi/spec/SFF8020-r2.6/PS/8020r26.ps
20 * ftp://ftp.avc-pioneer.com/Mtfuji4/Spec/Fuji4r10.pdf
22 * Drives that deviate from these standards will be accommodated as much
23 * as possible via compile time or command-line options. Since I only have
24 * a few drives, you generally need to send me patches...
26 * ----------------------------------
28 * -Make it so that Pioneer CD DR-A24X and friends don't get screwed up on
31 * ----------------------------------
32 * 1.00 Oct 31, 1994 -- Initial version.
33 * 1.01 Nov 2, 1994 -- Fixed problem with starting request in
35 * 1.03 Nov 25, 1994 -- leaving unmask_intr[] as a user-setting (as for disks)
36 * (from mlord) -- minor changes to cdrom_setup()
37 * -- renamed ide_dev_s to ide_drive_t, enable irq on command
38 * 2.00 Nov 27, 1994 -- Generalize packet command interface;
40 * 2.01 Dec 3, 1994 -- Rework packet command interface to handle devices
41 * which send an interrupt when ready for a command.
42 * 2.02 Dec 11, 1994 -- Cache the TOC in the driver.
43 * Don't use SCMD_PLAYAUDIO_TI; it's not included
44 * in the current version of ATAPI.
45 * Try to use LBA instead of track or MSF addressing
47 * Don't wait for READY_STAT.
48 * 2.03 Jan 10, 1995 -- Rewrite block read routines to handle block sizes
49 * other than 2k and to move multiple sectors in a
51 * 2.04 Apr 21, 1995 -- Add work-around for Creative Labs CD220E drives.
52 * Thanks to Nick Saw <cwsaw@pts7.pts.mot.com> for
53 * help in figuring this out. Ditto for Acer and
54 * Aztech drives, which seem to have the same problem.
55 * 2.04b May 30, 1995 -- Fix to match changes in ide.c version 3.16 -ml
56 * 2.05 Jun 8, 1995 -- Don't attempt to retry after an illegal request
57 * or data protect error.
58 * Use HWIF and DEV_HWIF macros as in ide.c.
59 * Always try to do a request_sense after
61 * Include an option to give textual descriptions
63 * Fix a bug in handling the sector cache which
64 * showed up if the drive returned data in 512 byte
65 * blocks (like Pioneer drives). Thanks to
66 * Richard Hirst <srh@gpt.co.uk> for diagnosing this.
67 * Properly supply the page number field in the
68 * MODE_SELECT command.
69 * PLAYAUDIO12 is broken on the Aztech; work around it.
70 * 2.05x Aug 11, 1995 -- lots of data structure renaming/restructuring in ide.c
71 * (my apologies to Scott, but now ide-cd.c is independent)
72 * 3.00 Aug 22, 1995 -- Implement CDROMMULTISESSION ioctl.
73 * Implement CDROMREADAUDIO ioctl (UNTESTED).
74 * Use input_ide_data() and output_ide_data().
76 * Fix usage count leak in cdrom_open, which happened
77 * when a read-write mount was attempted.
78 * Try to load the disk on open.
79 * Implement CDROMEJECT_SW ioctl (off by default).
80 * Read total cdrom capacity during open.
81 * Rearrange logic in cdrom_decode_status. Issue
82 * request sense commands for failed packet commands
83 * from here instead of from cdrom_queue_packet_command.
84 * Fix a race condition in retrieving error information.
85 * Suppress printing normal unit attention errors and
86 * some drive not ready errors.
87 * Implement CDROMVOLREAD ioctl.
88 * Implement CDROMREADMODE1/2 ioctls.
89 * Fix race condition in setting up interrupt handlers
90 * when the `serialize' option is used.
91 * 3.01 Sep 2, 1995 -- Fix ordering of reenabling interrupts in
92 * cdrom_queue_request.
93 * Another try at using ide_[input,output]_data.
94 * 3.02 Sep 16, 1995 -- Stick total disk capacity in partition table as well.
95 * Make VERBOSE_IDE_CD_ERRORS dump failed command again.
96 * Dump out more information for ILLEGAL REQUEST errs.
97 * Fix handling of errors occurring before the
98 * packet command is transferred.
99 * Fix transfers with odd bytelengths.
100 * 3.03 Oct 27, 1995 -- Some Creative drives have an id of just `CD'.
101 * `DCI-2S10' drives are broken too.
102 * 3.04 Nov 20, 1995 -- So are Vertos drives.
103 * 3.05 Dec 1, 1995 -- Changes to go with overhaul of ide.c and ide-tape.c
104 * 3.06 Dec 16, 1995 -- Add support needed for partitions.
105 * More workarounds for Vertos bugs (based on patches
106 * from Holger Dietze <dietze@aix520.informatik.uni-leipzig.de>).
107 * Try to eliminate byteorder assumptions.
108 * Use atapi_cdrom_subchnl struct definition.
109 * Add STANDARD_ATAPI compilation option.
110 * 3.07 Jan 29, 1996 -- More twiddling for broken drives: Sony 55D,
112 * Add NO_DOOR_LOCKING configuration option.
113 * Handle drive_cmd requests w/NULL args (for hdparm -t).
114 * Work around sporadic Sony55e audio play problem.
115 * 3.07a Feb 11, 1996 -- check drive->id for NULL before dereferencing, to fix
116 * problem with "hde=cdrom" with no drive present. -ml
117 * 3.08 Mar 6, 1996 -- More Vertos workarounds.
118 * 3.09 Apr 5, 1996 -- Add CDROMCLOSETRAY ioctl.
119 * Switch to using MSF addressing for audio commands.
120 * Reformat to match kernel tabbing style.
121 * Add CDROM_GET_UPC ioctl.
122 * 3.10 Apr 10, 1996 -- Fix compilation error with STANDARD_ATAPI.
123 * 3.11 Apr 29, 1996 -- Patch from Heiko Eißfeldt <heiko@colossus.escape.de>
124 * to remove redundant verify_area calls.
125 * 3.12 May 7, 1996 -- Rudimentary changer support. Based on patches
126 * from Gerhard Zuber <zuber@berlin.snafu.de>.
127 * Let open succeed even if there's no loaded disc.
128 * 3.13 May 19, 1996 -- Fixes for changer code.
129 * 3.14 May 29, 1996 -- Add work-around for Vertos 600.
130 * (From Hennus Bergman <hennus@sky.ow.nl>.)
131 * 3.15 July 2, 1996 -- Added support for Sanyo 3 CD changers
132 * from Ben Galliart <bgallia@luc.edu> with
133 * special help from Jeff Lightfoot
135 * 3.15a July 9, 1996 -- Improved Sanyo 3 CD changer identification
136 * 3.16 Jul 28, 1996 -- Fix from Gadi to reduce kernel stack usage for ioctl.
137 * 3.17 Sep 17, 1996 -- Tweak audio reads for some drives.
138 * Start changing CDROMLOADFROMSLOT to CDROM_SELECT_DISC.
139 * 3.18 Oct 31, 1996 -- Added module and DMA support.
142 * 4.00 Nov 5, 1996 -- New ide-cd maintainer,
143 * Erik B. Andersen <andersee@debian.org>
144 * -- Newer Creative drives don't always set the error
145 * register correctly. Make sure we see media changes
147 * -- Integrate with generic cdrom driver.
148 * -- CDROMGETSPINDOWN and CDROMSETSPINDOWN ioctls, based on
149 * a patch from Ciro Cattuto <>.
150 * -- Call set_device_ro.
151 * -- Implement CDROMMECHANISMSTATUS and CDROMSLOTTABLE
152 * ioctls, based on patch by Erik Andersen
153 * -- Add some probes of drive capability during setup.
155 * 4.01 Nov 11, 1996 -- Split into ide-cd.c and ide-cd.h
156 * -- Removed CDROMMECHANISMSTATUS and CDROMSLOTTABLE
157 * ioctls in favor of a generalized approach
158 * using the generic cdrom driver.
159 * -- Fully integrated with the 2.1.X kernel.
160 * -- Other stuff that I forgot (lots of changes)
162 * 4.02 Dec 01, 1996 -- Applied patch from Gadi Oxman <gadio@netvision.net.il>
163 * to fix the drive door locking problems.
165 * 4.03 Dec 04, 1996 -- Added DSC overlap support.
166 * 4.04 Dec 29, 1996 -- Added CDROMREADRAW ioclt based on patch
167 * by Ales Makarov (xmakarov@sun.felk.cvut.cz)
169 * 4.05 Nov 20, 1997 -- Modified to print more drive info on init
170 * Minor other changes
171 * Fix errors on CDROMSTOP (If you have a "Dolphin",
172 * you must define IHAVEADOLPHIN)
173 * Added identifier so new Sanyo CD-changer works
174 * Better detection if door locking isn't supported
176 * 4.06 Dec 17, 1997 -- fixed endless "tray open" messages -ml
177 * 4.07 Dec 17, 1997 -- fallback to set pc->stat on "tray open"
178 * 4.08 Dec 18, 1997 -- spew less noise when tray is empty
179 * -- fix speed display for ACER 24X, 18X
180 * 4.09 Jan 04, 1998 -- fix handling of the last block so we return
181 * an end of file instead of an I/O error (Gadi)
182 * 4.10 Jan 24, 1998 -- fixed a bug so now changers can change to a new
183 * slot when there is no disc in the current slot.
184 * -- Fixed a memory leak where info->changer_info was
185 * malloc'ed but never free'd when closing the device.
186 * -- Cleaned up the global namespace a bit by making more
187 * functions static that should already have been.
188 * 4.11 Mar 12, 1998 -- Added support for the CDROM_SELECT_SPEED ioctl
189 * based on a patch for 2.0.33 by Jelle Foks
190 * <jelle@scintilla.utwente.nl>, a patch for 2.0.33
191 * by Toni Giorgino <toni@pcape2.pi.infn.it>, the SCSI
192 * version, and my own efforts. -erik
193 * -- Fixed a stupid bug which egcs was kind enough to
194 * inform me of where "Illegal mode for this track"
195 * was never returned due to a comparison on data
196 * types of limited range.
197 * 4.12 Mar 29, 1998 -- Fixed bug in CDROM_SELECT_SPEED so write speed is
198 * now set ionly for CD-R and CD-RW drives. I had
199 * removed this support because it produced errors.
200 * It produced errors _only_ for non-writers. duh.
201 * 4.13 May 05, 1998 -- Suppress useless "in progress of becoming ready"
202 * messages, since this is not an error.
203 * -- Change error messages to be const
204 * -- Remove a "\t" which looks ugly in the syslogs
205 * 4.14 July 17, 1998 -- Change to pointing to .ps version of ATAPI spec
206 * since the .pdf version doesn't seem to work...
207 * -- Updated the TODO list to something more current.
209 * 4.15 Aug 25, 1998 -- Updated ide-cd.h to respect mechine endianess,
210 * patch thanks to "Eddie C. Dost" <ecd@skynet.be>
212 * 4.50 Oct 19, 1998 -- New maintainers!
213 * Jens Axboe <axboe@image.dk>
214 * Chris Zwilling <chris@cloudnet.com>
216 * 4.51 Dec 23, 1998 -- Jens Axboe <axboe@image.dk>
217 * - ide_cdrom_reset enabled since the ide subsystem
218 * handles resets fine now. <axboe@image.dk>
219 * - Transfer size fix for Samsung CD-ROMs, thanks to
220 * "Ville Hallik" <ville.hallik@mail.ee>.
221 * - other minor stuff.
223 * 4.52 Jan 19, 1999 -- Jens Axboe <axboe@image.dk>
224 * - Detect DVD-ROM/RAM drives
226 * 4.53 Feb 22, 1999 - Include other model Samsung and one Goldstar
227 * drive in transfer size limit.
228 * - Fix the I/O error when doing eject without a medium
229 * loaded on some drives.
230 * - CDROMREADMODE2 is now implemented through
231 * CDROMREADRAW, since many drives don't support
232 * MODE2 (even though ATAPI 2.6 says they must).
233 * - Added ignore parameter to ide-cd (as a module), eg
234 * insmod ide-cd ignore='hda hdb'
235 * Useful when using ide-cd in conjunction with
236 * ide-scsi. TODO: non-modular way of doing the
239 * 4.54 Aug 5, 1999 - Support for MMC2 class commands through the generic
240 * packet interface to cdrom.c.
241 * - Unified audio ioctl support, most of it.
242 * - cleaned up various deprecated verify_area().
243 * - Added ide_cdrom_packet() as the interface for
244 * the Uniform generic_packet().
245 * - bunch of other stuff, will fill in logs later.
246 * - report 1 slot for non-changers, like the other
247 * cd-rom drivers. don't report select disc for
248 * non-changers as well.
249 * - mask out audio playing, if the device can't do it.
251 * 4.55 Sep 1, 1999 - Eliminated the rest of the audio ioctls, except
252 * for CDROMREADTOC[ENTRY|HEADER]. Some of the drivers
253 * use this independently of the actual audio handling.
254 * They will disappear later when I get the time to
256 * - Minimize the TOC reading - only do it when we
257 * know a media change has occurred.
258 * - Moved all the CDROMREADx ioctls to the Uniform layer.
259 * - Heiko Eißfeldt <heiko@colossus.escape.de> supplied
260 * some fixes for CDI.
261 * - CD-ROM leaving door locked fix from Andries
262 * Brouwer <Andries.Brouwer@cwi.nl>
263 * - Erik Andersen <andersen@xmission.com> unified
264 * commands across the various drivers and how
265 * sense errors are handled.
267 * 4.56 Sep 12, 1999 - Removed changer support - it is now in the
269 * - Added partition based multisession handling.
270 * - Mode sense and mode select moved to the
272 * - Fixed a problem with WPI CDS-32X drive - it
273 * failed the capabilities
275 * 4.57 Apr 7, 2000 - Fixed sense reporting.
276 * - Fixed possible oops in ide_cdrom_get_last_session()
277 * - Fix locking mania and make ide_cdrom_reset relock
278 * - Stop spewing errors to log when magicdev polls with
279 * TEST_UNIT_READY on some drives.
280 * - Various fixes from Tobias Ringstrom:
281 * tray if it was locked prior to the reset.
282 * - cdrom_read_capacity returns one frame too little.
283 * - Fix real capacity reporting.
285 * 4.58 May 1, 2000 - Clean up ACER50 stuff.
286 * - Fix small problem with ide_cdrom_capacity
288 * 4.59 Aug 11, 2000 - Fix changer problem in cdrom_read_toc, we weren't
289 * correctly sensing a disc change.
290 * - Rearranged some code
291 * - Use extended sense on drives that support it for
292 * correctly reporting tray status -- from
293 * Michael D Johnson <johnsom@orst.edu>
294 * 4.60 Dec 17, 2003 - Add mt rainier support
295 * - Bump timeout for packet commands, matches sr
297 * 4.61 Jan 22, 2004 - support hardware sector sizes other than 2kB,
298 * Pascal Schmidt <der.eremit@email.de>
300 *************************************************************************/
302 #define IDECD_VERSION "4.61"
304 #include <linux/module.h>
305 #include <linux/types.h>
306 #include <linux/kernel.h>
307 #include <linux/delay.h>
308 #include <linux/timer.h>
309 #include <linux/slab.h>
310 #include <linux/interrupt.h>
311 #include <linux/errno.h>
312 #include <linux/cdrom.h>
313 #include <linux/ide.h>
314 #include <linux/completion.h>
315 #include <linux/mutex.h>
317 #include <scsi/scsi.h> /* For SCSI -> ATAPI command conversion */
321 #include <asm/byteorder.h>
322 #include <asm/uaccess.h>
323 #include <asm/unaligned.h>
327 static DEFINE_MUTEX(idecd_ref_mutex
);
329 #define to_ide_cd(obj) container_of(obj, struct cdrom_info, kref)
331 #define ide_cd_g(disk) \
332 container_of((disk)->private_data, struct cdrom_info, driver)
334 static struct cdrom_info
*ide_cd_get(struct gendisk
*disk
)
336 struct cdrom_info
*cd
= NULL
;
338 mutex_lock(&idecd_ref_mutex
);
342 mutex_unlock(&idecd_ref_mutex
);
346 static void ide_cd_release(struct kref
*);
348 static void ide_cd_put(struct cdrom_info
*cd
)
350 mutex_lock(&idecd_ref_mutex
);
351 kref_put(&cd
->kref
, ide_cd_release
);
352 mutex_unlock(&idecd_ref_mutex
);
355 /****************************************************************************
356 * Generic packet command support and error handling routines.
359 /* Mark that we've seen a media change, and invalidate our internal
361 static void cdrom_saw_media_change (ide_drive_t
*drive
)
363 struct cdrom_info
*info
= drive
->driver_data
;
365 CDROM_STATE_FLAGS (drive
)->media_changed
= 1;
366 CDROM_STATE_FLAGS (drive
)->toc_valid
= 0;
367 info
->nsectors_buffered
= 0;
370 static int cdrom_log_sense(ide_drive_t
*drive
, struct request
*rq
,
371 struct request_sense
*sense
)
375 if (!sense
|| !rq
|| (rq
->cmd_flags
& REQ_QUIET
))
378 switch (sense
->sense_key
) {
379 case NO_SENSE
: case RECOVERED_ERROR
:
383 * don't care about tray state messages for
384 * e.g. capacity commands or in-progress or
387 if (sense
->asc
== 0x3a || sense
->asc
== 0x04)
391 case ILLEGAL_REQUEST
:
393 * don't log START_STOP unit with LoEj set, since
394 * we cannot reliably check if drive can auto-close
396 if (rq
->cmd
[0] == GPCMD_START_STOP_UNIT
&& sense
->asc
== 0x24)
402 * Make good and sure we've seen this potential media
403 * change. Some drives (i.e. Creative) fail to present
404 * the correct sense key in the error register.
406 cdrom_saw_media_change(drive
);
416 void cdrom_analyze_sense_data(ide_drive_t
*drive
,
417 struct request
*failed_command
,
418 struct request_sense
*sense
)
420 unsigned long sector
;
421 unsigned long bio_sectors
;
423 struct cdrom_info
*info
= drive
->driver_data
;
425 if (!cdrom_log_sense(drive
, failed_command
, sense
))
429 * If a read toc is executed for a CD-R or CD-RW medium where
430 * the first toc has not been recorded yet, it will fail with
431 * 05/24/00 (which is a confusing error)
433 if (failed_command
&& failed_command
->cmd
[0] == GPCMD_READ_TOC_PMA_ATIP
)
434 if (sense
->sense_key
== 0x05 && sense
->asc
== 0x24)
437 if (sense
->error_code
== 0x70) { /* Current Error */
438 switch(sense
->sense_key
) {
440 case VOLUME_OVERFLOW
:
441 case ILLEGAL_REQUEST
:
444 if (failed_command
== NULL
||
445 !blk_fs_request(failed_command
))
447 sector
= (sense
->information
[0] << 24) |
448 (sense
->information
[1] << 16) |
449 (sense
->information
[2] << 8) |
450 (sense
->information
[3]);
452 bio_sectors
= bio_sectors(failed_command
->bio
);
455 if (drive
->queue
->hardsect_size
== 2048)
456 sector
<<= 2; /* Device sector size is 2K */
457 sector
&= ~(bio_sectors
-1);
458 valid
= (sector
- failed_command
->sector
) << 9;
462 if (sector
< get_capacity(info
->disk
) &&
463 drive
->probed_capacity
- sector
< 4 * 75) {
464 set_capacity(info
->disk
, sector
);
468 #if VERBOSE_IDE_CD_ERRORS
471 const char *s
= "bad sense key!";
474 printk ("ATAPI device %s:\n", drive
->name
);
475 if (sense
->error_code
==0x70)
477 else if (sense
->error_code
==0x71)
478 printk(" Deferred Error: ");
479 else if (sense
->error_code
== 0x7f)
480 printk(" Vendor-specific Error: ");
482 printk(" Unknown Error Type: ");
484 if (sense
->sense_key
< ARRAY_SIZE(sense_key_texts
))
485 s
= sense_key_texts
[sense
->sense_key
];
487 printk("%s -- (Sense key=0x%02x)\n", s
, sense
->sense_key
);
489 if (sense
->asc
== 0x40) {
490 sprintf(buf
, "Diagnostic failure on component 0x%02x",
494 int lo
= 0, mid
, hi
= ARRAY_SIZE(sense_data_texts
);
495 unsigned long key
= (sense
->sense_key
<< 16);
496 key
|= (sense
->asc
<< 8);
497 if (!(sense
->ascq
>= 0x80 && sense
->ascq
<= 0xdd))
503 if (sense_data_texts
[mid
].asc_ascq
== key
||
504 sense_data_texts
[mid
].asc_ascq
== (0xff0000|key
)) {
505 s
= sense_data_texts
[mid
].text
;
508 else if (sense_data_texts
[mid
].asc_ascq
> key
)
516 if (sense
->asc
> 0x80)
517 s
= "(vendor-specific error)";
519 s
= "(reserved error code)";
522 printk(KERN_ERR
" %s -- (asc=0x%02x, ascq=0x%02x)\n",
523 s
, sense
->asc
, sense
->ascq
);
525 if (failed_command
!= NULL
) {
527 int lo
=0, mid
, hi
= ARRAY_SIZE(packet_command_texts
);
532 if (packet_command_texts
[mid
].packet_command
==
533 failed_command
->cmd
[0]) {
534 s
= packet_command_texts
[mid
].text
;
537 if (packet_command_texts
[mid
].packet_command
>
538 failed_command
->cmd
[0])
544 printk (KERN_ERR
" The failed \"%s\" packet command was: \n \"", s
);
545 for (i
=0; i
<sizeof (failed_command
->cmd
); i
++)
546 printk ("%02x ", failed_command
->cmd
[i
]);
550 /* The SKSV bit specifies validity of the sense_key_specific
551 * in the next two commands. It is bit 7 of the first byte.
552 * In the case of NOT_READY, if SKSV is set the drive can
553 * give us nice ETA readings.
555 if (sense
->sense_key
== NOT_READY
&& (sense
->sks
[0] & 0x80)) {
556 int progress
= (sense
->sks
[1] << 8 | sense
->sks
[2]) * 100;
557 printk(KERN_ERR
" Command is %02d%% complete\n", progress
/ 0xffff);
561 if (sense
->sense_key
== ILLEGAL_REQUEST
&&
562 (sense
->sks
[0] & 0x80) != 0) {
563 printk(KERN_ERR
" Error in %s byte %d",
564 (sense
->sks
[0] & 0x40) != 0 ?
565 "command packet" : "command data",
566 (sense
->sks
[1] << 8) + sense
->sks
[2]);
568 if ((sense
->sks
[0] & 0x40) != 0)
569 printk (" bit %d", sense
->sks
[0] & 0x07);
575 #else /* not VERBOSE_IDE_CD_ERRORS */
577 /* Suppress printing unit attention and `in progress of becoming ready'
578 errors when we're not being verbose. */
580 if (sense
->sense_key
== UNIT_ATTENTION
||
581 (sense
->sense_key
== NOT_READY
&& (sense
->asc
== 4 ||
582 sense
->asc
== 0x3a)))
585 printk(KERN_ERR
"%s: error code: 0x%02x sense_key: 0x%02x asc: 0x%02x ascq: 0x%02x\n",
587 sense
->error_code
, sense
->sense_key
,
588 sense
->asc
, sense
->ascq
);
589 #endif /* not VERBOSE_IDE_CD_ERRORS */
593 * Initialize a ide-cd packet command request
595 static void cdrom_prepare_request(ide_drive_t
*drive
, struct request
*rq
)
597 struct cdrom_info
*cd
= drive
->driver_data
;
599 ide_init_drive_cmd(rq
);
600 rq
->cmd_type
= REQ_TYPE_ATA_PC
;
601 rq
->rq_disk
= cd
->disk
;
604 static void cdrom_queue_request_sense(ide_drive_t
*drive
, void *sense
,
605 struct request
*failed_command
)
607 struct cdrom_info
*info
= drive
->driver_data
;
608 struct request
*rq
= &info
->request_sense_request
;
611 sense
= &info
->sense_data
;
613 /* stuff the sense request in front of our current request */
614 cdrom_prepare_request(drive
, rq
);
617 rq
->cmd
[0] = GPCMD_REQUEST_SENSE
;
618 rq
->cmd
[4] = rq
->data_len
= 18;
620 rq
->cmd_type
= REQ_TYPE_SENSE
;
622 /* NOTE! Save the failed command in "rq->buffer" */
623 rq
->buffer
= (void *) failed_command
;
625 (void) ide_do_drive_cmd(drive
, rq
, ide_preempt
);
628 static void cdrom_end_request (ide_drive_t
*drive
, int uptodate
)
630 struct request
*rq
= HWGROUP(drive
)->rq
;
631 int nsectors
= rq
->hard_cur_sectors
;
633 if (blk_sense_request(rq
) && uptodate
) {
635 * For REQ_TYPE_SENSE, "rq->buffer" points to the original
638 struct request
*failed
= (struct request
*) rq
->buffer
;
639 struct cdrom_info
*info
= drive
->driver_data
;
640 void *sense
= &info
->sense_data
;
645 sense
= failed
->sense
;
646 failed
->sense_len
= rq
->sense_len
;
648 cdrom_analyze_sense_data(drive
, failed
, sense
);
650 * now end failed request
652 if (blk_fs_request(failed
)) {
653 if (ide_end_dequeued_request(drive
, failed
, 0,
654 failed
->hard_nr_sectors
))
657 spin_lock_irqsave(&ide_lock
, flags
);
658 if (__blk_end_request(failed
, -EIO
,
661 spin_unlock_irqrestore(&ide_lock
, flags
);
664 cdrom_analyze_sense_data(drive
, NULL
, sense
);
667 if (!rq
->current_nr_sectors
&& blk_fs_request(rq
))
669 /* make sure it's fully ended */
670 if (blk_pc_request(rq
))
671 nsectors
= (rq
->data_len
+ 511) >> 9;
675 ide_end_request(drive
, uptodate
, nsectors
);
678 static void ide_dump_status_no_sense(ide_drive_t
*drive
, const char *msg
, u8 stat
)
682 ide_dump_status(drive
, msg
, stat
);
685 /* Returns 0 if the request should be continued.
686 Returns 1 if the request was ended. */
687 static int cdrom_decode_status(ide_drive_t
*drive
, int good_stat
, int *stat_ret
)
689 struct request
*rq
= HWGROUP(drive
)->rq
;
690 int stat
, err
, sense_key
;
692 /* Check for errors. */
693 stat
= HWIF(drive
)->INB(IDE_STATUS_REG
);
697 if (OK_STAT(stat
, good_stat
, BAD_R_STAT
))
700 /* Get the IDE error register. */
701 err
= HWIF(drive
)->INB(IDE_ERROR_REG
);
702 sense_key
= err
>> 4;
705 printk("%s: missing rq in cdrom_decode_status\n", drive
->name
);
709 if (blk_sense_request(rq
)) {
710 /* We got an error trying to get sense info
711 from the drive (probably while trying
712 to recover from a former error). Just give up. */
714 rq
->cmd_flags
|= REQ_FAILED
;
715 cdrom_end_request(drive
, 0);
716 ide_error(drive
, "request sense failure", stat
);
719 } else if (blk_pc_request(rq
) || rq
->cmd_type
== REQ_TYPE_ATA_PC
) {
720 /* All other functions, except for READ. */
724 * if we have an error, pass back CHECK_CONDITION as the
727 if (blk_pc_request(rq
) && !rq
->errors
)
728 rq
->errors
= SAM_STAT_CHECK_CONDITION
;
730 /* Check for tray open. */
731 if (sense_key
== NOT_READY
) {
732 cdrom_saw_media_change (drive
);
733 } else if (sense_key
== UNIT_ATTENTION
) {
734 /* Check for media change. */
735 cdrom_saw_media_change (drive
);
736 /*printk("%s: media changed\n",drive->name);*/
738 } else if ((sense_key
== ILLEGAL_REQUEST
) &&
739 (rq
->cmd
[0] == GPCMD_START_STOP_UNIT
)) {
741 * Don't print error message for this condition--
742 * SFF8090i indicates that 5/24/00 is the correct
743 * response to a request to close the tray if the
744 * drive doesn't have that capability.
745 * cdrom_log_sense() knows this!
747 } else if (!(rq
->cmd_flags
& REQ_QUIET
)) {
748 /* Otherwise, print an error. */
749 ide_dump_status(drive
, "packet command error", stat
);
752 rq
->cmd_flags
|= REQ_FAILED
;
755 * instead of playing games with moving completions around,
756 * remove failed request completely and end it when the
757 * request sense has completed
759 if (stat
& ERR_STAT
) {
760 spin_lock_irqsave(&ide_lock
, flags
);
761 blkdev_dequeue_request(rq
);
762 HWGROUP(drive
)->rq
= NULL
;
763 spin_unlock_irqrestore(&ide_lock
, flags
);
765 cdrom_queue_request_sense(drive
, rq
->sense
, rq
);
767 cdrom_end_request(drive
, 0);
769 } else if (blk_fs_request(rq
)) {
770 int do_end_request
= 0;
772 /* Handle errors from READ and WRITE requests. */
774 if (blk_noretry_request(rq
))
777 if (sense_key
== NOT_READY
) {
779 if (rq_data_dir(rq
) == READ
) {
780 cdrom_saw_media_change (drive
);
782 /* Fail the request. */
783 printk ("%s: tray open\n", drive
->name
);
786 struct cdrom_info
*info
= drive
->driver_data
;
788 /* allow the drive 5 seconds to recover, some
789 * devices will return this error while flushing
792 info
->write_timeout
= jiffies
+ ATAPI_WAIT_WRITE_BUSY
;
794 if (time_after(jiffies
, info
->write_timeout
))
800 * take a breather relying on the
801 * unplug timer to kick us again
803 spin_lock_irqsave(&ide_lock
, flags
);
804 blk_plug_device(drive
->queue
);
805 spin_unlock_irqrestore(&ide_lock
,flags
);
809 } else if (sense_key
== UNIT_ATTENTION
) {
811 cdrom_saw_media_change (drive
);
813 /* Arrange to retry the request.
814 But be sure to give up if we've retried
816 if (++rq
->errors
> ERROR_MAX
)
818 } else if (sense_key
== ILLEGAL_REQUEST
||
819 sense_key
== DATA_PROTECT
) {
820 /* No point in retrying after an illegal
821 request or data protect error.*/
822 ide_dump_status_no_sense (drive
, "command error", stat
);
824 } else if (sense_key
== MEDIUM_ERROR
) {
825 /* No point in re-trying a zillion times on a bad
826 * sector... If we got here the error is not correctable */
827 ide_dump_status_no_sense (drive
, "media error (bad sector)", stat
);
829 } else if (sense_key
== BLANK_CHECK
) {
830 /* Disk appears blank ?? */
831 ide_dump_status_no_sense (drive
, "media error (blank)", stat
);
833 } else if ((err
& ~ABRT_ERR
) != 0) {
834 /* Go to the default handler
836 ide_error(drive
, "cdrom_decode_status", stat
);
838 } else if ((++rq
->errors
> ERROR_MAX
)) {
839 /* We've racked up too many retries. Abort. */
843 /* End a request through request sense analysis when we have
844 sense data. We need this in order to perform end of media
847 if (do_end_request
) {
848 if (stat
& ERR_STAT
) {
850 spin_lock_irqsave(&ide_lock
, flags
);
851 blkdev_dequeue_request(rq
);
852 HWGROUP(drive
)->rq
= NULL
;
853 spin_unlock_irqrestore(&ide_lock
, flags
);
855 cdrom_queue_request_sense(drive
, rq
->sense
, rq
);
857 cdrom_end_request(drive
, 0);
859 /* If we got a CHECK_CONDITION status,
860 queue a request sense command. */
862 cdrom_queue_request_sense(drive
, NULL
, NULL
);
865 blk_dump_rq_flags(rq
, "ide-cd: bad rq");
866 cdrom_end_request(drive
, 0);
869 /* Retry, or handle the next request. */
873 static int cdrom_timer_expiry(ide_drive_t
*drive
)
875 struct request
*rq
= HWGROUP(drive
)->rq
;
876 unsigned long wait
= 0;
879 * Some commands are *slow* and normally take a long time to
880 * complete. Usually we can use the ATAPI "disconnect" to bypass
881 * this, but not all commands/drives support that. Let
882 * ide_timer_expiry keep polling us for these.
884 switch (rq
->cmd
[0]) {
886 case GPCMD_FORMAT_UNIT
:
887 case GPCMD_RESERVE_RZONE_TRACK
:
888 case GPCMD_CLOSE_TRACK
:
889 case GPCMD_FLUSH_CACHE
:
890 wait
= ATAPI_WAIT_PC
;
893 if (!(rq
->cmd_flags
& REQ_QUIET
))
894 printk(KERN_INFO
"ide-cd: cmd 0x%x timed out\n", rq
->cmd
[0]);
901 /* Set up the device registers for transferring a packet command on DEV,
902 expecting to later transfer XFERLEN bytes. HANDLER is the routine
903 which actually transfers the command to the drive. If this is a
904 drq_interrupt device, this routine will arrange for HANDLER to be
905 called when the interrupt from the drive arrives. Otherwise, HANDLER
906 will be called immediately after the drive is prepared for the transfer. */
908 static ide_startstop_t
cdrom_start_packet_command(ide_drive_t
*drive
,
910 ide_handler_t
*handler
)
912 ide_startstop_t startstop
;
913 struct cdrom_info
*info
= drive
->driver_data
;
914 ide_hwif_t
*hwif
= drive
->hwif
;
916 /* Wait for the controller to be idle. */
917 if (ide_wait_stat(&startstop
, drive
, 0, BUSY_STAT
, WAIT_READY
))
920 /* FIXME: for Virtual DMA we must check harder */
922 info
->dma
= !hwif
->dma_setup(drive
);
924 /* Set up the controller registers. */
925 ide_pktcmd_tf_load(drive
, IDE_TFLAG_OUT_NSECT
| IDE_TFLAG_OUT_LBAL
|
926 IDE_TFLAG_NO_SELECT_MASK
, xferlen
, info
->dma
);
928 if (CDROM_CONFIG_FLAGS (drive
)->drq_interrupt
) {
929 /* waiting for CDB interrupt, not DMA yet. */
931 drive
->waiting_for_dma
= 0;
934 ide_execute_command(drive
, WIN_PACKETCMD
, handler
, ATAPI_WAIT_PC
, cdrom_timer_expiry
);
940 spin_lock_irqsave(&ide_lock
, flags
);
941 hwif
->OUTBSYNC(drive
, WIN_PACKETCMD
, IDE_COMMAND_REG
);
943 spin_unlock_irqrestore(&ide_lock
, flags
);
945 return (*handler
) (drive
);
949 /* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
950 The device registers must have already been prepared
951 by cdrom_start_packet_command.
952 HANDLER is the interrupt handler to call when the command completes
953 or there's data ready. */
955 * changed 5 parameters to 3 for dvd-ram
956 * struct packet_command *pc; now packet_command_t *pc;
958 #define ATAPI_MIN_CDB_BYTES 12
959 static ide_startstop_t
cdrom_transfer_packet_command (ide_drive_t
*drive
,
961 ide_handler_t
*handler
)
963 ide_hwif_t
*hwif
= drive
->hwif
;
965 struct cdrom_info
*info
= drive
->driver_data
;
966 ide_startstop_t startstop
;
968 if (CDROM_CONFIG_FLAGS(drive
)->drq_interrupt
) {
969 /* Here we should have been called after receiving an interrupt
970 from the device. DRQ should how be set. */
972 /* Check for errors. */
973 if (cdrom_decode_status(drive
, DRQ_STAT
, NULL
))
976 /* Ok, next interrupt will be DMA interrupt. */
978 drive
->waiting_for_dma
= 1;
980 /* Otherwise, we must wait for DRQ to get set. */
981 if (ide_wait_stat(&startstop
, drive
, DRQ_STAT
,
982 BUSY_STAT
, WAIT_READY
))
986 /* Arm the interrupt handler. */
987 ide_set_handler(drive
, handler
, rq
->timeout
, cdrom_timer_expiry
);
989 /* ATAPI commands get padded out to 12 bytes minimum */
990 cmd_len
= COMMAND_SIZE(rq
->cmd
[0]);
991 if (cmd_len
< ATAPI_MIN_CDB_BYTES
)
992 cmd_len
= ATAPI_MIN_CDB_BYTES
;
994 /* Send the command to the device. */
995 HWIF(drive
)->atapi_output_bytes(drive
, rq
->cmd
, cmd_len
);
997 /* Start the DMA if need be */
999 hwif
->dma_start(drive
);
1004 /****************************************************************************
1005 * Block read functions.
1008 typedef void (xfer_func_t
)(ide_drive_t
*, void *, u32
);
1010 static void ide_cd_pad_transfer(ide_drive_t
*drive
, xfer_func_t
*xf
, int len
)
1014 xf(drive
, &dum
, sizeof(dum
));
1020 * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
1021 * buffer. Once the first sector is added, any subsequent sectors are
1022 * assumed to be continuous (until the buffer is cleared). For the first
1023 * sector added, SECTOR is its sector number. (SECTOR is then ignored until
1024 * the buffer is cleared.)
1026 static void cdrom_buffer_sectors (ide_drive_t
*drive
, unsigned long sector
,
1027 int sectors_to_transfer
)
1029 struct cdrom_info
*info
= drive
->driver_data
;
1031 /* Number of sectors to read into the buffer. */
1032 int sectors_to_buffer
= min_t(int, sectors_to_transfer
,
1033 (SECTOR_BUFFER_SIZE
>> SECTOR_BITS
) -
1034 info
->nsectors_buffered
);
1038 /* If we couldn't get a buffer, don't try to buffer anything... */
1039 if (info
->buffer
== NULL
)
1040 sectors_to_buffer
= 0;
1042 /* If this is the first sector in the buffer, remember its number. */
1043 if (info
->nsectors_buffered
== 0)
1044 info
->sector_buffered
= sector
;
1046 /* Read the data into the buffer. */
1047 dest
= info
->buffer
+ info
->nsectors_buffered
* SECTOR_SIZE
;
1048 while (sectors_to_buffer
> 0) {
1049 HWIF(drive
)->atapi_input_bytes(drive
, dest
, SECTOR_SIZE
);
1050 --sectors_to_buffer
;
1051 --sectors_to_transfer
;
1052 ++info
->nsectors_buffered
;
1053 dest
+= SECTOR_SIZE
;
1056 /* Throw away any remaining data. */
1057 while (sectors_to_transfer
> 0) {
1058 static char dum
[SECTOR_SIZE
];
1059 HWIF(drive
)->atapi_input_bytes(drive
, dum
, sizeof (dum
));
1060 --sectors_to_transfer
;
1065 * Check the contents of the interrupt reason register from the cdrom
1066 * and attempt to recover if there are problems. Returns 0 if everything's
1067 * ok; nonzero if the request has been terminated.
1070 int cdrom_read_check_ireason (ide_drive_t
*drive
, int len
, int ireason
)
1074 else if (ireason
== 0) {
1075 ide_hwif_t
*hwif
= drive
->hwif
;
1077 /* Whoops... The drive is expecting to receive data from us! */
1078 printk(KERN_ERR
"%s: %s: wrong transfer direction!\n",
1079 drive
->name
, __FUNCTION__
);
1081 /* Throw some data at the drive so it doesn't hang
1082 and quit this request. */
1083 ide_cd_pad_transfer(drive
, hwif
->atapi_output_bytes
, len
);
1084 } else if (ireason
== 1) {
1085 /* Some drives (ASUS) seem to tell us that status
1086 * info is available. just get it and ignore.
1088 (void) HWIF(drive
)->INB(IDE_STATUS_REG
);
1091 /* Drive wants a command packet, or invalid ireason... */
1092 printk(KERN_ERR
"%s: %s: bad interrupt reason 0x%02x\n",
1093 drive
->name
, __FUNCTION__
, ireason
);
1096 cdrom_end_request(drive
, 0);
1101 * Interrupt routine. Called when a read request has completed.
1103 static ide_startstop_t
cdrom_read_intr (ide_drive_t
*drive
)
1106 int ireason
, len
, sectors_to_transfer
, nskip
;
1107 struct cdrom_info
*info
= drive
->driver_data
;
1108 u8 lowcyl
= 0, highcyl
= 0;
1109 int dma
= info
->dma
, dma_error
= 0;
1111 struct request
*rq
= HWGROUP(drive
)->rq
;
1118 dma_error
= HWIF(drive
)->ide_dma_end(drive
);
1120 printk(KERN_ERR
"%s: DMA read error\n", drive
->name
);
1125 if (cdrom_decode_status(drive
, 0, &stat
))
1130 ide_end_request(drive
, 1, rq
->nr_sectors
);
1133 return ide_error(drive
, "dma error", stat
);
1136 /* Read the interrupt reason and the transfer length. */
1137 ireason
= HWIF(drive
)->INB(IDE_IREASON_REG
) & 0x3;
1138 lowcyl
= HWIF(drive
)->INB(IDE_BCOUNTL_REG
);
1139 highcyl
= HWIF(drive
)->INB(IDE_BCOUNTH_REG
);
1141 len
= lowcyl
+ (256 * highcyl
);
1143 /* If DRQ is clear, the command has completed. */
1144 if ((stat
& DRQ_STAT
) == 0) {
1145 /* If we're not done filling the current buffer, complain.
1146 Otherwise, complete the command normally. */
1147 if (rq
->current_nr_sectors
> 0) {
1148 printk (KERN_ERR
"%s: cdrom_read_intr: data underrun (%d blocks)\n",
1149 drive
->name
, rq
->current_nr_sectors
);
1150 rq
->cmd_flags
|= REQ_FAILED
;
1151 cdrom_end_request(drive
, 0);
1153 cdrom_end_request(drive
, 1);
1157 /* Check that the drive is expecting to do the same thing we are. */
1158 if (cdrom_read_check_ireason (drive
, len
, ireason
))
1161 /* Assume that the drive will always provide data in multiples
1162 of at least SECTOR_SIZE, as it gets hairy to keep track
1163 of the transfers otherwise. */
1164 if ((len
% SECTOR_SIZE
) != 0) {
1165 printk (KERN_ERR
"%s: cdrom_read_intr: Bad transfer size %d\n",
1167 if (CDROM_CONFIG_FLAGS(drive
)->limit_nframes
)
1168 printk (KERN_ERR
" This drive is not supported by this version of the driver\n");
1170 printk (KERN_ERR
" Trying to limit transfer sizes\n");
1171 CDROM_CONFIG_FLAGS(drive
)->limit_nframes
= 1;
1173 cdrom_end_request(drive
, 0);
1177 /* The number of sectors we need to read from the drive. */
1178 sectors_to_transfer
= len
/ SECTOR_SIZE
;
1180 /* First, figure out if we need to bit-bucket
1181 any of the leading sectors. */
1182 nskip
= min_t(int, rq
->current_nr_sectors
- bio_cur_sectors(rq
->bio
), sectors_to_transfer
);
1185 /* We need to throw away a sector. */
1186 static char dum
[SECTOR_SIZE
];
1187 HWIF(drive
)->atapi_input_bytes(drive
, dum
, sizeof (dum
));
1189 --rq
->current_nr_sectors
;
1191 --sectors_to_transfer
;
1194 /* Now loop while we still have data to read from the drive. */
1195 while (sectors_to_transfer
> 0) {
1198 /* If we've filled the present buffer but there's another
1199 chained buffer after it, move on. */
1200 if (rq
->current_nr_sectors
== 0 && rq
->nr_sectors
)
1201 cdrom_end_request(drive
, 1);
1203 /* If the buffers are full, cache the rest of the data in our
1205 if (rq
->current_nr_sectors
== 0) {
1206 cdrom_buffer_sectors(drive
, rq
->sector
, sectors_to_transfer
);
1207 sectors_to_transfer
= 0;
1209 /* Transfer data to the buffers.
1210 Figure out how many sectors we can transfer
1211 to the current buffer. */
1212 this_transfer
= min_t(int, sectors_to_transfer
,
1213 rq
->current_nr_sectors
);
1215 /* Read this_transfer sectors
1216 into the current buffer. */
1217 while (this_transfer
> 0) {
1218 HWIF(drive
)->atapi_input_bytes(drive
, rq
->buffer
, SECTOR_SIZE
);
1219 rq
->buffer
+= SECTOR_SIZE
;
1221 --rq
->current_nr_sectors
;
1224 --sectors_to_transfer
;
1229 /* Done moving data! Wait for another interrupt. */
1230 ide_set_handler(drive
, &cdrom_read_intr
, ATAPI_WAIT_PC
, NULL
);
1235 * Try to satisfy some of the current read request from our cached data.
1236 * Returns nonzero if the request has been completed, zero otherwise.
1238 static int cdrom_read_from_buffer (ide_drive_t
*drive
)
1240 struct cdrom_info
*info
= drive
->driver_data
;
1241 struct request
*rq
= HWGROUP(drive
)->rq
;
1242 unsigned short sectors_per_frame
;
1244 sectors_per_frame
= queue_hardsect_size(drive
->queue
) >> SECTOR_BITS
;
1246 /* Can't do anything if there's no buffer. */
1247 if (info
->buffer
== NULL
) return 0;
1249 /* Loop while this request needs data and the next block is present
1251 while (rq
->nr_sectors
> 0 &&
1252 rq
->sector
>= info
->sector_buffered
&&
1253 rq
->sector
< info
->sector_buffered
+ info
->nsectors_buffered
) {
1254 if (rq
->current_nr_sectors
== 0)
1255 cdrom_end_request(drive
, 1);
1259 (rq
->sector
- info
->sector_buffered
) * SECTOR_SIZE
,
1261 rq
->buffer
+= SECTOR_SIZE
;
1262 --rq
->current_nr_sectors
;
1267 /* If we've satisfied the current request,
1268 terminate it successfully. */
1269 if (rq
->nr_sectors
== 0) {
1270 cdrom_end_request(drive
, 1);
1274 /* Move on to the next buffer if needed. */
1275 if (rq
->current_nr_sectors
== 0)
1276 cdrom_end_request(drive
, 1);
1278 /* If this condition does not hold, then the kluge i use to
1279 represent the number of sectors to skip at the start of a transfer
1280 will fail. I think that this will never happen, but let's be
1281 paranoid and check. */
1282 if (rq
->current_nr_sectors
< bio_cur_sectors(rq
->bio
) &&
1283 (rq
->sector
& (sectors_per_frame
- 1))) {
1284 printk(KERN_ERR
"%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
1285 drive
->name
, (long)rq
->sector
);
1286 cdrom_end_request(drive
, 0);
1294 * Routine to send a read packet command to the drive.
1295 * This is usually called directly from cdrom_start_read.
1296 * However, for drq_interrupt devices, it is called from an interrupt
1297 * when the drive is ready to accept the command.
1299 static ide_startstop_t
cdrom_start_read_continuation (ide_drive_t
*drive
)
1301 struct request
*rq
= HWGROUP(drive
)->rq
;
1302 unsigned short sectors_per_frame
;
1305 sectors_per_frame
= queue_hardsect_size(drive
->queue
) >> SECTOR_BITS
;
1307 /* If the requested sector doesn't start on a cdrom block boundary,
1308 we must adjust the start of the transfer so that it does,
1309 and remember to skip the first few sectors.
1310 If the CURRENT_NR_SECTORS field is larger than the size
1311 of the buffer, it will mean that we're to skip a number
1312 of sectors equal to the amount by which CURRENT_NR_SECTORS
1313 is larger than the buffer size. */
1314 nskip
= rq
->sector
& (sectors_per_frame
- 1);
1316 /* Sanity check... */
1317 if (rq
->current_nr_sectors
!= bio_cur_sectors(rq
->bio
) &&
1318 (rq
->sector
& (sectors_per_frame
- 1))) {
1319 printk(KERN_ERR
"%s: cdrom_start_read_continuation: buffer botch (%u)\n",
1320 drive
->name
, rq
->current_nr_sectors
);
1321 cdrom_end_request(drive
, 0);
1324 rq
->current_nr_sectors
+= nskip
;
1327 /* Set up the command */
1328 rq
->timeout
= ATAPI_WAIT_PC
;
1330 /* Send the command to the drive and return. */
1331 return cdrom_transfer_packet_command(drive
, rq
, &cdrom_read_intr
);
1335 #define IDECD_SEEK_THRESHOLD (1000) /* 1000 blocks */
1336 #define IDECD_SEEK_TIMER (5 * WAIT_MIN_SLEEP) /* 100 ms */
1337 #define IDECD_SEEK_TIMEOUT (2 * WAIT_CMD) /* 20 sec */
1339 static ide_startstop_t
cdrom_seek_intr (ide_drive_t
*drive
)
1341 struct cdrom_info
*info
= drive
->driver_data
;
1343 static int retry
= 10;
1345 if (cdrom_decode_status(drive
, 0, &stat
))
1347 CDROM_CONFIG_FLAGS(drive
)->seeking
= 1;
1349 if (retry
&& time_after(jiffies
, info
->start_seek
+ IDECD_SEEK_TIMER
)) {
1352 * this condition is far too common, to bother
1355 /* printk("%s: disabled DSC seek overlap\n", drive->name);*/
1356 drive
->dsc_overlap
= 0;
1362 static ide_startstop_t
cdrom_start_seek_continuation (ide_drive_t
*drive
)
1364 struct request
*rq
= HWGROUP(drive
)->rq
;
1365 sector_t frame
= rq
->sector
;
1367 sector_div(frame
, queue_hardsect_size(drive
->queue
) >> SECTOR_BITS
);
1369 memset(rq
->cmd
, 0, sizeof(rq
->cmd
));
1370 rq
->cmd
[0] = GPCMD_SEEK
;
1371 put_unaligned(cpu_to_be32(frame
), (unsigned int *) &rq
->cmd
[2]);
1373 rq
->timeout
= ATAPI_WAIT_PC
;
1374 return cdrom_transfer_packet_command(drive
, rq
, &cdrom_seek_intr
);
1377 static ide_startstop_t
cdrom_start_seek (ide_drive_t
*drive
, unsigned int block
)
1379 struct cdrom_info
*info
= drive
->driver_data
;
1382 info
->start_seek
= jiffies
;
1383 return cdrom_start_packet_command(drive
, 0, cdrom_start_seek_continuation
);
1386 /* Fix up a possibly partially-processed request so that we can
1387 start it over entirely, or even put it back on the request queue. */
1388 static void restore_request (struct request
*rq
)
1390 if (rq
->buffer
!= bio_data(rq
->bio
)) {
1391 sector_t n
= (rq
->buffer
- (char *) bio_data(rq
->bio
)) / SECTOR_SIZE
;
1393 rq
->buffer
= bio_data(rq
->bio
);
1394 rq
->nr_sectors
+= n
;
1397 rq
->hard_cur_sectors
= rq
->current_nr_sectors
= bio_cur_sectors(rq
->bio
);
1398 rq
->hard_nr_sectors
= rq
->nr_sectors
;
1399 rq
->hard_sector
= rq
->sector
;
1400 rq
->q
->prep_rq_fn(rq
->q
, rq
);
1404 * Start a read request from the CD-ROM.
1406 static ide_startstop_t
cdrom_start_read (ide_drive_t
*drive
, unsigned int block
)
1408 struct cdrom_info
*info
= drive
->driver_data
;
1409 struct request
*rq
= HWGROUP(drive
)->rq
;
1410 unsigned short sectors_per_frame
;
1412 sectors_per_frame
= queue_hardsect_size(drive
->queue
) >> SECTOR_BITS
;
1414 /* We may be retrying this request after an error. Fix up
1415 any weirdness which might be present in the request packet. */
1416 restore_request(rq
);
1418 /* Satisfy whatever we can of this request from our cached sector. */
1419 if (cdrom_read_from_buffer(drive
))
1422 /* Clear the local sector buffer. */
1423 info
->nsectors_buffered
= 0;
1425 /* use dma, if possible. */
1426 info
->dma
= drive
->using_dma
;
1427 if ((rq
->sector
& (sectors_per_frame
- 1)) ||
1428 (rq
->nr_sectors
& (sectors_per_frame
- 1)))
1431 /* Start sending the read request to the drive. */
1432 return cdrom_start_packet_command(drive
, 32768, cdrom_start_read_continuation
);
1435 /****************************************************************************
1436 * Execute all other packet commands.
1439 /* Interrupt routine for packet command completion. */
1440 static ide_startstop_t
cdrom_pc_intr (ide_drive_t
*drive
)
1442 struct request
*rq
= HWGROUP(drive
)->rq
;
1443 xfer_func_t
*xferfunc
= NULL
;
1444 int stat
, ireason
, len
, thislen
, write
;
1445 u8 lowcyl
= 0, highcyl
= 0;
1447 /* Check for errors. */
1448 if (cdrom_decode_status(drive
, 0, &stat
))
1451 /* Read the interrupt reason and the transfer length. */
1452 ireason
= HWIF(drive
)->INB(IDE_IREASON_REG
) & 0x3;
1453 lowcyl
= HWIF(drive
)->INB(IDE_BCOUNTL_REG
);
1454 highcyl
= HWIF(drive
)->INB(IDE_BCOUNTH_REG
);
1456 len
= lowcyl
+ (256 * highcyl
);
1458 /* If DRQ is clear, the command has completed.
1459 Complain if we still have data left to transfer. */
1460 if ((stat
& DRQ_STAT
) == 0) {
1461 /* Some of the trailing request sense fields are optional, and
1462 some drives don't send them. Sigh. */
1463 if (rq
->cmd
[0] == GPCMD_REQUEST_SENSE
&&
1465 rq
->data_len
<= 5) {
1466 while (rq
->data_len
> 0) {
1467 *(unsigned char *)rq
->data
++ = 0;
1472 if (rq
->data_len
== 0)
1473 cdrom_end_request(drive
, 1);
1475 /* Comment this out, because this always happens
1476 right after a reset occurs, and it is annoying to
1477 always print expected stuff. */
1479 printk ("%s: cdrom_pc_intr: data underrun %d\n",
1480 drive->name, pc->buflen);
1482 rq
->cmd_flags
|= REQ_FAILED
;
1483 cdrom_end_request(drive
, 0);
1488 /* Figure out how much data to transfer. */
1489 thislen
= rq
->data_len
;
1495 xferfunc
= HWIF(drive
)->atapi_output_bytes
;
1496 } else if (ireason
== 2) {
1498 xferfunc
= HWIF(drive
)->atapi_input_bytes
;
1503 printk(KERN_ERR
"%s: confused, missing data\n",
1505 blk_dump_rq_flags(rq
, write
? "cdrom_pc_intr, write"
1506 : "cdrom_pc_intr, read");
1509 /* Transfer the data. */
1510 xferfunc(drive
, rq
->data
, thislen
);
1512 /* Keep count of how much data we've moved. */
1514 rq
->data
+= thislen
;
1515 rq
->data_len
-= thislen
;
1517 if (write
&& blk_sense_request(rq
))
1518 rq
->sense_len
+= thislen
;
1520 printk (KERN_ERR
"%s: cdrom_pc_intr: The drive "
1521 "appears confused (ireason = 0x%02x). "
1522 "Trying to recover by ending request.\n",
1523 drive
->name
, ireason
);
1524 rq
->cmd_flags
|= REQ_FAILED
;
1525 cdrom_end_request(drive
, 0);
1530 * If we haven't moved enough data to satisfy the drive,
1534 ide_cd_pad_transfer(drive
, xferfunc
, len
);
1536 /* Now we wait for another interrupt. */
1537 ide_set_handler(drive
, &cdrom_pc_intr
, ATAPI_WAIT_PC
, cdrom_timer_expiry
);
1541 static ide_startstop_t
cdrom_do_pc_continuation (ide_drive_t
*drive
)
1543 struct request
*rq
= HWGROUP(drive
)->rq
;
1546 rq
->timeout
= ATAPI_WAIT_PC
;
1548 /* Send the command to the drive and return. */
1549 return cdrom_transfer_packet_command(drive
, rq
, &cdrom_pc_intr
);
1553 static ide_startstop_t
cdrom_do_packet_command (ide_drive_t
*drive
)
1556 struct request
*rq
= HWGROUP(drive
)->rq
;
1557 struct cdrom_info
*info
= drive
->driver_data
;
1560 rq
->cmd_flags
&= ~REQ_FAILED
;
1563 /* Start sending the command to the drive. */
1564 return cdrom_start_packet_command(drive
, len
, cdrom_do_pc_continuation
);
1568 static int cdrom_queue_packet_command(ide_drive_t
*drive
, struct request
*rq
)
1570 struct request_sense sense
;
1572 unsigned int flags
= rq
->cmd_flags
;
1574 if (rq
->sense
== NULL
)
1577 /* Start of retry loop. */
1580 unsigned long time
= jiffies
;
1581 rq
->cmd_flags
= flags
;
1583 error
= ide_do_drive_cmd(drive
, rq
, ide_wait
);
1584 time
= jiffies
- time
;
1586 /* FIXME: we should probably abort/retry or something
1587 * in case of failure */
1588 if (rq
->cmd_flags
& REQ_FAILED
) {
1589 /* The request failed. Retry if it was due to a unit
1591 (usually means media was changed). */
1592 struct request_sense
*reqbuf
= rq
->sense
;
1594 if (reqbuf
->sense_key
== UNIT_ATTENTION
)
1595 cdrom_saw_media_change(drive
);
1596 else if (reqbuf
->sense_key
== NOT_READY
&&
1597 reqbuf
->asc
== 4 && reqbuf
->ascq
!= 4) {
1598 /* The drive is in the process of loading
1599 a disk. Retry, but wait a little to give
1600 the drive time to complete the load. */
1603 /* Otherwise, don't retry. */
1609 /* End of retry loop. */
1610 } while ((rq
->cmd_flags
& REQ_FAILED
) && retries
>= 0);
1612 /* Return an error if the command failed. */
1613 return (rq
->cmd_flags
& REQ_FAILED
) ? -EIO
: 0;
1619 static int cdrom_write_check_ireason(ide_drive_t
*drive
, int len
, int ireason
)
1621 /* Two notes about IDE interrupt reason here - 0 means that
1622 * the drive wants to receive data from us, 2 means that
1623 * the drive is expecting to transfer data to us.
1627 else if (ireason
== 2) {
1628 ide_hwif_t
*hwif
= drive
->hwif
;
1630 /* Whoops... The drive wants to send data. */
1631 printk(KERN_ERR
"%s: %s: wrong transfer direction!\n",
1632 drive
->name
, __FUNCTION__
);
1634 ide_cd_pad_transfer(drive
, hwif
->atapi_input_bytes
, len
);
1636 /* Drive wants a command packet, or invalid ireason... */
1637 printk(KERN_ERR
"%s: %s: bad interrupt reason 0x%02x\n",
1638 drive
->name
, __FUNCTION__
, ireason
);
1641 cdrom_end_request(drive
, 0);
1646 * Called from blk_end_request_callback() after the data of the request
1647 * is completed and before the request is completed.
1648 * By returning value '1', blk_end_request_callback() returns immediately
1649 * without completing the request.
1651 static int cdrom_newpc_intr_dummy_cb(struct request
*rq
)
1657 * best way to deal with dma that is not sector aligned right now... note
1658 * that in this path we are not using ->data or ->buffer at all. this irs
1659 * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the
1662 static ide_startstop_t
cdrom_newpc_intr(ide_drive_t
*drive
)
1664 struct cdrom_info
*info
= drive
->driver_data
;
1665 struct request
*rq
= HWGROUP(drive
)->rq
;
1666 int dma_error
, dma
, stat
, ireason
, len
, thislen
;
1668 xfer_func_t
*xferfunc
;
1669 unsigned long flags
;
1671 /* Check for errors. */
1676 dma_error
= HWIF(drive
)->ide_dma_end(drive
);
1679 if (cdrom_decode_status(drive
, 0, &stat
))
1683 * using dma, transfer is complete now
1687 printk(KERN_ERR
"ide-cd: dma error\n");
1689 return ide_error(drive
, "dma error", stat
);
1692 spin_lock_irqsave(&ide_lock
, flags
);
1693 if (__blk_end_request(rq
, 0, rq
->data_len
))
1695 HWGROUP(drive
)->rq
= NULL
;
1696 spin_unlock_irqrestore(&ide_lock
, flags
);
1702 * ok we fall to pio :/
1704 ireason
= HWIF(drive
)->INB(IDE_IREASON_REG
) & 0x3;
1705 lowcyl
= HWIF(drive
)->INB(IDE_BCOUNTL_REG
);
1706 highcyl
= HWIF(drive
)->INB(IDE_BCOUNTH_REG
);
1708 len
= lowcyl
+ (256 * highcyl
);
1709 thislen
= rq
->data_len
;
1714 * If DRQ is clear, the command has completed.
1716 if ((stat
& DRQ_STAT
) == 0) {
1717 spin_lock_irqsave(&ide_lock
, flags
);
1718 if (__blk_end_request(rq
, 0, rq
->data_len
))
1720 HWGROUP(drive
)->rq
= NULL
;
1721 spin_unlock_irqrestore(&ide_lock
, flags
);
1727 * check which way to transfer data
1729 if (rq_data_dir(rq
) == WRITE
) {
1733 if (cdrom_write_check_ireason(drive
, len
, ireason
))
1736 xferfunc
= HWIF(drive
)->atapi_output_bytes
;
1741 if (cdrom_read_check_ireason(drive
, len
, ireason
))
1744 xferfunc
= HWIF(drive
)->atapi_input_bytes
;
1750 while (thislen
> 0) {
1751 int blen
= blen
= rq
->data_len
;
1752 char *ptr
= rq
->data
;
1758 ptr
= bio_data(rq
->bio
);
1759 blen
= bio_iovec(rq
->bio
)->bv_len
;
1763 printk(KERN_ERR
"%s: confused, missing data\n", drive
->name
);
1770 xferfunc(drive
, ptr
, blen
);
1774 rq
->data_len
-= blen
;
1778 * The request can't be completed until DRQ is cleared.
1779 * So complete the data, but don't complete the request
1780 * using the dummy function for the callback feature
1781 * of blk_end_request_callback().
1783 blk_end_request_callback(rq
, 0, blen
,
1784 cdrom_newpc_intr_dummy_cb
);
1793 ide_cd_pad_transfer(drive
, xferfunc
, len
);
1795 BUG_ON(HWGROUP(drive
)->handler
!= NULL
);
1797 ide_set_handler(drive
, cdrom_newpc_intr
, rq
->timeout
, NULL
);
1801 static ide_startstop_t
cdrom_write_intr(ide_drive_t
*drive
)
1803 int stat
, ireason
, len
, sectors_to_transfer
, uptodate
;
1804 struct cdrom_info
*info
= drive
->driver_data
;
1805 int dma_error
= 0, dma
= info
->dma
;
1806 u8 lowcyl
= 0, highcyl
= 0;
1808 struct request
*rq
= HWGROUP(drive
)->rq
;
1810 /* Check for errors. */
1813 dma_error
= HWIF(drive
)->ide_dma_end(drive
);
1815 printk(KERN_ERR
"%s: DMA write error\n", drive
->name
);
1820 if (cdrom_decode_status(drive
, 0, &stat
))
1824 * using dma, transfer is complete now
1828 return ide_error(drive
, "dma error", stat
);
1830 ide_end_request(drive
, 1, rq
->nr_sectors
);
1834 /* Read the interrupt reason and the transfer length. */
1835 ireason
= HWIF(drive
)->INB(IDE_IREASON_REG
) & 0x3;
1836 lowcyl
= HWIF(drive
)->INB(IDE_BCOUNTL_REG
);
1837 highcyl
= HWIF(drive
)->INB(IDE_BCOUNTH_REG
);
1839 len
= lowcyl
+ (256 * highcyl
);
1841 /* If DRQ is clear, the command has completed. */
1842 if ((stat
& DRQ_STAT
) == 0) {
1843 /* If we're not done writing, complain.
1844 * Otherwise, complete the command normally.
1847 if (rq
->current_nr_sectors
> 0) {
1848 printk(KERN_ERR
"%s: %s: data underrun (%d blocks)\n",
1849 drive
->name
, __FUNCTION__
,
1850 rq
->current_nr_sectors
);
1853 cdrom_end_request(drive
, uptodate
);
1857 /* Check that the drive is expecting to do the same thing we are. */
1858 if (cdrom_write_check_ireason(drive
, len
, ireason
))
1861 sectors_to_transfer
= len
/ SECTOR_SIZE
;
1864 * now loop and write out the data
1866 while (sectors_to_transfer
> 0) {
1869 if (!rq
->current_nr_sectors
) {
1870 printk(KERN_ERR
"%s: %s: confused, missing data\n",
1871 drive
->name
, __FUNCTION__
);
1876 * Figure out how many sectors we can transfer
1878 this_transfer
= min_t(int, sectors_to_transfer
, rq
->current_nr_sectors
);
1880 while (this_transfer
> 0) {
1881 HWIF(drive
)->atapi_output_bytes(drive
, rq
->buffer
, SECTOR_SIZE
);
1882 rq
->buffer
+= SECTOR_SIZE
;
1884 --rq
->current_nr_sectors
;
1887 --sectors_to_transfer
;
1891 * current buffer complete, move on
1893 if (rq
->current_nr_sectors
== 0 && rq
->nr_sectors
)
1894 cdrom_end_request(drive
, 1);
1897 /* re-arm handler */
1898 ide_set_handler(drive
, &cdrom_write_intr
, ATAPI_WAIT_PC
, NULL
);
1902 static ide_startstop_t
cdrom_start_write_cont(ide_drive_t
*drive
)
1904 struct request
*rq
= HWGROUP(drive
)->rq
;
1906 #if 0 /* the immediate bit */
1907 rq
->cmd
[1] = 1 << 3;
1909 rq
->timeout
= ATAPI_WAIT_PC
;
1911 return cdrom_transfer_packet_command(drive
, rq
, cdrom_write_intr
);
1914 static ide_startstop_t
cdrom_start_write(ide_drive_t
*drive
, struct request
*rq
)
1916 struct cdrom_info
*info
= drive
->driver_data
;
1917 struct gendisk
*g
= info
->disk
;
1918 unsigned short sectors_per_frame
= queue_hardsect_size(drive
->queue
) >> SECTOR_BITS
;
1921 * writes *must* be hardware frame aligned
1923 if ((rq
->nr_sectors
& (sectors_per_frame
- 1)) ||
1924 (rq
->sector
& (sectors_per_frame
- 1))) {
1925 cdrom_end_request(drive
, 0);
1930 * disk has become write protected
1933 cdrom_end_request(drive
, 0);
1937 info
->nsectors_buffered
= 0;
1939 /* use dma, if possible. we don't need to check more, since we
1940 * know that the transfer is always (at least!) frame aligned */
1941 info
->dma
= drive
->using_dma
? 1 : 0;
1943 info
->devinfo
.media_written
= 1;
1945 /* Start sending the write request to the drive. */
1946 return cdrom_start_packet_command(drive
, 32768, cdrom_start_write_cont
);
1949 static ide_startstop_t
cdrom_do_newpc_cont(ide_drive_t
*drive
)
1951 struct request
*rq
= HWGROUP(drive
)->rq
;
1954 rq
->timeout
= ATAPI_WAIT_PC
;
1956 return cdrom_transfer_packet_command(drive
, rq
, cdrom_newpc_intr
);
1959 static ide_startstop_t
cdrom_do_block_pc(ide_drive_t
*drive
, struct request
*rq
)
1961 struct cdrom_info
*info
= drive
->driver_data
;
1963 rq
->cmd_flags
|= REQ_QUIET
;
1971 int mask
= drive
->queue
->dma_alignment
;
1972 unsigned long addr
= (unsigned long) page_address(bio_page(rq
->bio
));
1974 info
->dma
= drive
->using_dma
;
1977 * check if dma is safe
1979 * NOTE! The "len" and "addr" checks should possibly have
1982 if ((rq
->data_len
& 15) || (addr
& mask
))
1986 /* Start sending the command to the drive. */
1987 return cdrom_start_packet_command(drive
, rq
->data_len
, cdrom_do_newpc_cont
);
1990 /****************************************************************************
1991 * cdrom driver request routine.
1993 static ide_startstop_t
1994 ide_do_rw_cdrom (ide_drive_t
*drive
, struct request
*rq
, sector_t block
)
1996 ide_startstop_t action
;
1997 struct cdrom_info
*info
= drive
->driver_data
;
1999 if (blk_fs_request(rq
)) {
2000 if (CDROM_CONFIG_FLAGS(drive
)->seeking
) {
2001 unsigned long elapsed
= jiffies
- info
->start_seek
;
2002 int stat
= HWIF(drive
)->INB(IDE_STATUS_REG
);
2004 if ((stat
& SEEK_STAT
) != SEEK_STAT
) {
2005 if (elapsed
< IDECD_SEEK_TIMEOUT
) {
2006 ide_stall_queue(drive
, IDECD_SEEK_TIMER
);
2009 printk (KERN_ERR
"%s: DSC timeout\n", drive
->name
);
2011 CDROM_CONFIG_FLAGS(drive
)->seeking
= 0;
2013 if ((rq_data_dir(rq
) == READ
) && IDE_LARGE_SEEK(info
->last_block
, block
, IDECD_SEEK_THRESHOLD
) && drive
->dsc_overlap
) {
2014 action
= cdrom_start_seek(drive
, block
);
2016 if (rq_data_dir(rq
) == READ
)
2017 action
= cdrom_start_read(drive
, block
);
2019 action
= cdrom_start_write(drive
, rq
);
2021 info
->last_block
= block
;
2023 } else if (rq
->cmd_type
== REQ_TYPE_SENSE
||
2024 rq
->cmd_type
== REQ_TYPE_ATA_PC
) {
2025 return cdrom_do_packet_command(drive
);
2026 } else if (blk_pc_request(rq
)) {
2027 return cdrom_do_block_pc(drive
, rq
);
2028 } else if (blk_special_request(rq
)) {
2030 * right now this can only be a reset...
2032 cdrom_end_request(drive
, 1);
2036 blk_dump_rq_flags(rq
, "ide-cd bad flags");
2037 cdrom_end_request(drive
, 0);
2043 /****************************************************************************
2046 * Routines which queue packet commands take as a final argument a pointer
2047 * to a request_sense struct. If execution of the command results
2048 * in an error with a CHECK CONDITION status, this structure will be filled
2049 * with the results of the subsequent request sense command. The pointer
2050 * can also be NULL, in which case no sense information is returned.
2053 #if ! STANDARD_ATAPI
2057 return (x
%10) | ((x
/10) << 4);
2064 return (x
>> 4) * 10 + (x
& 0x0f);
2068 void msf_from_bcd (struct atapi_msf
*msf
)
2070 msf
->minute
= bcd2bin (msf
->minute
);
2071 msf
->second
= bcd2bin (msf
->second
);
2072 msf
->frame
= bcd2bin (msf
->frame
);
2075 #endif /* not STANDARD_ATAPI */
2079 void lba_to_msf (int lba
, byte
*m
, byte
*s
, byte
*f
)
2081 lba
+= CD_MSF_OFFSET
;
2082 lba
&= 0xffffff; /* negative lbas use only 24 bits */
2083 *m
= lba
/ (CD_SECS
* CD_FRAMES
);
2084 lba
%= (CD_SECS
* CD_FRAMES
);
2085 *s
= lba
/ CD_FRAMES
;
2086 *f
= lba
% CD_FRAMES
;
2091 int msf_to_lba (byte m
, byte s
, byte f
)
2093 return (((m
* CD_SECS
) + s
) * CD_FRAMES
+ f
) - CD_MSF_OFFSET
;
2096 static int cdrom_check_status(ide_drive_t
*drive
, struct request_sense
*sense
)
2099 struct cdrom_info
*info
= drive
->driver_data
;
2100 struct cdrom_device_info
*cdi
= &info
->devinfo
;
2102 cdrom_prepare_request(drive
, &req
);
2105 req
.cmd
[0] = GPCMD_TEST_UNIT_READY
;
2106 req
.cmd_flags
|= REQ_QUIET
;
2108 #if ! STANDARD_ATAPI
2109 /* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
2110 switch CDs instead of supporting the LOAD_UNLOAD opcode */
2112 req
.cmd
[7] = cdi
->sanyo_slot
% 3;
2113 #endif /* not STANDARD_ATAPI */
2115 return cdrom_queue_packet_command(drive
, &req
);
2119 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
2121 cdrom_lockdoor(ide_drive_t
*drive
, int lockflag
, struct request_sense
*sense
)
2123 struct request_sense my_sense
;
2130 /* If the drive cannot lock the door, just pretend. */
2131 if (CDROM_CONFIG_FLAGS(drive
)->no_doorlock
) {
2134 cdrom_prepare_request(drive
, &req
);
2136 req
.cmd
[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL
;
2137 req
.cmd
[4] = lockflag
? 1 : 0;
2138 stat
= cdrom_queue_packet_command(drive
, &req
);
2141 /* If we got an illegal field error, the drive
2142 probably cannot lock the door. */
2144 sense
->sense_key
== ILLEGAL_REQUEST
&&
2145 (sense
->asc
== 0x24 || sense
->asc
== 0x20)) {
2146 printk (KERN_ERR
"%s: door locking not supported\n",
2148 CDROM_CONFIG_FLAGS(drive
)->no_doorlock
= 1;
2152 /* no medium, that's alright. */
2153 if (stat
!= 0 && sense
->sense_key
== NOT_READY
&& sense
->asc
== 0x3a)
2157 CDROM_STATE_FLAGS(drive
)->door_locked
= lockflag
;
2163 /* Eject the disk if EJECTFLAG is 0.
2164 If EJECTFLAG is 1, try to reload the disk. */
2165 static int cdrom_eject(ide_drive_t
*drive
, int ejectflag
,
2166 struct request_sense
*sense
)
2171 if (CDROM_CONFIG_FLAGS(drive
)->no_eject
&& !ejectflag
)
2172 return -EDRIVE_CANT_DO_THIS
;
2174 /* reload fails on some drives, if the tray is locked */
2175 if (CDROM_STATE_FLAGS(drive
)->door_locked
&& ejectflag
)
2178 cdrom_prepare_request(drive
, &req
);
2180 /* only tell drive to close tray if open, if it can do that */
2181 if (ejectflag
&& !CDROM_CONFIG_FLAGS(drive
)->close_tray
)
2185 req
.cmd
[0] = GPCMD_START_STOP_UNIT
;
2186 req
.cmd
[4] = loej
| (ejectflag
!= 0);
2187 return cdrom_queue_packet_command(drive
, &req
);
2190 static int cdrom_read_capacity(ide_drive_t
*drive
, unsigned long *capacity
,
2191 unsigned long *sectors_per_frame
,
2192 struct request_sense
*sense
)
2202 cdrom_prepare_request(drive
, &req
);
2205 req
.cmd
[0] = GPCMD_READ_CDVD_CAPACITY
;
2206 req
.data
= (char *)&capbuf
;
2207 req
.data_len
= sizeof(capbuf
);
2208 req
.cmd_flags
|= REQ_QUIET
;
2210 stat
= cdrom_queue_packet_command(drive
, &req
);
2212 *capacity
= 1 + be32_to_cpu(capbuf
.lba
);
2213 *sectors_per_frame
=
2214 be32_to_cpu(capbuf
.blocklen
) >> SECTOR_BITS
;
2220 static int cdrom_read_tocentry(ide_drive_t
*drive
, int trackno
, int msf_flag
,
2221 int format
, char *buf
, int buflen
,
2222 struct request_sense
*sense
)
2226 cdrom_prepare_request(drive
, &req
);
2230 req
.data_len
= buflen
;
2231 req
.cmd_flags
|= REQ_QUIET
;
2232 req
.cmd
[0] = GPCMD_READ_TOC_PMA_ATIP
;
2233 req
.cmd
[6] = trackno
;
2234 req
.cmd
[7] = (buflen
>> 8);
2235 req
.cmd
[8] = (buflen
& 0xff);
2236 req
.cmd
[9] = (format
<< 6);
2241 return cdrom_queue_packet_command(drive
, &req
);
2245 /* Try to read the entire TOC for the disk into our internal buffer. */
2246 static int cdrom_read_toc(ide_drive_t
*drive
, struct request_sense
*sense
)
2248 int stat
, ntracks
, i
;
2249 struct cdrom_info
*info
= drive
->driver_data
;
2250 struct cdrom_device_info
*cdi
= &info
->devinfo
;
2251 struct atapi_toc
*toc
= info
->toc
;
2253 struct atapi_toc_header hdr
;
2254 struct atapi_toc_entry ent
;
2257 unsigned long sectors_per_frame
= SECTORS_PER_FRAME
;
2260 /* Try to allocate space. */
2261 toc
= kmalloc(sizeof(struct atapi_toc
), GFP_KERNEL
);
2263 printk (KERN_ERR
"%s: No cdrom TOC buffer!\n", drive
->name
);
2269 /* Check to see if the existing data is still valid.
2270 If it is, just return. */
2271 (void) cdrom_check_status(drive
, sense
);
2273 if (CDROM_STATE_FLAGS(drive
)->toc_valid
)
2276 /* Try to get the total cdrom capacity and sector size. */
2277 stat
= cdrom_read_capacity(drive
, &toc
->capacity
, §ors_per_frame
,
2280 toc
->capacity
= 0x1fffff;
2282 set_capacity(info
->disk
, toc
->capacity
* sectors_per_frame
);
2283 /* Save a private copy of te TOC capacity for error handling */
2284 drive
->probed_capacity
= toc
->capacity
* sectors_per_frame
;
2286 blk_queue_hardsect_size(drive
->queue
,
2287 sectors_per_frame
<< SECTOR_BITS
);
2289 /* First read just the header, so we know how long the TOC is. */
2290 stat
= cdrom_read_tocentry(drive
, 0, 1, 0, (char *) &toc
->hdr
,
2291 sizeof(struct atapi_toc_header
), sense
);
2295 #if ! STANDARD_ATAPI
2296 if (CDROM_CONFIG_FLAGS(drive
)->toctracks_as_bcd
) {
2297 toc
->hdr
.first_track
= bcd2bin(toc
->hdr
.first_track
);
2298 toc
->hdr
.last_track
= bcd2bin(toc
->hdr
.last_track
);
2300 #endif /* not STANDARD_ATAPI */
2302 ntracks
= toc
->hdr
.last_track
- toc
->hdr
.first_track
+ 1;
2305 if (ntracks
> MAX_TRACKS
)
2306 ntracks
= MAX_TRACKS
;
2308 /* Now read the whole schmeer. */
2309 stat
= cdrom_read_tocentry(drive
, toc
->hdr
.first_track
, 1, 0,
2311 sizeof(struct atapi_toc_header
) +
2313 sizeof(struct atapi_toc_entry
), sense
);
2315 if (stat
&& toc
->hdr
.first_track
> 1) {
2316 /* Cds with CDI tracks only don't have any TOC entries,
2317 despite of this the returned values are
2318 first_track == last_track = number of CDI tracks + 1,
2319 so that this case is indistinguishable from the same
2320 layout plus an additional audio track.
2321 If we get an error for the regular case, we assume
2322 a CDI without additional audio tracks. In this case
2323 the readable TOC is empty (CDI tracks are not included)
2324 and only holds the Leadout entry. Heiko Eißfeldt */
2326 stat
= cdrom_read_tocentry(drive
, CDROM_LEADOUT
, 1, 0,
2328 sizeof(struct atapi_toc_header
) +
2330 sizeof(struct atapi_toc_entry
),
2335 #if ! STANDARD_ATAPI
2336 if (CDROM_CONFIG_FLAGS(drive
)->toctracks_as_bcd
) {
2337 toc
->hdr
.first_track
= bin2bcd(CDROM_LEADOUT
);
2338 toc
->hdr
.last_track
= bin2bcd(CDROM_LEADOUT
);
2340 #endif /* not STANDARD_ATAPI */
2342 toc
->hdr
.first_track
= CDROM_LEADOUT
;
2343 toc
->hdr
.last_track
= CDROM_LEADOUT
;
2350 toc
->hdr
.toc_length
= ntohs (toc
->hdr
.toc_length
);
2352 #if ! STANDARD_ATAPI
2353 if (CDROM_CONFIG_FLAGS(drive
)->toctracks_as_bcd
) {
2354 toc
->hdr
.first_track
= bcd2bin(toc
->hdr
.first_track
);
2355 toc
->hdr
.last_track
= bcd2bin(toc
->hdr
.last_track
);
2357 #endif /* not STANDARD_ATAPI */
2359 for (i
=0; i
<=ntracks
; i
++) {
2360 #if ! STANDARD_ATAPI
2361 if (CDROM_CONFIG_FLAGS(drive
)->tocaddr_as_bcd
) {
2362 if (CDROM_CONFIG_FLAGS(drive
)->toctracks_as_bcd
)
2363 toc
->ent
[i
].track
= bcd2bin(toc
->ent
[i
].track
);
2364 msf_from_bcd(&toc
->ent
[i
].addr
.msf
);
2366 #endif /* not STANDARD_ATAPI */
2367 toc
->ent
[i
].addr
.lba
= msf_to_lba (toc
->ent
[i
].addr
.msf
.minute
,
2368 toc
->ent
[i
].addr
.msf
.second
,
2369 toc
->ent
[i
].addr
.msf
.frame
);
2372 /* Read the multisession information. */
2373 if (toc
->hdr
.first_track
!= CDROM_LEADOUT
) {
2374 /* Read the multisession information. */
2375 stat
= cdrom_read_tocentry(drive
, 0, 0, 1, (char *)&ms_tmp
,
2376 sizeof(ms_tmp
), sense
);
2380 toc
->last_session_lba
= be32_to_cpu(ms_tmp
.ent
.addr
.lba
);
2382 ms_tmp
.hdr
.first_track
= ms_tmp
.hdr
.last_track
= CDROM_LEADOUT
;
2383 toc
->last_session_lba
= msf_to_lba(0, 2, 0); /* 0m 2s 0f */
2386 #if ! STANDARD_ATAPI
2387 if (CDROM_CONFIG_FLAGS(drive
)->tocaddr_as_bcd
) {
2388 /* Re-read multisession information using MSF format */
2389 stat
= cdrom_read_tocentry(drive
, 0, 1, 1, (char *)&ms_tmp
,
2390 sizeof(ms_tmp
), sense
);
2394 msf_from_bcd (&ms_tmp
.ent
.addr
.msf
);
2395 toc
->last_session_lba
= msf_to_lba(ms_tmp
.ent
.addr
.msf
.minute
,
2396 ms_tmp
.ent
.addr
.msf
.second
,
2397 ms_tmp
.ent
.addr
.msf
.frame
);
2399 #endif /* not STANDARD_ATAPI */
2401 toc
->xa_flag
= (ms_tmp
.hdr
.first_track
!= ms_tmp
.hdr
.last_track
);
2403 /* Now try to get the total cdrom capacity. */
2404 stat
= cdrom_get_last_written(cdi
, &last_written
);
2405 if (!stat
&& (last_written
> toc
->capacity
)) {
2406 toc
->capacity
= last_written
;
2407 set_capacity(info
->disk
, toc
->capacity
* sectors_per_frame
);
2408 drive
->probed_capacity
= toc
->capacity
* sectors_per_frame
;
2411 /* Remember that we've read this stuff. */
2412 CDROM_STATE_FLAGS(drive
)->toc_valid
= 1;
2418 static int cdrom_read_subchannel(ide_drive_t
*drive
, int format
, char *buf
,
2419 int buflen
, struct request_sense
*sense
)
2423 cdrom_prepare_request(drive
, &req
);
2427 req
.data_len
= buflen
;
2428 req
.cmd
[0] = GPCMD_READ_SUBCHANNEL
;
2429 req
.cmd
[1] = 2; /* MSF addressing */
2430 req
.cmd
[2] = 0x40; /* request subQ data */
2431 req
.cmd
[3] = format
;
2432 req
.cmd
[7] = (buflen
>> 8);
2433 req
.cmd
[8] = (buflen
& 0xff);
2434 return cdrom_queue_packet_command(drive
, &req
);
2437 /* ATAPI cdrom drives are free to select the speed you request or any slower
2438 rate :-( Requesting too fast a speed will _not_ produce an error. */
2439 static int cdrom_select_speed(ide_drive_t
*drive
, int speed
,
2440 struct request_sense
*sense
)
2443 cdrom_prepare_request(drive
, &req
);
2447 speed
= 0xffff; /* set to max */
2449 speed
*= 177; /* Nx to kbytes/s */
2451 req
.cmd
[0] = GPCMD_SET_SPEED
;
2452 /* Read Drive speed in kbytes/second MSB */
2453 req
.cmd
[2] = (speed
>> 8) & 0xff;
2454 /* Read Drive speed in kbytes/second LSB */
2455 req
.cmd
[3] = speed
& 0xff;
2456 if (CDROM_CONFIG_FLAGS(drive
)->cd_r
||
2457 CDROM_CONFIG_FLAGS(drive
)->cd_rw
||
2458 CDROM_CONFIG_FLAGS(drive
)->dvd_r
) {
2459 /* Write Drive speed in kbytes/second MSB */
2460 req
.cmd
[4] = (speed
>> 8) & 0xff;
2461 /* Write Drive speed in kbytes/second LSB */
2462 req
.cmd
[5] = speed
& 0xff;
2465 return cdrom_queue_packet_command(drive
, &req
);
2468 static int cdrom_play_audio(ide_drive_t
*drive
, int lba_start
, int lba_end
)
2470 struct request_sense sense
;
2473 cdrom_prepare_request(drive
, &req
);
2476 req
.cmd
[0] = GPCMD_PLAY_AUDIO_MSF
;
2477 lba_to_msf(lba_start
, &req
.cmd
[3], &req
.cmd
[4], &req
.cmd
[5]);
2478 lba_to_msf(lba_end
-1, &req
.cmd
[6], &req
.cmd
[7], &req
.cmd
[8]);
2480 return cdrom_queue_packet_command(drive
, &req
);
2483 static int cdrom_get_toc_entry(ide_drive_t
*drive
, int track
,
2484 struct atapi_toc_entry
**ent
)
2486 struct cdrom_info
*info
= drive
->driver_data
;
2487 struct atapi_toc
*toc
= info
->toc
;
2491 * don't serve cached data, if the toc isn't valid
2493 if (!CDROM_STATE_FLAGS(drive
)->toc_valid
)
2496 /* Check validity of requested track number. */
2497 ntracks
= toc
->hdr
.last_track
- toc
->hdr
.first_track
+ 1;
2498 if (toc
->hdr
.first_track
== CDROM_LEADOUT
) ntracks
= 0;
2499 if (track
== CDROM_LEADOUT
)
2500 *ent
= &toc
->ent
[ntracks
];
2501 else if (track
< toc
->hdr
.first_track
||
2502 track
> toc
->hdr
.last_track
)
2505 *ent
= &toc
->ent
[track
- toc
->hdr
.first_track
];
2510 /* the generic packet interface to cdrom.c */
2511 static int ide_cdrom_packet(struct cdrom_device_info
*cdi
,
2512 struct packet_command
*cgc
)
2515 ide_drive_t
*drive
= cdi
->handle
;
2517 if (cgc
->timeout
<= 0)
2518 cgc
->timeout
= ATAPI_WAIT_PC
;
2520 /* here we queue the commands from the uniform CD-ROM
2521 layer. the packet must be complete, as we do not
2523 cdrom_prepare_request(drive
, &req
);
2524 memcpy(req
.cmd
, cgc
->cmd
, CDROM_PACKET_SIZE
);
2526 memset(cgc
->sense
, 0, sizeof(struct request_sense
));
2527 req
.data
= cgc
->buffer
;
2528 req
.data_len
= cgc
->buflen
;
2529 req
.timeout
= cgc
->timeout
;
2532 req
.cmd_flags
|= REQ_QUIET
;
2534 req
.sense
= cgc
->sense
;
2535 cgc
->stat
= cdrom_queue_packet_command(drive
, &req
);
2537 cgc
->buflen
-= req
.data_len
;
2542 int ide_cdrom_audio_ioctl (struct cdrom_device_info
*cdi
,
2543 unsigned int cmd
, void *arg
)
2546 ide_drive_t
*drive
= cdi
->handle
;
2547 struct cdrom_info
*info
= drive
->driver_data
;
2552 * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
2553 * atapi doesn't support it
2555 case CDROMPLAYTRKIND
: {
2556 unsigned long lba_start
, lba_end
;
2557 struct cdrom_ti
*ti
= arg
;
2558 struct atapi_toc_entry
*first_toc
, *last_toc
;
2560 stat
= cdrom_get_toc_entry(drive
, ti
->cdti_trk0
, &first_toc
);
2564 stat
= cdrom_get_toc_entry(drive
, ti
->cdti_trk1
, &last_toc
);
2568 if (ti
->cdti_trk1
!= CDROM_LEADOUT
)
2570 lba_start
= first_toc
->addr
.lba
;
2571 lba_end
= last_toc
->addr
.lba
;
2573 if (lba_end
<= lba_start
)
2576 return cdrom_play_audio(drive
, lba_start
, lba_end
);
2579 case CDROMREADTOCHDR
: {
2580 struct cdrom_tochdr
*tochdr
= arg
;
2581 struct atapi_toc
*toc
;
2583 /* Make sure our saved TOC is valid. */
2584 stat
= cdrom_read_toc(drive
, NULL
);
2589 tochdr
->cdth_trk0
= toc
->hdr
.first_track
;
2590 tochdr
->cdth_trk1
= toc
->hdr
.last_track
;
2595 case CDROMREADTOCENTRY
: {
2596 struct cdrom_tocentry
*tocentry
= arg
;
2597 struct atapi_toc_entry
*toce
;
2599 stat
= cdrom_get_toc_entry(drive
, tocentry
->cdte_track
, &toce
);
2603 tocentry
->cdte_ctrl
= toce
->control
;
2604 tocentry
->cdte_adr
= toce
->adr
;
2605 if (tocentry
->cdte_format
== CDROM_MSF
) {
2606 lba_to_msf (toce
->addr
.lba
,
2607 &tocentry
->cdte_addr
.msf
.minute
,
2608 &tocentry
->cdte_addr
.msf
.second
,
2609 &tocentry
->cdte_addr
.msf
.frame
);
2611 tocentry
->cdte_addr
.lba
= toce
->addr
.lba
;
2622 int ide_cdrom_reset (struct cdrom_device_info
*cdi
)
2624 ide_drive_t
*drive
= cdi
->handle
;
2625 struct request_sense sense
;
2629 cdrom_prepare_request(drive
, &req
);
2630 req
.cmd_type
= REQ_TYPE_SPECIAL
;
2631 req
.cmd_flags
= REQ_QUIET
;
2632 ret
= ide_do_drive_cmd(drive
, &req
, ide_wait
);
2635 * A reset will unlock the door. If it was previously locked,
2638 if (CDROM_STATE_FLAGS(drive
)->door_locked
)
2639 (void) cdrom_lockdoor(drive
, 1, &sense
);
2646 int ide_cdrom_tray_move (struct cdrom_device_info
*cdi
, int position
)
2648 ide_drive_t
*drive
= cdi
->handle
;
2649 struct request_sense sense
;
2652 int stat
= cdrom_lockdoor(drive
, 0, &sense
);
2657 return cdrom_eject(drive
, !position
, &sense
);
2661 int ide_cdrom_lock_door (struct cdrom_device_info
*cdi
, int lock
)
2663 ide_drive_t
*drive
= cdi
->handle
;
2664 return cdrom_lockdoor(drive
, lock
, NULL
);
2668 int ide_cdrom_get_capabilities(ide_drive_t
*drive
, struct atapi_capabilities_page
*cap
)
2670 struct cdrom_info
*info
= drive
->driver_data
;
2671 struct cdrom_device_info
*cdi
= &info
->devinfo
;
2672 struct packet_command cgc
;
2673 int stat
, attempts
= 3, size
= sizeof(*cap
);
2676 * ACER50 (and others?) require the full spec length mode sense
2677 * page capabilities size, but older drives break.
2679 if (!(!strcmp(drive
->id
->model
, "ATAPI CD ROM DRIVE 50X MAX") ||
2680 !strcmp(drive
->id
->model
, "WPI CDS-32X")))
2681 size
-= sizeof(cap
->pad
);
2683 init_cdrom_command(&cgc
, cap
, size
, CGC_DATA_UNKNOWN
);
2684 do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2685 stat
= cdrom_mode_sense(cdi
, &cgc
, GPMODE_CAPABILITIES_PAGE
, 0);
2688 } while (--attempts
);
2693 void ide_cdrom_update_speed (ide_drive_t
*drive
, struct atapi_capabilities_page
*cap
)
2695 /* The ACER/AOpen 24X cdrom has the speed fields byte-swapped */
2696 if (!drive
->id
->model
[0] &&
2697 !strncmp(drive
->id
->fw_rev
, "241N", 4)) {
2698 CDROM_STATE_FLAGS(drive
)->current_speed
=
2699 (le16_to_cpu(cap
->curspeed
) + (176/2)) / 176;
2700 CDROM_CONFIG_FLAGS(drive
)->max_speed
=
2701 (le16_to_cpu(cap
->maxspeed
) + (176/2)) / 176;
2703 CDROM_STATE_FLAGS(drive
)->current_speed
=
2704 (be16_to_cpu(cap
->curspeed
) + (176/2)) / 176;
2705 CDROM_CONFIG_FLAGS(drive
)->max_speed
=
2706 (be16_to_cpu(cap
->maxspeed
) + (176/2)) / 176;
2711 int ide_cdrom_select_speed (struct cdrom_device_info
*cdi
, int speed
)
2713 ide_drive_t
*drive
= cdi
->handle
;
2714 struct request_sense sense
;
2715 struct atapi_capabilities_page cap
;
2718 if ((stat
= cdrom_select_speed(drive
, speed
, &sense
)) < 0)
2721 if (!ide_cdrom_get_capabilities(drive
, &cap
)) {
2722 ide_cdrom_update_speed(drive
, &cap
);
2723 cdi
->speed
= CDROM_STATE_FLAGS(drive
)->current_speed
;
2729 * add logic to try GET_EVENT command first to check for media and tray
2730 * status. this should be supported by newer cd-r/w and all DVD etc
2734 int ide_cdrom_drive_status (struct cdrom_device_info
*cdi
, int slot_nr
)
2736 ide_drive_t
*drive
= cdi
->handle
;
2737 struct media_event_desc med
;
2738 struct request_sense sense
;
2741 if (slot_nr
!= CDSL_CURRENT
)
2744 stat
= cdrom_check_status(drive
, &sense
);
2745 if (!stat
|| sense
.sense_key
== UNIT_ATTENTION
)
2748 if (!cdrom_get_media_event(cdi
, &med
)) {
2749 if (med
.media_present
)
2751 else if (med
.door_open
)
2752 return CDS_TRAY_OPEN
;
2757 if (sense
.sense_key
== NOT_READY
&& sense
.asc
== 0x04 && sense
.ascq
== 0x04)
2761 * If not using Mt Fuji extended media tray reports,
2762 * just return TRAY_OPEN since ATAPI doesn't provide
2763 * any other way to detect this...
2765 if (sense
.sense_key
== NOT_READY
) {
2766 if (sense
.asc
== 0x3a && sense
.ascq
== 1)
2769 return CDS_TRAY_OPEN
;
2771 return CDS_DRIVE_NOT_READY
;
2775 int ide_cdrom_get_last_session (struct cdrom_device_info
*cdi
,
2776 struct cdrom_multisession
*ms_info
)
2778 struct atapi_toc
*toc
;
2779 ide_drive_t
*drive
= cdi
->handle
;
2780 struct cdrom_info
*info
= drive
->driver_data
;
2781 struct request_sense sense
;
2784 if (!CDROM_STATE_FLAGS(drive
)->toc_valid
|| info
->toc
== NULL
)
2785 if ((ret
= cdrom_read_toc(drive
, &sense
)))
2789 ms_info
->addr
.lba
= toc
->last_session_lba
;
2790 ms_info
->xa_flag
= toc
->xa_flag
;
2796 int ide_cdrom_get_mcn (struct cdrom_device_info
*cdi
,
2797 struct cdrom_mcn
*mcn_info
)
2801 ide_drive_t
*drive
= cdi
->handle
;
2804 if ((stat
= cdrom_read_subchannel(drive
, 2, mcnbuf
, sizeof (mcnbuf
), NULL
)))
2807 memcpy (mcn_info
->medium_catalog_number
, mcnbuf
+9,
2808 sizeof (mcn_info
->medium_catalog_number
)-1);
2809 mcn_info
->medium_catalog_number
[sizeof (mcn_info
->medium_catalog_number
)-1]
2817 /****************************************************************************
2818 * Other driver requests (open, close, check media change).
2822 int ide_cdrom_check_media_change_real (struct cdrom_device_info
*cdi
,
2825 ide_drive_t
*drive
= cdi
->handle
;
2828 if (slot_nr
== CDSL_CURRENT
) {
2829 (void) cdrom_check_status(drive
, NULL
);
2830 retval
= CDROM_STATE_FLAGS(drive
)->media_changed
;
2831 CDROM_STATE_FLAGS(drive
)->media_changed
= 0;
2840 int ide_cdrom_open_real (struct cdrom_device_info
*cdi
, int purpose
)
2846 * Close down the device. Invalidate all cached blocks.
2850 void ide_cdrom_release_real (struct cdrom_device_info
*cdi
)
2852 ide_drive_t
*drive
= cdi
->handle
;
2854 if (!cdi
->use_count
)
2855 CDROM_STATE_FLAGS(drive
)->toc_valid
= 0;
2860 /****************************************************************************
2861 * Device initialization.
2863 static struct cdrom_device_ops ide_cdrom_dops
= {
2864 .open
= ide_cdrom_open_real
,
2865 .release
= ide_cdrom_release_real
,
2866 .drive_status
= ide_cdrom_drive_status
,
2867 .media_changed
= ide_cdrom_check_media_change_real
,
2868 .tray_move
= ide_cdrom_tray_move
,
2869 .lock_door
= ide_cdrom_lock_door
,
2870 .select_speed
= ide_cdrom_select_speed
,
2871 .get_last_session
= ide_cdrom_get_last_session
,
2872 .get_mcn
= ide_cdrom_get_mcn
,
2873 .reset
= ide_cdrom_reset
,
2874 .audio_ioctl
= ide_cdrom_audio_ioctl
,
2875 .capability
= CDC_CLOSE_TRAY
| CDC_OPEN_TRAY
| CDC_LOCK
|
2876 CDC_SELECT_SPEED
| CDC_SELECT_DISC
|
2877 CDC_MULTI_SESSION
| CDC_MCN
|
2878 CDC_MEDIA_CHANGED
| CDC_PLAY_AUDIO
| CDC_RESET
|
2879 CDC_DRIVE_STATUS
| CDC_CD_R
|
2880 CDC_CD_RW
| CDC_DVD
| CDC_DVD_R
| CDC_DVD_RAM
|
2881 CDC_GENERIC_PACKET
| CDC_MO_DRIVE
| CDC_MRW
|
2882 CDC_MRW_W
| CDC_RAM
,
2883 .generic_packet
= ide_cdrom_packet
,
2886 static int ide_cdrom_register (ide_drive_t
*drive
, int nslots
)
2888 struct cdrom_info
*info
= drive
->driver_data
;
2889 struct cdrom_device_info
*devinfo
= &info
->devinfo
;
2891 devinfo
->ops
= &ide_cdrom_dops
;
2893 devinfo
->speed
= CDROM_STATE_FLAGS(drive
)->current_speed
;
2894 devinfo
->capacity
= nslots
;
2895 devinfo
->handle
= drive
;
2896 strcpy(devinfo
->name
, drive
->name
);
2898 /* set capability mask to match the probe. */
2899 if (!CDROM_CONFIG_FLAGS(drive
)->cd_r
)
2900 devinfo
->mask
|= CDC_CD_R
;
2901 if (!CDROM_CONFIG_FLAGS(drive
)->cd_rw
)
2902 devinfo
->mask
|= CDC_CD_RW
;
2903 if (!CDROM_CONFIG_FLAGS(drive
)->dvd
)
2904 devinfo
->mask
|= CDC_DVD
;
2905 if (!CDROM_CONFIG_FLAGS(drive
)->dvd_r
)
2906 devinfo
->mask
|= CDC_DVD_R
;
2907 if (!CDROM_CONFIG_FLAGS(drive
)->dvd_ram
)
2908 devinfo
->mask
|= CDC_DVD_RAM
;
2909 if (!CDROM_CONFIG_FLAGS(drive
)->is_changer
)
2910 devinfo
->mask
|= CDC_SELECT_DISC
;
2911 if (!CDROM_CONFIG_FLAGS(drive
)->audio_play
)
2912 devinfo
->mask
|= CDC_PLAY_AUDIO
;
2913 if (!CDROM_CONFIG_FLAGS(drive
)->close_tray
)
2914 devinfo
->mask
|= CDC_CLOSE_TRAY
;
2915 if (!CDROM_CONFIG_FLAGS(drive
)->mo_drive
)
2916 devinfo
->mask
|= CDC_MO_DRIVE
;
2917 if (!CDROM_CONFIG_FLAGS(drive
)->ram
)
2918 devinfo
->mask
|= CDC_RAM
;
2920 if (CDROM_CONFIG_FLAGS(drive
)->no_speed_select
)
2921 devinfo
->mask
|= CDC_SELECT_SPEED
;
2923 devinfo
->disk
= info
->disk
;
2924 return register_cdrom(devinfo
);
2928 int ide_cdrom_probe_capabilities (ide_drive_t
*drive
)
2930 struct cdrom_info
*info
= drive
->driver_data
;
2931 struct cdrom_device_info
*cdi
= &info
->devinfo
;
2932 struct atapi_capabilities_page cap
;
2935 if (drive
->media
== ide_optical
) {
2936 CDROM_CONFIG_FLAGS(drive
)->mo_drive
= 1;
2937 CDROM_CONFIG_FLAGS(drive
)->ram
= 1;
2938 printk(KERN_ERR
"%s: ATAPI magneto-optical drive\n", drive
->name
);
2942 if (CDROM_CONFIG_FLAGS(drive
)->nec260
||
2943 !strcmp(drive
->id
->model
,"STINGRAY 8422 IDE 8X CD-ROM 7-27-95")) {
2944 CDROM_CONFIG_FLAGS(drive
)->no_eject
= 0;
2945 CDROM_CONFIG_FLAGS(drive
)->audio_play
= 1;
2950 * we have to cheat a little here. the packet will eventually
2951 * be queued with ide_cdrom_packet(), which extracts the
2952 * drive from cdi->handle. Since this device hasn't been
2953 * registered with the Uniform layer yet, it can't do this.
2954 * Same goes for cdi->ops.
2956 cdi
->handle
= drive
;
2957 cdi
->ops
= &ide_cdrom_dops
;
2959 if (ide_cdrom_get_capabilities(drive
, &cap
))
2963 CDROM_CONFIG_FLAGS(drive
)->no_doorlock
= 1;
2965 CDROM_CONFIG_FLAGS(drive
)->no_eject
= 0;
2967 CDROM_CONFIG_FLAGS(drive
)->cd_r
= 1;
2968 if (cap
.cd_rw_write
) {
2969 CDROM_CONFIG_FLAGS(drive
)->cd_rw
= 1;
2970 CDROM_CONFIG_FLAGS(drive
)->ram
= 1;
2973 CDROM_CONFIG_FLAGS(drive
)->test_write
= 1;
2974 if (cap
.dvd_ram_read
|| cap
.dvd_r_read
|| cap
.dvd_rom
)
2975 CDROM_CONFIG_FLAGS(drive
)->dvd
= 1;
2976 if (cap
.dvd_ram_write
) {
2977 CDROM_CONFIG_FLAGS(drive
)->dvd_ram
= 1;
2978 CDROM_CONFIG_FLAGS(drive
)->ram
= 1;
2980 if (cap
.dvd_r_write
)
2981 CDROM_CONFIG_FLAGS(drive
)->dvd_r
= 1;
2983 CDROM_CONFIG_FLAGS(drive
)->audio_play
= 1;
2984 if (cap
.mechtype
== mechtype_caddy
|| cap
.mechtype
== mechtype_popup
)
2985 CDROM_CONFIG_FLAGS(drive
)->close_tray
= 0;
2987 /* Some drives used by Apple don't advertise audio play
2988 * but they do support reading TOC & audio datas
2990 if (strcmp(drive
->id
->model
, "MATSHITADVD-ROM SR-8187") == 0 ||
2991 strcmp(drive
->id
->model
, "MATSHITADVD-ROM SR-8186") == 0 ||
2992 strcmp(drive
->id
->model
, "MATSHITADVD-ROM SR-8176") == 0 ||
2993 strcmp(drive
->id
->model
, "MATSHITADVD-ROM SR-8174") == 0)
2994 CDROM_CONFIG_FLAGS(drive
)->audio_play
= 1;
2996 #if ! STANDARD_ATAPI
2997 if (cdi
->sanyo_slot
> 0) {
2998 CDROM_CONFIG_FLAGS(drive
)->is_changer
= 1;
3003 #endif /* not STANDARD_ATAPI */
3004 if (cap
.mechtype
== mechtype_individual_changer
||
3005 cap
.mechtype
== mechtype_cartridge_changer
) {
3006 if ((nslots
= cdrom_number_of_slots(cdi
)) > 1) {
3007 CDROM_CONFIG_FLAGS(drive
)->is_changer
= 1;
3008 CDROM_CONFIG_FLAGS(drive
)->supp_disc_present
= 1;
3012 ide_cdrom_update_speed(drive
, &cap
);
3013 /* don't print speed if the drive reported 0.
3015 printk(KERN_INFO
"%s: ATAPI", drive
->name
);
3016 if (CDROM_CONFIG_FLAGS(drive
)->max_speed
)
3017 printk(" %dX", CDROM_CONFIG_FLAGS(drive
)->max_speed
);
3018 printk(" %s", CDROM_CONFIG_FLAGS(drive
)->dvd
? "DVD-ROM" : "CD-ROM");
3020 if (CDROM_CONFIG_FLAGS(drive
)->dvd_r
|CDROM_CONFIG_FLAGS(drive
)->dvd_ram
)
3022 (CDROM_CONFIG_FLAGS(drive
)->dvd_r
)? "-R" : "",
3023 (CDROM_CONFIG_FLAGS(drive
)->dvd_ram
)? "-RAM" : "");
3025 if (CDROM_CONFIG_FLAGS(drive
)->cd_r
|CDROM_CONFIG_FLAGS(drive
)->cd_rw
)
3027 (CDROM_CONFIG_FLAGS(drive
)->cd_r
)? "-R" : "",
3028 (CDROM_CONFIG_FLAGS(drive
)->cd_rw
)? "/RW" : "");
3030 if (CDROM_CONFIG_FLAGS(drive
)->is_changer
)
3031 printk(" changer w/%d slots", nslots
);
3035 printk(KERN_CONT
", %dkB Cache\n", be16_to_cpu(cap
.buffer_size
));
3040 #ifdef CONFIG_IDE_PROC_FS
3041 static void ide_cdrom_add_settings(ide_drive_t
*drive
)
3043 ide_add_setting(drive
, "dsc_overlap", SETTING_RW
, TYPE_BYTE
, 0, 1, 1, 1, &drive
->dsc_overlap
, NULL
);
3046 static inline void ide_cdrom_add_settings(ide_drive_t
*drive
) { ; }
3050 * standard prep_rq_fn that builds 10 byte cmds
3052 static int ide_cdrom_prep_fs(struct request_queue
*q
, struct request
*rq
)
3054 int hard_sect
= queue_hardsect_size(q
);
3055 long block
= (long)rq
->hard_sector
/ (hard_sect
>> 9);
3056 unsigned long blocks
= rq
->hard_nr_sectors
/ (hard_sect
>> 9);
3058 memset(rq
->cmd
, 0, sizeof(rq
->cmd
));
3060 if (rq_data_dir(rq
) == READ
)
3061 rq
->cmd
[0] = GPCMD_READ_10
;
3063 rq
->cmd
[0] = GPCMD_WRITE_10
;
3068 rq
->cmd
[2] = (block
>> 24) & 0xff;
3069 rq
->cmd
[3] = (block
>> 16) & 0xff;
3070 rq
->cmd
[4] = (block
>> 8) & 0xff;
3071 rq
->cmd
[5] = block
& 0xff;
3074 * and transfer length
3076 rq
->cmd
[7] = (blocks
>> 8) & 0xff;
3077 rq
->cmd
[8] = blocks
& 0xff;
3083 * Most of the SCSI commands are supported directly by ATAPI devices.
3084 * This transform handles the few exceptions.
3086 static int ide_cdrom_prep_pc(struct request
*rq
)
3091 * Transform 6-byte read/write commands to the 10-byte version
3093 if (c
[0] == READ_6
|| c
[0] == WRITE_6
) {
3100 c
[0] += (READ_10
- READ_6
);
3106 * it's silly to pretend we understand 6-byte sense commands, just
3107 * reject with ILLEGAL_REQUEST and the caller should take the
3108 * appropriate action
3110 if (c
[0] == MODE_SENSE
|| c
[0] == MODE_SELECT
) {
3111 rq
->errors
= ILLEGAL_REQUEST
;
3112 return BLKPREP_KILL
;
3118 static int ide_cdrom_prep_fn(struct request_queue
*q
, struct request
*rq
)
3120 if (blk_fs_request(rq
))
3121 return ide_cdrom_prep_fs(q
, rq
);
3122 else if (blk_pc_request(rq
))
3123 return ide_cdrom_prep_pc(rq
);
3129 int ide_cdrom_setup (ide_drive_t
*drive
)
3131 struct cdrom_info
*info
= drive
->driver_data
;
3132 struct cdrom_device_info
*cdi
= &info
->devinfo
;
3135 blk_queue_prep_rq(drive
->queue
, ide_cdrom_prep_fn
);
3136 blk_queue_dma_alignment(drive
->queue
, 31);
3137 drive
->queue
->unplug_delay
= (1 * HZ
) / 1000;
3138 if (!drive
->queue
->unplug_delay
)
3139 drive
->queue
->unplug_delay
= 1;
3141 drive
->special
.all
= 0;
3143 CDROM_STATE_FLAGS(drive
)->media_changed
= 1;
3144 CDROM_STATE_FLAGS(drive
)->toc_valid
= 0;
3145 CDROM_STATE_FLAGS(drive
)->door_locked
= 0;
3148 CDROM_CONFIG_FLAGS(drive
)->no_doorlock
= 1;
3150 CDROM_CONFIG_FLAGS(drive
)->no_doorlock
= 0;
3153 CDROM_CONFIG_FLAGS(drive
)->drq_interrupt
= ((drive
->id
->config
& 0x0060) == 0x20);
3154 CDROM_CONFIG_FLAGS(drive
)->is_changer
= 0;
3155 CDROM_CONFIG_FLAGS(drive
)->cd_r
= 0;
3156 CDROM_CONFIG_FLAGS(drive
)->cd_rw
= 0;
3157 CDROM_CONFIG_FLAGS(drive
)->test_write
= 0;
3158 CDROM_CONFIG_FLAGS(drive
)->dvd
= 0;
3159 CDROM_CONFIG_FLAGS(drive
)->dvd_r
= 0;
3160 CDROM_CONFIG_FLAGS(drive
)->dvd_ram
= 0;
3161 CDROM_CONFIG_FLAGS(drive
)->no_eject
= 1;
3162 CDROM_CONFIG_FLAGS(drive
)->supp_disc_present
= 0;
3163 CDROM_CONFIG_FLAGS(drive
)->audio_play
= 0;
3164 CDROM_CONFIG_FLAGS(drive
)->close_tray
= 1;
3166 /* limit transfer size per interrupt. */
3167 CDROM_CONFIG_FLAGS(drive
)->limit_nframes
= 0;
3168 /* a testament to the nice quality of Samsung drives... */
3169 if (!strcmp(drive
->id
->model
, "SAMSUNG CD-ROM SCR-2430"))
3170 CDROM_CONFIG_FLAGS(drive
)->limit_nframes
= 1;
3171 else if (!strcmp(drive
->id
->model
, "SAMSUNG CD-ROM SCR-2432"))
3172 CDROM_CONFIG_FLAGS(drive
)->limit_nframes
= 1;
3173 /* the 3231 model does not support the SET_CD_SPEED command */
3174 else if (!strcmp(drive
->id
->model
, "SAMSUNG CD-ROM SCR-3231"))
3175 CDROM_CONFIG_FLAGS(drive
)->no_speed_select
= 1;
3177 #if ! STANDARD_ATAPI
3178 /* by default Sanyo 3 CD changer support is turned off and
3179 ATAPI Rev 2.2+ standard support for CD changers is used */
3180 cdi
->sanyo_slot
= 0;
3182 CDROM_CONFIG_FLAGS(drive
)->nec260
= 0;
3183 CDROM_CONFIG_FLAGS(drive
)->toctracks_as_bcd
= 0;
3184 CDROM_CONFIG_FLAGS(drive
)->tocaddr_as_bcd
= 0;
3185 CDROM_CONFIG_FLAGS(drive
)->playmsf_as_bcd
= 0;
3186 CDROM_CONFIG_FLAGS(drive
)->subchan_as_bcd
= 0;
3188 if (strcmp (drive
->id
->model
, "V003S0DS") == 0 &&
3189 drive
->id
->fw_rev
[4] == '1' &&
3190 drive
->id
->fw_rev
[6] <= '2') {
3192 Some versions of this drive like to talk BCD. */
3193 CDROM_CONFIG_FLAGS(drive
)->toctracks_as_bcd
= 1;
3194 CDROM_CONFIG_FLAGS(drive
)->tocaddr_as_bcd
= 1;
3195 CDROM_CONFIG_FLAGS(drive
)->playmsf_as_bcd
= 1;
3196 CDROM_CONFIG_FLAGS(drive
)->subchan_as_bcd
= 1;
3199 else if (strcmp (drive
->id
->model
, "V006E0DS") == 0 &&
3200 drive
->id
->fw_rev
[4] == '1' &&
3201 drive
->id
->fw_rev
[6] <= '2') {
3202 /* Vertos 600 ESD. */
3203 CDROM_CONFIG_FLAGS(drive
)->toctracks_as_bcd
= 1;
3205 else if (strcmp(drive
->id
->model
, "NEC CD-ROM DRIVE:260") == 0 &&
3206 strncmp(drive
->id
->fw_rev
, "1.01", 4) == 0) { /* FIXME */
3207 /* Old NEC260 (not R).
3208 This drive was released before the 1.2 version
3210 CDROM_CONFIG_FLAGS(drive
)->tocaddr_as_bcd
= 1;
3211 CDROM_CONFIG_FLAGS(drive
)->playmsf_as_bcd
= 1;
3212 CDROM_CONFIG_FLAGS(drive
)->subchan_as_bcd
= 1;
3213 CDROM_CONFIG_FLAGS(drive
)->nec260
= 1;
3215 else if (strcmp(drive
->id
->model
, "WEARNES CDD-120") == 0 &&
3216 strncmp(drive
->id
->fw_rev
, "A1.1", 4) == 0) { /* FIXME */
3218 CDROM_CONFIG_FLAGS(drive
)->playmsf_as_bcd
= 1;
3219 CDROM_CONFIG_FLAGS(drive
)->subchan_as_bcd
= 1;
3221 /* Sanyo 3 CD changer uses a non-standard command
3223 else if ((strcmp(drive
->id
->model
, "CD-ROM CDR-C3 G") == 0) ||
3224 (strcmp(drive
->id
->model
, "CD-ROM CDR-C3G") == 0) ||
3225 (strcmp(drive
->id
->model
, "CD-ROM CDR_C36") == 0)) {
3226 /* uses CD in slot 0 when value is set to 3 */
3227 cdi
->sanyo_slot
= 3;
3229 #endif /* not STANDARD_ATAPI */
3232 info
->buffer
= NULL
;
3233 info
->sector_buffered
= 0;
3234 info
->nsectors_buffered
= 0;
3235 info
->changer_info
= NULL
;
3236 info
->last_block
= 0;
3237 info
->start_seek
= 0;
3239 nslots
= ide_cdrom_probe_capabilities (drive
);
3242 * set correct block size
3244 blk_queue_hardsect_size(drive
->queue
, CD_FRAMESIZE
);
3246 if (drive
->autotune
== IDE_TUNE_DEFAULT
||
3247 drive
->autotune
== IDE_TUNE_AUTO
)
3248 drive
->dsc_overlap
= (drive
->next
!= drive
);
3250 if (ide_cdrom_register(drive
, nslots
)) {
3251 printk (KERN_ERR
"%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive
->name
);
3252 info
->devinfo
.handle
= NULL
;
3255 ide_cdrom_add_settings(drive
);
3259 #ifdef CONFIG_IDE_PROC_FS
3261 sector_t
ide_cdrom_capacity (ide_drive_t
*drive
)
3263 unsigned long capacity
, sectors_per_frame
;
3265 if (cdrom_read_capacity(drive
, &capacity
, §ors_per_frame
, NULL
))
3268 return capacity
* sectors_per_frame
;
3272 static void ide_cd_remove(ide_drive_t
*drive
)
3274 struct cdrom_info
*info
= drive
->driver_data
;
3276 ide_proc_unregister_driver(drive
, info
->driver
);
3278 del_gendisk(info
->disk
);
3283 static void ide_cd_release(struct kref
*kref
)
3285 struct cdrom_info
*info
= to_ide_cd(kref
);
3286 struct cdrom_device_info
*devinfo
= &info
->devinfo
;
3287 ide_drive_t
*drive
= info
->drive
;
3288 struct gendisk
*g
= info
->disk
;
3290 kfree(info
->buffer
);
3292 kfree(info
->changer_info
);
3293 if (devinfo
->handle
== drive
&& unregister_cdrom(devinfo
))
3294 printk(KERN_ERR
"%s: %s failed to unregister device from the cdrom "
3295 "driver.\n", __FUNCTION__
, drive
->name
);
3296 drive
->dsc_overlap
= 0;
3297 drive
->driver_data
= NULL
;
3298 blk_queue_prep_rq(drive
->queue
, NULL
);
3299 g
->private_data
= NULL
;
3304 static int ide_cd_probe(ide_drive_t
*);
3306 #ifdef CONFIG_IDE_PROC_FS
3307 static int proc_idecd_read_capacity
3308 (char *page
, char **start
, off_t off
, int count
, int *eof
, void *data
)
3310 ide_drive_t
*drive
= data
;
3313 len
= sprintf(page
,"%llu\n", (long long)ide_cdrom_capacity(drive
));
3314 PROC_IDE_READ_RETURN(page
,start
,off
,count
,eof
,len
);
3317 static ide_proc_entry_t idecd_proc
[] = {
3318 { "capacity", S_IFREG
|S_IRUGO
, proc_idecd_read_capacity
, NULL
},
3319 { NULL
, 0, NULL
, NULL
}
3323 static ide_driver_t ide_cdrom_driver
= {
3325 .owner
= THIS_MODULE
,
3326 .name
= "ide-cdrom",
3327 .bus
= &ide_bus_type
,
3329 .probe
= ide_cd_probe
,
3330 .remove
= ide_cd_remove
,
3331 .version
= IDECD_VERSION
,
3333 .supports_dsc_overlap
= 1,
3334 .do_request
= ide_do_rw_cdrom
,
3335 .end_request
= ide_end_request
,
3336 .error
= __ide_error
,
3337 .abort
= __ide_abort
,
3338 #ifdef CONFIG_IDE_PROC_FS
3343 static int idecd_open(struct inode
* inode
, struct file
* file
)
3345 struct gendisk
*disk
= inode
->i_bdev
->bd_disk
;
3346 struct cdrom_info
*info
;
3349 if (!(info
= ide_cd_get(disk
)))
3353 info
->buffer
= kmalloc(SECTOR_BUFFER_SIZE
, GFP_KERNEL
|__GFP_REPEAT
);
3356 rc
= cdrom_open(&info
->devinfo
, inode
, file
);
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
);
3369 cdrom_release (&info
->devinfo
, file
);
3376 static int idecd_set_spindown(struct cdrom_device_info
*cdi
, unsigned long arg
)
3378 struct packet_command cgc
;
3383 if (copy_from_user(&spindown
, (void __user
*)arg
, sizeof(char)))
3386 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_UNKNOWN
);
3388 stat
= cdrom_mode_sense(cdi
, &cgc
, GPMODE_CDROM_PAGE
, 0);
3392 buffer
[11] = (buffer
[11] & 0xf0) | (spindown
& 0x0f);
3393 return cdrom_mode_select(cdi
, &cgc
);
3396 static int idecd_get_spindown(struct cdrom_device_info
*cdi
, unsigned long arg
)
3398 struct packet_command cgc
;
3403 init_cdrom_command(&cgc
, buffer
, sizeof(buffer
), CGC_DATA_UNKNOWN
);
3405 stat
= cdrom_mode_sense(cdi
, &cgc
, GPMODE_CDROM_PAGE
, 0);
3409 spindown
= buffer
[11] & 0x0f;
3410 if (copy_to_user((void __user
*)arg
, &spindown
, sizeof (char)))
3415 static int idecd_ioctl (struct inode
*inode
, struct file
*file
,
3416 unsigned int cmd
, unsigned long arg
)
3418 struct block_device
*bdev
= inode
->i_bdev
;
3419 struct cdrom_info
*info
= ide_cd_g(bdev
->bd_disk
);
3423 case CDROMSETSPINDOWN
:
3424 return idecd_set_spindown(&info
->devinfo
, arg
);
3425 case CDROMGETSPINDOWN
:
3426 return idecd_get_spindown(&info
->devinfo
, arg
);
3431 err
= generic_ide_ioctl(info
->drive
, file
, bdev
, cmd
, arg
);
3433 err
= cdrom_ioctl(file
, &info
->devinfo
, inode
, cmd
, arg
);
3438 static int idecd_media_changed(struct gendisk
*disk
)
3440 struct cdrom_info
*info
= ide_cd_g(disk
);
3441 return cdrom_media_changed(&info
->devinfo
);
3444 static int idecd_revalidate_disk(struct gendisk
*disk
)
3446 struct cdrom_info
*info
= ide_cd_g(disk
);
3447 struct request_sense sense
;
3448 cdrom_read_toc(info
->drive
, &sense
);
3452 static struct block_device_operations idecd_ops
= {
3453 .owner
= THIS_MODULE
,
3455 .release
= idecd_release
,
3456 .ioctl
= idecd_ioctl
,
3457 .media_changed
= idecd_media_changed
,
3458 .revalidate_disk
= idecd_revalidate_disk
3462 static char *ignore
= NULL
;
3464 module_param(ignore
, charp
, 0400);
3465 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
3467 static int ide_cd_probe(ide_drive_t
*drive
)
3469 struct cdrom_info
*info
;
3471 struct request_sense sense
;
3473 if (!strstr("ide-cdrom", drive
->driver_req
))
3475 if (!drive
->present
)
3477 if (drive
->media
!= ide_cdrom
&& drive
->media
!= ide_optical
)
3479 /* skip drives that we were told to ignore */
3480 if (ignore
!= NULL
) {
3481 if (strstr(ignore
, drive
->name
)) {
3482 printk(KERN_INFO
"ide-cd: ignoring drive %s\n", drive
->name
);
3487 printk(KERN_INFO
"ide-cd: passing drive %s to ide-scsi emulation.\n", drive
->name
);
3490 info
= kzalloc(sizeof(struct cdrom_info
), GFP_KERNEL
);
3492 printk(KERN_ERR
"%s: Can't allocate a cdrom structure\n", drive
->name
);
3496 g
= alloc_disk(1 << PARTN_BITS
);
3500 ide_init_disk(g
, drive
);
3502 ide_proc_register_driver(drive
, &ide_cdrom_driver
);
3504 kref_init(&info
->kref
);
3506 info
->drive
= drive
;
3507 info
->driver
= &ide_cdrom_driver
;
3510 g
->private_data
= &info
->driver
;
3512 drive
->driver_data
= info
;
3515 g
->driverfs_dev
= &drive
->gendev
;
3516 g
->flags
= GENHD_FL_CD
| GENHD_FL_REMOVABLE
;
3517 if (ide_cdrom_setup(drive
)) {
3518 ide_proc_unregister_driver(drive
, &ide_cdrom_driver
);
3519 ide_cd_release(&info
->kref
);
3523 cdrom_read_toc(drive
, &sense
);
3524 g
->fops
= &idecd_ops
;
3525 g
->flags
|= GENHD_FL_REMOVABLE
;
3535 static void __exit
ide_cdrom_exit(void)
3537 driver_unregister(&ide_cdrom_driver
.gen_driver
);
3540 static int __init
ide_cdrom_init(void)
3542 return driver_register(&ide_cdrom_driver
.gen_driver
);
3545 MODULE_ALIAS("ide:*m-cdrom*");
3546 module_init(ide_cdrom_init
);
3547 module_exit(ide_cdrom_exit
);
3548 MODULE_LICENSE("GPL");