drivers/ide/ide-cd.c

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