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