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