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