projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] list.h doc: change "counter" to "cursor"
[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>
cf8b8975 316#include <linux/mutex.h>
1da177e4
LT		 317
318#include <scsi/scsi.h> /* For SCSI -> ATAPI command conversion */
319
320#include <asm/irq.h>
321#include <asm/io.h>
322#include <asm/byteorder.h>
323#include <asm/uaccess.h>
324#include <asm/unaligned.h>
325
326#include "ide-cd.h"
327
cf8b8975 328static DEFINE_MUTEX(idecd_ref_mutex);
1da177e4
LT		 329
330#define to_ide_cd(obj) container_of(obj, struct cdrom_info, kref)
331
332#define ide_cd_g(disk) \
333 container_of((disk)->private_data, struct cdrom_info, driver)
334
335static struct cdrom_info *ide_cd_get(struct gendisk *disk)
336{
337 struct cdrom_info *cd = NULL;
338
cf8b8975 339 mutex_lock(&idecd_ref_mutex);
1da177e4
LT		 340 cd = ide_cd_g(disk);
341 if (cd)
342 kref_get(&cd->kref);
cf8b8975 343 mutex_unlock(&idecd_ref_mutex);
1da177e4
LT		 344 return cd;
345}
346
347static void ide_cd_release(struct kref *);
348
349static void ide_cd_put(struct cdrom_info *cd)
350{
cf8b8975 351 mutex_lock(&idecd_ref_mutex);
1da177e4 352 kref_put(&cd->kref, ide_cd_release);
cf8b8975 353 mutex_unlock(&idecd_ref_mutex);
1da177e4
LT		 354}
355
356/****************************************************************************
357 * Generic packet command support and error handling routines.
358 */
359
360/* Mark that we've seen a media change, and invalidate our internal
361 buffers. */
362static void cdrom_saw_media_change (ide_drive_t *drive)
363{
364 struct cdrom_info *info = drive->driver_data;
365
366 CDROM_STATE_FLAGS (drive)->media_changed = 1;
367 CDROM_STATE_FLAGS (drive)->toc_valid = 0;
368 info->nsectors_buffered = 0;
369}
370
371static int cdrom_log_sense(ide_drive_t *drive, struct request *rq,
372 struct request_sense *sense)
373{
374 int log = 0;
375
376 if (!sense || !rq || (rq->flags & REQ_QUIET))
377 return 0;
378
379 switch (sense->sense_key) {
380 case NO_SENSE: case RECOVERED_ERROR:
381 break;
382 case NOT_READY:
383 /*
384 * don't care about tray state messages for
385 * e.g. capacity commands or in-progress or
386 * becoming ready
387 */
388 if (sense->asc == 0x3a || sense->asc == 0x04)
389 break;
390 log = 1;
391 break;
392 case ILLEGAL_REQUEST:
393 /*
394 * don't log START_STOP unit with LoEj set, since
395 * we cannot reliably check if drive can auto-close
396 */
397 if (rq->cmd[0] == GPCMD_START_STOP_UNIT && sense->asc == 0x24)
398 log = 0;
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{
420 if (!cdrom_log_sense(drive, failed_command, sense))
421 return;
422
423 /*
424 * If a read toc is executed for a CD-R or CD-RW medium where
425 * the first toc has not been recorded yet, it will fail with
426 * 05/24/00 (which is a confusing error)
427 */
428 if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP)
429 if (sense->sense_key == 0x05 && sense->asc == 0x24)
430 return;
431
432#if VERBOSE_IDE_CD_ERRORS
433 {
434 int i;
70d1d47c 435 const char *s = "bad sense key!";
1da177e4
LT		 436 char buf[80];
437
438 printk ("ATAPI device %s:\n", drive->name);
439 if (sense->error_code==0x70)
440 printk(" Error: ");
441 else if (sense->error_code==0x71)
442 printk(" Deferred Error: ");
443 else if (sense->error_code == 0x7f)
444 printk(" Vendor-specific Error: ");
445 else
446 printk(" Unknown Error Type: ");
447
448 if (sense->sense_key < ARY_LEN(sense_key_texts))
449 s = sense_key_texts[sense->sense_key];
1da177e4
LT		 450
451 printk("%s -- (Sense key=0x%02x)\n", s, sense->sense_key);
452
453 if (sense->asc == 0x40) {
454 sprintf(buf, "Diagnostic failure on component 0x%02x",
455 sense->ascq);
456 s = buf;
457 } else {
458 int lo = 0, mid, hi = ARY_LEN(sense_data_texts);
459 unsigned long key = (sense->sense_key << 16);
460 key |= (sense->asc << 8);
461 if (!(sense->ascq >= 0x80 && sense->ascq <= 0xdd))
462 key |= sense->ascq;
463 s = NULL;
464
465 while (hi > lo) {
466 mid = (lo + hi) / 2;
467 if (sense_data_texts[mid].asc_ascq == key ||
468 sense_data_texts[mid].asc_ascq == (0xff0000|key)) {
469 s = sense_data_texts[mid].text;
470 break;
471 }
472 else if (sense_data_texts[mid].asc_ascq > key)
473 hi = mid;
474 else
475 lo = mid+1;
476 }
477 }
478
479 if (s == NULL) {
480 if (sense->asc > 0x80)
481 s = "(vendor-specific error)";
482 else
483 s = "(reserved error code)";
484 }
485
486 printk(KERN_ERR " %s -- (asc=0x%02x, ascq=0x%02x)\n",
487 s, sense->asc, sense->ascq);
488
489 if (failed_command != NULL) {
490
491 int lo=0, mid, hi= ARY_LEN (packet_command_texts);
492 s = NULL;
493
494 while (hi > lo) {
495 mid = (lo + hi) / 2;
496 if (packet_command_texts[mid].packet_command ==
497 failed_command->cmd[0]) {
498 s = packet_command_texts[mid].text;
499 break;
500 }
501 if (packet_command_texts[mid].packet_command >
502 failed_command->cmd[0])
503 hi = mid;
504 else
505 lo = mid+1;
506 }
507
508 printk (KERN_ERR " The failed \"%s\" packet command was: \n \"", s);
509 for (i=0; i<sizeof (failed_command->cmd); i++)
510 printk ("%02x ", failed_command->cmd[i]);
511 printk ("\"\n");
512 }
513
514 /* The SKSV bit specifies validity of the sense_key_specific
515 * in the next two commands. It is bit 7 of the first byte.
516 * In the case of NOT_READY, if SKSV is set the drive can
517 * give us nice ETA readings.
518 */
519 if (sense->sense_key == NOT_READY && (sense->sks[0] & 0x80)) {
520 int progress = (sense->sks[1] << 8 | sense->sks[2]) * 100;
521 printk(KERN_ERR " Command is %02d%% complete\n", progress / 0xffff);
522
523 }
524
525 if (sense->sense_key == ILLEGAL_REQUEST &&
526 (sense->sks[0] & 0x80) != 0) {
527 printk(KERN_ERR " Error in %s byte %d",
528 (sense->sks[0] & 0x40) != 0 ?
529 "command packet" : "command data",
530 (sense->sks[1] << 8) + sense->sks[2]);
531
532 if ((sense->sks[0] & 0x40) != 0)
533 printk (" bit %d", sense->sks[0] & 0x07);
534
535 printk ("\n");
536 }
537 }
538
539#else /* not VERBOSE_IDE_CD_ERRORS */
540
541 /* Suppress printing unit attention and `in progress of becoming ready'
542 errors when we're not being verbose. */
543
544 if (sense->sense_key == UNIT_ATTENTION ||
545 (sense->sense_key == NOT_READY && (sense->asc == 4 ||
546 sense->asc == 0x3a)))
547 return;
548
549 printk(KERN_ERR "%s: error code: 0x%02x sense_key: 0x%02x asc: 0x%02x ascq: 0x%02x\n",
550 drive->name,
551 sense->error_code, sense->sense_key,
552 sense->asc, sense->ascq);
553#endif /* not VERBOSE_IDE_CD_ERRORS */
554}
555
556/*
557 * Initialize a ide-cd packet command request
558 */
559static void cdrom_prepare_request(ide_drive_t *drive, struct request *rq)
560{
561 struct cdrom_info *cd = drive->driver_data;
562
563 ide_init_drive_cmd(rq);
564 rq->flags = REQ_PC;
565 rq->rq_disk = cd->disk;
566}
567
568static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense,
569 struct request *failed_command)
570{
571 struct cdrom_info *info = drive->driver_data;
572 struct request *rq = &info->request_sense_request;
573
574 if (sense == NULL)
575 sense = &info->sense_data;
576
577 /* stuff the sense request in front of our current request */
578 cdrom_prepare_request(drive, rq);
579
580 rq->data = sense;
581 rq->cmd[0] = GPCMD_REQUEST_SENSE;
582 rq->cmd[4] = rq->data_len = 18;
583
584 rq->flags = REQ_SENSE;
585
586 /* NOTE! Save the failed command in "rq->buffer" */
587 rq->buffer = (void *) failed_command;
588
589 (void) ide_do_drive_cmd(drive, rq, ide_preempt);
590}
591
592static void cdrom_end_request (ide_drive_t *drive, int uptodate)
593{
594 struct request *rq = HWGROUP(drive)->rq;
595 int nsectors = rq->hard_cur_sectors;
596
597 if ((rq->flags & REQ_SENSE) && uptodate) {
598 /*
599 * For REQ_SENSE, "rq->buffer" points to the original failed
600 * request
601 */
602 struct request *failed = (struct request *) rq->buffer;
603 struct cdrom_info *info = drive->driver_data;
604 void *sense = &info->sense_data;
605 unsigned long flags;
606
607 if (failed) {
608 if (failed->sense) {
609 sense = failed->sense;
610 failed->sense_len = rq->sense_len;
611 }
612
613 /*
614 * now end failed request
615 */
616 spin_lock_irqsave(&ide_lock, flags);
617 end_that_request_chunk(failed, 0, failed->data_len);
8ffdc655 618 end_that_request_last(failed, 0);
1da177e4
LT		 619 spin_unlock_irqrestore(&ide_lock, flags);
620 }
621
622 cdrom_analyze_sense_data(drive, failed, sense);
623 }
624
625 if (!rq->current_nr_sectors && blk_fs_request(rq))
626 uptodate = 1;
627 /* make sure it's fully ended */
628 if (blk_pc_request(rq))
629 nsectors = (rq->data_len + 511) >> 9;
630 if (!nsectors)
631 nsectors = 1;
632
633 ide_end_request(drive, uptodate, nsectors);
634}
635
636/* Returns 0 if the request should be continued.
637 Returns 1 if the request was ended. */
638static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
639{
640 struct request *rq = HWGROUP(drive)->rq;
641 int stat, err, sense_key;
642
643 /* Check for errors. */
644 stat = HWIF(drive)->INB(IDE_STATUS_REG);
645 if (stat_ret)
646 *stat_ret = stat;
647
648 if (OK_STAT(stat, good_stat, BAD_R_STAT))
649 return 0;
650
651 /* Get the IDE error register. */
652 err = HWIF(drive)->INB(IDE_ERROR_REG);
653 sense_key = err >> 4;
654
655 if (rq == NULL) {
656 printk("%s: missing rq in cdrom_decode_status\n", drive->name);
657 return 1;
658 }
659
660 if (rq->flags & REQ_SENSE) {
661 /* We got an error trying to get sense info
662 from the drive (probably while trying
663 to recover from a former error). Just give up. */
664
665 rq->flags |= REQ_FAILED;
666 cdrom_end_request(drive, 0);
667 ide_error(drive, "request sense failure", stat);
668 return 1;
669
670 } else if (rq->flags & (REQ_PC | REQ_BLOCK_PC)) {
671 /* All other functions, except for READ. */
672 unsigned long flags;
673
674 /*
675 * if we have an error, pass back CHECK_CONDITION as the
676 * scsi status byte
677 */
678 if ((rq->flags & REQ_BLOCK_PC) && !rq->errors)
679 rq->errors = SAM_STAT_CHECK_CONDITION;
680
681 /* Check for tray open. */
682 if (sense_key == NOT_READY) {
683 cdrom_saw_media_change (drive);
684 } else if (sense_key == UNIT_ATTENTION) {
685 /* Check for media change. */
686 cdrom_saw_media_change (drive);
687 /*printk("%s: media changed\n",drive->name);*/
688 return 0;
689 } else if (!(rq->flags & REQ_QUIET)) {
690 /* Otherwise, print an error. */
691 ide_dump_status(drive, "packet command error", stat);
692 }
693
694 rq->flags |= REQ_FAILED;
695
696 /*
697 * instead of playing games with moving completions around,
698 * remove failed request completely and end it when the
699 * request sense has completed
700 */
701 if (stat & ERR_STAT) {
702 spin_lock_irqsave(&ide_lock, flags);
703 blkdev_dequeue_request(rq);
704 HWGROUP(drive)->rq = NULL;
705 spin_unlock_irqrestore(&ide_lock, flags);
706
707 cdrom_queue_request_sense(drive, rq->sense, rq);
708 } else
709 cdrom_end_request(drive, 0);
710
711 } else if (blk_fs_request(rq)) {
712 int do_end_request = 0;
713
714 /* Handle errors from READ and WRITE requests. */
715
716 if (blk_noretry_request(rq))
717 do_end_request = 1;
718
719 if (sense_key == NOT_READY) {
720 /* Tray open. */
721 if (rq_data_dir(rq) == READ) {
722 cdrom_saw_media_change (drive);
723
724 /* Fail the request. */
725 printk ("%s: tray open\n", drive->name);
726 do_end_request = 1;
727 } else {
728 struct cdrom_info *info = drive->driver_data;
729
730 /* allow the drive 5 seconds to recover, some
731 * devices will return this error while flushing
732 * data from cache */
733 if (!rq->errors)
734 info->write_timeout = jiffies + ATAPI_WAIT_WRITE_BUSY;
735 rq->errors = 1;
736 if (time_after(jiffies, info->write_timeout))
737 do_end_request = 1;
738 else {
739 unsigned long flags;
740
741 /*
742 * take a breather relying on the
743 * unplug timer to kick us again
744 */
745 spin_lock_irqsave(&ide_lock, flags);
746 blk_plug_device(drive->queue);
747 spin_unlock_irqrestore(&ide_lock,flags);
748 return 1;
749 }
750 }
751 } else if (sense_key == UNIT_ATTENTION) {
752 /* Media change. */
753 cdrom_saw_media_change (drive);
754
755 /* Arrange to retry the request.
756 But be sure to give up if we've retried
757 too many times. */
758 if (++rq->errors > ERROR_MAX)
759 do_end_request = 1;
760 } else if (sense_key == ILLEGAL_REQUEST ||
761 sense_key == DATA_PROTECT) {
762 /* No point in retrying after an illegal
763 request or data protect error.*/
764 ide_dump_status (drive, "command error", stat);
765 do_end_request = 1;
766 } else if (sense_key == MEDIUM_ERROR) {
767 /* No point in re-trying a zillion times on a bad
768 * sector... If we got here the error is not correctable */
769 ide_dump_status (drive, "media error (bad sector)", stat);
770 do_end_request = 1;
771 } else if (sense_key == BLANK_CHECK) {
772 /* Disk appears blank ?? */
773 ide_dump_status (drive, "media error (blank)", stat);
774 do_end_request = 1;
775 } else if ((err & ~ABRT_ERR) != 0) {
776 /* Go to the default handler
777 for other errors. */
778 ide_error(drive, "cdrom_decode_status", stat);
779 return 1;
780 } else if ((++rq->errors > ERROR_MAX)) {
781 /* We've racked up too many retries. Abort. */
782 do_end_request = 1;
783 }
784
785 if (do_end_request)
786 cdrom_end_request(drive, 0);
787
788 /* If we got a CHECK_CONDITION status,
789 queue a request sense command. */
790 if ((stat & ERR_STAT) != 0)
791 cdrom_queue_request_sense(drive, NULL, NULL);
792 } else {
793 blk_dump_rq_flags(rq, "ide-cd: bad rq");
794 cdrom_end_request(drive, 0);
795 }
796
797 /* Retry, or handle the next request. */
798 return 1;
799}
800
801static int cdrom_timer_expiry(ide_drive_t *drive)
802{
803 struct request *rq = HWGROUP(drive)->rq;
804 unsigned long wait = 0;
805
806 /*
807 * Some commands are *slow* and normally take a long time to
808 * complete. Usually we can use the ATAPI "disconnect" to bypass
809 * this, but not all commands/drives support that. Let
810 * ide_timer_expiry keep polling us for these.
811 */
812 switch (rq->cmd[0]) {
813 case GPCMD_BLANK:
814 case GPCMD_FORMAT_UNIT:
815 case GPCMD_RESERVE_RZONE_TRACK:
816 case GPCMD_CLOSE_TRACK:
817 case GPCMD_FLUSH_CACHE:
818 wait = ATAPI_WAIT_PC;
819 break;
820 default:
821 if (!(rq->flags & REQ_QUIET))
822 printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n", rq->cmd[0]);
823 wait = 0;
824 break;
825 }
826 return wait;
827}
828
829/* Set up the device registers for transferring a packet command on DEV,
830 expecting to later transfer XFERLEN bytes. HANDLER is the routine
831 which actually transfers the command to the drive. If this is a
832 drq_interrupt device, this routine will arrange for HANDLER to be
833 called when the interrupt from the drive arrives. Otherwise, HANDLER
834 will be called immediately after the drive is prepared for the transfer. */
835
836static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
837 int xferlen,
838 ide_handler_t *handler)
839{
840 ide_startstop_t startstop;
841 struct cdrom_info *info = drive->driver_data;
842 ide_hwif_t *hwif = drive->hwif;
843
844 /* Wait for the controller to be idle. */
845 if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY))
846 return startstop;
847
848 if (info->dma)
849 info->dma = !hwif->dma_setup(drive);
850
851 /* Set up the controller registers. */
852 /* FIXME: for Virtual DMA we must check harder */
853 HWIF(drive)->OUTB(info->dma, IDE_FEATURE_REG);
854 HWIF(drive)->OUTB(0, IDE_IREASON_REG);
855 HWIF(drive)->OUTB(0, IDE_SECTOR_REG);
856
857 HWIF(drive)->OUTB(xferlen & 0xff, IDE_BCOUNTL_REG);
858 HWIF(drive)->OUTB(xferlen >> 8 , IDE_BCOUNTH_REG);
859 if (IDE_CONTROL_REG)
860 HWIF(drive)->OUTB(drive->ctl, IDE_CONTROL_REG);
861
862 if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt) {
863 /* packet command */
864 ide_execute_command(drive, WIN_PACKETCMD, handler, ATAPI_WAIT_PC, cdrom_timer_expiry);
865 return ide_started;
866 } else {
867 unsigned long flags;
868
869 /* packet command */
870 spin_lock_irqsave(&ide_lock, flags);
871 hwif->OUTBSYNC(drive, WIN_PACKETCMD, IDE_COMMAND_REG);
872 ndelay(400);
873 spin_unlock_irqrestore(&ide_lock, flags);
874
875 return (*handler) (drive);
876 }
877}
878
879/* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
880 The device registers must have already been prepared
881 by cdrom_start_packet_command.
882 HANDLER is the interrupt handler to call when the command completes
883 or there's data ready. */
884/*
885 * changed 5 parameters to 3 for dvd-ram
886 * struct packet_command *pc; now packet_command_t *pc;
887 */
888#define ATAPI_MIN_CDB_BYTES 12
889static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
890 struct request *rq,
891 ide_handler_t *handler)
892{
893 ide_hwif_t *hwif = drive->hwif;
894 int cmd_len;
895 struct cdrom_info *info = drive->driver_data;
896 ide_startstop_t startstop;
897
898 if (CDROM_CONFIG_FLAGS(drive)->drq_interrupt) {
899 /* Here we should have been called after receiving an interrupt
900 from the device. DRQ should how be set. */
901
902 /* Check for errors. */
903 if (cdrom_decode_status(drive, DRQ_STAT, NULL))
904 return ide_stopped;
905 } else {
906 /* Otherwise, we must wait for DRQ to get set. */
907 if (ide_wait_stat(&startstop, drive, DRQ_STAT,
908 BUSY_STAT, WAIT_READY))
909 return startstop;
910 }
911
912 /* Arm the interrupt handler. */
913 ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);
914
915 /* ATAPI commands get padded out to 12 bytes minimum */
916 cmd_len = COMMAND_SIZE(rq->cmd[0]);
917 if (cmd_len < ATAPI_MIN_CDB_BYTES)
918 cmd_len = ATAPI_MIN_CDB_BYTES;
919
920 /* Send the command to the device. */
921 HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len);
922
923 /* Start the DMA if need be */
924 if (info->dma)
925 hwif->dma_start(drive);
926
927 return ide_started;
928}
929
930/****************************************************************************
931 * Block read functions.
932 */
933
934/*
935 * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
936 * buffer. Once the first sector is added, any subsequent sectors are
937 * assumed to be continuous (until the buffer is cleared). For the first
938 * sector added, SECTOR is its sector number. (SECTOR is then ignored until
939 * the buffer is cleared.)
940 */
941static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
942 int sectors_to_transfer)
943{
944 struct cdrom_info *info = drive->driver_data;
945
946 /* Number of sectors to read into the buffer. */
947 int sectors_to_buffer = min_t(int, sectors_to_transfer,
948 (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
949 info->nsectors_buffered);
950
951 char *dest;
952
953 /* If we couldn't get a buffer, don't try to buffer anything... */
954 if (info->buffer == NULL)
955 sectors_to_buffer = 0;
956
957 /* If this is the first sector in the buffer, remember its number. */
958 if (info->nsectors_buffered == 0)
959 info->sector_buffered = sector;
960
961 /* Read the data into the buffer. */
962 dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
963 while (sectors_to_buffer > 0) {
964 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
965 --sectors_to_buffer;
966 --sectors_to_transfer;
967 ++info->nsectors_buffered;
968 dest += SECTOR_SIZE;
969 }
970
971 /* Throw away any remaining data. */
972 while (sectors_to_transfer > 0) {
973 static char dum[SECTOR_SIZE];
974 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
975 --sectors_to_transfer;
976 }
977}
978
979/*
980 * Check the contents of the interrupt reason register from the cdrom
981 * and attempt to recover if there are problems. Returns 0 if everything's
982 * ok; nonzero if the request has been terminated.
983 */
858119e1 984static
1da177e4
LT		 985int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
986{
987 if (ireason == 2)
988 return 0;
989 else if (ireason == 0) {
990 /* Whoops... The drive is expecting to receive data from us! */
991 printk(KERN_ERR "%s: read_intr: Drive wants to transfer data the "
992 "wrong way!\n", drive->name);
993
994 /* Throw some data at the drive so it doesn't hang
995 and quit this request. */
996 while (len > 0) {
997 int dum = 0;
998 HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof (dum));
999 len -= sizeof (dum);
1000 }
1001 } else if (ireason == 1) {
1002 /* Some drives (ASUS) seem to tell us that status
1003 * info is available. just get it and ignore.
1004 */
1005 (void) HWIF(drive)->INB(IDE_STATUS_REG);
1006 return 0;
1007 } else {
1008 /* Drive wants a command packet, or invalid ireason... */
1009 printk(KERN_ERR "%s: read_intr: bad interrupt reason %x\n", drive->name,
1010 ireason);
1011 }
1012
1013 cdrom_end_request(drive, 0);
1014 return -1;
1015}
1016
1017/*
1018 * Interrupt routine. Called when a read request has completed.
1019 */
1020static ide_startstop_t cdrom_read_intr (ide_drive_t *drive)
1021{
1022 int stat;
1023 int ireason, len, sectors_to_transfer, nskip;
1024 struct cdrom_info *info = drive->driver_data;
1025 u8 lowcyl = 0, highcyl = 0;
1026 int dma = info->dma, dma_error = 0;
1027
1028 struct request *rq = HWGROUP(drive)->rq;
1029
1030 /*
1031 * handle dma case
1032 */
1033 if (dma) {
1034 info->dma = 0;
1035 if ((dma_error = HWIF(drive)->ide_dma_end(drive)))
1036 __ide_dma_off(drive);
1037 }
1038
1039 if (cdrom_decode_status(drive, 0, &stat))
1040 return ide_stopped;
1041
1042 if (dma) {
1043 if (!dma_error) {
1044 ide_end_request(drive, 1, rq->nr_sectors);
1045 return ide_stopped;
1046 } else
1047 return ide_error(drive, "dma error", stat);
1048 }
1049
1050 /* Read the interrupt reason and the transfer length. */
1051 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1052 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1053 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1054
1055 len = lowcyl + (256 * highcyl);
1056
1057 /* If DRQ is clear, the command has completed. */
1058 if ((stat & DRQ_STAT) == 0) {
1059 /* If we're not done filling the current buffer, complain.
1060 Otherwise, complete the command normally. */
1061 if (rq->current_nr_sectors > 0) {
1062 printk (KERN_ERR "%s: cdrom_read_intr: data underrun (%d blocks)\n",
1063 drive->name, rq->current_nr_sectors);
1064 rq->flags |= REQ_FAILED;
1065 cdrom_end_request(drive, 0);
1066 } else
1067 cdrom_end_request(drive, 1);
1068 return ide_stopped;
1069 }
1070
1071 /* Check that the drive is expecting to do the same thing we are. */
1072 if (cdrom_read_check_ireason (drive, len, ireason))
1073 return ide_stopped;
1074
1075 /* Assume that the drive will always provide data in multiples
1076 of at least SECTOR_SIZE, as it gets hairy to keep track
1077 of the transfers otherwise. */
1078 if ((len % SECTOR_SIZE) != 0) {
1079 printk (KERN_ERR "%s: cdrom_read_intr: Bad transfer size %d\n",
1080 drive->name, len);
1081 if (CDROM_CONFIG_FLAGS(drive)->limit_nframes)
1082 printk (KERN_ERR " This drive is not supported by this version of the driver\n");
1083 else {
1084 printk (KERN_ERR " Trying to limit transfer sizes\n");
1085 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
1086 }
1087 cdrom_end_request(drive, 0);
1088 return ide_stopped;
1089 }
1090
1091 /* The number of sectors we need to read from the drive. */
1092 sectors_to_transfer = len / SECTOR_SIZE;
1093
1094 /* First, figure out if we need to bit-bucket
1095 any of the leading sectors. */
1096 nskip = min_t(int, rq->current_nr_sectors - bio_cur_sectors(rq->bio), sectors_to_transfer);
1097
1098 while (nskip > 0) {
1099 /* We need to throw away a sector. */
1100 static char dum[SECTOR_SIZE];
1101 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1102
1103 --rq->current_nr_sectors;
1104 --nskip;
1105 --sectors_to_transfer;
1106 }
1107
1108 /* Now loop while we still have data to read from the drive. */
1109 while (sectors_to_transfer > 0) {
1110 int this_transfer;
1111
1112 /* If we've filled the present buffer but there's another
1113 chained buffer after it, move on. */
1114 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1115 cdrom_end_request(drive, 1);
1116
1117 /* If the buffers are full, cache the rest of the data in our
1118 internal buffer. */
1119 if (rq->current_nr_sectors == 0) {
1120 cdrom_buffer_sectors(drive, rq->sector, sectors_to_transfer);
1121 sectors_to_transfer = 0;
1122 } else {
1123 /* Transfer data to the buffers.
1124 Figure out how many sectors we can transfer
1125 to the current buffer. */
1126 this_transfer = min_t(int, sectors_to_transfer,
1127 rq->current_nr_sectors);
1128
1129 /* Read this_transfer sectors
1130 into the current buffer. */
1131 while (this_transfer > 0) {
1132 HWIF(drive)->atapi_input_bytes(drive, rq->buffer, SECTOR_SIZE);
1133 rq->buffer += SECTOR_SIZE;
1134 --rq->nr_sectors;
1135 --rq->current_nr_sectors;
1136 ++rq->sector;
1137 --this_transfer;
1138 --sectors_to_transfer;
1139 }
1140 }
1141 }
1142
1143 /* Done moving data! Wait for another interrupt. */
1144 ide_set_handler(drive, &cdrom_read_intr, ATAPI_WAIT_PC, NULL);
1145 return ide_started;
1146}
1147
1148/*
1149 * Try to satisfy some of the current read request from our cached data.
1150 * Returns nonzero if the request has been completed, zero otherwise.
1151 */
1152static int cdrom_read_from_buffer (ide_drive_t *drive)
1153{
1154 struct cdrom_info *info = drive->driver_data;
1155 struct request *rq = HWGROUP(drive)->rq;
1156 unsigned short sectors_per_frame;
1157
1158 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1159
1160 /* Can't do anything if there's no buffer. */
1161 if (info->buffer == NULL) return 0;
1162
1163 /* Loop while this request needs data and the next block is present
1164 in our cache. */
1165 while (rq->nr_sectors > 0 &&
1166 rq->sector >= info->sector_buffered &&
1167 rq->sector < info->sector_buffered + info->nsectors_buffered) {
1168 if (rq->current_nr_sectors == 0)
1169 cdrom_end_request(drive, 1);
1170
1171 memcpy (rq->buffer,
1172 info->buffer +
1173 (rq->sector - info->sector_buffered) * SECTOR_SIZE,
1174 SECTOR_SIZE);
1175 rq->buffer += SECTOR_SIZE;
1176 --rq->current_nr_sectors;
1177 --rq->nr_sectors;
1178 ++rq->sector;
1179 }
1180
1181 /* If we've satisfied the current request,
1182 terminate it successfully. */
1183 if (rq->nr_sectors == 0) {
1184 cdrom_end_request(drive, 1);
1185 return -1;
1186 }
1187
1188 /* Move on to the next buffer if needed. */
1189 if (rq->current_nr_sectors == 0)
1190 cdrom_end_request(drive, 1);
1191
1192 /* If this condition does not hold, then the kluge i use to
1193 represent the number of sectors to skip at the start of a transfer
1194 will fail. I think that this will never happen, but let's be
1195 paranoid and check. */
1196 if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
1197 (rq->sector & (sectors_per_frame - 1))) {
1198 printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
1199 drive->name, (long)rq->sector);
1200 cdrom_end_request(drive, 0);
1201 return -1;
1202 }
1203
1204 return 0;
1205}
1206
1207/*
1208 * Routine to send a read packet command to the drive.
1209 * This is usually called directly from cdrom_start_read.
1210 * However, for drq_interrupt devices, it is called from an interrupt
1211 * when the drive is ready to accept the command.
1212 */
1213static ide_startstop_t cdrom_start_read_continuation (ide_drive_t *drive)
1214{
1215 struct request *rq = HWGROUP(drive)->rq;
1216 unsigned short sectors_per_frame;
1217 int nskip;
1218
1219 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1220
1221 /* If the requested sector doesn't start on a cdrom block boundary,
1222 we must adjust the start of the transfer so that it does,
1223 and remember to skip the first few sectors.
1224 If the CURRENT_NR_SECTORS field is larger than the size
1225 of the buffer, it will mean that we're to skip a number
1226 of sectors equal to the amount by which CURRENT_NR_SECTORS
1227 is larger than the buffer size. */
1228 nskip = rq->sector & (sectors_per_frame - 1);
1229 if (nskip > 0) {
1230 /* Sanity check... */
1231 if (rq->current_nr_sectors != bio_cur_sectors(rq->bio) &&
1232 (rq->sector & (sectors_per_frame - 1))) {
1233 printk(KERN_ERR "%s: cdrom_start_read_continuation: buffer botch (%u)\n",
1234 drive->name, rq->current_nr_sectors);
1235 cdrom_end_request(drive, 0);
1236 return ide_stopped;
1237 }
1238 rq->current_nr_sectors += nskip;
1239 }
1240
1241 /* Set up the command */
1242 rq->timeout = ATAPI_WAIT_PC;
1243
1244 /* Send the command to the drive and return. */
1245 return cdrom_transfer_packet_command(drive, rq, &cdrom_read_intr);
1246}
1247
1248
1249#define IDECD_SEEK_THRESHOLD (1000) /* 1000 blocks */
1250#define IDECD_SEEK_TIMER (5 * WAIT_MIN_SLEEP) /* 100 ms */
1251#define IDECD_SEEK_TIMEOUT (2 * WAIT_CMD) /* 20 sec */
1252
1253static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
1254{
1255 struct cdrom_info *info = drive->driver_data;
1256 int stat;
1257 static int retry = 10;
1258
1259 if (cdrom_decode_status(drive, 0, &stat))
1260 return ide_stopped;
1261 CDROM_CONFIG_FLAGS(drive)->seeking = 1;
1262
1263 if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
1264 if (--retry == 0) {
1265 /*
1266 * this condition is far too common, to bother
1267 * users about it
1268 */
1269 /* printk("%s: disabled DSC seek overlap\n", drive->name);*/
1270 drive->dsc_overlap = 0;
1271 }
1272 }
1273 return ide_stopped;
1274}
1275
1276static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
1277{
1278 struct request *rq = HWGROUP(drive)->rq;
1279 sector_t frame = rq->sector;
1280
1281 sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
1282
1283 memset(rq->cmd, 0, sizeof(rq->cmd));
1284 rq->cmd[0] = GPCMD_SEEK;
1285 put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
1286
1287 rq->timeout = ATAPI_WAIT_PC;
1288 return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
1289}
1290
1291static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
1292{
1293 struct cdrom_info *info = drive->driver_data;
1294
1295 info->dma = 0;
1da177e4
LT		 1296 info->start_seek = jiffies;
1297 return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
1298}
1299
1300/* Fix up a possibly partially-processed request so that we can
1301 start it over entirely, or even put it back on the request queue. */
1302static void restore_request (struct request *rq)
1303{
1304 if (rq->buffer != bio_data(rq->bio)) {
1305 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
1306
1307 rq->buffer = bio_data(rq->bio);
1308 rq->nr_sectors += n;
1309 rq->sector -= n;
1310 }
1311 rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
1312 rq->hard_nr_sectors = rq->nr_sectors;
1313 rq->hard_sector = rq->sector;
1314 rq->q->prep_rq_fn(rq->q, rq);
1315}
1316
1317/*
1318 * Start a read request from the CD-ROM.
1319 */
1320static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block)
1321{
1322 struct cdrom_info *info = drive->driver_data;
1323 struct request *rq = HWGROUP(drive)->rq;
1324 unsigned short sectors_per_frame;
1325
1326 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1327
1328 /* We may be retrying this request after an error. Fix up
1329 any weirdness which might be present in the request packet. */
1330 restore_request(rq);
1331
1332 /* Satisfy whatever we can of this request from our cached sector. */
1333 if (cdrom_read_from_buffer(drive))
1334 return ide_stopped;
1335
1da177e4
LT		 1336 /* Clear the local sector buffer. */
1337 info->nsectors_buffered = 0;
1338
1339 /* use dma, if possible. */
1340 info->dma = drive->using_dma;
1341 if ((rq->sector & (sectors_per_frame - 1)) ||
1342 (rq->nr_sectors & (sectors_per_frame - 1)))
1343 info->dma = 0;
1344
1da177e4
LT		 1345 /* Start sending the read request to the drive. */
1346 return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
1347}
1348
1349/****************************************************************************
1350 * Execute all other packet commands.
1351 */
1352
1353/* Interrupt routine for packet command completion. */
1354static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
1355{
1356 int ireason, len, thislen;
1357 struct request *rq = HWGROUP(drive)->rq;
1358 u8 lowcyl = 0, highcyl = 0;
1359 int stat;
1360
1361 /* Check for errors. */
1362 if (cdrom_decode_status(drive, 0, &stat))
1363 return ide_stopped;
1364
1365 /* Read the interrupt reason and the transfer length. */
1366 ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1367 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1368 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1369
1370 len = lowcyl + (256 * highcyl);
1371
1372 /* If DRQ is clear, the command has completed.
1373 Complain if we still have data left to transfer. */
1374 if ((stat & DRQ_STAT) == 0) {
1375 /* Some of the trailing request sense fields are optional, and
1376 some drives don't send them. Sigh. */
1377 if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
1378 rq->data_len > 0 &&
1379 rq->data_len <= 5) {
1380 while (rq->data_len > 0) {
1381 *(unsigned char *)rq->data++ = 0;
1382 --rq->data_len;
1383 }
1384 }
1385
1386 if (rq->data_len == 0)
1387 cdrom_end_request(drive, 1);
1388 else {
1389 /* Comment this out, because this always happens
1390 right after a reset occurs, and it is annoying to
1391 always print expected stuff. */
1392 /*
1393 printk ("%s: cdrom_pc_intr: data underrun %d\n",
1394 drive->name, pc->buflen);
1395 */
1396 rq->flags |= REQ_FAILED;
1397 cdrom_end_request(drive, 0);
1398 }
1399 return ide_stopped;
1400 }
1401
1402 /* Figure out how much data to transfer. */
1403 thislen = rq->data_len;
1404 if (thislen > len) thislen = len;
1405
1406 /* The drive wants to be written to. */
1407 if ((ireason & 3) == 0) {
1408 if (!rq->data) {
1409 blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1410 goto confused;
1411 }
1412 /* Transfer the data. */
1413 HWIF(drive)->atapi_output_bytes(drive, rq->data, thislen);
1414
1415 /* If we haven't moved enough data to satisfy the drive,
1416 add some padding. */
1417 while (len > thislen) {
1418 int dum = 0;
1419 HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof(dum));
1420 len -= sizeof(dum);
1421 }
1422
1423 /* Keep count of how much data we've moved. */
1424 rq->data += thislen;
1425 rq->data_len -= thislen;
1426 }
1427
1428 /* Same drill for reading. */
1429 else if ((ireason & 3) == 2) {
1430 if (!rq->data) {
1431 blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1432 goto confused;
1433 }
1434 /* Transfer the data. */
1435 HWIF(drive)->atapi_input_bytes(drive, rq->data, thislen);
1436
1437 /* If we haven't moved enough data to satisfy the drive,
1438 add some padding. */
1439 while (len > thislen) {
1440 int dum = 0;
1441 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1442 len -= sizeof(dum);
1443 }
1444
1445 /* Keep count of how much data we've moved. */
1446 rq->data += thislen;
1447 rq->data_len -= thislen;
1448
1449 if (rq->flags & REQ_SENSE)
1450 rq->sense_len += thislen;
1451 } else {
1452confused:
1453 printk (KERN_ERR "%s: cdrom_pc_intr: The drive "
1ad55440
RK		 1454 "appears confused (ireason = 0x%02x). "
1455 "Trying to recover by ending request.\n",
1da177e4
LT		 1456 drive->name, ireason);
1457 rq->flags |= REQ_FAILED;
1ad55440
RK		 1458 cdrom_end_request(drive, 0);
1459 return ide_stopped;
1da177e4
LT		 1460 }
1461
1462 /* Now we wait for another interrupt. */
1463 ide_set_handler(drive, &cdrom_pc_intr, ATAPI_WAIT_PC, cdrom_timer_expiry);
1464 return ide_started;
1465}
1466
1467static ide_startstop_t cdrom_do_pc_continuation (ide_drive_t *drive)
1468{
1469 struct request *rq = HWGROUP(drive)->rq;
1470
1471 if (!rq->timeout)
1472 rq->timeout = ATAPI_WAIT_PC;
1473
1474 /* Send the command to the drive and return. */
1475 return cdrom_transfer_packet_command(drive, rq, &cdrom_pc_intr);
1476}
1477
1478
1479static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
1480{
1481 int len;
1482 struct request *rq = HWGROUP(drive)->rq;
1483 struct cdrom_info *info = drive->driver_data;
1484
1485 info->dma = 0;
1da177e4
LT		 1486 rq->flags &= ~REQ_FAILED;
1487 len = rq->data_len;
1488
1489 /* Start sending the command to the drive. */
1490 return cdrom_start_packet_command(drive, len, cdrom_do_pc_continuation);
1491}
1492
1493
1494static
1495int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
1496{
1497 struct request_sense sense;
1498 int retries = 10;
1499 unsigned int flags = rq->flags;
1500
1501 if (rq->sense == NULL)
1502 rq->sense = &sense;
1503
1504 /* Start of retry loop. */
1505 do {
1506 int error;
1507 unsigned long time = jiffies;
1508 rq->flags = flags;
1509
1510 error = ide_do_drive_cmd(drive, rq, ide_wait);
1511 time = jiffies - time;
1512
1513 /* FIXME: we should probably abort/retry or something
1514 * in case of failure */
1515 if (rq->flags & REQ_FAILED) {
1516 /* The request failed. Retry if it was due to a unit
1517 attention status
1518 (usually means media was changed). */
1519 struct request_sense *reqbuf = rq->sense;
1520
1521 if (reqbuf->sense_key == UNIT_ATTENTION)
1522 cdrom_saw_media_change(drive);
1523 else if (reqbuf->sense_key == NOT_READY &&
1524 reqbuf->asc == 4 && reqbuf->ascq != 4) {
1525 /* The drive is in the process of loading
1526 a disk. Retry, but wait a little to give
1527 the drive time to complete the load. */
1528 ssleep(2);
1529 } else {
1530 /* Otherwise, don't retry. */
1531 retries = 0;
1532 }
1533 --retries;
1534 }
1535
1536 /* End of retry loop. */
1537 } while ((rq->flags & REQ_FAILED) && retries >= 0);
1538
1539 /* Return an error if the command failed. */
1540 return (rq->flags & REQ_FAILED) ? -EIO : 0;
1541}
1542
1543/*
1544 * Write handling
1545 */
858119e1 1546static int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
1da177e4
LT		 1547{
1548 /* Two notes about IDE interrupt reason here - 0 means that
1549 * the drive wants to receive data from us, 2 means that
1550 * the drive is expecting to transfer data to us.
1551 */
1552 if (ireason == 0)
1553 return 0;
1554 else if (ireason == 2) {
1555 /* Whoops... The drive wants to send data. */
1556 printk(KERN_ERR "%s: write_intr: wrong transfer direction!\n",
1557 drive->name);
1558
1559 while (len > 0) {
1560 int dum = 0;
1561 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1562 len -= sizeof(dum);
1563 }
1564 } else {
1565 /* Drive wants a command packet, or invalid ireason... */
1566 printk(KERN_ERR "%s: write_intr: bad interrupt reason %x\n",
1567 drive->name, ireason);
1568 }
1569
1570 cdrom_end_request(drive, 0);
1571 return 1;
1572}
1573
1574static void post_transform_command(struct request *req)
1575{
1576 u8 *c = req->cmd;
1577 char *ibuf;
1578
1579 if (!blk_pc_request(req))
1580 return;
1581
1582 if (req->bio)
1583 ibuf = bio_data(req->bio);
1584 else
1585 ibuf = req->data;
1586
1587 if (!ibuf)
1588 return;
1589
1590 /*
1591 * set ansi-revision and response data as atapi
1592 */
1593 if (c[0] == GPCMD_INQUIRY) {
1594 ibuf[2] |= 2;
1595 ibuf[3] = (ibuf[3] & 0xf0) | 2;
1596 }
1597}
1598
1599typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
1600
1601/*
1602 * best way to deal with dma that is not sector aligned right now... note
1603 * that in this path we are not using ->data or ->buffer at all. this irs
1604 * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the
1605 * future.
1606 */
1607static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1608{
1609 struct cdrom_info *info = drive->driver_data;
1610 struct request *rq = HWGROUP(drive)->rq;
1611 int dma_error, dma, stat, ireason, len, thislen;
1612 u8 lowcyl, highcyl;
1613 xfer_func_t *xferfunc;
1614 unsigned long flags;
1615
1616 /* Check for errors. */
1617 dma_error = 0;
1618 dma = info->dma;
1619 if (dma) {
1620 info->dma = 0;
1621 dma_error = HWIF(drive)->ide_dma_end(drive);
1622 }
1623
1624 if (cdrom_decode_status(drive, 0, &stat))
1625 return ide_stopped;
1626
1627 /*
1628 * using dma, transfer is complete now
1629 */
1630 if (dma) {
1631 if (dma_error) {
1632 printk(KERN_ERR "ide-cd: dma error\n");
1633 __ide_dma_off(drive);
1634 return ide_error(drive, "dma error", stat);
1635 }
1636
1637 end_that_request_chunk(rq, 1, rq->data_len);
1638 rq->data_len = 0;
1639 goto end_request;
1640 }
1641
1642 /*
1643 * ok we fall to pio :/
1644 */
1645 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1646 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1647 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1648
1649 len = lowcyl + (256 * highcyl);
1650 thislen = rq->data_len;
1651 if (thislen > len)
1652 thislen = len;
1653
1654 /*
1655 * If DRQ is clear, the command has completed.
1656 */
1657 if ((stat & DRQ_STAT) == 0)
1658 goto end_request;
1659
1660 /*
1661 * check which way to transfer data
1662 */
1663 if (rq_data_dir(rq) == WRITE) {
1664 /*
1665 * write to drive
1666 */
1667 if (cdrom_write_check_ireason(drive, len, ireason))
1668 return ide_stopped;
1669
1670 xferfunc = HWIF(drive)->atapi_output_bytes;
1671 } else {
1672 /*
1673 * read from drive
1674 */
1675 if (cdrom_read_check_ireason(drive, len, ireason))
1676 return ide_stopped;
1677
1678 xferfunc = HWIF(drive)->atapi_input_bytes;
1679 }
1680
1681 /*
1682 * transfer data
1683 */
1684 while (thislen > 0) {
1685 int blen = blen = rq->data_len;
1686 char *ptr = rq->data;
1687
1688 /*
1689 * bio backed?
1690 */
1691 if (rq->bio) {
1692 ptr = bio_data(rq->bio);
1693 blen = bio_iovec(rq->bio)->bv_len;
1694 }
1695
1696 if (!ptr) {
1697 printk(KERN_ERR "%s: confused, missing data\n", drive->name);
1698 break;
1699 }
1700
1701 if (blen > thislen)
1702 blen = thislen;
1703
1704 xferfunc(drive, ptr, blen);
1705
1706 thislen -= blen;
1707 len -= blen;
1708 rq->data_len -= blen;
1709
1710 if (rq->bio)
1711 end_that_request_chunk(rq, 1, blen);
1712 else
1713 rq->data += blen;
1714 }
1715
1716 /*
1717 * pad, if necessary
1718 */
1719 if (len > 0) {
1720 while (len > 0) {
1721 int pad = 0;
1722
1723 xferfunc(drive, &pad, sizeof(pad));
1724 len -= sizeof(pad);
1725 }
1726 }
1727
125e1874 1728 BUG_ON(HWGROUP(drive)->handler != NULL);
1da177e4
LT		 1729
1730 ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, NULL);
1731 return ide_started;
1732
1733end_request:
1734 if (!rq->data_len)
1735 post_transform_command(rq);
1736
1737 spin_lock_irqsave(&ide_lock, flags);
1738 blkdev_dequeue_request(rq);
8ffdc655 1739 end_that_request_last(rq, 1);
1da177e4
LT		 1740 HWGROUP(drive)->rq = NULL;
1741 spin_unlock_irqrestore(&ide_lock, flags);
1742 return ide_stopped;
1743}
1744
1745static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
1746{
1747 int stat, ireason, len, sectors_to_transfer, uptodate;
1748 struct cdrom_info *info = drive->driver_data;
1749 int dma_error = 0, dma = info->dma;
1750 u8 lowcyl = 0, highcyl = 0;
1751
1752 struct request *rq = HWGROUP(drive)->rq;
1753
1754 /* Check for errors. */
1755 if (dma) {
1756 info->dma = 0;
1757 if ((dma_error = HWIF(drive)->ide_dma_end(drive))) {
1758 printk(KERN_ERR "ide-cd: write dma error\n");
1759 __ide_dma_off(drive);
1760 }
1761 }
1762
1763 if (cdrom_decode_status(drive, 0, &stat))
1764 return ide_stopped;
1765
1766 /*
1767 * using dma, transfer is complete now
1768 */
1769 if (dma) {
1770 if (dma_error)
1771 return ide_error(drive, "dma error", stat);
1772
1773 ide_end_request(drive, 1, rq->nr_sectors);
1774 return ide_stopped;
1775 }
1776
1777 /* Read the interrupt reason and the transfer length. */
1778 ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1779 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1780 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1781
1782 len = lowcyl + (256 * highcyl);
1783
1784 /* If DRQ is clear, the command has completed. */
1785 if ((stat & DRQ_STAT) == 0) {
1786 /* If we're not done writing, complain.
1787 * Otherwise, complete the command normally.
1788 */
1789 uptodate = 1;
1790 if (rq->current_nr_sectors > 0) {
1791 printk(KERN_ERR "%s: write_intr: data underrun (%d blocks)\n",
1792 drive->name, rq->current_nr_sectors);
1793 uptodate = 0;
1794 }
1795 cdrom_end_request(drive, uptodate);
1796 return ide_stopped;
1797 }
1798
1799 /* Check that the drive is expecting to do the same thing we are. */
1800 if (cdrom_write_check_ireason(drive, len, ireason))
1801 return ide_stopped;
1802
1803 sectors_to_transfer = len / SECTOR_SIZE;
1804
1805 /*
1806 * now loop and write out the data
1807 */
1808 while (sectors_to_transfer > 0) {
1809 int this_transfer;
1810
1811 if (!rq->current_nr_sectors) {
1812 printk(KERN_ERR "ide-cd: write_intr: oops\n");
1813 break;
1814 }
1815
1816 /*
1817 * Figure out how many sectors we can transfer
1818 */
1819 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors);
1820
1821 while (this_transfer > 0) {
1822 HWIF(drive)->atapi_output_bytes(drive, rq->buffer, SECTOR_SIZE);
1823 rq->buffer += SECTOR_SIZE;
1824 --rq->nr_sectors;
1825 --rq->current_nr_sectors;
1826 ++rq->sector;
1827 --this_transfer;
1828 --sectors_to_transfer;
1829 }
1830
1831 /*
1832 * current buffer complete, move on
1833 */
1834 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1835 cdrom_end_request(drive, 1);
1836 }
1837
1838 /* re-arm handler */
1839 ide_set_handler(drive, &cdrom_write_intr, ATAPI_WAIT_PC, NULL);
1840 return ide_started;
1841}
1842
1843static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
1844{
1845 struct request *rq = HWGROUP(drive)->rq;
1846
1847#if 0 /* the immediate bit */
1848 rq->cmd[1] = 1 << 3;
1849#endif
1850 rq->timeout = ATAPI_WAIT_PC;
1851
1852 return cdrom_transfer_packet_command(drive, rq, cdrom_write_intr);
1853}
1854
1855static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
1856{
1857 struct cdrom_info *info = drive->driver_data;
1858 struct gendisk *g = info->disk;
1859 unsigned short sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1860
1861 /*
1862 * writes *must* be hardware frame aligned
1863 */
1864 if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1865 (rq->sector & (sectors_per_frame - 1))) {
1866 cdrom_end_request(drive, 0);
1867 return ide_stopped;
1868 }
1869
1870 /*
1871 * disk has become write protected
1872 */
1873 if (g->policy) {
1874 cdrom_end_request(drive, 0);
1875 return ide_stopped;
1876 }
1877
1da177e4
LT		 1878 info->nsectors_buffered = 0;
1879
1880 /* use dma, if possible. we don't need to check more, since we
1881 * know that the transfer is always (at least!) frame aligned */
1882 info->dma = drive->using_dma ? 1 : 0;
1da177e4
LT		 1883
1884 info->devinfo.media_written = 1;
1885
1886 /* Start sending the write request to the drive. */
1887 return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
1888}
1889
1890static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1891{
1892 struct request *rq = HWGROUP(drive)->rq;
1893
1894 if (!rq->timeout)
1895 rq->timeout = ATAPI_WAIT_PC;
1896
1897 return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1898}
1899
1900static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1901{
1902 struct cdrom_info *info = drive->driver_data;
1903
1904 rq->flags |= REQ_QUIET;
1905
1906 info->dma = 0;
1da177e4
LT		 1907
1908 /*
1909 * sg request
1910 */
1911 if (rq->bio) {
1912 int mask = drive->queue->dma_alignment;
1913 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
1914
1da177e4
LT		 1915 info->dma = drive->using_dma;
1916
1917 /*
1918 * check if dma is safe
5d9e4ea5
LT		 1919 *
1920 * NOTE! The "len" and "addr" checks should possibly have
1921 * separate masks.
1da177e4 1922 */
4e7c6816 1923 if ((rq->data_len & 15) || (addr & mask))
1da177e4
LT		 1924 info->dma = 0;
1925 }
1926
1927 /* Start sending the command to the drive. */
1928 return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1929}
1930
1931/****************************************************************************
1932 * cdrom driver request routine.
1933 */
1934static ide_startstop_t
1935ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1936{
1937 ide_startstop_t action;
1938 struct cdrom_info *info = drive->driver_data;
1939
1940 if (blk_fs_request(rq)) {
1941 if (CDROM_CONFIG_FLAGS(drive)->seeking) {
1942 unsigned long elapsed = jiffies - info->start_seek;
1943 int stat = HWIF(drive)->INB(IDE_STATUS_REG);
1944
1945 if ((stat & SEEK_STAT) != SEEK_STAT) {
1946 if (elapsed < IDECD_SEEK_TIMEOUT) {
1947 ide_stall_queue(drive, IDECD_SEEK_TIMER);
1948 return ide_stopped;
1949 }
1950 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
1951 }
1952 CDROM_CONFIG_FLAGS(drive)->seeking = 0;
1953 }
1954 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
1955 action = cdrom_start_seek(drive, block);
1956 } else {
1957 if (rq_data_dir(rq) == READ)
1958 action = cdrom_start_read(drive, block);
1959 else
1960 action = cdrom_start_write(drive, rq);
1961 }
1962 info->last_block = block;
1963 return action;
1964 } else if (rq->flags & (REQ_PC | REQ_SENSE)) {
1965 return cdrom_do_packet_command(drive);
1966 } else if (rq->flags & REQ_BLOCK_PC) {
1967 return cdrom_do_block_pc(drive, rq);
1968 } else if (rq->flags & REQ_SPECIAL) {
1969 /*
1970 * right now this can only be a reset...
1971 */
1972 cdrom_end_request(drive, 1);
1973 return ide_stopped;
1974 }
1975
1976 blk_dump_rq_flags(rq, "ide-cd bad flags");
1977 cdrom_end_request(drive, 0);
1978 return ide_stopped;
1979}
1980
1981
1982
1983/****************************************************************************
1984 * Ioctl handling.
1985 *
1986 * Routines which queue packet commands take as a final argument a pointer
1987 * to a request_sense struct. If execution of the command results
1988 * in an error with a CHECK CONDITION status, this structure will be filled
1989 * with the results of the subsequent request sense command. The pointer
1990 * can also be NULL, in which case no sense information is returned.
1991 */
1992
1993#if ! STANDARD_ATAPI
1994static inline
1995int bin2bcd (int x)
1996{
1997 return (x%10) | ((x/10) << 4);
1998}
1999
2000
2001static inline
2002int bcd2bin (int x)
2003{
2004 return (x >> 4) * 10 + (x & 0x0f);
2005}
2006
2007static
2008void msf_from_bcd (struct atapi_msf *msf)
2009{
2010 msf->minute = bcd2bin (msf->minute);
2011 msf->second = bcd2bin (msf->second);
2012 msf->frame = bcd2bin (msf->frame);
2013}
2014
2015#endif /* not STANDARD_ATAPI */
2016
2017
2018static inline
2019void lba_to_msf (int lba, byte *m, byte *s, byte *f)
2020{
2021 lba += CD_MSF_OFFSET;
2022 lba &= 0xffffff; /* negative lbas use only 24 bits */
2023 *m = lba / (CD_SECS * CD_FRAMES);
2024 lba %= (CD_SECS * CD_FRAMES);
2025 *s = lba / CD_FRAMES;
2026 *f = lba % CD_FRAMES;
2027}
2028
2029
2030static inline
2031int msf_to_lba (byte m, byte s, byte f)
2032{
2033 return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
2034}
2035
2036static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
2037{
2038 struct request req;
2039 struct cdrom_info *info = drive->driver_data;
2040 struct cdrom_device_info *cdi = &info->devinfo;
2041
2042 cdrom_prepare_request(drive, &req);
2043
2044 req.sense = sense;
2045 req.cmd[0] = GPCMD_TEST_UNIT_READY;
2046 req.flags |= REQ_QUIET;
2047
2048#if ! STANDARD_ATAPI
2049 /* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
2050 switch CDs instead of supporting the LOAD_UNLOAD opcode */
2051
2052 req.cmd[7] = cdi->sanyo_slot % 3;
2053#endif /* not STANDARD_ATAPI */
2054
2055 return cdrom_queue_packet_command(drive, &req);
2056}
2057
2058
2059/* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
2060static int
2061cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
2062{
2063 struct request_sense my_sense;
2064 struct request req;
2065 int stat;
2066
2067 if (sense == NULL)
2068 sense = &my_sense;
2069
2070 /* If the drive cannot lock the door, just pretend. */
2071 if (CDROM_CONFIG_FLAGS(drive)->no_doorlock) {
2072 stat = 0;
2073 } else {
2074 cdrom_prepare_request(drive, &req);
2075 req.sense = sense;
2076 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
2077 req.cmd[4] = lockflag ? 1 : 0;
2078 stat = cdrom_queue_packet_command(drive, &req);
2079 }
2080
2081 /* If we got an illegal field error, the drive
2082 probably cannot lock the door. */
2083 if (stat != 0 &&
2084 sense->sense_key == ILLEGAL_REQUEST &&
2085 (sense->asc == 0x24 || sense->asc == 0x20)) {
2086 printk (KERN_ERR "%s: door locking not supported\n",
2087 drive->name);
2088 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2089 stat = 0;
2090 }
2091
2092 /* no medium, that's alright. */
2093 if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
2094 stat = 0;
2095
2096 if (stat == 0)
2097 CDROM_STATE_FLAGS(drive)->door_locked = lockflag;
2098
2099 return stat;
2100}
2101
2102
2103/* Eject the disk if EJECTFLAG is 0.
2104 If EJECTFLAG is 1, try to reload the disk. */
2105static int cdrom_eject(ide_drive_t *drive, int ejectflag,
2106 struct request_sense *sense)
2107{
2108 struct request req;
2109 char loej = 0x02;
2110
2111 if (CDROM_CONFIG_FLAGS(drive)->no_eject && !ejectflag)
2112 return -EDRIVE_CANT_DO_THIS;
2113
2114 /* reload fails on some drives, if the tray is locked */
2115 if (CDROM_STATE_FLAGS(drive)->door_locked && ejectflag)
2116 return 0;
2117
2118 cdrom_prepare_request(drive, &req);
2119
2120 /* only tell drive to close tray if open, if it can do that */
2121 if (ejectflag && !CDROM_CONFIG_FLAGS(drive)->close_tray)
2122 loej = 0;
2123
2124 req.sense = sense;
2125 req.cmd[0] = GPCMD_START_STOP_UNIT;
2126 req.cmd[4] = loej | (ejectflag != 0);
2127 return cdrom_queue_packet_command(drive, &req);
2128}
2129
2130static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
2131 unsigned long *sectors_per_frame,
2132 struct request_sense *sense)
2133{
2134 struct {
2135 __u32 lba;
2136 __u32 blocklen;
2137 } capbuf;
2138
2139 int stat;
2140 struct request req;
2141
2142 cdrom_prepare_request(drive, &req);
2143
2144 req.sense = sense;
2145 req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
2146 req.data = (char *)&capbuf;
2147 req.data_len = sizeof(capbuf);
b8fca1c7 2148 req.flags |= REQ_QUIET;
1da177e4
LT		 2149
2150 stat = cdrom_queue_packet_command(drive, &req);
2151 if (stat == 0) {
2152 *capacity = 1 + be32_to_cpu(capbuf.lba);
2153 *sectors_per_frame =
2154 be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
2155 }
2156
2157 return stat;
2158}
2159
2160static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
2161 int format, char *buf, int buflen,
2162 struct request_sense *sense)
2163{
2164 struct request req;
2165
2166 cdrom_prepare_request(drive, &req);
2167
2168 req.sense = sense;
2169 req.data = buf;
2170 req.data_len = buflen;
2171 req.flags |= REQ_QUIET;
2172 req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
2173 req.cmd[6] = trackno;
2174 req.cmd[7] = (buflen >> 8);
2175 req.cmd[8] = (buflen & 0xff);
2176 req.cmd[9] = (format << 6);
2177
2178 if (msf_flag)
2179 req.cmd[1] = 2;
2180
2181 return cdrom_queue_packet_command(drive, &req);
2182}
2183
2184
2185/* Try to read the entire TOC for the disk into our internal buffer. */
2186static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2187{
2188 int stat, ntracks, i;
2189 struct cdrom_info *info = drive->driver_data;
2190 struct cdrom_device_info *cdi = &info->devinfo;
2191 struct atapi_toc *toc = info->toc;
2192 struct {
2193 struct atapi_toc_header hdr;
2194 struct atapi_toc_entry ent;
2195 } ms_tmp;
2196 long last_written;
2197 unsigned long sectors_per_frame = SECTORS_PER_FRAME;
2198
2199 if (toc == NULL) {
2200 /* Try to allocate space. */
2a91f3e5 2201 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
1da177e4
LT		 2202 if (toc == NULL) {
2203 printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
2204 return -ENOMEM;
2205 }
2a91f3e5 2206 info->toc = toc;
1da177e4
LT		 2207 }
2208
2209 /* Check to see if the existing data is still valid.
2210 If it is, just return. */
2211 (void) cdrom_check_status(drive, sense);
2212
2213 if (CDROM_STATE_FLAGS(drive)->toc_valid)
2214 return 0;
2215
2216 /* Try to get the total cdrom capacity and sector size. */
2217 stat = cdrom_read_capacity(drive, &toc->capacity, &sectors_per_frame,
2218 sense);
2219 if (stat)
2220 toc->capacity = 0x1fffff;
2221
2222 set_capacity(info->disk, toc->capacity * sectors_per_frame);
2223 blk_queue_hardsect_size(drive->queue,
2224 sectors_per_frame << SECTOR_BITS);
2225
2226 /* First read just the header, so we know how long the TOC is. */
2227 stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
2228 sizeof(struct atapi_toc_header), sense);
2a91f3e5
JJ		 2229 if (stat)
2230 return stat;
1da177e4
LT		 2231
2232#if ! STANDARD_ATAPI
2233 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2234 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2235 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2236 }
2237#endif /* not STANDARD_ATAPI */
2238
2239 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2240 if (ntracks <= 0)
2241 return -EIO;
2242 if (ntracks > MAX_TRACKS)
2243 ntracks = MAX_TRACKS;
2244
2245 /* Now read the whole schmeer. */
2246 stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
2247 (char *)&toc->hdr,
2248 sizeof(struct atapi_toc_header) +
2249 (ntracks + 1) *
2250 sizeof(struct atapi_toc_entry), sense);
2251
2252 if (stat && toc->hdr.first_track > 1) {
2253 /* Cds with CDI tracks only don't have any TOC entries,
2254 despite of this the returned values are
2255 first_track == last_track = number of CDI tracks + 1,
2256 so that this case is indistinguishable from the same
2257 layout plus an additional audio track.
2258 If we get an error for the regular case, we assume
2259 a CDI without additional audio tracks. In this case
2260 the readable TOC is empty (CDI tracks are not included)