drivers/ide/ide-cd.c

   1 /*
   2  * linux/drivers/ide/ide-cd.c
   3  *
   4  * Copyright (C) 1994, 1995, 1996  scott snyder  <snyder@fnald0.fnal.gov>
   5  * Copyright (C) 1996-1998  Erik Andersen <andersee@debian.org>
   6  * Copyright (C) 1998-2000  Jens Axboe <axboe@suse.de>
   7  *
   8  * May be copied or modified under the terms of the GNU General Public
   9  * License.  See linux/COPYING for more information.
  10  *
  11  * ATAPI CD-ROM driver.  To be used with ide.c.
  12  * See Documentation/cdrom/ide-cd for usage information.
  13  *
  14  * Suggestions are welcome. Patches that work are more welcome though. ;-)
  15  * For those wishing to work on this driver, please be sure you download
  16  * and comply with the latest Mt. Fuji (SFF8090 version 4) and ATAPI
  17  * (SFF-8020i rev 2.6) standards. These documents can be obtained by
  18  * anonymous ftp from:
  19  * ftp://fission.dt.wdc.com/pub/standards/SFF_atapi/spec/SFF8020-r2.6/PS/8020r26.ps
  20  * ftp://ftp.avc-pioneer.com/Mtfuji4/Spec/Fuji4r10.pdf
  21  *
  22  * Drives that deviate from these standards will be accommodated as much
  23  * as possible via compile time or command-line options.  Since I only have
  24  * a few drives, you generally need to send me patches...
  25  *
  26  * ----------------------------------
  27  * TO DO LIST:
  28  * -Make it so that Pioneer CD DR-A24X and friends don't get screwed up on
  29  *   boot
  30  *
  31  * ----------------------------------
  32  * 1.00  Oct 31, 1994 -- Initial version.
  33  * 1.01  Nov  2, 1994 -- Fixed problem with starting request in
  34  *                       cdrom_check_status.
  35  * 1.03  Nov 25, 1994 -- leaving unmask_intr[] as a user-setting (as for disks)
  36  * (from mlord)       -- minor changes to cdrom_setup()
  37  *                    -- renamed ide_dev_s to ide_drive_t, enable irq on command
  38  * 2.00  Nov 27, 1994 -- Generalize packet command interface;
  39  *                       add audio ioctls.
  40  * 2.01  Dec  3, 1994 -- Rework packet command interface to handle devices
  41  *                       which send an interrupt when ready for a command.
  42  * 2.02  Dec 11, 1994 -- Cache the TOC in the driver.
  43  *                       Don't use SCMD_PLAYAUDIO_TI; it's not included
  44  *                       in the current version of ATAPI.
  45  *                       Try to use LBA instead of track or MSF addressing
  46  *                       when possible.
  47  *                       Don't wait for READY_STAT.
  48  * 2.03  Jan 10, 1995 -- Rewrite block read routines to handle block sizes
  49  *                       other than 2k and to move multiple sectors in a
  50  *                       single transaction.
  51  * 2.04  Apr 21, 1995 -- Add work-around for Creative Labs CD220E drives.
  52  *                       Thanks to Nick Saw <cwsaw@pts7.pts.mot.com> for
  53  *                       help in figuring this out.  Ditto for Acer and
  54  *                       Aztech drives, which seem to have the same problem.
  55  * 2.04b May 30, 1995 -- Fix to match changes in ide.c version 3.16 -ml
  56  * 2.05  Jun  8, 1995 -- Don't attempt to retry after an illegal request
  57  *                        or data protect error.
  58  *                       Use HWIF and DEV_HWIF macros as in ide.c.
  59  *                       Always try to do a request_sense after
  60  *                        a failed command.
  61  *                       Include an option to give textual descriptions
  62  *                        of ATAPI errors.
  63  *                       Fix a bug in handling the sector cache which
  64  *                        showed up if the drive returned data in 512 byte
  65  *                        blocks (like Pioneer drives).  Thanks to
  66  *                        Richard Hirst <srh@gpt.co.uk> for diagnosing this.
  67  *                       Properly supply the page number field in the
  68  *                        MODE_SELECT command.
  69  *                       PLAYAUDIO12 is broken on the Aztech; work around it.
  70  * 2.05x Aug 11, 1995 -- lots of data structure renaming/restructuring in ide.c
  71  *                       (my apologies to Scott, but now ide-cd.c is independent)
  72  * 3.00  Aug 22, 1995 -- Implement CDROMMULTISESSION ioctl.
  73  *                       Implement CDROMREADAUDIO ioctl (UNTESTED).
  74  *                       Use input_ide_data() and output_ide_data().
  75  *                       Add door locking.
  76  *                       Fix usage count leak in cdrom_open, which happened
  77  *                        when a read-write mount was attempted.
  78  *                       Try to load the disk on open.
  79  *                       Implement CDROMEJECT_SW ioctl (off by default).
  80  *                       Read total cdrom capacity during open.
  81  *                       Rearrange logic in cdrom_decode_status.  Issue
  82  *                        request sense commands for failed packet commands
  83  *                        from here instead of from cdrom_queue_packet_command.
  84  *                        Fix a race condition in retrieving error information.
  85  *                       Suppress printing normal unit attention errors and
  86  *                        some drive not ready errors.
  87  *                       Implement CDROMVOLREAD ioctl.
  88  *                       Implement CDROMREADMODE1/2 ioctls.
  89  *                       Fix race condition in setting up interrupt handlers
  90  *                        when the `serialize' option is used.
  91  * 3.01  Sep  2, 1995 -- Fix ordering of reenabling interrupts in
  92  *                        cdrom_queue_request.
  93  *                       Another try at using ide_[input,output]_data.
  94  * 3.02  Sep 16, 1995 -- Stick total disk capacity in partition table as well.
  95  *                       Make VERBOSE_IDE_CD_ERRORS dump failed command again.
  96  *                       Dump out more information for ILLEGAL REQUEST errs.
  97  *                       Fix handling of errors occurring before the
  98  *                        packet command is transferred.
  99  *                       Fix transfers with odd bytelengths.
 100  * 3.03  Oct 27, 1995 -- Some Creative drives have an id of just `CD'.
 101  *                       `DCI-2S10' drives are broken too.
 102  * 3.04  Nov 20, 1995 -- So are Vertos drives.
 103  * 3.05  Dec  1, 1995 -- Changes to go with overhaul of ide.c and ide-tape.c
 104  * 3.06  Dec 16, 1995 -- Add support needed for partitions.
 105  *                       More workarounds for Vertos bugs (based on patches
 106  *                        from Holger Dietze <dietze@aix520.informatik.uni-leipzig.de>).
 107  *                       Try to eliminate byteorder assumptions.
 108  *                       Use atapi_cdrom_subchnl struct definition.
 109  *                       Add STANDARD_ATAPI compilation option.
 110  * 3.07  Jan 29, 1996 -- More twiddling for broken drives: Sony 55D,
 111  *                        Vertos 300.
 112  *                       Add NO_DOOR_LOCKING configuration option.
 113  *                       Handle drive_cmd requests w/NULL args (for hdparm -t).
 114  *                       Work around sporadic Sony55e audio play problem.
 115  * 3.07a Feb 11, 1996 -- check drive->id for NULL before dereferencing, to fix
 116  *                        problem with "hde=cdrom" with no drive present.  -ml
 117  * 3.08  Mar  6, 1996 -- More Vertos workarounds.
 118  * 3.09  Apr  5, 1996 -- Add CDROMCLOSETRAY ioctl.
 119  *                       Switch to using MSF addressing for audio commands.
 120  *                       Reformat to match kernel tabbing style.
 121  *                       Add CDROM_GET_UPC ioctl.
 122  * 3.10  Apr 10, 1996 -- Fix compilation error with STANDARD_ATAPI.
 123  * 3.11  Apr 29, 1996 -- Patch from Heiko Eißfeldt <heiko@colossus.escape.de>
 124  *                       to remove redundant verify_area calls.
 125  * 3.12  May  7, 1996 -- Rudimentary changer support.  Based on patches
 126  *                        from Gerhard Zuber <zuber@berlin.snafu.de>.
 127  *                       Let open succeed even if there's no loaded disc.
 128  * 3.13  May 19, 1996 -- Fixes for changer code.
 129  * 3.14  May 29, 1996 -- Add work-around for Vertos 600.
 130  *                        (From Hennus Bergman <hennus@sky.ow.nl>.)
 131  * 3.15  July 2, 1996 -- Added support for Sanyo 3 CD changers
 132  *                        from Ben Galliart <bgallia@luc.edu> with
 133  *                        special help from Jeff Lightfoot
 134  *                        <jeffml@pobox.com>
 135  * 3.15a July 9, 1996 -- Improved Sanyo 3 CD changer identification
 136  * 3.16  Jul 28, 1996 -- Fix from Gadi to reduce kernel stack usage for ioctl.
 137  * 3.17  Sep 17, 1996 -- Tweak audio reads for some drives.
 138  *                       Start changing CDROMLOADFROMSLOT to CDROM_SELECT_DISC.
 139  * 3.18  Oct 31, 1996 -- Added module and DMA support.
 140  *
 141  *
 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 Eißfeldt <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->cmd_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 < ARRAY_SIZE(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 = ARRAY_SIZE(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= ARRAY_SIZE(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->cmd_type = REQ_TYPE_ATA_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->cmd_type = REQ_TYPE_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 (blk_sense_request(rq) && uptodate) {
 634                 /*
 635                  * For REQ_TYPE_SENSE, "rq->buffer" points to the original
 636                  * failed 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 (blk_sense_request(rq)) {
 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->cmd_flags |= REQ_FAILED;
 715                 cdrom_end_request(drive, 0);
 716                 ide_error(drive, "request sense failure", stat);
 717                 return 1;
 718
 719         } else if (blk_pc_request(rq) || rq->cmd_type == REQ_TYPE_ATA_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 (blk_pc_request(rq) && !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 ((sense_key == ILLEGAL_REQUEST) &&
 739                            (rq->cmd[0] == GPCMD_START_STOP_UNIT)) {
 740                         /*
 741                          * Don't print error message for this condition--
 742                          * SFF8090i indicates that 5/24/00 is the correct
 743                          * response to a request to close the tray if the
 744                          * drive doesn't have that capability.
 745                          * cdrom_log_sense() knows this!
 746                          */
 747                 } else if (!(rq->cmd_flags & REQ_QUIET)) {
 748                         /* Otherwise, print an error. */
 749                         ide_dump_status(drive, "packet command error", stat);
 750                 }
 751
 752                 rq->cmd_flags |= REQ_FAILED;
 753
 754                 /*
 755                  * instead of playing games with moving completions around,
 756                  * remove failed request completely and end it when the
 757                  * request sense has completed
 758                  */
 759                 if (stat & ERR_STAT) {
 760                         spin_lock_irqsave(&ide_lock, flags);
 761                         blkdev_dequeue_request(rq);
 762                         HWGROUP(drive)->rq = NULL;
 763                         spin_unlock_irqrestore(&ide_lock, flags);
 764
 765                         cdrom_queue_request_sense(drive, rq->sense, rq);
 766                 } else
 767                         cdrom_end_request(drive, 0);
 768
 769         } else if (blk_fs_request(rq)) {
 770                 int do_end_request = 0;
 771
 772                 /* Handle errors from READ and WRITE requests. */
 773
 774                 if (blk_noretry_request(rq))
 775                         do_end_request = 1;
 776
 777                 if (sense_key == NOT_READY) {
 778                         /* Tray open. */
 779                         if (rq_data_dir(rq) == READ) {
 780                                 cdrom_saw_media_change (drive);
 781
 782                                 /* Fail the request. */
 783                                 printk ("%s: tray open\n", drive->name);
 784                                 do_end_request = 1;
 785                         } else {
 786                                 struct cdrom_info *info = drive->driver_data;
 787
 788                                 /* allow the drive 5 seconds to recover, some
 789                                  * devices will return this error while flushing
 790                                  * data from cache */
 791                                 if (!rq->errors)
 792                                         info->write_timeout = jiffies + ATAPI_WAIT_WRITE_BUSY;
 793                                 rq->errors = 1;
 794                                 if (time_after(jiffies, info->write_timeout))
 795                                         do_end_request = 1;
 796                                 else {
 797                                         unsigned long flags;
 798
 799                                         /*
 800                                          * take a breather relying on the
 801                                          * unplug timer to kick us again
 802                                          */
 803                                         spin_lock_irqsave(&ide_lock, flags);
 804                                         blk_plug_device(drive->queue);
 805                                         spin_unlock_irqrestore(&ide_lock,flags);
 806                                         return 1;
 807                                 }
 808                         }
 809                 } else if (sense_key == UNIT_ATTENTION) {
 810                         /* Media change. */
 811                         cdrom_saw_media_change (drive);
 812
 813                         /* Arrange to retry the request.
 814                            But be sure to give up if we've retried
 815                            too many times. */
 816                         if (++rq->errors > ERROR_MAX)
 817                                 do_end_request = 1;
 818                 } else if (sense_key == ILLEGAL_REQUEST ||
 819                            sense_key == DATA_PROTECT) {
 820                         /* No point in retrying after an illegal
 821                            request or data protect error.*/
 822                         ide_dump_status_no_sense (drive, "command error", stat);
 823                         do_end_request = 1;
 824                 } else if (sense_key == MEDIUM_ERROR) {
 825                         /* No point in re-trying a zillion times on a bad
 826                          * sector...  If we got here the error is not correctable */
 827                         ide_dump_status_no_sense (drive, "media error (bad sector)", stat);
 828                         do_end_request = 1;
 829                 } else if (sense_key == BLANK_CHECK) {
 830                         /* Disk appears blank ?? */
 831                         ide_dump_status_no_sense (drive, "media error (blank)", stat);
 832                         do_end_request = 1;
 833                 } else if ((err & ~ABRT_ERR) != 0) {
 834                         /* Go to the default handler
 835                            for other errors. */
 836                         ide_error(drive, "cdrom_decode_status", stat);
 837                         return 1;
 838                 } else if ((++rq->errors > ERROR_MAX)) {
 839                         /* We've racked up too many retries.  Abort. */
 840                         do_end_request = 1;
 841                 }
 842
 843                 /* End a request through request sense analysis when we have
 844                    sense data. We need this in order to perform end of media
 845                    processing */
 846
 847                 if (do_end_request) {
 848                         if (stat & ERR_STAT) {
 849                                 unsigned long flags;
 850                                 spin_lock_irqsave(&ide_lock, flags);
 851                                 blkdev_dequeue_request(rq);
 852                                 HWGROUP(drive)->rq = NULL;
 853                                 spin_unlock_irqrestore(&ide_lock, flags);
 854
 855                                 cdrom_queue_request_sense(drive, rq->sense, rq);
 856                         } else
 857                                 cdrom_end_request(drive, 0);
 858                 } else {
 859                         /* If we got a CHECK_CONDITION status,
 860                            queue a request sense command. */
 861                         if (stat & ERR_STAT)
 862                                 cdrom_queue_request_sense(drive, NULL, NULL);
 863                 }
 864         } else {
 865                 blk_dump_rq_flags(rq, "ide-cd: bad rq");
 866                 cdrom_end_request(drive, 0);
 867         }
 868
 869         /* Retry, or handle the next request. */
 870         return 1;
 871 }
 872
 873 static int cdrom_timer_expiry(ide_drive_t *drive)
 874 {
 875         struct request *rq = HWGROUP(drive)->rq;
 876         unsigned long wait = 0;
 877
 878         /*
 879          * Some commands are *slow* and normally take a long time to
 880          * complete. Usually we can use the ATAPI "disconnect" to bypass
 881          * this, but not all commands/drives support that. Let
 882          * ide_timer_expiry keep polling us for these.
 883          */
 884         switch (rq->cmd[0]) {
 885                 case GPCMD_BLANK:
 886                 case GPCMD_FORMAT_UNIT:
 887                 case GPCMD_RESERVE_RZONE_TRACK:
 888                 case GPCMD_CLOSE_TRACK:
 889                 case GPCMD_FLUSH_CACHE:
 890                         wait = ATAPI_WAIT_PC;
 891                         break;
 892                 default:
 893                         if (!(rq->cmd_flags & REQ_QUIET))
 894                                 printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n", rq->cmd[0]);
 895                         wait = 0;
 896                         break;
 897         }
 898         return wait;
 899 }
 900
 901 /* Set up the device registers for transferring a packet command on DEV,
 902    expecting to later transfer XFERLEN bytes.  HANDLER is the routine
 903    which actually transfers the command to the drive.  If this is a
 904    drq_interrupt device, this routine will arrange for HANDLER to be
 905    called when the interrupt from the drive arrives.  Otherwise, HANDLER
 906    will be called immediately after the drive is prepared for the transfer. */
 907
 908 static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
 909                                                   int xferlen,
 910                                                   ide_handler_t *handler)
 911 {
 912         ide_startstop_t startstop;
 913         struct cdrom_info *info = drive->driver_data;
 914         ide_hwif_t *hwif = drive->hwif;
 915
 916         /* Wait for the controller to be idle. */
 917         if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY))
 918                 return startstop;
 919
 920         if (info->dma)
 921                 info->dma = !hwif->dma_setup(drive);
 922
 923         /* Set up the controller registers. */
 924         /* FIXME: for Virtual DMA we must check harder */
 925         HWIF(drive)->OUTB(info->dma, IDE_FEATURE_REG);
 926         HWIF(drive)->OUTB(0, IDE_IREASON_REG);
 927         HWIF(drive)->OUTB(0, IDE_SECTOR_REG);
 928
 929         HWIF(drive)->OUTB(xferlen & 0xff, IDE_BCOUNTL_REG);
 930         HWIF(drive)->OUTB(xferlen >> 8  , IDE_BCOUNTH_REG);
 931         if (IDE_CONTROL_REG)
 932                 HWIF(drive)->OUTB(drive->ctl, IDE_CONTROL_REG);
 933
 934         if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt) {
 935                 /* waiting for CDB interrupt, not DMA yet. */
 936                 if (info->dma)
 937                         drive->waiting_for_dma = 0;
 938
 939                 /* packet command */
 940                 ide_execute_command(drive, WIN_PACKETCMD, handler, ATAPI_WAIT_PC, cdrom_timer_expiry);
 941                 return ide_started;
 942         } else {
 943                 unsigned long flags;
 944
 945                 /* packet command */
 946                 spin_lock_irqsave(&ide_lock, flags);
 947                 hwif->OUTBSYNC(drive, WIN_PACKETCMD, IDE_COMMAND_REG);
 948                 ndelay(400);
 949                 spin_unlock_irqrestore(&ide_lock, flags);
 950
 951                 return (*handler) (drive);
 952         }
 953 }
 954
 955 /* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
 956    The device registers must have already been prepared
 957    by cdrom_start_packet_command.
 958    HANDLER is the interrupt handler to call when the command completes
 959    or there's data ready. */
 960 /*
 961  * changed 5 parameters to 3 for dvd-ram
 962  * struct packet_command *pc; now packet_command_t *pc;
 963  */
 964 #define ATAPI_MIN_CDB_BYTES 12
 965 static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
 966                                           struct request *rq,
 967                                           ide_handler_t *handler)
 968 {
 969         ide_hwif_t *hwif = drive->hwif;
 970         int cmd_len;
 971         struct cdrom_info *info = drive->driver_data;
 972         ide_startstop_t startstop;
 973
 974         if (CDROM_CONFIG_FLAGS(drive)->drq_interrupt) {
 975                 /* Here we should have been called after receiving an interrupt
 976                    from the device.  DRQ should how be set. */
 977
 978                 /* Check for errors. */
 979                 if (cdrom_decode_status(drive, DRQ_STAT, NULL))
 980                         return ide_stopped;
 981
 982                 /* Ok, next interrupt will be DMA interrupt. */
 983                 if (info->dma)
 984                         drive->waiting_for_dma = 1;
 985         } else {
 986                 /* Otherwise, we must wait for DRQ to get set. */
 987                 if (ide_wait_stat(&startstop, drive, DRQ_STAT,
 988                                 BUSY_STAT, WAIT_READY))
 989                         return startstop;
 990         }
 991
 992         /* Arm the interrupt handler. */
 993         ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);
 994
 995         /* ATAPI commands get padded out to 12 bytes minimum */
 996         cmd_len = COMMAND_SIZE(rq->cmd[0]);
 997         if (cmd_len < ATAPI_MIN_CDB_BYTES)
 998                 cmd_len = ATAPI_MIN_CDB_BYTES;
 999
1000         /* Send the command to the device. */
1001         HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len);
1002
1003         /* Start the DMA if need be */
1004         if (info->dma)
1005                 hwif->dma_start(drive);
1006
1007         return ide_started;
1008 }
1009
1010 /****************************************************************************
1011  * Block read functions.
1012  */
1013
1014 /*
1015  * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
1016  * buffer.  Once the first sector is added, any subsequent sectors are
1017  * assumed to be continuous (until the buffer is cleared).  For the first
1018  * sector added, SECTOR is its sector number.  (SECTOR is then ignored until
1019  * the buffer is cleared.)
1020  */
1021 static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
1022                                   int sectors_to_transfer)
1023 {
1024         struct cdrom_info *info = drive->driver_data;
1025
1026         /* Number of sectors to read into the buffer. */
1027         int sectors_to_buffer = min_t(int, sectors_to_transfer,
1028                                      (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
1029                                        info->nsectors_buffered);
1030
1031         char *dest;
1032
1033         /* If we couldn't get a buffer, don't try to buffer anything... */
1034         if (info->buffer == NULL)
1035                 sectors_to_buffer = 0;
1036
1037         /* If this is the first sector in the buffer, remember its number. */
1038         if (info->nsectors_buffered == 0)
1039                 info->sector_buffered = sector;
1040
1041         /* Read the data into the buffer. */
1042         dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
1043         while (sectors_to_buffer > 0) {
1044                 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
1045                 --sectors_to_buffer;
1046                 --sectors_to_transfer;
1047                 ++info->nsectors_buffered;
1048                 dest += SECTOR_SIZE;
1049         }
1050
1051         /* Throw away any remaining data. */
1052         while (sectors_to_transfer > 0) {
1053                 static char dum[SECTOR_SIZE];
1054                 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1055                 --sectors_to_transfer;
1056         }
1057 }
1058
1059 /*
1060  * Check the contents of the interrupt reason register from the cdrom
1061  * and attempt to recover if there are problems.  Returns  0 if everything's
1062  * ok; nonzero if the request has been terminated.
1063  */
1064 static
1065 int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
1066 {
1067         if (ireason == 2)
1068                 return 0;
1069         else if (ireason == 0) {
1070                 /* Whoops... The drive is expecting to receive data from us! */
1071                 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
1072                                 drive->name, __FUNCTION__);
1073
1074                 /* Throw some data at the drive so it doesn't hang
1075                    and quit this request. */
1076                 while (len > 0) {
1077                         int dum = 0;
1078                         HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof (dum));
1079                         len -= sizeof (dum);
1080                 }
1081         } else  if (ireason == 1) {
1082                 /* Some drives (ASUS) seem to tell us that status
1083                  * info is available. just get it and ignore.
1084                  */
1085                 (void) HWIF(drive)->INB(IDE_STATUS_REG);
1086                 return 0;
1087         } else {
1088                 /* Drive wants a command packet, or invalid ireason... */
1089                 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
1090                                 drive->name, __FUNCTION__, ireason);
1091         }
1092
1093         cdrom_end_request(drive, 0);
1094         return -1;
1095 }
1096
1097 /*
1098  * Interrupt routine.  Called when a read request has completed.
1099  */
1100 static ide_startstop_t cdrom_read_intr (ide_drive_t *drive)
1101 {
1102         int stat;
1103         int ireason, len, sectors_to_transfer, nskip;
1104         struct cdrom_info *info = drive->driver_data;
1105         u8 lowcyl = 0, highcyl = 0;
1106         int dma = info->dma, dma_error = 0;
1107
1108         struct request *rq = HWGROUP(drive)->rq;
1109
1110         /*
1111          * handle dma case
1112          */
1113         if (dma) {
1114                 info->dma = 0;
1115                 dma_error = HWIF(drive)->ide_dma_end(drive);
1116                 if (dma_error) {
1117                         printk(KERN_ERR "%s: DMA read error\n", drive->name);
1118                         ide_dma_off(drive);
1119                 }
1120         }
1121
1122         if (cdrom_decode_status(drive, 0, &stat))
1123                 return ide_stopped;
1124
1125         if (dma) {
1126                 if (!dma_error) {
1127                         ide_end_request(drive, 1, rq->nr_sectors);
1128                         return ide_stopped;
1129                 } else
1130                         return ide_error(drive, "dma error", stat);
1131         }
1132
1133         /* Read the interrupt reason and the transfer length. */
1134         ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1135         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1136         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1137
1138         len = lowcyl + (256 * highcyl);
1139
1140         /* If DRQ is clear, the command has completed. */
1141         if ((stat & DRQ_STAT) == 0) {
1142                 /* If we're not done filling the current buffer, complain.
1143                    Otherwise, complete the command normally. */
1144                 if (rq->current_nr_sectors > 0) {
1145                         printk (KERN_ERR "%s: cdrom_read_intr: data underrun (%d blocks)\n",
1146                                 drive->name, rq->current_nr_sectors);
1147                         rq->cmd_flags |= REQ_FAILED;
1148                         cdrom_end_request(drive, 0);
1149                 } else
1150                         cdrom_end_request(drive, 1);
1151                 return ide_stopped;
1152         }
1153
1154         /* Check that the drive is expecting to do the same thing we are. */
1155         if (cdrom_read_check_ireason (drive, len, ireason))
1156                 return ide_stopped;
1157
1158         /* Assume that the drive will always provide data in multiples
1159            of at least SECTOR_SIZE, as it gets hairy to keep track
1160            of the transfers otherwise. */
1161         if ((len % SECTOR_SIZE) != 0) {
1162                 printk (KERN_ERR "%s: cdrom_read_intr: Bad transfer size %d\n",
1163                         drive->name, len);
1164                 if (CDROM_CONFIG_FLAGS(drive)->limit_nframes)
1165                         printk (KERN_ERR "  This drive is not supported by this version of the driver\n");
1166                 else {
1167                         printk (KERN_ERR "  Trying to limit transfer sizes\n");
1168                         CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
1169                 }
1170                 cdrom_end_request(drive, 0);
1171                 return ide_stopped;
1172         }
1173
1174         /* The number of sectors we need to read from the drive. */
1175         sectors_to_transfer = len / SECTOR_SIZE;
1176
1177         /* First, figure out if we need to bit-bucket
1178            any of the leading sectors. */
1179         nskip = min_t(int, rq->current_nr_sectors - bio_cur_sectors(rq->bio), sectors_to_transfer);
1180
1181         while (nskip > 0) {
1182                 /* We need to throw away a sector. */
1183                 static char dum[SECTOR_SIZE];
1184                 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1185
1186                 --rq->current_nr_sectors;
1187                 --nskip;
1188                 --sectors_to_transfer;
1189         }
1190
1191         /* Now loop while we still have data to read from the drive. */
1192         while (sectors_to_transfer > 0) {
1193                 int this_transfer;
1194
1195                 /* If we've filled the present buffer but there's another
1196                    chained buffer after it, move on. */
1197                 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1198                         cdrom_end_request(drive, 1);
1199
1200                 /* If the buffers are full, cache the rest of the data in our
1201                    internal buffer. */
1202                 if (rq->current_nr_sectors == 0) {
1203                         cdrom_buffer_sectors(drive, rq->sector, sectors_to_transfer);
1204                         sectors_to_transfer = 0;
1205                 } else {
1206                         /* Transfer data to the buffers.
1207                            Figure out how many sectors we can transfer
1208                            to the current buffer. */
1209                         this_transfer = min_t(int, sectors_to_transfer,
1210                                              rq->current_nr_sectors);
1211
1212                         /* Read this_transfer sectors
1213                            into the current buffer. */
1214                         while (this_transfer > 0) {
1215                                 HWIF(drive)->atapi_input_bytes(drive, rq->buffer, SECTOR_SIZE);
1216                                 rq->buffer += SECTOR_SIZE;
1217                                 --rq->nr_sectors;
1218                                 --rq->current_nr_sectors;
1219                                 ++rq->sector;
1220                                 --this_transfer;
1221                                 --sectors_to_transfer;
1222                         }
1223                 }
1224         }
1225
1226         /* Done moving data!  Wait for another interrupt. */
1227         ide_set_handler(drive, &cdrom_read_intr, ATAPI_WAIT_PC, NULL);
1228         return ide_started;
1229 }
1230
1231 /*
1232  * Try to satisfy some of the current read request from our cached data.
1233  * Returns nonzero if the request has been completed, zero otherwise.
1234  */
1235 static int cdrom_read_from_buffer (ide_drive_t *drive)
1236 {
1237         struct cdrom_info *info = drive->driver_data;
1238         struct request *rq = HWGROUP(drive)->rq;
1239         unsigned short sectors_per_frame;
1240
1241         sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1242
1243         /* Can't do anything if there's no buffer. */
1244         if (info->buffer == NULL) return 0;
1245
1246         /* Loop while this request needs data and the next block is present
1247            in our cache. */
1248         while (rq->nr_sectors > 0 &&
1249                rq->sector >= info->sector_buffered &&
1250                rq->sector < info->sector_buffered + info->nsectors_buffered) {
1251                 if (rq->current_nr_sectors == 0)
1252                         cdrom_end_request(drive, 1);
1253
1254                 memcpy (rq->buffer,
1255                         info->buffer +
1256                         (rq->sector - info->sector_buffered) * SECTOR_SIZE,
1257                         SECTOR_SIZE);
1258                 rq->buffer += SECTOR_SIZE;
1259                 --rq->current_nr_sectors;
1260                 --rq->nr_sectors;
1261                 ++rq->sector;
1262         }
1263
1264         /* If we've satisfied the current request,
1265            terminate it successfully. */
1266         if (rq->nr_sectors == 0) {
1267                 cdrom_end_request(drive, 1);
1268                 return -1;
1269         }
1270
1271         /* Move on to the next buffer if needed. */
1272         if (rq->current_nr_sectors == 0)
1273                 cdrom_end_request(drive, 1);
1274
1275         /* If this condition does not hold, then the kluge i use to
1276            represent the number of sectors to skip at the start of a transfer
1277            will fail.  I think that this will never happen, but let's be
1278            paranoid and check. */
1279         if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
1280             (rq->sector & (sectors_per_frame - 1))) {
1281                 printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
1282                         drive->name, (long)rq->sector);
1283                 cdrom_end_request(drive, 0);
1284                 return -1;
1285         }
1286
1287         return 0;
1288 }
1289
1290 /*
1291  * Routine to send a read packet command to the drive.
1292  * This is usually called directly from cdrom_start_read.
1293  * However, for drq_interrupt devices, it is called from an interrupt
1294  * when the drive is ready to accept the command.
1295  */
1296 static ide_startstop_t cdrom_start_read_continuation (ide_drive_t *drive)
1297 {
1298         struct request *rq = HWGROUP(drive)->rq;
1299         unsigned short sectors_per_frame;
1300         int nskip;
1301
1302         sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1303
1304         /* If the requested sector doesn't start on a cdrom block boundary,
1305            we must adjust the start of the transfer so that it does,
1306            and remember to skip the first few sectors.
1307            If the CURRENT_NR_SECTORS field is larger than the size
1308            of the buffer, it will mean that we're to skip a number
1309            of sectors equal to the amount by which CURRENT_NR_SECTORS
1310            is larger than the buffer size. */
1311         nskip = rq->sector & (sectors_per_frame - 1);
1312         if (nskip > 0) {
1313                 /* Sanity check... */
1314                 if (rq->current_nr_sectors != bio_cur_sectors(rq->bio) &&
1315                         (rq->sector & (sectors_per_frame - 1))) {
1316                         printk(KERN_ERR "%s: cdrom_start_read_continuation: buffer botch (%u)\n",
1317                                 drive->name, rq->current_nr_sectors);
1318                         cdrom_end_request(drive, 0);
1319                         return ide_stopped;
1320                 }
1321                 rq->current_nr_sectors += nskip;
1322         }
1323
1324         /* Set up the command */
1325         rq->timeout = ATAPI_WAIT_PC;
1326
1327         /* Send the command to the drive and return. */
1328         return cdrom_transfer_packet_command(drive, rq, &cdrom_read_intr);
1329 }
1330
1331
1332 #define IDECD_SEEK_THRESHOLD    (1000)                  /* 1000 blocks */
1333 #define IDECD_SEEK_TIMER        (5 * WAIT_MIN_SLEEP)    /* 100 ms */
1334 #define IDECD_SEEK_TIMEOUT      (2 * WAIT_CMD)          /* 20 sec */
1335
1336 static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
1337 {
1338         struct cdrom_info *info = drive->driver_data;
1339         int stat;
1340         static int retry = 10;
1341
1342         if (cdrom_decode_status(drive, 0, &stat))
1343                 return ide_stopped;
1344         CDROM_CONFIG_FLAGS(drive)->seeking = 1;
1345
1346         if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
1347                 if (--retry == 0) {
1348                         /*
1349                          * this condition is far too common, to bother
1350                          * users about it
1351                          */
1352                         /* printk("%s: disabled DSC seek overlap\n", drive->name);*/
1353                         drive->dsc_overlap = 0;
1354                 }
1355         }
1356         return ide_stopped;
1357 }
1358
1359 static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
1360 {
1361         struct request *rq = HWGROUP(drive)->rq;
1362         sector_t frame = rq->sector;
1363
1364         sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
1365
1366         memset(rq->cmd, 0, sizeof(rq->cmd));
1367         rq->cmd[0] = GPCMD_SEEK;
1368         put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
1369
1370         rq->timeout = ATAPI_WAIT_PC;
1371         return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
1372 }
1373
1374 static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
1375 {
1376         struct cdrom_info *info = drive->driver_data;
1377
1378         info->dma = 0;
1379         info->start_seek = jiffies;
1380         return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
1381 }
1382
1383 /* Fix up a possibly partially-processed request so that we can
1384    start it over entirely, or even put it back on the request queue. */
1385 static void restore_request (struct request *rq)
1386 {
1387         if (rq->buffer != bio_data(rq->bio)) {
1388                 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
1389
1390                 rq->buffer = bio_data(rq->bio);
1391                 rq->nr_sectors += n;
1392                 rq->sector -= n;
1393         }
1394         rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
1395         rq->hard_nr_sectors = rq->nr_sectors;
1396         rq->hard_sector = rq->sector;
1397         rq->q->prep_rq_fn(rq->q, rq);
1398 }
1399
1400 /*
1401  * Start a read request from the CD-ROM.
1402  */
1403 static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block)
1404 {
1405         struct cdrom_info *info = drive->driver_data;
1406         struct request *rq = HWGROUP(drive)->rq;
1407         unsigned short sectors_per_frame;
1408
1409         sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1410
1411         /* We may be retrying this request after an error.  Fix up
1412            any weirdness which might be present in the request packet. */
1413         restore_request(rq);
1414
1415         /* Satisfy whatever we can of this request from our cached sector. */
1416         if (cdrom_read_from_buffer(drive))
1417                 return ide_stopped;
1418
1419         /* Clear the local sector buffer. */
1420         info->nsectors_buffered = 0;
1421
1422         /* use dma, if possible. */
1423         info->dma = drive->using_dma;
1424         if ((rq->sector & (sectors_per_frame - 1)) ||
1425             (rq->nr_sectors & (sectors_per_frame - 1)))
1426                 info->dma = 0;
1427
1428         /* Start sending the read request to the drive. */
1429         return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
1430 }
1431
1432 /****************************************************************************
1433  * Execute all other packet commands.
1434  */
1435
1436 /* Interrupt routine for packet command completion. */
1437 static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
1438 {
1439         int ireason, len, thislen;
1440         struct request *rq = HWGROUP(drive)->rq;
1441         u8 lowcyl = 0, highcyl = 0;
1442         int stat;
1443
1444         /* Check for errors. */
1445         if (cdrom_decode_status(drive, 0, &stat))
1446                 return ide_stopped;
1447
1448         /* Read the interrupt reason and the transfer length. */
1449         ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1450         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1451         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1452
1453         len = lowcyl + (256 * highcyl);
1454
1455         /* If DRQ is clear, the command has completed.
1456            Complain if we still have data left to transfer. */
1457         if ((stat & DRQ_STAT) == 0) {
1458                 /* Some of the trailing request sense fields are optional, and
1459                    some drives don't send them.  Sigh. */
1460                 if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
1461                     rq->data_len > 0 &&
1462                     rq->data_len <= 5) {
1463                         while (rq->data_len > 0) {
1464                                 *(unsigned char *)rq->data++ = 0;
1465                                 --rq->data_len;
1466                         }
1467                 }
1468
1469                 if (rq->data_len == 0)
1470                         cdrom_end_request(drive, 1);
1471                 else {
1472                         /* Comment this out, because this always happens
1473                            right after a reset occurs, and it is annoying to
1474                            always print expected stuff.  */
1475                         /*
1476                         printk ("%s: cdrom_pc_intr: data underrun %d\n",
1477                                 drive->name, pc->buflen);
1478                         */
1479                         rq->cmd_flags |= REQ_FAILED;
1480                         cdrom_end_request(drive, 0);
1481                 }
1482                 return ide_stopped;
1483         }
1484
1485         /* Figure out how much data to transfer. */
1486         thislen = rq->data_len;
1487         if (thislen > len) thislen = len;
1488
1489         /* The drive wants to be written to. */
1490         if ((ireason & 3) == 0) {
1491                 if (!rq->data) {
1492                         blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1493                         goto confused;
1494                 }
1495                 /* Transfer the data. */
1496                 HWIF(drive)->atapi_output_bytes(drive, rq->data, thislen);
1497
1498                 /* If we haven't moved enough data to satisfy the drive,
1499                    add some padding. */
1500                 while (len > thislen) {
1501                         int dum = 0;
1502                         HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof(dum));
1503                         len -= sizeof(dum);
1504                 }
1505
1506                 /* Keep count of how much data we've moved. */
1507                 rq->data += thislen;
1508                 rq->data_len -= thislen;
1509         }
1510
1511         /* Same drill for reading. */
1512         else if ((ireason & 3) == 2) {
1513                 if (!rq->data) {
1514                         blk_dump_rq_flags(rq, "cdrom_pc_intr, read");
1515                         goto confused;
1516                 }
1517                 /* Transfer the data. */
1518                 HWIF(drive)->atapi_input_bytes(drive, rq->data, thislen);
1519
1520                 /* If we haven't moved enough data to satisfy the drive,
1521                    add some padding. */
1522                 while (len > thislen) {
1523                         int dum = 0;
1524                         HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1525                         len -= sizeof(dum);
1526                 }
1527
1528                 /* Keep count of how much data we've moved. */
1529                 rq->data += thislen;
1530                 rq->data_len -= thislen;
1531
1532                 if (blk_sense_request(rq))
1533                         rq->sense_len += thislen;
1534         } else {
1535 confused:
1536                 printk (KERN_ERR "%s: cdrom_pc_intr: The drive "
1537                         "appears confused (ireason = 0x%02x). "
1538                         "Trying to recover by ending request.\n",
1539                         drive->name, ireason);
1540                 rq->cmd_flags |= REQ_FAILED;
1541                 cdrom_end_request(drive, 0);
1542                 return ide_stopped;
1543         }
1544
1545         /* Now we wait for another interrupt. */
1546         ide_set_handler(drive, &cdrom_pc_intr, ATAPI_WAIT_PC, cdrom_timer_expiry);
1547         return ide_started;
1548 }
1549
1550 static ide_startstop_t cdrom_do_pc_continuation (ide_drive_t *drive)
1551 {
1552         struct request *rq = HWGROUP(drive)->rq;
1553
1554         if (!rq->timeout)
1555                 rq->timeout = ATAPI_WAIT_PC;
1556
1557         /* Send the command to the drive and return. */
1558         return cdrom_transfer_packet_command(drive, rq, &cdrom_pc_intr);
1559 }
1560
1561
1562 static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
1563 {
1564         int len;
1565         struct request *rq = HWGROUP(drive)->rq;
1566         struct cdrom_info *info = drive->driver_data;
1567
1568         info->dma = 0;
1569         rq->cmd_flags &= ~REQ_FAILED;
1570         len = rq->data_len;
1571
1572         /* Start sending the command to the drive. */
1573         return cdrom_start_packet_command(drive, len, cdrom_do_pc_continuation);
1574 }
1575
1576
1577 static int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
1578 {
1579         struct request_sense sense;
1580         int retries = 10;
1581         unsigned int flags = rq->cmd_flags;
1582
1583         if (rq->sense == NULL)
1584                 rq->sense = &sense;
1585
1586         /* Start of retry loop. */
1587         do {
1588                 int error;
1589                 unsigned long time = jiffies;
1590                 rq->cmd_flags = flags;
1591
1592                 error = ide_do_drive_cmd(drive, rq, ide_wait);
1593                 time = jiffies - time;
1594
1595                 /* FIXME: we should probably abort/retry or something
1596                  * in case of failure */
1597                 if (rq->cmd_flags & REQ_FAILED) {
1598                         /* The request failed.  Retry if it was due to a unit
1599                            attention status
1600                            (usually means media was changed). */
1601                         struct request_sense *reqbuf = rq->sense;
1602
1603                         if (reqbuf->sense_key == UNIT_ATTENTION)
1604                                 cdrom_saw_media_change(drive);
1605                         else if (reqbuf->sense_key == NOT_READY &&
1606                                  reqbuf->asc == 4 && reqbuf->ascq != 4) {
1607                                 /* The drive is in the process of loading
1608                                    a disk.  Retry, but wait a little to give
1609                                    the drive time to complete the load. */
1610                                 ssleep(2);
1611                         } else {
1612                                 /* Otherwise, don't retry. */
1613                                 retries = 0;
1614                         }
1615                         --retries;
1616                 }
1617
1618                 /* End of retry loop. */
1619         } while ((rq->cmd_flags & REQ_FAILED) && retries >= 0);
1620
1621         /* Return an error if the command failed. */
1622         return (rq->cmd_flags & REQ_FAILED) ? -EIO : 0;
1623 }
1624
1625 /*
1626  * Write handling
1627  */
1628 static int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
1629 {
1630         /* Two notes about IDE interrupt reason here - 0 means that
1631          * the drive wants to receive data from us, 2 means that
1632          * the drive is expecting to transfer data to us.
1633          */
1634         if (ireason == 0)
1635                 return 0;
1636         else if (ireason == 2) {
1637                 /* Whoops... The drive wants to send data. */
1638                 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
1639                                 drive->name, __FUNCTION__);
1640
1641                 while (len > 0) {
1642                         int dum = 0;
1643                         HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1644                         len -= sizeof(dum);
1645                 }
1646         } else {
1647                 /* Drive wants a command packet, or invalid ireason... */
1648                 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
1649                                 drive->name, __FUNCTION__, ireason);
1650         }
1651
1652         cdrom_end_request(drive, 0);
1653         return 1;
1654 }
1655
1656 typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
1657
1658 /*
1659  * best way to deal with dma that is not sector aligned right now... note
1660  * that in this path we are not using ->data or ->buffer at all. this irs
1661  * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the
1662  * future.
1663  */
1664 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1665 {
1666         struct cdrom_info *info = drive->driver_data;
1667         struct request *rq = HWGROUP(drive)->rq;
1668         int dma_error, dma, stat, ireason, len, thislen;
1669         u8 lowcyl, highcyl;
1670         xfer_func_t *xferfunc;
1671         unsigned long flags;
1672
1673         /* Check for errors. */
1674         dma_error = 0;
1675         dma = info->dma;
1676         if (dma) {
1677                 info->dma = 0;
1678                 dma_error = HWIF(drive)->ide_dma_end(drive);
1679         }
1680
1681         if (cdrom_decode_status(drive, 0, &stat))
1682                 return ide_stopped;
1683
1684         /*
1685          * using dma, transfer is complete now
1686          */
1687         if (dma) {
1688                 if (dma_error) {
1689                         printk(KERN_ERR "ide-cd: dma error\n");
1690                         ide_dma_off(drive);
1691                         return ide_error(drive, "dma error", stat);
1692                 }
1693
1694                 end_that_request_chunk(rq, 1, rq->data_len);
1695                 rq->data_len = 0;
1696                 goto end_request;
1697         }
1698
1699         /*
1700          * ok we fall to pio :/
1701          */
1702         ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1703         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1704         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1705
1706         len = lowcyl + (256 * highcyl);
1707         thislen = rq->data_len;
1708         if (thislen > len)
1709                 thislen = len;
1710
1711         /*
1712          * If DRQ is clear, the command has completed.
1713          */
1714         if ((stat & DRQ_STAT) == 0)
1715                 goto end_request;
1716
1717         /*
1718          * check which way to transfer data
1719          */
1720         if (rq_data_dir(rq) == WRITE) {
1721                 /*
1722                  * write to drive
1723                  */
1724                 if (cdrom_write_check_ireason(drive, len, ireason))
1725                         return ide_stopped;
1726
1727                 xferfunc = HWIF(drive)->atapi_output_bytes;
1728         } else  {
1729                 /*
1730                  * read from drive
1731                  */
1732                 if (cdrom_read_check_ireason(drive, len, ireason))
1733                         return ide_stopped;
1734
1735                 xferfunc = HWIF(drive)->atapi_input_bytes;
1736         }
1737
1738         /*
1739          * transfer data
1740          */
1741         while (thislen > 0) {
1742                 int blen = blen = rq->data_len;
1743                 char *ptr = rq->data;
1744
1745                 /*
1746                  * bio backed?
1747                  */
1748                 if (rq->bio) {
1749                         ptr = bio_data(rq->bio);
1750                         blen = bio_iovec(rq->bio)->bv_len;
1751                 }
1752
1753                 if (!ptr) {
1754                         printk(KERN_ERR "%s: confused, missing data\n", drive->name);
1755                         break;
1756                 }
1757
1758                 if (blen > thislen)
1759                         blen = thislen;
1760
1761                 xferfunc(drive, ptr, blen);
1762
1763                 thislen -= blen;
1764                 len -= blen;
1765                 rq->data_len -= blen;
1766
1767                 if (rq->bio)
1768                         end_that_request_chunk(rq, 1, blen);
1769                 else
1770                         rq->data += blen;
1771         }
1772
1773         /*
1774          * pad, if necessary
1775          */
1776         if (len > 0) {
1777                 while (len > 0) {
1778                         int pad = 0;
1779
1780                         xferfunc(drive, &pad, sizeof(pad));
1781                         len -= sizeof(pad);
1782                 }
1783         }
1784
1785         BUG_ON(HWGROUP(drive)->handler != NULL);
1786
1787         ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, NULL);
1788         return ide_started;
1789
1790 end_request:
1791         spin_lock_irqsave(&ide_lock, flags);
1792         blkdev_dequeue_request(rq);
1793         end_that_request_last(rq, 1);
1794         HWGROUP(drive)->rq = NULL;
1795         spin_unlock_irqrestore(&ide_lock, flags);
1796         return ide_stopped;
1797 }
1798
1799 static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
1800 {
1801         int stat, ireason, len, sectors_to_transfer, uptodate;
1802         struct cdrom_info *info = drive->driver_data;
1803         int dma_error = 0, dma = info->dma;
1804         u8 lowcyl = 0, highcyl = 0;
1805
1806         struct request *rq = HWGROUP(drive)->rq;
1807
1808         /* Check for errors. */
1809         if (dma) {
1810                 info->dma = 0;
1811                 dma_error = HWIF(drive)->ide_dma_end(drive);
1812                 if (dma_error) {
1813                         printk(KERN_ERR "%s: DMA write error\n", drive->name);
1814                         ide_dma_off(drive);
1815                 }
1816         }
1817
1818         if (cdrom_decode_status(drive, 0, &stat))
1819                 return ide_stopped;
1820
1821         /*
1822          * using dma, transfer is complete now
1823          */
1824         if (dma) {
1825                 if (dma_error)
1826                         return ide_error(drive, "dma error", stat);
1827
1828                 ide_end_request(drive, 1, rq->nr_sectors);
1829                 return ide_stopped;
1830         }
1831
1832         /* Read the interrupt reason and the transfer length. */
1833         ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1834         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1835         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1836
1837         len = lowcyl + (256 * highcyl);
1838
1839         /* If DRQ is clear, the command has completed. */
1840         if ((stat & DRQ_STAT) == 0) {
1841                 /* If we're not done writing, complain.
1842                  * Otherwise, complete the command normally.
1843                  */
1844                 uptodate = 1;
1845                 if (rq->current_nr_sectors > 0) {
1846                         printk(KERN_ERR "%s: %s: data underrun (%d blocks)\n",
1847                                         drive->name, __FUNCTION__,
1848                                         rq->current_nr_sectors);
1849                         uptodate = 0;
1850                 }
1851                 cdrom_end_request(drive, uptodate);
1852                 return ide_stopped;
1853         }
1854
1855         /* Check that the drive is expecting to do the same thing we are. */
1856         if (cdrom_write_check_ireason(drive, len, ireason))
1857                 return ide_stopped;
1858
1859         sectors_to_transfer = len / SECTOR_SIZE;
1860
1861         /*
1862          * now loop and write out the data
1863          */
1864         while (sectors_to_transfer > 0) {
1865                 int this_transfer;
1866
1867                 if (!rq->current_nr_sectors) {
1868                         printk(KERN_ERR "%s: %s: confused, missing data\n",
1869                                         drive->name, __FUNCTION__);
1870                         break;
1871                 }
1872
1873                 /*
1874                  * Figure out how many sectors we can transfer
1875                  */
1876                 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors);
1877
1878                 while (this_transfer > 0) {
1879                         HWIF(drive)->atapi_output_bytes(drive, rq->buffer, SECTOR_SIZE);
1880                         rq->buffer += SECTOR_SIZE;
1881                         --rq->nr_sectors;
1882                         --rq->current_nr_sectors;
1883                         ++rq->sector;
1884                         --this_transfer;
1885                         --sectors_to_transfer;
1886                 }
1887
1888                 /*
1889                  * current buffer complete, move on
1890                  */
1891                 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1892                         cdrom_end_request(drive, 1);
1893         }
1894
1895         /* re-arm handler */
1896         ide_set_handler(drive, &cdrom_write_intr, ATAPI_WAIT_PC, NULL);
1897         return ide_started;
1898 }
1899
1900 static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
1901 {
1902         struct request *rq = HWGROUP(drive)->rq;
1903
1904 #if 0   /* the immediate bit */
1905         rq->cmd[1] = 1 << 3;
1906 #endif
1907         rq->timeout = ATAPI_WAIT_PC;
1908
1909         return cdrom_transfer_packet_command(drive, rq, cdrom_write_intr);
1910 }
1911
1912 static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
1913 {
1914         struct cdrom_info *info = drive->driver_data;
1915         struct gendisk *g = info->disk;
1916         unsigned short sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1917
1918         /*
1919          * writes *must* be hardware frame aligned
1920          */
1921         if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1922             (rq->sector & (sectors_per_frame - 1))) {
1923                 cdrom_end_request(drive, 0);
1924                 return ide_stopped;
1925         }
1926
1927         /*
1928          * disk has become write protected
1929          */
1930         if (g->policy) {
1931                 cdrom_end_request(drive, 0);
1932                 return ide_stopped;
1933         }
1934
1935         info->nsectors_buffered = 0;
1936
1937         /* use dma, if possible. we don't need to check more, since we
1938          * know that the transfer is always (at least!) frame aligned */
1939         info->dma = drive->using_dma ? 1 : 0;
1940
1941         info->devinfo.media_written = 1;
1942
1943         /* Start sending the write request to the drive. */
1944         return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
1945 }
1946
1947 static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1948 {
1949         struct request *rq = HWGROUP(drive)->rq;
1950
1951         if (!rq->timeout)
1952                 rq->timeout = ATAPI_WAIT_PC;
1953
1954         return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1955 }
1956
1957 static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1958 {
1959         struct cdrom_info *info = drive->driver_data;
1960
1961         rq->cmd_flags |= REQ_QUIET;
1962
1963         info->dma = 0;
1964
1965         /*
1966          * sg request
1967          */
1968         if (rq->bio) {
1969                 int mask = drive->queue->dma_alignment;
1970                 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
1971
1972                 info->dma = drive->using_dma;
1973
1974                 /*
1975                  * check if dma is safe
1976                  *
1977                  * NOTE! The "len" and "addr" checks should possibly have
1978                  * separate masks.
1979                  */
1980                 if ((rq->data_len & 15) || (addr & mask))
1981                         info->dma = 0;
1982         }
1983
1984         /* Start sending the command to the drive. */
1985         return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1986 }
1987
1988 /****************************************************************************
1989  * cdrom driver request routine.
1990  */
1991 static ide_startstop_t
1992 ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1993 {
1994         ide_startstop_t action;
1995         struct cdrom_info *info = drive->driver_data;
1996
1997         if (blk_fs_request(rq)) {
1998                 if (CDROM_CONFIG_FLAGS(drive)->seeking) {
1999                         unsigned long elapsed = jiffies - info->start_seek;
2000                         int stat = HWIF(drive)->INB(IDE_STATUS_REG);
2001
2002                         if ((stat & SEEK_STAT) != SEEK_STAT) {
2003                                 if (elapsed < IDECD_SEEK_TIMEOUT) {
2004                                         ide_stall_queue(drive, IDECD_SEEK_TIMER);
2005                                         return ide_stopped;
2006                                 }
2007                                 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
2008                         }
2009                         CDROM_CONFIG_FLAGS(drive)->seeking = 0;
2010                 }
2011                 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
2012                         action = cdrom_start_seek(drive, block);
2013                 } else {
2014                         if (rq_data_dir(rq) == READ)
2015                                 action = cdrom_start_read(drive, block);
2016                         else
2017                                 action = cdrom_start_write(drive, rq);
2018                 }
2019                 info->last_block = block;
2020                 return action;
2021         } else if (rq->cmd_type == REQ_TYPE_SENSE ||
2022                    rq->cmd_type == REQ_TYPE_ATA_PC) {
2023                 return cdrom_do_packet_command(drive);
2024         } else if (blk_pc_request(rq)) {
2025                 return cdrom_do_block_pc(drive, rq);
2026         } else if (blk_special_request(rq)) {
2027                 /*
2028                  * right now this can only be a reset...
2029                  */
2030                 cdrom_end_request(drive, 1);
2031                 return ide_stopped;
2032         }
2033
2034         blk_dump_rq_flags(rq, "ide-cd bad flags");
2035         cdrom_end_request(drive, 0);
2036         return ide_stopped;
2037 }
2038
2039
2040
2041 /****************************************************************************
2042  * Ioctl handling.
2043  *
2044  * Routines which queue packet commands take as a final argument a pointer
2045  * to a request_sense struct.  If execution of the command results
2046  * in an error with a CHECK CONDITION status, this structure will be filled
2047  * with the results of the subsequent request sense command.  The pointer
2048  * can also be NULL, in which case no sense information is returned.
2049  */
2050
2051 #if ! STANDARD_ATAPI
2052 static inline
2053 int bin2bcd (int x)
2054 {
2055         return (x%10) | ((x/10) << 4);
2056 }
2057
2058
2059 static inline
2060 int bcd2bin (int x)
2061 {
2062         return (x >> 4) * 10 + (x & 0x0f);
2063 }
2064
2065 static
2066 void msf_from_bcd (struct atapi_msf *msf)
2067 {
2068         msf->minute = bcd2bin (msf->minute);
2069         msf->second = bcd2bin (msf->second);
2070         msf->frame  = bcd2bin (msf->frame);
2071 }
2072
2073 #endif /* not STANDARD_ATAPI */
2074
2075
2076 static inline
2077 void lba_to_msf (int lba, byte *m, byte *s, byte *f)
2078 {
2079         lba += CD_MSF_OFFSET;
2080         lba &= 0xffffff;  /* negative lbas use only 24 bits */
2081         *m = lba / (CD_SECS * CD_FRAMES);
2082         lba %= (CD_SECS * CD_FRAMES);
2083         *s = lba / CD_FRAMES;
2084         *f = lba % CD_FRAMES;
2085 }
2086
2087
2088 static inline
2089 int msf_to_lba (byte m, byte s, byte f)
2090 {
2091         return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
2092 }
2093
2094 static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
2095 {
2096         struct request req;
2097         struct cdrom_info *info = drive->driver_data;
2098         struct cdrom_device_info *cdi = &info->devinfo;
2099
2100         cdrom_prepare_request(drive, &req);
2101
2102         req.sense = sense;
2103         req.cmd[0] = GPCMD_TEST_UNIT_READY;
2104         req.cmd_flags |= REQ_QUIET;
2105
2106 #if ! STANDARD_ATAPI
2107         /* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
2108            switch CDs instead of supporting the LOAD_UNLOAD opcode   */
2109
2110         req.cmd[7] = cdi->sanyo_slot % 3;
2111 #endif /* not STANDARD_ATAPI */
2112
2113         return cdrom_queue_packet_command(drive, &req);
2114 }
2115
2116
2117 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
2118 static int
2119 cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
2120 {
2121         struct request_sense my_sense;
2122         struct request req;
2123         int stat;
2124
2125         if (sense == NULL)
2126                 sense = &my_sense;
2127
2128         /* If the drive cannot lock the door, just pretend. */
2129         if (CDROM_CONFIG_FLAGS(drive)->no_doorlock) {
2130                 stat = 0;
2131         } else {
2132                 cdrom_prepare_request(drive, &req);
2133                 req.sense = sense;
2134                 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
2135                 req.cmd[4] = lockflag ? 1 : 0;
2136                 stat = cdrom_queue_packet_command(drive, &req);
2137         }
2138
2139         /* If we got an illegal field error, the drive
2140            probably cannot lock the door. */
2141         if (stat != 0 &&
2142             sense->sense_key == ILLEGAL_REQUEST &&
2143             (sense->asc == 0x24 || sense->asc == 0x20)) {
2144                 printk (KERN_ERR "%s: door locking not supported\n",
2145                         drive->name);
2146                 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2147                 stat = 0;
2148         }
2149
2150         /* no medium, that's alright. */
2151         if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
2152                 stat = 0;
2153
2154         if (stat == 0)
2155                 CDROM_STATE_FLAGS(drive)->door_locked = lockflag;
2156
2157         return stat;
2158 }
2159
2160
2161 /* Eject the disk if EJECTFLAG is 0.
2162    If EJECTFLAG is 1, try to reload the disk. */
2163 static int cdrom_eject(ide_drive_t *drive, int ejectflag,
2164                        struct request_sense *sense)
2165 {
2166         struct request req;
2167         char loej = 0x02;
2168
2169         if (CDROM_CONFIG_FLAGS(drive)->no_eject && !ejectflag)
2170                 return -EDRIVE_CANT_DO_THIS;
2171
2172         /* reload fails on some drives, if the tray is locked */
2173         if (CDROM_STATE_FLAGS(drive)->door_locked && ejectflag)
2174                 return 0;
2175
2176         cdrom_prepare_request(drive, &req);
2177
2178         /* only tell drive to close tray if open, if it can do that */
2179         if (ejectflag && !CDROM_CONFIG_FLAGS(drive)->close_tray)
2180                 loej = 0;
2181
2182         req.sense = sense;
2183         req.cmd[0] = GPCMD_START_STOP_UNIT;
2184         req.cmd[4] = loej | (ejectflag != 0);
2185         return cdrom_queue_packet_command(drive, &req);
2186 }
2187
2188 static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
2189                                unsigned long *sectors_per_frame,
2190                                struct request_sense *sense)
2191 {
2192         struct {
2193                 __u32 lba;
2194                 __u32 blocklen;
2195         } capbuf;
2196
2197         int stat;
2198         struct request req;
2199
2200         cdrom_prepare_request(drive, &req);
2201
2202         req.sense = sense;
2203         req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
2204         req.data = (char *)&capbuf;
2205         req.data_len = sizeof(capbuf);
2206         req.cmd_flags |= REQ_QUIET;
2207
2208         stat = cdrom_queue_packet_command(drive, &req);
2209         if (stat == 0) {
2210                 *capacity = 1 + be32_to_cpu(capbuf.lba);
2211                 *sectors_per_frame =
2212                         be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
2213         }
2214
2215         return stat;
2216 }
2217
2218 static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
2219                                 int format, char *buf, int buflen,
2220                                 struct request_sense *sense)
2221 {
2222         struct request req;
2223
2224         cdrom_prepare_request(drive, &req);
2225
2226         req.sense = sense;
2227         req.data =  buf;
2228         req.data_len = buflen;
2229         req.cmd_flags |= REQ_QUIET;
2230         req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
2231         req.cmd[6] = trackno;
2232         req.cmd[7] = (buflen >> 8);
2233         req.cmd[8] = (buflen & 0xff);
2234         req.cmd[9] = (format << 6);
2235
2236         if (msf_flag)
2237                 req.cmd[1] = 2;
2238
2239         return cdrom_queue_packet_command(drive, &req);
2240 }
2241
2242
2243 /* Try to read the entire TOC for the disk into our internal buffer. */
2244 static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2245 {
2246         int stat, ntracks, i;
2247         struct cdrom_info *info = drive->driver_data;
2248         struct cdrom_device_info *cdi = &info->devinfo;
2249         struct atapi_toc *toc = info->toc;
2250         struct {
2251                 struct atapi_toc_header hdr;
2252                 struct atapi_toc_entry  ent;
2253         } ms_tmp;
2254         long last_written;
2255         unsigned long sectors_per_frame = SECTORS_PER_FRAME;
2256
2257         if (toc == NULL) {
2258                 /* Try to allocate space. */
2259                 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
2260                 if (toc == NULL) {
2261                         printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
2262                         return -ENOMEM;
2263                 }
2264                 info->toc = toc;
2265         }
2266
2267         /* Check to see if the existing data is still valid.
2268            If it is, just return. */
2269         (void) cdrom_check_status(drive, sense);
2270
2271         if (CDROM_STATE_FLAGS(drive)->toc_valid)
2272                 return 0;
2273
2274         /* Try to get the total cdrom capacity and sector size. */
2275         stat = cdrom_read_capacity(drive, &toc->capacity, &sectors_per_frame,
2276                                    sense);
2277         if (stat)
2278                 toc->capacity = 0x1fffff;
2279
2280         set_capacity(info->disk, toc->capacity * sectors_per_frame);
2281         /* Save a private copy of te TOC capacity for error handling */
2282         drive->probed_capacity = toc->capacity * sectors_per_frame;
2283
2284         blk_queue_hardsect_size(drive->queue,
2285                                 sectors_per_frame << SECTOR_BITS);
2286
2287         /* First read just the header, so we know how long the TOC is. */
2288         stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
2289                                     sizeof(struct atapi_toc_header), sense);
2290         if (stat)
2291                 return stat;
2292
2293 #if ! STANDARD_ATAPI
2294         if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2295                 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2296                 toc->hdr.last_track  = bcd2bin(toc->hdr.last_track);
2297         }
2298 #endif  /* not STANDARD_ATAPI */
2299
2300         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2301         if (ntracks <= 0)
2302                 return -EIO;
2303         if (ntracks > MAX_TRACKS)
2304                 ntracks = MAX_TRACKS;
2305
2306         /* Now read the whole schmeer. */
2307         stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
2308                                   (char *)&toc->hdr,
2309                                    sizeof(struct atapi_toc_header) +
2310                                    (ntracks + 1) *
2311                                    sizeof(struct atapi_toc_entry), sense);
2312
2313         if (stat && toc->hdr.first_track > 1) {
2314                 /* Cds with CDI tracks only don't have any TOC entries,
2315                    despite of this the returned values are
2316                    first_track == last_track = number of CDI tracks + 1,
2317                    so that this case is indistinguishable from the same
2318                    layout plus an additional audio track.
2319                    If we get an error for the regular case, we assume
2320                    a CDI without additional audio tracks. In this case
2321                    the readable TOC is empty (CDI tracks are not included)
2322                    and only holds the Leadout entry. Heiko Eißfeldt */
2323                 ntracks = 0;
2324                 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
2325                                            (char *)&toc->hdr,
2326                                            sizeof(struct atapi_toc_header) +
2327                                            (ntracks + 1) *
2328                                            sizeof(struct atapi_toc_entry),
2329                                            sense);
2330                 if (stat) {
2331                         return stat;
2332                 }
2333 #if ! STANDARD_ATAPI
2334                 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2335                         toc->hdr.first_track = bin2bcd(CDROM_LEADOUT);
2336                         toc->hdr.last_track = bin2bcd(CDROM_LEADOUT);
2337                 } else
2338 #endif  /* not STANDARD_ATAPI */
2339                 {
2340                         toc->hdr.first_track = CDROM_LEADOUT;
2341                         toc->hdr.last_track = CDROM_LEADOUT;
2342                 }
2343         }
2344
2345         if (stat)
2346                 return stat;
2347
2348         toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
2349
2350 #if ! STANDARD_ATAPI
2351         if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2352                 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2353                 toc->hdr.last_track  = bcd2bin(toc->hdr.last_track);
2354         }
2355 #endif  /* not STANDARD_ATAPI */
2356
2357         for (i=0; i<=ntracks; i++) {
2358 #if ! STANDARD_ATAPI
2359                 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2360                         if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd)
2361                                 toc->ent[i].track = bcd2bin(toc->ent[i].track);
2362                         msf_from_bcd(&toc->ent[i].addr.msf);
2363                 }
2364 #endif  /* not STANDARD_ATAPI */
2365                 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
2366                                                    toc->ent[i].addr.msf.second,
2367                                                    toc->ent[i].addr.msf.frame);
2368         }
2369
2370         /* Read the multisession information. */
2371         if (toc->hdr.first_track != CDROM_LEADOUT) {
2372                 /* Read the multisession information. */
2373                 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
2374                                            sizeof(ms_tmp), sense);
2375                 if (stat)
2376                         return stat;
2377
2378                 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
2379         } else {
2380                 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
2381                 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
2382         }
2383
2384 #if ! STANDARD_ATAPI
2385         if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2386                 /* Re-read multisession information using MSF format */
2387                 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
2388                                            sizeof(ms_tmp), sense);
2389                 if (stat)
2390                         return stat;
2391
2392                 msf_from_bcd (&ms_tmp.ent.addr.msf);
2393                 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
2394                                                    ms_tmp.ent.addr.msf.second,
2395                                                    ms_tmp.ent.addr.msf.frame);
2396         }
2397 #endif  /* not STANDARD_ATAPI */
2398
2399         toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
2400
2401         /* Now try to get the total cdrom capacity. */
2402         stat = cdrom_get_last_written(cdi, &last_written);
2403         if (!stat && (last_written > toc->capacity)) {
2404                 toc->capacity = last_written;
2405                 set_capacity(info->disk, toc->capacity * sectors_per_frame);
2406                 drive->probed_capacity = toc->capacity * sectors_per_frame;
2407         }
2408
2409         /* Remember that we've read this stuff. */
2410         CDROM_STATE_FLAGS(drive)->toc_valid = 1;
2411
2412         return 0;
2413 }
2414
2415
2416 static int cdrom_read_subchannel(ide_drive_t *drive, int format, char *buf,
2417                                  int buflen, struct request_sense *sense)
2418 {
2419         struct request req;
2420
2421         cdrom_prepare_request(drive, &req);
2422
2423         req.sense = sense;
2424         req.data = buf;
2425         req.data_len = buflen;
2426         req.cmd[0] = GPCMD_READ_SUBCHANNEL;
2427         req.cmd[1] = 2;     /* MSF addressing */
2428         req.cmd[2] = 0x40;  /* request subQ data */
2429         req.cmd[3] = format;
2430         req.cmd[7] = (buflen >> 8);
2431         req.cmd[8] = (buflen & 0xff);
2432         return cdrom_queue_packet_command(drive, &req);
2433 }
2434
2435 /* ATAPI cdrom drives are free to select the speed you request or any slower
2436    rate :-( Requesting too fast a speed will _not_ produce an error. */
2437 static int cdrom_select_speed(ide_drive_t *drive, int speed,
2438                               struct request_sense *sense)
2439 {
2440         struct request req;
2441         cdrom_prepare_request(drive, &req);
2442
2443         req.sense = sense;
2444         if (speed == 0)
2445                 speed = 0xffff; /* set to max */
2446         else
2447                 speed *= 177;   /* Nx to kbytes/s */
2448
2449         req.cmd[0] = GPCMD_SET_SPEED;
2450         /* Read Drive speed in kbytes/second MSB */
2451         req.cmd[2] = (speed >> 8) & 0xff;
2452         /* Read Drive speed in kbytes/second LSB */
2453         req.cmd[3] = speed & 0xff;
2454         if (CDROM_CONFIG_FLAGS(drive)->cd_r ||
2455             CDROM_CONFIG_FLAGS(drive)->cd_rw ||
2456             CDROM_CONFIG_FLAGS(drive)->dvd_r) {
2457                 /* Write Drive speed in kbytes/second MSB */
2458                 req.cmd[4] = (speed >> 8) & 0xff;
2459                 /* Write Drive speed in kbytes/second LSB */
2460                 req.cmd[5] = speed & 0xff;
2461        }
2462
2463         return cdrom_queue_packet_command(drive, &req);
2464 }
2465
2466 static int cdrom_play_audio(ide_drive_t *drive, int lba_start, int lba_end)
2467 {
2468         struct request_sense sense;
2469         struct request req;
2470
2471         cdrom_prepare_request(drive, &req);
2472
2473         req.sense = &sense;
2474         req.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2475         lba_to_msf(lba_start, &req.cmd[3], &req.cmd[4], &req.cmd[5]);
2476         lba_to_msf(lba_end-1, &req.cmd[6], &req.cmd[7], &req.cmd[8]);
2477
2478         return cdrom_queue_packet_command(drive, &req);
2479 }
2480
2481 static int cdrom_get_toc_entry(ide_drive_t *drive, int track,
2482                                 struct atapi_toc_entry **ent)
2483 {
2484         struct cdrom_info *info = drive->driver_data;
2485         struct atapi_toc *toc = info->toc;
2486         int ntracks;
2487
2488         /*
2489          * don't serve cached data, if the toc isn't valid
2490          */
2491         if (!CDROM_STATE_FLAGS(drive)->toc_valid)
2492                 return -EINVAL;
2493
2494         /* Check validity of requested track number. */
2495         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2496         if (toc->hdr.first_track == CDROM_LEADOUT) ntracks = 0;
2497         if (track == CDROM_LEADOUT)
2498                 *ent = &toc->ent[ntracks];
2499         else if (track < toc->hdr.first_track ||
2500                  track > toc->hdr.last_track)
2501                 return -EINVAL;
2502         else
2503                 *ent = &toc->ent[track - toc->hdr.first_track];
2504
2505         return 0;
2506 }
2507
2508 /* the generic packet interface to cdrom.c */
2509 static int ide_cdrom_packet(struct cdrom_device_info *cdi,
2510                             struct packet_command *cgc)
2511 {
2512         struct request req;
2513         ide_drive_t *drive = cdi->handle;
2514
2515         if (cgc->timeout <= 0)
2516                 cgc->timeout = ATAPI_WAIT_PC;
2517
2518         /* here we queue the commands from the uniform CD-ROM
2519            layer. the packet must be complete, as we do not
2520            touch it at all. */
2521         cdrom_prepare_request(drive, &req);
2522         memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
2523         if (cgc->sense)
2524                 memset(cgc->sense, 0, sizeof(struct request_sense));
2525         req.data = cgc->buffer;
2526         req.data_len = cgc->buflen;
2527         req.timeout = cgc->timeout;
2528
2529         if (cgc->quiet)
2530                 req.cmd_flags |= REQ_QUIET;
2531
2532         req.sense = cgc->sense;
2533         cgc->stat = cdrom_queue_packet_command(drive, &req);
2534         if (!cgc->stat)
2535                 cgc->buflen -= req.data_len;
2536         return cgc->stat;
2537 }
2538
2539 static
2540 int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
2541                            unsigned int cmd, void *arg)
2542
2543 {
2544         ide_drive_t *drive = cdi->handle;
2545         struct cdrom_info *info = drive->driver_data;
2546         int stat;
2547
2548         switch (cmd) {
2549         /*
2550          * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
2551          * atapi doesn't support it
2552          */
2553         case CDROMPLAYTRKIND: {
2554                 unsigned long lba_start, lba_end;
2555                 struct cdrom_ti *ti = arg;
2556                 struct atapi_toc_entry *first_toc, *last_toc;
2557
2558                 stat = cdrom_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
2559                 if (stat)
2560                         return stat;
2561
2562                 stat = cdrom_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
2563                 if (stat)
2564                         return stat;
2565
2566                 if (ti->cdti_trk1 != CDROM_LEADOUT)
2567                         ++last_toc;
2568                 lba_start = first_toc->addr.lba;
2569                 lba_end   = last_toc->addr.lba;
2570
2571                 if (lba_end <= lba_start)
2572                         return -EINVAL;
2573
2574                 return cdrom_play_audio(drive, lba_start, lba_end);
2575         }
2576
2577         case CDROMREADTOCHDR: {
2578                 struct cdrom_tochdr *tochdr = arg;
2579                 struct atapi_toc *toc;
2580
2581                 /* Make sure our saved TOC is valid. */
2582                 stat = cdrom_read_toc(drive, NULL);
2583                 if (stat)
2584                         return stat;
2585
2586                 toc = info->toc;
2587                 tochdr->cdth_trk0 = toc->hdr.first_track;
2588                 tochdr->cdth_trk1 = toc->hdr.last_track;
2589
2590                 return 0;
2591         }
2592
2593         case CDROMREADTOCENTRY: {
2594                 struct cdrom_tocentry *tocentry = arg;
2595                 struct atapi_toc_entry *toce;
2596
2597                 stat = cdrom_get_toc_entry(drive, tocentry->cdte_track, &toce);
2598                 if (stat)
2599                         return stat;
2600
2601                 tocentry->cdte_ctrl = toce->control;
2602                 tocentry->cdte_adr  = toce->adr;
2603                 if (tocentry->cdte_format == CDROM_MSF) {
2604                         lba_to_msf (toce->addr.lba,
2605                                    &tocentry->cdte_addr.msf.minute,
2606                                    &tocentry->cdte_addr.msf.second,
2607                                    &tocentry->cdte_addr.msf.frame);
2608                 } else
2609                         tocentry->cdte_addr.lba = toce->addr.lba;
2610
2611                 return 0;
2612         }
2613
2614         default:
2615                 return -EINVAL;
2616         }
2617 }
2618
2619 static
2620 int ide_cdrom_reset (struct cdrom_device_info *cdi)
2621 {
2622         ide_drive_t *drive = cdi->handle;
2623         struct request_sense sense;
2624         struct request req;
2625         int ret;
2626
2627         cdrom_prepare_request(drive, &req);
2628         req.cmd_type = REQ_TYPE_SPECIAL;
2629         req.cmd_flags = REQ_QUIET;
2630         ret = ide_do_drive_cmd(drive, &req, ide_wait);
2631
2632         /*
2633          * A reset will unlock the door. If it was previously locked,
2634          * lock it again.
2635          */
2636         if (CDROM_STATE_FLAGS(drive)->door_locked)
2637                 (void) cdrom_lockdoor(drive, 1, &sense);
2638
2639         return ret;
2640 }
2641
2642
2643 static
2644 int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
2645 {
2646         ide_drive_t *drive = cdi->handle;
2647         struct request_sense sense;
2648
2649         if (position) {
2650                 int stat = cdrom_lockdoor(drive, 0, &sense);
2651                 if (stat)
2652                         return stat;
2653         }
2654
2655         return cdrom_eject(drive, !position, &sense);
2656 }
2657
2658 static
2659 int ide_cdrom_lock_door (struct cdrom_device_info *cdi, int lock)
2660 {
2661         ide_drive_t *drive = cdi->handle;
2662         return cdrom_lockdoor(drive, lock, NULL);
2663 }
2664
2665 static
2666 int ide_cdrom_get_capabilities(ide_drive_t *drive, struct atapi_capabilities_page *cap)
2667 {
2668         struct cdrom_info *info = drive->driver_data;
2669         struct cdrom_device_info *cdi = &info->devinfo;
2670         struct packet_command cgc;
2671         int stat, attempts = 3, size = sizeof(*cap);
2672
2673         /*
2674          * ACER50 (and others?) require the full spec length mode sense
2675          * page capabilities size, but older drives break.
2676          */
2677         if (!(!strcmp(drive->id->model, "ATAPI CD ROM DRIVE 50X MAX") ||
2678             !strcmp(drive->id->model, "WPI CDS-32X")))
2679                 size -= sizeof(cap->pad);
2680
2681         init_cdrom_command(&cgc, cap, size, CGC_DATA_UNKNOWN);
2682         do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2683                 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
2684                 if (!stat)
2685                         break;
2686         } while (--attempts);
2687         return stat;
2688 }
2689
2690 static
2691 void ide_cdrom_update_speed (ide_drive_t *drive, struct atapi_capabilities_page *cap)
2692 {
2693         /* The ACER/AOpen 24X cdrom has the speed fields byte-swapped */
2694         if (!drive->id->model[0] &&
2695             !strncmp(drive->id->fw_rev, "241N", 4)) {
2696                 CDROM_STATE_FLAGS(drive)->current_speed  =
2697                         (le16_to_cpu(cap->curspeed) + (176/2)) / 176;
2698                 CDROM_CONFIG_FLAGS(drive)->max_speed =
2699                         (le16_to_cpu(cap->maxspeed) + (176/2)) / 176;
2700         } else {
2701                 CDROM_STATE_FLAGS(drive)->current_speed  =
2702                         (be16_to_cpu(cap->curspeed) + (176/2)) / 176;
2703                 CDROM_CONFIG_FLAGS(drive)->max_speed =
2704                         (be16_to_cpu(cap->maxspeed) + (176/2)) / 176;
2705         }
2706 }
2707
2708 static
2709 int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
2710 {
2711         ide_drive_t *drive = cdi->handle;
2712         struct request_sense sense;
2713         struct atapi_capabilities_page cap;
2714         int stat;
2715
2716         if ((stat = cdrom_select_speed(drive, speed, &sense)) < 0)
2717                 return stat;
2718
2719         if (!ide_cdrom_get_capabilities(drive, &cap)) {
2720                 ide_cdrom_update_speed(drive, &cap);
2721                 cdi->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2722         }
2723         return 0;
2724 }
2725
2726 /*
2727  * add logic to try GET_EVENT command first to check for media and tray
2728  * status. this should be supported by newer cd-r/w and all DVD etc
2729  * drives
2730  */
2731 static
2732 int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
2733 {
2734         ide_drive_t *drive = cdi->handle;
2735         struct media_event_desc med;
2736         struct request_sense sense;
2737         int stat;
2738
2739         if (slot_nr != CDSL_CURRENT)
2740                 return -EINVAL;
2741
2742         stat = cdrom_check_status(drive, &sense);
2743         if (!stat || sense.sense_key == UNIT_ATTENTION)
2744                 return CDS_DISC_OK;
2745
2746         if (!cdrom_get_media_event(cdi, &med)) {
2747                 if (med.media_present)
2748                         return CDS_DISC_OK;
2749                 else if (med.door_open)
2750                         return CDS_TRAY_OPEN;
2751                 else
2752                         return CDS_NO_DISC;
2753         }
2754
2755         if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
2756                 return CDS_DISC_OK;
2757
2758         /*
2759          * If not using Mt Fuji extended media tray reports,
2760          * just return TRAY_OPEN since ATAPI doesn't provide
2761          * any other way to detect this...
2762          */
2763         if (sense.sense_key == NOT_READY) {
2764                 if (sense.asc == 0x3a && sense.ascq == 1)
2765                         return CDS_NO_DISC;
2766                 else
2767                         return CDS_TRAY_OPEN;
2768         }
2769         return CDS_DRIVE_NOT_READY;
2770 }
2771
2772 static
2773 int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
2774                                 struct cdrom_multisession *ms_info)
2775 {
2776         struct atapi_toc *toc;
2777         ide_drive_t *drive = cdi->handle;
2778         struct cdrom_info *info = drive->driver_data;
2779         struct request_sense sense;
2780         int ret;
2781
2782         if (!CDROM_STATE_FLAGS(drive)->toc_valid || info->toc == NULL)
2783                 if ((ret = cdrom_read_toc(drive, &sense)))
2784                         return ret;
2785
2786         toc = info->toc;
2787         ms_info->addr.lba = toc->last_session_lba;
2788         ms_info->xa_flag = toc->xa_flag;
2789
2790         return 0;
2791 }
2792
2793 static
2794 int ide_cdrom_get_mcn (struct cdrom_device_info *cdi,
2795                        struct cdrom_mcn *mcn_info)
2796 {
2797         int stat;
2798         char mcnbuf[24];
2799         ide_drive_t *drive = cdi->handle;
2800
2801 /* get MCN */
2802         if ((stat = cdrom_read_subchannel(drive, 2, mcnbuf, sizeof (mcnbuf), NULL)))
2803                 return stat;
2804
2805         memcpy (mcn_info->medium_catalog_number, mcnbuf+9,
2806                 sizeof (mcn_info->medium_catalog_number)-1);
2807         mcn_info->medium_catalog_number[sizeof (mcn_info->medium_catalog_number)-1]
2808                 = '\0';
2809
2810         return 0;
2811 }
2812
2813
2814
2815 /****************************************************************************
2816  * Other driver requests (open, close, check media change).
2817  */
2818
2819 static
2820 int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
2821                                        int slot_nr)
2822 {
2823         ide_drive_t *drive = cdi->handle;
2824         int retval;
2825
2826         if (slot_nr == CDSL_CURRENT) {
2827                 (void) cdrom_check_status(drive, NULL);
2828                 retval = CDROM_STATE_FLAGS(drive)->media_changed;
2829                 CDROM_STATE_FLAGS(drive)->media_changed = 0;
2830                 return retval;
2831         } else {
2832                 return -EINVAL;
2833         }
2834 }
2835
2836
2837 static
2838 int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
2839 {
2840         return 0;
2841 }
2842
2843 /*
2844  * Close down the device.  Invalidate all cached blocks.
2845  */
2846
2847 static
2848 void ide_cdrom_release_real (struct cdrom_device_info *cdi)
2849 {
2850         ide_drive_t *drive = cdi->handle;
2851
2852         if (!cdi->use_count)
2853                 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
2854 }
2855
2856
2857
2858 /****************************************************************************
2859  * Device initialization.
2860  */
2861 static struct cdrom_device_ops ide_cdrom_dops = {
2862         .open                   = ide_cdrom_open_real,
2863         .release                = ide_cdrom_release_real,
2864         .drive_status           = ide_cdrom_drive_status,
2865         .media_changed          = ide_cdrom_check_media_change_real,
2866         .tray_move              = ide_cdrom_tray_move,
2867         .lock_door              = ide_cdrom_lock_door,
2868         .select_speed           = ide_cdrom_select_speed,
2869         .get_last_session       = ide_cdrom_get_last_session,
2870         .get_mcn                = ide_cdrom_get_mcn,
2871         .reset                  = ide_cdrom_reset,
2872         .audio_ioctl            = ide_cdrom_audio_ioctl,
2873         .capability             = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
2874                                 CDC_SELECT_SPEED | CDC_SELECT_DISC |
2875                                 CDC_MULTI_SESSION | CDC_MCN |
2876                                 CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO | CDC_RESET |
2877                                 CDC_DRIVE_STATUS | CDC_CD_R |
2878                                 CDC_CD_RW | CDC_DVD | CDC_DVD_R| CDC_DVD_RAM |
2879                                 CDC_GENERIC_PACKET | CDC_MO_DRIVE | CDC_MRW |
2880                                 CDC_MRW_W | CDC_RAM,
2881         .generic_packet         = ide_cdrom_packet,
2882 };
2883
2884 static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2885 {
2886         struct cdrom_info *info = drive->driver_data;
2887         struct cdrom_device_info *devinfo = &info->devinfo;
2888
2889         devinfo->ops = &ide_cdrom_dops;
2890         devinfo->mask = 0;
2891         devinfo->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2892         devinfo->capacity = nslots;
2893         devinfo->handle = drive;
2894         strcpy(devinfo->name, drive->name);
2895
2896         /* set capability mask to match the probe. */
2897         if (!CDROM_CONFIG_FLAGS(drive)->cd_r)
2898                 devinfo->mask |= CDC_CD_R;
2899         if (!CDROM_CONFIG_FLAGS(drive)->cd_rw)
2900                 devinfo->mask |= CDC_CD_RW;
2901         if (!CDROM_CONFIG_FLAGS(drive)->dvd)
2902                 devinfo->mask |= CDC_DVD;
2903         if (!CDROM_CONFIG_FLAGS(drive)->dvd_r)
2904                 devinfo->mask |= CDC_DVD_R;
2905         if (!CDROM_CONFIG_FLAGS(drive)->dvd_ram)
2906                 devinfo->mask |= CDC_DVD_RAM;
2907         if (!CDROM_CONFIG_FLAGS(drive)->is_changer)
2908                 devinfo->mask |= CDC_SELECT_DISC;
2909         if (!CDROM_CONFIG_FLAGS(drive)->audio_play)
2910                 devinfo->mask |= CDC_PLAY_AUDIO;
2911         if (!CDROM_CONFIG_FLAGS(drive)->close_tray)
2912                 devinfo->mask |= CDC_CLOSE_TRAY;
2913         if (!CDROM_CONFIG_FLAGS(drive)->mo_drive)
2914                 devinfo->mask |= CDC_MO_DRIVE;
2915         if (!CDROM_CONFIG_FLAGS(drive)->ram)
2916                 devinfo->mask |= CDC_RAM;
2917
2918         if (CDROM_CONFIG_FLAGS(drive)->no_speed_select)
2919                 devinfo->mask |= CDC_SELECT_SPEED;
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(KERN_CONT ", %dkB Cache\n", be16_to_cpu(cap.buffer_size));
3034
3035         return nslots;
3036 }
3037
3038 #ifdef CONFIG_IDE_PROC_FS
3039 static void ide_cdrom_add_settings(ide_drive_t *drive)
3040 {
3041         ide_add_setting(drive, "dsc_overlap", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
3042 }
3043 #else
3044 static inline void ide_cdrom_add_settings(ide_drive_t *drive) { ; }
3045 #endif
3046
3047 /*
3048  * standard prep_rq_fn that builds 10 byte cmds
3049  */
3050 static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
3051 {
3052         int hard_sect = queue_hardsect_size(q);
3053         long block = (long)rq->hard_sector / (hard_sect >> 9);
3054         unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
3055
3056         memset(rq->cmd, 0, sizeof(rq->cmd));
3057
3058         if (rq_data_dir(rq) == READ)
3059                 rq->cmd[0] = GPCMD_READ_10;
3060         else
3061                 rq->cmd[0] = GPCMD_WRITE_10;
3062
3063         /*
3064          * fill in lba
3065          */
3066         rq->cmd[2] = (block >> 24) & 0xff;
3067         rq->cmd[3] = (block >> 16) & 0xff;
3068         rq->cmd[4] = (block >>  8) & 0xff;
3069         rq->cmd[5] = block & 0xff;
3070
3071         /*
3072          * and transfer length
3073          */
3074         rq->cmd[7] = (blocks >> 8) & 0xff;
3075         rq->cmd[8] = blocks & 0xff;
3076         rq->cmd_len = 10;
3077         return BLKPREP_OK;
3078 }
3079
3080 /*
3081  * Most of the SCSI commands are supported directly by ATAPI devices.
3082  * This transform handles the few exceptions.
3083  */
3084 static int ide_cdrom_prep_pc(struct request *rq)
3085 {
3086         u8 *c = rq->cmd;
3087
3088         /*
3089          * Transform 6-byte read/write commands to the 10-byte version
3090          */
3091         if (c[0] == READ_6 || c[0] == WRITE_6) {
3092                 c[8] = c[4];
3093                 c[5] = c[3];
3094                 c[4] = c[2];
3095                 c[3] = c[1] & 0x1f;
3096                 c[2] = 0;
3097                 c[1] &= 0xe0;
3098                 c[0] += (READ_10 - READ_6);
3099                 rq->cmd_len = 10;
3100                 return BLKPREP_OK;
3101         }
3102
3103         /*
3104          * it's silly to pretend we understand 6-byte sense commands, just
3105          * reject with ILLEGAL_REQUEST and the caller should take the
3106          * appropriate action
3107          */
3108         if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
3109                 rq->errors = ILLEGAL_REQUEST;
3110                 return BLKPREP_KILL;
3111         }
3112
3113         return BLKPREP_OK;
3114 }
3115
3116 static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
3117 {
3118         if (blk_fs_request(rq))
3119                 return ide_cdrom_prep_fs(q, rq);
3120         else if (blk_pc_request(rq))
3121                 return ide_cdrom_prep_pc(rq);
3122
3123         return 0;
3124 }
3125
3126 static
3127 int ide_cdrom_setup (ide_drive_t *drive)
3128 {
3129         struct cdrom_info *info = drive->driver_data;
3130         struct cdrom_device_info *cdi = &info->devinfo;
3131         int nslots;
3132
3133         blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
3134         blk_queue_dma_alignment(drive->queue, 31);
3135         drive->queue->unplug_delay = (1 * HZ) / 1000;
3136         if (!drive->queue->unplug_delay)
3137                 drive->queue->unplug_delay = 1;
3138
3139         drive->special.all      = 0;
3140
3141         CDROM_STATE_FLAGS(drive)->media_changed = 1;
3142         CDROM_STATE_FLAGS(drive)->toc_valid     = 0;
3143         CDROM_STATE_FLAGS(drive)->door_locked   = 0;
3144
3145 #if NO_DOOR_LOCKING
3146         CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
3147 #else
3148         CDROM_CONFIG_FLAGS(drive)->no_doorlock = 0;
3149 #endif
3150
3151         CDROM_CONFIG_FLAGS(drive)->drq_interrupt = ((drive->id->config & 0x0060) == 0x20);
3152         CDROM_CONFIG_FLAGS(drive)->is_changer = 0;
3153         CDROM_CONFIG_FLAGS(drive)->cd_r = 0;
3154         CDROM_CONFIG_FLAGS(drive)->cd_rw = 0;
3155         CDROM_CONFIG_FLAGS(drive)->test_write = 0;
3156         CDROM_CONFIG_FLAGS(drive)->dvd = 0;
3157         CDROM_CONFIG_FLAGS(drive)->dvd_r = 0;
3158         CDROM_CONFIG_FLAGS(drive)->dvd_ram = 0;
3159         CDROM_CONFIG_FLAGS(drive)->no_eject = 1;
3160         CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 0;
3161         CDROM_CONFIG_FLAGS(drive)->audio_play = 0;
3162         CDROM_CONFIG_FLAGS(drive)->close_tray = 1;
3163
3164         /* limit transfer size per interrupt. */
3165         CDROM_CONFIG_FLAGS(drive)->limit_nframes = 0;
3166         /* a testament to the nice quality of Samsung drives... */
3167         if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2430"))
3168                 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3169         else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2432"))
3170                 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3171         /* the 3231 model does not support the SET_CD_SPEED command */
3172         else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-3231"))
3173                 CDROM_CONFIG_FLAGS(drive)->no_speed_select = 1;
3174
3175 #if ! STANDARD_ATAPI
3176         /* by default Sanyo 3 CD changer support is turned off and
3177            ATAPI Rev 2.2+ standard support for CD changers is used */
3178         cdi->sanyo_slot = 0;
3179
3180         CDROM_CONFIG_FLAGS(drive)->nec260 = 0;
3181         CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 0;
3182         CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 0;
3183         CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 0;
3184         CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 0;
3185
3186         if (strcmp (drive->id->model, "V003S0DS") == 0 &&
3187             drive->id->fw_rev[4] == '1' &&
3188             drive->id->fw_rev[6] <= '2') {
3189                 /* Vertos 300.
3190                    Some versions of this drive like to talk BCD. */
3191                 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3192                 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3193                 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3194                 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3195         }
3196
3197         else if (strcmp (drive->id->model, "V006E0DS") == 0 &&
3198             drive->id->fw_rev[4] == '1' &&
3199             drive->id->fw_rev[6] <= '2') {
3200                 /* Vertos 600 ESD. */
3201                 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3202         }
3203         else if (strcmp(drive->id->model, "NEC CD-ROM DRIVE:260") == 0 &&
3204                  strncmp(drive->id->fw_rev, "1.01", 4) == 0) { /* FIXME */
3205                 /* Old NEC260 (not R).
3206                    This drive was released before the 1.2 version
3207                    of the spec. */
3208                 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3209                 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3210                 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3211                 CDROM_CONFIG_FLAGS(drive)->nec260         = 1;
3212         }
3213         else if (strcmp(drive->id->model, "WEARNES CDD-120") == 0 &&
3214                  strncmp(drive->id->fw_rev, "A1.1", 4) == 0) { /* FIXME */
3215                 /* Wearnes */
3216                 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3217                 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3218         }
3219         /* Sanyo 3 CD changer uses a non-standard command
3220            for CD changing */
3221         else if ((strcmp(drive->id->model, "CD-ROM CDR-C3 G") == 0) ||
3222                  (strcmp(drive->id->model, "CD-ROM CDR-C3G") == 0) ||
3223                  (strcmp(drive->id->model, "CD-ROM CDR_C36") == 0)) {
3224                  /* uses CD in slot 0 when value is set to 3 */
3225                  cdi->sanyo_slot = 3;
3226         }
3227 #endif /* not STANDARD_ATAPI */
3228
3229         info->toc               = NULL;
3230         info->buffer            = NULL;
3231         info->sector_buffered   = 0;
3232         info->nsectors_buffered = 0;
3233         info->changer_info      = NULL;
3234         info->last_block        = 0;
3235         info->start_seek        = 0;
3236
3237         nslots = ide_cdrom_probe_capabilities (drive);
3238
3239         /*
3240          * set correct block size
3241          */
3242         blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
3243
3244         if (drive->autotune == IDE_TUNE_DEFAULT ||
3245             drive->autotune == IDE_TUNE_AUTO)
3246                 drive->dsc_overlap = (drive->next != drive);
3247
3248         if (ide_cdrom_register(drive, nslots)) {
3249                 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
3250                 info->devinfo.handle = NULL;
3251                 return 1;
3252         }
3253         ide_cdrom_add_settings(drive);
3254         return 0;
3255 }
3256
3257 #ifdef CONFIG_IDE_PROC_FS
3258 static
3259 sector_t ide_cdrom_capacity (ide_drive_t *drive)
3260 {
3261         unsigned long capacity, sectors_per_frame;
3262
3263         if (cdrom_read_capacity(drive, &capacity, &sectors_per_frame, NULL))
3264                 return 0;
3265
3266         return capacity * sectors_per_frame;
3267 }
3268 #endif
3269
3270 static void ide_cd_remove(ide_drive_t *drive)
3271 {
3272         struct cdrom_info *info = drive->driver_data;
3273
3274         ide_proc_unregister_driver(drive, info->driver);
3275
3276         del_gendisk(info->disk);
3277
3278         ide_cd_put(info);
3279 }
3280
3281 static void ide_cd_release(struct kref *kref)
3282 {
3283         struct cdrom_info *info = to_ide_cd(kref);
3284         struct cdrom_device_info *devinfo = &info->devinfo;
3285         ide_drive_t *drive = info->drive;
3286         struct gendisk *g = info->disk;
3287
3288         kfree(info->buffer);
3289         kfree(info->toc);
3290         kfree(info->changer_info);
3291         if (devinfo->handle == drive && unregister_cdrom(devinfo))
3292                 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom "
3293                                 "driver.\n", __FUNCTION__, drive->name);
3294         drive->dsc_overlap = 0;
3295         drive->driver_data = NULL;
3296         blk_queue_prep_rq(drive->queue, NULL);
3297         g->private_data = NULL;
3298         put_disk(g);
3299         kfree(info);
3300 }
3301
3302 static int ide_cd_probe(ide_drive_t *);
3303
3304 #ifdef CONFIG_IDE_PROC_FS
3305 static int proc_idecd_read_capacity
3306         (char *page, char **start, off_t off, int count, int *eof, void *data)
3307 {
3308         ide_drive_t *drive = data;
3309         int len;
3310
3311         len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
3312         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
3313 }
3314
3315 static ide_proc_entry_t idecd_proc[] = {
3316         { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
3317         { NULL, 0, NULL, NULL }
3318 };
3319 #endif
3320
3321 static ide_driver_t ide_cdrom_driver = {
3322         .gen_driver = {
3323                 .owner          = THIS_MODULE,
3324                 .name           = "ide-cdrom",
3325                 .bus            = &ide_bus_type,
3326         },
3327         .probe                  = ide_cd_probe,
3328         .remove                 = ide_cd_remove,
3329         .version                = IDECD_VERSION,
3330         .media                  = ide_cdrom,
3331         .supports_dsc_overlap   = 1,
3332         .do_request             = ide_do_rw_cdrom,
3333         .end_request            = ide_end_request,
3334         .error                  = __ide_error,
3335         .abort                  = __ide_abort,
3336 #ifdef CONFIG_IDE_PROC_FS
3337         .proc                   = idecd_proc,
3338 #endif
3339 };
3340
3341 static int idecd_open(struct inode * inode, struct file * file)
3342 {
3343         struct gendisk *disk = inode->i_bdev->bd_disk;
3344         struct cdrom_info *info;
3345         int rc = -ENOMEM;
3346
3347         if (!(info = ide_cd_get(disk)))
3348                 return -ENXIO;
3349
3350         if (!info->buffer)
3351                 info->buffer = kmalloc(SECTOR_BUFFER_SIZE, GFP_KERNEL|__GFP_REPEAT);
3352
3353         if (info->buffer)
3354                 rc = cdrom_open(&info->devinfo, inode, file);
3355
3356         if (rc < 0)
3357                 ide_cd_put(info);
3358
3359         return rc;
3360 }
3361
3362 static int idecd_release(struct inode * inode, struct file * file)
3363 {
3364         struct gendisk *disk = inode->i_bdev->bd_disk;
3365         struct cdrom_info *info = ide_cd_g(disk);
3366
3367         cdrom_release (&info->devinfo, file);
3368
3369         ide_cd_put(info);
3370
3371         return 0;
3372 }
3373
3374 static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg)
3375 {
3376         struct packet_command cgc;
3377         char buffer[16];
3378         int stat;
3379         char spindown;
3380
3381         if (copy_from_user(&spindown, (void __user *)arg, sizeof(char)))
3382                 return -EFAULT;
3383
3384         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
3385
3386         stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
3387         if (stat)
3388                 return stat;
3389
3390         buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
3391         return cdrom_mode_select(cdi, &cgc);
3392 }
3393
3394 static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
3395 {
3396         struct packet_command cgc;
3397         char buffer[16];
3398         int stat;
3399         char spindown;
3400
3401         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
3402
3403         stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
3404         if (stat)
3405                 return stat;
3406
3407         spindown = buffer[11] & 0x0f;
3408         if (copy_to_user((void __user *)arg, &spindown, sizeof (char)))
3409                 return -EFAULT;
3410         return 0;
3411 }
3412
3413 static int idecd_ioctl (struct inode *inode, struct file *file,
3414                         unsigned int cmd, unsigned long arg)
3415 {
3416         struct block_device *bdev = inode->i_bdev;
3417         struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
3418         int err;
3419
3420         switch (cmd) {
3421         case CDROMSETSPINDOWN:
3422                 return idecd_set_spindown(&info->devinfo, arg);
3423         case CDROMGETSPINDOWN:
3424                 return idecd_get_spindown(&info->devinfo, arg);
3425         default:
3426                 break;
3427         }
3428
3429         err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
3430         if (err == -EINVAL)
3431                 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
3432
3433         return err;
3434 }
3435
3436 static int idecd_media_changed(struct gendisk *disk)
3437 {
3438         struct cdrom_info *info = ide_cd_g(disk);
3439         return cdrom_media_changed(&info->devinfo);
3440 }
3441
3442 static int idecd_revalidate_disk(struct gendisk *disk)
3443 {
3444         struct cdrom_info *info = ide_cd_g(disk);
3445         struct request_sense sense;
3446         cdrom_read_toc(info->drive, &sense);
3447         return  0;
3448 }
3449
3450 static struct block_device_operations idecd_ops = {
3451         .owner          = THIS_MODULE,
3452         .open           = idecd_open,
3453         .release        = idecd_release,
3454         .ioctl          = idecd_ioctl,
3455         .media_changed  = idecd_media_changed,
3456         .revalidate_disk= idecd_revalidate_disk
3457 };
3458
3459 /* options */
3460 static char *ignore = NULL;
3461
3462 module_param(ignore, charp, 0400);
3463 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
3464
3465 static int ide_cd_probe(ide_drive_t *drive)
3466 {
3467         struct cdrom_info *info;
3468         struct gendisk *g;
3469         struct request_sense sense;
3470
3471         if (!strstr("ide-cdrom", drive->driver_req))
3472                 goto failed;
3473         if (!drive->present)
3474                 goto failed;
3475         if (drive->media != ide_cdrom && drive->media != ide_optical)
3476                 goto failed;
3477         /* skip drives that we were told to ignore */
3478         if (ignore != NULL) {
3479                 if (strstr(ignore, drive->name)) {
3480                         printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
3481                         goto failed;
3482                 }
3483         }
3484         if (drive->scsi) {
3485                 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
3486                 goto failed;
3487         }
3488         info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
3489         if (info == NULL) {
3490                 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
3491                 goto failed;
3492         }
3493
3494         g = alloc_disk(1 << PARTN_BITS);
3495         if (!g)
3496                 goto out_free_cd;
3497
3498         ide_init_disk(g, drive);
3499
3500         ide_proc_register_driver(drive, &ide_cdrom_driver);
3501
3502         kref_init(&info->kref);
3503
3504         info->drive = drive;
3505         info->driver = &ide_cdrom_driver;
3506         info->disk = g;
3507
3508         g->private_data = &info->driver;
3509
3510         drive->driver_data = info;
3511
3512         g->minors = 1;
3513         g->driverfs_dev = &drive->gendev;
3514         g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
3515         if (ide_cdrom_setup(drive)) {
3516                 ide_proc_unregister_driver(drive, &ide_cdrom_driver);
3517                 ide_cd_release(&info->kref);
3518                 goto failed;
3519         }
3520
3521         cdrom_read_toc(drive, &sense);
3522         g->fops = &idecd_ops;
3523         g->flags |= GENHD_FL_REMOVABLE;
3524         add_disk(g);
3525         return 0;
3526
3527 out_free_cd:
3528         kfree(info);
3529 failed:
3530         return -ENODEV;
3531 }
3532
3533 static void __exit ide_cdrom_exit(void)
3534 {
3535         driver_unregister(&ide_cdrom_driver.gen_driver);
3536 }
3537
3538 static int __init ide_cdrom_init(void)
3539 {
3540         return driver_register(&ide_cdrom_driver.gen_driver);
3541 }
3542
3543 MODULE_ALIAS("ide:*m-cdrom*");
3544 module_init(ide_cdrom_init);
3545 module_exit(ide_cdrom_exit);
3546 MODULE_LICENSE("GPL");