/drivers/ide/ide-cd.c
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