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 /*
1009  * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
1010  * buffer.  Once the first sector is added, any subsequent sectors are
1011  * assumed to be continuous (until the buffer is cleared).  For the first
1012  * sector added, SECTOR is its sector number.  (SECTOR is then ignored until
1013  * the buffer is cleared.)
1014  */
1015 static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
1016                                   int sectors_to_transfer)
1017 {
1018         struct cdrom_info *info = drive->driver_data;
1019
1020         /* Number of sectors to read into the buffer. */
1021         int sectors_to_buffer = min_t(int, sectors_to_transfer,
1022                                      (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
1023                                        info->nsectors_buffered);
1024
1025         char *dest;
1026
1027         /* If we couldn't get a buffer, don't try to buffer anything... */
1028         if (info->buffer == NULL)
1029                 sectors_to_buffer = 0;
1030
1031         /* If this is the first sector in the buffer, remember its number. */
1032         if (info->nsectors_buffered == 0)
1033                 info->sector_buffered = sector;
1034
1035         /* Read the data into the buffer. */
1036         dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
1037         while (sectors_to_buffer > 0) {
1038                 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
1039                 --sectors_to_buffer;
1040                 --sectors_to_transfer;
1041                 ++info->nsectors_buffered;
1042                 dest += SECTOR_SIZE;
1043         }
1044
1045         /* Throw away any remaining data. */
1046         while (sectors_to_transfer > 0) {
1047                 static char dum[SECTOR_SIZE];
1048                 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1049                 --sectors_to_transfer;
1050         }
1051 }
1052
1053 /*
1054  * Check the contents of the interrupt reason register from the cdrom
1055  * and attempt to recover if there are problems.  Returns  0 if everything's
1056  * ok; nonzero if the request has been terminated.
1057  */
1058 static
1059 int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
1060 {
1061         if (ireason == 2)
1062                 return 0;
1063         else if (ireason == 0) {
1064                 /* Whoops... The drive is expecting to receive data from us! */
1065                 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
1066                                 drive->name, __FUNCTION__);
1067
1068                 /* Throw some data at the drive so it doesn't hang
1069                    and quit this request. */
1070                 while (len > 0) {
1071                         int dum = 0;
1072                         HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof (dum));
1073                         len -= sizeof (dum);
1074                 }
1075         } else  if (ireason == 1) {
1076                 /* Some drives (ASUS) seem to tell us that status
1077                  * info is available. just get it and ignore.
1078                  */
1079                 (void) HWIF(drive)->INB(IDE_STATUS_REG);
1080                 return 0;
1081         } else {
1082                 /* Drive wants a command packet, or invalid ireason... */
1083                 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
1084                                 drive->name, __FUNCTION__, ireason);
1085         }
1086
1087         cdrom_end_request(drive, 0);
1088         return -1;
1089 }
1090
1091 /*
1092  * Interrupt routine.  Called when a read request has completed.
1093  */
1094 static ide_startstop_t cdrom_read_intr (ide_drive_t *drive)
1095 {
1096         int stat;
1097         int ireason, len, sectors_to_transfer, nskip;
1098         struct cdrom_info *info = drive->driver_data;
1099         u8 lowcyl = 0, highcyl = 0;
1100         int dma = info->dma, dma_error = 0;
1101
1102         struct request *rq = HWGROUP(drive)->rq;
1103
1104         /*
1105          * handle dma case
1106          */
1107         if (dma) {
1108                 info->dma = 0;
1109                 dma_error = HWIF(drive)->ide_dma_end(drive);
1110                 if (dma_error) {
1111                         printk(KERN_ERR "%s: DMA read error\n", drive->name);
1112                         ide_dma_off(drive);
1113                 }
1114         }
1115
1116         if (cdrom_decode_status(drive, 0, &stat))
1117                 return ide_stopped;
1118
1119         if (dma) {
1120                 if (!dma_error) {
1121                         ide_end_request(drive, 1, rq->nr_sectors);
1122                         return ide_stopped;
1123                 } else
1124                         return ide_error(drive, "dma error", stat);
1125         }
1126
1127         /* Read the interrupt reason and the transfer length. */
1128         ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1129         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1130         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1131
1132         len = lowcyl + (256 * highcyl);
1133
1134         /* If DRQ is clear, the command has completed. */
1135         if ((stat & DRQ_STAT) == 0) {
1136                 /* If we're not done filling the current buffer, complain.
1137                    Otherwise, complete the command normally. */
1138                 if (rq->current_nr_sectors > 0) {
1139                         printk (KERN_ERR "%s: cdrom_read_intr: data underrun (%d blocks)\n",
1140                                 drive->name, rq->current_nr_sectors);
1141                         rq->cmd_flags |= REQ_FAILED;
1142                         cdrom_end_request(drive, 0);
1143                 } else
1144                         cdrom_end_request(drive, 1);
1145                 return ide_stopped;
1146         }
1147
1148         /* Check that the drive is expecting to do the same thing we are. */
1149         if (cdrom_read_check_ireason (drive, len, ireason))
1150                 return ide_stopped;
1151
1152         /* Assume that the drive will always provide data in multiples
1153            of at least SECTOR_SIZE, as it gets hairy to keep track
1154            of the transfers otherwise. */
1155         if ((len % SECTOR_SIZE) != 0) {
1156                 printk (KERN_ERR "%s: cdrom_read_intr: Bad transfer size %d\n",
1157                         drive->name, len);
1158                 if (CDROM_CONFIG_FLAGS(drive)->limit_nframes)
1159                         printk (KERN_ERR "  This drive is not supported by this version of the driver\n");
1160                 else {
1161                         printk (KERN_ERR "  Trying to limit transfer sizes\n");
1162                         CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
1163                 }
1164                 cdrom_end_request(drive, 0);
1165                 return ide_stopped;
1166         }
1167
1168         /* The number of sectors we need to read from the drive. */
1169         sectors_to_transfer = len / SECTOR_SIZE;
1170
1171         /* First, figure out if we need to bit-bucket
1172            any of the leading sectors. */
1173         nskip = min_t(int, rq->current_nr_sectors - bio_cur_sectors(rq->bio), sectors_to_transfer);
1174
1175         while (nskip > 0) {
1176                 /* We need to throw away a sector. */
1177                 static char dum[SECTOR_SIZE];
1178                 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1179
1180                 --rq->current_nr_sectors;
1181                 --nskip;
1182                 --sectors_to_transfer;
1183         }
1184
1185         /* Now loop while we still have data to read from the drive. */
1186         while (sectors_to_transfer > 0) {
1187                 int this_transfer;
1188
1189                 /* If we've filled the present buffer but there's another
1190                    chained buffer after it, move on. */
1191                 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1192                         cdrom_end_request(drive, 1);
1193
1194                 /* If the buffers are full, cache the rest of the data in our
1195                    internal buffer. */
1196                 if (rq->current_nr_sectors == 0) {
1197                         cdrom_buffer_sectors(drive, rq->sector, sectors_to_transfer);
1198                         sectors_to_transfer = 0;
1199                 } else {
1200                         /* Transfer data to the buffers.
1201                            Figure out how many sectors we can transfer
1202                            to the current buffer. */
1203                         this_transfer = min_t(int, sectors_to_transfer,
1204                                              rq->current_nr_sectors);
1205
1206                         /* Read this_transfer sectors
1207                            into the current buffer. */
1208                         while (this_transfer > 0) {
1209                                 HWIF(drive)->atapi_input_bytes(drive, rq->buffer, SECTOR_SIZE);
1210                                 rq->buffer += SECTOR_SIZE;
1211                                 --rq->nr_sectors;
1212                                 --rq->current_nr_sectors;
1213                                 ++rq->sector;
1214                                 --this_transfer;
1215                                 --sectors_to_transfer;
1216                         }
1217                 }
1218         }
1219
1220         /* Done moving data!  Wait for another interrupt. */
1221         ide_set_handler(drive, &cdrom_read_intr, ATAPI_WAIT_PC, NULL);
1222         return ide_started;
1223 }
1224
1225 /*
1226  * Try to satisfy some of the current read request from our cached data.
1227  * Returns nonzero if the request has been completed, zero otherwise.
1228  */
1229 static int cdrom_read_from_buffer (ide_drive_t *drive)
1230 {
1231         struct cdrom_info *info = drive->driver_data;
1232         struct request *rq = HWGROUP(drive)->rq;
1233         unsigned short sectors_per_frame;
1234
1235         sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1236
1237         /* Can't do anything if there's no buffer. */
1238         if (info->buffer == NULL) return 0;
1239
1240         /* Loop while this request needs data and the next block is present
1241            in our cache. */
1242         while (rq->nr_sectors > 0 &&
1243                rq->sector >= info->sector_buffered &&
1244                rq->sector < info->sector_buffered + info->nsectors_buffered) {
1245                 if (rq->current_nr_sectors == 0)
1246                         cdrom_end_request(drive, 1);
1247
1248                 memcpy (rq->buffer,
1249                         info->buffer +
1250                         (rq->sector - info->sector_buffered) * SECTOR_SIZE,
1251                         SECTOR_SIZE);
1252                 rq->buffer += SECTOR_SIZE;
1253                 --rq->current_nr_sectors;
1254                 --rq->nr_sectors;
1255                 ++rq->sector;
1256         }
1257
1258         /* If we've satisfied the current request,
1259            terminate it successfully. */
1260         if (rq->nr_sectors == 0) {
1261                 cdrom_end_request(drive, 1);
1262                 return -1;
1263         }
1264
1265         /* Move on to the next buffer if needed. */
1266         if (rq->current_nr_sectors == 0)
1267                 cdrom_end_request(drive, 1);
1268
1269         /* If this condition does not hold, then the kluge i use to
1270            represent the number of sectors to skip at the start of a transfer
1271            will fail.  I think that this will never happen, but let's be
1272            paranoid and check. */
1273         if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
1274             (rq->sector & (sectors_per_frame - 1))) {
1275                 printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
1276                         drive->name, (long)rq->sector);
1277                 cdrom_end_request(drive, 0);
1278                 return -1;
1279         }
1280
1281         return 0;
1282 }
1283
1284 /*
1285  * Routine to send a read packet command to the drive.
1286  * This is usually called directly from cdrom_start_read.
1287  * However, for drq_interrupt devices, it is called from an interrupt
1288  * when the drive is ready to accept the command.
1289  */
1290 static ide_startstop_t cdrom_start_read_continuation (ide_drive_t *drive)
1291 {
1292         struct request *rq = HWGROUP(drive)->rq;
1293         unsigned short sectors_per_frame;
1294         int nskip;
1295
1296         sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1297
1298         /* If the requested sector doesn't start on a cdrom block boundary,
1299            we must adjust the start of the transfer so that it does,
1300            and remember to skip the first few sectors.
1301            If the CURRENT_NR_SECTORS field is larger than the size
1302            of the buffer, it will mean that we're to skip a number
1303            of sectors equal to the amount by which CURRENT_NR_SECTORS
1304            is larger than the buffer size. */
1305         nskip = rq->sector & (sectors_per_frame - 1);
1306         if (nskip > 0) {
1307                 /* Sanity check... */
1308                 if (rq->current_nr_sectors != bio_cur_sectors(rq->bio) &&
1309                         (rq->sector & (sectors_per_frame - 1))) {
1310                         printk(KERN_ERR "%s: cdrom_start_read_continuation: buffer botch (%u)\n",
1311                                 drive->name, rq->current_nr_sectors);
1312                         cdrom_end_request(drive, 0);
1313                         return ide_stopped;
1314                 }
1315                 rq->current_nr_sectors += nskip;
1316         }
1317
1318         /* Set up the command */
1319         rq->timeout = ATAPI_WAIT_PC;
1320
1321         /* Send the command to the drive and return. */
1322         return cdrom_transfer_packet_command(drive, rq, &cdrom_read_intr);
1323 }
1324
1325
1326 #define IDECD_SEEK_THRESHOLD    (1000)                  /* 1000 blocks */
1327 #define IDECD_SEEK_TIMER        (5 * WAIT_MIN_SLEEP)    /* 100 ms */
1328 #define IDECD_SEEK_TIMEOUT      (2 * WAIT_CMD)          /* 20 sec */
1329
1330 static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
1331 {
1332         struct cdrom_info *info = drive->driver_data;
1333         int stat;
1334         static int retry = 10;
1335
1336         if (cdrom_decode_status(drive, 0, &stat))
1337                 return ide_stopped;
1338         CDROM_CONFIG_FLAGS(drive)->seeking = 1;
1339
1340         if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
1341                 if (--retry == 0) {
1342                         /*
1343                          * this condition is far too common, to bother
1344                          * users about it
1345                          */
1346                         /* printk("%s: disabled DSC seek overlap\n", drive->name);*/
1347                         drive->dsc_overlap = 0;
1348                 }
1349         }
1350         return ide_stopped;
1351 }
1352
1353 static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
1354 {
1355         struct request *rq = HWGROUP(drive)->rq;
1356         sector_t frame = rq->sector;
1357
1358         sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
1359
1360         memset(rq->cmd, 0, sizeof(rq->cmd));
1361         rq->cmd[0] = GPCMD_SEEK;
1362         put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
1363
1364         rq->timeout = ATAPI_WAIT_PC;
1365         return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
1366 }
1367
1368 static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
1369 {
1370         struct cdrom_info *info = drive->driver_data;
1371
1372         info->dma = 0;
1373         info->start_seek = jiffies;
1374         return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
1375 }
1376
1377 /* Fix up a possibly partially-processed request so that we can
1378    start it over entirely, or even put it back on the request queue. */
1379 static void restore_request (struct request *rq)
1380 {
1381         if (rq->buffer != bio_data(rq->bio)) {
1382                 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
1383
1384                 rq->buffer = bio_data(rq->bio);
1385                 rq->nr_sectors += n;
1386                 rq->sector -= n;
1387         }
1388         rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
1389         rq->hard_nr_sectors = rq->nr_sectors;
1390         rq->hard_sector = rq->sector;
1391         rq->q->prep_rq_fn(rq->q, rq);
1392 }
1393
1394 /*
1395  * Start a read request from the CD-ROM.
1396  */
1397 static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block)
1398 {
1399         struct cdrom_info *info = drive->driver_data;
1400         struct request *rq = HWGROUP(drive)->rq;
1401         unsigned short sectors_per_frame;
1402
1403         sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1404
1405         /* We may be retrying this request after an error.  Fix up
1406            any weirdness which might be present in the request packet. */
1407         restore_request(rq);
1408
1409         /* Satisfy whatever we can of this request from our cached sector. */
1410         if (cdrom_read_from_buffer(drive))
1411                 return ide_stopped;
1412
1413         /* Clear the local sector buffer. */
1414         info->nsectors_buffered = 0;
1415
1416         /* use dma, if possible. */
1417         info->dma = drive->using_dma;
1418         if ((rq->sector & (sectors_per_frame - 1)) ||
1419             (rq->nr_sectors & (sectors_per_frame - 1)))
1420                 info->dma = 0;
1421
1422         /* Start sending the read request to the drive. */
1423         return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
1424 }
1425
1426 /****************************************************************************
1427  * Execute all other packet commands.
1428  */
1429
1430 /* Interrupt routine for packet command completion. */
1431 static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
1432 {
1433         int ireason, len, thislen;
1434         struct request *rq = HWGROUP(drive)->rq;
1435         u8 lowcyl = 0, highcyl = 0;
1436         int stat;
1437
1438         /* Check for errors. */
1439         if (cdrom_decode_status(drive, 0, &stat))
1440                 return ide_stopped;
1441
1442         /* Read the interrupt reason and the transfer length. */
1443         ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1444         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1445         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1446
1447         len = lowcyl + (256 * highcyl);
1448
1449         /* If DRQ is clear, the command has completed.
1450            Complain if we still have data left to transfer. */
1451         if ((stat & DRQ_STAT) == 0) {
1452                 /* Some of the trailing request sense fields are optional, and
1453                    some drives don't send them.  Sigh. */
1454                 if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
1455                     rq->data_len > 0 &&
1456                     rq->data_len <= 5) {
1457                         while (rq->data_len > 0) {
1458                                 *(unsigned char *)rq->data++ = 0;
1459                                 --rq->data_len;
1460                         }
1461                 }
1462
1463                 if (rq->data_len == 0)
1464                         cdrom_end_request(drive, 1);
1465                 else {
1466                         /* Comment this out, because this always happens
1467                            right after a reset occurs, and it is annoying to
1468                            always print expected stuff.  */
1469                         /*
1470                         printk ("%s: cdrom_pc_intr: data underrun %d\n",
1471                                 drive->name, pc->buflen);
1472                         */
1473                         rq->cmd_flags |= REQ_FAILED;
1474                         cdrom_end_request(drive, 0);
1475                 }
1476                 return ide_stopped;
1477         }
1478
1479         /* Figure out how much data to transfer. */
1480         thislen = rq->data_len;
1481         if (thislen > len) thislen = len;
1482
1483         /* The drive wants to be written to. */
1484         if (ireason == 0) {
1485                 if (!rq->data) {
1486                         blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1487                         goto confused;
1488                 }
1489                 /* Transfer the data. */
1490                 HWIF(drive)->atapi_output_bytes(drive, rq->data, thislen);
1491
1492                 /* If we haven't moved enough data to satisfy the drive,
1493                    add some padding. */
1494                 while (len > thislen) {
1495                         int dum = 0;
1496                         HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof(dum));
1497                         len -= sizeof(dum);
1498                 }
1499
1500                 /* Keep count of how much data we've moved. */
1501                 rq->data += thislen;
1502                 rq->data_len -= thislen;
1503         }
1504
1505         /* Same drill for reading. */
1506         else if (ireason == 2) {
1507                 if (!rq->data) {
1508                         blk_dump_rq_flags(rq, "cdrom_pc_intr, read");
1509                         goto confused;
1510                 }
1511                 /* Transfer the data. */
1512                 HWIF(drive)->atapi_input_bytes(drive, rq->data, thislen);
1513
1514                 /* If we haven't moved enough data to satisfy the drive,
1515                    add some padding. */
1516                 while (len > thislen) {
1517                         int dum = 0;
1518                         HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1519                         len -= sizeof(dum);
1520                 }
1521
1522                 /* Keep count of how much data we've moved. */
1523                 rq->data += thislen;
1524                 rq->data_len -= thislen;
1525
1526                 if (blk_sense_request(rq))
1527                         rq->sense_len += thislen;
1528         } else {
1529 confused:
1530                 printk (KERN_ERR "%s: cdrom_pc_intr: The drive "
1531                         "appears confused (ireason = 0x%02x). "
1532                         "Trying to recover by ending request.\n",
1533                         drive->name, ireason);
1534                 rq->cmd_flags |= REQ_FAILED;
1535                 cdrom_end_request(drive, 0);
1536                 return ide_stopped;
1537         }
1538
1539         /* Now we wait for another interrupt. */
1540         ide_set_handler(drive, &cdrom_pc_intr, ATAPI_WAIT_PC, cdrom_timer_expiry);
1541         return ide_started;
1542 }
1543
1544 static ide_startstop_t cdrom_do_pc_continuation (ide_drive_t *drive)
1545 {
1546         struct request *rq = HWGROUP(drive)->rq;
1547
1548         if (!rq->timeout)
1549                 rq->timeout = ATAPI_WAIT_PC;
1550
1551         /* Send the command to the drive and return. */
1552         return cdrom_transfer_packet_command(drive, rq, &cdrom_pc_intr);
1553 }
1554
1555
1556 static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
1557 {
1558         int len;
1559         struct request *rq = HWGROUP(drive)->rq;
1560         struct cdrom_info *info = drive->driver_data;
1561
1562         info->dma = 0;
1563         rq->cmd_flags &= ~REQ_FAILED;
1564         len = rq->data_len;
1565
1566         /* Start sending the command to the drive. */
1567         return cdrom_start_packet_command(drive, len, cdrom_do_pc_continuation);
1568 }
1569
1570
1571 static int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
1572 {
1573         struct request_sense sense;
1574         int retries = 10;
1575         unsigned int flags = rq->cmd_flags;
1576
1577         if (rq->sense == NULL)
1578                 rq->sense = &sense;
1579
1580         /* Start of retry loop. */
1581         do {
1582                 int error;
1583                 unsigned long time = jiffies;
1584                 rq->cmd_flags = flags;
1585
1586                 error = ide_do_drive_cmd(drive, rq, ide_wait);
1587                 time = jiffies - time;
1588
1589                 /* FIXME: we should probably abort/retry or something
1590                  * in case of failure */
1591                 if (rq->cmd_flags & REQ_FAILED) {
1592                         /* The request failed.  Retry if it was due to a unit
1593                            attention status
1594                            (usually means media was changed). */
1595                         struct request_sense *reqbuf = rq->sense;
1596
1597                         if (reqbuf->sense_key == UNIT_ATTENTION)
1598                                 cdrom_saw_media_change(drive);
1599                         else if (reqbuf->sense_key == NOT_READY &&
1600                                  reqbuf->asc == 4 && reqbuf->ascq != 4) {
1601                                 /* The drive is in the process of loading
1602                                    a disk.  Retry, but wait a little to give
1603                                    the drive time to complete the load. */
1604                                 ssleep(2);
1605                         } else {
1606                                 /* Otherwise, don't retry. */
1607                                 retries = 0;
1608                         }
1609                         --retries;
1610                 }
1611
1612                 /* End of retry loop. */
1613         } while ((rq->cmd_flags & REQ_FAILED) && retries >= 0);
1614
1615         /* Return an error if the command failed. */
1616         return (rq->cmd_flags & REQ_FAILED) ? -EIO : 0;
1617 }
1618
1619 /*
1620  * Write handling
1621  */
1622 static int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
1623 {
1624         /* Two notes about IDE interrupt reason here - 0 means that
1625          * the drive wants to receive data from us, 2 means that
1626          * the drive is expecting to transfer data to us.
1627          */
1628         if (ireason == 0)
1629                 return 0;
1630         else if (ireason == 2) {
1631                 /* Whoops... The drive wants to send data. */
1632                 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
1633                                 drive->name, __FUNCTION__);
1634
1635                 while (len > 0) {
1636                         int dum = 0;
1637                         HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1638                         len -= sizeof(dum);
1639                 }
1640         } else {
1641                 /* Drive wants a command packet, or invalid ireason... */
1642                 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
1643                                 drive->name, __FUNCTION__, ireason);
1644         }
1645
1646         cdrom_end_request(drive, 0);
1647         return 1;
1648 }
1649
1650 /*
1651  * Called from blk_end_request_callback() after the data of the request
1652  * is completed and before the request is completed.
1653  * By returning value '1', blk_end_request_callback() returns immediately
1654  * without completing the request.
1655  */
1656 static int cdrom_newpc_intr_dummy_cb(struct request *rq)
1657 {
1658         return 1;
1659 }
1660
1661 typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
1662
1663 /*
1664  * best way to deal with dma that is not sector aligned right now... note
1665  * that in this path we are not using ->data or ->buffer at all. this irs
1666  * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the
1667  * future.
1668  */
1669 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1670 {
1671         struct cdrom_info *info = drive->driver_data;
1672         struct request *rq = HWGROUP(drive)->rq;
1673         int dma_error, dma, stat, ireason, len, thislen;
1674         u8 lowcyl, highcyl;
1675         xfer_func_t *xferfunc;
1676         unsigned long flags;
1677
1678         /* Check for errors. */
1679         dma_error = 0;
1680         dma = info->dma;
1681         if (dma) {
1682                 info->dma = 0;
1683                 dma_error = HWIF(drive)->ide_dma_end(drive);
1684         }
1685
1686         if (cdrom_decode_status(drive, 0, &stat))
1687                 return ide_stopped;
1688
1689         /*
1690          * using dma, transfer is complete now
1691          */
1692         if (dma) {
1693                 if (dma_error) {
1694                         printk(KERN_ERR "ide-cd: dma error\n");
1695                         ide_dma_off(drive);
1696                         return ide_error(drive, "dma error", stat);
1697                 }
1698
1699                 spin_lock_irqsave(&ide_lock, flags);
1700                 if (__blk_end_request(rq, 0, rq->data_len))
1701                         BUG();
1702                 HWGROUP(drive)->rq = NULL;
1703                 spin_unlock_irqrestore(&ide_lock, flags);
1704
1705                 return ide_stopped;
1706         }
1707
1708         /*
1709          * ok we fall to pio :/
1710          */
1711         ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1712         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1713         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1714
1715         len = lowcyl + (256 * highcyl);
1716         thislen = rq->data_len;
1717         if (thislen > len)
1718                 thislen = len;
1719
1720         /*
1721          * If DRQ is clear, the command has completed.
1722          */
1723         if ((stat & DRQ_STAT) == 0) {
1724                 spin_lock_irqsave(&ide_lock, flags);
1725                 if (__blk_end_request(rq, 0, rq->data_len))
1726                         BUG();
1727                 HWGROUP(drive)->rq = NULL;
1728                 spin_unlock_irqrestore(&ide_lock, flags);
1729
1730                 return ide_stopped;
1731         }
1732
1733         /*
1734          * check which way to transfer data
1735          */
1736         if (rq_data_dir(rq) == WRITE) {
1737                 /*
1738                  * write to drive
1739                  */
1740                 if (cdrom_write_check_ireason(drive, len, ireason))
1741                         return ide_stopped;
1742
1743                 xferfunc = HWIF(drive)->atapi_output_bytes;
1744         } else  {
1745                 /*
1746                  * read from drive
1747                  */
1748                 if (cdrom_read_check_ireason(drive, len, ireason))
1749                         return ide_stopped;
1750
1751                 xferfunc = HWIF(drive)->atapi_input_bytes;
1752         }
1753
1754         /*
1755          * transfer data
1756          */
1757         while (thislen > 0) {
1758                 int blen = blen = rq->data_len;
1759                 char *ptr = rq->data;
1760
1761                 /*
1762                  * bio backed?
1763                  */
1764                 if (rq->bio) {
1765                         ptr = bio_data(rq->bio);
1766                         blen = bio_iovec(rq->bio)->bv_len;
1767                 }
1768
1769                 if (!ptr) {
1770                         printk(KERN_ERR "%s: confused, missing data\n", drive->name);
1771                         break;
1772                 }
1773
1774                 if (blen > thislen)
1775                         blen = thislen;
1776
1777                 xferfunc(drive, ptr, blen);
1778
1779                 thislen -= blen;
1780                 len -= blen;
1781                 rq->data_len -= blen;
1782
1783                 if (rq->bio)
1784                         /*
1785                          * The request can't be completed until DRQ is cleared.
1786                          * So complete the data, but don't complete the request
1787                          * using the dummy function for the callback feature
1788                          * of blk_end_request_callback().
1789                          */
1790                         blk_end_request_callback(rq, 0, blen,
1791                                                  cdrom_newpc_intr_dummy_cb);
1792                 else
1793                         rq->data += blen;
1794         }
1795
1796         /*
1797          * pad, if necessary
1798          */
1799         if (len > 0) {
1800                 while (len > 0) {
1801                         int pad = 0;
1802
1803                         xferfunc(drive, &pad, sizeof(pad));
1804                         len -= sizeof(pad);
1805                 }
1806         }
1807
1808         BUG_ON(HWGROUP(drive)->handler != NULL);
1809
1810         ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, NULL);
1811         return ide_started;
1812 }
1813
1814 static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
1815 {
1816         int stat, ireason, len, sectors_to_transfer, uptodate;
1817         struct cdrom_info *info = drive->driver_data;
1818         int dma_error = 0, dma = info->dma;
1819         u8 lowcyl = 0, highcyl = 0;
1820
1821         struct request *rq = HWGROUP(drive)->rq;
1822
1823         /* Check for errors. */
1824         if (dma) {
1825                 info->dma = 0;
1826                 dma_error = HWIF(drive)->ide_dma_end(drive);
1827                 if (dma_error) {
1828                         printk(KERN_ERR "%s: DMA write error\n", drive->name);
1829                         ide_dma_off(drive);
1830                 }
1831         }
1832
1833         if (cdrom_decode_status(drive, 0, &stat))
1834                 return ide_stopped;
1835
1836         /*
1837          * using dma, transfer is complete now
1838          */
1839         if (dma) {
1840                 if (dma_error)
1841                         return ide_error(drive, "dma error", stat);
1842
1843                 ide_end_request(drive, 1, rq->nr_sectors);
1844                 return ide_stopped;
1845         }
1846
1847         /* Read the interrupt reason and the transfer length. */
1848         ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1849         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1850         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1851
1852         len = lowcyl + (256 * highcyl);
1853
1854         /* If DRQ is clear, the command has completed. */
1855         if ((stat & DRQ_STAT) == 0) {
1856                 /* If we're not done writing, complain.
1857                  * Otherwise, complete the command normally.
1858                  */
1859                 uptodate = 1;
1860                 if (rq->current_nr_sectors > 0) {
1861                         printk(KERN_ERR "%s: %s: data underrun (%d blocks)\n",
1862                                         drive->name, __FUNCTION__,
1863                                         rq->current_nr_sectors);
1864                         uptodate = 0;
1865                 }
1866                 cdrom_end_request(drive, uptodate);
1867                 return ide_stopped;
1868         }
1869
1870         /* Check that the drive is expecting to do the same thing we are. */
1871         if (cdrom_write_check_ireason(drive, len, ireason))
1872                 return ide_stopped;
1873
1874         sectors_to_transfer = len / SECTOR_SIZE;
1875
1876         /*
1877          * now loop and write out the data
1878          */
1879         while (sectors_to_transfer > 0) {
1880                 int this_transfer;
1881
1882                 if (!rq->current_nr_sectors) {
1883                         printk(KERN_ERR "%s: %s: confused, missing data\n",
1884                                         drive->name, __FUNCTION__);
1885                         break;
1886                 }
1887
1888                 /*
1889                  * Figure out how many sectors we can transfer
1890                  */
1891                 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors);
1892
1893                 while (this_transfer > 0) {
1894                         HWIF(drive)->atapi_output_bytes(drive, rq->buffer, SECTOR_SIZE);
1895                         rq->buffer += SECTOR_SIZE;
1896                         --rq->nr_sectors;
1897                         --rq->current_nr_sectors;
1898                         ++rq->sector;
1899                         --this_transfer;
1900                         --sectors_to_transfer;
1901                 }
1902
1903                 /*
1904                  * current buffer complete, move on
1905                  */
1906                 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1907                         cdrom_end_request(drive, 1);
1908         }
1909
1910         /* re-arm handler */
1911         ide_set_handler(drive, &cdrom_write_intr, ATAPI_WAIT_PC, NULL);
1912         return ide_started;
1913 }
1914
1915 static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
1916 {
1917         struct request *rq = HWGROUP(drive)->rq;
1918
1919 #if 0   /* the immediate bit */
1920         rq->cmd[1] = 1 << 3;
1921 #endif
1922         rq->timeout = ATAPI_WAIT_PC;
1923
1924         return cdrom_transfer_packet_command(drive, rq, cdrom_write_intr);
1925 }
1926
1927 static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
1928 {
1929         struct cdrom_info *info = drive->driver_data;
1930         struct gendisk *g = info->disk;
1931         unsigned short sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1932
1933         /*
1934          * writes *must* be hardware frame aligned
1935          */
1936         if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1937             (rq->sector & (sectors_per_frame - 1))) {
1938                 cdrom_end_request(drive, 0);
1939                 return ide_stopped;
1940         }
1941
1942         /*
1943          * disk has become write protected
1944          */
1945         if (g->policy) {
1946                 cdrom_end_request(drive, 0);
1947                 return ide_stopped;
1948         }
1949
1950         info->nsectors_buffered = 0;
1951
1952         /* use dma, if possible. we don't need to check more, since we
1953          * know that the transfer is always (at least!) frame aligned */
1954         info->dma = drive->using_dma ? 1 : 0;
1955
1956         info->devinfo.media_written = 1;
1957
1958         /* Start sending the write request to the drive. */
1959         return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
1960 }
1961
1962 static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1963 {
1964         struct request *rq = HWGROUP(drive)->rq;
1965
1966         if (!rq->timeout)
1967                 rq->timeout = ATAPI_WAIT_PC;
1968
1969         return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1970 }
1971
1972 static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1973 {
1974         struct cdrom_info *info = drive->driver_data;
1975
1976         rq->cmd_flags |= REQ_QUIET;
1977
1978         info->dma = 0;
1979
1980         /*
1981          * sg request
1982          */
1983         if (rq->bio) {
1984                 int mask = drive->queue->dma_alignment;
1985                 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
1986
1987                 info->dma = drive->using_dma;
1988
1989                 /*
1990                  * check if dma is safe
1991                  *
1992                  * NOTE! The "len" and "addr" checks should possibly have
1993                  * separate masks.
1994                  */
1995                 if ((rq->data_len & 15) || (addr & mask))
1996                         info->dma = 0;
1997         }
1998
1999         /* Start sending the command to the drive. */
2000         return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
2001 }
2002
2003 /****************************************************************************
2004  * cdrom driver request routine.
2005  */
2006 static ide_startstop_t
2007 ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
2008 {
2009         ide_startstop_t action;
2010         struct cdrom_info *info = drive->driver_data;
2011
2012         if (blk_fs_request(rq)) {
2013                 if (CDROM_CONFIG_FLAGS(drive)->seeking) {
2014                         unsigned long elapsed = jiffies - info->start_seek;
2015                         int stat = HWIF(drive)->INB(IDE_STATUS_REG);
2016
2017                         if ((stat & SEEK_STAT) != SEEK_STAT) {
2018                                 if (elapsed < IDECD_SEEK_TIMEOUT) {
2019                                         ide_stall_queue(drive, IDECD_SEEK_TIMER);
2020                                         return ide_stopped;
2021                                 }
2022                                 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
2023                         }
2024                         CDROM_CONFIG_FLAGS(drive)->seeking = 0;
2025                 }
2026                 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
2027                         action = cdrom_start_seek(drive, block);
2028                 } else {
2029                         if (rq_data_dir(rq) == READ)
2030                                 action = cdrom_start_read(drive, block);
2031                         else
2032                                 action = cdrom_start_write(drive, rq);
2033                 }
2034                 info->last_block = block;
2035                 return action;
2036         } else if (rq->cmd_type == REQ_TYPE_SENSE ||
2037                    rq->cmd_type == REQ_TYPE_ATA_PC) {
2038                 return cdrom_do_packet_command(drive);
2039         } else if (blk_pc_request(rq)) {
2040                 return cdrom_do_block_pc(drive, rq);
2041         } else if (blk_special_request(rq)) {
2042                 /*
2043                  * right now this can only be a reset...
2044                  */
2045                 cdrom_end_request(drive, 1);
2046                 return ide_stopped;
2047         }
2048
2049         blk_dump_rq_flags(rq, "ide-cd bad flags");
2050         cdrom_end_request(drive, 0);
2051         return ide_stopped;
2052 }
2053
2054
2055
2056 /****************************************************************************
2057  * Ioctl handling.
2058  *
2059  * Routines which queue packet commands take as a final argument a pointer
2060  * to a request_sense struct.  If execution of the command results
2061  * in an error with a CHECK CONDITION status, this structure will be filled
2062  * with the results of the subsequent request sense command.  The pointer
2063  * can also be NULL, in which case no sense information is returned.
2064  */
2065
2066 #if ! STANDARD_ATAPI
2067 static inline
2068 int bin2bcd (int x)
2069 {
2070         return (x%10) | ((x/10) << 4);
2071 }
2072
2073
2074 static inline
2075 int bcd2bin (int x)
2076 {
2077         return (x >> 4) * 10 + (x & 0x0f);
2078 }
2079
2080 static
2081 void msf_from_bcd (struct atapi_msf *msf)
2082 {
2083         msf->minute = bcd2bin (msf->minute);
2084         msf->second = bcd2bin (msf->second);
2085         msf->frame  = bcd2bin (msf->frame);
2086 }
2087
2088 #endif /* not STANDARD_ATAPI */
2089
2090
2091 static inline
2092 void lba_to_msf (int lba, byte *m, byte *s, byte *f)
2093 {
2094         lba += CD_MSF_OFFSET;
2095         lba &= 0xffffff;  /* negative lbas use only 24 bits */
2096         *m = lba / (CD_SECS * CD_FRAMES);
2097         lba %= (CD_SECS * CD_FRAMES);
2098         *s = lba / CD_FRAMES;
2099         *f = lba % CD_FRAMES;
2100 }
2101
2102
2103 static inline
2104 int msf_to_lba (byte m, byte s, byte f)
2105 {
2106         return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
2107 }
2108
2109 static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
2110 {
2111         struct request req;
2112         struct cdrom_info *info = drive->driver_data;
2113         struct cdrom_device_info *cdi = &info->devinfo;
2114
2115         cdrom_prepare_request(drive, &req);
2116
2117         req.sense = sense;
2118         req.cmd[0] = GPCMD_TEST_UNIT_READY;
2119         req.cmd_flags |= REQ_QUIET;
2120
2121 #if ! STANDARD_ATAPI
2122         /* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
2123            switch CDs instead of supporting the LOAD_UNLOAD opcode   */
2124
2125         req.cmd[7] = cdi->sanyo_slot % 3;
2126 #endif /* not STANDARD_ATAPI */
2127
2128         return cdrom_queue_packet_command(drive, &req);
2129 }
2130
2131
2132 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
2133 static int
2134 cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
2135 {
2136         struct request_sense my_sense;
2137         struct request req;
2138         int stat;
2139
2140         if (sense == NULL)
2141                 sense = &my_sense;
2142
2143         /* If the drive cannot lock the door, just pretend. */
2144         if (CDROM_CONFIG_FLAGS(drive)->no_doorlock) {
2145                 stat = 0;
2146         } else {
2147                 cdrom_prepare_request(drive, &req);
2148                 req.sense = sense;
2149                 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
2150                 req.cmd[4] = lockflag ? 1 : 0;
2151                 stat = cdrom_queue_packet_command(drive, &req);
2152         }
2153
2154         /* If we got an illegal field error, the drive
2155            probably cannot lock the door. */
2156         if (stat != 0 &&
2157             sense->sense_key == ILLEGAL_REQUEST &&
2158             (sense->asc == 0x24 || sense->asc == 0x20)) {
2159                 printk (KERN_ERR "%s: door locking not supported\n",
2160                         drive->name);
2161                 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2162                 stat = 0;
2163         }
2164
2165         /* no medium, that's alright. */
2166         if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
2167                 stat = 0;
2168
2169         if (stat == 0)
2170                 CDROM_STATE_FLAGS(drive)->door_locked = lockflag;
2171
2172         return stat;
2173 }
2174
2175
2176 /* Eject the disk if EJECTFLAG is 0.
2177    If EJECTFLAG is 1, try to reload the disk. */
2178 static int cdrom_eject(ide_drive_t *drive, int ejectflag,
2179                        struct request_sense *sense)
2180 {
2181         struct request req;
2182         char loej = 0x02;
2183
2184         if (CDROM_CONFIG_FLAGS(drive)->no_eject && !ejectflag)
2185                 return -EDRIVE_CANT_DO_THIS;
2186
2187         /* reload fails on some drives, if the tray is locked */
2188         if (CDROM_STATE_FLAGS(drive)->door_locked && ejectflag)
2189                 return 0;
2190
2191         cdrom_prepare_request(drive, &req);
2192
2193         /* only tell drive to close tray if open, if it can do that */
2194         if (ejectflag && !CDROM_CONFIG_FLAGS(drive)->close_tray)
2195                 loej = 0;
2196
2197         req.sense = sense;
2198         req.cmd[0] = GPCMD_START_STOP_UNIT;
2199         req.cmd[4] = loej | (ejectflag != 0);
2200         return cdrom_queue_packet_command(drive, &req);
2201 }
2202
2203 static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
2204                                unsigned long *sectors_per_frame,
2205                                struct request_sense *sense)
2206 {
2207         struct {
2208                 __u32 lba;
2209                 __u32 blocklen;
2210         } capbuf;
2211
2212         int stat;
2213         struct request req;
2214
2215         cdrom_prepare_request(drive, &req);
2216
2217         req.sense = sense;
2218         req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
2219         req.data = (char *)&capbuf;
2220         req.data_len = sizeof(capbuf);
2221         req.cmd_flags |= REQ_QUIET;
2222
2223         stat = cdrom_queue_packet_command(drive, &req);
2224         if (stat == 0) {
2225                 *capacity = 1 + be32_to_cpu(capbuf.lba);
2226                 *sectors_per_frame =
2227                         be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
2228         }
2229
2230         return stat;
2231 }
2232
2233 static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
2234                                 int format, char *buf, int buflen,
2235                                 struct request_sense *sense)
2236 {
2237         struct request req;
2238
2239         cdrom_prepare_request(drive, &req);
2240
2241         req.sense = sense;
2242         req.data =  buf;
2243         req.data_len = buflen;
2244         req.cmd_flags |= REQ_QUIET;
2245         req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
2246         req.cmd[6] = trackno;
2247         req.cmd[7] = (buflen >> 8);
2248         req.cmd[8] = (buflen & 0xff);
2249         req.cmd[9] = (format << 6);
2250
2251         if (msf_flag)
2252                 req.cmd[1] = 2;
2253
2254         return cdrom_queue_packet_command(drive, &req);
2255 }
2256
2257
2258 /* Try to read the entire TOC for the disk into our internal buffer. */
2259 static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2260 {
2261         int stat, ntracks, i;
2262         struct cdrom_info *info = drive->driver_data;
2263         struct cdrom_device_info *cdi = &info->devinfo;
2264         struct atapi_toc *toc = info->toc;
2265         struct {
2266                 struct atapi_toc_header hdr;
2267                 struct atapi_toc_entry  ent;
2268         } ms_tmp;
2269         long last_written;
2270         unsigned long sectors_per_frame = SECTORS_PER_FRAME;
2271
2272         if (toc == NULL) {
2273                 /* Try to allocate space. */
2274                 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
2275                 if (toc == NULL) {
2276                         printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
2277                         return -ENOMEM;
2278                 }
2279                 info->toc = toc;
2280         }
2281
2282         /* Check to see if the existing data is still valid.
2283            If it is, just return. */
2284         (void) cdrom_check_status(drive, sense);
2285
2286         if (CDROM_STATE_FLAGS(drive)->toc_valid)
2287                 return 0;
2288
2289         /* Try to get the total cdrom capacity and sector size. */
2290         stat = cdrom_read_capacity(drive, &toc->capacity, &sectors_per_frame,
2291                                    sense);
2292         if (stat)
2293                 toc->capacity = 0x1fffff;
2294
2295         set_capacity(info->disk, toc->capacity * sectors_per_frame);
2296         /* Save a private copy of te TOC capacity for error handling */
2297         drive->probed_capacity = toc->capacity * sectors_per_frame;
2298
2299         blk_queue_hardsect_size(drive->queue,
2300                                 sectors_per_frame << SECTOR_BITS);
2301
2302         /* First read just the header, so we know how long the TOC is. */
2303         stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
2304                                     sizeof(struct atapi_toc_header), sense);
2305         if (stat)
2306                 return stat;
2307
2308 #if ! STANDARD_ATAPI
2309         if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2310                 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2311                 toc->hdr.last_track  = bcd2bin(toc->hdr.last_track);
2312         }
2313 #endif  /* not STANDARD_ATAPI */
2314
2315         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2316         if (ntracks <= 0)
2317                 return -EIO;
2318         if (ntracks > MAX_TRACKS)
2319                 ntracks = MAX_TRACKS;
2320
2321         /* Now read the whole schmeer. */
2322         stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
2323                                   (char *)&toc->hdr,
2324                                    sizeof(struct atapi_toc_header) +
2325                                    (ntracks + 1) *
2326                                    sizeof(struct atapi_toc_entry), sense);
2327
2328         if (stat && toc->hdr.first_track > 1) {
2329                 /* Cds with CDI tracks only don't have any TOC entries,
2330                    despite of this the returned values are
2331                    first_track == last_track = number of CDI tracks + 1,
2332                    so that this case is indistinguishable from the same
2333                    layout plus an additional audio track.
2334                    If we get an error for the regular case, we assume
2335                    a CDI without additional audio tracks. In this case
2336                    the readable TOC is empty (CDI tracks are not included)
2337                    and only holds the Leadout entry. Heiko Eißfeldt */
2338                 ntracks = 0;
2339                 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
2340                                            (char *)&toc->hdr,
2341                                            sizeof(struct atapi_toc_header) +
2342                                            (ntracks + 1) *
2343                                            sizeof(struct atapi_toc_entry),
2344                                            sense);
2345                 if (stat) {
2346                         return stat;
2347                 }
2348 #if ! STANDARD_ATAPI
2349                 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2350                         toc->hdr.first_track = bin2bcd(CDROM_LEADOUT);
2351                         toc->hdr.last_track = bin2bcd(CDROM_LEADOUT);
2352                 } else
2353 #endif  /* not STANDARD_ATAPI */
2354                 {
2355                         toc->hdr.first_track = CDROM_LEADOUT;
2356                         toc->hdr.last_track = CDROM_LEADOUT;
2357                 }
2358         }
2359
2360         if (stat)
2361                 return stat;
2362
2363         toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
2364
2365 #if ! STANDARD_ATAPI
2366         if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2367                 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2368                 toc->hdr.last_track  = bcd2bin(toc->hdr.last_track);
2369         }
2370 #endif  /* not STANDARD_ATAPI */
2371
2372         for (i=0; i<=ntracks; i++) {
2373 #if ! STANDARD_ATAPI
2374                 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2375                         if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd)
2376                                 toc->ent[i].track = bcd2bin(toc->ent[i].track);
2377                         msf_from_bcd(&toc->ent[i].addr.msf);
2378                 }
2379 #endif  /* not STANDARD_ATAPI */
2380                 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
2381                                                    toc->ent[i].addr.msf.second,
2382                                                    toc->ent[i].addr.msf.frame);
2383         }
2384
2385         /* Read the multisession information. */
2386         if (toc->hdr.first_track != CDROM_LEADOUT) {
2387                 /* Read the multisession information. */
2388                 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
2389                                            sizeof(ms_tmp), sense);
2390                 if (stat)
2391                         return stat;
2392
2393                 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
2394         } else {
2395                 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
2396                 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
2397         }
2398
2399 #if ! STANDARD_ATAPI
2400         if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2401                 /* Re-read multisession information using MSF format */
2402                 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
2403                                            sizeof(ms_tmp), sense);
2404                 if (stat)
2405                         return stat;
2406
2407                 msf_from_bcd (&ms_tmp.ent.addr.msf);
2408                 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
2409                                                    ms_tmp.ent.addr.msf.second,
2410                                                    ms_tmp.ent.addr.msf.frame);
2411         }
2412 #endif  /* not STANDARD_ATAPI */
2413
2414         toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
2415
2416         /* Now try to get the total cdrom capacity. */
2417         stat = cdrom_get_last_written(cdi, &last_written);
2418         if (!stat && (last_written > toc->capacity)) {
2419                 toc->capacity = last_written;
2420                 set_capacity(info->disk, toc->capacity * sectors_per_frame);
2421                 drive->probed_capacity = toc->capacity * sectors_per_frame;
2422         }
2423
2424         /* Remember that we've read this stuff. */
2425         CDROM_STATE_FLAGS(drive)->toc_valid = 1;
2426
2427         return 0;
2428 }
2429
2430
2431 static int cdrom_read_subchannel(ide_drive_t *drive, int format, char *buf,
2432                                  int buflen, struct request_sense *sense)
2433 {
2434         struct request req;
2435
2436         cdrom_prepare_request(drive, &req);
2437
2438         req.sense = sense;
2439         req.data = buf;
2440         req.data_len = buflen;
2441         req.cmd[0] = GPCMD_READ_SUBCHANNEL;
2442         req.cmd[1] = 2;     /* MSF addressing */
2443         req.cmd[2] = 0x40;  /* request subQ data */
2444         req.cmd[3] = format;
2445         req.cmd[7] = (buflen >> 8);
2446         req.cmd[8] = (buflen & 0xff);
2447         return cdrom_queue_packet_command(drive, &req);
2448 }
2449
2450 /* ATAPI cdrom drives are free to select the speed you request or any slower
2451    rate :-( Requesting too fast a speed will _not_ produce an error. */
2452 static int cdrom_select_speed(ide_drive_t *drive, int speed,
2453                               struct request_sense *sense)
2454 {
2455         struct request req;
2456         cdrom_prepare_request(drive, &req);
2457
2458         req.sense = sense;
2459         if (speed == 0)
2460                 speed = 0xffff; /* set to max */
2461         else
2462                 speed *= 177;   /* Nx to kbytes/s */
2463
2464         req.cmd[0] = GPCMD_SET_SPEED;
2465         /* Read Drive speed in kbytes/second MSB */
2466         req.cmd[2] = (speed >> 8) & 0xff;
2467         /* Read Drive speed in kbytes/second LSB */
2468         req.cmd[3] = speed & 0xff;
2469         if (CDROM_CONFIG_FLAGS(drive)->cd_r ||
2470             CDROM_CONFIG_FLAGS(drive)->cd_rw ||
2471             CDROM_CONFIG_FLAGS(drive)->dvd_r) {
2472                 /* Write Drive speed in kbytes/second MSB */
2473                 req.cmd[4] = (speed >> 8) & 0xff;
2474                 /* Write Drive speed in kbytes/second LSB */
2475                 req.cmd[5] = speed & 0xff;
2476        }
2477
2478         return cdrom_queue_packet_command(drive, &req);
2479 }
2480
2481 static int cdrom_play_audio(ide_drive_t *drive, int lba_start, int lba_end)
2482 {
2483         struct request_sense sense;
2484         struct request req;
2485
2486         cdrom_prepare_request(drive, &req);
2487
2488         req.sense = &sense;
2489         req.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2490         lba_to_msf(lba_start, &req.cmd[3], &req.cmd[4], &req.cmd[5]);
2491         lba_to_msf(lba_end-1, &req.cmd[6], &req.cmd[7], &req.cmd[8]);
2492
2493         return cdrom_queue_packet_command(drive, &req);
2494 }
2495
2496 static int cdrom_get_toc_entry(ide_drive_t *drive, int track,
2497                                 struct atapi_toc_entry **ent)
2498 {
2499         struct cdrom_info *info = drive->driver_data;
2500         struct atapi_toc *toc = info->toc;
2501         int ntracks;
2502
2503         /*
2504          * don't serve cached data, if the toc isn't valid
2505          */
2506         if (!CDROM_STATE_FLAGS(drive)->toc_valid)
2507                 return -EINVAL;
2508
2509         /* Check validity of requested track number. */
2510         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2511         if (toc->hdr.first_track == CDROM_LEADOUT) ntracks = 0;
2512         if (track == CDROM_LEADOUT)
2513                 *ent = &toc->ent[ntracks];
2514         else if (track < toc->hdr.first_track ||
2515                  track > toc->hdr.last_track)
2516                 return -EINVAL;
2517         else
2518                 *ent = &toc->ent[track - toc->hdr.first_track];
2519
2520         return 0;
2521 }
2522
2523 /* the generic packet interface to cdrom.c */
2524 static int ide_cdrom_packet(struct cdrom_device_info *cdi,
2525                             struct packet_command *cgc)
2526 {
2527         struct request req;
2528         ide_drive_t *drive = cdi->handle;
2529
2530         if (cgc->timeout <= 0)
2531                 cgc->timeout = ATAPI_WAIT_PC;
2532
2533         /* here we queue the commands from the uniform CD-ROM
2534            layer. the packet must be complete, as we do not
2535            touch it at all. */
2536         cdrom_prepare_request(drive, &req);
2537         memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
2538         if (cgc->sense)
2539                 memset(cgc->sense, 0, sizeof(struct request_sense));
2540         req.data = cgc->buffer;
2541         req.data_len = cgc->buflen;
2542         req.timeout = cgc->timeout;
2543
2544         if (cgc->quiet)
2545                 req.cmd_flags |= REQ_QUIET;
2546
2547         req.sense = cgc->sense;
2548         cgc->stat = cdrom_queue_packet_command(drive, &req);
2549         if (!cgc->stat)
2550                 cgc->buflen -= req.data_len;
2551         return cgc->stat;
2552 }
2553
2554 static
2555 int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
2556                            unsigned int cmd, void *arg)
2557
2558 {
2559         ide_drive_t *drive = cdi->handle;
2560         struct cdrom_info *info = drive->driver_data;
2561         int stat;
2562
2563         switch (cmd) {
2564         /*
2565          * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
2566          * atapi doesn't support it
2567          */
2568         case CDROMPLAYTRKIND: {
2569                 unsigned long lba_start, lba_end;
2570                 struct cdrom_ti *ti = arg;
2571                 struct atapi_toc_entry *first_toc, *last_toc;
2572
2573                 stat = cdrom_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
2574                 if (stat)
2575                         return stat;
2576
2577                 stat = cdrom_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
2578                 if (stat)
2579                         return stat;
2580
2581                 if (ti->cdti_trk1 != CDROM_LEADOUT)
2582                         ++last_toc;
2583                 lba_start = first_toc->addr.lba;
2584                 lba_end   = last_toc->addr.lba;
2585
2586                 if (lba_end <= lba_start)
2587                         return -EINVAL;
2588
2589                 return cdrom_play_audio(drive, lba_start, lba_end);
2590         }
2591
2592         case CDROMREADTOCHDR: {
2593                 struct cdrom_tochdr *tochdr = arg;
2594                 struct atapi_toc *toc;
2595
2596                 /* Make sure our saved TOC is valid. */
2597                 stat = cdrom_read_toc(drive, NULL);
2598                 if (stat)
2599                         return stat;
2600
2601                 toc = info->toc;
2602                 tochdr->cdth_trk0 = toc->hdr.first_track;
2603                 tochdr->cdth_trk1 = toc->hdr.last_track;
2604
2605                 return 0;
2606         }
2607
2608         case CDROMREADTOCENTRY: {
2609                 struct cdrom_tocentry *tocentry = arg;
2610                 struct atapi_toc_entry *toce;
2611
2612                 stat = cdrom_get_toc_entry(drive, tocentry->cdte_track, &toce);
2613                 if (stat)
2614                         return stat;
2615
2616                 tocentry->cdte_ctrl = toce->control;
2617                 tocentry->cdte_adr  = toce->adr;
2618                 if (tocentry->cdte_format == CDROM_MSF) {
2619                         lba_to_msf (toce->addr.lba,
2620                                    &tocentry->cdte_addr.msf.minute,
2621                                    &tocentry->cdte_addr.msf.second,
2622                                    &tocentry->cdte_addr.msf.frame);
2623                 } else
2624                         tocentry->cdte_addr.lba = toce->addr.lba;
2625
2626                 return 0;
2627         }
2628
2629         default:
2630                 return -EINVAL;
2631         }
2632 }
2633
2634 static
2635 int ide_cdrom_reset (struct cdrom_device_info *cdi)
2636 {
2637         ide_drive_t *drive = cdi->handle;
2638         struct request_sense sense;
2639         struct request req;
2640         int ret;
2641
2642         cdrom_prepare_request(drive, &req);
2643         req.cmd_type = REQ_TYPE_SPECIAL;
2644         req.cmd_flags = REQ_QUIET;
2645         ret = ide_do_drive_cmd(drive, &req, ide_wait);
2646
2647         /*
2648          * A reset will unlock the door. If it was previously locked,
2649          * lock it again.
2650          */
2651         if (CDROM_STATE_FLAGS(drive)->door_locked)
2652                 (void) cdrom_lockdoor(drive, 1, &sense);
2653
2654         return ret;
2655 }
2656
2657
2658 static
2659 int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
2660 {
2661         ide_drive_t *drive = cdi->handle;
2662         struct request_sense sense;
2663
2664         if (position) {
2665                 int stat = cdrom_lockdoor(drive, 0, &sense);
2666                 if (stat)
2667                         return stat;
2668         }
2669
2670         return cdrom_eject(drive, !position, &sense);
2671 }
2672
2673 static
2674 int ide_cdrom_lock_door (struct cdrom_device_info *cdi, int lock)
2675 {
2676         ide_drive_t *drive = cdi->handle;
2677         return cdrom_lockdoor(drive, lock, NULL);
2678 }
2679
2680 static
2681 int ide_cdrom_get_capabilities(ide_drive_t *drive, struct atapi_capabilities_page *cap)
2682 {
2683         struct cdrom_info *info = drive->driver_data;
2684         struct cdrom_device_info *cdi = &info->devinfo;
2685         struct packet_command cgc;
2686         int stat, attempts = 3, size = sizeof(*cap);
2687
2688         /*
2689          * ACER50 (and others?) require the full spec length mode sense
2690          * page capabilities size, but older drives break.
2691          */
2692         if (!(!strcmp(drive->id->model, "ATAPI CD ROM DRIVE 50X MAX") ||
2693             !strcmp(drive->id->model, "WPI CDS-32X")))
2694                 size -= sizeof(cap->pad);
2695
2696         init_cdrom_command(&cgc, cap, size, CGC_DATA_UNKNOWN);
2697         do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2698                 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
2699                 if (!stat)
2700                         break;
2701         } while (--attempts);
2702         return stat;
2703 }
2704
2705 static
2706 void ide_cdrom_update_speed (ide_drive_t *drive, struct atapi_capabilities_page *cap)
2707 {
2708         /* The ACER/AOpen 24X cdrom has the speed fields byte-swapped */
2709         if (!drive->id->model[0] &&
2710             !strncmp(drive->id->fw_rev, "241N", 4)) {
2711                 CDROM_STATE_FLAGS(drive)->current_speed  =
2712                         (le16_to_cpu(cap->curspeed) + (176/2)) / 176;
2713                 CDROM_CONFIG_FLAGS(drive)->max_speed =
2714                         (le16_to_cpu(cap->maxspeed) + (176/2)) / 176;
2715         } else {
2716                 CDROM_STATE_FLAGS(drive)->current_speed  =
2717                         (be16_to_cpu(cap->curspeed) + (176/2)) / 176;
2718                 CDROM_CONFIG_FLAGS(drive)->max_speed =
2719                         (be16_to_cpu(cap->maxspeed) + (176/2)) / 176;
2720         }
2721 }
2722
2723 static
2724 int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
2725 {
2726         ide_drive_t *drive = cdi->handle;
2727         struct request_sense sense;
2728         struct atapi_capabilities_page cap;
2729         int stat;
2730
2731         if ((stat = cdrom_select_speed(drive, speed, &sense)) < 0)
2732                 return stat;
2733
2734         if (!ide_cdrom_get_capabilities(drive, &cap)) {
2735                 ide_cdrom_update_speed(drive, &cap);
2736                 cdi->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2737         }
2738         return 0;
2739 }
2740
2741 /*
2742  * add logic to try GET_EVENT command first to check for media and tray
2743  * status. this should be supported by newer cd-r/w and all DVD etc
2744  * drives
2745  */
2746 static
2747 int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
2748 {
2749         ide_drive_t *drive = cdi->handle;
2750         struct media_event_desc med;
2751         struct request_sense sense;
2752         int stat;
2753
2754         if (slot_nr != CDSL_CURRENT)
2755                 return -EINVAL;
2756
2757         stat = cdrom_check_status(drive, &sense);
2758         if (!stat || sense.sense_key == UNIT_ATTENTION)
2759                 return CDS_DISC_OK;
2760
2761         if (!cdrom_get_media_event(cdi, &med)) {
2762                 if (med.media_present)
2763                         return CDS_DISC_OK;
2764                 else if (med.door_open)
2765                         return CDS_TRAY_OPEN;
2766                 else
2767                         return CDS_NO_DISC;
2768         }
2769
2770         if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
2771                 return CDS_DISC_OK;
2772
2773         /*
2774          * If not using Mt Fuji extended media tray reports,
2775          * just return TRAY_OPEN since ATAPI doesn't provide
2776          * any other way to detect this...
2777          */
2778         if (sense.sense_key == NOT_READY) {
2779                 if (sense.asc == 0x3a && sense.ascq == 1)
2780                         return CDS_NO_DISC;
2781                 else
2782                         return CDS_TRAY_OPEN;
2783         }
2784         return CDS_DRIVE_NOT_READY;
2785 }
2786
2787 static
2788 int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
2789                                 struct cdrom_multisession *ms_info)
2790 {
2791         struct atapi_toc *toc;
2792         ide_drive_t *drive = cdi->handle;
2793         struct cdrom_info *info = drive->driver_data;
2794         struct request_sense sense;
2795         int ret;
2796
2797         if (!CDROM_STATE_FLAGS(drive)->toc_valid || info->toc == NULL)
2798                 if ((ret = cdrom_read_toc(drive, &sense)))
2799                         return ret;
2800
2801         toc = info->toc;
2802         ms_info->addr.lba = toc->last_session_lba;
2803         ms_info->xa_flag = toc->xa_flag;
2804
2805         return 0;
2806 }
2807
2808 static
2809 int ide_cdrom_get_mcn (struct cdrom_device_info *cdi,
2810                        struct cdrom_mcn *mcn_info)
2811 {
2812         int stat;
2813         char mcnbuf[24];
2814         ide_drive_t *drive = cdi->handle;
2815
2816 /* get MCN */
2817         if ((stat = cdrom_read_subchannel(drive, 2, mcnbuf, sizeof (mcnbuf), NULL)))
2818                 return stat;
2819
2820         memcpy (mcn_info->medium_catalog_number, mcnbuf+9,
2821                 sizeof (mcn_info->medium_catalog_number)-1);
2822         mcn_info->medium_catalog_number[sizeof (mcn_info->medium_catalog_number)-1]
2823                 = '\0';
2824
2825         return 0;
2826 }
2827
2828
2829
2830 /****************************************************************************
2831  * Other driver requests (open, close, check media change).
2832  */
2833
2834 static
2835 int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
2836                                        int slot_nr)
2837 {
2838         ide_drive_t *drive = cdi->handle;
2839         int retval;
2840
2841         if (slot_nr == CDSL_CURRENT) {
2842                 (void) cdrom_check_status(drive, NULL);
2843                 retval = CDROM_STATE_FLAGS(drive)->media_changed;
2844                 CDROM_STATE_FLAGS(drive)->media_changed = 0;
2845                 return retval;
2846         } else {
2847                 return -EINVAL;
2848         }
2849 }
2850
2851
2852 static
2853 int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
2854 {
2855         return 0;
2856 }
2857
2858 /*
2859  * Close down the device.  Invalidate all cached blocks.
2860  */
2861
2862 static
2863 void ide_cdrom_release_real (struct cdrom_device_info *cdi)
2864 {
2865         ide_drive_t *drive = cdi->handle;
2866
2867         if (!cdi->use_count)
2868                 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
2869 }
2870
2871
2872
2873 /****************************************************************************
2874  * Device initialization.
2875  */
2876 static struct cdrom_device_ops ide_cdrom_dops = {
2877         .open                   = ide_cdrom_open_real,
2878         .release                = ide_cdrom_release_real,
2879         .drive_status           = ide_cdrom_drive_status,
2880         .media_changed          = ide_cdrom_check_media_change_real,
2881         .tray_move              = ide_cdrom_tray_move,
2882         .lock_door              = ide_cdrom_lock_door,
2883         .select_speed           = ide_cdrom_select_speed,
2884         .get_last_session       = ide_cdrom_get_last_session,
2885         .get_mcn                = ide_cdrom_get_mcn,
2886         .reset                  = ide_cdrom_reset,
2887         .audio_ioctl            = ide_cdrom_audio_ioctl,
2888         .capability             = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
2889                                 CDC_SELECT_SPEED | CDC_SELECT_DISC |
2890                                 CDC_MULTI_SESSION | CDC_MCN |
2891                                 CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO | CDC_RESET |
2892                                 CDC_DRIVE_STATUS | CDC_CD_R |
2893                                 CDC_CD_RW | CDC_DVD | CDC_DVD_R| CDC_DVD_RAM |
2894                                 CDC_GENERIC_PACKET | CDC_MO_DRIVE | CDC_MRW |
2895                                 CDC_MRW_W | CDC_RAM,
2896         .generic_packet         = ide_cdrom_packet,
2897 };
2898
2899 static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2900 {
2901         struct cdrom_info *info = drive->driver_data;
2902         struct cdrom_device_info *devinfo = &info->devinfo;
2903
2904         devinfo->ops = &ide_cdrom_dops;
2905         devinfo->mask = 0;
2906         devinfo->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2907         devinfo->capacity = nslots;
2908         devinfo->handle = drive;
2909         strcpy(devinfo->name, drive->name);
2910
2911         /* set capability mask to match the probe. */
2912         if (!CDROM_CONFIG_FLAGS(drive)->cd_r)
2913                 devinfo->mask |= CDC_CD_R;
2914         if (!CDROM_CONFIG_FLAGS(drive)->cd_rw)
2915                 devinfo->mask |= CDC_CD_RW;
2916         if (!CDROM_CONFIG_FLAGS(drive)->dvd)
2917                 devinfo->mask |= CDC_DVD;
2918         if (!CDROM_CONFIG_FLAGS(drive)->dvd_r)
2919                 devinfo->mask |= CDC_DVD_R;
2920         if (!CDROM_CONFIG_FLAGS(drive)->dvd_ram)
2921                 devinfo->mask |= CDC_DVD_RAM;
2922         if (!CDROM_CONFIG_FLAGS(drive)->is_changer)
2923                 devinfo->mask |= CDC_SELECT_DISC;
2924         if (!CDROM_CONFIG_FLAGS(drive)->audio_play)
2925                 devinfo->mask |= CDC_PLAY_AUDIO;
2926         if (!CDROM_CONFIG_FLAGS(drive)->close_tray)
2927                 devinfo->mask |= CDC_CLOSE_TRAY;
2928         if (!CDROM_CONFIG_FLAGS(drive)->mo_drive)
2929                 devinfo->mask |= CDC_MO_DRIVE;
2930         if (!CDROM_CONFIG_FLAGS(drive)->ram)
2931                 devinfo->mask |= CDC_RAM;
2932
2933         if (CDROM_CONFIG_FLAGS(drive)->no_speed_select)
2934                 devinfo->mask |= CDC_SELECT_SPEED;
2935
2936         devinfo->disk = info->disk;
2937         return register_cdrom(devinfo);
2938 }
2939
2940 static
2941 int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2942 {
2943         struct cdrom_info *info = drive->driver_data;
2944         struct cdrom_device_info *cdi = &info->devinfo;
2945         struct atapi_capabilities_page cap;
2946         int nslots = 1;
2947
2948         if (drive->media == ide_optical) {
2949                 CDROM_CONFIG_FLAGS(drive)->mo_drive = 1;
2950                 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2951                 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
2952                 return nslots;
2953         }
2954
2955         if (CDROM_CONFIG_FLAGS(drive)->nec260 ||
2956             !strcmp(drive->id->model,"STINGRAY 8422 IDE 8X CD-ROM 7-27-95")) {
2957                 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2958                 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2959                 return nslots;
2960         }
2961
2962         /*
2963          * we have to cheat a little here. the packet will eventually
2964          * be queued with ide_cdrom_packet(), which extracts the
2965          * drive from cdi->handle. Since this device hasn't been
2966          * registered with the Uniform layer yet, it can't do this.
2967          * Same goes for cdi->ops.
2968          */
2969         cdi->handle = drive;
2970         cdi->ops = &ide_cdrom_dops;
2971
2972         if (ide_cdrom_get_capabilities(drive, &cap))
2973                 return 0;
2974
2975         if (cap.lock == 0)
2976                 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2977         if (cap.eject)
2978                 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2979         if (cap.cd_r_write)
2980                 CDROM_CONFIG_FLAGS(drive)->cd_r = 1;
2981         if (cap.cd_rw_write) {
2982                 CDROM_CONFIG_FLAGS(drive)->cd_rw = 1;
2983                 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2984         }
2985         if (cap.test_write)
2986                 CDROM_CONFIG_FLAGS(drive)->test_write = 1;
2987         if (cap.dvd_ram_read || cap.dvd_r_read || cap.dvd_rom)
2988                 CDROM_CONFIG_FLAGS(drive)->dvd = 1;
2989         if (cap.dvd_ram_write) {
2990                 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 1;
2991                 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2992         }
2993         if (cap.dvd_r_write)
2994                 CDROM_CONFIG_FLAGS(drive)->dvd_r = 1;
2995         if (cap.audio_play)
2996                 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2997         if (cap.mechtype == mechtype_caddy || cap.mechtype == mechtype_popup)
2998                 CDROM_CONFIG_FLAGS(drive)->close_tray = 0;
2999
3000         /* Some drives used by Apple don't advertise audio play
3001          * but they do support reading TOC & audio datas
3002          */
3003         if (strcmp(drive->id->model, "MATSHITADVD-ROM SR-8187") == 0 ||
3004             strcmp(drive->id->model, "MATSHITADVD-ROM SR-8186") == 0 ||
3005             strcmp(drive->id->model, "MATSHITADVD-ROM SR-8176") == 0 ||
3006             strcmp(drive->id->model, "MATSHITADVD-ROM SR-8174") == 0)
3007                 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
3008
3009 #if ! STANDARD_ATAPI
3010         if (cdi->sanyo_slot > 0) {
3011                 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
3012                 nslots = 3;
3013         }
3014
3015         else
3016 #endif /* not STANDARD_ATAPI */
3017         if (cap.mechtype == mechtype_individual_changer ||
3018             cap.mechtype == mechtype_cartridge_changer) {
3019                 if ((nslots = cdrom_number_of_slots(cdi)) > 1) {
3020                         CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
3021                         CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 1;
3022                 }
3023         }
3024
3025         ide_cdrom_update_speed(drive, &cap);
3026         /* don't print speed if the drive reported 0.
3027          */
3028         printk(KERN_INFO "%s: ATAPI", drive->name);
3029         if (CDROM_CONFIG_FLAGS(drive)->max_speed)
3030                 printk(" %dX", CDROM_CONFIG_FLAGS(drive)->max_speed);
3031         printk(" %s", CDROM_CONFIG_FLAGS(drive)->dvd ? "DVD-ROM" : "CD-ROM");
3032
3033         if (CDROM_CONFIG_FLAGS(drive)->dvd_r|CDROM_CONFIG_FLAGS(drive)->dvd_ram)
3034                 printk(" DVD%s%s",
3035                 (CDROM_CONFIG_FLAGS(drive)->dvd_r)? "-R" : "",
3036                 (CDROM_CONFIG_FLAGS(drive)->dvd_ram)? "-RAM" : "");
3037
3038         if (CDROM_CONFIG_FLAGS(drive)->cd_r|CDROM_CONFIG_FLAGS(drive)->cd_rw)
3039                 printk(" CD%s%s",
3040                 (CDROM_CONFIG_FLAGS(drive)->cd_r)? "-R" : "",
3041                 (CDROM_CONFIG_FLAGS(drive)->cd_rw)? "/RW" : "");
3042
3043         if (CDROM_CONFIG_FLAGS(drive)->is_changer)
3044                 printk(" changer w/%d slots", nslots);
3045         else
3046                 printk(" drive");
3047
3048         printk(KERN_CONT ", %dkB Cache\n", be16_to_cpu(cap.buffer_size));
3049
3050         return nslots;
3051 }
3052
3053 #ifdef CONFIG_IDE_PROC_FS
3054 static void ide_cdrom_add_settings(ide_drive_t *drive)
3055 {
3056         ide_add_setting(drive, "dsc_overlap", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
3057 }
3058 #else
3059 static inline void ide_cdrom_add_settings(ide_drive_t *drive) { ; }
3060 #endif
3061
3062 /*
3063  * standard prep_rq_fn that builds 10 byte cmds
3064  */
3065 static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
3066 {
3067         int hard_sect = queue_hardsect_size(q);
3068         long block = (long)rq->hard_sector / (hard_sect >> 9);
3069         unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
3070
3071         memset(rq->cmd, 0, sizeof(rq->cmd));
3072
3073         if (rq_data_dir(rq) == READ)
3074                 rq->cmd[0] = GPCMD_READ_10;
3075         else
3076                 rq->cmd[0] = GPCMD_WRITE_10;
3077
3078         /*
3079          * fill in lba
3080          */
3081         rq->cmd[2] = (block >> 24) & 0xff;
3082         rq->cmd[3] = (block >> 16) & 0xff;
3083         rq->cmd[4] = (block >>  8) & 0xff;
3084         rq->cmd[5] = block & 0xff;
3085
3086         /*
3087          * and transfer length
3088          */
3089         rq->cmd[7] = (blocks >> 8) & 0xff;
3090         rq->cmd[8] = blocks & 0xff;
3091         rq->cmd_len = 10;
3092         return BLKPREP_OK;
3093 }
3094
3095 /*
3096  * Most of the SCSI commands are supported directly by ATAPI devices.
3097  * This transform handles the few exceptions.
3098  */
3099 static int ide_cdrom_prep_pc(struct request *rq)
3100 {
3101         u8 *c = rq->cmd;
3102
3103         /*
3104          * Transform 6-byte read/write commands to the 10-byte version
3105          */
3106         if (c[0] == READ_6 || c[0] == WRITE_6) {
3107                 c[8] = c[4];
3108                 c[5] = c[3];
3109                 c[4] = c[2];
3110                 c[3] = c[1] & 0x1f;
3111                 c[2] = 0;
3112                 c[1] &= 0xe0;
3113                 c[0] += (READ_10 - READ_6);
3114                 rq->cmd_len = 10;
3115                 return BLKPREP_OK;
3116         }
3117
3118         /*
3119          * it's silly to pretend we understand 6-byte sense commands, just
3120          * reject with ILLEGAL_REQUEST and the caller should take the
3121          * appropriate action
3122          */
3123         if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
3124                 rq->errors = ILLEGAL_REQUEST;
3125                 return BLKPREP_KILL;
3126         }
3127
3128         return BLKPREP_OK;
3129 }
3130
3131 static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
3132 {
3133         if (blk_fs_request(rq))
3134                 return ide_cdrom_prep_fs(q, rq);
3135         else if (blk_pc_request(rq))
3136                 return ide_cdrom_prep_pc(rq);
3137
3138         return 0;
3139 }
3140
3141 static
3142 int ide_cdrom_setup (ide_drive_t *drive)
3143 {
3144         struct cdrom_info *info = drive->driver_data;
3145         struct cdrom_device_info *cdi = &info->devinfo;
3146         int nslots;
3147
3148         blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
3149         blk_queue_dma_alignment(drive->queue, 31);
3150         drive->queue->unplug_delay = (1 * HZ) / 1000;
3151         if (!drive->queue->unplug_delay)
3152                 drive->queue->unplug_delay = 1;
3153
3154         drive->special.all      = 0;
3155
3156         CDROM_STATE_FLAGS(drive)->media_changed = 1;
3157         CDROM_STATE_FLAGS(drive)->toc_valid     = 0;
3158         CDROM_STATE_FLAGS(drive)->door_locked   = 0;
3159
3160 #if NO_DOOR_LOCKING
3161         CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
3162 #else
3163         CDROM_CONFIG_FLAGS(drive)->no_doorlock = 0;
3164 #endif
3165
3166         CDROM_CONFIG_FLAGS(drive)->drq_interrupt = ((drive->id->config & 0x0060) == 0x20);
3167         CDROM_CONFIG_FLAGS(drive)->is_changer = 0;
3168         CDROM_CONFIG_FLAGS(drive)->cd_r = 0;
3169         CDROM_CONFIG_FLAGS(drive)->cd_rw = 0;
3170         CDROM_CONFIG_FLAGS(drive)->test_write = 0;
3171         CDROM_CONFIG_FLAGS(drive)->dvd = 0;
3172         CDROM_CONFIG_FLAGS(drive)->dvd_r = 0;
3173         CDROM_CONFIG_FLAGS(drive)->dvd_ram = 0;
3174         CDROM_CONFIG_FLAGS(drive)->no_eject = 1;
3175         CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 0;
3176         CDROM_CONFIG_FLAGS(drive)->audio_play = 0;
3177         CDROM_CONFIG_FLAGS(drive)->close_tray = 1;
3178
3179         /* limit transfer size per interrupt. */
3180         CDROM_CONFIG_FLAGS(drive)->limit_nframes = 0;
3181         /* a testament to the nice quality of Samsung drives... */
3182         if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2430"))
3183                 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3184         else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2432"))
3185                 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3186         /* the 3231 model does not support the SET_CD_SPEED command */
3187         else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-3231"))
3188                 CDROM_CONFIG_FLAGS(drive)->no_speed_select = 1;
3189
3190 #if ! STANDARD_ATAPI
3191         /* by default Sanyo 3 CD changer support is turned off and
3192            ATAPI Rev 2.2+ standard support for CD changers is used */
3193         cdi->sanyo_slot = 0;
3194
3195         CDROM_CONFIG_FLAGS(drive)->nec260 = 0;
3196         CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 0;
3197         CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 0;
3198         CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 0;
3199         CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 0;
3200
3201         if (strcmp (drive->id->model, "V003S0DS") == 0 &&
3202             drive->id->fw_rev[4] == '1' &&
3203             drive->id->fw_rev[6] <= '2') {
3204                 /* Vertos 300.
3205                    Some versions of this drive like to talk BCD. */
3206                 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3207                 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3208                 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3209                 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3210         }
3211
3212         else if (strcmp (drive->id->model, "V006E0DS") == 0 &&
3213             drive->id->fw_rev[4] == '1' &&
3214             drive->id->fw_rev[6] <= '2') {
3215                 /* Vertos 600 ESD. */
3216                 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3217         }
3218         else if (strcmp(drive->id->model, "NEC CD-ROM DRIVE:260") == 0 &&
3219                  strncmp(drive->id->fw_rev, "1.01", 4) == 0) { /* FIXME */
3220                 /* Old NEC260 (not R).
3221                    This drive was released before the 1.2 version
3222                    of the spec. */
3223                 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3224                 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3225                 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3226                 CDROM_CONFIG_FLAGS(drive)->nec260         = 1;
3227         }
3228         else if (strcmp(drive->id->model, "WEARNES CDD-120") == 0 &&
3229                  strncmp(drive->id->fw_rev, "A1.1", 4) == 0) { /* FIXME */
3230                 /* Wearnes */
3231                 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3232                 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3233         }
3234         /* Sanyo 3 CD changer uses a non-standard command
3235            for CD changing */
3236         else if ((strcmp(drive->id->model, "CD-ROM CDR-C3 G") == 0) ||
3237                  (strcmp(drive->id->model, "CD-ROM CDR-C3G") == 0) ||
3238                  (strcmp(drive->id->model, "CD-ROM CDR_C36") == 0)) {
3239                  /* uses CD in slot 0 when value is set to 3 */
3240                  cdi->sanyo_slot = 3;
3241         }
3242 #endif /* not STANDARD_ATAPI */
3243
3244         info->toc               = NULL;
3245         info->buffer            = NULL;
3246         info->sector_buffered   = 0;
3247         info->nsectors_buffered = 0;
3248         info->changer_info      = NULL;
3249         info->last_block        = 0;
3250         info->start_seek        = 0;
3251
3252         nslots = ide_cdrom_probe_capabilities (drive);
3253
3254         /*
3255          * set correct block size
3256          */
3257         blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
3258
3259         if (drive->autotune == IDE_TUNE_DEFAULT ||
3260             drive->autotune == IDE_TUNE_AUTO)
3261                 drive->dsc_overlap = (drive->next != drive);
3262
3263         if (ide_cdrom_register(drive, nslots)) {
3264                 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
3265                 info->devinfo.handle = NULL;
3266                 return 1;
3267         }
3268         ide_cdrom_add_settings(drive);
3269         return 0;
3270 }
3271
3272 #ifdef CONFIG_IDE_PROC_FS
3273 static
3274 sector_t ide_cdrom_capacity (ide_drive_t *drive)
3275 {
3276         unsigned long capacity, sectors_per_frame;
3277
3278         if (cdrom_read_capacity(drive, &capacity, &sectors_per_frame, NULL))
3279                 return 0;
3280
3281         return capacity * sectors_per_frame;
3282 }
3283 #endif
3284
3285 static void ide_cd_remove(ide_drive_t *drive)
3286 {
3287         struct cdrom_info *info = drive->driver_data;
3288
3289         ide_proc_unregister_driver(drive, info->driver);
3290
3291         del_gendisk(info->disk);
3292
3293         ide_cd_put(info);
3294 }
3295
3296 static void ide_cd_release(struct kref *kref)
3297 {
3298         struct cdrom_info *info = to_ide_cd(kref);
3299         struct cdrom_device_info *devinfo = &info->devinfo;
3300         ide_drive_t *drive = info->drive;
3301         struct gendisk *g = info->disk;
3302
3303         kfree(info->buffer);
3304         kfree(info->toc);
3305         kfree(info->changer_info);
3306         if (devinfo->handle == drive && unregister_cdrom(devinfo))
3307                 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom "
3308                                 "driver.\n", __FUNCTION__, drive->name);
3309         drive->dsc_overlap = 0;
3310         drive->driver_data = NULL;
3311         blk_queue_prep_rq(drive->queue, NULL);
3312         g->private_data = NULL;
3313         put_disk(g);
3314         kfree(info);
3315 }
3316
3317 static int ide_cd_probe(ide_drive_t *);
3318
3319 #ifdef CONFIG_IDE_PROC_FS
3320 static int proc_idecd_read_capacity
3321         (char *page, char **start, off_t off, int count, int *eof, void *data)
3322 {
3323         ide_drive_t *drive = data;
3324         int len;
3325
3326         len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
3327         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
3328 }
3329
3330 static ide_proc_entry_t idecd_proc[] = {
3331         { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
3332         { NULL, 0, NULL, NULL }
3333 };
3334 #endif
3335
3336 static ide_driver_t ide_cdrom_driver = {
3337         .gen_driver = {
3338                 .owner          = THIS_MODULE,
3339                 .name           = "ide-cdrom",
3340                 .bus            = &ide_bus_type,
3341         },
3342         .probe                  = ide_cd_probe,
3343         .remove                 = ide_cd_remove,
3344         .version                = IDECD_VERSION,
3345         .media                  = ide_cdrom,
3346         .supports_dsc_overlap   = 1,
3347         .do_request             = ide_do_rw_cdrom,
3348         .end_request            = ide_end_request,
3349         .error                  = __ide_error,
3350         .abort                  = __ide_abort,
3351 #ifdef CONFIG_IDE_PROC_FS
3352         .proc                   = idecd_proc,
3353 #endif
3354 };
3355
3356 static int idecd_open(struct inode * inode, struct file * file)
3357 {
3358         struct gendisk *disk = inode->i_bdev->bd_disk;
3359         struct cdrom_info *info;
3360         int rc = -ENOMEM;
3361
3362         if (!(info = ide_cd_get(disk)))
3363                 return -ENXIO;
3364
3365         if (!info->buffer)
3366                 info->buffer = kmalloc(SECTOR_BUFFER_SIZE, GFP_KERNEL|__GFP_REPEAT);
3367
3368         if (info->buffer)
3369                 rc = cdrom_open(&info->devinfo, inode, file);
3370
3371         if (rc < 0)
3372                 ide_cd_put(info);
3373
3374         return rc;
3375 }
3376
3377 static int idecd_release(struct inode * inode, struct file * file)
3378 {
3379         struct gendisk *disk = inode->i_bdev->bd_disk;
3380         struct cdrom_info *info = ide_cd_g(disk);
3381
3382         cdrom_release (&info->devinfo, file);
3383
3384         ide_cd_put(info);
3385
3386         return 0;
3387 }
3388
3389 static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg)
3390 {
3391         struct packet_command cgc;
3392         char buffer[16];
3393         int stat;
3394         char spindown;
3395
3396         if (copy_from_user(&spindown, (void __user *)arg, sizeof(char)))
3397                 return -EFAULT;
3398
3399         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
3400
3401         stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
3402         if (stat)
3403                 return stat;
3404
3405         buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
3406         return cdrom_mode_select(cdi, &cgc);
3407 }
3408
3409 static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
3410 {
3411         struct packet_command cgc;
3412         char buffer[16];
3413         int stat;
3414         char spindown;
3415
3416         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
3417
3418         stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
3419         if (stat)
3420                 return stat;
3421
3422         spindown = buffer[11] & 0x0f;
3423         if (copy_to_user((void __user *)arg, &spindown, sizeof (char)))
3424                 return -EFAULT;
3425         return 0;
3426 }
3427
3428 static int idecd_ioctl (struct inode *inode, struct file *file,
3429                         unsigned int cmd, unsigned long arg)
3430 {
3431         struct block_device *bdev = inode->i_bdev;
3432         struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
3433         int err;
3434
3435         switch (cmd) {
3436         case CDROMSETSPINDOWN:
3437                 return idecd_set_spindown(&info->devinfo, arg);
3438         case CDROMGETSPINDOWN:
3439                 return idecd_get_spindown(&info->devinfo, arg);
3440         default:
3441                 break;
3442         }
3443
3444         err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
3445         if (err == -EINVAL)
3446                 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
3447
3448         return err;
3449 }
3450
3451 static int idecd_media_changed(struct gendisk *disk)
3452 {
3453         struct cdrom_info *info = ide_cd_g(disk);
3454         return cdrom_media_changed(&info->devinfo);
3455 }
3456
3457 static int idecd_revalidate_disk(struct gendisk *disk)
3458 {
3459         struct cdrom_info *info = ide_cd_g(disk);
3460         struct request_sense sense;
3461         cdrom_read_toc(info->drive, &sense);
3462         return  0;
3463 }
3464
3465 static struct block_device_operations idecd_ops = {
3466         .owner          = THIS_MODULE,
3467         .open           = idecd_open,
3468         .release        = idecd_release,
3469         .ioctl          = idecd_ioctl,
3470         .media_changed  = idecd_media_changed,
3471         .revalidate_disk= idecd_revalidate_disk
3472 };
3473
3474 /* options */
3475 static char *ignore = NULL;
3476
3477 module_param(ignore, charp, 0400);
3478 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
3479
3480 static int ide_cd_probe(ide_drive_t *drive)
3481 {
3482         struct cdrom_info *info;
3483         struct gendisk *g;
3484         struct request_sense sense;
3485
3486         if (!strstr("ide-cdrom", drive->driver_req))
3487                 goto failed;
3488         if (!drive->present)
3489                 goto failed;
3490         if (drive->media != ide_cdrom && drive->media != ide_optical)
3491                 goto failed;
3492         /* skip drives that we were told to ignore */
3493         if (ignore != NULL) {
3494                 if (strstr(ignore, drive->name)) {
3495                         printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
3496                         goto failed;
3497                 }
3498         }
3499         if (drive->scsi) {
3500                 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
3501                 goto failed;
3502         }
3503         info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
3504         if (info == NULL) {
3505                 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
3506                 goto failed;
3507         }
3508
3509         g = alloc_disk(1 << PARTN_BITS);
3510         if (!g)
3511                 goto out_free_cd;
3512
3513         ide_init_disk(g, drive);
3514
3515         ide_proc_register_driver(drive, &ide_cdrom_driver);
3516
3517         kref_init(&info->kref);
3518
3519         info->drive = drive;
3520         info->driver = &ide_cdrom_driver;
3521         info->disk = g;
3522
3523         g->private_data = &info->driver;
3524
3525         drive->driver_data = info;
3526
3527         g->minors = 1;
3528         g->driverfs_dev = &drive->gendev;
3529         g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
3530         if (ide_cdrom_setup(drive)) {
3531                 ide_proc_unregister_driver(drive, &ide_cdrom_driver);
3532                 ide_cd_release(&info->kref);
3533                 goto failed;
3534         }
3535
3536         cdrom_read_toc(drive, &sense);
3537         g->fops = &idecd_ops;
3538         g->flags |= GENHD_FL_REMOVABLE;
3539         add_disk(g);
3540         return 0;
3541
3542 out_free_cd:
3543         kfree(info);
3544 failed:
3545         return -ENODEV;
3546 }
3547
3548 static void __exit ide_cdrom_exit(void)
3549 {
3550         driver_unregister(&ide_cdrom_driver.gen_driver);
3551 }
3552
3553 static int __init ide_cdrom_init(void)
3554 {
3555         return driver_register(&ide_cdrom_driver.gen_driver);
3556 }
3557
3558 MODULE_ALIAS("ide:*m-cdrom*");
3559 module_init(ide_cdrom_init);
3560 module_exit(ide_cdrom_exit);
3561 MODULE_LICENSE("GPL");