err.no Git - linux-2.6/blob - drivers/ide/ide-cd.c

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