aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/ide/ide-cd.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/ide/ide-cd.c')
-rw-r--r--drivers/ide/ide-cd.c2333
1 files changed, 532 insertions, 1801 deletions
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index bee05a3f52ae..23074e84472e 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -1,14 +1,14 @@
1/* 1/*
2 * linux/drivers/ide/ide-cd.c 2 * ATAPI CD-ROM driver.
3 * 3 *
4 * Copyright (C) 1994, 1995, 1996 scott snyder <snyder@fnald0.fnal.gov> 4 * Copyright (C) 1994-1996 Scott Snyder <snyder@fnald0.fnal.gov>
5 * Copyright (C) 1996-1998 Erik Andersen <andersee@debian.org> 5 * Copyright (C) 1996-1998 Erik Andersen <andersee@debian.org>
6 * Copyright (C) 1998-2000 Jens Axboe <axboe@suse.de> 6 * Copyright (C) 1998-2000 Jens Axboe <axboe@suse.de>
7 * Copyright (C) 2005, 2007 Bartlomiej Zolnierkiewicz
7 * 8 *
8 * May be copied or modified under the terms of the GNU General Public 9 * May be copied or modified under the terms of the GNU General Public
9 * License. See linux/COPYING for more information. 10 * License. See linux/COPYING for more information.
10 * 11 *
11 * ATAPI CD-ROM driver. To be used with ide.c.
12 * See Documentation/cdrom/ide-cd for usage information. 12 * See Documentation/cdrom/ide-cd for usage information.
13 * 13 *
14 * Suggestions are welcome. Patches that work are more welcome though. ;-) 14 * Suggestions are welcome. Patches that work are more welcome though. ;-)
@@ -19,287 +19,11 @@
19 * ftp://fission.dt.wdc.com/pub/standards/SFF_atapi/spec/SFF8020-r2.6/PS/8020r26.ps 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 20 * ftp://ftp.avc-pioneer.com/Mtfuji4/Spec/Fuji4r10.pdf
21 * 21 *
22 * Drives that deviate from these standards will be accommodated as much 22 * For historical changelog please see:
23 * as possible via compile time or command-line options. Since I only have 23 * Documentation/ide/ChangeLog.ide-cd.1994-2004
24 * a few drives, you generally need to send me patches... 24 */
25 * 25
26 * ---------------------------------- 26#define IDECD_VERSION "5.00"
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 Eißfeldt <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 Eißfeldt <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 27
304#include <linux/module.h> 28#include <linux/module.h>
305#include <linux/types.h> 29#include <linux/types.h>
@@ -313,6 +37,7 @@
313#include <linux/ide.h> 37#include <linux/ide.h>
314#include <linux/completion.h> 38#include <linux/completion.h>
315#include <linux/mutex.h> 39#include <linux/mutex.h>
40#include <linux/bcd.h>
316 41
317#include <scsi/scsi.h> /* For SCSI -> ATAPI command conversion */ 42#include <scsi/scsi.h> /* For SCSI -> ATAPI command conversion */
318 43
@@ -360,11 +85,11 @@ static void ide_cd_put(struct cdrom_info *cd)
360 buffers. */ 85 buffers. */
361static void cdrom_saw_media_change (ide_drive_t *drive) 86static void cdrom_saw_media_change (ide_drive_t *drive)
362{ 87{
363 struct cdrom_info *info = drive->driver_data; 88 struct cdrom_info *cd = drive->driver_data;
364 89
365 CDROM_STATE_FLAGS (drive)->media_changed = 1; 90 cd->cd_flags |= IDE_CD_FLAG_MEDIA_CHANGED;
366 CDROM_STATE_FLAGS (drive)->toc_valid = 0; 91 cd->cd_flags &= ~IDE_CD_FLAG_TOC_VALID;
367 info->nsectors_buffered = 0; 92 cd->nsectors_buffered = 0;
368} 93}
369 94
370static int cdrom_log_sense(ide_drive_t *drive, struct request *rq, 95static int cdrom_log_sense(ide_drive_t *drive, struct request *rq,
@@ -465,134 +190,14 @@ void cdrom_analyze_sense_data(ide_drive_t *drive,
465 } 190 }
466 } 191 }
467 } 192 }
468#if VERBOSE_IDE_CD_ERRORS
469 {
470 int i;
471 const char *s = "bad sense key!";
472 char buf[80];
473
474 printk ("ATAPI device %s:\n", drive->name);
475 if (sense->error_code==0x70)
476 printk(" Error: ");
477 else if (sense->error_code==0x71)
478 printk(" Deferred Error: ");
479 else if (sense->error_code == 0x7f)
480 printk(" Vendor-specific Error: ");
481 else
482 printk(" Unknown Error Type: ");
483
484 if (sense->sense_key < ARRAY_SIZE(sense_key_texts))
485 s = sense_key_texts[sense->sense_key];
486
487 printk("%s -- (Sense key=0x%02x)\n", s, sense->sense_key);
488
489 if (sense->asc == 0x40) {
490 sprintf(buf, "Diagnostic failure on component 0x%02x",
491 sense->ascq);
492 s = buf;
493 } else {
494 int lo = 0, mid, hi = ARRAY_SIZE(sense_data_texts);
495 unsigned long key = (sense->sense_key << 16);
496 key |= (sense->asc << 8);
497 if (!(sense->ascq >= 0x80 && sense->ascq <= 0xdd))
498 key |= sense->ascq;
499 s = NULL;
500
501 while (hi > lo) {
502 mid = (lo + hi) / 2;
503 if (sense_data_texts[mid].asc_ascq == key ||
504 sense_data_texts[mid].asc_ascq == (0xff0000|key)) {
505 s = sense_data_texts[mid].text;
506 break;
507 }
508 else if (sense_data_texts[mid].asc_ascq > key)
509 hi = mid;
510 else
511 lo = mid+1;
512 }
513 }
514
515 if (s == NULL) {
516 if (sense->asc > 0x80)
517 s = "(vendor-specific error)";
518 else
519 s = "(reserved error code)";
520 }
521
522 printk(KERN_ERR " %s -- (asc=0x%02x, ascq=0x%02x)\n",
523 s, sense->asc, sense->ascq);
524
525 if (failed_command != NULL) {
526
527 int lo=0, mid, hi= ARRAY_SIZE(packet_command_texts);
528 s = NULL;
529
530 while (hi > lo) {
531 mid = (lo + hi) / 2;
532 if (packet_command_texts[mid].packet_command ==
533 failed_command->cmd[0]) {
534 s = packet_command_texts[mid].text;
535 break;
536 }
537 if (packet_command_texts[mid].packet_command >
538 failed_command->cmd[0])
539 hi = mid;
540 else
541 lo = mid+1;
542 }
543
544 printk (KERN_ERR " The failed \"%s\" packet command was: \n \"", s);
545 for (i=0; i<sizeof (failed_command->cmd); i++)
546 printk ("%02x ", failed_command->cmd[i]);
547 printk ("\"\n");
548 }
549
550 /* The SKSV bit specifies validity of the sense_key_specific
551 * in the next two commands. It is bit 7 of the first byte.
552 * In the case of NOT_READY, if SKSV is set the drive can
553 * give us nice ETA readings.
554 */
555 if (sense->sense_key == NOT_READY && (sense->sks[0] & 0x80)) {
556 int progress = (sense->sks[1] << 8 | sense->sks[2]) * 100;
557 printk(KERN_ERR " Command is %02d%% complete\n", progress / 0xffff);
558
559 }
560
561 if (sense->sense_key == ILLEGAL_REQUEST &&
562 (sense->sks[0] & 0x80) != 0) {
563 printk(KERN_ERR " Error in %s byte %d",
564 (sense->sks[0] & 0x40) != 0 ?
565 "command packet" : "command data",
566 (sense->sks[1] << 8) + sense->sks[2]);
567
568 if ((sense->sks[0] & 0x40) != 0)
569 printk (" bit %d", sense->sks[0] & 0x07);
570 193
571 printk ("\n"); 194 ide_cd_log_error(drive->name, failed_command, sense);
572 }
573 }
574
575#else /* not VERBOSE_IDE_CD_ERRORS */
576
577 /* Suppress printing unit attention and `in progress of becoming ready'
578 errors when we're not being verbose. */
579
580 if (sense->sense_key == UNIT_ATTENTION ||
581 (sense->sense_key == NOT_READY && (sense->asc == 4 ||
582 sense->asc == 0x3a)))
583 return;
584
585 printk(KERN_ERR "%s: error code: 0x%02x sense_key: 0x%02x asc: 0x%02x ascq: 0x%02x\n",
586 drive->name,
587 sense->error_code, sense->sense_key,
588 sense->asc, sense->ascq);
589#endif /* not VERBOSE_IDE_CD_ERRORS */
590} 195}
591 196
592/* 197/*
593 * Initialize a ide-cd packet command request 198 * Initialize a ide-cd packet command request
594 */ 199 */
595static void cdrom_prepare_request(ide_drive_t *drive, struct request *rq) 200void ide_cd_init_rq(ide_drive_t *drive, struct request *rq)
596{ 201{
597 struct cdrom_info *cd = drive->driver_data; 202 struct cdrom_info *cd = drive->driver_data;
598 203
@@ -611,7 +216,7 @@ static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense,
611 sense = &info->sense_data; 216 sense = &info->sense_data;
612 217
613 /* stuff the sense request in front of our current request */ 218 /* stuff the sense request in front of our current request */
614 cdrom_prepare_request(drive, rq); 219 ide_cd_init_rq(drive, rq);
615 220
616 rq->data = sense; 221 rq->data = sense;
617 rq->cmd[0] = GPCMD_REQUEST_SENSE; 222 rq->cmd[0] = GPCMD_REQUEST_SENSE;
@@ -718,7 +323,6 @@ static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
718 323
719 } else if (blk_pc_request(rq) || rq->cmd_type == REQ_TYPE_ATA_PC) { 324 } else if (blk_pc_request(rq) || rq->cmd_type == REQ_TYPE_ATA_PC) {
720 /* All other functions, except for READ. */ 325 /* All other functions, except for READ. */
721 unsigned long flags;
722 326
723 /* 327 /*
724 * if we have an error, pass back CHECK_CONDITION as the 328 * if we have an error, pass back CHECK_CONDITION as the
@@ -756,15 +360,7 @@ static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
756 * remove failed request completely and end it when the 360 * remove failed request completely and end it when the
757 * request sense has completed 361 * request sense has completed
758 */ 362 */
759 if (stat & ERR_STAT) { 363 goto end_request;
760 spin_lock_irqsave(&ide_lock, flags);
761 blkdev_dequeue_request(rq);
762 HWGROUP(drive)->rq = NULL;
763 spin_unlock_irqrestore(&ide_lock, flags);
764
765 cdrom_queue_request_sense(drive, rq->sense, rq);
766 } else
767 cdrom_end_request(drive, 0);
768 364
769 } else if (blk_fs_request(rq)) { 365 } else if (blk_fs_request(rq)) {
770 int do_end_request = 0; 366 int do_end_request = 0;
@@ -844,23 +440,15 @@ static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
844 sense data. We need this in order to perform end of media 440 sense data. We need this in order to perform end of media
845 processing */ 441 processing */
846 442
847 if (do_end_request) { 443 if (do_end_request)
848 if (stat & ERR_STAT) { 444 goto end_request;
849 unsigned long flags;
850 spin_lock_irqsave(&ide_lock, flags);
851 blkdev_dequeue_request(rq);
852 HWGROUP(drive)->rq = NULL;
853 spin_unlock_irqrestore(&ide_lock, flags);
854 445
855 cdrom_queue_request_sense(drive, rq->sense, rq); 446 /*
856 } else 447 * If we got a CHECK_CONDITION status,
857 cdrom_end_request(drive, 0); 448 * queue a request sense command.
858 } else { 449 */
859 /* If we got a CHECK_CONDITION status, 450 if (stat & ERR_STAT)
860 queue a request sense command. */ 451 cdrom_queue_request_sense(drive, NULL, NULL);
861 if (stat & ERR_STAT)
862 cdrom_queue_request_sense(drive, NULL, NULL);
863 }
864 } else { 452 } else {
865 blk_dump_rq_flags(rq, "ide-cd: bad rq"); 453 blk_dump_rq_flags(rq, "ide-cd: bad rq");
866 cdrom_end_request(drive, 0); 454 cdrom_end_request(drive, 0);
@@ -868,6 +456,21 @@ static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
868 456
869 /* Retry, or handle the next request. */ 457 /* Retry, or handle the next request. */
870 return 1; 458 return 1;
459
460end_request:
461 if (stat & ERR_STAT) {
462 unsigned long flags;
463
464 spin_lock_irqsave(&ide_lock, flags);
465 blkdev_dequeue_request(rq);
466 HWGROUP(drive)->rq = NULL;
467 spin_unlock_irqrestore(&ide_lock, flags);
468
469 cdrom_queue_request_sense(drive, rq->sense, rq);
470 } else
471 cdrom_end_request(drive, 0);
472
473 return 1;
871} 474}
872 475
873static int cdrom_timer_expiry(ide_drive_t *drive) 476static int cdrom_timer_expiry(ide_drive_t *drive)
@@ -924,8 +527,8 @@ static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
924 /* Set up the controller registers. */ 527 /* Set up the controller registers. */
925 ide_pktcmd_tf_load(drive, IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL | 528 ide_pktcmd_tf_load(drive, IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL |
926 IDE_TFLAG_NO_SELECT_MASK, xferlen, info->dma); 529 IDE_TFLAG_NO_SELECT_MASK, xferlen, info->dma);
927 530
928 if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt) { 531 if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) {
929 /* waiting for CDB interrupt, not DMA yet. */ 532 /* waiting for CDB interrupt, not DMA yet. */
930 if (info->dma) 533 if (info->dma)
931 drive->waiting_for_dma = 0; 534 drive->waiting_for_dma = 0;
@@ -951,10 +554,6 @@ static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
951 by cdrom_start_packet_command. 554 by cdrom_start_packet_command.
952 HANDLER is the interrupt handler to call when the command completes 555 HANDLER is the interrupt handler to call when the command completes
953 or there's data ready. */ 556 or there's data ready. */
954/*
955 * changed 5 parameters to 3 for dvd-ram
956 * struct packet_command *pc; now packet_command_t *pc;
957 */
958#define ATAPI_MIN_CDB_BYTES 12 557#define ATAPI_MIN_CDB_BYTES 12
959static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive, 558static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
960 struct request *rq, 559 struct request *rq,
@@ -965,7 +564,7 @@ static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
965 struct cdrom_info *info = drive->driver_data; 564 struct cdrom_info *info = drive->driver_data;
966 ide_startstop_t startstop; 565 ide_startstop_t startstop;
967 566
968 if (CDROM_CONFIG_FLAGS(drive)->drq_interrupt) { 567 if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) {
969 /* Here we should have been called after receiving an interrupt 568 /* Here we should have been called after receiving an interrupt
970 from the device. DRQ should how be set. */ 569 from the device. DRQ should how be set. */
971 570
@@ -1005,6 +604,27 @@ static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
1005 * Block read functions. 604 * Block read functions.
1006 */ 605 */
1007 606
607typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
608
609static void ide_cd_pad_transfer(ide_drive_t *drive, xfer_func_t *xf, int len)
610{
611 while (len > 0) {
612 int dum = 0;
613 xf(drive, &dum, sizeof(dum));
614 len -= sizeof(dum);
615 }
616}
617
618static void ide_cd_drain_data(ide_drive_t *drive, int nsects)
619{
620 while (nsects > 0) {
621 static char dum[SECTOR_SIZE];
622
623 drive->hwif->atapi_input_bytes(drive, dum, sizeof(dum));
624 nsects--;
625 }
626}
627
1008/* 628/*
1009 * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector 629 * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
1010 * buffer. Once the first sector is added, any subsequent sectors are 630 * buffer. Once the first sector is added, any subsequent sectors are
@@ -1043,11 +663,7 @@ static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
1043 } 663 }
1044 664
1045 /* Throw away any remaining data. */ 665 /* Throw away any remaining data. */
1046 while (sectors_to_transfer > 0) { 666 ide_cd_drain_data(drive, sectors_to_transfer);
1047 static char dum[SECTOR_SIZE];
1048 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1049 --sectors_to_transfer;
1050 }
1051} 667}
1052 668
1053/* 669/*
@@ -1056,23 +672,25 @@ static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
1056 * ok; nonzero if the request has been terminated. 672 * ok; nonzero if the request has been terminated.
1057 */ 673 */
1058static 674static
1059int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason) 675int ide_cd_check_ireason(ide_drive_t *drive, int len, int ireason, int rw)
1060{ 676{
1061 if (ireason == 2) 677 /*
678 * ireason == 0: the drive wants to receive data from us
679 * ireason == 2: the drive is expecting to transfer data to us
680 */
681 if (ireason == (!rw << 1))
1062 return 0; 682 return 0;
1063 else if (ireason == 0) { 683 else if (ireason == (rw << 1)) {
1064 /* Whoops... The drive is expecting to receive data from us! */ 684 ide_hwif_t *hwif = drive->hwif;
685 xfer_func_t *xf;
686
687 /* Whoops... */
1065 printk(KERN_ERR "%s: %s: wrong transfer direction!\n", 688 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
1066 drive->name, __FUNCTION__); 689 drive->name, __FUNCTION__);
1067 690
1068 /* Throw some data at the drive so it doesn't hang 691 xf = rw ? hwif->atapi_output_bytes : hwif->atapi_input_bytes;
1069 and quit this request. */ 692 ide_cd_pad_transfer(drive, xf, len);
1070 while (len > 0) { 693 } else if (rw == 0 && ireason == 1) {
1071 int dum = 0;
1072 HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof (dum));
1073 len -= sizeof (dum);
1074 }
1075 } else if (ireason == 1) {
1076 /* Some drives (ASUS) seem to tell us that status 694 /* Some drives (ASUS) seem to tell us that status
1077 * info is available. just get it and ignore. 695 * info is available. just get it and ignore.
1078 */ 696 */
@@ -1089,137 +707,28 @@ int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
1089} 707}
1090 708
1091/* 709/*
1092 * Interrupt routine. Called when a read request has completed. 710 * Assume that the drive will always provide data in multiples of at least
711 * SECTOR_SIZE, as it gets hairy to keep track of the transfers otherwise.
1093 */ 712 */
1094static ide_startstop_t cdrom_read_intr (ide_drive_t *drive) 713static int ide_cd_check_transfer_size(ide_drive_t *drive, int len)
1095{ 714{
1096 int stat; 715 struct cdrom_info *cd = drive->driver_data;
1097 int ireason, len, sectors_to_transfer, nskip;
1098 struct cdrom_info *info = drive->driver_data;
1099 u8 lowcyl = 0, highcyl = 0;
1100 int dma = info->dma, dma_error = 0;
1101
1102 struct request *rq = HWGROUP(drive)->rq;
1103
1104 /*
1105 * handle dma case
1106 */
1107 if (dma) {
1108 info->dma = 0;
1109 dma_error = HWIF(drive)->ide_dma_end(drive);
1110 if (dma_error) {
1111 printk(KERN_ERR "%s: DMA read error\n", drive->name);
1112 ide_dma_off(drive);
1113 }
1114 }
1115
1116 if (cdrom_decode_status(drive, 0, &stat))
1117 return ide_stopped;
1118
1119 if (dma) {
1120 if (!dma_error) {
1121 ide_end_request(drive, 1, rq->nr_sectors);
1122 return ide_stopped;
1123 } else
1124 return ide_error(drive, "dma error", stat);
1125 }
1126
1127 /* Read the interrupt reason and the transfer length. */
1128 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1129 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1130 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1131
1132 len = lowcyl + (256 * highcyl);
1133
1134 /* If DRQ is clear, the command has completed. */
1135 if ((stat & DRQ_STAT) == 0) {
1136 /* If we're not done filling the current buffer, complain.
1137 Otherwise, complete the command normally. */
1138 if (rq->current_nr_sectors > 0) {
1139 printk (KERN_ERR "%s: cdrom_read_intr: data underrun (%d blocks)\n",
1140 drive->name, rq->current_nr_sectors);
1141 rq->cmd_flags |= REQ_FAILED;
1142 cdrom_end_request(drive, 0);
1143 } else
1144 cdrom_end_request(drive, 1);
1145 return ide_stopped;
1146 }
1147
1148 /* Check that the drive is expecting to do the same thing we are. */
1149 if (cdrom_read_check_ireason (drive, len, ireason))
1150 return ide_stopped;
1151
1152 /* Assume that the drive will always provide data in multiples
1153 of at least SECTOR_SIZE, as it gets hairy to keep track
1154 of the transfers otherwise. */
1155 if ((len % SECTOR_SIZE) != 0) {
1156 printk (KERN_ERR "%s: cdrom_read_intr: Bad transfer size %d\n",
1157 drive->name, len);
1158 if (CDROM_CONFIG_FLAGS(drive)->limit_nframes)
1159 printk (KERN_ERR " This drive is not supported by this version of the driver\n");
1160 else {
1161 printk (KERN_ERR " Trying to limit transfer sizes\n");
1162 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
1163 }
1164 cdrom_end_request(drive, 0);
1165 return ide_stopped;
1166 }
1167
1168 /* The number of sectors we need to read from the drive. */
1169 sectors_to_transfer = len / SECTOR_SIZE;
1170
1171 /* First, figure out if we need to bit-bucket
1172 any of the leading sectors. */
1173 nskip = min_t(int, rq->current_nr_sectors - bio_cur_sectors(rq->bio), sectors_to_transfer);
1174
1175 while (nskip > 0) {
1176 /* We need to throw away a sector. */
1177 static char dum[SECTOR_SIZE];
1178 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1179
1180 --rq->current_nr_sectors;
1181 --nskip;
1182 --sectors_to_transfer;
1183 }
1184 716
1185 /* Now loop while we still have data to read from the drive. */ 717 if ((len % SECTOR_SIZE) == 0)
1186 while (sectors_to_transfer > 0) { 718 return 0;
1187 int this_transfer;
1188 719
1189 /* If we've filled the present buffer but there's another 720 printk(KERN_ERR "%s: %s: Bad transfer size %d\n",
1190 chained buffer after it, move on. */ 721 drive->name, __FUNCTION__, len);
1191 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1192 cdrom_end_request(drive, 1);
1193 722
1194 /* If the buffers are full, cache the rest of the data in our 723 if (cd->cd_flags & IDE_CD_FLAG_LIMIT_NFRAMES)
1195 internal buffer. */ 724 printk(KERN_ERR " This drive is not supported by "
1196 if (rq->current_nr_sectors == 0) { 725 "this version of the driver\n");
1197 cdrom_buffer_sectors(drive, rq->sector, sectors_to_transfer); 726 else {
1198 sectors_to_transfer = 0; 727 printk(KERN_ERR " Trying to limit transfer sizes\n");
1199 } else { 728 cd->cd_flags |= IDE_CD_FLAG_LIMIT_NFRAMES;
1200 /* Transfer data to the buffers.
1201 Figure out how many sectors we can transfer
1202 to the current buffer. */
1203 this_transfer = min_t(int, sectors_to_transfer,
1204 rq->current_nr_sectors);
1205
1206 /* Read this_transfer sectors
1207 into the current buffer. */
1208 while (this_transfer > 0) {
1209 HWIF(drive)->atapi_input_bytes(drive, rq->buffer, SECTOR_SIZE);
1210 rq->buffer += SECTOR_SIZE;
1211 --rq->nr_sectors;
1212 --rq->current_nr_sectors;
1213 ++rq->sector;
1214 --this_transfer;
1215 --sectors_to_transfer;
1216 }
1217 }
1218 } 729 }
1219 730
1220 /* Done moving data! Wait for another interrupt. */ 731 return 1;
1221 ide_set_handler(drive, &cdrom_read_intr, ATAPI_WAIT_PC, NULL);
1222 return ide_started;
1223} 732}
1224 733
1225/* 734/*
@@ -1281,48 +790,58 @@ static int cdrom_read_from_buffer (ide_drive_t *drive)
1281 return 0; 790 return 0;
1282} 791}
1283 792
793static ide_startstop_t cdrom_newpc_intr(ide_drive_t *);
794
1284/* 795/*
1285 * Routine to send a read packet command to the drive. 796 * Routine to send a read/write packet command to the drive.
1286 * This is usually called directly from cdrom_start_read. 797 * This is usually called directly from cdrom_start_{read,write}().
1287 * However, for drq_interrupt devices, it is called from an interrupt 798 * However, for drq_interrupt devices, it is called from an interrupt
1288 * when the drive is ready to accept the command. 799 * when the drive is ready to accept the command.
1289 */ 800 */
1290static ide_startstop_t cdrom_start_read_continuation (ide_drive_t *drive) 801static ide_startstop_t cdrom_start_rw_cont(ide_drive_t *drive)
1291{ 802{
1292 struct request *rq = HWGROUP(drive)->rq; 803 struct request *rq = HWGROUP(drive)->rq;
1293 unsigned short sectors_per_frame;
1294 int nskip;
1295 804
1296 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS; 805 if (rq_data_dir(rq) == READ) {
806 unsigned short sectors_per_frame =
807 queue_hardsect_size(drive->queue) >> SECTOR_BITS;
808 int nskip = rq->sector & (sectors_per_frame - 1);
1297 809
1298 /* If the requested sector doesn't start on a cdrom block boundary, 810 /*
1299 we must adjust the start of the transfer so that it does, 811 * If the requested sector doesn't start on a frame boundary,
1300 and remember to skip the first few sectors. 812 * we must adjust the start of the transfer so that it does,
1301 If the CURRENT_NR_SECTORS field is larger than the size 813 * and remember to skip the first few sectors.
1302 of the buffer, it will mean that we're to skip a number 814 *
1303 of sectors equal to the amount by which CURRENT_NR_SECTORS 815 * If the rq->current_nr_sectors field is larger than the size
1304 is larger than the buffer size. */ 816 * of the buffer, it will mean that we're to skip a number of
1305 nskip = rq->sector & (sectors_per_frame - 1); 817 * sectors equal to the amount by which rq->current_nr_sectors
1306 if (nskip > 0) { 818 * is larger than the buffer size.
1307 /* Sanity check... */ 819 */
1308 if (rq->current_nr_sectors != bio_cur_sectors(rq->bio) && 820 if (nskip > 0) {
1309 (rq->sector & (sectors_per_frame - 1))) { 821 /* Sanity check... */
1310 printk(KERN_ERR "%s: cdrom_start_read_continuation: buffer botch (%u)\n", 822 if (rq->current_nr_sectors !=
1311 drive->name, rq->current_nr_sectors); 823 bio_cur_sectors(rq->bio)) {
1312 cdrom_end_request(drive, 0); 824 printk(KERN_ERR "%s: %s: buffer botch (%u)\n",
1313 return ide_stopped; 825 drive->name, __FUNCTION__,
826 rq->current_nr_sectors);
827 cdrom_end_request(drive, 0);
828 return ide_stopped;
829 }
830 rq->current_nr_sectors += nskip;
1314 } 831 }
1315 rq->current_nr_sectors += nskip;
1316 } 832 }
1317 833#if 0
834 else
835 /* the immediate bit */
836 rq->cmd[1] = 1 << 3;
837#endif
1318 /* Set up the command */ 838 /* Set up the command */
1319 rq->timeout = ATAPI_WAIT_PC; 839 rq->timeout = ATAPI_WAIT_PC;
1320 840
1321 /* Send the command to the drive and return. */ 841 /* Send the command to the drive and return. */
1322 return cdrom_transfer_packet_command(drive, rq, &cdrom_read_intr); 842 return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1323} 843}
1324 844
1325
1326#define IDECD_SEEK_THRESHOLD (1000) /* 1000 blocks */ 845#define IDECD_SEEK_THRESHOLD (1000) /* 1000 blocks */
1327#define IDECD_SEEK_TIMER (5 * WAIT_MIN_SLEEP) /* 100 ms */ 846#define IDECD_SEEK_TIMER (5 * WAIT_MIN_SLEEP) /* 100 ms */
1328#define IDECD_SEEK_TIMEOUT (2 * WAIT_CMD) /* 20 sec */ 847#define IDECD_SEEK_TIMEOUT (2 * WAIT_CMD) /* 20 sec */
@@ -1335,7 +854,8 @@ static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
1335 854
1336 if (cdrom_decode_status(drive, 0, &stat)) 855 if (cdrom_decode_status(drive, 0, &stat))
1337 return ide_stopped; 856 return ide_stopped;
1338 CDROM_CONFIG_FLAGS(drive)->seeking = 1; 857
858 info->cd_flags |= IDE_CD_FLAG_SEEKING;
1339 859
1340 if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) { 860 if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
1341 if (--retry == 0) { 861 if (--retry == 0) {
@@ -1391,184 +911,25 @@ static void restore_request (struct request *rq)
1391 rq->q->prep_rq_fn(rq->q, rq); 911 rq->q->prep_rq_fn(rq->q, rq);
1392} 912}
1393 913
1394/*
1395 * Start a read request from the CD-ROM.
1396 */
1397static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block)
1398{
1399 struct cdrom_info *info = drive->driver_data;
1400 struct request *rq = HWGROUP(drive)->rq;
1401 unsigned short sectors_per_frame;
1402
1403 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1404
1405 /* We may be retrying this request after an error. Fix up
1406 any weirdness which might be present in the request packet. */
1407 restore_request(rq);
1408
1409 /* Satisfy whatever we can of this request from our cached sector. */
1410 if (cdrom_read_from_buffer(drive))
1411 return ide_stopped;
1412
1413 /* Clear the local sector buffer. */
1414 info->nsectors_buffered = 0;
1415
1416 /* use dma, if possible. */
1417 info->dma = drive->using_dma;
1418 if ((rq->sector & (sectors_per_frame - 1)) ||
1419 (rq->nr_sectors & (sectors_per_frame - 1)))
1420 info->dma = 0;
1421
1422 /* Start sending the read request to the drive. */
1423 return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
1424}
1425
1426/**************************************************************************** 914/****************************************************************************
1427 * Execute all other packet commands. 915 * Execute all other packet commands.
1428 */ 916 */
1429 917
1430/* Interrupt routine for packet command completion. */ 918static void ide_cd_request_sense_fixup(struct request *rq)
1431static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
1432{ 919{
1433 int ireason, len, thislen; 920 /*
1434 struct request *rq = HWGROUP(drive)->rq; 921 * Some of the trailing request sense fields are optional,
1435 u8 lowcyl = 0, highcyl = 0; 922 * and some drives don't send them. Sigh.
1436 int stat; 923 */
1437 924 if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
1438 /* Check for errors. */ 925 rq->data_len > 0 && rq->data_len <= 5)
1439 if (cdrom_decode_status(drive, 0, &stat)) 926 while (rq->data_len > 0) {
1440 return ide_stopped; 927 *(u8 *)rq->data++ = 0;
1441 928 --rq->data_len;
1442 /* Read the interrupt reason and the transfer length. */
1443 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1444 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1445 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1446
1447 len = lowcyl + (256 * highcyl);
1448
1449 /* If DRQ is clear, the command has completed.
1450 Complain if we still have data left to transfer. */
1451 if ((stat & DRQ_STAT) == 0) {
1452 /* Some of the trailing request sense fields are optional, and
1453 some drives don't send them. Sigh. */
1454 if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
1455 rq->data_len > 0 &&
1456 rq->data_len <= 5) {
1457 while (rq->data_len > 0) {
1458 *(unsigned char *)rq->data++ = 0;
1459 --rq->data_len;
1460 }
1461 }
1462
1463 if (rq->data_len == 0)
1464 cdrom_end_request(drive, 1);
1465 else {
1466 /* Comment this out, because this always happens
1467 right after a reset occurs, and it is annoying to
1468 always print expected stuff. */
1469 /*
1470 printk ("%s: cdrom_pc_intr: data underrun %d\n",
1471 drive->name, pc->buflen);
1472 */
1473 rq->cmd_flags |= REQ_FAILED;
1474 cdrom_end_request(drive, 0);
1475 }
1476 return ide_stopped;
1477 }
1478
1479 /* Figure out how much data to transfer. */
1480 thislen = rq->data_len;
1481 if (thislen > len) thislen = len;
1482
1483 /* The drive wants to be written to. */
1484 if (ireason == 0) {
1485 if (!rq->data) {
1486 blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1487 goto confused;
1488 }
1489 /* Transfer the data. */
1490 HWIF(drive)->atapi_output_bytes(drive, rq->data, thislen);
1491
1492 /* If we haven't moved enough data to satisfy the drive,
1493 add some padding. */
1494 while (len > thislen) {
1495 int dum = 0;
1496 HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof(dum));
1497 len -= sizeof(dum);
1498 }
1499
1500 /* Keep count of how much data we've moved. */
1501 rq->data += thislen;
1502 rq->data_len -= thislen;
1503 }
1504
1505 /* Same drill for reading. */
1506 else if (ireason == 2) {
1507 if (!rq->data) {
1508 blk_dump_rq_flags(rq, "cdrom_pc_intr, read");
1509 goto confused;
1510 }
1511 /* Transfer the data. */
1512 HWIF(drive)->atapi_input_bytes(drive, rq->data, thislen);
1513
1514 /* If we haven't moved enough data to satisfy the drive,
1515 add some padding. */
1516 while (len > thislen) {
1517 int dum = 0;
1518 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1519 len -= sizeof(dum);
1520 } 929 }
1521
1522 /* Keep count of how much data we've moved. */
1523 rq->data += thislen;
1524 rq->data_len -= thislen;
1525
1526 if (blk_sense_request(rq))
1527 rq->sense_len += thislen;
1528 } else {
1529confused:
1530 printk (KERN_ERR "%s: cdrom_pc_intr: The drive "
1531 "appears confused (ireason = 0x%02x). "
1532 "Trying to recover by ending request.\n",
1533 drive->name, ireason);
1534 rq->cmd_flags |= REQ_FAILED;
1535 cdrom_end_request(drive, 0);
1536 return ide_stopped;
1537 }
1538
1539 /* Now we wait for another interrupt. */
1540 ide_set_handler(drive, &cdrom_pc_intr, ATAPI_WAIT_PC, cdrom_timer_expiry);
1541 return ide_started;
1542} 930}
1543 931
1544static ide_startstop_t cdrom_do_pc_continuation (ide_drive_t *drive) 932int ide_cd_queue_pc(ide_drive_t *drive, struct request *rq)
1545{
1546 struct request *rq = HWGROUP(drive)->rq;
1547
1548 if (!rq->timeout)
1549 rq->timeout = ATAPI_WAIT_PC;
1550
1551 /* Send the command to the drive and return. */
1552 return cdrom_transfer_packet_command(drive, rq, &cdrom_pc_intr);
1553}
1554
1555
1556static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
1557{
1558 int len;
1559 struct request *rq = HWGROUP(drive)->rq;
1560 struct cdrom_info *info = drive->driver_data;
1561
1562 info->dma = 0;
1563 rq->cmd_flags &= ~REQ_FAILED;
1564 len = rq->data_len;
1565
1566 /* Start sending the command to the drive. */
1567 return cdrom_start_packet_command(drive, len, cdrom_do_pc_continuation);
1568}
1569
1570
1571static int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
1572{ 933{
1573 struct request_sense sense; 934 struct request_sense sense;
1574 int retries = 10; 935 int retries = 10;
@@ -1617,37 +978,6 @@ static int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
1617} 978}
1618 979
1619/* 980/*
1620 * Write handling
1621 */
1622static int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
1623{
1624 /* Two notes about IDE interrupt reason here - 0 means that
1625 * the drive wants to receive data from us, 2 means that
1626 * the drive is expecting to transfer data to us.
1627 */
1628 if (ireason == 0)
1629 return 0;
1630 else if (ireason == 2) {
1631 /* Whoops... The drive wants to send data. */
1632 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
1633 drive->name, __FUNCTION__);
1634
1635 while (len > 0) {
1636 int dum = 0;
1637 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1638 len -= sizeof(dum);
1639 }
1640 } else {
1641 /* Drive wants a command packet, or invalid ireason... */
1642 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
1643 drive->name, __FUNCTION__, ireason);
1644 }
1645
1646 cdrom_end_request(drive, 0);
1647 return 1;
1648}
1649
1650/*
1651 * Called from blk_end_request_callback() after the data of the request 981 * Called from blk_end_request_callback() after the data of the request
1652 * is completed and before the request is completed. 982 * is completed and before the request is completed.
1653 * By returning value '1', blk_end_request_callback() returns immediately 983 * By returning value '1', blk_end_request_callback() returns immediately
@@ -1658,29 +988,27 @@ static int cdrom_newpc_intr_dummy_cb(struct request *rq)
1658 return 1; 988 return 1;
1659} 989}
1660 990
1661typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
1662
1663/*
1664 * best way to deal with dma that is not sector aligned right now... note
1665 * that in this path we are not using ->data or ->buffer at all. this irs
1666 * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the
1667 * future.
1668 */
1669static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive) 991static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1670{ 992{
1671 struct cdrom_info *info = drive->driver_data; 993 struct cdrom_info *info = drive->driver_data;
1672 struct request *rq = HWGROUP(drive)->rq; 994 struct request *rq = HWGROUP(drive)->rq;
1673 int dma_error, dma, stat, ireason, len, thislen;
1674 u8 lowcyl, highcyl;
1675 xfer_func_t *xferfunc; 995 xfer_func_t *xferfunc;
1676 unsigned long flags; 996 ide_expiry_t *expiry = NULL;
997 int dma_error = 0, dma, stat, ireason, len, thislen, uptodate = 0;
998 int write = (rq_data_dir(rq) == WRITE) ? 1 : 0;
999 unsigned int timeout;
1000 u8 lowcyl, highcyl;
1677 1001
1678 /* Check for errors. */ 1002 /* Check for errors. */
1679 dma_error = 0;
1680 dma = info->dma; 1003 dma = info->dma;
1681 if (dma) { 1004 if (dma) {
1682 info->dma = 0; 1005 info->dma = 0;
1683 dma_error = HWIF(drive)->ide_dma_end(drive); 1006 dma_error = HWIF(drive)->ide_dma_end(drive);
1007 if (dma_error) {
1008 printk(KERN_ERR "%s: DMA %s error\n", drive->name,
1009 write ? "write" : "read");
1010 ide_dma_off(drive);
1011 }
1684 } 1012 }
1685 1013
1686 if (cdrom_decode_status(drive, 0, &stat)) 1014 if (cdrom_decode_status(drive, 0, &stat))
@@ -1690,19 +1018,13 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1690 * using dma, transfer is complete now 1018 * using dma, transfer is complete now
1691 */ 1019 */
1692 if (dma) { 1020 if (dma) {
1693 if (dma_error) { 1021 if (dma_error)
1694 printk(KERN_ERR "ide-cd: dma error\n");
1695 ide_dma_off(drive);
1696 return ide_error(drive, "dma error", stat); 1022 return ide_error(drive, "dma error", stat);
1023 if (blk_fs_request(rq)) {
1024 ide_end_request(drive, 1, rq->nr_sectors);
1025 return ide_stopped;
1697 } 1026 }
1698 1027 goto end_request;
1699 spin_lock_irqsave(&ide_lock, flags);
1700 if (__blk_end_request(rq, 0, rq->data_len))
1701 BUG();
1702 HWGROUP(drive)->rq = NULL;
1703 spin_unlock_irqrestore(&ide_lock, flags);
1704
1705 return ide_stopped;
1706 } 1028 }
1707 1029
1708 /* 1030 /*
@@ -1713,7 +1035,8 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1713 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG); 1035 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1714 1036
1715 len = lowcyl + (256 * highcyl); 1037 len = lowcyl + (256 * highcyl);
1716 thislen = rq->data_len; 1038
1039 thislen = blk_fs_request(rq) ? len : rq->data_len;
1717 if (thislen > len) 1040 if (thislen > len)
1718 thislen = len; 1041 thislen = len;
1719 1042
@@ -1721,53 +1044,111 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1721 * If DRQ is clear, the command has completed. 1044 * If DRQ is clear, the command has completed.
1722 */ 1045 */
1723 if ((stat & DRQ_STAT) == 0) { 1046 if ((stat & DRQ_STAT) == 0) {
1724 spin_lock_irqsave(&ide_lock, flags); 1047 if (blk_fs_request(rq)) {
1725 if (__blk_end_request(rq, 0, rq->data_len)) 1048 /*
1726 BUG(); 1049 * If we're not done reading/writing, complain.
1727 HWGROUP(drive)->rq = NULL; 1050 * Otherwise, complete the command normally.
1728 spin_unlock_irqrestore(&ide_lock, flags); 1051 */
1729 1052 uptodate = 1;
1730 return ide_stopped; 1053 if (rq->current_nr_sectors > 0) {
1054 printk(KERN_ERR "%s: %s: data underrun "
1055 "(%d blocks)\n",
1056 drive->name, __FUNCTION__,
1057 rq->current_nr_sectors);
1058 if (!write)
1059 rq->cmd_flags |= REQ_FAILED;
1060 uptodate = 0;
1061 }
1062 cdrom_end_request(drive, uptodate);
1063 return ide_stopped;
1064 } else if (!blk_pc_request(rq)) {
1065 ide_cd_request_sense_fixup(rq);
1066 /* Complain if we still have data left to transfer. */
1067 uptodate = rq->data_len ? 0 : 1;
1068 }
1069 goto end_request;
1731 } 1070 }
1732 1071
1733 /* 1072 /*
1734 * check which way to transfer data 1073 * check which way to transfer data
1735 */ 1074 */
1736 if (rq_data_dir(rq) == WRITE) { 1075 if (blk_fs_request(rq) || blk_pc_request(rq)) {
1737 /* 1076 if (ide_cd_check_ireason(drive, len, ireason, write))
1738 * write to drive
1739 */
1740 if (cdrom_write_check_ireason(drive, len, ireason))
1741 return ide_stopped; 1077 return ide_stopped;
1742 1078
1743 xferfunc = HWIF(drive)->atapi_output_bytes; 1079 if (blk_fs_request(rq) && write == 0) {
1744 } else { 1080 int nskip;
1745 /*
1746 * read from drive
1747 */
1748 if (cdrom_read_check_ireason(drive, len, ireason))
1749 return ide_stopped;
1750 1081
1082 if (ide_cd_check_transfer_size(drive, len)) {
1083 cdrom_end_request(drive, 0);
1084 return ide_stopped;
1085 }
1086
1087 /*
1088 * First, figure out if we need to bit-bucket
1089 * any of the leading sectors.
1090 */
1091 nskip = min_t(int, rq->current_nr_sectors
1092 - bio_cur_sectors(rq->bio),
1093 thislen >> 9);
1094 if (nskip > 0) {
1095 ide_cd_drain_data(drive, nskip);
1096 rq->current_nr_sectors -= nskip;
1097 thislen -= (nskip << 9);
1098 }
1099 }
1100 }
1101
1102 if (ireason == 0) {
1103 write = 1;
1104 xferfunc = HWIF(drive)->atapi_output_bytes;
1105 } else if (ireason == 2 || (ireason == 1 &&
1106 (blk_fs_request(rq) || blk_pc_request(rq)))) {
1107 write = 0;
1751 xferfunc = HWIF(drive)->atapi_input_bytes; 1108 xferfunc = HWIF(drive)->atapi_input_bytes;
1109 } else {
1110 printk(KERN_ERR "%s: %s: The drive "
1111 "appears confused (ireason = 0x%02x). "
1112 "Trying to recover by ending request.\n",
1113 drive->name, __FUNCTION__, ireason);
1114 goto end_request;
1752 } 1115 }
1753 1116
1754 /* 1117 /*
1755 * transfer data 1118 * transfer data
1756 */ 1119 */
1757 while (thislen > 0) { 1120 while (thislen > 0) {
1758 int blen = blen = rq->data_len; 1121 u8 *ptr = blk_fs_request(rq) ? NULL : rq->data;
1759 char *ptr = rq->data; 1122 int blen = rq->data_len;
1760 1123
1761 /* 1124 /*
1762 * bio backed? 1125 * bio backed?
1763 */ 1126 */
1764 if (rq->bio) { 1127 if (rq->bio) {
1765 ptr = bio_data(rq->bio); 1128 if (blk_fs_request(rq)) {
1766 blen = bio_iovec(rq->bio)->bv_len; 1129 ptr = rq->buffer;
1130 blen = rq->current_nr_sectors << 9;
1131 } else {
1132 ptr = bio_data(rq->bio);
1133 blen = bio_iovec(rq->bio)->bv_len;
1134 }
1767 } 1135 }
1768 1136
1769 if (!ptr) { 1137 if (!ptr) {
1770 printk(KERN_ERR "%s: confused, missing data\n", drive->name); 1138 if (blk_fs_request(rq) && !write)
1139 /*
1140 * If the buffers are full, cache the rest
1141 * of the data in our internal buffer.
1142 */
1143 cdrom_buffer_sectors(drive, rq->sector,
1144 thislen >> 9);
1145 else {
1146 printk(KERN_ERR "%s: confused, missing data\n",
1147 drive->name);
1148 blk_dump_rq_flags(rq, rq_data_dir(rq)
1149 ? "cdrom_newpc_intr, write"
1150 : "cdrom_newpc_intr, read");
1151 }
1771 break; 1152 break;
1772 } 1153 }
1773 1154
@@ -1778,185 +1159,117 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1778 1159
1779 thislen -= blen; 1160 thislen -= blen;
1780 len -= blen; 1161 len -= blen;
1781 rq->data_len -= blen;
1782 1162
1783 if (rq->bio) 1163 if (blk_fs_request(rq)) {
1164 rq->buffer += blen;
1165 rq->nr_sectors -= (blen >> 9);
1166 rq->current_nr_sectors -= (blen >> 9);
1167 rq->sector += (blen >> 9);
1168
1169 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1170 cdrom_end_request(drive, 1);
1171 } else {
1172 rq->data_len -= blen;
1173
1784 /* 1174 /*
1785 * The request can't be completed until DRQ is cleared. 1175 * The request can't be completed until DRQ is cleared.
1786 * So complete the data, but don't complete the request 1176 * So complete the data, but don't complete the request
1787 * using the dummy function for the callback feature 1177 * using the dummy function for the callback feature
1788 * of blk_end_request_callback(). 1178 * of blk_end_request_callback().
1789 */ 1179 */
1790 blk_end_request_callback(rq, 0, blen, 1180 if (rq->bio)
1181 blk_end_request_callback(rq, 0, blen,
1791 cdrom_newpc_intr_dummy_cb); 1182 cdrom_newpc_intr_dummy_cb);
1792 else 1183 else
1793 rq->data += blen; 1184 rq->data += blen;
1794 }
1795
1796 /*
1797 * pad, if necessary
1798 */
1799 if (len > 0) {
1800 while (len > 0) {
1801 int pad = 0;
1802
1803 xferfunc(drive, &pad, sizeof(pad));
1804 len -= sizeof(pad);
1805 }
1806 }
1807
1808 BUG_ON(HWGROUP(drive)->handler != NULL);
1809
1810 ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, NULL);
1811 return ide_started;
1812}
1813
1814static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
1815{
1816 int stat, ireason, len, sectors_to_transfer, uptodate;
1817 struct cdrom_info *info = drive->driver_data;
1818 int dma_error = 0, dma = info->dma;
1819 u8 lowcyl = 0, highcyl = 0;
1820
1821 struct request *rq = HWGROUP(drive)->rq;
1822
1823 /* Check for errors. */
1824 if (dma) {
1825 info->dma = 0;
1826 dma_error = HWIF(drive)->ide_dma_end(drive);
1827 if (dma_error) {
1828 printk(KERN_ERR "%s: DMA write error\n", drive->name);
1829 ide_dma_off(drive);
1830 } 1185 }
1831 } 1186 }
1832 1187
1833 if (cdrom_decode_status(drive, 0, &stat)) 1188 if (write && blk_sense_request(rq))
1834 return ide_stopped; 1189 rq->sense_len += thislen;
1835 1190
1836 /* 1191 /*
1837 * using dma, transfer is complete now 1192 * pad, if necessary
1838 */ 1193 */
1839 if (dma) { 1194 if (!blk_fs_request(rq) && len > 0)
1840 if (dma_error) 1195 ide_cd_pad_transfer(drive, xferfunc, len);
1841 return ide_error(drive, "dma error", stat);
1842 1196
1843 ide_end_request(drive, 1, rq->nr_sectors); 1197 if (blk_pc_request(rq)) {
1844 return ide_stopped; 1198 timeout = rq->timeout;
1199 } else {
1200 timeout = ATAPI_WAIT_PC;
1201 if (!blk_fs_request(rq))
1202 expiry = cdrom_timer_expiry;
1845 } 1203 }
1846 1204
1847 /* Read the interrupt reason and the transfer length. */ 1205 ide_set_handler(drive, cdrom_newpc_intr, timeout, expiry);
1848 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3; 1206 return ide_started;
1849 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1850 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1851 1207
1852 len = lowcyl + (256 * highcyl); 1208end_request:
1209 if (blk_pc_request(rq)) {
1210 unsigned long flags;
1853 1211
1854 /* If DRQ is clear, the command has completed. */ 1212 spin_lock_irqsave(&ide_lock, flags);
1855 if ((stat & DRQ_STAT) == 0) { 1213 if (__blk_end_request(rq, 0, rq->data_len))
1856 /* If we're not done writing, complain. 1214 BUG();
1857 * Otherwise, complete the command normally. 1215 HWGROUP(drive)->rq = NULL;
1858 */ 1216 spin_unlock_irqrestore(&ide_lock, flags);
1859 uptodate = 1; 1217 } else {
1860 if (rq->current_nr_sectors > 0) { 1218 if (!uptodate)
1861 printk(KERN_ERR "%s: %s: data underrun (%d blocks)\n", 1219 rq->cmd_flags |= REQ_FAILED;
1862 drive->name, __FUNCTION__,
1863 rq->current_nr_sectors);
1864 uptodate = 0;
1865 }
1866 cdrom_end_request(drive, uptodate); 1220 cdrom_end_request(drive, uptodate);
1867 return ide_stopped;
1868 } 1221 }
1222 return ide_stopped;
1223}
1869 1224
1870 /* Check that the drive is expecting to do the same thing we are. */ 1225static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq)
1871 if (cdrom_write_check_ireason(drive, len, ireason)) 1226{
1872 return ide_stopped; 1227 struct cdrom_info *cd = drive->driver_data;
1873 1228 int write = rq_data_dir(rq) == WRITE;
1874 sectors_to_transfer = len / SECTOR_SIZE; 1229 unsigned short sectors_per_frame =
1875 1230 queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1876 /*
1877 * now loop and write out the data
1878 */
1879 while (sectors_to_transfer > 0) {
1880 int this_transfer;
1881
1882 if (!rq->current_nr_sectors) {
1883 printk(KERN_ERR "%s: %s: confused, missing data\n",
1884 drive->name, __FUNCTION__);
1885 break;
1886 }
1887 1231
1232 if (write) {
1888 /* 1233 /*
1889 * Figure out how many sectors we can transfer 1234 * disk has become write protected
1890 */ 1235 */
1891 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors); 1236 if (cd->disk->policy) {
1892 1237 cdrom_end_request(drive, 0);
1893 while (this_transfer > 0) { 1238 return ide_stopped;
1894 HWIF(drive)->atapi_output_bytes(drive, rq->buffer, SECTOR_SIZE);
1895 rq->buffer += SECTOR_SIZE;
1896 --rq->nr_sectors;
1897 --rq->current_nr_sectors;
1898 ++rq->sector;
1899 --this_transfer;
1900 --sectors_to_transfer;
1901 } 1239 }
1902 1240 } else {
1903 /* 1241 /*
1904 * current buffer complete, move on 1242 * We may be retrying this request after an error. Fix up any
1243 * weirdness which might be present in the request packet.
1905 */ 1244 */
1906 if (rq->current_nr_sectors == 0 && rq->nr_sectors) 1245 restore_request(rq);
1907 cdrom_end_request(drive, 1);
1908 }
1909
1910 /* re-arm handler */
1911 ide_set_handler(drive, &cdrom_write_intr, ATAPI_WAIT_PC, NULL);
1912 return ide_started;
1913}
1914
1915static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
1916{
1917 struct request *rq = HWGROUP(drive)->rq;
1918 1246
1919#if 0 /* the immediate bit */ 1247 /* Satisfy whatever we can of this request from our cache. */
1920 rq->cmd[1] = 1 << 3; 1248 if (cdrom_read_from_buffer(drive))
1921#endif 1249 return ide_stopped;
1922 rq->timeout = ATAPI_WAIT_PC; 1250 }
1923
1924 return cdrom_transfer_packet_command(drive, rq, cdrom_write_intr);
1925}
1926
1927static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
1928{
1929 struct cdrom_info *info = drive->driver_data;
1930 struct gendisk *g = info->disk;
1931 unsigned short sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1932 1251
1933 /* 1252 /*
1934 * writes *must* be hardware frame aligned 1253 * use DMA, if possible / writes *must* be hardware frame aligned
1935 */ 1254 */
1936 if ((rq->nr_sectors & (sectors_per_frame - 1)) || 1255 if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1937 (rq->sector & (sectors_per_frame - 1))) { 1256 (rq->sector & (sectors_per_frame - 1))) {
1938 cdrom_end_request(drive, 0); 1257 if (write) {
1939 return ide_stopped; 1258 cdrom_end_request(drive, 0);
1940 } 1259 return ide_stopped;
1941 1260 }
1942 /* 1261 cd->dma = 0;
1943 * disk has become write protected 1262 } else
1944 */ 1263 cd->dma = drive->using_dma;
1945 if (g->policy) {
1946 cdrom_end_request(drive, 0);
1947 return ide_stopped;
1948 }
1949
1950 info->nsectors_buffered = 0;
1951 1264
1952 /* use dma, if possible. we don't need to check more, since we 1265 /* Clear the local sector buffer. */
1953 * know that the transfer is always (at least!) frame aligned */ 1266 cd->nsectors_buffered = 0;
1954 info->dma = drive->using_dma ? 1 : 0;
1955 1267
1956 info->devinfo.media_written = 1; 1268 if (write)
1269 cd->devinfo.media_written = 1;
1957 1270
1958 /* Start sending the write request to the drive. */ 1271 /* Start sending the read/write request to the drive. */
1959 return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont); 1272 return cdrom_start_packet_command(drive, 32768, cdrom_start_rw_cont);
1960} 1273}
1961 1274
1962static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive) 1275static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
@@ -1973,7 +1286,10 @@ static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1973{ 1286{
1974 struct cdrom_info *info = drive->driver_data; 1287 struct cdrom_info *info = drive->driver_data;
1975 1288
1976 rq->cmd_flags |= REQ_QUIET; 1289 if (blk_pc_request(rq))
1290 rq->cmd_flags |= REQ_QUIET;
1291 else
1292 rq->cmd_flags &= ~REQ_FAILED;
1977 1293
1978 info->dma = 0; 1294 info->dma = 0;
1979 1295
@@ -2010,7 +1326,7 @@ ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
2010 struct cdrom_info *info = drive->driver_data; 1326 struct cdrom_info *info = drive->driver_data;
2011 1327
2012 if (blk_fs_request(rq)) { 1328 if (blk_fs_request(rq)) {
2013 if (CDROM_CONFIG_FLAGS(drive)->seeking) { 1329 if (info->cd_flags & IDE_CD_FLAG_SEEKING) {
2014 unsigned long elapsed = jiffies - info->start_seek; 1330 unsigned long elapsed = jiffies - info->start_seek;
2015 int stat = HWIF(drive)->INB(IDE_STATUS_REG); 1331 int stat = HWIF(drive)->INB(IDE_STATUS_REG);
2016 1332
@@ -2021,22 +1337,16 @@ ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
2021 } 1337 }
2022 printk (KERN_ERR "%s: DSC timeout\n", drive->name); 1338 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
2023 } 1339 }
2024 CDROM_CONFIG_FLAGS(drive)->seeking = 0; 1340 info->cd_flags &= ~IDE_CD_FLAG_SEEKING;
2025 } 1341 }
2026 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) { 1342 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
2027 action = cdrom_start_seek(drive, block); 1343 action = cdrom_start_seek(drive, block);
2028 } else { 1344 } else
2029 if (rq_data_dir(rq) == READ) 1345 action = cdrom_start_rw(drive, rq);
2030 action = cdrom_start_read(drive, block);
2031 else
2032 action = cdrom_start_write(drive, rq);
2033 }
2034 info->last_block = block; 1346 info->last_block = block;
2035 return action; 1347 return action;
2036 } else if (rq->cmd_type == REQ_TYPE_SENSE || 1348 } else if (blk_sense_request(rq) || blk_pc_request(rq) ||
2037 rq->cmd_type == REQ_TYPE_ATA_PC) { 1349 rq->cmd_type == REQ_TYPE_ATA_PC) {
2038 return cdrom_do_packet_command(drive);
2039 } else if (blk_pc_request(rq)) {
2040 return cdrom_do_block_pc(drive, rq); 1350 return cdrom_do_block_pc(drive, rq);
2041 } else if (blk_special_request(rq)) { 1351 } else if (blk_special_request(rq)) {
2042 /* 1352 /*
@@ -2063,141 +1373,33 @@ ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
2063 * can also be NULL, in which case no sense information is returned. 1373 * can also be NULL, in which case no sense information is returned.
2064 */ 1374 */
2065 1375
2066#if ! STANDARD_ATAPI
2067static inline
2068int bin2bcd (int x)
2069{
2070 return (x%10) | ((x/10) << 4);
2071}
2072
2073
2074static inline
2075int bcd2bin (int x)
2076{
2077 return (x >> 4) * 10 + (x & 0x0f);
2078}
2079
2080static 1376static
2081void msf_from_bcd (struct atapi_msf *msf) 1377void msf_from_bcd (struct atapi_msf *msf)
2082{ 1378{
2083 msf->minute = bcd2bin (msf->minute); 1379 msf->minute = BCD2BIN(msf->minute);
2084 msf->second = bcd2bin (msf->second); 1380 msf->second = BCD2BIN(msf->second);
2085 msf->frame = bcd2bin (msf->frame); 1381 msf->frame = BCD2BIN(msf->frame);
2086}
2087
2088#endif /* not STANDARD_ATAPI */
2089
2090
2091static inline
2092void lba_to_msf (int lba, byte *m, byte *s, byte *f)
2093{
2094 lba += CD_MSF_OFFSET;
2095 lba &= 0xffffff; /* negative lbas use only 24 bits */
2096 *m = lba / (CD_SECS * CD_FRAMES);
2097 lba %= (CD_SECS * CD_FRAMES);
2098 *s = lba / CD_FRAMES;
2099 *f = lba % CD_FRAMES;
2100}
2101
2102
2103static inline
2104int msf_to_lba (byte m, byte s, byte f)
2105{
2106 return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
2107} 1382}
2108 1383
2109static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense) 1384int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
2110{ 1385{
2111 struct request req; 1386 struct request req;
2112 struct cdrom_info *info = drive->driver_data; 1387 struct cdrom_info *info = drive->driver_data;
2113 struct cdrom_device_info *cdi = &info->devinfo; 1388 struct cdrom_device_info *cdi = &info->devinfo;
2114 1389
2115 cdrom_prepare_request(drive, &req); 1390 ide_cd_init_rq(drive, &req);
2116 1391
2117 req.sense = sense; 1392 req.sense = sense;
2118 req.cmd[0] = GPCMD_TEST_UNIT_READY; 1393 req.cmd[0] = GPCMD_TEST_UNIT_READY;
2119 req.cmd_flags |= REQ_QUIET; 1394 req.cmd_flags |= REQ_QUIET;
2120 1395
2121#if ! STANDARD_ATAPI 1396 /*
2122 /* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to 1397 * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
2123 switch CDs instead of supporting the LOAD_UNLOAD opcode */ 1398 * switch CDs instead of supporting the LOAD_UNLOAD opcode.
2124 1399 */
2125 req.cmd[7] = cdi->sanyo_slot % 3; 1400 req.cmd[7] = cdi->sanyo_slot % 3;
2126#endif /* not STANDARD_ATAPI */
2127
2128 return cdrom_queue_packet_command(drive, &req);
2129}
2130
2131
2132/* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
2133static int
2134cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
2135{
2136 struct request_sense my_sense;
2137 struct request req;
2138 int stat;
2139
2140 if (sense == NULL)
2141 sense = &my_sense;
2142
2143 /* If the drive cannot lock the door, just pretend. */
2144 if (CDROM_CONFIG_FLAGS(drive)->no_doorlock) {
2145 stat = 0;
2146 } else {
2147 cdrom_prepare_request(drive, &req);
2148 req.sense = sense;
2149 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
2150 req.cmd[4] = lockflag ? 1 : 0;
2151 stat = cdrom_queue_packet_command(drive, &req);
2152 }
2153
2154 /* If we got an illegal field error, the drive
2155 probably cannot lock the door. */
2156 if (stat != 0 &&
2157 sense->sense_key == ILLEGAL_REQUEST &&
2158 (sense->asc == 0x24 || sense->asc == 0x20)) {
2159 printk (KERN_ERR "%s: door locking not supported\n",
2160 drive->name);
2161 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2162 stat = 0;
2163 }
2164
2165 /* no medium, that's alright. */
2166 if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
2167 stat = 0;
2168
2169 if (stat == 0)
2170 CDROM_STATE_FLAGS(drive)->door_locked = lockflag;
2171
2172 return stat;
2173}
2174 1401
2175 1402 return ide_cd_queue_pc(drive, &req);
2176/* Eject the disk if EJECTFLAG is 0.
2177 If EJECTFLAG is 1, try to reload the disk. */
2178static int cdrom_eject(ide_drive_t *drive, int ejectflag,
2179 struct request_sense *sense)
2180{
2181 struct request req;
2182 char loej = 0x02;
2183
2184 if (CDROM_CONFIG_FLAGS(drive)->no_eject && !ejectflag)
2185 return -EDRIVE_CANT_DO_THIS;
2186
2187 /* reload fails on some drives, if the tray is locked */
2188 if (CDROM_STATE_FLAGS(drive)->door_locked && ejectflag)
2189 return 0;
2190
2191 cdrom_prepare_request(drive, &req);
2192
2193 /* only tell drive to close tray if open, if it can do that */
2194 if (ejectflag && !CDROM_CONFIG_FLAGS(drive)->close_tray)
2195 loej = 0;
2196
2197 req.sense = sense;
2198 req.cmd[0] = GPCMD_START_STOP_UNIT;
2199 req.cmd[4] = loej | (ejectflag != 0);
2200 return cdrom_queue_packet_command(drive, &req);
2201} 1403}
2202 1404
2203static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity, 1405static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
@@ -2212,7 +1414,7 @@ static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
2212 int stat; 1414 int stat;
2213 struct request req; 1415 struct request req;
2214 1416
2215 cdrom_prepare_request(drive, &req); 1417 ide_cd_init_rq(drive, &req);
2216 1418
2217 req.sense = sense; 1419 req.sense = sense;
2218 req.cmd[0] = GPCMD_READ_CDVD_CAPACITY; 1420 req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
@@ -2220,7 +1422,7 @@ static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
2220 req.data_len = sizeof(capbuf); 1422 req.data_len = sizeof(capbuf);
2221 req.cmd_flags |= REQ_QUIET; 1423 req.cmd_flags |= REQ_QUIET;
2222 1424
2223 stat = cdrom_queue_packet_command(drive, &req); 1425 stat = ide_cd_queue_pc(drive, &req);
2224 if (stat == 0) { 1426 if (stat == 0) {
2225 *capacity = 1 + be32_to_cpu(capbuf.lba); 1427 *capacity = 1 + be32_to_cpu(capbuf.lba);
2226 *sectors_per_frame = 1428 *sectors_per_frame =
@@ -2236,7 +1438,7 @@ static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
2236{ 1438{
2237 struct request req; 1439 struct request req;
2238 1440
2239 cdrom_prepare_request(drive, &req); 1441 ide_cd_init_rq(drive, &req);
2240 1442
2241 req.sense = sense; 1443 req.sense = sense;
2242 req.data = buf; 1444 req.data = buf;
@@ -2251,12 +1453,11 @@ static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
2251 if (msf_flag) 1453 if (msf_flag)
2252 req.cmd[1] = 2; 1454 req.cmd[1] = 2;
2253 1455
2254 return cdrom_queue_packet_command(drive, &req); 1456 return ide_cd_queue_pc(drive, &req);
2255} 1457}
2256 1458
2257
2258/* Try to read the entire TOC for the disk into our internal buffer. */ 1459/* Try to read the entire TOC for the disk into our internal buffer. */
2259static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense) 1460int ide_cd_read_toc(ide_drive_t *drive, struct request_sense *sense)
2260{ 1461{
2261 int stat, ntracks, i; 1462 int stat, ntracks, i;
2262 struct cdrom_info *info = drive->driver_data; 1463 struct cdrom_info *info = drive->driver_data;
@@ -2283,7 +1484,7 @@ static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2283 If it is, just return. */ 1484 If it is, just return. */
2284 (void) cdrom_check_status(drive, sense); 1485 (void) cdrom_check_status(drive, sense);
2285 1486
2286 if (CDROM_STATE_FLAGS(drive)->toc_valid) 1487 if (info->cd_flags & IDE_CD_FLAG_TOC_VALID)
2287 return 0; 1488 return 0;
2288 1489
2289 /* Try to get the total cdrom capacity and sector size. */ 1490 /* Try to get the total cdrom capacity and sector size. */
@@ -2305,12 +1506,10 @@ static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2305 if (stat) 1506 if (stat)
2306 return stat; 1507 return stat;
2307 1508
2308#if ! STANDARD_ATAPI 1509 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
2309 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) { 1510 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
2310 toc->hdr.first_track = bcd2bin(toc->hdr.first_track); 1511 toc->hdr.last_track = BCD2BIN(toc->hdr.last_track);
2311 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2312 } 1512 }
2313#endif /* not STANDARD_ATAPI */
2314 1513
2315 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1; 1514 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2316 if (ntracks <= 0) 1515 if (ntracks <= 0)
@@ -2342,16 +1541,13 @@ static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2342 (ntracks + 1) * 1541 (ntracks + 1) *
2343 sizeof(struct atapi_toc_entry), 1542 sizeof(struct atapi_toc_entry),
2344 sense); 1543 sense);
2345 if (stat) { 1544 if (stat)
2346 return stat; 1545 return stat;
2347 } 1546
2348#if ! STANDARD_ATAPI 1547 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
2349 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) { 1548 toc->hdr.first_track = (u8)BIN2BCD(CDROM_LEADOUT);
2350 toc->hdr.first_track = bin2bcd(CDROM_LEADOUT); 1549 toc->hdr.last_track = (u8)BIN2BCD(CDROM_LEADOUT);
2351 toc->hdr.last_track = bin2bcd(CDROM_LEADOUT); 1550 } else {
2352 } else
2353#endif /* not STANDARD_ATAPI */
2354 {
2355 toc->hdr.first_track = CDROM_LEADOUT; 1551 toc->hdr.first_track = CDROM_LEADOUT;
2356 toc->hdr.last_track = CDROM_LEADOUT; 1552 toc->hdr.last_track = CDROM_LEADOUT;
2357 } 1553 }
@@ -2362,21 +1558,17 @@ static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2362 1558
2363 toc->hdr.toc_length = ntohs (toc->hdr.toc_length); 1559 toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
2364 1560
2365#if ! STANDARD_ATAPI 1561 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
2366 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) { 1562 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
2367 toc->hdr.first_track = bcd2bin(toc->hdr.first_track); 1563 toc->hdr.last_track = BCD2BIN(toc->hdr.last_track);
2368 toc->hdr.last_track = bcd2bin(toc->hdr.last_track);
2369 } 1564 }
2370#endif /* not STANDARD_ATAPI */
2371 1565
2372 for (i=0; i<=ntracks; i++) { 1566 for (i = 0; i <= ntracks; i++) {
2373#if ! STANDARD_ATAPI 1567 if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
2374 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) { 1568 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD)
2375 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) 1569 toc->ent[i].track = BCD2BIN(toc->ent[i].track);
2376 toc->ent[i].track = bcd2bin(toc->ent[i].track);
2377 msf_from_bcd(&toc->ent[i].addr.msf); 1570 msf_from_bcd(&toc->ent[i].addr.msf);
2378 } 1571 }
2379#endif /* not STANDARD_ATAPI */
2380 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute, 1572 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
2381 toc->ent[i].addr.msf.second, 1573 toc->ent[i].addr.msf.second,
2382 toc->ent[i].addr.msf.frame); 1574 toc->ent[i].addr.msf.frame);
@@ -2396,8 +1588,7 @@ static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2396 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */ 1588 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
2397 } 1589 }
2398 1590
2399#if ! STANDARD_ATAPI 1591 if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
2400 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2401 /* Re-read multisession information using MSF format */ 1592 /* Re-read multisession information using MSF format */
2402 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp, 1593 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
2403 sizeof(ms_tmp), sense); 1594 sizeof(ms_tmp), sense);
@@ -2409,7 +1600,6 @@ static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2409 ms_tmp.ent.addr.msf.second, 1600 ms_tmp.ent.addr.msf.second,
2410 ms_tmp.ent.addr.msf.frame); 1601 ms_tmp.ent.addr.msf.frame);
2411 } 1602 }
2412#endif /* not STANDARD_ATAPI */
2413 1603
2414 toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track); 1604 toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
2415 1605
@@ -2422,278 +1612,22 @@ static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2422 } 1612 }
2423 1613
2424 /* Remember that we've read this stuff. */ 1614 /* Remember that we've read this stuff. */
2425 CDROM_STATE_FLAGS(drive)->toc_valid = 1; 1615 info->cd_flags |= IDE_CD_FLAG_TOC_VALID;
2426 1616
2427 return 0; 1617 return 0;
2428} 1618}
2429 1619
2430 1620int ide_cdrom_get_capabilities(ide_drive_t *drive, u8 *buf)
2431static int cdrom_read_subchannel(ide_drive_t *drive, int format, char *buf,
2432 int buflen, struct request_sense *sense)
2433{
2434 struct request req;
2435
2436 cdrom_prepare_request(drive, &req);
2437
2438 req.sense = sense;
2439 req.data = buf;
2440 req.data_len = buflen;
2441 req.cmd[0] = GPCMD_READ_SUBCHANNEL;
2442 req.cmd[1] = 2; /* MSF addressing */
2443 req.cmd[2] = 0x40; /* request subQ data */
2444 req.cmd[3] = format;
2445 req.cmd[7] = (buflen >> 8);
2446 req.cmd[8] = (buflen & 0xff);
2447 return cdrom_queue_packet_command(drive, &req);
2448}
2449
2450/* ATAPI cdrom drives are free to select the speed you request or any slower
2451 rate :-( Requesting too fast a speed will _not_ produce an error. */
2452static int cdrom_select_speed(ide_drive_t *drive, int speed,
2453 struct request_sense *sense)
2454{
2455 struct request req;
2456 cdrom_prepare_request(drive, &req);
2457
2458 req.sense = sense;
2459 if (speed == 0)
2460 speed = 0xffff; /* set to max */
2461 else
2462 speed *= 177; /* Nx to kbytes/s */
2463
2464 req.cmd[0] = GPCMD_SET_SPEED;
2465 /* Read Drive speed in kbytes/second MSB */
2466 req.cmd[2] = (speed >> 8) & 0xff;
2467 /* Read Drive speed in kbytes/second LSB */
2468 req.cmd[3] = speed & 0xff;
2469 if (CDROM_CONFIG_FLAGS(drive)->cd_r ||
2470 CDROM_CONFIG_FLAGS(drive)->cd_rw ||
2471 CDROM_CONFIG_FLAGS(drive)->dvd_r) {
2472 /* Write Drive speed in kbytes/second MSB */
2473 req.cmd[4] = (speed >> 8) & 0xff;
2474 /* Write Drive speed in kbytes/second LSB */
2475 req.cmd[5] = speed & 0xff;
2476 }
2477
2478 return cdrom_queue_packet_command(drive, &req);
2479}
2480
2481static int cdrom_play_audio(ide_drive_t *drive, int lba_start, int lba_end)
2482{
2483 struct request_sense sense;
2484 struct request req;
2485
2486 cdrom_prepare_request(drive, &req);
2487
2488 req.sense = &sense;
2489 req.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2490 lba_to_msf(lba_start, &req.cmd[3], &req.cmd[4], &req.cmd[5]);
2491 lba_to_msf(lba_end-1, &req.cmd[6], &req.cmd[7], &req.cmd[8]);
2492
2493 return cdrom_queue_packet_command(drive, &req);
2494}
2495
2496static int cdrom_get_toc_entry(ide_drive_t *drive, int track,
2497 struct atapi_toc_entry **ent)
2498{
2499 struct cdrom_info *info = drive->driver_data;
2500 struct atapi_toc *toc = info->toc;
2501 int ntracks;
2502
2503 /*
2504 * don't serve cached data, if the toc isn't valid
2505 */
2506 if (!CDROM_STATE_FLAGS(drive)->toc_valid)
2507 return -EINVAL;
2508
2509 /* Check validity of requested track number. */
2510 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2511 if (toc->hdr.first_track == CDROM_LEADOUT) ntracks = 0;
2512 if (track == CDROM_LEADOUT)
2513 *ent = &toc->ent[ntracks];
2514 else if (track < toc->hdr.first_track ||
2515 track > toc->hdr.last_track)
2516 return -EINVAL;
2517 else
2518 *ent = &toc->ent[track - toc->hdr.first_track];
2519
2520 return 0;
2521}
2522
2523/* the generic packet interface to cdrom.c */
2524static int ide_cdrom_packet(struct cdrom_device_info *cdi,
2525 struct packet_command *cgc)
2526{
2527 struct request req;
2528 ide_drive_t *drive = cdi->handle;
2529
2530 if (cgc->timeout <= 0)
2531 cgc->timeout = ATAPI_WAIT_PC;
2532
2533 /* here we queue the commands from the uniform CD-ROM
2534 layer. the packet must be complete, as we do not
2535 touch it at all. */
2536 cdrom_prepare_request(drive, &req);
2537 memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
2538 if (cgc->sense)
2539 memset(cgc->sense, 0, sizeof(struct request_sense));
2540 req.data = cgc->buffer;
2541 req.data_len = cgc->buflen;
2542 req.timeout = cgc->timeout;
2543
2544 if (cgc->quiet)
2545 req.cmd_flags |= REQ_QUIET;
2546
2547 req.sense = cgc->sense;
2548 cgc->stat = cdrom_queue_packet_command(drive, &req);
2549 if (!cgc->stat)
2550 cgc->buflen -= req.data_len;
2551 return cgc->stat;
2552}
2553
2554static
2555int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
2556 unsigned int cmd, void *arg)
2557
2558{
2559 ide_drive_t *drive = cdi->handle;
2560 struct cdrom_info *info = drive->driver_data;
2561 int stat;
2562
2563 switch (cmd) {
2564 /*
2565 * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
2566 * atapi doesn't support it
2567 */
2568 case CDROMPLAYTRKIND: {
2569 unsigned long lba_start, lba_end;
2570 struct cdrom_ti *ti = arg;
2571 struct atapi_toc_entry *first_toc, *last_toc;
2572
2573 stat = cdrom_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
2574 if (stat)
2575 return stat;
2576
2577 stat = cdrom_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
2578 if (stat)
2579 return stat;
2580
2581 if (ti->cdti_trk1 != CDROM_LEADOUT)
2582 ++last_toc;
2583 lba_start = first_toc->addr.lba;
2584 lba_end = last_toc->addr.lba;
2585
2586 if (lba_end <= lba_start)
2587 return -EINVAL;
2588
2589 return cdrom_play_audio(drive, lba_start, lba_end);
2590 }
2591
2592 case CDROMREADTOCHDR: {
2593 struct cdrom_tochdr *tochdr = arg;
2594 struct atapi_toc *toc;
2595
2596 /* Make sure our saved TOC is valid. */
2597 stat = cdrom_read_toc(drive, NULL);
2598 if (stat)
2599 return stat;
2600
2601 toc = info->toc;
2602 tochdr->cdth_trk0 = toc->hdr.first_track;
2603 tochdr->cdth_trk1 = toc->hdr.last_track;
2604
2605 return 0;
2606 }
2607
2608 case CDROMREADTOCENTRY: {
2609 struct cdrom_tocentry *tocentry = arg;
2610 struct atapi_toc_entry *toce;
2611
2612 stat = cdrom_get_toc_entry(drive, tocentry->cdte_track, &toce);
2613 if (stat)
2614 return stat;
2615
2616 tocentry->cdte_ctrl = toce->control;
2617 tocentry->cdte_adr = toce->adr;
2618 if (tocentry->cdte_format == CDROM_MSF) {
2619 lba_to_msf (toce->addr.lba,
2620 &tocentry->cdte_addr.msf.minute,
2621 &tocentry->cdte_addr.msf.second,
2622 &tocentry->cdte_addr.msf.frame);
2623 } else
2624 tocentry->cdte_addr.lba = toce->addr.lba;
2625
2626 return 0;
2627 }
2628
2629 default:
2630 return -EINVAL;
2631 }
2632}
2633
2634static
2635int ide_cdrom_reset (struct cdrom_device_info *cdi)
2636{
2637 ide_drive_t *drive = cdi->handle;
2638 struct request_sense sense;
2639 struct request req;
2640 int ret;
2641
2642 cdrom_prepare_request(drive, &req);
2643 req.cmd_type = REQ_TYPE_SPECIAL;
2644 req.cmd_flags = REQ_QUIET;
2645 ret = ide_do_drive_cmd(drive, &req, ide_wait);
2646
2647 /*
2648 * A reset will unlock the door. If it was previously locked,
2649 * lock it again.
2650 */
2651 if (CDROM_STATE_FLAGS(drive)->door_locked)
2652 (void) cdrom_lockdoor(drive, 1, &sense);
2653
2654 return ret;
2655}
2656
2657
2658static
2659int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
2660{
2661 ide_drive_t *drive = cdi->handle;
2662 struct request_sense sense;
2663
2664 if (position) {
2665 int stat = cdrom_lockdoor(drive, 0, &sense);
2666 if (stat)
2667 return stat;
2668 }
2669
2670 return cdrom_eject(drive, !position, &sense);
2671}
2672
2673static
2674int ide_cdrom_lock_door (struct cdrom_device_info *cdi, int lock)
2675{
2676 ide_drive_t *drive = cdi->handle;
2677 return cdrom_lockdoor(drive, lock, NULL);
2678}
2679
2680static
2681int ide_cdrom_get_capabilities(ide_drive_t *drive, struct atapi_capabilities_page *cap)
2682{ 1621{
2683 struct cdrom_info *info = drive->driver_data; 1622 struct cdrom_info *info = drive->driver_data;
2684 struct cdrom_device_info *cdi = &info->devinfo; 1623 struct cdrom_device_info *cdi = &info->devinfo;
2685 struct packet_command cgc; 1624 struct packet_command cgc;
2686 int stat, attempts = 3, size = sizeof(*cap); 1625 int stat, attempts = 3, size = ATAPI_CAPABILITIES_PAGE_SIZE;
2687 1626
2688 /* 1627 if ((info->cd_flags & IDE_CD_FLAG_FULL_CAPS_PAGE) == 0)
2689 * ACER50 (and others?) require the full spec length mode sense 1628 size -= ATAPI_CAPABILITIES_PAGE_PAD_SIZE;
2690 * page capabilities size, but older drives break.
2691 */
2692 if (!(!strcmp(drive->id->model, "ATAPI CD ROM DRIVE 50X MAX") ||
2693 !strcmp(drive->id->model, "WPI CDS-32X")))
2694 size -= sizeof(cap->pad);
2695 1629
2696 init_cdrom_command(&cgc, cap, size, CGC_DATA_UNKNOWN); 1630 init_cdrom_command(&cgc, buf, size, CGC_DATA_UNKNOWN);
2697 do { /* we seem to get stat=0x01,err=0x00 the first time (??) */ 1631 do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2698 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0); 1632 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
2699 if (!stat) 1633 if (!stat)
@@ -2702,177 +1636,33 @@ int ide_cdrom_get_capabilities(ide_drive_t *drive, struct atapi_capabilities_pag
2702 return stat; 1636 return stat;
2703} 1637}
2704 1638
2705static 1639void ide_cdrom_update_speed(ide_drive_t *drive, u8 *buf)
2706void ide_cdrom_update_speed (ide_drive_t *drive, struct atapi_capabilities_page *cap)
2707{
2708 /* The ACER/AOpen 24X cdrom has the speed fields byte-swapped */
2709 if (!drive->id->model[0] &&
2710 !strncmp(drive->id->fw_rev, "241N", 4)) {
2711 CDROM_STATE_FLAGS(drive)->current_speed =
2712 (le16_to_cpu(cap->curspeed) + (176/2)) / 176;
2713 CDROM_CONFIG_FLAGS(drive)->max_speed =
2714 (le16_to_cpu(cap->maxspeed) + (176/2)) / 176;
2715 } else {
2716 CDROM_STATE_FLAGS(drive)->current_speed =
2717 (be16_to_cpu(cap->curspeed) + (176/2)) / 176;
2718 CDROM_CONFIG_FLAGS(drive)->max_speed =
2719 (be16_to_cpu(cap->maxspeed) + (176/2)) / 176;
2720 }
2721}
2722
2723static
2724int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
2725{
2726 ide_drive_t *drive = cdi->handle;
2727 struct request_sense sense;
2728 struct atapi_capabilities_page cap;
2729 int stat;
2730
2731 if ((stat = cdrom_select_speed(drive, speed, &sense)) < 0)
2732 return stat;
2733
2734 if (!ide_cdrom_get_capabilities(drive, &cap)) {
2735 ide_cdrom_update_speed(drive, &cap);
2736 cdi->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2737 }
2738 return 0;
2739}
2740
2741/*
2742 * add logic to try GET_EVENT command first to check for media and tray
2743 * status. this should be supported by newer cd-r/w and all DVD etc
2744 * drives
2745 */
2746static
2747int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
2748{
2749 ide_drive_t *drive = cdi->handle;
2750 struct media_event_desc med;
2751 struct request_sense sense;
2752 int stat;
2753
2754 if (slot_nr != CDSL_CURRENT)
2755 return -EINVAL;
2756
2757 stat = cdrom_check_status(drive, &sense);
2758 if (!stat || sense.sense_key == UNIT_ATTENTION)
2759 return CDS_DISC_OK;
2760
2761 if (!cdrom_get_media_event(cdi, &med)) {
2762 if (med.media_present)
2763 return CDS_DISC_OK;
2764 else if (med.door_open)
2765 return CDS_TRAY_OPEN;
2766 else
2767 return CDS_NO_DISC;
2768 }
2769
2770 if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
2771 return CDS_DISC_OK;
2772
2773 /*
2774 * If not using Mt Fuji extended media tray reports,
2775 * just return TRAY_OPEN since ATAPI doesn't provide
2776 * any other way to detect this...
2777 */
2778 if (sense.sense_key == NOT_READY) {
2779 if (sense.asc == 0x3a && sense.ascq == 1)
2780 return CDS_NO_DISC;
2781 else
2782 return CDS_TRAY_OPEN;
2783 }
2784 return CDS_DRIVE_NOT_READY;
2785}
2786
2787static
2788int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
2789 struct cdrom_multisession *ms_info)
2790{ 1640{
2791 struct atapi_toc *toc; 1641 struct cdrom_info *cd = drive->driver_data;
2792 ide_drive_t *drive = cdi->handle; 1642 u16 curspeed, maxspeed;
2793 struct cdrom_info *info = drive->driver_data;
2794 struct request_sense sense;
2795 int ret;
2796
2797 if (!CDROM_STATE_FLAGS(drive)->toc_valid || info->toc == NULL)
2798 if ((ret = cdrom_read_toc(drive, &sense)))
2799 return ret;
2800
2801 toc = info->toc;
2802 ms_info->addr.lba = toc->last_session_lba;
2803 ms_info->xa_flag = toc->xa_flag;
2804
2805 return 0;
2806}
2807
2808static
2809int ide_cdrom_get_mcn (struct cdrom_device_info *cdi,
2810 struct cdrom_mcn *mcn_info)
2811{
2812 int stat;
2813 char mcnbuf[24];
2814 ide_drive_t *drive = cdi->handle;
2815
2816/* get MCN */
2817 if ((stat = cdrom_read_subchannel(drive, 2, mcnbuf, sizeof (mcnbuf), NULL)))
2818 return stat;
2819
2820 memcpy (mcn_info->medium_catalog_number, mcnbuf+9,
2821 sizeof (mcn_info->medium_catalog_number)-1);
2822 mcn_info->medium_catalog_number[sizeof (mcn_info->medium_catalog_number)-1]
2823 = '\0';
2824
2825 return 0;
2826}
2827
2828
2829 1643
2830/**************************************************************************** 1644 curspeed = *(u16 *)&buf[8 + 14];
2831 * Other driver requests (open, close, check media change). 1645 maxspeed = *(u16 *)&buf[8 + 8];
2832 */
2833 1646
2834static 1647 if (cd->cd_flags & IDE_CD_FLAG_LE_SPEED_FIELDS) {
2835int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi, 1648 curspeed = le16_to_cpu(curspeed);
2836 int slot_nr) 1649 maxspeed = le16_to_cpu(maxspeed);
2837{
2838 ide_drive_t *drive = cdi->handle;
2839 int retval;
2840
2841 if (slot_nr == CDSL_CURRENT) {
2842 (void) cdrom_check_status(drive, NULL);
2843 retval = CDROM_STATE_FLAGS(drive)->media_changed;
2844 CDROM_STATE_FLAGS(drive)->media_changed = 0;
2845 return retval;
2846 } else { 1650 } else {
2847 return -EINVAL; 1651 curspeed = be16_to_cpu(curspeed);
1652 maxspeed = be16_to_cpu(maxspeed);
2848 } 1653 }
2849}
2850
2851 1654
2852static 1655 cd->current_speed = (curspeed + (176/2)) / 176;
2853int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose) 1656 cd->max_speed = (maxspeed + (176/2)) / 176;
2854{
2855 return 0;
2856} 1657}
2857 1658
2858/* 1659#define IDE_CD_CAPABILITIES \
2859 * Close down the device. Invalidate all cached blocks. 1660 (CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | CDC_SELECT_SPEED | \
2860 */ 1661 CDC_SELECT_DISC | CDC_MULTI_SESSION | CDC_MCN | CDC_MEDIA_CHANGED | \
2861 1662 CDC_PLAY_AUDIO | CDC_RESET | CDC_DRIVE_STATUS | CDC_CD_R | \
2862static 1663 CDC_CD_RW | CDC_DVD | CDC_DVD_R | CDC_DVD_RAM | CDC_GENERIC_PACKET | \
2863void ide_cdrom_release_real (struct cdrom_device_info *cdi) 1664 CDC_MO_DRIVE | CDC_MRW | CDC_MRW_W | CDC_RAM)
2864{
2865 ide_drive_t *drive = cdi->handle;
2866
2867 if (!cdi->use_count)
2868 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
2869}
2870 1665
2871
2872
2873/****************************************************************************
2874 * Device initialization.
2875 */
2876static struct cdrom_device_ops ide_cdrom_dops = { 1666static struct cdrom_device_ops ide_cdrom_dops = {
2877 .open = ide_cdrom_open_real, 1667 .open = ide_cdrom_open_real,
2878 .release = ide_cdrom_release_real, 1668 .release = ide_cdrom_release_real,
@@ -2885,14 +1675,7 @@ static struct cdrom_device_ops ide_cdrom_dops = {
2885 .get_mcn = ide_cdrom_get_mcn, 1675 .get_mcn = ide_cdrom_get_mcn,
2886 .reset = ide_cdrom_reset, 1676 .reset = ide_cdrom_reset,
2887 .audio_ioctl = ide_cdrom_audio_ioctl, 1677 .audio_ioctl = ide_cdrom_audio_ioctl,
2888 .capability = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | 1678 .capability = IDE_CD_CAPABILITIES,
2889 CDC_SELECT_SPEED | CDC_SELECT_DISC |
2890 CDC_MULTI_SESSION | CDC_MCN |
2891 CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO | CDC_RESET |
2892 CDC_DRIVE_STATUS | CDC_CD_R |
2893 CDC_CD_RW | CDC_DVD | CDC_DVD_R| CDC_DVD_RAM |
2894 CDC_GENERIC_PACKET | CDC_MO_DRIVE | CDC_MRW |
2895 CDC_MRW_W | CDC_RAM,
2896 .generic_packet = ide_cdrom_packet, 1679 .generic_packet = ide_cdrom_packet,
2897}; 1680};
2898 1681
@@ -2902,35 +1685,12 @@ static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2902 struct cdrom_device_info *devinfo = &info->devinfo; 1685 struct cdrom_device_info *devinfo = &info->devinfo;
2903 1686
2904 devinfo->ops = &ide_cdrom_dops; 1687 devinfo->ops = &ide_cdrom_dops;
2905 devinfo->mask = 0; 1688 devinfo->speed = info->current_speed;
2906 devinfo->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2907 devinfo->capacity = nslots; 1689 devinfo->capacity = nslots;
2908 devinfo->handle = drive; 1690 devinfo->handle = drive;
2909 strcpy(devinfo->name, drive->name); 1691 strcpy(devinfo->name, drive->name);
2910 1692
2911 /* set capability mask to match the probe. */ 1693 if (info->cd_flags & IDE_CD_FLAG_NO_SPEED_SELECT)
2912 if (!CDROM_CONFIG_FLAGS(drive)->cd_r)
2913 devinfo->mask |= CDC_CD_R;
2914 if (!CDROM_CONFIG_FLAGS(drive)->cd_rw)
2915 devinfo->mask |= CDC_CD_RW;
2916 if (!CDROM_CONFIG_FLAGS(drive)->dvd)
2917 devinfo->mask |= CDC_DVD;
2918 if (!CDROM_CONFIG_FLAGS(drive)->dvd_r)
2919 devinfo->mask |= CDC_DVD_R;
2920 if (!CDROM_CONFIG_FLAGS(drive)->dvd_ram)
2921 devinfo->mask |= CDC_DVD_RAM;
2922 if (!CDROM_CONFIG_FLAGS(drive)->is_changer)
2923 devinfo->mask |= CDC_SELECT_DISC;
2924 if (!CDROM_CONFIG_FLAGS(drive)->audio_play)
2925 devinfo->mask |= CDC_PLAY_AUDIO;
2926 if (!CDROM_CONFIG_FLAGS(drive)->close_tray)
2927 devinfo->mask |= CDC_CLOSE_TRAY;
2928 if (!CDROM_CONFIG_FLAGS(drive)->mo_drive)
2929 devinfo->mask |= CDC_MO_DRIVE;
2930 if (!CDROM_CONFIG_FLAGS(drive)->ram)
2931 devinfo->mask |= CDC_RAM;
2932
2933 if (CDROM_CONFIG_FLAGS(drive)->no_speed_select)
2934 devinfo->mask |= CDC_SELECT_SPEED; 1694 devinfo->mask |= CDC_SELECT_SPEED;
2935 1695
2936 devinfo->disk = info->disk; 1696 devinfo->disk = info->disk;
@@ -2940,22 +1700,25 @@ static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2940static 1700static
2941int ide_cdrom_probe_capabilities (ide_drive_t *drive) 1701int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2942{ 1702{
2943 struct cdrom_info *info = drive->driver_data; 1703 struct cdrom_info *cd = drive->driver_data;
2944 struct cdrom_device_info *cdi = &info->devinfo; 1704 struct cdrom_device_info *cdi = &cd->devinfo;
2945 struct atapi_capabilities_page cap; 1705 u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
1706 mechtype_t mechtype;
2946 int nslots = 1; 1707 int nslots = 1;
2947 1708
1709 cdi->mask = (CDC_CD_R | CDC_CD_RW | CDC_DVD | CDC_DVD_R |
1710 CDC_DVD_RAM | CDC_SELECT_DISC | CDC_PLAY_AUDIO |
1711 CDC_MO_DRIVE | CDC_RAM);
1712
2948 if (drive->media == ide_optical) { 1713 if (drive->media == ide_optical) {
2949 CDROM_CONFIG_FLAGS(drive)->mo_drive = 1; 1714 cdi->mask &= ~(CDC_MO_DRIVE | CDC_RAM);
2950 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2951 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name); 1715 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
2952 return nslots; 1716 return nslots;
2953 } 1717 }
2954 1718
2955 if (CDROM_CONFIG_FLAGS(drive)->nec260 || 1719 if (cd->cd_flags & IDE_CD_FLAG_PRE_ATAPI12) {
2956 !strcmp(drive->id->model,"STINGRAY 8422 IDE 8X CD-ROM 7-27-95")) { 1720 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
2957 CDROM_CONFIG_FLAGS(drive)->no_eject = 0; 1721 cdi->mask &= ~CDC_PLAY_AUDIO;
2958 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2959 return nslots; 1722 return nslots;
2960 } 1723 }
2961 1724
@@ -2969,83 +1732,66 @@ int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2969 cdi->handle = drive; 1732 cdi->handle = drive;
2970 cdi->ops = &ide_cdrom_dops; 1733 cdi->ops = &ide_cdrom_dops;
2971 1734
2972 if (ide_cdrom_get_capabilities(drive, &cap)) 1735 if (ide_cdrom_get_capabilities(drive, buf))
2973 return 0; 1736 return 0;
2974 1737
2975 if (cap.lock == 0) 1738 if ((buf[8 + 6] & 0x01) == 0)
2976 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1; 1739 cd->cd_flags |= IDE_CD_FLAG_NO_DOORLOCK;
2977 if (cap.eject) 1740 if (buf[8 + 6] & 0x08)
2978 CDROM_CONFIG_FLAGS(drive)->no_eject = 0; 1741 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
2979 if (cap.cd_r_write) 1742 if (buf[8 + 3] & 0x01)
2980 CDROM_CONFIG_FLAGS(drive)->cd_r = 1; 1743 cdi->mask &= ~CDC_CD_R;
2981 if (cap.cd_rw_write) { 1744 if (buf[8 + 3] & 0x02)
2982 CDROM_CONFIG_FLAGS(drive)->cd_rw = 1; 1745 cdi->mask &= ~(CDC_CD_RW | CDC_RAM);
2983 CDROM_CONFIG_FLAGS(drive)->ram = 1; 1746 if (buf[8 + 2] & 0x38)
2984 } 1747 cdi->mask &= ~CDC_DVD;
2985 if (cap.test_write) 1748 if (buf[8 + 3] & 0x20)
2986 CDROM_CONFIG_FLAGS(drive)->test_write = 1; 1749 cdi->mask &= ~(CDC_DVD_RAM | CDC_RAM);
2987 if (cap.dvd_ram_read || cap.dvd_r_read || cap.dvd_rom) 1750 if (buf[8 + 3] & 0x10)
2988 CDROM_CONFIG_FLAGS(drive)->dvd = 1; 1751 cdi->mask &= ~CDC_DVD_R;
2989 if (cap.dvd_ram_write) { 1752 if ((buf[8 + 4] & 0x01) || (cd->cd_flags & IDE_CD_FLAG_PLAY_AUDIO_OK))
2990 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 1; 1753 cdi->mask &= ~CDC_PLAY_AUDIO;
2991 CDROM_CONFIG_FLAGS(drive)->ram = 1; 1754
2992 } 1755 mechtype = buf[8 + 6] >> 5;
2993 if (cap.dvd_r_write) 1756 if (mechtype == mechtype_caddy || mechtype == mechtype_popup)
2994 CDROM_CONFIG_FLAGS(drive)->dvd_r = 1; 1757 cdi->mask |= CDC_CLOSE_TRAY;
2995 if (cap.audio_play)
2996 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2997 if (cap.mechtype == mechtype_caddy || cap.mechtype == mechtype_popup)
2998 CDROM_CONFIG_FLAGS(drive)->close_tray = 0;
2999
3000 /* Some drives used by Apple don't advertise audio play
3001 * but they do support reading TOC & audio datas
3002 */
3003 if (strcmp(drive->id->model, "MATSHITADVD-ROM SR-8187") == 0 ||
3004 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8186") == 0 ||
3005 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8176") == 0 ||
3006 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8174") == 0)
3007 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
3008 1758
3009#if ! STANDARD_ATAPI
3010 if (cdi->sanyo_slot > 0) { 1759 if (cdi->sanyo_slot > 0) {
3011 CDROM_CONFIG_FLAGS(drive)->is_changer = 1; 1760 cdi->mask &= ~CDC_SELECT_DISC;
3012 nslots = 3; 1761 nslots = 3;
1762 } else if (mechtype == mechtype_individual_changer ||
1763 mechtype == mechtype_cartridge_changer) {
1764 nslots = cdrom_number_of_slots(cdi);
1765 if (nslots > 1)
1766 cdi->mask &= ~CDC_SELECT_DISC;
3013 } 1767 }
3014 1768
3015 else 1769 ide_cdrom_update_speed(drive, buf);
3016#endif /* not STANDARD_ATAPI */
3017 if (cap.mechtype == mechtype_individual_changer ||
3018 cap.mechtype == mechtype_cartridge_changer) {
3019 if ((nslots = cdrom_number_of_slots(cdi)) > 1) {
3020 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
3021 CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 1;
3022 }
3023 }
3024 1770
3025 ide_cdrom_update_speed(drive, &cap);
3026 /* don't print speed if the drive reported 0.
3027 */
3028 printk(KERN_INFO "%s: ATAPI", drive->name); 1771 printk(KERN_INFO "%s: ATAPI", drive->name);
3029 if (CDROM_CONFIG_FLAGS(drive)->max_speed)
3030 printk(" %dX", CDROM_CONFIG_FLAGS(drive)->max_speed);
3031 printk(" %s", CDROM_CONFIG_FLAGS(drive)->dvd ? "DVD-ROM" : "CD-ROM");
3032 1772
3033 if (CDROM_CONFIG_FLAGS(drive)->dvd_r|CDROM_CONFIG_FLAGS(drive)->dvd_ram) 1773 /* don't print speed if the drive reported 0 */
3034 printk(" DVD%s%s", 1774 if (cd->max_speed)
3035 (CDROM_CONFIG_FLAGS(drive)->dvd_r)? "-R" : "", 1775 printk(KERN_CONT " %dX", cd->max_speed);
3036 (CDROM_CONFIG_FLAGS(drive)->dvd_ram)? "-RAM" : "");
3037 1776
3038 if (CDROM_CONFIG_FLAGS(drive)->cd_r|CDROM_CONFIG_FLAGS(drive)->cd_rw) 1777 printk(KERN_CONT " %s", (cdi->mask & CDC_DVD) ? "CD-ROM" : "DVD-ROM");
3039 printk(" CD%s%s",
3040 (CDROM_CONFIG_FLAGS(drive)->cd_r)? "-R" : "",
3041 (CDROM_CONFIG_FLAGS(drive)->cd_rw)? "/RW" : "");
3042 1778
3043 if (CDROM_CONFIG_FLAGS(drive)->is_changer) 1779 if ((cdi->mask & CDC_DVD_R) == 0 || (cdi->mask & CDC_DVD_RAM) == 0)
3044 printk(" changer w/%d slots", nslots); 1780 printk(KERN_CONT " DVD%s%s",
3045 else 1781 (cdi->mask & CDC_DVD_R) ? "" : "-R",
3046 printk(" drive"); 1782 (cdi->mask & CDC_DVD_RAM) ? "" : "-RAM");
3047 1783
3048 printk(KERN_CONT ", %dkB Cache\n", be16_to_cpu(cap.buffer_size)); 1784 if ((cdi->mask & CDC_CD_R) == 0 || (cdi->mask & CDC_CD_RW) == 0)
1785 printk(KERN_CONT " CD%s%s",
1786 (cdi->mask & CDC_CD_R) ? "" : "-R",
1787 (cdi->mask & CDC_CD_RW) ? "" : "/RW");
1788
1789 if ((cdi->mask & CDC_SELECT_DISC) == 0)
1790 printk(KERN_CONT " changer w/%d slots", nslots);
1791 else
1792 printk(KERN_CONT " drive");
1793
1794 printk(KERN_CONT ", %dkB Cache\n", be16_to_cpu(*(u16 *)&buf[8 + 12]));
3049 1795
3050 return nslots; 1796 return nslots;
3051} 1797}
@@ -3138,11 +1884,74 @@ static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
3138 return 0; 1884 return 0;
3139} 1885}
3140 1886
1887struct cd_list_entry {
1888 const char *id_model;
1889 const char *id_firmware;
1890 unsigned int cd_flags;
1891};
1892
1893static const struct cd_list_entry ide_cd_quirks_list[] = {
1894 /* Limit transfer size per interrupt. */
1895 { "SAMSUNG CD-ROM SCR-2430", NULL, IDE_CD_FLAG_LIMIT_NFRAMES },
1896 { "SAMSUNG CD-ROM SCR-2432", NULL, IDE_CD_FLAG_LIMIT_NFRAMES },
1897 /* SCR-3231 doesn't support the SET_CD_SPEED command. */
1898 { "SAMSUNG CD-ROM SCR-3231", NULL, IDE_CD_FLAG_NO_SPEED_SELECT },
1899 /* Old NEC260 (not R) was released before ATAPI 1.2 spec. */
1900 { "NEC CD-ROM DRIVE:260", "1.01", IDE_CD_FLAG_TOCADDR_AS_BCD |
1901 IDE_CD_FLAG_PRE_ATAPI12, },
1902 /* Vertos 300, some versions of this drive like to talk BCD. */
1903 { "V003S0DS", NULL, IDE_CD_FLAG_VERTOS_300_SSD, },
1904 /* Vertos 600 ESD. */
1905 { "V006E0DS", NULL, IDE_CD_FLAG_VERTOS_600_ESD, },
1906 /*
1907 * Sanyo 3 CD changer uses a non-standard command for CD changing
1908 * (by default standard ATAPI support for CD changers is used).
1909 */
1910 { "CD-ROM CDR-C3 G", NULL, IDE_CD_FLAG_SANYO_3CD },
1911 { "CD-ROM CDR-C3G", NULL, IDE_CD_FLAG_SANYO_3CD },
1912 { "CD-ROM CDR_C36", NULL, IDE_CD_FLAG_SANYO_3CD },
1913 /* Stingray 8X CD-ROM. */
1914 { "STINGRAY 8422 IDE 8X CD-ROM 7-27-95", NULL, IDE_CD_FLAG_PRE_ATAPI12},
1915 /*
1916 * ACER 50X CD-ROM and WPI 32X CD-ROM require the full spec length
1917 * mode sense page capabilities size, but older drives break.
1918 */
1919 { "ATAPI CD ROM DRIVE 50X MAX", NULL, IDE_CD_FLAG_FULL_CAPS_PAGE },
1920 { "WPI CDS-32X", NULL, IDE_CD_FLAG_FULL_CAPS_PAGE },
1921 /* ACER/AOpen 24X CD-ROM has the speed fields byte-swapped. */
1922 { "", "241N", IDE_CD_FLAG_LE_SPEED_FIELDS },
1923 /*
1924 * Some drives used by Apple don't advertise audio play
1925 * but they do support reading TOC & audio datas.
1926 */
1927 { "MATSHITADVD-ROM SR-8187", NULL, IDE_CD_FLAG_PLAY_AUDIO_OK },
1928 { "MATSHITADVD-ROM SR-8186", NULL, IDE_CD_FLAG_PLAY_AUDIO_OK },
1929 { "MATSHITADVD-ROM SR-8176", NULL, IDE_CD_FLAG_PLAY_AUDIO_OK },
1930 { "MATSHITADVD-ROM SR-8174", NULL, IDE_CD_FLAG_PLAY_AUDIO_OK },
1931 { NULL, NULL, 0 }
1932};
1933
1934static unsigned int ide_cd_flags(struct hd_driveid *id)
1935{
1936 const struct cd_list_entry *cle = ide_cd_quirks_list;
1937
1938 while (cle->id_model) {
1939 if (strcmp(cle->id_model, id->model) == 0 &&
1940 (cle->id_firmware == NULL ||
1941 strstr(id->fw_rev, cle->id_firmware)))
1942 return cle->cd_flags;
1943 cle++;
1944 }
1945
1946 return 0;
1947}
1948
3141static 1949static
3142int ide_cdrom_setup (ide_drive_t *drive) 1950int ide_cdrom_setup (ide_drive_t *drive)
3143{ 1951{
3144 struct cdrom_info *info = drive->driver_data; 1952 struct cdrom_info *cd = drive->driver_data;
3145 struct cdrom_device_info *cdi = &info->devinfo; 1953 struct cdrom_device_info *cdi = &cd->devinfo;
1954 struct hd_driveid *id = drive->id;
3146 int nslots; 1955 int nslots;
3147 1956
3148 blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn); 1957 blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
@@ -3153,101 +1962,21 @@ int ide_cdrom_setup (ide_drive_t *drive)
3153 1962
3154 drive->special.all = 0; 1963 drive->special.all = 0;
3155 1964
3156 CDROM_STATE_FLAGS(drive)->media_changed = 1; 1965 cd->cd_flags = IDE_CD_FLAG_MEDIA_CHANGED | IDE_CD_FLAG_NO_EJECT |
3157 CDROM_STATE_FLAGS(drive)->toc_valid = 0; 1966 ide_cd_flags(id);
3158 CDROM_STATE_FLAGS(drive)->door_locked = 0;
3159 1967
3160#if NO_DOOR_LOCKING 1968 if ((id->config & 0x0060) == 0x20)
3161 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1; 1969 cd->cd_flags |= IDE_CD_FLAG_DRQ_INTERRUPT;
3162#else
3163 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 0;
3164#endif
3165 1970
3166 CDROM_CONFIG_FLAGS(drive)->drq_interrupt = ((drive->id->config & 0x0060) == 0x20); 1971 if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_300_SSD) &&
3167 CDROM_CONFIG_FLAGS(drive)->is_changer = 0; 1972 id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
3168 CDROM_CONFIG_FLAGS(drive)->cd_r = 0; 1973 cd->cd_flags |= (IDE_CD_FLAG_TOCTRACKS_AS_BCD |
3169 CDROM_CONFIG_FLAGS(drive)->cd_rw = 0; 1974 IDE_CD_FLAG_TOCADDR_AS_BCD);
3170 CDROM_CONFIG_FLAGS(drive)->test_write = 0; 1975 else if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_600_ESD) &&
3171 CDROM_CONFIG_FLAGS(drive)->dvd = 0; 1976 id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
3172 CDROM_CONFIG_FLAGS(drive)->dvd_r = 0; 1977 cd->cd_flags |= IDE_CD_FLAG_TOCTRACKS_AS_BCD;
3173 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 0; 1978 else if (cd->cd_flags & IDE_CD_FLAG_SANYO_3CD)
3174 CDROM_CONFIG_FLAGS(drive)->no_eject = 1; 1979 cdi->sanyo_slot = 3; /* 3 => use CD in slot 0 */
3175 CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 0;
3176 CDROM_CONFIG_FLAGS(drive)->audio_play = 0;
3177 CDROM_CONFIG_FLAGS(drive)->close_tray = 1;
3178
3179 /* limit transfer size per interrupt. */
3180 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 0;
3181 /* a testament to the nice quality of Samsung drives... */
3182 if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2430"))
3183 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3184 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2432"))
3185 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3186 /* the 3231 model does not support the SET_CD_SPEED command */
3187 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-3231"))
3188 CDROM_CONFIG_FLAGS(drive)->no_speed_select = 1;
3189
3190#if ! STANDARD_ATAPI
3191 /* by default Sanyo 3 CD changer support is turned off and
3192 ATAPI Rev 2.2+ standard support for CD changers is used */
3193 cdi->sanyo_slot = 0;
3194
3195 CDROM_CONFIG_FLAGS(drive)->nec260 = 0;
3196 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 0;
3197 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 0;
3198 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 0;
3199 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 0;
3200
3201 if (strcmp (drive->id->model, "V003S0DS") == 0 &&
3202 drive->id->fw_rev[4] == '1' &&
3203 drive->id->fw_rev[6] <= '2') {
3204 /* Vertos 300.
3205 Some versions of this drive like to talk BCD. */
3206 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3207 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3208 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3209 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3210 }
3211
3212 else if (strcmp (drive->id->model, "V006E0DS") == 0 &&
3213 drive->id->fw_rev[4] == '1' &&
3214 drive->id->fw_rev[6] <= '2') {
3215 /* Vertos 600 ESD. */
3216 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3217 }
3218 else if (strcmp(drive->id->model, "NEC CD-ROM DRIVE:260") == 0 &&
3219 strncmp(drive->id->fw_rev, "1.01", 4) == 0) { /* FIXME */
3220 /* Old NEC260 (not R).
3221 This drive was released before the 1.2 version
3222 of the spec. */
3223 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3224 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3225 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3226 CDROM_CONFIG_FLAGS(drive)->nec260 = 1;
3227 }
3228 else if (strcmp(drive->id->model, "WEARNES CDD-120") == 0 &&
3229 strncmp(drive->id->fw_rev, "A1.1", 4) == 0) { /* FIXME */
3230 /* Wearnes */
3231 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3232 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3233 }
3234 /* Sanyo 3 CD changer uses a non-standard command
3235 for CD changing */
3236 else if ((strcmp(drive->id->model, "CD-ROM CDR-C3 G") == 0) ||
3237 (strcmp(drive->id->model, "CD-ROM CDR-C3G") == 0) ||
3238 (strcmp(drive->id->model, "CD-ROM CDR_C36") == 0)) {
3239 /* uses CD in slot 0 when value is set to 3 */
3240 cdi->sanyo_slot = 3;
3241 }
3242#endif /* not STANDARD_ATAPI */
3243
3244 info->toc = NULL;
3245 info->buffer = NULL;
3246 info->sector_buffered = 0;
3247 info->nsectors_buffered = 0;
3248 info->changer_info = NULL;
3249 info->last_block = 0;
3250 info->start_seek = 0;
3251 1980
3252 nslots = ide_cdrom_probe_capabilities (drive); 1981 nslots = ide_cdrom_probe_capabilities (drive);
3253 1982
@@ -3262,7 +1991,7 @@ int ide_cdrom_setup (ide_drive_t *drive)
3262 1991
3263 if (ide_cdrom_register(drive, nslots)) { 1992 if (ide_cdrom_register(drive, nslots)) {
3264 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name); 1993 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
3265 info->devinfo.handle = NULL; 1994 cd->devinfo.handle = NULL;
3266 return 1; 1995 return 1;
3267 } 1996 }
3268 ide_cdrom_add_settings(drive); 1997 ide_cdrom_add_settings(drive);
@@ -3302,7 +2031,6 @@ static void ide_cd_release(struct kref *kref)
3302 2031
3303 kfree(info->buffer); 2032 kfree(info->buffer);
3304 kfree(info->toc); 2033 kfree(info->toc);
3305 kfree(info->changer_info);
3306 if (devinfo->handle == drive && unregister_cdrom(devinfo)) 2034 if (devinfo->handle == drive && unregister_cdrom(devinfo))
3307 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom " 2035 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom "
3308 "driver.\n", __FUNCTION__, drive->name); 2036 "driver.\n", __FUNCTION__, drive->name);
@@ -3458,7 +2186,9 @@ static int idecd_revalidate_disk(struct gendisk *disk)
3458{ 2186{
3459 struct cdrom_info *info = ide_cd_g(disk); 2187 struct cdrom_info *info = ide_cd_g(disk);
3460 struct request_sense sense; 2188 struct request_sense sense;
3461 cdrom_read_toc(info->drive, &sense); 2189
2190 ide_cd_read_toc(info->drive, &sense);
2191
3462 return 0; 2192 return 0;
3463} 2193}
3464 2194
@@ -3533,7 +2263,7 @@ static int ide_cd_probe(ide_drive_t *drive)
3533 goto failed; 2263 goto failed;
3534 } 2264 }
3535 2265
3536 cdrom_read_toc(drive, &sense); 2266 ide_cd_read_toc(drive, &sense);
3537 g->fops = &idecd_ops; 2267 g->fops = &idecd_ops;
3538 g->flags |= GENHD_FL_REMOVABLE; 2268 g->flags |= GENHD_FL_REMOVABLE;
3539 add_disk(g); 2269 add_disk(g);
@@ -3556,6 +2286,7 @@ static int __init ide_cdrom_init(void)
3556} 2286}
3557 2287
3558MODULE_ALIAS("ide:*m-cdrom*"); 2288MODULE_ALIAS("ide:*m-cdrom*");
2289MODULE_ALIAS("ide-cd");
3559module_init(ide_cdrom_init); 2290module_init(ide_cdrom_init);
3560module_exit(ide_cdrom_exit); 2291module_exit(ide_cdrom_exit);
3561MODULE_LICENSE("GPL"); 2292MODULE_LICENSE("GPL");
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-16 01:48:06 -0500