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: read_intr: Drive wants to transfer data the "
1072                                                 "wrong way!\n", drive->name);
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: read_intr: bad interrupt reason %x\n", drive->name,
1090                                                                 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: write_intr: wrong transfer direction!\n",
1636                                                         drive->name);
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: write_intr: bad interrupt reason %x\n",
1646                                                         drive->name, 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                 if ((dma_error = HWIF(drive)->ide_dma_end(drive))) {
1809                         printk(KERN_ERR "ide-cd: write dma error\n");
1810                         ide_dma_off(drive);
1811                 }
1812         }
1813
1814         if (cdrom_decode_status(drive, 0, &stat))
1815                 return ide_stopped;
1816
1817         /*
1818          * using dma, transfer is complete now
1819          */
1820         if (dma) {
1821                 if (dma_error)
1822                         return ide_error(drive, "dma error", stat);
1823
1824                 ide_end_request(drive, 1, rq->nr_sectors);
1825                 return ide_stopped;
1826         }
1827
1828         /* Read the interrupt reason and the transfer length. */
1829         ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1830         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1831         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1832
1833         len = lowcyl + (256 * highcyl);
1834
1835         /* If DRQ is clear, the command has completed. */
1836         if ((stat & DRQ_STAT) == 0) {
1837                 /* If we're not done writing, complain.
1838                  * Otherwise, complete the command normally.
1839                  */
1840                 uptodate = 1;
1841                 if (rq->current_nr_sectors > 0) {
1842                         printk(KERN_ERR "%s: write_intr: data underrun (%d blocks)\n",
1843                         drive->name, rq->current_nr_sectors);
1844                         uptodate = 0;
1845                 }
1846                 cdrom_end_request(drive, uptodate);
1847                 return ide_stopped;
1848         }
1849
1850         /* Check that the drive is expecting to do the same thing we are. */
1851         if (cdrom_write_check_ireason(drive, len, ireason))
1852                 return ide_stopped;
1853
1854         sectors_to_transfer = len / SECTOR_SIZE;
1855
1856         /*
1857          * now loop and write out the data
1858          */
1859         while (sectors_to_transfer > 0) {
1860                 int this_transfer;
1861
1862                 if (!rq->current_nr_sectors) {
1863                         printk(KERN_ERR "ide-cd: write_intr: oops\n");
1864                         break;
1865                 }
1866
1867                 /*
1868                  * Figure out how many sectors we can transfer
1869                  */
1870                 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors);
1871
1872                 while (this_transfer > 0) {
1873                         HWIF(drive)->atapi_output_bytes(drive, rq->buffer, SECTOR_SIZE);
1874                         rq->buffer += SECTOR_SIZE;
1875                         --rq->nr_sectors;
1876                         --rq->current_nr_sectors;
1877                         ++rq->sector;
1878                         --this_transfer;
1879                         --sectors_to_transfer;
1880                 }
1881
1882                 /*
1883                  * current buffer complete, move on
1884                  */
1885                 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1886                         cdrom_end_request(drive, 1);
1887         }
1888
1889         /* re-arm handler */
1890         ide_set_handler(drive, &cdrom_write_intr, ATAPI_WAIT_PC, NULL);
1891         return ide_started;
1892 }
1893
1894 static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
1895 {
1896         struct request *rq = HWGROUP(drive)->rq;
1897
1898 #if 0   /* the immediate bit */
1899         rq->cmd[1] = 1 << 3;
1900 #endif
1901         rq->timeout = ATAPI_WAIT_PC;
1902
1903         return cdrom_transfer_packet_command(drive, rq, cdrom_write_intr);
1904 }
1905
1906 static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
1907 {
1908         struct cdrom_info *info = drive->driver_data;
1909         struct gendisk *g = info->disk;
1910         unsigned short sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1911
1912         /*
1913          * writes *must* be hardware frame aligned
1914          */
1915         if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1916             (rq->sector & (sectors_per_frame - 1))) {
1917                 cdrom_end_request(drive, 0);
1918                 return ide_stopped;
1919         }
1920
1921         /*
1922          * disk has become write protected
1923          */
1924         if (g->policy) {
1925                 cdrom_end_request(drive, 0);
1926                 return ide_stopped;
1927         }
1928
1929         info->nsectors_buffered = 0;
1930
1931         /* use dma, if possible. we don't need to check more, since we
1932          * know that the transfer is always (at least!) frame aligned */
1933         info->dma = drive->using_dma ? 1 : 0;
1934
1935         info->devinfo.media_written = 1;
1936
1937         /* Start sending the write request to the drive. */
1938         return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
1939 }
1940
1941 static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1942 {
1943         struct request *rq = HWGROUP(drive)->rq;
1944
1945         if (!rq->timeout)
1946                 rq->timeout = ATAPI_WAIT_PC;
1947
1948         return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1949 }
1950
1951 static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1952 {
1953         struct cdrom_info *info = drive->driver_data;
1954
1955         rq->cmd_flags |= REQ_QUIET;
1956
1957         info->dma = 0;
1958
1959         /*
1960          * sg request
1961          */
1962         if (rq->bio) {
1963                 int mask = drive->queue->dma_alignment;
1964                 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
1965
1966                 info->dma = drive->using_dma;
1967
1968                 /*
1969                  * check if dma is safe
1970                  *
1971                  * NOTE! The "len" and "addr" checks should possibly have
1972                  * separate masks.
1973                  */
1974                 if ((rq->data_len & 15) || (addr & mask))
1975                         info->dma = 0;
1976         }
1977
1978         /* Start sending the command to the drive. */
1979         return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1980 }
1981
1982 /****************************************************************************
1983  * cdrom driver request routine.
1984  */
1985 static ide_startstop_t
1986 ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1987 {
1988         ide_startstop_t action;
1989         struct cdrom_info *info = drive->driver_data;
1990
1991         if (blk_fs_request(rq)) {
1992                 if (CDROM_CONFIG_FLAGS(drive)->seeking) {
1993                         unsigned long elapsed = jiffies - info->start_seek;
1994                         int stat = HWIF(drive)->INB(IDE_STATUS_REG);
1995
1996                         if ((stat & SEEK_STAT) != SEEK_STAT) {
1997                                 if (elapsed < IDECD_SEEK_TIMEOUT) {
1998                                         ide_stall_queue(drive, IDECD_SEEK_TIMER);
1999                                         return ide_stopped;
2000                                 }
2001                                 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
2002                         }
2003                         CDROM_CONFIG_FLAGS(drive)->seeking = 0;
2004                 }
2005                 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
2006                         action = cdrom_start_seek(drive, block);
2007                 } else {
2008                         if (rq_data_dir(rq) == READ)
2009                                 action = cdrom_start_read(drive, block);
2010                         else
2011                                 action = cdrom_start_write(drive, rq);
2012                 }
2013                 info->last_block = block;
2014                 return action;
2015         } else if (rq->cmd_type == REQ_TYPE_SENSE ||
2016                    rq->cmd_type == REQ_TYPE_ATA_PC) {
2017                 return cdrom_do_packet_command(drive);
2018         } else if (blk_pc_request(rq)) {
2019                 return cdrom_do_block_pc(drive, rq);
2020         } else if (blk_special_request(rq)) {
2021                 /*
2022                  * right now this can only be a reset...
2023                  */
2024                 cdrom_end_request(drive, 1);
2025                 return ide_stopped;
2026         }
2027
2028         blk_dump_rq_flags(rq, "ide-cd bad flags");
2029         cdrom_end_request(drive, 0);
2030         return ide_stopped;
2031 }
2032
2033
2034
2035 /****************************************************************************
2036  * Ioctl handling.
2037  *
2038  * Routines which queue packet commands take as a final argument a pointer
2039  * to a request_sense struct.  If execution of the command results
2040  * in an error with a CHECK CONDITION status, this structure will be filled
2041  * with the results of the subsequent request sense command.  The pointer
2042  * can also be NULL, in which case no sense information is returned.
2043  */
2044
2045 #if ! STANDARD_ATAPI
2046 static inline
2047 int bin2bcd (int x)
2048 {
2049         return (x%10) | ((x/10) << 4);
2050 }
2051
2052
2053 static inline
2054 int bcd2bin (int x)
2055 {
2056         return (x >> 4) * 10 + (x & 0x0f);
2057 }
2058
2059 static
2060 void msf_from_bcd (struct atapi_msf *msf)
2061 {
2062         msf->minute = bcd2bin (msf->minute);
2063         msf->second = bcd2bin (msf->second);
2064         msf->frame  = bcd2bin (msf->frame);
2065 }
2066
2067 #endif /* not STANDARD_ATAPI */
2068
2069
2070 static inline
2071 void lba_to_msf (int lba, byte *m, byte *s, byte *f)
2072 {
2073         lba += CD_MSF_OFFSET;
2074         lba &= 0xffffff;  /* negative lbas use only 24 bits */
2075         *m = lba / (CD_SECS * CD_FRAMES);
2076         lba %= (CD_SECS * CD_FRAMES);
2077         *s = lba / CD_FRAMES;
2078         *f = lba % CD_FRAMES;
2079 }
2080
2081
2082 static inline
2083 int msf_to_lba (byte m, byte s, byte f)
2084 {
2085         return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
2086 }
2087
2088 static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
2089 {
2090         struct request req;
2091         struct cdrom_info *info = drive->driver_data;
2092         struct cdrom_device_info *cdi = &info->devinfo;
2093
2094         cdrom_prepare_request(drive, &req);
2095
2096         req.sense = sense;
2097         req.cmd[0] = GPCMD_TEST_UNIT_READY;
2098         req.cmd_flags |= REQ_QUIET;
2099
2100 #if ! STANDARD_ATAPI
2101         /* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
2102            switch CDs instead of supporting the LOAD_UNLOAD opcode   */
2103
2104         req.cmd[7] = cdi->sanyo_slot % 3;
2105 #endif /* not STANDARD_ATAPI */
2106
2107         return cdrom_queue_packet_command(drive, &req);
2108 }
2109
2110
2111 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
2112 static int
2113 cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
2114 {
2115         struct request_sense my_sense;
2116         struct request req;
2117         int stat;
2118
2119         if (sense == NULL)
2120                 sense = &my_sense;
2121
2122         /* If the drive cannot lock the door, just pretend. */
2123         if (CDROM_CONFIG_FLAGS(drive)->no_doorlock) {
2124                 stat = 0;
2125         } else {
2126                 cdrom_prepare_request(drive, &req);
2127                 req.sense = sense;
2128                 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
2129                 req.cmd[4] = lockflag ? 1 : 0;
2130                 stat = cdrom_queue_packet_command(drive, &req);
2131         }
2132
2133         /* If we got an illegal field error, the drive
2134            probably cannot lock the door. */
2135         if (stat != 0 &&
2136             sense->sense_key == ILLEGAL_REQUEST &&
2137             (sense->asc == 0x24 || sense->asc == 0x20)) {
2138                 printk (KERN_ERR "%s: door locking not supported\n",
2139                         drive->name);
2140                 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2141                 stat = 0;
2142         }
2143
2144         /* no medium, that's alright. */
2145         if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
2146                 stat = 0;
2147
2148         if (stat == 0)
2149                 CDROM_STATE_FLAGS(drive)->door_locked = lockflag;
2150
2151         return stat;
2152 }
2153
2154
2155 /* Eject the disk if EJECTFLAG is 0.
2156    If EJECTFLAG is 1, try to reload the disk. */
2157 static int cdrom_eject(ide_drive_t *drive, int ejectflag,
2158                        struct request_sense *sense)
2159 {
2160         struct request req;
2161         char loej = 0x02;
2162
2163         if (CDROM_CONFIG_FLAGS(drive)->no_eject && !ejectflag)
2164                 return -EDRIVE_CANT_DO_THIS;
2165
2166         /* reload fails on some drives, if the tray is locked */
2167         if (CDROM_STATE_FLAGS(drive)->door_locked && ejectflag)
2168                 return 0;
2169
2170         cdrom_prepare_request(drive, &req);
2171
2172         /* only tell drive to close tray if open, if it can do that */
2173         if (ejectflag && !CDROM_CONFIG_FLAGS(drive)->close_tray)
2174                 loej = 0;
2175
2176         req.sense = sense;
2177         req.cmd[0] = GPCMD_START_STOP_UNIT;
2178         req.cmd[4] = loej | (ejectflag != 0);
2179         return cdrom_queue_packet_command(drive, &req);
2180 }
2181
2182 static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
2183                                unsigned long *sectors_per_frame,
2184                                struct request_sense *sense)
2185 {
2186         struct {
2187                 __u32 lba;
2188                 __u32 blocklen;
2189         } capbuf;
2190
2191         int stat;
2192         struct request req;
2193
2194         cdrom_prepare_request(drive, &req);
2195
2196         req.sense = sense;
2197         req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
2198         req.data = (char *)&capbuf;
2199         req.data_len = sizeof(capbuf);
2200         req.cmd_flags |= REQ_QUIET;
2201
2202         stat = cdrom_queue_packet_command(drive, &req);
2203         if (stat == 0) {
2204                 *capacity = 1 + be32_to_cpu(capbuf.lba);
2205                 *sectors_per_frame =
2206                         be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
2207         }
2208
2209         return stat;
2210 }
2211
2212 static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
2213                                 int format, char *buf, int buflen,
2214                                 struct request_sense *sense)
2215 {
2216         struct request req;
2217
2218         cdrom_prepare_request(drive, &req);
2219
2220         req.sense = sense;
2221         req.data =  buf;
2222         req.data_len = buflen;
2223         req.cmd_flags |= REQ_QUIET;
2224         req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
2225         req.cmd[6] = trackno;
2226         req.cmd[7] = (buflen >> 8);
2227         req.cmd[8] = (buflen & 0xff);
2228         req.cmd[9] = (format << 6);
2229
2230         if (msf_flag)
2231                 req.cmd[1] = 2;
2232
2233         return cdrom_queue_packet_command(drive, &req);
2234 }
2235
2236
2237 /* Try to read the entire TOC for the disk into our internal buffer. */
2238 static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2239 {
2240         int stat, ntracks, i;
2241         struct cdrom_info *info = drive->driver_data;
2242         struct cdrom_device_info *cdi = &info->devinfo;
2243         struct atapi_toc *toc = info->toc;
2244         struct {
2245                 struct atapi_toc_header hdr;
2246                 struct atapi_toc_entry  ent;
2247         } ms_tmp;
2248         long last_written;
2249         unsigned long sectors_per_frame = SECTORS_PER_FRAME;
2250
2251         if (toc == NULL) {
2252                 /* Try to allocate space. */
2253                 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
2254                 if (toc == NULL) {
2255                         printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
2256                         return -ENOMEM;
2257                 }
2258                 info->toc = toc;
2259         }
2260
2261         /* Check to see if the existing data is still valid.
2262            If it is, just return. */
2263         (void) cdrom_check_status(drive, sense);
2264
2265         if (CDROM_STATE_FLAGS(drive)->toc_valid)
2266                 return 0;
2267
2268         /* Try to get the total cdrom capacity and sector size. */
2269         stat = cdrom_read_capacity(drive, &toc->capacity, &sectors_per_frame,
2270                                    sense);
2271         if (stat)
2272                 toc->capacity = 0x1fffff;
2273
2274         set_capacity(info->disk, toc->capacity * sectors_per_frame);
2275         /* Save a private copy of te TOC capacity for error handling */
2276         drive->probed_capacity = toc->capacity * sectors_per_frame;
2277
2278         blk_queue_hardsect_size(drive->queue,
2279                                 sectors_per_frame << SECTOR_BITS);
2280
2281         /* First read just the header, so we know how long the TOC is. */
2282         stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
2283                                     sizeof(struct atapi_toc_header), sense);
2284         if (stat)
2285                 return stat;
2286
2287 #if ! STANDARD_ATAPI
2288         if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2289                 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2290                 toc->hdr.last_track  = bcd2bin(toc->hdr.last_track);
2291         }
2292 #endif  /* not STANDARD_ATAPI */
2293
2294         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2295         if (ntracks <= 0)
2296                 return -EIO;
2297         if (ntracks > MAX_TRACKS)
2298                 ntracks = MAX_TRACKS;
2299
2300         /* Now read the whole schmeer. */
2301         stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
2302                                   (char *)&toc->hdr,
2303                                    sizeof(struct atapi_toc_header) +
2304                                    (ntracks + 1) *
2305                                    sizeof(struct atapi_toc_entry), sense);
2306
2307         if (stat && toc->hdr.first_track > 1) {
2308                 /* Cds with CDI tracks only don't have any TOC entries,
2309                    despite of this the returned values are
2310                    first_track == last_track = number of CDI tracks + 1,
2311                    so that this case is indistinguishable from the same
2312                    layout plus an additional audio track.
2313                    If we get an error for the regular case, we assume
2314                    a CDI without additional audio tracks. In this case
2315                    the readable TOC is empty (CDI tracks are not included)
2316                    and only holds the Leadout entry. Heiko Eißfeldt */
2317                 ntracks = 0;
2318                 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
2319                                            (char *)&toc->hdr,
2320                                            sizeof(struct atapi_toc_header) +
2321                                            (ntracks + 1) *
2322                                            sizeof(struct atapi_toc_entry),
2323                                            sense);
2324                 if (stat) {
2325                         return stat;
2326                 }
2327 #if ! STANDARD_ATAPI
2328                 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2329                         toc->hdr.first_track = bin2bcd(CDROM_LEADOUT);
2330                         toc->hdr.last_track = bin2bcd(CDROM_LEADOUT);
2331                 } else
2332 #endif  /* not STANDARD_ATAPI */
2333                 {
2334                         toc->hdr.first_track = CDROM_LEADOUT;
2335                         toc->hdr.last_track = CDROM_LEADOUT;
2336                 }
2337         }
2338
2339         if (stat)
2340                 return stat;
2341
2342         toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
2343
2344 #if ! STANDARD_ATAPI
2345         if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2346                 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2347                 toc->hdr.last_track  = bcd2bin(toc->hdr.last_track);
2348         }
2349 #endif  /* not STANDARD_ATAPI */
2350
2351         for (i=0; i<=ntracks; i++) {
2352 #if ! STANDARD_ATAPI
2353                 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2354                         if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd)
2355                                 toc->ent[i].track = bcd2bin(toc->ent[i].track);
2356                         msf_from_bcd(&toc->ent[i].addr.msf);
2357                 }
2358 #endif  /* not STANDARD_ATAPI */
2359                 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
2360                                                    toc->ent[i].addr.msf.second,
2361                                                    toc->ent[i].addr.msf.frame);
2362         }
2363
2364         /* Read the multisession information. */
2365         if (toc->hdr.first_track != CDROM_LEADOUT) {
2366                 /* Read the multisession information. */
2367                 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
2368                                            sizeof(ms_tmp), sense);
2369                 if (stat)
2370                         return stat;
2371
2372                 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
2373         } else {
2374                 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
2375                 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
2376         }
2377
2378 #if ! STANDARD_ATAPI
2379         if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2380                 /* Re-read multisession information using MSF format */
2381                 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
2382                                            sizeof(ms_tmp), sense);
2383                 if (stat)
2384                         return stat;
2385
2386                 msf_from_bcd (&ms_tmp.ent.addr.msf);
2387                 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
2388                                                    ms_tmp.ent.addr.msf.second,
2389                                                    ms_tmp.ent.addr.msf.frame);
2390         }
2391 #endif  /* not STANDARD_ATAPI */
2392
2393         toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
2394
2395         /* Now try to get the total cdrom capacity. */
2396         stat = cdrom_get_last_written(cdi, &last_written);
2397         if (!stat && (last_written > toc->capacity)) {
2398                 toc->capacity = last_written;
2399                 set_capacity(info->disk, toc->capacity * sectors_per_frame);
2400                 drive->probed_capacity = toc->capacity * sectors_per_frame;
2401         }
2402
2403         /* Remember that we've read this stuff. */
2404         CDROM_STATE_FLAGS(drive)->toc_valid = 1;
2405
2406         return 0;
2407 }
2408
2409
2410 static int cdrom_read_subchannel(ide_drive_t *drive, int format, char *buf,
2411                                  int buflen, struct request_sense *sense)
2412 {
2413         struct request req;
2414
2415         cdrom_prepare_request(drive, &req);
2416
2417         req.sense = sense;
2418         req.data = buf;
2419         req.data_len = buflen;
2420         req.cmd[0] = GPCMD_READ_SUBCHANNEL;
2421         req.cmd[1] = 2;     /* MSF addressing */
2422         req.cmd[2] = 0x40;  /* request subQ data */
2423         req.cmd[3] = format;
2424         req.cmd[7] = (buflen >> 8);
2425         req.cmd[8] = (buflen & 0xff);
2426         return cdrom_queue_packet_command(drive, &req);
2427 }
2428
2429 /* ATAPI cdrom drives are free to select the speed you request or any slower
2430    rate :-( Requesting too fast a speed will _not_ produce an error. */
2431 static int cdrom_select_speed(ide_drive_t *drive, int speed,
2432                               struct request_sense *sense)
2433 {
2434         struct request req;
2435         cdrom_prepare_request(drive, &req);
2436
2437         req.sense = sense;
2438         if (speed == 0)
2439                 speed = 0xffff; /* set to max */
2440         else
2441                 speed *= 177;   /* Nx to kbytes/s */
2442
2443         req.cmd[0] = GPCMD_SET_SPEED;
2444         /* Read Drive speed in kbytes/second MSB */
2445         req.cmd[2] = (speed >> 8) & 0xff;
2446         /* Read Drive speed in kbytes/second LSB */
2447         req.cmd[3] = speed & 0xff;
2448         if (CDROM_CONFIG_FLAGS(drive)->cd_r ||
2449             CDROM_CONFIG_FLAGS(drive)->cd_rw ||
2450             CDROM_CONFIG_FLAGS(drive)->dvd_r) {
2451                 /* Write Drive speed in kbytes/second MSB */
2452                 req.cmd[4] = (speed >> 8) & 0xff;
2453                 /* Write Drive speed in kbytes/second LSB */
2454                 req.cmd[5] = speed & 0xff;
2455        }
2456
2457         return cdrom_queue_packet_command(drive, &req);
2458 }
2459
2460 static int cdrom_play_audio(ide_drive_t *drive, int lba_start, int lba_end)
2461 {
2462         struct request_sense sense;
2463         struct request req;
2464
2465         cdrom_prepare_request(drive, &req);
2466
2467         req.sense = &sense;
2468         req.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2469         lba_to_msf(lba_start, &req.cmd[3], &req.cmd[4], &req.cmd[5]);
2470         lba_to_msf(lba_end-1, &req.cmd[6], &req.cmd[7], &req.cmd[8]);
2471
2472         return cdrom_queue_packet_command(drive, &req);
2473 }
2474
2475 static int cdrom_get_toc_entry(ide_drive_t *drive, int track,
2476                                 struct atapi_toc_entry **ent)
2477 {
2478         struct cdrom_info *info = drive->driver_data;
2479         struct atapi_toc *toc = info->toc;
2480         int ntracks;
2481
2482         /*
2483          * don't serve cached data, if the toc isn't valid
2484          */
2485         if (!CDROM_STATE_FLAGS(drive)->toc_valid)
2486                 return -EINVAL;
2487
2488         /* Check validity of requested track number. */
2489         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2490         if (toc->hdr.first_track == CDROM_LEADOUT) ntracks = 0;
2491         if (track == CDROM_LEADOUT)
2492                 *ent = &toc->ent[ntracks];
2493         else if (track < toc->hdr.first_track ||
2494                  track > toc->hdr.last_track)
2495                 return -EINVAL;
2496         else
2497                 *ent = &toc->ent[track - toc->hdr.first_track];
2498
2499         return 0;
2500 }
2501
2502 /* the generic packet interface to cdrom.c */
2503 static int ide_cdrom_packet(struct cdrom_device_info *cdi,
2504                             struct packet_command *cgc)
2505 {
2506         struct request req;
2507         ide_drive_t *drive = cdi->handle;
2508
2509         if (cgc->timeout <= 0)
2510                 cgc->timeout = ATAPI_WAIT_PC;
2511
2512         /* here we queue the commands from the uniform CD-ROM
2513            layer. the packet must be complete, as we do not
2514            touch it at all. */
2515         cdrom_prepare_request(drive, &req);
2516         memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
2517         if (cgc->sense)
2518                 memset(cgc->sense, 0, sizeof(struct request_sense));
2519         req.data = cgc->buffer;
2520         req.data_len = cgc->buflen;
2521         req.timeout = cgc->timeout;
2522
2523         if (cgc->quiet)
2524                 req.cmd_flags |= REQ_QUIET;
2525
2526         req.sense = cgc->sense;
2527         cgc->stat = cdrom_queue_packet_command(drive, &req);
2528         if (!cgc->stat)
2529                 cgc->buflen -= req.data_len;
2530         return cgc->stat;
2531 }
2532
2533 static
2534 int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
2535                            unsigned int cmd, void *arg)
2536
2537 {
2538         ide_drive_t *drive = cdi->handle;
2539         struct cdrom_info *info = drive->driver_data;
2540         int stat;
2541
2542         switch (cmd) {
2543         /*
2544          * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
2545          * atapi doesn't support it
2546          */
2547         case CDROMPLAYTRKIND: {
2548                 unsigned long lba_start, lba_end;
2549                 struct cdrom_ti *ti = arg;
2550                 struct atapi_toc_entry *first_toc, *last_toc;
2551
2552                 stat = cdrom_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
2553                 if (stat)
2554                         return stat;
2555
2556                 stat = cdrom_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
2557                 if (stat)
2558                         return stat;
2559
2560                 if (ti->cdti_trk1 != CDROM_LEADOUT)
2561                         ++last_toc;
2562                 lba_start = first_toc->addr.lba;
2563                 lba_end   = last_toc->addr.lba;
2564
2565                 if (lba_end <= lba_start)
2566                         return -EINVAL;
2567
2568                 return cdrom_play_audio(drive, lba_start, lba_end);
2569         }
2570
2571         case CDROMREADTOCHDR: {
2572                 struct cdrom_tochdr *tochdr = arg;
2573                 struct atapi_toc *toc;
2574
2575                 /* Make sure our saved TOC is valid. */
2576                 stat = cdrom_read_toc(drive, NULL);
2577                 if (stat)
2578                         return stat;
2579
2580                 toc = info->toc;
2581                 tochdr->cdth_trk0 = toc->hdr.first_track;
2582                 tochdr->cdth_trk1 = toc->hdr.last_track;
2583
2584                 return 0;
2585         }
2586
2587         case CDROMREADTOCENTRY: {
2588                 struct cdrom_tocentry *tocentry = arg;
2589                 struct atapi_toc_entry *toce;
2590
2591                 stat = cdrom_get_toc_entry(drive, tocentry->cdte_track, &toce);
2592                 if (stat)
2593                         return stat;
2594
2595                 tocentry->cdte_ctrl = toce->control;
2596                 tocentry->cdte_adr  = toce->adr;
2597                 if (tocentry->cdte_format == CDROM_MSF) {
2598                         lba_to_msf (toce->addr.lba,
2599                                    &tocentry->cdte_addr.msf.minute,
2600                                    &tocentry->cdte_addr.msf.second,
2601                                    &tocentry->cdte_addr.msf.frame);
2602                 } else
2603                         tocentry->cdte_addr.lba = toce->addr.lba;
2604
2605                 return 0;
2606         }
2607
2608         default:
2609                 return -EINVAL;
2610         }
2611 }
2612
2613 static
2614 int ide_cdrom_reset (struct cdrom_device_info *cdi)
2615 {
2616         ide_drive_t *drive = cdi->handle;
2617         struct request_sense sense;
2618         struct request req;
2619         int ret;
2620
2621         cdrom_prepare_request(drive, &req);
2622         req.cmd_type = REQ_TYPE_SPECIAL;
2623         req.cmd_flags = REQ_QUIET;
2624         ret = ide_do_drive_cmd(drive, &req, ide_wait);
2625
2626         /*
2627          * A reset will unlock the door. If it was previously locked,
2628          * lock it again.
2629          */
2630         if (CDROM_STATE_FLAGS(drive)->door_locked)
2631                 (void) cdrom_lockdoor(drive, 1, &sense);
2632
2633         return ret;
2634 }
2635
2636
2637 static
2638 int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
2639 {
2640         ide_drive_t *drive = cdi->handle;
2641         struct request_sense sense;
2642
2643         if (position) {
2644                 int stat = cdrom_lockdoor(drive, 0, &sense);
2645                 if (stat)
2646                         return stat;
2647         }
2648
2649         return cdrom_eject(drive, !position, &sense);
2650 }
2651
2652 static
2653 int ide_cdrom_lock_door (struct cdrom_device_info *cdi, int lock)
2654 {
2655         ide_drive_t *drive = cdi->handle;
2656         return cdrom_lockdoor(drive, lock, NULL);
2657 }
2658
2659 static
2660 int ide_cdrom_get_capabilities(ide_drive_t *drive, struct atapi_capabilities_page *cap)
2661 {
2662         struct cdrom_info *info = drive->driver_data;
2663         struct cdrom_device_info *cdi = &info->devinfo;
2664         struct packet_command cgc;
2665         int stat, attempts = 3, size = sizeof(*cap);
2666
2667         /*
2668          * ACER50 (and others?) require the full spec length mode sense
2669          * page capabilities size, but older drives break.
2670          */
2671         if (!(!strcmp(drive->id->model, "ATAPI CD ROM DRIVE 50X MAX") ||
2672             !strcmp(drive->id->model, "WPI CDS-32X")))
2673                 size -= sizeof(cap->pad);
2674
2675         init_cdrom_command(&cgc, cap, size, CGC_DATA_UNKNOWN);
2676         do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2677                 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
2678                 if (!stat)
2679                         break;
2680         } while (--attempts);
2681         return stat;
2682 }
2683
2684 static
2685 void ide_cdrom_update_speed (ide_drive_t *drive, struct atapi_capabilities_page *cap)
2686 {
2687         /* The ACER/AOpen 24X cdrom has the speed fields byte-swapped */
2688         if (!drive->id->model[0] &&
2689             !strncmp(drive->id->fw_rev, "241N", 4)) {
2690                 CDROM_STATE_FLAGS(drive)->current_speed  =
2691                         (le16_to_cpu(cap->curspeed) + (176/2)) / 176;
2692                 CDROM_CONFIG_FLAGS(drive)->max_speed =
2693                         (le16_to_cpu(cap->maxspeed) + (176/2)) / 176;
2694         } else {
2695                 CDROM_STATE_FLAGS(drive)->current_speed  =
2696                         (be16_to_cpu(cap->curspeed) + (176/2)) / 176;
2697                 CDROM_CONFIG_FLAGS(drive)->max_speed =
2698                         (be16_to_cpu(cap->maxspeed) + (176/2)) / 176;
2699         }
2700 }
2701
2702 static
2703 int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
2704 {
2705         ide_drive_t *drive = cdi->handle;
2706         struct request_sense sense;
2707         struct atapi_capabilities_page cap;
2708         int stat;
2709
2710         if ((stat = cdrom_select_speed(drive, speed, &sense)) < 0)
2711                 return stat;
2712
2713         if (!ide_cdrom_get_capabilities(drive, &cap)) {
2714                 ide_cdrom_update_speed(drive, &cap);
2715                 cdi->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2716         }
2717         return 0;
2718 }
2719
2720 /*
2721  * add logic to try GET_EVENT command first to check for media and tray
2722  * status. this should be supported by newer cd-r/w and all DVD etc
2723  * drives
2724  */
2725 static
2726 int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
2727 {
2728         ide_drive_t *drive = cdi->handle;
2729         struct media_event_desc med;
2730         struct request_sense sense;
2731         int stat;
2732
2733         if (slot_nr != CDSL_CURRENT)
2734                 return -EINVAL;
2735
2736         stat = cdrom_check_status(drive, &sense);
2737         if (!stat || sense.sense_key == UNIT_ATTENTION)
2738                 return CDS_DISC_OK;
2739
2740         if (!cdrom_get_media_event(cdi, &med)) {
2741                 if (med.media_present)
2742                         return CDS_DISC_OK;
2743                 else if (med.door_open)
2744                         return CDS_TRAY_OPEN;
2745                 else
2746                         return CDS_NO_DISC;
2747         }
2748
2749         if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
2750                 return CDS_DISC_OK;
2751
2752         /*
2753          * If not using Mt Fuji extended media tray reports,
2754          * just return TRAY_OPEN since ATAPI doesn't provide
2755          * any other way to detect this...
2756          */
2757         if (sense.sense_key == NOT_READY) {
2758                 if (sense.asc == 0x3a && sense.ascq == 1)
2759                         return CDS_NO_DISC;
2760                 else
2761                         return CDS_TRAY_OPEN;
2762         }
2763         return CDS_DRIVE_NOT_READY;
2764 }
2765
2766 static
2767 int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
2768                                 struct cdrom_multisession *ms_info)
2769 {
2770         struct atapi_toc *toc;
2771         ide_drive_t *drive = cdi->handle;
2772         struct cdrom_info *info = drive->driver_data;
2773         struct request_sense sense;
2774         int ret;
2775
2776         if (!CDROM_STATE_FLAGS(drive)->toc_valid || info->toc == NULL)
2777                 if ((ret = cdrom_read_toc(drive, &sense)))
2778                         return ret;
2779
2780         toc = info->toc;
2781         ms_info->addr.lba = toc->last_session_lba;
2782         ms_info->xa_flag = toc->xa_flag;
2783
2784         return 0;
2785 }
2786
2787 static
2788 int ide_cdrom_get_mcn (struct cdrom_device_info *cdi,
2789                        struct cdrom_mcn *mcn_info)
2790 {
2791         int stat;
2792         char mcnbuf[24];
2793         ide_drive_t *drive = cdi->handle;
2794
2795 /* get MCN */
2796         if ((stat = cdrom_read_subchannel(drive, 2, mcnbuf, sizeof (mcnbuf), NULL)))
2797                 return stat;
2798
2799         memcpy (mcn_info->medium_catalog_number, mcnbuf+9,
2800                 sizeof (mcn_info->medium_catalog_number)-1);
2801         mcn_info->medium_catalog_number[sizeof (mcn_info->medium_catalog_number)-1]
2802                 = '\0';
2803
2804         return 0;
2805 }
2806
2807
2808
2809 /****************************************************************************
2810  * Other driver requests (open, close, check media change).
2811  */
2812
2813 static
2814 int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
2815                                        int slot_nr)
2816 {
2817         ide_drive_t *drive = cdi->handle;
2818         int retval;
2819
2820         if (slot_nr == CDSL_CURRENT) {
2821                 (void) cdrom_check_status(drive, NULL);
2822                 retval = CDROM_STATE_FLAGS(drive)->media_changed;
2823                 CDROM_STATE_FLAGS(drive)->media_changed = 0;
2824                 return retval;
2825         } else {
2826                 return -EINVAL;
2827         }
2828 }
2829
2830
2831 static
2832 int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
2833 {
2834         return 0;
2835 }
2836
2837 /*
2838  * Close down the device.  Invalidate all cached blocks.
2839  */
2840
2841 static
2842 void ide_cdrom_release_real (struct cdrom_device_info *cdi)
2843 {
2844         ide_drive_t *drive = cdi->handle;
2845
2846         if (!cdi->use_count)
2847                 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
2848 }
2849
2850
2851
2852 /****************************************************************************
2853  * Device initialization.
2854  */
2855 static struct cdrom_device_ops ide_cdrom_dops = {
2856         .open                   = ide_cdrom_open_real,
2857         .release                = ide_cdrom_release_real,
2858         .drive_status           = ide_cdrom_drive_status,
2859         .media_changed          = ide_cdrom_check_media_change_real,
2860         .tray_move              = ide_cdrom_tray_move,
2861         .lock_door              = ide_cdrom_lock_door,
2862         .select_speed           = ide_cdrom_select_speed,
2863         .get_last_session       = ide_cdrom_get_last_session,
2864         .get_mcn                = ide_cdrom_get_mcn,
2865         .reset                  = ide_cdrom_reset,
2866         .audio_ioctl            = ide_cdrom_audio_ioctl,
2867         .capability             = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
2868                                 CDC_SELECT_SPEED | CDC_SELECT_DISC |
2869                                 CDC_MULTI_SESSION | CDC_MCN |
2870                                 CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO | CDC_RESET |
2871                                 CDC_DRIVE_STATUS | CDC_CD_R |
2872                                 CDC_CD_RW | CDC_DVD | CDC_DVD_R| CDC_DVD_RAM |
2873                                 CDC_GENERIC_PACKET | CDC_MO_DRIVE | CDC_MRW |
2874                                 CDC_MRW_W | CDC_RAM,
2875         .generic_packet         = ide_cdrom_packet,
2876 };
2877
2878 static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2879 {
2880         struct cdrom_info *info = drive->driver_data;
2881         struct cdrom_device_info *devinfo = &info->devinfo;
2882
2883         devinfo->ops = &ide_cdrom_dops;
2884         devinfo->mask = 0;
2885         devinfo->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2886         devinfo->capacity = nslots;
2887         devinfo->handle = drive;
2888         strcpy(devinfo->name, drive->name);
2889
2890         /* set capability mask to match the probe. */
2891         if (!CDROM_CONFIG_FLAGS(drive)->cd_r)
2892                 devinfo->mask |= CDC_CD_R;
2893         if (!CDROM_CONFIG_FLAGS(drive)->cd_rw)
2894                 devinfo->mask |= CDC_CD_RW;
2895         if (!CDROM_CONFIG_FLAGS(drive)->dvd)
2896                 devinfo->mask |= CDC_DVD;
2897         if (!CDROM_CONFIG_FLAGS(drive)->dvd_r)
2898                 devinfo->mask |= CDC_DVD_R;
2899         if (!CDROM_CONFIG_FLAGS(drive)->dvd_ram)
2900                 devinfo->mask |= CDC_DVD_RAM;
2901         if (!CDROM_CONFIG_FLAGS(drive)->is_changer)
2902                 devinfo->mask |= CDC_SELECT_DISC;
2903         if (!CDROM_CONFIG_FLAGS(drive)->audio_play)
2904                 devinfo->mask |= CDC_PLAY_AUDIO;
2905         if (!CDROM_CONFIG_FLAGS(drive)->close_tray)
2906                 devinfo->mask |= CDC_CLOSE_TRAY;
2907         if (!CDROM_CONFIG_FLAGS(drive)->mo_drive)
2908                 devinfo->mask |= CDC_MO_DRIVE;
2909         if (!CDROM_CONFIG_FLAGS(drive)->ram)
2910                 devinfo->mask |= CDC_RAM;
2911
2912         if (CDROM_CONFIG_FLAGS(drive)->no_speed_select)
2913                 devinfo->mask |= CDC_SELECT_SPEED;
2914
2915         devinfo->disk = info->disk;
2916         return register_cdrom(devinfo);
2917 }
2918
2919 static
2920 int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2921 {
2922         struct cdrom_info *info = drive->driver_data;
2923         struct cdrom_device_info *cdi = &info->devinfo;
2924         struct atapi_capabilities_page cap;
2925         int nslots = 1;
2926
2927         if (drive->media == ide_optical) {
2928                 CDROM_CONFIG_FLAGS(drive)->mo_drive = 1;
2929                 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2930                 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
2931                 return nslots;
2932         }
2933
2934         if (CDROM_CONFIG_FLAGS(drive)->nec260 ||
2935             !strcmp(drive->id->model,"STINGRAY 8422 IDE 8X CD-ROM 7-27-95")) {
2936                 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2937                 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2938                 return nslots;
2939         }
2940
2941         /*
2942          * we have to cheat a little here. the packet will eventually
2943          * be queued with ide_cdrom_packet(), which extracts the
2944          * drive from cdi->handle. Since this device hasn't been
2945          * registered with the Uniform layer yet, it can't do this.
2946          * Same goes for cdi->ops.
2947          */
2948         cdi->handle = drive;
2949         cdi->ops = &ide_cdrom_dops;
2950
2951         if (ide_cdrom_get_capabilities(drive, &cap))
2952                 return 0;
2953
2954         if (cap.lock == 0)
2955                 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2956         if (cap.eject)
2957                 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2958         if (cap.cd_r_write)
2959                 CDROM_CONFIG_FLAGS(drive)->cd_r = 1;
2960         if (cap.cd_rw_write) {
2961                 CDROM_CONFIG_FLAGS(drive)->cd_rw = 1;
2962                 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2963         }
2964         if (cap.test_write)
2965                 CDROM_CONFIG_FLAGS(drive)->test_write = 1;
2966         if (cap.dvd_ram_read || cap.dvd_r_read || cap.dvd_rom)
2967                 CDROM_CONFIG_FLAGS(drive)->dvd = 1;
2968         if (cap.dvd_ram_write) {
2969                 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 1;
2970                 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2971         }
2972         if (cap.dvd_r_write)
2973                 CDROM_CONFIG_FLAGS(drive)->dvd_r = 1;
2974         if (cap.audio_play)
2975                 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2976         if (cap.mechtype == mechtype_caddy || cap.mechtype == mechtype_popup)
2977                 CDROM_CONFIG_FLAGS(drive)->close_tray = 0;
2978
2979         /* Some drives used by Apple don't advertise audio play
2980          * but they do support reading TOC & audio datas
2981          */
2982         if (strcmp(drive->id->model, "MATSHITADVD-ROM SR-8187") == 0 ||
2983             strcmp(drive->id->model, "MATSHITADVD-ROM SR-8186") == 0 ||
2984             strcmp(drive->id->model, "MATSHITADVD-ROM SR-8176") == 0 ||
2985             strcmp(drive->id->model, "MATSHITADVD-ROM SR-8174") == 0)
2986                 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2987
2988 #if ! STANDARD_ATAPI
2989         if (cdi->sanyo_slot > 0) {
2990                 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
2991                 nslots = 3;
2992         }
2993
2994         else
2995 #endif /* not STANDARD_ATAPI */
2996         if (cap.mechtype == mechtype_individual_changer ||
2997             cap.mechtype == mechtype_cartridge_changer) {
2998                 if ((nslots = cdrom_number_of_slots(cdi)) > 1) {
2999                         CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
3000                         CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 1;
3001                 }
3002         }
3003
3004         ide_cdrom_update_speed(drive, &cap);
3005         /* don't print speed if the drive reported 0.
3006          */
3007         printk(KERN_INFO "%s: ATAPI", drive->name);
3008         if (CDROM_CONFIG_FLAGS(drive)->max_speed)
3009                 printk(" %dX", CDROM_CONFIG_FLAGS(drive)->max_speed);
3010         printk(" %s", CDROM_CONFIG_FLAGS(drive)->dvd ? "DVD-ROM" : "CD-ROM");
3011
3012         if (CDROM_CONFIG_FLAGS(drive)->dvd_r|CDROM_CONFIG_FLAGS(drive)->dvd_ram)
3013                 printk(" DVD%s%s",
3014                 (CDROM_CONFIG_FLAGS(drive)->dvd_r)? "-R" : "",
3015                 (CDROM_CONFIG_FLAGS(drive)->dvd_ram)? "-RAM" : "");
3016
3017         if (CDROM_CONFIG_FLAGS(drive)->cd_r|CDROM_CONFIG_FLAGS(drive)->cd_rw)
3018                 printk(" CD%s%s",
3019                 (CDROM_CONFIG_FLAGS(drive)->cd_r)? "-R" : "",
3020                 (CDROM_CONFIG_FLAGS(drive)->cd_rw)? "/RW" : "");
3021
3022         if (CDROM_CONFIG_FLAGS(drive)->is_changer)
3023                 printk(" changer w/%d slots", nslots);
3024         else
3025                 printk(" drive");
3026
3027         printk(KERN_CONT ", %dkB Cache\n", be16_to_cpu(cap.buffer_size));
3028
3029         return nslots;
3030 }
3031
3032 #ifdef CONFIG_IDE_PROC_FS
3033 static void ide_cdrom_add_settings(ide_drive_t *drive)
3034 {
3035         ide_add_setting(drive, "dsc_overlap", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
3036 }
3037 #else
3038 static inline void ide_cdrom_add_settings(ide_drive_t *drive) { ; }
3039 #endif
3040
3041 /*
3042  * standard prep_rq_fn that builds 10 byte cmds
3043  */
3044 static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
3045 {
3046         int hard_sect = queue_hardsect_size(q);
3047         long block = (long)rq->hard_sector / (hard_sect >> 9);
3048         unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
3049
3050         memset(rq->cmd, 0, sizeof(rq->cmd));
3051
3052         if (rq_data_dir(rq) == READ)
3053                 rq->cmd[0] = GPCMD_READ_10;
3054         else
3055                 rq->cmd[0] = GPCMD_WRITE_10;
3056
3057         /*
3058          * fill in lba
3059          */
3060         rq->cmd[2] = (block >> 24) & 0xff;
3061         rq->cmd[3] = (block >> 16) & 0xff;
3062         rq->cmd[4] = (block >>  8) & 0xff;
3063         rq->cmd[5] = block & 0xff;
3064
3065         /*
3066          * and transfer length
3067          */
3068         rq->cmd[7] = (blocks >> 8) & 0xff;
3069         rq->cmd[8] = blocks & 0xff;
3070         rq->cmd_len = 10;
3071         return BLKPREP_OK;
3072 }
3073
3074 /*
3075  * Most of the SCSI commands are supported directly by ATAPI devices.
3076  * This transform handles the few exceptions.
3077  */
3078 static int ide_cdrom_prep_pc(struct request *rq)
3079 {
3080         u8 *c = rq->cmd;
3081
3082         /*
3083          * Transform 6-byte read/write commands to the 10-byte version
3084          */
3085         if (c[0] == READ_6 || c[0] == WRITE_6) {
3086                 c[8] = c[4];
3087                 c[5] = c[3];
3088                 c[4] = c[2];
3089                 c[3] = c[1] & 0x1f;
3090                 c[2] = 0;
3091                 c[1] &= 0xe0;
3092                 c[0] += (READ_10 - READ_6);
3093                 rq->cmd_len = 10;
3094                 return BLKPREP_OK;
3095         }
3096
3097         /*
3098          * it's silly to pretend we understand 6-byte sense commands, just
3099          * reject with ILLEGAL_REQUEST and the caller should take the
3100          * appropriate action
3101          */
3102         if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
3103                 rq->errors = ILLEGAL_REQUEST;
3104                 return BLKPREP_KILL;
3105         }
3106
3107         return BLKPREP_OK;
3108 }
3109
3110 static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
3111 {
3112         if (blk_fs_request(rq))
3113                 return ide_cdrom_prep_fs(q, rq);
3114         else if (blk_pc_request(rq))
3115                 return ide_cdrom_prep_pc(rq);
3116
3117         return 0;
3118 }
3119
3120 static
3121 int ide_cdrom_setup (ide_drive_t *drive)
3122 {
3123         struct cdrom_info *info = drive->driver_data;
3124         struct cdrom_device_info *cdi = &info->devinfo;
3125         int nslots;
3126
3127         blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
3128         blk_queue_dma_alignment(drive->queue, 31);
3129         drive->queue->unplug_delay = (1 * HZ) / 1000;
3130         if (!drive->queue->unplug_delay)
3131                 drive->queue->unplug_delay = 1;
3132
3133         drive->special.all      = 0;
3134
3135         CDROM_STATE_FLAGS(drive)->media_changed = 1;
3136         CDROM_STATE_FLAGS(drive)->toc_valid     = 0;
3137         CDROM_STATE_FLAGS(drive)->door_locked   = 0;
3138
3139 #if NO_DOOR_LOCKING
3140         CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
3141 #else
3142         CDROM_CONFIG_FLAGS(drive)->no_doorlock = 0;
3143 #endif
3144
3145         CDROM_CONFIG_FLAGS(drive)->drq_interrupt = ((drive->id->config & 0x0060) == 0x20);
3146         CDROM_CONFIG_FLAGS(drive)->is_changer = 0;
3147         CDROM_CONFIG_FLAGS(drive)->cd_r = 0;
3148         CDROM_CONFIG_FLAGS(drive)->cd_rw = 0;
3149         CDROM_CONFIG_FLAGS(drive)->test_write = 0;
3150         CDROM_CONFIG_FLAGS(drive)->dvd = 0;
3151         CDROM_CONFIG_FLAGS(drive)->dvd_r = 0;
3152         CDROM_CONFIG_FLAGS(drive)->dvd_ram = 0;
3153         CDROM_CONFIG_FLAGS(drive)->no_eject = 1;
3154         CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 0;
3155         CDROM_CONFIG_FLAGS(drive)->audio_play = 0;
3156         CDROM_CONFIG_FLAGS(drive)->close_tray = 1;
3157
3158         /* limit transfer size per interrupt. */
3159         CDROM_CONFIG_FLAGS(drive)->limit_nframes = 0;
3160         /* a testament to the nice quality of Samsung drives... */
3161         if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2430"))
3162                 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3163         else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2432"))
3164                 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3165         /* the 3231 model does not support the SET_CD_SPEED command */
3166         else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-3231"))
3167                 CDROM_CONFIG_FLAGS(drive)->no_speed_select = 1;
3168
3169 #if ! STANDARD_ATAPI
3170         /* by default Sanyo 3 CD changer support is turned off and
3171            ATAPI Rev 2.2+ standard support for CD changers is used */
3172         cdi->sanyo_slot = 0;
3173
3174         CDROM_CONFIG_FLAGS(drive)->nec260 = 0;
3175         CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 0;
3176         CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 0;
3177         CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 0;
3178         CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 0;
3179
3180         if (strcmp (drive->id->model, "V003S0DS") == 0 &&
3181             drive->id->fw_rev[4] == '1' &&
3182             drive->id->fw_rev[6] <= '2') {
3183                 /* Vertos 300.
3184                    Some versions of this drive like to talk BCD. */
3185                 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3186                 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3187                 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3188                 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3189         }
3190
3191         else if (strcmp (drive->id->model, "V006E0DS") == 0 &&
3192             drive->id->fw_rev[4] == '1' &&
3193             drive->id->fw_rev[6] <= '2') {
3194                 /* Vertos 600 ESD. */
3195                 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3196         }
3197         else if (strcmp(drive->id->model, "NEC CD-ROM DRIVE:260") == 0 &&
3198                  strncmp(drive->id->fw_rev, "1.01", 4) == 0) { /* FIXME */
3199                 /* Old NEC260 (not R).
3200                    This drive was released before the 1.2 version
3201                    of the spec. */
3202                 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3203                 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3204                 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3205                 CDROM_CONFIG_FLAGS(drive)->nec260         = 1;
3206         }
3207         else if (strcmp(drive->id->model, "WEARNES CDD-120") == 0 &&
3208                  strncmp(drive->id->fw_rev, "A1.1", 4) == 0) { /* FIXME */
3209                 /* Wearnes */
3210                 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3211                 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3212         }
3213         /* Sanyo 3 CD changer uses a non-standard command
3214            for CD changing */
3215         else if ((strcmp(drive->id->model, "CD-ROM CDR-C3 G") == 0) ||
3216                  (strcmp(drive->id->model, "CD-ROM CDR-C3G") == 0) ||
3217                  (strcmp(drive->id->model, "CD-ROM CDR_C36") == 0)) {
3218                  /* uses CD in slot 0 when value is set to 3 */
3219                  cdi->sanyo_slot = 3;
3220         }
3221 #endif /* not STANDARD_ATAPI */
3222
3223         info->toc               = NULL;
3224         info->buffer            = NULL;
3225         info->sector_buffered   = 0;
3226         info->nsectors_buffered = 0;
3227         info->changer_info      = NULL;
3228         info->last_block        = 0;
3229         info->start_seek        = 0;
3230
3231         nslots = ide_cdrom_probe_capabilities (drive);
3232
3233         /*
3234          * set correct block size
3235          */
3236         blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
3237
3238         if (drive->autotune == IDE_TUNE_DEFAULT ||
3239             drive->autotune == IDE_TUNE_AUTO)
3240                 drive->dsc_overlap = (drive->next != drive);
3241
3242         if (ide_cdrom_register(drive, nslots)) {
3243                 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
3244                 info->devinfo.handle = NULL;
3245                 return 1;
3246         }
3247         ide_cdrom_add_settings(drive);
3248         return 0;
3249 }
3250
3251 #ifdef CONFIG_IDE_PROC_FS
3252 static
3253 sector_t ide_cdrom_capacity (ide_drive_t *drive)
3254 {
3255         unsigned long capacity, sectors_per_frame;
3256
3257         if (cdrom_read_capacity(drive, &capacity, &sectors_per_frame, NULL))
3258                 return 0;
3259
3260         return capacity * sectors_per_frame;
3261 }
3262 #endif
3263
3264 static void ide_cd_remove(ide_drive_t *drive)
3265 {
3266         struct cdrom_info *info = drive->driver_data;
3267
3268         ide_proc_unregister_driver(drive, info->driver);
3269
3270         del_gendisk(info->disk);
3271
3272         ide_cd_put(info);
3273 }
3274
3275 static void ide_cd_release(struct kref *kref)
3276 {
3277         struct cdrom_info *info = to_ide_cd(kref);
3278         struct cdrom_device_info *devinfo = &info->devinfo;
3279         ide_drive_t *drive = info->drive;
3280         struct gendisk *g = info->disk;
3281
3282         kfree(info->buffer);
3283         kfree(info->toc);
3284         kfree(info->changer_info);
3285         if (devinfo->handle == drive && unregister_cdrom(devinfo))
3286                 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom "
3287                                 "driver.\n", __FUNCTION__, drive->name);
3288         drive->dsc_overlap = 0;
3289         drive->driver_data = NULL;
3290         blk_queue_prep_rq(drive->queue, NULL);
3291         g->private_data = NULL;
3292         put_disk(g);
3293         kfree(info);
3294 }
3295
3296 static int ide_cd_probe(ide_drive_t *);
3297
3298 #ifdef CONFIG_IDE_PROC_FS
3299 static int proc_idecd_read_capacity
3300         (char *page, char **start, off_t off, int count, int *eof, void *data)
3301 {
3302         ide_drive_t *drive = data;
3303         int len;
3304
3305         len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
3306         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
3307 }
3308
3309 static ide_proc_entry_t idecd_proc[] = {
3310         { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
3311         { NULL, 0, NULL, NULL }
3312 };
3313 #endif
3314
3315 static ide_driver_t ide_cdrom_driver = {
3316         .gen_driver = {
3317                 .owner          = THIS_MODULE,
3318                 .name           = "ide-cdrom",
3319                 .bus            = &ide_bus_type,
3320         },
3321         .probe                  = ide_cd_probe,
3322         .remove                 = ide_cd_remove,
3323         .version                = IDECD_VERSION,
3324         .media                  = ide_cdrom,
3325         .supports_dsc_overlap   = 1,
3326         .do_request             = ide_do_rw_cdrom,
3327         .end_request            = ide_end_request,
3328         .error                  = __ide_error,
3329         .abort                  = __ide_abort,
3330 #ifdef CONFIG_IDE_PROC_FS
3331         .proc                   = idecd_proc,
3332 #endif
3333 };
3334
3335 static int idecd_open(struct inode * inode, struct file * file)
3336 {
3337         struct gendisk *disk = inode->i_bdev->bd_disk;
3338         struct cdrom_info *info;
3339         int rc = -ENOMEM;
3340
3341         if (!(info = ide_cd_get(disk)))
3342                 return -ENXIO;
3343
3344         if (!info->buffer)
3345                 info->buffer = kmalloc(SECTOR_BUFFER_SIZE, GFP_KERNEL|__GFP_REPEAT);
3346
3347         if (info->buffer)
3348                 rc = cdrom_open(&info->devinfo, inode, file);
3349
3350         if (rc < 0)
3351                 ide_cd_put(info);
3352
3353         return rc;
3354 }
3355
3356 static int idecd_release(struct inode * inode, struct file * file)
3357 {
3358         struct gendisk *disk = inode->i_bdev->bd_disk;
3359         struct cdrom_info *info = ide_cd_g(disk);
3360
3361         cdrom_release (&info->devinfo, file);
3362
3363         ide_cd_put(info);
3364
3365         return 0;
3366 }
3367
3368 static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg)
3369 {
3370         struct packet_command cgc;
3371         char buffer[16];
3372         int stat;
3373         char spindown;
3374
3375         if (copy_from_user(&spindown, (void __user *)arg, sizeof(char)))
3376                 return -EFAULT;
3377
3378         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
3379
3380         stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
3381         if (stat)
3382                 return stat;
3383
3384         buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
3385         return cdrom_mode_select(cdi, &cgc);
3386 }
3387
3388 static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
3389 {
3390         struct packet_command cgc;
3391         char buffer[16];
3392         int stat;
3393         char spindown;
3394
3395         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
3396
3397         stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
3398         if (stat)
3399                 return stat;
3400
3401         spindown = buffer[11] & 0x0f;
3402         if (copy_to_user((void __user *)arg, &spindown, sizeof (char)))
3403                 return -EFAULT;
3404         return 0;
3405 }
3406
3407 static int idecd_ioctl (struct inode *inode, struct file *file,
3408                         unsigned int cmd, unsigned long arg)
3409 {
3410         struct block_device *bdev = inode->i_bdev;
3411         struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
3412         int err;
3413
3414         switch (cmd) {
3415         case CDROMSETSPINDOWN:
3416                 return idecd_set_spindown(&info->devinfo, arg);
3417         case CDROMGETSPINDOWN:
3418                 return idecd_get_spindown(&info->devinfo, arg);
3419         default:
3420                 break;
3421         }
3422
3423         err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
3424         if (err == -EINVAL)
3425                 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
3426
3427         return err;
3428 }
3429
3430 static int idecd_media_changed(struct gendisk *disk)
3431 {
3432         struct cdrom_info *info = ide_cd_g(disk);
3433         return cdrom_media_changed(&info->devinfo);
3434 }
3435
3436 static int idecd_revalidate_disk(struct gendisk *disk)
3437 {
3438         struct cdrom_info *info = ide_cd_g(disk);
3439         struct request_sense sense;
3440         cdrom_read_toc(info->drive, &sense);
3441         return  0;
3442 }
3443
3444 static struct block_device_operations idecd_ops = {
3445         .owner          = THIS_MODULE,
3446         .open           = idecd_open,
3447         .release        = idecd_release,
3448         .ioctl          = idecd_ioctl,
3449         .media_changed  = idecd_media_changed,
3450         .revalidate_disk= idecd_revalidate_disk
3451 };
3452
3453 /* options */
3454 static char *ignore = NULL;
3455
3456 module_param(ignore, charp, 0400);
3457 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
3458
3459 static int ide_cd_probe(ide_drive_t *drive)
3460 {
3461         struct cdrom_info *info;
3462         struct gendisk *g;
3463         struct request_sense sense;
3464
3465         if (!strstr("ide-cdrom", drive->driver_req))
3466                 goto failed;
3467         if (!drive->present)
3468                 goto failed;
3469         if (drive->media != ide_cdrom && drive->media != ide_optical)
3470                 goto failed;
3471         /* skip drives that we were told to ignore */
3472         if (ignore != NULL) {
3473                 if (strstr(ignore, drive->name)) {
3474                         printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
3475                         goto failed;
3476                 }
3477         }
3478         if (drive->scsi) {
3479                 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
3480                 goto failed;
3481         }
3482         info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
3483         if (info == NULL) {
3484                 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
3485                 goto failed;
3486         }
3487
3488         g = alloc_disk(1 << PARTN_BITS);
3489         if (!g)
3490                 goto out_free_cd;
3491
3492         ide_init_disk(g, drive);
3493
3494         ide_proc_register_driver(drive, &ide_cdrom_driver);
3495
3496         kref_init(&info->kref);
3497
3498         info->drive = drive;
3499         info->driver = &ide_cdrom_driver;
3500         info->disk = g;
3501
3502         g->private_data = &info->driver;
3503
3504         drive->driver_data = info;
3505
3506         g->minors = 1;
3507         g->driverfs_dev = &drive->gendev;
3508         g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
3509         if (ide_cdrom_setup(drive)) {
3510                 ide_proc_unregister_driver(drive, &ide_cdrom_driver);
3511                 ide_cd_release(&info->kref);
3512                 goto failed;
3513         }
3514
3515         cdrom_read_toc(drive, &sense);
3516         g->fops = &idecd_ops;
3517         g->flags |= GENHD_FL_REMOVABLE;
3518         add_disk(g);
3519         return 0;
3520
3521 out_free_cd:
3522         kfree(info);
3523 failed:
3524         return -ENODEV;
3525 }
3526
3527 static void __exit ide_cdrom_exit(void)
3528 {
3529         driver_unregister(&ide_cdrom_driver.gen_driver);
3530 }
3531
3532 static int __init ide_cdrom_init(void)
3533 {
3534         return driver_register(&ide_cdrom_driver.gen_driver);
3535 }
3536
3537 MODULE_ALIAS("ide:*m-cdrom*");
3538 module_init(ide_cdrom_init);
3539 module_exit(ide_cdrom_exit);
3540 MODULE_LICENSE("GPL");