ide-cd.c revision 4ef3b8f4a5c056d5f784725974a530d1a7b4a811
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); 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->cmd = 0; 1296 info->start_seek = jiffies; 1297 return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation); 1298} 1299 1300/* Fix up a possibly partially-processed request so that we can 1301 start it over entirely, or even put it back on the request queue. */ 1302static void restore_request (struct request *rq) 1303{ 1304 if (rq->buffer != bio_data(rq->bio)) { 1305 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE; 1306 1307 rq->buffer = bio_data(rq->bio); 1308 rq->nr_sectors += n; 1309 rq->sector -= n; 1310 } 1311 rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio); 1312 rq->hard_nr_sectors = rq->nr_sectors; 1313 rq->hard_sector = rq->sector; 1314 rq->q->prep_rq_fn(rq->q, rq); 1315} 1316 1317/* 1318 * Start a read request from the CD-ROM. 1319 */ 1320static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block) 1321{ 1322 struct cdrom_info *info = drive->driver_data; 1323 struct request *rq = HWGROUP(drive)->rq; 1324 unsigned short sectors_per_frame; 1325 1326 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS; 1327 1328 /* We may be retrying this request after an error. Fix up 1329 any weirdness which might be present in the request packet. */ 1330 restore_request(rq); 1331 1332 /* Satisfy whatever we can of this request from our cached sector. */ 1333 if (cdrom_read_from_buffer(drive)) 1334 return ide_stopped; 1335 1336 blk_attempt_remerge(drive->queue, rq); 1337 1338 /* Clear the local sector buffer. */ 1339 info->nsectors_buffered = 0; 1340 1341 /* use dma, if possible. */ 1342 info->dma = drive->using_dma; 1343 if ((rq->sector & (sectors_per_frame - 1)) || 1344 (rq->nr_sectors & (sectors_per_frame - 1))) 1345 info->dma = 0; 1346 1347 info->cmd = READ; 1348 1349 /* Start sending the read request to the drive. */ 1350 return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation); 1351} 1352 1353/**************************************************************************** 1354 * Execute all other packet commands. 1355 */ 1356 1357/* Interrupt routine for packet command completion. */ 1358static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive) 1359{ 1360 int ireason, len, thislen; 1361 struct request *rq = HWGROUP(drive)->rq; 1362 u8 lowcyl = 0, highcyl = 0; 1363 int stat; 1364 1365 /* Check for errors. */ 1366 if (cdrom_decode_status(drive, 0, &stat)) 1367 return ide_stopped; 1368 1369 /* Read the interrupt reason and the transfer length. */ 1370 ireason = HWIF(drive)->INB(IDE_IREASON_REG); 1371 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG); 1372 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG); 1373 1374 len = lowcyl + (256 * highcyl); 1375 1376 /* If DRQ is clear, the command has completed. 1377 Complain if we still have data left to transfer. */ 1378 if ((stat & DRQ_STAT) == 0) { 1379 /* Some of the trailing request sense fields are optional, and 1380 some drives don't send them. Sigh. */ 1381 if (rq->cmd[0] == GPCMD_REQUEST_SENSE && 1382 rq->data_len > 0 && 1383 rq->data_len <= 5) { 1384 while (rq->data_len > 0) { 1385 *(unsigned char *)rq->data++ = 0; 1386 --rq->data_len; 1387 } 1388 } 1389 1390 if (rq->data_len == 0) 1391 cdrom_end_request(drive, 1); 1392 else { 1393 /* Comment this out, because this always happens 1394 right after a reset occurs, and it is annoying to 1395 always print expected stuff. */ 1396 /* 1397 printk ("%s: cdrom_pc_intr: data underrun %d\n", 1398 drive->name, pc->buflen); 1399 */ 1400 rq->flags |= REQ_FAILED; 1401 cdrom_end_request(drive, 0); 1402 } 1403 return ide_stopped; 1404 } 1405 1406 /* Figure out how much data to transfer. */ 1407 thislen = rq->data_len; 1408 if (thislen > len) thislen = len; 1409 1410 /* The drive wants to be written to. */ 1411 if ((ireason & 3) == 0) { 1412 if (!rq->data) { 1413 blk_dump_rq_flags(rq, "cdrom_pc_intr, write"); 1414 goto confused; 1415 } 1416 /* Transfer the data. */ 1417 HWIF(drive)->atapi_output_bytes(drive, rq->data, thislen); 1418 1419 /* If we haven't moved enough data to satisfy the drive, 1420 add some padding. */ 1421 while (len > thislen) { 1422 int dum = 0; 1423 HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof(dum)); 1424 len -= sizeof(dum); 1425 } 1426 1427 /* Keep count of how much data we've moved. */ 1428 rq->data += thislen; 1429 rq->data_len -= thislen; 1430 } 1431 1432 /* Same drill for reading. */ 1433 else if ((ireason & 3) == 2) { 1434 if (!rq->data) { 1435 blk_dump_rq_flags(rq, "cdrom_pc_intr, write"); 1436 goto confused; 1437 } 1438 /* Transfer the data. */ 1439 HWIF(drive)->atapi_input_bytes(drive, rq->data, thislen); 1440 1441 /* If we haven't moved enough data to satisfy the drive, 1442 add some padding. */ 1443 while (len > thislen) { 1444 int dum = 0; 1445 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum)); 1446 len -= sizeof(dum); 1447 } 1448 1449 /* Keep count of how much data we've moved. */ 1450 rq->data += thislen; 1451 rq->data_len -= thislen; 1452 1453 if (rq->flags & REQ_SENSE) 1454 rq->sense_len += thislen; 1455 } else { 1456confused: 1457 printk (KERN_ERR "%s: cdrom_pc_intr: The drive " 1458 "appears confused (ireason = 0x%02x)\n", 1459 drive->name, ireason); 1460 rq->flags |= REQ_FAILED; 1461 } 1462 1463 /* Now we wait for another interrupt. */ 1464 ide_set_handler(drive, &cdrom_pc_intr, ATAPI_WAIT_PC, cdrom_timer_expiry); 1465 return ide_started; 1466} 1467 1468static ide_startstop_t cdrom_do_pc_continuation (ide_drive_t *drive) 1469{ 1470 struct request *rq = HWGROUP(drive)->rq; 1471 1472 if (!rq->timeout) 1473 rq->timeout = ATAPI_WAIT_PC; 1474 1475 /* Send the command to the drive and return. */ 1476 return cdrom_transfer_packet_command(drive, rq, &cdrom_pc_intr); 1477} 1478 1479 1480static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive) 1481{ 1482 int len; 1483 struct request *rq = HWGROUP(drive)->rq; 1484 struct cdrom_info *info = drive->driver_data; 1485 1486 info->dma = 0; 1487 info->cmd = 0; 1488 rq->flags &= ~REQ_FAILED; 1489 len = rq->data_len; 1490 1491 /* Start sending the command to the drive. */ 1492 return cdrom_start_packet_command(drive, len, cdrom_do_pc_continuation); 1493} 1494 1495 1496static 1497int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq) 1498{ 1499 struct request_sense sense; 1500 int retries = 10; 1501 unsigned int flags = rq->flags; 1502 1503 if (rq->sense == NULL) 1504 rq->sense = &sense; 1505 1506 /* Start of retry loop. */ 1507 do { 1508 int error; 1509 unsigned long time = jiffies; 1510 rq->flags = flags; 1511 1512 error = ide_do_drive_cmd(drive, rq, ide_wait); 1513 time = jiffies - time; 1514 1515 /* FIXME: we should probably abort/retry or something 1516 * in case of failure */ 1517 if (rq->flags & REQ_FAILED) { 1518 /* The request failed. Retry if it was due to a unit 1519 attention status 1520 (usually means media was changed). */ 1521 struct request_sense *reqbuf = rq->sense; 1522 1523 if (reqbuf->sense_key == UNIT_ATTENTION) 1524 cdrom_saw_media_change(drive); 1525 else if (reqbuf->sense_key == NOT_READY && 1526 reqbuf->asc == 4 && reqbuf->ascq != 4) { 1527 /* The drive is in the process of loading 1528 a disk. Retry, but wait a little to give 1529 the drive time to complete the load. */ 1530 ssleep(2); 1531 } else { 1532 /* Otherwise, don't retry. */ 1533 retries = 0; 1534 } 1535 --retries; 1536 } 1537 1538 /* End of retry loop. */ 1539 } while ((rq->flags & REQ_FAILED) && retries >= 0); 1540 1541 /* Return an error if the command failed. */ 1542 return (rq->flags & REQ_FAILED) ? -EIO : 0; 1543} 1544 1545/* 1546 * Write handling 1547 */ 1548static inline int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason) 1549{ 1550 /* Two notes about IDE interrupt reason here - 0 means that 1551 * the drive wants to receive data from us, 2 means that 1552 * the drive is expecting to transfer data to us. 1553 */ 1554 if (ireason == 0) 1555 return 0; 1556 else if (ireason == 2) { 1557 /* Whoops... The drive wants to send data. */ 1558 printk(KERN_ERR "%s: write_intr: wrong transfer direction!\n", 1559 drive->name); 1560 1561 while (len > 0) { 1562 int dum = 0; 1563 HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum)); 1564 len -= sizeof(dum); 1565 } 1566 } else { 1567 /* Drive wants a command packet, or invalid ireason... */ 1568 printk(KERN_ERR "%s: write_intr: bad interrupt reason %x\n", 1569 drive->name, ireason); 1570 } 1571 1572 cdrom_end_request(drive, 0); 1573 return 1; 1574} 1575 1576static void post_transform_command(struct request *req) 1577{ 1578 u8 *c = req->cmd; 1579 char *ibuf; 1580 1581 if (!blk_pc_request(req)) 1582 return; 1583 1584 if (req->bio) 1585 ibuf = bio_data(req->bio); 1586 else 1587 ibuf = req->data; 1588 1589 if (!ibuf) 1590 return; 1591 1592 /* 1593 * set ansi-revision and response data as atapi 1594 */ 1595 if (c[0] == GPCMD_INQUIRY) { 1596 ibuf[2] |= 2; 1597 ibuf[3] = (ibuf[3] & 0xf0) | 2; 1598 } 1599} 1600 1601typedef void (xfer_func_t)(ide_drive_t *, void *, u32); 1602 1603/* 1604 * best way to deal with dma that is not sector aligned right now... note 1605 * that in this path we are not using ->data or ->buffer at all. this irs 1606 * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the 1607 * future. 1608 */ 1609static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive) 1610{ 1611 struct cdrom_info *info = drive->driver_data; 1612 struct request *rq = HWGROUP(drive)->rq; 1613 int dma_error, dma, stat, ireason, len, thislen; 1614 u8 lowcyl, highcyl; 1615 xfer_func_t *xferfunc; 1616 unsigned long flags; 1617 1618 /* Check for errors. */ 1619 dma_error = 0; 1620 dma = info->dma; 1621 if (dma) { 1622 info->dma = 0; 1623 dma_error = HWIF(drive)->ide_dma_end(drive); 1624 } 1625 1626 if (cdrom_decode_status(drive, 0, &stat)) 1627 return ide_stopped; 1628 1629 /* 1630 * using dma, transfer is complete now 1631 */ 1632 if (dma) { 1633 if (dma_error) { 1634 printk(KERN_ERR "ide-cd: dma error\n"); 1635 __ide_dma_off(drive); 1636 return ide_error(drive, "dma error", stat); 1637 } 1638 1639 end_that_request_chunk(rq, 1, rq->data_len); 1640 rq->data_len = 0; 1641 goto end_request; 1642 } 1643 1644 /* 1645 * ok we fall to pio :/ 1646 */ 1647 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3; 1648 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG); 1649 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG); 1650 1651 len = lowcyl + (256 * highcyl); 1652 thislen = rq->data_len; 1653 if (thislen > len) 1654 thislen = len; 1655 1656 /* 1657 * If DRQ is clear, the command has completed. 1658 */ 1659 if ((stat & DRQ_STAT) == 0) 1660 goto end_request; 1661 1662 /* 1663 * check which way to transfer data 1664 */ 1665 if (rq_data_dir(rq) == WRITE) { 1666 /* 1667 * write to drive 1668 */ 1669 if (cdrom_write_check_ireason(drive, len, ireason)) 1670 return ide_stopped; 1671 1672 xferfunc = HWIF(drive)->atapi_output_bytes; 1673 } else { 1674 /* 1675 * read from drive 1676 */ 1677 if (cdrom_read_check_ireason(drive, len, ireason)) 1678 return ide_stopped; 1679 1680 xferfunc = HWIF(drive)->atapi_input_bytes; 1681 } 1682 1683 /* 1684 * transfer data 1685 */ 1686 while (thislen > 0) { 1687 int blen = blen = rq->data_len; 1688 char *ptr = rq->data; 1689 1690 /* 1691 * bio backed? 1692 */ 1693 if (rq->bio) { 1694 ptr = bio_data(rq->bio); 1695 blen = bio_iovec(rq->bio)->bv_len; 1696 } 1697 1698 if (!ptr) { 1699 printk(KERN_ERR "%s: confused, missing data\n", drive->name); 1700 break; 1701 } 1702 1703 if (blen > thislen) 1704 blen = thislen; 1705 1706 xferfunc(drive, ptr, blen); 1707 1708 thislen -= blen; 1709 len -= blen; 1710 rq->data_len -= blen; 1711 1712 if (rq->bio) 1713 end_that_request_chunk(rq, 1, blen); 1714 else 1715 rq->data += blen; 1716 } 1717 1718 /* 1719 * pad, if necessary 1720 */ 1721 if (len > 0) { 1722 while (len > 0) { 1723 int pad = 0; 1724 1725 xferfunc(drive, &pad, sizeof(pad)); 1726 len -= sizeof(pad); 1727 } 1728 } 1729 1730 if (HWGROUP(drive)->handler != NULL) 1731 BUG(); 1732 1733 ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, NULL); 1734 return ide_started; 1735 1736end_request: 1737 if (!rq->data_len) 1738 post_transform_command(rq); 1739 1740 spin_lock_irqsave(&ide_lock, flags); 1741 blkdev_dequeue_request(rq); 1742 end_that_request_last(rq); 1743 HWGROUP(drive)->rq = NULL; 1744 spin_unlock_irqrestore(&ide_lock, flags); 1745 return ide_stopped; 1746} 1747 1748static ide_startstop_t cdrom_write_intr(ide_drive_t *drive) 1749{ 1750 int stat, ireason, len, sectors_to_transfer, uptodate; 1751 struct cdrom_info *info = drive->driver_data; 1752 int dma_error = 0, dma = info->dma; 1753 u8 lowcyl = 0, highcyl = 0; 1754 1755 struct request *rq = HWGROUP(drive)->rq; 1756 1757 /* Check for errors. */ 1758 if (dma) { 1759 info->dma = 0; 1760 if ((dma_error = HWIF(drive)->ide_dma_end(drive))) { 1761 printk(KERN_ERR "ide-cd: write dma error\n"); 1762 __ide_dma_off(drive); 1763 } 1764 } 1765 1766 if (cdrom_decode_status(drive, 0, &stat)) 1767 return ide_stopped; 1768 1769 /* 1770 * using dma, transfer is complete now 1771 */ 1772 if (dma) { 1773 if (dma_error) 1774 return ide_error(drive, "dma error", stat); 1775 1776 ide_end_request(drive, 1, rq->nr_sectors); 1777 return ide_stopped; 1778 } 1779 1780 /* Read the interrupt reason and the transfer length. */ 1781 ireason = HWIF(drive)->INB(IDE_IREASON_REG); 1782 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG); 1783 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG); 1784 1785 len = lowcyl + (256 * highcyl); 1786 1787 /* If DRQ is clear, the command has completed. */ 1788 if ((stat & DRQ_STAT) == 0) { 1789 /* If we're not done writing, complain. 1790 * Otherwise, complete the command normally. 1791 */ 1792 uptodate = 1; 1793 if (rq->current_nr_sectors > 0) { 1794 printk(KERN_ERR "%s: write_intr: data underrun (%d blocks)\n", 1795 drive->name, rq->current_nr_sectors); 1796 uptodate = 0; 1797 } 1798 cdrom_end_request(drive, uptodate); 1799 return ide_stopped; 1800 } 1801 1802 /* Check that the drive is expecting to do the same thing we are. */ 1803 if (cdrom_write_check_ireason(drive, len, ireason)) 1804 return ide_stopped; 1805 1806 sectors_to_transfer = len / SECTOR_SIZE; 1807 1808 /* 1809 * now loop and write out the data 1810 */ 1811 while (sectors_to_transfer > 0) { 1812 int this_transfer; 1813 1814 if (!rq->current_nr_sectors) { 1815 printk(KERN_ERR "ide-cd: write_intr: oops\n"); 1816 break; 1817 } 1818 1819 /* 1820 * Figure out how many sectors we can transfer 1821 */ 1822 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors); 1823 1824 while (this_transfer > 0) { 1825 HWIF(drive)->atapi_output_bytes(drive, rq->buffer, SECTOR_SIZE); 1826 rq->buffer += SECTOR_SIZE; 1827 --rq->nr_sectors; 1828 --rq->current_nr_sectors; 1829 ++rq->sector; 1830 --this_transfer; 1831 --sectors_to_transfer; 1832 } 1833 1834 /* 1835 * current buffer complete, move on 1836 */ 1837 if (rq->current_nr_sectors == 0 && rq->nr_sectors) 1838 cdrom_end_request(drive, 1); 1839 } 1840 1841 /* re-arm handler */ 1842 ide_set_handler(drive, &cdrom_write_intr, ATAPI_WAIT_PC, NULL); 1843 return ide_started; 1844} 1845 1846static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive) 1847{ 1848 struct request *rq = HWGROUP(drive)->rq; 1849 1850#if 0 /* the immediate bit */ 1851 rq->cmd[1] = 1 << 3; 1852#endif 1853 rq->timeout = ATAPI_WAIT_PC; 1854 1855 return cdrom_transfer_packet_command(drive, rq, cdrom_write_intr); 1856} 1857 1858static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq) 1859{ 1860 struct cdrom_info *info = drive->driver_data; 1861 struct gendisk *g = info->disk; 1862 unsigned short sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS; 1863 1864 /* 1865 * writes *must* be hardware frame aligned 1866 */ 1867 if ((rq->nr_sectors & (sectors_per_frame - 1)) || 1868 (rq->sector & (sectors_per_frame - 1))) { 1869 cdrom_end_request(drive, 0); 1870 return ide_stopped; 1871 } 1872 1873 /* 1874 * disk has become write protected 1875 */ 1876 if (g->policy) { 1877 cdrom_end_request(drive, 0); 1878 return ide_stopped; 1879 } 1880 1881 /* 1882 * for dvd-ram and such media, it's a really big deal to get 1883 * big writes all the time. so scour the queue and attempt to 1884 * remerge requests, often the plugging will not have had time 1885 * to do this properly 1886 */ 1887 blk_attempt_remerge(drive->queue, rq); 1888 1889 info->nsectors_buffered = 0; 1890 1891 /* use dma, if possible. we don't need to check more, since we 1892 * know that the transfer is always (at least!) frame aligned */ 1893 info->dma = drive->using_dma ? 1 : 0; 1894 info->cmd = WRITE; 1895 1896 info->devinfo.media_written = 1; 1897 1898 /* Start sending the write request to the drive. */ 1899 return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont); 1900} 1901 1902static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive) 1903{ 1904 struct request *rq = HWGROUP(drive)->rq; 1905 1906 if (!rq->timeout) 1907 rq->timeout = ATAPI_WAIT_PC; 1908 1909 return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr); 1910} 1911 1912static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq) 1913{ 1914 struct cdrom_info *info = drive->driver_data; 1915 1916 rq->flags |= REQ_QUIET; 1917 1918 info->dma = 0; 1919 info->cmd = 0; 1920 1921 /* 1922 * sg request 1923 */ 1924 if (rq->bio) { 1925 int mask = drive->queue->dma_alignment; 1926 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio)); 1927 1928 info->cmd = rq_data_dir(rq); 1929 info->dma = drive->using_dma; 1930 1931 /* 1932 * check if dma is safe 1933 * 1934 * NOTE! The "len" and "addr" checks should possibly have 1935 * separate masks. 1936 */ 1937 if ((rq->data_len & 15) || (addr & mask)) 1938 info->dma = 0; 1939 } 1940 1941 /* Start sending the command to the drive. */ 1942 return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont); 1943} 1944 1945/**************************************************************************** 1946 * cdrom driver request routine. 1947 */ 1948static ide_startstop_t 1949ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block) 1950{ 1951 ide_startstop_t action; 1952 struct cdrom_info *info = drive->driver_data; 1953 1954 if (blk_fs_request(rq)) { 1955 if (CDROM_CONFIG_FLAGS(drive)->seeking) { 1956 unsigned long elapsed = jiffies - info->start_seek; 1957 int stat = HWIF(drive)->INB(IDE_STATUS_REG); 1958 1959 if ((stat & SEEK_STAT) != SEEK_STAT) { 1960 if (elapsed < IDECD_SEEK_TIMEOUT) { 1961 ide_stall_queue(drive, IDECD_SEEK_TIMER); 1962 return ide_stopped; 1963 } 1964 printk (KERN_ERR "%s: DSC timeout\n", drive->name); 1965 } 1966 CDROM_CONFIG_FLAGS(drive)->seeking = 0; 1967 } 1968 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) { 1969 action = cdrom_start_seek(drive, block); 1970 } else { 1971 if (rq_data_dir(rq) == READ) 1972 action = cdrom_start_read(drive, block); 1973 else 1974 action = cdrom_start_write(drive, rq); 1975 } 1976 info->last_block = block; 1977 return action; 1978 } else if (rq->flags & (REQ_PC | REQ_SENSE)) { 1979 return cdrom_do_packet_command(drive); 1980 } else if (rq->flags & REQ_BLOCK_PC) { 1981 return cdrom_do_block_pc(drive, rq); 1982 } else if (rq->flags & REQ_SPECIAL) { 1983 /* 1984 * right now this can only be a reset... 1985 */ 1986 cdrom_end_request(drive, 1); 1987 return ide_stopped; 1988 } 1989 1990 blk_dump_rq_flags(rq, "ide-cd bad flags"); 1991 cdrom_end_request(drive, 0); 1992 return ide_stopped; 1993} 1994 1995 1996 1997/**************************************************************************** 1998 * Ioctl handling. 1999 * 2000 * Routines which queue packet commands take as a final argument a pointer 2001 * to a request_sense struct. If execution of the command results 2002 * in an error with a CHECK CONDITION status, this structure will be filled 2003 * with the results of the subsequent request sense command. The pointer 2004 * can also be NULL, in which case no sense information is returned. 2005 */ 2006 2007#if ! STANDARD_ATAPI 2008static inline 2009int bin2bcd (int x) 2010{ 2011 return (x%10) | ((x/10) << 4); 2012} 2013 2014 2015static inline 2016int bcd2bin (int x) 2017{ 2018 return (x >> 4) * 10 + (x & 0x0f); 2019} 2020 2021static 2022void msf_from_bcd (struct atapi_msf *msf) 2023{ 2024 msf->minute = bcd2bin (msf->minute); 2025 msf->second = bcd2bin (msf->second); 2026 msf->frame = bcd2bin (msf->frame); 2027} 2028 2029#endif /* not STANDARD_ATAPI */ 2030 2031 2032static inline 2033void lba_to_msf (int lba, byte *m, byte *s, byte *f) 2034{ 2035 lba += CD_MSF_OFFSET; 2036 lba &= 0xffffff; /* negative lbas use only 24 bits */ 2037 *m = lba / (CD_SECS * CD_FRAMES); 2038 lba %= (CD_SECS * CD_FRAMES); 2039 *s = lba / CD_FRAMES; 2040 *f = lba % CD_FRAMES; 2041} 2042 2043 2044static inline 2045int msf_to_lba (byte m, byte s, byte f) 2046{ 2047 return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET; 2048} 2049 2050static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense) 2051{ 2052 struct request req; 2053 struct cdrom_info *info = drive->driver_data; 2054 struct cdrom_device_info *cdi = &info->devinfo; 2055 2056 cdrom_prepare_request(drive, &req); 2057 2058 req.sense = sense; 2059 req.cmd[0] = GPCMD_TEST_UNIT_READY; 2060 req.flags |= REQ_QUIET; 2061 2062#if ! STANDARD_ATAPI 2063 /* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to 2064 switch CDs instead of supporting the LOAD_UNLOAD opcode */ 2065 2066 req.cmd[7] = cdi->sanyo_slot % 3; 2067#endif /* not STANDARD_ATAPI */ 2068 2069 return cdrom_queue_packet_command(drive, &req); 2070} 2071 2072 2073/* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */ 2074static int 2075cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense) 2076{ 2077 struct request_sense my_sense; 2078 struct request req; 2079 int stat; 2080 2081 if (sense == NULL) 2082 sense = &my_sense; 2083 2084 /* If the drive cannot lock the door, just pretend. */ 2085 if (CDROM_CONFIG_FLAGS(drive)->no_doorlock) { 2086 stat = 0; 2087 } else { 2088 cdrom_prepare_request(drive, &req); 2089 req.sense = sense; 2090 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL; 2091 req.cmd[4] = lockflag ? 1 : 0; 2092 stat = cdrom_queue_packet_command(drive, &req); 2093 } 2094 2095 /* If we got an illegal field error, the drive 2096 probably cannot lock the door. */ 2097 if (stat != 0 && 2098 sense->sense_key == ILLEGAL_REQUEST && 2099 (sense->asc == 0x24 || sense->asc == 0x20)) { 2100 printk (KERN_ERR "%s: door locking not supported\n", 2101 drive->name); 2102 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1; 2103 stat = 0; 2104 } 2105 2106 /* no medium, that's alright. */ 2107 if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a) 2108 stat = 0; 2109 2110 if (stat == 0) 2111 CDROM_STATE_FLAGS(drive)->door_locked = lockflag; 2112 2113 return stat; 2114} 2115 2116 2117/* Eject the disk if EJECTFLAG is 0. 2118 If EJECTFLAG is 1, try to reload the disk. */ 2119static int cdrom_eject(ide_drive_t *drive, int ejectflag, 2120 struct request_sense *sense) 2121{ 2122 struct request req; 2123 char loej = 0x02; 2124 2125 if (CDROM_CONFIG_FLAGS(drive)->no_eject && !ejectflag) 2126 return -EDRIVE_CANT_DO_THIS; 2127 2128 /* reload fails on some drives, if the tray is locked */ 2129 if (CDROM_STATE_FLAGS(drive)->door_locked && ejectflag) 2130 return 0; 2131 2132 cdrom_prepare_request(drive, &req); 2133 2134 /* only tell drive to close tray if open, if it can do that */ 2135 if (ejectflag && !CDROM_CONFIG_FLAGS(drive)->close_tray) 2136 loej = 0; 2137 2138 req.sense = sense; 2139 req.cmd[0] = GPCMD_START_STOP_UNIT; 2140 req.cmd[4] = loej | (ejectflag != 0); 2141 return cdrom_queue_packet_command(drive, &req); 2142} 2143 2144static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity, 2145 unsigned long *sectors_per_frame, 2146 struct request_sense *sense) 2147{ 2148 struct { 2149 __u32 lba; 2150 __u32 blocklen; 2151 } capbuf; 2152 2153 int stat; 2154 struct request req; 2155 2156 cdrom_prepare_request(drive, &req); 2157 2158 req.sense = sense; 2159 req.cmd[0] = GPCMD_READ_CDVD_CAPACITY; 2160 req.data = (char *)&capbuf; 2161 req.data_len = sizeof(capbuf); 2162 2163 stat = cdrom_queue_packet_command(drive, &req); 2164 if (stat == 0) { 2165 *capacity = 1 + be32_to_cpu(capbuf.lba); 2166 *sectors_per_frame = 2167 be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS; 2168 } 2169 2170 return stat; 2171} 2172 2173static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag, 2174 int format, char *buf, int buflen, 2175 struct request_sense *sense) 2176{ 2177 struct request req; 2178 2179 cdrom_prepare_request(drive, &req); 2180 2181 req.sense = sense; 2182 req.data = buf; 2183 req.data_len = buflen; 2184 req.flags |= REQ_QUIET; 2185 req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP; 2186 req.cmd[6] = trackno; 2187 req.cmd[7] = (buflen >> 8); 2188 req.cmd[8] = (buflen & 0xff); 2189 req.cmd[9] = (format << 6); 2190 2191 if (msf_flag) 2192 req.cmd[1] = 2; 2193 2194 return cdrom_queue_packet_command(drive, &req); 2195} 2196 2197 2198/* Try to read the entire TOC for the disk into our internal buffer. */ 2199static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense) 2200{ 2201 int stat, ntracks, i; 2202 struct cdrom_info *info = drive->driver_data; 2203 struct cdrom_device_info *cdi = &info->devinfo; 2204 struct atapi_toc *toc = info->toc; 2205 struct { 2206 struct atapi_toc_header hdr; 2207 struct atapi_toc_entry ent; 2208 } ms_tmp; 2209 long last_written; 2210 unsigned long sectors_per_frame = SECTORS_PER_FRAME; 2211 2212 if (toc == NULL) { 2213 /* Try to allocate space. */ 2214 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL); 2215 if (toc == NULL) { 2216 printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name); 2217 return -ENOMEM; 2218 } 2219 info->toc = toc; 2220 } 2221 2222 /* Check to see if the existing data is still valid. 2223 If it is, just return. */ 2224 (void) cdrom_check_status(drive, sense); 2225 2226 if (CDROM_STATE_FLAGS(drive)->toc_valid) 2227 return 0; 2228 2229 /* Try to get the total cdrom capacity and sector size. */ 2230 stat = cdrom_read_capacity(drive, &toc->capacity, §ors_per_frame, 2231 sense); 2232 if (stat) 2233 toc->capacity = 0x1fffff; 2234 2235 set_capacity(info->disk, toc->capacity * sectors_per_frame); 2236 blk_queue_hardsect_size(drive->queue, 2237 sectors_per_frame << SECTOR_BITS); 2238 2239 /* First read just the header, so we know how long the TOC is. */ 2240 stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr, 2241 sizeof(struct atapi_toc_header), sense); 2242 if (stat) 2243 return stat; 2244 2245#if ! STANDARD_ATAPI 2246 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) { 2247 toc->hdr.first_track = bcd2bin(toc->hdr.first_track); 2248 toc->hdr.last_track = bcd2bin(toc->hdr.last_track); 2249 } 2250#endif /* not STANDARD_ATAPI */ 2251 2252 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1; 2253 if (ntracks <= 0) 2254 return -EIO; 2255 if (ntracks > MAX_TRACKS) 2256 ntracks = MAX_TRACKS; 2257 2258 /* Now read the whole schmeer. */ 2259 stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0, 2260 (char *)&toc->hdr, 2261 sizeof(struct atapi_toc_header) + 2262 (ntracks + 1) * 2263 sizeof(struct atapi_toc_entry), sense); 2264 2265 if (stat && toc->hdr.first_track > 1) { 2266 /* Cds with CDI tracks only don't have any TOC entries, 2267 despite of this the returned values are 2268 first_track == last_track = number of CDI tracks + 1, 2269 so that this case is indistinguishable from the same 2270 layout plus an additional audio track. 2271 If we get an error for the regular case, we assume 2272 a CDI without additional audio tracks. In this case 2273 the readable TOC is empty (CDI tracks are not included) 2274 and only holds the Leadout entry. Heiko Ei�feldt */ 2275 ntracks = 0; 2276 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0, 2277 (char *)&toc->hdr, 2278 sizeof(struct atapi_toc_header) + 2279 (ntracks + 1) * 2280 sizeof(struct atapi_toc_entry), 2281 sense); 2282 if (stat) { 2283 return stat; 2284 } 2285#if ! STANDARD_ATAPI 2286 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) { 2287 toc->hdr.first_track = bin2bcd(CDROM_LEADOUT); 2288 toc->hdr.last_track = bin2bcd(CDROM_LEADOUT); 2289 } else 2290#endif /* not STANDARD_ATAPI */ 2291 { 2292 toc->hdr.first_track = CDROM_LEADOUT; 2293 toc->hdr.last_track = CDROM_LEADOUT; 2294 } 2295 } 2296 2297 if (stat) 2298 return stat; 2299 2300 toc->hdr.toc_length = ntohs (toc->hdr.toc_length); 2301 2302#if ! STANDARD_ATAPI 2303 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) { 2304 toc->hdr.first_track = bcd2bin(toc->hdr.first_track); 2305 toc->hdr.last_track = bcd2bin(toc->hdr.last_track); 2306 } 2307#endif /* not STANDARD_ATAPI */ 2308 2309 for (i=0; i<=ntracks; i++) { 2310#if ! STANDARD_ATAPI 2311 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) { 2312 if (CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd) 2313 toc->ent[i].track = bcd2bin(toc->ent[i].track); 2314 msf_from_bcd(&toc->ent[i].addr.msf); 2315 } 2316#endif /* not STANDARD_ATAPI */ 2317 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute, 2318 toc->ent[i].addr.msf.second, 2319 toc->ent[i].addr.msf.frame); 2320 } 2321 2322 /* Read the multisession information. */ 2323 if (toc->hdr.first_track != CDROM_LEADOUT) { 2324 /* Read the multisession information. */ 2325 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp, 2326 sizeof(ms_tmp), sense); 2327 if (stat) 2328 return stat; 2329 2330 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba); 2331 } else { 2332 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT; 2333 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */ 2334 } 2335 2336#if ! STANDARD_ATAPI 2337 if (CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd) { 2338 /* Re-read multisession information using MSF format */ 2339 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp, 2340 sizeof(ms_tmp), sense); 2341 if (stat) 2342 return stat; 2343 2344 msf_from_bcd (&ms_tmp.ent.addr.msf); 2345 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute, 2346 ms_tmp.ent.addr.msf.second, 2347 ms_tmp.ent.addr.msf.frame); 2348 } 2349#endif /* not STANDARD_ATAPI */ 2350 2351 toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track); 2352 2353 /* Now try to get the total cdrom capacity. */ 2354 stat = cdrom_get_last_written(cdi, &last_written); 2355 if (!stat && (last_written > toc->capacity)) { 2356 toc->capacity = last_written; 2357 set_capacity(info->disk, toc->capacity * sectors_per_frame); 2358 } 2359 2360 /* Remember that we've read this stuff. */ 2361 CDROM_STATE_FLAGS(drive)->toc_valid = 1; 2362 2363 return 0; 2364} 2365 2366 2367static int cdrom_read_subchannel(ide_drive_t *drive, int format, char *buf, 2368 int buflen, struct request_sense *sense) 2369{ 2370 struct request req; 2371 2372 cdrom_prepare_request(drive, &req); 2373 2374 req.sense = sense; 2375 req.data = buf; 2376 req.data_len = buflen; 2377 req.cmd[0] = GPCMD_READ_SUBCHANNEL; 2378 req.cmd[1] = 2; /* MSF addressing */ 2379 req.cmd[2] = 0x40; /* request subQ data */ 2380 req.cmd[3] = format; 2381 req.cmd[7] = (buflen >> 8); 2382 req.cmd[8] = (buflen & 0xff); 2383 return cdrom_queue_packet_command(drive, &req); 2384} 2385 2386/* ATAPI cdrom drives are free to select the speed you request or any slower 2387 rate :-( Requesting too fast a speed will _not_ produce an error. */ 2388static int cdrom_select_speed(ide_drive_t *drive, int speed, 2389 struct request_sense *sense) 2390{ 2391 struct request req; 2392 cdrom_prepare_request(drive, &req); 2393 2394 req.sense = sense; 2395 if (speed == 0) 2396 speed = 0xffff; /* set to max */ 2397 else 2398 speed *= 177; /* Nx to kbytes/s */ 2399 2400 req.cmd[0] = GPCMD_SET_SPEED; 2401 /* Read Drive speed in kbytes/second MSB */ 2402 req.cmd[2] = (speed >> 8) & 0xff; 2403 /* Read Drive speed in kbytes/second LSB */ 2404 req.cmd[3] = speed & 0xff; 2405 if (CDROM_CONFIG_FLAGS(drive)->cd_r || 2406 CDROM_CONFIG_FLAGS(drive)->cd_rw || 2407 CDROM_CONFIG_FLAGS(drive)->dvd_r) { 2408 /* Write Drive speed in kbytes/second MSB */ 2409 req.cmd[4] = (speed >> 8) & 0xff; 2410 /* Write Drive speed in kbytes/second LSB */ 2411 req.cmd[5] = speed & 0xff; 2412 } 2413 2414 return cdrom_queue_packet_command(drive, &req); 2415} 2416 2417static int cdrom_play_audio(ide_drive_t *drive, int lba_start, int lba_end) 2418{ 2419 struct request_sense sense; 2420 struct request req; 2421 2422 cdrom_prepare_request(drive, &req); 2423 2424 req.sense = &sense; 2425 req.cmd[0] = GPCMD_PLAY_AUDIO_MSF; 2426 lba_to_msf(lba_start, &req.cmd[3], &req.cmd[4], &req.cmd[5]); 2427 lba_to_msf(lba_end-1, &req.cmd[6], &req.cmd[7], &req.cmd[8]); 2428 2429 return cdrom_queue_packet_command(drive, &req); 2430} 2431 2432static int cdrom_get_toc_entry(ide_drive_t *drive, int track, 2433 struct atapi_toc_entry **ent) 2434{ 2435 struct cdrom_info *info = drive->driver_data; 2436 struct atapi_toc *toc = info->toc; 2437 int ntracks; 2438 2439 /* 2440 * don't serve cached data, if the toc isn't valid 2441 */ 2442 if (!CDROM_STATE_FLAGS(drive)->toc_valid) 2443 return -EINVAL; 2444 2445 /* Check validity of requested track number. */ 2446 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1; 2447 if (toc->hdr.first_track == CDROM_LEADOUT) ntracks = 0; 2448 if (track == CDROM_LEADOUT) 2449 *ent = &toc->ent[ntracks]; 2450 else if (track < toc->hdr.first_track || 2451 track > toc->hdr.last_track) 2452 return -EINVAL; 2453 else 2454 *ent = &toc->ent[track - toc->hdr.first_track]; 2455 2456 return 0; 2457} 2458 2459/* the generic packet interface to cdrom.c */ 2460static int ide_cdrom_packet(struct cdrom_device_info *cdi, 2461 struct packet_command *cgc) 2462{ 2463 struct request req; 2464 ide_drive_t *drive = cdi->handle; 2465 2466 if (cgc->timeout <= 0) 2467 cgc->timeout = ATAPI_WAIT_PC; 2468 2469 /* here we queue the commands from the uniform CD-ROM 2470 layer. the packet must be complete, as we do not 2471 touch it at all. */ 2472 cdrom_prepare_request(drive, &req); 2473 memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE); 2474 if (cgc->sense) 2475 memset(cgc->sense, 0, sizeof(struct request_sense)); 2476 req.data = cgc->buffer; 2477 req.data_len = cgc->buflen; 2478 req.timeout = cgc->timeout; 2479 2480 if (cgc->quiet) 2481 req.flags |= REQ_QUIET; 2482 2483 req.sense = cgc->sense; 2484 cgc->stat = cdrom_queue_packet_command(drive, &req); 2485 if (!cgc->stat) 2486 cgc->buflen -= req.data_len; 2487 return cgc->stat; 2488} 2489 2490static 2491int ide_cdrom_dev_ioctl (struct cdrom_device_info *cdi, 2492 unsigned int cmd, unsigned long arg) 2493{ 2494 struct packet_command cgc; 2495 char buffer[16]; 2496 int stat; 2497 2498 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN); 2499 2500 /* These will be moved into the Uniform layer shortly... */ 2501 switch (cmd) { 2502 case CDROMSETSPINDOWN: { 2503 char spindown; 2504 2505 if (copy_from_user(&spindown, (void __user *) arg, sizeof(char))) 2506 return -EFAULT; 2507 2508 if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0))) 2509 return stat; 2510 2511 buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f); 2512 2513 return cdrom_mode_select(cdi, &cgc); 2514 } 2515 2516 case CDROMGETSPINDOWN: { 2517 char spindown; 2518 2519 if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0))) 2520 return stat; 2521 2522 spindown = buffer[11] & 0x0f; 2523 2524 if (copy_to_user((void __user *) arg, &spindown, sizeof (char))) 2525 return -EFAULT; 2526 2527 return 0; 2528 } 2529 2530 default: 2531 return -EINVAL; 2532 } 2533 2534} 2535 2536static 2537int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi, 2538 unsigned int cmd, void *arg) 2539 2540{ 2541 ide_drive_t *drive = cdi->handle; 2542 struct cdrom_info *info = drive->driver_data; 2543 int stat; 2544 2545 switch (cmd) { 2546 /* 2547 * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since 2548 * atapi doesn't support it 2549 */ 2550 case CDROMPLAYTRKIND: { 2551 unsigned long lba_start, lba_end; 2552 struct cdrom_ti *ti = arg; 2553 struct atapi_toc_entry *first_toc, *last_toc; 2554 2555 stat = cdrom_get_toc_entry(drive, ti->cdti_trk0, &first_toc); 2556 if (stat) 2557 return stat; 2558 2559 stat = cdrom_get_toc_entry(drive, ti->cdti_trk1, &last_toc); 2560 if (stat) 2561 return stat; 2562 2563 if (ti->cdti_trk1 != CDROM_LEADOUT) 2564 ++last_toc; 2565 lba_start = first_toc->addr.lba; 2566 lba_end = last_toc->addr.lba; 2567 2568 if (lba_end <= lba_start) 2569 return -EINVAL; 2570 2571 return cdrom_play_audio(drive, lba_start, lba_end); 2572 } 2573 2574 case CDROMREADTOCHDR: { 2575 struct cdrom_tochdr *tochdr = arg; 2576 struct atapi_toc *toc; 2577 2578 /* Make sure our saved TOC is valid. */ 2579 stat = cdrom_read_toc(drive, NULL); 2580 if (stat) 2581 return stat; 2582 2583 toc = info->toc; 2584 tochdr->cdth_trk0 = toc->hdr.first_track; 2585 tochdr->cdth_trk1 = toc->hdr.last_track; 2586 2587 return 0; 2588 } 2589 2590 case CDROMREADTOCENTRY: { 2591 struct cdrom_tocentry *tocentry = arg; 2592 struct atapi_toc_entry *toce; 2593 2594 stat = cdrom_get_toc_entry(drive, tocentry->cdte_track, &toce); 2595 if (stat) 2596 return stat; 2597 2598 tocentry->cdte_ctrl = toce->control; 2599 tocentry->cdte_adr = toce->adr; 2600 if (tocentry->cdte_format == CDROM_MSF) { 2601 lba_to_msf (toce->addr.lba, 2602 &tocentry->cdte_addr.msf.minute, 2603 &tocentry->cdte_addr.msf.second, 2604 &tocentry->cdte_addr.msf.frame); 2605 } else 2606 tocentry->cdte_addr.lba = toce->addr.lba; 2607 2608 return 0; 2609 } 2610 2611 default: 2612 return -EINVAL; 2613 } 2614} 2615 2616static 2617int ide_cdrom_reset (struct cdrom_device_info *cdi) 2618{ 2619 ide_drive_t *drive = cdi->handle; 2620 struct request_sense sense; 2621 struct request req; 2622 int ret; 2623 2624 cdrom_prepare_request(drive, &req); 2625 req.flags = REQ_SPECIAL | REQ_QUIET; 2626 ret = ide_do_drive_cmd(drive, &req, ide_wait); 2627 2628 /* 2629 * A reset will unlock the door. If it was previously locked, 2630 * lock it again. 2631 */ 2632 if (CDROM_STATE_FLAGS(drive)->door_locked) 2633 (void) cdrom_lockdoor(drive, 1, &sense); 2634 2635 return ret; 2636} 2637 2638 2639static 2640int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position) 2641{ 2642 ide_drive_t *drive = cdi->handle; 2643 struct request_sense sense; 2644 2645 if (position) { 2646 int stat = cdrom_lockdoor(drive, 0, &sense); 2647 if (stat) 2648 return stat; 2649 } 2650 2651 return cdrom_eject(drive, !position, &sense); 2652} 2653 2654static 2655int ide_cdrom_lock_door (struct cdrom_device_info *cdi, int lock) 2656{ 2657 ide_drive_t *drive = cdi->handle; 2658 return cdrom_lockdoor(drive, lock, NULL); 2659} 2660 2661static 2662int ide_cdrom_get_capabilities(ide_drive_t *drive, struct atapi_capabilities_page *cap) 2663{ 2664 struct cdrom_info *info = drive->driver_data; 2665 struct cdrom_device_info *cdi = &info->devinfo; 2666 struct packet_command cgc; 2667 int stat, attempts = 3, size = sizeof(*cap); 2668 2669 /* 2670 * ACER50 (and others?) require the full spec length mode sense 2671 * page capabilities size, but older drives break. 2672 */ 2673 if (!(!strcmp(drive->id->model, "ATAPI CD ROM DRIVE 50X MAX") || 2674 !strcmp(drive->id->model, "WPI CDS-32X"))) 2675 size -= sizeof(cap->pad); 2676 2677 init_cdrom_command(&cgc, cap, size, CGC_DATA_UNKNOWN); 2678 do { /* we seem to get stat=0x01,err=0x00 the first time (??) */ 2679 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0); 2680 if (!stat) 2681 break; 2682 } while (--attempts); 2683 return stat; 2684} 2685 2686static 2687void ide_cdrom_update_speed (ide_drive_t *drive, struct atapi_capabilities_page *cap) 2688{ 2689 /* The ACER/AOpen 24X cdrom has the speed fields byte-swapped */ 2690 if (!drive->id->model[0] && 2691 !strncmp(drive->id->fw_rev, "241N", 4)) { 2692 CDROM_STATE_FLAGS(drive)->current_speed = 2693 (((unsigned int)cap->curspeed) + (176/2)) / 176; 2694 CDROM_CONFIG_FLAGS(drive)->max_speed = 2695 (((unsigned int)cap->maxspeed) + (176/2)) / 176; 2696 } else { 2697 CDROM_STATE_FLAGS(drive)->current_speed = 2698 (ntohs(cap->curspeed) + (176/2)) / 176; 2699 CDROM_CONFIG_FLAGS(drive)->max_speed = 2700 (ntohs(cap->maxspeed) + (176/2)) / 176; 2701 } 2702} 2703 2704static 2705int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed) 2706{ 2707 ide_drive_t *drive = cdi->handle; 2708 struct request_sense sense; 2709 struct atapi_capabilities_page cap; 2710 int stat; 2711 2712 if ((stat = cdrom_select_speed(drive, speed, &sense)) < 0) 2713 return stat; 2714 2715 if (!ide_cdrom_get_capabilities(drive, &cap)) { 2716 ide_cdrom_update_speed(drive, &cap); 2717 cdi->speed = CDROM_STATE_FLAGS(drive)->current_speed; 2718 } 2719 return 0; 2720} 2721 2722/* 2723 * add logic to try GET_EVENT command first to check for media and tray 2724 * status. this should be supported by newer cd-r/w and all DVD etc 2725 * drives 2726 */ 2727static 2728int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr) 2729{ 2730 ide_drive_t *drive = cdi->handle; 2731 struct media_event_desc med; 2732 struct request_sense sense; 2733 int stat; 2734 2735 if (slot_nr != CDSL_CURRENT) 2736 return -EINVAL; 2737 2738 stat = cdrom_check_status(drive, &sense); 2739 if (!stat || sense.sense_key == UNIT_ATTENTION) 2740 return CDS_DISC_OK; 2741 2742 if (!cdrom_get_media_event(cdi, &med)) { 2743 if (med.media_present) 2744 return CDS_DISC_OK; 2745 else if (med.door_open) 2746 return CDS_TRAY_OPEN; 2747 else 2748 return CDS_NO_DISC; 2749 } 2750 2751 if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04) 2752 return CDS_DISC_OK; 2753 2754 /* 2755 * If not using Mt Fuji extended media tray reports, 2756 * just return TRAY_OPEN since ATAPI doesn't provide 2757 * any other way to detect this... 2758 */ 2759 if (sense.sense_key == NOT_READY) { 2760 if (sense.asc == 0x3a) { 2761 if (sense.ascq == 1) 2762 return CDS_NO_DISC; 2763 else if (sense.ascq == 0 || sense.ascq == 2) 2764 return CDS_TRAY_OPEN; 2765 } 2766 } 2767 2768 return CDS_DRIVE_NOT_READY; 2769} 2770 2771static 2772int ide_cdrom_get_last_session (struct cdrom_device_info *cdi, 2773 struct cdrom_multisession *ms_info) 2774{ 2775 struct atapi_toc *toc; 2776 ide_drive_t *drive = cdi->handle; 2777 struct cdrom_info *info = drive->driver_data; 2778 struct request_sense sense; 2779 int ret; 2780 2781 if (!CDROM_STATE_FLAGS(drive)->toc_valid || info->toc == NULL) 2782 if ((ret = cdrom_read_toc(drive, &sense))) 2783 return ret; 2784 2785 toc = info->toc; 2786 ms_info->addr.lba = toc->last_session_lba; 2787 ms_info->xa_flag = toc->xa_flag; 2788 2789 return 0; 2790} 2791 2792static 2793int ide_cdrom_get_mcn (struct cdrom_device_info *cdi, 2794 struct cdrom_mcn *mcn_info) 2795{ 2796 int stat; 2797 char mcnbuf[24]; 2798 ide_drive_t *drive = cdi->handle; 2799 2800/* get MCN */ 2801 if ((stat = cdrom_read_subchannel(drive, 2, mcnbuf, sizeof (mcnbuf), NULL))) 2802 return stat; 2803 2804 memcpy (mcn_info->medium_catalog_number, mcnbuf+9, 2805 sizeof (mcn_info->medium_catalog_number)-1); 2806 mcn_info->medium_catalog_number[sizeof (mcn_info->medium_catalog_number)-1] 2807 = '\0'; 2808 2809 return 0; 2810} 2811 2812 2813 2814/**************************************************************************** 2815 * Other driver requests (open, close, check media change). 2816 */ 2817 2818static 2819int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi, 2820 int slot_nr) 2821{ 2822 ide_drive_t *drive = cdi->handle; 2823 int retval; 2824 2825 if (slot_nr == CDSL_CURRENT) { 2826 (void) cdrom_check_status(drive, NULL); 2827 retval = CDROM_STATE_FLAGS(drive)->media_changed; 2828 CDROM_STATE_FLAGS(drive)->media_changed = 0; 2829 return retval; 2830 } else { 2831 return -EINVAL; 2832 } 2833} 2834 2835 2836static 2837int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose) 2838{ 2839 return 0; 2840} 2841 2842/* 2843 * Close down the device. Invalidate all cached blocks. 2844 */ 2845 2846static 2847void ide_cdrom_release_real (struct cdrom_device_info *cdi) 2848{ 2849 ide_drive_t *drive = cdi->handle; 2850 2851 if (!cdi->use_count) 2852 CDROM_STATE_FLAGS(drive)->toc_valid = 0; 2853} 2854 2855 2856 2857/**************************************************************************** 2858 * Device initialization. 2859 */ 2860static struct cdrom_device_ops ide_cdrom_dops = { 2861 .open = ide_cdrom_open_real, 2862 .release = ide_cdrom_release_real, 2863 .drive_status = ide_cdrom_drive_status, 2864 .media_changed = ide_cdrom_check_media_change_real, 2865 .tray_move = ide_cdrom_tray_move, 2866 .lock_door = ide_cdrom_lock_door, 2867 .select_speed = ide_cdrom_select_speed, 2868 .get_last_session = ide_cdrom_get_last_session, 2869 .get_mcn = ide_cdrom_get_mcn, 2870 .reset = ide_cdrom_reset, 2871 .audio_ioctl = ide_cdrom_audio_ioctl, 2872 .dev_ioctl = ide_cdrom_dev_ioctl, 2873 .capability = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | 2874 CDC_SELECT_SPEED | CDC_SELECT_DISC | 2875 CDC_MULTI_SESSION | CDC_MCN | 2876 CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO | CDC_RESET | 2877 CDC_IOCTLS | CDC_DRIVE_STATUS | CDC_CD_R | 2878 CDC_CD_RW | CDC_DVD | CDC_DVD_R| CDC_DVD_RAM | 2879 CDC_GENERIC_PACKET | CDC_MO_DRIVE | CDC_MRW | 2880 CDC_MRW_W | CDC_RAM, 2881 .generic_packet = ide_cdrom_packet, 2882}; 2883 2884static int ide_cdrom_register (ide_drive_t *drive, int nslots) 2885{ 2886 struct cdrom_info *info = drive->driver_data; 2887 struct cdrom_device_info *devinfo = &info->devinfo; 2888 2889 devinfo->ops = &ide_cdrom_dops; 2890 devinfo->mask = 0; 2891 devinfo->speed = CDROM_STATE_FLAGS(drive)->current_speed; 2892 devinfo->capacity = nslots; 2893 devinfo->handle = drive; 2894 strcpy(devinfo->name, drive->name); 2895 2896 /* set capability mask to match the probe. */ 2897 if (!CDROM_CONFIG_FLAGS(drive)->cd_r) 2898 devinfo->mask |= CDC_CD_R; 2899 if (!CDROM_CONFIG_FLAGS(drive)->cd_rw) 2900 devinfo->mask |= CDC_CD_RW; 2901 if (!CDROM_CONFIG_FLAGS(drive)->dvd) 2902 devinfo->mask |= CDC_DVD; 2903 if (!CDROM_CONFIG_FLAGS(drive)->dvd_r) 2904 devinfo->mask |= CDC_DVD_R; 2905 if (!CDROM_CONFIG_FLAGS(drive)->dvd_ram) 2906 devinfo->mask |= CDC_DVD_RAM; 2907 if (!CDROM_CONFIG_FLAGS(drive)->is_changer) 2908 devinfo->mask |= CDC_SELECT_DISC; 2909 if (!CDROM_CONFIG_FLAGS(drive)->audio_play) 2910 devinfo->mask |= CDC_PLAY_AUDIO; 2911 if (!CDROM_CONFIG_FLAGS(drive)->close_tray) 2912 devinfo->mask |= CDC_CLOSE_TRAY; 2913 if (!CDROM_CONFIG_FLAGS(drive)->mo_drive) 2914 devinfo->mask |= CDC_MO_DRIVE; 2915 2916 devinfo->disk = info->disk; 2917 return register_cdrom(devinfo); 2918} 2919 2920static 2921int ide_cdrom_probe_capabilities (ide_drive_t *drive) 2922{ 2923 struct cdrom_info *info = drive->driver_data; 2924 struct cdrom_device_info *cdi = &info->devinfo; 2925 struct atapi_capabilities_page cap; 2926 int nslots = 1; 2927 2928 if (drive->media == ide_optical) { 2929 CDROM_CONFIG_FLAGS(drive)->mo_drive = 1; 2930 CDROM_CONFIG_FLAGS(drive)->ram = 1; 2931 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name); 2932 return nslots; 2933 } 2934 2935 if (CDROM_CONFIG_FLAGS(drive)->nec260 || 2936 !strcmp(drive->id->model,"STINGRAY 8422 IDE 8X CD-ROM 7-27-95")) { 2937 CDROM_CONFIG_FLAGS(drive)->no_eject = 0; 2938 CDROM_CONFIG_FLAGS(drive)->audio_play = 1; 2939 return nslots; 2940 } 2941 2942 /* 2943 * we have to cheat a little here. the packet will eventually 2944 * be queued with ide_cdrom_packet(), which extracts the 2945 * drive from cdi->handle. Since this device hasn't been 2946 * registered with the Uniform layer yet, it can't do this. 2947 * Same goes for cdi->ops. 2948 */ 2949 cdi->handle = drive; 2950 cdi->ops = &ide_cdrom_dops; 2951 2952 if (ide_cdrom_get_capabilities(drive, &cap)) 2953 return 0; 2954 2955 if (cap.lock == 0) 2956 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1; 2957 if (cap.eject) 2958 CDROM_CONFIG_FLAGS(drive)->no_eject = 0; 2959 if (cap.cd_r_write) 2960 CDROM_CONFIG_FLAGS(drive)->cd_r = 1; 2961 if (cap.cd_rw_write) { 2962 CDROM_CONFIG_FLAGS(drive)->cd_rw = 1; 2963 CDROM_CONFIG_FLAGS(drive)->ram = 1; 2964 } 2965 if (cap.test_write) 2966 CDROM_CONFIG_FLAGS(drive)->test_write = 1; 2967 if (cap.dvd_ram_read || cap.dvd_r_read || cap.dvd_rom) 2968 CDROM_CONFIG_FLAGS(drive)->dvd = 1; 2969 if (cap.dvd_ram_write) { 2970 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 1; 2971 CDROM_CONFIG_FLAGS(drive)->ram = 1; 2972 } 2973 if (cap.dvd_r_write) 2974 CDROM_CONFIG_FLAGS(drive)->dvd_r = 1; 2975 if (cap.audio_play) 2976 CDROM_CONFIG_FLAGS(drive)->audio_play = 1; 2977 if (cap.mechtype == mechtype_caddy || cap.mechtype == mechtype_popup) 2978 CDROM_CONFIG_FLAGS(drive)->close_tray = 0; 2979 2980 /* Some drives used by Apple don't advertise audio play 2981 * but they do support reading TOC & audio datas 2982 */ 2983 if (strcmp(drive->id->model, "MATSHITADVD-ROM SR-8187") == 0 || 2984 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8186") == 0 || 2985 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8176") == 0 || 2986 strcmp(drive->id->model, "MATSHITADVD-ROM SR-8174") == 0) 2987 CDROM_CONFIG_FLAGS(drive)->audio_play = 1; 2988 2989#if ! STANDARD_ATAPI 2990 if (cdi->sanyo_slot > 0) { 2991 CDROM_CONFIG_FLAGS(drive)->is_changer = 1; 2992 nslots = 3; 2993 } 2994 2995 else 2996#endif /* not STANDARD_ATAPI */ 2997 if (cap.mechtype == mechtype_individual_changer || 2998 cap.mechtype == mechtype_cartridge_changer) { 2999 if ((nslots = cdrom_number_of_slots(cdi)) > 1) { 3000 CDROM_CONFIG_FLAGS(drive)->is_changer = 1; 3001 CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 1; 3002 } 3003 } 3004 3005 ide_cdrom_update_speed(drive, &cap); 3006 /* don't print speed if the drive reported 0. 3007 */ 3008 printk(KERN_INFO "%s: ATAPI", drive->name); 3009 if (CDROM_CONFIG_FLAGS(drive)->max_speed) 3010 printk(" %dX", CDROM_CONFIG_FLAGS(drive)->max_speed); 3011 printk(" %s", CDROM_CONFIG_FLAGS(drive)->dvd ? "DVD-ROM" : "CD-ROM"); 3012 3013 if (CDROM_CONFIG_FLAGS(drive)->dvd_r|CDROM_CONFIG_FLAGS(drive)->dvd_ram) 3014 printk(" DVD%s%s", 3015 (CDROM_CONFIG_FLAGS(drive)->dvd_r)? "-R" : "", 3016 (CDROM_CONFIG_FLAGS(drive)->dvd_ram)? "-RAM" : ""); 3017 3018 if (CDROM_CONFIG_FLAGS(drive)->cd_r|CDROM_CONFIG_FLAGS(drive)->cd_rw) 3019 printk(" CD%s%s", 3020 (CDROM_CONFIG_FLAGS(drive)->cd_r)? "-R" : "", 3021 (CDROM_CONFIG_FLAGS(drive)->cd_rw)? "/RW" : ""); 3022 3023 if (CDROM_CONFIG_FLAGS(drive)->is_changer) 3024 printk(" changer w/%d slots", nslots); 3025 else 3026 printk(" drive"); 3027 3028 printk(", %dkB Cache", be16_to_cpu(cap.buffer_size)); 3029 3030 if (drive->using_dma) 3031 ide_dma_verbose(drive); 3032 3033 printk("\n"); 3034 3035 return nslots; 3036} 3037 3038static void ide_cdrom_add_settings(ide_drive_t *drive) 3039{ 3040 ide_add_setting(drive, "dsc_overlap", SETTING_RW, -1, -1, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL); 3041} 3042 3043/* 3044 * standard prep_rq_fn that builds 10 byte cmds 3045 */ 3046static int ide_cdrom_prep_fs(request_queue_t *q, struct request *rq) 3047{ 3048 int hard_sect = queue_hardsect_size(q); 3049 long block = (long)rq->hard_sector / (hard_sect >> 9); 3050 unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9); 3051 3052 memset(rq->cmd, 0, sizeof(rq->cmd)); 3053 3054 if (rq_data_dir(rq) == READ) 3055 rq->cmd[0] = GPCMD_READ_10; 3056 else 3057 rq->cmd[0] = GPCMD_WRITE_10; 3058 3059 /* 3060 * fill in lba 3061 */ 3062 rq->cmd[2] = (block >> 24) & 0xff; 3063 rq->cmd[3] = (block >> 16) & 0xff; 3064 rq->cmd[4] = (block >> 8) & 0xff; 3065 rq->cmd[5] = block & 0xff; 3066 3067 /* 3068 * and transfer length 3069 */ 3070 rq->cmd[7] = (blocks >> 8) & 0xff; 3071 rq->cmd[8] = blocks & 0xff; 3072 rq->cmd_len = 10; 3073 return BLKPREP_OK; 3074} 3075 3076/* 3077 * Most of the SCSI commands are supported directly by ATAPI devices. 3078 * This transform handles the few exceptions. 3079 */ 3080static int ide_cdrom_prep_pc(struct request *rq) 3081{ 3082 u8 *c = rq->cmd; 3083 3084 /* 3085 * Transform 6-byte read/write commands to the 10-byte version 3086 */ 3087 if (c[0] == READ_6 || c[0] == WRITE_6) { 3088 c[8] = c[4]; 3089 c[5] = c[3]; 3090 c[4] = c[2]; 3091 c[3] = c[1] & 0x1f; 3092 c[2] = 0; 3093 c[1] &= 0xe0; 3094 c[0] += (READ_10 - READ_6); 3095 rq->cmd_len = 10; 3096 return BLKPREP_OK; 3097 } 3098 3099 /* 3100 * it's silly to pretend we understand 6-byte sense commands, just 3101 * reject with ILLEGAL_REQUEST and the caller should take the 3102 * appropriate action 3103 */ 3104 if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) { 3105 rq->errors = ILLEGAL_REQUEST; 3106 return BLKPREP_KILL; 3107 } 3108 3109 return BLKPREP_OK; 3110} 3111 3112static int ide_cdrom_prep_fn(request_queue_t *q, struct request *rq) 3113{ 3114 if (rq->flags & REQ_CMD) 3115 return ide_cdrom_prep_fs(q, rq); 3116 else if (rq->flags & REQ_BLOCK_PC) 3117 return ide_cdrom_prep_pc(rq); 3118 3119 return 0; 3120} 3121 3122static 3123int ide_cdrom_setup (ide_drive_t *drive) 3124{ 3125 struct cdrom_info *info = drive->driver_data; 3126 struct cdrom_device_info *cdi = &info->devinfo; 3127 int nslots; 3128 3129 blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn); 3130 blk_queue_dma_alignment(drive->queue, 31); 3131 drive->queue->unplug_delay = (1 * HZ) / 1000; 3132 if (!drive->queue->unplug_delay) 3133 drive->queue->unplug_delay = 1; 3134 3135 drive->special.all = 0; 3136 3137 CDROM_STATE_FLAGS(drive)->media_changed = 1; 3138 CDROM_STATE_FLAGS(drive)->toc_valid = 0; 3139 CDROM_STATE_FLAGS(drive)->door_locked = 0; 3140 3141#if NO_DOOR_LOCKING 3142 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 1; 3143#else 3144 CDROM_CONFIG_FLAGS(drive)->no_doorlock = 0; 3145#endif 3146 3147 CDROM_CONFIG_FLAGS(drive)->drq_interrupt = ((drive->id->config & 0x0060) == 0x20); 3148 CDROM_CONFIG_FLAGS(drive)->is_changer = 0; 3149 CDROM_CONFIG_FLAGS(drive)->cd_r = 0; 3150 CDROM_CONFIG_FLAGS(drive)->cd_rw = 0; 3151 CDROM_CONFIG_FLAGS(drive)->test_write = 0; 3152 CDROM_CONFIG_FLAGS(drive)->dvd = 0; 3153 CDROM_CONFIG_FLAGS(drive)->dvd_r = 0; 3154 CDROM_CONFIG_FLAGS(drive)->dvd_ram = 0; 3155 CDROM_CONFIG_FLAGS(drive)->no_eject = 1; 3156 CDROM_CONFIG_FLAGS(drive)->supp_disc_present = 0; 3157 CDROM_CONFIG_FLAGS(drive)->audio_play = 0; 3158 CDROM_CONFIG_FLAGS(drive)->close_tray = 1; 3159 3160 /* limit transfer size per interrupt. */ 3161 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 0; 3162 /* a testament to the nice quality of Samsung drives... */ 3163 if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2430")) 3164 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1; 3165 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-2432")) 3166 CDROM_CONFIG_FLAGS(drive)->limit_nframes = 1; 3167 /* the 3231 model does not support the SET_CD_SPEED command */ 3168 else if (!strcmp(drive->id->model, "SAMSUNG CD-ROM SCR-3231")) 3169 cdi->mask |= CDC_SELECT_SPEED; 3170 3171#if ! STANDARD_ATAPI 3172 /* by default Sanyo 3 CD changer support is turned off and 3173 ATAPI Rev 2.2+ standard support for CD changers is used */ 3174 cdi->sanyo_slot = 0; 3175 3176 CDROM_CONFIG_FLAGS(drive)->nec260 = 0; 3177 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 0; 3178 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 0; 3179 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 0; 3180 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 0; 3181 3182 if (strcmp (drive->id->model, "V003S0DS") == 0 && 3183 drive->id->fw_rev[4] == '1' && 3184 drive->id->fw_rev[6] <= '2') { 3185 /* Vertos 300. 3186 Some versions of this drive like to talk BCD. */ 3187 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1; 3188 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1; 3189 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1; 3190 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1; 3191 } 3192 3193 else if (strcmp (drive->id->model, "V006E0DS") == 0 && 3194 drive->id->fw_rev[4] == '1' && 3195 drive->id->fw_rev[6] <= '2') { 3196 /* Vertos 600 ESD. */ 3197 CDROM_CONFIG_FLAGS(drive)->toctracks_as_bcd = 1; 3198 } 3199 else if (strcmp(drive->id->model, "NEC CD-ROM DRIVE:260") == 0 && 3200 strncmp(drive->id->fw_rev, "1.01", 4) == 0) { /* FIXME */ 3201 /* Old NEC260 (not R). 3202 This drive was released before the 1.2 version 3203 of the spec. */ 3204 CDROM_CONFIG_FLAGS(drive)->tocaddr_as_bcd = 1; 3205 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1; 3206 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1; 3207 CDROM_CONFIG_FLAGS(drive)->nec260 = 1; 3208 } 3209 else if (strcmp(drive->id->model, "WEARNES CDD-120") == 0 && 3210 strncmp(drive->id->fw_rev, "A1.1", 4) == 0) { /* FIXME */ 3211 /* Wearnes */ 3212 CDROM_CONFIG_FLAGS(drive)->playmsf_as_bcd = 1; 3213 CDROM_CONFIG_FLAGS(drive)->subchan_as_bcd = 1; 3214 } 3215 /* Sanyo 3 CD changer uses a non-standard command 3216 for CD changing */ 3217 else if ((strcmp(drive->id->model, "CD-ROM CDR-C3 G") == 0) || 3218 (strcmp(drive->id->model, "CD-ROM CDR-C3G") == 0) || 3219 (strcmp(drive->id->model, "CD-ROM CDR_C36") == 0)) { 3220 /* uses CD in slot 0 when value is set to 3 */ 3221 cdi->sanyo_slot = 3; 3222 } 3223#endif /* not STANDARD_ATAPI */ 3224 3225 info->toc = NULL; 3226 info->buffer = NULL; 3227 info->sector_buffered = 0; 3228 info->nsectors_buffered = 0; 3229 info->changer_info = NULL; 3230 info->last_block = 0; 3231 info->start_seek = 0; 3232 3233 nslots = ide_cdrom_probe_capabilities (drive); 3234 3235 /* 3236 * set correct block size 3237 */ 3238 blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE); 3239 3240 if (drive->autotune == IDE_TUNE_DEFAULT || 3241 drive->autotune == IDE_TUNE_AUTO) 3242 drive->dsc_overlap = (drive->next != drive); 3243#if 0 3244 drive->dsc_overlap = (HWIF(drive)->no_dsc) ? 0 : 1; 3245 if (HWIF(drive)->no_dsc) { 3246 printk(KERN_INFO "ide-cd: %s: disabling DSC overlap\n", 3247 drive->name); 3248 drive->dsc_overlap = 0; 3249 } 3250#endif 3251 3252 if (ide_cdrom_register(drive, nslots)) { 3253 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name); 3254 info->devinfo.handle = NULL; 3255 return 1; 3256 } 3257 ide_cdrom_add_settings(drive); 3258 return 0; 3259} 3260 3261#ifdef CONFIG_PROC_FS 3262static 3263sector_t ide_cdrom_capacity (ide_drive_t *drive) 3264{ 3265 unsigned long capacity, sectors_per_frame; 3266 3267 if (cdrom_read_capacity(drive, &capacity, §ors_per_frame, NULL)) 3268 return 0; 3269 3270 return capacity * sectors_per_frame; 3271} 3272#endif 3273 3274static int ide_cd_remove(struct device *dev) 3275{ 3276 ide_drive_t *drive = to_ide_device(dev); 3277 struct cdrom_info *info = drive->driver_data; 3278 3279 ide_unregister_subdriver(drive, info->driver); 3280 3281 del_gendisk(info->disk); 3282 3283 ide_cd_put(info); 3284 3285 return 0; 3286} 3287 3288static void ide_cd_release(struct kref *kref) 3289{ 3290 struct cdrom_info *info = to_ide_cd(kref); 3291 struct cdrom_device_info *devinfo = &info->devinfo; 3292 ide_drive_t *drive = info->drive; 3293 struct gendisk *g = info->disk; 3294 3295 kfree(info->buffer); 3296 kfree(info->toc); 3297 kfree(info->changer_info); 3298 if (devinfo->handle == drive && unregister_cdrom(devinfo)) 3299 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom " 3300 "driver.\n", __FUNCTION__, drive->name); 3301 drive->dsc_overlap = 0; 3302 drive->driver_data = NULL; 3303 blk_queue_prep_rq(drive->queue, NULL); 3304 g->private_data = NULL; 3305 put_disk(g); 3306 kfree(info); 3307} 3308 3309static int ide_cd_probe(struct device *); 3310 3311#ifdef CONFIG_PROC_FS 3312static int proc_idecd_read_capacity 3313 (char *page, char **start, off_t off, int count, int *eof, void *data) 3314{ 3315 ide_drive_t *drive = data; 3316 int len; 3317 3318 len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive)); 3319 PROC_IDE_READ_RETURN(page,start,off,count,eof,len); 3320} 3321 3322static ide_proc_entry_t idecd_proc[] = { 3323 { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL }, 3324 { NULL, 0, NULL, NULL } 3325}; 3326#else 3327# define idecd_proc NULL 3328#endif 3329 3330static ide_driver_t ide_cdrom_driver = { 3331 .gen_driver = { 3332 .owner = THIS_MODULE, 3333 .name = "ide-cdrom", 3334 .bus = &ide_bus_type, 3335 .probe = ide_cd_probe, 3336 .remove = ide_cd_remove, 3337 }, 3338 .version = IDECD_VERSION, 3339 .media = ide_cdrom, 3340 .supports_dsc_overlap = 1, 3341 .do_request = ide_do_rw_cdrom, 3342 .end_request = ide_end_request, 3343 .error = __ide_error, 3344 .abort = __ide_abort, 3345 .proc = idecd_proc, 3346}; 3347 3348static int idecd_open(struct inode * inode, struct file * file) 3349{ 3350 struct gendisk *disk = inode->i_bdev->bd_disk; 3351 struct cdrom_info *info; 3352 ide_drive_t *drive; 3353 int rc = -ENOMEM; 3354 3355 if (!(info = ide_cd_get(disk))) 3356 return -ENXIO; 3357 3358 drive = info->drive; 3359 3360 drive->usage++; 3361 3362 if (!info->buffer) 3363 info->buffer = kmalloc(SECTOR_BUFFER_SIZE, 3364 GFP_KERNEL|__GFP_REPEAT); 3365 if (!info->buffer || (rc = cdrom_open(&info->devinfo, inode, file))) 3366 drive->usage--; 3367 3368 if (rc < 0) 3369 ide_cd_put(info); 3370 3371 return rc; 3372} 3373 3374static int idecd_release(struct inode * inode, struct file * file) 3375{ 3376 struct gendisk *disk = inode->i_bdev->bd_disk; 3377 struct cdrom_info *info = ide_cd_g(disk); 3378 ide_drive_t *drive = info->drive; 3379 3380 cdrom_release (&info->devinfo, file); 3381 drive->usage--; 3382 3383 ide_cd_put(info); 3384 3385 return 0; 3386} 3387 3388static int idecd_ioctl (struct inode *inode, struct file *file, 3389 unsigned int cmd, unsigned long arg) 3390{ 3391 struct block_device *bdev = inode->i_bdev; 3392 struct cdrom_info *info = ide_cd_g(bdev->bd_disk); 3393 int err; 3394 3395 err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg); 3396 if (err == -EINVAL) 3397 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg); 3398 3399 return err; 3400} 3401 3402static int idecd_media_changed(struct gendisk *disk) 3403{ 3404 struct cdrom_info *info = ide_cd_g(disk); 3405 return cdrom_media_changed(&info->devinfo); 3406} 3407 3408static int idecd_revalidate_disk(struct gendisk *disk) 3409{ 3410 struct cdrom_info *info = ide_cd_g(disk); 3411 struct request_sense sense; 3412 cdrom_read_toc(info->drive, &sense); 3413 return 0; 3414} 3415 3416static struct block_device_operations idecd_ops = { 3417 .owner = THIS_MODULE, 3418 .open = idecd_open, 3419 .release = idecd_release, 3420 .ioctl = idecd_ioctl, 3421 .media_changed = idecd_media_changed, 3422 .revalidate_disk= idecd_revalidate_disk 3423}; 3424 3425/* options */ 3426static char *ignore = NULL; 3427 3428module_param(ignore, charp, 0400); 3429MODULE_DESCRIPTION("ATAPI CD-ROM Driver"); 3430 3431static int ide_cd_probe(struct device *dev) 3432{ 3433 ide_drive_t *drive = to_ide_device(dev); 3434 struct cdrom_info *info; 3435 struct gendisk *g; 3436 struct request_sense sense; 3437 3438 if (!strstr("ide-cdrom", drive->driver_req)) 3439 goto failed; 3440 if (!drive->present) 3441 goto failed; 3442 if (drive->media != ide_cdrom && drive->media != ide_optical) 3443 goto failed; 3444 /* skip drives that we were told to ignore */ 3445 if (ignore != NULL) { 3446 if (strstr(ignore, drive->name)) { 3447 printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name); 3448 goto failed; 3449 } 3450 } 3451 if (drive->scsi) { 3452 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name); 3453 goto failed; 3454 } 3455 info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL); 3456 if (info == NULL) { 3457 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name); 3458 goto failed; 3459 } 3460 3461 g = alloc_disk(1 << PARTN_BITS); 3462 if (!g) 3463 goto out_free_cd; 3464 3465 ide_init_disk(g, drive); 3466 3467 ide_register_subdriver(drive, &ide_cdrom_driver); 3468 3469 kref_init(&info->kref); 3470 3471 info->drive = drive; 3472 info->driver = &ide_cdrom_driver; 3473 info->disk = g; 3474 3475 g->private_data = &info->driver; 3476 3477 drive->driver_data = info; 3478 3479 g->minors = 1; 3480 snprintf(g->devfs_name, sizeof(g->devfs_name), 3481 "%s/cd", drive->devfs_name); 3482 g->driverfs_dev = &drive->gendev; 3483 g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE; 3484 if (ide_cdrom_setup(drive)) { 3485 struct cdrom_device_info *devinfo = &info->devinfo; 3486 ide_unregister_subdriver(drive, &ide_cdrom_driver); 3487 kfree(info->buffer); 3488 kfree(info->toc); 3489 kfree(info->changer_info); 3490 if (devinfo->handle == drive && unregister_cdrom(devinfo)) 3491 printk (KERN_ERR "%s: ide_cdrom_cleanup failed to unregister device from the cdrom driver.\n", drive->name); 3492 kfree(info); 3493 drive->driver_data = NULL; 3494 goto failed; 3495 } 3496 3497 cdrom_read_toc(drive, &sense); 3498 g->fops = &idecd_ops; 3499 g->flags |= GENHD_FL_REMOVABLE; 3500 add_disk(g); 3501 return 0; 3502 3503out_free_cd: 3504 kfree(info); 3505failed: 3506 return -ENODEV; 3507} 3508 3509static void __exit ide_cdrom_exit(void) 3510{ 3511 driver_unregister(&ide_cdrom_driver.gen_driver); 3512} 3513 3514static int ide_cdrom_init(void) 3515{ 3516 return driver_register(&ide_cdrom_driver.gen_driver); 3517} 3518 3519module_init(ide_cdrom_init); 3520module_exit(ide_cdrom_exit); 3521MODULE_LICENSE("GPL"); 3522