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