blob: 78e3e7b24d7d62fb12bb2736f001d95894b1d42b [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;
434 const char *s;
435 char buf[80];
436
437 printk ("ATAPI device %s:\n", drive->name);
438 if (sense->error_code==0x70)
439 printk(" Error: ");
440 else if (sense->error_code==0x71)
441 printk(" Deferred Error: ");
442 else if (sense->error_code == 0x7f)
443 printk(" Vendor-specific Error: ");
444 else
445 printk(" Unknown Error Type: ");
446
447 if (sense->sense_key < ARY_LEN(sense_key_texts))
448 s = sense_key_texts[sense->sense_key];
449 else
450 s = "bad sense key!";
451
452 printk("%s -- (Sense key=0x%02x)\n", s, sense->sense_key);
453
454 if (sense->asc == 0x40) {
455 sprintf(buf, "Diagnostic failure on component 0x%02x",
456 sense->ascq);
457 s = buf;
458 } else {
459 int lo = 0, mid, hi = ARY_LEN(sense_data_texts);
460 unsigned long key = (sense->sense_key << 16);
461 key |= (sense->asc << 8);
462 if (!(sense->ascq >= 0x80 && sense->ascq <= 0xdd))
463 key |= sense->ascq;
464 s = NULL;
465
466 while (hi > lo) {
467 mid = (lo + hi) / 2;
468 if (sense_data_texts[mid].asc_ascq == key ||
469 sense_data_texts[mid].asc_ascq == (0xff0000|key)) {
470 s = sense_data_texts[mid].text;
471 break;
472 }
473 else if (sense_data_texts[mid].asc_ascq > key)
474 hi = mid;
475 else
476 lo = mid+1;
477 }
478 }
479
480 if (s == NULL) {
481 if (sense->asc > 0x80)
482 s = "(vendor-specific error)";
483 else
484 s = "(reserved error code)";
485 }
486
487 printk(KERN_ERR " %s -- (asc=0x%02x, ascq=0x%02x)\n",
488 s, sense->asc, sense->ascq);
489
490 if (failed_command != NULL) {
491
492 int lo=0, mid, hi= ARY_LEN (packet_command_texts);
493 s = NULL;
494
495 while (hi > lo) {
496 mid = (lo + hi) / 2;
497 if (packet_command_texts[mid].packet_command ==
498 failed_command->cmd[0]) {
499 s = packet_command_texts[mid].text;
500 break;
501 }
502 if (packet_command_texts[mid].packet_command >
503 failed_command->cmd[0])
504 hi = mid;
505 else
506 lo = mid+1;
507 }
508
509 printk (KERN_ERR " The failed \"%s\" packet command was: \n \"", s);
510 for (i=0; i<sizeof (failed_command->cmd); i++)
511 printk ("%02x ", failed_command->cmd[i]);
512 printk ("\"\n");
513 }
514
515 /* The SKSV bit specifies validity of the sense_key_specific
516 * in the next two commands. It is bit 7 of the first byte.
517 * In the case of NOT_READY, if SKSV is set the drive can
518 * give us nice ETA readings.
519 */
520 if (sense->sense_key == NOT_READY && (sense->sks[0] & 0x80)) {
521 int progress = (sense->sks[1] << 8 | sense->sks[2]) * 100;
522 printk(KERN_ERR " Command is %02d%% complete\n", progress / 0xffff);
523
524 }
525
526 if (sense->sense_key == ILLEGAL_REQUEST &&
527 (sense->sks[0] & 0x80) != 0) {
528 printk(KERN_ERR " Error in %s byte %d",
529 (sense->sks[0] & 0x40) != 0 ?
530 "command packet" : "command data",
531 (sense->sks[1] << 8) + sense->sks[2]);
532
533 if ((sense->sks[0] & 0x40) != 0)
534 printk (" bit %d", sense->sks[0] & 0x07);
535
536 printk ("\n");
537 }
538 }
539
540#else /* not VERBOSE_IDE_CD_ERRORS */
541
542 /* Suppress printing unit attention and `in progress of becoming ready'
543 errors when we're not being verbose. */
544
545 if (sense->sense_key == UNIT_ATTENTION ||
546 (sense->sense_key == NOT_READY && (sense->asc == 4 ||
547 sense->asc == 0x3a)))
548 return;
549
550 printk(KERN_ERR "%s: error code: 0x%02x sense_key: 0x%02x asc: 0x%02x ascq: 0x%02x\n",
551 drive->name,
552 sense->error_code, sense->sense_key,
553 sense->asc, sense->ascq);
554#endif /* not VERBOSE_IDE_CD_ERRORS */
555}
556
557/*
558 * Initialize a ide-cd packet command request
559 */
560static void cdrom_prepare_request(ide_drive_t *drive, struct request *rq)
561{
562 struct cdrom_info *cd = drive->driver_data;
563
564 ide_init_drive_cmd(rq);
565 rq->flags = REQ_PC;
566 rq->rq_disk = cd->disk;
567}
568
569static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense,
570 struct request *failed_command)
571{
572 struct cdrom_info *info = drive->driver_data;
573 struct request *rq = &info->request_sense_request;
574
575 if (sense == NULL)
576 sense = &info->sense_data;
577
578 /* stuff the sense request in front of our current request */
579 cdrom_prepare_request(drive, rq);
580
581 rq->data = sense;
582 rq->cmd[0] = GPCMD_REQUEST_SENSE;
583 rq->cmd[4] = rq->data_len = 18;
584
585 rq->flags = REQ_SENSE;
586
587 /* NOTE! Save the failed command in "rq->buffer" */
588 rq->buffer = (void *) failed_command;
589
590 (void) ide_do_drive_cmd(drive, rq, ide_preempt);
591}
592
593static void cdrom_end_request (ide_drive_t *drive, int uptodate)
594{
595 struct request *rq = HWGROUP(drive)->rq;
596 int nsectors = rq->hard_cur_sectors;
597
598 if ((rq->flags & REQ_SENSE) && uptodate) {
599 /*
600 * For REQ_SENSE, "rq->buffer" points to the original failed
601 * request
602 */
603 struct request *failed = (struct request *) rq->buffer;
604 struct cdrom_info *info = drive->driver_data;
605 void *sense = &info->sense_data;
606 unsigned long flags;
607
608 if (failed) {
609 if (failed->sense) {
610 sense = failed->sense;
611 failed->sense_len = rq->sense_len;
612 }
613
614 /*
615 * now end failed request
616 */
617 spin_lock_irqsave(&ide_lock, flags);
618 end_that_request_chunk(failed, 0, failed->data_len);
619 end_that_request_last(failed);
620 spin_unlock_irqrestore(&ide_lock, flags);
621 }
622
623 cdrom_analyze_sense_data(drive, failed, sense);
624 }
625
626 if (!rq->current_nr_sectors && blk_fs_request(rq))
627 uptodate = 1;
628 /* make sure it's fully ended */
629 if (blk_pc_request(rq))
630 nsectors = (rq->data_len + 511) >> 9;
631 if (!nsectors)
632 nsectors = 1;
633
634 ide_end_request(drive, uptodate, nsectors);
635}
636
637/* Returns 0 if the request should be continued.
638 Returns 1 if the request was ended. */
639static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
640{
641 struct request *rq = HWGROUP(drive)->rq;
642 int stat, err, sense_key;
643
644 /* Check for errors. */
645 stat = HWIF(drive)->INB(IDE_STATUS_REG);
646 if (stat_ret)
647 *stat_ret = stat;
648
649 if (OK_STAT(stat, good_stat, BAD_R_STAT))
650 return 0;
651
652 /* Get the IDE error register. */
653 err = HWIF(drive)->INB(IDE_ERROR_REG);
654 sense_key = err >> 4;
655
656 if (rq == NULL) {
657 printk("%s: missing rq in cdrom_decode_status\n", drive->name);
658 return 1;
659 }
660
661 if (rq->flags & REQ_SENSE) {
662 /* We got an error trying to get sense info
663 from the drive (probably while trying
664 to recover from a former error). Just give up. */
665
666 rq->flags |= REQ_FAILED;
667 cdrom_end_request(drive, 0);
668 ide_error(drive, "request sense failure", stat);
669 return 1;
670
671 } else if (rq->flags & (REQ_PC | REQ_BLOCK_PC)) {
672 /* All other functions, except for READ. */
673 unsigned long flags;
674
675 /*
676 * if we have an error, pass back CHECK_CONDITION as the
677 * scsi status byte
678 */
679 if ((rq->flags & REQ_BLOCK_PC) && !rq->errors)
680 rq->errors = SAM_STAT_CHECK_CONDITION;
681
682 /* Check for tray open. */
683 if (sense_key == NOT_READY) {
684 cdrom_saw_media_change (drive);
685 } else if (sense_key == UNIT_ATTENTION) {
686 /* Check for media change. */
687 cdrom_saw_media_change (drive);
688 /*printk("%s: media changed\n",drive->name);*/
689 return 0;
690 } else if (!(rq->flags & REQ_QUIET)) {
691 /* Otherwise, print an error. */
692 ide_dump_status(drive, "packet command error", stat);
693 }
694
695 rq->flags |= REQ_FAILED;
696
697 /*
698 * instead of playing games with moving completions around,
699 * remove failed request completely and end it when the
700 * request sense has completed
701 */
702 if (stat & ERR_STAT) {
703 spin_lock_irqsave(&ide_lock, flags);
704 blkdev_dequeue_request(rq);
705 HWGROUP(drive)->rq = NULL;
706 spin_unlock_irqrestore(&ide_lock, flags);
707
708 cdrom_queue_request_sense(drive, rq->sense, rq);
709 } else
710 cdrom_end_request(drive, 0);
711
712 } else if (blk_fs_request(rq)) {
713 int do_end_request = 0;
714
715 /* Handle errors from READ and WRITE requests. */
716
717 if (blk_noretry_request(rq))
718 do_end_request = 1;
719
720 if (sense_key == NOT_READY) {
721 /* Tray open. */
722 if (rq_data_dir(rq) == READ) {
723 cdrom_saw_media_change (drive);
724
725 /* Fail the request. */
726 printk ("%s: tray open\n", drive->name);
727 do_end_request = 1;
728 } else {
729 struct cdrom_info *info = drive->driver_data;
730
731 /* allow the drive 5 seconds to recover, some
732 * devices will return this error while flushing
733 * data from cache */
734 if (!rq->errors)
735 info->write_timeout = jiffies + ATAPI_WAIT_WRITE_BUSY;
736 rq->errors = 1;
737 if (time_after(jiffies, info->write_timeout))
738 do_end_request = 1;
739 else {
740 unsigned long flags;
741
742 /*
743 * take a breather relying on the
744 * unplug timer to kick us again
745 */
746 spin_lock_irqsave(&ide_lock, flags);
747 blk_plug_device(drive->queue);
748 spin_unlock_irqrestore(&ide_lock,flags);
749 return 1;
750 }
751 }
752 } else if (sense_key == UNIT_ATTENTION) {
753 /* Media change. */
754 cdrom_saw_media_change (drive);
755
756 /* Arrange to retry the request.
757 But be sure to give up if we've retried
758 too many times. */
759 if (++rq->errors > ERROR_MAX)
760 do_end_request = 1;
761 } else if (sense_key == ILLEGAL_REQUEST ||
762 sense_key == DATA_PROTECT) {
763 /* No point in retrying after an illegal
764 request or data protect error.*/
765 ide_dump_status (drive, "command error", stat);
766 do_end_request = 1;
767 } else if (sense_key == MEDIUM_ERROR) {
768 /* No point in re-trying a zillion times on a bad
769 * sector... If we got here the error is not correctable */
770 ide_dump_status (drive, "media error (bad sector)", stat);
771 do_end_request = 1;
772 } else if (sense_key == BLANK_CHECK) {
773 /* Disk appears blank ?? */
774 ide_dump_status (drive, "media error (blank)", stat);
775 do_end_request = 1;
776 } else if ((err & ~ABRT_ERR) != 0) {
777 /* Go to the default handler
778 for other errors. */
779 ide_error(drive, "cdrom_decode_status", stat);
780 return 1;
781 } else if ((++rq->errors > ERROR_MAX)) {
782 /* We've racked up too many retries. Abort. */
783 do_end_request = 1;
784 }
785
786 if (do_end_request)
787 cdrom_end_request(drive, 0);
788
789 /* If we got a CHECK_CONDITION status,
790 queue a request sense command. */
791 if ((stat & ERR_STAT) != 0)
792 cdrom_queue_request_sense(drive, NULL, NULL);
793 } else {
794 blk_dump_rq_flags(rq, "ide-cd: bad rq");
795 cdrom_end_request(drive, 0);
796 }
797
798 /* Retry, or handle the next request. */
799 return 1;
800}
801
802static int cdrom_timer_expiry(ide_drive_t *drive)
803{
804 struct request *rq = HWGROUP(drive)->rq;
805 unsigned long wait = 0;
806
807 /*
808 * Some commands are *slow* and normally take a long time to
809 * complete. Usually we can use the ATAPI "disconnect" to bypass
810 * this, but not all commands/drives support that. Let
811 * ide_timer_expiry keep polling us for these.
812 */
813 switch (rq->cmd[0]) {
814 case GPCMD_BLANK:
815 case GPCMD_FORMAT_UNIT:
816 case GPCMD_RESERVE_RZONE_TRACK:
817 case GPCMD_CLOSE_TRACK:
818 case GPCMD_FLUSH_CACHE:
819 wait = ATAPI_WAIT_PC;
820 break;
821 default:
822 if (!(rq->flags & REQ_QUIET))
823 printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n", rq->cmd[0]);
824 wait = 0;
825 break;
826 }
827 return wait;
828}
829
830/* Set up the device registers for transferring a packet command on DEV,
831 expecting to later transfer XFERLEN bytes. HANDLER is the routine
832 which actually transfers the command to the drive. If this is a
833 drq_interrupt device, this routine will arrange for HANDLER to be
834 called when the interrupt from the drive arrives. Otherwise, HANDLER
835 will be called immediately after the drive is prepared for the transfer. */
836
837static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
838 int xferlen,
839 ide_handler_t *handler)
840{
841 ide_startstop_t startstop;
842 struct cdrom_info *info = drive->driver_data;
843 ide_hwif_t *hwif = drive->hwif;
844
845 /* Wait for the controller to be idle. */
846 if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY))
847 return startstop;
848
849 if (info->dma)
850 info->dma = !hwif->dma_setup(drive);
851
852 /* Set up the controller registers. */
853 /* FIXME: for Virtual DMA we must check harder */
854 HWIF(drive)->OUTB(info->dma, IDE_FEATURE_REG);
855 HWIF(drive)->OUTB(0, IDE_IREASON_REG);
856 HWIF(drive)->OUTB(0, IDE_SECTOR_REG);
857
858 HWIF(drive)->OUTB(xferlen & 0xff, IDE_BCOUNTL_REG);
859 HWIF(drive)->OUTB(xferlen >> 8 , IDE_BCOUNTH_REG);
860 if (IDE_CONTROL_REG)
861 HWIF(drive)->OUTB(drive->ctl, IDE_CONTROL_REG);
862
863 if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt) {
864 /* packet command */
865 ide_execute_command(drive, WIN_PACKETCMD, handler, ATAPI_WAIT_PC, cdrom_timer_expiry);
866 return ide_started;
867 } else {
868 unsigned long flags;
869
870 /* packet command */
871 spin_lock_irqsave(&ide_lock, flags);
872 hwif->OUTBSYNC(drive, WIN_PACKETCMD, IDE_COMMAND_REG);
873 ndelay(400);
874 spin_unlock_irqrestore(&ide_lock, flags);
875
876 return (*handler) (drive);
877 }
878}
879
880/* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
881 The device registers must have already been prepared
882 by cdrom_start_packet_command.
883 HANDLER is the interrupt handler to call when the command completes
884 or there's data ready. */
885/*
886 * changed 5 parameters to 3 for dvd-ram
887 * struct packet_command *pc; now packet_command_t *pc;
888 */
889#define ATAPI_MIN_CDB_BYTES 12
890static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
891 struct request *rq,
892 ide_handler_t *handler)
893{
894 ide_hwif_t *hwif = drive->hwif;
895 int cmd_len;
896 struct cdrom_info *info = drive->driver_data;
897 ide_startstop_t startstop;
898
899 if (CDROM_CONFIG_FLAGS(drive)->drq_interrupt) {
900 /* Here we should have been called after receiving an interrupt
901 from the device. DRQ should how be set. */
902
903 /* Check for errors. */
904 if (cdrom_decode_status(drive, DRQ_STAT, NULL))
905 return ide_stopped;
906 } else {
907 /* Otherwise, we must wait for DRQ to get set. */
908 if (ide_wait_stat(&startstop, drive, DRQ_STAT,
909 BUSY_STAT, WAIT_READY))
910 return startstop;
911 }
912
913 /* Arm the interrupt handler. */
914 ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);
915
916 /* ATAPI commands get padded out to 12 bytes minimum */
917 cmd_len = COMMAND_SIZE(rq->cmd[0]);
918 if (cmd_len < ATAPI_MIN_CDB_BYTES)
919 cmd_len = ATAPI_MIN_CDB_BYTES;
920
921 /* Send the command to the device. */
922 HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len);
923
924 /* Start the DMA if need be */
925 if (info->dma)
926 hwif->dma_start(drive);
927
928 return ide_started;
929}
930
931/****************************************************************************
932 * Block read functions.
933 */
934
935/*
936 * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
937 * buffer. Once the first sector is added, any subsequent sectors are
938 * assumed to be continuous (until the buffer is cleared). For the first
939 * sector added, SECTOR is its sector number. (SECTOR is then ignored until
940 * the buffer is cleared.)
941 */
942static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
943 int sectors_to_transfer)
944{
945 struct cdrom_info *info = drive->driver_data;
946
947 /* Number of sectors to read into the buffer. */
948 int sectors_to_buffer = min_t(int, sectors_to_transfer,
949 (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
950 info->nsectors_buffered);
951
952 char *dest;
953
954 /* If we couldn't get a buffer, don't try to buffer anything... */
955 if (info->buffer == NULL)
956 sectors_to_buffer = 0;
957
958 /* If this is the first sector in the buffer, remember its number. */
959 if (info->nsectors_buffered == 0)
960 info->sector_buffered = sector;
961
962 /* Read the data into the buffer. */
963 dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
964 while (sectors_to_buffer > 0) {
965 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
966 --sectors_to_buffer;
967 --sectors_to_transfer;
968 ++info->nsectors_buffered;
969 dest += SECTOR_SIZE;
970 }
971
972 /* Throw away any remaining data. */
973 while (sectors_to_transfer > 0) {
974 static char dum[SECTOR_SIZE];
975 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
976 --sectors_to_transfer;
977 }
978}
979
980/*
981 * Check the contents of the interrupt reason register from the cdrom
982 * and attempt to recover if there are problems. Returns 0 if everything's
983 * ok; nonzero if the request has been terminated.
984 */
985static inline
986int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
987{
988 if (ireason == 2)
989 return 0;
990 else if (ireason == 0) {
991 /* Whoops... The drive is expecting to receive data from us! */
992 printk(KERN_ERR "%s: read_intr: Drive wants to transfer data the "
993 "wrong way!\n", drive->name);
994
995 /* Throw some data at the drive so it doesn't hang
996 and quit this request. */
997 while (len > 0) {
998 int dum = 0;
999 HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof (dum));
1000 len -= sizeof (dum);
1001 }
1002 } else if (ireason == 1) {
1003 /* Some drives (ASUS) seem to tell us that status
1004 * info is available. just get it and ignore.
1005 */
1006 (void) HWIF(drive)->INB(IDE_STATUS_REG);
1007 return 0;
1008 } else {
1009 /* Drive wants a command packet, or invalid ireason... */
1010 printk(KERN_ERR "%s: read_intr: bad interrupt reason %x\n", drive->name,
1011 ireason);
1012 }
1013
1014 cdrom_end_request(drive, 0);
1015 return -1;
1016}
1017
1018/*
1019 * Interrupt routine. Called when a read request has completed.
1020 */
1021static ide_startstop_t cdrom_read_intr (ide_drive_t *drive)
1022{
1023 int stat;
1024 int ireason, len, sectors_to_transfer, nskip;
1025 struct cdrom_info *info = drive->driver_data;
1026 u8 lowcyl = 0, highcyl = 0;
1027 int dma = info->dma, dma_error = 0;
1028
1029 struct request *rq = HWGROUP(drive)->rq;
1030
1031 /*
1032 * handle dma case
1033 */
1034 if (dma) {
1035 info->dma = 0;
1036 if ((dma_error = HWIF(drive)->ide_dma_end(drive)))
1037 __ide_dma_off(drive);
1038 }
1039
1040 if (cdrom_decode_status(drive, 0, &stat))
1041 return ide_stopped;
1042
1043 if (dma) {
1044 if (!dma_error) {
1045 ide_end_request(drive, 1, rq->nr_sectors);
1046 return ide_stopped;
1047 } else
1048 return ide_error(drive, "dma error", stat);
1049 }
1050
1051 /* Read the interrupt reason and the transfer length. */
1052 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1053 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1054 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1055
1056 len = lowcyl + (256 * highcyl);
1057
1058 /* If DRQ is clear, the command has completed. */
1059 if ((stat & DRQ_STAT) == 0) {
1060 /* If we're not done filling the current buffer, complain.
1061 Otherwise, complete the command normally. */
1062 if (rq->current_nr_sectors > 0) {
1063 printk (KERN_ERR "%s: cdrom_read_intr: data underrun (%d blocks)\n",
1064 drive->name, rq->current_nr_sectors);
1065 rq->flags |= REQ_FAILED;
1066 cdrom_end_request(drive, 0);
1067 } else
1068 cdrom_end_request(drive, 1);
1069 return ide_stopped;
1070 }
1071
1072 /* Check that the drive is expecting to do the same thing we are. */
1073 if (cdrom_read_check_ireason (drive, len, ireason))
1074 return ide_stopped;
1075
1076 /* Assume that the drive will always provide data in multiples
1077 of at least SECTOR_SIZE, as it gets hairy to keep track
1078 of the transfers otherwise. */
1079 if ((len % SECTOR_SIZE) != 0) {
1080 printk (KERN_ERR "%s: cdrom_read_intr: Bad transfer size %d\n",
1081 drive->name, len);
1082 if (CDROM_CONFIG_FLAGS(drive)->limit_nframes)
1083 printk (KERN_ERR " This drive is not supported by this version of the driver\n");
1084 else {
1085 printk (KERN_ERR " Trying to limit transfer sizes\n");
1086 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
1087 }
1088 cdrom_end_request(drive, 0);
1089 return ide_stopped;
1090 }
1091
1092 /* The number of sectors we need to read from the drive. */
1093 sectors_to_transfer = len / SECTOR_SIZE;
1094
1095 /* First, figure out if we need to bit-bucket
1096 any of the leading sectors. */
1097 nskip = min_t(int, rq->current_nr_sectors - bio_cur_sectors(rq->bio), sectors_to_transfer);
1098
1099 while (nskip > 0) {
1100 /* We need to throw away a sector. */
1101 static char dum[SECTOR_SIZE];
1102 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1103
1104 --rq->current_nr_sectors;
1105 --nskip;
1106 --sectors_to_transfer;
1107 }
1108
1109 /* Now loop while we still have data to read from the drive. */
1110 while (sectors_to_transfer > 0) {
1111 int this_transfer;
1112
1113 /* If we've filled the present buffer but there's another
1114 chained buffer after it, move on. */
1115 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1116 cdrom_end_request(drive, 1);
1117
1118 /* If the buffers are full, cache the rest of the data in our
1119 internal buffer. */
1120 if (rq->current_nr_sectors == 0) {
1121 cdrom_buffer_sectors(drive, rq->sector, sectors_to_transfer);
1122 sectors_to_transfer = 0;
1123 } else {
1124 /* Transfer data to the buffers.
1125 Figure out how many sectors we can transfer
1126 to the current buffer. */
1127 this_transfer = min_t(int, sectors_to_transfer,
1128 rq->current_nr_sectors);
1129
1130 /* Read this_transfer sectors
1131 into the current buffer. */
1132 while (this_transfer > 0) {
1133 HWIF(drive)->atapi_input_bytes(drive, rq->buffer, SECTOR_SIZE);
1134 rq->buffer += SECTOR_SIZE;
1135 --rq->nr_sectors;
1136 --rq->current_nr_sectors;
1137 ++rq->sector;
1138 --this_transfer;
1139 --sectors_to_transfer;
1140 }
1141 }
1142 }
1143
1144 /* Done moving data! Wait for another interrupt. */
1145 ide_set_handler(drive, &cdrom_read_intr, ATAPI_WAIT_PC, NULL);
1146 return ide_started;
1147}
1148
1149/*
1150 * Try to satisfy some of the current read request from our cached data.
1151 * Returns nonzero if the request has been completed, zero otherwise.
1152 */
1153static int cdrom_read_from_buffer (ide_drive_t *drive)
1154{
1155 struct cdrom_info *info = drive->driver_data;
1156 struct request *rq = HWGROUP(drive)->rq;
1157 unsigned short sectors_per_frame;
1158
1159 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1160
1161 /* Can't do anything if there's no buffer. */
1162 if (info->buffer == NULL) return 0;
1163
1164 /* Loop while this request needs data and the next block is present
1165 in our cache. */
1166 while (rq->nr_sectors > 0 &&
1167 rq->sector >= info->sector_buffered &&
1168 rq->sector < info->sector_buffered + info->nsectors_buffered) {
1169 if (rq->current_nr_sectors == 0)
1170 cdrom_end_request(drive, 1);
1171
1172 memcpy (rq->buffer,
1173 info->buffer +
1174 (rq->sector - info->sector_buffered) * SECTOR_SIZE,
1175 SECTOR_SIZE);
1176 rq->buffer += SECTOR_SIZE;
1177 --rq->current_nr_sectors;
1178 --rq->nr_sectors;
1179 ++rq->sector;
1180 }
1181
1182 /* If we've satisfied the current request,
1183 terminate it successfully. */
1184 if (rq->nr_sectors == 0) {
1185 cdrom_end_request(drive, 1);
1186 return -1;
1187 }
1188
1189 /* Move on to the next buffer if needed. */
1190 if (rq->current_nr_sectors == 0)
1191 cdrom_end_request(drive, 1);
1192
1193 /* If this condition does not hold, then the kluge i use to
1194 represent the number of sectors to skip at the start of a transfer
1195 will fail. I think that this will never happen, but let's be
1196 paranoid and check. */
1197 if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
1198 (rq->sector & (sectors_per_frame - 1))) {
1199 printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
1200 drive->name, (long)rq->sector);
1201 cdrom_end_request(drive, 0);
1202 return -1;
1203 }
1204
1205 return 0;
1206}
1207
1208/*
1209 * Routine to send a read packet command to the drive.
1210 * This is usually called directly from cdrom_start_read.
1211 * However, for drq_interrupt devices, it is called from an interrupt
1212 * when the drive is ready to accept the command.
1213 */
1214static ide_startstop_t cdrom_start_read_continuation (ide_drive_t *drive)
1215{
1216 struct request *rq = HWGROUP(drive)->rq;
1217 unsigned short sectors_per_frame;
1218 int nskip;
1219
1220 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1221
1222 /* If the requested sector doesn't start on a cdrom block boundary,
1223 we must adjust the start of the transfer so that it does,
1224 and remember to skip the first few sectors.
1225 If the CURRENT_NR_SECTORS field is larger than the size
1226 of the buffer, it will mean that we're to skip a number
1227 of sectors equal to the amount by which CURRENT_NR_SECTORS
1228 is larger than the buffer size. */
1229 nskip = rq->sector & (sectors_per_frame - 1);
1230 if (nskip > 0) {
1231 /* Sanity check... */
1232 if (rq->current_nr_sectors != bio_cur_sectors(rq->bio) &&
1233 (rq->sector & (sectors_per_frame - 1))) {
1234 printk(KERN_ERR "%s: cdrom_start_read_continuation: buffer botch (%u)\n",
1235 drive->name, rq->current_nr_sectors);
1236 cdrom_end_request(drive, 0);
1237 return ide_stopped;
1238 }
1239 rq->current_nr_sectors += nskip;
1240 }
1241
1242 /* Set up the command */
1243 rq->timeout = ATAPI_WAIT_PC;
1244
1245 /* Send the command to the drive and return. */
1246 return cdrom_transfer_packet_command(drive, rq, &cdrom_read_intr);
1247}
1248
1249
1250#define IDECD_SEEK_THRESHOLD (1000) /* 1000 blocks */
1251#define IDECD_SEEK_TIMER (5 * WAIT_MIN_SLEEP) /* 100 ms */
1252#define IDECD_SEEK_TIMEOUT (2 * WAIT_CMD) /* 20 sec */
1253
1254static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
1255{
1256 struct cdrom_info *info = drive->driver_data;
1257 int stat;
1258 static int retry = 10;
1259
1260 if (cdrom_decode_status(drive, 0, &stat))
1261 return ide_stopped;
1262 CDROM_CONFIG_FLAGS(drive)->seeking = 1;
1263
1264 if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
1265 if (--retry == 0) {
1266 /*
1267 * this condition is far too common, to bother
1268 * users about it
1269 */
1270 /* printk("%s: disabled DSC seek overlap\n", drive->name);*/
1271 drive->dsc_overlap = 0;
1272 }
1273 }
1274 return ide_stopped;
1275}
1276
1277static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
1278{
1279 struct request *rq = HWGROUP(drive)->rq;
1280 sector_t frame = rq->sector;
1281
1282 sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
1283
1284 memset(rq->cmd, 0, sizeof(rq->cmd));
1285 rq->cmd[0] = GPCMD_SEEK;
1286 put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
1287
1288 rq->timeout = ATAPI_WAIT_PC;
1289 return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
1290}
1291
1292static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
1293{
1294 struct cdrom_info *info = drive->driver_data;
1295
1296 info->dma = 0;
1297 info->cmd = 0;
1298 info->start_seek = jiffies;
1299 return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
1300}
1301
1302/* Fix up a possibly partially-processed request so that we can
1303 start it over entirely, or even put it back on the request queue. */
1304static void restore_request (struct request *rq)
1305{
1306 if (rq->buffer != bio_data(rq->bio)) {
1307 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
1308
1309 rq->buffer = bio_data(rq->bio);
1310 rq->nr_sectors += n;
1311 rq->sector -= n;
1312 }
1313 rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
1314 rq->hard_nr_sectors = rq->nr_sectors;
1315 rq->hard_sector = rq->sector;
1316 rq->q->prep_rq_fn(rq->q, rq);
1317}
1318
1319/*
1320 * Start a read request from the CD-ROM.
1321 */
1322static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block)
1323{
1324 struct cdrom_info *info = drive->driver_data;
1325 struct request *rq = HWGROUP(drive)->rq;
1326 unsigned short sectors_per_frame;
1327
1328 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1329
1330 /* We may be retrying this request after an error. Fix up
1331 any weirdness which might be present in the request packet. */
1332 restore_request(rq);
1333
1334 /* Satisfy whatever we can of this request from our cached sector. */
1335 if (cdrom_read_from_buffer(drive))
1336 return ide_stopped;
1337
1338 blk_attempt_remerge(drive->queue, rq);
1339
1340 /* Clear the local sector buffer. */
1341 info->nsectors_buffered = 0;
1342
1343 /* use dma, if possible. */
1344 info->dma = drive->using_dma;
1345 if ((rq->sector & (sectors_per_frame - 1)) ||
1346 (rq->nr_sectors & (sectors_per_frame - 1)))
1347 info->dma = 0;
1348
1349 info->cmd = READ;
1350
1351 /* Start sending the read request to the drive. */
1352 return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
1353}
1354
1355/****************************************************************************
1356 * Execute all other packet commands.
1357 */
1358
1359/* Interrupt routine for packet command completion. */
1360static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
1361{
1362 int ireason, len, thislen;
1363 struct request *rq = HWGROUP(drive)->rq;
1364 u8 lowcyl = 0, highcyl = 0;
1365 int stat;
1366
1367 /* Check for errors. */
1368 if (cdrom_decode_status(drive, 0, &stat))
1369 return ide_stopped;
1370
1371 /* Read the interrupt reason and the transfer length. */
1372 ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1373 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1374 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1375
1376 len = lowcyl + (256 * highcyl);
1377
1378 /* If DRQ is clear, the command has completed.
1379 Complain if we still have data left to transfer. */
1380 if ((stat & DRQ_STAT) == 0) {
1381 /* Some of the trailing request sense fields are optional, and
1382 some drives don't send them. Sigh. */
1383 if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
1384 rq->data_len > 0 &&
1385 rq->data_len <= 5) {
1386 while (rq->data_len > 0) {
1387 *(unsigned char *)rq->data++ = 0;
1388 --rq->data_len;
1389 }
1390 }
1391
1392 if (rq->data_len == 0)
1393 cdrom_end_request(drive, 1);
1394 else {
1395 /* Comment this out, because this always happens
1396 right after a reset occurs, and it is annoying to
1397 always print expected stuff. */
1398 /*
1399 printk ("%s: cdrom_pc_intr: data underrun %d\n",
1400 drive->name, pc->buflen);
1401 */
1402 rq->flags |= REQ_FAILED;
1403 cdrom_end_request(drive, 0);
1404 }
1405 return ide_stopped;
1406 }
1407
1408 /* Figure out how much data to transfer. */
1409 thislen = rq->data_len;
1410 if (thislen > len) thislen = len;
1411
1412 /* The drive wants to be written to. */
1413 if ((ireason & 3) == 0) {
1414 if (!rq->data) {
1415 blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1416 goto confused;
1417 }
1418 /* Transfer the data. */
1419 HWIF(drive)->atapi_output_bytes(drive, rq->data, thislen);
1420
1421 /* If we haven't moved enough data to satisfy the drive,
1422 add some padding. */
1423 while (len > thislen) {
1424 int dum = 0;
1425 HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof(dum));
1426 len -= sizeof(dum);
1427 }
1428
1429 /* Keep count of how much data we've moved. */
1430 rq->data += thislen;
1431 rq->data_len -= thislen;
1432 }
1433
1434 /* Same drill for reading. */
1435 else if ((ireason & 3) == 2) {
1436 if (!rq->data) {
1437 blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1438 goto confused;
1439 }
1440 /* Transfer the data. */
1441 HWIF(drive)->atapi_input_bytes(drive, rq->data, thislen);
1442
1443 /* If we haven't moved enough data to satisfy the drive,
1444 add some padding. */
1445 while (len > thislen) {
1446 int dum = 0;
1447 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1448 len -= sizeof(dum);
1449 }
1450
1451 /* Keep count of how much data we've moved. */
1452 rq->data += thislen;
1453 rq->data_len -= thislen;
1454
1455 if (rq->flags & REQ_SENSE)
1456 rq->sense_len += thislen;
1457 } else {
1458confused:
1459 printk (KERN_ERR "%s: cdrom_pc_intr: The drive "
1460 "appears confused (ireason = 0x%02x)\n",
1461 drive->name, ireason);
1462 rq->flags |= REQ_FAILED;
1463 }
1464
1465 /* Now we wait for another interrupt. */
1466 ide_set_handler(drive, &cdrom_pc_intr, ATAPI_WAIT_PC, cdrom_timer_expiry);
1467 return ide_started;
1468}
1469
1470static ide_startstop_t cdrom_do_pc_continuation (ide_drive_t *drive)
1471{
1472 struct request *rq = HWGROUP(drive)->rq;
1473
1474 if (!rq->timeout)
1475 rq->timeout = ATAPI_WAIT_PC;
1476
1477 /* Send the command to the drive and return. */
1478 return cdrom_transfer_packet_command(drive, rq, &cdrom_pc_intr);
1479}
1480
1481
1482static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
1483{
1484 int len;
1485 struct request *rq = HWGROUP(drive)->rq;
1486 struct cdrom_info *info = drive->driver_data;
1487
1488 info->dma = 0;
1489 info->cmd = 0;
1490 rq->flags &= ~REQ_FAILED;
1491 len = rq->data_len;
1492
1493 /* Start sending the command to the drive. */
1494 return cdrom_start_packet_command(drive, len, cdrom_do_pc_continuation);
1495}
1496
1497
1498static
1499int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
1500{
1501 struct request_sense sense;
1502 int retries = 10;
1503 unsigned int flags = rq->flags;
1504
1505 if (rq->sense == NULL)
1506 rq->sense = &sense;
1507
1508 /* Start of retry loop. */
1509 do {
1510 int error;
1511 unsigned long time = jiffies;
1512 rq->flags = flags;
1513
1514 error = ide_do_drive_cmd(drive, rq, ide_wait);
1515 time = jiffies - time;
1516
1517 /* FIXME: we should probably abort/retry or something
1518 * in case of failure */
1519 if (rq->flags & REQ_FAILED) {
1520 /* The request failed. Retry if it was due to a unit
1521 attention status
1522 (usually means media was changed). */
1523 struct request_sense *reqbuf = rq->sense;
1524
1525 if (reqbuf->sense_key == UNIT_ATTENTION)
1526 cdrom_saw_media_change(drive);
1527 else if (reqbuf->sense_key == NOT_READY &&
1528 reqbuf->asc == 4 && reqbuf->ascq != 4) {
1529 /* The drive is in the process of loading
1530 a disk. Retry, but wait a little to give
1531 the drive time to complete the load. */
1532 ssleep(2);
1533 } else {
1534 /* Otherwise, don't retry. */
1535 retries = 0;
1536 }
1537 --retries;
1538 }
1539
1540 /* End of retry loop. */
1541 } while ((rq->flags & REQ_FAILED) && retries >= 0);
1542
1543 /* Return an error if the command failed. */
1544 return (rq->flags & REQ_FAILED) ? -EIO : 0;
1545}
1546
1547/*
1548 * Write handling
1549 */
1550static inline int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
1551{
1552 /* Two notes about IDE interrupt reason here - 0 means that
1553 * the drive wants to receive data from us, 2 means that
1554 * the drive is expecting to transfer data to us.
1555 */
1556 if (ireason == 0)
1557 return 0;
1558 else if (ireason == 2) {
1559 /* Whoops... The drive wants to send data. */
1560 printk(KERN_ERR "%s: write_intr: wrong transfer direction!\n",
1561 drive->name);
1562
1563 while (len > 0) {
1564 int dum = 0;
1565 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1566 len -= sizeof(dum);
1567 }
1568 } else {
1569 /* Drive wants a command packet, or invalid ireason... */
1570 printk(KERN_ERR "%s: write_intr: bad interrupt reason %x\n",
1571 drive->name, ireason);
1572 }
1573
1574 cdrom_end_request(drive, 0);
1575 return 1;
1576}
1577
1578static void post_transform_command(struct request *req)
1579{
1580 u8 *c = req->cmd;
1581 char *ibuf;
1582
1583 if (!blk_pc_request(req))
1584 return;
1585
1586 if (req->bio)
1587 ibuf = bio_data(req->bio);
1588 else
1589 ibuf = req->data;
1590
1591 if (!ibuf)
1592 return;
1593
1594 /*
1595 * set ansi-revision and response data as atapi
1596 */
1597 if (c[0] == GPCMD_INQUIRY) {
1598 ibuf[2] |= 2;
1599 ibuf[3] = (ibuf[3] & 0xf0) | 2;
1600 }
1601}
1602
1603typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
1604
1605/*
1606 * best way to deal with dma that is not sector aligned right now... note
1607 * that in this path we are not using ->data or ->buffer at all. this irs
1608 * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the
1609 * future.
1610 */
1611static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1612{
1613 struct cdrom_info *info = drive->driver_data;
1614 struct request *rq = HWGROUP(drive)->rq;
1615 int dma_error, dma, stat, ireason, len, thislen;
1616 u8 lowcyl, highcyl;
1617 xfer_func_t *xferfunc;
1618 unsigned long flags;
1619
1620 /* Check for errors. */
1621 dma_error = 0;
1622 dma = info->dma;
1623 if (dma) {
1624 info->dma = 0;
1625 dma_error = HWIF(drive)->ide_dma_end(drive);
1626 }
1627
1628 if (cdrom_decode_status(drive, 0, &stat))
1629 return ide_stopped;
1630
1631 /*
1632 * using dma, transfer is complete now
1633 */
1634 if (dma) {
1635 if (dma_error) {
1636 printk(KERN_ERR "ide-cd: dma error\n");
1637 __ide_dma_off(drive);
1638 return ide_error(drive, "dma error", stat);
1639 }
1640
1641 end_that_request_chunk(rq, 1, rq->data_len);
1642 rq->data_len = 0;
1643 goto end_request;
1644 }
1645
1646 /*
1647 * ok we fall to pio :/
1648 */
1649 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1650 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1651 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1652
1653 len = lowcyl + (256 * highcyl);
1654 thislen = rq->data_len;
1655 if (thislen > len)
1656 thislen = len;
1657
1658 /*
1659 * If DRQ is clear, the command has completed.
1660 */
1661 if ((stat & DRQ_STAT) == 0)
1662 goto end_request;
1663
1664 /*
1665 * check which way to transfer data
1666 */
1667 if (rq_data_dir(rq) == WRITE) {
1668 /*
1669 * write to drive
1670 */
1671 if (cdrom_write_check_ireason(drive, len, ireason))
1672 return ide_stopped;
1673
1674 xferfunc = HWIF(drive)->atapi_output_bytes;
1675 } else {
1676 /*
1677 * read from drive
1678 */
1679 if (cdrom_read_check_ireason(drive, len, ireason))
1680 return ide_stopped;
1681
1682 xferfunc = HWIF(drive)->atapi_input_bytes;
1683 }
1684
1685 /*
1686 * transfer data
1687 */
1688 while (thislen > 0) {
1689 int blen = blen = rq->data_len;
1690 char *ptr = rq->data;
1691
1692 /*
1693 * bio backed?
1694 */
1695 if (rq->bio) {
1696 ptr = bio_data(rq->bio);
1697 blen = bio_iovec(rq->bio)->bv_len;
1698 }
1699
1700 if (!ptr) {
1701 printk(KERN_ERR "%s: confused, missing data\n", drive->name);
1702 break;
1703 }
1704
1705 if (blen > thislen)
1706 blen = thislen;
1707
1708 xferfunc(drive, ptr, blen);
1709
1710 thislen -= blen;
1711 len -= blen;
1712 rq->data_len -= blen;
1713
1714 if (rq->bio)
1715 end_that_request_chunk(rq, 1, blen);
1716 else
1717 rq->data += blen;
1718 }
1719
1720 /*
1721 * pad, if necessary
1722 */
1723 if (len > 0) {
1724 while (len > 0) {
1725 int pad = 0;
1726
1727 xferfunc(drive, &pad, sizeof(pad));
1728 len -= sizeof(pad);
1729 }
1730 }
1731
1732 if (HWGROUP(drive)->handler != NULL)
1733 BUG();
1734
1735 ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, NULL);
1736 return ide_started;
1737
1738end_request:
1739 if (!rq->data_len)
1740 post_transform_command(rq);
1741
1742 spin_lock_irqsave(&ide_lock, flags);
1743 blkdev_dequeue_request(rq);
1744 end_that_request_last(rq);
1745 HWGROUP(drive)->rq = NULL;
1746 spin_unlock_irqrestore(&ide_lock, flags);
1747 return ide_stopped;
1748}
1749
1750static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
1751{
1752 int stat, ireason, len, sectors_to_transfer, uptodate;
1753 struct cdrom_info *info = drive->driver_data;
1754 int dma_error = 0, dma = info->dma;
1755 u8 lowcyl = 0, highcyl = 0;
1756
1757 struct request *rq = HWGROUP(drive)->rq;
1758
1759 /* Check for errors. */
1760 if (dma) {
1761 info->dma = 0;
1762 if ((dma_error = HWIF(drive)->ide_dma_end(drive))) {
1763 printk(KERN_ERR "ide-cd: write dma error\n");
1764 __ide_dma_off(drive);
1765 }
1766 }
1767
1768 if (cdrom_decode_status(drive, 0, &stat))
1769 return ide_stopped;
1770
1771 /*
1772 * using dma, transfer is complete now
1773 */
1774 if (dma) {
1775 if (dma_error)
1776 return ide_error(drive, "dma error", stat);
1777
1778 ide_end_request(drive, 1, rq->nr_sectors);
1779 return ide_stopped;
1780 }
1781
1782 /* Read the interrupt reason and the transfer length. */
1783 ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1784 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1785 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1786
1787 len = lowcyl + (256 * highcyl);
1788
1789 /* If DRQ is clear, the command has completed. */
1790 if ((stat & DRQ_STAT) == 0) {
1791 /* If we're not done writing, complain.
1792 * Otherwise, complete the command normally.
1793 */
1794 uptodate = 1;
1795 if (rq->current_nr_sectors > 0) {
1796 printk(KERN_ERR "%s: write_intr: data underrun (%d blocks)\n",
1797 drive->name, rq->current_nr_sectors);
1798 uptodate = 0;
1799 }
1800 cdrom_end_request(drive, uptodate);
1801 return ide_stopped;
1802 }
1803
1804 /* Check that the drive is expecting to do the same thing we are. */
1805 if (cdrom_write_check_ireason(drive, len, ireason))
1806 return ide_stopped;
1807
1808 sectors_to_transfer = len / SECTOR_SIZE;
1809
1810 /*
1811 * now loop and write out the data
1812 */
1813 while (sectors_to_transfer > 0) {
1814 int this_transfer;
1815
1816 if (!rq->current_nr_sectors) {
1817 printk(KERN_ERR "ide-cd: write_intr: oops\n");
1818 break;
1819 }
1820
1821 /*
1822 * Figure out how many sectors we can transfer
1823 */
1824 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors);
1825
1826 while (this_transfer > 0) {
1827 HWIF(drive)->atapi_output_bytes(drive, rq->buffer, SECTOR_SIZE);
1828 rq->buffer += SECTOR_SIZE;
1829 --rq->nr_sectors;
1830 --rq->current_nr_sectors;
1831 ++rq->sector;
1832 --this_transfer;
1833 --sectors_to_transfer;
1834 }
1835
1836 /*
1837 * current buffer complete, move on
1838 */
1839 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1840 cdrom_end_request(drive, 1);
1841 }
1842
1843 /* re-arm handler */
1844 ide_set_handler(drive, &cdrom_write_intr, ATAPI_WAIT_PC, NULL);
1845 return ide_started;
1846}
1847
1848static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
1849{
1850 struct request *rq = HWGROUP(drive)->rq;
1851
1852#if 0 /* the immediate bit */
1853 rq->cmd[1] = 1 << 3;
1854#endif
1855 rq->timeout = ATAPI_WAIT_PC;
1856
1857 return cdrom_transfer_packet_command(drive, rq, cdrom_write_intr);
1858}
1859
1860static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
1861{
1862 struct cdrom_info *info = drive->driver_data;
1863 struct gendisk *g = info->disk;
1864 unsigned short sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1865
1866 /*
1867 * writes *must* be hardware frame aligned
1868 */
1869 if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1870 (rq->sector & (sectors_per_frame - 1))) {
1871 cdrom_end_request(drive, 0);
1872 return ide_stopped;
1873 }
1874
1875 /*
1876 * disk has become write protected
1877 */
1878 if (g->policy) {
1879 cdrom_end_request(drive, 0);
1880 return ide_stopped;
1881 }
1882
1883 /*
1884 * for dvd-ram and such media, it's a really big deal to get
1885 * big writes all the time. so scour the queue and attempt to
1886 * remerge requests, often the plugging will not have had time
1887 * to do this properly
1888 */
1889 blk_attempt_remerge(drive->queue, rq);
1890
1891 info->nsectors_buffered = 0;
1892
1893 /* use dma, if possible. we don't need to check more, since we
1894 * know that the transfer is always (at least!) frame aligned */
1895 info->dma = drive->using_dma ? 1 : 0;
1896 info->cmd = WRITE;
1897
1898 info->devinfo.media_written = 1;
1899
1900 /* Start sending the write request to the drive. */
1901 return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
1902}
1903
1904static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1905{
1906 struct request *rq = HWGROUP(drive)->rq;
1907
1908 if (!rq->timeout)
1909 rq->timeout = ATAPI_WAIT_PC;
1910
1911 return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1912}
1913
1914static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1915{
1916 struct cdrom_info *info = drive->driver_data;
1917
1918 rq->flags |= REQ_QUIET;
1919
1920 info->dma = 0;
1921 info->cmd = 0;
1922
1923 /*
1924 * sg request
1925 */
1926 if (rq->bio) {
1927 int mask = drive->queue->dma_alignment;
1928 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
1929
1930 info->cmd = rq_data_dir(rq);
1931 info->dma = drive->using_dma;
1932
1933 /*
1934 * check if dma is safe
Linus Torvalds5d9e4ea2005-05-27 07:36:17 -07001935 *
1936 * NOTE! The "len" and "addr" checks should possibly have
1937 * separate masks.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938 */
Linus Torvalds5d9e4ea2005-05-27 07:36:17 -07001939 if ((rq->data_len & mask) || (addr & mask))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 info->dma = 0;
1941 }
1942
1943 /* Start sending the command to the drive. */
1944 return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1945}
1946
1947/****************************************************************************
1948 * cdrom driver request routine.
1949 */
1950static ide_startstop_t
1951ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1952{
1953 ide_startstop_t action;
1954 struct cdrom_info *info = drive->driver_data;
1955
1956 if (blk_fs_request(rq)) {
1957 if (CDROM_CONFIG_FLAGS(drive)->seeking) {
1958 unsigned long elapsed = jiffies - info->start_seek;
1959 int stat = HWIF(drive)->INB(IDE_STATUS_REG);
1960
1961 if ((stat & SEEK_STAT) != SEEK_STAT) {
1962 if (elapsed < IDECD_SEEK_TIMEOUT) {
1963 ide_stall_queue(drive, IDECD_SEEK_TIMER);
1964 return ide_stopped;
1965 }
1966 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
1967 }
1968 CDROM_CONFIG_FLAGS(drive)->seeking = 0;
1969 }
1970 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
1971 action = cdrom_start_seek(drive, block);
1972 } else {
1973 if (rq_data_dir(rq) == READ)
1974 action = cdrom_start_read(drive, block);
1975 else
1976 action = cdrom_start_write(drive, rq);
1977 }
1978 info->last_block = block;
1979 return action;
1980 } else if (rq->flags & (REQ_PC | REQ_SENSE)) {
1981 return cdrom_do_packet_command(drive);
1982 } else if (rq->flags & REQ_BLOCK_PC) {
1983 return cdrom_do_block_pc(drive, rq);
1984 } else if (rq->flags & REQ_SPECIAL) {
1985 /*
1986 * right now this can only be a reset...
1987 */
1988 cdrom_end_request(drive, 1);
1989 return ide_stopped;
1990 }
1991
1992 blk_dump_rq_flags(rq, "ide-cd bad flags");
1993 cdrom_end_request(drive, 0);
1994 return ide_stopped;
1995}
1996
1997
1998
1999/****************************************************************************
2000 * Ioctl handling.
2001 *
2002 * Routines which queue packet commands take as a final argument a pointer
2003 * to a request_sense struct. If execution of the command results
2004 * in an error with a CHECK CONDITION status, this structure will be filled
2005 * with the results of the subsequent request sense command. The pointer
2006 * can also be NULL, in which case no sense information is returned.
2007 */
2008
2009#if ! STANDARD_ATAPI
2010static inline
2011int bin2bcd (int x)
2012{
2013 return (x%10) | ((x/10) << 4);
2014}
2015
2016
2017static inline
2018int bcd2bin (int x)
2019{
2020 return (x >> 4) * 10 + (x & 0x0f);
2021}
2022
2023static
2024void msf_from_bcd (struct atapi_msf *msf)
2025{
2026 msf->minute = bcd2bin (msf->minute);
2027 msf->second = bcd2bin (msf->second);
2028 msf->frame = bcd2bin (msf->frame);
2029}
2030
2031#endif /* not STANDARD_ATAPI */
2032
2033
2034static inline
2035void lba_to_msf (int lba, byte *m, byte *s, byte *f)
2036{
2037 lba += CD_MSF_OFFSET;
2038 lba &= 0xffffff; /* negative lbas use only 24 bits */
2039 *m = lba / (CD_SECS * CD_FRAMES);
2040 lba %= (CD_SECS * CD_FRAMES);
2041 *s = lba / CD_FRAMES;
2042 *f = lba % CD_FRAMES;
2043}
2044
2045
2046static inline
2047int msf_to_lba (byte m, byte s, byte f)
2048{
2049 return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
2050}
2051
2052static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
2053{
2054 struct request req;
2055 struct cdrom_info *info = drive->driver_data;
2056 struct cdrom_device_info *cdi = &info->devinfo;
2057
2058 cdrom_prepare_request(drive, &req);
2059
2060 req.sense = sense;
2061 req.cmd[0] = GPCMD_TEST_UNIT_READY;
2062 req.flags |= REQ_QUIET;
2063
2064#if ! STANDARD_ATAPI
2065 /* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
2066 switch CDs instead of supporting the LOAD_UNLOAD opcode */
2067
2068 req.cmd[7] = cdi->sanyo_slot % 3;
2069#endif /* not STANDARD_ATAPI */
2070
2071 return cdrom_queue_packet_command(drive, &req);
2072}
2073
2074
2075/* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
2076static int
2077cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
2078{
2079 struct request_sense my_sense;
2080 struct request req;
2081 int stat;
2082
2083 if (sense == NULL)
2084 sense = &my_sense;
2085
2086 /* If the drive cannot lock the door, just pretend. */
2087 if (CDROM_CONFIG_FLAGS(drive)->no_doorlock) {
2088 stat = 0;
2089 } else {
2090 cdrom_prepare_request(drive, &req);
2091 req.sense = sense;
2092 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
2093 req.cmd[4] = lockflag ? 1 : 0;
2094 stat = cdrom_queue_packet_command(drive, &req);
2095 }
2096
2097 /* If we got an illegal field error, the drive
2098 probably cannot lock the door. */
2099 if (stat != 0 &&
2100 sense->sense_key == ILLEGAL_REQUEST &&
2101 (sense->asc == 0x24 || sense->asc == 0x20)) {
2102 printk (KERN_ERR "%s: door locking not supported\n",
2103 drive->name);
2104 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2105 stat = 0;
2106 }
2107
2108 /* no medium, that's alright. */
2109 if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
2110 stat = 0;
2111
2112 if (stat == 0)
2113 CDROM_STATE_FLAGS(drive)->door_locked = lockflag;
2114
2115 return stat;
2116}
2117
2118
2119/* Eject the disk if EJECTFLAG is 0.
2120 If EJECTFLAG is 1, try to reload the disk. */
2121static int cdrom_eject(ide_drive_t *drive, int ejectflag,
2122 struct request_sense *sense)
2123{
2124 struct request req;
2125 char loej = 0x02;
2126
2127 if (CDROM_CONFIG_FLAGS(drive)->no_eject && !ejectflag)
2128 return -EDRIVE_CANT_DO_THIS;
2129
2130 /* reload fails on some drives, if the tray is locked */
2131 if (CDROM_STATE_FLAGS(drive)->door_locked && ejectflag)
2132 return 0;
2133
2134 cdrom_prepare_request(drive, &req);
2135
2136 /* only tell drive to close tray if open, if it can do that */
2137 if (ejectflag && !CDROM_CONFIG_FLAGS(drive)->close_tray)
2138 loej = 0;
2139
2140 req.sense = sense;
2141 req.cmd[0] = GPCMD_START_STOP_UNIT;
2142 req.cmd[4] = loej | (ejectflag != 0);
2143 return cdrom_queue_packet_command(drive, &req);
2144}
2145
2146static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
2147 unsigned long *sectors_per_frame,
2148 struct request_sense *sense)
2149{
2150 struct {
2151 __u32 lba;
2152 __u32 blocklen;
2153 } capbuf;
2154
2155 int stat;
2156 struct request req;
2157
2158 cdrom_prepare_request(drive, &req);
2159
2160 req.sense = sense;
2161 req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
2162 req.data = (char *)&capbuf;
2163 req.data_len = sizeof(capbuf);
2164
2165 stat = cdrom_queue_packet_command(drive, &req);
2166 if (stat == 0) {
2167 *capacity = 1 + be32_to_cpu(capbuf.lba);
2168 *sectors_per_frame =
2169 be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
2170 }
2171
2172 return stat;
2173}
2174
2175static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
2176 int format, char *buf, int buflen,
2177 struct request_sense *sense)
2178{
2179 struct request req;
2180
2181 cdrom_prepare_request(drive, &req);
2182
2183 req.sense = sense;
2184 req.data = buf;
2185 req.data_len = buflen;
2186 req.flags |= REQ_QUIET;
2187 req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
2188 req.cmd[6] = trackno;
2189 req.cmd[7] = (buflen >> 8);
2190 req.cmd[8] = (buflen & 0xff);
2191 req.cmd[9] = (format << 6);
2192
2193 if (msf_flag)
2194 req.cmd[1] = 2;
2195
2196 return cdrom_queue_packet_command(drive, &req);
2197}
2198
2199
2200/* Try to read the entire TOC for the disk into our internal buffer. */
2201static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2202{
2203 int stat, ntracks, i;
2204 struct cdrom_info *info = drive->driver_data;
2205 struct cdrom_device_info *cdi = &info->devinfo;
2206 struct atapi_toc *toc = info->toc;
2207 struct {
2208 struct atapi_toc_header hdr;
2209 struct atapi_toc_entry ent;
2210 } ms_tmp;
2211 long last_written;
2212 unsigned long sectors_per_frame = SECTORS_PER_FRAME;
2213
2214 if (toc == NULL) {
2215 /* Try to allocate space. */
2216 toc = (struct atapi_toc *) kmalloc (sizeof (struct atapi_toc),
2217 GFP_KERNEL);
2218 info->toc = toc;
2219 if (toc == NULL) {
2220 printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
2221 return -ENOMEM;
2222 }
2223 }
2224
2225 /* Check to see if the existing data is still valid.
2226 If it is, just return. */
2227 (void) cdrom_check_status(drive, sense);
2228
2229 if (CDROM_STATE_FLAGS(drive)->toc_valid)
2230 return 0;
2231
2232 /* Try to get the total cdrom capacity and sector size. */
2233 stat = cdrom_read_capacity(drive, &toc->capacity, &sectors_per_frame,
2234 sense);
2235 if (stat)
2236 toc->capacity = 0x1fffff;
2237
2238 set_capacity(info->disk, toc->capacity * sectors_per_frame);
2239 blk_queue_hardsect_size(drive->queue,
2240 sectors_per_frame << SECTOR_BITS);
2241
2242 /* First read just the header, so we know how long the TOC is. */
2243 stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
2244 sizeof(struct atapi_toc_header), sense);
2245 if (stat) return stat;
2246
2247#if ! STANDARD_ATAPI
2248 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2249 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2250 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2251 }
2252#endif /* not STANDARD_ATAPI */
2253
2254 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2255 if (ntracks <= 0)
2256 return -EIO;
2257 if (ntracks > MAX_TRACKS)
2258 ntracks = MAX_TRACKS;
2259
2260 /* Now read the whole schmeer. */
2261 stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
2262 (char *)&toc->hdr,
2263 sizeof(struct atapi_toc_header) +
2264 (ntracks + 1) *
2265 sizeof(struct atapi_toc_entry), sense);
2266
2267 if (stat && toc->hdr.first_track > 1) {
2268 /* Cds with CDI tracks only don't have any TOC entries,
2269 despite of this the returned values are
2270 first_track == last_track = number of CDI tracks + 1,
2271 so that this case is indistinguishable from the same
2272 layout plus an additional audio track.
2273 If we get an error for the regular case, we assume
2274 a CDI without additional audio tracks. In this case
2275 the readable TOC is empty (CDI tracks are not included)
2276 and only holds the Leadout entry. Heiko Eißfeldt */
2277 ntracks = 0;
2278 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
2279 (char *)&toc->hdr,
2280 sizeof(struct atapi_toc_header) +
2281 (ntracks + 1) *
2282 sizeof(struct atapi_toc_entry),
2283 sense);
2284 if (stat) {
2285 return stat;
2286 }
2287#if ! STANDARD_ATAPI
2288 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2289 toc->hdr.first_track = bin2bcd(CDROM_LEADOUT);
2290 toc->hdr.last_track = bin2bcd(CDROM_LEADOUT);
2291 } else
2292#endif /* not STANDARD_ATAPI */
2293 {
2294 toc->hdr.first_track = CDROM_LEADOUT;
2295 toc->hdr.last_track = CDROM_LEADOUT;
2296 }
2297 }
2298
2299 if (stat)
2300 return stat;
2301
2302 toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
2303
2304#if ! STANDARD_ATAPI
2305 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2306 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2307 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2308 }
2309#endif /* not STANDARD_ATAPI */
2310
2311 for (i=0; i<=ntracks; i++) {
2312#if ! STANDARD_ATAPI
2313 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2314 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd)
2315 toc->ent[i].track = bcd2bin(toc->ent[i].track);
2316 msf_from_bcd(&toc->ent[i].addr.msf);
2317 }
2318#endif /* not STANDARD_ATAPI */
2319 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
2320 toc->ent[i].addr.msf.second,
2321 toc->ent[i].addr.msf.frame);
2322 }
2323
2324 /* Read the multisession information. */
2325 if (toc->hdr.first_track != CDROM_LEADOUT) {
2326 /* Read the multisession information. */
2327 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
2328 sizeof(ms_tmp), sense);
2329 if (stat) return stat;
2330
2331 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
2332 } else {
2333 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
2334 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
2335 }
2336
2337#if ! STANDARD_ATAPI
2338 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2339 /* Re-read multisession information using MSF format */
2340 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
2341 sizeof(ms_tmp), sense);
2342 if (stat)
2343 return stat;
2344
2345 msf_from_bcd (&ms_tmp.ent.addr.msf);
2346 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
2347 ms_tmp.ent.addr.msf.second,
2348 ms_tmp.ent.addr.msf.frame);
2349 }
2350#endif /* not STANDARD_ATAPI */
2351
2352 toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
2353
2354 /* Now try to get the total cdrom capacity. */
2355 stat = cdrom_get_last_written(cdi, &last_written);
2356 if (!stat && (last_written > toc->capacity)) {
2357 toc->capacity = last_written;
2358 set_capacity(info->disk, toc->capacity * sectors_per_frame);
2359 }
2360
2361 /* Remember that we've read this stuff. */
2362 CDROM_STATE_FLAGS(drive)->toc_valid = 1;
2363
2364 return 0;
2365}
2366
2367
2368static int cdrom_read_subchannel(ide_drive_t *drive, int format, char *buf,
2369 int buflen, struct request_sense *sense)
2370{
2371 struct request req;
2372
2373 cdrom_prepare_request(drive, &req);
2374
2375 req.sense = sense;
2376 req.data = buf;
2377 req.data_len = buflen;
2378 req.cmd[0] = GPCMD_READ_SUBCHANNEL;
2379 req.cmd[1] = 2; /* MSF addressing */
2380 req.cmd[2] = 0x40; /* request subQ data */
2381 req.cmd[3] = format;
2382 req.cmd[7] = (buflen >> 8);
2383 req.cmd[8] = (buflen & 0xff);
2384 return cdrom_queue_packet_command(drive, &req);
2385}
2386
2387/* ATAPI cdrom drives are free to select the speed you request or any slower
2388 rate :-( Requesting too fast a speed will _not_ produce an error. */
2389static int cdrom_select_speed(ide_drive_t *drive, int speed,
2390 struct request_sense *sense)
2391{
2392 struct request req;
2393 cdrom_prepare_request(drive, &req);
2394
2395 req.sense = sense;
2396 if (speed == 0)
2397 speed = 0xffff; /* set to max */
2398 else
2399 speed *= 177; /* Nx to kbytes/s */
2400
2401 req.cmd[0] = GPCMD_SET_SPEED;
2402 /* Read Drive speed in kbytes/second MSB */
2403 req.cmd[2] = (speed >> 8) & 0xff;
2404 /* Read Drive speed in kbytes/second LSB */
2405 req.cmd[3] = speed & 0xff;
2406 if (CDROM_CONFIG_FLAGS(drive)->cd_r ||
2407 CDROM_CONFIG_FLAGS(drive)->cd_rw ||
2408 CDROM_CONFIG_FLAGS(drive)->dvd_r) {
2409 /* Write Drive speed in kbytes/second MSB */
2410 req.cmd[4] = (speed >> 8) & 0xff;
2411 /* Write Drive speed in kbytes/second LSB */
2412 req.cmd[5] = speed & 0xff;
2413 }
2414
2415 return cdrom_queue_packet_command(drive, &req);
2416}
2417
2418static int cdrom_play_audio(ide_drive_t *drive, int lba_start, int lba_end)
2419{
2420 struct request_sense sense;
2421 struct request req;
2422
2423 cdrom_prepare_request(drive, &req);
2424
2425 req.sense = &sense;
2426 req.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2427 lba_to_msf(lba_start, &req.cmd[3], &req.cmd[4], &req.cmd[5]);
2428 lba_to_msf(lba_end-1, &req.cmd[6], &req.cmd[7], &req.cmd[8]);
2429
2430 return cdrom_queue_packet_command(drive, &req);
2431}
2432
2433static int cdrom_get_toc_entry(ide_drive_t *drive, int track,
2434 struct atapi_toc_entry **ent)
2435{
2436 struct cdrom_info *info = drive->driver_data;
2437 struct atapi_toc *toc = info->toc;
2438 int ntracks;
2439
2440 /*
2441 * don't serve cached data, if the toc isn't valid
2442 */
2443 if (!CDROM_STATE_FLAGS(drive)->toc_valid)
2444 return -EINVAL;
2445
2446 /* Check validity of requested track number. */
2447 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2448 if (toc->hdr.first_track == CDROM_LEADOUT) ntracks = 0;
2449 if (track == CDROM_LEADOUT)
2450 *ent = &toc->ent[ntracks];
2451 else if (track < toc->hdr.first_track ||
2452 track > toc->hdr.last_track)
2453 return -EINVAL;
2454 else
2455 *ent = &toc->ent[track - toc->hdr.first_track];
2456
2457 return 0;
2458}
2459
2460/* the generic packet interface to cdrom.c */
2461static int ide_cdrom_packet(struct cdrom_device_info *cdi,
2462 struct packet_command *cgc)
2463{
2464 struct request req;
2465 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2466
2467 if (cgc->timeout <= 0)
2468 cgc->timeout = ATAPI_WAIT_PC;
2469
2470 /* here we queue the commands from the uniform CD-ROM
2471 layer. the packet must be complete, as we do not
2472 touch it at all. */
2473 cdrom_prepare_request(drive, &req);
2474 memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
2475 if (cgc->sense)
2476 memset(cgc->sense, 0, sizeof(struct request_sense));
2477 req.data = cgc->buffer;
2478 req.data_len = cgc->buflen;
2479 req.timeout = cgc->timeout;
2480
2481 if (cgc->quiet)
2482 req.flags |= REQ_QUIET;
2483
2484 req.sense = cgc->sense;
2485 cgc->stat = cdrom_queue_packet_command(drive, &req);
2486 if (!cgc->stat)
2487 cgc->buflen -= req.data_len;
2488 return cgc->stat;
2489}
2490
2491static
2492int ide_cdrom_dev_ioctl (struct cdrom_device_info *cdi,
2493 unsigned int cmd, unsigned long arg)
2494{
2495 struct packet_command cgc;
2496 char buffer[16];
2497 int stat;
2498
2499 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2500
2501 /* These will be moved into the Uniform layer shortly... */
2502 switch (cmd) {
2503 case CDROMSETSPINDOWN: {
2504 char spindown;
2505
2506 if (copy_from_user(&spindown, (void __user *) arg, sizeof(char)))
2507 return -EFAULT;
2508
2509 if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0)))
2510 return stat;
2511
2512 buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
2513
2514 return cdrom_mode_select(cdi, &cgc);
2515 }
2516
2517 case CDROMGETSPINDOWN: {
2518 char spindown;
2519
2520 if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0)))
2521 return stat;
2522
2523 spindown = buffer[11] & 0x0f;
2524
2525 if (copy_to_user((void __user *) arg, &spindown, sizeof (char)))
2526 return -EFAULT;
2527
2528 return 0;
2529 }
2530
2531 default:
2532 return -EINVAL;
2533 }
2534
2535}
2536
2537static
2538int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
2539 unsigned int cmd, void *arg)
2540
2541{
2542 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2543 struct cdrom_info *info = drive->driver_data;
2544 int stat;
2545
2546 switch (cmd) {
2547 /*
2548 * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
2549 * atapi doesn't support it
2550 */
2551 case CDROMPLAYTRKIND: {
2552 unsigned long lba_start, lba_end;
2553 struct cdrom_ti *ti = (struct cdrom_ti *)arg;
2554 struct atapi_toc_entry *first_toc, *last_toc;
2555
2556 stat = cdrom_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
2557 if (stat)
2558 return stat;
2559
2560 stat = cdrom_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
2561 if (stat)
2562 return stat;
2563
2564 if (ti->cdti_trk1 != CDROM_LEADOUT)
2565 ++last_toc;
2566 lba_start = first_toc->addr.lba;
2567 lba_end = last_toc->addr.lba;
2568
2569 if (lba_end <= lba_start)
2570 return -EINVAL;
2571
2572 return cdrom_play_audio(drive, lba_start, lba_end);
2573 }
2574
2575 case CDROMREADTOCHDR: {
2576 struct cdrom_tochdr *tochdr = (struct cdrom_tochdr *) arg;
2577 struct atapi_toc *toc;
2578
2579 /* Make sure our saved TOC is valid. */
2580 stat = cdrom_read_toc(drive, NULL);
2581 if (stat) return stat;
2582
2583 toc = info->toc;
2584 tochdr->cdth_trk0 = toc->hdr.first_track;
2585 tochdr->cdth_trk1 = toc->hdr.last_track;
2586
2587 return 0;
2588 }
2589
2590 case CDROMREADTOCENTRY: {
2591 struct cdrom_tocentry *tocentry = (struct cdrom_tocentry*) arg;
2592 struct atapi_toc_entry *toce;
2593
2594 stat = cdrom_get_toc_entry(drive, tocentry->cdte_track, &toce);
2595 if (stat) return stat;
2596
2597 tocentry->cdte_ctrl = toce->control;
2598 tocentry->cdte_adr = toce->adr;
2599 if (tocentry->cdte_format == CDROM_MSF) {
2600 lba_to_msf (toce->addr.lba,
2601 &tocentry->cdte_addr.msf.minute,
2602 &tocentry->cdte_addr.msf.second,
2603 &tocentry->cdte_addr.msf.frame);
2604 } else
2605 tocentry->cdte_addr.lba = toce->addr.lba;
2606
2607 return 0;
2608 }
2609
2610 default:
2611 return -EINVAL;
2612 }
2613}
2614
2615static
2616int ide_cdrom_reset (struct cdrom_device_info *cdi)
2617{
2618 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2619 struct request_sense sense;
2620 struct request req;
2621 int ret;
2622
2623 cdrom_prepare_request(drive, &req);
2624 req.flags = REQ_SPECIAL | REQ_QUIET;
2625 ret = ide_do_drive_cmd(drive, &req, ide_wait);
2626
2627 /*
2628 * A reset will unlock the door. If it was previously locked,
2629 * lock it again.
2630 */
2631 if (CDROM_STATE_FLAGS(drive)->door_locked)
2632 (void) cdrom_lockdoor(drive, 1, &sense);
2633
2634 return ret;
2635}
2636
2637
2638static
2639int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
2640{
2641 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2642 struct request_sense sense;
2643
2644 if (position) {
2645 int stat = cdrom_lockdoor(drive, 0, &sense);
2646 if (stat) return stat;
2647 }
2648
2649 return cdrom_eject(drive, !position, &sense);
2650}
2651
2652static
2653int ide_cdrom_lock_door (struct cdrom_device_info *cdi, int lock)
2654{
2655 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2656 return cdrom_lockdoor(drive, lock, NULL);
2657}
2658
2659static
2660int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
2661{
2662 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2663 struct request_sense sense;
2664 int stat;
2665
2666 if ((stat = cdrom_select_speed(drive, speed, &sense)) < 0)
2667 return stat;
2668
2669 cdi->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2670 return 0;
2671}
2672
2673/*
2674 * add logic to try GET_EVENT command first to check for media and tray
2675 * status. this should be supported by newer cd-r/w and all DVD etc
2676 * drives
2677 */
2678static
2679int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
2680{
2681 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2682 struct media_event_desc med;
2683 struct request_sense sense;
2684 int stat;
2685
2686 if (slot_nr != CDSL_CURRENT)
2687 return -EINVAL;
2688
2689 stat = cdrom_check_status(drive, &sense);
2690 if (!stat || sense.sense_key == UNIT_ATTENTION)
2691 return CDS_DISC_OK;
2692
2693 if (!cdrom_get_media_event(cdi, &med)) {
2694 if (med.media_present)
2695 return CDS_DISC_OK;
2696 else if (med.door_open)
2697 return CDS_TRAY_OPEN;
2698 else
2699 return CDS_NO_DISC;
2700 }
2701
2702 if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
2703 return CDS_DISC_OK;
2704
2705 /*
2706 * If not using Mt Fuji extended media tray reports,
2707 * just return TRAY_OPEN since ATAPI doesn't provide
2708 * any other way to detect this...
2709 */
2710 if (sense.sense_key == NOT_READY) {
2711 if (sense.asc == 0x3a) {
2712 if (sense.ascq == 1)
2713 return CDS_NO_DISC;
2714 else if (sense.ascq == 0 || sense.ascq == 2)
2715 return CDS_TRAY_OPEN;
2716 }
2717 }
2718
2719 return CDS_DRIVE_NOT_READY;
2720}
2721
2722static
2723int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
2724 struct cdrom_multisession *ms_info)
2725{
2726 struct atapi_toc *toc;
2727 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2728 struct cdrom_info *info = drive->driver_data;
2729 struct request_sense sense;
2730 int ret;
2731
2732 if (!CDROM_STATE_FLAGS(drive)->toc_valid || info->toc == NULL)
2733 if ((ret = cdrom_read_toc(drive, &sense)))
2734 return ret;
2735
2736 toc = info->toc;
2737 ms_info->addr.lba = toc->last_session_lba;
2738 ms_info->xa_flag = toc->xa_flag;
2739
2740 return 0;
2741}
2742
2743static
2744int ide_cdrom_get_mcn (struct cdrom_device_info *cdi,
2745 struct cdrom_mcn *mcn_info)
2746{
2747 int stat;
2748 char mcnbuf[24];
2749 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2750
2751/* get MCN */
2752 if ((stat = cdrom_read_subchannel(drive, 2, mcnbuf, sizeof (mcnbuf), NULL)))
2753 return stat;
2754
2755 memcpy (mcn_info->medium_catalog_number, mcnbuf+9,
2756 sizeof (mcn_info->medium_catalog_number)-1);
2757 mcn_info->medium_catalog_number[sizeof (mcn_info->medium_catalog_number)-1]
2758 = '\0';
2759
2760 return 0;
2761}
2762
2763
2764
2765/****************************************************************************
2766 * Other driver requests (open, close, check media change).
2767 */
2768
2769static
2770int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
2771 int slot_nr)
2772{
2773 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2774 int retval;
2775
2776 if (slot_nr == CDSL_CURRENT) {
2777 (void) cdrom_check_status(drive, NULL);
2778 retval = CDROM_STATE_FLAGS(drive)->media_changed;
2779 CDROM_STATE_FLAGS(drive)->media_changed = 0;
2780 return retval;
2781 } else {
2782 return -EINVAL;
2783 }
2784}
2785
2786
2787static
2788int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
2789{
2790 return 0;
2791}
2792
2793/*
2794 * Close down the device. Invalidate all cached blocks.
2795 */
2796
2797static
2798void ide_cdrom_release_real (struct cdrom_device_info *cdi)
2799{
2800 ide_drive_t *drive = cdi->handle;
2801
2802 if (!cdi->use_count)
2803 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
2804}
2805
2806
2807
2808/****************************************************************************
2809 * Device initialization.
2810 */
2811static struct cdrom_device_ops ide_cdrom_dops = {
2812 .open = ide_cdrom_open_real,
2813 .release = ide_cdrom_release_real,
2814 .drive_status = ide_cdrom_drive_status,
2815 .media_changed = ide_cdrom_check_media_change_real,
2816 .tray_move = ide_cdrom_tray_move,
2817 .lock_door = ide_cdrom_lock_door,
2818 .select_speed = ide_cdrom_select_speed,
2819 .get_last_session = ide_cdrom_get_last_session,
2820 .get_mcn = ide_cdrom_get_mcn,
2821 .reset = ide_cdrom_reset,
2822 .audio_ioctl = ide_cdrom_audio_ioctl,
2823 .dev_ioctl = ide_cdrom_dev_ioctl,
2824 .capability = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
2825 CDC_SELECT_SPEED | CDC_SELECT_DISC |
2826 CDC_MULTI_SESSION | CDC_MCN |
2827 CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO | CDC_RESET |
2828 CDC_IOCTLS | CDC_DRIVE_STATUS | CDC_CD_R |
2829 CDC_CD_RW | CDC_DVD | CDC_DVD_R| CDC_DVD_RAM |
2830 CDC_GENERIC_PACKET | CDC_MO_DRIVE | CDC_MRW |
2831 CDC_MRW_W | CDC_RAM,
2832 .generic_packet = ide_cdrom_packet,
2833};
2834
2835static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2836{
2837 struct cdrom_info *info = drive->driver_data;
2838 struct cdrom_device_info *devinfo = &info->devinfo;
2839
2840 devinfo->ops = &ide_cdrom_dops;
2841 devinfo->mask = 0;
2842 devinfo->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2843 devinfo->capacity = nslots;
2844 devinfo->handle = (void *) drive;
2845 strcpy(devinfo->name, drive->name);
2846
2847 /* set capability mask to match the probe. */
2848 if (!CDROM_CONFIG_FLAGS(drive)->cd_r)
2849 devinfo->mask |= CDC_CD_R;
2850 if (!CDROM_CONFIG_FLAGS(drive)->cd_rw)
2851 devinfo->mask |= CDC_CD_RW;
2852 if (!CDROM_CONFIG_FLAGS(drive)->dvd)
2853 devinfo->mask |= CDC_DVD;
2854 if (!CDROM_CONFIG_FLAGS(drive)->dvd_r)
2855 devinfo->mask |= CDC_DVD_R;
2856 if (!CDROM_CONFIG_FLAGS(drive)->dvd_ram)
2857 devinfo->mask |= CDC_DVD_RAM;
2858 if (!CDROM_CONFIG_FLAGS(drive)->is_changer)
2859 devinfo->mask |= CDC_SELECT_DISC;
2860 if (!CDROM_CONFIG_FLAGS(drive)->audio_play)
2861 devinfo->mask |= CDC_PLAY_AUDIO;
2862 if (!CDROM_CONFIG_FLAGS(drive)->close_tray)
2863 devinfo->mask |= CDC_CLOSE_TRAY;
2864 if (!CDROM_CONFIG_FLAGS(drive)->mo_drive)
2865 devinfo->mask |= CDC_MO_DRIVE;
2866
2867 devinfo->disk = info->disk;
2868 return register_cdrom(devinfo);
2869}
2870
2871static
2872int ide_cdrom_get_capabilities(ide_drive_t *drive, struct atapi_capabilities_page *cap)
2873{
2874 struct cdrom_info *info = drive->driver_data;
2875 struct cdrom_device_info *cdi = &info->devinfo;
2876 struct packet_command cgc;
2877 int stat, attempts = 3, size = sizeof(*cap);
2878
2879 /*
2880 * ACER50 (and others?) require the full spec length mode sense
2881 * page capabilities size, but older drives break.
2882 */
2883 if (!(!strcmp(drive->id->model, "ATAPI CD ROM DRIVE 50X MAX") ||
2884 !strcmp(drive->id->model, "WPI CDS-32X")))
2885 size -= sizeof(cap->pad);
2886
2887 init_cdrom_command(&cgc, cap, size, CGC_DATA_UNKNOWN);
2888 do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2889 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
2890 if (!stat)
2891 break;
2892 } while (--attempts);
2893 return stat;
2894}
2895
2896static
2897int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2898{
2899 struct cdrom_info *info = drive->driver_data;
2900 struct cdrom_device_info *cdi = &info->devinfo;
2901 struct atapi_capabilities_page cap;
2902 int nslots = 1;
2903
2904 if (drive->media == ide_optical) {
2905 CDROM_CONFIG_FLAGS(drive)->mo_drive = 1;
2906 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2907 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
2908 return nslots;
2909 }
2910
2911 if (CDROM_CONFIG_FLAGS(drive)->nec260 ||
2912 !strcmp(drive->id->model,"STINGRAY 8422 IDE 8X CD-ROM 7-27-95")) {
2913 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2914 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2915 return nslots;
2916 }
2917
2918 /*
2919 * we have to cheat a little here. the packet will eventually
2920 * be queued with ide_cdrom_packet(), which extracts the
2921 * drive from cdi->handle. Since this device hasn't been
2922 * registered with the Uniform layer yet, it can't do this.
2923 * Same goes for cdi->ops.
2924 */
2925 cdi->handle = (ide_drive_t *) drive;
2926 cdi->ops = &ide_cdrom_dops;
2927
2928 if (ide_cdrom_get_capabilities(drive, &cap))
2929 return 0;
2930
2931 if (cap.lock == 0)
2932 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2933 if (cap.eject)
2934 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2935 if (cap.cd_r_write)
2936 CDROM_CONFIG_FLAGS(drive)->cd_r = 1;
2937 if (cap.cd_rw_write) {
2938 CDROM_CONFIG_FLAGS(drive)->cd_rw = 1;
2939 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2940 }
2941 if (cap.test_write)
2942 CDROM_CONFIG_FLAGS(drive)->test_write = 1;
2943 if (cap.dvd_ram_read || cap.dvd_r_read || cap.dvd_rom)
2944 CDROM_CONFIG_FLAGS(drive)->dvd = 1;
2945 if (cap.dvd_ram_write) {
2946 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 1;
2947 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2948 }
2949 if (cap.dvd_r_write)
2950 CDROM_CONFIG_FLAGS(drive)->dvd_r = 1;
2951 if (cap.audio_play)
2952 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2953 if (cap.mechtype == mechtype_caddy || cap.mechtype == mechtype_popup)
2954 CDROM_CONFIG_FLAGS(drive)->close_tray = 0;
2955
2956 /* Some drives used by Apple don't advertise audio play
2957 * but they do support reading TOC & audio datas
2958 */
2959 if (strcmp(drive->id->model, "MATSHITADVD-ROM SR-8187") == 0 ||
2960 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8186") == 0 ||
2961 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8176") == 0 ||
2962 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8174") == 0)
2963 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2964
2965#if ! STANDARD_ATAPI
2966 if (cdi->sanyo_slot > 0) {
2967 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
2968 nslots = 3;
2969 }
2970
2971 else
2972#endif /* not STANDARD_ATAPI */
2973 if (cap.mechtype == mechtype_individual_changer ||
2974 cap.mechtype == mechtype_cartridge_changer) {
2975 if ((nslots = cdrom_number_of_slots(cdi)) > 1) {
2976 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
2977 CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 1;
2978 }
2979 }
2980
2981 /* The ACER/AOpen 24X cdrom has the speed fields byte-swapped */
2982 if (!drive->id->model[0] &&
2983 !strncmp(drive->id->fw_rev, "241N", 4)) {
2984 CDROM_STATE_FLAGS(drive)->current_speed =
2985 (((unsigned int)cap.curspeed) + (176/2)) / 176;
2986 CDROM_CONFIG_FLAGS(drive)->max_speed =
2987 (((unsigned int)cap.maxspeed) + (176/2)) / 176;
2988 } else {
2989 CDROM_STATE_FLAGS(drive)->current_speed =
2990 (ntohs(cap.curspeed) + (176/2)) / 176;
2991 CDROM_CONFIG_FLAGS(drive)->max_speed =
2992 (ntohs(cap.maxspeed) + (176/2)) / 176;
2993 }
2994
2995 /* don't print speed if the drive reported 0.
2996 */
2997 printk(KERN_INFO "%s: ATAPI", drive->name);
2998 if (CDROM_CONFIG_FLAGS(drive)->max_speed)
2999 printk(" %dX", CDROM_CONFIG_FLAGS(drive)->max_speed);
3000 printk(" %s", CDROM_CONFIG_FLAGS(drive)->dvd ? "DVD-ROM" : "CD-ROM");
3001
3002 if (CDROM_CONFIG_FLAGS(drive)->dvd_r|CDROM_CONFIG_FLAGS(drive)->dvd_ram)
3003 printk(" DVD%s%s",
3004 (CDROM_CONFIG_FLAGS(drive)->dvd_r)? "-R" : "",
3005 (CDROM_CONFIG_FLAGS(drive)->dvd_ram)? "-RAM" : "");
3006
3007 if (CDROM_CONFIG_FLAGS(drive)->cd_r|CDROM_CONFIG_FLAGS(drive)->cd_rw)
3008 printk(" CD%s%s",
3009 (CDROM_CONFIG_FLAGS(drive)->cd_r)? "-R" : "",
3010 (CDROM_CONFIG_FLAGS(drive)->cd_rw)? "/RW" : "");
3011
3012 if (CDROM_CONFIG_FLAGS(drive)->is_changer)
3013 printk(" changer w/%d slots", nslots);
3014 else
3015 printk(" drive");
3016
3017 printk(", %dkB Cache", be16_to_cpu(cap.buffer_size));
3018
3019 if (drive->using_dma)
3020 ide_dma_verbose(drive);
3021
3022 printk("\n");
3023
3024 return nslots;
3025}
3026
3027static void ide_cdrom_add_settings(ide_drive_t *drive)
3028{
3029 ide_add_setting(drive, "dsc_overlap", SETTING_RW, -1, -1, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
3030}
3031
3032/*
3033 * standard prep_rq_fn that builds 10 byte cmds
3034 */
3035static int ide_cdrom_prep_fs(request_queue_t *q, struct request *rq)
3036{
3037 int hard_sect = queue_hardsect_size(q);
3038 long block = (long)rq->hard_sector / (hard_sect >> 9);
3039 unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
3040
3041 memset(rq->cmd, 0, sizeof(rq->cmd));
3042
3043 if (rq_data_dir(rq) == READ)
3044 rq->cmd[0] = GPCMD_READ_10;
3045 else
3046 rq->cmd[0] = GPCMD_WRITE_10;
3047
3048 /*
3049 * fill in lba
3050 */
3051 rq->cmd[2] = (block >> 24) & 0xff;
3052 rq->cmd[3] = (block >> 16) & 0xff;
3053 rq->cmd[4] = (block >> 8) & 0xff;
3054 rq->cmd[5] = block & 0xff;
3055
3056 /*
3057 * and transfer length
3058 */
3059 rq->cmd[7] = (blocks >> 8) & 0xff;
3060 rq->cmd[8] = blocks & 0xff;
3061 rq->cmd_len = 10;
3062 return BLKPREP_OK;
3063}
3064
3065/*
3066 * Most of the SCSI commands are supported directly by ATAPI devices.
3067 * This transform handles the few exceptions.
3068 */
3069static int ide_cdrom_prep_pc(struct request *rq)
3070{
3071 u8 *c = rq->cmd;
3072
3073 /*
3074 * Transform 6-byte read/write commands to the 10-byte version
3075 */
3076 if (c[0] == READ_6 || c[0] == WRITE_6) {
3077 c[8] = c[4];
3078 c[5] = c[3];
3079 c[4] = c[2];
3080 c[3] = c[1] & 0x1f;
3081 c[2] = 0;
3082 c[1] &= 0xe0;
3083 c[0] += (READ_10 - READ_6);
3084 rq->cmd_len = 10;
3085 return BLKPREP_OK;
3086 }
3087
3088 /*
3089 * it's silly to pretend we understand 6-byte sense commands, just
3090 * reject with ILLEGAL_REQUEST and the caller should take the
3091 * appropriate action
3092 */
3093 if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
3094 rq->errors = ILLEGAL_REQUEST;
3095 return BLKPREP_KILL;
3096 }
3097
3098 return BLKPREP_OK;
3099}
3100
3101static int ide_cdrom_prep_fn(request_queue_t *q, struct request *rq)
3102{
3103 if (rq->flags & REQ_CMD)
3104 return ide_cdrom_prep_fs(q, rq);
3105 else if (rq->flags & REQ_BLOCK_PC)
3106 return ide_cdrom_prep_pc(rq);
3107
3108 return 0;
3109}
3110
3111static
3112int ide_cdrom_setup (ide_drive_t *drive)
3113{
3114 struct cdrom_info *info = drive->driver_data;
3115 struct cdrom_device_info *cdi = &info->devinfo;
3116 int nslots;
3117
3118 blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
3119 blk_queue_dma_alignment(drive->queue, 31);
3120 drive->queue->unplug_delay = (1 * HZ) / 1000;
3121 if (!drive->queue->unplug_delay)
3122 drive->queue->unplug_delay = 1;
3123
3124 drive->special.all = 0;
3125
3126 CDROM_STATE_FLAGS(drive)->media_changed = 1;
3127 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
3128 CDROM_STATE_FLAGS(drive)->door_locked = 0;
3129
3130#if NO_DOOR_LOCKING
3131 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
3132#else
3133 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 0;
3134#endif
3135
3136 CDROM_CONFIG_FLAGS(drive)->drq_interrupt = ((drive->id->config & 0x0060) == 0x20);
3137 CDROM_CONFIG_FLAGS(drive)->is_changer = 0;
3138 CDROM_CONFIG_FLAGS(drive)->cd_r = 0;
3139 CDROM_CONFIG_FLAGS(drive)->cd_rw = 0;
3140 CDROM_CONFIG_FLAGS(drive)->test_write = 0;
3141 CDROM_CONFIG_FLAGS(drive)->dvd = 0;
3142 CDROM_CONFIG_FLAGS(drive)->dvd_r = 0;
3143 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 0;
3144 CDROM_CONFIG_FLAGS(drive)->no_eject = 1;
3145 CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 0;
3146 CDROM_CONFIG_FLAGS(drive)->audio_play = 0;
3147 CDROM_CONFIG_FLAGS(drive)->close_tray = 1;
3148
3149 /* limit transfer size per interrupt. */
3150 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 0;
3151 /* a testament to the nice quality of Samsung drives... */
3152 if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2430"))
3153 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3154 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2432"))
3155 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3156 /* the 3231 model does not support the SET_CD_SPEED command */
3157 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-3231"))
3158 cdi->mask |= CDC_SELECT_SPEED;
3159
3160#if ! STANDARD_ATAPI
3161 /* by default Sanyo 3 CD changer support is turned off and
3162 ATAPI Rev 2.2+ standard support for CD changers is used */
3163 cdi->sanyo_slot = 0;
3164
3165 CDROM_CONFIG_FLAGS(drive)->nec260 = 0;
3166 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 0;
3167 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 0;
3168 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 0;
3169 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 0;
3170
3171 if (strcmp (drive->id->model, "V003S0DS") == 0 &&
3172 drive->id->fw_rev[4] == '1' &&
3173 drive->id->fw_rev[6] <= '2') {
3174 /* Vertos 300.
3175 Some versions of this drive like to talk BCD. */
3176 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3177 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3178 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3179 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3180 }
3181
3182 else if (strcmp (drive->id->model, "V006E0DS") == 0 &&
3183 drive->id->fw_rev[4] == '1' &&
3184 drive->id->fw_rev[6] <= '2') {
3185 /* Vertos 600 ESD. */
3186 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3187 }
3188 else if (strcmp(drive->id->model, "NEC CD-ROM DRIVE:260") == 0 &&
3189 strncmp(drive->id->fw_rev, "1.01", 4) == 0) { /* FIXME */
3190 /* Old NEC260 (not R).
3191 This drive was released before the 1.2 version
3192 of the spec. */
3193 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3194 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3195 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3196 CDROM_CONFIG_FLAGS(drive)->nec260 = 1;
3197 }
3198 else if (strcmp(drive->id->model, "WEARNES CDD-120") == 0 &&
3199 strncmp(drive->id->fw_rev, "A1.1", 4) == 0) { /* FIXME */
3200 /* Wearnes */
3201 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3202 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3203 }
3204 /* Sanyo 3 CD changer uses a non-standard command
3205 for CD changing */
3206 else if ((strcmp(drive->id->model, "CD-ROM CDR-C3 G") == 0) ||
3207 (strcmp(drive->id->model, "CD-ROM CDR-C3G") == 0) ||
3208 (strcmp(drive->id->model, "CD-ROM CDR_C36") == 0)) {
3209 /* uses CD in slot 0 when value is set to 3 */
3210 cdi->sanyo_slot = 3;
3211 }
3212#endif /* not STANDARD_ATAPI */
3213
3214 info->toc = NULL;
3215 info->buffer = NULL;
3216 info->sector_buffered = 0;
3217 info->nsectors_buffered = 0;
3218 info->changer_info = NULL;
3219 info->last_block = 0;
3220 info->start_seek = 0;
3221
3222 nslots = ide_cdrom_probe_capabilities (drive);
3223
3224 /*
3225 * set correct block size
3226 */
3227 blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
3228
3229 if (drive->autotune == IDE_TUNE_DEFAULT ||
3230 drive->autotune == IDE_TUNE_AUTO)
3231 drive->dsc_overlap = (drive->next != drive);
3232#if 0
3233 drive->dsc_overlap = (HWIF(drive)->no_dsc) ? 0 : 1;
3234 if (HWIF(drive)->no_dsc) {
3235 printk(KERN_INFO "ide-cd: %s: disabling DSC overlap\n",
3236 drive->name);
3237 drive->dsc_overlap = 0;
3238 }
3239#endif
3240
3241 if (ide_cdrom_register(drive, nslots)) {
3242 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
3243 info->devinfo.handle = NULL;
3244 return 1;
3245 }
3246 ide_cdrom_add_settings(drive);
3247 return 0;
3248}
3249
3250static
3251sector_t ide_cdrom_capacity (ide_drive_t *drive)
3252{
3253 unsigned long capacity, sectors_per_frame;
3254
3255 if (cdrom_read_capacity(drive, &capacity, &sectors_per_frame, NULL))
3256 return 0;
3257
3258 return capacity * sectors_per_frame;
3259}
3260
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02003261static int ide_cd_remove(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003262{
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02003263 ide_drive_t *drive = to_ide_device(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003264 struct cdrom_info *info = drive->driver_data;
3265
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02003266 ide_unregister_subdriver(drive, info->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003267
3268 del_gendisk(info->disk);
3269
3270 ide_cd_put(info);
3271
3272 return 0;
3273}
3274
3275static void ide_cd_release(struct kref *kref)
3276{
3277 struct cdrom_info *info = to_ide_cd(kref);
3278 struct cdrom_device_info *devinfo = &info->devinfo;
3279 ide_drive_t *drive = info->drive;
3280 struct gendisk *g = info->disk;
3281
3282 if (info->buffer != NULL)
3283 kfree(info->buffer);
3284 if (info->toc != NULL)
3285 kfree(info->toc);
3286 if (info->changer_info != NULL)
3287 kfree(info->changer_info);
3288 if (devinfo->handle == drive && unregister_cdrom(devinfo))
3289 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom "
3290 "driver.\n", __FUNCTION__, drive->name);
3291 drive->dsc_overlap = 0;
3292 drive->driver_data = NULL;
3293 blk_queue_prep_rq(drive->queue, NULL);
3294 g->private_data = NULL;
3295 put_disk(g);
3296 kfree(info);
3297}
3298
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02003299static int ide_cd_probe(struct device *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003300
3301#ifdef CONFIG_PROC_FS
3302static int proc_idecd_read_capacity
3303 (char *page, char **start, off_t off, int count, int *eof, void *data)
3304{
3305 ide_drive_t*drive = (ide_drive_t *)data;
3306 int len;
3307
3308 len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
3309 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
3310}
3311
3312static ide_proc_entry_t idecd_proc[] = {
3313 { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
3314 { NULL, 0, NULL, NULL }
3315};
3316#else
3317# define idecd_proc NULL
3318#endif
3319
3320static ide_driver_t ide_cdrom_driver = {
3321 .owner = THIS_MODULE,
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02003322 .gen_driver = {
3323 .name = "ide-cdrom",
3324 .bus = &ide_bus_type,
3325 .probe = ide_cd_probe,
3326 .remove = ide_cd_remove,
3327 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07003328 .version = IDECD_VERSION,
3329 .media = ide_cdrom,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003330 .supports_dsc_overlap = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003331 .do_request = ide_do_rw_cdrom,
3332 .end_request = ide_end_request,
3333 .error = __ide_error,
3334 .abort = __ide_abort,
3335 .proc = idecd_proc,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003336};
3337
3338static int idecd_open(struct inode * inode, struct file * file)
3339{
3340 struct gendisk *disk = inode->i_bdev->bd_disk;
3341 struct cdrom_info *info;
3342 ide_drive_t *drive;
3343 int rc = -ENOMEM;
3344
3345 if (!(info = ide_cd_get(disk)))
3346 return -ENXIO;
3347
3348 drive = info->drive;
3349
3350 drive->usage++;
3351
3352 if (!info->buffer)
3353 info->buffer = kmalloc(SECTOR_BUFFER_SIZE,
3354 GFP_KERNEL|__GFP_REPEAT);
3355 if (!info->buffer || (rc = cdrom_open(&info->devinfo, inode, file)))
3356 drive->usage--;
3357
3358 if (rc < 0)
3359 ide_cd_put(info);
3360
3361 return rc;
3362}
3363
3364static int idecd_release(struct inode * inode, struct file * file)
3365{
3366 struct gendisk *disk = inode->i_bdev->bd_disk;
3367 struct cdrom_info *info = ide_cd_g(disk);
3368 ide_drive_t *drive = info->drive;
3369
3370 cdrom_release (&info->devinfo, file);
3371 drive->usage--;
3372
3373 ide_cd_put(info);
3374
3375 return 0;
3376}
3377
3378static int idecd_ioctl (struct inode *inode, struct file *file,
3379 unsigned int cmd, unsigned long arg)
3380{
3381 struct block_device *bdev = inode->i_bdev;
3382 struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
3383 int err;
3384
3385 err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
3386 if (err == -EINVAL)
3387 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
3388
3389 return err;
3390}
3391
3392static int idecd_media_changed(struct gendisk *disk)
3393{
3394 struct cdrom_info *info = ide_cd_g(disk);
3395 return cdrom_media_changed(&info->devinfo);
3396}
3397
3398static int idecd_revalidate_disk(struct gendisk *disk)
3399{
3400 struct cdrom_info *info = ide_cd_g(disk);
3401 struct request_sense sense;
3402 cdrom_read_toc(info->drive, &sense);
3403 return 0;
3404}
3405
3406static struct block_device_operations idecd_ops = {
3407 .owner = THIS_MODULE,
3408 .open = idecd_open,
3409 .release = idecd_release,
3410 .ioctl = idecd_ioctl,
3411 .media_changed = idecd_media_changed,
3412 .revalidate_disk= idecd_revalidate_disk
3413};
3414
3415/* options */
3416static char *ignore = NULL;
3417
3418module_param(ignore, charp, 0400);
3419MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
3420
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02003421static int ide_cd_probe(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003422{
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02003423 ide_drive_t *drive = to_ide_device(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003424 struct cdrom_info *info;
3425 struct gendisk *g;
3426 struct request_sense sense;
3427
3428 if (!strstr("ide-cdrom", drive->driver_req))
3429 goto failed;
3430 if (!drive->present)
3431 goto failed;
3432 if (drive->media != ide_cdrom && drive->media != ide_optical)
3433 goto failed;
3434 /* skip drives that we were told to ignore */
3435 if (ignore != NULL) {
3436 if (strstr(ignore, drive->name)) {
3437 printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
3438 goto failed;
3439 }
3440 }
3441 if (drive->scsi) {
3442 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
3443 goto failed;
3444 }
3445 info = (struct cdrom_info *) kmalloc (sizeof (struct cdrom_info), GFP_KERNEL);
3446 if (info == NULL) {
3447 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
3448 goto failed;
3449 }
3450
3451 g = alloc_disk(1 << PARTN_BITS);
3452 if (!g)
3453 goto out_free_cd;
3454
3455 ide_init_disk(g, drive);
3456
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02003457 ide_register_subdriver(drive, &ide_cdrom_driver);
3458
Linus Torvalds1da177e2005-04-16 15:20:36 -07003459 memset(info, 0, sizeof (struct cdrom_info));
3460
3461 kref_init(&info->kref);
3462
3463 info->drive = drive;
3464 info->driver = &ide_cdrom_driver;
3465 info->disk = g;
3466
3467 g->private_data = &info->driver;
3468
3469 drive->driver_data = info;
3470
Linus Torvalds1da177e2005-04-16 15:20:36 -07003471 g->minors = 1;
3472 snprintf(g->devfs_name, sizeof(g->devfs_name),
3473 "%s/cd", drive->devfs_name);
3474 g->driverfs_dev = &drive->gendev;
3475 g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
3476 if (ide_cdrom_setup(drive)) {
3477 struct cdrom_device_info *devinfo = &info->devinfo;
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02003478 ide_unregister_subdriver(drive, &ide_cdrom_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003479 if (info->buffer != NULL)
3480 kfree(info->buffer);
3481 if (info->toc != NULL)
3482 kfree(info->toc);
3483 if (info->changer_info != NULL)
3484 kfree(info->changer_info);
3485 if (devinfo->handle == drive && unregister_cdrom(devinfo))
3486 printk (KERN_ERR "%s: ide_cdrom_cleanup failed to unregister device from the cdrom driver.\n", drive->name);
3487 kfree(info);
3488 drive->driver_data = NULL;
3489 goto failed;
3490 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003491
3492 cdrom_read_toc(drive, &sense);
3493 g->fops = &idecd_ops;
3494 g->flags |= GENHD_FL_REMOVABLE;
3495 add_disk(g);
3496 return 0;
3497
Linus Torvalds1da177e2005-04-16 15:20:36 -07003498out_free_cd:
3499 kfree(info);
3500failed:
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02003501 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003502}
3503
3504static void __exit ide_cdrom_exit(void)
3505{
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02003506 driver_unregister(&ide_cdrom_driver.gen_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003507}
3508
3509static int ide_cdrom_init(void)
3510{
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02003511 return driver_register(&ide_cdrom_driver.gen_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003512}
3513
3514module_init(ide_cdrom_init);
3515module_exit(ide_cdrom_exit);
3516MODULE_LICENSE("GPL");