drivers/ide/ide-cd.c

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