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