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