drivers/ide/ide-cd.c

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