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)\n",
1455                         drive->name, ireason);
1456                 rq->flags |= REQ_FAILED;
1457         }
1458
1459         /* Now we wait for another interrupt. */
1460         ide_set_handler(drive, &cdrom_pc_intr, ATAPI_WAIT_PC, cdrom_timer_expiry);
1461         return ide_started;
1462 }
1463
1464 static ide_startstop_t cdrom_do_pc_continuation (ide_drive_t *drive)
1465 {
1466         struct request *rq = HWGROUP(drive)->rq;
1467
1468         if (!rq->timeout)
1469                 rq->timeout = ATAPI_WAIT_PC;
1470
1471         /* Send the command to the drive and return. */
1472         return cdrom_transfer_packet_command(drive, rq, &cdrom_pc_intr);
1473 }
1474
1475
1476 static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
1477 {
1478         int len;
1479         struct request *rq = HWGROUP(drive)->rq;
1480         struct cdrom_info *info = drive->driver_data;
1481
1482         info->dma = 0;
1483         rq->flags &= ~REQ_FAILED;
1484         len = rq->data_len;
1485
1486         /* Start sending the command to the drive. */
1487         return cdrom_start_packet_command(drive, len, cdrom_do_pc_continuation);
1488 }
1489
1490
1491 static
1492 int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
1493 {
1494         struct request_sense sense;
1495         int retries = 10;
1496         unsigned int flags = rq->flags;
1497
1498         if (rq->sense == NULL)
1499                 rq->sense = &sense;
1500
1501         /* Start of retry loop. */
1502         do {
1503                 int error;
1504                 unsigned long time = jiffies;
1505                 rq->flags = flags;
1506
1507                 error = ide_do_drive_cmd(drive, rq, ide_wait);
1508                 time = jiffies - time;
1509
1510                 /* FIXME: we should probably abort/retry or something
1511                  * in case of failure */
1512                 if (rq->flags & REQ_FAILED) {
1513                         /* The request failed.  Retry if it was due to a unit
1514                            attention status
1515                            (usually means media was changed). */
1516                         struct request_sense *reqbuf = rq->sense;
1517
1518                         if (reqbuf->sense_key == UNIT_ATTENTION)
1519                                 cdrom_saw_media_change(drive);
1520                         else if (reqbuf->sense_key == NOT_READY &&
1521                                  reqbuf->asc == 4 && reqbuf->ascq != 4) {
1522                                 /* The drive is in the process of loading
1523                                    a disk.  Retry, but wait a little to give
1524                                    the drive time to complete the load. */
1525                                 ssleep(2);
1526                         } else {
1527                                 /* Otherwise, don't retry. */
1528                                 retries = 0;
1529                         }
1530                         --retries;
1531                 }
1532
1533                 /* End of retry loop. */
1534         } while ((rq->flags & REQ_FAILED) && retries >= 0);
1535
1536         /* Return an error if the command failed. */
1537         return (rq->flags & REQ_FAILED) ? -EIO : 0;
1538 }
1539
1540 /*
1541  * Write handling
1542  */
1543 static int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
1544 {
1545         /* Two notes about IDE interrupt reason here - 0 means that
1546          * the drive wants to receive data from us, 2 means that
1547          * the drive is expecting to transfer data to us.
1548          */
1549         if (ireason == 0)
1550                 return 0;
1551         else if (ireason == 2) {
1552                 /* Whoops... The drive wants to send data. */
1553                 printk(KERN_ERR "%s: write_intr: wrong transfer direction!\n",
1554                                                         drive->name);
1555
1556                 while (len > 0) {
1557                         int dum = 0;
1558                         HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1559                         len -= sizeof(dum);
1560                 }
1561         } else {
1562                 /* Drive wants a command packet, or invalid ireason... */
1563                 printk(KERN_ERR "%s: write_intr: bad interrupt reason %x\n",
1564                                                         drive->name, ireason);
1565         }
1566
1567         cdrom_end_request(drive, 0);
1568         return 1;
1569 }
1570
1571 static void post_transform_command(struct request *req)
1572 {
1573         u8 *c = req->cmd;
1574         char *ibuf;
1575
1576         if (!blk_pc_request(req))
1577                 return;
1578
1579         if (req->bio)
1580                 ibuf = bio_data(req->bio);
1581         else
1582                 ibuf = req->data;
1583
1584         if (!ibuf)
1585                 return;
1586
1587         /*
1588          * set ansi-revision and response data as atapi
1589          */
1590         if (c[0] == GPCMD_INQUIRY) {
1591                 ibuf[2] |= 2;
1592                 ibuf[3] = (ibuf[3] & 0xf0) | 2;
1593         }
1594 }
1595
1596 typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
1597
1598 /*
1599  * best way to deal with dma that is not sector aligned right now... note
1600  * that in this path we are not using ->data or ->buffer at all. this irs
1601  * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the
1602  * future.
1603  */
1604 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1605 {
1606         struct cdrom_info *info = drive->driver_data;
1607         struct request *rq = HWGROUP(drive)->rq;
1608         int dma_error, dma, stat, ireason, len, thislen;
1609         u8 lowcyl, highcyl;
1610         xfer_func_t *xferfunc;
1611         unsigned long flags;
1612
1613         /* Check for errors. */
1614         dma_error = 0;
1615         dma = info->dma;
1616         if (dma) {
1617                 info->dma = 0;
1618                 dma_error = HWIF(drive)->ide_dma_end(drive);
1619         }
1620
1621         if (cdrom_decode_status(drive, 0, &stat))
1622                 return ide_stopped;
1623
1624         /*
1625          * using dma, transfer is complete now
1626          */
1627         if (dma) {
1628                 if (dma_error) {
1629                         printk(KERN_ERR "ide-cd: dma error\n");
1630                         __ide_dma_off(drive);
1631                         return ide_error(drive, "dma error", stat);
1632                 }
1633
1634                 end_that_request_chunk(rq, 1, rq->data_len);
1635                 rq->data_len = 0;
1636                 goto end_request;
1637         }
1638
1639         /*
1640          * ok we fall to pio :/
1641          */
1642         ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1643         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1644         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1645
1646         len = lowcyl + (256 * highcyl);
1647         thislen = rq->data_len;
1648         if (thislen > len)
1649                 thislen = len;
1650
1651         /*
1652          * If DRQ is clear, the command has completed.
1653          */
1654         if ((stat & DRQ_STAT) == 0)
1655                 goto end_request;
1656
1657         /*
1658          * check which way to transfer data
1659          */
1660         if (rq_data_dir(rq) == WRITE) {
1661                 /*
1662                  * write to drive
1663                  */
1664                 if (cdrom_write_check_ireason(drive, len, ireason))
1665                         return ide_stopped;
1666
1667                 xferfunc = HWIF(drive)->atapi_output_bytes;
1668         } else  {
1669                 /*
1670                  * read from drive
1671                  */
1672                 if (cdrom_read_check_ireason(drive, len, ireason))
1673                         return ide_stopped;
1674
1675                 xferfunc = HWIF(drive)->atapi_input_bytes;
1676         }
1677
1678         /*
1679          * transfer data
1680          */
1681         while (thislen > 0) {
1682                 int blen = blen = rq->data_len;
1683                 char *ptr = rq->data;
1684
1685                 /*
1686                  * bio backed?
1687                  */
1688                 if (rq->bio) {
1689                         ptr = bio_data(rq->bio);
1690                         blen = bio_iovec(rq->bio)->bv_len;
1691                 }
1692
1693                 if (!ptr) {
1694                         printk(KERN_ERR "%s: confused, missing data\n", drive->name);
1695                         break;
1696                 }
1697
1698                 if (blen > thislen)
1699                         blen = thislen;
1700
1701                 xferfunc(drive, ptr, blen);
1702
1703                 thislen -= blen;
1704                 len -= blen;
1705                 rq->data_len -= blen;
1706
1707                 if (rq->bio)
1708                         end_that_request_chunk(rq, 1, blen);
1709                 else
1710                         rq->data += blen;
1711         }
1712
1713         /*
1714          * pad, if necessary
1715          */
1716         if (len > 0) {
1717                 while (len > 0) {
1718                         int pad = 0;
1719
1720                         xferfunc(drive, &pad, sizeof(pad));
1721                         len -= sizeof(pad);
1722                 }
1723         }
1724
1725         if (HWGROUP(drive)->handler != NULL)
1726                 BUG();
1727
1728         ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, NULL);
1729         return ide_started;
1730
1731 end_request:
1732         if (!rq->data_len)
1733                 post_transform_command(rq);
1734
1735         spin_lock_irqsave(&ide_lock, flags);
1736         blkdev_dequeue_request(rq);
1737         end_that_request_last(rq, 1);
1738         HWGROUP(drive)->rq = NULL;
1739         spin_unlock_irqrestore(&ide_lock, flags);
1740         return ide_stopped;
1741 }
1742
1743 static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
1744 {
1745         int stat, ireason, len, sectors_to_transfer, uptodate;
1746         struct cdrom_info *info = drive->driver_data;
1747         int dma_error = 0, dma = info->dma;
1748         u8 lowcyl = 0, highcyl = 0;
1749
1750         struct request *rq = HWGROUP(drive)->rq;
1751
1752         /* Check for errors. */
1753         if (dma) {
1754                 info->dma = 0;
1755                 if ((dma_error = HWIF(drive)->ide_dma_end(drive))) {
1756                         printk(KERN_ERR "ide-cd: write dma error\n");
1757                         __ide_dma_off(drive);
1758                 }
1759         }
1760
1761         if (cdrom_decode_status(drive, 0, &stat))
1762                 return ide_stopped;
1763
1764         /*
1765          * using dma, transfer is complete now
1766          */
1767         if (dma) {
1768                 if (dma_error)
1769                         return ide_error(drive, "dma error", stat);
1770
1771                 ide_end_request(drive, 1, rq->nr_sectors);
1772                 return ide_stopped;
1773         }
1774
1775         /* Read the interrupt reason and the transfer length. */
1776         ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1777         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1778         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1779
1780         len = lowcyl + (256 * highcyl);
1781
1782         /* If DRQ is clear, the command has completed. */
1783         if ((stat & DRQ_STAT) == 0) {
1784                 /* If we're not done writing, complain.
1785                  * Otherwise, complete the command normally.
1786                  */
1787                 uptodate = 1;
1788                 if (rq->current_nr_sectors > 0) {
1789                         printk(KERN_ERR "%s: write_intr: data underrun (%d blocks)\n",
1790                         drive->name, rq->current_nr_sectors);
1791                         uptodate = 0;
1792                 }
1793                 cdrom_end_request(drive, uptodate);
1794                 return ide_stopped;
1795         }
1796
1797         /* Check that the drive is expecting to do the same thing we are. */
1798         if (cdrom_write_check_ireason(drive, len, ireason))
1799                 return ide_stopped;
1800
1801         sectors_to_transfer = len / SECTOR_SIZE;
1802
1803         /*
1804          * now loop and write out the data
1805          */
1806         while (sectors_to_transfer > 0) {
1807                 int this_transfer;
1808
1809                 if (!rq->current_nr_sectors) {
1810                         printk(KERN_ERR "ide-cd: write_intr: oops\n");
1811                         break;
1812                 }
1813
1814                 /*
1815                  * Figure out how many sectors we can transfer
1816                  */
1817                 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors);
1818
1819                 while (this_transfer > 0) {
1820                         HWIF(drive)->atapi_output_bytes(drive, rq->buffer, SECTOR_SIZE);
1821                         rq->buffer += SECTOR_SIZE;
1822                         --rq->nr_sectors;
1823                         --rq->current_nr_sectors;
1824                         ++rq->sector;
1825                         --this_transfer;
1826                         --sectors_to_transfer;
1827                 }
1828
1829                 /*
1830                  * current buffer complete, move on
1831                  */
1832                 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1833                         cdrom_end_request(drive, 1);
1834         }
1835
1836         /* re-arm handler */
1837         ide_set_handler(drive, &cdrom_write_intr, ATAPI_WAIT_PC, NULL);
1838         return ide_started;
1839 }
1840
1841 static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
1842 {
1843         struct request *rq = HWGROUP(drive)->rq;
1844
1845 #if 0   /* the immediate bit */
1846         rq->cmd[1] = 1 << 3;
1847 #endif
1848         rq->timeout = ATAPI_WAIT_PC;
1849
1850         return cdrom_transfer_packet_command(drive, rq, cdrom_write_intr);
1851 }
1852
1853 static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
1854 {
1855         struct cdrom_info *info = drive->driver_data;
1856         struct gendisk *g = info->disk;
1857         unsigned short sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1858
1859         /*
1860          * writes *must* be hardware frame aligned
1861          */
1862         if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1863             (rq->sector & (sectors_per_frame - 1))) {
1864                 cdrom_end_request(drive, 0);
1865                 return ide_stopped;
1866         }
1867
1868         /*
1869          * disk has become write protected
1870          */
1871         if (g->policy) {
1872                 cdrom_end_request(drive, 0);
1873                 return ide_stopped;
1874         }
1875
1876         info->nsectors_buffered = 0;
1877
1878         /* use dma, if possible. we don't need to check more, since we
1879          * know that the transfer is always (at least!) frame aligned */
1880         info->dma = drive->using_dma ? 1 : 0;
1881
1882         info->devinfo.media_written = 1;
1883
1884         /* Start sending the write request to the drive. */
1885         return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
1886 }
1887
1888 static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1889 {
1890         struct request *rq = HWGROUP(drive)->rq;
1891
1892         if (!rq->timeout)
1893                 rq->timeout = ATAPI_WAIT_PC;
1894
1895         return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1896 }
1897
1898 static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1899 {
1900         struct cdrom_info *info = drive->driver_data;
1901
1902         rq->flags |= REQ_QUIET;
1903
1904         info->dma = 0;
1905
1906         /*
1907          * sg request
1908          */
1909         if (rq->bio) {
1910                 int mask = drive->queue->dma_alignment;
1911                 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
1912
1913                 info->dma = drive->using_dma;
1914
1915                 /*
1916                  * check if dma is safe
1917                  *
1918                  * NOTE! The "len" and "addr" checks should possibly have
1919                  * separate masks.
1920                  */
1921                 if ((rq->data_len & 15) || (addr & mask))
1922                         info->dma = 0;
1923         }
1924
1925         /* Start sending the command to the drive. */
1926         return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1927 }
1928
1929 /****************************************************************************
1930  * cdrom driver request routine.
1931  */
1932 static ide_startstop_t
1933 ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1934 {
1935         ide_startstop_t action;
1936         struct cdrom_info *info = drive->driver_data;
1937
1938         if (blk_fs_request(rq)) {
1939                 if (CDROM_CONFIG_FLAGS(drive)->seeking) {
1940                         unsigned long elapsed = jiffies - info->start_seek;
1941                         int stat = HWIF(drive)->INB(IDE_STATUS_REG);
1942
1943                         if ((stat & SEEK_STAT) != SEEK_STAT) {
1944                                 if (elapsed < IDECD_SEEK_TIMEOUT) {
1945                                         ide_stall_queue(drive, IDECD_SEEK_TIMER);
1946                                         return ide_stopped;
1947                                 }
1948                                 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
1949                         }
1950                         CDROM_CONFIG_FLAGS(drive)->seeking = 0;
1951                 }
1952                 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
1953                         action = cdrom_start_seek(drive, block);
1954                 } else {
1955                         if (rq_data_dir(rq) == READ)
1956                                 action = cdrom_start_read(drive, block);
1957                         else
1958                                 action = cdrom_start_write(drive, rq);
1959                 }
1960                 info->last_block = block;
1961                 return action;
1962         } else if (rq->flags & (REQ_PC | REQ_SENSE)) {
1963                 return cdrom_do_packet_command(drive);
1964         } else if (rq->flags & REQ_BLOCK_PC) {
1965                 return cdrom_do_block_pc(drive, rq);
1966         } else if (rq->flags & REQ_SPECIAL) {
1967                 /*
1968                  * right now this can only be a reset...
1969                  */
1970                 cdrom_end_request(drive, 1);
1971                 return ide_stopped;
1972         }
1973
1974         blk_dump_rq_flags(rq, "ide-cd bad flags");
1975         cdrom_end_request(drive, 0);
1976         return ide_stopped;
1977 }
1978
1979
1980
1981 /****************************************************************************
1982  * Ioctl handling.
1983  *
1984  * Routines which queue packet commands take as a final argument a pointer
1985  * to a request_sense struct.  If execution of the command results
1986  * in an error with a CHECK CONDITION status, this structure will be filled
1987  * with the results of the subsequent request sense command.  The pointer
1988  * can also be NULL, in which case no sense information is returned.
1989  */
1990
1991 #if ! STANDARD_ATAPI
1992 static inline
1993 int bin2bcd (int x)
1994 {
1995         return (x%10) | ((x/10) << 4);
1996 }
1997
1998
1999 static inline
2000 int bcd2bin (int x)
2001 {
2002         return (x >> 4) * 10 + (x & 0x0f);
2003 }
2004
2005 static
2006 void msf_from_bcd (struct atapi_msf *msf)
2007 {
2008         msf->minute = bcd2bin (msf->minute);
2009         msf->second = bcd2bin (msf->second);
2010         msf->frame  = bcd2bin (msf->frame);
2011 }
2012
2013 #endif /* not STANDARD_ATAPI */
2014
2015
2016 static inline
2017 void lba_to_msf (int lba, byte *m, byte *s, byte *f)
2018 {
2019         lba += CD_MSF_OFFSET;
2020         lba &= 0xffffff;  /* negative lbas use only 24 bits */
2021         *m = lba / (CD_SECS * CD_FRAMES);
2022         lba %= (CD_SECS * CD_FRAMES);
2023         *s = lba / CD_FRAMES;
2024         *f = lba % CD_FRAMES;
2025 }
2026
2027
2028 static inline
2029 int msf_to_lba (byte m, byte s, byte f)
2030 {
2031         return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
2032 }
2033
2034 static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
2035 {
2036         struct request req;
2037         struct cdrom_info *info = drive->driver_data;
2038         struct cdrom_device_info *cdi = &info->devinfo;
2039
2040         cdrom_prepare_request(drive, &req);
2041
2042         req.sense = sense;
2043         req.cmd[0] = GPCMD_TEST_UNIT_READY;
2044         req.flags |= REQ_QUIET;
2045
2046 #if ! STANDARD_ATAPI
2047         /* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
2048            switch CDs instead of supporting the LOAD_UNLOAD opcode   */
2049
2050         req.cmd[7] = cdi->sanyo_slot % 3;
2051 #endif /* not STANDARD_ATAPI */
2052
2053         return cdrom_queue_packet_command(drive, &req);
2054 }
2055
2056
2057 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
2058 static int
2059 cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
2060 {
2061         struct request_sense my_sense;
2062         struct request req;
2063         int stat;
2064
2065         if (sense == NULL)
2066                 sense = &my_sense;
2067
2068         /* If the drive cannot lock the door, just pretend. */
2069         if (CDROM_CONFIG_FLAGS(drive)->no_doorlock) {
2070                 stat = 0;
2071         } else {
2072                 cdrom_prepare_request(drive, &req);
2073                 req.sense = sense;
2074                 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
2075                 req.cmd[4] = lockflag ? 1 : 0;
2076                 stat = cdrom_queue_packet_command(drive, &req);
2077         }
2078
2079         /* If we got an illegal field error, the drive
2080            probably cannot lock the door. */
2081         if (stat != 0 &&
2082             sense->sense_key == ILLEGAL_REQUEST &&
2083             (sense->asc == 0x24 || sense->asc == 0x20)) {
2084                 printk (KERN_ERR "%s: door locking not supported\n",
2085                         drive->name);
2086                 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2087                 stat = 0;
2088         }
2089
2090         /* no medium, that's alright. */
2091         if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
2092                 stat = 0;
2093
2094         if (stat == 0)
2095                 CDROM_STATE_FLAGS(drive)->door_locked = lockflag;
2096
2097         return stat;
2098 }
2099
2100
2101 /* Eject the disk if EJECTFLAG is 0.
2102    If EJECTFLAG is 1, try to reload the disk. */
2103 static int cdrom_eject(ide_drive_t *drive, int ejectflag,
2104                        struct request_sense *sense)
2105 {
2106         struct request req;
2107         char loej = 0x02;
2108
2109         if (CDROM_CONFIG_FLAGS(drive)->no_eject && !ejectflag)
2110                 return -EDRIVE_CANT_DO_THIS;
2111
2112         /* reload fails on some drives, if the tray is locked */
2113         if (CDROM_STATE_FLAGS(drive)->door_locked && ejectflag)
2114                 return 0;
2115
2116         cdrom_prepare_request(drive, &req);
2117
2118         /* only tell drive to close tray if open, if it can do that */
2119         if (ejectflag && !CDROM_CONFIG_FLAGS(drive)->close_tray)
2120                 loej = 0;
2121
2122         req.sense = sense;
2123         req.cmd[0] = GPCMD_START_STOP_UNIT;
2124         req.cmd[4] = loej | (ejectflag != 0);
2125         return cdrom_queue_packet_command(drive, &req);
2126 }
2127
2128 static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
2129                                unsigned long *sectors_per_frame,
2130                                struct request_sense *sense)
2131 {
2132         struct {
2133                 __u32 lba;
2134                 __u32 blocklen;
2135         } capbuf;
2136
2137         int stat;
2138         struct request req;
2139
2140         cdrom_prepare_request(drive, &req);
2141
2142         req.sense = sense;
2143         req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
2144         req.data = (char *)&capbuf;
2145         req.data_len = sizeof(capbuf);
2146         req.flags |= REQ_QUIET;
2147
2148         stat = cdrom_queue_packet_command(drive, &req);
2149         if (stat == 0) {
2150                 *capacity = 1 + be32_to_cpu(capbuf.lba);
2151                 *sectors_per_frame =
2152                         be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
2153         }
2154
2155         return stat;
2156 }
2157
2158 static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
2159                                 int format, char *buf, int buflen,
2160                                 struct request_sense *sense)
2161 {
2162         struct request req;
2163
2164         cdrom_prepare_request(drive, &req);
2165
2166         req.sense = sense;
2167         req.data =  buf;
2168         req.data_len = buflen;
2169         req.flags |= REQ_QUIET;
2170         req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
2171         req.cmd[6] = trackno;
2172         req.cmd[7] = (buflen >> 8);
2173         req.cmd[8] = (buflen & 0xff);
2174         req.cmd[9] = (format << 6);
2175
2176         if (msf_flag)
2177                 req.cmd[1] = 2;
2178
2179         return cdrom_queue_packet_command(drive, &req);
2180 }
2181
2182
2183 /* Try to read the entire TOC for the disk into our internal buffer. */
2184 static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
2185 {
2186         int stat, ntracks, i;
2187         struct cdrom_info *info = drive->driver_data;
2188         struct cdrom_device_info *cdi = &info->devinfo;
2189         struct atapi_toc *toc = info->toc;
2190         struct {
2191                 struct atapi_toc_header hdr;
2192                 struct atapi_toc_entry  ent;
2193         } ms_tmp;
2194         long last_written;
2195         unsigned long sectors_per_frame = SECTORS_PER_FRAME;
2196
2197         if (toc == NULL) {
2198                 /* Try to allocate space. */
2199                 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
2200                 if (toc == NULL) {
2201                         printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
2202                         return -ENOMEM;
2203                 }
2204                 info->toc = toc;
2205         }
2206
2207         /* Check to see if the existing data is still valid.
2208            If it is, just return. */
2209         (void) cdrom_check_status(drive, sense);
2210
2211         if (CDROM_STATE_FLAGS(drive)->toc_valid)
2212                 return 0;
2213
2214         /* Try to get the total cdrom capacity and sector size. */
2215         stat = cdrom_read_capacity(drive, &toc->capacity, &sectors_per_frame,
2216                                    sense);
2217         if (stat)
2218                 toc->capacity = 0x1fffff;
2219
2220         set_capacity(info->disk, toc->capacity * sectors_per_frame);
2221         blk_queue_hardsect_size(drive->queue,
2222                                 sectors_per_frame << SECTOR_BITS);
2223
2224         /* First read just the header, so we know how long the TOC is. */
2225         stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
2226                                     sizeof(struct atapi_toc_header), sense);
2227         if (stat)
2228                 return stat;
2229
2230 #if ! STANDARD_ATAPI
2231         if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2232                 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2233                 toc->hdr.last_track  = bcd2bin(toc->hdr.last_track);
2234         }
2235 #endif  /* not STANDARD_ATAPI */
2236
2237         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2238         if (ntracks <= 0)
2239                 return -EIO;
2240         if (ntracks > MAX_TRACKS)
2241                 ntracks = MAX_TRACKS;
2242
2243         /* Now read the whole schmeer. */
2244         stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
2245                                   (char *)&toc->hdr,
2246                                    sizeof(struct atapi_toc_header) +
2247                                    (ntracks + 1) *
2248                                    sizeof(struct atapi_toc_entry), sense);
2249
2250         if (stat && toc->hdr.first_track > 1) {
2251                 /* Cds with CDI tracks only don't have any TOC entries,
2252                    despite of this the returned values are
2253                    first_track == last_track = number of CDI tracks + 1,
2254                    so that this case is indistinguishable from the same
2255                    layout plus an additional audio track.
2256                    If we get an error for the regular case, we assume
2257                    a CDI without additional audio tracks. In this case
2258                    the readable TOC is empty (CDI tracks are not included)
2259                    and only holds the Leadout entry. Heiko Eißfeldt */
2260                 ntracks = 0;
2261                 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
2262                                            (char *)&toc->hdr,
2263                                            sizeof(struct atapi_toc_header) +
2264                                            (ntracks + 1) *
2265                                            sizeof(struct atapi_toc_entry),
2266                                            sense);
2267                 if (stat) {
2268                         return stat;
2269                 }
2270 #if ! STANDARD_ATAPI
2271                 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2272                         toc->hdr.first_track = bin2bcd(CDROM_LEADOUT);
2273                         toc->hdr.last_track = bin2bcd(CDROM_LEADOUT);
2274                 } else
2275 #endif  /* not STANDARD_ATAPI */
2276                 {
2277                         toc->hdr.first_track = CDROM_LEADOUT;
2278                         toc->hdr.last_track = CDROM_LEADOUT;
2279                 }
2280         }
2281
2282         if (stat)
2283                 return stat;
2284
2285         toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
2286
2287 #if ! STANDARD_ATAPI
2288         if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) {
2289                 toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
2290                 toc->hdr.last_track  = bcd2bin(toc->hdr.last_track);
2291         }
2292 #endif  /* not STANDARD_ATAPI */
2293
2294         for (i=0; i<=ntracks; i++) {
2295 #if ! STANDARD_ATAPI
2296                 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2297                         if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd)
2298                                 toc->ent[i].track = bcd2bin(toc->ent[i].track);
2299                         msf_from_bcd(&toc->ent[i].addr.msf);
2300                 }
2301 #endif  /* not STANDARD_ATAPI */
2302                 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
2303                                                    toc->ent[i].addr.msf.second,
2304                                                    toc->ent[i].addr.msf.frame);
2305         }
2306
2307         /* Read the multisession information. */
2308         if (toc->hdr.first_track != CDROM_LEADOUT) {
2309                 /* Read the multisession information. */
2310                 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
2311                                            sizeof(ms_tmp), sense);
2312                 if (stat)
2313                         return stat;
2314
2315                 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
2316         } else {
2317                 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
2318                 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
2319         }
2320
2321 #if ! STANDARD_ATAPI
2322         if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) {
2323                 /* Re-read multisession information using MSF format */
2324                 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
2325                                            sizeof(ms_tmp), sense);
2326                 if (stat)
2327                         return stat;
2328
2329                 msf_from_bcd (&ms_tmp.ent.addr.msf);
2330                 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
2331                                                    ms_tmp.ent.addr.msf.second,
2332                                                    ms_tmp.ent.addr.msf.frame);
2333         }
2334 #endif  /* not STANDARD_ATAPI */
2335
2336         toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
2337
2338         /* Now try to get the total cdrom capacity. */
2339         stat = cdrom_get_last_written(cdi, &last_written);
2340         if (!stat && (last_written > toc->capacity)) {
2341                 toc->capacity = last_written;
2342                 set_capacity(info->disk, toc->capacity * sectors_per_frame);
2343         }
2344
2345         /* Remember that we've read this stuff. */
2346         CDROM_STATE_FLAGS(drive)->toc_valid = 1;
2347
2348         return 0;
2349 }
2350
2351
2352 static int cdrom_read_subchannel(ide_drive_t *drive, int format, char *buf,
2353                                  int buflen, struct request_sense *sense)
2354 {
2355         struct request req;
2356
2357         cdrom_prepare_request(drive, &req);
2358
2359         req.sense = sense;
2360         req.data = buf;
2361         req.data_len = buflen;
2362         req.cmd[0] = GPCMD_READ_SUBCHANNEL;
2363         req.cmd[1] = 2;     /* MSF addressing */
2364         req.cmd[2] = 0x40;  /* request subQ data */
2365         req.cmd[3] = format;
2366         req.cmd[7] = (buflen >> 8);
2367         req.cmd[8] = (buflen & 0xff);
2368         return cdrom_queue_packet_command(drive, &req);
2369 }
2370
2371 /* ATAPI cdrom drives are free to select the speed you request or any slower
2372    rate :-( Requesting too fast a speed will _not_ produce an error. */
2373 static int cdrom_select_speed(ide_drive_t *drive, int speed,
2374                               struct request_sense *sense)
2375 {
2376         struct request req;
2377         cdrom_prepare_request(drive, &req);
2378
2379         req.sense = sense;
2380         if (speed == 0)
2381                 speed = 0xffff; /* set to max */
2382         else
2383                 speed *= 177;   /* Nx to kbytes/s */
2384
2385         req.cmd[0] = GPCMD_SET_SPEED;
2386         /* Read Drive speed in kbytes/second MSB */
2387         req.cmd[2] = (speed >> 8) & 0xff;
2388         /* Read Drive speed in kbytes/second LSB */
2389         req.cmd[3] = speed & 0xff;
2390         if (CDROM_CONFIG_FLAGS(drive)->cd_r ||
2391             CDROM_CONFIG_FLAGS(drive)->cd_rw ||
2392             CDROM_CONFIG_FLAGS(drive)->dvd_r) {
2393                 /* Write Drive speed in kbytes/second MSB */
2394                 req.cmd[4] = (speed >> 8) & 0xff;
2395                 /* Write Drive speed in kbytes/second LSB */
2396                 req.cmd[5] = speed & 0xff;
2397        }
2398
2399         return cdrom_queue_packet_command(drive, &req);
2400 }
2401
2402 static int cdrom_play_audio(ide_drive_t *drive, int lba_start, int lba_end)
2403 {
2404         struct request_sense sense;
2405         struct request req;
2406
2407         cdrom_prepare_request(drive, &req);
2408
2409         req.sense = &sense;
2410         req.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2411         lba_to_msf(lba_start, &req.cmd[3], &req.cmd[4], &req.cmd[5]);
2412         lba_to_msf(lba_end-1, &req.cmd[6], &req.cmd[7], &req.cmd[8]);
2413
2414         return cdrom_queue_packet_command(drive, &req);
2415 }
2416
2417 static int cdrom_get_toc_entry(ide_drive_t *drive, int track,
2418                                 struct atapi_toc_entry **ent)
2419 {
2420         struct cdrom_info *info = drive->driver_data;
2421         struct atapi_toc *toc = info->toc;
2422         int ntracks;
2423
2424         /*
2425          * don't serve cached data, if the toc isn't valid
2426          */
2427         if (!CDROM_STATE_FLAGS(drive)->toc_valid)
2428                 return -EINVAL;
2429
2430         /* Check validity of requested track number. */
2431         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2432         if (toc->hdr.first_track == CDROM_LEADOUT) ntracks = 0;
2433         if (track == CDROM_LEADOUT)
2434                 *ent = &toc->ent[ntracks];
2435         else if (track < toc->hdr.first_track ||
2436                  track > toc->hdr.last_track)
2437                 return -EINVAL;
2438         else
2439                 *ent = &toc->ent[track - toc->hdr.first_track];
2440
2441         return 0;
2442 }
2443
2444 /* the generic packet interface to cdrom.c */
2445 static int ide_cdrom_packet(struct cdrom_device_info *cdi,
2446                             struct packet_command *cgc)
2447 {
2448         struct request req;
2449         ide_drive_t *drive = cdi->handle;
2450
2451         if (cgc->timeout <= 0)
2452                 cgc->timeout = ATAPI_WAIT_PC;
2453
2454         /* here we queue the commands from the uniform CD-ROM
2455            layer. the packet must be complete, as we do not
2456            touch it at all. */
2457         cdrom_prepare_request(drive, &req);
2458         memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
2459         if (cgc->sense)
2460                 memset(cgc->sense, 0, sizeof(struct request_sense));
2461         req.data = cgc->buffer;
2462         req.data_len = cgc->buflen;
2463         req.timeout = cgc->timeout;
2464
2465         if (cgc->quiet)
2466                 req.flags |= REQ_QUIET;
2467
2468         req.sense = cgc->sense;
2469         cgc->stat = cdrom_queue_packet_command(drive, &req);
2470         if (!cgc->stat)
2471                 cgc->buflen -= req.data_len;
2472         return cgc->stat;
2473 }
2474
2475 static
2476 int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
2477                            unsigned int cmd, void *arg)
2478
2479 {
2480         ide_drive_t *drive = cdi->handle;
2481         struct cdrom_info *info = drive->driver_data;
2482         int stat;
2483
2484         switch (cmd) {
2485         /*
2486          * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
2487          * atapi doesn't support it
2488          */
2489         case CDROMPLAYTRKIND: {
2490                 unsigned long lba_start, lba_end;
2491                 struct cdrom_ti *ti = arg;
2492                 struct atapi_toc_entry *first_toc, *last_toc;
2493
2494                 stat = cdrom_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
2495                 if (stat)
2496                         return stat;
2497
2498                 stat = cdrom_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
2499                 if (stat)
2500                         return stat;
2501
2502                 if (ti->cdti_trk1 != CDROM_LEADOUT)
2503                         ++last_toc;
2504                 lba_start = first_toc->addr.lba;
2505                 lba_end   = last_toc->addr.lba;
2506
2507                 if (lba_end <= lba_start)
2508                         return -EINVAL;
2509
2510                 return cdrom_play_audio(drive, lba_start, lba_end);
2511         }
2512
2513         case CDROMREADTOCHDR: {
2514                 struct cdrom_tochdr *tochdr = arg;
2515                 struct atapi_toc *toc;
2516
2517                 /* Make sure our saved TOC is valid. */
2518                 stat = cdrom_read_toc(drive, NULL);
2519                 if (stat)
2520                         return stat;
2521
2522                 toc = info->toc;
2523                 tochdr->cdth_trk0 = toc->hdr.first_track;
2524                 tochdr->cdth_trk1 = toc->hdr.last_track;
2525
2526                 return 0;
2527         }
2528
2529         case CDROMREADTOCENTRY: {
2530                 struct cdrom_tocentry *tocentry = arg;
2531                 struct atapi_toc_entry *toce;
2532
2533                 stat = cdrom_get_toc_entry(drive, tocentry->cdte_track, &toce);
2534                 if (stat)
2535                         return stat;
2536
2537                 tocentry->cdte_ctrl = toce->control;
2538                 tocentry->cdte_adr  = toce->adr;
2539                 if (tocentry->cdte_format == CDROM_MSF) {
2540                         lba_to_msf (toce->addr.lba,
2541                                    &tocentry->cdte_addr.msf.minute,
2542                                    &tocentry->cdte_addr.msf.second,
2543                                    &tocentry->cdte_addr.msf.frame);
2544                 } else
2545                         tocentry->cdte_addr.lba = toce->addr.lba;
2546
2547                 return 0;
2548         }
2549
2550         default:
2551                 return -EINVAL;
2552         }
2553 }
2554
2555 static
2556 int ide_cdrom_reset (struct cdrom_device_info *cdi)
2557 {
2558         ide_drive_t *drive = cdi->handle;
2559         struct request_sense sense;
2560         struct request req;
2561         int ret;
2562
2563         cdrom_prepare_request(drive, &req);
2564         req.flags = REQ_SPECIAL | REQ_QUIET;
2565         ret = ide_do_drive_cmd(drive, &req, ide_wait);
2566
2567         /*
2568          * A reset will unlock the door. If it was previously locked,
2569          * lock it again.
2570          */
2571         if (CDROM_STATE_FLAGS(drive)->door_locked)
2572                 (void) cdrom_lockdoor(drive, 1, &sense);
2573
2574         return ret;
2575 }
2576
2577
2578 static
2579 int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
2580 {
2581         ide_drive_t *drive = cdi->handle;
2582         struct request_sense sense;
2583
2584         if (position) {
2585                 int stat = cdrom_lockdoor(drive, 0, &sense);
2586                 if (stat)
2587                         return stat;
2588         }
2589
2590         return cdrom_eject(drive, !position, &sense);
2591 }
2592
2593 static
2594 int ide_cdrom_lock_door (struct cdrom_device_info *cdi, int lock)
2595 {
2596         ide_drive_t *drive = cdi->handle;
2597         return cdrom_lockdoor(drive, lock, NULL);
2598 }
2599
2600 static
2601 int ide_cdrom_get_capabilities(ide_drive_t *drive, struct atapi_capabilities_page *cap)
2602 {
2603         struct cdrom_info *info = drive->driver_data;
2604         struct cdrom_device_info *cdi = &info->devinfo;
2605         struct packet_command cgc;
2606         int stat, attempts = 3, size = sizeof(*cap);
2607
2608         /*
2609          * ACER50 (and others?) require the full spec length mode sense
2610          * page capabilities size, but older drives break.
2611          */
2612         if (!(!strcmp(drive->id->model, "ATAPI CD ROM DRIVE 50X MAX") ||
2613             !strcmp(drive->id->model, "WPI CDS-32X")))
2614                 size -= sizeof(cap->pad);
2615
2616         init_cdrom_command(&cgc, cap, size, CGC_DATA_UNKNOWN);
2617         do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2618                 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
2619                 if (!stat)
2620                         break;
2621         } while (--attempts);
2622         return stat;
2623 }
2624
2625 static
2626 void ide_cdrom_update_speed (ide_drive_t *drive, struct atapi_capabilities_page *cap)
2627 {
2628         /* The ACER/AOpen 24X cdrom has the speed fields byte-swapped */
2629         if (!drive->id->model[0] &&
2630             !strncmp(drive->id->fw_rev, "241N", 4)) {
2631                 CDROM_STATE_FLAGS(drive)->current_speed  =
2632                         (((unsigned int)cap->curspeed) + (176/2)) / 176;
2633                 CDROM_CONFIG_FLAGS(drive)->max_speed =
2634                         (((unsigned int)cap->maxspeed) + (176/2)) / 176;
2635         } else {
2636                 CDROM_STATE_FLAGS(drive)->current_speed  =
2637                         (ntohs(cap->curspeed) + (176/2)) / 176;
2638                 CDROM_CONFIG_FLAGS(drive)->max_speed =
2639                         (ntohs(cap->maxspeed) + (176/2)) / 176;
2640         }
2641 }
2642
2643 static
2644 int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
2645 {
2646         ide_drive_t *drive = cdi->handle;
2647         struct request_sense sense;
2648         struct atapi_capabilities_page cap;
2649         int stat;
2650
2651         if ((stat = cdrom_select_speed(drive, speed, &sense)) < 0)
2652                 return stat;
2653
2654         if (!ide_cdrom_get_capabilities(drive, &cap)) {
2655                 ide_cdrom_update_speed(drive, &cap);
2656                 cdi->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2657         }
2658         return 0;
2659 }
2660
2661 /*
2662  * add logic to try GET_EVENT command first to check for media and tray
2663  * status. this should be supported by newer cd-r/w and all DVD etc
2664  * drives
2665  */
2666 static
2667 int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
2668 {
2669         ide_drive_t *drive = cdi->handle;
2670         struct media_event_desc med;
2671         struct request_sense sense;
2672         int stat;
2673
2674         if (slot_nr != CDSL_CURRENT)
2675                 return -EINVAL;
2676
2677         stat = cdrom_check_status(drive, &sense);
2678         if (!stat || sense.sense_key == UNIT_ATTENTION)
2679                 return CDS_DISC_OK;
2680
2681         if (!cdrom_get_media_event(cdi, &med)) {
2682                 if (med.media_present)
2683                         return CDS_DISC_OK;
2684                 else if (med.door_open)
2685                         return CDS_TRAY_OPEN;
2686                 else
2687                         return CDS_NO_DISC;
2688         }
2689
2690         if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
2691                 return CDS_DISC_OK;
2692
2693         /*
2694          * If not using Mt Fuji extended media tray reports,
2695          * just return TRAY_OPEN since ATAPI doesn't provide
2696          * any other way to detect this...
2697          */
2698         if (sense.sense_key == NOT_READY) {
2699                 if (sense.asc == 0x3a) {
2700                         if (sense.ascq == 1)
2701                                 return CDS_NO_DISC;
2702                         else if (sense.ascq == 0 || sense.ascq == 2)
2703                                 return CDS_TRAY_OPEN;
2704                 }
2705         }
2706
2707         return CDS_DRIVE_NOT_READY;
2708 }
2709
2710 static
2711 int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
2712                                 struct cdrom_multisession *ms_info)
2713 {
2714         struct atapi_toc *toc;
2715         ide_drive_t *drive = cdi->handle;
2716         struct cdrom_info *info = drive->driver_data;
2717         struct request_sense sense;
2718         int ret;
2719
2720         if (!CDROM_STATE_FLAGS(drive)->toc_valid || info->toc == NULL)
2721                 if ((ret = cdrom_read_toc(drive, &sense)))
2722                         return ret;
2723
2724         toc = info->toc;
2725         ms_info->addr.lba = toc->last_session_lba;
2726         ms_info->xa_flag = toc->xa_flag;
2727
2728         return 0;
2729 }
2730
2731 static
2732 int ide_cdrom_get_mcn (struct cdrom_device_info *cdi,
2733                        struct cdrom_mcn *mcn_info)
2734 {
2735         int stat;
2736         char mcnbuf[24];
2737         ide_drive_t *drive = cdi->handle;
2738
2739 /* get MCN */
2740         if ((stat = cdrom_read_subchannel(drive, 2, mcnbuf, sizeof (mcnbuf), NULL)))
2741                 return stat;
2742
2743         memcpy (mcn_info->medium_catalog_number, mcnbuf+9,
2744                 sizeof (mcn_info->medium_catalog_number)-1);
2745         mcn_info->medium_catalog_number[sizeof (mcn_info->medium_catalog_number)-1]
2746                 = '\0';
2747
2748         return 0;
2749 }
2750
2751
2752
2753 /****************************************************************************
2754  * Other driver requests (open, close, check media change).
2755  */
2756
2757 static
2758 int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
2759                                        int slot_nr)
2760 {
2761         ide_drive_t *drive = cdi->handle;
2762         int retval;
2763
2764         if (slot_nr == CDSL_CURRENT) {
2765                 (void) cdrom_check_status(drive, NULL);
2766                 retval = CDROM_STATE_FLAGS(drive)->media_changed;
2767                 CDROM_STATE_FLAGS(drive)->media_changed = 0;
2768                 return retval;
2769         } else {
2770                 return -EINVAL;
2771         }
2772 }
2773
2774
2775 static
2776 int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
2777 {
2778         return 0;
2779 }
2780
2781 /*
2782  * Close down the device.  Invalidate all cached blocks.
2783  */
2784
2785 static
2786 void ide_cdrom_release_real (struct cdrom_device_info *cdi)
2787 {
2788         ide_drive_t *drive = cdi->handle;
2789
2790         if (!cdi->use_count)
2791                 CDROM_STATE_FLAGS(drive)->toc_valid = 0;
2792 }
2793
2794
2795
2796 /****************************************************************************
2797  * Device initialization.
2798  */
2799 static struct cdrom_device_ops ide_cdrom_dops = {
2800         .open                   = ide_cdrom_open_real,
2801         .release                = ide_cdrom_release_real,
2802         .drive_status           = ide_cdrom_drive_status,
2803         .media_changed          = ide_cdrom_check_media_change_real,
2804         .tray_move              = ide_cdrom_tray_move,
2805         .lock_door              = ide_cdrom_lock_door,
2806         .select_speed           = ide_cdrom_select_speed,
2807         .get_last_session       = ide_cdrom_get_last_session,
2808         .get_mcn                = ide_cdrom_get_mcn,
2809         .reset                  = ide_cdrom_reset,
2810         .audio_ioctl            = ide_cdrom_audio_ioctl,
2811         .capability             = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
2812                                 CDC_SELECT_SPEED | CDC_SELECT_DISC |
2813                                 CDC_MULTI_SESSION | CDC_MCN |
2814                                 CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO | CDC_RESET |
2815                                 CDC_DRIVE_STATUS | CDC_CD_R |
2816                                 CDC_CD_RW | CDC_DVD | CDC_DVD_R| CDC_DVD_RAM |
2817                                 CDC_GENERIC_PACKET | CDC_MO_DRIVE | CDC_MRW |
2818                                 CDC_MRW_W | CDC_RAM,
2819         .generic_packet         = ide_cdrom_packet,
2820 };
2821
2822 static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2823 {
2824         struct cdrom_info *info = drive->driver_data;
2825         struct cdrom_device_info *devinfo = &info->devinfo;
2826
2827         devinfo->ops = &ide_cdrom_dops;
2828         devinfo->mask = 0;
2829         devinfo->speed = CDROM_STATE_FLAGS(drive)->current_speed;
2830         devinfo->capacity = nslots;
2831         devinfo->handle = drive;
2832         strcpy(devinfo->name, drive->name);
2833
2834         /* set capability mask to match the probe. */
2835         if (!CDROM_CONFIG_FLAGS(drive)->cd_r)
2836                 devinfo->mask |= CDC_CD_R;
2837         if (!CDROM_CONFIG_FLAGS(drive)->cd_rw)
2838                 devinfo->mask |= CDC_CD_RW;
2839         if (!CDROM_CONFIG_FLAGS(drive)->dvd)
2840                 devinfo->mask |= CDC_DVD;
2841         if (!CDROM_CONFIG_FLAGS(drive)->dvd_r)
2842                 devinfo->mask |= CDC_DVD_R;
2843         if (!CDROM_CONFIG_FLAGS(drive)->dvd_ram)
2844                 devinfo->mask |= CDC_DVD_RAM;
2845         if (!CDROM_CONFIG_FLAGS(drive)->is_changer)
2846                 devinfo->mask |= CDC_SELECT_DISC;
2847         if (!CDROM_CONFIG_FLAGS(drive)->audio_play)
2848                 devinfo->mask |= CDC_PLAY_AUDIO;
2849         if (!CDROM_CONFIG_FLAGS(drive)->close_tray)
2850                 devinfo->mask |= CDC_CLOSE_TRAY;
2851         if (!CDROM_CONFIG_FLAGS(drive)->mo_drive)
2852                 devinfo->mask |= CDC_MO_DRIVE;
2853         if (!CDROM_CONFIG_FLAGS(drive)->ram)
2854                 devinfo->mask |= CDC_RAM;
2855
2856         devinfo->disk = info->disk;
2857         return register_cdrom(devinfo);
2858 }
2859
2860 static
2861 int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2862 {
2863         struct cdrom_info *info = drive->driver_data;
2864         struct cdrom_device_info *cdi = &info->devinfo;
2865         struct atapi_capabilities_page cap;
2866         int nslots = 1;
2867
2868         if (drive->media == ide_optical) {
2869                 CDROM_CONFIG_FLAGS(drive)->mo_drive = 1;
2870                 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2871                 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
2872                 return nslots;
2873         }
2874
2875         if (CDROM_CONFIG_FLAGS(drive)->nec260 ||
2876             !strcmp(drive->id->model,"STINGRAY 8422 IDE 8X CD-ROM 7-27-95")) {
2877                 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2878                 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2879                 return nslots;
2880         }
2881
2882         /*
2883          * we have to cheat a little here. the packet will eventually
2884          * be queued with ide_cdrom_packet(), which extracts the
2885          * drive from cdi->handle. Since this device hasn't been
2886          * registered with the Uniform layer yet, it can't do this.
2887          * Same goes for cdi->ops.
2888          */
2889         cdi->handle = drive;
2890         cdi->ops = &ide_cdrom_dops;
2891
2892         if (ide_cdrom_get_capabilities(drive, &cap))
2893                 return 0;
2894
2895         if (cap.lock == 0)
2896                 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
2897         if (cap.eject)
2898                 CDROM_CONFIG_FLAGS(drive)->no_eject = 0;
2899         if (cap.cd_r_write)
2900                 CDROM_CONFIG_FLAGS(drive)->cd_r = 1;
2901         if (cap.cd_rw_write) {
2902                 CDROM_CONFIG_FLAGS(drive)->cd_rw = 1;
2903                 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2904         }
2905         if (cap.test_write)
2906                 CDROM_CONFIG_FLAGS(drive)->test_write = 1;
2907         if (cap.dvd_ram_read || cap.dvd_r_read || cap.dvd_rom)
2908                 CDROM_CONFIG_FLAGS(drive)->dvd = 1;
2909         if (cap.dvd_ram_write) {
2910                 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 1;
2911                 CDROM_CONFIG_FLAGS(drive)->ram = 1;
2912         }
2913         if (cap.dvd_r_write)
2914                 CDROM_CONFIG_FLAGS(drive)->dvd_r = 1;
2915         if (cap.audio_play)
2916                 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2917         if (cap.mechtype == mechtype_caddy || cap.mechtype == mechtype_popup)
2918                 CDROM_CONFIG_FLAGS(drive)->close_tray = 0;
2919
2920         /* Some drives used by Apple don't advertise audio play
2921          * but they do support reading TOC & audio datas
2922          */
2923         if (strcmp(drive->id->model, "MATSHITADVD-ROM SR-8187") == 0 ||
2924             strcmp(drive->id->model, "MATSHITADVD-ROM SR-8186") == 0 ||
2925             strcmp(drive->id->model, "MATSHITADVD-ROM SR-8176") == 0 ||
2926             strcmp(drive->id->model, "MATSHITADVD-ROM SR-8174") == 0)
2927                 CDROM_CONFIG_FLAGS(drive)->audio_play = 1;
2928
2929 #if ! STANDARD_ATAPI
2930         if (cdi->sanyo_slot > 0) {
2931                 CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
2932                 nslots = 3;
2933         }
2934
2935         else
2936 #endif /* not STANDARD_ATAPI */
2937         if (cap.mechtype == mechtype_individual_changer ||
2938             cap.mechtype == mechtype_cartridge_changer) {
2939                 if ((nslots = cdrom_number_of_slots(cdi)) > 1) {
2940                         CDROM_CONFIG_FLAGS(drive)->is_changer = 1;
2941                         CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 1;
2942                 }
2943         }
2944
2945         ide_cdrom_update_speed(drive, &cap);
2946         /* don't print speed if the drive reported 0.
2947          */
2948         printk(KERN_INFO "%s: ATAPI", drive->name);
2949         if (CDROM_CONFIG_FLAGS(drive)->max_speed)
2950                 printk(" %dX", CDROM_CONFIG_FLAGS(drive)->max_speed);
2951         printk(" %s", CDROM_CONFIG_FLAGS(drive)->dvd ? "DVD-ROM" : "CD-ROM");
2952
2953         if (CDROM_CONFIG_FLAGS(drive)->dvd_r|CDROM_CONFIG_FLAGS(drive)->dvd_ram)
2954                 printk(" DVD%s%s",
2955                 (CDROM_CONFIG_FLAGS(drive)->dvd_r)? "-R" : "",
2956                 (CDROM_CONFIG_FLAGS(drive)->dvd_ram)? "-RAM" : "");
2957
2958         if (CDROM_CONFIG_FLAGS(drive)->cd_r|CDROM_CONFIG_FLAGS(drive)->cd_rw)
2959                 printk(" CD%s%s",
2960                 (CDROM_CONFIG_FLAGS(drive)->cd_r)? "-R" : "",
2961                 (CDROM_CONFIG_FLAGS(drive)->cd_rw)? "/RW" : "");
2962
2963         if (CDROM_CONFIG_FLAGS(drive)->is_changer)
2964                 printk(" changer w/%d slots", nslots);
2965         else
2966                 printk(" drive");
2967
2968         printk(", %dkB Cache", be16_to_cpu(cap.buffer_size));
2969
2970         if (drive->using_dma)
2971                 ide_dma_verbose(drive);
2972
2973         printk("\n");
2974
2975         return nslots;
2976 }
2977
2978 static void ide_cdrom_add_settings(ide_drive_t *drive)
2979 {
2980         ide_add_setting(drive,  "dsc_overlap",          SETTING_RW, -1, -1, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
2981 }
2982
2983 /*
2984  * standard prep_rq_fn that builds 10 byte cmds
2985  */
2986 static int ide_cdrom_prep_fs(request_queue_t *q, struct request *rq)
2987 {
2988         int hard_sect = queue_hardsect_size(q);
2989         long block = (long)rq->hard_sector / (hard_sect >> 9);
2990         unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
2991
2992         memset(rq->cmd, 0, sizeof(rq->cmd));
2993
2994         if (rq_data_dir(rq) == READ)
2995                 rq->cmd[0] = GPCMD_READ_10;
2996         else
2997                 rq->cmd[0] = GPCMD_WRITE_10;
2998
2999         /*
3000          * fill in lba
3001          */
3002         rq->cmd[2] = (block >> 24) & 0xff;
3003         rq->cmd[3] = (block >> 16) & 0xff;
3004         rq->cmd[4] = (block >>  8) & 0xff;
3005         rq->cmd[5] = block & 0xff;
3006
3007         /*
3008          * and transfer length
3009          */
3010         rq->cmd[7] = (blocks >> 8) & 0xff;
3011         rq->cmd[8] = blocks & 0xff;
3012         rq->cmd_len = 10;
3013         return BLKPREP_OK;
3014 }
3015
3016 /*
3017  * Most of the SCSI commands are supported directly by ATAPI devices.
3018  * This transform handles the few exceptions.
3019  */
3020 static int ide_cdrom_prep_pc(struct request *rq)
3021 {
3022         u8 *c = rq->cmd;
3023
3024         /*
3025          * Transform 6-byte read/write commands to the 10-byte version
3026          */
3027         if (c[0] == READ_6 || c[0] == WRITE_6) {
3028                 c[8] = c[4];
3029                 c[5] = c[3];
3030                 c[4] = c[2];
3031                 c[3] = c[1] & 0x1f;
3032                 c[2] = 0;
3033                 c[1] &= 0xe0;
3034                 c[0] += (READ_10 - READ_6);
3035                 rq->cmd_len = 10;
3036                 return BLKPREP_OK;
3037         }
3038
3039         /*
3040          * it's silly to pretend we understand 6-byte sense commands, just
3041          * reject with ILLEGAL_REQUEST and the caller should take the
3042          * appropriate action
3043          */
3044         if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
3045                 rq->errors = ILLEGAL_REQUEST;
3046                 return BLKPREP_KILL;
3047         }
3048
3049         return BLKPREP_OK;
3050 }
3051
3052 static int ide_cdrom_prep_fn(request_queue_t *q, struct request *rq)
3053 {
3054         if (rq->flags & REQ_CMD)
3055                 return ide_cdrom_prep_fs(q, rq);
3056         else if (rq->flags & REQ_BLOCK_PC)
3057                 return ide_cdrom_prep_pc(rq);
3058
3059         return 0;
3060 }
3061
3062 static
3063 int ide_cdrom_setup (ide_drive_t *drive)
3064 {
3065         struct cdrom_info *info = drive->driver_data;
3066         struct cdrom_device_info *cdi = &info->devinfo;
3067         int nslots;
3068
3069         blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
3070         blk_queue_dma_alignment(drive->queue, 31);
3071         drive->queue->unplug_delay = (1 * HZ) / 1000;
3072         if (!drive->queue->unplug_delay)
3073                 drive->queue->unplug_delay = 1;
3074
3075         drive->special.all      = 0;
3076
3077         CDROM_STATE_FLAGS(drive)->media_changed = 1;
3078         CDROM_STATE_FLAGS(drive)->toc_valid     = 0;
3079         CDROM_STATE_FLAGS(drive)->door_locked   = 0;
3080
3081 #if NO_DOOR_LOCKING
3082         CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1;
3083 #else
3084         CDROM_CONFIG_FLAGS(drive)->no_doorlock = 0;
3085 #endif
3086
3087         CDROM_CONFIG_FLAGS(drive)->drq_interrupt = ((drive->id->config & 0x0060) == 0x20);
3088         CDROM_CONFIG_FLAGS(drive)->is_changer = 0;
3089         CDROM_CONFIG_FLAGS(drive)->cd_r = 0;
3090         CDROM_CONFIG_FLAGS(drive)->cd_rw = 0;
3091         CDROM_CONFIG_FLAGS(drive)->test_write = 0;
3092         CDROM_CONFIG_FLAGS(drive)->dvd = 0;
3093         CDROM_CONFIG_FLAGS(drive)->dvd_r = 0;
3094         CDROM_CONFIG_FLAGS(drive)->dvd_ram = 0;
3095         CDROM_CONFIG_FLAGS(drive)->no_eject = 1;
3096         CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 0;
3097         CDROM_CONFIG_FLAGS(drive)->audio_play = 0;
3098         CDROM_CONFIG_FLAGS(drive)->close_tray = 1;
3099
3100         /* limit transfer size per interrupt. */
3101         CDROM_CONFIG_FLAGS(drive)->limit_nframes = 0;
3102         /* a testament to the nice quality of Samsung drives... */
3103         if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2430"))
3104                 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3105         else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2432"))
3106                 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
3107         /* the 3231 model does not support the SET_CD_SPEED command */
3108         else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-3231"))
3109                 cdi->mask |= CDC_SELECT_SPEED;
3110
3111 #if ! STANDARD_ATAPI
3112         /* by default Sanyo 3 CD changer support is turned off and
3113            ATAPI Rev 2.2+ standard support for CD changers is used */
3114         cdi->sanyo_slot = 0;
3115
3116         CDROM_CONFIG_FLAGS(drive)->nec260 = 0;
3117         CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 0;
3118         CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 0;
3119         CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 0;
3120         CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 0;
3121
3122         if (strcmp (drive->id->model, "V003S0DS") == 0 &&
3123             drive->id->fw_rev[4] == '1' &&
3124             drive->id->fw_rev[6] <= '2') {
3125                 /* Vertos 300.
3126                    Some versions of this drive like to talk BCD. */
3127                 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3128                 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3129                 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3130                 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3131         }
3132
3133         else if (strcmp (drive->id->model, "V006E0DS") == 0 &&
3134             drive->id->fw_rev[4] == '1' &&
3135             drive->id->fw_rev[6] <= '2') {
3136                 /* Vertos 600 ESD. */
3137                 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1;
3138         }
3139         else if (strcmp(drive->id->model, "NEC CD-ROM DRIVE:260") == 0 &&
3140                  strncmp(drive->id->fw_rev, "1.01", 4) == 0) { /* FIXME */
3141                 /* Old NEC260 (not R).
3142                    This drive was released before the 1.2 version
3143                    of the spec. */
3144                 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1;
3145                 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3146                 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3147                 CDROM_CONFIG_FLAGS(drive)->nec260         = 1;
3148         }
3149         else if (strcmp(drive->id->model, "WEARNES CDD-120") == 0 &&
3150                  strncmp(drive->id->fw_rev, "A1.1", 4) == 0) { /* FIXME */
3151                 /* Wearnes */
3152                 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1;
3153                 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1;
3154         }
3155         /* Sanyo 3 CD changer uses a non-standard command
3156            for CD changing */
3157         else if ((strcmp(drive->id->model, "CD-ROM CDR-C3 G") == 0) ||
3158                  (strcmp(drive->id->model, "CD-ROM CDR-C3G") == 0) ||
3159                  (strcmp(drive->id->model, "CD-ROM CDR_C36") == 0)) {
3160                  /* uses CD in slot 0 when value is set to 3 */
3161                  cdi->sanyo_slot = 3;
3162         }
3163 #endif /* not STANDARD_ATAPI */
3164
3165         info->toc               = NULL;
3166         info->buffer            = NULL;
3167         info->sector_buffered   = 0;
3168         info->nsectors_buffered = 0;
3169         info->changer_info      = NULL;
3170         info->last_block        = 0;
3171         info->start_seek        = 0;
3172
3173         nslots = ide_cdrom_probe_capabilities (drive);
3174
3175         /*
3176          * set correct block size
3177          */
3178         blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
3179
3180         if (drive->autotune == IDE_TUNE_DEFAULT ||
3181             drive->autotune == IDE_TUNE_AUTO)
3182                 drive->dsc_overlap = (drive->next != drive);
3183 #if 0
3184         drive->dsc_overlap = (HWIF(drive)->no_dsc) ? 0 : 1;
3185         if (HWIF(drive)->no_dsc) {
3186                 printk(KERN_INFO "ide-cd: %s: disabling DSC overlap\n",
3187                         drive->name);
3188                 drive->dsc_overlap = 0;
3189         }
3190 #endif
3191
3192         if (ide_cdrom_register(drive, nslots)) {
3193                 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
3194                 info->devinfo.handle = NULL;
3195                 return 1;
3196         }
3197         ide_cdrom_add_settings(drive);
3198         return 0;
3199 }
3200
3201 #ifdef CONFIG_PROC_FS
3202 static
3203 sector_t ide_cdrom_capacity (ide_drive_t *drive)
3204 {
3205         unsigned long capacity, sectors_per_frame;
3206
3207         if (cdrom_read_capacity(drive, &capacity, &sectors_per_frame, NULL))
3208                 return 0;
3209
3210         return capacity * sectors_per_frame;
3211 }
3212 #endif
3213
3214 static void ide_cd_remove(ide_drive_t *drive)
3215 {
3216         struct cdrom_info *info = drive->driver_data;
3217
3218         ide_unregister_subdriver(drive, info->driver);
3219
3220         del_gendisk(info->disk);
3221
3222         ide_cd_put(info);
3223 }
3224
3225 static void ide_cd_release(struct kref *kref)
3226 {
3227         struct cdrom_info *info = to_ide_cd(kref);
3228         struct cdrom_device_info *devinfo = &info->devinfo;
3229         ide_drive_t *drive = info->drive;
3230         struct gendisk *g = info->disk;
3231
3232         kfree(info->buffer);
3233         kfree(info->toc);
3234         kfree(info->changer_info);
3235         if (devinfo->handle == drive && unregister_cdrom(devinfo))
3236                 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom "
3237                                 "driver.\n", __FUNCTION__, drive->name);
3238         drive->dsc_overlap = 0;
3239         drive->driver_data = NULL;
3240         blk_queue_prep_rq(drive->queue, NULL);
3241         g->private_data = NULL;
3242         put_disk(g);
3243         kfree(info);
3244 }
3245
3246 static int ide_cd_probe(ide_drive_t *);
3247
3248 #ifdef CONFIG_PROC_FS
3249 static int proc_idecd_read_capacity
3250         (char *page, char **start, off_t off, int count, int *eof, void *data)
3251 {
3252         ide_drive_t *drive = data;
3253         int len;
3254
3255         len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
3256         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
3257 }
3258
3259 static ide_proc_entry_t idecd_proc[] = {
3260         { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
3261         { NULL, 0, NULL, NULL }
3262 };
3263 #else
3264 # define idecd_proc     NULL
3265 #endif
3266
3267 static ide_driver_t ide_cdrom_driver = {
3268         .gen_driver = {
3269                 .owner          = THIS_MODULE,
3270                 .name           = "ide-cdrom",
3271                 .bus            = &ide_bus_type,
3272         },
3273         .probe                  = ide_cd_probe,
3274         .remove                 = ide_cd_remove,
3275         .version                = IDECD_VERSION,
3276         .media                  = ide_cdrom,
3277         .supports_dsc_overlap   = 1,
3278         .do_request             = ide_do_rw_cdrom,
3279         .end_request            = ide_end_request,
3280         .error                  = __ide_error,
3281         .abort                  = __ide_abort,
3282         .proc                   = idecd_proc,
3283 };
3284
3285 static int idecd_open(struct inode * inode, struct file * file)
3286 {
3287         struct gendisk *disk = inode->i_bdev->bd_disk;
3288         struct cdrom_info *info;
3289         ide_drive_t *drive;
3290         int rc = -ENOMEM;
3291
3292         if (!(info = ide_cd_get(disk)))
3293                 return -ENXIO;
3294
3295         drive = info->drive;
3296
3297         drive->usage++;
3298
3299         if (!info->buffer)
3300                 info->buffer = kmalloc(SECTOR_BUFFER_SIZE,
3301                                         GFP_KERNEL|__GFP_REPEAT);
3302         if (!info->buffer || (rc = cdrom_open(&info->devinfo, inode, file)))
3303                 drive->usage--;
3304
3305         if (rc < 0)
3306                 ide_cd_put(info);
3307
3308         return rc;
3309 }
3310
3311 static int idecd_release(struct inode * inode, struct file * file)
3312 {
3313         struct gendisk *disk = inode->i_bdev->bd_disk;
3314         struct cdrom_info *info = ide_cd_g(disk);
3315         ide_drive_t *drive = info->drive;
3316
3317         cdrom_release (&info->devinfo, file);
3318         drive->usage--;
3319
3320         ide_cd_put(info);
3321
3322         return 0;
3323 }
3324
3325 static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg)
3326 {
3327         struct packet_command cgc;
3328         char buffer[16];
3329         int stat;
3330         char spindown;
3331
3332         if (copy_from_user(&spindown, (void __user *)arg, sizeof(char)))
3333                 return -EFAULT;
3334
3335         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
3336
3337         stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
3338         if (stat)
3339                 return stat;
3340
3341         buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
3342         return cdrom_mode_select(cdi, &cgc);
3343 }
3344
3345 static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
3346 {
3347         struct packet_command cgc;
3348         char buffer[16];
3349         int stat;
3350         char spindown;
3351
3352         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
3353
3354         stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
3355         if (stat)
3356                 return stat;
3357
3358         spindown = buffer[11] & 0x0f;
3359         if (copy_to_user((void __user *)arg, &spindown, sizeof (char)))
3360                 return -EFAULT;
3361         return 0;
3362 }
3363
3364 static int idecd_ioctl (struct inode *inode, struct file *file,
3365                         unsigned int cmd, unsigned long arg)
3366 {
3367         struct block_device *bdev = inode->i_bdev;
3368         struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
3369         int err;
3370
3371         switch (cmd) {
3372         case CDROMSETSPINDOWN:
3373                 return idecd_set_spindown(&info->devinfo, arg);
3374         case CDROMGETSPINDOWN:
3375                 return idecd_get_spindown(&info->devinfo, arg);
3376         default:
3377                 break;
3378         }
3379
3380         err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
3381         if (err == -EINVAL)
3382                 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
3383
3384         return err;
3385 }
3386
3387 static int idecd_media_changed(struct gendisk *disk)
3388 {
3389         struct cdrom_info *info = ide_cd_g(disk);
3390         return cdrom_media_changed(&info->devinfo);
3391 }
3392
3393 static int idecd_revalidate_disk(struct gendisk *disk)
3394 {
3395         struct cdrom_info *info = ide_cd_g(disk);
3396         struct request_sense sense;
3397         cdrom_read_toc(info->drive, &sense);
3398         return  0;
3399 }
3400
3401 static struct block_device_operations idecd_ops = {
3402         .owner          = THIS_MODULE,
3403         .open           = idecd_open,
3404         .release        = idecd_release,
3405         .ioctl          = idecd_ioctl,
3406         .media_changed  = idecd_media_changed,
3407         .revalidate_disk= idecd_revalidate_disk
3408 };
3409
3410 /* options */
3411 static char *ignore = NULL;
3412
3413 module_param(ignore, charp, 0400);
3414 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
3415
3416 static int ide_cd_probe(ide_drive_t *drive)
3417 {
3418         struct cdrom_info *info;
3419         struct gendisk *g;
3420         struct request_sense sense;
3421
3422         if (!strstr("ide-cdrom", drive->driver_req))
3423                 goto failed;
3424         if (!drive->present)
3425                 goto failed;
3426         if (drive->media != ide_cdrom && drive->media != ide_optical)
3427                 goto failed;
3428         /* skip drives that we were told to ignore */
3429         if (ignore != NULL) {
3430                 if (strstr(ignore, drive->name)) {
3431                         printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
3432                         goto failed;
3433                 }
3434         }
3435         if (drive->scsi) {
3436                 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
3437                 goto failed;
3438         }
3439         info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
3440         if (info == NULL) {
3441                 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
3442                 goto failed;
3443         }
3444
3445         g = alloc_disk(1 << PARTN_BITS);
3446         if (!g)
3447                 goto out_free_cd;
3448
3449         ide_init_disk(g, drive);
3450
3451         ide_register_subdriver(drive, &ide_cdrom_driver);
3452
3453         kref_init(&info->kref);
3454
3455         info->drive = drive;
3456         info->driver = &ide_cdrom_driver;
3457         info->disk = g;
3458
3459         g->private_data = &info->driver;
3460
3461         drive->driver_data = info;
3462
3463         g->minors = 1;
3464         snprintf(g->devfs_name, sizeof(g->devfs_name),
3465                         "%s/cd", drive->devfs_name);
3466         g->driverfs_dev = &drive->gendev;
3467         g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
3468         if (ide_cdrom_setup(drive)) {
3469                 struct cdrom_device_info *devinfo = &info->devinfo;
3470                 ide_unregister_subdriver(drive, &ide_cdrom_driver);
3471                 kfree(info->buffer);
3472                 kfree(info->toc);
3473                 kfree(info->changer_info);
3474                 if (devinfo->handle == drive && unregister_cdrom(devinfo))
3475                         printk (KERN_ERR "%s: ide_cdrom_cleanup failed to unregister device from the cdrom driver.\n", drive->name);
3476                 kfree(info);
3477                 drive->driver_data = NULL;
3478                 goto failed;
3479         }
3480
3481         cdrom_read_toc(drive, &sense);
3482         g->fops = &idecd_ops;
3483         g->flags |= GENHD_FL_REMOVABLE;
3484         add_disk(g);
3485         return 0;
3486
3487 out_free_cd:
3488         kfree(info);
3489 failed:
3490         return -ENODEV;
3491 }
3492
3493 static void __exit ide_cdrom_exit(void)
3494 {
3495         driver_unregister(&ide_cdrom_driver.gen_driver);
3496 }
3497
3498 static int __init ide_cdrom_init(void)
3499 {
3500         return driver_register(&ide_cdrom_driver.gen_driver);
3501 }
3502
3503 MODULE_ALIAS("ide:*m-cdrom*");
3504 module_init(ide_cdrom_init);
3505 module_exit(ide_cdrom_exit);
3506 MODULE_LICENSE("GPL");