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

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