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