drivers/ide/ide-cd.c

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