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

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