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