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