projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[BLOCK] add @uptodate to end_that_request_last() and @error to rq_end_io_fn()
[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.
123 * 3.11 Apr 29, 1996 -- Patch from Heiko Eissfeldt <heiko@colossus.escape.de>
124 * to remove redundant verify_area calls.
125 * 3.12 May 7, 1996 -- Rudimentary changer support. Based on patches
126 * from Gerhard Zuber <zuber@berlin.snafu.de>.
127 * Let open succeed even if there's no loaded disc.
128 * 3.13 May 19, 1996 -- Fixes for changer code.
129 * 3.14 May 29, 1996 -- Add work-around for Vertos 600.
130 * (From Hennus Bergman <hennus@sky.ow.nl>.)
131 * 3.15 July 2, 1996 -- Added support for Sanyo 3 CD changers
132 * from Ben Galliart <bgallia@luc.edu> with
133 * special help from Jeff Lightfoot
134 * <jeffml@pobox.com>
135 * 3.15a July 9, 1996 -- Improved Sanyo 3 CD changer identification
136 * 3.16 Jul 28, 1996 -- Fix from Gadi to reduce kernel stack usage for ioctl.
137 * 3.17 Sep 17, 1996 -- Tweak audio reads for some drives.
138 * Start changing CDROMLOADFROMSLOT to CDROM_SELECT_DISC.
139 * 3.18 Oct 31, 1996 -- Added module and DMA support.
140 *
141 *
142 * 4.00 Nov 5, 1996 -- New ide-cd maintainer,
143 * Erik B. Andersen <andersee@debian.org>
144 * -- Newer Creative drives don't always set the error
145 * register correctly. Make sure we see media changes
146 * regardless.
147 * -- Integrate with generic cdrom driver.
148 * -- CDROMGETSPINDOWN and CDROMSETSPINDOWN ioctls, based on
149 * a patch from Ciro Cattuto <>.
150 * -- Call set_device_ro.
151 * -- Implement CDROMMECHANISMSTATUS and CDROMSLOTTABLE
152 * ioctls, based on patch by Erik Andersen
153 * -- Add some probes of drive capability during setup.
154 *
155 * 4.01 Nov 11, 1996 -- Split into ide-cd.c and ide-cd.h
156 * -- Removed CDROMMECHANISMSTATUS and CDROMSLOTTABLE
157 * ioctls in favor of a generalized approach
158 * using the generic cdrom driver.
159 * -- Fully integrated with the 2.1.X kernel.
160 * -- Other stuff that I forgot (lots of changes)
161 *
162 * 4.02 Dec 01, 1996 -- Applied patch from Gadi Oxman <gadio@netvision.net.il>
163 * to fix the drive door locking problems.
164 *
165 * 4.03 Dec 04, 1996 -- Added DSC overlap support.
166 * 4.04 Dec 29, 1996 -- Added CDROMREADRAW ioclt based on patch
167 * by Ales Makarov (xmakarov@sun.felk.cvut.cz)
168 *
169 * 4.05 Nov 20, 1997 -- Modified to print more drive info on init
170 * Minor other changes
171 * Fix errors on CDROMSTOP (If you have a "Dolphin",
172 * you must define IHAVEADOLPHIN)
173 * Added identifier so new Sanyo CD-changer works
174 * Better detection if door locking isn't supported
175 *
176 * 4.06 Dec 17, 1997 -- fixed endless "tray open" messages -ml
177 * 4.07 Dec 17, 1997 -- fallback to set pc->stat on "tray open"
178 * 4.08 Dec 18, 1997 -- spew less noise when tray is empty
179 * -- fix speed display for ACER 24X, 18X
180 * 4.09 Jan 04, 1998 -- fix handling of the last block so we return
181 * an end of file instead of an I/O error (Gadi)
182 * 4.10 Jan 24, 1998 -- fixed a bug so now changers can change to a new
183 * slot when there is no disc in the current slot.
184 * -- Fixed a memory leak where info->changer_info was
185 * malloc'ed but never free'd when closing the device.
186 * -- Cleaned up the global namespace a bit by making more
187 * functions static that should already have been.
188 * 4.11 Mar 12, 1998 -- Added support for the CDROM_SELECT_SPEED ioctl
189 * based on a patch for 2.0.33 by Jelle Foks
190 * <jelle@scintilla.utwente.nl>, a patch for 2.0.33
191 * by Toni Giorgino <toni@pcape2.pi.infn.it>, the SCSI
192 * version, and my own efforts. -erik
193 * -- Fixed a stupid bug which egcs was kind enough to
194 * inform me of where "Illegal mode for this track"
195 * was never returned due to a comparison on data
196 * types of limited range.
197 * 4.12 Mar 29, 1998 -- Fixed bug in CDROM_SELECT_SPEED so write speed is
198 * now set ionly for CD-R and CD-RW drives. I had
199 * removed this support because it produced errors.
200 * It produced errors _only_ for non-writers. duh.
201 * 4.13 May 05, 1998 -- Suppress useless "in progress of becoming ready"
202 * messages, since this is not an error.
203 * -- Change error messages to be const
204 * -- Remove a "\t" which looks ugly in the syslogs
205 * 4.14 July 17, 1998 -- Change to pointing to .ps version of ATAPI spec
206 * since the .pdf version doesn't seem to work...
207 * -- Updated the TODO list to something more current.
208 *
209 * 4.15 Aug 25, 1998 -- Updated ide-cd.h to respect mechine endianess,
210 * patch thanks to "Eddie C. Dost" <ecd@skynet.be>
211 *
212 * 4.50 Oct 19, 1998 -- New maintainers!
213 * Jens Axboe <axboe@image.dk>
214 * Chris Zwilling <chris@cloudnet.com>
215 *
216 * 4.51 Dec 23, 1998 -- Jens Axboe <axboe@image.dk>
217 * - ide_cdrom_reset enabled since the ide subsystem
218 * handles resets fine now. <axboe@image.dk>
219 * - Transfer size fix for Samsung CD-ROMs, thanks to
220 * "Ville Hallik" <ville.hallik@mail.ee>.
221 * - other minor stuff.
222 *
223 * 4.52 Jan 19, 1999 -- Jens Axboe <axboe@image.dk>
224 * - Detect DVD-ROM/RAM drives
225 *
226 * 4.53 Feb 22, 1999 - Include other model Samsung and one Goldstar
227 * drive in transfer size limit.
228 * - Fix the I/O error when doing eject without a medium
229 * loaded on some drives.
230 * - CDROMREADMODE2 is now implemented through
231 * CDROMREADRAW, since many drives don't support
232 * MODE2 (even though ATAPI 2.6 says they must).
233 * - Added ignore parameter to ide-cd (as a module), eg
234 * insmod ide-cd ignore='hda hdb'
235 * Useful when using ide-cd in conjunction with
236 * ide-scsi. TODO: non-modular way of doing the
237 * same.
238 *
239 * 4.54 Aug 5, 1999 - Support for MMC2 class commands through the generic
240 * packet interface to cdrom.c.
241 * - Unified audio ioctl support, most of it.
242 * - cleaned up various deprecated verify_area().
243 * - Added ide_cdrom_packet() as the interface for
244 * the Uniform generic_packet().
245 * - bunch of other stuff, will fill in logs later.
246 * - report 1 slot for non-changers, like the other
247 * cd-rom drivers. don't report select disc for
248 * non-changers as well.
249 * - mask out audio playing, if the device can't do it.
250 *
251 * 4.55 Sep 1, 1999 - Eliminated the rest of the audio ioctls, except
252 * for CDROMREADTOC[ENTRY|HEADER]. Some of the drivers
253 * use this independently of the actual audio handling.
254 * They will disappear later when I get the time to
255 * do it cleanly.
256 * - Minimize the TOC reading - only do it when we
257 * know a media change has occurred.
258 * - Moved all the CDROMREADx ioctls to the Uniform layer.
259 * - Heiko Eissfeldt <heiko@colossus.escape.de> supplied
260 * some fixes for CDI.
261 * - CD-ROM leaving door locked fix from Andries
262 * Brouwer <Andries.Brouwer@cwi.nl>
263 * - Erik Andersen <andersen@xmission.com> unified
264 * commands across the various drivers and how
265 * sense errors are handled.
266 *
267 * 4.56 Sep 12, 1999 - Removed changer support - it is now in the
268 * Uniform layer.
269 * - Added partition based multisession handling.
270 * - Mode sense and mode select moved to the
271 * Uniform layer.
272 * - Fixed a problem with WPI CDS-32X drive - it
273 * failed the capabilities
274 *
275 * 4.57 Apr 7, 2000 - Fixed sense reporting.
276 * - Fixed possible oops in ide_cdrom_get_last_session()
277 * - Fix locking mania and make ide_cdrom_reset relock
278 * - Stop spewing errors to log when magicdev polls with
279 * TEST_UNIT_READY on some drives.
280 * - Various fixes from Tobias Ringstrom:
281 * tray if it was locked prior to the reset.
282 * - cdrom_read_capacity returns one frame too little.
283 * - Fix real capacity reporting.
284 *
285 * 4.58 May 1, 2000 - Clean up ACER50 stuff.
286 * - Fix small problem with ide_cdrom_capacity
287 *
288 * 4.59 Aug 11, 2000 - Fix changer problem in cdrom_read_toc, we weren't
289 * correctly sensing a disc change.
290 * - Rearranged some code
291 * - Use extended sense on drives that support it for
292 * correctly reporting tray status -- from
293 * Michael D Johnson <johnsom@orst.edu>
294 * 4.60 Dec 17, 2003 - Add mt rainier support
295 * - Bump timeout for packet commands, matches sr
296 * - Odd stuff
297 * 4.61 Jan 22, 2004 - support hardware sector sizes other than 2kB,
298 * Pascal Schmidt <der.eremit@email.de>
299 *
300 *************************************************************************/
301
302#define IDECD_VERSION "4.61"
303
304#include <linux/config.h>
305#include <linux/module.h>
306#include <linux/types.h>
307#include <linux/kernel.h>
308#include <linux/delay.h>
309#include <linux/timer.h>
310#include <linux/slab.h>
311#include <linux/interrupt.h>
312#include <linux/errno.h>
313#include <linux/cdrom.h>
314#include <linux/ide.h>
315#include <linux/completion.h>
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
327static DECLARE_MUTEX(idecd_ref_sem);
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
338 down(&idecd_ref_sem);
339 cd = ide_cd_g(disk);
340 if (cd)
341 kref_get(&cd->kref);
342 up(&idecd_ref_sem);
343 return cd;
344}
345
346static void ide_cd_release(struct kref *);
347
348static void ide_cd_put(struct cdrom_info *cd)
349{
350 down(&idecd_ref_sem);
351 kref_put(&cd->kref, ide_cd_release);
352 up(&idecd_ref_sem);
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
375 if (!sense || !rq || (rq->flags & REQ_QUIET))
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)
397 log = 0;
398 break;
399 case UNIT_ATTENTION:
400 /*
401 * Make good and sure we've seen this potential media
402 * change. Some drives (i.e. Creative) fail to present
403 * the correct sense key in the error register.
404 */
405 cdrom_saw_media_change(drive);
406 break;
407 default:
408 log = 1;
409 break;
410 }
411 return log;
412}
413
414static
415void cdrom_analyze_sense_data(ide_drive_t *drive,
416 struct request *failed_command,
417 struct request_sense *sense)
418{
419 if (!cdrom_log_sense(drive, failed_command, sense))
420 return;
421
422 /*
423 * If a read toc is executed for a CD-R or CD-RW medium where
424 * the first toc has not been recorded yet, it will fail with
425 * 05/24/00 (which is a confusing error)
426 */
427 if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP)
428 if (sense->sense_key == 0x05 && sense->asc == 0x24)
429 return;
430
431#if VERBOSE_IDE_CD_ERRORS
432 {
433 int i;
70d1d47c 434 const char *s = "bad sense key!";
1da177e4
LT		 435 char buf[80];
436
437 printk ("ATAPI device %s:\n", drive->name);
438 if (sense->error_code==0x70)
439 printk(" Error: ");
440 else if (sense->error_code==0x71)
441 printk(" Deferred Error: ");
442 else if (sense->error_code == 0x7f)
443 printk(" Vendor-specific Error: ");
444 else
445 printk(" Unknown Error Type: ");
446
447 if (sense->sense_key < ARY_LEN(sense_key_texts))
448 s = sense_key_texts[sense->sense_key];
1da177e4
LT		 449
450 printk("%s -- (Sense key=0x%02x)\n", s, sense->sense_key);
451
452 if (sense->asc == 0x40) {
453 sprintf(buf, "Diagnostic failure on component 0x%02x",
454 sense->ascq);
455 s = buf;
456 } else {
457 int lo = 0, mid, hi = ARY_LEN(sense_data_texts);
458 unsigned long key = (sense->sense_key << 16);
459 key |= (sense->asc << 8);
460 if (!(sense->ascq >= 0x80 && sense->ascq <= 0xdd))
461 key |= sense->ascq;
462 s = NULL;
463
464 while (hi > lo) {
465 mid = (lo + hi) / 2;
466 if (sense_data_texts[mid].asc_ascq == key ||
467 sense_data_texts[mid].asc_ascq == (0xff0000|key)) {
468 s = sense_data_texts[mid].text;
469 break;
470 }
471 else if (sense_data_texts[mid].asc_ascq > key)
472 hi = mid;
473 else
474 lo = mid+1;
475 }
476 }
477
478 if (s == NULL) {
479 if (sense->asc > 0x80)
480 s = "(vendor-specific error)";
481 else
482 s = "(reserved error code)";
483 }
484
485 printk(KERN_ERR " %s -- (asc=0x%02x, ascq=0x%02x)\n",
486 s, sense->asc, sense->ascq);
487
488 if (failed_command != NULL) {
489
490 int lo=0, mid, hi= ARY_LEN (packet_command_texts);
491 s = NULL;
492
493 while (hi > lo) {
494 mid = (lo + hi) / 2;
495 if (packet_command_texts[mid].packet_command ==
496 failed_command->cmd[0]) {
497 s = packet_command_texts[mid].text;
498 break;
499 }
500 if (packet_command_texts[mid].packet_command >
501 failed_command->cmd[0])
502 hi = mid;
503 else
504 lo = mid+1;
505 }
506
507 printk (KERN_ERR " The failed \"%s\" packet command was: \n \"", s);
508 for (i=0; i<sizeof (failed_command->cmd); i++)
509 printk ("%02x ", failed_command->cmd[i]);
510 printk ("\"\n");
511 }
512
513 /* The SKSV bit specifies validity of the sense_key_specific
514 * in the next two commands. It is bit 7 of the first byte.
515 * In the case of NOT_READY, if SKSV is set the drive can
516 * give us nice ETA readings.
517 */
518 if (sense->sense_key == NOT_READY && (sense->sks[0] & 0x80)) {
519 int progress = (sense->sks[1] << 8 | sense->sks[2]) * 100;
520 printk(KERN_ERR " Command is %02d%% complete\n", progress / 0xffff);
521
522 }
523
524 if (sense->sense_key == ILLEGAL_REQUEST &&
525 (sense->sks[0] & 0x80) != 0) {
526 printk(KERN_ERR " Error in %s byte %d",
527 (sense->sks[0] & 0x40) != 0 ?
528 "command packet" : "command data",
529 (sense->sks[1] << 8) + sense->sks[2]);
530
531 if ((sense->sks[0] & 0x40) != 0)
532 printk (" bit %d", sense->sks[0] & 0x07);
533
534 printk ("\n");
535 }
536 }
537
538#else /* not VERBOSE_IDE_CD_ERRORS */
539
540 /* Suppress printing unit attention and `in progress of becoming ready'
541 errors when we're not being verbose. */
542
543 if (sense->sense_key == UNIT_ATTENTION ||
544 (sense->sense_key == NOT_READY && (sense->asc == 4 ||
545 sense->asc == 0x3a)))
546 return;
547
548 printk(KERN_ERR "%s: error code: 0x%02x sense_key: 0x%02x asc: 0x%02x ascq: 0x%02x\n",
549 drive->name,
550 sense->error_code, sense->sense_key,
551 sense->asc, sense->ascq);
552#endif /* not VERBOSE_IDE_CD_ERRORS */
553}
554
555/*
556 * Initialize a ide-cd packet command request
557 */
558static void cdrom_prepare_request(ide_drive_t *drive, struct request *rq)
559{
560 struct cdrom_info *cd = drive->driver_data;
561
562 ide_init_drive_cmd(rq);
563 rq->flags = REQ_PC;
564 rq->rq_disk = cd->disk;
565}
566
567static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense,
568 struct request *failed_command)
569{
570 struct cdrom_info *info = drive->driver_data;
571 struct request *rq = &info->request_sense_request;
572
573 if (sense == NULL)
574 sense = &info->sense_data;
575
576 /* stuff the sense request in front of our current request */
577 cdrom_prepare_request(drive, rq);
578
579 rq->data = sense;
580 rq->cmd[0] = GPCMD_REQUEST_SENSE;
581 rq->cmd[4] = rq->data_len = 18;
582
583 rq->flags = REQ_SENSE;
584
585 /* NOTE! Save the failed command in "rq->buffer" */
586 rq->buffer = (void *) failed_command;
587
588 (void) ide_do_drive_cmd(drive, rq, ide_preempt);
589}
590
591static void cdrom_end_request (ide_drive_t *drive, int uptodate)
592{
593 struct request *rq = HWGROUP(drive)->rq;
594 int nsectors = rq->hard_cur_sectors;
595
596 if ((rq->flags & REQ_SENSE) && uptodate) {
597 /*
598 * For REQ_SENSE, "rq->buffer" points to the original failed
599 * request
600 */
601 struct request *failed = (struct request *) rq->buffer;
602 struct cdrom_info *info = drive->driver_data;
603 void *sense = &info->sense_data;
604 unsigned long flags;
605
606 if (failed) {
607 if (failed->sense) {
608 sense = failed->sense;
609 failed->sense_len = rq->sense_len;
610 }
611
612 /*
613 * now end failed request
614 */
615 spin_lock_irqsave(&ide_lock, flags);
616 end_that_request_chunk(failed, 0, failed->data_len);
8ffdc655 617 end_that_request_last(failed, 0);
1da177e4
LT		 618 spin_unlock_irqrestore(&ide_lock, flags);
619 }
620
621 cdrom_analyze_sense_data(drive, failed, sense);
622 }
623
624 if (!rq->current_nr_sectors && blk_fs_request(rq))
625 uptodate = 1;
626 /* make sure it's fully ended */
627 if (blk_pc_request(rq))
628 nsectors = (rq->data_len + 511) >> 9;
629 if (!nsectors)
630 nsectors = 1;
631
632 ide_end_request(drive, uptodate, nsectors);
633}
634
635/* Returns 0 if the request should be continued.
636 Returns 1 if the request was ended. */
637static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
638{
639 struct request *rq = HWGROUP(drive)->rq;
640 int stat, err, sense_key;
641
642 /* Check for errors. */
643 stat = HWIF(drive)->INB(IDE_STATUS_REG);
644 if (stat_ret)
645 *stat_ret = stat;
646
647 if (OK_STAT(stat, good_stat, BAD_R_STAT))
648 return 0;
649
650 /* Get the IDE error register. */
651 err = HWIF(drive)->INB(IDE_ERROR_REG);
652 sense_key = err >> 4;
653
654 if (rq == NULL) {
655 printk("%s: missing rq in cdrom_decode_status\n", drive->name);
656 return 1;
657 }
658
659 if (rq->flags & REQ_SENSE) {
660 /* We got an error trying to get sense info
661 from the drive (probably while trying
662 to recover from a former error). Just give up. */
663
664 rq->flags |= REQ_FAILED;
665 cdrom_end_request(drive, 0);
666 ide_error(drive, "request sense failure", stat);
667 return 1;
668
669 } else if (rq->flags & (REQ_PC | REQ_BLOCK_PC)) {
670 /* All other functions, except for READ. */
671 unsigned long flags;
672
673 /*
674 * if we have an error, pass back CHECK_CONDITION as the
675 * scsi status byte
676 */
677 if ((rq->flags & REQ_BLOCK_PC) && !rq->errors)
678 rq->errors = SAM_STAT_CHECK_CONDITION;
679
680 /* Check for tray open. */
681 if (sense_key == NOT_READY) {
682 cdrom_saw_media_change (drive);
683 } else if (sense_key == UNIT_ATTENTION) {
684 /* Check for media change. */
685 cdrom_saw_media_change (drive);
686 /*printk("%s: media changed\n",drive->name);*/
687 return 0;
688 } else if (!(rq->flags & REQ_QUIET)) {
689 /* Otherwise, print an error. */
690 ide_dump_status(drive, "packet command error", stat);
691 }
692
693 rq->flags |= REQ_FAILED;
694
695 /*
696 * instead of playing games with moving completions around,
697 * remove failed request completely and end it when the
698 * request sense has completed
699 */
700 if (stat & ERR_STAT) {
701 spin_lock_irqsave(&ide_lock, flags);
702 blkdev_dequeue_request(rq);
703 HWGROUP(drive)->rq = NULL;
704 spin_unlock_irqrestore(&ide_lock, flags);
705
706 cdrom_queue_request_sense(drive, rq->sense, rq);
707 } else
708 cdrom_end_request(drive, 0);
709
710 } else if (blk_fs_request(rq)) {
711 int do_end_request = 0;
712
713 /* Handle errors from READ and WRITE requests. */
714
715 if (blk_noretry_request(rq))
716 do_end_request = 1;
717
718 if (sense_key == NOT_READY) {
719 /* Tray open. */
720 if (rq_data_dir(rq) == READ) {
721 cdrom_saw_media_change (drive);
722
723 /* Fail the request. */
724 printk ("%s: tray open\n", drive->name);
725 do_end_request = 1;
726 } else {
727 struct cdrom_info *info = drive->driver_data;
728
729 /* allow the drive 5 seconds to recover, some
730 * devices will return this error while flushing
731 * data from cache */
732 if (!rq->errors)
733 info->write_timeout = jiffies + ATAPI_WAIT_WRITE_BUSY;
734 rq->errors = 1;
735 if (time_after(jiffies, info->write_timeout))
736 do_end_request = 1;
737 else {
738 unsigned long flags;
739
740 /*
741 * take a breather relying on the
742 * unplug timer to kick us again
743 */
744 spin_lock_irqsave(&ide_lock, flags);
745 blk_plug_device(drive->queue);
746 spin_unlock_irqrestore(&ide_lock,flags);
747 return 1;
748 }
749 }
750 } else if (sense_key == UNIT_ATTENTION) {
751 /* Media change. */
752 cdrom_saw_media_change (drive);
753
754 /* Arrange to retry the request.
755 But be sure to give up if we've retried
756 too many times. */
757 if (++rq->errors > ERROR_MAX)
758 do_end_request = 1;
759 } else if (sense_key == ILLEGAL_REQUEST ||
760 sense_key == DATA_PROTECT) {
761 /* No point in retrying after an illegal
762 request or data protect error.*/
763 ide_dump_status (drive, "command error", stat);
764 do_end_request = 1;
765 } else if (sense_key == MEDIUM_ERROR) {
766 /* No point in re-trying a zillion times on a bad
767 * sector... If we got here the error is not correctable */
768 ide_dump_status (drive, "media error (bad sector)", stat);
769 do_end_request = 1;
770 } else if (sense_key == BLANK_CHECK) {
771 /* Disk appears blank ?? */
772 ide_dump_status (drive, "media error (blank)", stat);
773 do_end_request = 1;
774 } else if ((err & ~ABRT_ERR) != 0) {
775 /* Go to the default handler
776 for other errors. */
777 ide_error(drive, "cdrom_decode_status", stat);
778 return 1;
779 } else if ((++rq->errors > ERROR_MAX)) {
780 /* We've racked up too many retries. Abort. */
781 do_end_request = 1;
782 }
783
784 if (do_end_request)
785 cdrom_end_request(drive, 0);
786
787 /* If we got a CHECK_CONDITION status,
788 queue a request sense command. */
789 if ((stat & ERR_STAT) != 0)
790 cdrom_queue_request_sense(drive, NULL, NULL);
791 } else {
792 blk_dump_rq_flags(rq, "ide-cd: bad rq");
793 cdrom_end_request(drive, 0);
794 }
795
796 /* Retry, or handle the next request. */
797 return 1;
798}
799
800static int cdrom_timer_expiry(ide_drive_t *drive)
801{
802 struct request *rq = HWGROUP(drive)->rq;
803 unsigned long wait = 0;
804
805 /*
806 * Some commands are *slow* and normally take a long time to
807 * complete. Usually we can use the ATAPI "disconnect" to bypass
808 * this, but not all commands/drives support that. Let
809 * ide_timer_expiry keep polling us for these.
810 */
811 switch (rq->cmd[0]) {
812 case GPCMD_BLANK:
813 case GPCMD_FORMAT_UNIT:
814 case GPCMD_RESERVE_RZONE_TRACK:
815 case GPCMD_CLOSE_TRACK:
816 case GPCMD_FLUSH_CACHE:
817 wait = ATAPI_WAIT_PC;
818 break;
819 default:
820 if (!(rq->flags & REQ_QUIET))
821 printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n", rq->cmd[0]);
822 wait = 0;
823 break;
824 }
825 return wait;
826}
827
828/* Set up the device registers for transferring a packet command on DEV,
829 expecting to later transfer XFERLEN bytes. HANDLER is the routine
830 which actually transfers the command to the drive. If this is a
831 drq_interrupt device, this routine will arrange for HANDLER to be
832 called when the interrupt from the drive arrives. Otherwise, HANDLER
833 will be called immediately after the drive is prepared for the transfer. */
834
835static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
836 int xferlen,
837 ide_handler_t *handler)
838{
839 ide_startstop_t startstop;
840 struct cdrom_info *info = drive->driver_data;
841 ide_hwif_t *hwif = drive->hwif;
842
843 /* Wait for the controller to be idle. */
844 if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY))
845 return startstop;
846
847 if (info->dma)
848 info->dma = !hwif->dma_setup(drive);
849
850 /* Set up the controller registers. */
851 /* FIXME: for Virtual DMA we must check harder */
852 HWIF(drive)->OUTB(info->dma, IDE_FEATURE_REG);
853 HWIF(drive)->OUTB(0, IDE_IREASON_REG);
854 HWIF(drive)->OUTB(0, IDE_SECTOR_REG);
855
856 HWIF(drive)->OUTB(xferlen & 0xff, IDE_BCOUNTL_REG);
857 HWIF(drive)->OUTB(xferlen >> 8 , IDE_BCOUNTH_REG);
858 if (IDE_CONTROL_REG)
859 HWIF(drive)->OUTB(drive->ctl, IDE_CONTROL_REG);
860
861 if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt) {
862 /* packet command */
863 ide_execute_command(drive, WIN_PACKETCMD, handler, ATAPI_WAIT_PC, cdrom_timer_expiry);
864 return ide_started;
865 } else {
866 unsigned long flags;
867
868 /* packet command */
869 spin_lock_irqsave(&ide_lock, flags);
870 hwif->OUTBSYNC(drive, WIN_PACKETCMD, IDE_COMMAND_REG);
871 ndelay(400);
872 spin_unlock_irqrestore(&ide_lock, flags);
873
874 return (*handler) (drive);
875 }
876}
877
878/* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
879 The device registers must have already been prepared
880 by cdrom_start_packet_command.
881 HANDLER is the interrupt handler to call when the command completes
882 or there's data ready. */
883/*
884 * changed 5 parameters to 3 for dvd-ram
885 * struct packet_command *pc; now packet_command_t *pc;
886 */
887#define ATAPI_MIN_CDB_BYTES 12
888static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
889 struct request *rq,
890 ide_handler_t *handler)
891{
892 ide_hwif_t *hwif = drive->hwif;
893 int cmd_len;
894 struct cdrom_info *info = drive->driver_data;
895 ide_startstop_t startstop;
896
897 if (CDROM_CONFIG_FLAGS(drive)->drq_interrupt) {
898 /* Here we should have been called after receiving an interrupt
899 from the device. DRQ should how be set. */
900
901 /* Check for errors. */
902 if (cdrom_decode_status(drive, DRQ_STAT, NULL))
903 return ide_stopped;
904 } else {
905 /* Otherwise, we must wait for DRQ to get set. */
906 if (ide_wait_stat(&startstop, drive, DRQ_STAT,
907 BUSY_STAT, WAIT_READY))
908 return startstop;
909 }
910
911 /* Arm the interrupt handler. */
912 ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);
913
914 /* ATAPI commands get padded out to 12 bytes minimum */
915 cmd_len = COMMAND_SIZE(rq->cmd[0]);
916 if (cmd_len < ATAPI_MIN_CDB_BYTES)
917 cmd_len = ATAPI_MIN_CDB_BYTES;
918
919 /* Send the command to the device. */
920 HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len);
921
922 /* Start the DMA if need be */
923 if (info->dma)
924 hwif->dma_start(drive);
925
926 return ide_started;
927}
928
929/****************************************************************************
930 * Block read functions.
931 */
932
933/*
934 * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
935 * buffer. Once the first sector is added, any subsequent sectors are
936 * assumed to be continuous (until the buffer is cleared). For the first
937 * sector added, SECTOR is its sector number. (SECTOR is then ignored until
938 * the buffer is cleared.)
939 */
940static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
941 int sectors_to_transfer)
942{
943 struct cdrom_info *info = drive->driver_data;
944
945 /* Number of sectors to read into the buffer. */
946 int sectors_to_buffer = min_t(int, sectors_to_transfer,
947 (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
948 info->nsectors_buffered);
949
950 char *dest;
951
952 /* If we couldn't get a buffer, don't try to buffer anything... */
953 if (info->buffer == NULL)
954 sectors_to_buffer = 0;
955
956 /* If this is the first sector in the buffer, remember its number. */
957 if (info->nsectors_buffered == 0)
958 info->sector_buffered = sector;
959
960 /* Read the data into the buffer. */
961 dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
962 while (sectors_to_buffer > 0) {
963 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
964 --sectors_to_buffer;
965 --sectors_to_transfer;
966 ++info->nsectors_buffered;
967 dest += SECTOR_SIZE;
968 }
969
970 /* Throw away any remaining data. */
971 while (sectors_to_transfer > 0) {
972 static char dum[SECTOR_SIZE];
973 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
974 --sectors_to_transfer;
975 }
976}
977
978/*
979 * Check the contents of the interrupt reason register from the cdrom
980 * and attempt to recover if there are problems. Returns 0 if everything's
981 * ok; nonzero if the request has been terminated.
982 */
983static inline
984int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
985{
986 if (ireason == 2)
987 return 0;
988 else if (ireason == 0) {
989 /* Whoops... The drive is expecting to receive data from us! */
990 printk(KERN_ERR "%s: read_intr: Drive wants to transfer data the "
991 "wrong way!\n", drive->name);
992
993 /* Throw some data at the drive so it doesn't hang
994 and quit this request. */
995 while (len > 0) {
996 int dum = 0;
997 HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof (dum));
998 len -= sizeof (dum);
999 }
1000 } else if (ireason == 1) {
1001 /* Some drives (ASUS) seem to tell us that status
1002 * info is available. just get it and ignore.
1003 */
1004 (void) HWIF(drive)->INB(IDE_STATUS_REG);
1005 return 0;
1006 } else {
1007 /* Drive wants a command packet, or invalid ireason... */
1008 printk(KERN_ERR "%s: read_intr: bad interrupt reason %x\n", drive->name,
1009 ireason);
1010 }
1011
1012 cdrom_end_request(drive, 0);
1013 return -1;
1014}
1015
1016/*
1017 * Interrupt routine. Called when a read request has completed.
1018 */
1019static ide_startstop_t cdrom_read_intr (ide_drive_t *drive)
1020{
1021 int stat;
1022 int ireason, len, sectors_to_transfer, nskip;
1023 struct cdrom_info *info = drive->driver_data;
1024 u8 lowcyl = 0, highcyl = 0;
1025 int dma = info->dma, dma_error = 0;
1026
1027 struct request *rq = HWGROUP(drive)->rq;
1028
1029 /*
1030 * handle dma case
1031 */
1032 if (dma) {
1033 info->dma = 0;
1034 if ((dma_error = HWIF(drive)->ide_dma_end(drive)))
1035 __ide_dma_off(drive);
1036 }
1037
1038 if (cdrom_decode_status(drive, 0, &stat))
1039 return ide_stopped;
1040
1041 if (dma) {
1042 if (!dma_error) {
1043 ide_end_request(drive, 1, rq->nr_sectors);
1044 return ide_stopped;
1045 } else
1046 return ide_error(drive, "dma error", stat);
1047 }
1048
1049 /* Read the interrupt reason and the transfer length. */
1050 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1051 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1052 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1053
1054 len = lowcyl + (256 * highcyl);
1055
1056 /* If DRQ is clear, the command has completed. */
1057 if ((stat & DRQ_STAT) == 0) {
1058 /* If we're not done filling the current buffer, complain.
1059 Otherwise, complete the command normally. */
1060 if (rq->current_nr_sectors > 0) {
1061 printk (KERN_ERR "%s: cdrom_read_intr: data underrun (%d blocks)\n",
1062 drive->name, rq->current_nr_sectors);
1063 rq->flags |= REQ_FAILED;
1064 cdrom_end_request(drive, 0);
1065 } else
1066 cdrom_end_request(drive, 1);
1067 return ide_stopped;
1068 }
1069
1070 /* Check that the drive is expecting to do the same thing we are. */
1071 if (cdrom_read_check_ireason (drive, len, ireason))
1072 return ide_stopped;
1073
1074 /* Assume that the drive will always provide data in multiples
1075 of at least SECTOR_SIZE, as it gets hairy to keep track
1076 of the transfers otherwise. */
1077 if ((len % SECTOR_SIZE) != 0) {
1078 printk (KERN_ERR "%s: cdrom_read_intr: Bad transfer size %d\n",
1079 drive->name, len);
1080 if (CDROM_CONFIG_FLAGS(drive)->limit_nframes)
1081 printk (KERN_ERR " This drive is not supported by this version of the driver\n");
1082 else {
1083 printk (KERN_ERR " Trying to limit transfer sizes\n");
1084 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
1085 }
1086 cdrom_end_request(drive, 0);
1087 return ide_stopped;
1088 }
1089
1090 /* The number of sectors we need to read from the drive. */
1091 sectors_to_transfer = len / SECTOR_SIZE;
1092
1093 /* First, figure out if we need to bit-bucket
1094 any of the leading sectors. */
1095 nskip = min_t(int, rq->current_nr_sectors - bio_cur_sectors(rq->bio), sectors_to_transfer);
1096
1097 while (nskip > 0) {
1098 /* We need to throw away a sector. */
1099 static char dum[SECTOR_SIZE];
1100 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1101
1102 --rq->current_nr_sectors;
1103 --nskip;
1104 --sectors_to_transfer;
1105 }
1106
1107 /* Now loop while we still have data to read from the drive. */
1108 while (sectors_to_transfer > 0) {
1109 int this_transfer;
1110
1111 /* If we've filled the present buffer but there's another
1112 chained buffer after it, move on. */
1113 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1114 cdrom_end_request(drive, 1);
1115
1116 /* If the buffers are full, cache the rest of the data in our
1117 internal buffer. */
1118 if (rq->current_nr_sectors == 0) {
1119 cdrom_buffer_sectors(drive, rq->sector, sectors_to_transfer);
1120 sectors_to_transfer = 0;
1121 } else {
1122 /* Transfer data to the buffers.
1123 Figure out how many sectors we can transfer
1124 to the current buffer. */
1125 this_transfer = min_t(int, sectors_to_transfer,
1126 rq->current_nr_sectors);
1127
1128 /* Read this_transfer sectors
1129 into the current buffer. */
1130 while (this_transfer > 0) {
1131 HWIF(drive)->atapi_input_bytes(drive, rq->buffer, SECTOR_SIZE);
1132 rq->buffer += SECTOR_SIZE;
1133 --rq->nr_sectors;
1134 --rq->current_nr_sectors;
1135 ++rq->sector;
1136 --this_transfer;
1137 --sectors_to_transfer;
1138 }
1139 }
1140 }
1141
1142 /* Done moving data! Wait for another interrupt. */
1143 ide_set_handler(drive, &cdrom_read_intr, ATAPI_WAIT_PC, NULL);
1144 return ide_started;
1145}
1146
1147/*
1148 * Try to satisfy some of the current read request from our cached data.
1149 * Returns nonzero if the request has been completed, zero otherwise.
1150 */
1151static int cdrom_read_from_buffer (ide_drive_t *drive)
1152{
1153 struct cdrom_info *info = drive->driver_data;
1154 struct request *rq = HWGROUP(drive)->rq;
1155 unsigned short sectors_per_frame;
1156
1157 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1158
1159 /* Can't do anything if there's no buffer. */
1160 if (info->buffer == NULL) return 0;
1161
1162 /* Loop while this request needs data and the next block is present
1163 in our cache. */
1164 while (rq->nr_sectors > 0 &&
1165 rq->sector >= info->sector_buffered &&
1166 rq->sector < info->sector_buffered + info->nsectors_buffered) {
1167 if (rq->current_nr_sectors == 0)
1168 cdrom_end_request(drive, 1);
1169
1170 memcpy (rq->buffer,
1171 info->buffer +
1172 (rq->sector - info->sector_buffered) * SECTOR_SIZE,
1173 SECTOR_SIZE);
1174 rq->buffer += SECTOR_SIZE;
1175 --rq->current_nr_sectors;
1176 --rq->nr_sectors;
1177 ++rq->sector;
1178 }
1179
1180 /* If we've satisfied the current request,
1181 terminate it successfully. */
1182 if (rq->nr_sectors == 0) {
1183 cdrom_end_request(drive, 1);
1184 return -1;
1185 }
1186
1187 /* Move on to the next buffer if needed. */
1188 if (rq->current_nr_sectors == 0)
1189 cdrom_end_request(drive, 1);
1190
1191 /* If this condition does not hold, then the kluge i use to
1192 represent the number of sectors to skip at the start of a transfer
1193 will fail. I think that this will never happen, but let's be
1194 paranoid and check. */
1195 if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
1196 (rq->sector & (sectors_per_frame - 1))) {
1197 printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
1198 drive->name, (long)rq->sector);
1199 cdrom_end_request(drive, 0);
1200 return -1;
1201 }
1202
1203 return 0;
1204}
1205
1206/*
1207 * Routine to send a read packet command to the drive.
1208 * This is usually called directly from cdrom_start_read.
1209 * However, for drq_interrupt devices, it is called from an interrupt
1210 * when the drive is ready to accept the command.
1211 */
1212static ide_startstop_t cdrom_start_read_continuation (ide_drive_t *drive)
1213{
1214 struct request *rq = HWGROUP(drive)->rq;
1215 unsigned short sectors_per_frame;
1216 int nskip;
1217
1218 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1219
1220 /* If the requested sector doesn't start on a cdrom block boundary,
1221 we must adjust the start of the transfer so that it does,
1222 and remember to skip the first few sectors.
1223 If the CURRENT_NR_SECTORS field is larger than the size
1224 of the buffer, it will mean that we're to skip a number
1225 of sectors equal to the amount by which CURRENT_NR_SECTORS
1226 is larger than the buffer size. */
1227 nskip = rq->sector & (sectors_per_frame - 1);
1228 if (nskip > 0) {
1229 /* Sanity check... */
1230 if (rq->current_nr_sectors != bio_cur_sectors(rq->bio) &&
1231 (rq->sector & (sectors_per_frame - 1))) {
1232 printk(KERN_ERR "%s: cdrom_start_read_continuation: buffer botch (%u)\n",
1233 drive->name, rq->current_nr_sectors);
1234 cdrom_end_request(drive, 0);
1235 return ide_stopped;
1236 }
1237 rq->current_nr_sectors += nskip;
1238 }
1239
1240 /* Set up the command */
1241 rq->timeout = ATAPI_WAIT_PC;
1242
1243 /* Send the command to the drive and return. */
1244 return cdrom_transfer_packet_command(drive, rq, &cdrom_read_intr);
1245}
1246
1247
1248#define IDECD_SEEK_THRESHOLD (1000) /* 1000 blocks */
1249#define IDECD_SEEK_TIMER (5 * WAIT_MIN_SLEEP) /* 100 ms */
1250#define IDECD_SEEK_TIMEOUT (2 * WAIT_CMD) /* 20 sec */
1251
1252static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
1253{
1254 struct cdrom_info *info = drive->driver_data;
1255 int stat;
1256 static int retry = 10;
1257
1258 if (cdrom_decode_status(drive, 0, &stat))
1259 return ide_stopped;
1260 CDROM_CONFIG_FLAGS(drive)->seeking = 1;
1261
1262 if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
1263 if (--retry == 0) {
1264 /*
1265 * this condition is far too common, to bother
1266 * users about it
1267 */
1268 /* printk("%s: disabled DSC seek overlap\n", drive->name);*/
1269 drive->dsc_overlap = 0;
1270 }
1271 }
1272 return ide_stopped;
1273}
1274
1275static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
1276{
1277 struct request *rq = HWGROUP(drive)->rq;
1278 sector_t frame = rq->sector;
1279
1280 sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
1281
1282 memset(rq->cmd, 0, sizeof(rq->cmd));
1283 rq->cmd[0] = GPCMD_SEEK;
1284 put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
1285
1286 rq->timeout = ATAPI_WAIT_PC;
1287 return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
1288}
1289
1290static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
1291{
1292 struct cdrom_info *info = drive->driver_data;
1293
1294 info->dma = 0;
1da177e4
LT		 1295 info->start_seek = jiffies;
1296 return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
1297}
1298
1299/* Fix up a possibly partially-processed request so that we can
1300 start it over entirely, or even put it back on the request queue. */
1301static void restore_request (struct request *rq)
1302{
1303 if (rq->buffer != bio_data(rq->bio)) {
1304 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
1305
1306 rq->buffer = bio_data(rq->bio);
1307 rq->nr_sectors += n;
1308 rq->sector -= n;
1309 }
1310 rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
1311 rq->hard_nr_sectors = rq->nr_sectors;
1312 rq->hard_sector = rq->sector;
1313 rq->q->prep_rq_fn(rq->q, rq);
1314}
1315
1316/*
1317 * Start a read request from the CD-ROM.
1318 */
1319static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block)
1320{
1321 struct cdrom_info *info = drive->driver_data;
1322 struct request *rq = HWGROUP(drive)->rq;
1323 unsigned short sectors_per_frame;
1324
1325 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1326
1327 /* We may be retrying this request after an error. Fix up
1328 any weirdness which might be present in the request packet. */
1329 restore_request(rq);
1330
1331 /* Satisfy whatever we can of this request from our cached sector. */
1332 if (cdrom_read_from_buffer(drive))
1333 return ide_stopped;
1334
1335 blk_attempt_remerge(drive->queue, rq);
1336
1337 /* Clear the local sector buffer. */
1338 info->nsectors_buffered = 0;
1339
1340 /* use dma, if possible. */
1341 info->dma = drive->using_dma;
1342 if ((rq->sector & (sectors_per_frame - 1)) ||
1343 (rq->nr_sectors & (sectors_per_frame - 1)))
1344 info->dma = 0;
1345
1da177e4
LT		 1346 /* Start sending the read request to the drive. */
1347 return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
1348}
1349
1350/****************************************************************************
1351 * Execute all other packet commands.
1352 */
1353
1354/* Interrupt routine for packet command completion. */
1355static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
1356{
1357 int ireason, len, thislen;
1358 struct request *rq = HWGROUP(drive)->rq;
1359 u8 lowcyl = 0, highcyl = 0;
1360 int stat;
1361
1362 /* Check for errors. */
1363 if (cdrom_decode_status(drive, 0, &stat))
1364 return ide_stopped;
1365
1366 /* Read the interrupt reason and the transfer length. */
1367 ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1368 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1369 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1370
1371 len = lowcyl + (256 * highcyl);
1372
1373 /* If DRQ is clear, the command has completed.
1374 Complain if we still have data left to transfer. */
1375 if ((stat & DRQ_STAT) == 0) {
1376 /* Some of the trailing request sense fields are optional, and
1377 some drives don't send them. Sigh. */
1378 if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
1379 rq->data_len > 0 &&
1380 rq->data_len <= 5) {
1381 while (rq->data_len > 0) {
1382 *(unsigned char *)rq->data++ = 0;
1383 --rq->data_len;
1384 }
1385 }
1386
1387 if (rq->data_len == 0)
1388 cdrom_end_request(drive, 1);
1389 else {
1390 /* Comment this out, because this always happens
1391 right after a reset occurs, and it is annoying to
1392 always print expected stuff. */
1393 /*
1394 printk ("%s: cdrom_pc_intr: data underrun %d\n",
1395 drive->name, pc->buflen);
1396 */
1397 rq->flags |= REQ_FAILED;
1398 cdrom_end_request(drive, 0);
1399 }
1400 return ide_stopped;
1401 }
1402
1403 /* Figure out how much data to transfer. */
1404 thislen = rq->data_len;
1405 if (thislen > len) thislen = len;
1406
1407 /* The drive wants to be written to. */
1408 if ((ireason & 3) == 0) {
1409 if (!rq->data) {
1410 blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1411 goto confused;
1412 }
1413 /* Transfer the data. */
1414 HWIF(drive)->atapi_output_bytes(drive, rq->data, thislen);
1415
1416 /* If we haven't moved enough data to satisfy the drive,
1417 add some padding. */
1418 while (len > thislen) {
1419 int dum = 0;
1420 HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof(dum));
1421 len -= sizeof(dum);
1422 }
1423
1424 /* Keep count of how much data we've moved. */
1425 rq->data += thislen;
1426 rq->data_len -= thislen;
1427 }
1428
1429 /* Same drill for reading. */
1430 else if ((ireason & 3) == 2) {
1431 if (!rq->data) {
1432 blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1433 goto confused;
1434 }
1435 /* Transfer the data. */
1436 HWIF(drive)->atapi_input_bytes(drive, rq->data, thislen);
1437
1438 /* If we haven't moved enough data to satisfy the drive,
1439 add some padding. */
1440 while (len > thislen) {
1441 int dum = 0;
1442 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1443 len -= sizeof(dum);
1444 }
1445
1446 /* Keep count of how much data we've moved. */
1447 rq->data += thislen;
1448 rq->data_len -= thislen;
1449
1450 if (rq->flags & REQ_SENSE)
1451 rq->sense_len += thislen;
1452 } else {
1453confused:
1454 printk (KERN_ERR "%s: cdrom_pc_intr: The drive "
1455 "appears confused (ireason = 0x%02x)\n",
1456 drive->name, ireason);
1457 rq->flags |= REQ_FAILED;
1458 }
1459
1460 /* Now we wait for another interrupt. */
1461 ide_set_handler(drive, &cdrom_pc_intr, ATAPI_WAIT_PC, cdrom_timer_expiry);
1462 return ide_started;
1463}
1464
1465static ide_startstop_t cdrom_do_pc_continuation (ide_drive_t *drive)
1466{
1467 struct request *rq = HWGROUP(drive)->rq;
1468
1469 if (!rq->timeout)
1470 rq->timeout = ATAPI_WAIT_PC;
1471
1472 /* Send the command to the drive and return. */
1473 return cdrom_transfer_packet_command(drive, rq, &cdrom_pc_intr);
1474}
1475
1476
1477static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
1478{
1479 int len;
1480 struct request *rq = HWGROUP(drive)->rq;
1481 struct cdrom_info *info = drive->driver_data;
1482
1483 info->dma = 0;
1da177e4
LT		 1484 rq->flags &= ~REQ_FAILED;
1485 len = rq->data_len;
1486
1487 /* Start sending the command to the drive. */
1488 return cdrom_start_packet_command(drive, len, cdrom_do_pc_continuation);
1489}
1490
1491
1492static
1493int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
1494{
1495 struct request_sense sense;
1496 int retries = 10;
1497 unsigned int flags = rq->flags;
1498
1499 if (rq->sense == NULL)
1500 rq->sense = &sense;
1501
1502 /* Start of retry loop. */
1503 do {
1504 int error;
1505 unsigned long time = jiffies;
1506 rq->flags = flags;
1507
1508 error = ide_do_drive_cmd(drive, rq, ide_wait);
1509 time = jiffies - time;
1510
1511 /* FIXME: we should probably abort/retry or something
1512 * in case of failure */
1513 if (rq->flags & REQ_FAILED) {
1514 /* The request failed. Retry if it was due to a unit
1515 attention status
1516 (usually means media was changed). */
1517 struct request_sense *reqbuf = rq->sense;
1518
1519 if (reqbuf->sense_key == UNIT_ATTENTION)
1520 cdrom_saw_media_change(drive);
1521 else if (reqbuf->sense_key == NOT_READY &&
1522 reqbuf->asc == 4 && reqbuf->ascq != 4) {
1523 /* The drive is in the process of loading
1524 a disk. Retry, but wait a little to give
1525 the drive time to complete the load. */
1526 ssleep(2);
1527 } else {
1528 /* Otherwise, don't retry. */
1529 retries = 0;
1530 }
1531 --retries;
1532 }
1533
1534 /* End of retry loop. */
1535 } while ((rq->flags & REQ_FAILED) && retries >= 0);
1536
1537 /* Return an error if the command failed. */
1538 return (rq->flags & REQ_FAILED) ? -EIO : 0;
1539}
1540
1541/*
1542 * Write handling
1543 */
1544static inline int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
1545{
1546 /* Two notes about IDE interrupt reason here - 0 means that
1547 * the drive wants to receive data from us, 2 means that
1548 * the drive is expecting to transfer data to us.
1549 */
1550 if (ireason == 0)
1551 return 0;
1552 else if (ireason == 2) {
1553 /* Whoops... The drive wants to send data. */
1554 printk(KERN_ERR "%s: write_intr: wrong transfer direction!\n",
1555 drive->name);
1556
1557 while (len > 0) {
1558 int dum = 0;
1559 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1560 len -= sizeof(dum);
1561 }
1562 } else {
1563 /* Drive wants a command packet, or invalid ireason... */
1564 printk(KERN_ERR "%s: write_intr: bad interrupt reason %x\n",
1565 drive->name, ireason);
1566 }
1567
1568 cdrom_end_request(drive, 0);
1569 return 1;
1570}
1571
1572static void post_transform_command(struct request *req)
1573{
1574 u8 *c = req->cmd;
1575 char *ibuf;
1576
1577 if (!blk_pc_request(req))
1578 return;
1579
1580 if (req->bio)
1581 ibuf = bio_data(req->bio);
1582 else
1583 ibuf = req->data;
1584
1585 if (!ibuf)
1586 return;
1587
1588 /*
1589 * set ansi-revision and response data as atapi
1590 */
1591 if (c[0] == GPCMD_INQUIRY) {
1592 ibuf[2] |= 2;
1593 ibuf[3] = (ibuf[3] & 0xf0) | 2;
1594 }
1595}
1596
1597typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
1598
1599/*
1600 * best way to deal with dma that is not sector aligned right now... note
1601 * that in this path we are not using ->data or ->buffer at all. this irs
1602 * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the
1603 * future.
1604 */
1605static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1606{
1607 struct cdrom_info *info = drive->driver_data;
1608 struct request *rq = HWGROUP(drive)->rq;
1609 int dma_error, dma, stat, ireason, len, thislen;
1610 u8 lowcyl, highcyl;
1611 xfer_func_t *xferfunc;
1612 unsigned long flags;
1613
1614 /* Check for errors. */
1615 dma_error = 0;
1616 dma = info->dma;
1617 if (dma) {
1618 info->dma = 0;
1619 dma_error = HWIF(drive)->ide_dma_end(drive);
1620 }
1621
1622 if (cdrom_decode_status(drive, 0, &stat))
1623 return ide_stopped;
1624
1625 /*
1626 * using dma, transfer is complete now
1627 */
1628 if (dma) {
1629 if (dma_error) {
1630 printk(KERN_ERR "ide-cd: dma error\n");
1631 __ide_dma_off(drive);
1632 return ide_error(drive, "dma error", stat);
1633 }
1634
1635 end_that_request_chunk(rq, 1, rq->data_len);
1636 rq->data_len = 0;
1637 goto end_request;
1638 }
1639
1640 /*
1641 * ok we fall to pio :/
1642 */
1643 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1644 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1645 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1646
1647 len = lowcyl + (256 * highcyl);
1648 thislen = rq->data_len;
1649 if (thislen > len)
1650 thislen = len;
1651
1652 /*
1653 * If DRQ is clear, the command has completed.
1654 */
1655 if ((stat & DRQ_STAT) == 0)
1656 goto end_request;
1657
1658 /*
1659 * check which way to transfer data
1660 */
1661 if (rq_data_dir(rq) == WRITE) {
1662 /*
1663 * write to drive
1664 */
1665 if (cdrom_write_check_ireason(drive, len, ireason))
1666 return ide_stopped;
1667
1668 xferfunc = HWIF(drive)->atapi_output_bytes;
1669 } else {
1670 /*
1671 * read from drive
1672 */
1673 if (cdrom_read_check_ireason(drive, len, ireason))
1674 return ide_stopped;
1675
1676 xferfunc = HWIF(drive)->atapi_input_bytes;
1677 }
1678
1679 /*
1680 * transfer data
1681 */
1682 while (thislen > 0) {
1683 int blen = blen = rq->data_len;
1684 char *ptr = rq->data;
1685
1686 /*
1687 * bio backed?
1688 */
1689 if (rq->bio) {
1690 ptr = bio_data(rq->bio);
1691 blen = bio_iovec(rq->bio)->bv_len;
1692 }
1693
1694 if (!ptr) {
1695 printk(KERN_ERR "%s: confused, missing data\n", drive->name);
1696 break;
1697 }
1698
1699 if (blen > thislen)
1700 blen = thislen;
1701
1702 xferfunc(drive, ptr, blen);
1703
1704 thislen -= blen;
1705 len -= blen;
1706 rq->data_len -= blen;
1707
1708 if (rq->bio)
1709 end_that_request_chunk(rq, 1, blen);
1710 else
1711 rq->data += blen;
1712 }
1713
1714 /*
1715 * pad, if necessary
1716 */
1717 if (len > 0) {
1718 while (len > 0) {
1719 int pad = 0;
1720
1721 xferfunc(drive, &pad, sizeof(pad));
1722 len -= sizeof(pad);
1723 }
1724 }
1725
1726 if (HWGROUP(drive)->handler != NULL)
1727 BUG();
1728
1729 ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, NULL);
1730 return ide_started;
1731
1732end_request:
1733 if (!rq->data_len)
1734 post_transform_command(rq);
1735
1736 spin_lock_irqsave(&ide_lock, flags);
1737 blkdev_dequeue_request(rq);
8ffdc655 1738 end_that_request_last(rq, 1);
1da177e4
LT		 1739 HWGROUP(drive)->rq = NULL;
1740 spin_unlock_irqrestore(&ide_lock, flags);
1741 return ide_stopped;
1742}
1743
1744static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
1745{
1746 int stat, ireason, len, sectors_to_transfer, uptodate;
1747 struct cdrom_info *info = drive->driver_data;
1748 int dma_error = 0, dma = info->dma;
1749 u8 lowcyl = 0, highcyl = 0;
1750
1751 struct request *rq = HWGROUP(drive)->rq;
1752
1753 /* Check for errors. */
1754 if (dma) {
1755 info->dma = 0;
1756 if ((dma_error = HWIF(drive)->ide_dma_end(drive))) {
1757 printk(KERN_ERR "ide-cd: write dma error\n");
1758 __ide_dma_off(drive);
1759 }
1760 }
1761
1762 if (cdrom_decode_status(drive, 0, &stat))
1763 return ide_stopped;
1764
1765 /*
1766 * using dma, transfer is complete now
1767 */
1768 if (dma) {
1769 if (dma_error)
1770 return ide_error(drive, "dma error", stat);
1771
1772 ide_end_request(drive, 1, rq->nr_sectors);
1773 return ide_stopped;
1774 }
1775
1776 /* Read the interrupt reason and the transfer length. */
1777 ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1778 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1779 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1780
1781 len = lowcyl + (256 * highcyl);
1782
1783 /* If DRQ is clear, the command has completed. */
1784 if ((stat & DRQ_STAT) == 0) {
1785 /* If we're not done writing, complain.
1786 * Otherwise, complete the command normally.
1787 */
1788 uptodate = 1;
1789 if (rq->current_nr_sectors > 0) {
1790 printk(KERN_ERR "%s: write_intr: data underrun (%d blocks)\n",
1791 drive->name, rq->current_nr_sectors);
1792 uptodate = 0;
1793 }
1794 cdrom_end_request(drive, uptodate);
1795 return ide_stopped;
1796 }
1797
1798 /* Check that the drive is expecting to do the same thing we are. */
1799 if (cdrom_write_check_ireason(drive, len, ireason))
1800 return ide_stopped;
1801
1802 sectors_to_transfer = len / SECTOR_SIZE;
1803
1804 /*
1805 * now loop and write out the data
1806 */
1807 while (sectors_to_transfer > 0) {
1808 int this_transfer;
1809
1810 if (!rq->current_nr_sectors) {
1811 printk(KERN_ERR "ide-cd: write_intr: oops\n");
1812 break;
1813 }
1814
1815 /*
1816 * Figure out how many sectors we can transfer
1817 */
1818 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors);
1819
1820 while (this_transfer > 0) {
1821 HWIF(drive)->atapi_output_bytes(drive, rq->buffer, SECTOR_SIZE);
1822 rq->buffer += SECTOR_SIZE;
1823 --rq->nr_sectors;
1824 --rq->current_nr_sectors;
1825 ++rq->sector;
1826 --this_transfer;
1827 --sectors_to_transfer;
1828 }
1829
1830 /*
1831 * current buffer complete, move on
1832 */
1833 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1834 cdrom_end_request(drive, 1);
1835 }
1836
1837 /* re-arm handler */
1838 ide_set_handler(drive, &cdrom_write_intr, ATAPI_WAIT_PC, NULL);
1839 return ide_started;
1840}
1841
1842static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
1843{
1844 struct request *rq = HWGROUP(drive)->rq;
1845
1846#if 0 /* the immediate bit */
1847 rq->cmd[1] = 1 << 3;
1848#endif
1849 rq->timeout = ATAPI_WAIT_PC;
1850
1851 return cdrom_transfer_packet_command(drive, rq, cdrom_write_intr);
1852}
1853
1854static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
1855{
1856 struct cdrom_info *info = drive->driver_data;
1857 struct gendisk *g = info->disk;
1858 unsigned short sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1859
1860 /*
1861 * writes *must* be hardware frame aligned
1862 */
1863 if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1864 (rq->sector & (sectors_per_frame - 1))) {
1865 cdrom_end_request(drive, 0);
1866 return ide_stopped;
1867 }
1868
1869 /*
1870 * disk has become write protected
1871 */
1872 if (g->policy) {
1873 cdrom_end_request(drive, 0);
1874 return ide_stopped;
1875 }
1876
1877 /*
1878 * for dvd-ram and such media, it's a really big deal to get
1879 * big writes all the time. so scour the queue and attempt to
1880 * remerge requests, often the plugging will not have had time
1881 * to do this properly
1882 */
1883 blk_attempt_remerge(drive->queue, rq);
1884
1885 info->nsectors_buffered = 0;
1886
1887 /* use dma, if possible. we don't need to check more, since we
1888 * know that the transfer is always (at least!) frame aligned */
1889 info->dma = drive->using_dma ? 1 : 0;
1da177e4
LT		 1890
1891 info->devinfo.media_written = 1;
1892
1893 /* Start sending the write request to the drive. */
1894 return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
1895}
1896
1897static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1898{
1899 struct request *rq = HWGROUP(drive)->rq;
1900
1901 if (!rq->timeout)
1902 rq->timeout = ATAPI_WAIT_PC;
1903
1904 return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1905}
1906
1907static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1908{
1909 struct cdrom_info *info = drive->driver_data;
1910
1911 rq->flags |= REQ_QUIET;
1912
1913 info->dma = 0;
1da177e4
LT		 1914
1915 /*
1916 * sg request
1917 */
1918 if (rq->bio) {
1919 int mask = drive->queue->dma_alignment;
1920 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
1921
1da177e4
LT		 1922 info->dma = drive->using_dma;
1923
1924 /*
1925 * check if dma is safe
5d9e4ea5
LT		 1926 *
1927 * NOTE! The "len" and "addr" checks should possibly have
1928 * separate masks.
1da177e4 1929 */
4e7c6816 1930 if ((rq->data_len & 15) || (addr & mask))
1da177e4
LT		 1931 info->dma = 0;
1932 }
1933
1934 /* Start sending the command to the drive. */
1935 return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1936}
1937
1938/****************************************************************************
1939 * cdrom driver request routine.
1940 */
1941static ide_startstop_t
1942ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1943{
1944 ide_startstop_t action;
1945 struct cdrom_info *info = drive->driver_data;
1946
1947 if (blk_fs_request(rq)) {
1948 if (CDROM_CONFIG_FLAGS(drive)->seeking) {
1949 unsigned long elapsed = jiffies - info->start_seek;
1950 int stat = HWIF(drive)->INB(IDE_STATUS_REG);
1951
1952 if ((stat & SEEK_STAT) != SEEK_STAT) {
1953 if (elapsed < IDECD_SEEK_TIMEOUT) {
1954 ide_stall_queue(drive, IDECD_SEEK_TIMER);
1955 return ide_stopped;
1956 }
1957 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
1958 }
1959 CDROM_CONFIG_FLAGS(drive)->seeking = 0;
1960 }
1961 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
1962 action = cdrom_start_seek(drive, block);
1963 } else {
1964 if (rq_data_dir(rq) == READ)
1965 action = cdrom_start_read(drive, block);
1966 else
1967 action = cdrom_start_write(drive, rq);
1968 }
1969 info->last_block = block;
1970 return action;
1971 } else if (rq->flags & (REQ_PC | REQ_SENSE)) {
1972 return cdrom_do_packet_command(drive);
1973 } else if (rq->flags & REQ_BLOCK_PC) {
1974 return cdrom_do_block_pc(drive, rq);
1975 } else if (rq->flags & REQ_SPECIAL) {
1976 /*
1977 * right now this can only be a reset...
1978 */
1979 cdrom_end_request(drive, 1);
1980 return ide_stopped;
1981 }
1982
1983 blk_dump_rq_flags(rq, "ide-cd bad flags");
1984 cdrom_end_request(drive, 0);
1985 return ide_stopped;
1986}
1987
1988
1989
1990/****************************************************************************
1991 * Ioctl handling.
1992 *
1993 * Routines which queue packet commands take as a final argument a pointer
1994 * to a request_sense struct. If execution of the command results
1995 * in an error with a CHECK CONDITION status, this structure will be filled
1996 * with the results of the subsequent request sense command. The pointer
1997 * can also be NULL, in which case no sense information is returned.
1998 */
1999
2000#if ! STANDARD_ATAPI
2001static inline
2002int bin2bcd (int x)
2003{
2004 return (x%10) | ((x/10) << 4);
2005}
2006
2007
2008static inline
2009int bcd2bin (int x)
2010{
2011 return (x >> 4) * 10 + (x & 0x0f);
2012}
2013
2014static
2015void msf_from_bcd (struct atapi_msf *msf)
2016{
2017 msf->minute = bcd2bin (msf->minute);
2018 msf->second = bcd2bin (msf->second);
2019 msf->frame = bcd2bin (msf->frame);
2020}
2021
2022#endif /* not STANDARD_ATAPI */
2023
2024
2025static inline
2026void lba_to_msf (int lba, byte *m, byte *s, byte *f)
2027{
2028 lba += CD_MSF_OFFSET;
2029 lba &= 0xffffff; /* negative lbas use only 24 bits */
2030 *m = lba / (CD_SECS * CD_FRAMES);
2031 lba %= (CD_SECS * CD_FRAMES);
2032 *s = lba / CD_FRAMES;
2033 *f = lba % CD_FRAMES;
2034}
2035
2036
2037static inline
2038int msf_to_lba (byte m, byte s, byte f)
2039{
2040 return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
2041}
2042
2043static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
2044{
2045 struct request req;
2046 struct cdrom_info *info = drive->driver_data;
2047 struct cdrom_device_info *cdi = &info->devinfo;
2048
2049 cdrom_prepare_request(drive, &req);
2050
2051 req.sense = sense;
2052 req.cmd[0] = GPCMD_TEST_UNIT_READY;
2053 req.flags |= REQ_QUIET;
2054
2055#if ! STANDARD_ATAPI
2056 /* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
2057 switch CDs instead of supporting the LOAD_UNLOAD opcode */
2058
2059 req.cmd[7] = cdi->sanyo_slot % 3;
2060#endif /* not STANDARD_ATAPI */
2061
2062 return cdrom_queue_packet_command(drive, &req);
2063}
2064
2065
2066/* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
2067static int
2068cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
2069{
2070 struct request_sense my_sense;
2071 struct request req;
2072 int stat;
2073
2074 if (sense == NULL)
2075 sense = &my_sense;
2076
2077 /* If the drive cannot lock the door, just pretend. */
2078 if (CDROM_CONFIG_FLAGS(drive)->no_doorlock) {
2079 stat = 0;
2080 } else {
2081 cdrom_prepare_request(drive, &req);
2082 req.sense = sense;
2083 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
2084 req.cmd[4] = lockflag ? 1 : 0;
2085 stat = cdrom_queue_packet_command(drive, &req);
2086 }
2087
2088 /* If we got an illegal field error, the drive
2089 probably cannot lock the door. */
2090 if (stat != 0 &&
2091 sense->sense_key == ILLEGAL_REQUEST &&
2092 (sense->asc == 0x24 || sense->asc == 0x20)) {
2093 printk (KERN_ERR "%s: door locking not supported\n",
2094 drive->name);
2095 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2096 stat = 0;
2097 }
2098
2099 /* no medium, that's alright. */
2100 if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
2101 stat = 0;
2102
2103 if (stat == 0)
2104 CDROM_STATE_FLAGS(drive)->door_locked = lockflag;
2105
2106 return stat;
2107}
2108
2109
2110/* Eject the disk if EJECTFLAG is 0.
2111 If EJECTFLAG is 1, try to reload the disk. */
2112static int cdrom_eject(ide_drive_t *drive, int ejectflag,
2113 struct request_sense *sense)
2114{
2115 struct request req;
2116 char loej = 0x02;
2117
2118 if (CDROM_CONFIG_FLAGS(drive)->no_eject && !ejectflag)
2119 return -EDRIVE_CANT_DO_THIS;
2120
2121 /* reload fails on some drives, if the tray is locked */
2122 if (CDROM_STATE_FLAGS(drive)->door_locked && ejectflag)
2123 return 0;
2124
2125 cdrom_prepare_request(drive, &req);
2126
2127 /* only tell drive to close tray if open, if it can do that */
2128 if (ejectflag && !CDROM_CONFIG_FLAGS(drive)->close_tray)
2129 loej = 0;
2130
2131 req.sense = sense;
2132 req.cmd[0] = GPCMD_START_STOP_UNIT;
2133 req.cmd[4] = loej | (ejectflag != 0);
2134 return cdrom_queue_packet_command(drive, &req);
2135}
2136
2137static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
2138 unsigned long *sectors_per_frame,
2139 struct request_sense *sense)
2140{
2141 struct {
2142 __u32 lba;
2143 __u32 blocklen;
2144 } capbuf;
2145
2146 int stat;
2147 struct request req;
2148
2149 cdrom_prepare_request(drive, &req);
2150
2151 req.sense = sense;
2152 req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
2153 req.data = (char *)&capbuf;
2154 req.data_len = sizeof(capbuf);
2155
2156 stat = cdrom_queue_packet_command(drive, &req);
2157 if (stat == 0) {
2158 *capacity = 1 + be32_to_cpu(capbuf.lba);
2159 *sectors_per_frame =
2160 be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
2161 }
2162
2163 return stat;
2164}
2165
2166static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
2167 int format, char *buf, int buflen,
2168 struct request_sense *sense)
2169{
2170 struct request req;
2171
2172 cdrom_prepare_request(drive, &req);
2173
2174 req.sense = sense;
2175 req.data = buf;
2176 req.data_len = buflen;
2177 req.flags |= REQ_QUIET;
2178 req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
2179 req.cmd[6] = trackno;
2180 req.cmd[7] = (buflen >> 8);
2181 req.cmd[8] = (buflen & 0xff);
2182 req.cmd[9] = (format << 6);
2183
2184 if (msf_flag)
2185 req.cmd[1] = 2;
2186
2187 return cdrom_queue_packet_command(drive, &req);
2188}
2189
2190
2191/* Try to read the entire TOC for the disk into our internal buffer. */
2192static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2193{
2194 int stat, ntracks, i;
2195 struct cdrom_info *info = drive->driver_data;
2196 struct cdrom_device_info *cdi = &info->devinfo;
2197 struct atapi_toc *toc = info->toc;
2198 struct {
2199 struct atapi_toc_header hdr;
2200 struct atapi_toc_entry ent;
2201 } ms_tmp;
2202 long last_written;
2203 unsigned long sectors_per_frame = SECTORS_PER_FRAME;
2204
2205 if (toc == NULL) {
2206 /* Try to allocate space. */
2a91f3e5 2207 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
1da177e4
LT		 2208 if (toc == NULL) {
2209 printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
2210 return -ENOMEM;
2211 }
2a91f3e5 2212 info->toc = toc;
1da177e4
LT		 2213 }
2214
2215 /* Check to see if the existing data is still valid.
2216 If it is, just return. */
2217 (void) cdrom_check_status(drive, sense);
2218
2219 if (CDROM_STATE_FLAGS(drive)->toc_valid)
2220 return 0;
2221
2222 /* Try to get the total cdrom capacity and sector size. */
2223 stat = cdrom_read_capacity(drive, &toc->capacity, &sectors_per_frame,
2224 sense);
2225 if (stat)
2226 toc->capacity = 0x1fffff;
2227
2228 set_capacity(info->disk, toc->capacity * sectors_per_frame);
2229 blk_queue_hardsect_size(drive->queue,
2230 sectors_per_frame << SECTOR_BITS);
2231
2232 /* First read just the header, so we know how long the TOC is. */
2233 stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
2234 sizeof(struct atapi_toc_header), sense);
2a91f3e5
JJ		 2235 if (stat)
2236 return stat;
1da177e4
LT		 2237
2238#if ! STANDARD_ATAPI
2239 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2240 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2241 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2242 }
2243#endif /* not STANDARD_ATAPI */
2244
2245 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2246 if (ntracks <= 0)
2247 return -EIO;
2248 if (ntracks > MAX_TRACKS)
2249 ntracks = MAX_TRACKS;
2250
2251 /* Now read the whole schmeer. */
2252 stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
2253 (char *)&toc->hdr,
2254 sizeof(struct atapi_toc_header) +
2255 (ntracks + 1) *
2256 sizeof(struct atapi_toc_entry), sense);
2257
2258 if (stat && toc->hdr.first_track > 1) {
2259 /* Cds with CDI tracks only don't have any TOC entries,
2260 despite of this the returned values are
2261 first_track == last_track = number of CDI tracks + 1,
2262 so that this case is indistinguishable from the same
2263 layout plus an additional audio track.
2264 If we get an error for the regular case, we assume
2265 a CDI without additional audio tracks. In this case
2266 the readable TOC is empty (CDI tracks are not included)