drivers/ide/ide-cd.c

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