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