[PATCH] 2.5.17 IDE 70
[opensuse:kernel.git] / drivers / ide / ide-cd.c
1 /*
2  * Copyright (C) 1994, 1995, 1996  scott snyder  <snyder@fnald0.fnal.gov>
3  * Copyright (C) 1996-1998  Erik Andersen <andersee@debian.org>
4  * Copyright (C) 1998-2000  Jens Axboe <axboe@suse.de>
5  *
6  * May be copied or modified under the terms of the GNU General Public
7  * License.  See linux/COPYING for more information.
8  *
9  * ATAPI CD-ROM driver.  To be used with ide.c.
10  * See Documentation/cdrom/ide-cd for usage information.
11  *
12  * Suggestions are welcome. Patches that work are more welcome though. ;-)
13  * For those wishing to work on this driver, please be sure you download
14  * and comply with the latest Mt. Fuji (SFF8090 version 4) and ATAPI
15  * (SFF-8020i rev 2.6) standards. These documents can be obtained by
16  * anonymous ftp from:
17  *
18  * ftp://fission.dt.wdc.com/pub/standards/SFF_atapi/spec/SFF8020-r2.6/PS/8020r26.ps
19  * ftp://ftp.avc-pioneer.com/Mtfuji4/Spec/Fuji4r10.pdf
20  *
21  * Drives that deviate from these standards will be accomodated as much
22  * as possible via compile time or command-line options.  Since I only have
23  * a few drives, you generally need to send me patches...
24  *
25  * ----------------------------------
26  * TO DO LIST:
27  * -Make it so that Pioneer CD DR-A24X and friends don't get screwed up on
28  *   boot
29  *
30  * ----------------------------------
31  * 1.00  Oct 31, 1994 -- Initial version.
32  * 1.01  Nov  2, 1994 -- Fixed problem with starting request in
33  *                       cdrom_check_status.
34  * 1.03  Nov 25, 1994 -- leaving unmask_intr[] as a user-setting (as for disks)
35  * (from mlord)       -- minor changes to cdrom_setup()
36  *                    -- renamed ide_dev_s to ide_drive_t, enable irq on command
37  * 2.00  Nov 27, 1994 -- Generalize packet command interface;
38  *                       add audio ioctls.
39  * 2.01  Dec  3, 1994 -- Rework packet command interface to handle devices
40  *                       which send an interrupt when ready for a command.
41  * 2.02  Dec 11, 1994 -- Cache the TOC in the driver.
42  *                       Don't use SCMD_PLAYAUDIO_TI; it's not included
43  *                       in the current version of ATAPI.
44  *                       Try to use LBA instead of track or MSF addressing
45  *                       when possible.
46  *                       Don't wait for READY_STAT.
47  * 2.03  Jan 10, 1995 -- Rewrite block read routines to handle block sizes
48  *                       other than 2k and to move multiple sectors in a
49  *                       single transaction.
50  * 2.04  Apr 21, 1995 -- Add work-around for Creative Labs CD220E drives.
51  *                       Thanks to Nick Saw <cwsaw@pts7.pts.mot.com> for
52  *                       help in figuring this out.  Ditto for Acer and
53  *                       Aztech drives, which seem to have the same problem.
54  * 2.04b May 30, 1995 -- Fix to match changes in ide.c version 3.16 -ml
55  * 2.05  Jun  8, 1995 -- Don't attempt to retry after an illegal request
56  *                       or data protect error.
57  *                       Use HWIF and DEV_HWIF macros as in ide.c.
58  *                       Always try to do a request_sense after
59  *                       a failed command.
60  *                       Include an option to give textual descriptions
61  *                       of ATAPI errors.
62  *                       Fix a bug in handling the sector cache which
63  *                       showed up if the drive returned data in 512 byte
64  *                       blocks (like Pioneer drives).  Thanks to
65  *                       Richard Hirst <srh@gpt.co.uk> for diagnosing this.
66  *                       Properly supply the page number field in the
67  *                       MODE_SELECT command.
68  *                       PLAYAUDIO12 is broken on the Aztech; work around it.
69  * 2.05x Aug 11, 1995 -- lots of data structure renaming/restructuring in ide.c
70  *                       (my apologies to Scott, but now ide-cd.c is independent)
71  * 3.00  Aug 22, 1995 -- Implement CDROMMULTISESSION ioctl.
72  *                       Implement CDROMREADAUDIO ioctl (UNTESTED).
73  *                       Use input_ide_data() and output_ide_data().
74  *                       Add door locking.
75  *                       Fix usage count leak in cdrom_open, which happened
76  *                       when a read-write mount was attempted.
77  *                       Try to load the disk on open.
78  *                       Implement CDROMEJECT_SW ioctl (off by default).
79  *                       Read total cdrom capacity during open.
80  *                       Rearrange logic in cdrom_decode_status.  Issue
81  *                       request sense commands for failed packet commands
82  *                       from here instead of from cdrom_queue_packet_command.
83  *                       Fix a race condition in retrieving error information.
84  *                       Suppress printing normal unit attention errors and
85  *                       some drive not ready errors.
86  *                       Implement CDROMVOLREAD ioctl.
87  *                       Implement CDROMREADMODE1/2 ioctls.
88  *                       Fix race condition in setting up interrupt handlers
89  *                       when the `serialize' option is used.
90  * 3.01  Sep  2, 1995 -- Fix ordering of reenabling interrupts in
91  *                       cdrom_queue_request.
92  *                       Another try at using ide_[input,output]_data.
93  * 3.02  Sep 16, 1995 -- Stick total disk capacity in partition table as well.
94  *                       Make VERBOSE_IDE_CD_ERRORS dump failed command again.
95  *                       Dump out more information for ILLEGAL REQUEST errs.
96  *                       Fix handling of errors occurring before the
97  *                       packet command is transferred.
98  *                       Fix transfers with odd bytelengths.
99  * 3.03  Oct 27, 1995 -- Some Creative drives have an id of just `CD'.
100  *                       `DCI-2S10' drives are broken too.
101  * 3.04  Nov 20, 1995 -- So are Vertos drives.
102  * 3.05  Dec  1, 1995 -- Changes to go with overhaul of ide.c and ide-tape.c
103  * 3.06  Dec 16, 1995 -- Add support needed for partitions.
104  *                       More workarounds for Vertos bugs (based on patches
105  *                       from Holger Dietze <dietze@aix520.informatik.uni-leipzig.de>).
106  *                       Try to eliminate byteorder assumptions.
107  *                       Use atapi_cdrom_subchnl struct definition.
108  *                       Add STANDARD_ATAPI compilation option.
109  * 3.07  Jan 29, 1996 -- More twiddling for broken drives: Sony 55D,
110  *                       Vertos 300.
111  *                       Add NO_DOOR_LOCKING configuration option.
112  *                       Handle drive_cmd requests w/NULL args (for hdparm -t).
113  *                       Work around sporadic Sony55e audio play problem.
114  * 3.07a Feb 11, 1996 -- check drive->id for NULL before dereferencing, to fix
115  *                       problem with "hde=cdrom" with no drive present.  -ml
116  * 3.08  Mar  6, 1996 -- More Vertos workarounds.
117  * 3.09  Apr  5, 1996 -- Add CDROMCLOSETRAY ioctl.
118  *                       Switch to using MSF addressing for audio commands.
119  *                       Reformat to match kernel tabbing style.
120  *                       Add CDROM_GET_UPC ioctl.
121  * 3.10  Apr 10, 1996 -- Fix compilation error with STANDARD_ATAPI.
122  * 3.11  Apr 29, 1996 -- Patch from Heiko Eissfeldt <heiko@colossus.escape.de>
123  *                       to remove redundant verify_area calls.
124  * 3.12  May  7, 1996 -- Rudimentary changer support.  Based on patches
125  *                        from Gerhard Zuber <zuber@berlin.snafu.de>.
126  *                       Let open succeed even if there's no loaded disc.
127  * 3.13  May 19, 1996 -- Fixes for changer code.
128  * 3.14  May 29, 1996 -- Add work-around for Vertos 600.
129  *                        (From Hennus Bergman <hennus@sky.ow.nl>.)
130  * 3.15  July 2, 1996 -- Added support for Sanyo 3 CD changers
131  *                       from Ben Galliart <bgallia@luc.edu> with
132  *                       special help from Jeff Lightfoot
133  *                       <jeffml@pobox.com>
134  * 3.15a July 9, 1996 -- Improved Sanyo 3 CD changer identification
135  * 3.16  Jul 28, 1996 -- Fix from Gadi to reduce kernel stack usage for ioctl.
136  * 3.17  Sep 17, 1996 -- Tweak audio reads for some drives.
137  *                       Start changing CDROMLOADFROMSLOT to CDROM_SELECT_DISC.
138  * 3.18  Oct 31, 1996 -- Added module and DMA support.
139  *
140  *
141  * 4.00  Nov 5, 1996   -- New ide-cd maintainer,
142  *                        Erik B. Andersen <andersee@debian.org>
143  *                     -- Newer Creative drives don't always set the error
144  *                        register correctly.  Make sure we see media changes
145  *                        regardless.
146  *                     -- Integrate with generic cdrom driver.
147  *                     -- CDROMGETSPINDOWN and CDROMSETSPINDOWN ioctls, based on
148  *                        a patch from Ciro Cattuto <>.
149  *                     -- Call set_device_ro.
150  *                     -- Implement CDROMMECHANISMSTATUS and CDROMSLOTTABLE
151  *                        ioctls, based on patch by Erik Andersen
152  *                     -- Add some probes of drive capability during setup.
153  *
154  * 4.01  Nov 11, 1996  -- Split into ide-cd.c and ide-cd.h
155  *                     -- Removed CDROMMECHANISMSTATUS and CDROMSLOTTABLE
156  *                        ioctls in favor of a generalized approach
157  *                        using the generic cdrom driver.
158  *                     -- Fully integrated with the 2.1.X kernel.
159  *                     -- Other stuff that I forgot (lots of changes)
160  *
161  * 4.02  Dec 01, 1996  -- Applied patch from Gadi Oxman <gadio@netvision.net.il>
162  *                        to fix the drive door locking problems.
163  *
164  * 4.03  Dec 04, 1996  -- Added DSC overlap support.
165  * 4.04  Dec 29, 1996  -- Added CDROMREADRAW ioclt based on patch
166  *                        by Aleks Makarov (xmakarov@sun.felk.cvut.cz)
167  *
168  * 4.05  Nov 20, 1997  -- Modified to print more drive info on init
169  *                        Minor other changes
170  *                        Fix errors on CDROMSTOP (If you have a "Dolphin",
171  *                        you must define IHAVEADOLPHIN)
172  *                        Added identifier so new Sanyo CD-changer works
173  *                        Better detection if door locking isn't supported
174  *
175  * 4.06  Dec 17, 1997  -- fixed endless "tray open" messages  -ml
176  * 4.07  Dec 17, 1997  -- fallback to set pc->stat on "tray open"
177  * 4.08  Dec 18, 1997  -- spew less noise when tray is empty
178  *                     -- fix speed display for ACER 24X, 18X
179  * 4.09  Jan 04, 1998  -- fix handling of the last block so we return
180  *                        an end of file instead of an I/O error (Gadi)
181  * 4.10  Jan 24, 1998  -- fixed a bug so now changers can change to a new
182  *                        slot when there is no disc in the current slot.
183  *                     -- Fixed a memory leak where info->changer_info was
184  *                        malloc'ed but never free'd when closing the device.
185  *                     -- Cleaned up the global namespace a bit by making more
186  *                        functions static that should already have been.
187  * 4.11  Mar 12, 1998  -- Added support for the CDROM_SELECT_SPEED ioctl
188  *                        based on a patch for 2.0.33 by Jelle Foks
189  *                        <jelle@scintilla.utwente.nl>, a patch for 2.0.33
190  *                        by Toni Giorgino <toni@pcape2.pi.infn.it>, the SCSI
191  *                        version, and my own efforts.  -erik
192  *                     -- Fixed a stupid bug which egcs was kind enough to
193  *                        inform me of where "Illegal mode for this track"
194  *                        was never returned due to a comparison on data
195  *                        types of limited range.
196  * 4.12  Mar 29, 1998  -- Fixed bug in CDROM_SELECT_SPEED so write speed is
197  *                        now set ionly for CD-R and CD-RW drives.  I had
198  *                        removed this support because it produced errors.
199  *                        It produced errors _only_ for non-writers. duh.
200  * 4.13  May 05, 1998  -- Suppress useless "in progress of becoming ready"
201  *                        messages, since this is not an error.
202  *                     -- Change error messages to be const
203  *                     -- Remove a "\t" which looks ugly in the syslogs
204  * 4.14  July 17, 1998 -- Change to pointing to .ps version of ATAPI spec
205  *                        since the .pdf version doesn't seem to work...
206  *                     -- Updated the TODO list to something more current.
207  *
208  * 4.15  Aug 25, 1998  -- Updated ide-cd.h to respect mechine endianess,
209  *                        patch thanks to "Eddie C. Dost" <ecd@skynet.be>
210  *
211  * 4.50  Oct 19, 1998  -- New maintainers!
212  *                        Jens Axboe <axboe@image.dk>
213  *                        Chris Zwilling <chris@cloudnet.com>
214  *
215  * 4.51  Dec 23, 1998  -- Jens Axboe <axboe@image.dk>
216  *                      - ide_cdrom_reset enabled since the ide subsystem
217  *                         handles resets fine now. <axboe@image.dk>
218  *                      - Transfer size fix for Samsung CD-ROMs, thanks to
219  *                        "Ville Hallik" <ville.hallik@mail.ee>.
220  *                      - other minor stuff.
221  *
222  * 4.52  Jan 19, 1999  -- Jens Axboe <axboe@image.dk>
223  *                      - Detect DVD-ROM/RAM drives
224  *
225  * 4.53  Feb 22, 1999   - Include other model Samsung and one Goldstar
226  *                        drive in transfer size limit.
227  *                      - Fix the I/O error when doing eject without a medium
228  *                        loaded on some drives.
229  *                      - CDROMREADMODE2 is now implemented through
230  *                        CDROMREADRAW, since many drives don't support
231  *                        MODE2 (even though ATAPI 2.6 says they must).
232  *                      - Added ignore parameter to ide-cd (as a module), eg
233  *                        insmod ide-cd ignore='hda hdb'
234  *                        Useful when using ide-cd in conjunction with
235  *                        ide-scsi. TODO: non-modular way of doing the
236  *                        same.
237  *
238  * 4.54  Aug 5, 1999    - Support for MMC2 class commands through the generic
239  *                        packet interface to cdrom.c.
240  *                      - Unified audio ioctl support, most of it.
241  *                      - cleaned up various deprecated verify_area().
242  *                      - Added ide_cdrom_packet() as the interface for
243  *                        the Uniform generic_packet().
244  *                      - bunch of other stuff, will fill in logs later.
245  *                      - report 1 slot for non-changers, like the other
246  *                        cd-rom drivers. don't report select disc for
247  *                        non-changers as well.
248  *                      - mask out audio playing, if the device can't do it.
249  *
250  * 4.55  Sep 1, 1999    - Eliminated the rest of the audio ioctls, except
251  *                        for CDROMREADTOC[ENTRY|HEADER]. Some of the drivers
252  *                        use this independently of the actual audio handling.
253  *                        They will disappear later when I get the time to
254  *                        do it cleanly.
255  *                      - Minimize the TOC reading - only do it when we
256  *                        know a media change has occurred.
257  *                      - Moved all the CDROMREADx ioctls to the Uniform layer.
258  *                      - Heiko Eissfeldt <heiko@colossus.escape.de> supplied
259  *                        some fixes for CDI.
260  *                      - CD-ROM leaving door locked fix from Andries
261  *                        Brouwer <Andries.Brouwer@cwi.nl>
262  *                      - Erik Andersen <andersen@xmission.com> unified
263  *                        commands across the various drivers and how
264  *                        sense errors are handled.
265  *
266  * 4.56  Sep 12, 1999   - Removed changer support - it is now in the
267  *                        Uniform layer.
268  *                      - Added partition based multisession handling.
269  *                      - Mode sense and mode select moved to the
270  *                        Uniform layer.
271  *                      - Fixed a problem with WPI CDS-32X drive - it
272  *                        failed the capabilities
273  *
274  * 4.57  Apr 7, 2000    - Fixed sense reporting.
275  *                      - Fixed possible oops in ide_cdrom_get_last_session()
276  *                      - Fix locking mania and make ide_cdrom_reset relock
277  *                      - Stop spewing errors to log when magicdev polls with
278  *                        TEST_UNIT_READY on some drives.
279  *                      - Various fixes from Tobias Ringstrom:
280  *                        tray if it was locked prior to the reset.
281  *                        - cdrom_read_capacity returns one frame too little.
282  *                        - Fix real capacity reporting.
283  *
284  * 4.58  May 1, 2000    - Clean up ACER50 stuff.
285  *                      - Fix small problem with ide_cdrom_capacity
286  *
287  * 4.59  Aug 11, 2000   - Fix changer problem in cdrom_read_toc, we weren't
288  *                        correctly sensing a disc change.
289  *                      - Rearranged some code
290  *                      - Use extended sense on drives that support it for
291  *                        correctly reporting tray status -- from
292  *                        Michael D Johnson <johnsom@orst.edu>
293  *
294  *************************************************************************/
295
296 #define IDECD_VERSION "4.59"
297
298 #include <linux/config.h>
299 #include <linux/module.h>
300 #include <linux/types.h>
301 #include <linux/kernel.h>
302 #include <linux/delay.h>
303 #include <linux/timer.h>
304 #include <linux/slab.h>
305 #include <linux/interrupt.h>
306 #include <linux/errno.h>
307 #include <linux/cdrom.h>
308 #include <linux/ide.h>
309 #include <linux/completion.h>
310
311 #include <asm/irq.h>
312 #include <asm/io.h>
313 #include <asm/byteorder.h>
314 #include <asm/uaccess.h>
315 #include <asm/unaligned.h>
316
317 #include "ide-cd.h"
318
319 /****************************************************************************
320  * Generic packet command support and error handling routines.
321  */
322
323 /* Mark that we've seen a media change, and invalidate our internal
324    buffers. */
325 static void cdrom_saw_media_change(struct ata_device *drive)
326 {
327         struct cdrom_info *info = drive->driver_data;
328
329         CDROM_STATE_FLAGS (drive)->media_changed = 1;
330         CDROM_STATE_FLAGS (drive)->toc_valid = 0;
331         info->nsectors_buffered = 0;
332 }
333
334 static void cdrom_analyze_sense_data(struct ata_device *drive, struct request *rq)
335 {
336         int log = 0;
337         /* FIXME --mdcki */
338         struct packet_command *pc = (struct packet_command *) rq->special;
339         struct packet_command *failed_command = pc->failed_command;
340
341         /* Decode sense data from drive */
342         struct request_sense *sense = (struct request_sense *) (pc->buffer - rq->cmd[4]);
343         unsigned char fail_cmd;
344
345         if (sense == NULL || failed_command == NULL || failed_command->quiet)
346                 return;
347
348         fail_cmd = rq->cmd[0];
349
350         /* Check whatever this error should be logged:
351          */
352         switch (sense->sense_key) {
353                 case NO_SENSE:
354                 case RECOVERED_ERROR:
355                         break;
356
357                 case NOT_READY:
358
359                         /* Don't care about tray state messages for e.g.
360                          * capacity commands or in-progress or becoming ready.
361                          */
362                         if (sense->asc == 0x3a || sense->asc == 0x04)
363                                 break;
364                         log = 1;
365                         break;
366
367                 case UNIT_ATTENTION:
368
369                         /* Make good and sure we've seen this potential media
370                          * change. Some drives (i.e. Creative) fail to present
371                          * the correct sense key in the error register.
372                          */
373                         cdrom_saw_media_change(drive);
374                         break;
375
376                 default:
377                         log = 1;
378                         break;
379         }
380
381         if (!log)
382                 return;
383
384         /*
385          * If a read toc is executed for a CD-R or CD-RW medium where the first
386          * toc has not been recorded yet, it will fail with 05/24/00 (which is
387          * a confusing error).
388          */
389
390         if (fail_cmd == GPCMD_READ_TOC_PMA_ATIP)
391                 if (sense->sense_key == 0x05 && sense->asc == 0x24)
392                         return;
393
394 #if VERBOSE_IDE_CD_ERRORS
395         {
396                 int i;
397                 const char *s;
398                 char buf[80];
399
400                 printk ("ATAPI device %s:\n", drive->name);
401                 if (sense->error_code==0x70)
402                         printk("  Error: ");
403                 else if (sense->error_code==0x71)
404                         printk("  Deferred Error: ");
405                 else if (sense->error_code == 0x7f)
406                         printk("  Vendor-specific Error: ");
407                 else
408                         printk("  Unknown Error Type: ");
409
410                 if (sense->sense_key < ARY_LEN(sense_key_texts))
411                         s = sense_key_texts[sense->sense_key];
412                 else
413                         s = "bad sense key!";
414
415                 printk("%s -- (Sense key=0x%02x)\n", s, sense->sense_key);
416
417                 if (sense->asc == 0x40) {
418                         sprintf(buf, "Diagnostic failure on component 0x%02x",
419                                  sense->ascq);
420                         s = buf;
421                 } else {
422                         int lo = 0, mid, hi = ARY_LEN(sense_data_texts);
423                         unsigned long key = (sense->sense_key << 16);
424                         key |= (sense->asc << 8);
425                         if (!(sense->ascq >= 0x80 && sense->ascq <= 0xdd))
426                                 key |= sense->ascq;
427                         s = NULL;
428
429                         while (hi > lo) {
430                                 mid = (lo + hi) / 2;
431                                 if (sense_data_texts[mid].asc_ascq == key ||
432                                     sense_data_texts[mid].asc_ascq == (0xff0000|key)) {
433                                         s = sense_data_texts[mid].text;
434                                         break;
435                                 }
436                                 else if (sense_data_texts[mid].asc_ascq > key)
437                                         hi = mid;
438                                 else
439                                         lo = mid+1;
440                         }
441                 }
442
443                 if (s == NULL) {
444                         if (sense->asc > 0x80)
445                                 s = "(vendor-specific error)";
446                         else
447                                 s = "(reserved error code)";
448                 }
449
450                 printk("  %s -- (asc=0x%02x, ascq=0x%02x)\n",
451                         s, sense->asc, sense->ascq);
452
453                 {
454
455                         int lo=0, mid, hi= ARY_LEN (packet_command_texts);
456                         s = NULL;
457
458                         while (hi > lo) {
459                                 mid = (lo + hi) / 2;
460                                 if (packet_command_texts[mid].packet_command == fail_cmd) {
461                                         s = packet_command_texts[mid].text;
462                                         break;
463                                 }
464                                 if (packet_command_texts[mid].packet_command > fail_cmd)
465                                         hi = mid;
466                                 else
467                                         lo = mid+1;
468                         }
469
470                         printk ("  The failed \"%s\" packet command was: \n  \"", s);
471                         for (i=0; i < CDROM_PACKET_SIZE; i++)
472                                 printk ("%02x ", rq->cmd[i]);
473                         printk ("\"\n");
474                 }
475
476                 /* The SKSV bit specifies validity of the sense_key_specific
477                  * in the next two commands. It is bit 7 of the first byte.
478                  * In the case of NOT_READY, if SKSV is set the drive can
479                  * give us nice ETA readings.
480                  */
481                 if (sense->sense_key == NOT_READY && (sense->sks[0] & 0x80)) {
482                         int progress = (sense->sks[1] << 8 | sense->sks[2]) * 100;
483                         printk("  Command is %02d%% complete\n", progress / 0xffff);
484
485                 }
486
487                 if (sense->sense_key == ILLEGAL_REQUEST &&
488                     (sense->sks[0] & 0x80) != 0) {
489                         printk("  Error in %s byte %d",
490                                 (sense->sks[0] & 0x40) != 0 ?
491                                 "command packet" : "command data",
492                                 (sense->sks[1] << 8) + sense->sks[2]);
493
494                         if ((sense->sks[0] & 0x40) != 0)
495                                 printk (" bit %d", sense->sks[0] & 0x07);
496
497                         printk ("\n");
498                 }
499         }
500
501 #else
502
503         /* Suppress printing unit attention and `in progress of becoming ready'
504            errors when we're not being verbose. */
505
506         if (sense->sense_key == UNIT_ATTENTION ||
507             (sense->sense_key == NOT_READY && (sense->asc == 4 ||
508                                                 sense->asc == 0x3a)))
509                 return;
510
511         printk("%s: error code: 0x%02x  sense_key: 0x%02x  asc: 0x%02x  ascq: 0x%02x\n",
512                 drive->name,
513                 sense->error_code, sense->sense_key,
514                 sense->asc, sense->ascq);
515 #endif
516 }
517
518 static void cdrom_queue_request_sense(struct ata_device *drive,
519                                       struct completion *wait,
520                                       struct request_sense *sense,
521                                       struct packet_command *failed_command)
522 {
523         struct cdrom_info *info         = drive->driver_data;
524         struct packet_command *pc       = &info->request_sense_pc;
525         struct request *rq;
526
527         if (sense == NULL)
528                 sense = &info->sense_data;
529
530         memset(pc, 0, sizeof(*pc));
531         pc->buffer = (void *) sense;
532         pc->buflen = 18;
533         pc->failed_command = failed_command;
534
535         /* stuff the sense request in front of our current request */
536         rq = &info->request_sense_request;
537         ide_init_drive_cmd(rq);
538         rq->cmd[0] = GPCMD_REQUEST_SENSE;
539         rq->cmd[4] = pc->buflen;
540         rq->flags = REQ_SENSE;
541
542         /* FIXME --mdcki */
543         rq->special = (char *) pc;
544
545         rq->waiting = wait;
546         ide_do_drive_cmd(drive, rq, ide_preempt);
547 }
548
549
550 static void cdrom_end_request(struct ata_device *drive, struct request *rq, int uptodate)
551 {
552         if ((rq->flags & REQ_SENSE) && uptodate)
553                 cdrom_analyze_sense_data(drive, rq);
554
555         if ((rq->flags & REQ_CMD) && !rq->current_nr_sectors)
556                 uptodate = 1;
557
558         ide_end_request(drive, rq, uptodate);
559 }
560
561
562 /* Returns 0 if the request should be continued.
563    Returns 1 if the request was ended. */
564 static int cdrom_decode_status(ide_startstop_t *startstop, struct ata_device *drive, struct request *rq,
565                                 int good_stat, int *stat_ret)
566 {
567         int stat, err, sense_key;
568         struct packet_command *pc;
569
570         /* Check for errors. */
571         stat = GET_STAT();
572         *stat_ret = stat;
573
574         if (OK_STAT (stat, good_stat, BAD_R_STAT))
575                 return 0;
576
577         /* Get the IDE error register. */
578         err = GET_ERR();
579         sense_key = err >> 4;
580
581         if (rq == NULL) {
582                 printk("%s: missing rq in %s\n", drive->name, __FUNCTION__);
583                 *startstop = ide_stopped;
584                 return 1;
585         }
586
587         if (rq->flags & REQ_SENSE) {
588                 /* We got an error trying to get sense info
589                    from the drive (probably while trying
590                    to recover from a former error).  Just give up. */
591
592                 /* FIXME --mdcki */
593                 pc = (struct packet_command *) rq->special;
594                 pc->stat = 1;
595                 cdrom_end_request(drive, rq, 1);
596                 *startstop = ide_error (drive, rq, "request sense failure", stat);
597
598                 return 1;
599         } else if (rq->flags & (REQ_PC | REQ_BLOCK_PC)) {
600                 /* All other functions, except for READ. */
601                 struct completion *wait = NULL;
602
603                 /* FIXME --mdcki */
604                 pc = (struct packet_command *) rq->special;
605
606                 /* Check for tray open. */
607                 if (sense_key == NOT_READY) {
608                         cdrom_saw_media_change (drive);
609                 } else if (sense_key == UNIT_ATTENTION) {
610                         /* Check for media change. */
611                         cdrom_saw_media_change (drive);
612                         /*printk("%s: media changed\n",drive->name);*/
613                         return 0;
614                 } else if (!pc->quiet) {
615                         /* Otherwise, print an error. */
616                         ide_dump_status(drive, rq, "packet command error", stat);
617                 }
618
619                 /* Set the error flag and complete the request.
620                    Then, if we have a CHECK CONDITION status, queue a request
621                    sense command.  We must be careful, though: we don't want
622                    the thread in cdrom_queue_packet_command to wake up until
623                    the request sense has completed.  We do this by transferring
624                    the semaphore from the packet command request to the request
625                    sense request. */
626
627                 if ((stat & ERR_STAT) != 0) {
628                         wait = rq->waiting;
629                         rq->waiting = NULL;
630                 }
631
632                 pc->stat = 1;
633                 cdrom_end_request(drive, rq, 1);
634
635                 /* FIXME: this is the only place where pc->sense get's used.
636                  * Think hard about how to get rid of it...
637                  */
638
639                 if ((stat & ERR_STAT) != 0)
640                         cdrom_queue_request_sense(drive, wait, pc->sense, pc);
641         } else if (rq->flags & REQ_CMD) {
642                 /* Handle errors from READ and WRITE requests. */
643
644                 if (sense_key == NOT_READY) {
645                         /* Tray open. */
646                         cdrom_saw_media_change (drive);
647
648                         /* Fail the request. */
649                         printk ("%s: tray open\n", drive->name);
650                         cdrom_end_request(drive, rq, 0);
651                 } else if (sense_key == UNIT_ATTENTION) {
652                         /* Media change. */
653                         cdrom_saw_media_change (drive);
654
655                         /* Arrange to retry the request.
656                            But be sure to give up if we've retried
657                            too many times. */
658                         if (++rq->errors > ERROR_MAX)
659                                 cdrom_end_request(drive, rq, 0);
660                 } else if (sense_key == ILLEGAL_REQUEST ||
661                            sense_key == DATA_PROTECT) {
662                         /* No point in retrying after an illegal
663                            request or data protect error.*/
664                         ide_dump_status(drive, rq, "command error", stat);
665                         cdrom_end_request(drive, rq,  0);
666                 } else if (sense_key == MEDIUM_ERROR) {
667                         /* No point in re-trying a zillion times on a bad
668                          * sector.  The error is not correctable at all.
669                          */
670                         ide_dump_status(drive, rq, "media error (bad sector)", stat);
671                         cdrom_end_request(drive, rq, 0);
672                 } else if ((err & ~ABRT_ERR) != 0) {
673                         /* Go to the default handler
674                            for other errors. */
675                         *startstop = ide_error(drive, rq, __FUNCTION__, stat);
676                         return 1;
677                 } else if ((++rq->errors > ERROR_MAX)) {
678                         /* We've racked up too many retries.  Abort. */
679                         cdrom_end_request(drive, rq, 0);
680                 }
681
682                 /* If we got a CHECK_CONDITION status,
683                    queue a request sense command. */
684                 if ((stat & ERR_STAT) != 0)
685                         cdrom_queue_request_sense(drive, NULL, NULL, NULL);
686         } else
687                 blk_dump_rq_flags(rq, "ide-cd bad flags");
688
689         /* Retry, or handle the next request. */
690         *startstop = ide_stopped;
691         return 1;
692 }
693
694 static int cdrom_timer_expiry(struct ata_device *drive, struct request *rq)
695 {
696         unsigned long wait = 0;
697
698         /*
699          * Some commands are *slow* and normally take a long time to
700          * complete. Usually we can use the ATAPI "disconnect" to bypass
701          * this, but not all commands/drives support that. Let
702          * ide_timer_expiry keep polling us for these.
703          */
704         switch (rq->cmd[0]) {
705                 case GPCMD_BLANK:
706                 case GPCMD_FORMAT_UNIT:
707                 case GPCMD_RESERVE_RZONE_TRACK:
708                         wait = WAIT_CMD;
709                         break;
710                 default:
711                         wait = 0;
712                         break;
713         }
714
715         return wait;
716 }
717
718 /* Set up the device registers for transferring a packet command on DEV,
719    expecting to later transfer XFERLEN bytes.  HANDLER is the routine
720    which actually transfers the command to the drive.  If this is a
721    drq_interrupt device, this routine will arrange for HANDLER to be
722    called when the interrupt from the drive arrives.  Otherwise, HANDLER
723    will be called immediately after the drive is prepared for the transfer. */
724
725 static ide_startstop_t cdrom_start_packet_command(struct ata_device *drive,
726                                                   struct request *rq,
727                                                   int xferlen,
728                                                   ata_handler_t handler)
729 {
730         ide_startstop_t startstop;
731         struct cdrom_info *info = drive->driver_data;
732
733         /* Wait for the controller to be idle. */
734         if (ide_wait_stat(&startstop, drive, rq, 0, BUSY_STAT, WAIT_READY))
735                 return startstop;
736
737         if (info->dma) {
738                 if (info->cmd == READ)
739                         info->dma = !udma_read(drive, rq);
740                 else if (info->cmd == WRITE)
741                         info->dma = !udma_write(drive, rq);
742                 else
743                         printk("ide-cd: DMA set, but not allowed\n");
744         }
745
746         /* Set up the controller registers. */
747         OUT_BYTE(info->dma, IDE_FEATURE_REG);
748         OUT_BYTE(0, IDE_NSECTOR_REG);
749         OUT_BYTE(0, IDE_SECTOR_REG);
750
751         OUT_BYTE(xferlen & 0xff, IDE_LCYL_REG);
752         OUT_BYTE(xferlen >> 8  , IDE_HCYL_REG);
753         if (IDE_CONTROL_REG)
754                 OUT_BYTE (drive->ctl, IDE_CONTROL_REG);
755
756         if (info->dma)
757                 udma_start(drive, rq);
758
759         if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt) {
760                 ide_set_handler(drive, handler, WAIT_CMD, cdrom_timer_expiry);
761                 OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG); /* packet command */
762                 return ide_started;
763         } else {
764                 OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG); /* packet command */
765                 return handler(drive, rq);
766         }
767 }
768
769 /*
770  * Send a packet command cmd to the drive.  The device registers must have
771  * already been prepared by cdrom_start_packet_command.  "handler" is the
772  * interrupt handler to call when the command completes or there's data ready.
773  */
774 static ide_startstop_t cdrom_transfer_packet_command(struct ata_device *drive,
775                 struct request *rq,
776                 unsigned char *cmd, unsigned long timeout,
777                 ata_handler_t handler)
778 {
779         ide_startstop_t startstop;
780
781         if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt) {
782                 /* Here we should have been called after receiving an interrupt
783                    from the device.  DRQ should how be set. */
784                 int stat_dum;
785
786                 /* Check for errors. */
787                 if (cdrom_decode_status(&startstop, drive, rq, DRQ_STAT, &stat_dum))
788                         return startstop;
789         } else {
790                 /* Otherwise, we must wait for DRQ to get set. */
791                 if (ide_wait_stat(&startstop, drive, rq, DRQ_STAT, BUSY_STAT, WAIT_READY))
792                         return startstop;
793         }
794
795         /* Arm the interrupt handler. */
796         ide_set_handler(drive, handler, timeout, cdrom_timer_expiry);
797
798         /* Send the command to the device. */
799         atapi_write(drive, cmd, CDROM_PACKET_SIZE);
800
801         return ide_started;
802 }
803
804 /****************************************************************************
805  * Block read functions.
806  */
807
808 /*
809  * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
810  * buffer.  Once the first sector is added, any subsequent sectors are
811  * assumed to be continuous (until the buffer is cleared).  For the first
812  * sector added, SECTOR is its sector number.  (SECTOR is then ignored until
813  * the buffer is cleared.)
814  */
815 static void cdrom_buffer_sectors(struct ata_device *drive, unsigned long sector,
816                                   int sectors_to_transfer)
817 {
818         struct cdrom_info *info = drive->driver_data;
819
820         /* Number of sectors to read into the buffer. */
821         int sectors_to_buffer = MIN (sectors_to_transfer,
822                                      (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
823                                        info->nsectors_buffered);
824
825         char *dest;
826
827         /* If we couldn't get a buffer, don't try to buffer anything... */
828         if (info->buffer == NULL)
829                 sectors_to_buffer = 0;
830
831         /* If this is the first sector in the buffer, remember its number. */
832         if (info->nsectors_buffered == 0)
833                 info->sector_buffered = sector;
834
835         /* Read the data into the buffer. */
836         dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
837         while (sectors_to_buffer > 0) {
838                 atapi_read(drive, dest, SECTOR_SIZE);
839                 --sectors_to_buffer;
840                 --sectors_to_transfer;
841                 ++info->nsectors_buffered;
842                 dest += SECTOR_SIZE;
843         }
844
845         /* Throw away any remaining data. */
846         while (sectors_to_transfer > 0) {
847                 char dum[SECTOR_SIZE];
848                 atapi_read(drive, dum, sizeof (dum));
849                 --sectors_to_transfer;
850         }
851 }
852
853 /*
854  * Check the contents of the interrupt reason register from the cdrom
855  * and attempt to recover if there are problems.  Returns  0 if everything's
856  * ok; nonzero if the request has been terminated.
857  */
858 static inline
859 int cdrom_read_check_ireason(struct ata_device *drive, struct request *rq, int len, int ireason)
860 {
861         ireason &= 3;
862         if (ireason == 2) return 0;
863
864         if (ireason == 0) {
865                 /* Whoops... The drive is expecting to receive data from us! */
866                 printk ("%s: cdrom_read_intr: "
867                         "Drive wants to transfer data the wrong way!\n",
868                         drive->name);
869
870                 /* Throw some data at the drive so it doesn't hang
871                    and quit this request. */
872                 while (len > 0) {
873                         int dum = 0;
874                         atapi_write(drive, &dum, sizeof (dum));
875                         len -= sizeof (dum);
876                 }
877         } else  if (ireason == 1) {
878                 /* Some drives (ASUS) seem to tell us that status
879                  * info is available. just get it and ignore.
880                  */
881                 GET_STAT();
882                 return 0;
883         } else {
884                 /* Drive wants a command packet, or invalid ireason... */
885                 printk ("%s: cdrom_read_intr: bad interrupt reason %d\n",
886                         drive->name, ireason);
887         }
888
889         cdrom_end_request(drive, rq, 0);
890         return -1;
891 }
892
893 /*
894  * Interrupt routine.  Called when a read request has completed.
895  */
896 static ide_startstop_t cdrom_read_intr(struct ata_device *drive, struct request *rq)
897 {
898         int stat;
899         int ireason, len, sectors_to_transfer, nskip;
900         struct cdrom_info *info = drive->driver_data;
901         int dma = info->dma, dma_error = 0;
902         ide_startstop_t startstop;
903
904         /* Check for errors. */
905         if (dma) {
906                 info->dma = 0;
907                 if ((dma_error = udma_stop(drive)))
908                         udma_enable(drive, 0, 1);
909         }
910
911         if (cdrom_decode_status(&startstop, drive, rq, 0, &stat))
912                 return startstop;
913
914         if (dma) {
915                 if (!dma_error) {
916                         __ide_end_request(drive, rq, 1, rq->nr_sectors);
917                         return ide_stopped;
918                 } else
919                         return ide_error (drive, rq, "dma error", stat);
920         }
921
922         /* Read the interrupt reason and the transfer length. */
923         ireason = IN_BYTE (IDE_NSECTOR_REG);
924         len = IN_BYTE (IDE_LCYL_REG) + 256 * IN_BYTE (IDE_HCYL_REG);
925
926         /* If DRQ is clear, the command has completed. */
927         if ((stat & DRQ_STAT) == 0) {
928                 /* If we're not done filling the current buffer, complain.
929                    Otherwise, complete the command normally. */
930                 if (rq->current_nr_sectors > 0) {
931                         printk ("%s: cdrom_read_intr: data underrun (%u blocks)\n",
932                                 drive->name, rq->current_nr_sectors);
933                         cdrom_end_request(drive, rq, 0);
934                 } else
935                         cdrom_end_request(drive, rq, 1);
936                 return ide_stopped;
937         }
938
939         /* Check that the drive is expecting to do the same thing we are. */
940         if (cdrom_read_check_ireason(drive, rq, len, ireason))
941                 return ide_stopped;
942
943         /* Assume that the drive will always provide data in multiples
944            of at least SECTOR_SIZE, as it gets hairy to keep track
945            of the transfers otherwise. */
946         if ((len % SECTOR_SIZE) != 0) {
947                 printk ("%s: cdrom_read_intr: Bad transfer size %d\n",
948                         drive->name, len);
949                 if (CDROM_CONFIG_FLAGS (drive)->limit_nframes)
950                         printk ("  This drive is not supported by this version of the driver\n");
951                 else {
952                         printk ("  Trying to limit transfer sizes\n");
953                         CDROM_CONFIG_FLAGS (drive)->limit_nframes = 1;
954                 }
955                 cdrom_end_request(drive, rq, 0);
956                 return ide_stopped;
957         }
958
959         /* The number of sectors we need to read from the drive. */
960         sectors_to_transfer = len / SECTOR_SIZE;
961
962         /* First, figure out if we need to bit-bucket
963            any of the leading sectors. */
964         nskip = MIN((int)(rq->current_nr_sectors - bio_sectors(rq->bio)), sectors_to_transfer);
965
966         while (nskip > 0) {
967                 /* We need to throw away a sector. */
968                 char dum[SECTOR_SIZE];
969                 atapi_read(drive, dum, SECTOR_SIZE);
970
971                 --rq->current_nr_sectors;
972                 --nskip;
973                 --sectors_to_transfer;
974         }
975
976         /* Now loop while we still have data to read from the drive. */
977         while (sectors_to_transfer > 0) {
978                 int this_transfer;
979
980                 /* If we've filled the present buffer but there's another
981                    chained buffer after it, move on. */
982                 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
983                         cdrom_end_request(drive, rq, 1);
984
985                 /* If the buffers are full, cache the rest of the data in our
986                    internal buffer. */
987                 if (rq->current_nr_sectors == 0) {
988                         cdrom_buffer_sectors(drive, rq->sector, sectors_to_transfer);
989                         sectors_to_transfer = 0;
990                 } else {
991                         /* Transfer data to the buffers.
992                            Figure out how many sectors we can transfer
993                            to the current buffer. */
994                         this_transfer = MIN (sectors_to_transfer,
995                                              rq->current_nr_sectors);
996
997                         /* Read this_transfer sectors
998                            into the current buffer. */
999                         while (this_transfer > 0) {
1000                                 atapi_read(drive, rq->buffer, SECTOR_SIZE);
1001                                 rq->buffer += SECTOR_SIZE;
1002                                 --rq->nr_sectors;
1003                                 --rq->current_nr_sectors;
1004                                 ++rq->sector;
1005                                 --this_transfer;
1006                                 --sectors_to_transfer;
1007                         }
1008                 }
1009         }
1010
1011         /* Done moving data! Wait for another interrupt. */
1012         ide_set_handler(drive, cdrom_read_intr, WAIT_CMD, NULL);
1013
1014         return ide_started;
1015 }
1016
1017 /*
1018  * Try to satisfy some of the current read request from our cached data.
1019  * Returns nonzero if the request has been completed, zero otherwise.
1020  */
1021 static int cdrom_read_from_buffer(struct ata_device *drive, struct request *rq)
1022 {
1023         struct cdrom_info *info = drive->driver_data;
1024
1025         /* Can't do anything if there's no buffer. */
1026         if (info->buffer == NULL) return 0;
1027
1028         /* Loop while this request needs data and the next block is present
1029            in our cache. */
1030         while (rq->nr_sectors > 0 &&
1031                rq->sector >= info->sector_buffered &&
1032                rq->sector < info->sector_buffered + info->nsectors_buffered) {
1033                 if (rq->current_nr_sectors == 0)
1034                         cdrom_end_request(drive, rq, 1);
1035
1036                 memcpy (rq->buffer,
1037                         info->buffer +
1038                         (rq->sector - info->sector_buffered) * SECTOR_SIZE,
1039                         SECTOR_SIZE);
1040                 rq->buffer += SECTOR_SIZE;
1041                 --rq->current_nr_sectors;
1042                 --rq->nr_sectors;
1043                 ++rq->sector;
1044         }
1045
1046         /* If we've satisfied the current request,
1047            terminate it successfully. */
1048         if (rq->nr_sectors == 0) {
1049                 cdrom_end_request(drive, rq, 1);
1050                 return -1;
1051         }
1052
1053         /* Move on to the next buffer if needed. */
1054         if (rq->current_nr_sectors == 0)
1055                 cdrom_end_request(drive, rq, 1);
1056
1057         /* If this condition does not hold, then the kluge i use to
1058            represent the number of sectors to skip at the start of a transfer
1059            will fail.  I think that this will never happen, but let's be
1060            paranoid and check. */
1061         if (rq->current_nr_sectors < bio_sectors(rq->bio) &&
1062             (rq->sector % SECTORS_PER_FRAME) != 0) {
1063                 printk ("%s: %s: buffer botch (%ld)\n",
1064                         drive->name, __FUNCTION__, rq->sector);
1065                 cdrom_end_request(drive, rq, 0);
1066                 return -1;
1067         }
1068
1069         return 0;
1070 }
1071
1072 /*
1073  * Routine to send a read packet command to the drive.  This is usually called
1074  * directly from cdrom_start_read.  However, for drq_interrupt devices, it is
1075  * called from an interrupt when the drive is ready to accept the command.
1076  */
1077 static ide_startstop_t cdrom_start_read_continuation(struct ata_device *drive, struct request *rq)
1078 {
1079         int nsect, sector, nframes, frame, nskip;
1080
1081         /* Number of sectors to transfer. */
1082         nsect = rq->nr_sectors;
1083
1084         /* Starting sector. */
1085         sector = rq->sector;
1086
1087         /* If the requested sector doesn't start on a cdrom block boundary,
1088            we must adjust the start of the transfer so that it does,
1089            and remember to skip the first few sectors.
1090            If the CURRENT_NR_SECTORS field is larger than the size
1091            of the buffer, it will mean that we're to skip a number
1092            of sectors equal to the amount by which CURRENT_NR_SECTORS
1093            is larger than the buffer size. */
1094         nskip = (sector % SECTORS_PER_FRAME);
1095         if (nskip > 0) {
1096                 /* Sanity check... */
1097                 if (rq->current_nr_sectors != bio_sectors(rq->bio) &&
1098                         (rq->sector % CD_FRAMESIZE != 0)) {
1099                         printk ("%s: %s: buffer botch (%u)\n",
1100                                 drive->name, __FUNCTION__, rq->current_nr_sectors);
1101                         cdrom_end_request(drive, rq, 0);
1102                         return ide_stopped;
1103                 }
1104                 sector -= nskip;
1105                 nsect += nskip;
1106                 rq->current_nr_sectors += nskip;
1107         }
1108
1109         /* Convert from sectors to cdrom blocks, rounding up the transfer
1110            length if needed. */
1111         nframes = (nsect + SECTORS_PER_FRAME-1) / SECTORS_PER_FRAME;
1112         frame = sector / SECTORS_PER_FRAME;
1113
1114         /* Largest number of frames was can transfer at once is 64k-1. For
1115            some drives we need to limit this even more. */
1116         nframes = MIN(nframes, (CDROM_CONFIG_FLAGS (drive)->limit_nframes) ?
1117                 (65534 / CD_FRAMESIZE) : 65535);
1118
1119         /* Send the command to the drive and return. */
1120         return cdrom_transfer_packet_command(drive, rq, rq->cmd, WAIT_CMD, &cdrom_read_intr);
1121 }
1122
1123
1124 #define IDECD_SEEK_THRESHOLD    (1000)                  /* 1000 blocks */
1125 #define IDECD_SEEK_TIMER        (5 * WAIT_MIN_SLEEP)    /* 100 ms */
1126 #define IDECD_SEEK_TIMEOUT     WAIT_CMD                 /* 10 sec */
1127
1128 static ide_startstop_t cdrom_seek_intr(struct ata_device *drive, struct request *rq)
1129 {
1130         struct cdrom_info *info = drive->driver_data;
1131         int stat;
1132         static int retry = 10;
1133         ide_startstop_t startstop;
1134
1135         if (cdrom_decode_status (&startstop, drive, rq, 0, &stat))
1136                 return startstop;
1137         CDROM_CONFIG_FLAGS(drive)->seeking = 1;
1138
1139         if (retry && jiffies - info->start_seek > IDECD_SEEK_TIMER) {
1140                 if (--retry == 0) {
1141                         /*
1142                          * this condition is far too common, to bother
1143                          * users about it
1144                          */
1145 #if 0
1146                         printk("%s: disabled DSC seek overlap\n", drive->name);
1147 #endif
1148                         drive->dsc_overlap = 0;
1149                 }
1150         }
1151         return ide_stopped;
1152 }
1153
1154 static ide_startstop_t cdrom_start_seek_continuation(struct ata_device *drive, struct request *rq)
1155 {
1156         unsigned char cmd[CDROM_PACKET_SIZE];
1157         sector_t sector;
1158         int frame, nskip;
1159
1160         sector = rq->sector;
1161         nskip = (sector % SECTORS_PER_FRAME);
1162         if (nskip > 0)
1163                 sector -= nskip;
1164         frame = sector / SECTORS_PER_FRAME;
1165
1166         memset(rq->cmd, 0, sizeof(rq->cmd));
1167         cmd[0] = GPCMD_SEEK;
1168         put_unaligned(cpu_to_be32(frame), (unsigned int *) &cmd[2]);
1169
1170         return cdrom_transfer_packet_command(drive, rq, cmd, WAIT_CMD, &cdrom_seek_intr);
1171 }
1172
1173 static ide_startstop_t cdrom_start_seek(struct ata_device *drive, struct request *rq, sector_t block)
1174 {
1175         struct cdrom_info *info = drive->driver_data;
1176
1177         info->dma = 0;
1178         info->cmd = 0;
1179         info->start_seek = jiffies;
1180         return cdrom_start_packet_command(drive, rq, 0, cdrom_start_seek_continuation);
1181 }
1182
1183 /*
1184  * Fix up a possibly partially-processed request so that we can
1185  * start it over entirely -- remember to call prep_rq_fn again since we
1186  * may have changed the layout
1187  */
1188 static void restore_request (struct request *rq)
1189 {
1190         if (rq->buffer != bio_data(rq->bio)) {
1191                 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
1192                 rq->buffer = bio_data(rq->bio);
1193                 rq->nr_sectors += n;
1194                 rq->sector -= n;
1195         }
1196         rq->hard_cur_sectors = rq->current_nr_sectors = bio_sectors(rq->bio);
1197         rq->hard_nr_sectors = rq->nr_sectors;
1198         rq->hard_sector = rq->sector;
1199         rq->q->prep_rq_fn(rq->q, rq);
1200 }
1201
1202 /*
1203  * Start a read request from the CD-ROM.
1204  */
1205 static ide_startstop_t cdrom_start_read(struct ata_device *drive, struct request *rq, sector_t block)
1206 {
1207         struct cdrom_info *info = drive->driver_data;
1208
1209         restore_request(rq);
1210
1211         /* Satisfy whatever we can of this request from our cached sector. */
1212         if (cdrom_read_from_buffer(drive, rq))
1213                 return ide_stopped;
1214
1215         blk_attempt_remerge(&drive->queue, rq);
1216
1217         /* Clear the local sector buffer. */
1218         info->nsectors_buffered = 0;
1219
1220         /* use dma, if possible. */
1221         if (drive->using_dma && (rq->sector % SECTORS_PER_FRAME == 0) &&
1222                                 (rq->nr_sectors % SECTORS_PER_FRAME == 0))
1223                 info->dma = 1;
1224         else
1225                 info->dma = 0;
1226
1227         info->cmd = READ;
1228         /* Start sending the read request to the drive. */
1229         return cdrom_start_packet_command(drive, rq, 32768, cdrom_start_read_continuation);
1230 }
1231
1232 /****************************************************************************
1233  * Execute all other packet commands.
1234  */
1235
1236 /* Interrupt routine for packet command completion. */
1237 static ide_startstop_t cdrom_pc_intr(struct ata_device *drive, struct request *rq)
1238 {
1239         int ireason, len, stat, thislen;
1240
1241         /* FIXME --mdcki */
1242         struct packet_command *pc = (struct packet_command *) rq->special;
1243         ide_startstop_t startstop;
1244
1245         /* Check for errors. */
1246         if (cdrom_decode_status (&startstop, drive, rq, 0, &stat))
1247                 return startstop;
1248
1249         /* Read the interrupt reason and the transfer length. */
1250         ireason = IN_BYTE (IDE_NSECTOR_REG);
1251         len = IN_BYTE (IDE_LCYL_REG) + 256 * IN_BYTE (IDE_HCYL_REG);
1252
1253         /* If DRQ is clear, the command has completed.
1254            Complain if we still have data left to transfer. */
1255         if ((stat & DRQ_STAT) == 0) {
1256                 /* Some of the trailing request sense fields are optional, and
1257                    some drives don't send them.  Sigh. */
1258                 if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
1259                     pc->buflen > 0 &&
1260                     pc->buflen <= 5) {
1261                         while (pc->buflen > 0) {
1262                                 *pc->buffer++ = 0;
1263                                 --pc->buflen;
1264                         }
1265                 }
1266
1267                 if (pc->buflen == 0)
1268                         cdrom_end_request(drive, rq, 1);
1269                 else {
1270                         /* Comment this out, because this always happens
1271                            right after a reset occurs, and it is annoying to
1272                            always print expected stuff.  */
1273                         /*
1274                         printk ("%s: cdrom_pc_intr: data underrun %d\n",
1275                                 drive->name, pc->buflen);
1276                         */
1277                         pc->stat = 1;
1278                         cdrom_end_request(drive, rq, 1);
1279                 }
1280                 return ide_stopped;
1281         }
1282
1283         /* Figure out how much data to transfer. */
1284         thislen = pc->buflen;
1285         if (thislen > len) thislen = len;
1286
1287         /* The drive wants to be written to. */
1288         if ((ireason & 3) == 0) {
1289                 /* Transfer the data. */
1290                 atapi_write(drive, pc->buffer, thislen);
1291
1292                 /* If we haven't moved enough data to satisfy the drive,
1293                    add some padding. */
1294                 while (len > thislen) {
1295                         int dum = 0;
1296
1297                         atapi_write(drive, &dum, sizeof (dum));
1298                         len -= sizeof (dum);
1299                 }
1300
1301                 /* Keep count of how much data we've moved. */
1302                 pc->buffer += thislen;
1303                 pc->buflen -= thislen;
1304         }
1305
1306         /* Same drill for reading. */
1307         else if ((ireason & 3) == 2) {
1308                 /* Transfer the data. */
1309                 atapi_read(drive, pc->buffer, thislen);
1310
1311                 /* If we haven't moved enough data to satisfy the drive,
1312                    add some padding. */
1313                 while (len > thislen) {
1314                         int dum = 0;
1315                         atapi_read(drive, &dum, sizeof (dum));
1316                         len -= sizeof (dum);
1317                 }
1318
1319                 /* Keep count of how much data we've moved. */
1320                 pc->buffer += thislen;
1321                 pc->buflen -= thislen;
1322         } else {
1323                 printk ("%s: cdrom_pc_intr: The drive "
1324                         "appears confused (ireason = 0x%2x)\n",
1325                         drive->name, ireason);
1326                 pc->stat = 1;
1327         }
1328
1329         /* Now we wait for another interrupt. */
1330         ide_set_handler(drive, cdrom_pc_intr, WAIT_CMD, cdrom_timer_expiry);
1331
1332         return ide_started;
1333 }
1334
1335 static ide_startstop_t cdrom_do_pc_continuation(struct ata_device *drive, struct request *rq)
1336 {
1337         unsigned long timeout;
1338
1339         /* FIXME --mdcki */
1340         struct packet_command *pc = (struct packet_command *) rq->special;
1341
1342         if (pc->timeout)
1343                 timeout = pc->timeout;
1344         else
1345                 timeout = WAIT_CMD;
1346
1347         /* Send the command to the drive and return. */
1348         return cdrom_transfer_packet_command(drive, rq, rq->cmd, timeout, &cdrom_pc_intr);
1349 }
1350
1351 static ide_startstop_t cdrom_do_packet_command(struct ata_device *drive, struct request *rq)
1352 {
1353         int len;
1354
1355         /* FIXME --mdcki */
1356         struct packet_command *pc = (struct packet_command *) rq->special;
1357         struct cdrom_info *info = drive->driver_data;
1358
1359         info->dma = 0;
1360         info->cmd = 0;
1361         pc->stat = 0;
1362         len = pc->buflen;
1363
1364         /* Start sending the command to the drive. */
1365         return cdrom_start_packet_command (drive, rq, len, cdrom_do_pc_continuation);
1366 }
1367
1368
1369 /* Sleep for TIME jiffies.
1370    Not to be called from an interrupt handler. */
1371 static
1372 void cdrom_sleep (int time)
1373 {
1374         int sleep = time;
1375
1376         do {
1377                 set_current_state(TASK_INTERRUPTIBLE);
1378                 sleep = schedule_timeout(sleep);
1379         } while (sleep);
1380 }
1381
1382 static
1383 int cdrom_queue_packet_command(struct ata_device *drive, unsigned char *cmd,
1384                 struct request_sense *sense, struct packet_command *pc)
1385 {
1386         struct request rq;
1387         int retries = 10;
1388
1389         /* Start of retry loop. */
1390         do {
1391                 ide_init_drive_cmd(&rq);
1392                 memcpy(rq.cmd, cmd, CDROM_PACKET_SIZE);
1393
1394                 rq.flags = REQ_PC;
1395
1396                 /* FIXME --mdcki */
1397                 rq.special = (void *) pc;
1398                 if (ide_do_drive_cmd(drive, &rq, ide_wait)) {
1399                         printk("%s: do_drive_cmd returned stat=%02x,err=%02x\n",
1400                                 drive->name, rq.buffer[0], rq.buffer[1]);
1401
1402                         /* FIXME: we should probably abort/retry or something */
1403                         if (sense) {
1404
1405                                 /* Decode the error here at least for error
1406                                  * reporting to upper layers.!
1407                                  */
1408
1409                         }
1410                 }
1411                 if (pc->stat != 0) {
1412                         /* The request failed.  Retry if it was due to a unit
1413                            attention status
1414                            (usually means media was changed). */
1415
1416                         if (sense && sense->sense_key == UNIT_ATTENTION)
1417                                 cdrom_saw_media_change (drive);
1418                         else if (sense && sense->sense_key == NOT_READY &&
1419                                  sense->asc == 4 && sense->ascq != 4) {
1420                                 /* The drive is in the process of loading
1421                                    a disk.  Retry, but wait a little to give
1422                                    the drive time to complete the load. */
1423                                 cdrom_sleep(2 * HZ);
1424                         } else {
1425                                 /* Otherwise, don't retry. */
1426                                 retries = 0;
1427                         }
1428                         --retries;
1429                 }
1430
1431                 /* End of retry loop. */
1432         } while (pc->stat != 0 && retries >= 0);
1433
1434         /* Return an error if the command failed. */
1435         return pc->stat ? -EIO : 0;
1436 }
1437
1438 /*
1439  * Write handling
1440  */
1441 static inline int cdrom_write_check_ireason(struct ata_device *drive, struct request *rq,
1442         int len, int ireason)
1443 {
1444         /* Two notes about IDE interrupt reason here - 0 means that
1445          * the drive wants to receive data from us, 2 means that
1446          * the drive is expecting data from us.
1447          */
1448         ireason &= 3;
1449
1450         if (ireason == 2) {
1451                 /* Whoops... The drive wants to send data. */
1452                 printk("%s: cdrom_write_intr: wrong transfer direction!\n",
1453                         drive->name);
1454
1455                 /* Throw some data at the drive so it doesn't hang
1456                    and quit this request. */
1457                 while (len > 0) {
1458                         int dum = 0;
1459                         atapi_write(drive, &dum, sizeof(dum));
1460                         len -= sizeof(dum);
1461                 }
1462         } else {
1463                 /* Drive wants a command packet, or invalid ireason... */
1464                 printk("%s: cdrom_write_intr: bad interrupt reason %d\n",
1465                         drive->name, ireason);
1466         }
1467
1468         cdrom_end_request(drive, rq, 0);
1469         return 1;
1470 }
1471
1472 static ide_startstop_t cdrom_write_intr(struct ata_device *drive, struct request *rq)
1473 {
1474         int stat, ireason, len, sectors_to_transfer, uptodate;
1475         struct cdrom_info *info = drive->driver_data;
1476         int dma_error = 0, dma = info->dma;
1477         ide_startstop_t startstop;
1478
1479         /* Check for errors. */
1480         if (dma) {
1481                 info->dma = 0;
1482                 if ((dma_error = udma_stop(drive))) {
1483                         printk("ide-cd: write dma error\n");
1484                         udma_enable(drive, 0, 1);
1485                 }
1486         }
1487
1488         if (cdrom_decode_status(&startstop, drive, rq, 0, &stat)) {
1489                 printk("ide-cd: write_intr decode_status bad\n");
1490                 return startstop;
1491         }
1492
1493         /*
1494          * using dma, transfer is complete now
1495          */
1496         if (dma) {
1497                 if (dma_error)
1498                         return ide_error(drive, rq, "dma error", stat);
1499
1500                 __ide_end_request(drive, rq, 1, rq->nr_sectors);
1501                 return ide_stopped;
1502         }
1503
1504         /* Read the interrupt reason and the transfer length. */
1505         ireason = IN_BYTE(IDE_NSECTOR_REG);
1506         len = IN_BYTE(IDE_LCYL_REG) + 256 * IN_BYTE(IDE_HCYL_REG);
1507
1508         /* If DRQ is clear, the command has completed. */
1509         if ((stat & DRQ_STAT) == 0) {
1510                 /* If we're not done writing, complain.
1511                  * Otherwise, complete the command normally.
1512                  */
1513                 uptodate = 1;
1514                 if (rq->current_nr_sectors > 0) {
1515                         printk("%s: write_intr: data underrun (%u blocks)\n",
1516                         drive->name, rq->current_nr_sectors);
1517                         uptodate = 0;
1518                 }
1519                 cdrom_end_request(drive, rq, uptodate);
1520                 return ide_stopped;
1521         }
1522
1523         /* Check that the drive is expecting to do the same thing we are. */
1524         if (ireason & 3)
1525                 if (cdrom_write_check_ireason(drive, rq, len, ireason))
1526                         return ide_stopped;
1527
1528         sectors_to_transfer = len / SECTOR_SIZE;
1529
1530         /*
1531          * now loop and write out the data
1532          */
1533         while (sectors_to_transfer > 0) {
1534                 int this_transfer;
1535
1536                 if (!rq->current_nr_sectors) {
1537                         printk("ide-cd: write_intr: oops\n");
1538                         break;
1539                 }
1540
1541                 /*
1542                  * Figure out how many sectors we can transfer
1543                  */
1544                 this_transfer = MIN(sectors_to_transfer,rq->current_nr_sectors);
1545
1546                 while (this_transfer > 0) {
1547                         atapi_write(drive, rq->buffer, SECTOR_SIZE);
1548                         rq->buffer += SECTOR_SIZE;
1549                         --rq->nr_sectors;
1550                         --rq->current_nr_sectors;
1551                         ++rq->sector;
1552                         --this_transfer;
1553                         --sectors_to_transfer;
1554                 }
1555
1556                 /*
1557                  * current buffer complete, move on
1558                  */
1559                 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1560                         cdrom_end_request(drive, rq, 1);
1561         }
1562
1563         /* re-arm handler */
1564         ide_set_handler(drive, cdrom_write_intr, 5 * WAIT_CMD, NULL);
1565
1566         return ide_started;
1567 }
1568
1569 static ide_startstop_t cdrom_start_write_cont(struct ata_device *drive, struct request *rq)
1570 {
1571         return cdrom_transfer_packet_command(drive, rq, rq->cmd, 2 * WAIT_CMD, cdrom_write_intr);
1572 }
1573
1574 static ide_startstop_t cdrom_start_write(struct ata_device *drive, struct request *rq)
1575 {
1576         struct cdrom_info *info = drive->driver_data;
1577
1578         /*
1579          * writes *must* be 2kB frame aligned
1580          */
1581         if ((rq->nr_sectors & 3) || (rq->sector & 3)) {
1582                 cdrom_end_request(drive, rq, 0);
1583                 return ide_stopped;
1584         }
1585
1586         /*
1587          * for dvd-ram and such media, it's a really big deal to get
1588          * big writes all the time. so scour the queue and attempt to
1589          * remerge requests, often the plugging will not have had time
1590          * to do this properly
1591          */
1592         blk_attempt_remerge(&drive->queue, rq);
1593
1594         info->nsectors_buffered = 0;
1595
1596         /* use dma, if possible. we don't need to check more, since we
1597          * know that the transfer is always (at least!) 2KB aligned */
1598         info->dma = drive->using_dma ? 1 : 0;
1599         info->cmd = WRITE;
1600
1601         /* Start sending the read request to the drive. */
1602         return cdrom_start_packet_command(drive, rq, 32768, cdrom_start_write_cont);
1603 }
1604
1605 #define IDE_LARGE_SEEK(b1,b2,t) (((b1) > (b2) + (t)) || ((b2) > (b1) + (t)))
1606
1607 /****************************************************************************
1608  * cdrom driver request routine.
1609  */
1610 static ide_startstop_t
1611 ide_cdrom_do_request(struct ata_device *drive, struct request *rq, sector_t block)
1612 {
1613         ide_startstop_t action;
1614         struct cdrom_info *info = drive->driver_data;
1615
1616         if (rq->flags & REQ_CMD) {
1617                 if (CDROM_CONFIG_FLAGS(drive)->seeking) {
1618                         unsigned long elpased = jiffies - info->start_seek;
1619                         int stat = GET_STAT();
1620
1621                         if ((stat & SEEK_STAT) != SEEK_STAT) {
1622                                 if (elpased < IDECD_SEEK_TIMEOUT) {
1623                                         ide_stall_queue(drive, IDECD_SEEK_TIMER);
1624                                         return ide_stopped;
1625                                 }
1626                                 printk ("%s: DSC timeout\n", drive->name);
1627                         }
1628                         CDROM_CONFIG_FLAGS(drive)->seeking = 0;
1629                 }
1630                 if (IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap)
1631                         action = cdrom_start_seek(drive, rq, block);
1632                 else {
1633                         if (rq_data_dir(rq) == READ)
1634                                 action = cdrom_start_read(drive, rq, block);
1635                         else
1636                                 action = cdrom_start_write(drive, rq);
1637                 }
1638                 info->last_block = block;
1639                 return action;
1640         } else if (rq->flags & (REQ_PC | REQ_SENSE)) {
1641                 return cdrom_do_packet_command(drive, rq);
1642         } else if (rq->flags & REQ_SPECIAL) {
1643                 /*
1644                  * FIXME: Kill REQ_SEPCIAL and replace it with commands queued
1645                  * at the request queue instead as suggested by Linus.
1646                  *
1647                  * right now this can only be a reset...
1648                  */
1649
1650                 cdrom_end_request(drive, rq, 1);
1651                 return ide_stopped;
1652         } else if (rq->flags & REQ_BLOCK_PC) {
1653                 struct packet_command pc;
1654                 ide_startstop_t startstop;
1655
1656                 memset(&pc, 0, sizeof(pc));
1657                 pc.quiet = 1;
1658                 pc.timeout = 60 * HZ;
1659
1660                 /* FIXME --mdcki */
1661                 rq->special = (char *) &pc;
1662
1663                 startstop = cdrom_do_packet_command(drive, rq);
1664                 if (pc.stat)
1665                         ++rq->errors;
1666
1667                 return startstop;
1668         }
1669
1670         blk_dump_rq_flags(rq, "ide-cd bad flags");
1671         cdrom_end_request(drive, rq, 0);
1672         return ide_stopped;
1673 }
1674
1675
1676
1677 /****************************************************************************
1678  * Ioctl handling.
1679  *
1680  * Routines which queue packet commands take as a final argument a pointer
1681  * to a request_sense struct.  If execution of the command results
1682  * in an error with a CHECK CONDITION status, this structure will be filled
1683  * with the results of the subsequent request sense command.  The pointer
1684  * can also be NULL, in which case no sense information is returned.
1685  */
1686
1687 #if ! STANDARD_ATAPI
1688 static inline
1689 int bin2bcd (int x)
1690 {
1691         return (x%10) | ((x/10) << 4);
1692 }
1693
1694
1695 static inline
1696 int bcd2bin (int x)
1697 {
1698         return (x >> 4) * 10 + (x & 0x0f);
1699 }
1700
1701 static
1702 void msf_from_bcd (struct atapi_msf *msf)
1703 {
1704         msf->minute = bcd2bin (msf->minute);
1705         msf->second = bcd2bin (msf->second);
1706         msf->frame  = bcd2bin (msf->frame);
1707 }
1708
1709 #endif /* not STANDARD_ATAPI */
1710
1711
1712 static inline
1713 void lba_to_msf (int lba, byte *m, byte *s, byte *f)
1714 {
1715         lba += CD_MSF_OFFSET;
1716         lba &= 0xffffff;  /* negative lbas use only 24 bits */
1717         *m = lba / (CD_SECS * CD_FRAMES);
1718         lba %= (CD_SECS * CD_FRAMES);
1719         *s = lba / CD_FRAMES;
1720         *f = lba % CD_FRAMES;
1721 }
1722
1723
1724 static inline
1725 int msf_to_lba (byte m, byte s, byte f)
1726 {
1727         return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
1728 }
1729
1730 static int cdrom_check_status(struct ata_device *drive, struct request_sense *sense)
1731 {
1732         unsigned char cmd[CDROM_PACKET_SIZE];
1733         struct packet_command pc;
1734         struct cdrom_info *info = drive->driver_data;
1735         struct cdrom_device_info *cdi = &info->devinfo;
1736
1737         memset(&pc, 0, sizeof(pc));
1738         pc.sense = sense;
1739
1740         cmd[0] = GPCMD_TEST_UNIT_READY;
1741
1742 #if !STANDARD_ATAPI
1743         /* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
1744            switch CDs instead of supporting the LOAD_UNLOAD opcode   */
1745
1746         cmd[7] = cdi->sanyo_slot % 3;
1747 #endif
1748
1749         return cdrom_queue_packet_command(drive, cmd, sense, &pc);
1750 }
1751
1752
1753 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
1754 static int
1755 cdrom_lockdoor(struct ata_device *drive, int lockflag, struct request_sense *sense)
1756 {
1757         struct packet_command pc;
1758         int stat;
1759
1760         /* If the drive cannot lock the door, just pretend. */
1761         if (CDROM_CONFIG_FLAGS(drive)->no_doorlock) {
1762                 stat = 0;
1763         } else {
1764                 unsigned char cmd[CDROM_PACKET_SIZE];
1765
1766                 memset(&pc, 0, sizeof(pc));
1767                 pc.sense = sense;
1768                 cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
1769                 cmd[4] = lockflag ? 1 : 0;
1770                 stat = cdrom_queue_packet_command(drive, cmd, sense, &pc);
1771         }
1772
1773         /* If we got an illegal field error, the drive
1774            probably cannot lock the door. */
1775         if (stat != 0 &&
1776             sense->sense_key == ILLEGAL_REQUEST &&
1777             (sense->asc == 0x24 || sense->asc == 0x20)) {
1778                 printk ("%s: door locking not supported\n",
1779                         drive->name);
1780                 CDROM_CONFIG_FLAGS (drive)->no_doorlock = 1;
1781                 stat = 0;
1782         }
1783
1784         /* no medium, that's alright. */
1785         if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
1786                 stat = 0;
1787
1788         if (stat == 0)
1789                 CDROM_STATE_FLAGS (drive)->door_locked = lockflag;
1790
1791         return stat;
1792 }
1793
1794
1795 /* Eject the disk if EJECTFLAG is 0.
1796    If EJECTFLAG is 1, try to reload the disk. */
1797 static int cdrom_eject(struct ata_device *drive, int ejectflag,
1798                        struct request_sense *sense)
1799 {
1800         struct packet_command pc;
1801         unsigned char cmd[CDROM_PACKET_SIZE];
1802
1803         if (CDROM_CONFIG_FLAGS(drive)->no_eject && !ejectflag)
1804                 return -EDRIVE_CANT_DO_THIS;
1805
1806         /* reload fails on some drives, if the tray is locked */
1807         if (CDROM_STATE_FLAGS(drive)->door_locked && ejectflag)
1808                 return 0;
1809
1810         memset(&pc, 0, sizeof (pc));
1811         pc.sense = sense;
1812
1813         cmd[0] = GPCMD_START_STOP_UNIT;
1814         cmd[4] = 0x02 + (ejectflag != 0);
1815         return cdrom_queue_packet_command(drive, cmd, sense, &pc);
1816 }
1817
1818 static int cdrom_read_capacity(struct ata_device *drive, u32 *capacity,
1819                                struct request_sense *sense)
1820 {
1821         struct {
1822                 __u32 lba;
1823                 __u32 blocklen;
1824         } capbuf;
1825
1826         int stat;
1827         unsigned char cmd[CDROM_PACKET_SIZE];
1828         struct packet_command pc;
1829
1830         memset(&pc, 0, sizeof(pc));
1831         pc.sense = sense;
1832
1833         cmd[0] = GPCMD_READ_CDVD_CAPACITY;
1834         pc.buffer = (char *)&capbuf;
1835         pc.buflen = sizeof(capbuf);
1836         stat = cdrom_queue_packet_command(drive, cmd, sense, &pc);
1837         if (stat == 0)
1838                 *capacity = 1 + be32_to_cpu(capbuf.lba);
1839
1840         return stat;
1841 }
1842
1843 static int cdrom_read_tocentry(struct ata_device *drive, int trackno, int msf_flag,
1844                                 int format, char *buf, int buflen,
1845                                 struct request_sense *sense)
1846 {
1847         unsigned char cmd[CDROM_PACKET_SIZE];
1848         struct packet_command pc;
1849
1850         memset(&pc, 0, sizeof(pc));
1851         pc.sense = sense;
1852
1853         pc.buffer =  buf;
1854         pc.buflen = buflen;
1855         pc.quiet = 1;
1856
1857         cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
1858         if (msf_flag)
1859                 cmd[1] = 2;
1860         cmd[6] = trackno;
1861         cmd[7] = (buflen >> 8);
1862         cmd[8] = (buflen & 0xff);
1863         cmd[9] = (format << 6);
1864
1865         return cdrom_queue_packet_command(drive, cmd, sense, &pc);
1866 }
1867
1868
1869 /* Try to read the entire TOC for the disk into our internal buffer. */
1870 static int cdrom_read_toc(struct ata_device *drive, struct request_sense *sense)
1871 {
1872         int minor, stat, ntracks, i;
1873         kdev_t dev;
1874         struct cdrom_info *info = drive->driver_data;
1875         struct atapi_toc *toc = info->toc;
1876         struct {
1877                 struct atapi_toc_header hdr;
1878                 struct atapi_toc_entry  ent;
1879         } ms_tmp;
1880
1881         if (toc == NULL) {
1882                 /* Try to allocate space. */
1883                 toc = (struct atapi_toc *) kmalloc (sizeof (struct atapi_toc),
1884                                                     GFP_KERNEL);
1885                 info->toc = toc;
1886                 if (toc == NULL) {
1887                         printk ("%s: No cdrom TOC buffer!\n", drive->name);
1888                         return -ENOMEM;
1889                 }
1890         }
1891
1892         /* Check to see if the existing data is still valid.
1893            If it is, just return. */
1894         cdrom_check_status(drive, sense);
1895
1896         if (CDROM_STATE_FLAGS(drive)->toc_valid)
1897                 return 0;
1898
1899         /* First read just the header, so we know how long the TOC is. */
1900         stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
1901                                     sizeof(struct atapi_toc_header), sense);
1902         if (stat) return stat;
1903
1904 #if ! STANDARD_ATAPI
1905         if (CDROM_CONFIG_FLAGS (drive)->toctracks_as_bcd) {
1906                 toc->hdr.first_track = bcd2bin (toc->hdr.first_track);
1907                 toc->hdr.last_track  = bcd2bin (toc->hdr.last_track);
1908         }
1909 #endif  /* not STANDARD_ATAPI */
1910
1911         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
1912         if (ntracks <= 0)
1913                 return -EIO;
1914         if (ntracks > MAX_TRACKS)
1915                 ntracks = MAX_TRACKS;
1916
1917         /* Now read the whole schmeer. */
1918         stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
1919                                   (char *)&toc->hdr,
1920                                    sizeof(struct atapi_toc_header) +
1921                                    (ntracks + 1) *
1922                                    sizeof(struct atapi_toc_entry), sense);
1923
1924         if (stat && toc->hdr.first_track > 1) {
1925                 /* Cds with CDI tracks only don't have any TOC entries,
1926                    despite of this the returned values are
1927                    first_track == last_track = number of CDI tracks + 1,
1928                    so that this case is indistinguishable from the same
1929                    layout plus an additional audio track.
1930                    If we get an error for the regular case, we assume
1931                    a CDI without additional audio tracks. In this case
1932                    the readable TOC is empty (CDI tracks are not included)
1933                    and only holds the Leadout entry. Heiko EiƟfeldt */
1934                 ntracks = 0;
1935                 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
1936                                            (char *)&toc->hdr,
1937                                            sizeof(struct atapi_toc_header) +
1938                                            (ntracks + 1) *
1939                                            sizeof(struct atapi_toc_entry),
1940                                            sense);
1941                 if (stat) {
1942                         return stat;
1943                 }
1944 #if ! STANDARD_ATAPI
1945                 if (CDROM_CONFIG_FLAGS (drive)->toctracks_as_bcd) {
1946                         toc->hdr.first_track = bin2bcd(CDROM_LEADOUT);
1947                         toc->hdr.last_track = bin2bcd(CDROM_LEADOUT);
1948                 } else
1949 #endif  /* not STANDARD_ATAPI */
1950                 {
1951                         toc->hdr.first_track = CDROM_LEADOUT;
1952                         toc->hdr.last_track = CDROM_LEADOUT;
1953                 }
1954         }
1955
1956         if (stat)
1957                 return stat;
1958
1959         toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
1960
1961 #if ! STANDARD_ATAPI
1962         if (CDROM_CONFIG_FLAGS (drive)->toctracks_as_bcd) {
1963                 toc->hdr.first_track = bcd2bin (toc->hdr.first_track);
1964                 toc->hdr.last_track  = bcd2bin (toc->hdr.last_track);
1965         }
1966 #endif  /* not STANDARD_ATAPI */
1967
1968         for (i=0; i<=ntracks; i++) {
1969 #if ! STANDARD_ATAPI
1970                 if (CDROM_CONFIG_FLAGS (drive)->tocaddr_as_bcd) {
1971                         if (CDROM_CONFIG_FLAGS (drive)->toctracks_as_bcd)
1972                                 toc->ent[i].track = bcd2bin (toc->ent[i].track);
1973                         msf_from_bcd (&toc->ent[i].addr.msf);
1974                 }
1975 #endif  /* not STANDARD_ATAPI */
1976                 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
1977                                                    toc->ent[i].addr.msf.second,
1978                                                    toc->ent[i].addr.msf.frame);
1979         }
1980
1981         /* Read the multisession information. */
1982         if (toc->hdr.first_track != CDROM_LEADOUT) {
1983                 /* Read the multisession information. */
1984                 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
1985                                            sizeof(ms_tmp), sense);
1986                 if (stat) return stat;
1987         } else {
1988                 ms_tmp.ent.addr.msf.minute = 0;
1989                 ms_tmp.ent.addr.msf.second = 2;
1990                 ms_tmp.ent.addr.msf.frame  = 0;
1991                 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
1992         }
1993
1994 #if ! STANDARD_ATAPI
1995         if (CDROM_CONFIG_FLAGS (drive)->tocaddr_as_bcd)
1996                 msf_from_bcd (&ms_tmp.ent.addr.msf);
1997 #endif  /* not STANDARD_ATAPI */
1998
1999         toc->last_session_lba = msf_to_lba (ms_tmp.ent.addr.msf.minute,
2000                                             ms_tmp.ent.addr.msf.second,
2001                                             ms_tmp.ent.addr.msf.frame);
2002
2003         toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
2004
2005         /* Now try to get the total cdrom capacity. */
2006         minor = (drive->select.b.unit) << PARTN_BITS;
2007         dev = mk_kdev(drive->channel->major, minor);
2008         /* FIXME: This is making worng assumptions about register layout. */
2009         stat = cdrom_get_last_written(dev, (unsigned long *) &toc->capacity);
2010         if (stat)
2011                 stat = cdrom_read_capacity(drive, &toc->capacity, sense);
2012         if (stat)
2013                 toc->capacity = 0x1fffff;
2014
2015         drive->channel->gd->sizes[drive->select.b.unit << PARTN_BITS] = (toc->capacity * SECTORS_PER_FRAME) >> (BLOCK_SIZE_BITS - 9);
2016         drive->part[0].nr_sects = toc->capacity * SECTORS_PER_FRAME;
2017
2018         /* Remember that we've read this stuff. */
2019         CDROM_STATE_FLAGS (drive)->toc_valid = 1;
2020
2021         return 0;
2022 }
2023
2024
2025 static int cdrom_read_subchannel(struct ata_device *drive, int format, char *buf,
2026                                  int buflen, struct request_sense *sense)
2027 {
2028         unsigned char cmd[CDROM_PACKET_SIZE];
2029         struct packet_command pc;
2030
2031         memset(&pc, 0, sizeof(pc));
2032         pc.sense = sense;
2033
2034         pc.buffer = buf;
2035         pc.buflen = buflen;
2036         cmd[0] = GPCMD_READ_SUBCHANNEL;
2037         cmd[1] = 2;     /* MSF addressing */
2038         cmd[2] = 0x40;  /* request subQ data */
2039         cmd[3] = format;
2040         cmd[7] = (buflen >> 8);
2041         cmd[8] = (buflen & 0xff);
2042
2043         return cdrom_queue_packet_command(drive, cmd, sense, &pc);
2044 }
2045
2046 /* ATAPI cdrom drives are free to select the speed you request or any slower
2047    rate :-( Requesting too fast a speed will _not_ produce an error. */
2048 static int cdrom_select_speed(struct ata_device *drive, int speed,
2049                               struct request_sense *sense)
2050 {
2051         unsigned char cmd[CDROM_PACKET_SIZE];
2052         struct packet_command pc;
2053         memset(&pc, 0, sizeof(pc));
2054         pc.sense = sense;
2055
2056         if (speed == 0)
2057                 speed = 0xffff; /* set to max */
2058         else
2059                 speed *= 177;   /* Nx to kbytes/s */
2060
2061         cmd[0] = GPCMD_SET_SPEED;
2062         /* Read Drive speed in kbytes/second MSB */
2063         cmd[2] = (speed >> 8) & 0xff;
2064         /* Read Drive speed in kbytes/second LSB */
2065         cmd[3] = speed & 0xff;
2066         if (CDROM_CONFIG_FLAGS(drive)->cd_r ||
2067             CDROM_CONFIG_FLAGS(drive)->cd_rw ||
2068             CDROM_CONFIG_FLAGS(drive)->dvd_r) {
2069                 /* Write Drive speed in kbytes/second MSB */
2070                 cmd[4] = (speed >> 8) & 0xff;
2071                 /* Write Drive speed in kbytes/second LSB */
2072                 cmd[5] = speed & 0xff;
2073        }
2074
2075         return cdrom_queue_packet_command(drive, cmd, sense, &pc);
2076 }
2077
2078 static int cdrom_play_audio(struct ata_device *drive, int lba_start, int lba_end)
2079 {
2080         struct request_sense sense;
2081         unsigned char cmd[CDROM_PACKET_SIZE];
2082         struct packet_command pc;
2083
2084         memset(&pc, 0, sizeof (pc));
2085         pc.sense = &sense;
2086
2087         cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2088         lba_to_msf(lba_start, &cmd[3], &cmd[4], &cmd[5]);
2089         lba_to_msf(lba_end-1, &cmd[6], &cmd[7], &cmd[8]);
2090
2091         return cdrom_queue_packet_command(drive, cmd, &sense, &pc);
2092 }
2093
2094 static int cdrom_get_toc_entry(struct ata_device *drive, int track,
2095                                 struct atapi_toc_entry **ent)
2096 {
2097         struct cdrom_info *info = drive->driver_data;
2098         struct atapi_toc *toc = info->toc;
2099         int ntracks;
2100
2101         /*
2102          * don't serve cached data, if the toc isn't valid
2103          */
2104         if (!CDROM_STATE_FLAGS(drive)->toc_valid)
2105                 return -EINVAL;
2106
2107         /* Check validity of requested track number. */
2108         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2109         if (toc->hdr.first_track == CDROM_LEADOUT) ntracks = 0;
2110         if (track == CDROM_LEADOUT)
2111                 *ent = &toc->ent[ntracks];
2112         else if (track < toc->hdr.first_track ||
2113                  track > toc->hdr.last_track)
2114                 return -EINVAL;
2115         else
2116                 *ent = &toc->ent[track - toc->hdr.first_track];
2117
2118         return 0;
2119 }
2120
2121 /* the generic packet interface to cdrom.c */
2122 static int ide_cdrom_packet(struct cdrom_device_info *cdi,
2123                             struct cdrom_generic_command *cgc)
2124 {
2125         struct packet_command pc;
2126         struct ata_device *drive = (struct ata_device *) cdi->handle;
2127
2128         if (cgc->timeout <= 0)
2129                 cgc->timeout = WAIT_CMD;
2130
2131         /* here we queue the commands from the uniform CD-ROM
2132            layer. the packet must be complete, as we do not
2133            touch it at all. */
2134         memset(&pc, 0, sizeof(pc));
2135         pc.buffer = cgc->buffer;
2136         pc.buflen = cgc->buflen;
2137         pc.quiet = cgc->quiet;
2138         pc.timeout = cgc->timeout;
2139         pc.sense = cgc->sense;
2140         cgc->stat = cdrom_queue_packet_command(drive, cgc->cmd, cgc->sense, &pc);
2141         if (!cgc->stat)
2142                 cgc->buflen -= pc.buflen;
2143
2144         return cgc->stat;
2145 }
2146
2147
2148 static
2149 int ide_cdrom_dev_ioctl (struct cdrom_device_info *cdi,
2150                          unsigned int cmd, unsigned long arg)
2151 {
2152         struct cdrom_generic_command cgc;
2153         char buffer[16];
2154         int stat;
2155
2156         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2157
2158         /* These will be moved into the Uniform layer shortly... */
2159         switch (cmd) {
2160         case CDROMSETSPINDOWN: {
2161                 char spindown;
2162
2163                 if (copy_from_user(&spindown, (void *) arg, sizeof(char)))
2164                         return -EFAULT;
2165
2166                 if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0)))
2167                         return stat;
2168
2169                 buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
2170
2171                 return cdrom_mode_select(cdi, &cgc);
2172         }
2173
2174         case CDROMGETSPINDOWN: {
2175                 char spindown;
2176
2177                 if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0)))
2178                         return stat;
2179
2180                 spindown = buffer[11] & 0x0f;
2181
2182                 if (copy_to_user((void *) arg, &spindown, sizeof (char)))
2183                         return -EFAULT;
2184
2185                 return 0;
2186         }
2187
2188         default:
2189                 return -EINVAL;
2190         }
2191
2192 }
2193
2194 static
2195 int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
2196                            unsigned int cmd, void *arg)
2197 {
2198         struct ata_device *drive = (struct ata_device *) cdi->handle;
2199         struct cdrom_info *info = drive->driver_data;
2200         int stat;
2201
2202         switch (cmd) {
2203         /*
2204          * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
2205          * atapi doesn't support it
2206          */
2207         case CDROMPLAYTRKIND: {
2208                 unsigned long lba_start, lba_end;
2209                 struct cdrom_ti *ti = (struct cdrom_ti *)arg;
2210                 struct atapi_toc_entry *first_toc, *last_toc;
2211
2212                 stat = cdrom_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
2213                 if (stat)
2214                         return stat;
2215
2216                 stat = cdrom_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
2217                 if (stat)
2218                         return stat;
2219
2220                 if (ti->cdti_trk1 != CDROM_LEADOUT)
2221                         ++last_toc;
2222                 lba_start = first_toc->addr.lba;
2223                 lba_end   = last_toc->addr.lba;
2224
2225                 if (lba_end <= lba_start)
2226                         return -EINVAL;
2227
2228                 return cdrom_play_audio(drive, lba_start, lba_end);
2229         }
2230
2231         case CDROMREADTOCHDR: {
2232                 struct cdrom_tochdr *tochdr = (struct cdrom_tochdr *) arg;
2233                 struct atapi_toc *toc;
2234
2235                 /* Make sure our saved TOC is valid. */
2236                 stat = cdrom_read_toc(drive, NULL);
2237                 if (stat) return stat;
2238
2239                 toc = info->toc;
2240                 tochdr->cdth_trk0 = toc->hdr.first_track;
2241                 tochdr->cdth_trk1 = toc->hdr.last_track;
2242
2243                 return 0;
2244         }
2245
2246         case CDROMREADTOCENTRY: {
2247                 struct cdrom_tocentry *tocentry = (struct cdrom_tocentry*) arg;
2248                 struct atapi_toc_entry *toce;
2249
2250                 stat = cdrom_get_toc_entry (drive, tocentry->cdte_track, &toce);
2251                 if (stat) return stat;
2252
2253                 tocentry->cdte_ctrl = toce->control;
2254                 tocentry->cdte_adr  = toce->adr;
2255                 if (tocentry->cdte_format == CDROM_MSF) {
2256                         lba_to_msf (toce->addr.lba,
2257                                    &tocentry->cdte_addr.msf.minute,
2258                                    &tocentry->cdte_addr.msf.second,
2259                                    &tocentry->cdte_addr.msf.frame);
2260                 } else
2261                         tocentry->cdte_addr.lba = toce->addr.lba;
2262
2263                 return 0;
2264         }
2265
2266         default:
2267                 return -EINVAL;
2268         }
2269 }
2270
2271 static
2272 int ide_cdrom_reset (struct cdrom_device_info *cdi)
2273 {
2274         struct ata_device *drive = (struct ata_device *) cdi->handle;
2275         struct request_sense sense;
2276         struct request req;
2277         int ret;
2278
2279         ide_init_drive_cmd(&req);
2280         req.flags = REQ_SPECIAL;
2281         ret = ide_do_drive_cmd(drive, &req, ide_wait);
2282
2283         /*
2284          * A reset will unlock the door. If it was previously locked,
2285          * lock it again.
2286          */
2287         if (CDROM_STATE_FLAGS(drive)->door_locked)
2288                 cdrom_lockdoor(drive, 1, &sense);
2289
2290         return ret;
2291 }
2292
2293
2294 static
2295 int ide_cdrom_tray_move(struct cdrom_device_info *cdi, int position)
2296 {
2297         struct ata_device *drive = (struct ata_device *) cdi->handle;
2298         struct request_sense sense;
2299
2300         if (position) {
2301                 int stat = cdrom_lockdoor(drive, 0, &sense);
2302                 if (stat)
2303                         return stat;
2304         }
2305
2306         return cdrom_eject(drive, !position, &sense);
2307 }
2308
2309 static
2310 int ide_cdrom_lock_door(struct cdrom_device_info *cdi, int lock)
2311 {
2312         struct ata_device *drive = (struct ata_device *) cdi->handle;
2313         struct request_sense sense;
2314
2315         return cdrom_lockdoor(drive, lock, &sense);
2316 }
2317
2318 static
2319 int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
2320 {
2321         struct ata_device *drive = (struct ata_device *) cdi->handle;
2322         struct request_sense sense;
2323         int stat;
2324
2325         if ((stat = cdrom_select_speed (drive, speed, &sense)) < 0)
2326                 return stat;
2327
2328         cdi->speed = CDROM_STATE_FLAGS (drive)->current_speed;
2329         return 0;
2330 }
2331
2332 static
2333 int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
2334 {
2335         struct ata_device *drive = (struct ata_device *) cdi->handle;
2336
2337         if (slot_nr == CDSL_CURRENT) {
2338                 struct request_sense sense;
2339                 int stat = cdrom_check_status(drive, &sense);
2340                 if (stat == 0 || sense.sense_key == UNIT_ATTENTION)
2341                         return CDS_DISC_OK;
2342
2343                 if (sense.sense_key == NOT_READY && sense.asc == 0x04 &&
2344                     sense.ascq == 0x04)
2345                         return CDS_DISC_OK;
2346
2347
2348                 /*
2349                  * If not using Mt Fuji extended media tray reports,
2350                  * just return TRAY_OPEN since ATAPI doesn't provide
2351                  * any other way to detect this...
2352                  */
2353                 if (sense.sense_key == NOT_READY) {
2354                         if (sense.asc == 0x3a && sense.ascq == 1)
2355                                 return CDS_NO_DISC;
2356                         else
2357                                 return CDS_TRAY_OPEN;
2358                 }
2359
2360                 return CDS_DRIVE_NOT_READY;
2361         }
2362         return -EINVAL;
2363 }
2364
2365 static
2366 int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
2367                                 struct cdrom_multisession *ms_info)
2368 {
2369         struct atapi_toc *toc;
2370         struct ata_device *drive = (struct ata_device *) cdi->handle;
2371         struct cdrom_info *info = drive->driver_data;
2372         struct request_sense sense;
2373         int ret;
2374
2375         if (!CDROM_STATE_FLAGS(drive)->toc_valid || info->toc == NULL)
2376                 if ((ret = cdrom_read_toc(drive, &sense)))
2377                         return ret;
2378
2379         toc = info->toc;
2380         ms_info->addr.lba = toc->last_session_lba;
2381         ms_info->xa_flag = toc->xa_flag;
2382
2383         return 0;
2384 }
2385
2386 static
2387 int ide_cdrom_get_mcn (struct cdrom_device_info *cdi,
2388                        struct cdrom_mcn *mcn_info)
2389 {
2390         int stat;
2391         char mcnbuf[24];
2392         struct ata_device *drive = (struct ata_device *) cdi->handle;
2393
2394 /* get MCN */
2395         if ((stat = cdrom_read_subchannel(drive, 2, mcnbuf, sizeof (mcnbuf), NULL)))
2396                 return stat;
2397
2398         memcpy (mcn_info->medium_catalog_number, mcnbuf+9,
2399                 sizeof (mcn_info->medium_catalog_number)-1);
2400         mcn_info->medium_catalog_number[sizeof (mcn_info->medium_catalog_number)-1]
2401                 = '\0';
2402
2403         return 0;
2404 }
2405
2406
2407
2408 /****************************************************************************
2409  * Other driver requests (open, close, check media change).
2410  */
2411
2412 static
2413 int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
2414                                        int slot_nr)
2415 {
2416         struct ata_device *drive = (struct ata_device *) cdi->handle;
2417         int retval;
2418
2419         if (slot_nr == CDSL_CURRENT) {
2420                 cdrom_check_status(drive, NULL);
2421                 retval = CDROM_STATE_FLAGS (drive)->media_changed;
2422                 CDROM_STATE_FLAGS (drive)->media_changed = 0;
2423                 return retval;
2424         } else {
2425                 return -EINVAL;
2426         }
2427 }
2428
2429
2430 static
2431 int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
2432 {
2433         return 0;
2434 }
2435
2436
2437 /*
2438  * Close down the device.  Invalidate all cached blocks.
2439  */
2440
2441 static
2442 void ide_cdrom_release_real (struct cdrom_device_info *cdi)
2443 {
2444 }
2445
2446
2447
2448 /****************************************************************************
2449  * Device initialization.
2450  */
2451 static struct cdrom_device_ops ide_cdrom_dops = {
2452         open:                   ide_cdrom_open_real,
2453         release:                ide_cdrom_release_real,
2454         drive_status:           ide_cdrom_drive_status,
2455         media_changed:          ide_cdrom_check_media_change_real,
2456         tray_move:              ide_cdrom_tray_move,
2457         lock_door:              ide_cdrom_lock_door,
2458         select_speed:           ide_cdrom_select_speed,
2459         get_last_session:       ide_cdrom_get_last_session,
2460         get_mcn:                ide_cdrom_get_mcn,
2461         reset:                  ide_cdrom_reset,
2462         audio_ioctl:            ide_cdrom_audio_ioctl,
2463         dev_ioctl:              ide_cdrom_dev_ioctl,
2464         capability:             CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
2465                                 CDC_SELECT_SPEED | CDC_SELECT_DISC |
2466                                 CDC_MULTI_SESSION | CDC_MCN |
2467                                 CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO | CDC_RESET |
2468                                 CDC_IOCTLS | CDC_DRIVE_STATUS | CDC_CD_R |
2469                                 CDC_CD_RW | CDC_DVD | CDC_DVD_R| CDC_DVD_RAM |
2470                                 CDC_GENERIC_PACKET,
2471         generic_packet:         ide_cdrom_packet,
2472 };
2473
2474 static int ide_cdrom_register(struct ata_device *drive, int nslots)
2475 {
2476         struct cdrom_info *info = drive->driver_data;
2477         struct cdrom_device_info *devinfo = &info->devinfo;
2478         int minor = (drive->select.b.unit) << PARTN_BITS;
2479
2480         devinfo->dev = mk_kdev(drive->channel->major, minor);
2481         devinfo->ops = &ide_cdrom_dops;
2482         devinfo->mask = 0;
2483         *(int *)&devinfo->speed = CDROM_STATE_FLAGS (drive)->current_speed;
2484         *(int *)&devinfo->capacity = nslots;
2485         devinfo->handle = (void *) drive;
2486         strcpy(devinfo->name, drive->name);
2487
2488         /* set capability mask to match the probe. */
2489         if (!CDROM_CONFIG_FLAGS (drive)->cd_r)
2490                 devinfo->mask |= CDC_CD_R;
2491         if (!CDROM_CONFIG_FLAGS (drive)->cd_rw)
2492                 devinfo->mask |= CDC_CD_RW;
2493         if (!CDROM_CONFIG_FLAGS (drive)->dvd)
2494                 devinfo->mask |= CDC_DVD;
2495         if (!CDROM_CONFIG_FLAGS (drive)->dvd_r)
2496                 devinfo->mask |= CDC_DVD_R;
2497         if (!CDROM_CONFIG_FLAGS (drive)->dvd_ram)
2498                 devinfo->mask |= CDC_DVD_RAM;
2499         if (!CDROM_CONFIG_FLAGS (drive)->is_changer)
2500                 devinfo->mask |= CDC_SELECT_DISC;
2501         if (!CDROM_CONFIG_FLAGS (drive)->audio_play)
2502                 devinfo->mask |= CDC_PLAY_AUDIO;
2503         if (!CDROM_CONFIG_FLAGS (drive)->close_tray)
2504                 devinfo->mask |= CDC_CLOSE_TRAY;
2505
2506         /* FIXME: I'm less that sure that this is the proper thing to do, since
2507          * ware already adding the devices to devfs int ide.c upon device
2508          * registration.
2509          */
2510
2511         devinfo->de = devfs_register(drive->de, "cd", DEVFS_FL_DEFAULT,
2512                                      drive->channel->major, minor,
2513                                      S_IFBLK | S_IRUGO | S_IWUGO,
2514                                      ide_fops, NULL);
2515
2516         return register_cdrom(devinfo);
2517 }
2518
2519 static
2520 int ide_cdrom_get_capabilities(struct ata_device *drive, struct atapi_capabilities_page *cap)
2521 {
2522         struct cdrom_info *info = drive->driver_data;
2523         struct cdrom_device_info *cdi = &info->devinfo;
2524         struct cdrom_generic_command cgc;
2525         int stat, attempts = 3, size = sizeof(*cap);
2526
2527         /*
2528          * ACER50 (and others?) require the full spec length mode sense
2529          * page capabilities size, but older drives break.
2530          */
2531         if (drive->id) {
2532                 if (!(!strcmp(drive->id->model, "ATAPI CD ROM DRIVE 50X MAX") ||
2533                     !strcmp(drive->id->model, "WPI CDS-32X")))
2534                         size -= sizeof(cap->pad);
2535         }
2536
2537         /* we have to cheat a little here. the packet will eventually
2538          * be queued with ide_cdrom_packet(), which extracts the
2539          * drive from cdi->handle. Since this device hasn't been
2540          * registered with the Uniform layer yet, it can't do this.
2541          * Same goes for cdi->ops.
2542          */
2543         cdi->handle = (struct ata_device *) drive;
2544         cdi->ops = &ide_cdrom_dops;
2545         init_cdrom_command(&cgc, cap, size, CGC_DATA_UNKNOWN);
2546         do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2547                 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
2548                 if (!stat)
2549                         break;
2550         } while (--attempts);
2551         return stat;
2552 }
2553
2554 static
2555 int ide_cdrom_probe_capabilities(struct ata_device *drive)
2556 {
2557         struct cdrom_info *info = drive->driver_data;
2558         struct cdrom_device_info *cdi = &info->devinfo;
2559         struct atapi_capabilities_page cap;
2560         int nslots = 1;
2561
2562         if (CDROM_CONFIG_FLAGS (drive)->nec260) {
2563                 CDROM_CONFIG_FLAGS (drive)->no_eject = 0;
2564                 CDROM_CONFIG_FLAGS (drive)->audio_play = 1;
2565                 return nslots;
2566         }
2567
2568         if (ide_cdrom_get_capabilities(drive, &cap))
2569                 return 0;
2570
2571         if (cap.lock == 0)
2572                 CDROM_CONFIG_FLAGS (drive)->no_doorlock = 1;
2573         if (cap.eject)
2574                 CDROM_CONFIG_FLAGS (drive)->no_eject = 0;
2575         if (cap.cd_r_write)
2576                 CDROM_CONFIG_FLAGS (drive)->cd_r = 1;
2577         if (cap.cd_rw_write)
2578                 CDROM_CONFIG_FLAGS (drive)->cd_rw = 1;
2579         if (cap.test_write)
2580                 CDROM_CONFIG_FLAGS (drive)->test_write = 1;
2581         if (cap.dvd_ram_read || cap.dvd_r_read || cap.dvd_rom)
2582                 CDROM_CONFIG_FLAGS (drive)->dvd = 1;
2583         if (cap.dvd_ram_write)
2584                 CDROM_CONFIG_FLAGS (drive)->dvd_ram = 1;
2585         if (cap.dvd_r_write)
2586                 CDROM_CONFIG_FLAGS (drive)->dvd_r = 1;
2587         if (cap.audio_play)
2588                 CDROM_CONFIG_FLAGS (drive)->audio_play = 1;
2589         if (cap.mechtype == mechtype_caddy || cap.mechtype == mechtype_popup)
2590                 CDROM_CONFIG_FLAGS (drive)->close_tray = 0;
2591
2592         /* Some drives used by Apple don't advertise audio play
2593          * but they do support reading TOC & audio datas
2594          */
2595         if (strcmp (drive->id->model, "MATSHITADVD-ROM SR-8187") == 0 ||
2596             strcmp (drive->id->model, "MATSHITADVD-ROM SR-8186") == 0)
2597                 CDROM_CONFIG_FLAGS (drive)->audio_play = 1;
2598
2599 #if ! STANDARD_ATAPI
2600         if (cdi->sanyo_slot > 0) {
2601                 CDROM_CONFIG_FLAGS (drive)->is_changer = 1;
2602                 nslots = 3;
2603         }
2604
2605         else
2606 #endif /* not STANDARD_ATAPI */
2607         if (cap.mechtype == mechtype_individual_changer ||
2608             cap.mechtype == mechtype_cartridge_changer) {
2609                 if ((nslots = cdrom_number_of_slots(cdi)) > 1) {
2610                         CDROM_CONFIG_FLAGS (drive)->is_changer = 1;
2611                         CDROM_CONFIG_FLAGS (drive)->supp_disc_present = 1;
2612                 }
2613         }
2614
2615         /* The ACER/AOpen 24X cdrom has the speed fields byte-swapped */
2616         if (drive->id && !drive->id->model[0] && !strncmp(drive->id->fw_rev, "241N", 4)) {
2617                 CDROM_STATE_FLAGS (drive)->current_speed  =
2618                         (((unsigned int)cap.curspeed) + (176/2)) / 176;
2619                 CDROM_CONFIG_FLAGS (drive)->max_speed =
2620                         (((unsigned int)cap.maxspeed) + (176/2)) / 176;
2621         } else {
2622                 CDROM_STATE_FLAGS (drive)->current_speed  =
2623                         (ntohs(cap.curspeed) + (176/2)) / 176;
2624                 CDROM_CONFIG_FLAGS (drive)->max_speed =
2625                         (ntohs(cap.maxspeed) + (176/2)) / 176;
2626         }
2627
2628         /* don't print speed if the drive reported 0.
2629          */
2630         printk("%s: ATAPI", drive->name);
2631         if (CDROM_CONFIG_FLAGS(drive)->max_speed)
2632                 printk(" %dX", CDROM_CONFIG_FLAGS(drive)->max_speed);
2633         printk(" %s", CDROM_CONFIG_FLAGS(drive)->dvd ? "DVD-ROM" : "CD-ROM");
2634
2635         if (CDROM_CONFIG_FLAGS (drive)->dvd_r|CDROM_CONFIG_FLAGS (drive)->dvd_ram)
2636                 printk (" DVD%s%s",
2637                 (CDROM_CONFIG_FLAGS (drive)->dvd_r)? "-R" : "",
2638                 (CDROM_CONFIG_FLAGS (drive)->dvd_ram)? "-RAM" : "");
2639
2640         if (CDROM_CONFIG_FLAGS (drive)->cd_r|CDROM_CONFIG_FLAGS (drive)->cd_rw)
2641                 printk (" CD%s%s",
2642                 (CDROM_CONFIG_FLAGS (drive)->cd_r)? "-R" : "",
2643                 (CDROM_CONFIG_FLAGS (drive)->cd_rw)? "/RW" : "");
2644
2645         if (CDROM_CONFIG_FLAGS (drive)->is_changer)
2646                 printk (" changer w/%d slots", nslots);
2647         else
2648                 printk (" drive");
2649
2650         printk (", %dkB Cache", be16_to_cpu(cap.buffer_size));
2651
2652 #ifdef CONFIG_BLK_DEV_IDEDMA
2653         if (drive->using_dma)
2654                 udma_print(drive);
2655 #endif
2656         printk("\n");
2657
2658         return nslots;
2659 }
2660
2661
2662 /*
2663  * standard prep_rq_fn that builds 10 byte cmds
2664  */
2665 static int ll_10byte_cmd_build(request_queue_t *q, struct request *rq)
2666 {
2667         int hard_sect = queue_hardsect_size(q);
2668         sector_t block = rq->hard_sector / (hard_sect >> 9);
2669         unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
2670
2671         if (!(rq->flags & REQ_CMD))
2672                 return 0;
2673
2674         if (rq->hard_nr_sectors != rq->nr_sectors) {
2675                 printk(KERN_ERR "ide-cd: hard_nr_sectors differs from nr_sectors! %lu %lu\n",
2676                                 rq->nr_sectors, rq->hard_nr_sectors);
2677         }
2678         memset(rq->cmd, 0, sizeof(rq->cmd));
2679
2680         if (rq_data_dir(rq) == READ)
2681                 rq->cmd[0] = GPCMD_READ_10;
2682         else
2683                 rq->cmd[0] = GPCMD_WRITE_10;
2684
2685         /*
2686          * fill in lba
2687          */
2688         rq->cmd[2] = (block >> 24) & 0xff;
2689         rq->cmd[3] = (block >> 16) & 0xff;
2690         rq->cmd[4] = (block >>  8) & 0xff;
2691         rq->cmd[5] = block & 0xff;