ia64/linux-2.6.18-xen.hg

view drivers/ide/ide-cd.c @ 893:f994bfe9b93b

linux/blktap2: reduce TLB flush scope

c/s 885 added very coarse TLB flushing. Since these flushes always
follow single page updates, single page flushes (when available) are
sufficient.

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu Jun 04 10:32:57 2009 +0100 (2009-06-04)
parents 831230e53067
children
line source
1 /*
2 * linux/drivers/ide/ide-cd.c
3 *
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>
7 *
8 * May be copied or modified under the terms of the GNU General Public
9 * License. See linux/COPYING for more information.
10 *
11 * ATAPI CD-ROM driver. To be used with ide.c.
12 * See Documentation/cdrom/ide-cd for usage information.
13 *
14 * Suggestions are welcome. Patches that work are more welcome though. ;-)
15 * For those wishing to work on this driver, please be sure you download
16 * and comply with the latest Mt. Fuji (SFF8090 version 4) and ATAPI
17 * (SFF-8020i rev 2.6) standards. These documents can be obtained by
18 * anonymous ftp from:
19 * ftp://fission.dt.wdc.com/pub/standards/SFF_atapi/spec/SFF8020-r2.6/PS/8020r26.ps
20 * ftp://ftp.avc-pioneer.com/Mtfuji4/Spec/Fuji4r10.pdf
21 *
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...
25 *
26 * ----------------------------------
27 * TO DO LIST:
28 * -Make it so that Pioneer CD DR-A24X and friends don't get screwed up on
29 * boot
30 *
31 * ----------------------------------
32 * 1.00 Oct 31, 1994 -- Initial version.
33 * 1.01 Nov 2, 1994 -- Fixed problem with starting request in
34 * cdrom_check_status.
35 * 1.03 Nov 25, 1994 -- leaving unmask_intr[] as a user-setting (as for disks)
36 * (from mlord) -- minor changes to cdrom_setup()
37 * -- renamed ide_dev_s to ide_drive_t, enable irq on command
38 * 2.00 Nov 27, 1994 -- Generalize packet command interface;
39 * add audio ioctls.
40 * 2.01 Dec 3, 1994 -- Rework packet command interface to handle devices
41 * which send an interrupt when ready for a command.
42 * 2.02 Dec 11, 1994 -- Cache the TOC in the driver.
43 * Don't use SCMD_PLAYAUDIO_TI; it's not included
44 * in the current version of ATAPI.
45 * Try to use LBA instead of track or MSF addressing
46 * when possible.
47 * Don't wait for READY_STAT.
48 * 2.03 Jan 10, 1995 -- Rewrite block read routines to handle block sizes
49 * other than 2k and to move multiple sectors in a
50 * single transaction.
51 * 2.04 Apr 21, 1995 -- Add work-around for Creative Labs CD220E drives.
52 * Thanks to Nick Saw <cwsaw@pts7.pts.mot.com> for
53 * help in figuring this out. Ditto for Acer and
54 * Aztech drives, which seem to have the same problem.
55 * 2.04b May 30, 1995 -- Fix to match changes in ide.c version 3.16 -ml
56 * 2.05 Jun 8, 1995 -- Don't attempt to retry after an illegal request
57 * or data protect error.
58 * Use HWIF and DEV_HWIF macros as in ide.c.
59 * Always try to do a request_sense after
60 * a failed command.
61 * Include an option to give textual descriptions
62 * of ATAPI errors.
63 * Fix a bug in handling the sector cache which
64 * showed up if the drive returned data in 512 byte
65 * blocks (like Pioneer drives). Thanks to
66 * Richard Hirst <srh@gpt.co.uk> for diagnosing this.
67 * Properly supply the page number field in the
68 * MODE_SELECT command.
69 * PLAYAUDIO12 is broken on the Aztech; work around it.
70 * 2.05x Aug 11, 1995 -- lots of data structure renaming/restructuring in ide.c
71 * (my apologies to Scott, but now ide-cd.c is independent)
72 * 3.00 Aug 22, 1995 -- Implement CDROMMULTISESSION ioctl.
73 * Implement CDROMREADAUDIO ioctl (UNTESTED).
74 * Use input_ide_data() and output_ide_data().
75 * Add door locking.
76 * Fix usage count leak in cdrom_open, which happened
77 * when a read-write mount was attempted.
78 * Try to load the disk on open.
79 * Implement CDROMEJECT_SW ioctl (off by default).
80 * Read total cdrom capacity during open.
81 * Rearrange logic in cdrom_decode_status. Issue
82 * request sense commands for failed packet commands
83 * from here instead of from cdrom_queue_packet_command.
84 * Fix a race condition in retrieving error information.
85 * Suppress printing normal unit attention errors and
86 * some drive not ready errors.
87 * Implement CDROMVOLREAD ioctl.
88 * Implement CDROMREADMODE1/2 ioctls.
89 * Fix race condition in setting up interrupt handlers
90 * when the `serialize' option is used.
91 * 3.01 Sep 2, 1995 -- Fix ordering of reenabling interrupts in
92 * cdrom_queue_request.
93 * Another try at using ide_[input,output]_data.
94 * 3.02 Sep 16, 1995 -- Stick total disk capacity in partition table as well.
95 * Make VERBOSE_IDE_CD_ERRORS dump failed command again.
96 * Dump out more information for ILLEGAL REQUEST errs.
97 * Fix handling of errors occurring before the
98 * packet command is transferred.
99 * Fix transfers with odd bytelengths.
100 * 3.03 Oct 27, 1995 -- Some Creative drives have an id of just `CD'.
101 * `DCI-2S10' drives are broken too.
102 * 3.04 Nov 20, 1995 -- So are Vertos drives.
103 * 3.05 Dec 1, 1995 -- Changes to go with overhaul of ide.c and ide-tape.c
104 * 3.06 Dec 16, 1995 -- Add support needed for partitions.
105 * More workarounds for Vertos bugs (based on patches
106 * from Holger Dietze <dietze@aix520.informatik.uni-leipzig.de>).
107 * Try to eliminate byteorder assumptions.
108 * Use atapi_cdrom_subchnl struct definition.
109 * Add STANDARD_ATAPI compilation option.
110 * 3.07 Jan 29, 1996 -- More twiddling for broken drives: Sony 55D,
111 * Vertos 300.
112 * Add NO_DOOR_LOCKING configuration option.
113 * Handle drive_cmd requests w/NULL args (for hdparm -t).
114 * Work around sporadic Sony55e audio play problem.
115 * 3.07a Feb 11, 1996 -- check drive->id for NULL before dereferencing, to fix
116 * problem with "hde=cdrom" with no drive present. -ml
117 * 3.08 Mar 6, 1996 -- More Vertos workarounds.
118 * 3.09 Apr 5, 1996 -- Add CDROMCLOSETRAY ioctl.
119 * Switch to using MSF addressing for audio commands.
120 * Reformat to match kernel tabbing style.
121 * Add CDROM_GET_UPC ioctl.
122 * 3.10 Apr 10, 1996 -- Fix compilation error with STANDARD_ATAPI.
123 * 3.11 Apr 29, 1996 -- Patch from Heiko Eissfeldt <heiko@colossus.escape.de>
124 * to remove redundant verify_area calls.
125 * 3.12 May 7, 1996 -- Rudimentary changer support. Based on patches
126 * from Gerhard Zuber <zuber@berlin.snafu.de>.
127 * Let open succeed even if there's no loaded disc.
128 * 3.13 May 19, 1996 -- Fixes for changer code.
129 * 3.14 May 29, 1996 -- Add work-around for Vertos 600.
130 * (From Hennus Bergman <hennus@sky.ow.nl>.)
131 * 3.15 July 2, 1996 -- Added support for Sanyo 3 CD changers
132 * from Ben Galliart <bgallia@luc.edu> with
133 * special help from Jeff Lightfoot
134 * <jeffml@pobox.com>
135 * 3.15a July 9, 1996 -- Improved Sanyo 3 CD changer identification
136 * 3.16 Jul 28, 1996 -- Fix from Gadi to reduce kernel stack usage for ioctl.
137 * 3.17 Sep 17, 1996 -- Tweak audio reads for some drives.
138 * Start changing CDROMLOADFROMSLOT to CDROM_SELECT_DISC.
139 * 3.18 Oct 31, 1996 -- Added module and DMA support.
140 *
141 *
142 * 4.00 Nov 5, 1996 -- New ide-cd maintainer,
143 * Erik B. Andersen <andersee@debian.org>
144 * -- Newer Creative drives don't always set the error
145 * register correctly. Make sure we see media changes
146 * regardless.
147 * -- Integrate with generic cdrom driver.
148 * -- CDROMGETSPINDOWN and CDROMSETSPINDOWN ioctls, based on
149 * a patch from Ciro Cattuto <>.
150 * -- Call set_device_ro.
151 * -- Implement CDROMMECHANISMSTATUS and CDROMSLOTTABLE
152 * ioctls, based on patch by Erik Andersen
153 * -- Add some probes of drive capability during setup.
154 *
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)
161 *
162 * 4.02 Dec 01, 1996 -- Applied patch from Gadi Oxman <gadio@netvision.net.il>
163 * to fix the drive door locking problems.
164 *
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)
168 *
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
175 *
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.
208 *
209 * 4.15 Aug 25, 1998 -- Updated ide-cd.h to respect mechine endianess,
210 * patch thanks to "Eddie C. Dost" <ecd@skynet.be>
211 *
212 * 4.50 Oct 19, 1998 -- New maintainers!
213 * Jens Axboe <axboe@image.dk>
214 * Chris Zwilling <chris@cloudnet.com>
215 *
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.
222 *
223 * 4.52 Jan 19, 1999 -- Jens Axboe <axboe@image.dk>
224 * - Detect DVD-ROM/RAM drives
225 *
226 * 4.53 Feb 22, 1999 - Include other model Samsung and one Goldstar
227 * drive in transfer size limit.
228 * - Fix the I/O error when doing eject without a medium
229 * loaded on some drives.
230 * - CDROMREADMODE2 is now implemented through
231 * CDROMREADRAW, since many drives don't support
232 * MODE2 (even though ATAPI 2.6 says they must).
233 * - Added ignore parameter to ide-cd (as a module), eg
234 * insmod ide-cd ignore='hda hdb'
235 * Useful when using ide-cd in conjunction with
236 * ide-scsi. TODO: non-modular way of doing the
237 * same.
238 *
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.
250 *
251 * 4.55 Sep 1, 1999 - Eliminated the rest of the audio ioctls, except
252 * for CDROMREADTOC[ENTRY|HEADER]. Some of the drivers
253 * use this independently of the actual audio handling.
254 * They will disappear later when I get the time to
255 * do it cleanly.
256 * - Minimize the TOC reading - only do it when we
257 * know a media change has occurred.
258 * - Moved all the CDROMREADx ioctls to the Uniform layer.
259 * - Heiko Eissfeldt <heiko@colossus.escape.de> supplied
260 * some fixes for CDI.
261 * - CD-ROM leaving door locked fix from Andries
262 * Brouwer <Andries.Brouwer@cwi.nl>
263 * - Erik Andersen <andersen@xmission.com> unified
264 * commands across the various drivers and how
265 * sense errors are handled.
266 *
267 * 4.56 Sep 12, 1999 - Removed changer support - it is now in the
268 * Uniform layer.
269 * - Added partition based multisession handling.
270 * - Mode sense and mode select moved to the
271 * Uniform layer.
272 * - Fixed a problem with WPI CDS-32X drive - it
273 * failed the capabilities
274 *
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.
284 *
285 * 4.58 May 1, 2000 - Clean up ACER50 stuff.
286 * - Fix small problem with ide_cdrom_capacity
287 *
288 * 4.59 Aug 11, 2000 - Fix changer problem in cdrom_read_toc, we weren't
289 * correctly sensing a disc change.
290 * - Rearranged some code
291 * - Use extended sense on drives that support it for
292 * correctly reporting tray status -- from
293 * Michael D Johnson <johnsom@orst.edu>
294 * 4.60 Dec 17, 2003 - Add mt rainier support
295 * - Bump timeout for packet commands, matches sr
296 * - Odd stuff
297 * 4.61 Jan 22, 2004 - support hardware sector sizes other than 2kB,
298 * Pascal Schmidt <der.eremit@email.de>
299 *
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 */
319 #include <asm/irq.h>
320 #include <asm/io.h>
321 #include <asm/byteorder.h>
322 #include <asm/uaccess.h>
323 #include <asm/unaligned.h>
325 #include "ide-cd.h"
327 static 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)
335 {
336 struct cdrom_info *cd = NULL;
338 mutex_lock(&idecd_ref_mutex);
339 cd = ide_cd_g(disk);
340 if (cd)
341 kref_get(&cd->kref);
342 mutex_unlock(&idecd_ref_mutex);
343 return cd;
344 }
346 static void ide_cd_release(struct kref *);
348 static void ide_cd_put(struct cdrom_info *cd)
349 {
350 mutex_lock(&idecd_ref_mutex);
351 kref_put(&cd->kref, ide_cd_release);
352 mutex_unlock(&idecd_ref_mutex);
353 }
355 /****************************************************************************
356 * Generic packet command support and error handling routines.
357 */
359 /* Mark that we've seen a media change, and invalidate our internal
360 buffers. */
361 static void cdrom_saw_media_change (ide_drive_t *drive)
362 {
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;
368 }
370 static int cdrom_log_sense(ide_drive_t *drive, struct request *rq,
371 struct request_sense *sense)
372 {
373 int log = 0;
375 if (!sense || !rq || (rq->flags & REQ_QUIET))
376 return 0;
378 switch (sense->sense_key) {
379 case NO_SENSE: case RECOVERED_ERROR:
380 break;
381 case NOT_READY:
382 /*
383 * don't care about tray state messages for
384 * e.g. capacity commands or in-progress or
385 * becoming ready
386 */
387 if (sense->asc == 0x3a || sense->asc == 0x04)
388 break;
389 log = 1;
390 break;
391 case ILLEGAL_REQUEST:
392 /*
393 * don't log START_STOP unit with LoEj set, since
394 * we cannot reliably check if drive can auto-close
395 */
396 if (rq->cmd[0] == GPCMD_START_STOP_UNIT && sense->asc == 0x24)
397 break;
398 log = 1;
399 break;
400 case UNIT_ATTENTION:
401 /*
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.
405 */
406 cdrom_saw_media_change(drive);
407 break;
408 default:
409 log = 1;
410 break;
411 }
412 return log;
413 }
415 static
416 void cdrom_analyze_sense_data(ide_drive_t *drive,
417 struct request *failed_command,
418 struct request_sense *sense)
419 {
420 unsigned long sector;
421 unsigned long bio_sectors;
422 unsigned long valid;
423 struct cdrom_info *info = drive->driver_data;
425 if (!cdrom_log_sense(drive, failed_command, sense))
426 return;
428 /*
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)
432 */
433 if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP)
434 if (sense->sense_key == 0x05 && sense->asc == 0x24)
435 return;
437 if (sense->error_code == 0x70) { /* Current Error */
438 switch(sense->sense_key) {
439 case MEDIUM_ERROR:
440 case VOLUME_OVERFLOW:
441 case ILLEGAL_REQUEST:
442 if (!sense->valid)
443 break;
444 if (failed_command == NULL ||
445 !blk_fs_request(failed_command))
446 break;
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);
453 if (bio_sectors < 4)
454 bio_sectors = 4;
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;
460 if (valid < 0)
461 valid = 0;
462 if (sector < get_capacity(info->disk) &&
463 drive->probed_capacity - sector < 4 * 75) {
464 set_capacity(info->disk, sector);
465 }
466 }
467 }
468 #if VERBOSE_IDE_CD_ERRORS
469 {
470 int i;
471 const char *s = "bad sense key!";
472 char buf[80];
474 printk ("ATAPI device %s:\n", drive->name);
475 if (sense->error_code==0x70)
476 printk(" Error: ");
477 else if (sense->error_code==0x71)
478 printk(" Deferred Error: ");
479 else if (sense->error_code == 0x7f)
480 printk(" Vendor-specific Error: ");
481 else
482 printk(" Unknown Error Type: ");
484 if (sense->sense_key < ARY_LEN(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",
491 sense->ascq);
492 s = buf;
493 } else {
494 int lo = 0, mid, hi = ARY_LEN(sense_data_texts);
495 unsigned long key = (sense->sense_key << 16);
496 key |= (sense->asc << 8);
497 if (!(sense->ascq >= 0x80 && sense->ascq <= 0xdd))
498 key |= sense->ascq;
499 s = NULL;
501 while (hi > lo) {
502 mid = (lo + hi) / 2;
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;
506 break;
507 }
508 else if (sense_data_texts[mid].asc_ascq > key)
509 hi = mid;
510 else
511 lo = mid+1;
512 }
513 }
515 if (s == NULL) {
516 if (sense->asc > 0x80)
517 s = "(vendor-specific error)";
518 else
519 s = "(reserved error code)";
520 }
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= ARY_LEN (packet_command_texts);
528 s = NULL;
530 while (hi > lo) {
531 mid = (lo + hi) / 2;
532 if (packet_command_texts[mid].packet_command ==
533 failed_command->cmd[0]) {
534 s = packet_command_texts[mid].text;
535 break;
536 }
537 if (packet_command_texts[mid].packet_command >
538 failed_command->cmd[0])
539 hi = mid;
540 else
541 lo = mid+1;
542 }
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]);
547 printk ("\"\n");
548 }
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.
554 */
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);
559 }
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);
571 printk ("\n");
572 }
573 }
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)))
583 return;
585 printk(KERN_ERR "%s: error code: 0x%02x sense_key: 0x%02x asc: 0x%02x ascq: 0x%02x\n",
586 drive->name,
587 sense->error_code, sense->sense_key,
588 sense->asc, sense->ascq);
589 #endif /* not VERBOSE_IDE_CD_ERRORS */
590 }
592 /*
593 * Initialize a ide-cd packet command request
594 */
595 static void cdrom_prepare_request(ide_drive_t *drive, struct request *rq)
596 {
597 struct cdrom_info *cd = drive->driver_data;
599 ide_init_drive_cmd(rq);
600 rq->flags = REQ_PC;
601 rq->rq_disk = cd->disk;
602 }
604 static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense,
605 struct request *failed_command)
606 {
607 struct cdrom_info *info = drive->driver_data;
608 struct request *rq = &info->request_sense_request;
610 if (sense == NULL)
611 sense = &info->sense_data;
613 /* stuff the sense request in front of our current request */
614 cdrom_prepare_request(drive, rq);
616 rq->data = sense;
617 rq->cmd[0] = GPCMD_REQUEST_SENSE;
618 rq->cmd[4] = rq->data_len = 18;
620 rq->flags = REQ_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);
626 }
628 static void cdrom_end_request (ide_drive_t *drive, int uptodate)
629 {
630 struct request *rq = HWGROUP(drive)->rq;
631 int nsectors = rq->hard_cur_sectors;
633 if ((rq->flags & REQ_SENSE) && uptodate) {
634 /*
635 * For REQ_SENSE, "rq->buffer" points to the original failed
636 * request
637 */
638 struct request *failed = (struct request *) rq->buffer;
639 struct cdrom_info *info = drive->driver_data;
640 void *sense = &info->sense_data;
641 unsigned long flags;
643 if (failed) {
644 if (failed->sense) {
645 sense = failed->sense;
646 failed->sense_len = rq->sense_len;
647 }
648 cdrom_analyze_sense_data(drive, failed, sense);
649 /*
650 * now end failed request
651 */
652 if (blk_fs_request(failed)) {
653 if (ide_end_dequeued_request(drive, failed, 0,
654 failed->hard_nr_sectors))
655 BUG();
656 } else {
657 spin_lock_irqsave(&ide_lock, flags);
658 end_that_request_chunk(failed, 0,
659 failed->data_len);
660 end_that_request_last(failed, 0);
661 spin_unlock_irqrestore(&ide_lock, flags);
662 }
663 } else
664 cdrom_analyze_sense_data(drive, NULL, sense);
665 }
667 if (!rq->current_nr_sectors && blk_fs_request(rq))
668 uptodate = 1;
669 /* make sure it's fully ended */
670 if (blk_pc_request(rq))
671 nsectors = (rq->data_len + 511) >> 9;
672 if (!nsectors)
673 nsectors = 1;
675 ide_end_request(drive, uptodate, nsectors);
676 }
678 static void ide_dump_status_no_sense(ide_drive_t *drive, const char *msg, u8 stat)
679 {
680 if (stat & 0x80)
681 return;
682 ide_dump_status(drive, msg, stat);
683 }
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)
688 {
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);
694 if (stat_ret)
695 *stat_ret = stat;
697 if (OK_STAT(stat, good_stat, BAD_R_STAT))
698 return 0;
700 /* Get the IDE error register. */
701 err = HWIF(drive)->INB(IDE_ERROR_REG);
702 sense_key = err >> 4;
704 if (rq == NULL) {
705 printk("%s: missing rq in cdrom_decode_status\n", drive->name);
706 return 1;
707 }
709 if (rq->flags & REQ_SENSE) {
710 /* We got an error trying to get sense info
711 from the drive (probably while trying
712 to recover from a former error). Just give up. */
714 rq->flags |= REQ_FAILED;
715 cdrom_end_request(drive, 0);
716 ide_error(drive, "request sense failure", stat);
717 return 1;
719 } else if (rq->flags & (REQ_PC | REQ_BLOCK_PC)) {
720 /* All other functions, except for READ. */
721 unsigned long flags;
723 /*
724 * if we have an error, pass back CHECK_CONDITION as the
725 * scsi status byte
726 */
727 if ((rq->flags & REQ_BLOCK_PC) && !rq->errors)
728 rq->errors = SAM_STAT_CHECK_CONDITION;
730 /* Check for tray open. */
731 if (sense_key == NOT_READY) {
732 cdrom_saw_media_change (drive);
733 } else if (sense_key == UNIT_ATTENTION) {
734 /* Check for media change. */
735 cdrom_saw_media_change (drive);
736 /*printk("%s: media changed\n",drive->name);*/
737 return 0;
738 } else if (!(rq->flags & REQ_QUIET)) {
739 /* Otherwise, print an error. */
740 ide_dump_status(drive, "packet command error", stat);
741 }
743 rq->flags |= REQ_FAILED;
745 /*
746 * instead of playing games with moving completions around,
747 * remove failed request completely and end it when the
748 * request sense has completed
749 */
750 if (stat & ERR_STAT) {
751 spin_lock_irqsave(&ide_lock, flags);
752 blkdev_dequeue_request(rq);
753 HWGROUP(drive)->rq = NULL;
754 spin_unlock_irqrestore(&ide_lock, flags);
756 cdrom_queue_request_sense(drive, rq->sense, rq);
757 } else
758 cdrom_end_request(drive, 0);
760 } else if (blk_fs_request(rq)) {
761 int do_end_request = 0;
763 /* Handle errors from READ and WRITE requests. */
765 if (blk_noretry_request(rq))
766 do_end_request = 1;
768 if (sense_key == NOT_READY) {
769 /* Tray open. */
770 if (rq_data_dir(rq) == READ) {
771 cdrom_saw_media_change (drive);
773 /* Fail the request. */
774 printk ("%s: tray open\n", drive->name);
775 do_end_request = 1;
776 } else {
777 struct cdrom_info *info = drive->driver_data;
779 /* allow the drive 5 seconds to recover, some
780 * devices will return this error while flushing
781 * data from cache */
782 if (!rq->errors)
783 info->write_timeout = jiffies + ATAPI_WAIT_WRITE_BUSY;
784 rq->errors = 1;
785 if (time_after(jiffies, info->write_timeout))
786 do_end_request = 1;
787 else {
788 unsigned long flags;
790 /*
791 * take a breather relying on the
792 * unplug timer to kick us again
793 */
794 spin_lock_irqsave(&ide_lock, flags);
795 blk_plug_device(drive->queue);
796 spin_unlock_irqrestore(&ide_lock,flags);
797 return 1;
798 }
799 }
800 } else if (sense_key == UNIT_ATTENTION) {
801 /* Media change. */
802 cdrom_saw_media_change (drive);
804 /* Arrange to retry the request.
805 But be sure to give up if we've retried
806 too many times. */
807 if (++rq->errors > ERROR_MAX)
808 do_end_request = 1;
809 } else if (sense_key == ILLEGAL_REQUEST ||
810 sense_key == DATA_PROTECT) {
811 /* No point in retrying after an illegal
812 request or data protect error.*/
813 ide_dump_status_no_sense (drive, "command error", stat);
814 do_end_request = 1;
815 } else if (sense_key == MEDIUM_ERROR) {
816 /* No point in re-trying a zillion times on a bad
817 * sector... If we got here the error is not correctable */
818 ide_dump_status_no_sense (drive, "media error (bad sector)", stat);
819 do_end_request = 1;
820 } else if (sense_key == BLANK_CHECK) {
821 /* Disk appears blank ?? */
822 ide_dump_status_no_sense (drive, "media error (blank)", stat);
823 do_end_request = 1;
824 } else if ((err & ~ABRT_ERR) != 0) {
825 /* Go to the default handler
826 for other errors. */
827 ide_error(drive, "cdrom_decode_status", stat);
828 return 1;
829 } else if ((++rq->errors > ERROR_MAX)) {
830 /* We've racked up too many retries. Abort. */
831 do_end_request = 1;
832 }
834 /* End a request through request sense analysis when we have
835 sense data. We need this in order to perform end of media
836 processing */
838 if (do_end_request) {
839 if (stat & ERR_STAT) {
840 unsigned long flags;
841 spin_lock_irqsave(&ide_lock, flags);
842 blkdev_dequeue_request(rq);
843 HWGROUP(drive)->rq = NULL;
844 spin_unlock_irqrestore(&ide_lock, flags);
846 cdrom_queue_request_sense(drive, rq->sense, rq);
847 } else
848 cdrom_end_request(drive, 0);
849 } else {
850 /* If we got a CHECK_CONDITION status,
851 queue a request sense command. */
852 if (stat & ERR_STAT)
853 cdrom_queue_request_sense(drive, NULL, NULL);
854 }
855 } else {
856 blk_dump_rq_flags(rq, "ide-cd: bad rq");
857 cdrom_end_request(drive, 0);
858 }
860 /* Retry, or handle the next request. */
861 return 1;
862 }
864 static int cdrom_timer_expiry(ide_drive_t *drive)
865 {
866 struct request *rq = HWGROUP(drive)->rq;
867 unsigned long wait = 0;
869 /*
870 * Some commands are *slow* and normally take a long time to
871 * complete. Usually we can use the ATAPI "disconnect" to bypass
872 * this, but not all commands/drives support that. Let
873 * ide_timer_expiry keep polling us for these.
874 */
875 switch (rq->cmd[0]) {
876 case GPCMD_BLANK:
877 case GPCMD_FORMAT_UNIT:
878 case GPCMD_RESERVE_RZONE_TRACK:
879 case GPCMD_CLOSE_TRACK:
880 case GPCMD_FLUSH_CACHE:
881 wait = ATAPI_WAIT_PC;
882 break;
883 default:
884 if (!(rq->flags & REQ_QUIET))
885 printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n", rq->cmd[0]);
886 wait = 0;
887 break;
888 }
889 return wait;
890 }
892 /* Set up the device registers for transferring a packet command on DEV,
893 expecting to later transfer XFERLEN bytes. HANDLER is the routine
894 which actually transfers the command to the drive. If this is a
895 drq_interrupt device, this routine will arrange for HANDLER to be
896 called when the interrupt from the drive arrives. Otherwise, HANDLER
897 will be called immediately after the drive is prepared for the transfer. */
899 static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
900 int xferlen,
901 ide_handler_t *handler)
902 {
903 ide_startstop_t startstop;
904 struct cdrom_info *info = drive->driver_data;
905 ide_hwif_t *hwif = drive->hwif;
907 /* Wait for the controller to be idle. */
908 if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY))
909 return startstop;
911 if (info->dma)
912 info->dma = !hwif->dma_setup(drive);
914 /* Set up the controller registers. */
915 /* FIXME: for Virtual DMA we must check harder */
916 HWIF(drive)->OUTB(info->dma, IDE_FEATURE_REG);
917 HWIF(drive)->OUTB(0, IDE_IREASON_REG);
918 HWIF(drive)->OUTB(0, IDE_SECTOR_REG);
920 HWIF(drive)->OUTB(xferlen & 0xff, IDE_BCOUNTL_REG);
921 HWIF(drive)->OUTB(xferlen >> 8 , IDE_BCOUNTH_REG);
922 if (IDE_CONTROL_REG)
923 HWIF(drive)->OUTB(drive->ctl, IDE_CONTROL_REG);
925 if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt) {
926 /* packet command */
927 ide_execute_command(drive, WIN_PACKETCMD, handler, ATAPI_WAIT_PC, cdrom_timer_expiry);
928 return ide_started;
929 } else {
930 unsigned long flags;
932 /* packet command */
933 spin_lock_irqsave(&ide_lock, flags);
934 hwif->OUTBSYNC(drive, WIN_PACKETCMD, IDE_COMMAND_REG);
935 ndelay(400);
936 spin_unlock_irqrestore(&ide_lock, flags);
938 return (*handler) (drive);
939 }
940 }
942 /* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
943 The device registers must have already been prepared
944 by cdrom_start_packet_command.
945 HANDLER is the interrupt handler to call when the command completes
946 or there's data ready. */
947 /*
948 * changed 5 parameters to 3 for dvd-ram
949 * struct packet_command *pc; now packet_command_t *pc;
950 */
951 #define ATAPI_MIN_CDB_BYTES 12
952 static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
953 struct request *rq,
954 ide_handler_t *handler)
955 {
956 ide_hwif_t *hwif = drive->hwif;
957 int cmd_len;
958 struct cdrom_info *info = drive->driver_data;
959 ide_startstop_t startstop;
961 if (CDROM_CONFIG_FLAGS(drive)->drq_interrupt) {
962 /* Here we should have been called after receiving an interrupt
963 from the device. DRQ should how be set. */
965 /* Check for errors. */
966 if (cdrom_decode_status(drive, DRQ_STAT, NULL))
967 return ide_stopped;
968 } else {
969 /* Otherwise, we must wait for DRQ to get set. */
970 if (ide_wait_stat(&startstop, drive, DRQ_STAT,
971 BUSY_STAT, WAIT_READY))
972 return startstop;
973 }
975 /* Arm the interrupt handler. */
976 ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);
978 /* ATAPI commands get padded out to 12 bytes minimum */
979 cmd_len = COMMAND_SIZE(rq->cmd[0]);
980 if (cmd_len < ATAPI_MIN_CDB_BYTES)
981 cmd_len = ATAPI_MIN_CDB_BYTES;
983 /* Send the command to the device. */
984 HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len);
986 /* Start the DMA if need be */
987 if (info->dma)
988 hwif->dma_start(drive);
990 return ide_started;
991 }
993 /****************************************************************************
994 * Block read functions.
995 */
997 /*
998 * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
999 * buffer. Once the first sector is added, any subsequent sectors are
1000 * assumed to be continuous (until the buffer is cleared). For the first
1001 * sector added, SECTOR is its sector number. (SECTOR is then ignored until
1002 * the buffer is cleared.)
1003 */
1004 static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
1005 int sectors_to_transfer)
1007 struct cdrom_info *info = drive->driver_data;
1009 /* Number of sectors to read into the buffer. */
1010 int sectors_to_buffer = min_t(int, sectors_to_transfer,
1011 (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
1012 info->nsectors_buffered);
1014 char *dest;
1016 /* If we couldn't get a buffer, don't try to buffer anything... */
1017 if (info->buffer == NULL)
1018 sectors_to_buffer = 0;
1020 /* If this is the first sector in the buffer, remember its number. */
1021 if (info->nsectors_buffered == 0)
1022 info->sector_buffered = sector;
1024 /* Read the data into the buffer. */
1025 dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
1026 while (sectors_to_buffer > 0) {
1027 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
1028 --sectors_to_buffer;
1029 --sectors_to_transfer;
1030 ++info->nsectors_buffered;
1031 dest += SECTOR_SIZE;
1034 /* Throw away any remaining data. */
1035 while (sectors_to_transfer > 0) {
1036 static char dum[SECTOR_SIZE];
1037 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1038 --sectors_to_transfer;
1042 /*
1043 * Check the contents of the interrupt reason register from the cdrom
1044 * and attempt to recover if there are problems. Returns 0 if everything's
1045 * ok; nonzero if the request has been terminated.
1046 */
1047 static
1048 int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
1050 if (ireason == 2)
1051 return 0;
1052 else if (ireason == 0) {
1053 /* Whoops... The drive is expecting to receive data from us! */
1054 printk(KERN_ERR "%s: read_intr: Drive wants to transfer data the "
1055 "wrong way!\n", drive->name);
1057 /* Throw some data at the drive so it doesn't hang
1058 and quit this request. */
1059 while (len > 0) {
1060 int dum = 0;
1061 HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof (dum));
1062 len -= sizeof (dum);
1064 } else if (ireason == 1) {
1065 /* Some drives (ASUS) seem to tell us that status
1066 * info is available. just get it and ignore.
1067 */
1068 (void) HWIF(drive)->INB(IDE_STATUS_REG);
1069 return 0;
1070 } else {
1071 /* Drive wants a command packet, or invalid ireason... */
1072 printk(KERN_ERR "%s: read_intr: bad interrupt reason %x\n", drive->name,
1073 ireason);
1076 cdrom_end_request(drive, 0);
1077 return -1;
1080 /*
1081 * Interrupt routine. Called when a read request has completed.
1082 */
1083 static ide_startstop_t cdrom_read_intr (ide_drive_t *drive)
1085 int stat;
1086 int ireason, len, sectors_to_transfer, nskip;
1087 struct cdrom_info *info = drive->driver_data;
1088 u8 lowcyl = 0, highcyl = 0;
1089 int dma = info->dma, dma_error = 0;
1091 struct request *rq = HWGROUP(drive)->rq;
1093 /*
1094 * handle dma case
1095 */
1096 if (dma) {
1097 info->dma = 0;
1098 if ((dma_error = HWIF(drive)->ide_dma_end(drive)))
1099 __ide_dma_off(drive);
1102 if (cdrom_decode_status(drive, 0, &stat))
1103 return ide_stopped;
1105 if (dma) {
1106 if (!dma_error) {
1107 ide_end_request(drive, 1, rq->nr_sectors);
1108 return ide_stopped;
1109 } else
1110 return ide_error(drive, "dma error", stat);
1113 /* Read the interrupt reason and the transfer length. */
1114 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1115 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1116 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1118 len = lowcyl + (256 * highcyl);
1120 /* If DRQ is clear, the command has completed. */
1121 if ((stat & DRQ_STAT) == 0) {
1122 /* If we're not done filling the current buffer, complain.
1123 Otherwise, complete the command normally. */
1124 if (rq->current_nr_sectors > 0) {
1125 printk (KERN_ERR "%s: cdrom_read_intr: data underrun (%d blocks)\n",
1126 drive->name, rq->current_nr_sectors);
1127 rq->flags |= REQ_FAILED;
1128 cdrom_end_request(drive, 0);
1129 } else
1130 cdrom_end_request(drive, 1);
1131 return ide_stopped;
1134 /* Check that the drive is expecting to do the same thing we are. */
1135 if (cdrom_read_check_ireason (drive, len, ireason))
1136 return ide_stopped;
1138 /* Assume that the drive will always provide data in multiples
1139 of at least SECTOR_SIZE, as it gets hairy to keep track
1140 of the transfers otherwise. */
1141 if ((len % SECTOR_SIZE) != 0) {
1142 printk (KERN_ERR "%s: cdrom_read_intr: Bad transfer size %d\n",
1143 drive->name, len);
1144 if (CDROM_CONFIG_FLAGS(drive)->limit_nframes)
1145 printk (KERN_ERR " This drive is not supported by this version of the driver\n");
1146 else {
1147 printk (KERN_ERR " Trying to limit transfer sizes\n");
1148 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
1150 cdrom_end_request(drive, 0);
1151 return ide_stopped;
1154 /* The number of sectors we need to read from the drive. */
1155 sectors_to_transfer = len / SECTOR_SIZE;
1157 /* First, figure out if we need to bit-bucket
1158 any of the leading sectors. */
1159 nskip = min_t(int, rq->current_nr_sectors - bio_cur_sectors(rq->bio), sectors_to_transfer);
1161 while (nskip > 0) {
1162 /* We need to throw away a sector. */
1163 static char dum[SECTOR_SIZE];
1164 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1166 --rq->current_nr_sectors;
1167 --nskip;
1168 --sectors_to_transfer;
1171 /* Now loop while we still have data to read from the drive. */
1172 while (sectors_to_transfer > 0) {
1173 int this_transfer;
1175 /* If we've filled the present buffer but there's another
1176 chained buffer after it, move on. */
1177 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1178 cdrom_end_request(drive, 1);
1180 /* If the buffers are full, cache the rest of the data in our
1181 internal buffer. */
1182 if (rq->current_nr_sectors == 0) {
1183 cdrom_buffer_sectors(drive, rq->sector, sectors_to_transfer);
1184 sectors_to_transfer = 0;
1185 } else {
1186 /* Transfer data to the buffers.
1187 Figure out how many sectors we can transfer
1188 to the current buffer. */
1189 this_transfer = min_t(int, sectors_to_transfer,
1190 rq->current_nr_sectors);
1192 /* Read this_transfer sectors
1193 into the current buffer. */
1194 while (this_transfer > 0) {
1195 HWIF(drive)->atapi_input_bytes(drive, rq->buffer, SECTOR_SIZE);
1196 rq->buffer += SECTOR_SIZE;
1197 --rq->nr_sectors;
1198 --rq->current_nr_sectors;
1199 ++rq->sector;
1200 --this_transfer;
1201 --sectors_to_transfer;
1206 /* Done moving data! Wait for another interrupt. */
1207 ide_set_handler(drive, &cdrom_read_intr, ATAPI_WAIT_PC, NULL);
1208 return ide_started;
1211 /*
1212 * Try to satisfy some of the current read request from our cached data.
1213 * Returns nonzero if the request has been completed, zero otherwise.
1214 */
1215 static int cdrom_read_from_buffer (ide_drive_t *drive)
1217 struct cdrom_info *info = drive->driver_data;
1218 struct request *rq = HWGROUP(drive)->rq;
1219 unsigned short sectors_per_frame;
1221 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1223 /* Can't do anything if there's no buffer. */
1224 if (info->buffer == NULL) return 0;
1226 /* Loop while this request needs data and the next block is present
1227 in our cache. */
1228 while (rq->nr_sectors > 0 &&
1229 rq->sector >= info->sector_buffered &&
1230 rq->sector < info->sector_buffered + info->nsectors_buffered) {
1231 if (rq->current_nr_sectors == 0)
1232 cdrom_end_request(drive, 1);
1234 memcpy (rq->buffer,
1235 info->buffer +
1236 (rq->sector - info->sector_buffered) * SECTOR_SIZE,
1237 SECTOR_SIZE);
1238 rq->buffer += SECTOR_SIZE;
1239 --rq->current_nr_sectors;
1240 --rq->nr_sectors;
1241 ++rq->sector;
1244 /* If we've satisfied the current request,
1245 terminate it successfully. */
1246 if (rq->nr_sectors == 0) {
1247 cdrom_end_request(drive, 1);
1248 return -1;
1251 /* Move on to the next buffer if needed. */
1252 if (rq->current_nr_sectors == 0)
1253 cdrom_end_request(drive, 1);
1255 /* If this condition does not hold, then the kluge i use to
1256 represent the number of sectors to skip at the start of a transfer
1257 will fail. I think that this will never happen, but let's be
1258 paranoid and check. */
1259 if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
1260 (rq->sector & (sectors_per_frame - 1))) {
1261 printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
1262 drive->name, (long)rq->sector);
1263 cdrom_end_request(drive, 0);
1264 return -1;
1267 return 0;
1270 /*
1271 * Routine to send a read packet command to the drive.
1272 * This is usually called directly from cdrom_start_read.
1273 * However, for drq_interrupt devices, it is called from an interrupt
1274 * when the drive is ready to accept the command.
1275 */
1276 static ide_startstop_t cdrom_start_read_continuation (ide_drive_t *drive)
1278 struct request *rq = HWGROUP(drive)->rq;
1279 unsigned short sectors_per_frame;
1280 int nskip;
1282 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1284 /* If the requested sector doesn't start on a cdrom block boundary,
1285 we must adjust the start of the transfer so that it does,
1286 and remember to skip the first few sectors.
1287 If the CURRENT_NR_SECTORS field is larger than the size
1288 of the buffer, it will mean that we're to skip a number
1289 of sectors equal to the amount by which CURRENT_NR_SECTORS
1290 is larger than the buffer size. */
1291 nskip = rq->sector & (sectors_per_frame - 1);
1292 if (nskip > 0) {
1293 /* Sanity check... */
1294 if (rq->current_nr_sectors != bio_cur_sectors(rq->bio) &&
1295 (rq->sector & (sectors_per_frame - 1))) {
1296 printk(KERN_ERR "%s: cdrom_start_read_continuation: buffer botch (%u)\n",
1297 drive->name, rq->current_nr_sectors);
1298 cdrom_end_request(drive, 0);
1299 return ide_stopped;
1301 rq->current_nr_sectors += nskip;
1304 /* Set up the command */
1305 rq->timeout = ATAPI_WAIT_PC;
1307 /* Send the command to the drive and return. */
1308 return cdrom_transfer_packet_command(drive, rq, &cdrom_read_intr);
1312 #define IDECD_SEEK_THRESHOLD (1000) /* 1000 blocks */
1313 #define IDECD_SEEK_TIMER (5 * WAIT_MIN_SLEEP) /* 100 ms */
1314 #define IDECD_SEEK_TIMEOUT (2 * WAIT_CMD) /* 20 sec */
1316 static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
1318 struct cdrom_info *info = drive->driver_data;
1319 int stat;
1320 static int retry = 10;
1322 if (cdrom_decode_status(drive, 0, &stat))
1323 return ide_stopped;
1324 CDROM_CONFIG_FLAGS(drive)->seeking = 1;
1326 if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
1327 if (--retry == 0) {
1328 /*
1329 * this condition is far too common, to bother
1330 * users about it
1331 */
1332 /* printk("%s: disabled DSC seek overlap\n", drive->name);*/
1333 drive->dsc_overlap = 0;
1336 return ide_stopped;
1339 static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
1341 struct request *rq = HWGROUP(drive)->rq;
1342 sector_t frame = rq->sector;
1344 sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
1346 memset(rq->cmd, 0, sizeof(rq->cmd));
1347 rq->cmd[0] = GPCMD_SEEK;
1348 put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
1350 rq->timeout = ATAPI_WAIT_PC;
1351 return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
1354 static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
1356 struct cdrom_info *info = drive->driver_data;
1358 info->dma = 0;
1359 info->start_seek = jiffies;
1360 return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
1363 /* Fix up a possibly partially-processed request so that we can
1364 start it over entirely, or even put it back on the request queue. */
1365 static void restore_request (struct request *rq)
1367 if (rq->buffer != bio_data(rq->bio)) {
1368 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
1370 rq->buffer = bio_data(rq->bio);
1371 rq->nr_sectors += n;
1372 rq->sector -= n;
1374 rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
1375 rq->hard_nr_sectors = rq->nr_sectors;
1376 rq->hard_sector = rq->sector;
1377 rq->q->prep_rq_fn(rq->q, rq);
1380 /*
1381 * Start a read request from the CD-ROM.
1382 */
1383 static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block)
1385 struct cdrom_info *info = drive->driver_data;
1386 struct request *rq = HWGROUP(drive)->rq;
1387 unsigned short sectors_per_frame;
1389 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1391 /* We may be retrying this request after an error. Fix up
1392 any weirdness which might be present in the request packet. */
1393 restore_request(rq);
1395 /* Satisfy whatever we can of this request from our cached sector. */
1396 if (cdrom_read_from_buffer(drive))
1397 return ide_stopped;
1399 /* Clear the local sector buffer. */
1400 info->nsectors_buffered = 0;
1402 /* use dma, if possible. */
1403 info->dma = drive->using_dma;
1404 if ((rq->sector & (sectors_per_frame - 1)) ||
1405 (rq->nr_sectors & (sectors_per_frame - 1)))
1406 info->dma = 0;
1408 /* Start sending the read request to the drive. */
1409 return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
1412 /****************************************************************************
1413 * Execute all other packet commands.
1414 */
1416 /* Interrupt routine for packet command completion. */
1417 static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
1419 int ireason, len, thislen;
1420 struct request *rq = HWGROUP(drive)->rq;
1421 u8 lowcyl = 0, highcyl = 0;
1422 int stat;
1424 /* Check for errors. */
1425 if (cdrom_decode_status(drive, 0, &stat))
1426 return ide_stopped;
1428 /* Read the interrupt reason and the transfer length. */
1429 ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1430 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1431 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1433 len = lowcyl + (256 * highcyl);
1435 /* If DRQ is clear, the command has completed.
1436 Complain if we still have data left to transfer. */
1437 if ((stat & DRQ_STAT) == 0) {
1438 /* Some of the trailing request sense fields are optional, and
1439 some drives don't send them. Sigh. */
1440 if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
1441 rq->data_len > 0 &&
1442 rq->data_len <= 5) {
1443 while (rq->data_len > 0) {
1444 *(unsigned char *)rq->data++ = 0;
1445 --rq->data_len;
1449 if (rq->data_len == 0)
1450 cdrom_end_request(drive, 1);
1451 else {
1452 /* Comment this out, because this always happens
1453 right after a reset occurs, and it is annoying to
1454 always print expected stuff. */
1455 /*
1456 printk ("%s: cdrom_pc_intr: data underrun %d\n",
1457 drive->name, pc->buflen);
1458 */
1459 rq->flags |= REQ_FAILED;
1460 cdrom_end_request(drive, 0);
1462 return ide_stopped;
1465 /* Figure out how much data to transfer. */
1466 thislen = rq->data_len;
1467 if (thislen > len) thislen = len;
1469 /* The drive wants to be written to. */
1470 if ((ireason & 3) == 0) {
1471 if (!rq->data) {
1472 blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1473 goto confused;
1475 /* Transfer the data. */
1476 HWIF(drive)->atapi_output_bytes(drive, rq->data, thislen);
1478 /* If we haven't moved enough data to satisfy the drive,
1479 add some padding. */
1480 while (len > thislen) {
1481 int dum = 0;
1482 HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof(dum));
1483 len -= sizeof(dum);
1486 /* Keep count of how much data we've moved. */
1487 rq->data += thislen;
1488 rq->data_len -= thislen;
1491 /* Same drill for reading. */
1492 else if ((ireason & 3) == 2) {
1493 if (!rq->data) {
1494 blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1495 goto confused;
1497 /* Transfer the data. */
1498 HWIF(drive)->atapi_input_bytes(drive, rq->data, thislen);
1500 /* If we haven't moved enough data to satisfy the drive,
1501 add some padding. */
1502 while (len > thislen) {
1503 int dum = 0;
1504 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1505 len -= sizeof(dum);
1508 /* Keep count of how much data we've moved. */
1509 rq->data += thislen;
1510 rq->data_len -= thislen;
1512 if (rq->flags & REQ_SENSE)
1513 rq->sense_len += thislen;
1514 } else {
1515 confused:
1516 printk (KERN_ERR "%s: cdrom_pc_intr: The drive "
1517 "appears confused (ireason = 0x%02x). "
1518 "Trying to recover by ending request.\n",
1519 drive->name, ireason);
1520 rq->flags |= REQ_FAILED;
1521 cdrom_end_request(drive, 0);
1522 return ide_stopped;
1525 /* Now we wait for another interrupt. */
1526 ide_set_handler(drive, &cdrom_pc_intr, ATAPI_WAIT_PC, cdrom_timer_expiry);
1527 return ide_started;
1530 static ide_startstop_t cdrom_do_pc_continuation (ide_drive_t *drive)
1532 struct request *rq = HWGROUP(drive)->rq;
1534 if (!rq->timeout)
1535 rq->timeout = ATAPI_WAIT_PC;
1537 /* Send the command to the drive and return. */
1538 return cdrom_transfer_packet_command(drive, rq, &cdrom_pc_intr);
1542 static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
1544 int len;
1545 struct request *rq = HWGROUP(drive)->rq;
1546 struct cdrom_info *info = drive->driver_data;
1548 info->dma = 0;
1549 rq->flags &= ~REQ_FAILED;
1550 len = rq->data_len;
1552 /* Start sending the command to the drive. */
1553 return cdrom_start_packet_command(drive, len, cdrom_do_pc_continuation);
1557 static int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
1559 struct request_sense sense;
1560 int retries = 10;
1561 unsigned int flags = rq->flags;
1563 if (rq->sense == NULL)
1564 rq->sense = &sense;
1566 /* Start of retry loop. */
1567 do {
1568 int error;
1569 unsigned long time = jiffies;
1570 rq->flags = flags;
1572 error = ide_do_drive_cmd(drive, rq, ide_wait);
1573 time = jiffies - time;
1575 /* FIXME: we should probably abort/retry or something
1576 * in case of failure */
1577 if (rq->flags & REQ_FAILED) {
1578 /* The request failed. Retry if it was due to a unit
1579 attention status
1580 (usually means media was changed). */
1581 struct request_sense *reqbuf = rq->sense;
1583 if (reqbuf->sense_key == UNIT_ATTENTION)
1584 cdrom_saw_media_change(drive);
1585 else if (reqbuf->sense_key == NOT_READY &&
1586 reqbuf->asc == 4 && reqbuf->ascq != 4) {
1587 /* The drive is in the process of loading
1588 a disk. Retry, but wait a little to give
1589 the drive time to complete the load. */
1590 ssleep(2);
1591 } else {
1592 /* Otherwise, don't retry. */
1593 retries = 0;
1595 --retries;
1598 /* End of retry loop. */
1599 } while ((rq->flags & REQ_FAILED) && retries >= 0);
1601 /* Return an error if the command failed. */
1602 return (rq->flags & REQ_FAILED) ? -EIO : 0;
1605 /*
1606 * Write handling
1607 */
1608 static int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
1610 /* Two notes about IDE interrupt reason here - 0 means that
1611 * the drive wants to receive data from us, 2 means that
1612 * the drive is expecting to transfer data to us.
1613 */
1614 if (ireason == 0)
1615 return 0;
1616 else if (ireason == 2) {
1617 /* Whoops... The drive wants to send data. */
1618 printk(KERN_ERR "%s: write_intr: wrong transfer direction!\n",
1619 drive->name);
1621 while (len > 0) {
1622 int dum = 0;
1623 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1624 len -= sizeof(dum);
1626 } else {
1627 /* Drive wants a command packet, or invalid ireason... */
1628 printk(KERN_ERR "%s: write_intr: bad interrupt reason %x\n",
1629 drive->name, ireason);
1632 cdrom_end_request(drive, 0);
1633 return 1;
1636 static void post_transform_command(struct request *req)
1638 u8 *c = req->cmd;
1639 char *ibuf;
1641 if (!blk_pc_request(req))
1642 return;
1644 if (req->bio)
1645 ibuf = bio_data(req->bio);
1646 else
1647 ibuf = req->data;
1649 if (!ibuf)
1650 return;
1652 /*
1653 * set ansi-revision and response data as atapi
1654 */
1655 if (c[0] == GPCMD_INQUIRY) {
1656 ibuf[2] |= 2;
1657 ibuf[3] = (ibuf[3] & 0xf0) | 2;
1661 typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
1663 /*
1664 * best way to deal with dma that is not sector aligned right now... note
1665 * that in this path we are not using ->data or ->buffer at all. this irs
1666 * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the
1667 * future.
1668 */
1669 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1671 struct cdrom_info *info = drive->driver_data;
1672 struct request *rq = HWGROUP(drive)->rq;
1673 int dma_error, dma, stat, ireason, len, thislen;
1674 u8 lowcyl, highcyl;
1675 xfer_func_t *xferfunc;
1676 unsigned long flags;
1678 /* Check for errors. */
1679 dma_error = 0;
1680 dma = info->dma;
1681 if (dma) {
1682 info->dma = 0;
1683 dma_error = HWIF(drive)->ide_dma_end(drive);
1686 if (cdrom_decode_status(drive, 0, &stat))
1687 return ide_stopped;
1689 /*
1690 * using dma, transfer is complete now
1691 */
1692 if (dma) {
1693 if (dma_error) {
1694 printk(KERN_ERR "ide-cd: dma error\n");
1695 __ide_dma_off(drive);
1696 return ide_error(drive, "dma error", stat);
1699 end_that_request_chunk(rq, 1, rq->data_len);
1700 rq->data_len = 0;
1701 goto end_request;
1704 /*
1705 * ok we fall to pio :/
1706 */
1707 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1708 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1709 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1711 len = lowcyl + (256 * highcyl);
1712 thislen = rq->data_len;
1713 if (thislen > len)
1714 thislen = len;
1716 /*
1717 * If DRQ is clear, the command has completed.
1718 */
1719 if ((stat & DRQ_STAT) == 0)
1720 goto end_request;
1722 /*
1723 * check which way to transfer data
1724 */
1725 if (rq_data_dir(rq) == WRITE) {
1726 /*
1727 * write to drive
1728 */
1729 if (cdrom_write_check_ireason(drive, len, ireason))
1730 return ide_stopped;
1732 xferfunc = HWIF(drive)->atapi_output_bytes;
1733 } else {
1734 /*
1735 * read from drive
1736 */
1737 if (cdrom_read_check_ireason(drive, len, ireason))
1738 return ide_stopped;
1740 xferfunc = HWIF(drive)->atapi_input_bytes;
1743 /*
1744 * transfer data
1745 */
1746 while (thislen > 0) {
1747 int blen = blen = rq->data_len;
1748 char *ptr = rq->data;
1750 /*
1751 * bio backed?
1752 */
1753 if (rq->bio) {
1754 ptr = bio_data(rq->bio);
1755 blen = bio_iovec(rq->bio)->bv_len;
1758 if (!ptr) {
1759 printk(KERN_ERR "%s: confused, missing data\n", drive->name);
1760 break;
1763 if (blen > thislen)
1764 blen = thislen;
1766 xferfunc(drive, ptr, blen);
1768 thislen -= blen;
1769 len -= blen;
1770 rq->data_len -= blen;
1772 if (rq->bio)
1773 end_that_request_chunk(rq, 1, blen);
1774 else
1775 rq->data += blen;
1778 /*
1779 * pad, if necessary
1780 */
1781 if (len > 0) {
1782 while (len > 0) {
1783 int pad = 0;
1785 xferfunc(drive, &pad, sizeof(pad));
1786 len -= sizeof(pad);
1790 BUG_ON(HWGROUP(drive)->handler != NULL);
1792 ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, NULL);
1793 return ide_started;
1795 end_request:
1796 if (!rq->data_len)
1797 post_transform_command(rq);
1799 spin_lock_irqsave(&ide_lock, flags);
1800 blkdev_dequeue_request(rq);
1801 end_that_request_last(rq, 1);
1802 HWGROUP(drive)->rq = NULL;
1803 spin_unlock_irqrestore(&ide_lock, flags);
1804 return ide_stopped;
1807 static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
1809 int stat, ireason, len, sectors_to_transfer, uptodate;
1810 struct cdrom_info *info = drive->driver_data;
1811 int dma_error = 0, dma = info->dma;
1812 u8 lowcyl = 0, highcyl = 0;
1814 struct request *rq = HWGROUP(drive)->rq;
1816 /* Check for errors. */
1817 if (dma) {
1818 info->dma = 0;
1819 if ((dma_error = HWIF(drive)->ide_dma_end(drive))) {
1820 printk(KERN_ERR "ide-cd: write dma error\n");
1821 __ide_dma_off(drive);
1825 if (cdrom_decode_status(drive, 0, &stat))
1826 return ide_stopped;
1828 /*
1829 * using dma, transfer is complete now
1830 */
1831 if (dma) {
1832 if (dma_error)
1833 return ide_error(drive, "dma error", stat);
1835 ide_end_request(drive, 1, rq->nr_sectors);
1836 return ide_stopped;
1839 /* Read the interrupt reason and the transfer length. */
1840 ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1841 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1842 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1844 len = lowcyl + (256 * highcyl);
1846 /* If DRQ is clear, the command has completed. */
1847 if ((stat & DRQ_STAT) == 0) {
1848 /* If we're not done writing, complain.
1849 * Otherwise, complete the command normally.
1850 */
1851 uptodate = 1;
1852 if (rq->current_nr_sectors > 0) {
1853 printk(KERN_ERR "%s: write_intr: data underrun (%d blocks)\n",
1854 drive->name, rq->current_nr_sectors);
1855 uptodate = 0;
1857 cdrom_end_request(drive, uptodate);
1858 return ide_stopped;
1861 /* Check that the drive is expecting to do the same thing we are. */
1862 if (cdrom_write_check_ireason(drive, len, ireason))
1863 return ide_stopped;
1865 sectors_to_transfer = len / SECTOR_SIZE;
1867 /*
1868 * now loop and write out the data
1869 */
1870 while (sectors_to_transfer > 0) {
1871 int this_transfer;
1873 if (!rq->current_nr_sectors) {
1874 printk(KERN_ERR "ide-cd: write_intr: oops\n");
1875 break;
1878 /*
1879 * Figure out how many sectors we can transfer
1880 */
1881 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors);
1883 while (this_transfer > 0) {
1884 HWIF(drive)->atapi_output_bytes(drive, rq->buffer, SECTOR_SIZE);
1885 rq->buffer += SECTOR_SIZE;
1886 --rq->nr_sectors;
1887 --rq->current_nr_sectors;
1888 ++rq->sector;
1889 --this_transfer;
1890 --sectors_to_transfer;
1893 /*
1894 * current buffer complete, move on
1895 */
1896 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1897 cdrom_end_request(drive, 1);
1900 /* re-arm handler */
1901 ide_set_handler(drive, &cdrom_write_intr, ATAPI_WAIT_PC, NULL);
1902 return ide_started;
1905 static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
1907 struct request *rq = HWGROUP(drive)->rq;
1909 #if 0 /* the immediate bit */
1910 rq->cmd[1] = 1 << 3;
1911 #endif
1912 rq->timeout = ATAPI_WAIT_PC;
1914 return cdrom_transfer_packet_command(drive, rq, cdrom_write_intr);
1917 static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
1919 struct cdrom_info *info = drive->driver_data;
1920 struct gendisk *g = info->disk;
1921 unsigned short sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1923 /*
1924 * writes *must* be hardware frame aligned
1925 */
1926 if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1927 (rq->sector & (sectors_per_frame - 1))) {
1928 cdrom_end_request(drive, 0);
1929 return ide_stopped;
1932 /*
1933 * disk has become write protected
1934 */
1935 if (g->policy) {
1936 cdrom_end_request(drive, 0);
1937 return ide_stopped;
1940 info->nsectors_buffered = 0;
1942 /* use dma, if possible. we don't need to check more, since we
1943 * know that the transfer is always (at least!) frame aligned */
1944 info->dma = drive->using_dma ? 1 : 0;
1946 info->devinfo.media_written = 1;
1948 /* Start sending the write request to the drive. */
1949 return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
1952 static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1954 struct request *rq = HWGROUP(drive)->rq;
1956 if (!rq->timeout)
1957 rq->timeout = ATAPI_WAIT_PC;
1959 return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1962 static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1964 struct cdrom_info *info = drive->driver_data;
1966 rq->flags |= REQ_QUIET;
1968 info->dma = 0;
1970 /*
1971 * sg request
1972 */
1973 if (rq->bio) {
1974 int mask = drive->queue->dma_alignment;
1975 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
1977 info->dma = drive->using_dma;
1979 /*
1980 * check if dma is safe
1982 * NOTE! The "len" and "addr" checks should possibly have
1983 * separate masks.
1984 */
1985 if ((rq->data_len & 15) || (addr & mask))
1986 info->dma = 0;
1989 /* Start sending the command to the drive. */
1990 return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1993 /****************************************************************************
1994 * cdrom driver request routine.
1995 */
1996 static ide_startstop_t
1997 ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1999 ide_startstop_t action;
2000 struct cdrom_info *info = drive->driver_data;
2002 if (blk_fs_request(rq)) {
2003 if (CDROM_CONFIG_FLAGS(drive)->seeking) {
2004 unsigned long elapsed = jiffies - info->start_seek;
2005 int stat = HWIF(drive)->INB(IDE_STATUS_REG);
2007 if ((stat & SEEK_STAT) != SEEK_STAT) {
2008 if (elapsed < IDECD_SEEK_TIMEOUT) {
2009 ide_stall_queue(drive, IDECD_SEEK_TIMER);
2010 return ide_stopped;
2012 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
2014 CDROM_CONFIG_FLAGS(drive)->seeking = 0;
2016 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
2017 action = cdrom_start_seek(drive, block);
2018 } else {
2019 if (rq_data_dir(rq) == READ)
2020 action = cdrom_start_read(drive, block);
2021 else
2022 action = cdrom_start_write(drive, rq);
2024 info->last_block = block;
2025 return action;
2026 } else if (rq->flags & (REQ_PC | REQ_SENSE)) {
2027 return cdrom_do_packet_command(drive);
2028 } else if (rq->flags & REQ_BLOCK_PC) {
2029 return cdrom_do_block_pc(drive, rq);
2030 } else if (rq->flags & REQ_SPECIAL) {
2031 /*
2032 * right now this can only be a reset...
2033 */
2034 cdrom_end_request(drive, 1);
2035 return ide_stopped;
2038 blk_dump_rq_flags(rq, "ide-cd bad flags");
2039 cdrom_end_request(drive, 0);
2040 return ide_stopped;
2045 /****************************************************************************
2046 * Ioctl handling.
2048 * Routines which queue packet commands take as a final argument a pointer
2049 * to a request_sense struct. If execution of the command results
2050 * in an error with a CHECK CONDITION status, this structure will be filled
2051 * with the results of the subsequent request sense command. The pointer
2052 * can also be NULL, in which case no sense information is returned.
2053 */
2055 #if ! STANDARD_ATAPI
2056 static inline
2057 int bin2bcd (int x)
2059 return (x%10) | ((x/10) << 4);
2063 static inline
2064 int bcd2bin (int x)
2066 return (x >> 4) * 10 + (x & 0x0f);
2069 static
2070 void msf_from_bcd (struct atapi_msf *msf)
2072 msf->minute = bcd2bin (msf->minute);
2073 msf->second = bcd2bin (msf->second);
2074 msf->frame = bcd2bin (msf->frame);
2077 #endif /* not STANDARD_ATAPI */
2080 static inline
2081 void lba_to_msf (int lba, byte *m, byte *s, byte *f)
2083 lba += CD_MSF_OFFSET;
2084 lba &= 0xffffff; /* negative lbas use only 24 bits */
2085 *m = lba / (CD_SECS * CD_FRAMES);
2086 lba %= (CD_SECS * CD_FRAMES);
2087 *s = lba / CD_FRAMES;
2088 *f = lba % CD_FRAMES;
2092 static inline
2093 int msf_to_lba (byte m, byte s, byte f)
2095 return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
2098 static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
2100 struct request req;
2101 struct cdrom_info *info = drive->driver_data;
2102 struct cdrom_device_info *cdi = &info->devinfo;
2104 cdrom_prepare_request(drive, &req);
2106 req.sense = sense;
2107 req.cmd[0] = GPCMD_TEST_UNIT_READY;
2108 req.flags |= REQ_QUIET;
2110 #if ! STANDARD_ATAPI
2111 /* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
2112 switch CDs instead of supporting the LOAD_UNLOAD opcode */
2114 req.cmd[7] = cdi->sanyo_slot % 3;
2115 #endif /* not STANDARD_ATAPI */
2117 return cdrom_queue_packet_command(drive, &req);
2121 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
2122 static int
2123 cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
2125 struct request_sense my_sense;
2126 struct request req;
2127 int stat;
2129 if (sense == NULL)
2130 sense = &my_sense;
2132 /* If the drive cannot lock the door, just pretend. */
2133 if (CDROM_CONFIG_FLAGS(drive)->no_doorlock) {
2134 stat = 0;
2135 } else {
2136 cdrom_prepare_request(drive, &req);
2137 req.sense = sense;
2138 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
2139 req.cmd[4] = lockflag ? 1 : 0;
2140 stat = cdrom_queue_packet_command(drive, &req);
2143 /* If we got an illegal field error, the drive
2144 probably cannot lock the door. */
2145 if (stat != 0 &&
2146 sense->sense_key == ILLEGAL_REQUEST &&
2147 (sense->asc == 0x24 || sense->asc == 0x20)) {
2148 printk (KERN_ERR "%s: door locking not supported\n",
2149 drive->name);
2150 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2151 stat = 0;
2154 /* no medium, that's alright. */
2155 if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
2156 stat = 0;
2158 if (stat == 0)
2159 CDROM_STATE_FLAGS(drive)->door_locked = lockflag;
2161 return stat;
2165 /* Eject the disk if EJECTFLAG is 0.
2166 If EJECTFLAG is 1, try to reload the disk. */
2167 static int cdrom_eject(ide_drive_t *drive, int ejectflag,
2168 struct request_sense *sense)
2170 struct request req;
2171 char loej = 0x02;
2173 if (CDROM_CONFIG_FLAGS(drive)->no_eject && !ejectflag)
2174 return -EDRIVE_CANT_DO_THIS;
2176 /* reload fails on some drives, if the tray is locked */
2177 if (CDROM_STATE_FLAGS(drive)->door_locked && ejectflag)
2178 return 0;
2180 cdrom_prepare_request(drive, &req);
2182 /* only tell drive to close tray if open, if it can do that */
2183 if (ejectflag && !CDROM_CONFIG_FLAGS(drive)->close_tray)
2184 loej = 0;
2186 req.sense = sense;
2187 req.cmd[0] = GPCMD_START_STOP_UNIT;
2188 req.cmd[4] = loej | (ejectflag != 0);
2189 return cdrom_queue_packet_command(drive, &req);
2192 static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
2193 unsigned long *sectors_per_frame,
2194 struct request_sense *sense)
2196 struct {
2197 __u32 lba;
2198 __u32 blocklen;
2199 } capbuf;
2201 int stat;
2202 struct request req;
2204 cdrom_prepare_request(drive, &req);
2206 req.sense = sense;
2207 req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
2208 req.data = (char *)&capbuf;
2209 req.data_len = sizeof(capbuf);
2210 req.flags |= REQ_QUIET;
2212 stat = cdrom_queue_packet_command(drive, &req);
2213 if (stat == 0) {
2214 *capacity = 1 + be32_to_cpu(capbuf.lba);
2215 *sectors_per_frame =
2216 be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
2219 return stat;
2222 static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
2223 int format, char *buf, int buflen,
2224 struct request_sense *sense)
2226 struct request req;
2228 cdrom_prepare_request(drive, &req);
2230 req.sense = sense;
2231 req.data = buf;
2232 req.data_len = buflen;
2233 req.flags |= REQ_QUIET;
2234 req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
2235 req.cmd[6] = trackno;
2236 req.cmd[7] = (buflen >> 8);
2237 req.cmd[8] = (buflen & 0xff);
2238 req.cmd[9] = (format << 6);
2240 if (msf_flag)
2241 req.cmd[1] = 2;
2243 return cdrom_queue_packet_command(drive, &req);
2247 /* Try to read the entire TOC for the disk into our internal buffer. */
2248 static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2250 int stat, ntracks, i;
2251 struct cdrom_info *info = drive->driver_data;
2252 struct cdrom_device_info *cdi = &info->devinfo;
2253 struct atapi_toc *toc = info->toc;
2254 struct {
2255 struct atapi_toc_header hdr;
2256 struct atapi_toc_entry ent;
2257 } ms_tmp;
2258 long last_written;
2259 unsigned long sectors_per_frame = SECTORS_PER_FRAME;
2261 if (toc == NULL) {
2262 /* Try to allocate space. */
2263 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
2264 if (toc == NULL) {
2265 printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
2266 return -ENOMEM;
2268 info->toc = toc;
2271 /* Check to see if the existing data is still valid.
2272 If it is, just return. */
2273 (void) cdrom_check_status(drive, sense);
2275 if (CDROM_STATE_FLAGS(drive)->toc_valid)
2276 return 0;
2278 /* Try to get the total cdrom capacity and sector size. */
2279 stat = cdrom_read_capacity(drive, &toc->capacity, &sectors_per_frame,
2280 sense);
2281 if (stat)
2282 toc->capacity = 0x1fffff;
2284 set_capacity(info->disk, toc->capacity * sectors_per_frame);
2285 /* Save a private copy of te TOC capacity for error handling */
2286 drive->probed_capacity = toc->capacity * sectors_per_frame;
2288 blk_queue_hardsect_size(drive->queue,
2289 sectors_per_frame << SECTOR_BITS);
2291 /* First read just the header, so we know how long the TOC is. */
2292 stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
2293 sizeof(struct atapi_toc_header), sense);
2294 if (stat)
2295 return stat;
2297 #if ! STANDARD_ATAPI
2298 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2299 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2300 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2302 #endif /* not STANDARD_ATAPI */
2304 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2305 if (ntracks <= 0)
2306 return -EIO;
2307 if (ntracks > MAX_TRACKS)
2308 ntracks = MAX_TRACKS;
2310 /* Now read the whole schmeer. */
2311 stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
2312 (char *)&toc->hdr,
2313 sizeof(struct atapi_toc_header) +
2314 (ntracks + 1) *
2315 sizeof(struct atapi_toc_entry), sense);
2317 if (stat && toc->hdr.first_track > 1) {
2318 /* Cds with CDI tracks only don't have any TOC entries,
2319 despite of this the returned values are
2320 first_track == last_track = number of CDI tracks + 1,
2321 so that this case is indistinguishable from the same
2322 layout plus an additional audio track.
2323 If we get an error for the regular case, we assume
2324 a CDI without additional audio tracks. In this case
2325 the readable TOC is empty (CDI tracks are not included)
2326 and only holds the Leadout entry. Heiko Ei▀feldt */
2327 ntracks = 0;
2328 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
2329 (char *)&toc->hdr,
2330 sizeof(struct atapi_toc_header) +
2331 (ntracks + 1) *
2332 sizeof(struct atapi_toc_entry),
2333 sense);
2334 if (stat) {
2335 return stat;
2337 #if ! STANDARD_ATAPI
2338 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2339 toc->hdr.first_track = bin2bcd(CDROM_LEADOUT);
2340 toc->hdr.last_track = bin2bcd(CDROM_LEADOUT);
2341 } else
2342 #endif /* not STANDARD_ATAPI */
2344 toc->hdr.first_track = CDROM_LEADOUT;
2345 toc->hdr.last_track = CDROM_LEADOUT;
2349 if (stat)
2350 return stat;
2352 toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
2354 #if ! STANDARD_ATAPI
2355 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2356 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2357 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2359 #endif /* not STANDARD_ATAPI */
2361 for (i=0; i<=ntracks; i++) {
2362 #if ! STANDARD_ATAPI
2363 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2364 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd)
2365 toc->ent[i].track = bcd2bin(toc->ent[i].track);
2366 msf_from_bcd(&toc->ent[i].addr.msf);
2368 #endif /* not STANDARD_ATAPI */
2369 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
2370 toc->ent[i].addr.msf.second,
2371 toc->ent[i].addr.msf.frame);
2374 /* Read the multisession information. */
2375 if (toc->hdr.first_track != CDROM_LEADOUT) {
2376 /* Read the multisession information. */
2377 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
2378 sizeof(ms_tmp), sense);
2379 if (stat)
2380 return stat;
2382 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
2383 } else {
2384 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
2385 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
2388 #if ! STANDARD_ATAPI
2389 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2390 /* Re-read multisession information using MSF format */
2391 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
2392 sizeof(ms_tmp), sense);
2393 if (stat)
2394 return stat;
2396 msf_from_bcd (&ms_tmp.ent.addr.msf);
2397 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
2398 ms_tmp.ent.addr.msf.second,
2399 ms_tmp.ent.addr.msf.frame);
2401 #endif /* not STANDARD_ATAPI */
2403 toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
2405 /* Now try to get the total cdrom capacity. */
2406 stat = cdrom_get_last_written(cdi, &last_written);
2407 if (!stat && (last_written > toc->capacity)) {
2408 toc->capacity = last_written;
2409 set_capacity(info->disk, toc->capacity * sectors_per_frame);
2410 drive->probed_capacity = toc->capacity * sectors_per_frame;
2413 /* Remember that we've read this stuff. */
2414 CDROM_STATE_FLAGS(drive)->toc_valid = 1;
2416 return 0;
2420 static int cdrom_read_subchannel(ide_drive_t *drive, int format, char *buf,
2421 int buflen, struct request_sense *sense)
2423 struct request req;
2425 cdrom_prepare_request(drive, &req);
2427 req.sense = sense;
2428 req.data = buf;
2429 req.data_len = buflen;
2430 req.cmd[0] = GPCMD_READ_SUBCHANNEL;
2431 req.cmd[1] = 2; /* MSF addressing */
2432 req.cmd[2] = 0x40; /* request subQ data */
2433 req.cmd[3] = format;
2434 req.cmd[7] = (buflen >> 8);
2435 req.cmd[8] = (buflen & 0xff);
2436 return cdrom_queue_packet_command(drive, &req);
2439 /* ATAPI cdrom drives are free to select the speed you request or any slower
2440 rate :-( Requesting too fast a speed will _not_ produce an error. */
2441 static int cdrom_select_speed(ide_drive_t *drive, int speed,
2442 struct request_sense *sense)
2444 struct request req;
2445 cdrom_prepare_request(drive, &req);
2447 req.sense = sense;
2448 if (speed == 0)
2449 speed = 0xffff; /* set to max */
2450 else
2451 speed *= 177; /* Nx to kbytes/s */
2453 req.cmd[0] = GPCMD_SET_SPEED;
2454 /* Read Drive speed in kbytes/second MSB */
2455 req.cmd[2] = (speed >> 8) & 0xff;
2456 /* Read Drive speed in kbytes/second LSB */
2457 req.cmd[3] = speed & 0xff;
2458 if (CDROM_CONFIG_FLAGS(drive)->cd_r ||
2459 CDROM_CONFIG_FLAGS(drive)->cd_rw ||
2460 CDROM_CONFIG_FLAGS(drive)->dvd_r) {
2461 /* Write Drive speed in kbytes/second MSB */
2462 req.cmd[4] = (speed >> 8) & 0xff;
2463 /* Write Drive speed in kbytes/second LSB */
2464 req.cmd[5] = speed & 0xff;
2467 return cdrom_queue_packet_command(drive, &req);
2470 static int cdrom_play_audio(ide_drive_t *drive, int lba_start, int lba_end)
2472 struct request_sense sense;
2473 struct request req;
2475 cdrom_prepare_request(drive, &req);
2477 req.sense = &sense;
2478 req.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2479 lba_to_msf(lba_start, &req.cmd[3], &req.cmd[4], &req.cmd[5]);
2480 lba_to_msf(lba_end-1, &req.cmd[6], &req.cmd[7], &req.cmd[8]);
2482 return cdrom_queue_packet_command(drive, &req);
2485 static int cdrom_get_toc_entry(ide_drive_t *drive, int track,
2486 struct atapi_toc_entry **ent)
2488 struct cdrom_info *info = drive->driver_data;
2489 struct atapi_toc *toc = info->toc;
2490 int ntracks;
2492 /*
2493 * don't serve cached data, if the toc isn't valid
2494 */
2495 if (!CDROM_STATE_FLAGS(drive)->toc_valid)
2496 return -EINVAL;
2498 /* Check validity of requested track number. */
2499 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2500 if (toc->hdr.first_track == CDROM_LEADOUT) ntracks = 0;
2501 if (track == CDROM_LEADOUT)
2502 *ent = &toc->ent[ntracks];
2503 else if (track < toc->hdr.first_track ||
2504 track > toc->hdr.last_track)
2505 return -EINVAL;
2506 else
2507 *ent = &toc->ent[track - toc->hdr.first_track];
2509 return 0;
2512 /* the generic packet interface to cdrom.c */
2513 static int ide_cdrom_packet(struct cdrom_device_info *cdi,
2514 struct packet_command *cgc)
2516 struct request req;
2517 ide_drive_t *drive = cdi->handle;
2519 if (cgc->timeout <= 0)
2520 cgc->timeout = ATAPI_WAIT_PC;
2522 /* here we queue the commands from the uniform CD-ROM
2523 layer. the packet must be complete, as we do not
2524 touch it at all. */
2525 cdrom_prepare_request(drive, &req);
2526 memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
2527 if (cgc->sense)
2528 memset(cgc->sense, 0, sizeof(struct request_sense));
2529 req.data = cgc->buffer;
2530 req.data_len = cgc->buflen;
2531 req.timeout = cgc->timeout;
2533 if (cgc->quiet)
2534 req.flags |= REQ_QUIET;
2536 req.sense = cgc->sense;
2537 cgc->stat = cdrom_queue_packet_command(drive, &req);
2538 if (!cgc->stat)
2539 cgc->buflen -= req.data_len;
2540 return cgc->stat;
2543 static
2544 int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
2545 unsigned int cmd, void *arg)
2548 ide_drive_t *drive = cdi->handle;
2549 struct cdrom_info *info = drive->driver_data;
2550 int stat;
2552 switch (cmd) {
2553 /*
2554 * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
2555 * atapi doesn't support it
2556 */
2557 case CDROMPLAYTRKIND: {
2558 unsigned long lba_start, lba_end;
2559 struct cdrom_ti *ti = arg;
2560 struct atapi_toc_entry *first_toc, *last_toc;
2562 stat = cdrom_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
2563 if (stat)
2564 return stat;
2566 stat = cdrom_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
2567 if (stat)
2568 return stat;
2570 if (ti->cdti_trk1 != CDROM_LEADOUT)
2571 ++last_toc;
2572 lba_start = first_toc->addr.lba;
2573 lba_end = last_toc->addr.lba;
2575 if (lba_end <= lba_start)
2576 return -EINVAL;
2578 return cdrom_play_audio(drive, lba_start, lba_end);
2581 case CDROMREADTOCHDR: {
2582 struct cdrom_tochdr *tochdr = arg;
2583 struct atapi_toc *toc;
2585 /* Make sure our saved TOC is valid. */
2586 stat = cdrom_read_toc(drive, NULL);
2587 if (stat)
2588 return stat;
2590 toc = info->toc;
2591 tochdr->cdth_trk0 = toc->hdr.first_track;
2592 tochdr->cdth_trk1 = toc->hdr.last_track;
2594 return 0;
2597 case CDROMREADTOCENTRY: {
2598 struct cdrom_tocentry *tocentry = arg;
2599 struct atapi_toc_entry *toce;
2601 stat = cdrom_get_toc_entry(drive, tocentry->cdte_track, &toce);
2602 if (stat)
2603 return stat;
2605 tocentry->cdte_ctrl = toce->control;
2606 tocentry->cdte_adr = toce->adr;
2607 if (tocentry->cdte_format == CDROM_MSF) {
2608 lba_to_msf (toce->addr.lba,
2609 &tocentry->cdte_addr.msf.minute,
2610 &tocentry->cdte_addr.msf.second,
2611 &tocentry->cdte_addr.msf.frame);
2612 } else
2613 tocentry->cdte_addr.lba = toce->addr.lba;
2615 return 0;
2618 default:
2619 return -EINVAL;
2623 static
2624 int ide_cdrom_reset (struct cdrom_device_info *cdi)
2626 ide_drive_t *drive = cdi->handle;
2627 struct request_sense sense;
2628 struct request req;
2629 int ret;
2631 cdrom_prepare_request(drive, &req);
2632 req.flags = REQ_SPECIAL | REQ_QUIET;
2633 ret = ide_do_drive_cmd(drive, &req, ide_wait);
2635 /*
2636 * A reset will unlock the door. If it was previously locked,
2637 * lock it again.
2638 */
2639 if (CDROM_STATE_FLAGS(drive)->door_locked)
2640 (void) cdrom_lockdoor(drive, 1, &sense);
2642 return ret;
2646 static
2647 int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
2649 ide_drive_t *drive = cdi->handle;
2650 struct request_sense sense;
2652 if (position) {
2653 int stat = cdrom_lockdoor(drive, 0, &sense);
2654 if (stat)
2655 return stat;
2658 return cdrom_eject(drive, !position, &sense);
2661 static
2662 int ide_cdrom_lock_door (struct cdrom_device_info *cdi, int lock)
2664 ide_drive_t *drive = cdi->handle;
2665 return cdrom_lockdoor(drive, lock, NULL);
2668 static
2669 int ide_cdrom_get_capabilities(ide_drive_t *drive, struct atapi_capabilities_page *cap)
2671 struct cdrom_info *info = drive->driver_data;
2672 struct cdrom_device_info *cdi = &info->devinfo;
2673 struct packet_command cgc;
2674 int stat, attempts = 3, size = sizeof(*cap);
2676 /*
2677 * ACER50 (and others?) require the full spec length mode sense
2678 * page capabilities size, but older drives break.
2679 */
2680 if (!(!strcmp(drive->id->model, "ATAPI CD ROM DRIVE 50X MAX") ||
2681 !strcmp(drive->id->model, "WPI CDS-32X")))
2682 size -= sizeof(cap->pad);
2684 init_cdrom_command(&cgc, cap, size, CGC_DATA_UNKNOWN);
2685 do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2686 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
2687 if (!stat)
2688 break;
2689 } while (--attempts);
2690 return stat;
2693 static
2694 void ide_cdrom_update_speed (ide_drive_t *drive, struct atapi_capabilities_page *cap)
2696 /* The ACER/AOpen 24X cdrom has the speed fields byte-swapped */
2697 if (!drive->id->model[0] &&
2698 !strncmp(drive->id->fw_rev, "241N", 4)) {
2699 CDROM_STATE_FLAGS(drive)->current_speed =
2700 (((unsigned int)cap->curspeed) + (176/2)) / 176;
2701 CDROM_CONFIG_FLAGS(drive)->max_speed =
2702 (((unsigned int)cap->maxspeed) + (176/2)) / 176;
2703 } else {
2704 CDROM_STATE_FLAGS(drive)->current_speed =
2705 (ntohs(cap->curspeed) + (176/2)) / 176;
2706 CDROM_CONFIG_FLAGS(drive)->max_speed =
2707 (ntohs(cap->maxspeed) + (176/2)) / 176;
2711 static
2712 int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
2714 ide_drive_t *drive = cdi->handle;
2715 struct request_sense sense;
2716 struct atapi_capabilities_page cap;
2717 int stat;
2719 if ((stat = cdrom_select_speed(drive, speed, &sense)) < 0)
2720 return stat;
2722 if (!ide_cdrom_get_capabilities(drive, &cap)) {
2723 ide_cdrom_update_speed(drive, &cap);
2724 cdi->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2726 return 0;
2729 /*
2730 * add logic to try GET_EVENT command first to check for media and tray
2731 * status. this should be supported by newer cd-r/w and all DVD etc
2732 * drives
2733 */
2734 static
2735 int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
2737 ide_drive_t *drive = cdi->handle;
2738 struct media_event_desc med;
2739 struct request_sense sense;
2740 int stat;
2742 if (slot_nr != CDSL_CURRENT)
2743 return -EINVAL;
2745 stat = cdrom_check_status(drive, &sense);
2746 if (!stat || sense.sense_key == UNIT_ATTENTION)
2747 return CDS_DISC_OK;
2749 if (!cdrom_get_media_event(cdi, &med)) {
2750 if (med.media_present)
2751 return CDS_DISC_OK;
2752 else if (med.door_open)
2753 return CDS_TRAY_OPEN;
2754 else
2755 return CDS_NO_DISC;
2758 if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
2759 return CDS_DISC_OK;
2761 /*
2762 * If not using Mt Fuji extended media tray reports,
2763 * just return TRAY_OPEN since ATAPI doesn't provide
2764 * any other way to detect this...
2765 */
2766 if (sense.sense_key == NOT_READY) {
2767 if (sense.asc == 0x3a && sense.ascq == 1)
2768 return CDS_NO_DISC;
2769 else
2770 return CDS_TRAY_OPEN;
2772 return CDS_DRIVE_NOT_READY;
2775 static
2776 int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
2777 struct cdrom_multisession *ms_info)
2779 struct atapi_toc *toc;
2780 ide_drive_t *drive = cdi->handle;
2781 struct cdrom_info *info = drive->driver_data;
2782 struct request_sense sense;
2783 int ret;
2785 if (!CDROM_STATE_FLAGS(drive)->toc_valid || info->toc == NULL)
2786 if ((ret = cdrom_read_toc(drive, &sense)))
2787 return ret;
2789 toc = info->toc;
2790 ms_info->addr.lba = toc->last_session_lba;
2791 ms_info->xa_flag = toc->xa_flag;
2793 return 0;
2796 static
2797 int ide_cdrom_get_mcn (struct cdrom_device_info *cdi,
2798 struct cdrom_mcn *mcn_info)
2800 int stat;
2801 char mcnbuf[24];
2802 ide_drive_t *drive = cdi->handle;
2804 /* get MCN */
2805 if ((stat = cdrom_read_subchannel(drive, 2, mcnbuf, sizeof (mcnbuf), NULL)))
2806 return stat;
2808 memcpy (mcn_info->medium_catalog_number, mcnbuf+9,
2809 sizeof (mcn_info->medium_catalog_number)-1);
2810 mcn_info->medium_catalog_number[sizeof (mcn_info->medium_catalog_number)-1]
2811 = '\0';
2813 return 0;
2818 /****************************************************************************
2819 * Other driver requests (open, close, check media change).
2820 */
2822 static
2823 int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
2824 int slot_nr)
2826 ide_drive_t *drive = cdi->handle;
2827 int retval;
2829 if (slot_nr == CDSL_CURRENT) {
2830 (void) cdrom_check_status(drive, NULL);
2831 retval = CDROM_STATE_FLAGS(drive)->media_changed;
2832 CDROM_STATE_FLAGS(drive)->media_changed = 0;
2833 return retval;
2834 } else {
2835 return -EINVAL;
2840 static
2841 int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
2843 return 0;
2846 /*
2847 * Close down the device. Invalidate all cached blocks.
2848 */
2850 static
2851 void ide_cdrom_release_real (struct cdrom_device_info *cdi)
2853 ide_drive_t *drive = cdi->handle;
2855 if (!cdi->use_count)
2856 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
2861 /****************************************************************************
2862 * Device initialization.
2863 */
2864 static struct cdrom_device_ops ide_cdrom_dops = {
2865 .open = ide_cdrom_open_real,
2866 .release = ide_cdrom_release_real,
2867 .drive_status = ide_cdrom_drive_status,
2868 .media_changed = ide_cdrom_check_media_change_real,
2869 .tray_move = ide_cdrom_tray_move,
2870 .lock_door = ide_cdrom_lock_door,
2871 .select_speed = ide_cdrom_select_speed,
2872 .get_last_session = ide_cdrom_get_last_session,
2873 .get_mcn = ide_cdrom_get_mcn,
2874 .reset = ide_cdrom_reset,
2875 .audio_ioctl = ide_cdrom_audio_ioctl,
2876 .capability = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
2877 CDC_SELECT_SPEED | CDC_SELECT_DISC |
2878 CDC_MULTI_SESSION | CDC_MCN |
2879 CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO | CDC_RESET |
2880 CDC_DRIVE_STATUS | CDC_CD_R |
2881 CDC_CD_RW | CDC_DVD | CDC_DVD_R| CDC_DVD_RAM |
2882 CDC_GENERIC_PACKET | CDC_MO_DRIVE | CDC_MRW |
2883 CDC_MRW_W | CDC_RAM,
2884 .generic_packet = ide_cdrom_packet,
2885 };
2887 static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2889 struct cdrom_info *info = drive->driver_data;
2890 struct cdrom_device_info *devinfo = &info->devinfo;
2892 devinfo->ops = &ide_cdrom_dops;
2893 devinfo->mask = 0;
2894 devinfo->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2895 devinfo->capacity = nslots;
2896 devinfo->handle = drive;
2897 strcpy(devinfo->name, drive->name);
2899 /* set capability mask to match the probe. */
2900 if (!CDROM_CONFIG_FLAGS(drive)->cd_r)
2901 devinfo->mask |= CDC_CD_R;
2902 if (!CDROM_CONFIG_FLAGS(drive)->cd_rw)
2903 devinfo->mask |= CDC_CD_RW;
2904 if (!CDROM_CONFIG_FLAGS(drive)->dvd)
2905 devinfo->mask |= CDC_DVD;
2906 if (!CDROM_CONFIG_FLAGS(drive)->dvd_r)
2907 devinfo->mask |= CDC_DVD_R;
2908 if (!CDROM_CONFIG_FLAGS(drive)->dvd_ram)
2909 devinfo->mask |= CDC_DVD_RAM;
2910 if (!CDROM_CONFIG_FLAGS(drive)->is_changer)
2911 devinfo->mask |= CDC_SELECT_DISC;
2912 if (!CDROM_CONFIG_FLAGS(drive)->audio_play)
2913 devinfo->mask |= CDC_PLAY_AUDIO;
2914 if (!CDROM_CONFIG_FLAGS(drive)->close_tray)
2915 devinfo->mask |= CDC_CLOSE_TRAY;
2916 if (!CDROM_CONFIG_FLAGS(drive)->mo_drive)
2917 devinfo->mask |= CDC_MO_DRIVE;
2918 if (!CDROM_CONFIG_FLAGS(drive)->ram)
2919 devinfo->mask |= CDC_RAM;
2921 devinfo->disk = info->disk;
2922 return register_cdrom(devinfo);
2925 static
2926 int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2928 struct cdrom_info *info = drive->driver_data;
2929 struct cdrom_device_info *cdi = &info->devinfo;
2930 struct atapi_capabilities_page cap;
2931 int nslots = 1;
2933 if (drive->media == ide_optical) {
2934 CDROM_CONFIG_FLAGS(drive)->mo_drive = 1;
2935 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2936 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
2937 return nslots;
2940 if (CDROM_CONFIG_FLAGS(drive)->nec260 ||
2941 !strcmp(drive->id->model,"STINGRAY 8422 IDE 8X CD-ROM 7-27-95")) {
2942 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2943 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2944 return nslots;
2947 /*
2948 * we have to cheat a little here. the packet will eventually
2949 * be queued with ide_cdrom_packet(), which extracts the
2950 * drive from cdi->handle. Since this device hasn't been
2951 * registered with the Uniform layer yet, it can't do this.
2952 * Same goes for cdi->ops.
2953 */
2954 cdi->handle = drive;
2955 cdi->ops = &ide_cdrom_dops;
2957 if (ide_cdrom_get_capabilities(drive, &cap))
2958 return 0;
2960 if (cap.lock == 0)
2961 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2962 if (cap.eject)
2963 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2964 if (cap.cd_r_write)
2965 CDROM_CONFIG_FLAGS(drive)->cd_r = 1;
2966 if (cap.cd_rw_write) {
2967 CDROM_CONFIG_FLAGS(drive)->cd_rw = 1;
2968 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2970 if (cap.test_write)
2971 CDROM_CONFIG_FLAGS(drive)->test_write = 1;
2972 if (cap.dvd_ram_read || cap.dvd_r_read || cap.dvd_rom)
2973 CDROM_CONFIG_FLAGS(drive)->dvd = 1;
2974 if (cap.dvd_ram_write) {
2975 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 1;
2976 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2978 if (cap.dvd_r_write)
2979 CDROM_CONFIG_FLAGS(drive)->dvd_r = 1;
2980 if (cap.audio_play)
2981 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2982 if (cap.mechtype == mechtype_caddy || cap.mechtype == mechtype_popup)
2983 CDROM_CONFIG_FLAGS(drive)->close_tray = 0;
2985 /* Some drives used by Apple don't advertise audio play
2986 * but they do support reading TOC & audio datas
2987 */
2988 if (strcmp(drive->id->model, "MATSHITADVD-ROM SR-8187") == 0 ||
2989 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8186") == 0 ||
2990 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8176") == 0 ||
2991 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8174") == 0)
2992 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2994 #if ! STANDARD_ATAPI
2995 if (cdi->sanyo_slot > 0) {
2996 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
2997 nslots = 3;
3000 else
3001 #endif /* not STANDARD_ATAPI */
3002 if (cap.mechtype == mechtype_individual_changer ||
3003 cap.mechtype == mechtype_cartridge_changer) {
3004 if ((nslots = cdrom_number_of_slots(cdi)) > 1) {
3005 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
3006 CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 1;
3010 ide_cdrom_update_speed(drive, &cap);
3011 /* don't print speed if the drive reported 0.
3012 */
3013 printk(KERN_INFO "%s: ATAPI", drive->name);
3014 if (CDROM_CONFIG_FLAGS(drive)->max_speed)
3015 printk(" %dX", CDROM_CONFIG_FLAGS(drive)->max_speed);
3016 printk(" %s", CDROM_CONFIG_FLAGS(drive)->dvd ? "DVD-ROM" : "CD-ROM");
3018 if (CDROM_CONFIG_FLAGS(drive)->dvd_r|CDROM_CONFIG_FLAGS(drive)->dvd_ram)
3019 printk(" DVD%s%s",
3020 (CDROM_CONFIG_FLAGS(drive)->dvd_r)? "-R" : "",
3021 (CDROM_CONFIG_FLAGS(drive)->dvd_ram)? "-RAM" : "");
3023 if (CDROM_CONFIG_FLAGS(drive)->cd_r|CDROM_CONFIG_FLAGS(drive)->cd_rw)
3024 printk(" CD%s%s",
3025 (CDROM_CONFIG_FLAGS(drive)->cd_r)? "-R" : "",
3026 (CDROM_CONFIG_FLAGS(drive)->cd_rw)? "/RW" : "");
3028 if (CDROM_CONFIG_FLAGS(drive)->is_changer)
3029 printk(" changer w/%d slots", nslots);
3030 else
3031 printk(" drive");
3033 printk(", %dkB Cache", be16_to_cpu(cap.buffer_size));
3035 if (drive->using_dma)
3036 ide_dma_verbose(drive);
3038 printk("\n");
3040 return nslots;
3043 static void ide_cdrom_add_settings(ide_drive_t *drive)
3045 ide_add_setting(drive, "dsc_overlap", SETTING_RW, -1, -1, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
3048 /*
3049 * standard prep_rq_fn that builds 10 byte cmds
3050 */
3051 static int ide_cdrom_prep_fs(request_queue_t *q, struct request *rq)
3053 int hard_sect = queue_hardsect_size(q);
3054 long block = (long)rq->hard_sector / (hard_sect >> 9);
3055 unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
3057 memset(rq->cmd, 0, sizeof(rq->cmd));
3059 if (rq_data_dir(rq) == READ)
3060 rq->cmd[0] = GPCMD_READ_10;
3061 else
3062 rq->cmd[0] = GPCMD_WRITE_10;
3064 /*
3065 * fill in lba
3066 */
3067 rq->cmd[2] = (block >> 24) & 0xff;
3068 rq->cmd[3] = (block >> 16) & 0xff;
3069 rq->cmd[4] = (block >> 8) & 0xff;
3070 rq->cmd[5] = block & 0xff;
3072 /*
3073 * and transfer length
3074 */
3075 rq->cmd[7] = (blocks >> 8) & 0xff;
3076 rq->cmd[8] = blocks & 0xff;
3077 rq->cmd_len = 10;
3078 return BLKPREP_OK;
3081 /*
3082 * Most of the SCSI commands are supported directly by ATAPI devices.
3083 * This transform handles the few exceptions.
3084 */
3085 static int ide_cdrom_prep_pc(struct request *rq)
3087 u8 *c = rq->cmd;
3089 /*
3090 * Transform 6-byte read/write commands to the 10-byte version
3091 */
3092 if (c[0] == READ_6 || c[0] == WRITE_6) {
3093 c[8] = c[4];
3094 c[5] = c[3];
3095 c[4] = c[2];
3096 c[3] = c[1] & 0x1f;
3097 c[2] = 0;
3098 c[1] &= 0xe0;
3099 c[0] += (READ_10 - READ_6);
3100 rq->cmd_len = 10;
3101 return BLKPREP_OK;
3104 /*
3105 * it's silly to pretend we understand 6-byte sense commands, just
3106 * reject with ILLEGAL_REQUEST and the caller should take the
3107 * appropriate action
3108 */
3109 if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
3110 rq->errors = ILLEGAL_REQUEST;
3111 return BLKPREP_KILL;
3114 return BLKPREP_OK;
3117 static int ide_cdrom_prep_fn(request_queue_t *q, struct request *rq)
3119 if (rq->flags & REQ_CMD)
3120 return ide_cdrom_prep_fs(q, rq);
3121 else if (rq->flags & REQ_BLOCK_PC)
3122 return ide_cdrom_prep_pc(rq);
3124 return 0;
3127 static
3128 int ide_cdrom_setup (ide_drive_t *drive)
3130 struct cdrom_info *info = drive->driver_data;
3131 struct cdrom_device_info *cdi = &info->devinfo;
3132 int nslots;
3134 blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
3135 blk_queue_dma_alignment(drive->queue, 31);
3136 drive->queue->unplug_delay = (1 * HZ) / 1000;
3137 if (!drive->queue->unplug_delay)
3138 drive->queue->unplug_delay = 1;
3140 drive->special.all = 0;
3142 CDROM_STATE_FLAGS(drive)->media_changed = 1;
3143 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
3144 CDROM_STATE_FLAGS(drive)->door_locked = 0;
3146 #if NO_DOOR_LOCKING
3147 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
3148 #else
3149 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 0;
3150 #endif
3152 CDROM_CONFIG_FLAGS(drive)->drq_interrupt = ((drive->id->config & 0x0060) == 0x20);
3153 CDROM_CONFIG_FLAGS(drive)->is_changer = 0;
3154 CDROM_CONFIG_FLAGS(drive)->cd_r = 0;
3155 CDROM_CONFIG_FLAGS(drive)->cd_rw = 0;
3156 CDROM_CONFIG_FLAGS(drive)->test_write = 0;
3157 CDROM_CONFIG_FLAGS(drive)->dvd = 0;
3158 CDROM_CONFIG_FLAGS(drive)->dvd_r = 0;
3159 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 0;
3160 CDROM_CONFIG_FLAGS(drive)->no_eject = 1;
3161 CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 0;
3162 CDROM_CONFIG_FLAGS(drive)->audio_play = 0;
3163 CDROM_CONFIG_FLAGS(drive)->close_tray = 1;
3165 /* limit transfer size per interrupt. */
3166 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 0;
3167 /* a testament to the nice quality of Samsung drives... */
3168 if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2430"))
3169 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3170 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2432"))
3171 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3172 /* the 3231 model does not support the SET_CD_SPEED command */
3173 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-3231"))
3174 cdi->mask |= CDC_SELECT_SPEED;
3176 #if ! STANDARD_ATAPI
3177 /* by default Sanyo 3 CD changer support is turned off and
3178 ATAPI Rev 2.2+ standard support for CD changers is used */
3179 cdi->sanyo_slot = 0;
3181 CDROM_CONFIG_FLAGS(drive)->nec260 = 0;
3182 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 0;
3183 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 0;
3184 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 0;
3185 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 0;
3187 if (strcmp (drive->id->model, "V003S0DS") == 0 &&
3188 drive->id->fw_rev[4] == '1' &&
3189 drive->id->fw_rev[6] <= '2') {
3190 /* Vertos 300.
3191 Some versions of this drive like to talk BCD. */
3192 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3193 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3194 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3195 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3198 else if (strcmp (drive->id->model, "V006E0DS") == 0 &&
3199 drive->id->fw_rev[4] == '1' &&
3200 drive->id->fw_rev[6] <= '2') {
3201 /* Vertos 600 ESD. */
3202 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3204 else if (strcmp(drive->id->model, "NEC CD-ROM DRIVE:260") == 0 &&
3205 strncmp(drive->id->fw_rev, "1.01", 4) == 0) { /* FIXME */
3206 /* Old NEC260 (not R).
3207 This drive was released before the 1.2 version
3208 of the spec. */
3209 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3210 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3211 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3212 CDROM_CONFIG_FLAGS(drive)->nec260 = 1;
3214 else if (strcmp(drive->id->model, "WEARNES CDD-120") == 0 &&
3215 strncmp(drive->id->fw_rev, "A1.1", 4) == 0) { /* FIXME */
3216 /* Wearnes */
3217 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3218 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3220 /* Sanyo 3 CD changer uses a non-standard command
3221 for CD changing */
3222 else if ((strcmp(drive->id->model, "CD-ROM CDR-C3 G") == 0) ||
3223 (strcmp(drive->id->model, "CD-ROM CDR-C3G") == 0) ||
3224 (strcmp(drive->id->model, "CD-ROM CDR_C36") == 0)) {
3225 /* uses CD in slot 0 when value is set to 3 */
3226 cdi->sanyo_slot = 3;
3228 #endif /* not STANDARD_ATAPI */
3230 info->toc = NULL;
3231 info->buffer = NULL;
3232 info->sector_buffered = 0;
3233 info->nsectors_buffered = 0;
3234 info->changer_info = NULL;
3235 info->last_block = 0;
3236 info->start_seek = 0;
3238 nslots = ide_cdrom_probe_capabilities (drive);
3240 /*
3241 * set correct block size
3242 */
3243 blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
3245 if (drive->autotune == IDE_TUNE_DEFAULT ||
3246 drive->autotune == IDE_TUNE_AUTO)
3247 drive->dsc_overlap = (drive->next != drive);
3248 #if 0
3249 drive->dsc_overlap = (HWIF(drive)->no_dsc) ? 0 : 1;
3250 if (HWIF(drive)->no_dsc) {
3251 printk(KERN_INFO "ide-cd: %s: disabling DSC overlap\n",
3252 drive->name);
3253 drive->dsc_overlap = 0;
3255 #endif
3257 if (ide_cdrom_register(drive, nslots)) {
3258 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
3259 info->devinfo.handle = NULL;
3260 return 1;
3262 ide_cdrom_add_settings(drive);
3263 return 0;
3266 #ifdef CONFIG_PROC_FS
3267 static
3268 sector_t ide_cdrom_capacity (ide_drive_t *drive)
3270 unsigned long capacity, sectors_per_frame;
3272 if (cdrom_read_capacity(drive, &capacity, &sectors_per_frame, NULL))
3273 return 0;
3275 return capacity * sectors_per_frame;
3277 #endif
3279 static void ide_cd_remove(ide_drive_t *drive)
3281 struct cdrom_info *info = drive->driver_data;
3283 ide_unregister_subdriver(drive, info->driver);
3285 del_gendisk(info->disk);
3287 ide_cd_put(info);
3290 static void ide_cd_release(struct kref *kref)
3292 struct cdrom_info *info = to_ide_cd(kref);
3293 struct cdrom_device_info *devinfo = &info->devinfo;
3294 ide_drive_t *drive = info->drive;
3295 struct gendisk *g = info->disk;
3297 kfree(info->buffer);
3298 kfree(info->toc);
3299 kfree(info->changer_info);
3300 if (devinfo->handle == drive && unregister_cdrom(devinfo))
3301 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom "
3302 "driver.\n", __FUNCTION__, drive->name);
3303 drive->dsc_overlap = 0;
3304 drive->driver_data = NULL;
3305 blk_queue_prep_rq(drive->queue, NULL);
3306 g->private_data = NULL;
3307 put_disk(g);
3308 kfree(info);
3311 static int ide_cd_probe(ide_drive_t *);
3313 #ifdef CONFIG_PROC_FS
3314 static int proc_idecd_read_capacity
3315 (char *page, char **start, off_t off, int count, int *eof, void *data)
3317 ide_drive_t *drive = data;
3318 int len;
3320 len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
3321 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
3324 static ide_proc_entry_t idecd_proc[] = {
3325 { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
3326 { NULL, 0, NULL, NULL }
3327 };
3328 #else
3329 # define idecd_proc NULL
3330 #endif
3332 static ide_driver_t ide_cdrom_driver = {
3333 .gen_driver = {
3334 .owner = THIS_MODULE,
3335 .name = "ide-cdrom",
3336 .bus = &ide_bus_type,
3337 },
3338 .probe = ide_cd_probe,
3339 .remove = ide_cd_remove,
3340 .version = IDECD_VERSION,
3341 .media = ide_cdrom,
3342 .supports_dsc_overlap = 1,
3343 .do_request = ide_do_rw_cdrom,
3344 .end_request = ide_end_request,
3345 .error = __ide_error,
3346 .abort = __ide_abort,
3347 .proc = idecd_proc,
3348 };
3350 static int idecd_open(struct inode * inode, struct file * file)
3352 struct gendisk *disk = inode->i_bdev->bd_disk;
3353 struct cdrom_info *info;
3354 ide_drive_t *drive;
3355 int rc = -ENOMEM;
3357 if (!(info = ide_cd_get(disk)))
3358 return -ENXIO;
3360 drive = info->drive;
3362 drive->usage++;
3364 if (!info->buffer)
3365 info->buffer = kmalloc(SECTOR_BUFFER_SIZE,
3366 GFP_KERNEL|__GFP_REPEAT);
3367 if (!info->buffer || (rc = cdrom_open(&info->devinfo, inode, file)))
3368 drive->usage--;
3370 if (rc < 0)
3371 ide_cd_put(info);
3373 return rc;
3376 static int idecd_release(struct inode * inode, struct file * file)
3378 struct gendisk *disk = inode->i_bdev->bd_disk;
3379 struct cdrom_info *info = ide_cd_g(disk);
3380 ide_drive_t *drive = info->drive;
3382 cdrom_release (&info->devinfo, file);
3383 drive->usage--;
3385 ide_cd_put(info);
3387 return 0;
3390 static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg)
3392 struct packet_command cgc;
3393 char buffer[16];
3394 int stat;
3395 char spindown;
3397 if (copy_from_user(&spindown, (void __user *)arg, sizeof(char)))
3398 return -EFAULT;
3400 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
3402 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
3403 if (stat)
3404 return stat;
3406 buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
3407 return cdrom_mode_select(cdi, &cgc);
3410 static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
3412 struct packet_command cgc;
3413 char buffer[16];
3414 int stat;
3415 char spindown;
3417 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
3419 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
3420 if (stat)
3421 return stat;
3423 spindown = buffer[11] & 0x0f;
3424 if (copy_to_user((void __user *)arg, &spindown, sizeof (char)))
3425 return -EFAULT;
3426 return 0;
3429 static int idecd_ioctl (struct inode *inode, struct file *file,
3430 unsigned int cmd, unsigned long arg)
3432 struct block_device *bdev = inode->i_bdev;
3433 struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
3434 int err;
3436 switch (cmd) {
3437 case CDROMSETSPINDOWN:
3438 return idecd_set_spindown(&info->devinfo, arg);
3439 case CDROMGETSPINDOWN:
3440 return idecd_get_spindown(&info->devinfo, arg);
3441 default:
3442 break;
3445 err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
3446 if (err == -EINVAL)
3447 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
3449 return err;
3452 static int idecd_media_changed(struct gendisk *disk)
3454 struct cdrom_info *info = ide_cd_g(disk);
3455 return cdrom_media_changed(&info->devinfo);
3458 static int idecd_revalidate_disk(struct gendisk *disk)
3460 struct cdrom_info *info = ide_cd_g(disk);
3461 struct request_sense sense;
3462 cdrom_read_toc(info->drive, &sense);
3463 return 0;
3466 static struct block_device_operations idecd_ops = {
3467 .owner = THIS_MODULE,
3468 .open = idecd_open,
3469 .release = idecd_release,
3470 .ioctl = idecd_ioctl,
3471 .media_changed = idecd_media_changed,
3472 .revalidate_disk= idecd_revalidate_disk
3473 };
3475 /* options */
3476 static char *ignore = NULL;
3478 module_param(ignore, charp, 0400);
3479 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
3481 static int ide_cd_probe(ide_drive_t *drive)
3483 struct cdrom_info *info;
3484 struct gendisk *g;
3485 struct request_sense sense;
3487 if (!strstr("ide-cdrom", drive->driver_req))
3488 goto failed;
3489 if (!drive->present)
3490 goto failed;
3491 if (drive->media != ide_cdrom && drive->media != ide_optical)
3492 goto failed;
3493 /* skip drives that we were told to ignore */
3494 if (ignore != NULL) {
3495 if (strstr(ignore, drive->name)) {
3496 printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
3497 goto failed;
3500 if (drive->scsi) {
3501 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
3502 goto failed;
3504 info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
3505 if (info == NULL) {
3506 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
3507 goto failed;
3510 g = alloc_disk(1 << PARTN_BITS);
3511 if (!g)
3512 goto out_free_cd;
3514 ide_init_disk(g, drive);
3516 ide_register_subdriver(drive, &ide_cdrom_driver);
3518 kref_init(&info->kref);
3520 info->drive = drive;
3521 info->driver = &ide_cdrom_driver;
3522 info->disk = g;
3524 g->private_data = &info->driver;
3526 drive->driver_data = info;
3528 g->minors = 1;
3529 g->driverfs_dev = &drive->gendev;
3530 g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
3531 if (ide_cdrom_setup(drive)) {
3532 struct cdrom_device_info *devinfo = &info->devinfo;
3533 ide_unregister_subdriver(drive, &ide_cdrom_driver);
3534 kfree(info->buffer);
3535 kfree(info->toc);
3536 kfree(info->changer_info);
3537 if (devinfo->handle == drive && unregister_cdrom(devinfo))
3538 printk (KERN_ERR "%s: ide_cdrom_cleanup failed to unregister device from the cdrom driver.\n", drive->name);
3539 kfree(info);
3540 drive->driver_data = NULL;
3541 goto failed;
3544 cdrom_read_toc(drive, &sense);
3545 g->fops = &idecd_ops;
3546 g->flags |= GENHD_FL_REMOVABLE;
3547 add_disk(g);
3548 return 0;
3550 out_free_cd:
3551 kfree(info);
3552 failed:
3553 return -ENODEV;
3556 static void __exit ide_cdrom_exit(void)
3558 driver_unregister(&ide_cdrom_driver.gen_driver);
3561 static int __init ide_cdrom_init(void)
3563 return driver_register(&ide_cdrom_driver.gen_driver);
3566 MODULE_ALIAS("ide:*m-cdrom*");
3567 module_init(ide_cdrom_init);
3568 module_exit(ide_cdrom_exit);
3569 MODULE_LICENSE("GPL");