PageRenderTime 78ms CodeModel.GetById 14ms app.highlight 49ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/ide/ide-cd.c

https://bitbucket.org/evzijst/gittest
C | 3524 lines | 2182 code | 535 blank | 807 comment | 568 complexity | 28a50b51c4f2de81781a39e90cf8186b MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1/*
   2 * linux/drivers/ide/ide-cd.c
   3 *
   4 * Copyright (C) 1994, 1995, 1996  scott snyder  <snyder@fnald0.fnal.gov>
   5 * Copyright (C) 1996-1998  Erik Andersen <andersee@debian.org>
   6 * Copyright (C) 1998-2000  Jens Axboe <axboe@suse.de>
   7 *
   8 * May be copied or modified under the terms of the GNU General Public
   9 * License.  See linux/COPYING for more information.
  10 *
  11 * ATAPI CD-ROM driver.  To be used with ide.c.
  12 * See Documentation/cdrom/ide-cd for usage information.
  13 *
  14 * Suggestions are welcome. Patches that work are more welcome though. ;-)
  15 * For those wishing to work on this driver, please be sure you download
  16 * and comply with the latest Mt. Fuji (SFF8090 version 4) and ATAPI 
  17 * (SFF-8020i rev 2.6) standards. These documents can be obtained by 
  18 * anonymous ftp from:
  19 * ftp://fission.dt.wdc.com/pub/standards/SFF_atapi/spec/SFF8020-r2.6/PS/8020r26.ps
  20 * ftp://ftp.avc-pioneer.com/Mtfuji4/Spec/Fuji4r10.pdf
  21 *
  22 * Drives that deviate from these standards will be accommodated as much
  23 * as possible via compile time or command-line options.  Since I only have
  24 * a few drives, you generally need to send me patches...
  25 *
  26 * ----------------------------------
  27 * TO DO LIST:
  28 * -Make it so that Pioneer CD DR-A24X and friends don't get screwed up on
  29 *   boot
  30 *
  31 * ----------------------------------
  32 * 1.00  Oct 31, 1994 -- Initial version.
  33 * 1.01  Nov  2, 1994 -- Fixed problem with starting request in
  34 *                       cdrom_check_status.
  35 * 1.03  Nov 25, 1994 -- leaving unmask_intr[] as a user-setting (as for disks)
  36 * (from mlord)       -- minor changes to cdrom_setup()
  37 *                    -- renamed ide_dev_s to ide_drive_t, enable irq on command
  38 * 2.00  Nov 27, 1994 -- Generalize packet command interface;
  39 *                       add audio ioctls.
  40 * 2.01  Dec  3, 1994 -- Rework packet command interface to handle devices
  41 *                       which send an interrupt when ready for a command.
  42 * 2.02  Dec 11, 1994 -- Cache the TOC in the driver.
  43 *                       Don't use SCMD_PLAYAUDIO_TI; it's not included
  44 *                       in the current version of ATAPI.
  45 *                       Try to use LBA instead of track or MSF addressing
  46 *                       when possible.
  47 *                       Don't wait for READY_STAT.
  48 * 2.03  Jan 10, 1995 -- Rewrite block read routines to handle block sizes
  49 *                       other than 2k and to move multiple sectors in a
  50 *                       single transaction.
  51 * 2.04  Apr 21, 1995 -- Add work-around for Creative Labs CD220E drives.
  52 *                       Thanks to Nick Saw <cwsaw@pts7.pts.mot.com> for
  53 *                       help in figuring this out.  Ditto for Acer and
  54 *                       Aztech drives, which seem to have the same problem.
  55 * 2.04b May 30, 1995 -- Fix to match changes in ide.c version 3.16 -ml
  56 * 2.05  Jun  8, 1995 -- Don't attempt to retry after an illegal request
  57 *                        or data protect error.
  58 *                       Use HWIF and DEV_HWIF macros as in ide.c.
  59 *                       Always try to do a request_sense after
  60 *                        a failed command.
  61 *                       Include an option to give textual descriptions
  62 *                        of ATAPI errors.
  63 *                       Fix a bug in handling the sector cache which
  64 *                        showed up if the drive returned data in 512 byte
  65 *                        blocks (like Pioneer drives).  Thanks to
  66 *                        Richard Hirst <srh@gpt.co.uk> for diagnosing this.
  67 *                       Properly supply the page number field in the
  68 *                        MODE_SELECT command.
  69 *                       PLAYAUDIO12 is broken on the Aztech; work around it.
  70 * 2.05x Aug 11, 1995 -- lots of data structure renaming/restructuring in ide.c
  71 *                       (my apologies to Scott, but now ide-cd.c is independent)
  72 * 3.00  Aug 22, 1995 -- Implement CDROMMULTISESSION ioctl.
  73 *                       Implement CDROMREADAUDIO ioctl (UNTESTED).
  74 *                       Use input_ide_data() and output_ide_data().
  75 *                       Add door locking.
  76 *                       Fix usage count leak in cdrom_open, which happened
  77 *                        when a read-write mount was attempted.
  78 *                       Try to load the disk on open.
  79 *                       Implement CDROMEJECT_SW ioctl (off by default).
  80 *                       Read total cdrom capacity during open.
  81 *                       Rearrange logic in cdrom_decode_status.  Issue
  82 *                        request sense commands for failed packet commands
  83 *                        from here instead of from cdrom_queue_packet_command.
  84 *                        Fix a race condition in retrieving error information.
  85 *                       Suppress printing normal unit attention errors and
  86 *                        some drive not ready errors.
  87 *                       Implement CDROMVOLREAD ioctl.
  88 *                       Implement CDROMREADMODE1/2 ioctls.
  89 *                       Fix race condition in setting up interrupt handlers
  90 *                        when the `serialize' option is used.
  91 * 3.01  Sep  2, 1995 -- Fix ordering of reenabling interrupts in
  92 *                        cdrom_queue_request.
  93 *                       Another try at using ide_[input,output]_data.
  94 * 3.02  Sep 16, 1995 -- Stick total disk capacity in partition table as well.
  95 *                       Make VERBOSE_IDE_CD_ERRORS dump failed command again.
  96 *                       Dump out more information for ILLEGAL REQUEST errs.
  97 *                       Fix handling of errors occurring before the
  98 *                        packet command is transferred.
  99 *                       Fix transfers with odd bytelengths.
 100 * 3.03  Oct 27, 1995 -- Some Creative drives have an id of just `CD'.
 101 *                       `DCI-2S10' drives are broken too.
 102 * 3.04  Nov 20, 1995 -- So are Vertos drives.
 103 * 3.05  Dec  1, 1995 -- Changes to go with overhaul of ide.c and ide-tape.c
 104 * 3.06  Dec 16, 1995 -- Add support needed for partitions.
 105 *                       More workarounds for Vertos bugs (based on patches
 106 *                        from Holger Dietze <dietze@aix520.informatik.uni-leipzig.de>).
 107 *                       Try to eliminate byteorder assumptions.
 108 *                       Use atapi_cdrom_subchnl struct definition.
 109 *                       Add STANDARD_ATAPI compilation option.
 110 * 3.07  Jan 29, 1996 -- More twiddling for broken drives: Sony 55D,
 111 *                        Vertos 300.
 112 *                       Add NO_DOOR_LOCKING configuration option.
 113 *                       Handle drive_cmd requests w/NULL args (for hdparm -t).
 114 *                       Work around sporadic Sony55e audio play problem.
 115 * 3.07a Feb 11, 1996 -- check drive->id for NULL before dereferencing, to fix
 116 *                        problem with "hde=cdrom" with no drive present.  -ml
 117 * 3.08  Mar  6, 1996 -- More Vertos workarounds.
 118 * 3.09  Apr  5, 1996 -- Add CDROMCLOSETRAY ioctl.
 119 *                       Switch to using MSF addressing for audio commands.
 120 *                       Reformat to match kernel tabbing style.
 121 *                       Add CDROM_GET_UPC ioctl.
 122 * 3.10  Apr 10, 1996 -- Fix compilation error with STANDARD_ATAPI.
 123 * 3.11  Apr 29, 1996 -- Patch from Heiko Eissfeldt <heiko@colossus.escape.de>
 124 *                       to remove redundant verify_area calls.
 125 * 3.12  May  7, 1996 -- Rudimentary changer support.  Based on patches
 126 *                        from Gerhard Zuber <zuber@berlin.snafu.de>.
 127 *                       Let open succeed even if there's no loaded disc.
 128 * 3.13  May 19, 1996 -- Fixes for changer code.
 129 * 3.14  May 29, 1996 -- Add work-around for Vertos 600.
 130 *                        (From Hennus Bergman <hennus@sky.ow.nl>.)
 131 * 3.15  July 2, 1996 -- Added support for Sanyo 3 CD changers
 132 *                        from Ben Galliart <bgallia@luc.edu> with 
 133 *                        special help from Jeff Lightfoot 
 134 *                        <jeffml@pobox.com>
 135 * 3.15a July 9, 1996 -- Improved Sanyo 3 CD changer identification
 136 * 3.16  Jul 28, 1996 -- Fix from Gadi to reduce kernel stack usage for ioctl.
 137 * 3.17  Sep 17, 1996 -- Tweak audio reads for some drives.
 138 *                       Start changing CDROMLOADFROMSLOT to CDROM_SELECT_DISC.
 139 * 3.18  Oct 31, 1996 -- Added module and DMA support.
 140 *                       
 141 *                       
 142 * 4.00  Nov 5, 1996   -- New ide-cd maintainer,
 143 *                                 Erik B. Andersen <andersee@debian.org>
 144 *                     -- Newer Creative drives don't always set the error
 145 *                          register correctly.  Make sure we see media changes
 146 *                          regardless.
 147 *                     -- Integrate with generic cdrom driver.
 148 *                     -- CDROMGETSPINDOWN and CDROMSETSPINDOWN ioctls, based on
 149 *                          a patch from Ciro Cattuto <>.
 150 *                     -- Call set_device_ro.
 151 *                     -- Implement CDROMMECHANISMSTATUS and CDROMSLOTTABLE
 152 *                          ioctls, based on patch by Erik Andersen
 153 *                     -- Add some probes of drive capability during setup.
 154 *
 155 * 4.01  Nov 11, 1996  -- Split into ide-cd.c and ide-cd.h
 156 *                     -- Removed CDROMMECHANISMSTATUS and CDROMSLOTTABLE 
 157 *                          ioctls in favor of a generalized approach 
 158 *                          using the generic cdrom driver.
 159 *                     -- Fully integrated with the 2.1.X kernel.
 160 *                     -- Other stuff that I forgot (lots of changes)
 161 *
 162 * 4.02  Dec 01, 1996  -- Applied patch from Gadi Oxman <gadio@netvision.net.il>
 163 *                          to fix the drive door locking problems.
 164 *
 165 * 4.03  Dec 04, 1996  -- Added DSC overlap support.
 166 * 4.04  Dec 29, 1996  -- Added CDROMREADRAW ioclt based on patch 
 167 *                          by Ales Makarov (xmakarov@sun.felk.cvut.cz)
 168 *
 169 * 4.05  Nov 20, 1997  -- Modified to print more drive info on init
 170 *                        Minor other changes
 171 *                        Fix errors on CDROMSTOP (If you have a "Dolphin",
 172 *                          you must define IHAVEADOLPHIN)
 173 *                        Added identifier so new Sanyo CD-changer works
 174 *                        Better detection if door locking isn't supported
 175 *
 176 * 4.06  Dec 17, 1997  -- fixed endless "tray open" messages  -ml
 177 * 4.07  Dec 17, 1997  -- fallback to set pc->stat on "tray open"
 178 * 4.08  Dec 18, 1997  -- spew less noise when tray is empty
 179 *                     -- fix speed display for ACER 24X, 18X
 180 * 4.09  Jan 04, 1998  -- fix handling of the last block so we return
 181 *                         an end of file instead of an I/O error (Gadi)
 182 * 4.10  Jan 24, 1998  -- fixed a bug so now changers can change to a new
 183 *                         slot when there is no disc in the current slot.
 184 *                     -- Fixed a memory leak where info->changer_info was
 185 *                         malloc'ed but never free'd when closing the device.
 186 *                     -- Cleaned up the global namespace a bit by making more
 187 *                         functions static that should already have been.
 188 * 4.11  Mar 12, 1998  -- Added support for the CDROM_SELECT_SPEED ioctl
 189 *                         based on a patch for 2.0.33 by Jelle Foks 
 190 *                         <jelle@scintilla.utwente.nl>, a patch for 2.0.33
 191 *                         by Toni Giorgino <toni@pcape2.pi.infn.it>, the SCSI
 192 *                         version, and my own efforts.  -erik
 193 *                     -- Fixed a stupid bug which egcs was kind enough to
 194 *                         inform me of where "Illegal mode for this track"
 195 *                         was never returned due to a comparison on data
 196 *                         types of limited range.
 197 * 4.12  Mar 29, 1998  -- Fixed bug in CDROM_SELECT_SPEED so write speed is 
 198 *                         now set ionly for CD-R and CD-RW drives.  I had 
 199 *                         removed this support because it produced errors.
 200 *                         It produced errors _only_ for non-writers. duh.
 201 * 4.13  May 05, 1998  -- Suppress useless "in progress of becoming ready"
 202 *                         messages, since this is not an error.
 203 *                     -- Change error messages to be const
 204 *                     -- Remove a "\t" which looks ugly in the syslogs
 205 * 4.14  July 17, 1998 -- Change to pointing to .ps version of ATAPI spec
 206 *                         since the .pdf version doesn't seem to work...
 207 *                     -- Updated the TODO list to something more current.
 208 *
 209 * 4.15  Aug 25, 1998  -- Updated ide-cd.h to respect mechine endianess, 
 210 *                         patch thanks to "Eddie C. Dost" <ecd@skynet.be>
 211 *
 212 * 4.50  Oct 19, 1998  -- New maintainers!
 213 *                         Jens Axboe <axboe@image.dk>
 214 *                         Chris Zwilling <chris@cloudnet.com>
 215 *
 216 * 4.51  Dec 23, 1998  -- Jens Axboe <axboe@image.dk>
 217 *                      - ide_cdrom_reset enabled since the ide subsystem
 218 *                         handles resets fine now. <axboe@image.dk>
 219 *                      - Transfer size fix for Samsung CD-ROMs, thanks to
 220 *                        "Ville Hallik" <ville.hallik@mail.ee>.
 221 *                      - other minor stuff.
 222 *
 223 * 4.52  Jan 19, 1999  -- Jens Axboe <axboe@image.dk>
 224 *                      - Detect DVD-ROM/RAM drives
 225 *
 226 * 4.53  Feb 22, 1999   - Include other model Samsung and one Goldstar
 227 *                         drive in transfer size limit.
 228 *                      - Fix the I/O error when doing eject without a medium
 229 *                         loaded on some drives.
 230 *                      - CDROMREADMODE2 is now implemented through
 231 *                         CDROMREADRAW, since many drives don't support
 232 *                         MODE2 (even though ATAPI 2.6 says they must).
 233 *                      - Added ignore parameter to ide-cd (as a module), eg
 234 *                         	insmod ide-cd ignore='hda hdb'
 235 *                         Useful when using ide-cd in conjunction with
 236 *                         ide-scsi. TODO: non-modular way of doing the
 237 *                         same.
 238 *
 239 * 4.54  Aug 5, 1999	- Support for MMC2 class commands through the generic
 240 *			  packet interface to cdrom.c.
 241 *			- Unified audio ioctl support, most of it.
 242 *			- cleaned up various deprecated verify_area().
 243 *			- Added ide_cdrom_packet() as the interface for
 244 *			  the Uniform generic_packet().
 245 *			- bunch of other stuff, will fill in logs later.
 246 *			- report 1 slot for non-changers, like the other
 247 *			  cd-rom drivers. don't report select disc for
 248 *			  non-changers as well.
 249 *			- mask out audio playing, if the device can't do it.
 250 *
 251 * 4.55  Sep 1, 1999	- Eliminated the rest of the audio ioctls, except
 252 *			  for CDROMREADTOC[ENTRY|HEADER]. Some of the drivers
 253 *			  use this independently of the actual audio handling.
 254 *			  They will disappear later when I get the time to
 255 *			  do it cleanly.
 256 *			- Minimize the TOC reading - only do it when we
 257 *			  know a media change has occurred.
 258 *			- Moved all the CDROMREADx ioctls to the Uniform layer.
 259 *			- Heiko Eissfeldt <heiko@colossus.escape.de> supplied
 260 *			  some fixes for CDI.
 261 *			- CD-ROM leaving door locked fix from Andries
 262 *			  Brouwer <Andries.Brouwer@cwi.nl>
 263 *			- Erik Andersen <andersen@xmission.com> unified
 264 *			  commands across the various drivers and how
 265 *			  sense errors are handled.
 266 *
 267 * 4.56  Sep 12, 1999	- Removed changer support - it is now in the
 268 *			  Uniform layer.
 269 *			- Added partition based multisession handling.
 270 *			- Mode sense and mode select moved to the
 271 *			  Uniform layer.
 272 *			- Fixed a problem with WPI CDS-32X drive - it
 273 *			  failed the capabilities 
 274 *
 275 * 4.57  Apr 7, 2000	- Fixed sense reporting.
 276 *			- Fixed possible oops in ide_cdrom_get_last_session()
 277 *			- Fix locking mania and make ide_cdrom_reset relock
 278 *			- Stop spewing errors to log when magicdev polls with
 279 *			  TEST_UNIT_READY on some drives.
 280 *			- Various fixes from Tobias Ringstrom:
 281 *			  tray if it was locked prior to the reset.
 282 *			  - cdrom_read_capacity returns one frame too little.
 283 *			  - Fix real capacity reporting.
 284 *
 285 * 4.58  May 1, 2000	- Clean up ACER50 stuff.
 286 *			- Fix small problem with ide_cdrom_capacity
 287 *
 288 * 4.59  Aug 11, 2000	- Fix changer problem in cdrom_read_toc, we weren't
 289 *			  correctly sensing a disc change.
 290 *			- Rearranged some code
 291 *			- Use extended sense on drives that support it for
 292 *			  correctly reporting tray status -- from
 293 *			  Michael D Johnson <johnsom@orst.edu>
 294 * 4.60  Dec 17, 2003	- Add mt rainier support
 295 *			- Bump timeout for packet commands, matches sr
 296 *			- Odd stuff
 297 * 4.61  Jan 22, 2004	- support hardware sector sizes other than 2kB,
 298 *			  Pascal Schmidt <der.eremit@email.de>
 299 *
 300 *************************************************************************/
 301 
 302#define IDECD_VERSION "4.61"
 303
 304#include <linux/config.h>
 305#include <linux/module.h>
 306#include <linux/types.h>
 307#include <linux/kernel.h>
 308#include <linux/delay.h>
 309#include <linux/timer.h>
 310#include <linux/slab.h>
 311#include <linux/interrupt.h>
 312#include <linux/errno.h>
 313#include <linux/cdrom.h>
 314#include <linux/ide.h>
 315#include <linux/completion.h>
 316
 317#include <scsi/scsi.h>	/* For SCSI -> ATAPI command conversion */
 318
 319#include <asm/irq.h>
 320#include <asm/io.h>
 321#include <asm/byteorder.h>
 322#include <asm/uaccess.h>
 323#include <asm/unaligned.h>
 324
 325#include "ide-cd.h"
 326
 327static DECLARE_MUTEX(idecd_ref_sem);
 328
 329#define to_ide_cd(obj) container_of(obj, struct cdrom_info, kref) 
 330
 331#define ide_cd_g(disk) \
 332	container_of((disk)->private_data, struct cdrom_info, driver)
 333
 334static struct cdrom_info *ide_cd_get(struct gendisk *disk)
 335{
 336	struct cdrom_info *cd = NULL;
 337
 338	down(&idecd_ref_sem);
 339	cd = ide_cd_g(disk);
 340	if (cd)
 341		kref_get(&cd->kref);
 342	up(&idecd_ref_sem);
 343	return cd;
 344}
 345
 346static void ide_cd_release(struct kref *);
 347
 348static void ide_cd_put(struct cdrom_info *cd)
 349{
 350	down(&idecd_ref_sem);
 351	kref_put(&cd->kref, ide_cd_release);
 352	up(&idecd_ref_sem);
 353}
 354
 355/****************************************************************************
 356 * Generic packet command support and error handling routines.
 357 */
 358
 359/* Mark that we've seen a media change, and invalidate our internal
 360   buffers. */
 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->flags & REQ_QUIET))
 376		return 0;
 377
 378	switch (sense->sense_key) {
 379		case NO_SENSE: case RECOVERED_ERROR:
 380			break;
 381		case NOT_READY:
 382			/*
 383			 * don't care about tray state messages for
 384			 * e.g. capacity commands or in-progress or
 385			 * becoming ready
 386			 */
 387			if (sense->asc == 0x3a || sense->asc == 0x04)
 388				break;
 389			log = 1;
 390			break;
 391		case ILLEGAL_REQUEST:
 392			/*
 393			 * don't log START_STOP unit with LoEj set, since
 394			 * we cannot reliably check if drive can auto-close
 395			 */
 396			if (rq->cmd[0] == GPCMD_START_STOP_UNIT && sense->asc == 0x24)
 397				log = 0;
 398			break;
 399		case UNIT_ATTENTION:
 400			/*
 401			 * Make good and sure we've seen this potential media
 402			 * change. Some drives (i.e. Creative) fail to present
 403			 * the correct sense key in the error register.
 404			 */
 405			cdrom_saw_media_change(drive);
 406			break;
 407		default:
 408			log = 1;
 409			break;
 410	}
 411	return log;
 412}
 413
 414static
 415void cdrom_analyze_sense_data(ide_drive_t *drive,
 416			      struct request *failed_command,
 417			      struct request_sense *sense)
 418{
 419	if (!cdrom_log_sense(drive, failed_command, sense))
 420		return;
 421
 422	/*
 423	 * If a read toc is executed for a CD-R or CD-RW medium where
 424	 * the first toc has not been recorded yet, it will fail with
 425	 * 05/24/00 (which is a confusing error)
 426	 */
 427	if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP)
 428		if (sense->sense_key == 0x05 && sense->asc == 0x24)
 429			return;
 430
 431#if VERBOSE_IDE_CD_ERRORS
 432	{
 433		int i;
 434		const char *s;
 435		char buf[80];
 436
 437		printk ("ATAPI device %s:\n", drive->name);
 438		if (sense->error_code==0x70)
 439			printk("  Error: ");
 440		else if (sense->error_code==0x71)
 441			printk("  Deferred Error: ");
 442		else if (sense->error_code == 0x7f)
 443			printk("  Vendor-specific Error: ");
 444		else
 445			printk("  Unknown Error Type: ");
 446
 447		if (sense->sense_key < ARY_LEN(sense_key_texts))
 448			s = sense_key_texts[sense->sense_key];
 449		else
 450			s = "bad sense key!";
 451
 452		printk("%s -- (Sense key=0x%02x)\n", s, sense->sense_key);
 453
 454		if (sense->asc == 0x40) {
 455			sprintf(buf, "Diagnostic failure on component 0x%02x",
 456				 sense->ascq);
 457			s = buf;
 458		} else {
 459			int lo = 0, mid, hi = ARY_LEN(sense_data_texts);
 460			unsigned long key = (sense->sense_key << 16);
 461			key |= (sense->asc << 8);
 462			if (!(sense->ascq >= 0x80 && sense->ascq <= 0xdd))
 463				key |= sense->ascq;
 464			s = NULL;
 465
 466			while (hi > lo) {
 467				mid = (lo + hi) / 2;
 468				if (sense_data_texts[mid].asc_ascq == key ||
 469				    sense_data_texts[mid].asc_ascq == (0xff0000|key)) {
 470					s = sense_data_texts[mid].text;
 471					break;
 472				}
 473				else if (sense_data_texts[mid].asc_ascq > key)
 474					hi = mid;
 475				else
 476					lo = mid+1;
 477			}
 478		}
 479
 480		if (s == NULL) {
 481			if (sense->asc > 0x80)
 482				s = "(vendor-specific error)";
 483			else
 484				s = "(reserved error code)";
 485		}
 486
 487		printk(KERN_ERR "  %s -- (asc=0x%02x, ascq=0x%02x)\n",
 488			s, sense->asc, sense->ascq);
 489
 490		if (failed_command != NULL) {
 491
 492			int lo=0, mid, hi= ARY_LEN (packet_command_texts);
 493			s = NULL;
 494
 495			while (hi > lo) {
 496				mid = (lo + hi) / 2;
 497				if (packet_command_texts[mid].packet_command ==
 498				    failed_command->cmd[0]) {
 499					s = packet_command_texts[mid].text;
 500					break;
 501				}
 502				if (packet_command_texts[mid].packet_command >
 503				    failed_command->cmd[0])
 504					hi = mid;
 505				else
 506					lo = mid+1;
 507			}
 508
 509			printk (KERN_ERR "  The failed \"%s\" packet command was: \n  \"", s);
 510			for (i=0; i<sizeof (failed_command->cmd); i++)
 511				printk ("%02x ", failed_command->cmd[i]);
 512			printk ("\"\n");
 513		}
 514
 515		/* The SKSV bit specifies validity of the sense_key_specific
 516		 * in the next two commands. It is bit 7 of the first byte.
 517		 * In the case of NOT_READY, if SKSV is set the drive can
 518		 * give us nice ETA readings.
 519		 */
 520		if (sense->sense_key == NOT_READY && (sense->sks[0] & 0x80)) {
 521			int progress = (sense->sks[1] << 8 | sense->sks[2]) * 100;
 522			printk(KERN_ERR "  Command is %02d%% complete\n", progress / 0xffff);
 523
 524		}
 525
 526		if (sense->sense_key == ILLEGAL_REQUEST &&
 527		    (sense->sks[0] & 0x80) != 0) {
 528			printk(KERN_ERR "  Error in %s byte %d",
 529				(sense->sks[0] & 0x40) != 0 ?
 530				"command packet" : "command data",
 531				(sense->sks[1] << 8) + sense->sks[2]);
 532
 533			if ((sense->sks[0] & 0x40) != 0)
 534				printk (" bit %d", sense->sks[0] & 0x07);
 535
 536			printk ("\n");
 537		}
 538	}
 539
 540#else /* not VERBOSE_IDE_CD_ERRORS */
 541
 542	/* Suppress printing unit attention and `in progress of becoming ready'
 543	   errors when we're not being verbose. */
 544
 545	if (sense->sense_key == UNIT_ATTENTION ||
 546	    (sense->sense_key == NOT_READY && (sense->asc == 4 ||
 547						sense->asc == 0x3a)))
 548		return;
 549
 550	printk(KERN_ERR "%s: error code: 0x%02x  sense_key: 0x%02x  asc: 0x%02x  ascq: 0x%02x\n",
 551		drive->name,
 552		sense->error_code, sense->sense_key,
 553		sense->asc, sense->ascq);
 554#endif /* not VERBOSE_IDE_CD_ERRORS */
 555}
 556
 557/*
 558 * Initialize a ide-cd packet command request
 559 */
 560static void cdrom_prepare_request(ide_drive_t *drive, struct request *rq)
 561{
 562	struct cdrom_info *cd = drive->driver_data;
 563
 564	ide_init_drive_cmd(rq);
 565	rq->flags = REQ_PC;
 566	rq->rq_disk = cd->disk;
 567}
 568
 569static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense,
 570				      struct request *failed_command)
 571{
 572	struct cdrom_info *info		= drive->driver_data;
 573	struct request *rq		= &info->request_sense_request;
 574
 575	if (sense == NULL)
 576		sense = &info->sense_data;
 577
 578	/* stuff the sense request in front of our current request */
 579	cdrom_prepare_request(drive, rq);
 580
 581	rq->data = sense;
 582	rq->cmd[0] = GPCMD_REQUEST_SENSE;
 583	rq->cmd[4] = rq->data_len = 18;
 584
 585	rq->flags = REQ_SENSE;
 586
 587	/* NOTE! Save the failed command in "rq->buffer" */
 588	rq->buffer = (void *) failed_command;
 589
 590	(void) ide_do_drive_cmd(drive, rq, ide_preempt);
 591}
 592
 593static void cdrom_end_request (ide_drive_t *drive, int uptodate)
 594{
 595	struct request *rq = HWGROUP(drive)->rq;
 596	int nsectors = rq->hard_cur_sectors;
 597
 598	if ((rq->flags & REQ_SENSE) && uptodate) {
 599		/*
 600		 * For REQ_SENSE, "rq->buffer" points to the original failed
 601		 * request
 602		 */
 603		struct request *failed = (struct request *) rq->buffer;
 604		struct cdrom_info *info = drive->driver_data;
 605		void *sense = &info->sense_data;
 606		unsigned long flags;
 607
 608		if (failed) {
 609			if (failed->sense) {
 610				sense = failed->sense;
 611				failed->sense_len = rq->sense_len;
 612			}
 613
 614			/*
 615			 * now end failed request
 616			 */
 617			spin_lock_irqsave(&ide_lock, flags);
 618			end_that_request_chunk(failed, 0, failed->data_len);
 619			end_that_request_last(failed);
 620			spin_unlock_irqrestore(&ide_lock, flags);
 621		}
 622
 623		cdrom_analyze_sense_data(drive, failed, sense);
 624	}
 625
 626	if (!rq->current_nr_sectors && blk_fs_request(rq))
 627		uptodate = 1;
 628	/* make sure it's fully ended */
 629	if (blk_pc_request(rq))
 630		nsectors = (rq->data_len + 511) >> 9;
 631	if (!nsectors)
 632		nsectors = 1;
 633
 634	ide_end_request(drive, uptodate, nsectors);
 635}
 636
 637/* Returns 0 if the request should be continued.
 638   Returns 1 if the request was ended. */
 639static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
 640{
 641	struct request *rq = HWGROUP(drive)->rq;
 642	int stat, err, sense_key;
 643	
 644	/* Check for errors. */
 645	stat = HWIF(drive)->INB(IDE_STATUS_REG);
 646	if (stat_ret)
 647		*stat_ret = stat;
 648
 649	if (OK_STAT(stat, good_stat, BAD_R_STAT))
 650		return 0;
 651
 652	/* Get the IDE error register. */
 653	err = HWIF(drive)->INB(IDE_ERROR_REG);
 654	sense_key = err >> 4;
 655
 656	if (rq == NULL) {
 657		printk("%s: missing rq in cdrom_decode_status\n", drive->name);
 658		return 1;
 659	}
 660
 661	if (rq->flags & REQ_SENSE) {
 662		/* We got an error trying to get sense info
 663		   from the drive (probably while trying
 664		   to recover from a former error).  Just give up. */
 665
 666		rq->flags |= REQ_FAILED;
 667		cdrom_end_request(drive, 0);
 668		ide_error(drive, "request sense failure", stat);
 669		return 1;
 670
 671	} else if (rq->flags & (REQ_PC | REQ_BLOCK_PC)) {
 672		/* All other functions, except for READ. */
 673		unsigned long flags;
 674
 675		/*
 676		 * if we have an error, pass back CHECK_CONDITION as the
 677		 * scsi status byte
 678		 */
 679		if ((rq->flags & REQ_BLOCK_PC) && !rq->errors)
 680			rq->errors = SAM_STAT_CHECK_CONDITION;
 681
 682		/* Check for tray open. */
 683		if (sense_key == NOT_READY) {
 684			cdrom_saw_media_change (drive);
 685		} else if (sense_key == UNIT_ATTENTION) {
 686			/* Check for media change. */
 687			cdrom_saw_media_change (drive);
 688			/*printk("%s: media changed\n",drive->name);*/
 689			return 0;
 690		} else if (!(rq->flags & REQ_QUIET)) {
 691			/* Otherwise, print an error. */
 692			ide_dump_status(drive, "packet command error", stat);
 693		}
 694		
 695		rq->flags |= REQ_FAILED;
 696
 697		/*
 698		 * instead of playing games with moving completions around,
 699		 * remove failed request completely and end it when the
 700		 * request sense has completed
 701		 */
 702		if (stat & ERR_STAT) {
 703			spin_lock_irqsave(&ide_lock, flags);
 704			blkdev_dequeue_request(rq);
 705			HWGROUP(drive)->rq = NULL;
 706			spin_unlock_irqrestore(&ide_lock, flags);
 707
 708			cdrom_queue_request_sense(drive, rq->sense, rq);
 709		} else
 710			cdrom_end_request(drive, 0);
 711
 712	} else if (blk_fs_request(rq)) {
 713		int do_end_request = 0;
 714
 715		/* Handle errors from READ and WRITE requests. */
 716
 717		if (blk_noretry_request(rq))
 718			do_end_request = 1;
 719
 720		if (sense_key == NOT_READY) {
 721			/* Tray open. */
 722			if (rq_data_dir(rq) == READ) {
 723				cdrom_saw_media_change (drive);
 724
 725				/* Fail the request. */
 726				printk ("%s: tray open\n", drive->name);
 727				do_end_request = 1;
 728			} else {
 729				struct cdrom_info *info = drive->driver_data;
 730
 731				/* allow the drive 5 seconds to recover, some
 732				 * devices will return this error while flushing
 733				 * data from cache */
 734				if (!rq->errors)
 735					info->write_timeout = jiffies + ATAPI_WAIT_WRITE_BUSY;
 736				rq->errors = 1;
 737				if (time_after(jiffies, info->write_timeout))
 738					do_end_request = 1;
 739				else {
 740					unsigned long flags;
 741
 742					/*
 743					 * take a breather relying on the
 744					 * unplug timer to kick us again
 745					 */
 746					spin_lock_irqsave(&ide_lock, flags);
 747					blk_plug_device(drive->queue);
 748					spin_unlock_irqrestore(&ide_lock,flags);
 749					return 1;
 750				}
 751			}
 752		} else if (sense_key == UNIT_ATTENTION) {
 753			/* Media change. */
 754			cdrom_saw_media_change (drive);
 755
 756			/* Arrange to retry the request.
 757			   But be sure to give up if we've retried
 758			   too many times. */
 759			if (++rq->errors > ERROR_MAX)
 760				do_end_request = 1;
 761		} else if (sense_key == ILLEGAL_REQUEST ||
 762			   sense_key == DATA_PROTECT) {
 763			/* No point in retrying after an illegal
 764			   request or data protect error.*/
 765			ide_dump_status (drive, "command error", stat);
 766			do_end_request = 1;
 767		} else if (sense_key == MEDIUM_ERROR) {
 768			/* No point in re-trying a zillion times on a bad 
 769			 * sector...  If we got here the error is not correctable */
 770			ide_dump_status (drive, "media error (bad sector)", stat);
 771			do_end_request = 1;
 772		} else if (sense_key == BLANK_CHECK) {
 773			/* Disk appears blank ?? */
 774			ide_dump_status (drive, "media error (blank)", stat);
 775			do_end_request = 1;
 776		} else if ((err & ~ABRT_ERR) != 0) {
 777			/* Go to the default handler
 778			   for other errors. */
 779			ide_error(drive, "cdrom_decode_status", stat);
 780			return 1;
 781		} else if ((++rq->errors > ERROR_MAX)) {
 782			/* We've racked up too many retries.  Abort. */
 783			do_end_request = 1;
 784		}
 785
 786		if (do_end_request)
 787			cdrom_end_request(drive, 0);
 788
 789		/* If we got a CHECK_CONDITION status,
 790		   queue a request sense command. */
 791		if ((stat & ERR_STAT) != 0)
 792			cdrom_queue_request_sense(drive, NULL, NULL);
 793	} else {
 794		blk_dump_rq_flags(rq, "ide-cd: bad rq");
 795		cdrom_end_request(drive, 0);
 796	}
 797
 798	/* Retry, or handle the next request. */
 799	return 1;
 800}
 801
 802static int cdrom_timer_expiry(ide_drive_t *drive)
 803{
 804	struct request *rq = HWGROUP(drive)->rq;
 805	unsigned long wait = 0;
 806
 807	/*
 808	 * Some commands are *slow* and normally take a long time to
 809	 * complete. Usually we can use the ATAPI "disconnect" to bypass
 810	 * this, but not all commands/drives support that. Let
 811	 * ide_timer_expiry keep polling us for these.
 812	 */
 813	switch (rq->cmd[0]) {
 814		case GPCMD_BLANK:
 815		case GPCMD_FORMAT_UNIT:
 816		case GPCMD_RESERVE_RZONE_TRACK:
 817		case GPCMD_CLOSE_TRACK:
 818		case GPCMD_FLUSH_CACHE:
 819			wait = ATAPI_WAIT_PC;
 820			break;
 821		default:
 822			if (!(rq->flags & REQ_QUIET))
 823				printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n", rq->cmd[0]);
 824			wait = 0;
 825			break;
 826	}
 827	return wait;
 828}
 829
 830/* Set up the device registers for transferring a packet command on DEV,
 831   expecting to later transfer XFERLEN bytes.  HANDLER is the routine
 832   which actually transfers the command to the drive.  If this is a
 833   drq_interrupt device, this routine will arrange for HANDLER to be
 834   called when the interrupt from the drive arrives.  Otherwise, HANDLER
 835   will be called immediately after the drive is prepared for the transfer. */
 836
 837static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
 838						  int xferlen,
 839						  ide_handler_t *handler)
 840{
 841	ide_startstop_t startstop;
 842	struct cdrom_info *info = drive->driver_data;
 843	ide_hwif_t *hwif = drive->hwif;
 844
 845	/* Wait for the controller to be idle. */
 846	if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY))
 847		return startstop;
 848
 849	if (info->dma)
 850		info->dma = !hwif->dma_setup(drive);
 851
 852	/* Set up the controller registers. */
 853	/* FIXME: for Virtual DMA we must check harder */
 854	HWIF(drive)->OUTB(info->dma, IDE_FEATURE_REG);
 855	HWIF(drive)->OUTB(0, IDE_IREASON_REG);
 856	HWIF(drive)->OUTB(0, IDE_SECTOR_REG);
 857
 858	HWIF(drive)->OUTB(xferlen & 0xff, IDE_BCOUNTL_REG);
 859	HWIF(drive)->OUTB(xferlen >> 8  , IDE_BCOUNTH_REG);
 860	if (IDE_CONTROL_REG)
 861		HWIF(drive)->OUTB(drive->ctl, IDE_CONTROL_REG);
 862 
 863	if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt) {
 864		/* packet command */
 865		ide_execute_command(drive, WIN_PACKETCMD, handler, ATAPI_WAIT_PC, cdrom_timer_expiry);
 866		return ide_started;
 867	} else {
 868		unsigned long flags;
 869
 870		/* packet command */
 871		spin_lock_irqsave(&ide_lock, flags);
 872		hwif->OUTBSYNC(drive, WIN_PACKETCMD, IDE_COMMAND_REG);
 873		ndelay(400);
 874		spin_unlock_irqrestore(&ide_lock, flags);
 875
 876		return (*handler) (drive);
 877	}
 878}
 879
 880/* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
 881   The device registers must have already been prepared
 882   by cdrom_start_packet_command.
 883   HANDLER is the interrupt handler to call when the command completes
 884   or there's data ready. */
 885/*
 886 * changed 5 parameters to 3 for dvd-ram
 887 * struct packet_command *pc; now packet_command_t *pc;
 888 */
 889#define ATAPI_MIN_CDB_BYTES 12
 890static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
 891					  struct request *rq,
 892					  ide_handler_t *handler)
 893{
 894	ide_hwif_t *hwif = drive->hwif;
 895	int cmd_len;
 896	struct cdrom_info *info = drive->driver_data;
 897	ide_startstop_t startstop;
 898
 899	if (CDROM_CONFIG_FLAGS(drive)->drq_interrupt) {
 900		/* Here we should have been called after receiving an interrupt
 901		   from the device.  DRQ should how be set. */
 902
 903		/* Check for errors. */
 904		if (cdrom_decode_status(drive, DRQ_STAT, NULL))
 905			return ide_stopped;
 906	} else {
 907		/* Otherwise, we must wait for DRQ to get set. */
 908		if (ide_wait_stat(&startstop, drive, DRQ_STAT,
 909				BUSY_STAT, WAIT_READY))
 910			return startstop;
 911	}
 912
 913	/* Arm the interrupt handler. */
 914	ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);
 915
 916	/* ATAPI commands get padded out to 12 bytes minimum */
 917	cmd_len = COMMAND_SIZE(rq->cmd[0]);
 918	if (cmd_len < ATAPI_MIN_CDB_BYTES)
 919		cmd_len = ATAPI_MIN_CDB_BYTES;
 920
 921	/* Send the command to the device. */
 922	HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len);
 923
 924	/* Start the DMA if need be */
 925	if (info->dma)
 926		hwif->dma_start(drive);
 927
 928	return ide_started;
 929}
 930
 931/****************************************************************************
 932 * Block read functions.
 933 */
 934
 935/*
 936 * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
 937 * buffer.  Once the first sector is added, any subsequent sectors are
 938 * assumed to be continuous (until the buffer is cleared).  For the first
 939 * sector added, SECTOR is its sector number.  (SECTOR is then ignored until
 940 * the buffer is cleared.)
 941 */
 942static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
 943                                  int sectors_to_transfer)
 944{
 945	struct cdrom_info *info = drive->driver_data;
 946
 947	/* Number of sectors to read into the buffer. */
 948	int sectors_to_buffer = min_t(int, sectors_to_transfer,
 949				     (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
 950				       info->nsectors_buffered);
 951
 952	char *dest;
 953
 954	/* If we couldn't get a buffer, don't try to buffer anything... */
 955	if (info->buffer == NULL)
 956		sectors_to_buffer = 0;
 957
 958	/* If this is the first sector in the buffer, remember its number. */
 959	if (info->nsectors_buffered == 0)
 960		info->sector_buffered = sector;
 961
 962	/* Read the data into the buffer. */
 963	dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
 964	while (sectors_to_buffer > 0) {
 965		HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
 966		--sectors_to_buffer;
 967		--sectors_to_transfer;
 968		++info->nsectors_buffered;
 969		dest += SECTOR_SIZE;
 970	}
 971
 972	/* Throw away any remaining data. */
 973	while (sectors_to_transfer > 0) {
 974		static char dum[SECTOR_SIZE];
 975		HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
 976		--sectors_to_transfer;
 977	}
 978}
 979
 980/*
 981 * Check the contents of the interrupt reason register from the cdrom
 982 * and attempt to recover if there are problems.  Returns  0 if everything's
 983 * ok; nonzero if the request has been terminated.
 984 */
 985static inline
 986int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
 987{
 988	if (ireason == 2)
 989		return 0;
 990	else if (ireason == 0) {
 991		/* Whoops... The drive is expecting to receive data from us! */
 992		printk(KERN_ERR "%s: read_intr: Drive wants to transfer data the "
 993						"wrong way!\n", drive->name);
 994
 995		/* Throw some data at the drive so it doesn't hang
 996		   and quit this request. */
 997		while (len > 0) {
 998			int dum = 0;
 999			HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof (dum));
1000			len -= sizeof (dum);
1001		}
1002	} else  if (ireason == 1) {
1003		/* Some drives (ASUS) seem to tell us that status
1004		 * info is available. just get it and ignore.
1005		 */
1006		(void) HWIF(drive)->INB(IDE_STATUS_REG);
1007		return 0;
1008	} else {
1009		/* Drive wants a command packet, or invalid ireason... */
1010		printk(KERN_ERR "%s: read_intr: bad interrupt reason %x\n", drive->name,
1011								ireason);
1012	}
1013
1014	cdrom_end_request(drive, 0);
1015	return -1;
1016}
1017
1018/*
1019 * Interrupt routine.  Called when a read request has completed.
1020 */
1021static ide_startstop_t cdrom_read_intr (ide_drive_t *drive)
1022{
1023	int stat;
1024	int ireason, len, sectors_to_transfer, nskip;
1025	struct cdrom_info *info = drive->driver_data;
1026	u8 lowcyl = 0, highcyl = 0;
1027	int dma = info->dma, dma_error = 0;
1028
1029	struct request *rq = HWGROUP(drive)->rq;
1030
1031	/*
1032	 * handle dma case
1033	 */
1034	if (dma) {
1035		info->dma = 0;
1036		if ((dma_error = HWIF(drive)->ide_dma_end(drive)))
1037			__ide_dma_off(drive);
1038	}
1039
1040	if (cdrom_decode_status(drive, 0, &stat))
1041		return ide_stopped;
1042
1043	if (dma) {
1044		if (!dma_error) {
1045			ide_end_request(drive, 1, rq->nr_sectors);
1046			return ide_stopped;
1047		} else
1048			return ide_error(drive, "dma error", stat);
1049	}
1050
1051	/* Read the interrupt reason and the transfer length. */
1052	ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1053	lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1054	highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1055
1056	len = lowcyl + (256 * highcyl);
1057
1058	/* If DRQ is clear, the command has completed. */
1059	if ((stat & DRQ_STAT) == 0) {
1060		/* If we're not done filling the current buffer, complain.
1061		   Otherwise, complete the command normally. */
1062		if (rq->current_nr_sectors > 0) {
1063			printk (KERN_ERR "%s: cdrom_read_intr: data underrun (%d blocks)\n",
1064				drive->name, rq->current_nr_sectors);
1065			rq->flags |= REQ_FAILED;
1066			cdrom_end_request(drive, 0);
1067		} else
1068			cdrom_end_request(drive, 1);
1069		return ide_stopped;
1070	}
1071
1072	/* Check that the drive is expecting to do the same thing we are. */
1073	if (cdrom_read_check_ireason (drive, len, ireason))
1074		return ide_stopped;
1075
1076	/* Assume that the drive will always provide data in multiples
1077	   of at least SECTOR_SIZE, as it gets hairy to keep track
1078	   of the transfers otherwise. */
1079	if ((len % SECTOR_SIZE) != 0) {
1080		printk (KERN_ERR "%s: cdrom_read_intr: Bad transfer size %d\n",
1081			drive->name, len);
1082		if (CDROM_CONFIG_FLAGS(drive)->limit_nframes)
1083			printk (KERN_ERR "  This drive is not supported by this version of the driver\n");
1084		else {
1085			printk (KERN_ERR "  Trying to limit transfer sizes\n");
1086			CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1;
1087		}
1088		cdrom_end_request(drive, 0);
1089		return ide_stopped;
1090	}
1091
1092	/* The number of sectors we need to read from the drive. */
1093	sectors_to_transfer = len / SECTOR_SIZE;
1094
1095	/* First, figure out if we need to bit-bucket
1096	   any of the leading sectors. */
1097	nskip = min_t(int, rq->current_nr_sectors - bio_cur_sectors(rq->bio), sectors_to_transfer);
1098
1099	while (nskip > 0) {
1100		/* We need to throw away a sector. */
1101		static char dum[SECTOR_SIZE];
1102		HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
1103
1104		--rq->current_nr_sectors;
1105		--nskip;
1106		--sectors_to_transfer;
1107	}
1108
1109	/* Now loop while we still have data to read from the drive. */
1110	while (sectors_to_transfer > 0) {
1111		int this_transfer;
1112
1113		/* If we've filled the present buffer but there's another
1114		   chained buffer after it, move on. */
1115		if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1116			cdrom_end_request(drive, 1);
1117
1118		/* If the buffers are full, cache the rest of the data in our
1119		   internal buffer. */
1120		if (rq->current_nr_sectors == 0) {
1121			cdrom_buffer_sectors(drive, rq->sector, sectors_to_transfer);
1122			sectors_to_transfer = 0;
1123		} else {
1124			/* Transfer data to the buffers.
1125			   Figure out how many sectors we can transfer
1126			   to the current buffer. */
1127			this_transfer = min_t(int, sectors_to_transfer,
1128					     rq->current_nr_sectors);
1129
1130			/* Read this_transfer sectors
1131			   into the current buffer. */
1132			while (this_transfer > 0) {
1133				HWIF(drive)->atapi_input_bytes(drive, rq->buffer, SECTOR_SIZE);
1134				rq->buffer += SECTOR_SIZE;
1135				--rq->nr_sectors;
1136				--rq->current_nr_sectors;
1137				++rq->sector;
1138				--this_transfer;
1139				--sectors_to_transfer;
1140			}
1141		}
1142	}
1143
1144	/* Done moving data!  Wait for another interrupt. */
1145	ide_set_handler(drive, &cdrom_read_intr, ATAPI_WAIT_PC, NULL);
1146	return ide_started;
1147}
1148
1149/*
1150 * Try to satisfy some of the current read request from our cached data.
1151 * Returns nonzero if the request has been completed, zero otherwise.
1152 */
1153static int cdrom_read_from_buffer (ide_drive_t *drive)
1154{
1155	struct cdrom_info *info = drive->driver_data;
1156	struct request *rq = HWGROUP(drive)->rq;
1157	unsigned short sectors_per_frame;
1158
1159	sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1160
1161	/* Can't do anything if there's no buffer. */
1162	if (info->buffer == NULL) return 0;
1163
1164	/* Loop while this request needs data and the next block is present
1165	   in our cache. */
1166	while (rq->nr_sectors > 0 &&
1167	       rq->sector >= info->sector_buffered &&
1168	       rq->sector < info->sector_buffered + info->nsectors_buffered) {
1169		if (rq->current_nr_sectors == 0)
1170			cdrom_end_request(drive, 1);
1171
1172		memcpy (rq->buffer,
1173			info->buffer +
1174			(rq->sector - info->sector_buffered) * SECTOR_SIZE,
1175			SECTOR_SIZE);
1176		rq->buffer += SECTOR_SIZE;
1177		--rq->current_nr_sectors;
1178		--rq->nr_sectors;
1179		++rq->sector;
1180	}
1181
1182	/* If we've satisfied the current request,
1183	   terminate it successfully. */
1184	if (rq->nr_sectors == 0) {
1185		cdrom_end_request(drive, 1);
1186		return -1;
1187	}
1188
1189	/* Move on to the next buffer if needed. */
1190	if (rq->current_nr_sectors == 0)
1191		cdrom_end_request(drive, 1);
1192
1193	/* If this condition does not hold, then the kluge i use to
1194	   represent the number of sectors to skip at the start of a transfer
1195	   will fail.  I think that this will never happen, but let's be
1196	   paranoid and check. */
1197	if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
1198	    (rq->sector & (sectors_per_frame - 1))) {
1199		printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
1200			drive->name, (long)rq->sector);
1201		cdrom_end_request(drive, 0);
1202		return -1;
1203	}
1204
1205	return 0;
1206}
1207
1208/*
1209 * Routine to send a read packet command to the drive.
1210 * This is usually called directly from cdrom_start_read.
1211 * However, for drq_interrupt devices, it is called from an interrupt
1212 * when the drive is ready to accept the command.
1213 */
1214static ide_startstop_t cdrom_start_read_continuation (ide_drive_t *drive)
1215{
1216	struct request *rq = HWGROUP(drive)->rq;
1217	unsigned short sectors_per_frame;
1218	int nskip;
1219
1220	sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1221
1222	/* If the requested sector doesn't start on a cdrom block boundary,
1223	   we must adjust the start of the transfer so that it does,
1224	   and remember to skip the first few sectors.
1225	   If the CURRENT_NR_SECTORS field is larger than the size
1226	   of the buffer, it will mean that we're to skip a number
1227	   of sectors equal to the amount by which CURRENT_NR_SECTORS
1228	   is larger than the buffer size. */
1229	nskip = rq->sector & (sectors_per_frame - 1);
1230	if (nskip > 0) {
1231		/* Sanity check... */
1232		if (rq->current_nr_sectors != bio_cur_sectors(rq->bio) &&
1233			(rq->sector & (sectors_per_frame - 1))) {
1234			printk(KERN_ERR "%s: cdrom_start_read_continuation: buffer botch (%u)\n",
1235				drive->name, rq->current_nr_sectors);
1236			cdrom_end_request(drive, 0);
1237			return ide_stopped;
1238		}
1239		rq->current_nr_sectors += nskip;
1240	}
1241
1242	/* Set up the command */
1243	rq->timeout = ATAPI_WAIT_PC;
1244
1245	/* Send the command to the drive and return. */
1246	return cdrom_transfer_packet_command(drive, rq, &cdrom_read_intr);
1247}
1248
1249
1250#define IDECD_SEEK_THRESHOLD	(1000)			/* 1000 blocks */
1251#define IDECD_SEEK_TIMER	(5 * WAIT_MIN_SLEEP)	/* 100 ms */
1252#define IDECD_SEEK_TIMEOUT	(2 * WAIT_CMD)		/* 20 sec */
1253
1254static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
1255{
1256	struct cdrom_info *info = drive->driver_data;
1257	int stat;
1258	static int retry = 10;
1259
1260	if (cdrom_decode_status(drive, 0, &stat))
1261		return ide_stopped;
1262	CDROM_CONFIG_FLAGS(drive)->seeking = 1;
1263
1264	if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
1265		if (--retry == 0) {
1266			/*
1267			 * this condition is far too common, to bother
1268			 * users about it
1269			 */
1270			/* printk("%s: disabled DSC seek overlap\n", drive->name);*/ 
1271			drive->dsc_overlap = 0;
1272		}
1273	}
1274	return ide_stopped;
1275}
1276
1277static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
1278{
1279	struct request *rq = HWGROUP(drive)->rq;
1280	sector_t frame = rq->sector;
1281
1282	sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
1283
1284	memset(rq->cmd, 0, sizeof(rq->cmd));
1285	rq->cmd[0] = GPCMD_SEEK;
1286	put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
1287
1288	rq->timeout = ATAPI_WAIT_PC;
1289	return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
1290}
1291
1292static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
1293{
1294	struct cdrom_info *info = drive->driver_data;
1295
1296	info->dma = 0;
1297	info->cmd = 0;
1298	info->start_seek = jiffies;
1299	return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
1300}
1301
1302/* Fix up a possibly partially-processed request so that we can
1303   start it over entirely, or even put it back on the request queue. */
1304static void restore_request (struct request *rq)
1305{
1306	if (rq->buffer != bio_data(rq->bio)) {
1307		sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
1308
1309		rq->buffer = bio_data(rq->bio);
1310		rq->nr_sectors += n;
1311		rq->sector -= n;
1312	}
1313	rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
1314	rq->hard_nr_sectors = rq->nr_sectors;
1315	rq->hard_sector = rq->sector;
1316	rq->q->prep_rq_fn(rq->q, rq);
1317}
1318
1319/*
1320 * Start a read request from the CD-ROM.
1321 */
1322static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block)
1323{
1324	struct cdrom_info *info = drive->driver_data;
1325	struct request *rq = HWGROUP(drive)->rq;
1326	unsigned short sectors_per_frame;
1327
1328	sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1329
1330	/* We may be retrying this request after an error.  Fix up
1331	   any weirdness which might be present in the request packet. */
1332	restore_request(rq);
1333
1334	/* Satisfy whatever we can of this request from our cached sector. */
1335	if (cdrom_read_from_buffer(drive))
1336		return ide_stopped;
1337
1338	blk_attempt_remerge(drive->queue, rq);
1339
1340	/* Clear the local sector buffer. */
1341	info->nsectors_buffered = 0;
1342
1343	/* use dma, if possible. */
1344	info->dma = drive->using_dma;
1345	if ((rq->sector & (sectors_per_frame - 1)) ||
1346	    (rq->nr_sectors & (sectors_per_frame - 1)))
1347		info->dma = 0;
1348
1349	info->cmd = READ;
1350
1351	/* Start sending the read request to the drive. */
1352	return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
1353}
1354
1355/****************************************************************************
1356 * Execute all other packet commands.
1357 */
1358
1359/* Interrupt routine for packet command completion. */
1360static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
1361{
1362	int ireason, len, thislen;
1363	struct request *rq = HWGROUP(drive)->rq;
1364	u8 lowcyl = 0, highcyl = 0;
1365	int stat;
1366
1367	/* Check for errors. */
1368	if (cdrom_decode_status(drive, 0, &stat))
1369		return ide_stopped;
1370
1371	/* Read the interrupt reason and the transfer length. */
1372	ireason = HWIF(drive)->INB(IDE_IREASON_REG);
1373	lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1374	highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1375
1376	len = lowcyl + (256 * highcyl);
1377
1378	/* If DRQ is clear, the command has completed.
1379	   Complain if we still have data left to transfer. */
1380	if ((stat & DRQ_STAT) == 0) {
1381		/* Some of the trailing request sense fields are optional, and
1382		   some drives don't send them.  Sigh. */
1383		if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
1384		    rq->data_len > 0 &&
1385		    rq->data_len <= 5) {
1386			while (rq->data_len > 0) {
1387				*(unsigned char *)rq->data++ = 0;
1388				--rq->data_len;
1389			}
1390		}
1391
1392		if (rq->data_len == 0)
1393			cdrom_end_request(drive, 1);
1394		else {
1395			/* Comment this out, because this always happens 
1396			   right after a reset occurs, and it is annoying to 
1397			   always print expected stuff.  */
1398			/*
1399			printk ("%s: cdrom_pc_intr: data underrun %d\n",
1400				drive->name, pc->buflen);
1401			*/
1402			rq->flags |= REQ_FAILED;
1403			cdrom_end_request(drive, 0);
1404		}
1405		return ide_stopped;
1406	}
1407
1408	/* Figure out how much data to transfer. */
1409	thislen = rq->data_len;
1410	if (thislen > len) thislen = len;
1411
1412	/* The drive wants to be written to. */
1413	if ((ireason & 3) == 0) {
1414		if (!rq->data) {
1415			blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1416			goto confused;
1417		}
1418		/* Transfer the data. */
1419		HWIF(drive)->atapi_output_bytes(drive, rq->data, thislen);
1420
1421		/* If we haven't moved enough data to satisfy the drive,
1422		   add some padding. */
1423		while (len > thislen) {
1424			int dum = 0;
1425			HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof(dum));
1426			len -= sizeof(dum);
1427		}
1428
1429		/* Keep count of how much data we've moved. */
1430		rq->data += thislen;
1431		rq->data_len -= thislen;
1432	}
1433
1434	/* Same drill for reading. */
1435	else if ((ireason & 3) == 2) {
1436		if (!rq->data) {
1437			blk_dump_rq_flags(rq, "cdrom_pc_intr, write");
1438			goto confused;
1439		}
1440		/* Transfer the data. */
1441		HWIF(drive)->atapi_input_bytes(drive, rq->data, thislen);
1442
1443		/* If we haven't moved enough data to satisfy the drive,
1444		   add some padding. */
1445		while (len > thislen) {
1446			int dum = 0;
1447			HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
1448			len -= sizeof(dum);
1449		}
1450
1451		/* Keep count of how much data we've moved. */
1452		rq->data += thislen;
1453		rq->data_len -= thislen;
1454
1455		if (rq->flags & REQ_SENSE)
1456			rq->sense_len += thislen;
1457	} else {
1458confused:
1459		printk (KERN_ERR "%s: cdrom_pc_intr: The drive "
1460			"appears confused (ireason = 0x%02x)\n",
1461			drive->name, ireason);
1462		rq->flags |= REQ_FAILED;
1463	}
1464
1465	/* Now we wait for another interrupt. */
1466	ide_set_handler(drive, &cdrom_pc_intr, ATAPI_WAIT_PC, cdrom_timer_ex

Large files files are truncated, but you can click here to view the full file