drivers/ide/ide-cd.c

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