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