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 static 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 static 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         ide_hwif_t *hwif = drive->hwif;
 930
 931         /* Wait for the controller to be idle. */
 932         if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY))
 933                 return startstop;
 934
 935         if (info->dma)
 936                 info->dma = !hwif->ide_dma_setup(drive);
 937
 938         /* Set up the controller registers. */
 939         /* FIXME: for Virtual DMA we must check harder */
 940         HWIF(drive)->OUTB(info->dma, IDE_FEATURE_REG);
 941         HWIF(drive)->OUTB(0, IDE_IREASON_REG);
 942         HWIF(drive)->OUTB(0, IDE_SECTOR_REG);
 943
 944         HWIF(drive)->OUTB(xferlen & 0xff, IDE_BCOUNTL_REG);
 945         HWIF(drive)->OUTB(xferlen >> 8  , IDE_BCOUNTH_REG);
 946         if (IDE_CONTROL_REG)
 947                 HWIF(drive)->OUTB(drive->ctl, IDE_CONTROL_REG);
 948
 949         if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt) {
 950                 /* packet command */
 951                 ide_execute_command(drive, WIN_PACKETCMD, handler, ATAPI_WAIT_PC, cdrom_timer_expiry);
 952                 return ide_started;
 953         } else {
 954                 unsigned long flags;
 955
 956                 /* packet command */
 957                 spin_lock_irqsave(&ide_lock, flags);
 958                 hwif->OUTBSYNC(drive, WIN_PACKETCMD, IDE_COMMAND_REG);
 959                 ndelay(400);
 960                 spin_unlock_irqrestore(&ide_lock, flags);
 961
 962                 return (*handler) (drive);
 963         }
 964 }
 965
 966 /* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
 967    The device registers must have already been prepared
 968    by cdrom_start_packet_command.
 969    HANDLER is the interrupt handler to call when the command completes
 970    or there's data ready. */
 971 /*
 972  * changed 5 parameters to 3 for dvd-ram
 973  * struct packet_command *pc; now packet_command_t *pc;
 974  */
 975 #define ATAPI_MIN_CDB_BYTES 12
 976 static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
 977                                           struct request *rq,
 978                                           ide_handler_t *handler)
 979 {
 980         ide_hwif_t *hwif = drive->hwif;
 981         int cmd_len;
 982         struct cdrom_info *info = drive->driver_data;
 983         ide_startstop_t startstop;
 984
 985         if (CDROM_CONFIG_FLAGS(drive)->drq_interrupt) {
 986                 /* Here we should have been called after receiving an interrupt
 987                    from the device.  DRQ should how be set. */
 988
 989                 /* Check for errors. */
 990                 if (cdrom_decode_status(drive, DRQ_STAT, NULL))
 991                         return ide_stopped;
 992         } else {
 993                 /* Otherwise, we must wait for DRQ to get set. */
 994                 if (ide_wait_stat(&startstop, drive, DRQ_STAT,
 995                                 BUSY_STAT, WAIT_READY))
 996                         return startstop;
 997         }
 998
 999         /* Arm the interrupt handler. */
1000         ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);
1001
1002         /* ATAPI commands get padded out to 12 bytes minimum */
1003         cmd_len = COMMAND_SIZE(rq->cmd[0]);
1004         if (cmd_len < ATAPI_MIN_CDB_BYTES)
1005                 cmd_len = ATAPI_MIN_CDB_BYTES;
1006
1007         /* Send the command to the device. */
1008         HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len);
1009
1010         /* Start the DMA if need be */
1011         if (info->dma)
1012                 hwif->ide_dma_start(drive);
1013
1014         return ide_started;
1015 }
1016
1017 /****************************************************************************
1018  * Block read functions.
1019  */
1020
1021 /*
1022  * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
1023  * buffer.  Once the first sector is added, any subsequent sectors are
1024  * assumed to be continuous (until the buffer is cleared).  For the first
1025  * sector added, SECTOR is its sector number.  (SECTOR is then ignored until
1026  * the buffer is cleared.)
1027  */
1028 static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
1029                                   int sectors_to_transfer)
1030 {
1031         struct cdrom_info *info = drive->driver_data;
1032
1033         /* Number of sectors to read into the buffer. */
1034         int sectors_to_buffer = min_t(int, sectors_to_transfer,
1035                                      (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
1036                                        info->nsectors_buffered);
1037
1038         char *dest;
1039
1040         /* If we couldn't get a buffer, don't try to buffer anything... */
1041         if (info->buffer == NULL)
1042                 sectors_to_buffer = 0;
1043
1044         /* If this is the first sector in the buffer, remember its number. */
1045         if (info->nsectors_buffered == 0)
1046                 info->sector_buffered = sector;
1047
1048         /* Read the data into the buffer. */
1049         dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
1050         while (sectors_to_buffer > 0) {
1051                 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
1052                 --sectors_to_buffer;
1053                 --sectors_to_transfer;
1054                 ++info->nsectors_buffered;
1055                 dest += SECTOR_SIZE;
1056         }
1057
1058         /* Throw away any remaining data. */
1059         while (sectors_to_transfer > 0) {
1060                 static char dum[SECTOR_SIZE];
1061                 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1062                 --sectors_to_transfer;
1063         }
1064 }
1065
1066 /*
1067  * Check the contents of the interrupt reason register from the cdrom
1068  * and attempt to recover if there are problems.  Returns  0 if everything's
1069  * ok; nonzero if the request has been terminated.
1070  */
1071 static inline
1072 int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
1073 {
1074         if (ireason == 2)
1075                 return 0;
1076         else if (ireason == 0) {
1077                 /* Whoops... The drive is expecting to receive data from us! */
1078                 printk(KERN_ERR "%s: read_intr: Drive wants to transfer data the "
1079                                                 "wrong way!\n", drive->name);
1080
1081                 /* Throw some data at the drive so it doesn't hang
1082                    and quit this request. */
1083                 while (len > 0) {
1084                         int dum = 0;
1085                         HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof (dum));
1086                         len -= sizeof (dum);
1087                 }
1088         } else  if (ireason == 1) {
1089                 /* Some drives (ASUS) seem to tell us that status
1090                  * info is available. just get it and ignore.
1091                  */
1092                 (void) HWIF(drive)->INB(IDE_STATUS_REG);
1093                 return 0;
1094         } else {
1095                 /* Drive wants a command packet, or invalid ireason... */
1096                 printk(KERN_ERR "%s: read_intr: bad interrupt reason %x\n", drive->name,
1097                                                                 ireason);
1098         }
1099
1100         cdrom_end_request(drive, 0);
1101         return -1;
1102 }
1103
1104 /*
1105  * Interrupt routine.  Called when a read request has completed.
1106  */
1107 static ide_startstop_t cdrom_read_intr (ide_drive_t *drive)
1108 {
1109         int stat;
1110         int ireason, len, sectors_to_transfer, nskip;
1111         struct cdrom_info *info = drive->driver_data;
1112         u8 lowcyl = 0, highcyl = 0;
1113         int dma = info->dma, dma_error = 0;
1114
1115         struct request *rq = HWGROUP(drive)->rq;
1116
1117         /*
1118          * handle dma case
1119          */
1120         if (dma) {
1121                 info->dma = 0;
1122                 if ((dma_error = HWIF(drive)->ide_dma_end(drive)))
1123                         __ide_dma_off(drive);
1124         }
1125
1126         if (cdrom_decode_status(drive, 0, &stat))
1127                 return ide_stopped;
1128
1129         if (dma) {
1130                 if (!dma_error) {
1131                         ide_end_request(drive, 1, rq->nr_sectors);
1132                         return ide_stopped;
1133                 } else
1134                         return DRIVER(drive)->error(drive, "dma error", stat);
1135         }
1136
1137         /* Read the interrupt reason and the transfer length. */
1138         ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1139         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1140         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1141
1142         len = lowcyl + (256 * highcyl);
1143
1144         /* If DRQ is clear, the command has completed. */
1145         if ((stat & DRQ_STAT) == 0) {
1146                 /* If we're not done filling the current buffer, complain.
1147                    Otherwise, complete the command normally. */
1148                 if (rq->current_nr_sectors > 0) {
1149                         printk (KERN_ERR "%s: cdrom_read_intr: data underrun (%d blocks)\n",
1150                                 drive->name, rq->current_nr_sectors);
1151                         rq->flags |= REQ_FAILED;
1152                         cdrom_end_request(drive, 0);
1153                 } else
1154                         cdrom_end_request(drive, 1);
1155                 return ide_stopped;
1156         }
1157
1158         /* Check that the drive is expecting to do the same thing we are. */
1159         if (cdrom_read_check_ireason (drive, len, ireason))
1160                 return ide_stopped;
1161
1162         /* Assume that the drive will always provide data in multiples
1163            of at least SECTOR_SIZE, as it gets hairy to keep track
1164            of the transfers otherwise. */
1165         if ((len % SECTOR_SIZE) != 0) {
1166                 printk (KERN_ERR "%s: cdrom_read_intr: Bad transfer size %d\n",
1167                         drive->name, len);
1168                 if (CDROM_CONFIG_FLAGS(drive)->limit_nframes)
1169                         printk (KERN_ERR "  This drive is not supported by this version of the driver\n");
1170                 else {
1171                         printk (KERN_ERR "  Trying to limit transfer sizes\n");
1172                         CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
1173                 }
1174                 cdrom_end_request(drive, 0);
1175                 return ide_stopped;
1176         }
1177
1178         /* The number of sectors we need to read from the drive. */
1179         sectors_to_transfer = len / SECTOR_SIZE;
1180
1181         /* First, figure out if we need to bit-bucket
1182            any of the leading sectors. */
1183         nskip = min_t(int, rq->current_nr_sectors - bio_cur_sectors(rq->bio), sectors_to_transfer);
1184
1185         while (nskip > 0) {
1186                 /* We need to throw away a sector. */
1187                 static char dum[SECTOR_SIZE];
1188                 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1189
1190                 --rq->current_nr_sectors;
1191                 --nskip;
1192                 --sectors_to_transfer;
1193         }
1194
1195         /* Now loop while we still have data to read from the drive. */
1196         while (sectors_to_transfer > 0) {
1197                 int this_transfer;
1198
1199                 /* If we've filled the present buffer but there's another
1200                    chained buffer after it, move on. */
1201                 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1202                         cdrom_end_request(drive, 1);
1203
1204                 /* If the buffers are full, cache the rest of the data in our
1205                    internal buffer. */
1206                 if (rq->current_nr_sectors == 0) {
1207                         cdrom_buffer_sectors(drive, rq->sector, sectors_to_transfer);
1208                         sectors_to_transfer = 0;
1209                 } else {
1210                         /* Transfer data to the buffers.
1211                            Figure out how many sectors we can transfer
1212                            to the current buffer. */
1213                         this_transfer = min_t(int, sectors_to_transfer,
1214                                              rq->current_nr_sectors);
1215
1216                         /* Read this_transfer sectors
1217                            into the current buffer. */
1218                         while (this_transfer > 0) {
1219                                 HWIF(drive)->atapi_input_bytes(drive, rq->buffer, SECTOR_SIZE);
1220                                 rq->buffer += SECTOR_SIZE;
1221                                 --rq->nr_sectors;
1222                                 --rq->current_nr_sectors;
1223                                 ++rq->sector;
1224                                 --this_transfer;
1225                                 --sectors_to_transfer;
1226                         }
1227                 }
1228         }
1229
1230         /* Done moving data!  Wait for another interrupt. */
1231         ide_set_handler(drive, &cdrom_read_intr, ATAPI_WAIT_PC, NULL);
1232         return ide_started;
1233 }
1234
1235 /*
1236  * Try to satisfy some of the current read request from our cached data.
1237  * Returns nonzero if the request has been completed, zero otherwise.
1238  */
1239 static int cdrom_read_from_buffer (ide_drive_t *drive)
1240 {
1241         struct cdrom_info *info = drive->driver_data;
1242         struct request *rq = HWGROUP(drive)->rq;
1243         unsigned short sectors_per_frame;
1244
1245         sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1246
1247         /* Can't do anything if there's no buffer. */
1248         if (info->buffer == NULL) return 0;
1249
1250         /* Loop while this request needs data and the next block is present
1251            in our cache. */
1252         while (rq->nr_sectors > 0 &&
1253                rq->sector >= info->sector_buffered &&
1254                rq->sector < info->sector_buffered + info->nsectors_buffered) {
1255                 if (rq->current_nr_sectors == 0)
1256                         cdrom_end_request(drive, 1);
1257
1258                 memcpy (rq->buffer,
1259                         info->buffer +
1260                         (rq->sector - info->sector_buffered) * SECTOR_SIZE,
1261                         SECTOR_SIZE);
1262                 rq->buffer += SECTOR_SIZE;
1263                 --rq->current_nr_sectors;
1264                 --rq->nr_sectors;
1265                 ++rq->sector;
1266         }
1267
1268         /* If we've satisfied the current request,
1269            terminate it successfully. */
1270         if (rq->nr_sectors == 0) {
1271                 cdrom_end_request(drive, 1);
1272                 return -1;
1273         }
1274
1275         /* Move on to the next buffer if needed. */
1276         if (rq->current_nr_sectors == 0)
1277                 cdrom_end_request(drive, 1);
1278
1279         /* If this condition does not hold, then the kluge i use to
1280            represent the number of sectors to skip at the start of a transfer
1281            will fail.  I think that this will never happen, but let's be
1282            paranoid and check. */
1283         if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
1284             (rq->sector & (sectors_per_frame - 1))) {
1285                 printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
1286                         drive->name, (long)rq->sector);
1287                 cdrom_end_request(drive, 0);
1288                 return -1;
1289         }
1290
1291         return 0;
1292 }
1293
1294 /*
1295  * Routine to send a read packet command to the drive.
1296  * This is usually called directly from cdrom_start_read.
1297  * However, for drq_interrupt devices, it is called from an interrupt
1298  * when the drive is ready to accept the command.
1299  */
1300 static ide_startstop_t cdrom_start_read_continuation (ide_drive_t *drive)
1301 {
1302         struct request *rq = HWGROUP(drive)->rq;
1303         unsigned short sectors_per_frame;
1304         int nskip;
1305
1306         sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1307
1308         /* If the requested sector doesn't start on a cdrom block boundary,
1309            we must adjust the start of the transfer so that it does,
1310            and remember to skip the first few sectors.
1311            If the CURRENT_NR_SECTORS field is larger than the size
1312            of the buffer, it will mean that we're to skip a number
1313            of sectors equal to the amount by which CURRENT_NR_SECTORS
1314            is larger than the buffer size. */
1315         nskip = rq->sector & (sectors_per_frame - 1);
1316         if (nskip > 0) {
1317                 /* Sanity check... */
1318                 if (rq->current_nr_sectors != bio_cur_sectors(rq->bio) &&
1319                         (rq->sector & (sectors_per_frame - 1))) {
1320                         printk(KERN_ERR "%s: cdrom_start_read_continuation: buffer botch (%u)\n",
1321                                 drive->name, rq->current_nr_sectors);
1322                         cdrom_end_request(drive, 0);
1323                         return ide_stopped;
1324                 }
1325                 rq->current_nr_sectors += nskip;
1326         }
1327
1328         /* Set up the command */
1329         rq->timeout = ATAPI_WAIT_PC;
1330
1331         /* Send the command to the drive and return. */
1332         return cdrom_transfer_packet_command(drive, rq, &cdrom_read_intr);
1333 }
1334
1335
1336 #define IDECD_SEEK_THRESHOLD    (1000)                  /* 1000 blocks */
1337 #define IDECD_SEEK_TIMER        (5 * WAIT_MIN_SLEEP)    /* 100 ms */
1338 #define IDECD_SEEK_TIMEOUT      (2 * WAIT_CMD)          /* 20 sec */
1339
1340 static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
1341 {
1342         struct cdrom_info *info = drive->driver_data;
1343         int stat;
1344         static int retry = 10;
1345
1346         if (cdrom_decode_status(drive, 0, &stat))
1347                 return ide_stopped;
1348         CDROM_CONFIG_FLAGS(drive)->seeking = 1;
1349
1350         if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
1351                 if (--retry == 0) {
1352                         /*
1353                          * this condition is far too common, to bother
1354                          * users about it
1355                          */
1356                         /* printk("%s: disabled DSC seek overlap\n", drive->name);*/
1357                         drive->dsc_overlap = 0;
1358                 }
1359         }
1360         return ide_stopped;
1361 }
1362
1363 static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
1364 {
1365         struct request *rq = HWGROUP(drive)->rq;
1366         sector_t frame = rq->sector;
1367
1368         sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
1369
1370         memset(rq->cmd, 0, sizeof(rq->cmd));
1371         rq->cmd[0] = GPCMD_SEEK;
1372         put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
1373
1374         rq->timeout = ATAPI_WAIT_PC;
1375         return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
1376 }
1377
1378 static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
1379 {
1380         struct cdrom_info *info = drive->driver_data;
1381
1382         info->dma = 0;
1383         info->cmd = 0;
1384         info->start_seek = jiffies;
1385         return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
1386 }
1387
1388 /* Fix up a possibly partially-processed request so that we can
1389    start it over entirely, or even put it back on the request queue. */
1390 static void restore_request (struct request *rq)
1391 {
1392         if (rq->buffer != bio_data(rq->bio)) {
1393                 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
1394
1395                 rq->buffer = bio_data(rq->bio);
1396                 rq->nr_sectors += n;
1397                 rq->sector -= n;
1398         }
1399         rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
1400         rq->hard_nr_sectors = rq->nr_sectors;
1401         rq->hard_sector = rq->sector;
1402         rq->q->prep_rq_fn(rq->q, rq);
1403 }
1404
1405 /*
1406  * Start a read request from the CD-ROM.
1407  */
1408 static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block)
1409 {
1410         struct cdrom_info *info = drive->driver_data;
1411         struct request *rq = HWGROUP(drive)->rq;
1412         unsigned short sectors_per_frame;
1413
1414         sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1415
1416         /* We may be retrying this request after an error.  Fix up
1417            any weirdness which might be present in the request packet. */
1418         restore_request(rq);
1419
1420         /* Satisfy whatever we can of this request from our cached sector. */
1421         if (cdrom_read_from_buffer(drive))
1422                 return ide_stopped;
1423
1424         blk_attempt_remerge(drive->queue, rq);
1425
1426         /* Clear the local sector buffer. */
1427         info->nsectors_buffered = 0;
1428
1429         /* use dma, if possible. */
1430         info->dma = drive->using_dma;
1431         if ((rq->sector & (sectors_per_frame - 1)) ||
1432             (rq->nr_sectors & (sectors_per_frame - 1)))
1433                 info->dma = 0;
1434
1435         info->cmd = READ;
1436
1437         /* Start sending the read request to the drive. */
1438         return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
1439 }
1440
1441 /****************************************************************************
1442  * Execute all other packet commands.
1443  */
1444
1445 /* Interrupt routine for packet command completion. */
1446 static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
1447 {
1448         int ireason, len, thislen;
1449         struct request *rq = HWGROUP(drive)->rq;
1450         u8 lowcyl = 0, highcyl = 0;
1451         int stat;
1452
1453         /* Check for errors. */
1454         if (cdrom_decode_status(drive, 0, &stat))
1455                 return ide_stopped;
1456
1457         /* Read the interrupt reason and the transfer length. */
1458         ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1459         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1460         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1461
1462         len = lowcyl + (256 * highcyl);
1463
1464         /* If DRQ is clear, the command has completed.
1465            Complain if we still have data left to transfer. */
1466         if ((stat & DRQ_STAT) == 0) {
1467                 /* Some of the trailing request sense fields are optional, and
1468                    some drives don't send them.  Sigh. */
1469                 if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
1470                     rq->data_len > 0 &&
1471                     rq->data_len <= 5) {
1472                         while (rq->data_len > 0) {
1473                                 *(unsigned char *)rq->data++ = 0;
1474                                 --rq->data_len;
1475                         }
1476                 }
1477
1478                 if (rq->data_len == 0)
1479                         cdrom_end_request(drive, 1);
1480                 else {
1481                         /* Comment this out, because this always happens
1482                            right after a reset occurs, and it is annoying to
1483                            always print expected stuff.  */
1484                         /*
1485                         printk ("%s: cdrom_pc_intr: data underrun %d\n",
1486                                 drive->name, pc->buflen);
1487                         */
1488                         rq->flags |= REQ_FAILED;
1489                         cdrom_end_request(drive, 0);
1490                 }
1491                 return ide_stopped;
1492         }
1493
1494         /* Figure out how much data to transfer. */
1495         thislen = rq->data_len;
1496         if (thislen > len) thislen = len;
1497
1498         /* The drive wants to be written to. */
1499         if ((ireason & 3) == 0) {
1500                 if (!rq->data) {
1501                         blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1502                         goto confused;
1503                 }
1504                 /* Transfer the data. */
1505                 HWIF(drive)->atapi_output_bytes(drive, rq->data, thislen);
1506
1507                 /* If we haven't moved enough data to satisfy the drive,
1508                    add some padding. */
1509                 while (len > thislen) {
1510                         int dum = 0;
1511                         HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof(dum));
1512                         len -= sizeof(dum);
1513                 }
1514
1515                 /* Keep count of how much data we've moved. */
1516                 rq->data += thislen;
1517                 rq->data_len -= thislen;
1518         }
1519
1520         /* Same drill for reading. */
1521         else if ((ireason & 3) == 2) {
1522                 if (!rq->data) {
1523                         blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1524                         goto confused;
1525                 }
1526                 /* Transfer the data. */
1527                 HWIF(drive)->atapi_input_bytes(drive, rq->data, thislen);
1528
1529                 /* If we haven't moved enough data to satisfy the drive,
1530                    add some padding. */
1531                 while (len > thislen) {
1532                         int dum = 0;
1533                         HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1534                         len -= sizeof(dum);
1535                 }
1536
1537                 /* Keep count of how much data we've moved. */
1538                 rq->data += thislen;
1539                 rq->data_len -= thislen;
1540
1541                 if (rq->flags & REQ_SENSE)
1542                         rq->sense_len += thislen;
1543         } else {
1544 confused:
1545                 printk (KERN_ERR "%s: cdrom_pc_intr: The drive "
1546                         "appears confused (ireason = 0x%02x)\n",
1547                         drive->name, ireason);
1548                 rq->flags |= REQ_FAILED;
1549         }
1550
1551         /* Now we wait for another interrupt. */
1552         ide_set_handler(drive, &cdrom_pc_intr, ATAPI_WAIT_PC, cdrom_timer_expiry);
1553         return ide_started;
1554 }
1555
1556 static ide_startstop_t cdrom_do_pc_continuation (ide_drive_t *drive)
1557 {
1558         struct request *rq = HWGROUP(drive)->rq;
1559
1560         if (!rq->timeout)
1561                 rq->timeout = ATAPI_WAIT_PC;
1562
1563         /* Send the command to the drive and return. */
1564         return cdrom_transfer_packet_command(drive, rq, &cdrom_pc_intr);
1565 }
1566
1567
1568 static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
1569 {
1570         int len;
1571         struct request *rq = HWGROUP(drive)->rq;
1572         struct cdrom_info *info = drive->driver_data;
1573
1574         info->dma = 0;
1575         info->cmd = 0;
1576         rq->flags &= ~REQ_FAILED;
1577         len = rq->data_len;
1578
1579         /* Start sending the command to the drive. */
1580         return cdrom_start_packet_command(drive, len, cdrom_do_pc_continuation);
1581 }
1582
1583
1584 static int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
1585 {
1586         struct request_sense sense;
1587         int retries = 10;
1588         unsigned int flags = rq->flags;
1589
1590         if (rq->sense == NULL)
1591                 rq->sense = &sense;
1592
1593         /* Start of retry loop. */
1594         do {
1595                 int error;
1596                 unsigned long time = jiffies;
1597                 rq->flags = flags;
1598
1599                 error = ide_do_drive_cmd(drive, rq, ide_wait);
1600                 time = jiffies - time;
1601
1602                 /* FIXME: we should probably abort/retry or something
1603                  * in case of failure */
1604                 if (rq->flags & REQ_FAILED) {
1605                         /* The request failed.  Retry if it was due to a unit
1606                            attention status
1607                            (usually means media was changed). */
1608                         struct request_sense *reqbuf = rq->sense;
1609
1610                         if (reqbuf->sense_key == UNIT_ATTENTION)
1611                                 cdrom_saw_media_change(drive);
1612                         else if (reqbuf->sense_key == NOT_READY &&
1613                                  reqbuf->asc == 4 && reqbuf->ascq != 4) {
1614                                 /* The drive is in the process of loading
1615                                    a disk.  Retry, but wait a little to give
1616                                    the drive time to complete the load. */
1617                                 msleep(2000);
1618                         } else {
1619                                 /* Otherwise, don't retry. */
1620                                 retries = 0;
1621                         }
1622                         --retries;
1623                 }
1624
1625                 /* End of retry loop. */
1626         } while ((rq->flags & REQ_FAILED) && retries >= 0);
1627
1628         /* Return an error if the command failed. */
1629         return (rq->flags & REQ_FAILED) ? -EIO : 0;
1630 }
1631
1632 /*
1633  * Write handling
1634  */
1635 static inline int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
1636 {
1637         /* Two notes about IDE interrupt reason here - 0 means that
1638          * the drive wants to receive data from us, 2 means that
1639          * the drive is expecting to transfer data to us.
1640          */
1641         if (ireason == 0)
1642                 return 0;
1643         else if (ireason == 2) {
1644                 /* Whoops... The drive wants to send data. */
1645                 printk(KERN_ERR "%s: write_intr: wrong transfer direction!\n",
1646                                                         drive->name);
1647
1648                 while (len > 0) {
1649                         int dum = 0;
1650                         HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1651                         len -= sizeof(dum);
1652                 }
1653         } else {
1654                 /* Drive wants a command packet, or invalid ireason... */
1655                 printk(KERN_ERR "%s: write_intr: bad interrupt reason %x\n",
1656                                                         drive->name, ireason);
1657         }
1658
1659         cdrom_end_request(drive, 0);
1660         return 1;
1661 }
1662
1663 static void post_transform_command(struct request *req)
1664 {
1665         u8 *c = req->cmd;
1666         char *ibuf;
1667
1668         if (!blk_pc_request(req))
1669                 return;
1670
1671         if (req->bio)
1672                 ibuf = bio_data(req->bio);
1673         else
1674                 ibuf = req->data;
1675
1676         if (!ibuf)
1677                 return;
1678
1679         /*
1680          * set ansi-revision and response data as atapi
1681          */
1682         if (c[0] == GPCMD_INQUIRY) {
1683                 ibuf[2] |= 2;
1684                 ibuf[3] = (ibuf[3] & 0xf0) | 2;
1685         }
1686 }
1687
1688 typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
1689
1690 /*
1691  * best way to deal with dma that is not sector aligned right now... note
1692  * that in this path we are not using ->data or ->buffer at all. this irs
1693  * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the
1694  * future.
1695  */
1696 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1697 {
1698         struct cdrom_info *info = drive->driver_data;
1699         struct request *rq = HWGROUP(drive)->rq;
1700         int dma_error, dma, stat, ireason, len, thislen;
1701         u8 lowcyl, highcyl;
1702         xfer_func_t *xferfunc;
1703         unsigned long flags;
1704
1705         /* Check for errors. */
1706         dma_error = 0;
1707         dma = info->dma;
1708         if (dma) {
1709                 info->dma = 0;
1710                 dma_error = HWIF(drive)->ide_dma_end(drive);
1711         }
1712
1713         if (cdrom_decode_status(drive, 0, &stat))
1714                 return ide_stopped;
1715
1716         /*
1717          * using dma, transfer is complete now
1718          */
1719         if (dma) {
1720                 if (dma_error) {
1721                         printk(KERN_ERR "ide-cd: dma error\n");
1722                         __ide_dma_off(drive);
1723                         return DRIVER(drive)->error(drive, "dma error", stat);
1724                 }
1725
1726                 end_that_request_chunk(rq, 1, rq->data_len);
1727                 rq->data_len = 0;
1728                 goto end_request;
1729         }
1730
1731         /*
1732          * ok we fall to pio :/
1733          */
1734         ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1735         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1736         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1737
1738         len = lowcyl + (256 * highcyl);
1739         thislen = rq->data_len;
1740         if (thislen > len)
1741                 thislen = len;
1742
1743         /*
1744          * If DRQ is clear, the command has completed.
1745          */
1746         if ((stat & DRQ_STAT) == 0)
1747                 goto end_request;
1748
1749         /*
1750          * check which way to transfer data
1751          */
1752         if (rq_data_dir(rq) == WRITE) {
1753                 /*
1754                  * write to drive
1755                  */
1756                 if (cdrom_write_check_ireason(drive, len, ireason))
1757                         return ide_stopped;
1758
1759                 xferfunc = HWIF(drive)->atapi_output_bytes;
1760         } else  {
1761                 /*
1762                  * read from drive
1763                  */
1764                 if (cdrom_read_check_ireason(drive, len, ireason))
1765                         return ide_stopped;
1766
1767                 xferfunc = HWIF(drive)->atapi_input_bytes;
1768         }
1769
1770         /*
1771          * transfer data
1772          */
1773         while (thislen > 0) {
1774                 int blen = blen = rq->data_len;
1775                 char *ptr = rq->data;
1776
1777                 /*
1778                  * bio backed?
1779                  */
1780                 if (rq->bio) {
1781                         ptr = bio_data(rq->bio);
1782                         blen = bio_iovec(rq->bio)->bv_len;
1783                 }
1784
1785                 if (!ptr) {
1786                         printk(KERN_ERR "%s: confused, missing data\n", drive->name);
1787                         break;
1788                 }
1789
1790                 if (blen > thislen)
1791                         blen = thislen;
1792
1793                 xferfunc(drive, ptr, blen);
1794
1795                 thislen -= blen;
1796                 len -= blen;
1797                 rq->data_len -= blen;
1798
1799                 if (rq->bio)
1800                         end_that_request_chunk(rq, 1, blen);
1801                 else
1802                         rq->data += blen;
1803         }
1804
1805         /*
1806          * pad, if necessary
1807          */
1808         if (len > 0) {
1809                 while (len > 0) {
1810                         int pad = 0;
1811
1812                         xferfunc(drive, &pad, sizeof(pad));
1813                         len -= sizeof(pad);
1814                 }
1815         }
1816
1817         if (HWGROUP(drive)->handler != NULL)
1818                 BUG();
1819
1820         ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, NULL);
1821         return ide_started;
1822
1823 end_request:
1824         if (!rq->data_len)
1825                 post_transform_command(rq);
1826
1827         spin_lock_irqsave(&ide_lock, flags);
1828         blkdev_dequeue_request(rq);
1829         end_that_request_last(rq);
1830         HWGROUP(drive)->rq = NULL;
1831         spin_unlock_irqrestore(&ide_lock, flags);
1832         return ide_stopped;
1833 }
1834
1835 static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
1836 {
1837         int stat, ireason, len, sectors_to_transfer, uptodate;
1838         struct cdrom_info *info = drive->driver_data;
1839         int dma_error = 0, dma = info->dma;
1840         u8 lowcyl = 0, highcyl = 0;
1841
1842         struct request *rq = HWGROUP(drive)->rq;
1843
1844         /* Check for errors. */
1845         if (dma) {
1846                 info->dma = 0;
1847                 if ((dma_error = HWIF(drive)->ide_dma_end(drive))) {
1848                         printk(KERN_ERR "ide-cd: write dma error\n");
1849                         __ide_dma_off(drive);
1850                 }
1851         }
1852
1853         if (cdrom_decode_status(drive, 0, &stat))
1854                 return ide_stopped;
1855
1856         /*
1857          * using dma, transfer is complete now
1858          */
1859         if (dma) {
1860                 if (dma_error)
1861                         return DRIVER(drive)->error(drive, "dma error", stat);
1862
1863                 ide_end_request(drive, 1, rq->nr_sectors);
1864                 return ide_stopped;
1865         }
1866
1867         /* Read the interrupt reason and the transfer length. */
1868         ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1869         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1870         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1871
1872         len = lowcyl + (256 * highcyl);
1873
1874         /* If DRQ is clear, the command has completed. */
1875         if ((stat & DRQ_STAT) == 0) {
1876                 /* If we're not done writing, complain.
1877                  * Otherwise, complete the command normally.
1878                  */
1879                 uptodate = 1;
1880                 if (rq->current_nr_sectors > 0) {
1881                         printk(KERN_ERR "%s: write_intr: data underrun (%d blocks)\n",
1882                         drive->name, rq->current_nr_sectors);
1883                         uptodate = 0;
1884                 }
1885                 cdrom_end_request(drive, uptodate);
1886                 return ide_stopped;
1887         }
1888
1889         /* Check that the drive is expecting to do the same thing we are. */
1890         if (cdrom_write_check_ireason(drive, len, ireason))
1891                 return ide_stopped;
1892
1893         sectors_to_transfer = len / SECTOR_SIZE;
1894
1895         /*
1896          * now loop and write out the data
1897          */
1898         while (sectors_to_transfer > 0) {
1899                 int this_transfer;
1900
1901                 if (!rq->current_nr_sectors) {
1902                         printk(KERN_ERR "ide-cd: write_intr: oops\n");
1903                         break;
1904                 }
1905
1906                 /*
1907                  * Figure out how many sectors we can transfer
1908                  */
1909                 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors);
1910
1911                 while (this_transfer > 0) {
1912                         HWIF(drive)->atapi_output_bytes(drive, rq->buffer, SECTOR_SIZE);
1913                         rq->buffer += SECTOR_SIZE;
1914                         --rq->nr_sectors;
1915                         --rq->current_nr_sectors;
1916                         ++rq->sector;
1917                         --this_transfer;
1918                         --sectors_to_transfer;
1919                 }
1920
1921                 /*
1922                  * current buffer complete, move on
1923                  */
1924                 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1925                         cdrom_end_request(drive, 1);
1926         }
1927
1928         /* re-arm handler */
1929         ide_set_handler(drive, &cdrom_write_intr, ATAPI_WAIT_PC, NULL);
1930         return ide_started;
1931 }
1932
1933 static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
1934 {
1935         struct request *rq = HWGROUP(drive)->rq;
1936
1937 #if 0   /* the immediate bit */
1938         rq->cmd[1] = 1 << 3;
1939 #endif
1940         rq->timeout = ATAPI_WAIT_PC;
1941
1942         return cdrom_transfer_packet_command(drive, rq, cdrom_write_intr);
1943 }
1944
1945 static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
1946 {
1947         struct cdrom_info *info = drive->driver_data;
1948         struct gendisk *g = drive->disk;
1949         unsigned short sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1950
1951         /*
1952          * writes *must* be hardware frame aligned
1953          */
1954         if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1955             (rq->sector & (sectors_per_frame - 1))) {
1956                 cdrom_end_request(drive, 0);
1957                 return ide_stopped;
1958         }
1959
1960         /*
1961          * disk has become write protected
1962          */
1963         if (g->policy) {
1964                 cdrom_end_request(drive, 0);
1965                 return ide_stopped;
1966         }
1967
1968         /*
1969          * for dvd-ram and such media, it's a really big deal to get
1970          * big writes all the time. so scour the queue and attempt to
1971          * remerge requests, often the plugging will not have had time
1972          * to do this properly
1973          */
1974         blk_attempt_remerge(drive->queue, rq);
1975
1976         info->nsectors_buffered = 0;
1977
1978         /* use dma, if possible. we don't need to check more, since we
1979          * know that the transfer is always (at least!) frame aligned */
1980         info->dma = drive->using_dma ? 1 : 0;
1981         info->cmd = WRITE;
1982
1983         info->devinfo.media_written = 1;
1984
1985         /* Start sending the write request to the drive. */
1986         return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
1987 }
1988
1989 static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1990 {
1991         struct request *rq = HWGROUP(drive)->rq;
1992
1993         if (!rq->timeout)
1994                 rq->timeout = ATAPI_WAIT_PC;
1995
1996         return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1997 }
1998
1999 static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
2000 {
2001         struct cdrom_info *info = drive->driver_data;
2002
2003         rq->flags |= REQ_QUIET;
2004
2005         info->dma = 0;
2006         info->cmd = 0;
2007
2008         /*
2009          * sg request
2010          */
2011         if (rq->bio) {
2012                 int mask = drive->queue->dma_alignment;
2013                 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
2014
2015                 info->cmd = rq_data_dir(rq);
2016                 info->dma = drive->using_dma;
2017
2018                 /*
2019                  * check if dma is safe
2020                  */
2021                 if ((rq->data_len & mask) || (addr & mask))
2022                         info->dma = 0;
2023         }
2024
2025         /* Start sending the command to the drive. */
2026         return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
2027 }
2028
2029 /****************************************************************************
2030  * cdrom driver request routine.
2031  */
2032 static ide_startstop_t
2033 ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
2034 {
2035         ide_startstop_t action;
2036         struct cdrom_info *info = drive->driver_data;
2037
2038         if (blk_fs_request(rq)) {
2039                 if (CDROM_CONFIG_FLAGS(drive)->seeking) {
2040                         unsigned long elapsed = jiffies - info->start_seek;
2041                         int stat = HWIF(drive)->INB(IDE_STATUS_REG);
2042
2043                         if ((stat & SEEK_STAT) != SEEK_STAT) {
2044                                 if (elapsed < IDECD_SEEK_TIMEOUT) {
2045                                         ide_stall_queue(drive, IDECD_SEEK_TIMER);
2046                                         return ide_stopped;
2047                                 }
2048                                 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
2049                         }
2050                         CDROM_CONFIG_FLAGS(drive)->seeking = 0;
2051                 }
2052                 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
2053                         action = cdrom_start_seek(drive, block);
2054                 } else {
2055                         if (rq_data_dir(rq) == READ)
2056                                 action = cdrom_start_read(drive, block);
2057                         else
2058                                 action = cdrom_start_write(drive, rq);
2059                 }
2060                 info->last_block = block;
2061                 return action;
2062         } else if (rq->flags & (REQ_PC | REQ_SENSE)) {
2063                 return cdrom_do_packet_command(drive);
2064         } else if (rq->flags & REQ_BLOCK_PC) {
2065                 return cdrom_do_block_pc(drive, rq);
2066         } else if (rq->flags & REQ_SPECIAL) {
2067                 /*
2068                  * right now this can only be a reset...
2069                  */
2070                 cdrom_end_request(drive, 1);
2071                 return ide_stopped;
2072         }
2073
2074         blk_dump_rq_flags(rq, "ide-cd bad flags");
2075         cdrom_end_request(drive, 0);
2076         return ide_stopped;
2077 }
2078
2079
2080
2081 /****************************************************************************
2082  * Ioctl handling.
2083  *
2084  * Routines which queue packet commands take as a final argument a pointer
2085  * to a request_sense struct.  If execution of the command results
2086  * in an error with a CHECK CONDITION status, this structure will be filled
2087  * with the results of the subsequent request sense command.  The pointer
2088  * can also be NULL, in which case no sense information is returned.
2089  */
2090
2091 #if ! STANDARD_ATAPI
2092 static inline
2093 int bin2bcd (int x)
2094 {
2095         return (x%10) | ((x/10) << 4);
2096 }
2097
2098
2099 static inline
2100 int bcd2bin (int x)
2101 {
2102         return (x >> 4) * 10 + (x & 0x0f);
2103 }
2104
2105 static
2106 void msf_from_bcd (struct atapi_msf *msf)
2107 {
2108         msf->minute = bcd2bin (msf->minute);
2109         msf->second = bcd2bin (msf->second);
2110         msf->frame  = bcd2bin (msf->frame);
2111 }
2112
2113 #endif /* not STANDARD_ATAPI */
2114
2115
2116 static inline
2117 void lba_to_msf (int lba, byte *m, byte *s, byte *f)
2118 {
2119         lba += CD_MSF_OFFSET;
2120         lba &= 0xffffff;  /* negative lbas use only 24 bits */
2121         *m = lba / (CD_SECS * CD_FRAMES);
2122         lba %= (CD_SECS * CD_FRAMES);
2123         *s = lba / CD_FRAMES;
2124         *f = lba % CD_FRAMES;
2125 }
2126
2127
2128 static inline
2129 int msf_to_lba (byte m, byte s, byte f)
2130 {
2131         return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
2132 }
2133
2134 static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
2135 {
2136         struct request req;
2137         struct cdrom_info *info = drive->driver_data;
2138         struct cdrom_device_info *cdi = &info->devinfo;
2139
2140         cdrom_prepare_request(&req);
2141
2142         req.sense = sense;
2143         req.cmd[0] = GPCMD_TEST_UNIT_READY;
2144         req.flags |= REQ_QUIET;
2145
2146 #if ! STANDARD_ATAPI
2147         /* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
2148            switch CDs instead of supporting the LOAD_UNLOAD opcode   */
2149
2150         req.cmd[7] = cdi->sanyo_slot % 3;
2151 #endif /* not STANDARD_ATAPI */
2152
2153         return cdrom_queue_packet_command(drive, &req);
2154 }
2155
2156
2157 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
2158 static int
2159 cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
2160 {
2161         struct request_sense my_sense;
2162         struct request req;
2163         int stat;
2164
2165         if (sense == NULL)
2166                 sense = &my_sense;
2167
2168         /* If the drive cannot lock the door, just pretend. */
2169         if (CDROM_CONFIG_FLAGS(drive)->no_doorlock) {
2170                 stat = 0;
2171         } else {
2172                 cdrom_prepare_request(&req);
2173                 req.sense = sense;
2174                 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
2175                 req.cmd[4] = lockflag ? 1 : 0;
2176                 stat = cdrom_queue_packet_command(drive, &req);
2177         }
2178
2179         /* If we got an illegal field error, the drive
2180            probably cannot lock the door. */
2181         if (stat != 0 &&
2182             sense->sense_key == ILLEGAL_REQUEST &&
2183             (sense->asc == 0x24 || sense->asc == 0x20)) {
2184                 printk (KERN_ERR "%s: door locking not supported\n",
2185                         drive->name);
2186                 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2187                 stat = 0;
2188         }
2189
2190         /* no medium, that's alright. */
2191         if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
2192                 stat = 0;
2193
2194         if (stat == 0)
2195                 CDROM_STATE_FLAGS(drive)->door_locked = lockflag;
2196
2197         return stat;
2198 }
2199
2200
2201 /* Eject the disk if EJECTFLAG is 0.
2202    If EJECTFLAG is 1, try to reload the disk. */
2203 static int cdrom_eject(ide_drive_t *drive, int ejectflag,
2204                        struct request_sense *sense)
2205 {
2206         struct request req;
2207         char loej = 0x02;
2208
2209         if (CDROM_CONFIG_FLAGS(drive)->no_eject && !ejectflag)
2210                 return -EDRIVE_CANT_DO_THIS;
2211
2212         /* reload fails on some drives, if the tray is locked */
2213         if (CDROM_STATE_FLAGS(drive)->door_locked && ejectflag)
2214                 return 0;
2215
2216         cdrom_prepare_request(&req);
2217
2218         /* only tell drive to close tray if open, if it can do that */
2219         if (ejectflag && !CDROM_CONFIG_FLAGS(drive)->close_tray)
2220                 loej = 0;
2221
2222         req.sense = sense;
2223         req.cmd[0] = GPCMD_START_STOP_UNIT;
2224         req.cmd[4] = loej | (ejectflag != 0);
2225         return cdrom_queue_packet_command(drive, &req);
2226 }
2227
2228 static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
2229                                unsigned long *sectors_per_frame,
2230                                struct request_sense *sense)
2231 {
2232         struct {
2233                 __u32 lba;
2234                 __u32 blocklen;
2235         } capbuf;
2236
2237         int stat;
2238         struct request req;
2239
2240         cdrom_prepare_request(&req);
2241
2242         req.sense = sense;
2243         req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
2244         req.data = (char *)&capbuf;
2245         req.data_len = sizeof(capbuf);
2246
2247         stat = cdrom_queue_packet_command(drive, &req);
2248         if (stat == 0) {
2249                 *capacity = 1 + be32_to_cpu(capbuf.lba);
2250                 *sectors_per_frame =
2251                         be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
2252         }
2253
2254         return stat;
2255 }
2256
2257 static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
2258                                 int format, char *buf, int buflen,
2259                                 struct request_sense *sense)
2260 {
2261         struct request req;
2262
2263         cdrom_prepare_request(&req);
2264
2265         req.sense = sense;
2266         req.data =  buf;
2267         req.data_len = buflen;
2268         req.flags |= REQ_QUIET;
2269         req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
2270         req.cmd[6] = trackno;
2271         req.cmd[7] = (buflen >> 8);
2272         req.cmd[8] = (buflen & 0xff);
2273         req.cmd[9] = (format << 6);
2274
2275         if (msf_flag)
2276                 req.cmd[1] = 2;
2277
2278         return cdrom_queue_packet_command(drive, &req);
2279 }
2280
2281
2282 /* Try to read the entire TOC for the disk into our internal buffer. */
2283 static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2284 {
2285         int stat, ntracks, i;
2286         struct cdrom_info *info = drive->driver_data;
2287         struct cdrom_device_info *cdi = &info->devinfo;
2288         struct atapi_toc *toc = info->toc;
2289         struct {
2290                 struct atapi_toc_header hdr;
2291                 struct atapi_toc_entry  ent;
2292         } ms_tmp;
2293         long last_written;
2294         unsigned long sectors_per_frame = SECTORS_PER_FRAME;
2295
2296         if (toc == NULL) {
2297                 /* Try to allocate space. */
2298                 toc = (struct atapi_toc *) kmalloc (sizeof (struct atapi_toc),
2299                                                     GFP_KERNEL);
2300                 info->toc = toc;
2301                 if (toc == NULL) {
2302                         printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
2303                         return -ENOMEM;
2304                 }
2305         }
2306
2307         /* Check to see if the existing data is still valid.
2308            If it is, just return. */
2309         (void) cdrom_check_status(drive, sense);
2310
2311         if (CDROM_STATE_FLAGS(drive)->toc_valid)
2312                 return 0;
2313
2314         /* Try to get the total cdrom capacity and sector size. */
2315         stat = cdrom_read_capacity(drive, &toc->capacity, &sectors_per_frame,
2316                                    sense);
2317         if (stat)
2318                 toc->capacity = 0x1fffff;
2319
2320         set_capacity(drive->disk, toc->capacity * sectors_per_frame);
2321         /* Save a private copy of te TOC capacity for error handling */
2322         drive->probed_capacity = toc->capacity * sectors_per_frame;
2323
2324         blk_queue_hardsect_size(drive->queue,
2325                                 sectors_per_frame << SECTOR_BITS);
2326
2327         /* First read just the header, so we know how long the TOC is. */
2328         stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
2329                                     sizeof(struct atapi_toc_header), sense);
2330         if (stat) return stat;
2331
2332 #if ! STANDARD_ATAPI
2333         if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2334                 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2335                 toc->hdr.last_track  = bcd2bin(toc->hdr.last_track);
2336         }
2337 #endif  /* not STANDARD_ATAPI */
2338
2339         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2340         if (ntracks <= 0)
2341                 return -EIO;
2342         if (ntracks > MAX_TRACKS)
2343                 ntracks = MAX_TRACKS;
2344
2345         /* Now read the whole schmeer. */
2346         stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
2347                                   (char *)&toc->hdr,
2348                                    sizeof(struct atapi_toc_header) +
2349                                    (ntracks + 1) *
2350                                    sizeof(struct atapi_toc_entry), sense);
2351
2352         if (stat && toc->hdr.first_track > 1) {
2353                 /* Cds with CDI tracks only don't have any TOC entries,
2354                    despite of this the returned values are
2355                    first_track == last_track = number of CDI tracks + 1,
2356                    so that this case is indistinguishable from the same
2357                    layout plus an additional audio track.
2358                    If we get an error for the regular case, we assume
2359                    a CDI without additional audio tracks. In this case
2360                    the readable TOC is empty (CDI tracks are not included)
2361                    and only holds the Leadout entry. Heiko Eißfeldt */
2362                 ntracks = 0;
2363                 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
2364                                            (char *)&toc->hdr,
2365                                            sizeof(struct atapi_toc_header) +
2366                                            (ntracks + 1) *
2367                                            sizeof(struct atapi_toc_entry),
2368                                            sense);
2369                 if (stat) {
2370                         return stat;
2371                 }
2372 #if ! STANDARD_ATAPI
2373                 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2374                         toc->hdr.first_track = bin2bcd(CDROM_LEADOUT);
2375                         toc->hdr.last_track = bin2bcd(CDROM_LEADOUT);
2376                 } else
2377 #endif  /* not STANDARD_ATAPI */
2378                 {
2379                         toc->hdr.first_track = CDROM_LEADOUT;
2380                         toc->hdr.last_track = CDROM_LEADOUT;
2381                 }
2382         }
2383
2384         if (stat)
2385                 return stat;
2386
2387         toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
2388
2389 #if ! STANDARD_ATAPI
2390         if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2391                 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2392                 toc->hdr.last_track  = bcd2bin(toc->hdr.last_track);
2393         }
2394 #endif  /* not STANDARD_ATAPI */
2395
2396         for (i=0; i<=ntracks; i++) {
2397 #if ! STANDARD_ATAPI
2398                 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2399                         if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd)
2400                                 toc->ent[i].track = bcd2bin(toc->ent[i].track);
2401                         msf_from_bcd(&toc->ent[i].addr.msf);
2402                 }
2403 #endif  /* not STANDARD_ATAPI */
2404                 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
2405                                                    toc->ent[i].addr.msf.second,
2406                                                    toc->ent[i].addr.msf.frame);
2407         }
2408
2409         /* Read the multisession information. */
2410         if (toc->hdr.first_track != CDROM_LEADOUT) {
2411                 /* Read the multisession information. */
2412                 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
2413                                            sizeof(ms_tmp), sense);
2414                 if (stat) return stat;
2415
2416                 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
2417         } else {
2418                 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
2419                 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
2420         }
2421
2422 #if ! STANDARD_ATAPI
2423         if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2424                 /* Re-read multisession information using MSF format */
2425                 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
2426                                            sizeof(ms_tmp), sense);
2427                 if (stat)
2428                         return stat;
2429
2430                 msf_from_bcd (&ms_tmp.ent.addr.msf);
2431                 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
2432                                                    ms_tmp.ent.addr.msf.second,
2433                                                    ms_tmp.ent.addr.msf.frame);
2434         }
2435 #endif  /* not STANDARD_ATAPI */
2436
2437         toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
2438
2439         /* Now try to get the total cdrom capacity. */
2440         stat = cdrom_get_last_written(cdi, &last_written);
2441         if (!stat && (last_written > toc->capacity)) {
2442                 toc->capacity = last_written;
2443                 set_capacity(drive->disk, toc->capacity * sectors_per_frame);
2444                 drive->probed_capacity = toc->capacity * sectors_per_frame;
2445         }
2446
2447         /* Remember that we've read this stuff. */
2448         CDROM_STATE_FLAGS(drive)->toc_valid = 1;
2449
2450         return 0;
2451 }
2452
2453
2454 static int cdrom_read_subchannel(ide_drive_t *drive, int format, char *buf,
2455                                  int buflen, struct request_sense *sense)
2456 {
2457         struct request req;
2458
2459         cdrom_prepare_request(&req);
2460
2461         req.sense = sense;
2462         req.data = buf;
2463         req.data_len = buflen;
2464         req.cmd[0] = GPCMD_READ_SUBCHANNEL;
2465         req.cmd[1] = 2;     /* MSF addressing */
2466         req.cmd[2] = 0x40;  /* request subQ data */
2467         req.cmd[3] = format;
2468         req.cmd[7] = (buflen >> 8);
2469         req.cmd[8] = (buflen & 0xff);
2470         return cdrom_queue_packet_command(drive, &req);
2471 }
2472
2473 /* ATAPI cdrom drives are free to select the speed you request or any slower
2474    rate :-( Requesting too fast a speed will _not_ produce an error. */
2475 static int cdrom_select_speed(ide_drive_t *drive, int speed,
2476                               struct request_sense *sense)
2477 {
2478         struct request req;
2479         cdrom_prepare_request(&req);
2480
2481         req.sense = sense;
2482         if (speed == 0)
2483                 speed = 0xffff; /* set to max */
2484         else
2485                 speed *= 177;   /* Nx to kbytes/s */
2486
2487         req.cmd[0] = GPCMD_SET_SPEED;
2488         /* Read Drive speed in kbytes/second MSB */
2489         req.cmd[2] = (speed >> 8) & 0xff;
2490         /* Read Drive speed in kbytes/second LSB */
2491         req.cmd[3] = speed & 0xff;
2492         if (CDROM_CONFIG_FLAGS(drive)->cd_r ||
2493             CDROM_CONFIG_FLAGS(drive)->cd_rw ||
2494             CDROM_CONFIG_FLAGS(drive)->dvd_r) {
2495                 /* Write Drive speed in kbytes/second MSB */
2496                 req.cmd[4] = (speed >> 8) & 0xff;
2497                 /* Write Drive speed in kbytes/second LSB */
2498                 req.cmd[5] = speed & 0xff;
2499        }
2500
2501         return cdrom_queue_packet_command(drive, &req);
2502 }
2503
2504 static int cdrom_play_audio(ide_drive_t *drive, int lba_start, int lba_end)
2505 {
2506         struct request_sense sense;
2507         struct request req;
2508
2509         cdrom_prepare_request(&req);
2510
2511         req.sense = &sense;
2512         req.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2513         lba_to_msf(lba_start, &req.cmd[3], &req.cmd[4], &req.cmd[5]);
2514         lba_to_msf(lba_end-1, &req.cmd[6], &req.cmd[7], &req.cmd[8]);
2515
2516         return cdrom_queue_packet_command(drive, &req);
2517 }
2518
2519 static int cdrom_get_toc_entry(ide_drive_t *drive, int track,
2520                                 struct atapi_toc_entry **ent)
2521 {
2522         struct cdrom_info *info = drive->driver_data;
2523         struct atapi_toc *toc = info->toc;
2524         int ntracks;
2525
2526         /*
2527          * don't serve cached data, if the toc isn't valid
2528          */
2529         if (!CDROM_STATE_FLAGS(drive)->toc_valid)
2530                 return -EINVAL;
2531
2532         /* Check validity of requested track number. */
2533         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2534         if (toc->hdr.first_track == CDROM_LEADOUT) ntracks = 0;
2535         if (track == CDROM_LEADOUT)
2536                 *ent = &toc->ent[ntracks];
2537         else if (track < toc->hdr.first_track ||
2538                  track > toc->hdr.last_track)
2539                 return -EINVAL;
2540         else
2541                 *ent = &toc->ent[track - toc->hdr.first_track];
2542
2543         return 0;
2544 }
2545
2546 /* the generic packet interface to cdrom.c */
2547 static int ide_cdrom_packet(struct cdrom_device_info *cdi,
2548                             struct packet_command *cgc)
2549 {
2550         struct request req;
2551         ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2552
2553         if (cgc->timeout <= 0)
2554                 cgc->timeout = ATAPI_WAIT_PC;
2555
2556         /* here we queue the commands from the uniform CD-ROM
2557            layer. the packet must be complete, as we do not
2558            touch it at all. */
2559         cdrom_prepare_request(&req);
2560         memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
2561         if (cgc->sense)
2562                 memset(cgc->sense, 0, sizeof(struct request_sense));
2563         req.data = cgc->buffer;
2564         req.data_len = cgc->buflen;
2565         req.timeout = cgc->timeout;
2566
2567         if (cgc->quiet)
2568                 req.flags |= REQ_QUIET;
2569
2570         req.sense = cgc->sense;
2571         cgc->stat = cdrom_queue_packet_command(drive, &req);
2572         if (!cgc->stat)
2573                 cgc->buflen -= req.data_len;
2574         return cgc->stat;
2575 }
2576
2577 static
2578 int ide_cdrom_dev_ioctl (struct cdrom_device_info *cdi,
2579                          unsigned int cmd, unsigned long arg)
2580 {
2581         struct packet_command cgc;
2582         char buffer[16];
2583         int stat;
2584
2585         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2586
2587         /* These will be moved into the Uniform layer shortly... */
2588         switch (cmd) {
2589         case CDROMSETSPINDOWN: {
2590                 char spindown;
2591
2592                 if (copy_from_user(&spindown, (void __user *) arg, sizeof(char)))
2593                         return -EFAULT;
2594
2595                 if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0)))
2596                         return stat;
2597
2598                 buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
2599
2600                 return cdrom_mode_select(cdi, &cgc);
2601         }
2602
2603         case CDROMGETSPINDOWN: {
2604                 char spindown;
2605
2606                 if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0)))
2607                         return stat;
2608
2609                 spindown = buffer[11] & 0x0f;
2610
2611                 if (copy_to_user((void __user *) arg, &spindown, sizeof (char)))
2612                         return -EFAULT;
2613
2614                 return 0;
2615         }
2616
2617         default:
2618                 return -EINVAL;
2619         }
2620
2621 }
2622
2623 static
2624 int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
2625                            unsigned int cmd, void *arg)
2626
2627 {
2628         ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2629         struct cdrom_info *info = drive->driver_data;
2630         int stat;
2631
2632         switch (cmd) {
2633         /*
2634          * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
2635          * atapi doesn't support it
2636          */
2637         case CDROMPLAYTRKIND: {
2638                 unsigned long lba_start, lba_end;
2639                 struct cdrom_ti *ti = (struct cdrom_ti *)arg;
2640                 struct atapi_toc_entry *first_toc, *last_toc;
2641
2642                 stat = cdrom_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
2643                 if (stat)
2644                         return stat;
2645
2646                 stat = cdrom_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
2647                 if (stat)
2648                         return stat;
2649
2650                 if (ti->cdti_trk1 != CDROM_LEADOUT)
2651                         ++last_toc;
2652                 lba_start = first_toc->addr.lba;
2653                 lba_end   = last_toc->addr.lba;
2654
2655                 if (lba_end <= lba_start)
2656                         return -EINVAL;
2657
2658                 return cdrom_play_audio(drive, lba_start, lba_end);
2659         }
2660
2661         case CDROMREADTOCHDR: {
2662                 struct cdrom_tochdr *tochdr = (struct cdrom_tochdr *) arg;
2663                 struct atapi_toc *toc;
2664
2665                 /* Make sure our saved TOC is valid. */
2666                 stat = cdrom_read_toc(drive, NULL);
2667                 if (stat) return stat;
2668
2669                 toc = info->toc;
2670                 tochdr->cdth_trk0 = toc->hdr.first_track;
2671                 tochdr->cdth_trk1 = toc->hdr.last_track;
2672
2673                 return 0;
2674         }
2675
2676         case CDROMREADTOCENTRY: {
2677                 struct cdrom_tocentry *tocentry = (struct cdrom_tocentry*) arg;
2678                 struct atapi_toc_entry *toce;
2679
2680                 stat = cdrom_get_toc_entry(drive, tocentry->cdte_track, &toce);
2681                 if (stat) return stat;
2682
2683                 tocentry->cdte_ctrl = toce->control;
2684                 tocentry->cdte_adr  = toce->adr;
2685                 if (tocentry->cdte_format == CDROM_MSF) {
2686                         lba_to_msf (toce->addr.lba,
2687                                    &tocentry->cdte_addr.msf.minute,
2688                                    &tocentry->cdte_addr.msf.second,
2689                                    &tocentry->cdte_addr.msf.frame);
2690                 } else
2691                         tocentry->cdte_addr.lba = toce->addr.lba;
2692
2693                 return 0;
2694         }
2695
2696         default:
2697                 return -EINVAL;
2698         }
2699 }
2700
2701 static
2702 int ide_cdrom_reset (struct cdrom_device_info *cdi)
2703 {
2704         ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2705         struct request_sense sense;
2706         struct request req;
2707         int ret;
2708
2709         cdrom_prepare_request(&req);
2710         req.flags = REQ_SPECIAL | REQ_QUIET;
2711         ret = ide_do_drive_cmd(drive, &req, ide_wait);
2712
2713         /*
2714          * A reset will unlock the door. If it was previously locked,
2715          * lock it again.
2716          */
2717         if (CDROM_STATE_FLAGS(drive)->door_locked)
2718                 (void) cdrom_lockdoor(drive, 1, &sense);
2719
2720         return ret;
2721 }
2722
2723
2724 static
2725 int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
2726 {
2727         ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2728         struct request_sense sense;
2729
2730         if (position) {
2731                 int stat = cdrom_lockdoor(drive, 0, &sense);
2732                 if (stat) return stat;
2733         }
2734
2735         return cdrom_eject(drive, !position, &sense);
2736 }
2737
2738 static
2739 int ide_cdrom_lock_door (struct cdrom_device_info *cdi, int lock)
2740 {
2741         ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2742         return cdrom_lockdoor(drive, lock, NULL);
2743 }
2744
2745 static
2746 int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
2747 {
2748         ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2749         struct request_sense sense;
2750         int stat;
2751
2752         if ((stat = cdrom_select_speed(drive, speed, &sense)) < 0)
2753                 return stat;
2754
2755         cdi->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2756         return 0;
2757 }
2758
2759 /*
2760  * add logic to try GET_EVENT command first to check for media and tray
2761  * status. this should be supported by newer cd-r/w and all DVD etc
2762  * drives
2763  */
2764 static
2765 int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
2766 {
2767         ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2768         struct media_event_desc med;
2769         struct request_sense sense;
2770         int stat;
2771
2772         if (slot_nr != CDSL_CURRENT)
2773                 return -EINVAL;
2774
2775         stat = cdrom_check_status(drive, &sense);
2776         if (!stat || sense.sense_key == UNIT_ATTENTION)
2777                 return CDS_DISC_OK;
2778
2779         if (!cdrom_get_media_event(cdi, &med)) {
2780                 if (med.media_present)
2781                         return CDS_DISC_OK;
2782                 else if (med.door_open)
2783                         return CDS_TRAY_OPEN;
2784                 else
2785                         return CDS_NO_DISC;
2786         }
2787
2788         if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
2789                 return CDS_DISC_OK;
2790
2791         /*
2792          * If not using Mt Fuji extended media tray reports,
2793          * just return TRAY_OPEN since ATAPI doesn't provide
2794          * any other way to detect this...
2795          */
2796         if (sense.sense_key == NOT_READY) {
2797                 if (sense.asc == 0x3a && sense.ascq == 1)
2798                         return CDS_NO_DISC;
2799                 else
2800                         return CDS_TRAY_OPEN;
2801         }
2802
2803         return CDS_DRIVE_NOT_READY;
2804 }
2805
2806 static
2807 int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
2808                                 struct cdrom_multisession *ms_info)
2809 {
2810         struct atapi_toc *toc;
2811         ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2812         struct cdrom_info *info = drive->driver_data;
2813         struct request_sense sense;
2814         int ret;
2815
2816         if (!CDROM_STATE_FLAGS(drive)->toc_valid || info->toc == NULL)
2817                 if ((ret = cdrom_read_toc(drive, &sense)))
2818                         return ret;
2819
2820         toc = info->toc;
2821         ms_info->addr.lba = toc->last_session_lba;
2822         ms_info->xa_flag = toc->xa_flag;
2823
2824         return 0;
2825 }
2826
2827 static
2828 int ide_cdrom_get_mcn (struct cdrom_device_info *cdi,
2829                        struct cdrom_mcn *mcn_info)
2830 {
2831         int stat;
2832         char mcnbuf[24];
2833         ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2834
2835 /* get MCN */
2836         if ((stat = cdrom_read_subchannel(drive, 2, mcnbuf, sizeof (mcnbuf), NULL)))
2837                 return stat;
2838
2839         memcpy (mcn_info->medium_catalog_number, mcnbuf+9,
2840                 sizeof (mcn_info->medium_catalog_number)-1);
2841         mcn_info->medium_catalog_number[sizeof (mcn_info->medium_catalog_number)-1]
2842                 = '\0';
2843
2844         return 0;
2845 }
2846
2847
2848
2849 /****************************************************************************
2850  * Other driver requests (open, close, check media change).
2851  */
2852
2853 static
2854 int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
2855                                        int slot_nr)
2856 {
2857         ide_drive_t *drive = (ide_drive_t*) cdi->handle;
2858         int retval;
2859
2860         if (slot_nr == CDSL_CURRENT) {
2861                 (void) cdrom_check_status(drive, NULL);
2862                 retval = CDROM_STATE_FLAGS(drive)->media_changed;
2863                 CDROM_STATE_FLAGS(drive)->media_changed = 0;
2864                 return retval;
2865         } else {
2866                 return -EINVAL;
2867         }
2868 }
2869
2870
2871 static
2872 int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
2873 {
2874         return 0;
2875 }
2876
2877 /*
2878  * Close down the device.  Invalidate all cached blocks.
2879  */
2880
2881 static
2882 void ide_cdrom_release_real (struct cdrom_device_info *cdi)
2883 {
2884         ide_drive_t *drive = cdi->handle;
2885
2886         if (!cdi->use_count)
2887                 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
2888 }
2889
2890
2891
2892 /****************************************************************************
2893  * Device initialization.
2894  */
2895 static struct cdrom_device_ops ide_cdrom_dops = {
2896         .open                   = ide_cdrom_open_real,
2897         .release                = ide_cdrom_release_real,
2898         .drive_status           = ide_cdrom_drive_status,
2899         .media_changed          = ide_cdrom_check_media_change_real,
2900         .tray_move              = ide_cdrom_tray_move,
2901         .lock_door              = ide_cdrom_lock_door,
2902         .select_speed           = ide_cdrom_select_speed,
2903         .get_last_session       = ide_cdrom_get_last_session,
2904         .get_mcn                = ide_cdrom_get_mcn,
2905         .reset                  = ide_cdrom_reset,
2906         .audio_ioctl            = ide_cdrom_audio_ioctl,
2907         .dev_ioctl              = ide_cdrom_dev_ioctl,
2908         .capability             = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
2909                                 CDC_SELECT_SPEED | CDC_SELECT_DISC |
2910                                 CDC_MULTI_SESSION | CDC_MCN |
2911                                 CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO | CDC_RESET |
2912                                 CDC_IOCTLS | CDC_DRIVE_STATUS | CDC_CD_R |
2913                                 CDC_CD_RW | CDC_DVD | CDC_DVD_R| CDC_DVD_RAM |
2914                                 CDC_GENERIC_PACKET | CDC_MO_DRIVE | CDC_MRW |
2915                                 CDC_MRW_W | CDC_RAM,
2916         .generic_packet         = ide_cdrom_packet,
2917 };
2918
2919 static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2920 {
2921         struct cdrom_info *info = drive->driver_data;
2922         struct cdrom_device_info *devinfo = &info->devinfo;
2923
2924         devinfo->ops = &ide_cdrom_dops;
2925         devinfo->mask = 0;
2926         devinfo->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2927         devinfo->capacity = nslots;
2928         devinfo->handle = (void *) drive;
2929         strcpy(devinfo->name, drive->name);
2930
2931         /* set capability mask to match the probe. */
2932         if (!CDROM_CONFIG_FLAGS(drive)->cd_r)
2933                 devinfo->mask |= CDC_CD_R;
2934         if (!CDROM_CONFIG_FLAGS(drive)->cd_rw)
2935                 devinfo->mask |= CDC_CD_RW;
2936         if (!CDROM_CONFIG_FLAGS(drive)->dvd)
2937                 devinfo->mask |= CDC_DVD;
2938         if (!CDROM_CONFIG_FLAGS(drive)->dvd_r)
2939                 devinfo->mask |= CDC_DVD_R;
2940         if (!CDROM_CONFIG_FLAGS(drive)->dvd_ram)
2941                 devinfo->mask |= CDC_DVD_RAM;
2942         if (!CDROM_CONFIG_FLAGS(drive)->is_changer)
2943                 devinfo->mask |= CDC_SELECT_DISC;
2944         if (!CDROM_CONFIG_FLAGS(drive)->audio_play)
2945                 devinfo->mask |= CDC_PLAY_AUDIO;
2946         if (!CDROM_CONFIG_FLAGS(drive)->close_tray)
2947                 devinfo->mask |= CDC_CLOSE_TRAY;
2948         if (!CDROM_CONFIG_FLAGS(drive)->mo_drive)
2949                 devinfo->mask |= CDC_MO_DRIVE;
2950
2951         devinfo->disk = drive->disk;
2952         return register_cdrom(devinfo);
2953 }
2954
2955 static
2956 int ide_cdrom_get_capabilities(ide_drive_t *drive, struct atapi_capabilities_page *cap)
2957 {
2958         struct cdrom_info *info = drive->driver_data;
2959         struct cdrom_device_info *cdi = &info->devinfo;
2960         struct packet_command cgc;
2961         int stat, attempts = 3, size = sizeof(*cap);
2962
2963         /*
2964          * ACER50 (and others?) require the full spec length mode sense
2965          * page capabilities size, but older drives break.
2966          */
2967         if (!(!strcmp(drive->id->model, "ATAPI CD ROM DRIVE 50X MAX") ||
2968             !strcmp(drive->id->model, "WPI CDS-32X")))
2969                 size -= sizeof(cap->pad);
2970
2971         init_cdrom_command(&cgc, cap, size, CGC_DATA_UNKNOWN);
2972         do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2973                 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
2974                 if (!stat)
2975                         break;
2976         } while (--attempts);
2977         return stat;
2978 }
2979
2980 static
2981 int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2982 {
2983         struct cdrom_info *info = drive->driver_data;
2984         struct cdrom_device_info *cdi = &info->devinfo;
2985         struct atapi_capabilities_page cap;
2986         int nslots = 1;
2987
2988         if (drive->media == ide_optical) {
2989                 CDROM_CONFIG_FLAGS(drive)->mo_drive = 1;
2990                 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2991                 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
2992                 return nslots;
2993         }
2994
2995         if (CDROM_CONFIG_FLAGS(drive)->nec260 ||
2996             !strcmp(drive->id->model,"STINGRAY 8422 IDE 8X CD-ROM 7-27-95")) {
2997                 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2998                 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2999                 return nslots;
3000         }
3001
3002         /*
3003          * we have to cheat a little here. the packet will eventually
3004          * be queued with ide_cdrom_packet(), which extracts the
3005          * drive from cdi->handle. Since this device hasn't been
3006          * registered with the Uniform layer yet, it can't do this.
3007          * Same goes for cdi->ops.
3008          */
3009         cdi->handle = (ide_drive_t *) drive;
3010         cdi->ops = &ide_cdrom_dops;
3011
3012         if (ide_cdrom_get_capabilities(drive, &cap))
3013                 return 0;
3014
3015         if (cap.lock == 0)
3016                 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
3017         if (cap.eject)
3018                 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
3019         if (cap.cd_r_write)
3020                 CDROM_CONFIG_FLAGS(drive)->cd_r = 1;
3021         if (cap.cd_rw_write) {
3022                 CDROM_CONFIG_FLAGS(drive)->cd_rw = 1;
3023                 CDROM_CONFIG_FLAGS(drive)->ram = 1;
3024         }
3025         if (cap.test_write)
3026                 CDROM_CONFIG_FLAGS(drive)->test_write = 1;
3027         if (cap.dvd_ram_read || cap.dvd_r_read || cap.dvd_rom)
3028                 CDROM_CONFIG_FLAGS(drive)->dvd = 1;
3029         if (cap.dvd_ram_write) {
3030                 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 1;
3031                 CDROM_CONFIG_FLAGS(drive)->ram = 1;
3032         }
3033         if (cap.dvd_r_write)
3034                 CDROM_CONFIG_FLAGS(drive)->dvd_r = 1;
3035         if (cap.audio_play)
3036                 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
3037         if (cap.mechtype == mechtype_caddy || cap.mechtype == mechtype_popup)
3038                 CDROM_CONFIG_FLAGS(drive)->close_tray = 0;
3039
3040         /* Some drives used by Apple don't advertise audio play
3041          * but they do support reading TOC & audio datas
3042          */
3043         if (strcmp(drive->id->model, "MATSHITADVD-ROM SR-8187") == 0 ||
3044             strcmp(drive->id->model, "MATSHITADVD-ROM SR-8186") == 0 ||
3045             strcmp(drive->id->model, "MATSHITADVD-ROM SR-8176") == 0 ||
3046             strcmp(drive->id->model, "MATSHITADVD-ROM SR-8174") == 0)
3047                 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
3048
3049 #if ! STANDARD_ATAPI
3050         if (cdi->sanyo_slot > 0) {
3051                 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
3052                 nslots = 3;
3053         }
3054
3055         else
3056 #endif /* not STANDARD_ATAPI */
3057         if (cap.mechtype == mechtype_individual_changer ||
3058             cap.mechtype == mechtype_cartridge_changer) {
3059                 if ((nslots = cdrom_number_of_slots(cdi)) > 1) {
3060                         CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
3061                         CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 1;
3062                 }
3063         }
3064
3065         /* The ACER/AOpen 24X cdrom has the speed fields byte-swapped */
3066         if (!drive->id->model[0] &&
3067             !strncmp(drive->id->fw_rev, "241N", 4)) {
3068                 CDROM_STATE_FLAGS(drive)->current_speed  =
3069                         (((unsigned int)cap.curspeed) + (176/2)) / 176;
3070                 CDROM_CONFIG_FLAGS(drive)->max_speed =
3071                         (((unsigned int)cap.maxspeed) + (176/2)) / 176;
3072         } else {
3073                 CDROM_STATE_FLAGS(drive)->current_speed  =
3074                         (ntohs(cap.curspeed) + (176/2)) / 176;
3075                 CDROM_CONFIG_FLAGS(drive)->max_speed =
3076                         (ntohs(cap.maxspeed) + (176/2)) / 176;
3077         }
3078
3079         /* don't print speed if the drive reported 0.
3080          */
3081         printk(KERN_INFO "%s: ATAPI", drive->name);
3082         if (CDROM_CONFIG_FLAGS(drive)->max_speed)
3083                 printk(" %dX", CDROM_CONFIG_FLAGS(drive)->max_speed);
3084         printk(" %s", CDROM_CONFIG_FLAGS(drive)->dvd ? "DVD-ROM" : "CD-ROM");
3085
3086         if (CDROM_CONFIG_FLAGS(drive)->dvd_r|CDROM_CONFIG_FLAGS(drive)->dvd_ram)
3087                 printk(" DVD%s%s",
3088                 (CDROM_CONFIG_FLAGS(drive)->dvd_r)? "-R" : "",
3089                 (CDROM_CONFIG_FLAGS(drive)->dvd_ram)? "-RAM" : "");
3090
3091         if (CDROM_CONFIG_FLAGS(drive)->cd_r|CDROM_CONFIG_FLAGS(drive)->cd_rw)
3092                 printk(" CD%s%s",
3093                 (CDROM_CONFIG_FLAGS(drive)->cd_r)? "-R" : "",
3094                 (CDROM_CONFIG_FLAGS(drive)->cd_rw)? "/RW" : "");
3095
3096         if (CDROM_CONFIG_FLAGS(drive)->is_changer)
3097                 printk(" changer w/%d slots", nslots);
3098         else
3099                 printk(" drive");
3100
3101         printk(", %dkB Cache", be16_to_cpu(cap.buffer_size));
3102
3103         if (drive->using_dma)
3104                 ide_dma_verbose(drive);
3105
3106         printk("\n");
3107
3108         return nslots;
3109 }
3110
3111 static void ide_cdrom_add_settings(ide_drive_t *drive)
3112 {
3113         ide_add_setting(drive,  "dsc_overlap",          SETTING_RW, -1, -1, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
3114 }
3115
3116 /*
3117  * standard prep_rq_fn that builds 10 byte cmds
3118  */
3119 static int ide_cdrom_prep_fs(request_queue_t *q, struct request *rq)
3120 {
3121         int hard_sect = queue_hardsect_size(q);
3122         long block = (long)rq->hard_sector / (hard_sect >> 9);
3123         unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
3124
3125         memset(rq->cmd, 0, sizeof(rq->cmd));
3126
3127         if (rq_data_dir(rq) == READ)
3128                 rq->cmd[0] = GPCMD_READ_10;
3129         else
3130                 rq->cmd[0] = GPCMD_WRITE_10;
3131
3132         /*
3133          * fill in lba
3134          */
3135         rq->cmd[2] = (block >> 24) & 0xff;
3136         rq->cmd[3] = (block >> 16) & 0xff;
3137         rq->cmd[4] = (block >>  8) & 0xff;
3138         rq->cmd[5] = block & 0xff;
3139
3140         /*
3141          * and transfer length
3142          */
3143         rq->cmd[7] = (blocks >> 8) & 0xff;
3144         rq->cmd[8] = blocks & 0xff;
3145         rq->cmd_len = 10;
3146         return BLKPREP_OK;
3147 }
3148
3149 /*
3150  * Most of the SCSI commands are supported directly by ATAPI devices.
3151  * This transform handles the few exceptions.
3152  */
3153 static int ide_cdrom_prep_pc(struct request *rq)
3154 {
3155         u8 *c = rq->cmd;
3156
3157         /*
3158          * Transform 6-byte read/write commands to the 10-byte version
3159          */
3160         if (c[0] == READ_6 || c[0] == WRITE_6) {
3161                 c[8] = c[4];
3162                 c[5] = c[3];
3163                 c[4] = c[2];
3164                 c[3] = c[1] & 0x1f;
3165                 c[2] = 0;
3166                 c[1] &= 0xe0;
3167                 c[0] += (READ_10 - READ_6);
3168                 rq->cmd_len = 10;
3169                 return BLKPREP_OK;
3170         }
3171
3172         /*
3173          * it's silly to pretend we understand 6-byte sense commands, just
3174          * reject with ILLEGAL_REQUEST and the caller should take the
3175          * appropriate action
3176          */
3177         if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
3178                 rq->errors = ILLEGAL_REQUEST;
3179                 return BLKPREP_KILL;
3180         }
3181
3182         return BLKPREP_OK;
3183 }
3184
3185 static int ide_cdrom_prep_fn(request_queue_t *q, struct request *rq)
3186 {
3187         if (rq->flags & REQ_CMD)
3188                 return ide_cdrom_prep_fs(q, rq);
3189         else if (rq->flags & REQ_BLOCK_PC)
3190                 return ide_cdrom_prep_pc(rq);
3191
3192         return 0;
3193 }
3194
3195 static
3196 int ide_cdrom_setup (ide_drive_t *drive)
3197 {
3198         struct cdrom_info *info = drive->driver_data;
3199         struct cdrom_device_info *cdi = &info->devinfo;
3200         int nslots;
3201
3202         blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
3203         blk_queue_dma_alignment(drive->queue, 31);
3204         drive->queue->unplug_delay = (1 * HZ) / 1000;
3205         if (!drive->queue->unplug_delay)
3206                 drive->queue->unplug_delay = 1;
3207
3208         drive->special.all      = 0;
3209         drive->ready_stat       = 0;
3210
3211         CDROM_STATE_FLAGS(drive)->media_changed = 1;
3212         CDROM_STATE_FLAGS(drive)->toc_valid     = 0;
3213         CDROM_STATE_FLAGS(drive)->door_locked   = 0;
3214
3215 #if NO_DOOR_LOCKING
3216         CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
3217 #else
3218         CDROM_CONFIG_FLAGS(drive)->no_doorlock = 0;
3219 #endif
3220
3221         CDROM_CONFIG_FLAGS(drive)->drq_interrupt = ((drive->id->config & 0x0060) == 0x20);
3222         CDROM_CONFIG_FLAGS(drive)->is_changer = 0;
3223         CDROM_CONFIG_FLAGS(drive)->cd_r = 0;
3224         CDROM_CONFIG_FLAGS(drive)->cd_rw = 0;
3225         CDROM_CONFIG_FLAGS(drive)->test_write = 0;
3226         CDROM_CONFIG_FLAGS(drive)->dvd = 0;
3227         CDROM_CONFIG_FLAGS(drive)->dvd_r = 0;
3228         CDROM_CONFIG_FLAGS(drive)->dvd_ram = 0;
3229         CDROM_CONFIG_FLAGS(drive)->no_eject = 1;
3230         CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 0;
3231         CDROM_CONFIG_FLAGS(drive)->audio_play = 0;
3232         CDROM_CONFIG_FLAGS(drive)->close_tray = 1;
3233
3234         /* limit transfer size per interrupt. */
3235         CDROM_CONFIG_FLAGS(drive)->limit_nframes = 0;
3236         /* a testament to the nice quality of Samsung drives... */
3237         if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2430"))
3238                 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3239         else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2432"))
3240                 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3241         /* the 3231 model does not support the SET_CD_SPEED command */
3242         else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-3231"))
3243                 cdi->mask |= CDC_SELECT_SPEED;
3244
3245 #if ! STANDARD_ATAPI
3246         /* by default Sanyo 3 CD changer support is turned off and
3247            ATAPI Rev 2.2+ standard support for CD changers is used */
3248         cdi->sanyo_slot = 0;
3249
3250         CDROM_CONFIG_FLAGS(drive)->nec260 = 0;
3251         CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 0;
3252         CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 0;
3253         CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 0;
3254         CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 0;
3255
3256         if (strcmp (drive->id->model, "V003S0DS") == 0 &&
3257             drive->id->fw_rev[4] == '1' &&
3258             drive->id->fw_rev[6] <= '2') {
3259                 /* Vertos 300.
3260                    Some versions of this drive like to talk BCD. */
3261                 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3262                 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3263                 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3264                 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3265         }
3266
3267         else if (strcmp (drive->id->model, "V006E0DS") == 0 &&
3268             drive->id->fw_rev[4] == '1' &&
3269             drive->id->fw_rev[6] <= '2') {
3270                 /* Vertos 600 ESD. */
3271                 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3272         }
3273         else if (strcmp(drive->id->model, "NEC CD-ROM DRIVE:260") == 0 &&
3274                  strncmp(drive->id->fw_rev, "1.01", 4) == 0) { /* FIXME */
3275                 /* Old NEC260 (not R).
3276                    This drive was released before the 1.2 version
3277                    of the spec. */
3278                 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3279                 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3280                 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3281                 CDROM_CONFIG_FLAGS(drive)->nec260         = 1;
3282         }
3283         else if (strcmp(drive->id->model, "WEARNES CDD-120") == 0 &&
3284                  strncmp(drive->id->fw_rev, "A1.1", 4) == 0) { /* FIXME */
3285                 /* Wearnes */
3286                 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3287                 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3288         }
3289         /* Sanyo 3 CD changer uses a non-standard command
3290            for CD changing */
3291         else if ((strcmp(drive->id->model, "CD-ROM CDR-C3 G") == 0) ||
3292                  (strcmp(drive->id->model, "CD-ROM CDR-C3G") == 0) ||
3293                  (strcmp(drive->id->model, "CD-ROM CDR_C36") == 0)) {
3294                  /* uses CD in slot 0 when value is set to 3 */
3295                  cdi->sanyo_slot = 3;
3296         }
3297 #endif /* not STANDARD_ATAPI */
3298
3299         info->toc               = NULL;
3300         info->buffer            = NULL;
3301         info->sector_buffered   = 0;
3302         info->nsectors_buffered = 0;
3303         info->changer_info      = NULL;
3304         info->last_block        = 0;
3305         info->start_seek        = 0;
3306
3307         nslots = ide_cdrom_probe_capabilities (drive);
3308
3309         /*
3310          * set correct block size
3311          */
3312         blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
3313
3314 #if 0
3315         drive->dsc_overlap = (HWIF(drive)->no_dsc) ? 0 : 1;
3316         if (HWIF(drive)->no_dsc) {
3317                 printk(KERN_INFO "ide-cd: %s: disabling DSC overlap\n",
3318                         drive->name);
3319                 drive->dsc_overlap = 0;
3320         }
3321 #endif
3322
3323         if (ide_cdrom_register(drive, nslots)) {
3324                 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
3325                 info->devinfo.handle = NULL;
3326                 return 1;
3327         }
3328         ide_cdrom_add_settings(drive);
3329         return 0;
3330 }
3331
3332 static
3333 sector_t ide_cdrom_capacity (ide_drive_t *drive)
3334 {
3335         unsigned long capacity, sectors_per_frame;
3336
3337         if (cdrom_read_capacity(drive, &capacity, &sectors_per_frame, NULL))
3338                 return 0;
3339
3340         return capacity * sectors_per_frame;
3341 }
3342
3343 static
3344 int ide_cdrom_cleanup(ide_drive_t *drive)
3345 {
3346         struct cdrom_info *info = drive->driver_data;
3347         struct cdrom_device_info *devinfo = &info->devinfo;
3348         struct gendisk *g = drive->disk;
3349
3350         if (ide_unregister_subdriver(drive)) {
3351                 printk(KERN_ERR "%s: %s: failed to ide_unregister_subdriver\n",
3352                         __FUNCTION__, drive->name);
3353                 return 1;
3354         }
3355         if (info->buffer != NULL)
3356                 kfree(info->buffer);
3357         if (info->toc != NULL)
3358                 kfree(info->toc);
3359         if (info->changer_info != NULL)
3360                 kfree(info->changer_info);
3361         if (devinfo->handle == drive && unregister_cdrom(devinfo))
3362                 printk(KERN_ERR "%s: ide_cdrom_cleanup failed to unregister device from the cdrom driver.\n", drive->name);
3363         kfree(info);
3364         drive->driver_data = NULL;
3365         blk_queue_prep_rq(drive->queue, NULL);
3366         del_gendisk(g);
3367         g->fops = ide_fops;
3368         return 0;
3369 }
3370
3371 static int ide_cdrom_attach (ide_drive_t *drive);
3372
3373 /*
3374  * Power Management state machine.
3375  *
3376  * We don't do much for CDs right now.
3377  */
3378
3379 static void ide_cdrom_complete_power_step (ide_drive_t *drive, struct request *rq, u8 stat, u8 error)
3380 {
3381 }
3382
3383 static ide_startstop_t ide_cdrom_start_power_step (ide_drive_t *drive, struct request *rq)
3384 {
3385         ide_task_t *args = rq->special;
3386
3387         memset(args, 0, sizeof(*args));
3388
3389         switch (rq->pm->pm_step) {
3390         case ide_pm_state_start_suspend:
3391                 break;
3392
3393         case ide_pm_state_start_resume: /* Resume step 1 (restore DMA) */
3394                 /*
3395                  * Right now, all we do is call hwif->ide_dma_check(drive),
3396                  * we could be smarter and check for current xfer_speed
3397                  * in struct drive etc...
3398                  * Also, this step could be implemented as a generic helper
3399                  * as most subdrivers will use it.
3400                  */
3401                 if ((drive->id->capability & 1) == 0)
3402                         break;
3403                 if (HWIF(drive)->ide_dma_check == NULL)
3404                         break;
3405                 HWIF(drive)->ide_dma_check(drive);
3406                 break;
3407         }
3408         rq->pm->pm_step = ide_pm_state_completed;
3409         return ide_stopped;
3410 }
3411
3412 static ide_driver_t ide_cdrom_driver = {
3413         .owner                  = THIS_MODULE,
3414         .name                   = "ide-cdrom",
3415         .version                = IDECD_VERSION,
3416         .media                  = ide_cdrom,
3417         .busy                   = 0,
3418         .supports_dsc_overlap   = 1,
3419         .cleanup                = ide_cdrom_cleanup,
3420         .do_request             = ide_do_rw_cdrom,
3421         .sense                  = ide_dump_atapi_status,
3422         .error                  = ide_cdrom_error,
3423         .abort                  = ide_cdrom_abort,
3424         .capacity               = ide_cdrom_capacity,
3425         .attach                 = ide_cdrom_attach,
3426         .drives                 = LIST_HEAD_INIT(ide_cdrom_driver.drives),
3427         .start_power_step       = ide_cdrom_start_power_step,
3428         .complete_power_step    = ide_cdrom_complete_power_step,
3429 };
3430
3431 static int idecd_open(struct inode * inode, struct file * file)
3432 {
3433         ide_drive_t *drive = inode->i_bdev->bd_disk->private_data;
3434         struct cdrom_info *info = drive->driver_data;
3435         int rc = -ENOMEM;
3436         drive->usage++;
3437
3438         if (!info->buffer)
3439                 info->buffer = kmalloc(SECTOR_BUFFER_SIZE,
3440                                         GFP_KERNEL|__GFP_REPEAT);
3441         if (!info->buffer || (rc = cdrom_open(&info->devinfo, inode, file)))
3442                 drive->usage--;
3443         return rc;
3444 }
3445
3446 static int idecd_release(struct inode * inode, struct file * file)
3447 {
3448         ide_drive_t *drive = inode->i_bdev->bd_disk->private_data;
3449         struct cdrom_info *info = drive->driver_data;
3450
3451         cdrom_release (&info->devinfo, file);
3452         drive->usage--;
3453         return 0;
3454 }
3455
3456 static int idecd_ioctl (struct inode *inode, struct file *file,
3457                         unsigned int cmd, unsigned long arg)
3458 {
3459         struct block_device *bdev = inode->i_bdev;
3460         ide_drive_t *drive = bdev->bd_disk->private_data;
3461         int err = generic_ide_ioctl(file, bdev, cmd, arg);
3462         if (err == -EINVAL) {
3463                 struct cdrom_info *info = drive->driver_data;
3464                 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
3465         }
3466         return err;
3467 }
3468
3469 static int idecd_media_changed(struct gendisk *disk)
3470 {
3471         ide_drive_t *drive = disk->private_data;
3472         struct cdrom_info *info = drive->driver_data;
3473         return cdrom_media_changed(&info->devinfo);
3474 }
3475
3476 static int idecd_revalidate_disk(struct gendisk *disk)
3477 {
3478         ide_drive_t *drive = disk->private_data;
3479         struct request_sense sense;
3480         cdrom_read_toc(drive, &sense);
3481         return  0;
3482 }
3483
3484 static struct block_device_operations idecd_ops = {
3485         .owner          = THIS_MODULE,
3486         .open           = idecd_open,
3487         .release        = idecd_release,
3488         .ioctl          = idecd_ioctl,
3489         .media_changed  = idecd_media_changed,
3490         .revalidate_disk= idecd_revalidate_disk
3491 };
3492
3493 /* options */
3494 static char *ignore = NULL;
3495
3496 module_param(ignore, charp, 0400);
3497 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
3498
3499 static int ide_cdrom_attach (ide_drive_t *drive)
3500 {
3501         struct cdrom_info *info;
3502         struct gendisk *g = drive->disk;
3503         struct request_sense sense;
3504
3505         if (!strstr("ide-cdrom", drive->driver_req))
3506                 goto failed;
3507         if (!drive->present)
3508                 goto failed;
3509         if (drive->media != ide_cdrom && drive->media != ide_optical)
3510                 goto failed;
3511         /* skip drives that we were told to ignore */
3512         if (ignore != NULL) {
3513                 if (strstr(ignore, drive->name)) {
3514                         printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
3515                         goto failed;
3516                 }
3517         }
3518         if (drive->scsi) {
3519                 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
3520                 goto failed;
3521         }
3522         info = (struct cdrom_info *) kmalloc (sizeof (struct cdrom_info), GFP_KERNEL);
3523         if (info == NULL) {
3524                 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
3525                 goto failed;
3526         }
3527         if (ide_register_subdriver(drive, &ide_cdrom_driver)) {
3528                 printk(KERN_ERR "%s: Failed to register the driver with ide.c\n",
3529                         drive->name);
3530                 kfree(info);
3531                 goto failed;
3532         }
3533         memset(info, 0, sizeof (struct cdrom_info));
3534         drive->driver_data = info;
3535         DRIVER(drive)->busy++;
3536         g->minors = 1;
3537         snprintf(g->devfs_name, sizeof(g->devfs_name),
3538                         "%s/cd", drive->devfs_name);
3539         g->driverfs_dev = &drive->gendev;
3540         g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
3541         if (ide_cdrom_setup(drive)) {
3542                 struct cdrom_device_info *devinfo = &info->devinfo;
3543                 DRIVER(drive)->busy--;
3544                 ide_unregister_subdriver(drive);
3545                 if (info->buffer != NULL)
3546                         kfree(info->buffer);
3547                 if (info->toc != NULL)
3548                         kfree(info->toc);
3549                 if (info->changer_info != NULL)
3550                         kfree(info->changer_info);
3551                 if (devinfo->handle == drive && unregister_cdrom(devinfo))
3552                         printk (KERN_ERR "%s: ide_cdrom_cleanup failed to unregister device from the cdrom driver.\n", drive->name);
3553                 kfree(info);
3554                 drive->driver_data = NULL;
3555                 goto failed;
3556         }
3557         DRIVER(drive)->busy--;
3558
3559         cdrom_read_toc(drive, &sense);
3560         g->fops = &idecd_ops;
3561         g->flags |= GENHD_FL_REMOVABLE;
3562         add_disk(g);
3563         return 0;
3564 failed:
3565         return 1;
3566 }
3567
3568 static void __exit ide_cdrom_exit(void)
3569 {
3570         ide_unregister_driver(&ide_cdrom_driver);
3571 }
3572
3573 static int ide_cdrom_init(void)
3574 {
3575         ide_register_driver(&ide_cdrom_driver);
3576         return 0;
3577 }
3578
3579 module_init(ide_cdrom_init);
3580 module_exit(ide_cdrom_exit);
3581 MODULE_LICENSE("GPL");