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