drivers/ide/ide-cd.c

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