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