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