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