projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ide-cd: fix "missing data" handling in cdrom_pc_intr()
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / ide / ide-cd.c
CommitLineData
1da177e4
LT		 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.
96de0e25 123 * 3.11 Apr 29, 1996 -- Patch from Heiko Eißfeldt <heiko@colossus.escape.de>
1da177e4
LT		 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.
96de0e25 259 * - Heiko Eißfeldt <heiko@colossus.escape.de> supplied
1da177e4
LT		 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 *************************************************************************/
301
302#define IDECD_VERSION "4.61"
303
1da177e4
LT		 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>
cf8b8975 315#include <linux/mutex.h>
1da177e4
LT		 316
317#include <scsi/scsi.h> /* For SCSI -> ATAPI command conversion */
318
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>
324
325#include "ide-cd.h"
326
cf8b8975 327static DEFINE_MUTEX(idecd_ref_mutex);
1da177e4
LT		 328
329#define to_ide_cd(obj) container_of(obj, struct cdrom_info, kref)
330
331#define ide_cd_g(disk) \
332 container_of((disk)->private_data, struct cdrom_info, driver)
333
334static struct cdrom_info *ide_cd_get(struct gendisk *disk)
335{
336 struct cdrom_info *cd = NULL;
337
cf8b8975 338 mutex_lock(&idecd_ref_mutex);
1da177e4
LT		 339 cd = ide_cd_g(disk);
340 if (cd)
341 kref_get(&cd->kref);
cf8b8975 342 mutex_unlock(&idecd_ref_mutex);
1da177e4
LT		 343 return cd;
344}
345
346static void ide_cd_release(struct kref *);
347
348static void ide_cd_put(struct cdrom_info *cd)
349{
cf8b8975 350 mutex_lock(&idecd_ref_mutex);
1da177e4 351 kref_put(&cd->kref, ide_cd_release);
cf8b8975 352 mutex_unlock(&idecd_ref_mutex);
1da177e4
LT		 353}
354
355/****************************************************************************
356 * Generic packet command support and error handling routines.
357 */
358
359/* Mark that we've seen a media change, and invalidate our internal
360 buffers. */
361static void cdrom_saw_media_change (ide_drive_t *drive)
362{
363 struct cdrom_info *info = drive->driver_data;
364
365 CDROM_STATE_FLAGS (drive)->media_changed = 1;
366 CDROM_STATE_FLAGS (drive)->toc_valid = 0;
367 info->nsectors_buffered = 0;
368}
369
370static int cdrom_log_sense(ide_drive_t *drive, struct request *rq,
371 struct request_sense *sense)
372{
373 int log = 0;
374
4aff5e23 375 if (!sense || !rq || (rq->cmd_flags & REQ_QUIET))
1da177e4
LT		 376 return 0;
377
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)
dbe217af
AC		 397 break;
398 log = 1;
1da177e4
LT		 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}
414
415static
416void cdrom_analyze_sense_data(ide_drive_t *drive,
417 struct request *failed_command,
418 struct request_sense *sense)
419{
dbe217af
AC		 420 unsigned long sector;
421 unsigned long bio_sectors;
422 unsigned long valid;
423 struct cdrom_info *info = drive->driver_data;
424
1da177e4
LT		 425 if (!cdrom_log_sense(drive, failed_command, sense))
426 return;
427
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;
436
dbe217af
AC		 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]);
451
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;
459
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 }
1da177e4
LT		 468#if VERBOSE_IDE_CD_ERRORS
469 {
470 int i;
70d1d47c 471 const char *s = "bad sense key!";
1da177e4
LT		 472 char buf[80];
473
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: ");
483
74c8f97a 484 if (sense->sense_key < ARRAY_SIZE(sense_key_texts))
1da177e4 485 s = sense_key_texts[sense->sense_key];
1da177e4
LT		 486
487 printk("%s -- (Sense key=0x%02x)\n", s, sense->sense_key);
488
489 if (sense->asc == 0x40) {
490 sprintf(buf, "Diagnostic failure on component 0x%02x",
491 sense->ascq);
492 s = buf;
493 } else {
74c8f97a 494 int lo = 0, mid, hi = ARRAY_SIZE(sense_data_texts);
1da177e4
LT		 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;
500
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 }
514
515 if (s == NULL) {
516 if (sense->asc > 0x80)
517 s = "(vendor-specific error)";
518 else
519 s = "(reserved error code)";
520 }
521
522 printk(KERN_ERR " %s -- (asc=0x%02x, ascq=0x%02x)\n",
523 s, sense->asc, sense->ascq);
524
525 if (failed_command != NULL) {
526
74c8f97a 527 int lo=0, mid, hi= ARRAY_SIZE(packet_command_texts);
1da177e4
LT		 528 s = NULL;
529
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 }
543
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 }
549
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);
558
559 }
560
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]);
567
568 if ((sense->sks[0] & 0x40) != 0)
569 printk (" bit %d", sense->sks[0] & 0x07);
570
571 printk ("\n");
572 }
573 }
574
575#else /* not VERBOSE_IDE_CD_ERRORS */
576
577 /* Suppress printing unit attention and `in progress of becoming ready'
578 errors when we're not being verbose. */
579
580 if (sense->sense_key == UNIT_ATTENTION ||
581 (sense->sense_key == NOT_READY && (sense->asc == 4 ||
582 sense->asc == 0x3a)))
583 return;
584
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}
591
592/*
593 * Initialize a ide-cd packet command request
594 */
595static void cdrom_prepare_request(ide_drive_t *drive, struct request *rq)
596{
597 struct cdrom_info *cd = drive->driver_data;
598
599 ide_init_drive_cmd(rq);
cea2885a 600 rq->cmd_type = REQ_TYPE_ATA_PC;
1da177e4
LT		 601 rq->rq_disk = cd->disk;
602}
603
604static 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;
609
610 if (sense == NULL)
611 sense = &info->sense_data;
612
613 /* stuff the sense request in front of our current request */
614 cdrom_prepare_request(drive, rq);
615
616 rq->data = sense;
617 rq->cmd[0] = GPCMD_REQUEST_SENSE;
618 rq->cmd[4] = rq->data_len = 18;
619
4aff5e23 620 rq->cmd_type = REQ_TYPE_SENSE;
1da177e4
LT		 621
622 /* NOTE! Save the failed command in "rq->buffer" */
623 rq->buffer = (void *) failed_command;
624
625 (void) ide_do_drive_cmd(drive, rq, ide_preempt);
626}
627
628static 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;
632
4aff5e23 633 if (blk_sense_request(rq) && uptodate) {
1da177e4 634 /*
4aff5e23
JA		 635 * For REQ_TYPE_SENSE, "rq->buffer" points to the original
636 * failed request
1da177e4
LT		 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;
642
643 if (failed) {
644 if (failed->sense) {
645 sense = failed->sense;
646 failed->sense_len = rq->sense_len;
647 }
dbe217af 648 cdrom_analyze_sense_data(drive, failed, sense);
1da177e4
LT		 649 /*
650 * now end failed request
651 */
dbe217af
AC		 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);
5e36bb6e
KU		 658 if (__blk_end_request(failed, -EIO,
659 failed->data_len))
660 BUG();
dbe217af
AC		 661 spin_unlock_irqrestore(&ide_lock, flags);
662 }
663 } else
664 cdrom_analyze_sense_data(drive, NULL, sense);
1da177e4
LT		 665 }
666
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;
674
675 ide_end_request(drive, uptodate, nsectors);
676}
677
dbe217af
AC		 678static 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}
684
1da177e4
LT		 685/* Returns 0 if the request should be continued.
686 Returns 1 if the request was ended. */
687static 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;
691
692 /* Check for errors. */
693 stat = HWIF(drive)->INB(IDE_STATUS_REG);
694 if (stat_ret)
695 *stat_ret = stat;
696
697 if (OK_STAT(stat, good_stat, BAD_R_STAT))
698 return 0;
699
700 /* Get the IDE error register. */
701 err = HWIF(drive)->INB(IDE_ERROR_REG);
702 sense_key = err >> 4;
703
704 if (rq == NULL) {
705 printk("%s: missing rq in cdrom_decode_status\n", drive->name);
706 return 1;
707 }
708
4aff5e23 709 if (blk_sense_request(rq)) {
1da177e4
LT		 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. */
713
4aff5e23 714 rq->cmd_flags |= REQ_FAILED;
1da177e4
LT		 715 cdrom_end_request(drive, 0);
716 ide_error(drive, "request sense failure", stat);
717 return 1;
718
8770c018 719 } else if (blk_pc_request(rq) || rq->cmd_type == REQ_TYPE_ATA_PC) {
1da177e4
LT		 720 /* All other functions, except for READ. */
721 unsigned long flags;
722
723 /*
724 * if we have an error, pass back CHECK_CONDITION as the
725 * scsi status byte
726 */
b7156731 727 if (blk_pc_request(rq) && !rq->errors)
1da177e4
LT		 728 rq->errors = SAM_STAT_CHECK_CONDITION;
729
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;
76ca1af1
SH		 738 } else if ((sense_key == ILLEGAL_REQUEST) &&
739 (rq->cmd[0] == GPCMD_START_STOP_UNIT)) {
740 /*
741 * Don't print error message for this condition--
742 * SFF8090i indicates that 5/24/00 is the correct
743 * response to a request to close the tray if the
744 * drive doesn't have that capability.
745 * cdrom_log_sense() knows this!
746 */
4aff5e23 747 } else if (!(rq->cmd_flags & REQ_QUIET)) {
1da177e4
LT		 748 /* Otherwise, print an error. */
749 ide_dump_status(drive, "packet command error", stat);
750 }
751
4aff5e23 752 rq->cmd_flags |= REQ_FAILED;
1da177e4
LT		 753
754 /*
755 * instead of playing games with moving completions around,
756 * remove failed request completely and end it when the
757 * request sense has completed
758 */
759 if (stat & ERR_STAT) {
760 spin_lock_irqsave(&ide_lock, flags);
761 blkdev_dequeue_request(rq);
762 HWGROUP(drive)->rq = NULL;
763 spin_unlock_irqrestore(&ide_lock, flags);
764
765 cdrom_queue_request_sense(drive, rq->sense, rq);
766 } else
767 cdrom_end_request(drive, 0);
768
769 } else if (blk_fs_request(rq)) {
770 int do_end_request = 0;
771
772 /* Handle errors from READ and WRITE requests. */
773
774 if (blk_noretry_request(rq))
775 do_end_request = 1;
776
777 if (sense_key == NOT_READY) {
778 /* Tray open. */
779 if (rq_data_dir(rq) == READ) {
780 cdrom_saw_media_change (drive);
781
782 /* Fail the request. */
783 printk ("%s: tray open\n", drive->name);
784 do_end_request = 1;
785 } else {
786 struct cdrom_info *info = drive->driver_data;
787
788 /* allow the drive 5 seconds to recover, some
789 * devices will return this error while flushing
790 * data from cache */
791 if (!rq->errors)
792 info->write_timeout = jiffies + ATAPI_WAIT_WRITE_BUSY;
793 rq->errors = 1;
794 if (time_after(jiffies, info->write_timeout))
795 do_end_request = 1;
796 else {
797 unsigned long flags;
798
799 /*
800 * take a breather relying on the
801 * unplug timer to kick us again
802 */
803 spin_lock_irqsave(&ide_lock, flags);
804 blk_plug_device(drive->queue);
805 spin_unlock_irqrestore(&ide_lock,flags);
806 return 1;
807 }
808 }
809 } else if (sense_key == UNIT_ATTENTION) {
810 /* Media change. */
811 cdrom_saw_media_change (drive);
812
813 /* Arrange to retry the request.
814 But be sure to give up if we've retried
815 too many times. */
816 if (++rq->errors > ERROR_MAX)
817 do_end_request = 1;
818 } else if (sense_key == ILLEGAL_REQUEST ||
819 sense_key == DATA_PROTECT) {
820 /* No point in retrying after an illegal
821 request or data protect error.*/
dbe217af 822 ide_dump_status_no_sense (drive, "command error", stat);
1da177e4
LT		 823 do_end_request = 1;
824 } else if (sense_key == MEDIUM_ERROR) {
825 /* No point in re-trying a zillion times on a bad
826 * sector... If we got here the error is not correctable */
dbe217af 827 ide_dump_status_no_sense (drive, "media error (bad sector)", stat);
1da177e4
LT		 828 do_end_request = 1;
829 } else if (sense_key == BLANK_CHECK) {
830 /* Disk appears blank ?? */
dbe217af 831 ide_dump_status_no_sense (drive, "media error (blank)", stat);
1da177e4
LT		 832 do_end_request = 1;
833 } else if ((err & ~ABRT_ERR) != 0) {
834 /* Go to the default handler
835 for other errors. */
836 ide_error(drive, "cdrom_decode_status", stat);
837 return 1;
838 } else if ((++rq->errors > ERROR_MAX)) {
839 /* We've racked up too many retries. Abort. */
840 do_end_request = 1;
841 }
842
dbe217af
AC		 843 /* End a request through request sense analysis when we have
844 sense data. We need this in order to perform end of media
845 processing */
846
847 if (do_end_request) {
848 if (stat & ERR_STAT) {
849 unsigned long flags;
850 spin_lock_irqsave(&ide_lock, flags);
851 blkdev_dequeue_request(rq);
852 HWGROUP(drive)->rq = NULL;
853 spin_unlock_irqrestore(&ide_lock, flags);
854
855 cdrom_queue_request_sense(drive, rq->sense, rq);
856 } else
857 cdrom_end_request(drive, 0);
858 } else {
859 /* If we got a CHECK_CONDITION status,
860 queue a request sense command. */
861 if (stat & ERR_STAT)
862 cdrom_queue_request_sense(drive, NULL, NULL);
863 }
1da177e4
LT		 864 } else {
865 blk_dump_rq_flags(rq, "ide-cd: bad rq");
866 cdrom_end_request(drive, 0);
867 }
868
869 /* Retry, or handle the next request. */
870 return 1;
871}
872
873static int cdrom_timer_expiry(ide_drive_t *drive)
874{
875 struct request *rq = HWGROUP(drive)->rq;
876 unsigned long wait = 0;
877
878 /*
879 * Some commands are *slow* and normally take a long time to
880 * complete. Usually we can use the ATAPI "disconnect" to bypass
881 * this, but not all commands/drives support that. Let
882 * ide_timer_expiry keep polling us for these.
883 */
884 switch (rq->cmd[0]) {
885 case GPCMD_BLANK:
886 case GPCMD_FORMAT_UNIT:
887 case GPCMD_RESERVE_RZONE_TRACK:
888 case GPCMD_CLOSE_TRACK:
889 case GPCMD_FLUSH_CACHE:
890 wait = ATAPI_WAIT_PC;
891 break;
892 default:
4aff5e23 893 if (!(rq->cmd_flags & REQ_QUIET))
1da177e4
LT		 894 printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n", rq->cmd[0]);
895 wait = 0;
896 break;
897 }
898 return wait;
899}
900
901/* Set up the device registers for transferring a packet command on DEV,
902 expecting to later transfer XFERLEN bytes. HANDLER is the routine
903 which actually transfers the command to the drive. If this is a
904 drq_interrupt device, this routine will arrange for HANDLER to be
905 called when the interrupt from the drive arrives. Otherwise, HANDLER
906 will be called immediately after the drive is prepared for the transfer. */
907
908static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
909 int xferlen,
910 ide_handler_t *handler)
911{
912 ide_startstop_t startstop;
913 struct cdrom_info *info = drive->driver_data;
914 ide_hwif_t *hwif = drive->hwif;
915
916 /* Wait for the controller to be idle. */
917 if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY))
918 return startstop;
919
3a6a3549 920 /* FIXME: for Virtual DMA we must check harder */
1da177e4
LT		 921 if (info->dma)
922 info->dma = !hwif->dma_setup(drive);
923
924 /* Set up the controller registers. */
2fc57388
BZ		 925 ide_pktcmd_tf_load(drive, IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL |
926 IDE_TFLAG_NO_SELECT_MASK, xferlen, info->dma);
1da177e4
LT		 927
928 if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt) {
f0dd8712
AL		 929 /* waiting for CDB interrupt, not DMA yet. */
930 if (info->dma)
931 drive->waiting_for_dma = 0;
932
1da177e4
LT		 933 /* packet command */
934 ide_execute_command(drive, WIN_PACKETCMD, handler, ATAPI_WAIT_PC, cdrom_timer_expiry);
935 return ide_started;
936 } else {
937 unsigned long flags;
938
939 /* packet command */
940 spin_lock_irqsave(&ide_lock, flags);
941 hwif->OUTBSYNC(drive, WIN_PACKETCMD, IDE_COMMAND_REG);
942 ndelay(400);
943 spin_unlock_irqrestore(&ide_lock, flags);
944
945 return (*handler) (drive);
946 }
947}
948
949/* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
950 The device registers must have already been prepared
951 by cdrom_start_packet_command.
952 HANDLER is the interrupt handler to call when the command completes
953 or there's data ready. */
954/*
955 * changed 5 parameters to 3 for dvd-ram
956 * struct packet_command *pc; now packet_command_t *pc;
957 */
958#define ATAPI_MIN_CDB_BYTES 12
959static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
960 struct request *rq,
961 ide_handler_t *handler)
962{
963 ide_hwif_t *hwif = drive->hwif;
964 int cmd_len;
965 struct cdrom_info *info = drive->driver_data;
966 ide_startstop_t startstop;
967
968 if (CDROM_CONFIG_FLAGS(drive)->drq_interrupt) {
969 /* Here we should have been called after receiving an interrupt
970 from the device. DRQ should how be set. */
971
972 /* Check for errors. */
973 if (cdrom_decode_status(drive, DRQ_STAT, NULL))
974 return ide_stopped;
f0dd8712
AL		 975
976 /* Ok, next interrupt will be DMA interrupt. */
977 if (info->dma)
978 drive->waiting_for_dma = 1;
1da177e4
LT		 979 } else {
980 /* Otherwise, we must wait for DRQ to get set. */
981 if (ide_wait_stat(&startstop, drive, DRQ_STAT,
982 BUSY_STAT, WAIT_READY))
983 return startstop;
984 }
985
986 /* Arm the interrupt handler. */
987 ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);
988
989 /* ATAPI commands get padded out to 12 bytes minimum */
990 cmd_len = COMMAND_SIZE(rq->cmd[0]);
991 if (cmd_len < ATAPI_MIN_CDB_BYTES)
992 cmd_len = ATAPI_MIN_CDB_BYTES;
993
994 /* Send the command to the device. */
995 HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len);
996
997 /* Start the DMA if need be */
998 if (info->dma)
999 hwif->dma_start(drive);
1000
1001 return ide_started;
1002}
1003
1004/****************************************************************************
1005 * Block read functions.
1006 */
1007
68661c53
BZ		 1008typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
1009
5a5222d9
BZ		 1010static void ide_cd_pad_transfer(ide_drive_t *drive, xfer_func_t *xf, int len)
1011{
1012 while (len > 0) {
1013 int dum = 0;
1014 xf(drive, &dum, sizeof(dum));
1015 len -= sizeof(dum);
1016 }
1017}
1018
1da177e4
LT		 1019/*
1020 * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
1021 * buffer. Once the first sector is added, any subsequent sectors are
1022 * assumed to be continuous (until the buffer is cleared). For the first
1023 * sector added, SECTOR is its sector number. (SECTOR is then ignored until
1024 * the buffer is cleared.)
1025 */
1026static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
1027 int sectors_to_transfer)
1028{
1029 struct cdrom_info *info = drive->driver_data;
1030
1031 /* Number of sectors to read into the buffer. */
1032 int sectors_to_buffer = min_t(int, sectors_to_transfer,
1033 (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
1034 info->nsectors_buffered);
1035
1036 char *dest;
1037
1038 /* If we couldn't get a buffer, don't try to buffer anything... */
1039 if (info->buffer == NULL)
1040 sectors_to_buffer = 0;
1041
1042 /* If this is the first sector in the buffer, remember its number. */
1043 if (info->nsectors_buffered == 0)
1044 info->sector_buffered = sector;
1045
1046 /* Read the data into the buffer. */
1047 dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
1048 while (sectors_to_buffer > 0) {
1049 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
1050 --sectors_to_buffer;
1051 --sectors_to_transfer;
1052 ++info->nsectors_buffered;
1053 dest += SECTOR_SIZE;
1054 }
1055
1056 /* Throw away any remaining data. */
1057 while (sectors_to_transfer > 0) {
1058 static char dum[SECTOR_SIZE];
1059 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1060 --sectors_to_transfer;
1061 }
1062}
1063
1064/*
1065 * Check the contents of the interrupt reason register from the cdrom
1066 * and attempt to recover if there are problems. Returns 0 if everything's
1067 * ok; nonzero if the request has been terminated.
1068 */
858119e1 1069static
1da177e4
LT		 1070int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
1071{
1072 if (ireason == 2)
1073 return 0;
1074 else if (ireason == 0) {
5a5222d9
BZ		 1075 ide_hwif_t *hwif = drive->hwif;
1076
1da177e4 1077 /* Whoops... The drive is expecting to receive data from us! */
35379c07
BZ		 1078 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
1079 drive->name, __FUNCTION__);
1da177e4
LT		 1080
1081 /* Throw some data at the drive so it doesn't hang
1082 and quit this request. */
5a5222d9 1083 ide_cd_pad_transfer(drive, hwif->atapi_output_bytes, len);
1da177e4
LT		 1084 } else if (ireason == 1) {
1085 /* Some drives (ASUS) seem to tell us that status
1086 * info is available. just get it and ignore.
1087 */
1088 (void) HWIF(drive)->INB(IDE_STATUS_REG);
1089 return 0;
1090 } else {
1091 /* Drive wants a command packet, or invalid ireason... */
35379c07
BZ		 1092 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
1093 drive->name, __FUNCTION__, ireason);
1da177e4
LT		 1094 }
1095
1096 cdrom_end_request(drive, 0);
1097 return -1;
1098}
1099
1100/*
1101 * Interrupt routine. Called when a read request has completed.
1102 */
1103static ide_startstop_t cdrom_read_intr (ide_drive_t *drive)
1104{
1105 int stat;
1106 int ireason, len, sectors_to_transfer, nskip;
1107 struct cdrom_info *info = drive->driver_data;
1108 u8 lowcyl = 0, highcyl = 0;
1109 int dma = info->dma, dma_error = 0;
1110
1111 struct request *rq = HWGROUP(drive)->rq;
1112
1113 /*
1114 * handle dma case
1115 */
1116 if (dma) {
1117 info->dma = 0;
52ef2ed0
BZ		 1118 dma_error = HWIF(drive)->ide_dma_end(drive);
1119 if (dma_error) {
1120 printk(KERN_ERR "%s: DMA read error\n", drive->name);
7469aaf6 1121 ide_dma_off(drive);
52ef2ed0 1122 }
1da177e4
LT		 1123 }
1124
1125 if (cdrom_decode_status(drive, 0, &stat))
1126 return ide_stopped;
1127
1128 if (dma) {
1129 if (!dma_error) {
1130 ide_end_request(drive, 1, rq->nr_sectors);
1131 return ide_stopped;
1132 } else
1133 return ide_error(drive, "dma error", stat);
1134 }
1135
1136 /* Read the interrupt reason and the transfer length. */
1137 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1138 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1139 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1140
1141 len = lowcyl + (256 * highcyl);
1142
1143 /* If DRQ is clear, the command has completed. */
1144 if ((stat & DRQ_STAT) == 0) {
1145 /* If we're not done filling the current buffer, complain.
1146 Otherwise, complete the command normally. */
1147 if (rq->current_nr_sectors > 0) {
1148 printk (KERN_ERR "%s: cdrom_read_intr: data underrun (%d blocks)\n",
1149 drive->name, rq->current_nr_sectors);
4aff5e23 1150 rq->cmd_flags |= REQ_FAILED;
1da177e4
LT		 1151 cdrom_end_request(drive, 0);
1152 } else
1153 cdrom_end_request(drive, 1);
1154 return ide_stopped;
1155 }
1156
1157 /* Check that the drive is expecting to do the same thing we are. */
1158 if (cdrom_read_check_ireason (drive, len, ireason))
1159 return ide_stopped;
1160
1161 /* Assume that the drive will always provide data in multiples
1162 of at least SECTOR_SIZE, as it gets hairy to keep track
1163 of the transfers otherwise. */
1164 if ((len % SECTOR_SIZE) != 0) {
1165 printk (KERN_ERR "%s: cdrom_read_intr: Bad transfer size %d\n",
1166 drive->name, len);
1167 if (CDROM_CONFIG_FLAGS(drive)->limit_nframes)
1168 printk (KERN_ERR " This drive is not supported by this version of the driver\n");
1169 else {
1170 printk (KERN_ERR " Trying to limit transfer sizes\n");
1171 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
1172 }
1173 cdrom_end_request(drive, 0);
1174 return ide_stopped;
1175 }
1176
1177 /* The number of sectors we need to read from the drive. */
1178 sectors_to_transfer = len / SECTOR_SIZE;
1179
1180 /* First, figure out if we need to bit-bucket
1181 any of the leading sectors. */
1182 nskip = min_t(int, rq->current_nr_sectors - bio_cur_sectors(rq->bio), sectors_to_transfer);
1183
1184 while (nskip > 0) {
1185 /* We need to throw away a sector. */
1186 static char dum[SECTOR_SIZE];
1187 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1188
1189 --rq->current_nr_sectors;
1190 --nskip;
1191 --sectors_to_transfer;
1192 }
1193
1194 /* Now loop while we still have data to read from the drive. */
1195 while (sectors_to_transfer > 0) {
1196 int this_transfer;
1197
1198 /* If we've filled the present buffer but there's another
1199 chained buffer after it, move on. */
1200 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1201 cdrom_end_request(drive, 1);
1202
1203 /* If the buffers are full, cache the rest of the data in our
1204 internal buffer. */
1205 if (rq->current_nr_sectors == 0) {
1206 cdrom_buffer_sectors(drive, rq->sector, sectors_to_transfer);
1207 sectors_to_transfer = 0;
1208 } else {
1209 /* Transfer data to the buffers.
1210 Figure out how many sectors we can transfer
1211 to the current buffer. */
1212 this_transfer = min_t(int, sectors_to_transfer,
1213 rq->current_nr_sectors);
1214
1215 /* Read this_transfer sectors
1216 into the current buffer. */
1217 while (this_transfer > 0) {
1218 HWIF(drive)->atapi_input_bytes(drive, rq->buffer, SECTOR_SIZE);
1219 rq->buffer += SECTOR_SIZE;
1220 --rq->nr_sectors;
1221 --rq->current_nr_sectors;
1222 ++rq->sector;
1223 --this_transfer;
1224 --sectors_to_transfer;
1225 }
1226 }
1227 }
1228
1229 /* Done moving data! Wait for another interrupt. */
1230 ide_set_handler(drive, &cdrom_read_intr, ATAPI_WAIT_PC, NULL);
1231 return ide_started;
1232}
1233
1234/*
1235 * Try to satisfy some of the current read request from our cached data.
1236 * Returns nonzero if the request has been completed, zero otherwise.
1237 */
1238static int cdrom_read_from_buffer (ide_drive_t *drive)
1239{
1240 struct cdrom_info *info = drive->driver_data;
1241 struct request *rq = HWGROUP(drive)->rq;
1242 unsigned short sectors_per_frame;
1243
1244 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1245
1246 /* Can't do anything if there's no buffer. */
1247 if (info->buffer == NULL) return 0;
1248
1249 /* Loop while this request needs data and the next block is present
1250 in our cache. */
1251 while (rq->nr_sectors > 0 &&
1252 rq->sector >= info->sector_buffered &&
1253 rq->sector < info->sector_buffered + info->nsectors_buffered) {
1254 if (rq->current_nr_sectors == 0)
1255 cdrom_end_request(drive, 1);
1256
1257 memcpy (rq->buffer,
1258 info->buffer +
1259 (rq->sector - info->sector_buffered) * SECTOR_SIZE,
1260 SECTOR_SIZE);
1261 rq->buffer += SECTOR_SIZE;
1262 --rq->current_nr_sectors;
1263 --rq->nr_sectors;
1264 ++rq->sector;
1265 }
1266
1267 /* If we've satisfied the current request,
1268 terminate it successfully. */
1269 if (rq->nr_sectors == 0) {
1270 cdrom_end_request(drive, 1);
1271 return -1;
1272 }
1273
1274 /* Move on to the next buffer if needed. */
1275 if (rq->current_nr_sectors == 0)
1276 cdrom_end_request(drive, 1);
1277
1278 /* If this condition does not hold, then the kluge i use to
1279 represent the number of sectors to skip at the start of a transfer
1280 will fail. I think that this will never happen, but let's be
1281 paranoid and check. */
1282 if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
1283 (rq->sector & (sectors_per_frame - 1))) {
1284 printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
1285 drive->name, (long)rq->sector);
1286 cdrom_end_request(drive, 0);
1287 return -1;
1288 }
1289
1290 return 0;
1291}
1292
1293/*
1294 * Routine to send a read packet command to the drive.
1295 * This is usually called directly from cdrom_start_read.
1296 * However, for drq_interrupt devices, it is called from an interrupt
1297 * when the drive is ready to accept the command.
1298 */
1299static ide_startstop_t cdrom_start_read_continuation (ide_drive_t *drive)
1300{
1301 struct request *rq = HWGROUP(drive)->rq;
1302 unsigned short sectors_per_frame;
1303 int nskip;
1304
1305 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1306
1307 /* If the requested sector doesn't start on a cdrom block boundary,
1308 we must adjust the start of the transfer so that it does,
1309 and remember to skip the first few sectors.
1310 If the CURRENT_NR_SECTORS field is larger than the size
1311 of the buffer, it will mean that we're to skip a number
1312 of sectors equal to the amount by which CURRENT_NR_SECTORS
1313 is larger than the buffer size. */
1314 nskip = rq->sector & (sectors_per_frame - 1);
1315 if (nskip > 0) {
1316 /* Sanity check... */
1317 if (rq->current_nr_sectors != bio_cur_sectors(rq->bio) &&
1318 (rq->sector & (sectors_per_frame - 1))) {
1319 printk(KERN_ERR "%s: cdrom_start_read_continuation: buffer botch (%u)\n",
1320 drive->name, rq->current_nr_sectors);
1321 cdrom_end_request(drive, 0);
1322 return ide_stopped;
1323 }
1324 rq->current_nr_sectors += nskip;
1325 }
1326
1327 /* Set up the command */
1328 rq->timeout = ATAPI_WAIT_PC;
1329
1330 /* Send the command to the drive and return. */
1331 return cdrom_transfer_packet_command(drive, rq, &cdrom_read_intr);
1332}
1333
1334
1335#define IDECD_SEEK_THRESHOLD (1000) /* 1000 blocks */
1336#define IDECD_SEEK_TIMER (5 * WAIT_MIN_SLEEP) /* 100 ms */
1337#define IDECD_SEEK_TIMEOUT (2 * WAIT_CMD) /* 20 sec */
1338
1339static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
1340{
1341 struct cdrom_info *info = drive->driver_data;
1342 int stat;
1343 static int retry = 10;
1344
1345 if (cdrom_decode_status(drive, 0, &stat))
1346 return ide_stopped;
1347 CDROM_CONFIG_FLAGS(drive)->seeking = 1;
1348
1349 if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
1350 if (--retry == 0) {
1351 /*
1352 * this condition is far too common, to bother
1353 * users about it
1354 */
1355 /* printk("%s: disabled DSC seek overlap\n", drive->name);*/
1356 drive->dsc_overlap = 0;
1357 }
1358 }
1359 return ide_stopped;
1360}
1361
1362static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
1363{
1364 struct request *rq = HWGROUP(drive)->rq;
1365 sector_t frame = rq->sector;
1366
1367 sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
1368
1369 memset(rq->cmd, 0, sizeof(rq->cmd));
1370 rq->cmd[0] = GPCMD_SEEK;
1371 put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
1372
1373 rq->timeout = ATAPI_WAIT_PC;
1374 return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
1375}
1376
1377static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
1378{
1379 struct cdrom_info *info = drive->driver_data;
1380
1381 info->dma = 0;
1da177e4
LT		 1382 info->start_seek = jiffies;
1383 return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
1384}
1385
1386/* Fix up a possibly partially-processed request so that we can
1387 start it over entirely, or even put it back on the request queue. */
1388static void restore_request (struct request *rq)
1389{
1390 if (rq->buffer != bio_data(rq->bio)) {
1391 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
1392
1393 rq->buffer = bio_data(rq->bio);
1394 rq->nr_sectors += n;
1395 rq->sector -= n;
1396 }
1397 rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
1398 rq->hard_nr_sectors = rq->nr_sectors;
1399 rq->hard_sector = rq->sector;
1400 rq->q->prep_rq_fn(rq->q, rq);
1401}
1402
1403/*
1404 * Start a read request from the CD-ROM.
1405 */
1406static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block)
1407{
1408 struct cdrom_info *info = drive->driver_data;
1409 struct request *rq = HWGROUP(drive)->rq;
1410 unsigned short sectors_per_frame;
1411
1412 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1413
1414 /* We may be retrying this request after an error. Fix up
1415 any weirdness which might be present in the request packet. */
1416 restore_request(rq);
1417
1418 /* Satisfy whatever we can of this request from our cached sector. */
1419 if (cdrom_read_from_buffer(drive))
1420 return ide_stopped;
1421
1da177e4
LT		 1422 /* Clear the local sector buffer. */
1423 info->nsectors_buffered = 0;
1424
1425 /* use dma, if possible. */
1426 info->dma = drive->using_dma;
1427 if ((rq->sector & (sectors_per_frame - 1)) ||
1428 (rq->nr_sectors & (sectors_per_frame - 1)))
1429 info->dma = 0;
1430
1da177e4
LT		 1431 /* Start sending the read request to the drive. */
1432 return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
1433}
1434
1435/****************************************************************************
1436 * Execute all other packet commands.
1437 */
1438
1439/* Interrupt routine for packet command completion. */
1440static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
1441{
1da177e4 1442 struct request *rq = HWGROUP(drive)->rq;
68661c53
BZ		 1443 xfer_func_t *xferfunc = NULL;
1444 int stat, ireason, len, thislen, write;
1da177e4 1445 u8 lowcyl = 0, highcyl = 0;
1da177e4
LT		 1446
1447 /* Check for errors. */
1448 if (cdrom_decode_status(drive, 0, &stat))
1449 return ide_stopped;
1450
1451 /* Read the interrupt reason and the transfer length. */
8606ab09 1452 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1da177e4
LT		 1453 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1454 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1455
1456 len = lowcyl + (256 * highcyl);
1457
1458 /* If DRQ is clear, the command has completed.
1459 Complain if we still have data left to transfer. */
1460 if ((stat & DRQ_STAT) == 0) {
1461 /* Some of the trailing request sense fields are optional, and
1462 some drives don't send them. Sigh. */
1463 if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
1464 rq->data_len > 0 &&
1465 rq->data_len <= 5) {
1466 while (rq->data_len > 0) {
1467 *(unsigned char *)rq->data++ = 0;
1468 --rq->data_len;
1469 }
1470 }
1471
1472 if (rq->data_len == 0)
1473 cdrom_end_request(drive, 1);
1474 else {
1475 /* Comment this out, because this always happens
1476 right after a reset occurs, and it is annoying to
1477 always print expected stuff. */
1478 /*
1479 printk ("%s: cdrom_pc_intr: data underrun %d\n",
1480 drive->name, pc->buflen);
1481 */
4aff5e23 1482 rq->cmd_flags |= REQ_FAILED;
1da177e4
LT		 1483 cdrom_end_request(drive, 0);
1484 }
1485 return ide_stopped;
1486 }
1487
1488 /* Figure out how much data to transfer. */
1489 thislen = rq->data_len;
68661c53
BZ		 1490 if (thislen > len)
1491 thislen = len;
1da177e4 1492
8606ab09 1493 if (ireason == 0) {
68661c53
BZ		 1494 write = 1;
1495 xferfunc = HWIF(drive)->atapi_output_bytes;
1496 } else if (ireason == 2) {
1497 write = 0;
1498 xferfunc = HWIF(drive)->atapi_input_bytes;
1da177e4
LT		 1499 }
1500
68661c53 1501 if (xferfunc) {
1da177e4 1502 if (!rq->data) {
f1071e62
BZ		 1503 printk(KERN_ERR "%s: confused, missing data\n",
1504 drive->name);
68661c53
BZ		 1505 blk_dump_rq_flags(rq, write ? "cdrom_pc_intr, write"
1506 : "cdrom_pc_intr, read");
f1071e62 1507 goto pad;
1da177e4
LT		 1508 }
1509 /* Transfer the data. */
68661c53 1510 xferfunc(drive, rq->data, thislen);
1da177e4 1511
1da177e4 1512 /* Keep count of how much data we've moved. */
5a5222d9 1513 len -= thislen;
1da177e4
LT		 1514 rq->data += thislen;
1515 rq->data_len -= thislen;
1516
68661c53 1517 if (write && blk_sense_request(rq))
1da177e4
LT		 1518 rq->sense_len += thislen;
1519 } else {
1da177e4 1520 printk (KERN_ERR "%s: cdrom_pc_intr: The drive "
1ad55440
RK		 1521 "appears confused (ireason = 0x%02x). "
1522 "Trying to recover by ending request.\n",
1da177e4 1523 drive->name, ireason);
4aff5e23 1524 rq->cmd_flags |= REQ_FAILED;
1ad55440
RK		 1525 cdrom_end_request(drive, 0);
1526 return ide_stopped;
1da177e4 1527 }
f1071e62 1528pad:
5a5222d9
BZ		 1529 /*
1530 * If we haven't moved enough data to satisfy the drive,
1531 * add some padding.
1532 */
1533 if (len > 0)
1534 ide_cd_pad_transfer(drive, xferfunc, len);
1535
1da177e4
LT		 1536 /* Now we wait for another interrupt. */
1537 ide_set_handler(drive, &cdrom_pc_intr, ATAPI_WAIT_PC, cdrom_timer_expiry);
1538 return ide_started;
1539}
1540
1541static ide_startstop_t cdrom_do_pc_continuation (ide_drive_t *drive)
1542{
1543 struct request *rq = HWGROUP(drive)->rq;
1544
1545 if (!rq->timeout)
1546 rq->timeout = ATAPI_WAIT_PC;
1547
1548 /* Send the command to the drive and return. */
1549 return cdrom_transfer_packet_command(drive, rq, &cdrom_pc_intr);
1550}
1551
1552
1553static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
1554{
1555 int len;
1556 struct request *rq = HWGROUP(drive)->rq;
1557 struct cdrom_info *info = drive->driver_data;
1558
1559 info->dma = 0;
4aff5e23 1560 rq->cmd_flags &= ~REQ_FAILED;
1da177e4
LT		 1561 len = rq->data_len;
1562
1563 /* Start sending the command to the drive. */
1564 return cdrom_start_packet_command(drive, len, cdrom_do_pc_continuation);
1565}
1566
1567
dbe217af 1568static int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
1da177e4
LT		 1569{
1570 struct request_sense sense;
1571 int retries = 10;
4aff5e23 1572 unsigned int flags = rq->cmd_flags;
1da177e4
LT		 1573
1574 if (rq->sense == NULL)
1575 rq->sense = &sense;
1576
1577 /* Start of retry loop. */
1578 do {
1579 int error;
1580 unsigned long time = jiffies;
4aff5e23 1581 rq->cmd_flags = flags;
1da177e4
LT		 1582
1583 error = ide_do_drive_cmd(drive, rq, ide_wait);
1584 time = jiffies - time;
1585
1586 /* FIXME: we should probably abort/retry or something
1587 * in case of failure */
4aff5e23 1588 if (rq->cmd_flags & REQ_FAILED) {
1da177e4
LT		 1589 /* The request failed. Retry if it was due to a unit
1590 attention status
1591 (usually means media was changed). */
1592 struct request_sense *reqbuf = rq->sense;
1593
1594 if (reqbuf->sense_key == UNIT_ATTENTION)
1595 cdrom_saw_media_change(drive);
1596 else if (reqbuf->sense_key == NOT_READY &&
1597 reqbuf->asc == 4 && reqbuf->ascq != 4) {
1598 /* The drive is in the process of loading
1599 a disk. Retry, but wait a little to give
1600 the drive time to complete the load. */
1601 ssleep(2);
1602 } else {
1603 /* Otherwise, don't retry. */
1604 retries = 0;
1605 }
1606 --retries;
1607 }
1608
1609 /* End of retry loop. */
4aff5e23 1610 } while ((rq->cmd_flags & REQ_FAILED) && retries >= 0);
1da177e4
LT		 1611
1612 /* Return an error if the command failed. */
4aff5e23 1613 return (rq->cmd_flags & REQ_FAILED) ? -EIO : 0;
1da177e4
LT		 1614}
1615
1616/*
1617 * Write handling
1618 */
858119e1 1619static int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
1da177e4
LT		 1620{
1621 /* Two notes about IDE interrupt reason here - 0 means that
1622 * the drive wants to receive data from us, 2 means that
1623 * the drive is expecting to transfer data to us.
1624 */
1625 if (ireason == 0)
1626 return 0;
1627 else if (ireason == 2) {
5a5222d9
BZ		 1628 ide_hwif_t *hwif = drive->hwif;
1629
1da177e4 1630 /* Whoops... The drive wants to send data. */
35379c07
BZ		 1631 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
1632 drive->name, __FUNCTION__);
1da177e4 1633
5a5222d9 1634 ide_cd_pad_transfer(drive, hwif->atapi_input_bytes, len);
1da177e4
LT		 1635 } else {
1636 /* Drive wants a command packet, or invalid ireason... */
35379c07
BZ		 1637 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
1638 drive->name, __FUNCTION__, ireason);
1da177e4
LT		 1639 }
1640
1641 cdrom_end_request(drive, 0);
1642 return 1;
1643}
1644
aaa04c28
KU		 1645/*
1646 * Called from blk_end_request_callback() after the data of the request
1647 * is completed and before the request is completed.
1648 * By returning value '1', blk_end_request_callback() returns immediately
1649 * without completing the request.
1650 */
1651static int cdrom_newpc_intr_dummy_cb(struct request *rq)
1652{
1653 return 1;
1654}
1655
1da177e4
LT		 1656/*
1657 * best way to deal with dma that is not sector aligned right now... note
1658 * that in this path we are not using ->data or ->buffer at all. this irs
1659 * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the
1660 * future.
1661 */
1662static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1663{
1664 struct cdrom_info *info = drive->driver_data;
1665 struct request *rq = HWGROUP(drive)->rq;
1666 int dma_error, dma, stat, ireason, len, thislen;
1667 u8 lowcyl, highcyl;
1668 xfer_func_t *xferfunc;
1669 unsigned long flags;
1670
1671 /* Check for errors. */
1672 dma_error = 0;
1673 dma = info->dma;
1674 if (dma) {
1675 info->dma = 0;
1676 dma_error = HWIF(drive)->ide_dma_end(drive);
1677 }
1678
1679 if (cdrom_decode_status(drive, 0, &stat))
1680 return ide_stopped;
1681
1682 /*
1683 * using dma, transfer is complete now
1684 */
1685 if (dma) {
1686 if (dma_error) {
1687 printk(KERN_ERR "ide-cd: dma error\n");
7469aaf6 1688 ide_dma_off(drive);
1da177e4
LT		 1689 return ide_error(drive, "dma error", stat);
1690 }
1691
aaa04c28
KU		 1692 spin_lock_irqsave(&ide_lock, flags);
1693 if (__blk_end_request(rq, 0, rq->data_len))
1694 BUG();
1695 HWGROUP(drive)->rq = NULL;
1696 spin_unlock_irqrestore(&ide_lock, flags);
1697
1698 return ide_stopped;
1da177e4
LT		 1699 }
1700
1701 /*
1702 * ok we fall to pio :/
1703 */
1704 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1705 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1706 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1707
1708 len = lowcyl + (256 * highcyl);
1709 thislen = rq->data_len;
1710 if (thislen > len)
1711 thislen = len;
1712
1713 /*
1714 * If DRQ is clear, the command has completed.
1715 */
aaa04c28
KU		 1716 if ((stat & DRQ_STAT) == 0) {
1717 spin_lock_irqsave(&ide_lock, flags);
4f4f6c25 1718 if (__blk_end_request(rq, 0, rq->data_len))
aaa04c28
KU		 1719 BUG();
1720 HWGROUP(drive)->rq = NULL;
1721 spin_unlock_irqrestore(&ide_lock, flags);
1722
1723 return ide_stopped;
1724 }
1da177e4
LT		 1725
1726 /*
1727 * check which way to transfer data
1728 */
1729 if (rq_data_dir(rq) == WRITE) {
1730 /*
1731 * write to drive
1732 */
1733 if (cdrom_write_check_ireason(drive, len, ireason))
1734 return ide_stopped;
1735
1736 xferfunc = HWIF(drive)->atapi_output_bytes;
1737 } else {
1738 /*
1739 * read from drive
1740 */
1741 if (cdrom_read_check_ireason(drive, len, ireason))
1742 return ide_stopped;
1743
1744 xferfunc = HWIF(drive)->atapi_input_bytes;
1745 }
1746
1747 /*
1748 * transfer data
1749 */
1750 while (thislen > 0) {
1751 int blen = blen = rq->data_len;
1752 char *ptr = rq->data;
1753
1754 /*
1755 * bio backed?
1756 */
1757 if (rq->bio) {
1758 ptr = bio_data(rq->bio);
1759 blen = bio_iovec(rq->bio)->bv_len;
1760 }
1761
1762 if (!ptr) {
1763 printk(KERN_ERR "%s: confused, missing data\n", drive->name);
1764 break;
1765 }
1766
1767 if (blen > thislen)
1768 blen = thislen;
1769
1770 xferfunc(drive, ptr, blen);
1771
1772 thislen -= blen;
1773 len -= blen;
1774 rq->data_len -= blen;
1775
1776 if (rq->bio)
aaa04c28
KU		 1777 /*
1778 * The request can't be completed until DRQ is cleared.
1779 * So complete the data, but don't complete the request
1780 * using the dummy function for the callback feature
1781 * of blk_end_request_callback().
1782 */
1783 blk_end_request_callback(rq, 0, blen,
1784 cdrom_newpc_intr_dummy_cb);
1da177e4
LT		 1785 else
1786 rq->data += blen;
1787 }
1788
1789 /*
1790 * pad, if necessary
1791 */
5a5222d9
BZ		 1792 if (len > 0)
1793 ide_cd_pad_transfer(drive, xferfunc, len);
1da177e4 1794
125e1874 1795 BUG_ON(HWGROUP(drive)->handler != NULL);
1da177e4
LT		 1796
1797 ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, NULL);
1798 return ide_started;
1da177e4
LT		 1799}
1800
1801static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
1802{
1803 int stat, ireason, len, sectors_to_transfer, uptodate;
1804 struct cdrom_info *info = drive->driver_data;
1805 int dma_error = 0, dma = info->dma;
1806 u8 lowcyl = 0, highcyl = 0;
1807
1808 struct request *rq = HWGROUP(drive)->rq;
1809
1810 /* Check for errors. */
1811 if (dma) {
1812 info->dma = 0;
b481b238
BZ		 1813 dma_error = HWIF(drive)->ide_dma_end(drive);
1814 if (dma_error) {
1815 printk(KERN_ERR "%s: DMA write error\n", drive->name);
7469aaf6 1816 ide_dma_off(drive);
1da177e4
LT		 1817 }
1818 }
1819
1820 if (cdrom_decode_status(drive, 0, &stat))
1821 return ide_stopped;
1822
1823 /*
1824 * using dma, transfer is complete now
1825 */
1826 if (dma) {
1827 if (dma_error)
1828 return ide_error(drive, "dma error", stat);
1829
1830 ide_end_request(drive, 1, rq->nr_sectors);
1831 return ide_stopped;
1832 }
1833
1834 /* Read the interrupt reason and the transfer length. */
31a71191 1835 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1da177e4
LT		 1836 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1837 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1838
1839 len = lowcyl + (256 * highcyl);
1840
1841 /* If DRQ is clear, the command has completed. */
1842 if ((stat & DRQ_STAT) == 0) {
1843 /* If we're not done writing, complain.
1844 * Otherwise, complete the command normally.
1845 */
1846 uptodate = 1;
1847 if (rq->current_nr_sectors > 0) {
b481b238
BZ		 1848 printk(KERN_ERR "%s: %s: data underrun (%d blocks)\n",
1849 drive->name, __FUNCTION__,
1850 rq->current_nr_sectors);
1da177e4
LT		 1851 uptodate = 0;
1852 }
1853 cdrom_end_request(drive, uptodate);
1854 return ide_stopped;
1855 }
1856
1857 /* Check that the drive is expecting to do the same thing we are. */
1858 if (cdrom_write_check_ireason(drive, len, ireason))
1859 return ide_stopped;
1860
1861 sectors_to_transfer = len / SECTOR_SIZE;
1862
1863 /*
1864 * now loop and write out the data
1865 */
1866 while (sectors_to_transfer > 0) {
1867 int this_transfer;
1868
1869 if (!rq->current_nr_sectors) {
b481b238
BZ		 1870 printk(KERN_ERR "%s: %s: confused, missing data\n",
1871 drive->name, __FUNCTION__);
1da177e4
LT		 1872 break;
1873 }
1874
1875 /*
1876 * Figure out how many sectors we can transfer
1877 */
1878 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors);
1879
1880 while (this_transfer > 0) {
1881 HWIF(drive)->atapi_output_bytes(drive, rq->buffer, SECTOR_SIZE);
1882 rq->buffer += SECTOR_SIZE;
1883 --rq->nr_sectors;
1884 --rq->current_nr_sectors;
1885 ++rq->sector;
1886 --this_transfer;
1887 --sectors_to_transfer;
1888 }
1889
1890 /*
1891 * current buffer complete, move on
1892 */
1893 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1894 cdrom_end_request(drive, 1);
1895 }
1896
1897 /* re-arm handler */
1898 ide_set_handler(drive, &cdrom_write_intr, ATAPI_WAIT_PC, NULL);
1899 return ide_started;
1900}
1901
1902static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
1903{
1904 struct request *rq = HWGROUP(drive)->rq;
1905
1906#if 0 /* the immediate bit */
1907 rq->cmd[1] = 1 << 3;
1908#endif
1909 rq->timeout = ATAPI_WAIT_PC;
1910
1911 return cdrom_transfer_packet_command(drive, rq, cdrom_write_intr);
1912}
1913
1914static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
1915{
1916 struct cdrom_info *info = drive->driver_data;
1917 struct gendisk *g = info->disk;
1918 unsigned short sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1919
1920 /*
1921 * writes *must* be hardware frame aligned
1922 */
1923 if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1924 (rq->sector & (sectors_per_frame - 1))) {
1925 cdrom_end_request(drive, 0);
1926 return ide_stopped;
1927 }
1928
1929 /*
1930 * disk has become write protected
1931 */
1932 if (g->policy) {
1933 cdrom_end_request(drive, 0);
1934 return ide_stopped;
1935 }
1936
1da177e4
LT		 1937 info->nsectors_buffered = 0;
1938
1939 /* use dma, if possible. we don't need to check more, since we
1940 * know that the transfer is always (at least!) frame aligned */
1941 info->dma = drive->using_dma ? 1 : 0;
1da177e4
LT		 1942
1943 info->devinfo.media_written = 1;
1944
1945 /* Start sending the write request to the drive. */
1946 return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
1947}
1948
1949static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1950{
1951 struct request *rq = HWGROUP(drive)->rq;
1952
1953 if (!rq->timeout)
1954 rq->timeout = ATAPI_WAIT_PC;
1955
1956 return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1957}
1958
1959static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1960{
1961 struct cdrom_info *info = drive->driver_data;
1962
4aff5e23 1963 rq->cmd_flags |= REQ_QUIET;
1da177e4
LT		 1964
1965 info->dma = 0;
1da177e4
LT		 1966
1967 /*
1968 * sg request
1969 */
1970 if (rq->bio) {
1971 int mask = drive->queue->dma_alignment;
1972 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
1973
1da177e4
LT		 1974 info->dma = drive->using_dma;
1975
1976 /*
1977 * check if dma is safe
5d9e4ea5
LT		 1978 *
1979 * NOTE! The "len" and "addr" checks should possibly have
1980 * separate masks.
1da177e4 1981 */
4e7c6816 1982 if ((rq->data_len & 15) || (addr & mask))
1da177e4
LT		 1983 info->dma = 0;
1984 }
1985
1986 /* Start sending the command to the drive. */
1987 return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1988}
1989
1990/****************************************************************************
1991 * cdrom driver request routine.
1992 */
1993static ide_startstop_t
1994ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1995{
1996 ide_startstop_t action;
1997 struct cdrom_info *info = drive->driver_data;
1998
1999 if (blk_fs_request(rq)) {
2000 if (CDROM_CONFIG_FLAGS(drive)->seeking) {
2001 unsigned long elapsed = jiffies - info->start_seek;
2002 int stat = HWIF(drive)->INB(IDE_STATUS_REG);
2003
2004 if ((stat & SEEK_STAT) != SEEK_STAT) {
2005 if (elapsed < IDECD_SEEK_TIMEOUT) {
2006 ide_stall_queue(drive, IDECD_SEEK_TIMER);
2007 return ide_stopped;
2008 }
2009 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
2010 }
2011 CDROM_CONFIG_FLAGS(drive)->seeking = 0;
2012 }
2013 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
2014 action = cdrom_start_seek(drive, block);
2015 } else {
2016 if (rq_data_dir(rq) == READ)
2017 action = cdrom_start_read(drive, block);
2018 else
2019 action = cdrom_start_write(drive, rq);
2020 }
2021 info->last_block = block;
2022 return action;
cea2885a
JA		 2023 } else if (rq->cmd_type == REQ_TYPE_SENSE ||
2024 rq->cmd_type == REQ_TYPE_ATA_PC) {
1da177e4 2025 return cdrom_do_packet_command(drive);
4aff5e23 2026 } else if (blk_pc_request(rq)) {
1da177e4 2027 return cdrom_do_block_pc(drive, rq);
4aff5e23 2028 } else if (blk_special_request(rq)) {
1da177e4
LT		 2029 /*
2030 * right now this can only be a reset...
2031 */
2032 cdrom_end_request(drive, 1);
2033 return ide_stopped;
2034 }
2035
2036 blk_dump_rq_flags(rq, "ide-cd bad flags");
2037 cdrom_end_request(drive, 0);
2038 return ide_stopped;
2039}
2040
2041
2042
2043/****************************************************************************
2044 * Ioctl handling.
2045 *
2046 * Routines which queue packet commands take as a final argument a pointer
2047 * to a request_sense struct. If execution of the command results
2048 * in an error with a CHECK CONDITION status, this structure will be filled
2049 * with the results of the subsequent request sense command. The pointer
2050 * can also be NULL, in which case no sense information is returned.
2051 */
2052
2053#if ! STANDARD_ATAPI
2054static inline
2055int bin2bcd (int x)
2056{
2057 return (x%10) | ((x/10) << 4);
2058}
2059
2060
2061static inline
2062int bcd2bin (int x)
2063{
2064 return (x >> 4) * 10 + (x & 0x0f);
2065}
2066
2067static
2068void msf_from_bcd (struct atapi_msf *msf)
2069{
2070 msf->minute = bcd2bin (msf->minute);
2071 msf->second = bcd2bin (msf->second);
2072 msf->frame = bcd2bin (msf->frame);
2073}
2074
2075#endif /* not STANDARD_ATAPI */
2076
2077
2078static inline
2079void lba_to_msf (int lba, byte *m, byte *s, byte *f)
2080{
2081 lba += CD_MSF_OFFSET;
2082 lba &= 0xffffff; /* negative lbas use only 24 bits */
2083 *m = lba / (CD_SECS * CD_FRAMES);
2084 lba %= (CD_SECS * CD_FRAMES);
2085 *s = lba / CD_FRAMES;
2086 *f = lba % CD_FRAMES;
2087}
2088
2089
2090static inline
2091int msf_to_lba (byte m, byte s, byte f)
2092{
2093 return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
2094}
2095
2096static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
2097{
2098 struct request req;
2099 struct cdrom_info *info = drive->driver_data;
2100 struct cdrom_device_info *cdi = &info->devinfo;
2101
2102 cdrom_prepare_request(drive, &req);
2103
2104 req.sense = sense;
2105 req.cmd[0] = GPCMD_TEST_UNIT_READY;
4aff5e23 2106 req.cmd_flags |= REQ_QUIET;
1da177e4
LT		 2107
2108#if ! STANDARD_ATAPI
2109 /* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
2110 switch CDs instead of supporting the LOAD_UNLOAD opcode */
2111
2112 req.cmd[7] = cdi->sanyo_slot % 3;
2113#endif /* not STANDARD_ATAPI */
2114
2115 return cdrom_queue_packet_command(drive, &req);
2116}
2117
2118
2119/* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
2120static int
2121cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
2122{
2123 struct request_sense my_sense;
2124 struct request req;
2125 int stat;
2126
2127 if (sense == NULL)
2128 sense = &my_sense;
2129
2130 /* If the drive cannot lock the door, just pretend. */
2131 if (CDROM_CONFIG_FLAGS(drive)->no_doorlock) {
2132 stat = 0;
2133 } else {
2134 cdrom_prepare_request(drive, &req);
2135 req.sense = sense;
2136 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
2137 req.cmd[4] = lockflag ? 1 : 0;
2138 stat = cdrom_queue_packet_command(drive, &req);
2139 }
2140
2141 /* If we got an illegal field error, the drive
2142 probably cannot lock the door. */
2143 if (stat != 0 &&
2144 sense->sense_key == ILLEGAL_REQUEST &&
2145 (sense->asc == 0x24 || sense->asc == 0x20)) {
2146 printk (KERN_ERR "%s: door locking not supported\n",
2147 drive->name);
2148 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2149 stat = 0;
2150 }
2151
2152 /* no medium, that's alright. */
2153 if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
2154 stat = 0;
2155
2156 if (stat == 0)
2157 CDROM_STATE_FLAGS(drive)->door_locked = lockflag;
2158
2159 return stat;
2160}
2161
2162
2163/* Eject the disk if EJECTFLAG is 0.
2164 If EJECTFLAG is 1, try to reload the disk. */
2165static int cdrom_eject(ide_drive_t *drive, int ejectflag,
2166 struct request_sense *sense)
2167{
2168 struct request req;
2169 char loej = 0x02;
2170
2171 if (CDROM_CONFIG_FLAGS(drive)->no_eject && !ejectflag)
2172 return -EDRIVE_CANT_DO_THIS;
2173
2174 /* reload fails on some drives, if the tray is locked */
2175 if (CDROM_STATE_FLAGS(drive)->door_locked && ejectflag)
2176 return 0;
2177
2178 cdrom_prepare_request(drive, &req);
2179
2180 /* only tell drive to close tray if open, if it can do that */
2181 if (ejectflag && !CDROM_CONFIG_FLAGS(drive)->close_tray)
2182 loej = 0;
2183
2184 req.sense = sense;
2185 req.cmd[0] = GPCMD_START_STOP_UNIT;
2186 req.cmd[4] = loej | (ejectflag != 0);
2187 return cdrom_queue_packet_command(drive, &req);
2188}
2189
2190static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
2191 unsigned long *sectors_per_frame,
2192 struct request_sense *sense)
2193{
2194 struct {
2195 __u32 lba;
2196 __u32 blocklen;
2197 } capbuf;
2198
2199 int stat;
2200 struct request req;
2201
2202 cdrom_prepare_request(drive, &req);
2203
2204 req.sense = sense;
2205 req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
2206 req.data = (char *)&capbuf;
2207 req.data_len = sizeof(capbuf);
4aff5e23 2208 req.cmd_flags |= REQ_QUIET;
1da177e4
LT		 2209
2210 stat = cdrom_queue_packet_command(drive, &req);
2211 if (stat == 0) {
2212 *capacity = 1 + be32_to_cpu(capbuf.lba);
2213 *sectors_per_frame =
2214 be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
2215 }
2216
2217 return stat;
2218}
2219
2220static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
2221 int format, char *buf, int buflen,
2222 struct request_sense *sense)
2223{
2224 struct request req;
2225
2226 cdrom_prepare_request(drive, &req);
2227
2228 req.sense = sense;
2229 req.data = buf;
2230 req.data_len = buflen;
4aff5e23 2231 req.cmd_flags |= REQ_QUIET;
1da177e4
LT		 2232 req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
2233 req.cmd[6] = trackno;
2234 req.cmd[7] = (buflen >> 8);
2235 req.cmd[8] = (buflen & 0xff);
2236 req.cmd[9] = (format << 6);
2237
2238 if (msf_flag)
2239 req.cmd[1] = 2;
2240
2241 return cdrom_queue_packet_command(drive, &req);
2242}
2243
2244
2245/* Try to read the entire TOC for the disk into our internal buffer. */
2246static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2247{
2248 int stat, ntracks, i;
2249 struct cdrom_info *info = drive->driver_data;
2250 struct cdrom_device_info *cdi = &info->devinfo;
2251 struct atapi_toc *toc = info->toc;
2252 struct {
2253 struct atapi_toc_header hdr;
2254 struct atapi_toc_entry ent;
2255 } ms_tmp;
2256 long last_written;
2257 unsigned long sectors_per_frame = SECTORS_PER_FRAME;
2258
2259 if (toc == NULL) {
2260 /* Try to allocate space. */
2a91f3e5 2261 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
1da177e4
LT		 2262 if (toc == NULL) {
2263 printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
2264 return -ENOMEM;
2265 }
2a91f3e5 2266 info->toc = toc;
1da177e4
LT		 2267 }
2268
2269 /* Check to see if the existing data is still valid.
2270 If it is, just return. */
2271 (void) cdrom_check_status(drive, sense);
2272
2273 if (CDROM_STATE_FLAGS(drive)->toc_valid)
2274 return 0;
2275
2276 /* Try to get the total cdrom capacity and sector size. */
2277 stat = cdrom_read_capacity(drive, &toc->capacity, &sectors_per_frame,
2278 sense);
2279 if (stat)
2280 toc->capacity = 0x1fffff;
2281
2282 set_capacity(info->disk, toc->capacity * sectors_per_frame);
dbe217af
AC		 2283 /* Save a private copy of te TOC capacity for error handling */
2284 drive->probed_capacity = toc->capacity * sectors_per_frame;
2285
1da177e4
LT		 2286 blk_queue_hardsect_size(drive->queue,
2287 sectors_per_frame << SECTOR_BITS);
2288
2289 /* First read just the header, so we know how long the TOC is. */
2290 stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
2291 sizeof(struct atapi_toc_header), sense);
2a91f3e5
JJ		 2292 if (stat)
2293 return stat;
1da177e4
LT		 2294
2295#if ! STANDARD_ATAPI
2296 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2297 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2298 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2299 }
2300#endif /* not STANDARD_ATAPI */
2301
2302 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2303 if (ntracks <= 0)
2304 return -EIO;
2305 if (ntracks > MAX_TRACKS)
2306 ntracks = MAX_TRACKS;
2307
2308 /* Now read the whole schmeer. */
2309 stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
2310 (char *)&toc->hdr,
2311 sizeof(struct atapi_toc_header) +
2312 (ntracks + 1) *
2313 sizeof(struct atapi_toc_entry), sense);
2314
2315 if (stat && toc->hdr.first_track > 1) {
2316 /* Cds with CDI tracks only don't have any TOC entries,
2317 despite of this the returned values are
2318 first_track == last_track = number of CDI tracks + 1,
2319 so that this case is indistinguishable from the same
2320 layout plus an additional audio track.
2321 If we get an error for the regular case, we assume
2322 a CDI without additional audio tracks. In this case
2323 the readable TOC is empty (CDI tracks are not included)
96de0e25 2324 and only holds the Leadout entry. Heiko Eißfeldt */
1da177e4
LT		 2325 ntracks = 0;
2326 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
2327 (char *)&toc->hdr,
2328 sizeof(struct atapi_toc_header) +
2329 (ntracks + 1) *
2330 sizeof(struct atapi_toc_entry),
2331 sense);
2332 if (stat) {
2333 return stat;
2334 }
2335#if ! STANDARD_ATAPI
2336 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2337 toc->hdr.first_track = bin2bcd(CDROM_LEADOUT);
2338 toc->hdr.last_track = bin2bcd(CDROM_LEADOUT);
2339 } else
2340#endif /* not STANDARD_ATAPI */
2341 {
2342 toc->hdr.first_track = CDROM_LEADOUT;
2343 toc->hdr.last_track = CDROM_LEADOUT;
2344 }
2345 }
2346
2347 if (stat)
2348 return stat;
2349
2350 toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
2351
2352#if ! STANDARD_ATAPI
2353 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2354 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2355 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2356 }
2357#endif /* not STANDARD_ATAPI */
2358
2359 for (i=0; i<=ntracks; i++) {
2360#if ! STANDARD_ATAPI
2361 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2362 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd)
2363 toc->ent[i].track = bcd2bin(toc->ent[i].track);
2364 msf_from_bcd(&toc->ent[i].addr.msf);
2365 }
2366#endif /* not STANDARD_ATAPI */
2367 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
2368 toc->ent[i].addr.msf.second,
2369 toc->ent[i].addr.msf.frame);
2370 }
2371
2372 /* Read the multisession information. */
2373 if (toc->hdr.first_track != CDROM_LEADOUT) {
2374 /* Read the multisession information. */
2375 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
2376 sizeof(ms_tmp), sense);
2a91f3e5
JJ		 2377 if (stat)
2378 return stat;
1da177e4
LT		 2379
2380 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
2381 } else {
2382 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
2383 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
2384 }
2385
2386#if ! STANDARD_ATAPI
2387 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2388 /* Re-read multisession information using MSF format */
2389 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
2390 sizeof(ms_tmp), sense);
2391 if (stat)
2392 return stat;
2393
2394 msf_from_bcd (&ms_tmp.ent.addr.msf);
2395 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
2396 ms_tmp.ent.addr.msf.second,
2397 ms_tmp.ent.addr.msf.frame);
2398 }
2399#endif /* not STANDARD_ATAPI */
2400
2401 toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
2402
2403 /* Now try to get the total cdrom capacity. */
2404 stat = cdrom_get_last_written(cdi, &last_written);
2405 if (!stat && (last_written > toc->capacity)) {
2406 toc->capacity = last_written;
2407 set_capacity(info->disk, toc->capacity * sectors_per_frame);
dbe217af 2408 drive->probed_capacity = toc->capacity * sectors_per_frame;
1da177e4
LT		 2409 }
2410
2411 /* Remember that we've read this stuff. */
2412 CDROM_STATE_FLAGS(drive)->toc_valid = 1;
2413
2414 return 0;
2415}
2416
2417
2418static int cdrom_read_subchannel(ide_drive_t *drive, int format, char *buf,
2419 int buflen, struct request_sense *sense)
2420{
2421 struct request req;
2422
2423 cdrom_prepare_request(drive, &req);
2424
2425 req.sense = sense;
2426 req.data = buf;
2427 req.data_len = buflen;
2428 req.cmd[0] = GPCMD_READ_SUBCHANNEL;
2429 req.cmd[1] = 2; /* MSF addressing */
2430 req.cmd[2] = 0x40; /* request subQ data */
2431 req.cmd[3] = format;
2432 req.cmd[7] = (buflen >> 8);
2433 req.cmd[8] = (buflen & 0xff);
2434 return cdrom_queue_packet_command(drive, &req);
2435}
2436
2437/* ATAPI cdrom drives are free to select the speed you request or any slower
2438 rate :-( Requesting too fast a speed will _not_ produce an error. */
2439static int cdrom_select_speed(ide_drive_t *drive, int speed,
2440 struct request_sense *sense)
2441{
2442 struct request req;
2443 cdrom_prepare_request(drive, &req);
2444
2445 req.sense = sense;
2446 if (speed == 0)
2447 speed = 0xffff; /* set to max */
2448 else
2449 speed *= 177; /* Nx to kbytes/s */
2450
2451 req.cmd[0] = GPCMD_SET_SPEED;
2452 /* Read Drive speed in kbytes/second MSB */
2453 req.cmd[2] = (speed >> 8) & 0xff;
2454 /* Read Drive speed in kbytes/second LSB */
2455 req.cmd[3] = speed & 0xff;
2456 if (CDROM_CONFIG_FLAGS(drive)->cd_r ||
2457 CDROM_CONFIG_FLAGS(drive)->cd_rw ||
2458 CDROM_CONFIG_FLAGS(drive)->dvd_r) {
2459 /* Write Drive speed in kbytes/second MSB */
2460 req.cmd[4] = (speed >> 8) & 0xff;
2461 /* Write Drive speed in kbytes/second LSB */
2462 req.cmd[5] = speed & 0xff;
2463 }
2464
2465 return cdrom_queue_packet_command(drive, &req);
2466}
2467
2468static int cdrom_play_audio(ide_drive_t *drive, int lba_start, int lba_end)
2469{
2470 struct request_sense sense;
2471 struct request req;
2472
2473 cdrom_prepare_request(drive, &req);
2474
2475 req.sense = &sense;
2476 req.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2477 lba_to_msf(lba_start, &req.cmd[3], &req.cmd[4], &req.cmd[5]);
2478 lba_to_msf(lba_end-1, &req.cmd[6], &req.cmd[7], &req.cmd[8]);
2479
2480 return cdrom_queue_packet_command(drive, &req);
2481}
2482
2483static int cdrom_get_toc_entry(ide_drive_t *drive, int track,
2484 struct atapi_toc_entry **ent)
2485{
2486 struct cdrom_info *info = drive->driver_data;
2487 struct atapi_toc *toc = info->toc;
2488 int ntracks;
2489
2490 /*
2491 * don't serve cached data, if the toc isn't valid
2492 */
2493 if (!CDROM_STATE_FLAGS(drive)->toc_valid)
2494 return -EINVAL;
2495
2496 /* Check validity of requested track number. */
2497 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2498 if (toc->hdr.first_track == CDROM_LEADOUT) ntracks = 0;
2499 if (track == CDROM_LEADOUT)
2500 *ent = &toc->ent[ntracks];
2501 else if (track < toc->hdr.first_track ||
2502 track > toc->hdr.last_track)
2503 return -EINVAL;
2504 else
2505 *ent = &toc->ent[track - toc->hdr.first_track];
2506
2507 return 0;
2508}
2509
2510/* the generic packet interface to cdrom.c */
2511static int ide_cdrom_packet(struct cdrom_device_info *cdi,
2512 struct packet_command *cgc)
2513{
2514 struct request req;
2a91f3e5 2515 ide_drive_t *drive = cdi->handle;
1da177e4
LT		 2516
2517 if (cgc->timeout <= 0)
2518 cgc->timeout = ATAPI_WAIT_PC;
2519
2520 /* here we queue the commands from the uniform CD-ROM
2521 layer. the packet must be complete, as we do not
2522 touch it at all. */
2523 cdrom_prepare_request(drive, &req);
2524 memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
2525 if (cgc->sense)
2526 memset(cgc->sense, 0, sizeof(struct request_sense));
2527 req.data = cgc->buffer;
2528 req.data_len = cgc->buflen;
2529 req.timeout = cgc->timeout;
2530
2531 if (cgc->quiet)
4aff5e23 2532 req.cmd_flags |= REQ_QUIET;
1da177e4
LT		 2533
2534 req.sense = cgc->sense;
2535 cgc->stat = cdrom_queue_packet_command(drive, &req);
2536 if (!cgc->stat)
2537 cgc->buflen -= req.data_len;
2538 return cgc->stat;
2539}
2540
1da177e4
LT		 2541static
2542int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
2543 unsigned int cmd, void *arg)
2544
2545{
2a91f3e5 2546 ide_drive_t *drive = cdi->handle;
1da177e4
LT		 2547 struct cdrom_info *info = drive->driver_data;
2548 int stat;
2549
2550 switch (cmd) {
2551 /*
2552 * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
2553 * atapi doesn't support it
2554 */
2555 case CDROMPLAYTRKIND: {
2556 unsigned long lba_start, lba_end;
2a91f3e5 2557 struct cdrom_ti *ti = arg;
1da177e4
LT		 2558 struct atapi_toc_entry *first_toc, *last_toc;
2559
2560 stat = cdrom_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
2561 if (stat)
2562 return stat;
2563
2564 stat = cdrom_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
2565 if (stat)
2566 return stat;
2567
2568 if (ti->cdti_trk1 != CDROM_LEADOUT)
2569 ++last_toc;
2570 lba_start = first_toc->addr.lba;
2571 lba_end = last_toc->addr.lba;
2572
2573 if (lba_end <= lba_start)
2574 return -EINVAL;
2575
2576 return cdrom_play_audio(drive, lba_start, lba_end);
2577 }
2578
2579 case CDROMREADTOCHDR: {
2a91f3e5 2580 struct cdrom_tochdr *tochdr = arg;
1da177e4
LT		 2581 struct atapi_toc *toc;
2582
2583 /* Make sure our saved TOC is valid. */
2584 stat = cdrom_read_toc(drive, NULL);
2a91f3e5
JJ		 2585 if (stat)
2586 return stat;
1da177e4
LT		 2587
2588 toc = info->toc;
2589 tochdr->cdth_trk0 = toc->hdr.first_track;
2590 tochdr->cdth_trk1 = toc->hdr.last_track;
2591
2592 return 0;
2593 }
2594
2595 case CDROMREADTOCENTRY: {
2a91f3e5 2596 struct cdrom_tocentry *tocentry = arg;
1da177e4
LT		 2597 struct atapi_toc_entry *toce;
2598
2599 stat = cdrom_get_toc_entry(drive, tocentry->cdte_track, &toce);
2a91f3e5
JJ		 2600 if (stat)
2601 return stat;
1da177e4
LT		 2602
2603 tocentry->cdte_ctrl = toce->control;
2604 tocentry->cdte_adr = toce->adr;
2605 if (tocentry->cdte_format == CDROM_MSF) {
2606 lba_to_msf (toce->addr.lba,
2607 &tocentry->cdte_addr.msf.minute,
2608 &tocentry->cdte_addr.msf.second,
2609 &tocentry->cdte_addr.msf.frame);
2610 } else
2611 tocentry->cdte_addr.lba = toce->addr.lba;
2612
2613 return 0;
2614 }
2615
2616 default:
2617 return -EINVAL;
2618 }
2619}
2620
2621static
2622int ide_cdrom_reset (struct cdrom_device_info *cdi)
2623{
2a91f3e5 2624 ide_drive_t *drive = cdi->handle;
1da177e4
LT		 2625 struct request_sense sense;
2626 struct request req;
2627 int ret;
2628
2629 cdrom_prepare_request(drive, &req);
4aff5e23
JA		 2630 req.cmd_type = REQ_TYPE_SPECIAL;
2631 req.cmd_flags = REQ_QUIET;
1da177e4
LT		 2632 ret = ide_do_drive_cmd(drive, &req, ide_wait);
2633
2634 /*
2635 * A reset will unlock the door. If it was previously locked,
2636 * lock it again.
2637 */
2638 if (CDROM_STATE_FLAGS(drive)->door_locked)
2639 (void) cdrom_lockdoor(drive, 1, &sense);
2640
2641 return ret;
2642}
2643
2644
2645static
2646int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
2647{
2a91f3e5 2648 ide_drive_t *drive = cdi->handle;
1da177e4
LT		 2649 struct request_sense sense;
2650
2651 if (position) {
2652 int stat = cdrom_lockdoor(drive, 0, &sense);
2a91f3e5
JJ		 2653 if (stat)
2654 return stat;
1da177e4
LT		 2655 }
2656
2657 return cdrom_eject(drive, !position, &sense);
2658}
2659
2660static
2661int ide_cdrom_lock_door (struct cdrom_device_info *cdi, int lock)
2662{
2a91f3e5 2663 ide_drive_t *drive = cdi->handle;
1da177e4
LT		 2664 return cdrom_lockdoor(drive, lock, NULL);
2665}
2666
9235e68b
EP		 2667static
2668int ide_cdrom_get_capabilities(ide_drive_t *drive, struct atapi_capabilities_page *cap)
2669{
2670 struct cdrom_info *info = drive->driver_data;
2671 struct cdrom_device_info *cdi = &info->devinfo;
2672 struct packet_command cgc;
2673 int stat, attempts = 3, size = sizeof(*cap);
2674
2675 /*
2676 * ACER50 (and others?) require the full spec length mode sense
2677 * page capabilities size, but older drives break.
2678 */
2679 if (!(!strcmp(drive->id->model, "ATAPI CD ROM DRIVE 50X MAX") ||
2680 !strcmp(drive->id->model, "WPI CDS-32X")))
2681 size -= sizeof(cap->pad);
2682
2683 init_cdrom_command(&cgc, cap, size, CGC_DATA_UNKNOWN);
2684 do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2685 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
2686 if (!stat)
2687 break;
2688 } while (--attempts);
2689 return stat;
2690}
2691
2692static
2693void ide_cdrom_update_speed (ide_drive_t *drive, struct atapi_capabilities_page *cap)
2694{
2695 /* The ACER/AOpen 24X cdrom has the speed fields byte-swapped */
2696 if (!drive->id->model[0] &&
2697 !strncmp(drive->id->fw_rev, "241N", 4)) {
2698 CDROM_STATE_FLAGS(drive)->current_speed =
aa5dc8eb 2699 (le16_to_cpu(cap->curspeed) + (176/2)) / 176;
9235e68b 2700 CDROM_CONFIG_FLAGS(drive)->max_speed =
aa5dc8eb 2701 (le16_to_cpu(cap->maxspeed) + (176/2)) / 176;
9235e68b
EP		 2702 } else {
2703 CDROM_STATE_FLAGS(drive)->current_speed =
aa5dc8eb 2704 (be16_to_cpu(cap->curspeed) + (176/2)) / 176;
9235e68b 2705 CDROM_CONFIG_FLAGS(drive)->max_speed =
aa5dc8eb 2706 (be16_to_cpu(cap->maxspeed) + (176/2)) / 176;
9235e68b
EP		 2707 }
2708}
2709
1da177e4
LT		 2710static
2711int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
2712{
2a91f3e5 2713 ide_drive_t *drive = cdi->handle;
1da177e4 2714 struct request_sense sense;
9235e68b 2715 struct atapi_capabilities_page cap;
1da177e4
LT		 2716 int stat;
2717
2718 if ((stat = cdrom_select_speed(drive, speed, &sense)) < 0)
2719 return stat;
2720
9235e68b
EP		 2721 if (!ide_cdrom_get_capabilities(drive, &cap)) {
2722 ide_cdrom_update_speed(drive, &cap);
2723 cdi->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2724 }
1da177e4
LT		 2725 return 0;
2726}
2727
2728/*
2729 * add logic to try GET_EVENT command first to check for media and tray
2730 * status. this should be supported by newer cd-r/w and all DVD etc
2731 * drives
2732 */
2733static
2734int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
2735{
2a91f3e5 2736 ide_drive_t *drive = cdi->handle;
1da177e4
LT		 2737 struct media_event_desc med;
2738 struct request_sense sense;
2739 int stat;
2740
2741 if (slot_nr != CDSL_CURRENT)
2742 return -EINVAL;
2743
2744 stat = cdrom_check_status(drive, &sense);
2745 if (!stat || sense.sense_key == UNIT_ATTENTION)
2746 return CDS_DISC_OK;
2747
2748 if (!cdrom_get_media_event(cdi, &med)) {
2749 if (med.media_present)
2750 return CDS_DISC_OK;
2751 else if (med.door_open)
2752 return CDS_TRAY_OPEN;
2753 else
2754 return CDS_NO_DISC;
2755 }
2756
2757 if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
2758 return CDS_DISC_OK;
2759
2760 /*
2761 * If not using Mt Fuji extended media tray reports,
2762 * just return TRAY_OPEN since ATAPI doesn't provide
2763 * any other way to detect this...
2764 */
2765 if (sense.sense_key == NOT_READY) {
dbe217af
AC		 2766 if (sense.asc == 0x3a && sense.ascq == 1)
2767 return CDS_NO_DISC;
2768 else
2769 return CDS_TRAY_OPEN;
1da177e4 2770 }
1da177e4
LT		 2771 return CDS_DRIVE_NOT_READY;
2772}
2773
2774static
2775int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
2776 struct cdrom_multisession *ms_info)
2777{
2778 struct atapi_toc *toc;
2a91f3e5 2779 ide_drive_t *drive = cdi->handle;
1da177e4
LT		 2780 struct cdrom_info *info = drive->driver_data;
2781 struct request_sense sense;
2782 int ret;
2783
2784 if (!CDROM_STATE_FLAGS(drive)->toc_valid || info->toc == NULL)
2785 if ((ret = cdrom_read_toc(drive, &sense)))
2786 return ret;
2787
2788 toc = info->toc;
2789 ms_info->addr.lba = toc->last_session_lba;
2790 ms_info->xa_flag = toc->xa_flag;
2791
2792 return 0;
2793}
2794
2795static
2796int ide_cdrom_get_mcn (struct cdrom_device_info *cdi,
2797 struct cdrom_mcn *mcn_info)
2798{
2799 int stat;
2800 char mcnbuf[24];
2a91f3e5 2801 ide_drive_t *drive = cdi->handle;
1da177e4
LT		 2802
2803/* get MCN */
2804 if ((stat = cdrom_read_subchannel(drive, 2, mcnbuf, sizeof (mcnbuf), NULL)))
2805 return stat;
2806
2807 memcpy (mcn_info->medium_catalog_number, mcnbuf+9,
2808 sizeof (mcn_info->medium_catalog_number)-1);
2809 mcn_info->medium_catalog_number[sizeof (mcn_info->medium_catalog_number)-1]
2810 = '\0';
2811
2812 return 0;
2813}
2814
2815
2816
2817/****************************************************************************
2818 * Other driver requests (open, close, check media change).
2819 */
2820
2821static
2822int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
2823 int slot_nr)
2824{
2a91f3e5 2825 ide_drive_t *drive = cdi->handle;
1da177e4
LT		 2826 int retval;
2827
2828 if (slot_nr == CDSL_CURRENT) {
2829 (void) cdrom_check_status(drive, NULL);
2830 retval = CDROM_STATE_FLAGS(drive)->media_changed;
2831 CDROM_STATE_FLAGS(drive)->media_changed = 0;
2832 return retval;
2833 } else {
2834 return -EINVAL;
2835 }
2836}
2837
2838
2839static
2840int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
2841{
2842 return 0;
2843}
2844
2845/*
2846 * Close down the device. Invalidate all cached blocks.
2847 */
2848
2849static
2850void ide_cdrom_release_real (struct cdrom_device_info *cdi)
2851{
2852 ide_drive_t *drive = cdi->handle;
2853
2854 if (!cdi->use_count)
2855 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
2856}
2857
2858
2859
2860/****************************************************************************
2861 * Device initialization.
2862 */
2863static struct cdrom_device_ops ide_cdrom_dops = {
2864 .open = ide_cdrom_open_real,
2865 .release = ide_cdrom_release_real,
2866 .drive_status = ide_cdrom_drive_status,
2867 .media_changed = ide_cdrom_check_media_change_real,
2868 .tray_move = ide_cdrom_tray_move,
2869 .lock_door = ide_cdrom_lock_door,
2870 .select_speed = ide_cdrom_select_speed,
2871 .get_last_session = ide_cdrom_get_last_session,
2872 .get_mcn = ide_cdrom_get_mcn,
2873 .reset = ide_cdrom_reset,
2874 .audio_ioctl = ide_cdrom_audio_ioctl,
1da177e4
LT		 2875 .capability = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
2876 CDC_SELECT_SPEED | CDC_SELECT_DISC |
2877 CDC_MULTI_SESSION | CDC_MCN |
2878 CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO | CDC_RESET |
6a2900b6 2879 CDC_DRIVE_STATUS | CDC_CD_R |
1da177e4
LT		 2880 CDC_CD_RW | CDC_DVD | CDC_DVD_R| CDC_DVD_RAM |
2881 CDC_GENERIC_PACKET | CDC_MO_DRIVE | CDC_MRW |
2882 CDC_MRW_W | CDC_RAM,
2883 .generic_packet = ide_cdrom_packet,
2884};
2885
2886static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2887{
2888 struct cdrom_info *info = drive->driver_data;
2889 struct cdrom_device_info *devinfo = &info->devinfo;
2890
2891 devinfo->ops = &ide_cdrom_dops;
2892 devinfo->mask = 0;
2893 devinfo->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2894 devinfo->capacity = nslots;
2a91f3e5 2895 devinfo->handle = drive;
1da177e4
LT		 2896 strcpy(devinfo->name, drive->name);
2897
2898 /* set capability mask to match the probe. */
2899 if (!CDROM_CONFIG_FLAGS(drive)->cd_r)
2900 devinfo->mask |= CDC_CD_R;
2901 if (!CDROM_CONFIG_FLAGS(drive)->cd_rw)
2902 devinfo->mask |= CDC_CD_RW;
2903 if (!CDROM_CONFIG_FLAGS(drive)->dvd)
2904 devinfo->mask |= CDC_DVD;
2905 if (!CDROM_CONFIG_FLAGS(drive)->dvd_r)
2906 devinfo->mask |= CDC_DVD_R;
2907 if (!CDROM_CONFIG_FLAGS(drive)->dvd_ram)
2908 devinfo->mask |= CDC_DVD_RAM;
2909 if (!CDROM_CONFIG_FLAGS(drive)->is_changer)
2910 devinfo->mask |= CDC_SELECT_DISC;
2911 if (!CDROM_CONFIG_FLAGS(drive)->audio_play)
2912 devinfo->mask |= CDC_PLAY_AUDIO;
2913 if (!CDROM_CONFIG_FLAGS(drive)->close_tray)
2914 devinfo->mask |= CDC_CLOSE_TRAY;
2915 if (!CDROM_CONFIG_FLAGS(drive)->mo_drive)
2916 devinfo->mask |= CDC_MO_DRIVE;
c0400dc5
AB		 2917 if (!CDROM_CONFIG_FLAGS(drive)->ram)
2918 devinfo->mask |= CDC_RAM;
1da177e4 2919
3cbd814e
BZ		 2920 if (CDROM_CONFIG_FLAGS(drive)->no_speed_select)
2921 devinfo->mask |= CDC_SELECT_SPEED;
2922
1da177e4
LT		 2923 devinfo->disk = info->disk;
2924 return register_cdrom(devinfo);
2925}
2926
1da177e4
LT		 2927static
2928int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2929{
2930 struct cdrom_info *info = drive->driver_data;
2931 struct cdrom_device_info *cdi = &info->devinfo;
2932 struct atapi_capabilities_page cap;
2933 int nslots = 1;
2934
2935 if (drive->media == ide_optical) {
2936 CDROM_CONFIG_FLAGS(drive)->mo_drive = 1;
2937 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2938 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
2939 return nslots;
2940 }
2941
2942 if (CDROM_CONFIG_FLAGS(drive)->nec260 ||
2943 !strcmp(drive->id->model,"STINGRAY 8422 IDE 8X CD-ROM 7-27-95")) {
2944 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2945 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2946 return nslots;
2947 }
2948
2949 /*
2950 * we have to cheat a little here. the packet will eventually
2951 * be queued with ide_cdrom_packet(), which extracts the
2952 * drive from cdi->handle. Since this device hasn't been
2953 * registered with the Uniform layer yet, it can't do this.
2954 * Same goes for cdi->ops.
2955 */
2a91f3e5 2956 cdi->handle = drive;
1da177e4
LT		 2957 cdi->ops = &ide_cdrom_dops;
2958
2959 if (ide_cdrom_get_capabilities(drive, &cap))
2960 return 0;
2961
2962 if (cap.lock == 0)
2963 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2964 if (cap.eject)
2965 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2966 if (cap.cd_r_write)
2967 CDROM_CONFIG_FLAGS(drive)->cd_r = 1;
2968 if (cap.cd_rw_write) {
2969 CDROM_CONFIG_FLAGS(drive)->cd_rw = 1;
2970 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2971 }
2972 if (cap.test_write)
2973 CDROM_CONFIG_FLAGS(drive)->test_write = 1;
2974 if (cap.dvd_ram_read || cap.dvd_r_read || cap.dvd_rom)
2975 CDROM_CONFIG_FLAGS(drive)->dvd = 1;
2976 if (cap.dvd_ram_write) {
2977 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 1;
2978 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2979 }
2980 if (cap.dvd_r_write)
2981 CDROM_CONFIG_FLAGS(drive)->dvd_r = 1;
2982 if (cap.audio_play)
2983 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2984 if (cap.mechtype == mechtype_caddy || cap.mechtype == mechtype_popup)
2985 CDROM_CONFIG_FLAGS(drive)->close_tray = 0;
2986
2987 /* Some drives used by Apple don't advertise audio play
2988 * but they do support reading TOC & audio datas
2989 */
2990 if (strcmp(drive->id->model, "MATSHITADVD-ROM SR-8187") == 0 ||
2991 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8186") == 0 ||
2992 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8176") == 0 ||
2993 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8174") == 0)
2994 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2995
2996#if ! STANDARD_ATAPI
2997 if (cdi->sanyo_slot > 0) {
2998 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
2999 nslots = 3;
3000 }
3001
3002 else
3003#endif /* not STANDARD_ATAPI */
3004 if (cap.mechtype == mechtype_individual_changer ||
3005 cap.mechtype == mechtype_cartridge_changer) {
3006 if ((nslots = cdrom_number_of_slots(cdi)) > 1) {
3007 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
3008 CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 1;
3009 }
3010 }
3011
9235e68b 3012 ide_cdrom_update_speed(drive, &cap);
1da177e4
LT		 3013 /* don't print speed if the drive reported 0.
3014 */
3015 printk(KERN_INFO "%s: ATAPI", drive->name);
3016 if (CDROM_CONFIG_FLAGS(drive)->max_speed)
3017 printk(" %dX", CDROM_CONFIG_FLAGS(drive)->max_speed);
3018 printk(" %s", CDROM_CONFIG_FLAGS(drive)->dvd ? "DVD-ROM" : "CD-ROM");
3019
3020 if (CDROM_CONFIG_FLAGS(drive)->dvd_r|CDROM_CONFIG_FLAGS(drive)->dvd_ram)
3021 printk(" DVD%s%s",
3022 (CDROM_CONFIG_FLAGS(drive)->dvd_r)? "-R" : "",
3023 (CDROM_CONFIG_FLAGS(drive)->dvd_ram)? "-RAM" : "");
3024
3025 if (CDROM_CONFIG_FLAGS(drive)->cd_r|CDROM_CONFIG_FLAGS(drive)->cd_rw)
3026 printk(" CD%s%s",
3027 (CDROM_CONFIG_FLAGS(drive)->cd_r)? "-R" : "",
3028 (CDROM_CONFIG_FLAGS(drive)->cd_rw)? "/RW" : "");
3029
3030 if (CDROM_CONFIG_FLAGS(drive)->is_changer)
3031 printk(" changer w/%d slots", nslots);
3032 else
3033 printk(" drive");
3034
3ab7efe8 3035 printk(KERN_CONT ", %dkB Cache\n", be16_to_cpu(cap.buffer_size));
1da177e4
LT		 3036
3037 return nslots;
3038}
3039
7662d046 3040#ifdef CONFIG_IDE_PROC_FS
1da177e4
LT		 3041static void ide_cdrom_add_settings(ide_drive_t *drive)
3042{
1497943e 3043 ide_add_setting(drive, "dsc_overlap", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
1da177e4 3044}
7662d046
BZ		 3045#else
3046static inline void ide_cdrom_add_settings(ide_drive_t *drive) { ; }
3047#endif
1da177e4
LT		 3048
3049/*
3050 * standard prep_rq_fn that builds 10 byte cmds
3051 */
165125e1 3052static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
1da177e4
LT		 3053{
3054 int hard_sect = queue_hardsect_size(q);
3055 long block = (long)rq->hard_sector / (hard_sect >> 9);
3056 unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
3057
3058 memset(rq->cmd, 0, sizeof(rq->cmd));
3059
3060 if (rq_data_dir(rq) == READ)
3061 rq->cmd[0] = GPCMD_READ_10;
3062 else
3063 rq->cmd[0] = GPCMD_WRITE_10;
3064
3065 /*
3066 * fill in lba
3067 */
3068 rq->cmd[2] = (block >> 24) & 0xff;
3069 rq->cmd[3] = (block >> 16) & 0xff;
3070 rq->cmd[4] = (block >> 8) & 0xff;
3071 rq->cmd[5] = block & 0xff;
3072
3073 /*
3074 * and transfer length
3075 */
3076 rq->cmd[7] = (blocks >> 8) & 0xff;
3077 rq->cmd[8] = blocks & 0xff;
3078 rq->cmd_len = 10;
3079 return BLKPREP_OK;
3080}
3081
3082/*
3083 * Most of the SCSI commands are supported directly by ATAPI devices.
3084 * This transform handles the few exceptions.
3085 */
3086static int ide_cdrom_prep_pc(struct request *rq)
3087{
3088 u8 *c = rq->cmd;
3089
3090 /*
3091 * Transform 6-byte read/write commands to the 10-byte version
3092 */
3093 if (c[0] == READ_6 || c[0] == WRITE_6) {
3094 c[8] = c[4];
3095 c[5] = c[3];
3096 c[4] = c[2];
3097 c[3] = c[1] & 0x1f;
3098 c[2] = 0;
3099 c[1] &= 0xe0;
3100 c[0] += (READ_10 - READ_6);
3101 rq->cmd_len = 10;
3102 return BLKPREP_OK;
3103 }
3104
3105 /*
3106 * it's silly to pretend we understand 6-byte sense commands, just
3107 * reject with ILLEGAL_REQUEST and the caller should take the
3108 * appropriate action
3109 */
3110 if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
3111 rq->errors = ILLEGAL_REQUEST;
3112 return BLKPREP_KILL;
3113 }
3114
3115 return BLKPREP_OK;
3116}
3117
165125e1 3118static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
1da177e4 3119{
4aff5e23 3120 if (blk_fs_request(rq))
1da177e4 3121 return ide_cdrom_prep_fs(q, rq);
4aff5e23 3122 else if (blk_pc_request(rq))
1da177e4
LT		 3123 return ide_cdrom_prep_pc(rq);
3124
3125 return 0;
3126}
3127
3128static
3129int ide_cdrom_setup (ide_drive_t *drive)
3130{
3131 struct cdrom_info *info = drive->driver_data;
3132 struct cdrom_device_info *cdi = &info->devinfo;
3133 int nslots;
3134
3135 blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
3136 blk_queue_dma_alignment(drive->queue, 31);
3137 drive->queue->unplug_delay = (1 * HZ) / 1000;
3138 if (!drive->queue->unplug_delay)
3139 drive->queue->unplug_delay = 1;
3140
3141 drive->special.all = 0;
3142
3143 CDROM_STATE_FLAGS(drive)->media_changed = 1;
3144 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
3145 CDROM_STATE_FLAGS(drive)->door_locked = 0;
3146
3147#if NO_DOOR_LOCKING
3148 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
3149#else
3150 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 0;
3151#endif
3152
3153 CDROM_CONFIG_FLAGS(drive)->drq_interrupt = ((drive->id->config & 0x0060) == 0x20);
3154 CDROM_CONFIG_FLAGS(drive)->is_changer = 0;
3155 CDROM_CONFIG_FLAGS(drive)->cd_r = 0;
3156 CDROM_CONFIG_FLAGS(drive)->cd_rw = 0;
3157 CDROM_CONFIG_FLAGS(drive)->test_write = 0;
3158 CDROM_CONFIG_FLAGS(drive)->dvd = 0;
3159 CDROM_CONFIG_FLAGS(drive)->dvd_r = 0;
3160 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 0;
3161 CDROM_CONFIG_FLAGS(drive)->no_eject = 1;
3162 CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 0;
3163 CDROM_CONFIG_FLAGS(drive)->audio_play = 0;
3164 CDROM_CONFIG_FLAGS(drive)->close_tray = 1;
3165
3166 /* limit transfer size per interrupt. */
3167 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 0;
3168 /* a testament to the nice quality of Samsung drives... */
3169 if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2430"))
3170 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3171 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2432"))
3172 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3173 /* the 3231 model does not support the SET_CD_SPEED command */
3174 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-3231"))
3cbd814e 3175 CDROM_CONFIG_FLAGS(drive)->no_speed_select = 1;
1da177e4
LT		 3176
3177#if ! STANDARD_ATAPI
3178 /* by default Sanyo 3 CD changer support is turned off and
3179 ATAPI Rev 2.2+ standard support for CD changers is used */
3180 cdi->sanyo_slot = 0;
3181
3182 CDROM_CONFIG_FLAGS(drive)->nec260 = 0;
3183 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 0;
3184 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 0;
3185 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 0;
3186 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 0;
3187
3188 if (strcmp (drive->id->model, "V003S0DS") == 0 &&
3189 drive->id->fw_rev[4] == '1' &&
3190 drive->id->fw_rev[6] <= '2') {
3191 /* Vertos 300.
3192 Some versions of this drive like to talk BCD. */
3193 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3194 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3195 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3196 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3197 }
3198
3199 else if (strcmp (drive->id->model, "V006E0DS") == 0 &&
3200 drive->id->fw_rev[4] == '1' &&
3201 drive->id->fw_rev[6] <= '2') {
3202 /* Vertos 600 ESD. */
3203 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3204 }
3205 else if (strcmp(drive->id->model, "NEC CD-ROM DRIVE:260") == 0 &&
3206 strncmp(drive->id->fw_rev, "1.01", 4) == 0) { /* FIXME */
3207 /* Old NEC260 (not R).
3208 This drive was released before the 1.2 version
3209 of the spec. */
3210 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3211 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3212 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3213 CDROM_CONFIG_FLAGS(drive)->nec260 = 1;
3214 }
3215 else if (strcmp(drive->id->model, "WEARNES CDD-120") == 0 &&
3216 strncmp(drive->id->fw_rev, "A1.1", 4) == 0) { /* FIXME */
3217 /* Wearnes */
3218 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3219 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3220 }
3221 /* Sanyo 3 CD changer uses a non-standard command
3222 for CD changing */
3223 else if ((strcmp(drive->id->model, "CD-ROM CDR-C3 G") == 0) ||
3224 (strcmp(drive->id->model, "CD-ROM CDR-C3G") == 0) ||
3225 (strcmp(drive->id->model, "CD-ROM CDR_C36") == 0)) {
3226 /* uses CD in slot 0 when value is set to 3 */
3227 cdi->sanyo_slot = 3;
3228 }
3229#endif /* not STANDARD_ATAPI */
3230
3231 info->toc = NULL;
3232 info->buffer = NULL;
3233 info->sector_buffered = 0;
3234 info->nsectors_buffered = 0;
3235 info->changer_info = NULL;
3236 info->last_block = 0;
3237 info->start_seek = 0;
3238
3239 nslots = ide_cdrom_probe_capabilities (drive);
3240
3241 /*
3242 * set correct block size
3243 */
3244 blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
3245
3246 if (drive->autotune == IDE_TUNE_DEFAULT ||
3247 drive->autotune == IDE_TUNE_AUTO)
3248 drive->dsc_overlap = (drive->next != drive);
1da177e4
LT		 3249
3250 if (ide_cdrom_register(drive, nslots)) {
3251 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
3252 info->devinfo.handle = NULL;
3253 return 1;
3254 }
3255 ide_cdrom_add_settings(drive);
3256 return 0;
3257}
3258
ecfd80e4 3259#ifdef CONFIG_IDE_PROC_FS
1da177e4
LT		 3260static
3261sector_t ide_cdrom_capacity (ide_drive_t *drive)
3262{
3263 unsigned long capacity, sectors_per_frame;
3264
3265 if (cdrom_read_capacity(drive, &capacity, &sectors_per_frame, NULL))
3266 return 0;
3267
3268 return capacity * sectors_per_frame;
3269}
d97b3214 3270#endif
1da177e4 3271
4031bbe4 3272static void ide_cd_remove(ide_drive_t *drive)
1da177e4
LT		 3273{
3274 struct cdrom_info *info = drive->driver_data;
3275
7662d046 3276 ide_proc_unregister_driver(drive, info->driver);
1da177e4
LT		 3277
3278 del_gendisk(info->disk);
3279
3280 ide_cd_put(info);
1da177e4
LT		 3281}
3282
3283static void ide_cd_release(struct kref *kref)
3284{
3285 struct cdrom_info *info = to_ide_cd(kref);
3286 struct cdrom_device_info *devinfo = &info->devinfo;
3287 ide_drive_t *drive = info->drive;
3288 struct gendisk *g = info->disk;
3289
6044ec88
JJ		 3290 kfree(info->buffer);
3291 kfree(info->toc);
3292 kfree(info->changer_info);
1da177e4
LT		 3293 if (devinfo->handle == drive && unregister_cdrom(devinfo))
3294 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom "
3295 "driver.\n", __FUNCTION__, drive->name);
3296 drive->dsc_overlap = 0;
3297 drive->driver_data = NULL;
3298 blk_queue_prep_rq(drive->queue, NULL);
3299 g->private_data = NULL;
3300 put_disk(g);
3301 kfree(info);
3302}
3303
4031bbe4 3304static int ide_cd_probe(ide_drive_t *);
1da177e4 3305
ecfd80e4 3306#ifdef CONFIG_IDE_PROC_FS
1da177e4
LT		 3307static int proc_idecd_read_capacity
3308 (char *page, char **start, off_t off, int count, int *eof, void *data)
3309{
2a91f3e5 3310 ide_drive_t *drive = data;
1da177e4
LT		 3311 int len;
3312
3313 len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
3314 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
3315}
3316
3317static ide_proc_entry_t idecd_proc[] = {
3318 { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
3319 { NULL, 0, NULL, NULL }
3320};
1da177e4
LT		 3321#endif
3322
3323static ide_driver_t ide_cdrom_driver = {
8604affd 3324 .gen_driver = {
4ef3b8f4 3325 .owner = THIS_MODULE,
8604affd
BZ		 3326 .name = "ide-cdrom",
3327 .bus = &ide_bus_type,
8604affd 3328 },
4031bbe4
RK		 3329 .probe = ide_cd_probe,
3330 .remove = ide_cd_remove,
1da177e4
LT		 3331 .version = IDECD_VERSION,
3332 .media = ide_cdrom,
1da177e4 3333 .supports_dsc_overlap = 1,
1da177e4
LT		 3334 .do_request = ide_do_rw_cdrom,
3335 .end_request = ide_end_request,
3336 .error = __ide_error,
3337 .abort = __ide_abort,
7662d046 3338#ifdef CONFIG_IDE_PROC_FS
1da177e4 3339 .proc = idecd_proc,
7662d046 3340#endif
1da177e4
LT		 3341};
3342
3343static int idecd_open(struct inode * inode, struct file * file)
3344{
3345 struct gendisk *disk = inode->i_bdev->bd_disk;
3346 struct cdrom_info *info;
1da177e4
LT		 3347 int rc = -ENOMEM;
3348
3349 if (!(info = ide_cd_get(disk)))
3350 return -ENXIO;
3351
1da177e4 3352 if (!info->buffer)
c94964a4
BZ		 3353 info->buffer = kmalloc(SECTOR_BUFFER_SIZE, GFP_KERNEL|__GFP_REPEAT);
3354
3355 if (info->buffer)
3356 rc = cdrom_open(&info->devinfo, inode, file);
1da177e4
LT		 3357
3358 if (rc < 0)
3359 ide_cd_put(info);
3360
3361 return rc;
3362}
3363
3364static int idecd_release(struct inode * inode, struct file * file)
3365{
3366 struct gendisk *disk = inode->i_bdev->bd_disk;
3367 struct cdrom_info *info = ide_cd_g(disk);
1da177e4
LT		 3368
3369 cdrom_release (&info->devinfo, file);
1da177e4
LT		 3370
3371 ide_cd_put(info);
3372
3373 return 0;
3374}
3375
6a2900b6
CH		 3376static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg)
3377{
3378 struct packet_command cgc;
3379 char buffer[16];
3380 int stat;
3381 char spindown;
3382
3383 if (copy_from_user(&spindown, (void __user *)arg, sizeof(char)))
3384 return -EFAULT;
3385
3386 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
3387
3388 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
3389 if (stat)
3390 return stat;
3391
3392 buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
3393 return cdrom_mode_select(cdi, &cgc);
3394}
3395
3396static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
3397{
3398 struct packet_command cgc;
3399 char buffer[16];
3400 int stat;
3401 char spindown;
3402
3403 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
3404
3405 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
3406 if (stat)
3407 return stat;
3408
3409 spindown = buffer[11] & 0x0f;
3410 if (copy_to_user((void __user *)arg, &spindown, sizeof (char)))
3411 return -EFAULT;
3412 return 0;
3413}
3414
1da177e4
LT		 3415static int idecd_ioctl (struct inode *inode, struct file *file,
3416 unsigned int cmd, unsigned long arg)
3417{
3418 struct block_device *bdev = inode->i_bdev;
3419 struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
3420 int err;
3421
6a2900b6
CH		 3422 switch (cmd) {
3423 case CDROMSETSPINDOWN:
3424 return idecd_set_spindown(&info->devinfo, arg);
3425 case CDROMGETSPINDOWN:
3426 return idecd_get_spindown(&info->devinfo, arg);
3427 default:
3428 break;
3429 }
3430
3431 err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
1da177e4
LT		 3432 if (err == -EINVAL)
3433 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
3434
3435 return err;
3436}
3437
3438static int idecd_media_changed(struct gendisk *disk)
3439{
3440 struct cdrom_info *info = ide_cd_g(disk);
3441 return cdrom_media_changed(&info->devinfo);
3442}
3443
3444static int idecd_revalidate_disk(struct gendisk *disk)
3445{
3446 struct cdrom_info *info = ide_cd_g(disk);
3447 struct request_sense sense;
3448 cdrom_read_toc(info->drive, &sense);
3449 return 0;
3450}
3451
3452static struct block_device_operations idecd_ops = {
3453 .owner = THIS_MODULE,
3454 .open = idecd_open,
3455 .release = idecd_release,
3456 .ioctl = idecd_ioctl,
3457 .media_changed = idecd_media_changed,
3458 .revalidate_disk= idecd_revalidate_disk
3459};
3460
3461/* options */
3462static char *ignore = NULL;
3463
3464module_param(ignore, charp, 0400);
3465MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
3466
4031bbe4 3467static int ide_cd_probe(ide_drive_t *drive)
1da177e4
LT		 3468{
3469 struct cdrom_info *info;
3470 struct gendisk *g;
3471 struct request_sense sense;
3472
3473 if (!strstr("ide-cdrom", drive->driver_req))
3474 goto failed;
3475 if (!drive->present)
3476 goto failed;
3477 if (drive->media != ide_cdrom && drive->media != ide_optical)
3478 goto failed;
3479 /* skip drives that we were told to ignore */
3480 if (ignore != NULL) {
3481 if (strstr(ignore, drive->name)) {
3482 printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
3483 goto failed;
3484 }
3485 }
3486 if (drive->scsi) {
3487 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
3488 goto failed;
3489 }
f5e3c2fa 3490 info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
1da177e4
LT		 3491 if (info == NULL) {
3492 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
3493 goto failed;
3494 }
3495
3496 g = alloc_disk(1 << PARTN_BITS);
3497 if (!g)
3498 goto out_free_cd;
3499
3500 ide_init_disk(g, drive);
3501
7662d046 3502 ide_proc_register_driver(drive, &ide_cdrom_driver);
8604affd 3503
1da177e4
LT		 3504 kref_init(&info->kref);
3505
3506 info->drive = drive;
3507 info->driver = &ide_cdrom_driver;
3508 info->disk = g;
3509
3510 g->private_data = &info->driver;
3511
3512 drive->driver_data = info;
3513
1da177e4 3514 g->minors = 1;
1da177e4
LT		 3515 g->driverfs_dev = &drive->gendev;
3516 g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
3517 if (ide_cdrom_setup(drive)) {
7662d046 3518 ide_proc_unregister_driver(drive, &ide_cdrom_driver);
05017db3 3519 ide_cd_release(&info->kref);
1da177e4
LT		 3520 goto failed;
3521 }
1da177e4
LT		 3522
3523 cdrom_read_toc(drive, &sense);
3524 g->fops = &idecd_ops;
3525 g->flags |= GENHD_FL_REMOVABLE;
3526 add_disk(g);
3527 return 0;
3528
1da177e4
LT		 3529out_free_cd:
3530 kfree(info);
3531failed:
8604affd 3532 return -ENODEV;
1da177e4
LT		 3533}
3534
3535static void __exit ide_cdrom_exit(void)
3536{
8604affd 3537 driver_unregister(&ide_cdrom_driver.gen_driver);
1da177e4 3538}
17514e8a
BZ		 3539
3540static int __init ide_cdrom_init(void)
1da177e4 3541{
8604affd 3542 return driver_register(&ide_cdrom_driver.gen_driver);
1da177e4
LT		 3543}
3544
263756ec 3545MODULE_ALIAS("ide:*m-cdrom*");
1da177e4
LT		 3546module_init(ide_cdrom_init);
3547module_exit(ide_cdrom_exit);
3548MODULE_LICENSE("GPL");
kernel source for telekom puls (alcatel/mediatek)