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