drivers/ide/ide-cd.c

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