git.oblomov.eu Git - linux-2.6/blob - drivers/ide/ide-cd.c

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