[PATCH] relax ide-cd dma restrictions
[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                 if ((rq->data_len & 3) || (addr & mask))
1937                         info->dma = 0;
1938         }
1939
1940         /* Start sending the command to the drive. */
1941         return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1942 }
1943
1944 /****************************************************************************
1945  * cdrom driver request routine.
1946  */
1947 static ide_startstop_t
1948 ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1949 {
1950         ide_startstop_t action;
1951         struct cdrom_info *info = drive->driver_data;
1952
1953         if (blk_fs_request(rq)) {
1954                 if (CDROM_CONFIG_FLAGS(drive)->seeking) {
1955                         unsigned long elapsed = jiffies - info->start_seek;
1956                         int stat = HWIF(drive)->INB(IDE_STATUS_REG);
1957
1958                         if ((stat & SEEK_STAT) != SEEK_STAT) {
1959                                 if (elapsed < IDECD_SEEK_TIMEOUT) {
1960                                         ide_stall_queue(drive, IDECD_SEEK_TIMER);
1961                                         return ide_stopped;
1962                                 }
1963                                 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
1964                         }
1965                         CDROM_CONFIG_FLAGS(drive)->seeking = 0;
1966                 }
1967                 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
1968                         action = cdrom_start_seek(drive, block);
1969                 } else {
1970                         if (rq_data_dir(rq) == READ)
1971                                 action = cdrom_start_read(drive, block);
1972                         else
1973                                 action = cdrom_start_write(drive, rq);
1974                 }
1975                 info->last_block = block;
1976                 return action;
1977         } else if (rq->flags & (REQ_PC | REQ_SENSE)) {
1978                 return cdrom_do_packet_command(drive);
1979         } else if (rq->flags & REQ_BLOCK_PC) {
1980                 return cdrom_do_block_pc(drive, rq);
1981         } else if (rq->flags & REQ_SPECIAL) {
1982                 /*
1983                  * right now this can only be a reset...
1984                  */
1985                 cdrom_end_request(drive, 1);
1986                 return ide_stopped;
1987         }
1988
1989         blk_dump_rq_flags(rq, "ide-cd bad flags");
1990         cdrom_end_request(drive, 0);
1991         return ide_stopped;
1992 }
1993
1994
1995
1996 /****************************************************************************
1997  * Ioctl handling.
1998  *
1999  * Routines which queue packet commands take as a final argument a pointer
2000  * to a request_sense struct.  If execution of the command results
2001  * in an error with a CHECK CONDITION status, this structure will be filled
2002  * with the results of the subsequent request sense command.  The pointer
2003  * can also be NULL, in which case no sense information is returned.
2004  */
2005
2006 #if ! STANDARD_ATAPI
2007 static inline
2008 int bin2bcd (int x)
2009 {
2010         return (x%10) | ((x/10) << 4);
2011 }
2012
2013
2014 static inline
2015 int bcd2bin (int x)
2016 {
2017         return (x >> 4) * 10 + (x & 0x0f);
2018 }
2019
2020 static
2021 void msf_from_bcd (struct atapi_msf *msf)
2022 {
2023         msf->minute = bcd2bin (msf->minute);
2024         msf->second = bcd2bin (msf->second);
2025         msf->frame  = bcd2bin (msf->frame);
2026 }
2027
2028 #endif /* not STANDARD_ATAPI */
2029
2030
2031 static inline
2032 void lba_to_msf (int lba, byte *m, byte *s, byte *f)
2033 {
2034         lba += CD_MSF_OFFSET;
2035         lba &= 0xffffff;  /* negative lbas use only 24 bits */
2036         *m = lba / (CD_SECS * CD_FRAMES);
2037         lba %= (CD_SECS * CD_FRAMES);
2038         *s = lba / CD_FRAMES;
2039         *f = lba % CD_FRAMES;
2040 }
2041
2042
2043 static inline
2044 int msf_to_lba (byte m, byte s, byte f)
2045 {
2046         return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
2047 }
2048
2049 static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
2050 {
2051         struct request req;
2052         struct cdrom_info *info = drive->driver_data;
2053         struct cdrom_device_info *cdi = &info->devinfo;
2054
2055         cdrom_prepare_request(drive, &req);
2056
2057         req.sense = sense;
2058         req.cmd[0] = GPCMD_TEST_UNIT_READY;
2059         req.flags |= REQ_QUIET;
2060
2061 #if ! STANDARD_ATAPI
2062         /* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to 
2063            switch CDs instead of supporting the LOAD_UNLOAD opcode   */
2064
2065         req.cmd[7] = cdi->sanyo_slot % 3;
2066 #endif /* not STANDARD_ATAPI */
2067
2068         return cdrom_queue_packet_command(drive, &req);
2069 }
2070
2071
2072 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
2073 static int
2074 cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
2075 {
2076         struct request_sense my_sense;
2077         struct request req;
2078         int stat;
2079
2080         if (sense == NULL)
2081                 sense = &my_sense;
2082
2083         /* If the drive cannot lock the door, just pretend. */
2084         if (CDROM_CONFIG_FLAGS(drive)->no_doorlock) {
2085                 stat = 0;
2086         } else {
2087                 cdrom_prepare_request(drive, &req);
2088                 req.sense = sense;
2089                 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
2090                 req.cmd[4] = lockflag ? 1 : 0;
2091                 stat = cdrom_queue_packet_command(drive, &req);
2092         }
2093
2094         /* If we got an illegal field error, the drive
2095            probably cannot lock the door. */
2096         if (stat != 0 &&
2097             sense->sense_key == ILLEGAL_REQUEST &&
2098             (sense->asc == 0x24 || sense->asc == 0x20)) {
2099                 printk (KERN_ERR "%s: door locking not supported\n",
2100                         drive->name);
2101                 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2102                 stat = 0;
2103         }
2104         
2105         /* no medium, that's alright. */
2106         if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
2107                 stat = 0;
2108
2109         if (stat == 0)
2110                 CDROM_STATE_FLAGS(drive)->door_locked = lockflag;
2111
2112         return stat;
2113 }
2114
2115
2116 /* Eject the disk if EJECTFLAG is 0.
2117    If EJECTFLAG is 1, try to reload the disk. */
2118 static int cdrom_eject(ide_drive_t *drive, int ejectflag,
2119                        struct request_sense *sense)
2120 {
2121         struct request req;
2122         char loej = 0x02;
2123
2124         if (CDROM_CONFIG_FLAGS(drive)->no_eject && !ejectflag)
2125                 return -EDRIVE_CANT_DO_THIS;
2126         
2127         /* reload fails on some drives, if the tray is locked */
2128         if (CDROM_STATE_FLAGS(drive)->door_locked && ejectflag)
2129                 return 0;
2130
2131         cdrom_prepare_request(drive, &req);
2132
2133         /* only tell drive to close tray if open, if it can do that */
2134         if (ejectflag && !CDROM_CONFIG_FLAGS(drive)->close_tray)
2135                 loej = 0;
2136
2137         req.sense = sense;
2138         req.cmd[0] = GPCMD_START_STOP_UNIT;
2139         req.cmd[4] = loej | (ejectflag != 0);
2140         return cdrom_queue_packet_command(drive, &req);
2141 }
2142
2143 static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
2144                                unsigned long *sectors_per_frame,
2145                                struct request_sense *sense)
2146 {
2147         struct {
2148                 __u32 lba;
2149                 __u32 blocklen;
2150         } capbuf;
2151
2152         int stat;
2153         struct request req;
2154
2155         cdrom_prepare_request(drive, &req);
2156
2157         req.sense = sense;
2158         req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
2159         req.data = (char *)&capbuf;
2160         req.data_len = sizeof(capbuf);
2161
2162         stat = cdrom_queue_packet_command(drive, &req);
2163         if (stat == 0) {
2164                 *capacity = 1 + be32_to_cpu(capbuf.lba);
2165                 *sectors_per_frame =
2166                         be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
2167         }
2168
2169         return stat;
2170 }
2171
2172 static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
2173                                 int format, char *buf, int buflen,
2174                                 struct request_sense *sense)
2175 {
2176         struct request req;
2177
2178         cdrom_prepare_request(drive, &req);
2179
2180         req.sense = sense;
2181         req.data =  buf;
2182         req.data_len = buflen;
2183         req.flags |= REQ_QUIET;
2184         req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
2185         req.cmd[6] = trackno;
2186         req.cmd[7] = (buflen >> 8);
2187         req.cmd[8] = (buflen & 0xff);
2188         req.cmd[9] = (format << 6);
2189
2190         if (msf_flag)
2191                 req.cmd[1] = 2;
2192
2193         return cdrom_queue_packet_command(drive, &req);
2194 }
2195
2196
2197 /* Try to read the entire TOC for the disk into our internal buffer. */
2198 static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2199 {
2200         int stat, ntracks, i;
2201         struct cdrom_info *info = drive->driver_data;
2202         struct cdrom_device_info *cdi = &info->devinfo;
2203         struct atapi_toc *toc = info->toc;
2204         struct {
2205                 struct atapi_toc_header hdr;
2206                 struct atapi_toc_entry  ent;
2207         } ms_tmp;
2208         long last_written;
2209         unsigned long sectors_per_frame = SECTORS_PER_FRAME;
2210
2211         if (toc == NULL) {
2212                 /* Try to allocate space. */
2213                 toc = (struct atapi_toc *) kmalloc (sizeof (struct atapi_toc),
2214                                                     GFP_KERNEL);
2215                 info->toc = toc;
2216                 if (toc == NULL) {
2217                         printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
2218                         return -ENOMEM;
2219                 }
2220         }
2221
2222         /* Check to see if the existing data is still valid.
2223            If it is, just return. */
2224         (void) cdrom_check_status(drive, sense);
2225
2226         if (CDROM_STATE_FLAGS(drive)->toc_valid)
2227                 return 0;
2228
2229         /* Try to get the total cdrom capacity and sector size. */
2230         stat = cdrom_read_capacity(drive, &toc->capacity, &sectors_per_frame,
2231                                    sense);
2232         if (stat)
2233                 toc->capacity = 0x1fffff;
2234
2235         set_capacity(info->disk, toc->capacity * sectors_per_frame);
2236         blk_queue_hardsect_size(drive->queue,
2237                                 sectors_per_frame << SECTOR_BITS);
2238
2239         /* First read just the header, so we know how long the TOC is. */
2240         stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
2241                                     sizeof(struct atapi_toc_header), sense);
2242         if (stat) return stat;
2243
2244 #if ! STANDARD_ATAPI
2245         if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2246                 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2247                 toc->hdr.last_track  = bcd2bin(toc->hdr.last_track);
2248         }
2249 #endif  /* not STANDARD_ATAPI */
2250
2251         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2252         if (ntracks <= 0)
2253                 return -EIO;
2254         if (ntracks > MAX_TRACKS)
2255                 ntracks = MAX_TRACKS;
2256
2257         /* Now read the whole schmeer. */
2258         stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
2259                                   (char *)&toc->hdr,
2260                                    sizeof(struct atapi_toc_header) +
2261                                    (ntracks + 1) *
2262                                    sizeof(struct atapi_toc_entry), sense);
2263
2264         if (stat && toc->hdr.first_track > 1) {
2265                 /* Cds with CDI tracks only don't have any TOC entries,
2266                    despite of this the returned values are
2267                    first_track == last_track = number of CDI tracks + 1,
2268                    so that this case is indistinguishable from the same
2269                    layout plus an additional audio track.
2270                    If we get an error for the regular case, we assume
2271                    a CDI without additional audio tracks. In this case
2272                    the readable TOC is empty (CDI tracks are not included)
2273                    and only holds the Leadout entry. Heiko EiƟfeldt */
2274                 ntracks = 0;
2275                 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
2276                                            (char *)&toc->hdr,
2277                                            sizeof(struct atapi_toc_header) +
2278                                            (ntracks + 1) *
2279                                            sizeof(struct atapi_toc_entry),
2280                                            sense);
2281                 if (stat) {
2282                         return stat;
2283                 }
2284 #if ! STANDARD_ATAPI
2285                 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2286                         toc->hdr.first_track = bin2bcd(CDROM_LEADOUT);
2287                         toc->hdr.last_track = bin2bcd(CDROM_LEADOUT);
2288                 } else
2289 #endif  /* not STANDARD_ATAPI */
2290                 {
2291                         toc->hdr.first_track = CDROM_LEADOUT;
2292                         toc->hdr.last_track = CDROM_LEADOUT;
2293                 }
2294         }
2295
2296         if (stat)
2297                 return stat;
2298
2299         toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
2300
2301 #if ! STANDARD_ATAPI
2302         if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2303                 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2304                 toc->hdr.last_track  = bcd2bin(toc->hdr.last_track);
2305         }
2306 #endif  /* not STANDARD_ATAPI */
2307
2308         for (i=0; i<=ntracks; i++) {
2309 #if ! STANDARD_ATAPI
2310                 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2311                         if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd)
2312                                 toc->ent[i].track = bcd2bin(toc->ent[i].track);
2313                         msf_from_bcd(&toc->ent[i].addr.msf);
2314                 }
2315 #endif  /* not STANDARD_ATAPI */
2316                 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
2317                                                    toc->ent[i].addr.msf.second,
2318                                                    toc->ent[i].addr.msf.frame);
2319         }
2320
2321         /* Read the multisession information. */
2322         if (toc->hdr.first_track != CDROM_LEADOUT) {
2323                 /* Read the multisession information. */
2324                 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
2325                                            sizeof(ms_tmp), sense);
2326                 if (stat) return stat;
2327
2328                 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
2329         } else {
2330                 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
2331                 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
2332         }
2333
2334 #if ! STANDARD_ATAPI
2335         if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2336                 /* Re-read multisession information using MSF format */
2337                 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
2338                                            sizeof(ms_tmp), sense);
2339                 if (stat)
2340                         return stat;
2341
2342                 msf_from_bcd (&ms_tmp.ent.addr.msf);
2343                 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
2344                                                    ms_tmp.ent.addr.msf.second,
2345                                                    ms_tmp.ent.addr.msf.frame);
2346         }
2347 #endif  /* not STANDARD_ATAPI */
2348
2349         toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
2350
2351         /* Now try to get the total cdrom capacity. */
2352         stat = cdrom_get_last_written(cdi, &last_written);
2353         if (!stat && (last_written > toc->capacity)) {
2354                 toc->capacity = last_written;
2355                 set_capacity(info->disk, toc->capacity * sectors_per_frame);
2356         }
2357
2358         /* Remember that we've read this stuff. */
2359         CDROM_STATE_FLAGS(drive)->toc_valid = 1;
2360
2361         return 0;
2362 }
2363
2364
2365 static int cdrom_read_subchannel(ide_drive_t *drive, int format, char *buf,
2366                                  int buflen, struct request_sense *sense)
2367 {
2368         struct request req;
2369
2370         cdrom_prepare_request(drive, &req);
2371
2372         req.sense = sense;
2373         req.data = buf;
2374         req.data_len = buflen;
2375         req.cmd[0] = GPCMD_READ_SUBCHANNEL;
2376         req.cmd[1] = 2;     /* MSF addressing */
2377         req.cmd[2] = 0x40;  /* request subQ data */
2378         req.cmd[3] = format;
2379         req.cmd[7] = (buflen >> 8);
2380         req.cmd[8] = (buflen & 0xff);
2381         return cdrom_queue_packet_command(drive, &req);
2382 }
2383
2384 /* ATAPI cdrom drives are free to select the speed you request or any slower
2385    rate :-( Requesting too fast a speed will _not_ produce an error. */
2386 static int cdrom_select_speed(ide_drive_t *drive, int speed,
2387                               struct request_sense *sense)
2388 {
2389         struct request req;
2390         cdrom_prepare_request(drive, &req);
2391
2392         req.sense = sense;
2393         if (speed == 0)
2394                 speed = 0xffff; /* set to max */
2395         else
2396                 speed *= 177;   /* Nx to kbytes/s */
2397
2398         req.cmd[0] = GPCMD_SET_SPEED;
2399         /* Read Drive speed in kbytes/second MSB */
2400         req.cmd[2] = (speed >> 8) & 0xff;       
2401         /* Read Drive speed in kbytes/second LSB */
2402         req.cmd[3] = speed & 0xff;
2403         if (CDROM_CONFIG_FLAGS(drive)->cd_r ||
2404             CDROM_CONFIG_FLAGS(drive)->cd_rw ||
2405             CDROM_CONFIG_FLAGS(drive)->dvd_r) {
2406                 /* Write Drive speed in kbytes/second MSB */
2407                 req.cmd[4] = (speed >> 8) & 0xff;
2408                 /* Write Drive speed in kbytes/second LSB */
2409                 req.cmd[5] = speed & 0xff;
2410        }
2411
2412         return cdrom_queue_packet_command(drive, &req);
2413 }
2414
2415 static int cdrom_play_audio(ide_drive_t *drive, int lba_start, int lba_end)
2416 {
2417         struct request_sense sense;
2418         struct request req;
2419
2420         cdrom_prepare_request(drive, &req);
2421
2422         req.sense = &sense;
2423         req.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2424         lba_to_msf(lba_start, &req.cmd[3], &req.cmd[4], &req.cmd[5]);
2425         lba_to_msf(lba_end-1, &req.cmd[6], &req.cmd[7], &req.cmd[8]);
2426
2427         return cdrom_queue_packet_command(drive, &req);
2428 }
2429
2430 static int cdrom_get_toc_entry(ide_drive_t *drive, int track,
2431                                 struct atapi_toc_entry **ent)
2432 {
2433         struct cdrom_info *info = drive->driver_data;
2434         struct atapi_toc *toc = info->toc;
2435         int ntracks;
2436
2437         /*
2438          * don't serve cached data, if the toc isn't valid
2439          */
2440         if (!CDROM_STATE_FLAGS(drive)->toc_valid)
2441                 return -EINVAL;
2442
2443         /* Check validity of requested track number. */
2444         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2445         if (toc->hdr.first_track == CDROM_LEADOUT) ntracks = 0;
2446         if (track == CDROM_LEADOUT)
2447                 *ent = &toc->ent[ntracks];
2448         else if (track < toc->hdr.first_track ||
2449                  track > toc->hdr.last_track)
2450                 return -EINVAL;
2451         else
2452                 *ent = &toc->ent[track - toc->hdr.first_track];
2453
2454         return 0;
2455 }
2456
2457 /* the generic packet interface to cdrom.c */
2458 static int ide_cdrom_packet(struct cdrom_device_info *cdi,
2459                             struct packet_command *cgc)
2460 {
2461         struct request req;
2462         ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2463
2464         if (cgc->timeout <= 0)
2465                 cgc->timeout = ATAPI_WAIT_PC;
2466
2467         /* here we queue the commands from the uniform CD-ROM
2468            layer. the packet must be complete, as we do not
2469            touch it at all. */
2470         cdrom_prepare_request(drive, &req);
2471         memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
2472         if (cgc->sense)
2473                 memset(cgc->sense, 0, sizeof(struct request_sense));
2474         req.data = cgc->buffer;
2475         req.data_len = cgc->buflen;
2476         req.timeout = cgc->timeout;
2477
2478         if (cgc->quiet)
2479                 req.flags |= REQ_QUIET;
2480
2481         req.sense = cgc->sense;
2482         cgc->stat = cdrom_queue_packet_command(drive, &req);
2483         if (!cgc->stat)
2484                 cgc->buflen -= req.data_len;
2485         return cgc->stat;
2486 }
2487
2488 static
2489 int ide_cdrom_dev_ioctl (struct cdrom_device_info *cdi,
2490                          unsigned int cmd, unsigned long arg)
2491 {
2492         struct packet_command cgc;
2493         char buffer[16];
2494         int stat;
2495
2496         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2497
2498         /* These will be moved into the Uniform layer shortly... */
2499         switch (cmd) {
2500         case CDROMSETSPINDOWN: {
2501                 char spindown;
2502  
2503                 if (copy_from_user(&spindown, (void __user *) arg, sizeof(char)))
2504                         return -EFAULT;
2505  
2506                 if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0)))
2507                         return stat;
2508
2509                 buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
2510
2511                 return cdrom_mode_select(cdi, &cgc);
2512         } 
2513  
2514         case CDROMGETSPINDOWN: {
2515                 char spindown;
2516  
2517                 if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0)))
2518                         return stat;
2519  
2520                 spindown = buffer[11] & 0x0f;
2521  
2522                 if (copy_to_user((void __user *) arg, &spindown, sizeof (char)))
2523                         return -EFAULT;
2524  
2525                 return 0;
2526         }
2527   
2528         default:
2529                 return -EINVAL;
2530         }
2531
2532 }
2533
2534 static
2535 int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
2536                            unsigned int cmd, void *arg)
2537                            
2538 {
2539         ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2540         struct cdrom_info *info = drive->driver_data;
2541         int stat;
2542
2543         switch (cmd) {
2544         /*
2545          * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
2546          * atapi doesn't support it
2547          */
2548         case CDROMPLAYTRKIND: {
2549                 unsigned long lba_start, lba_end;
2550                 struct cdrom_ti *ti = (struct cdrom_ti *)arg;
2551                 struct atapi_toc_entry *first_toc, *last_toc;
2552
2553                 stat = cdrom_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
2554                 if (stat)
2555                         return stat;
2556
2557                 stat = cdrom_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
2558                 if (stat)
2559                         return stat;
2560
2561                 if (ti->cdti_trk1 != CDROM_LEADOUT)
2562                         ++last_toc;
2563                 lba_start = first_toc->addr.lba;
2564                 lba_end   = last_toc->addr.lba;
2565
2566                 if (lba_end <= lba_start)
2567                         return -EINVAL;
2568
2569                 return cdrom_play_audio(drive, lba_start, lba_end);
2570         }
2571
2572         case CDROMREADTOCHDR: {
2573                 struct cdrom_tochdr *tochdr = (struct cdrom_tochdr *) arg;
2574                 struct atapi_toc *toc;
2575
2576                 /* Make sure our saved TOC is valid. */
2577                 stat = cdrom_read_toc(drive, NULL);
2578                 if (stat) return stat;
2579
2580                 toc = info->toc;
2581                 tochdr->cdth_trk0 = toc->hdr.first_track;
2582                 tochdr->cdth_trk1 = toc->hdr.last_track;
2583
2584                 return 0;
2585         }
2586
2587         case CDROMREADTOCENTRY: {
2588                 struct cdrom_tocentry *tocentry = (struct cdrom_tocentry*) arg;
2589                 struct atapi_toc_entry *toce;
2590
2591                 stat = cdrom_get_toc_entry(drive, tocentry->cdte_track, &toce);
2592                 if (stat) return stat;
2593
2594                 tocentry->cdte_ctrl = toce->control;
2595                 tocentry->cdte_adr  = toce->adr;
2596                 if (tocentry->cdte_format == CDROM_MSF) {
2597                         lba_to_msf (toce->addr.lba,
2598                                    &tocentry->cdte_addr.msf.minute,
2599                                    &tocentry->cdte_addr.msf.second,
2600                                    &tocentry->cdte_addr.msf.frame);
2601                 } else
2602                         tocentry->cdte_addr.lba = toce->addr.lba;
2603
2604                 return 0;
2605         }
2606
2607         default:
2608                 return -EINVAL;
2609         }
2610 }
2611
2612 static
2613 int ide_cdrom_reset (struct cdrom_device_info *cdi)
2614 {
2615         ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2616         struct request_sense sense;
2617         struct request req;
2618         int ret;
2619
2620         cdrom_prepare_request(drive, &req);
2621         req.flags = REQ_SPECIAL | REQ_QUIET;
2622         ret = ide_do_drive_cmd(drive, &req, ide_wait);
2623
2624         /*
2625          * A reset will unlock the door. If it was previously locked,
2626          * lock it again.
2627          */
2628         if (CDROM_STATE_FLAGS(drive)->door_locked)
2629                 (void) cdrom_lockdoor(drive, 1, &sense);
2630
2631         return ret;
2632 }
2633
2634
2635 static
2636 int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
2637 {
2638         ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2639         struct request_sense sense;
2640
2641         if (position) {
2642                 int stat = cdrom_lockdoor(drive, 0, &sense);
2643                 if (stat) return stat;
2644         }
2645
2646         return cdrom_eject(drive, !position, &sense);
2647 }
2648
2649 static
2650 int ide_cdrom_lock_door (struct cdrom_device_info *cdi, int lock)
2651 {
2652         ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2653         return cdrom_lockdoor(drive, lock, NULL);
2654 }
2655
2656 static
2657 int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
2658 {
2659         ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2660         struct request_sense sense;
2661         int stat;
2662
2663         if ((stat = cdrom_select_speed(drive, speed, &sense)) < 0)
2664                 return stat;
2665
2666         cdi->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2667         return 0;
2668 }
2669
2670 /*
2671  * add logic to try GET_EVENT command first to check for media and tray
2672  * status. this should be supported by newer cd-r/w and all DVD etc
2673  * drives
2674  */
2675 static
2676 int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
2677 {
2678         ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2679         struct media_event_desc med;
2680         struct request_sense sense;
2681         int stat;
2682
2683         if (slot_nr != CDSL_CURRENT)
2684                 return -EINVAL;
2685
2686         stat = cdrom_check_status(drive, &sense);
2687         if (!stat || sense.sense_key == UNIT_ATTENTION)
2688                 return CDS_DISC_OK;
2689
2690         if (!cdrom_get_media_event(cdi, &med)) {
2691                 if (med.media_present)
2692                         return CDS_DISC_OK;
2693                 else if (med.door_open)
2694                         return CDS_TRAY_OPEN;
2695                 else
2696                         return CDS_NO_DISC;
2697         }
2698
2699         if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
2700                 return CDS_DISC_OK;
2701
2702         /*
2703          * If not using Mt Fuji extended media tray reports,
2704          * just return TRAY_OPEN since ATAPI doesn't provide
2705          * any other way to detect this...
2706          */
2707         if (sense.sense_key == NOT_READY) {
2708                 if (sense.asc == 0x3a) {
2709                         if (sense.ascq == 1)
2710                                 return CDS_NO_DISC;
2711                         else if (sense.ascq == 0 || sense.ascq == 2)
2712                                 return CDS_TRAY_OPEN;
2713                 }
2714         }
2715
2716         return CDS_DRIVE_NOT_READY;
2717 }
2718
2719 static
2720 int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
2721                                 struct cdrom_multisession *ms_info)
2722 {
2723         struct atapi_toc *toc;
2724         ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2725         struct cdrom_info *info = drive->driver_data;
2726         struct request_sense sense;
2727         int ret;
2728
2729         if (!CDROM_STATE_FLAGS(drive)->toc_valid || info->toc == NULL)
2730                 if ((ret = cdrom_read_toc(drive, &sense)))
2731                         return ret;
2732
2733         toc = info->toc;
2734         ms_info->addr.lba = toc->last_session_lba;
2735         ms_info->xa_flag = toc->xa_flag;
2736
2737         return 0;
2738 }
2739
2740 static
2741 int ide_cdrom_get_mcn (struct cdrom_device_info *cdi,
2742                        struct cdrom_mcn *mcn_info)
2743 {
2744         int stat;
2745         char mcnbuf[24];
2746         ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2747
2748 /* get MCN */
2749         if ((stat = cdrom_read_subchannel(drive, 2, mcnbuf, sizeof (mcnbuf), NULL)))
2750                 return stat;
2751
2752         memcpy (mcn_info->medium_catalog_number, mcnbuf+9,
2753                 sizeof (mcn_info->medium_catalog_number)-1);
2754         mcn_info->medium_catalog_number[sizeof (mcn_info->medium_catalog_number)-1]
2755                 = '\0';
2756
2757         return 0;
2758 }
2759
2760
2761
2762 /****************************************************************************
2763  * Other driver requests (open, close, check media change).
2764  */
2765
2766 static
2767 int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
2768                                        int slot_nr)
2769 {
2770         ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2771         int retval;
2772         
2773         if (slot_nr == CDSL_CURRENT) {
2774                 (void) cdrom_check_status(drive, NULL);
2775                 retval = CDROM_STATE_FLAGS(drive)->media_changed;
2776                 CDROM_STATE_FLAGS(drive)->media_changed = 0;
2777                 return retval;
2778         } else {
2779                 return -EINVAL;
2780         }
2781 }
2782
2783
2784 static
2785 int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
2786 {
2787         return 0;
2788 }
2789
2790 /*
2791  * Close down the device.  Invalidate all cached blocks.
2792  */
2793
2794 static
2795 void ide_cdrom_release_real (struct cdrom_device_info *cdi)
2796 {
2797         ide_drive_t *drive = cdi->handle;
2798
2799         if (!cdi->use_count)
2800                 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
2801 }
2802
2803
2804
2805 /****************************************************************************
2806  * Device initialization.
2807  */
2808 static struct cdrom_device_ops ide_cdrom_dops = {
2809         .open                   = ide_cdrom_open_real,
2810         .release                = ide_cdrom_release_real,
2811         .drive_status           = ide_cdrom_drive_status,
2812         .media_changed          = ide_cdrom_check_media_change_real,
2813         .tray_move              = ide_cdrom_tray_move,
2814         .lock_door              = ide_cdrom_lock_door,
2815         .select_speed           = ide_cdrom_select_speed,
2816         .get_last_session       = ide_cdrom_get_last_session,
2817         .get_mcn                = ide_cdrom_get_mcn,
2818         .reset                  = ide_cdrom_reset,
2819         .audio_ioctl            = ide_cdrom_audio_ioctl,
2820         .dev_ioctl              = ide_cdrom_dev_ioctl,
2821         .capability             = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
2822                                 CDC_SELECT_SPEED | CDC_SELECT_DISC |
2823                                 CDC_MULTI_SESSION | CDC_MCN |
2824                                 CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO | CDC_RESET |
2825                                 CDC_IOCTLS | CDC_DRIVE_STATUS | CDC_CD_R |
2826                                 CDC_CD_RW | CDC_DVD | CDC_DVD_R| CDC_DVD_RAM |
2827                                 CDC_GENERIC_PACKET | CDC_MO_DRIVE | CDC_MRW |
2828                                 CDC_MRW_W | CDC_RAM,
2829         .generic_packet         = ide_cdrom_packet,
2830 };
2831
2832 static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2833 {
2834         struct cdrom_info *info = drive->driver_data;
2835         struct cdrom_device_info *devinfo = &info->devinfo;
2836
2837         devinfo->ops = &ide_cdrom_dops;
2838         devinfo->mask = 0;
2839         devinfo->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2840         devinfo->capacity = nslots;
2841         devinfo->handle = (void *) drive;
2842         strcpy(devinfo->name, drive->name);
2843         
2844         /* set capability mask to match the probe. */
2845         if (!CDROM_CONFIG_FLAGS(drive)->cd_r)
2846                 devinfo->mask |= CDC_CD_R;
2847         if (!CDROM_CONFIG_FLAGS(drive)->cd_rw)
2848                 devinfo->mask |= CDC_CD_RW;
2849         if (!CDROM_CONFIG_FLAGS(drive)->dvd)
2850                 devinfo->mask |= CDC_DVD;
2851         if (!CDROM_CONFIG_FLAGS(drive)->dvd_r)
2852                 devinfo->mask |= CDC_DVD_R;
2853         if (!CDROM_CONFIG_FLAGS(drive)->dvd_ram)
2854                 devinfo->mask |= CDC_DVD_RAM;
2855         if (!CDROM_CONFIG_FLAGS(drive)->is_changer)
2856                 devinfo->mask |= CDC_SELECT_DISC;
2857         if (!CDROM_CONFIG_FLAGS(drive)->audio_play)
2858                 devinfo->mask |= CDC_PLAY_AUDIO;
2859         if (!CDROM_CONFIG_FLAGS(drive)->close_tray)
2860                 devinfo->mask |= CDC_CLOSE_TRAY;
2861         if (!CDROM_CONFIG_FLAGS(drive)->mo_drive)
2862                 devinfo->mask |= CDC_MO_DRIVE;
2863
2864         devinfo->disk = info->disk;
2865         return register_cdrom(devinfo);
2866 }
2867
2868 static
2869 int ide_cdrom_get_capabilities(ide_drive_t *drive, struct atapi_capabilities_page *cap)
2870 {
2871         struct cdrom_info *info = drive->driver_data;
2872         struct cdrom_device_info *cdi = &info->devinfo;
2873         struct packet_command cgc;
2874         int stat, attempts = 3, size = sizeof(*cap);
2875
2876         /*
2877          * ACER50 (and others?) require the full spec length mode sense
2878          * page capabilities size, but older drives break.
2879          */
2880         if (!(!strcmp(drive->id->model, "ATAPI CD ROM DRIVE 50X MAX") ||
2881             !strcmp(drive->id->model, "WPI CDS-32X")))
2882                 size -= sizeof(cap->pad);
2883
2884         init_cdrom_command(&cgc, cap, size, CGC_DATA_UNKNOWN);
2885         do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2886                 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
2887                 if (!stat)
2888                         break;
2889         } while (--attempts);
2890         return stat;
2891 }
2892
2893 static
2894 int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2895 {
2896         struct cdrom_info *info = drive->driver_data;
2897         struct cdrom_device_info *cdi = &info->devinfo;
2898         struct atapi_capabilities_page cap;
2899         int nslots = 1;
2900
2901         if (drive->media == ide_optical) {
2902                 CDROM_CONFIG_FLAGS(drive)->mo_drive = 1;
2903                 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2904                 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
2905                 return nslots;
2906         }
2907
2908         if (CDROM_CONFIG_FLAGS(drive)->nec260 ||
2909             !strcmp(drive->id->model,"STINGRAY 8422 IDE 8X CD-ROM 7-27-95")) {
2910                 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2911                 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2912                 return nslots;
2913         }
2914
2915         /*
2916          * we have to cheat a little here. the packet will eventually
2917          * be queued with ide_cdrom_packet(), which extracts the
2918          * drive from cdi->handle. Since this device hasn't been
2919          * registered with the Uniform layer yet, it can't do this.
2920          * Same goes for cdi->ops.
2921          */
2922         cdi->handle = (ide_drive_t *) drive;
2923         cdi->ops = &ide_cdrom_dops;
2924
2925         if (ide_cdrom_get_capabilities(drive, &cap))
2926                 return 0;
2927
2928         if (cap.lock == 0)
2929                 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2930         if (cap.eject)
2931                 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2932         if (cap.cd_r_write)
2933                 CDROM_CONFIG_FLAGS(drive)->cd_r = 1;
2934         if (cap.cd_rw_write) {
2935                 CDROM_CONFIG_FLAGS(drive)->cd_rw = 1;
2936                 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2937         }
2938         if (cap.test_write)
2939                 CDROM_CONFIG_FLAGS(drive)->test_write = 1;
2940         if (cap.dvd_ram_read || cap.dvd_r_read || cap.dvd_rom)
2941                 CDROM_CONFIG_FLAGS(drive)->dvd = 1;
2942         if (cap.dvd_ram_write) {
2943                 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 1;
2944                 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2945         }
2946         if (cap.dvd_r_write)
2947                 CDROM_CONFIG_FLAGS(drive)->dvd_r = 1;
2948         if (cap.audio_play)
2949                 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2950         if (cap.mechtype == mechtype_caddy || cap.mechtype == mechtype_popup)
2951                 CDROM_CONFIG_FLAGS(drive)->close_tray = 0;
2952
2953         /* Some drives used by Apple don't advertise audio play
2954          * but they do support reading TOC & audio datas
2955          */
2956         if (strcmp(drive->id->model, "MATSHITADVD-ROM SR-8187") == 0 ||
2957             strcmp(drive->id->model, "MATSHITADVD-ROM SR-8186") == 0 ||
2958             strcmp(drive->id->model, "MATSHITADVD-ROM SR-8176") == 0 ||
2959             strcmp(drive->id->model, "MATSHITADVD-ROM SR-8174") == 0)
2960                 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2961
2962 #if ! STANDARD_ATAPI
2963         if (cdi->sanyo_slot > 0) {
2964                 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
2965                 nslots = 3;
2966         }
2967
2968         else
2969 #endif /* not STANDARD_ATAPI */
2970         if (cap.mechtype == mechtype_individual_changer ||
2971             cap.mechtype == mechtype_cartridge_changer) {
2972                 if ((nslots = cdrom_number_of_slots(cdi)) > 1) {
2973                         CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
2974                         CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 1;
2975                 }
2976         }
2977
2978         /* The ACER/AOpen 24X cdrom has the speed fields byte-swapped */
2979         if (!drive->id->model[0] &&
2980             !strncmp(drive->id->fw_rev, "241N", 4)) {
2981                 CDROM_STATE_FLAGS(drive)->current_speed  = 
2982                         (((unsigned int)cap.curspeed) + (176/2)) / 176;
2983                 CDROM_CONFIG_FLAGS(drive)->max_speed = 
2984                         (((unsigned int)cap.maxspeed) + (176/2)) / 176;
2985         } else {
2986                 CDROM_STATE_FLAGS(drive)->current_speed  = 
2987                         (ntohs(cap.curspeed) + (176/2)) / 176;
2988                 CDROM_CONFIG_FLAGS(drive)->max_speed = 
2989                         (ntohs(cap.maxspeed) + (176/2)) / 176;
2990         }
2991
2992         /* don't print speed if the drive reported 0.
2993          */
2994         printk(KERN_INFO "%s: ATAPI", drive->name);
2995         if (CDROM_CONFIG_FLAGS(drive)->max_speed)
2996                 printk(" %dX", CDROM_CONFIG_FLAGS(drive)->max_speed);
2997         printk(" %s", CDROM_CONFIG_FLAGS(drive)->dvd ? "DVD-ROM" : "CD-ROM");
2998
2999         if (CDROM_CONFIG_FLAGS(drive)->dvd_r|CDROM_CONFIG_FLAGS(drive)->dvd_ram)
3000                 printk(" DVD%s%s", 
3001                 (CDROM_CONFIG_FLAGS(drive)->dvd_r)? "-R" : "", 
3002                 (CDROM_CONFIG_FLAGS(drive)->dvd_ram)? "-RAM" : "");
3003
3004         if (CDROM_CONFIG_FLAGS(drive)->cd_r|CDROM_CONFIG_FLAGS(drive)->cd_rw) 
3005                 printk(" CD%s%s", 
3006                 (CDROM_CONFIG_FLAGS(drive)->cd_r)? "-R" : "", 
3007                 (CDROM_CONFIG_FLAGS(drive)->cd_rw)? "/RW" : "");
3008
3009         if (CDROM_CONFIG_FLAGS(drive)->is_changer) 
3010                 printk(" changer w/%d slots", nslots);
3011         else    
3012                 printk(" drive");
3013
3014         printk(", %dkB Cache", be16_to_cpu(cap.buffer_size));
3015
3016         if (drive->using_dma)
3017                 ide_dma_verbose(drive);
3018
3019         printk("\n");
3020
3021         return nslots;
3022 }
3023
3024 static void ide_cdrom_add_settings(ide_drive_t *drive)
3025 {
3026         ide_add_setting(drive,  "dsc_overlap",          SETTING_RW, -1, -1, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
3027 }
3028
3029 /*
3030  * standard prep_rq_fn that builds 10 byte cmds
3031  */
3032 static int ide_cdrom_prep_fs(request_queue_t *q, struct request *rq)
3033 {
3034         int hard_sect = queue_hardsect_size(q);
3035         long block = (long)rq->hard_sector / (hard_sect >> 9);
3036         unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
3037
3038         memset(rq->cmd, 0, sizeof(rq->cmd));
3039
3040         if (rq_data_dir(rq) == READ)
3041                 rq->cmd[0] = GPCMD_READ_10;
3042         else
3043                 rq->cmd[0] = GPCMD_WRITE_10;
3044
3045         /*
3046          * fill in lba
3047          */
3048         rq->cmd[2] = (block >> 24) & 0xff;
3049         rq->cmd[3] = (block >> 16) & 0xff;
3050         rq->cmd[4] = (block >>  8) & 0xff;
3051         rq->cmd[5] = block & 0xff;
3052
3053         /*
3054          * and transfer length
3055          */
3056         rq->cmd[7] = (blocks >> 8) & 0xff;
3057         rq->cmd[8] = blocks & 0xff;
3058         rq->cmd_len = 10;
3059         return BLKPREP_OK;
3060 }
3061
3062 /*
3063  * Most of the SCSI commands are supported directly by ATAPI devices.
3064  * This transform handles the few exceptions.
3065  */
3066 static int ide_cdrom_prep_pc(struct request *rq)
3067 {
3068         u8 *c = rq->cmd;
3069
3070         /*
3071          * Transform 6-byte read/write commands to the 10-byte version
3072          */
3073         if (c[0] == READ_6 || c[0] == WRITE_6) {
3074                 c[8] = c[4];
3075                 c[5] = c[3];
3076                 c[4] = c[2];
3077                 c[3] = c[1] & 0x1f;
3078                 c[2] = 0;
3079                 c[1] &= 0xe0;
3080                 c[0] += (READ_10 - READ_6);
3081                 rq->cmd_len = 10;
3082                 return BLKPREP_OK;
3083         }
3084
3085         /*
3086          * it's silly to pretend we understand 6-byte sense commands, just
3087          * reject with ILLEGAL_REQUEST and the caller should take the
3088          * appropriate action
3089          */
3090         if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
3091                 rq->errors = ILLEGAL_REQUEST;
3092                 return BLKPREP_KILL;
3093         }
3094         
3095         return BLKPREP_OK;
3096 }
3097
3098 static int ide_cdrom_prep_fn(request_queue_t *q, struct request *rq)
3099 {
3100         if (rq->flags & REQ_CMD)
3101                 return ide_cdrom_prep_fs(q, rq);
3102         else if (rq->flags & REQ_BLOCK_PC)
3103                 return ide_cdrom_prep_pc(rq);
3104
3105         return 0;
3106 }
3107
3108 static
3109 int ide_cdrom_setup (ide_drive_t *drive)
3110 {
3111         struct cdrom_info *info = drive->driver_data;
3112         struct cdrom_device_info *cdi = &info->devinfo;
3113         int nslots;
3114
3115         blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
3116         blk_queue_dma_alignment(drive->queue, 31);
3117         drive->queue->unplug_delay = (1 * HZ) / 1000;
3118         if (!drive->queue->unplug_delay)
3119                 drive->queue->unplug_delay = 1;
3120
3121         drive->special.all      = 0;
3122
3123         CDROM_STATE_FLAGS(drive)->media_changed = 1;
3124         CDROM_STATE_FLAGS(drive)->toc_valid     = 0;
3125         CDROM_STATE_FLAGS(drive)->door_locked   = 0;
3126
3127 #if NO_DOOR_LOCKING
3128         CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
3129 #else
3130         CDROM_CONFIG_FLAGS(drive)->no_doorlock = 0;
3131 #endif
3132
3133         CDROM_CONFIG_FLAGS(drive)->drq_interrupt = ((drive->id->config & 0x0060) == 0x20);
3134         CDROM_CONFIG_FLAGS(drive)->is_changer = 0;
3135         CDROM_CONFIG_FLAGS(drive)->cd_r = 0;
3136         CDROM_CONFIG_FLAGS(drive)->cd_rw = 0;
3137         CDROM_CONFIG_FLAGS(drive)->test_write = 0;
3138         CDROM_CONFIG_FLAGS(drive)->dvd = 0;
3139         CDROM_CONFIG_FLAGS(drive)->dvd_r = 0;
3140         CDROM_CONFIG_FLAGS(drive)->dvd_ram = 0;
3141         CDROM_CONFIG_FLAGS(drive)->no_eject = 1;
3142         CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 0;
3143         CDROM_CONFIG_FLAGS(drive)->audio_play = 0;
3144         CDROM_CONFIG_FLAGS(drive)->close_tray = 1;
3145         
3146         /* limit transfer size per interrupt. */
3147         CDROM_CONFIG_FLAGS(drive)->limit_nframes = 0;
3148         /* a testament to the nice quality of Samsung drives... */
3149         if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2430"))
3150                 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3151         else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2432"))
3152                 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3153         /* the 3231 model does not support the SET_CD_SPEED command */
3154         else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-3231"))
3155                 cdi->mask |= CDC_SELECT_SPEED;
3156
3157 #if ! STANDARD_ATAPI
3158         /* by default Sanyo 3 CD changer support is turned off and
3159            ATAPI Rev 2.2+ standard support for CD changers is used */
3160         cdi->sanyo_slot = 0;
3161
3162         CDROM_CONFIG_FLAGS(drive)->nec260 = 0;
3163         CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 0;
3164         CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 0;
3165         CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 0;
3166         CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 0;
3167
3168         if (strcmp (drive->id->model, "V003S0DS") == 0 &&
3169             drive->id->fw_rev[4] == '1' &&
3170             drive->id->fw_rev[6] <= '2') {
3171                 /* Vertos 300.
3172                    Some versions of this drive like to talk BCD. */
3173                 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3174                 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3175                 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3176                 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3177         }
3178
3179         else if (strcmp (drive->id->model, "V006E0DS") == 0 &&
3180             drive->id->fw_rev[4] == '1' &&
3181             drive->id->fw_rev[6] <= '2') {
3182                 /* Vertos 600 ESD. */
3183                 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3184         }
3185         else if (strcmp(drive->id->model, "NEC CD-ROM DRIVE:260") == 0 &&
3186                  strncmp(drive->id->fw_rev, "1.01", 4) == 0) { /* FIXME */
3187                 /* Old NEC260 (not R).
3188                    This drive was released before the 1.2 version
3189                    of the spec. */
3190                 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3191                 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3192                 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3193                 CDROM_CONFIG_FLAGS(drive)->nec260         = 1;
3194         }
3195         else if (strcmp(drive->id->model, "WEARNES CDD-120") == 0 &&
3196                  strncmp(drive->id->fw_rev, "A1.1", 4) == 0) { /* FIXME */
3197                 /* Wearnes */
3198                 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3199                 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3200         }
3201         /* Sanyo 3 CD changer uses a non-standard command
3202            for CD changing */
3203         else if ((strcmp(drive->id->model, "CD-ROM CDR-C3 G") == 0) ||
3204                  (strcmp(drive->id->model, "CD-ROM CDR-C3G") == 0) ||
3205                  (strcmp(drive->id->model, "CD-ROM CDR_C36") == 0)) {
3206                  /* uses CD in slot 0 when value is set to 3 */
3207                  cdi->sanyo_slot = 3;
3208         }
3209 #endif /* not STANDARD_ATAPI */
3210
3211         info->toc               = NULL;
3212         info->buffer            = NULL;
3213         info->sector_buffered   = 0;
3214         info->nsectors_buffered = 0;
3215         info->changer_info      = NULL;
3216         info->last_block        = 0;
3217         info->start_seek        = 0;
3218
3219         nslots = ide_cdrom_probe_capabilities (drive);
3220
3221         /*
3222          * set correct block size
3223          */
3224         blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
3225
3226         if (drive->autotune == IDE_TUNE_DEFAULT ||
3227             drive->autotune == IDE_TUNE_AUTO)
3228                 drive->dsc_overlap = (drive->next != drive);
3229 #if 0
3230         drive->dsc_overlap = (HWIF(drive)->no_dsc) ? 0 : 1;
3231         if (HWIF(drive)->no_dsc) {
3232                 printk(KERN_INFO "ide-cd: %s: disabling DSC overlap\n",
3233                         drive->name);
3234                 drive->dsc_overlap = 0;
3235         }
3236 #endif
3237
3238         if (ide_cdrom_register(drive, nslots)) {
3239                 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
3240                 info->devinfo.handle = NULL;
3241                 return 1;
3242         }
3243         ide_cdrom_add_settings(drive);
3244         return 0;
3245 }
3246
3247 static
3248 sector_t ide_cdrom_capacity (ide_drive_t *drive)
3249 {
3250         unsigned long capacity, sectors_per_frame;
3251
3252         if (cdrom_read_capacity(drive, &capacity, &sectors_per_frame, NULL))
3253                 return 0;
3254
3255         return capacity * sectors_per_frame;
3256 }
3257
3258 static
3259 int ide_cdrom_cleanup(ide_drive_t *drive)
3260 {
3261         struct cdrom_info *info = drive->driver_data;
3262
3263         if (ide_unregister_subdriver(drive)) {
3264                 printk(KERN_ERR "%s: %s: failed to ide_unregister_subdriver\n",
3265                         __FUNCTION__, drive->name);
3266                 return 1;
3267         }
3268
3269         del_gendisk(info->disk);
3270
3271         ide_cd_put(info);
3272
3273         return 0;
3274 }
3275
3276 static void ide_cd_release(struct kref *kref)
3277 {
3278         struct cdrom_info *info = to_ide_cd(kref);
3279         struct cdrom_device_info *devinfo = &info->devinfo;
3280         ide_drive_t *drive = info->drive;
3281         struct gendisk *g = info->disk;
3282
3283         if (info->buffer != NULL)
3284                 kfree(info->buffer);
3285         if (info->toc != NULL)
3286                 kfree(info->toc);
3287         if (info->changer_info != NULL)
3288                 kfree(info->changer_info);
3289         if (devinfo->handle == drive && unregister_cdrom(devinfo))
3290                 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom "
3291                                 "driver.\n", __FUNCTION__, drive->name);
3292         drive->dsc_overlap = 0;
3293         drive->driver_data = NULL;
3294         blk_queue_prep_rq(drive->queue, NULL);
3295         g->private_data = NULL;
3296         put_disk(g);
3297         kfree(info);
3298 }
3299
3300 static int ide_cdrom_attach (ide_drive_t *drive);
3301
3302 #ifdef CONFIG_PROC_FS
3303 static int proc_idecd_read_capacity
3304         (char *page, char **start, off_t off, int count, int *eof, void *data)
3305 {
3306         ide_drive_t*drive = (ide_drive_t *)data;
3307         int len;
3308
3309         len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
3310         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
3311 }
3312
3313 static ide_proc_entry_t idecd_proc[] = {
3314         { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
3315         { NULL, 0, NULL, NULL }
3316 };
3317 #else
3318 # define idecd_proc     NULL
3319 #endif
3320
3321 static ide_driver_t ide_cdrom_driver = {
3322         .owner                  = THIS_MODULE,
3323         .name                   = "ide-cdrom",
3324         .version                = IDECD_VERSION,
3325         .media                  = ide_cdrom,
3326         .busy                   = 0,
3327         .supports_dsc_overlap   = 1,
3328         .cleanup                = ide_cdrom_cleanup,
3329         .do_request             = ide_do_rw_cdrom,
3330         .end_request            = ide_end_request,
3331         .error                  = __ide_error,
3332         .abort                  = __ide_abort,
3333         .proc                   = idecd_proc,
3334         .attach                 = ide_cdrom_attach,
3335         .drives                 = LIST_HEAD_INIT(ide_cdrom_driver.drives),
3336 };
3337
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_cdrom_attach (ide_drive_t *drive)
3422 {
3423         struct cdrom_info *info;
3424         struct gendisk *g;
3425         struct request_sense sense;
3426
3427         if (!strstr("ide-cdrom", drive->driver_req))
3428                 goto failed;
3429         if (!drive->present)
3430                 goto failed;
3431         if (drive->media != ide_cdrom && drive->media != ide_optical)
3432                 goto failed;
3433         /* skip drives that we were told to ignore */
3434         if (ignore != NULL) {
3435                 if (strstr(ignore, drive->name)) {
3436                         printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
3437                         goto failed;
3438                 }
3439         }
3440         if (drive->scsi) {
3441                 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
3442                 goto failed;
3443         }
3444         info = (struct cdrom_info *) kmalloc (sizeof (struct cdrom_info), GFP_KERNEL);
3445         if (info == NULL) {
3446                 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
3447                 goto failed;
3448         }
3449
3450         g = alloc_disk(1 << PARTN_BITS);
3451         if (!g)
3452                 goto out_free_cd;
3453
3454         ide_init_disk(g, drive);
3455
3456         if (ide_register_subdriver(drive, &ide_cdrom_driver)) {
3457                 printk(KERN_ERR "%s: Failed to register the driver with ide.c\n",
3458                         drive->name);
3459                 goto out_put_disk;
3460         }
3461         memset(info, 0, sizeof (struct cdrom_info));
3462
3463         kref_init(&info->kref);
3464
3465         info->drive = drive;
3466         info->driver = &ide_cdrom_driver;
3467         info->disk = g;
3468
3469         g->private_data = &info->driver;
3470
3471         drive->driver_data = info;
3472
3473         DRIVER(drive)->busy++;
3474         g->minors = 1;
3475         snprintf(g->devfs_name, sizeof(g->devfs_name),
3476                         "%s/cd", drive->devfs_name);
3477         g->driverfs_dev = &drive->gendev;
3478         g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
3479         if (ide_cdrom_setup(drive)) {
3480                 struct cdrom_device_info *devinfo = &info->devinfo;
3481                 DRIVER(drive)->busy--;
3482                 ide_unregister_subdriver(drive);
3483                 if (info->buffer != NULL)
3484                         kfree(info->buffer);
3485                 if (info->toc != NULL)
3486                         kfree(info->toc);
3487                 if (info->changer_info != NULL)
3488                         kfree(info->changer_info);
3489                 if (devinfo->handle == drive && unregister_cdrom(devinfo))
3490                         printk (KERN_ERR "%s: ide_cdrom_cleanup failed to unregister device from the cdrom driver.\n", drive->name);
3491                 kfree(info);
3492                 drive->driver_data = NULL;
3493                 goto failed;
3494         }
3495         DRIVER(drive)->busy--;
3496
3497         cdrom_read_toc(drive, &sense);
3498         g->fops = &idecd_ops;
3499         g->flags |= GENHD_FL_REMOVABLE;
3500         add_disk(g);
3501         return 0;
3502
3503 out_put_disk:
3504         put_disk(g);
3505 out_free_cd:
3506         kfree(info);
3507 failed:
3508         return 1;
3509 }
3510
3511 static void __exit ide_cdrom_exit(void)
3512 {
3513         ide_unregister_driver(&ide_cdrom_driver);
3514 }
3515  
3516 static int ide_cdrom_init(void)
3517 {
3518         ide_register_driver(&ide_cdrom_driver);
3519         return 0;
3520 }
3521
3522 module_init(ide_cdrom_init);
3523 module_exit(ide_cdrom_exit);
3524 MODULE_LICENSE("GPL");