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