1 /*
2 * linux/drivers/ide/ide-cd.c
3 *
4 * Copyright (C) 1994, 1995, 1996 scott snyder <snyder@fnald0.fnal.gov>
5 * Copyright (C) 1996-1998 Erik Andersen <andersee@debian.org>
6 * Copyright (C) 1998-2000 Jens Axboe <axboe@suse.de>
7 *
8 * May be copied or modified under the terms of the GNU General Public
9 * License. See linux/COPYING for more information.
10 *
11 * ATAPI CD-ROM driver. To be used with ide.c.
12 * See Documentation/cdrom/ide-cd for usage information.
13 *
14 * Suggestions are welcome. Patches that work are more welcome though. ;-)
15 * For those wishing to work on this driver, please be sure you download
16 * and comply with the latest Mt. Fuji (SFF8090 version 4) and ATAPI
17 * (SFF-8020i rev 2.6) standards. These documents can be obtained by
18 * anonymous ftp from:
19 * ftp://fission.dt.wdc.com/pub/standards/SFF_atapi/spec/SFF8020-r2.6/PS/8020r26.ps
20 * ftp://ftp.avc-pioneer.com/Mtfuji4/Spec/Fuji4r10.pdf
21 *
22 * Drives that deviate from these standards will be accommodated as much
23 * as possible via compile time or command-line options. Since I only have
24 * a few drives, you generally need to send me patches...
25 *
26 * ----------------------------------
27 * TO DO LIST:
28 * -Make it so that Pioneer CD DR-A24X and friends don't get screwed up on
29 * boot
30 *
31 * ----------------------------------
32 * 1.00 Oct 31, 1994 -- Initial version.
33 * 1.01 Nov 2, 1994 -- Fixed problem with starting request in
34 * cdrom_check_status.
35 * 1.03 Nov 25, 1994 -- leaving unmask_intr[] as a user-setting (as for disks)
36 * (from mlord) -- minor changes to cdrom_setup()
37 * -- renamed ide_dev_s to ide_drive_t, enable irq on command
38 * 2.00 Nov 27, 1994 -- Generalize packet command interface;
39 * add audio ioctls.
40 * 2.01 Dec 3, 1994 -- Rework packet command interface to handle devices
41 * which send an interrupt when ready for a command.
42 * 2.02 Dec 11, 1994 -- Cache the TOC in the driver.
43 * Don't use SCMD_PLAYAUDIO_TI; it's not included
44 * in the current version of ATAPI.
45 * Try to use LBA instead of track or MSF addressing
46 * when possible.
47 * Don't wait for READY_STAT.
48 * 2.03 Jan 10, 1995 -- Rewrite block read routines to handle block sizes
49 * other than 2k and to move multiple sectors in a
50 * single transaction.
51 * 2.04 Apr 21, 1995 -- Add work-around for Creative Labs CD220E drives.
52 * Thanks to Nick Saw <cwsaw@pts7.pts.mot.com> for
53 * help in figuring this out. Ditto for Acer and
54 * Aztech drives, which seem to have the same problem.
55 * 2.04b May 30, 1995 -- Fix to match changes in ide.c version 3.16 -ml
56 * 2.05 Jun 8, 1995 -- Don't attempt to retry after an illegal request
57 * or data protect error.
58 * Use HWIF and DEV_HWIF macros as in ide.c.
59 * Always try to do a request_sense after
60 * a failed command.
61 * Include an option to give textual descriptions
62 * of ATAPI errors.
63 * Fix a bug in handling the sector cache which
64 * showed up if the drive returned data in 512 byte
65 * blocks (like Pioneer drives). Thanks to
66 * Richard Hirst <srh@gpt.co.uk> for diagnosing this.
67 * Properly supply the page number field in the
68 * MODE_SELECT command.
69 * PLAYAUDIO12 is broken on the Aztech; work around it.
70 * 2.05x Aug 11, 1995 -- lots of data structure renaming/restructuring in ide.c
71 * (my apologies to Scott, but now ide-cd.c is independent)
72 * 3.00 Aug 22, 1995 -- Implement CDROMMULTISESSION ioctl.
73 * Implement CDROMREADAUDIO ioctl (UNTESTED).
74 * Use input_ide_data() and output_ide_data().
75 * Add door locking.
76 * Fix usage count leak in cdrom_open, which happened
77 * when a read-write mount was attempted.
78 * Try to load the disk on open.
79 * Implement CDROMEJECT_SW ioctl (off by default).
80 * Read total cdrom capacity during open.
81 * Rearrange logic in cdrom_decode_status. Issue
82 * request sense commands for failed packet commands
83 * from here instead of from cdrom_queue_packet_command.
84 * Fix a race condition in retrieving error information.
85 * Suppress printing normal unit attention errors and
86 * some drive not ready errors.
87 * Implement CDROMVOLREAD ioctl.
88 * Implement CDROMREADMODE1/2 ioctls.
89 * Fix race condition in setting up interrupt handlers
90 * when the `serialize' option is used.
91 * 3.01 Sep 2, 1995 -- Fix ordering of reenabling interrupts in
92 * cdrom_queue_request.
93 * Another try at using ide_[input,output]_data.
94 * 3.02 Sep 16, 1995 -- Stick total disk capacity in partition table as well.
95 * Make VERBOSE_IDE_CD_ERRORS dump failed command again.
96 * Dump out more information for ILLEGAL REQUEST errs.
97 * Fix handling of errors occurring before the
98 * packet command is transferred.
99 * Fix transfers with odd bytelengths.
100 * 3.03 Oct 27, 1995 -- Some Creative drives have an id of just `CD'.
101 * `DCI-2S10' drives are broken too.
102 * 3.04 Nov 20, 1995 -- So are Vertos drives.
103 * 3.05 Dec 1, 1995 -- Changes to go with overhaul of ide.c and ide-tape.c
104 * 3.06 Dec 16, 1995 -- Add support needed for partitions.
105 * More workarounds for Vertos bugs (based on patches
106 * from Holger Dietze <dietze@aix520.informatik.uni-leipzig.de>).
107 * Try to eliminate byteorder assumptions.
108 * Use atapi_cdrom_subchnl struct definition.
109 * Add STANDARD_ATAPI compilation option.
110 * 3.07 Jan 29, 1996 -- More twiddling for broken drives: Sony 55D,
111 * Vertos 300.
112 * Add NO_DOOR_LOCKING configuration option.
113 * Handle drive_cmd requests w/NULL args (for hdparm -t).
114 * Work around sporadic Sony55e audio play problem.
115 * 3.07a Feb 11, 1996 -- check drive->id for NULL before dereferencing, to fix
116 * problem with "hde=cdrom" with no drive present. -ml
117 * 3.08 Mar 6, 1996 -- More Vertos workarounds.
118 * 3.09 Apr 5, 1996 -- Add CDROMCLOSETRAY ioctl.
119 * Switch to using MSF addressing for audio commands.
120 * Reformat to match kernel tabbing style.
121 * Add CDROM_GET_UPC ioctl.
122 * 3.10 Apr 10, 1996 -- Fix compilation error with STANDARD_ATAPI.
123 * 3.11 Apr 29, 1996 -- Patch from Heiko Eissfeldt <heiko@colossus.escape.de>
124 * to remove redundant verify_area calls.
125 * 3.12 May 7, 1996 -- Rudimentary changer support. Based on patches
126 * from Gerhard Zuber <zuber@berlin.snafu.de>.
127 * Let open succeed even if there's no loaded disc.
128 * 3.13 May 19, 1996 -- Fixes for changer code.
129 * 3.14 May 29, 1996 -- Add work-around for Vertos 600.
130 * (From Hennus Bergman <hennus@sky.ow.nl>.)
131 * 3.15 July 2, 1996 -- Added support for Sanyo 3 CD changers
132 * from Ben Galliart <bgallia@luc.edu> with
133 * special help from Jeff Lightfoot
134 * <jeffml@pobox.com>
135 * 3.15a July 9, 1996 -- Improved Sanyo 3 CD changer identification
136 * 3.16 Jul 28, 1996 -- Fix from Gadi to reduce kernel stack usage for ioctl.
137 * 3.17 Sep 17, 1996 -- Tweak audio reads for some drives.
138 * Start changing CDROMLOADFROMSLOT to CDROM_SELECT_DISC.
139 * 3.18 Oct 31, 1996 -- Added module and DMA support.
140 *
141 *
142 * 4.00 Nov 5, 1996 -- New ide-cd maintainer,
143 * Erik B. Andersen <andersee@debian.org>
144 * -- Newer Creative drives don't always set the error
145 * register correctly. Make sure we see media changes
146 * regardless.
147 * -- Integrate with generic cdrom driver.
148 * -- CDROMGETSPINDOWN and CDROMSETSPINDOWN ioctls, based on
149 * a patch from Ciro Cattuto <>.
150 * -- Call set_device_ro.
151 * -- Implement CDROMMECHANISMSTATUS and CDROMSLOTTABLE
152 * ioctls, based on patch by Erik Andersen
153 * -- Add some probes of drive capability during setup.
154 *
155 * 4.01 Nov 11, 1996 -- Split into ide-cd.c and ide-cd.h
156 * -- Removed CDROMMECHANISMSTATUS and CDROMSLOTTABLE
157 * ioctls in favor of a generalized approach
158 * using the generic cdrom driver.
159 * -- Fully integrated with the 2.1.X kernel.
160 * -- Other stuff that I forgot (lots of changes)
161 *
162 * 4.02 Dec 01, 1996 -- Applied patch from Gadi Oxman <gadio@netvision.net.il>
163 * to fix the drive door locking problems.
164 *
165 * 4.03 Dec 04, 1996 -- Added DSC overlap support.
166 * 4.04 Dec 29, 1996 -- Added CDROMREADRAW ioclt based on patch
167 * by Ales Makarov (xmakarov@sun.felk.cvut.cz)
168 *
169 * 4.05 Nov 20, 1997 -- Modified to print more drive info on init
170 * Minor other changes
171 * Fix errors on CDROMSTOP (If you have a "Dolphin",
172 * you must define IHAVEADOLPHIN)
173 * Added identifier so new Sanyo CD-changer works
174 * Better detection if door locking isn't supported
175 *
176 * 4.06 Dec 17, 1997 -- fixed endless "tray open" messages -ml
177 * 4.07 Dec 17, 1997 -- fallback to set pc->stat on "tray open"
178 * 4.08 Dec 18, 1997 -- spew less noise when tray is empty
179 * -- fix speed display for ACER 24X, 18X
180 * 4.09 Jan 04, 1998 -- fix handling of the last block so we return
181 * an end of file instead of an I/O error (Gadi)
182 * 4.10 Jan 24, 1998 -- fixed a bug so now changers can change to a new
183 * slot when there is no disc in the current slot.
184 * -- Fixed a memory leak where info->changer_info was
185 * malloc'ed but never free'd when closing the device.
186 * -- Cleaned up the global namespace a bit by making more
187 * functions static that should already have been.
188 * 4.11 Mar 12, 1998 -- Added support for the CDROM_SELECT_SPEED ioctl
189 * based on a patch for 2.0.33 by Jelle Foks
190 * <jelle@scintilla.utwente.nl>, a patch for 2.0.33
191 * by Toni Giorgino <toni@pcape2.pi.infn.it>, the SCSI
192 * version, and my own efforts. -erik
193 * -- Fixed a stupid bug which egcs was kind enough to
194 * inform me of where "Illegal mode for this track"
195 * was never returned due to a comparison on data
196 * types of limited range.
197 * 4.12 Mar 29, 1998 -- Fixed bug in CDROM_SELECT_SPEED so write speed is
198 * now set ionly for CD-R and CD-RW drives. I had
199 * removed this support because it produced errors.
200 * It produced errors _only_ for non-writers. duh.
201 * 4.13 May 05, 1998 -- Suppress useless "in progress of becoming ready"
202 * messages, since this is not an error.
203 * -- Change error messages to be const
204 * -- Remove a "\t" which looks ugly in the syslogs
205 * 4.14 July 17, 1998 -- Change to pointing to .ps version of ATAPI spec
206 * since the .pdf version doesn't seem to work...
207 * -- Updated the TODO list to something more current.
208 *
209 * 4.15 Aug 25, 1998 -- Updated ide-cd.h to respect mechine endianess,
210 * patch thanks to "Eddie C. Dost" <ecd@skynet.be>
211 *
212 * 4.50 Oct 19, 1998 -- New maintainers!
213 * Jens Axboe <axboe@image.dk>
214 * Chris Zwilling <chris@cloudnet.com>
215 *
216 * 4.51 Dec 23, 1998 -- Jens Axboe <axboe@image.dk>
217 * - ide_cdrom_reset enabled since the ide subsystem
218 * handles resets fine now. <axboe@image.dk>
219 * - Transfer size fix for Samsung CD-ROMs, thanks to
220 * "Ville Hallik" <ville.hallik@mail.ee>.
221 * - other minor stuff.
222 *
223 * 4.52 Jan 19, 1999 -- Jens Axboe <axboe@image.dk>
224 * - Detect DVD-ROM/RAM drives
225 *
226 * 4.53 Feb 22, 1999 - Include other model Samsung and one Goldstar
227 * drive in transfer size limit.
228 * - Fix the I/O error when doing eject without a medium
229 * loaded on some drives.
230 * - CDROMREADMODE2 is now implemented through
231 * CDROMREADRAW, since many drives don't support
232 * MODE2 (even though ATAPI 2.6 says they must).
233 * - Added ignore parameter to ide-cd (as a module), eg
234 * insmod ide-cd ignore='hda hdb'
235 * Useful when using ide-cd in conjunction with
236 * ide-scsi. TODO: non-modular way of doing the
237 * same.
238 *
239 * 4.54 Aug 5, 1999 - Support for MMC2 class commands through the generic
240 * packet interface to cdrom.c.
241 * - Unified audio ioctl support, most of it.
242 * - cleaned up various deprecated verify_area().
243 * - Added ide_cdrom_packet() as the interface for
244 * the Uniform generic_packet().
245 * - bunch of other stuff, will fill in logs later.
246 * - report 1 slot for non-changers, like the other
247 * cd-rom drivers. don't report select disc for
248 * non-changers as well.
249 * - mask out audio playing, if the device can't do it.
250 *
251 * 4.55 Sep 1, 1999 - Eliminated the rest of the audio ioctls, except
252 * for CDROMREADTOC[ENTRY|HEADER]. Some of the drivers
253 * use this independently of the actual audio handling.
254 * They will disappear later when I get the time to
255 * do it cleanly.
256 * - Minimize the TOC reading - only do it when we
257 * know a media change has occurred.
258 * - Moved all the CDROMREADx ioctls to the Uniform layer.
259 * - Heiko Eissfeldt <heiko@colossus.escape.de> supplied
260 * some fixes for CDI.
261 * - CD-ROM leaving door locked fix from Andries
262 * Brouwer <Andries.Brouwer@cwi.nl>
263 * - Erik Andersen <andersen@xmission.com> unified
264 * commands across the various drivers and how
265 * sense errors are handled.
266 *
267 * 4.56 Sep 12, 1999 - Removed changer support - it is now in the
268 * Uniform layer.
269 * - Added partition based multisession handling.
270 * - Mode sense and mode select moved to the
271 * Uniform layer.
272 * - Fixed a problem with WPI CDS-32X drive - it
273 * failed the capabilities
274 *
275 * 4.57 Apr 7, 2000 - Fixed sense reporting.
276 * - Fixed possible oops in ide_cdrom_get_last_session()
277 * - Fix locking mania and make ide_cdrom_reset relock
278 * - Stop spewing errors to log when magicdev polls with
279 * TEST_UNIT_READY on some drives.
280 * - Various fixes from Tobias Ringstrom:
281 * tray if it was locked prior to the reset.
282 * - cdrom_read_capacity returns one frame too little.
283 * - Fix real capacity reporting.
284 *
285 * 4.58 May 1, 2000 - Clean up ACER50 stuff.
286 * - Fix small problem with ide_cdrom_capacity
287 *
288 * 4.59 Aug 11, 2000 - Fix changer problem in cdrom_read_toc, we weren't
289 * correctly sensing a disc change.
290 * - Rearranged some code
291 * - Use extended sense on drives that support it for
292 * correctly reporting tray status -- from
293 * Michael D Johnson <johnsom@orst.edu>
294 * 4.60 Dec 17, 2003 - Add mt rainier support
295 * - Bump timeout for packet commands, matches sr
296 * - Odd stuff
297 * 4.61 Jan 22, 2004 - support hardware sector sizes other than 2kB,
298 * Pascal Schmidt <der.eremit@email.de>
299 *
300 *************************************************************************/
301
302 #define IDECD_VERSION "4.61"
303
304 #include <linux/config.h>
305 #include <linux/module.h>
306 #include <linux/types.h>
307 #include <linux/kernel.h>
308 #include <linux/delay.h>
309 #include <linux/timer.h>
310 #include <linux/slab.h>
311 #include <linux/interrupt.h>
312 #include <linux/errno.h>
313 #include <linux/cdrom.h>
314 #include <linux/ide.h>
315 #include <linux/completion.h>
316
317 #include <scsi/scsi.h> /* For SCSI -> ATAPI command conversion */
318
319 #include <asm/irq.h>
320 #include <asm/io.h>
321 #include <asm/byteorder.h>
322 #include <asm/uaccess.h>
323 #include <asm/unaligned.h>
324
325 #include "ide-cd.h"
326
327 /****************************************************************************
328 * Generic packet command support and error handling routines.
329 */
330
331 /* Mark that we've seen a media change, and invalidate our internal
332 buffers. */
333 static void cdrom_saw_media_change (ide_drive_t *drive)
334 {
335 struct cdrom_info *info = drive->driver_data;
336
337 CDROM_STATE_FLAGS (drive)->media_changed = 1;
338 CDROM_STATE_FLAGS (drive)->toc_valid = 0;
339 info->nsectors_buffered = 0;
340 }
341
342 static int cdrom_log_sense(ide_drive_t *drive, struct request *rq,
343 struct request_sense *sense)
344 {
345 int log = 0;
346
347 if (!sense || !rq || (rq->flags & REQ_QUIET))
348 return 0;
349
350 switch (sense->sense_key) {
351 case NO_SENSE: case RECOVERED_ERROR:
352 break;
353 case NOT_READY:
354 /*
355 * don't care about tray state messages for
356 * e.g. capacity commands or in-progress or
357 * becoming ready
358 */
359 if (sense->asc == 0x3a || sense->asc == 0x04)
360 break;
361 log = 1;
362 break;
363 case ILLEGAL_REQUEST:
364 /*
365 * don't log START_STOP unit with LoEj set, since
366 * we cannot reliably check if drive can auto-close
367 */
368 if (rq->cmd[0] == GPCMD_START_STOP_UNIT && sense->asc == 0x24)
369 log = 0;
370 break;
371 case UNIT_ATTENTION:
372 /*
373 * Make good and sure we've seen this potential media
374 * change. Some drives (i.e. Creative) fail to present
375 * the correct sense key in the error register.
376 */
377 cdrom_saw_media_change(drive);
378 break;
379 default:
380 log = 1;
381 break;
382 }
383 return log;
384 }
385
386 static
387 void cdrom_analyze_sense_data(ide_drive_t *drive,
388 struct request *failed_command,
389 struct request_sense *sense)
390 {
391 if (!cdrom_log_sense(drive, failed_command, sense))
392 return;
393
394 /*
395 * If a read toc is executed for a CD-R or CD-RW medium where
396 * the first toc has not been recorded yet, it will fail with
397 * 05/24/00 (which is a confusing error)
398 */
399 if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP)
400 if (sense->sense_key == 0x05 && sense->asc == 0x24)
401 return;
402
403 #if VERBOSE_IDE_CD_ERRORS
404 {
405 int i;
406 const char *s;
407 char buf[80];
408
409 printk ("ATAPI device %s:\n", drive->name);
410 if (sense->error_code==0x70)
411 printk(" Error: ");
412 else if (sense->error_code==0x71)
413 printk(" Deferred Error: ");
414 else if (sense->error_code == 0x7f)
415 printk(" Vendor-specific Error: ");
416 else
417 printk(" Unknown Error Type: ");
418
419 if (sense->sense_key < ARY_LEN(sense_key_texts))
420 s = sense_key_texts[sense->sense_key];
421 else
422 s = "bad sense key!";
423
424 printk("%s -- (Sense key=0x%02x)\n", s, sense->sense_key);
425
426 if (sense->asc == 0x40) {
427 sprintf(buf, "Diagnostic failure on component 0x%02x",
428 sense->ascq);
429 s = buf;
430 } else {
431 int lo = 0, mid, hi = ARY_LEN(sense_data_texts);
432 unsigned long key = (sense->sense_key << 16);
433 key |= (sense->asc << 8);
434 if (!(sense->ascq >= 0x80 && sense->ascq <= 0xdd))
435 key |= sense->ascq;
436 s = NULL;
437
438 while (hi > lo) {
439 mid = (lo + hi) / 2;
440 if (sense_data_texts[mid].asc_ascq == key ||
441 sense_data_texts[mid].asc_ascq == (0xff0000|key)) {
442 s = sense_data_texts[mid].text;
443 break;
444 }
445 else if (sense_data_texts[mid].asc_ascq > key)
446 hi = mid;
447 else
448 lo = mid+1;
449 }
450 }
451
452 if (s == NULL) {
453 if (sense->asc > 0x80)
454 s = "(vendor-specific error)";
455 else
456 s = "(reserved error code)";
457 }
458
459 printk(KERN_ERR " %s -- (asc=0x%02x, ascq=0x%02x)\n",
460 s, sense->asc, sense->ascq);
461
462 if (failed_command != NULL) {
463
464 int lo=0, mid, hi= ARY_LEN (packet_command_texts);
465 s = NULL;
466
467 while (hi > lo) {
468 mid = (lo + hi) / 2;
469 if (packet_command_texts[mid].packet_command ==
470 failed_command->cmd[0]) {
471 s = packet_command_texts[mid].text;
472 break;
473 }
474 if (packet_command_texts[mid].packet_command >
475 failed_command->cmd[0])
476 hi = mid;
477 else
478 lo = mid+1;
479 }
480
481 printk (KERN_ERR " The failed \"%s\" packet command was: \n \"", s);
482 for (i=0; i<sizeof (failed_command->cmd); i++)
483 printk ("%02x ", failed_command->cmd[i]);
484 printk ("\"\n");
485 }
486
487 /* The SKSV bit specifies validity of the sense_key_specific
488 * in the next two commands. It is bit 7 of the first byte.
489 * In the case of NOT_READY, if SKSV is set the drive can
490 * give us nice ETA readings.
491 */
492 if (sense->sense_key == NOT_READY && (sense->sks[0] & 0x80)) {
493 int progress = (sense->sks[1] << 8 | sense->sks[2]) * 100;
494 printk(KERN_ERR " Command is %02d%% complete\n", progress / 0xffff);
495
496 }
497
498 if (sense->sense_key == ILLEGAL_REQUEST &&
499 (sense->sks[0] & 0x80) != 0) {
500 printk(KERN_ERR " Error in %s byte %d",
501 (sense->sks[0] & 0x40) != 0 ?
502 "command packet" : "command data",
503 (sense->sks[1] << 8) + sense->sks[2]);
504
505 if ((sense->sks[0] & 0x40) != 0)
506 printk (" bit %d", sense->sks[0] & 0x07);
507
508 printk ("\n");
509 }
510 }
511
512 #else /* not VERBOSE_IDE_CD_ERRORS */
513
514 /* Suppress printing unit attention and `in progress of becoming ready'
515 errors when we're not being verbose. */
516
517 if (sense->sense_key == UNIT_ATTENTION ||
518 (sense->sense_key == NOT_READY && (sense->asc == 4 ||
519 sense->asc == 0x3a)))
520 return;
521
522 printk(KERN_ERR "%s: error code: 0x%02x sense_key: 0x%02x asc: 0x%02x ascq: 0x%02x\n",
523 drive->name,
524 sense->error_code, sense->sense_key,
525 sense->asc, sense->ascq);
526 #endif /* not VERBOSE_IDE_CD_ERRORS */
527 }
528
529 /*
530 * Initialize a ide-cd packet command request
531 */
532 static void cdrom_prepare_request(struct request *rq)
533 {
534 ide_init_drive_cmd(rq);
535 rq->flags = REQ_PC;
536 }
537
538 static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense,
539 struct request *failed_command)
540 {
541 struct cdrom_info *info = drive->driver_data;
542 struct request *rq = &info->request_sense_request;
543
544 if (sense == NULL)
545 sense = &info->sense_data;
546
547 /* stuff the sense request in front of our current request */
548 cdrom_prepare_request(rq);
549
550 rq->data = sense;
551 rq->cmd[0] = GPCMD_REQUEST_SENSE;
552 rq->cmd[4] = rq->data_len = 18;
553
554 rq->flags = REQ_SENSE;
555
556 /* NOTE! Save the failed command in "rq->buffer" */
557 rq->buffer = (void *) failed_command;
558
559 (void) ide_do_drive_cmd(drive, rq, ide_preempt);
560 }
561
562 static void cdrom_end_request (ide_drive_t *drive, int uptodate)
563 {
564 struct request *rq = HWGROUP(drive)->rq;
565 int nsectors = rq->hard_cur_sectors;
566
567 if ((rq->flags & REQ_SENSE) && uptodate) {
568 /*
569 * For REQ_SENSE, "rq->buffer" points to the original failed
570 * request
571 */
572 struct request *failed = (struct request *) rq->buffer;
573 struct cdrom_info *info = drive->driver_data;
574 void *sense = &info->sense_data;
575 unsigned long flags;
576
577 if (failed) {
578 if (failed->sense) {
579 sense = failed->sense;
580 failed->sense_len = rq->sense_len;
581 }
582
583 /*
584 * now end failed request
585 */
586 spin_lock_irqsave(&ide_lock, flags);
587 end_that_request_chunk(failed, 0, failed->data_len);
588 end_that_request_last(failed);
589 spin_unlock_irqrestore(&ide_lock, flags);
590 }
591
592 cdrom_analyze_sense_data(drive, failed, sense);
593 }
594
595 if (!rq->current_nr_sectors && blk_fs_request(rq))
596 uptodate = 1;
597 /* make sure it's fully ended */
598 if (blk_pc_request(rq))
599 nsectors = (rq->data_len + 511) >> 9;
600 if (!nsectors)
601 nsectors = 1;
602
603 ide_end_request(drive, uptodate, nsectors);
604 }
605
606 /* Returns 0 if the request should be continued.
607 Returns 1 if the request was ended. */
608 static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
609 {
610 struct request *rq = HWGROUP(drive)->rq;
611 int stat, err, sense_key;
612
613 /* Check for errors. */
614 stat = HWIF(drive)->INB(IDE_STATUS_REG);
615 if (stat_ret)
616 *stat_ret = stat;
617
618 if (OK_STAT(stat, good_stat, BAD_R_STAT))
619 return 0;
620
621 /* Get the IDE error register. */
622 err = HWIF(drive)->INB(IDE_ERROR_REG);
623 sense_key = err >> 4;
624
625 if (rq == NULL) {
626 printk("%s: missing rq in cdrom_decode_status\n", drive->name);
627 return 1;
628 }
629
630 if (rq->flags & REQ_SENSE) {
631 /* We got an error trying to get sense info
632 from the drive (probably while trying
633 to recover from a former error). Just give up. */
634
635 rq->flags |= REQ_FAILED;
636 cdrom_end_request(drive, 0);
637 ide_error(drive, "request sense failure", stat);
638 return 1;
639
640 } else if (rq->flags & (REQ_PC | REQ_BLOCK_PC)) {
641 /* All other functions, except for READ. */
642 unsigned long flags;
643
644 /*
645 * if we have an error, pass back CHECK_CONDITION as the
646 * scsi status byte
647 */
648 if ((rq->flags & REQ_BLOCK_PC) && !rq->errors)
649 rq->errors = SAM_STAT_CHECK_CONDITION;
650
651 /* Check for tray open. */
652 if (sense_key == NOT_READY) {
653 cdrom_saw_media_change (drive);
654 } else if (sense_key == UNIT_ATTENTION) {
655 /* Check for media change. */
656 cdrom_saw_media_change (drive);
657 /*printk("%s: media changed\n",drive->name);*/
658 return 0;
659 } else if (!(rq->flags & REQ_QUIET)) {
660 /* Otherwise, print an error. */
661 ide_dump_status(drive, "packet command error", stat);
662 }
663
664 rq->flags |= REQ_FAILED;
665
666 /*
667 * instead of playing games with moving completions around,
668 * remove failed request completely and end it when the
669 * request sense has completed
670 */
671 if (stat & ERR_STAT) {
672 spin_lock_irqsave(&ide_lock, flags);
673 blkdev_dequeue_request(rq);
674 HWGROUP(drive)->rq = NULL;
675 spin_unlock_irqrestore(&ide_lock, flags);
676
677 cdrom_queue_request_sense(drive, rq->sense, rq);
678 } else
679 cdrom_end_request(drive, 0);
680
681 } else if (blk_fs_request(rq)) {
682 int do_end_request = 0;
683
684 /* Handle errors from READ and WRITE requests. */
685
686 if (blk_noretry_request(rq))
687 do_end_request = 1;
688
689 if (sense_key == NOT_READY) {
690 /* Tray open. */
691 if (rq_data_dir(rq) == READ) {
692 cdrom_saw_media_change (drive);
693
694 /* Fail the request. */
695 printk ("%s: tray open\n", drive->name);
696 do_end_request = 1;
697 } else {
698 struct cdrom_info *info = drive->driver_data;
699
700 /* allow the drive 5 seconds to recover, some
701 * devices will return this error while flushing
702 * data from cache */
703 if (!rq->errors)
704 info->write_timeout = jiffies + ATAPI_WAIT_WRITE_BUSY;
705 rq->errors = 1;
706 if (time_after(jiffies, info->write_timeout))
707 do_end_request = 1;
708 else {
709 unsigned long flags;
710
711 /*
712 * take a breather relying on the
713 * unplug timer to kick us again
714 */
715 spin_lock_irqsave(&ide_lock, flags);
716 blk_plug_device(drive->queue);
717 spin_unlock_irqrestore(&ide_lock,flags);
718 return 1;
719 }
720 }
721 } else if (sense_key == UNIT_ATTENTION) {
722 /* Media change. */
723 cdrom_saw_media_change (drive);
724
725 /* Arrange to retry the request.
726 But be sure to give up if we've retried
727 too many times. */
728 if (++rq->errors > ERROR_MAX)
729 do_end_request = 1;
730 } else if (sense_key == ILLEGAL_REQUEST ||
731 sense_key == DATA_PROTECT) {
732 /* No point in retrying after an illegal
733 request or data protect error.*/
734 ide_dump_status (drive, "command error", stat);
735 do_end_request = 1;
736 } else if (sense_key == MEDIUM_ERROR) {
737 /* No point in re-trying a zillion times on a bad
738 * sector... If we got here the error is not correctable */
739 ide_dump_status (drive, "media error (bad sector)", stat);
740 do_end_request = 1;
741 } else if (sense_key == BLANK_CHECK) {
742 /* Disk appears blank ?? */
743 ide_dump_status (drive, "media error (blank)", stat);
744 do_end_request = 1;
745 } else if ((err & ~ABRT_ERR) != 0) {
746 /* Go to the default handler
747 for other errors. */
748 ide_error(drive, "cdrom_decode_status", stat);
749 return 1;
750 } else if ((++rq->errors > ERROR_MAX)) {
751 /* We've racked up too many retries. Abort. */
752 do_end_request = 1;
753 }
754
755 if (do_end_request)
756 cdrom_end_request(drive, 0);
757
758 /* If we got a CHECK_CONDITION status,
759 queue a request sense command. */
760 if ((stat & ERR_STAT) != 0)
761 cdrom_queue_request_sense(drive, NULL, NULL);
762 } else {
763 blk_dump_rq_flags(rq, "ide-cd: bad rq");
764 cdrom_end_request(drive, 0);
765 }
766
767 /* Retry, or handle the next request. */
768 return 1;
769 }
770
771 static int cdrom_timer_expiry(ide_drive_t *drive)
772 {
773 struct request *rq = HWGROUP(drive)->rq;
774 unsigned long wait = 0;
775
776 /*
777 * Some commands are *slow* and normally take a long time to
778 * complete. Usually we can use the ATAPI "disconnect" to bypass
779 * this, but not all commands/drives support that. Let
780 * ide_timer_expiry keep polling us for these.
781 */
782 switch (rq->cmd[0]) {
783 case GPCMD_BLANK:
784 case GPCMD_FORMAT_UNIT:
785 case GPCMD_RESERVE_RZONE_TRACK:
786 case GPCMD_CLOSE_TRACK:
787 case GPCMD_FLUSH_CACHE:
788 wait = ATAPI_WAIT_PC;
789 break;
790 default:
791 if (!(rq->flags & REQ_QUIET))
792 printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n", rq->cmd[0]);
793 wait = 0;
794 break;
795 }
796 return wait;
797 }
798
799 /* Set up the device registers for transferring a packet command on DEV,
800 expecting to later transfer XFERLEN bytes. HANDLER is the routine
801 which actually transfers the command to the drive. If this is a
802 drq_interrupt device, this routine will arrange for HANDLER to be
803 called when the interrupt from the drive arrives. Otherwise, HANDLER
804 will be called immediately after the drive is prepared for the transfer. */
805
806 static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
807 int xferlen,
808 ide_handler_t *handler)
809 {
810 ide_startstop_t startstop;
811 struct cdrom_info *info = drive->driver_data;
812 ide_hwif_t *hwif = drive->hwif;
813
814 /* Wait for the controller to be idle. */
815 if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY))
816 return startstop;
817
818 if (info->dma)
819 info->dma = !hwif->dma_setup(drive);
820
821 /* Set up the controller registers. */
822 /* FIXME: for Virtual DMA we must check harder */
823 HWIF(drive)->OUTB(info->dma, IDE_FEATURE_REG);
824 HWIF(drive)->OUTB(0, IDE_IREASON_REG);
825 HWIF(drive)->OUTB(0, IDE_SECTOR_REG);
826
827 HWIF(drive)->OUTB(xferlen & 0xff, IDE_BCOUNTL_REG);
828 HWIF(drive)->OUTB(xferlen >> 8 , IDE_BCOUNTH_REG);
829 if (IDE_CONTROL_REG)
830 HWIF(drive)->OUTB(drive->ctl, IDE_CONTROL_REG);
831
832 if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt) {
833 /* packet command */
834 ide_execute_command(drive, WIN_PACKETCMD, handler, ATAPI_WAIT_PC, cdrom_timer_expiry);
835 return ide_started;
836 } else {
837 unsigned long flags;
838
839 /* packet command */
840 spin_lock_irqsave(&ide_lock, flags);
841 hwif->OUTBSYNC(drive, WIN_PACKETCMD, IDE_COMMAND_REG);
842 ndelay(400);
843 spin_unlock_irqrestore(&ide_lock, flags);
844
845 return (*handler) (drive);
846 }
847 }
848
849 /* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
850 The device registers must have already been prepared
851 by cdrom_start_packet_command.
852 HANDLER is the interrupt handler to call when the command completes
853 or there's data ready. */
854 /*
855 * changed 5 parameters to 3 for dvd-ram
856 * struct packet_command *pc; now packet_command_t *pc;
857 */
858 #define ATAPI_MIN_CDB_BYTES 12
859 static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
860 struct request *rq,
861 ide_handler_t *handler)
862 {
863 ide_hwif_t *hwif = drive->hwif;
864 int cmd_len;
865 struct cdrom_info *info = drive->driver_data;
866 ide_startstop_t startstop;
867
868 if (CDROM_CONFIG_FLAGS(drive)->drq_interrupt) {
869 /* Here we should have been called after receiving an interrupt
870 from the device. DRQ should how be set. */
871
872 /* Check for errors. */
873 if (cdrom_decode_status(drive, DRQ_STAT, NULL))
874 return ide_stopped;
875 } else {
876 /* Otherwise, we must wait for DRQ to get set. */
877 if (ide_wait_stat(&startstop, drive, DRQ_STAT,
878 BUSY_STAT, WAIT_READY))
879 return startstop;
880 }
881
882 /* Arm the interrupt handler. */
883 ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);
884
885 /* ATAPI commands get padded out to 12 bytes minimum */
886 cmd_len = COMMAND_SIZE(rq->cmd[0]);
887 if (cmd_len < ATAPI_MIN_CDB_BYTES)
888 cmd_len = ATAPI_MIN_CDB_BYTES;
889
890 /* Send the command to the device. */
891 HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len);
892
893 /* Start the DMA if need be */
894 if (info->dma)
895 hwif->dma_start(drive);
896
897 return ide_started;
898 }
899
900 /****************************************************************************
901 * Block read functions.
902 */
903
904 /*
905 * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
906 * buffer. Once the first sector is added, any subsequent sectors are
907 * assumed to be continuous (until the buffer is cleared). For the first
908 * sector added, SECTOR is its sector number. (SECTOR is then ignored until
909 * the buffer is cleared.)
910 */
911 static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
912 int sectors_to_transfer)
913 {
914 struct cdrom_info *info = drive->driver_data;
915
916 /* Number of sectors to read into the buffer. */
917 int sectors_to_buffer = min_t(int, sectors_to_transfer,
918 (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
919 info->nsectors_buffered);
920
921 char *dest;
922
923 /* If we couldn't get a buffer, don't try to buffer anything... */
924 if (info->buffer == NULL)
925 sectors_to_buffer = 0;
926
927 /* If this is the first sector in the buffer, remember its number. */
928 if (info->nsectors_buffered == 0)
929 info->sector_buffered = sector;
930
931 /* Read the data into the buffer. */
932 dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
933 while (sectors_to_buffer > 0) {
934 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
935 --sectors_to_buffer;
936 --sectors_to_transfer;
937 ++info->nsectors_buffered;
938 dest += SECTOR_SIZE;
939 }
940
941 /* Throw away any remaining data. */
942 while (sectors_to_transfer > 0) {
943 static char dum[SECTOR_SIZE];
944 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
945 --sectors_to_transfer;
946 }
947 }
948
949 /*
950 * Check the contents of the interrupt reason register from the cdrom
951 * and attempt to recover if there are problems. Returns 0 if everything's
952 * ok; nonzero if the request has been terminated.
953 */
954 static inline
955 int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
956 {
957 if (ireason == 2)
958 return 0;
959 else if (ireason == 0) {
960 /* Whoops... The drive is expecting to receive data from us! */
961 printk(KERN_ERR "%s: read_intr: Drive wants to transfer data the "
962 "wrong way!\n", drive->name);
963
964 /* Throw some data at the drive so it doesn't hang
965 and quit this request. */
966 while (len > 0) {
967 int dum = 0;
968 HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof (dum));
969 len -= sizeof (dum);
970 }
971 } else if (ireason == 1) {
972 /* Some drives (ASUS) seem to tell us that status
973 * info is available. just get it and ignore.
974 */
975 (void) HWIF(drive)->INB(IDE_STATUS_REG);
976 return 0;
977 } else {
978 /* Drive wants a command packet, or invalid ireason... */
979 printk(KERN_ERR "%s: read_intr: bad interrupt reason %x\n", drive->name,
980 ireason);
981 }
982
983 cdrom_end_request(drive, 0);
984 return -1;
985 }
986
987 /*
988 * Interrupt routine. Called when a read request has completed.
989 */
990 static ide_startstop_t cdrom_read_intr (ide_drive_t *drive)
991 {
992 int stat;
993 int ireason, len, sectors_to_transfer, nskip;
994 struct cdrom_info *info = drive->driver_data;
995 u8 lowcyl = 0, highcyl = 0;
996 int dma = info->dma, dma_error = 0;
997
998 struct request *rq = HWGROUP(drive)->rq;
999
1000 /*
1001 * handle dma case
1002 */
1003 if (dma) {
1004 info->dma = 0;
1005 if ((dma_error = HWIF(drive)->ide_dma_end(drive)))
1006 __ide_dma_off(drive);
1007 }
1008
1009 if (cdrom_decode_status(drive, 0, &stat))
1010 return ide_stopped;
1011
1012 if (dma) {
1013 if (!dma_error) {
1014 ide_end_request(drive, 1, rq->nr_sectors);
1015 return ide_stopped;
1016 } else
1017 return ide_error(drive, "dma error", stat);
1018 }
1019
1020 /* Read the interrupt reason and the transfer length. */
1021 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1022 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1023 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1024
1025 len = lowcyl + (256 * highcyl);
1026
1027 /* If DRQ is clear, the command has completed. */
1028 if ((stat & DRQ_STAT) == 0) {
1029 /* If we're not done filling the current buffer, complain.
1030 Otherwise, complete the command normally. */
1031 if (rq->current_nr_sectors > 0) {
1032 printk (KERN_ERR "%s: cdrom_read_intr: data underrun (%d blocks)\n",
1033 drive->name, rq->current_nr_sectors);
1034 rq->flags |= REQ_FAILED;
1035 cdrom_end_request(drive, 0);
1036 } else
1037 cdrom_end_request(drive, 1);
1038 return ide_stopped;
1039 }
1040
1041 /* Check that the drive is expecting to do the same thing we are. */
1042 if (cdrom_read_check_ireason (drive, len, ireason))
1043 return ide_stopped;
1044
1045 /* Assume that the drive will always provide data in multiples
1046 of at least SECTOR_SIZE, as it gets hairy to keep track
1047 of the transfers otherwise. */
1048 if ((len % SECTOR_SIZE) != 0) {
1049 printk (KERN_ERR "%s: cdrom_read_intr: Bad transfer size %d\n",
1050 drive->name, len);
1051 if (CDROM_CONFIG_FLAGS(drive)->limit_nframes)
1052 printk (KERN_ERR " This drive is not supported by this version of the driver\n");
1053 else {
1054 printk (KERN_ERR " Trying to limit transfer sizes\n");
1055 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
1056 }
1057 cdrom_end_request(drive, 0);
1058 return ide_stopped;
1059 }
1060
1061 /* The number of sectors we need to read from the drive. */
1062 sectors_to_transfer = len / SECTOR_SIZE;
1063
1064 /* First, figure out if we need to bit-bucket
1065 any of the leading sectors. */
1066 nskip = min_t(int, rq->current_nr_sectors - bio_cur_sectors(rq->bio), sectors_to_transfer);
1067
1068 while (nskip > 0) {
1069 /* We need to throw away a sector. */
1070 static char dum[SECTOR_SIZE];
1071 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1072
1073 --rq->current_nr_sectors;
1074 --nskip;
1075 --sectors_to_transfer;
1076 }
1077
1078 /* Now loop while we still have data to read from the drive. */
1079 while (sectors_to_transfer > 0) {
1080 int this_transfer;
1081
1082 /* If we've filled the present buffer but there's another
1083 chained buffer after it, move on. */
1084 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1085 cdrom_end_request(drive, 1);
1086
1087 /* If the buffers are full, cache the rest of the data in our
1088 internal buffer. */
1089 if (rq->current_nr_sectors == 0) {
1090 cdrom_buffer_sectors(drive, rq->sector, sectors_to_transfer);
1091 sectors_to_transfer = 0;
1092 } else {
1093 /* Transfer data to the buffers.
1094 Figure out how many sectors we can transfer
1095 to the current buffer. */
1096 this_transfer = min_t(int, sectors_to_transfer,
1097 rq->current_nr_sectors);
1098
1099 /* Read this_transfer sectors
1100 into the current buffer. */
1101 while (this_transfer > 0) {
1102 HWIF(drive)->atapi_input_bytes(drive, rq->buffer, SECTOR_SIZE);
1103 rq->buffer += SECTOR_SIZE;
1104 --rq->nr_sectors;
1105 --rq->current_nr_sectors;
1106 ++rq->sector;
1107 --this_transfer;
1108 --sectors_to_transfer;
1109 }
1110 }
1111 }
1112
1113 /* Done moving data! Wait for another interrupt. */
1114 ide_set_handler(drive, &cdrom_read_intr, ATAPI_WAIT_PC, NULL);
1115 return ide_started;
1116 }
1117
1118 /*
1119 * Try to satisfy some of the current read request from our cached data.
1120 * Returns nonzero if the request has been completed, zero otherwise.
1121 */
1122 static int cdrom_read_from_buffer (ide_drive_t *drive)
1123 {
1124 struct cdrom_info *info = drive->driver_data;
1125 struct request *rq = HWGROUP(drive)->rq;
1126 unsigned short sectors_per_frame;
1127
1128 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1129
1130 /* Can't do anything if there's no buffer. */
1131 if (info->buffer == NULL) return 0;
1132
1133 /* Loop while this request needs data and the next block is present
1134 in our cache. */
1135 while (rq->nr_sectors > 0 &&
1136 rq->sector >= info->sector_buffered &&
1137 rq->sector < info->sector_buffered + info->nsectors_buffered) {
1138 if (rq->current_nr_sectors == 0)
1139 cdrom_end_request(drive, 1);
1140
1141 memcpy (rq->buffer,
1142 info->buffer +
1143 (rq->sector - info->sector_buffered) * SECTOR_SIZE,
1144 SECTOR_SIZE);
1145 rq->buffer += SECTOR_SIZE;
1146 --rq->current_nr_sectors;
1147 --rq->nr_sectors;
1148 ++rq->sector;
1149 }
1150
1151 /* If we've satisfied the current request,
1152 terminate it successfully. */
1153 if (rq->nr_sectors == 0) {
1154 cdrom_end_request(drive, 1);
1155 return -1;
1156 }
1157
1158 /* Move on to the next buffer if needed. */
1159 if (rq->current_nr_sectors == 0)
1160 cdrom_end_request(drive, 1);
1161
1162 /* If this condition does not hold, then the kluge i use to
1163 represent the number of sectors to skip at the start of a transfer
1164 will fail. I think that this will never happen, but let's be
1165 paranoid and check. */
1166 if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
1167 (rq->sector & (sectors_per_frame - 1))) {
1168 printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
1169 drive->name, (long)rq->sector);
1170 cdrom_end_request(drive, 0);
1171 return -1;
1172 }
1173
1174 return 0;
1175 }
1176
1177 /*
1178 * Routine to send a read packet command to the drive.
1179 * This is usually called directly from cdrom_start_read.
1180 * However, for drq_interrupt devices, it is called from an interrupt
1181 * when the drive is ready to accept the command.
1182 */
1183 static ide_startstop_t cdrom_start_read_continuation (ide_drive_t *drive)
1184 {
1185 struct request *rq = HWGROUP(drive)->rq;
1186 unsigned short sectors_per_frame;
1187 int nskip;
1188
1189 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1190
1191 /* If the requested sector doesn't start on a cdrom block boundary,
1192 we must adjust the start of the transfer so that it does,
1193 and remember to skip the first few sectors.
1194 If the CURRENT_NR_SECTORS field is larger than the size
1195 of the buffer, it will mean that we're to skip a number
1196 of sectors equal to the amount by which CURRENT_NR_SECTORS
1197 is larger than the buffer size. */
1198 nskip = rq->sector & (sectors_per_frame - 1);
1199 if (nskip > 0) {
1200 /* Sanity check... */
1201 if (rq->current_nr_sectors != bio_cur_sectors(rq->bio) &&
1202 (rq->sector & (sectors_per_frame - 1))) {
1203 printk(KERN_ERR "%s: cdrom_start_read_continuation: buffer botch (%u)\n",
1204 drive->name, rq->current_nr_sectors);
1205 cdrom_end_request(drive, 0);
1206 return ide_stopped;
1207 }
1208 rq->current_nr_sectors += nskip;
1209 }
1210
1211 /* Set up the command */
1212 rq->timeout = ATAPI_WAIT_PC;
1213
1214 /* Send the command to the drive and return. */
1215 return cdrom_transfer_packet_command(drive, rq, &cdrom_read_intr);
1216 }
1217
1218
1219 #define IDECD_SEEK_THRESHOLD (1000) /* 1000 blocks */
1220 #define IDECD_SEEK_TIMER (5 * WAIT_MIN_SLEEP) /* 100 ms */
1221 #define IDECD_SEEK_TIMEOUT (2 * WAIT_CMD) /* 20 sec */
1222
1223 static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
1224 {
1225 struct cdrom_info *info = drive->driver_data;
1226 int stat;
1227 static int retry = 10;
1228
1229 if (cdrom_decode_status(drive, 0, &stat))
1230 return ide_stopped;
1231 CDROM_CONFIG_FLAGS(drive)->seeking = 1;
1232
1233 if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
1234 if (--retry == 0) {
1235 /*
1236 * this condition is far too common, to bother
1237 * users about it
1238 */
1239 /* printk("%s: disabled DSC seek overlap\n", drive->name);*/
1240 drive->dsc_overlap = 0;
1241 }
1242 }
1243 return ide_stopped;
1244 }
1245
1246 static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
1247 {
1248 struct request *rq = HWGROUP(drive)->rq;
1249 sector_t frame = rq->sector;
1250
1251 sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
1252
1253 memset(rq->cmd, 0, sizeof(rq->cmd));
1254 rq->cmd[0] = GPCMD_SEEK;
1255 put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
1256
1257 rq->timeout = ATAPI_WAIT_PC;
1258 return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
1259 }
1260
1261 static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
1262 {
1263 struct cdrom_info *info = drive->driver_data;
1264
1265 info->dma = 0;
1266 info->cmd = 0;
1267 info->start_seek = jiffies;
1268 return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
1269 }
1270
1271 /* Fix up a possibly partially-processed request so that we can
1272 start it over entirely, or even put it back on the request queue. */
1273 static void restore_request (struct request *rq)
1274 {
1275 if (rq->buffer != bio_data(rq->bio)) {
1276 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
1277
1278 rq->buffer = bio_data(rq->bio);
1279 rq->nr_sectors += n;
1280 rq->sector -= n;
1281 }
1282 rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
1283 rq->hard_nr_sectors = rq->nr_sectors;
1284 rq->hard_sector = rq->sector;
1285 rq->q->prep_rq_fn(rq->q, rq);
1286 }
1287
1288 /*
1289 * Start a read request from the CD-ROM.
1290 */
1291 static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block)
1292 {
1293 struct cdrom_info *info = drive->driver_data;
1294 struct request *rq = HWGROUP(drive)->rq;
1295 unsigned short sectors_per_frame;
1296
1297 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1298
1299 /* We may be retrying this request after an error. Fix up
1300 any weirdness which might be present in the request packet. */
1301 restore_request(rq);
1302
1303 /* Satisfy whatever we can of this request from our cached sector. */
1304 if (cdrom_read_from_buffer(drive))
1305 return ide_stopped;
1306
1307 blk_attempt_remerge(drive->queue, rq);
1308
1309 /* Clear the local sector buffer. */
1310 info->nsectors_buffered = 0;
1311
1312 /* use dma, if possible. */
1313 info->dma = drive->using_dma;
1314 if ((rq->sector & (sectors_per_frame - 1)) ||
1315 (rq->nr_sectors & (sectors_per_frame - 1)))
1316 info->dma = 0;
1317
1318 info->cmd = READ;
1319
1320 /* Start sending the read request to the drive. */
1321 return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
1322 }
1323
1324 /****************************************************************************
1325 * Execute all other packet commands.
1326 */
1327
1328 /* Interrupt routine for packet command completion. */
1329 static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
1330 {
1331 int ireason, len, thislen;
1332 struct request *rq = HWGROUP(drive)->rq;
1333 u8 lowcyl = 0, highcyl = 0;
1334 int stat;
1335
1336 /* Check for errors. */
1337 if (cdrom_decode_status(drive, 0, &stat))
1338 return ide_stopped;
1339
1340 /* Read the interrupt reason and the transfer length. */
1341 ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1342 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1343 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1344
1345 len = lowcyl + (256 * highcyl);
1346
1347 /* If DRQ is clear, the command has completed.
1348 Complain if we still have data left to transfer. */
1349 if ((stat & DRQ_STAT) == 0) {
1350 /* Some of the trailing request sense fields are optional, and
1351 some drives don't send them. Sigh. */
1352 if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
1353 rq->data_len > 0 &&
1354 rq->data_len <= 5) {
1355 while (rq->data_len > 0) {
1356 *(unsigned char *)rq->data++ = 0;
1357 --rq->data_len;
1358 }
1359 }
1360
1361 if (rq->data_len == 0)
1362 cdrom_end_request(drive, 1);
1363 else {
1364 /* Comment this out, because this always happens
1365 right after a reset occurs, and it is annoying to
1366 always print expected stuff. */
1367 /*
1368 printk ("%s: cdrom_pc_intr: data underrun %d\n",
1369 drive->name, pc->buflen);
1370 */
1371 rq->flags |= REQ_FAILED;
1372 cdrom_end_request(drive, 0);
1373 }
1374 return ide_stopped;
1375 }
1376
1377 /* Figure out how much data to transfer. */
1378 thislen = rq->data_len;
1379 if (thislen > len) thislen = len;
1380
1381 /* The drive wants to be written to. */
1382 if ((ireason & 3) == 0) {
1383 if (!rq->data) {
1384 blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1385 goto confused;
1386 }
1387 /* Transfer the data. */
1388 HWIF(drive)->atapi_output_bytes(drive, rq->data, thislen);
1389
1390 /* If we haven't moved enough data to satisfy the drive,
1391 add some padding. */
1392 while (len > thislen) {
1393 int dum = 0;
1394 HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof(dum));
1395 len -= sizeof(dum);
1396 }
1397
1398 /* Keep count of how much data we've moved. */
1399 rq->data += thislen;
1400 rq->data_len -= thislen;
1401 }
1402
1403 /* Same drill for reading. */
1404 else if ((ireason & 3) == 2) {
1405 if (!rq->data) {
1406 blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1407 goto confused;
1408 }
1409 /* Transfer the data. */
1410 HWIF(drive)->atapi_input_bytes(drive, rq->data, thislen);
1411
1412 /* If we haven't moved enough data to satisfy the drive,
1413 add some padding. */
1414 while (len > thislen) {
1415 int dum = 0;
1416 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1417 len -= sizeof(dum);
1418 }
1419
1420 /* Keep count of how much data we've moved. */
1421 rq->data += thislen;
1422 rq->data_len -= thislen;
1423
1424 if (rq->flags & REQ_SENSE)
1425 rq->sense_len += thislen;
1426 } else {
1427 confused:
1428 printk (KERN_ERR "%s: cdrom_pc_intr: The drive "
1429 "appears confused (ireason = 0x%02x)\n",
1430 drive->name, ireason);
1431 rq->flags |= REQ_FAILED;
1432 }
1433
1434 /* Now we wait for another interrupt. */
1435 ide_set_handler(drive, &cdrom_pc_intr, ATAPI_WAIT_PC, cdrom_timer_expiry);
1436 return ide_started;
1437 }
1438
1439 static ide_startstop_t cdrom_do_pc_continuation (ide_drive_t *drive)
1440 {
1441 struct request *rq = HWGROUP(drive)->rq;
1442
1443 if (!rq->timeout)
1444 rq->timeout = ATAPI_WAIT_PC;
1445
1446 /* Send the command to the drive and return. */
1447 return cdrom_transfer_packet_command(drive, rq, &cdrom_pc_intr);
1448 }
1449
1450
1451 static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
1452 {
1453 int len;
1454 struct request *rq = HWGROUP(drive)->rq;
1455 struct cdrom_info *info = drive->driver_data;
1456
1457 info->dma = 0;
1458 info->cmd = 0;
1459 rq->flags &= ~REQ_FAILED;
1460 len = rq->data_len;
1461
1462 /* Start sending the command to the drive. */
1463 return cdrom_start_packet_command(drive, len, cdrom_do_pc_continuation);
1464 }
1465
1466
1467 static
1468 int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
1469 {
1470 struct request_sense sense;
1471 int retries = 10;
1472 unsigned int flags = rq->flags;
1473
1474 if (rq->sense == NULL)
1475 rq->sense = &sense;
1476
1477 /* Start of retry loop. */
1478 do {
1479 int error;
1480 unsigned long time = jiffies;
1481 rq->flags = flags;
1482
1483 error = ide_do_drive_cmd(drive, rq, ide_wait);
1484 time = jiffies - time;
1485
1486 /* FIXME: we should probably abort/retry or something
1487 * in case of failure */
1488 if (rq->flags & REQ_FAILED) {
1489 /* The request failed. Retry if it was due to a unit
1490 attention status
1491 (usually means media was changed). */
1492 struct request_sense *reqbuf = rq->sense;
1493
1494 if (reqbuf->sense_key == UNIT_ATTENTION)
1495 cdrom_saw_media_change(drive);
1496 else if (reqbuf->sense_key == NOT_READY &&
1497 reqbuf->asc == 4 && reqbuf->ascq != 4) {
1498 /* The drive is in the process of loading
1499 a disk. Retry, but wait a little to give
1500 the drive time to complete the load. */
1501 ssleep(2);
1502 } else {
1503 /* Otherwise, don't retry. */
1504 retries = 0;
1505 }
1506 --retries;
1507 }
1508
1509 /* End of retry loop. */
1510 } while ((rq->flags & REQ_FAILED) && retries >= 0);
1511
1512 /* Return an error if the command failed. */
1513 return (rq->flags & REQ_FAILED) ? -EIO : 0;
1514 }
1515
1516 /*
1517 * Write handling
1518 */
1519 static inline int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
1520 {
1521 /* Two notes about IDE interrupt reason here - 0 means that
1522 * the drive wants to receive data from us, 2 means that
1523 * the drive is expecting to transfer data to us.
1524 */
1525 if (ireason == 0)
1526 return 0;
1527 else if (ireason == 2) {
1528 /* Whoops... The drive wants to send data. */
1529 printk(KERN_ERR "%s: write_intr: wrong transfer direction!\n",
1530 drive->name);
1531
1532 while (len > 0) {
1533 int dum = 0;
1534 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1535 len -= sizeof(dum);
1536 }
1537 } else {
1538 /* Drive wants a command packet, or invalid ireason... */
1539 printk(KERN_ERR "%s: write_intr: bad interrupt reason %x\n",
1540 drive->name, ireason);
1541 }
1542
1543 cdrom_end_request(drive, 0);
1544 return 1;
1545 }
1546
1547 static void post_transform_command(struct request *req)
1548 {
1549 u8 *c = req->cmd;
1550 char *ibuf;
1551
1552 if (!blk_pc_request(req))
1553 return;
1554
1555 if (req->bio)
1556 ibuf = bio_data(req->bio);
1557 else
1558 ibuf = req->data;
1559
1560 if (!ibuf)
1561 return;
1562
1563 /*
1564 * set ansi-revision and response data as atapi
1565 */
1566 if (c[0] == GPCMD_INQUIRY) {
1567 ibuf[2] |= 2;
1568 ibuf[3] = (ibuf[3] & 0xf0) | 2;
1569 }
1570 }
1571
1572 typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
1573
1574 /*
1575 * best way to deal with dma that is not sector aligned right now... note
1576 * that in this path we are not using ->data or ->buffer at all. this irs
1577 * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the
1578 * future.
1579 */
1580 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1581 {
1582 struct cdrom_info *info = drive->driver_data;
1583 struct request *rq = HWGROUP(drive)->rq;
1584 int dma_error, dma, stat, ireason, len, thislen;
1585 u8 lowcyl, highcyl;
1586 xfer_func_t *xferfunc;
1587 unsigned long flags;
1588
1589 /* Check for errors. */
1590 dma_error = 0;
1591 dma = info->dma;
1592 if (dma) {
1593 info->dma = 0;
1594 dma_error = HWIF(drive)->ide_dma_end(drive);
1595 }
1596
1597 if (cdrom_decode_status(drive, 0, &stat))
1598 return ide_stopped;
1599
1600 /*
1601 * using dma, transfer is complete now
1602 */
1603 if (dma) {
1604 if (dma_error) {
1605 printk(KERN_ERR "ide-cd: dma error\n");
1606 __ide_dma_off(drive);
1607 return ide_error(drive, "dma error", stat);
1608 }
1609
1610 end_that_request_chunk(rq, 1, rq->data_len);
1611 rq->data_len = 0;
1612 goto end_request;
1613 }
1614
1615 /*
1616 * ok we fall to pio :/
1617 */
1618 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1619 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1620 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1621
1622 len = lowcyl + (256 * highcyl);
1623 thislen = rq->data_len;
1624 if (thislen > len)
1625 thislen = len;
1626
1627 /*
1628 * If DRQ is clear, the command has completed.
1629 */
1630 if ((stat & DRQ_STAT) == 0)
1631 goto end_request;
1632
1633 /*
1634 * check which way to transfer data
1635 */
1636 if (rq_data_dir(rq) == WRITE) {
1637 /*
1638 * write to drive
1639 */
1640 if (cdrom_write_check_ireason(drive, len, ireason))
1641 return ide_stopped;
1642
1643 xferfunc = HWIF(drive)->atapi_output_bytes;
1644 } else {
1645 /*
1646 * read from drive
1647 */
1648 if (cdrom_read_check_ireason(drive, len, ireason))
1649 return ide_stopped;
1650
1651 xferfunc = HWIF(drive)->atapi_input_bytes;
1652 }
1653
1654 /*
1655 * transfer data
1656 */
1657 while (thislen > 0) {
1658 int blen = blen = rq->data_len;
1659 char *ptr = rq->data;
1660
1661 /*
1662 * bio backed?
1663 */
1664 if (rq->bio) {
1665 ptr = bio_data(rq->bio);
1666 blen = bio_iovec(rq->bio)->bv_len;
1667 }
1668
1669 if (!ptr) {
1670 printk(KERN_ERR "%s: confused, missing data\n", drive->name);
1671 break;
1672 }
1673
1674 if (blen > thislen)
1675 blen = thislen;
1676
1677 xferfunc(drive, ptr, blen);
1678
1679 thislen -= blen;
1680 len -= blen;
1681 rq->data_len -= blen;
1682
1683 if (rq->bio)
1684 end_that_request_chunk(rq, 1, blen);
1685 else
1686 rq->data += blen;
1687 }
1688
1689 /*
1690 * pad, if necessary
1691 */
1692 if (len > 0) {
1693 while (len > 0) {
1694 int pad = 0;
1695
1696 xferfunc(drive, &pad, sizeof(pad));
1697 len -= sizeof(pad);
1698 }
1699 }
1700
1701 if (HWGROUP(drive)->handler != NULL)
1702 BUG();
1703
1704 ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, NULL);
1705 return ide_started;
1706
1707 end_request:
1708 if (!rq->data_len)
1709 post_transform_command(rq);
1710
1711 spin_lock_irqsave(&ide_lock, flags);
1712 blkdev_dequeue_request(rq);
1713 end_that_request_last(rq);
1714 HWGROUP(drive)->rq = NULL;
1715 spin_unlock_irqrestore(&ide_lock, flags);
1716 return ide_stopped;
1717 }
1718
1719 static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
1720 {
1721 int stat, ireason, len, sectors_to_transfer, uptodate;
1722 struct cdrom_info *info = drive->driver_data;
1723 int dma_error = 0, dma = info->dma;
1724 u8 lowcyl = 0, highcyl = 0;
1725
1726 struct request *rq = HWGROUP(drive)->rq;
1727
1728 /* Check for errors. */
1729 if (dma) {
1730 info->dma = 0;
1731 if ((dma_error = HWIF(drive)->ide_dma_end(drive))) {
1732 printk(KERN_ERR "ide-cd: write dma error\n");
1733 __ide_dma_off(drive);
1734 }
1735 }
1736
1737 if (cdrom_decode_status(drive, 0, &stat))
1738 return ide_stopped;
1739
1740 /*
1741 * using dma, transfer is complete now
1742 */
1743 if (dma) {
1744 if (dma_error)
1745 return ide_error(drive, "dma error", stat);
1746
1747 ide_end_request(drive, 1, rq->nr_sectors);
1748 return ide_stopped;
1749 }
1750
1751 /* Read the interrupt reason and the transfer length. */
1752 ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1753 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1754 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1755
1756 len = lowcyl + (256 * highcyl);
1757
1758 /* If DRQ is clear, the command has completed. */
1759 if ((stat & DRQ_STAT) == 0) {
1760 /* If we're not done writing, complain.
1761 * Otherwise, complete the command normally.
1762 */
1763 uptodate = 1;
1764 if (rq->current_nr_sectors > 0) {
1765 printk(KERN_ERR "%s: write_intr: data underrun (%d blocks)\n",
1766 drive->name, rq->current_nr_sectors);
1767 uptodate = 0;
1768 }
1769 cdrom_end_request(drive, uptodate);
1770 return ide_stopped;
1771 }
1772
1773 /* Check that the drive is expecting to do the same thing we are. */
1774 if (cdrom_write_check_ireason(drive, len, ireason))
1775 return ide_stopped;
1776
1777 sectors_to_transfer = len / SECTOR_SIZE;
1778
1779 /*
1780 * now loop and write out the data
1781 */
1782 while (sectors_to_transfer > 0) {
1783 int this_transfer;
1784
1785 if (!rq->current_nr_sectors) {
1786 printk(KERN_ERR "ide-cd: write_intr: oops\n");
1787 break;
1788 }
1789
1790 /*
1791 * Figure out how many sectors we can transfer
1792 */
1793 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors);
1794
1795 while (this_transfer > 0) {
1796 HWIF(drive)->atapi_output_bytes(drive, rq->buffer, SECTOR_SIZE);
1797 rq->buffer += SECTOR_SIZE;
1798 --rq->nr_sectors;
1799 --rq->current_nr_sectors;
1800 ++rq->sector;
1801 --this_transfer;
1802 --sectors_to_transfer;
1803 }
1804
1805 /*
1806 * current buffer complete, move on
1807 */
1808 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1809 cdrom_end_request(drive, 1);
1810 }
1811
1812 /* re-arm handler */
1813 ide_set_handler(drive, &cdrom_write_intr, ATAPI_WAIT_PC, NULL);
1814 return ide_started;
1815 }
1816
1817 static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
1818 {
1819 struct request *rq = HWGROUP(drive)->rq;
1820
1821 #if 0 /* the immediate bit */
1822 rq->cmd[1] = 1 << 3;
1823 #endif
1824 rq->timeout = ATAPI_WAIT_PC;
1825
1826 return cdrom_transfer_packet_command(drive, rq, cdrom_write_intr);
1827 }
1828
1829 static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
1830 {
1831 struct cdrom_info *info = drive->driver_data;
1832 struct gendisk *g = drive->disk;
1833 unsigned short sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1834
1835 /*
1836 * writes *must* be hardware frame aligned
1837 */
1838 if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1839 (rq->sector & (sectors_per_frame - 1))) {
1840 cdrom_end_request(drive, 0);
1841 return ide_stopped;
1842 }
1843
1844 /*
1845 * disk has become write protected
1846 */
1847 if (g->policy) {
1848 cdrom_end_request(drive, 0);
1849 return ide_stopped;
1850 }
1851
1852 /*
1853 * for dvd-ram and such media, it's a really big deal to get
1854 * big writes all the time. so scour the queue and attempt to
1855 * remerge requests, often the plugging will not have had time
1856 * to do this properly
1857 */
1858 blk_attempt_remerge(drive->queue, rq);
1859
1860 info->nsectors_buffered = 0;
1861
1862 /* use dma, if possible. we don't need to check more, since we
1863 * know that the transfer is always (at least!) frame aligned */
1864 info->dma = drive->using_dma ? 1 : 0;
1865 info->cmd = WRITE;
1866
1867 info->devinfo.media_written = 1;
1868
1869 /* Start sending the write request to the drive. */
1870 return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
1871 }
1872
1873 static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1874 {
1875 struct request *rq = HWGROUP(drive)->rq;
1876
1877 if (!rq->timeout)
1878 rq->timeout = ATAPI_WAIT_PC;
1879
1880 return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1881 }
1882
1883 static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1884 {
1885 struct cdrom_info *info = drive->driver_data;
1886
1887 rq->flags |= REQ_QUIET;
1888
1889 info->dma = 0;
1890 info->cmd = 0;
1891
1892 /*
1893 * sg request
1894 */
1895 if (rq->bio) {
1896 int mask = drive->queue->dma_alignment;
1897 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
1898
1899 info->cmd = rq_data_dir(rq);
1900 info->dma = drive->using_dma;
1901
1902 /*
1903 * check if dma is safe
1904 */
1905 if ((rq->data_len & mask) || (addr & mask))
1906 info->dma = 0;
1907 }
1908
1909 /* Start sending the command to the drive. */
1910 return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1911 }
1912
1913 /****************************************************************************
1914 * cdrom driver request routine.
1915 */
1916 static ide_startstop_t
1917 ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1918 {
1919 ide_startstop_t action;
1920 struct cdrom_info *info = drive->driver_data;
1921
1922 if (blk_fs_request(rq)) {
1923 if (CDROM_CONFIG_FLAGS(drive)->seeking) {
1924 unsigned long elapsed = jiffies - info->start_seek;
1925 int stat = HWIF(drive)->INB(IDE_STATUS_REG);
1926
1927 if ((stat & SEEK_STAT) != SEEK_STAT) {
1928 if (elapsed < IDECD_SEEK_TIMEOUT) {
1929 ide_stall_queue(drive, IDECD_SEEK_TIMER);
1930 return ide_stopped;
1931 }
1932 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
1933 }
1934 CDROM_CONFIG_FLAGS(drive)->seeking = 0;
1935 }
1936 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
1937 action = cdrom_start_seek(drive, block);
1938 } else {
1939 if (rq_data_dir(rq) == READ)
1940 action = cdrom_start_read(drive, block);
1941 else
1942 action = cdrom_start_write(drive, rq);
1943 }
1944 info->last_block = block;
1945 return action;
1946 } else if (rq->flags & (REQ_PC | REQ_SENSE)) {
1947 return cdrom_do_packet_command(drive);
1948 } else if (rq->flags & REQ_BLOCK_PC) {
1949 return cdrom_do_block_pc(drive, rq);
1950 } else if (rq->flags & REQ_SPECIAL) {
1951 /*
1952 * right now this can only be a reset...
1953 */
1954 cdrom_end_request(drive, 1);
1955 return ide_stopped;
1956 }
1957
1958 blk_dump_rq_flags(rq, "ide-cd bad flags");
1959 cdrom_end_request(drive, 0);
1960 return ide_stopped;
1961 }
1962
1963
1964
1965 /****************************************************************************
1966 * Ioctl handling.
1967 *
1968 * Routines which queue packet commands take as a final argument a pointer
1969 * to a request_sense struct. If execution of the command results
1970 * in an error with a CHECK CONDITION status, this structure will be filled
1971 * with the results of the subsequent request sense command. The pointer
1972 * can also be NULL, in which case no sense information is returned.
1973 */
1974
1975 #if ! STANDARD_ATAPI
1976 static inline
1977 int bin2bcd (int x)
1978 {
1979 return (x%10) | ((x/10) << 4);
1980 }
1981
1982
1983 static inline
1984 int bcd2bin (int x)
1985 {
1986 return (x >> 4) * 10 + (x & 0x0f);
1987 }
1988
1989 static
1990 void msf_from_bcd (struct atapi_msf *msf)
1991 {
1992 msf->minute = bcd2bin (msf->minute);
1993 msf->second = bcd2bin (msf->second);
1994 msf->frame = bcd2bin (msf->frame);
1995 }
1996
1997 #endif /* not STANDARD_ATAPI */
1998
1999
2000 static inline
2001 void lba_to_msf (int lba, byte *m, byte *s, byte *f)
2002 {
2003 lba += CD_MSF_OFFSET;
2004 lba &= 0xffffff; /* negative lbas use only 24 bits */
2005 *m = lba / (CD_SECS * CD_FRAMES);
2006 lba %= (CD_SECS * CD_FRAMES);
2007 *s = lba / CD_FRAMES;
2008 *f = lba % CD_FRAMES;
2009 }
2010
2011
2012 static inline
2013 int msf_to_lba (byte m, byte s, byte f)
2014 {
2015 return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
2016 }
2017
2018 static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
2019 {
2020 struct request req;
2021 struct cdrom_info *info = drive->driver_data;
2022 struct cdrom_device_info *cdi = &info->devinfo;
2023
2024 cdrom_prepare_request(&req);
2025
2026 req.sense = sense;
2027 req.cmd[0] = GPCMD_TEST_UNIT_READY;
2028 req.flags |= REQ_QUIET;
2029
2030 #if ! STANDARD_ATAPI
2031 /* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
2032 switch CDs instead of supporting the LOAD_UNLOAD opcode */
2033
2034 req.cmd[7] = cdi->sanyo_slot % 3;
2035 #endif /* not STANDARD_ATAPI */
2036
2037 return cdrom_queue_packet_command(drive, &req);
2038 }
2039
2040
2041 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
2042 static int
2043 cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
2044 {
2045 struct request_sense my_sense;
2046 struct request req;
2047 int stat;
2048
2049 if (sense == NULL)
2050 sense = &my_sense;
2051
2052 /* If the drive cannot lock the door, just pretend. */
2053 if (CDROM_CONFIG_FLAGS(drive)->no_doorlock) {
2054 stat = 0;
2055 } else {
2056 cdrom_prepare_request(&req);
2057 req.sense = sense;
2058 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
2059 req.cmd[4] = lockflag ? 1 : 0;
2060 stat = cdrom_queue_packet_command(drive, &req);
2061 }
2062
2063 /* If we got an illegal field error, the drive
2064 probably cannot lock the door. */
2065 if (stat != 0 &&
2066 sense->sense_key == ILLEGAL_REQUEST &&
2067 (sense->asc == 0x24 || sense->asc == 0x20)) {
2068 printk (KERN_ERR "%s: door locking not supported\n",
2069 drive->name);
2070 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2071 stat = 0;
2072 }
2073
2074 /* no medium, that's alright. */
2075 if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
2076 stat = 0;
2077
2078 if (stat == 0)
2079 CDROM_STATE_FLAGS(drive)->door_locked = lockflag;
2080
2081 return stat;
2082 }
2083
2084
2085 /* Eject the disk if EJECTFLAG is 0.
2086 If EJECTFLAG is 1, try to reload the disk. */
2087 static int cdrom_eject(ide_drive_t *drive, int ejectflag,
2088 struct request_sense *sense)
2089 {
2090 struct request req;
2091 char loej = 0x02;
2092
2093 if (CDROM_CONFIG_FLAGS(drive)->no_eject && !ejectflag)
2094 return -EDRIVE_CANT_DO_THIS;
2095
2096 /* reload fails on some drives, if the tray is locked */
2097 if (CDROM_STATE_FLAGS(drive)->door_locked && ejectflag)
2098 return 0;
2099
2100 cdrom_prepare_request(&req);
2101
2102 /* only tell drive to close tray if open, if it can do that */
2103 if (ejectflag && !CDROM_CONFIG_FLAGS(drive)->close_tray)
2104 loej = 0;
2105
2106 req.sense = sense;
2107 req.cmd[0] = GPCMD_START_STOP_UNIT;
2108 req.cmd[4] = loej | (ejectflag != 0);
2109 return cdrom_queue_packet_command(drive, &req);
2110 }
2111
2112 static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
2113 unsigned long *sectors_per_frame,
2114 struct request_sense *sense)
2115 {
2116 struct {
2117 __u32 lba;
2118 __u32 blocklen;
2119 } capbuf;
2120
2121 int stat;
2122 struct request req;
2123
2124 cdrom_prepare_request(&req);
2125
2126 req.sense = sense;
2127 req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
2128 req.data = (char *)&capbuf;
2129 req.data_len = sizeof(capbuf);
2130
2131 stat = cdrom_queue_packet_command(drive, &req);
2132 if (stat == 0) {
2133 *capacity = 1 + be32_to_cpu(capbuf.lba);
2134 *sectors_per_frame =
2135 be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
2136 }
2137
2138 return stat;
2139 }
2140
2141 static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
2142 int format, char *buf, int buflen,
2143 struct request_sense *sense)
2144 {
2145 struct request req;
2146
2147 cdrom_prepare_request(&req);
2148
2149 req.sense = sense;
2150 req.data = buf;
2151 req.data_len = buflen;
2152 req.flags |= REQ_QUIET;
2153 req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
2154 req.cmd[6] = trackno;
2155 req.cmd[7] = (buflen >> 8);
2156 req.cmd[8] = (buflen & 0xff);
2157 req.cmd[9] = (format << 6);
2158
2159 if (msf_flag)
2160 req.cmd[1] = 2;
2161
2162 return cdrom_queue_packet_command(drive, &req);
2163 }
2164
2165
2166 /* Try to read the entire TOC for the disk into our internal buffer. */
2167 static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2168 {
2169 int stat, ntracks, i;
2170 struct cdrom_info *info = drive->driver_data;
2171 struct cdrom_device_info *cdi = &info->devinfo;
2172 struct atapi_toc *toc = info->toc;
2173 struct {
2174 struct atapi_toc_header hdr;
2175 struct atapi_toc_entry ent;
2176 } ms_tmp;
2177 long last_written;
2178 unsigned long sectors_per_frame = SECTORS_PER_FRAME;
2179
2180 if (toc == NULL) {
2181 /* Try to allocate space. */
2182 toc = (struct atapi_toc *) kmalloc (sizeof (struct atapi_toc),
2183 GFP_KERNEL);
2184 info->toc = toc;
2185 if (toc == NULL) {
2186 printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
2187 return -ENOMEM;
2188 }
2189 }
2190
2191 /* Check to see if the existing data is still valid.
2192 If it is, just return. */
2193 (void) cdrom_check_status(drive, sense);
2194
2195 if (CDROM_STATE_FLAGS(drive)->toc_valid)
2196 return 0;
2197
2198 /* Try to get the total cdrom capacity and sector size. */
2199 stat = cdrom_read_capacity(drive, &toc->capacity, §ors_per_frame,
2200 sense);
2201 if (stat)
2202 toc->capacity = 0x1fffff;
2203
2204 set_capacity(drive->disk, toc->capacity * sectors_per_frame);
2205 blk_queue_hardsect_size(drive->queue,
2206 sectors_per_frame << SECTOR_BITS);
2207
2208 /* First read just the header, so we know how long the TOC is. */
2209 stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
2210 sizeof(struct atapi_toc_header), sense);
2211 if (stat) return stat;
2212
2213 #if ! STANDARD_ATAPI
2214 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2215 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2216 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2217 }
2218 #endif /* not STANDARD_ATAPI */
2219
2220 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2221 if (ntracks <= 0)
2222 return -EIO;
2223 if (ntracks > MAX_TRACKS)
2224 ntracks = MAX_TRACKS;
2225
2226 /* Now read the whole schmeer. */
2227 stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
2228 (char *)&toc->hdr,
2229 sizeof(struct atapi_toc_header) +
2230 (ntracks + 1) *
2231 sizeof(struct atapi_toc_entry), sense);
2232
2233 if (stat && toc->hdr.first_track > 1) {
2234 /* Cds with CDI tracks only don't have any TOC entries,
2235 despite of this the returned values are
2236 first_track == last_track = number of CDI tracks + 1,
2237 so that this case is indistinguishable from the same
2238 layout plus an additional audio track.
2239 If we get an error for the regular case, we assume
2240 a CDI without additional audio tracks. In this case
2241 the readable TOC is empty (CDI tracks are not included)
2242 and only holds the Leadout entry. Heiko Eißfeldt */
2243 ntracks = 0;
2244 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
2245 (char *)&toc->hdr,
2246 sizeof(struct atapi_toc_header) +
2247 (ntracks + 1) *
2248 sizeof(struct atapi_toc_entry),
2249 sense);
2250 if (stat) {
2251 return stat;
2252 }
2253 #if ! STANDARD_ATAPI
2254 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2255 toc->hdr.first_track = bin2bcd(CDROM_LEADOUT);
2256 toc->hdr.last_track = bin2bcd(CDROM_LEADOUT);
2257 } else
2258 #endif /* not STANDARD_ATAPI */
2259 {
2260 toc->hdr.first_track = CDROM_LEADOUT;
2261 toc->hdr.last_track = CDROM_LEADOUT;
2262 }
2263 }
2264
2265 if (stat)
2266 return stat;
2267
2268 toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
2269
2270 #if ! STANDARD_ATAPI
2271 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2272 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2273 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2274 }
2275 #endif /* not STANDARD_ATAPI */
2276
2277 for (i=0; i<=ntracks; i++) {
2278 #if ! STANDARD_ATAPI
2279 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2280 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd)
2281 toc->ent[i].track = bcd2bin(toc->ent[i].track);
2282 msf_from_bcd(&toc->ent[i].addr.msf);
2283 }
2284 #endif /* not STANDARD_ATAPI */
2285 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
2286 toc->ent[i].addr.msf.second,
2287 toc->ent[i].addr.msf.frame);
2288 }
2289
2290 /* Read the multisession information. */
2291 if (toc->hdr.first_track != CDROM_LEADOUT) {
2292 /* Read the multisession information. */
2293 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
2294 sizeof(ms_tmp), sense);
2295 if (stat) return stat;
2296
2297 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
2298 } else {
2299 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
2300 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
2301 }
2302
2303 #if ! STANDARD_ATAPI
2304 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2305 /* Re-read multisession information using MSF format */
2306 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
2307 sizeof(ms_tmp), sense);
2308 if (stat)
2309 return stat;
2310
2311 msf_from_bcd (&ms_tmp.ent.addr.msf);
2312 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
2313 ms_tmp.ent.addr.msf.second,
2314 ms_tmp.ent.addr.msf.frame);
2315 }
2316 #endif /* not STANDARD_ATAPI */
2317
2318 toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
2319
2320 /* Now try to get the total cdrom capacity. */
2321 stat = cdrom_get_last_written(cdi, &last_written);
2322 if (!stat && (last_written > toc->capacity)) {
2323 toc->capacity = last_written;
2324 set_capacity(drive->disk, toc->capacity * sectors_per_frame);
2325 }
2326
2327 /* Remember that we've read this stuff. */
2328 CDROM_STATE_FLAGS(drive)->toc_valid = 1;
2329
2330 return 0;
2331 }
2332
2333
2334 static int cdrom_read_subchannel(ide_drive_t *drive, int format, char *buf,
2335 int buflen, struct request_sense *sense)
2336 {
2337 struct request req;
2338
2339 cdrom_prepare_request(&req);
2340
2341 req.sense = sense;
2342 req.data = buf;
2343 req.data_len = buflen;
2344 req.cmd[0] = GPCMD_READ_SUBCHANNEL;
2345 req.cmd[1] = 2; /* MSF addressing */
2346 req.cmd[2] = 0x40; /* request subQ data */
2347 req.cmd[3] = format;
2348 req.cmd[7] = (buflen >> 8);
2349 req.cmd[8] = (buflen & 0xff);
2350 return cdrom_queue_packet_command(drive, &req);
2351 }
2352
2353 /* ATAPI cdrom drives are free to select the speed you request or any slower
2354 rate :-( Requesting too fast a speed will _not_ produce an error. */
2355 static int cdrom_select_speed(ide_drive_t *drive, int speed,
2356 struct request_sense *sense)
2357 {
2358 struct request req;
2359 cdrom_prepare_request(&req);
2360
2361 req.sense = sense;
2362 if (speed == 0)
2363 speed = 0xffff; /* set to max */
2364 else
2365 speed *= 177; /* Nx to kbytes/s */
2366
2367 req.cmd[0] = GPCMD_SET_SPEED;
2368 /* Read Drive speed in kbytes/second MSB */
2369 req.cmd[2] = (speed >> 8) & 0xff;
2370 /* Read Drive speed in kbytes/second LSB */
2371 req.cmd[3] = speed & 0xff;
2372 if (CDROM_CONFIG_FLAGS(drive)->cd_r ||
2373 CDROM_CONFIG_FLAGS(drive)->cd_rw ||
2374 CDROM_CONFIG_FLAGS(drive)->dvd_r) {
2375 /* Write Drive speed in kbytes/second MSB */
2376 req.cmd[4] = (speed >> 8) & 0xff;
2377 /* Write Drive speed in kbytes/second LSB */
2378 req.cmd[5] = speed & 0xff;
2379 }
2380
2381 return cdrom_queue_packet_command(drive, &req);
2382 }
2383
2384 static int cdrom_play_audio(ide_drive_t *drive, int lba_start, int lba_end)
2385 {
2386 struct request_sense sense;
2387 struct request req;
2388
2389 cdrom_prepare_request(&req);
2390
2391 req.sense = &sense;
2392 req.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2393 lba_to_msf(lba_start, &req.cmd[3], &req.cmd[4], &req.cmd[5]);
2394 lba_to_msf(lba_end-1, &req.cmd[6], &req.cmd[7], &req.cmd[8]);
2395
2396 return cdrom_queue_packet_command(drive, &req);
2397 }
2398
2399 static int cdrom_get_toc_entry(ide_drive_t *drive, int track,
2400 struct atapi_toc_entry **ent)
2401 {
2402 struct cdrom_info *info = drive->driver_data;
2403 struct atapi_toc *toc = info->toc;
2404 int ntracks;
2405
2406 /*
2407 * don't serve cached data, if the toc isn't valid
2408 */
2409 if (!CDROM_STATE_FLAGS(drive)->toc_valid)
2410 return -EINVAL;
2411
2412 /* Check validity of requested track number. */
2413 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2414 if (toc->hdr.first_track == CDROM_LEADOUT) ntracks = 0;
2415 if (track == CDROM_LEADOUT)
2416 *ent = &toc->ent[ntracks];
2417 else if (track < toc->hdr.first_track ||
2418 track > toc->hdr.last_track)
2419 return -EINVAL;
2420 else
2421 *ent = &toc->ent[track - toc->hdr.first_track];
2422
2423 return 0;
2424 }
2425
2426 /* the generic packet interface to cdrom.c */
2427 static int ide_cdrom_packet(struct cdrom_device_info *cdi,
2428 struct packet_command *cgc)
2429 {
2430 struct request req;
2431 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2432
2433 if (cgc->timeout <= 0)
2434 cgc->timeout = ATAPI_WAIT_PC;
2435
2436 /* here we queue the commands from the uniform CD-ROM
2437 layer. the packet must be complete, as we do not
2438 touch it at all. */
2439 cdrom_prepare_request(&req);
2440 memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
2441 if (cgc->sense)
2442 memset(cgc->sense, 0, sizeof(struct request_sense));
2443 req.data = cgc->buffer;
2444 req.data_len = cgc->buflen;
2445 req.timeout = cgc->timeout;
2446
2447 if (cgc->quiet)
2448 req.flags |= REQ_QUIET;
2449
2450 req.sense = cgc->sense;
2451 cgc->stat = cdrom_queue_packet_command(drive, &req);
2452 if (!cgc->stat)
2453 cgc->buflen -= req.data_len;
2454 return cgc->stat;
2455 }
2456
2457 static
2458 int ide_cdrom_dev_ioctl (struct cdrom_device_info *cdi,
2459 unsigned int cmd, unsigned long arg)
2460 {
2461 struct packet_command cgc;
2462 char buffer[16];
2463 int stat;
2464
2465 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2466
2467 /* These will be moved into the Uniform layer shortly... */
2468 switch (cmd) {
2469 case CDROMSETSPINDOWN: {
2470 char spindown;
2471
2472 if (copy_from_user(&spindown, (void __user *) arg, sizeof(char)))
2473 return -EFAULT;
2474
2475 if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0)))
2476 return stat;
2477
2478 buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
2479
2480 return cdrom_mode_select(cdi, &cgc);
2481 }
2482
2483 case CDROMGETSPINDOWN: {
2484 char spindown;
2485
2486 if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0)))
2487 return stat;
2488
2489 spindown = buffer[11] & 0x0f;
2490
2491 if (copy_to_user((void __user *) arg, &spindown, sizeof (char)))
2492 return -EFAULT;
2493
2494 return 0;
2495 }
2496
2497 default:
2498 return -EINVAL;
2499 }
2500
2501 }
2502
2503 static
2504 int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
2505 unsigned int cmd, void *arg)
2506
2507 {
2508 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2509 struct cdrom_info *info = drive->driver_data;
2510 int stat;
2511
2512 switch (cmd) {
2513 /*
2514 * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
2515 * atapi doesn't support it
2516 */
2517 case CDROMPLAYTRKIND: {
2518 unsigned long lba_start, lba_end;
2519 struct cdrom_ti *ti = (struct cdrom_ti *)arg;
2520 struct atapi_toc_entry *first_toc, *last_toc;
2521
2522 stat = cdrom_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
2523 if (stat)
2524 return stat;
2525
2526 stat = cdrom_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
2527 if (stat)
2528 return stat;
2529
2530 if (ti->cdti_trk1 != CDROM_LEADOUT)
2531 ++last_toc;
2532 lba_start = first_toc->addr.lba;
2533 lba_end = last_toc->addr.lba;
2534
2535 if (lba_end <= lba_start)
2536 return -EINVAL;
2537
2538 return cdrom_play_audio(drive, lba_start, lba_end);
2539 }
2540
2541 case CDROMREADTOCHDR: {
2542 struct cdrom_tochdr *tochdr = (struct cdrom_tochdr *) arg;
2543 struct atapi_toc *toc;
2544
2545 /* Make sure our saved TOC is valid. */
2546 stat = cdrom_read_toc(drive, NULL);
2547 if (stat) return stat;
2548
2549 toc = info->toc;
2550 tochdr->cdth_trk0 = toc->hdr.first_track;
2551 tochdr->cdth_trk1 = toc->hdr.last_track;
2552
2553 return 0;
2554 }
2555
2556 case CDROMREADTOCENTRY: {
2557 struct cdrom_tocentry *tocentry = (struct cdrom_tocentry*) arg;
2558 struct atapi_toc_entry *toce;
2559
2560 stat = cdrom_get_toc_entry(drive, tocentry->cdte_track, &toce);
2561 if (stat) return stat;
2562
2563 tocentry->cdte_ctrl = toce->control;
2564 tocentry->cdte_adr = toce->adr;
2565 if (tocentry->cdte_format == CDROM_MSF) {
2566 lba_to_msf (toce->addr.lba,
2567 &tocentry->cdte_addr.msf.minute,
2568 &tocentry->cdte_addr.msf.second,
2569 &tocentry->cdte_addr.msf.frame);
2570 } else
2571 tocentry->cdte_addr.lba = toce->addr.lba;
2572
2573 return 0;
2574 }
2575
2576 default:
2577 return -EINVAL;
2578 }
2579 }
2580
2581 static
2582 int ide_cdrom_reset (struct cdrom_device_info *cdi)
2583 {
2584 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2585 struct request_sense sense;
2586 struct request req;
2587 int ret;
2588
2589 cdrom_prepare_request(&req);
2590 req.flags = REQ_SPECIAL | REQ_QUIET;
2591 ret = ide_do_drive_cmd(drive, &req, ide_wait);
2592
2593 /*
2594 * A reset will unlock the door. If it was previously locked,
2595 * lock it again.
2596 */
2597 if (CDROM_STATE_FLAGS(drive)->door_locked)
2598 (void) cdrom_lockdoor(drive, 1, &sense);
2599
2600 return ret;
2601 }
2602
2603
2604 static
2605 int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
2606 {
2607 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2608 struct request_sense sense;
2609
2610 if (position) {
2611 int stat = cdrom_lockdoor(drive, 0, &sense);
2612 if (stat) return stat;
2613 }
2614
2615 return cdrom_eject(drive, !position, &sense);
2616 }
2617
2618 static
2619 int ide_cdrom_lock_door (struct cdrom_device_info *cdi, int lock)
2620 {
2621 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2622 return cdrom_lockdoor(drive, lock, NULL);
2623 }
2624
2625 static
2626 int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
2627 {
2628 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2629 struct request_sense sense;
2630 int stat;
2631
2632 if ((stat = cdrom_select_speed(drive, speed, &sense)) < 0)
2633 return stat;
2634
2635 cdi->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2636 return 0;
2637 }
2638
2639 /*
2640 * add logic to try GET_EVENT command first to check for media and tray
2641 * status. this should be supported by newer cd-r/w and all DVD etc
2642 * drives
2643 */
2644 static
2645 int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
2646 {
2647 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2648 struct media_event_desc med;
2649 struct request_sense sense;
2650 int stat;
2651
2652 if (slot_nr != CDSL_CURRENT)
2653 return -EINVAL;
2654
2655 stat = cdrom_check_status(drive, &sense);
2656 if (!stat || sense.sense_key == UNIT_ATTENTION)
2657 return CDS_DISC_OK;
2658
2659 if (!cdrom_get_media_event(cdi, &med)) {
2660 if (med.media_present)
2661 return CDS_DISC_OK;
2662 else if (med.door_open)
2663 return CDS_TRAY_OPEN;
2664 else
2665 return CDS_NO_DISC;
2666 }
2667
2668 if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
2669 return CDS_DISC_OK;
2670
2671 /*
2672 * If not using Mt Fuji extended media tray reports,
2673 * just return TRAY_OPEN since ATAPI doesn't provide
2674 * any other way to detect this...
2675 */
2676 if (sense.sense_key == NOT_READY) {
2677 if (sense.asc == 0x3a) {
2678 if (sense.ascq == 1)
2679 return CDS_NO_DISC;
2680 else if (sense.ascq == 0 || sense.ascq == 2)
2681 return CDS_TRAY_OPEN;
2682 }
2683 }
2684
2685 return CDS_DRIVE_NOT_READY;
2686 }
2687
2688 static
2689 int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
2690 struct cdrom_multisession *ms_info)
2691 {
2692 struct atapi_toc *toc;
2693 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2694 struct cdrom_info *info = drive->driver_data;
2695 struct request_sense sense;
2696 int ret;
2697
2698 if (!CDROM_STATE_FLAGS(drive)->toc_valid || info->toc == NULL)
2699 if ((ret = cdrom_read_toc(drive, &sense)))
2700 return ret;
2701
2702 toc = info->toc;
2703 ms_info->addr.lba = toc->last_session_lba;
2704 ms_info->xa_flag = toc->xa_flag;
2705
2706 return 0;
2707 }
2708
2709 static
2710 int ide_cdrom_get_mcn (struct cdrom_device_info *cdi,
2711 struct cdrom_mcn *mcn_info)
2712 {
2713 int stat;
2714 char mcnbuf[24];
2715 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2716
2717 /* get MCN */
2718 if ((stat = cdrom_read_subchannel(drive, 2, mcnbuf, sizeof (mcnbuf), NULL)))
2719 return stat;
2720
2721 memcpy (mcn_info->medium_catalog_number, mcnbuf+9,
2722 sizeof (mcn_info->medium_catalog_number)-1);
2723 mcn_info->medium_catalog_number[sizeof (mcn_info->medium_catalog_number)-1]
2724 = '\0';
2725
2726 return 0;
2727 }
2728
2729
2730
2731 /****************************************************************************
2732 * Other driver requests (open, close, check media change).
2733 */
2734
2735 static
2736 int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
2737 int slot_nr)
2738 {
2739 ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2740 int retval;
2741
2742 if (slot_nr == CDSL_CURRENT) {
2743 (void) cdrom_check_status(drive, NULL);
2744 retval = CDROM_STATE_FLAGS(drive)->media_changed;
2745 CDROM_STATE_FLAGS(drive)->media_changed = 0;
2746 return retval;
2747 } else {
2748 return -EINVAL;
2749 }
2750 }
2751
2752
2753 static
2754 int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
2755 {
2756 return 0;
2757 }
2758
2759 /*
2760 * Close down the device. Invalidate all cached blocks.
2761 */
2762
2763 static
2764 void ide_cdrom_release_real (struct cdrom_device_info *cdi)
2765 {
2766 ide_drive_t *drive = cdi->handle;
2767
2768 if (!cdi->use_count)
2769 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
2770 }
2771
2772
2773
2774 /****************************************************************************
2775 * Device initialization.
2776 */
2777 static struct cdrom_device_ops ide_cdrom_dops = {
2778 .open = ide_cdrom_open_real,
2779 .release = ide_cdrom_release_real,
2780 .drive_status = ide_cdrom_drive_status,
2781 .media_changed = ide_cdrom_check_media_change_real,
2782 .tray_move = ide_cdrom_tray_move,
2783 .lock_door = ide_cdrom_lock_door,
2784 .select_speed = ide_cdrom_select_speed,
2785 .get_last_session = ide_cdrom_get_last_session,
2786 .get_mcn = ide_cdrom_get_mcn,
2787 .reset = ide_cdrom_reset,
2788 .audio_ioctl = ide_cdrom_audio_ioctl,
2789 .dev_ioctl = ide_cdrom_dev_ioctl,
2790 .capability = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
2791 CDC_SELECT_SPEED | CDC_SELECT_DISC |
2792 CDC_MULTI_SESSION | CDC_MCN |
2793 CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO | CDC_RESET |
2794 CDC_IOCTLS | CDC_DRIVE_STATUS | CDC_CD_R |
2795 CDC_CD_RW | CDC_DVD | CDC_DVD_R| CDC_DVD_RAM |
2796 CDC_GENERIC_PACKET | CDC_MO_DRIVE | CDC_MRW |
2797 CDC_MRW_W | CDC_RAM,
2798 .generic_packet = ide_cdrom_packet,
2799 };
2800
2801 static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2802 {
2803 struct cdrom_info *info = drive->driver_data;
2804 struct cdrom_device_info *devinfo = &info->devinfo;
2805
2806 devinfo->ops = &ide_cdrom_dops;
2807 devinfo->mask = 0;
2808 devinfo->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2809 devinfo->capacity = nslots;
2810 devinfo->handle = (void *) drive;
2811 strcpy(devinfo->name, drive->name);
2812
2813 /* set capability mask to match the probe. */
2814 if (!CDROM_CONFIG_FLAGS(drive)->cd_r)
2815 devinfo->mask |= CDC_CD_R;
2816 if (!CDROM_CONFIG_FLAGS(drive)->cd_rw)
2817 devinfo->mask |= CDC_CD_RW;
2818 if (!CDROM_CONFIG_FLAGS(drive)->dvd)
2819 devinfo->mask |= CDC_DVD;
2820 if (!CDROM_CONFIG_FLAGS(drive)->dvd_r)
2821 devinfo->mask |= CDC_DVD_R;
2822 if (!CDROM_CONFIG_FLAGS(drive)->dvd_ram)
2823 devinfo->mask |= CDC_DVD_RAM;
2824 if (!CDROM_CONFIG_FLAGS(drive)->is_changer)
2825 devinfo->mask |= CDC_SELECT_DISC;
2826 if (!CDROM_CONFIG_FLAGS(drive)->audio_play)
2827 devinfo->mask |= CDC_PLAY_AUDIO;
2828 if (!CDROM_CONFIG_FLAGS(drive)->close_tray)
2829 devinfo->mask |= CDC_CLOSE_TRAY;
2830 if (!CDROM_CONFIG_FLAGS(drive)->mo_drive)
2831 devinfo->mask |= CDC_MO_DRIVE;
2832
2833 devinfo->disk = drive->disk;
2834 return register_cdrom(devinfo);
2835 }
2836
2837 static
2838 int ide_cdrom_get_capabilities(ide_drive_t *drive, struct atapi_capabilities_page *cap)
2839 {
2840 struct cdrom_info *info = drive->driver_data;
2841 struct cdrom_device_info *cdi = &info->devinfo;
2842 struct packet_command cgc;
2843 int stat, attempts = 3, size = sizeof(*cap);
2844
2845 /*
2846 * ACER50 (and others?) require the full spec length mode sense
2847 * page capabilities size, but older drives break.
2848 */
2849 if (!(!strcmp(drive->id->model, "ATAPI CD ROM DRIVE 50X MAX") ||
2850 !strcmp(drive->id->model, "WPI CDS-32X")))
2851 size -= sizeof(cap->pad);
2852
2853 init_cdrom_command(&cgc, cap, size, CGC_DATA_UNKNOWN);
2854 do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2855 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
2856 if (!stat)
2857 break;
2858 } while (--attempts);
2859 return stat;
2860 }
2861
2862 static
2863 int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2864 {
2865 struct cdrom_info *info = drive->driver_data;
2866 struct cdrom_device_info *cdi = &info->devinfo;
2867 struct atapi_capabilities_page cap;
2868 int nslots = 1;
2869
2870 if (drive->media == ide_optical) {
2871 CDROM_CONFIG_FLAGS(drive)->mo_drive = 1;
2872 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2873 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
2874 return nslots;
2875 }
2876
2877 if (CDROM_CONFIG_FLAGS(drive)->nec260 ||
2878 !strcmp(drive->id->model,"STINGRAY 8422 IDE 8X CD-ROM 7-27-95")) {
2879 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2880 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2881 return nslots;
2882 }
2883
2884 /*
2885 * we have to cheat a little here. the packet will eventually
2886 * be queued with ide_cdrom_packet(), which extracts the
2887 * drive from cdi->handle. Since this device hasn't been
2888 * registered with the Uniform layer yet, it can't do this.
2889 * Same goes for cdi->ops.
2890 */
2891 cdi->handle = (ide_drive_t *) drive;
2892 cdi->ops = &ide_cdrom_dops;
2893
2894 if (ide_cdrom_get_capabilities(drive, &cap))
2895 return 0;
2896
2897 if (cap.lock == 0)
2898 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2899 if (cap.eject)
2900 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2901 if (cap.cd_r_write)
2902 CDROM_CONFIG_FLAGS(drive)->cd_r = 1;
2903 if (cap.cd_rw_write) {
2904 CDROM_CONFIG_FLAGS(drive)->cd_rw = 1;
2905 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2906 }
2907 if (cap.test_write)
2908 CDROM_CONFIG_FLAGS(drive)->test_write = 1;
2909 if (cap.dvd_ram_read || cap.dvd_r_read || cap.dvd_rom)
2910 CDROM_CONFIG_FLAGS(drive)->dvd = 1;
2911 if (cap.dvd_ram_write) {
2912 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 1;
2913 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2914 }
2915 if (cap.dvd_r_write)
2916 CDROM_CONFIG_FLAGS(drive)->dvd_r = 1;
2917 if (cap.audio_play)
2918 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2919 if (cap.mechtype == mechtype_caddy || cap.mechtype == mechtype_popup)
2920 CDROM_CONFIG_FLAGS(drive)->close_tray = 0;
2921
2922 /* Some drives used by Apple don't advertise audio play
2923 * but they do support reading TOC & audio datas
2924 */
2925 if (strcmp(drive->id->model, "MATSHITADVD-ROM SR-8187") == 0 ||
2926 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8186") == 0 ||
2927 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8176") == 0 ||
2928 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8174") == 0)
2929 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2930
2931 #if ! STANDARD_ATAPI
2932 if (cdi->sanyo_slot > 0) {
2933 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
2934 nslots = 3;
2935 }
2936
2937 else
2938 #endif /* not STANDARD_ATAPI */
2939 if (cap.mechtype == mechtype_individual_changer ||
2940 cap.mechtype == mechtype_cartridge_changer) {
2941 if ((nslots = cdrom_number_of_slots(cdi)) > 1) {
2942 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
2943 CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 1;
2944 }
2945 }
2946
2947 /* The ACER/AOpen 24X cdrom has the speed fields byte-swapped */
2948 if (!drive->id->model[0] &&
2949 !strncmp(drive->id->fw_rev, "241N", 4)) {
2950 CDROM_STATE_FLAGS(drive)->current_speed =
2951 (((unsigned int)cap.curspeed) + (176/2)) / 176;
2952 CDROM_CONFIG_FLAGS(drive)->max_speed =
2953 (((unsigned int)cap.maxspeed) + (176/2)) / 176;
2954 } else {
2955 CDROM_STATE_FLAGS(drive)->current_speed =
2956 (ntohs(cap.curspeed) + (176/2)) / 176;
2957 CDROM_CONFIG_FLAGS(drive)->max_speed =
2958 (ntohs(cap.maxspeed) + (176/2)) / 176;
2959 }
2960
2961 /* don't print speed if the drive reported 0.
2962 */
2963 printk(KERN_INFO "%s: ATAPI", drive->name);
2964 if (CDROM_CONFIG_FLAGS(drive)->max_speed)
2965 printk(" %dX", CDROM_CONFIG_FLAGS(drive)->max_speed);
2966 printk(" %s", CDROM_CONFIG_FLAGS(drive)->dvd ? "DVD-ROM" : "CD-ROM");
2967
2968 if (CDROM_CONFIG_FLAGS(drive)->dvd_r|CDROM_CONFIG_FLAGS(drive)->dvd_ram)
2969 printk(" DVD%s%s",
2970 (CDROM_CONFIG_FLAGS(drive)->dvd_r)? "-R" : "",
2971 (CDROM_CONFIG_FLAGS(drive)->dvd_ram)? "-RAM" : "");
2972
2973 if (CDROM_CONFIG_FLAGS(drive)->cd_r|CDROM_CONFIG_FLAGS(drive)->cd_rw)
2974 printk(" CD%s%s",
2975 (CDROM_CONFIG_FLAGS(drive)->cd_r)? "-R" : "",
2976 (CDROM_CONFIG_FLAGS(drive)->cd_rw)? "/RW" : "");
2977
2978 if (CDROM_CONFIG_FLAGS(drive)->is_changer)
2979 printk(" changer w/%d slots", nslots);
2980 else
2981 printk(" drive");
2982
2983 printk(", %dkB Cache", be16_to_cpu(cap.buffer_size));
2984
2985 if (drive->using_dma)
2986 ide_dma_verbose(drive);
2987
2988 printk("\n");
2989
2990 return nslots;
2991 }
2992
2993 static void ide_cdrom_add_settings(ide_drive_t *drive)
2994 {
2995 ide_add_setting(drive, "dsc_overlap", SETTING_RW, -1, -1, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
2996 }
2997
2998 /*
2999 * standard prep_rq_fn that builds 10 byte cmds
3000 */
3001 static int ide_cdrom_prep_fs(request_queue_t *q, struct request *rq)
3002 {
3003 int hard_sect = queue_hardsect_size(q);
3004 long block = (long)rq->hard_sector / (hard_sect >> 9);
3005 unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
3006
3007 memset(rq->cmd, 0, sizeof(rq->cmd));
3008
3009 if (rq_data_dir(rq) == READ)
3010 rq->cmd[0] = GPCMD_READ_10;
3011 else
3012 rq->cmd[0] = GPCMD_WRITE_10;
3013
3014 /*
3015 * fill in lba
3016 */
3017 rq->cmd[2] = (block >> 24) & 0xff;
3018 rq->cmd[3] = (block >> 16) & 0xff;
3019 rq->cmd[4] = (block >> 8) & 0xff;
3020 rq->cmd[5] = block & 0xff;
3021
3022 /*
3023 * and transfer length
3024 */
3025 rq->cmd[7] = (blocks >> 8) & 0xff;
3026 rq->cmd[8] = blocks & 0xff;
3027 rq->cmd_len = 10;
3028 return BLKPREP_OK;
3029 }
3030
3031 /*
3032 * Most of the SCSI commands are supported directly by ATAPI devices.
3033 * This transform handles the few exceptions.
3034 */
3035 static int ide_cdrom_prep_pc(struct request *rq)
3036 {
3037 u8 *c = rq->cmd;
3038
3039 /*
3040 * Transform 6-byte read/write commands to the 10-byte version
3041 */
3042 if (c[0] == READ_6 || c[0] == WRITE_6) {
3043 c[8] = c[4];
3044 c[5] = c[3];
3045 c[4] = c[2];
3046 c[3] = c[1] & 0x1f;
3047 c[2] = 0;
3048 c[1] &= 0xe0;
3049 c[0] += (READ_10 - READ_6);
3050 rq->cmd_len = 10;
3051 return BLKPREP_OK;
3052 }
3053
3054 /*
3055 * it's silly to pretend we understand 6-byte sense commands, just
3056 * reject with ILLEGAL_REQUEST and the caller should take the
3057 * appropriate action
3058 */
3059 if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
3060 rq->errors = ILLEGAL_REQUEST;
3061 return BLKPREP_KILL;
3062 }
3063
3064 return BLKPREP_OK;
3065 }
3066
3067 static int ide_cdrom_prep_fn(request_queue_t *q, struct request *rq)
3068 {
3069 if (rq->flags & REQ_CMD)
3070 return ide_cdrom_prep_fs(q, rq);
3071 else if (rq->flags & REQ_BLOCK_PC)
3072 return ide_cdrom_prep_pc(rq);
3073
3074 return 0;
3075 }
3076
3077 static
3078 int ide_cdrom_setup (ide_drive_t *drive)
3079 {
3080 struct cdrom_info *info = drive->driver_data;
3081 struct cdrom_device_info *cdi = &info->devinfo;
3082 int nslots;
3083
3084 blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
3085 blk_queue_dma_alignment(drive->queue, 31);
3086 drive->queue->unplug_delay = (1 * HZ) / 1000;
3087 if (!drive->queue->unplug_delay)
3088 drive->queue->unplug_delay = 1;
3089
3090 drive->special.all = 0;
3091 drive->ready_stat = 0;
3092
3093 CDROM_STATE_FLAGS(drive)->media_changed = 1;
3094 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
3095 CDROM_STATE_FLAGS(drive)->door_locked = 0;
3096
3097 #if NO_DOOR_LOCKING
3098 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
3099 #else
3100 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 0;
3101 #endif
3102
3103 CDROM_CONFIG_FLAGS(drive)->drq_interrupt = ((drive->id->config & 0x0060) == 0x20);
3104 CDROM_CONFIG_FLAGS(drive)->is_changer = 0;
3105 CDROM_CONFIG_FLAGS(drive)->cd_r = 0;
3106 CDROM_CONFIG_FLAGS(drive)->cd_rw = 0;
3107 CDROM_CONFIG_FLAGS(drive)->test_write = 0;
3108 CDROM_CONFIG_FLAGS(drive)->dvd = 0;
3109 CDROM_CONFIG_FLAGS(drive)->dvd_r = 0;
3110 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 0;
3111 CDROM_CONFIG_FLAGS(drive)->no_eject = 1;
3112 CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 0;
3113 CDROM_CONFIG_FLAGS(drive)->audio_play = 0;
3114 CDROM_CONFIG_FLAGS(drive)->close_tray = 1;
3115
3116 /* limit transfer size per interrupt. */
3117 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 0;
3118 /* a testament to the nice quality of Samsung drives... */
3119 if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2430"))
3120 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3121 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2432"))
3122 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3123 /* the 3231 model does not support the SET_CD_SPEED command */
3124 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-3231"))
3125 cdi->mask |= CDC_SELECT_SPEED;
3126
3127 #if ! STANDARD_ATAPI
3128 /* by default Sanyo 3 CD changer support is turned off and
3129 ATAPI Rev 2.2+ standard support for CD changers is used */
3130 cdi->sanyo_slot = 0;
3131
3132 CDROM_CONFIG_FLAGS(drive)->nec260 = 0;
3133 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 0;
3134 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 0;
3135 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 0;
3136 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 0;
3137
3138 if (strcmp (drive->id->model, "V003S0DS") == 0 &&
3139 drive->id->fw_rev[4] == '1' &&
3140 drive->id->fw_rev[6] <= '2') {
3141 /* Vertos 300.
3142 Some versions of this drive like to talk BCD. */
3143 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3144 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3145 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3146 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3147 }
3148
3149 else if (strcmp (drive->id->model, "V006E0DS") == 0 &&
3150 drive->id->fw_rev[4] == '1' &&
3151 drive->id->fw_rev[6] <= '2') {
3152 /* Vertos 600 ESD. */
3153 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3154 }
3155 else if (strcmp(drive->id->model, "NEC CD-ROM DRIVE:260") == 0 &&
3156 strncmp(drive->id->fw_rev, "1.01", 4) == 0) { /* FIXME */
3157 /* Old NEC260 (not R).
3158 This drive was released before the 1.2 version
3159 of the spec. */
3160 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3161 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3162 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3163 CDROM_CONFIG_FLAGS(drive)->nec260 = 1;
3164 }
3165 else if (strcmp(drive->id->model, "WEARNES CDD-120") == 0 &&
3166 strncmp(drive->id->fw_rev, "A1.1", 4) == 0) { /* FIXME */
3167 /* Wearnes */
3168 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3169 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3170 }
3171 /* Sanyo 3 CD changer uses a non-standard command
3172 for CD changing */
3173 else if ((strcmp(drive->id->model, "CD-ROM CDR-C3 G") == 0) ||
3174 (strcmp(drive->id->model, "CD-ROM CDR-C3G") == 0) ||
3175 (strcmp(drive->id->model, "CD-ROM CDR_C36") == 0)) {
3176 /* uses CD in slot 0 when value is set to 3 */
3177 cdi->sanyo_slot = 3;
3178 }
3179 #endif /* not STANDARD_ATAPI */
3180
3181 info->toc = NULL;
3182 info->buffer = NULL;
3183 info->sector_buffered = 0;
3184 info->nsectors_buffered = 0;
3185 info->changer_info = NULL;
3186 info->last_block = 0;
3187 info->start_seek = 0;
3188
3189 nslots = ide_cdrom_probe_capabilities (drive);
3190
3191 /*
3192 * set correct block size
3193 */
3194 blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
3195
3196 #if 0
3197 drive->dsc_overlap = (HWIF(drive)->no_dsc) ? 0 : 1;
3198 if (HWIF(drive)->no_dsc) {
3199 printk(KERN_INFO "ide-cd: %s: disabling DSC overlap\n",
3200 drive->name);
3201 drive->dsc_overlap = 0;
3202 }
3203 #endif
3204
3205 if (ide_cdrom_register(drive, nslots)) {
3206 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
3207 info->devinfo.handle = NULL;
3208 return 1;
3209 }
3210 ide_cdrom_add_settings(drive);
3211 return 0;
3212 }
3213
3214 static
3215 sector_t ide_cdrom_capacity (ide_drive_t *drive)
3216 {
3217 unsigned long capacity, sectors_per_frame;
3218
3219 if (cdrom_read_capacity(drive, &capacity, §ors_per_frame, NULL))
3220 return 0;
3221
3222 return capacity * sectors_per_frame;
3223 }
3224
3225 static
3226 int ide_cdrom_cleanup(ide_drive_t *drive)
3227 {
3228 struct cdrom_info *info = drive->driver_data;
3229 struct cdrom_device_info *devinfo = &info->devinfo;
3230 struct gendisk *g = drive->disk;
3231
3232 if (ide_unregister_subdriver(drive)) {
3233 printk(KERN_ERR "%s: %s: failed to ide_unregister_subdriver\n",
3234 __FUNCTION__, drive->name);
3235 return 1;
3236 }
3237 if (info->buffer != NULL)
3238 kfree(info->buffer);
3239 if (info->toc != NULL)
3240 kfree(info->toc);
3241 if (info->changer_info != NULL)
3242 kfree(info->changer_info);
3243 if (devinfo->handle == drive && unregister_cdrom(devinfo))
3244 printk(KERN_ERR "%s: ide_cdrom_cleanup failed to unregister device from the cdrom driver.\n", drive->name);
3245 kfree(info);
3246 drive->driver_data = NULL;
3247 blk_queue_prep_rq(drive->queue, NULL);
3248 del_gendisk(g);
3249 g->fops = ide_fops;
3250 return 0;
3251 }
3252
3253 static int ide_cdrom_attach (ide_drive_t *drive);
3254
3255 /*
3256 * Power Management state machine.
3257 *
3258 * We don't do much for CDs right now.
3259 */
3260
3261 static void ide_cdrom_complete_power_step (ide_drive_t *drive, struct request *rq, u8 stat, u8 error)
3262 {
3263 }
3264
3265 static ide_startstop_t ide_cdrom_start_power_step (ide_drive_t *drive, struct request *rq)
3266 {
3267 ide_task_t *args = rq->special;
3268
3269 memset(args, 0, sizeof(*args));
3270
3271 switch (rq->pm->pm_step) {
3272 case ide_pm_state_start_suspend:
3273 break;
3274
3275 case ide_pm_state_start_resume: /* Resume step 1 (restore DMA) */
3276 /*
3277 * Right now, all we do is call hwif->ide_dma_check(drive),
3278 * we could be smarter and check for current xfer_speed
3279 * in struct drive etc...
3280 * Also, this step could be implemented as a generic helper
3281 * as most subdrivers will use it.
3282 */
3283 if ((drive->id->capability & 1) == 0)
3284 break;
3285 if (HWIF(drive)->ide_dma_check == NULL)
3286 break;
3287 HWIF(drive)->ide_dma_check(drive);
3288 break;
3289 }
3290 rq->pm->pm_step = ide_pm_state_completed;
3291 return ide_stopped;
3292 }
3293
3294 static ide_driver_t ide_cdrom_driver = {
3295 .owner = THIS_MODULE,
3296 .name = "ide-cdrom",
3297 .version = IDECD_VERSION,
3298 .media = ide_cdrom,
3299 .busy = 0,
3300 .supports_dsc_overlap = 1,
3301 .cleanup = ide_cdrom_cleanup,
3302 .do_request = ide_do_rw_cdrom,
3303 .capacity = ide_cdrom_capacity,
3304 .attach = ide_cdrom_attach,
3305 .drives = LIST_HEAD_INIT(ide_cdrom_driver.drives),
3306 .start_power_step = ide_cdrom_start_power_step,
3307 .complete_power_step = ide_cdrom_complete_power_step,
3308 };
3309
3310 static int idecd_open(struct inode * inode, struct file * file)
3311 {
3312 ide_drive_t *drive = inode->i_bdev->bd_disk->private_data;
3313 struct cdrom_info *info = drive->driver_data;
3314 int rc = -ENOMEM;
3315 drive->usage++;
3316
3317 if (!info->buffer)
3318 info->buffer = kmalloc(SECTOR_BUFFER_SIZE,
3319 GFP_KERNEL|__GFP_REPEAT);
3320 if (!info->buffer || (rc = cdrom_open(&info->devinfo, inode, file)))
3321 drive->usage--;
3322 return rc;
3323 }
3324
3325 static int idecd_release(struct inode * inode, struct file * file)
3326 {
3327 ide_drive_t *drive = inode->i_bdev->bd_disk->private_data;
3328 struct cdrom_info *info = drive->driver_data;
3329
3330 cdrom_release (&info->devinfo, file);
3331 drive->usage--;
3332 return 0;
3333 }
3334
3335 static int idecd_ioctl (struct inode *inode, struct file *file,
3336 unsigned int cmd, unsigned long arg)
3337 {
3338 struct block_device *bdev = inode->i_bdev;
3339 ide_drive_t *drive = bdev->bd_disk->private_data;
3340 int err = generic_ide_ioctl(file, bdev, cmd, arg);
3341 if (err == -EINVAL) {
3342 struct cdrom_info *info = drive->driver_data;
3343 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
3344 }
3345 return err;
3346 }
3347
3348 static int idecd_media_changed(struct gendisk *disk)
3349 {
3350 ide_drive_t *drive = disk->private_data;
3351 struct cdrom_info *info = drive->driver_data;
3352 return cdrom_media_changed(&info->devinfo);
3353 }
3354
3355 static int idecd_revalidate_disk(struct gendisk *disk)
3356 {
3357 ide_drive_t *drive = disk->private_data;
3358 struct request_sense sense;
3359 cdrom_read_toc(drive, &sense);
3360 return 0;
3361 }
3362
3363 static struct block_device_operations idecd_ops = {
3364 .owner = THIS_MODULE,
3365 .open = idecd_open,
3366 .release = idecd_release,
3367 .ioctl = idecd_ioctl,
3368 .media_changed = idecd_media_changed,
3369 .revalidate_disk= idecd_revalidate_disk
3370 };
3371
3372 /* options */
3373 static char *ignore = NULL;
3374
3375 module_param(ignore, charp, 0400);
3376 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
3377
3378 static int ide_cdrom_attach (ide_drive_t *drive)
3379 {
3380 struct cdrom_info *info;
3381 struct gendisk *g = drive->disk;
3382 struct request_sense sense;
3383
3384 if (!strstr("ide-cdrom", drive->driver_req))
3385 goto failed;
3386 if (!drive->present)
3387 goto failed;
3388 if (drive->media != ide_cdrom && drive->media != ide_optical)
3389 goto failed;
3390 /* skip drives that we were told to ignore */
3391 if (ignore != NULL) {
3392 if (strstr(ignore, drive->name)) {
3393 printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
3394 goto failed;
3395 }
3396 }
3397 if (drive->scsi) {
3398 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
3399 goto failed;
3400 }
3401 info = (struct cdrom_info *) kmalloc (sizeof (struct cdrom_info), GFP_KERNEL);
3402 if (info == NULL) {
3403 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
3404 goto failed;
3405 }
3406 if (ide_register_subdriver(drive, &ide_cdrom_driver)) {
3407 printk(KERN_ERR "%s: Failed to register the driver with ide.c\n",
3408 drive->name);
3409 kfree(info);
3410 goto failed;
3411 }
3412 memset(info, 0, sizeof (struct cdrom_info));
3413 drive->driver_data = info;
3414 DRIVER(drive)->busy++;
3415 g->minors = 1;
3416 snprintf(g->devfs_name, sizeof(g->devfs_name),
3417 "%s/cd", drive->devfs_name);
3418 g->driverfs_dev = &drive->gendev;
3419 g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
3420 if (ide_cdrom_setup(drive)) {
3421 struct cdrom_device_info *devinfo = &info->devinfo;
3422 DRIVER(drive)->busy--;
3423 ide_unregister_subdriver(drive);
3424 if (info->buffer != NULL)
3425 kfree(info->buffer);
3426 if (info->toc != NULL)
3427 kfree(info->toc);
3428 if (info->changer_info != NULL)
3429 kfree(info->changer_info);
3430 if (devinfo->handle == drive && unregister_cdrom(devinfo))
3431 printk (KERN_ERR "%s: ide_cdrom_cleanup failed to unregister device from the cdrom driver.\n", drive->name);
3432 kfree(info);
3433 drive->driver_data = NULL;
3434 goto failed;
3435 }
3436 DRIVER(drive)->busy--;
3437
3438 cdrom_read_toc(drive, &sense);
3439 g->fops = &idecd_ops;
3440 g->flags |= GENHD_FL_REMOVABLE;
3441 add_disk(g);
3442 return 0;
3443 failed:
3444 return 1;
3445 }
3446
3447 static void __exit ide_cdrom_exit(void)
3448 {
3449 ide_unregister_driver(&ide_cdrom_driver);
3450 }
3451
3452 static int ide_cdrom_init(void)
3453 {
3454 ide_register_driver(&ide_cdrom_driver);
3455 return 0;
3456 }
3457
3458 module_init(ide_cdrom_init);
3459 module_exit(ide_cdrom_exit);
3460 MODULE_LICENSE("GPL");
3461
|
This page was automatically generated by the
LXR engine.
|