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