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