ide-cd.c revision 0eea6458c04a1cbb2e8e5c2cdbef736d882d200c
1/* 2 * ATAPI CD-ROM driver. 3 * 4 * Copyright (C) 1994-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 * Copyright (C) 2005, 2007 Bartlomiej Zolnierkiewicz 8 * 9 * May be copied or modified under the terms of the GNU General Public 10 * License. See linux/COPYING for more information. 11 * 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 * For historical changelog please see: 23 * Documentation/ide/ChangeLog.ide-cd.1994-2004 24 */ 25 26#define IDECD_VERSION "5.00" 27 28#include <linux/module.h> 29#include <linux/types.h> 30#include <linux/kernel.h> 31#include <linux/delay.h> 32#include <linux/timer.h> 33#include <linux/slab.h> 34#include <linux/interrupt.h> 35#include <linux/errno.h> 36#include <linux/cdrom.h> 37#include <linux/ide.h> 38#include <linux/completion.h> 39#include <linux/mutex.h> 40#include <linux/bcd.h> 41 42#include <scsi/scsi.h> /* For SCSI -> ATAPI command conversion */ 43 44#include <asm/irq.h> 45#include <asm/io.h> 46#include <asm/byteorder.h> 47#include <asm/uaccess.h> 48#include <asm/unaligned.h> 49 50#include "ide-cd.h" 51 52static DEFINE_MUTEX(idecd_ref_mutex); 53 54#define to_ide_cd(obj) container_of(obj, struct cdrom_info, kref) 55 56#define ide_cd_g(disk) \ 57 container_of((disk)->private_data, struct cdrom_info, driver) 58 59static struct cdrom_info *ide_cd_get(struct gendisk *disk) 60{ 61 struct cdrom_info *cd = NULL; 62 63 mutex_lock(&idecd_ref_mutex); 64 cd = ide_cd_g(disk); 65 if (cd) 66 kref_get(&cd->kref); 67 mutex_unlock(&idecd_ref_mutex); 68 return cd; 69} 70 71static void ide_cd_release(struct kref *); 72 73static void ide_cd_put(struct cdrom_info *cd) 74{ 75 mutex_lock(&idecd_ref_mutex); 76 kref_put(&cd->kref, ide_cd_release); 77 mutex_unlock(&idecd_ref_mutex); 78} 79 80/**************************************************************************** 81 * Generic packet command support and error handling routines. 82 */ 83 84/* Mark that we've seen a media change, and invalidate our internal 85 buffers. */ 86static void cdrom_saw_media_change (ide_drive_t *drive) 87{ 88 struct cdrom_info *cd = drive->driver_data; 89 90 cd->cd_flags |= IDE_CD_FLAG_MEDIA_CHANGED; 91 cd->cd_flags &= ~IDE_CD_FLAG_TOC_VALID; 92 cd->nsectors_buffered = 0; 93} 94 95static int cdrom_log_sense(ide_drive_t *drive, struct request *rq, 96 struct request_sense *sense) 97{ 98 int log = 0; 99 100 if (!sense || !rq || (rq->cmd_flags & REQ_QUIET)) 101 return 0; 102 103 switch (sense->sense_key) { 104 case NO_SENSE: case RECOVERED_ERROR: 105 break; 106 case NOT_READY: 107 /* 108 * don't care about tray state messages for 109 * e.g. capacity commands or in-progress or 110 * becoming ready 111 */ 112 if (sense->asc == 0x3a || sense->asc == 0x04) 113 break; 114 log = 1; 115 break; 116 case ILLEGAL_REQUEST: 117 /* 118 * don't log START_STOP unit with LoEj set, since 119 * we cannot reliably check if drive can auto-close 120 */ 121 if (rq->cmd[0] == GPCMD_START_STOP_UNIT && sense->asc == 0x24) 122 break; 123 log = 1; 124 break; 125 case UNIT_ATTENTION: 126 /* 127 * Make good and sure we've seen this potential media 128 * change. Some drives (i.e. Creative) fail to present 129 * the correct sense key in the error register. 130 */ 131 cdrom_saw_media_change(drive); 132 break; 133 default: 134 log = 1; 135 break; 136 } 137 return log; 138} 139 140static 141void cdrom_analyze_sense_data(ide_drive_t *drive, 142 struct request *failed_command, 143 struct request_sense *sense) 144{ 145 unsigned long sector; 146 unsigned long bio_sectors; 147 unsigned long valid; 148 struct cdrom_info *info = drive->driver_data; 149 150 if (!cdrom_log_sense(drive, failed_command, sense)) 151 return; 152 153 /* 154 * If a read toc is executed for a CD-R or CD-RW medium where 155 * the first toc has not been recorded yet, it will fail with 156 * 05/24/00 (which is a confusing error) 157 */ 158 if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP) 159 if (sense->sense_key == 0x05 && sense->asc == 0x24) 160 return; 161 162 if (sense->error_code == 0x70) { /* Current Error */ 163 switch(sense->sense_key) { 164 case MEDIUM_ERROR: 165 case VOLUME_OVERFLOW: 166 case ILLEGAL_REQUEST: 167 if (!sense->valid) 168 break; 169 if (failed_command == NULL || 170 !blk_fs_request(failed_command)) 171 break; 172 sector = (sense->information[0] << 24) | 173 (sense->information[1] << 16) | 174 (sense->information[2] << 8) | 175 (sense->information[3]); 176 177 bio_sectors = bio_sectors(failed_command->bio); 178 if (bio_sectors < 4) 179 bio_sectors = 4; 180 if (drive->queue->hardsect_size == 2048) 181 sector <<= 2; /* Device sector size is 2K */ 182 sector &= ~(bio_sectors -1); 183 valid = (sector - failed_command->sector) << 9; 184 185 if (valid < 0) 186 valid = 0; 187 if (sector < get_capacity(info->disk) && 188 drive->probed_capacity - sector < 4 * 75) { 189 set_capacity(info->disk, sector); 190 } 191 } 192 } 193 194 ide_cd_log_error(drive->name, failed_command, sense); 195} 196 197/* 198 * Initialize a ide-cd packet command request 199 */ 200void ide_cd_init_rq(ide_drive_t *drive, struct request *rq) 201{ 202 struct cdrom_info *cd = drive->driver_data; 203 204 ide_init_drive_cmd(rq); 205 rq->cmd_type = REQ_TYPE_ATA_PC; 206 rq->rq_disk = cd->disk; 207} 208 209static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense, 210 struct request *failed_command) 211{ 212 struct cdrom_info *info = drive->driver_data; 213 struct request *rq = &info->request_sense_request; 214 215 if (sense == NULL) 216 sense = &info->sense_data; 217 218 /* stuff the sense request in front of our current request */ 219 ide_cd_init_rq(drive, rq); 220 221 rq->data = sense; 222 rq->cmd[0] = GPCMD_REQUEST_SENSE; 223 rq->cmd[4] = rq->data_len = 18; 224 225 rq->cmd_type = REQ_TYPE_SENSE; 226 227 /* NOTE! Save the failed command in "rq->buffer" */ 228 rq->buffer = (void *) failed_command; 229 230 (void) ide_do_drive_cmd(drive, rq, ide_preempt); 231} 232 233static void cdrom_end_request (ide_drive_t *drive, int uptodate) 234{ 235 struct request *rq = HWGROUP(drive)->rq; 236 int nsectors = rq->hard_cur_sectors; 237 238 if (blk_sense_request(rq) && uptodate) { 239 /* 240 * For REQ_TYPE_SENSE, "rq->buffer" points to the original 241 * failed request 242 */ 243 struct request *failed = (struct request *) rq->buffer; 244 struct cdrom_info *info = drive->driver_data; 245 void *sense = &info->sense_data; 246 unsigned long flags; 247 248 if (failed) { 249 if (failed->sense) { 250 sense = failed->sense; 251 failed->sense_len = rq->sense_len; 252 } 253 cdrom_analyze_sense_data(drive, failed, sense); 254 /* 255 * now end failed request 256 */ 257 if (blk_fs_request(failed)) { 258 if (ide_end_dequeued_request(drive, failed, 0, 259 failed->hard_nr_sectors)) 260 BUG(); 261 } else { 262 spin_lock_irqsave(&ide_lock, flags); 263 if (__blk_end_request(failed, -EIO, 264 failed->data_len)) 265 BUG(); 266 spin_unlock_irqrestore(&ide_lock, flags); 267 } 268 } else 269 cdrom_analyze_sense_data(drive, NULL, sense); 270 } 271 272 if (!rq->current_nr_sectors && blk_fs_request(rq)) 273 uptodate = 1; 274 /* make sure it's fully ended */ 275 if (blk_pc_request(rq)) 276 nsectors = (rq->data_len + 511) >> 9; 277 if (!nsectors) 278 nsectors = 1; 279 280 ide_end_request(drive, uptodate, nsectors); 281} 282 283static void ide_dump_status_no_sense(ide_drive_t *drive, const char *msg, u8 stat) 284{ 285 if (stat & 0x80) 286 return; 287 ide_dump_status(drive, msg, stat); 288} 289 290/* Returns 0 if the request should be continued. 291 Returns 1 if the request was ended. */ 292static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret) 293{ 294 struct request *rq = HWGROUP(drive)->rq; 295 int stat, err, sense_key; 296 297 /* Check for errors. */ 298 stat = HWIF(drive)->INB(IDE_STATUS_REG); 299 if (stat_ret) 300 *stat_ret = stat; 301 302 if (OK_STAT(stat, good_stat, BAD_R_STAT)) 303 return 0; 304 305 /* Get the IDE error register. */ 306 err = HWIF(drive)->INB(IDE_ERROR_REG); 307 sense_key = err >> 4; 308 309 if (rq == NULL) { 310 printk("%s: missing rq in cdrom_decode_status\n", drive->name); 311 return 1; 312 } 313 314 if (blk_sense_request(rq)) { 315 /* We got an error trying to get sense info 316 from the drive (probably while trying 317 to recover from a former error). Just give up. */ 318 319 rq->cmd_flags |= REQ_FAILED; 320 cdrom_end_request(drive, 0); 321 ide_error(drive, "request sense failure", stat); 322 return 1; 323 324 } else if (blk_pc_request(rq) || rq->cmd_type == REQ_TYPE_ATA_PC) { 325 /* All other functions, except for READ. */ 326 327 /* 328 * if we have an error, pass back CHECK_CONDITION as the 329 * scsi status byte 330 */ 331 if (blk_pc_request(rq) && !rq->errors) 332 rq->errors = SAM_STAT_CHECK_CONDITION; 333 334 /* Check for tray open. */ 335 if (sense_key == NOT_READY) { 336 cdrom_saw_media_change (drive); 337 } else if (sense_key == UNIT_ATTENTION) { 338 /* Check for media change. */ 339 cdrom_saw_media_change (drive); 340 /*printk("%s: media changed\n",drive->name);*/ 341 return 0; 342 } else if ((sense_key == ILLEGAL_REQUEST) && 343 (rq->cmd[0] == GPCMD_START_STOP_UNIT)) { 344 /* 345 * Don't print error message for this condition-- 346 * SFF8090i indicates that 5/24/00 is the correct 347 * response to a request to close the tray if the 348 * drive doesn't have that capability. 349 * cdrom_log_sense() knows this! 350 */ 351 } else if (!(rq->cmd_flags & REQ_QUIET)) { 352 /* Otherwise, print an error. */ 353 ide_dump_status(drive, "packet command error", stat); 354 } 355 356 rq->cmd_flags |= REQ_FAILED; 357 358 /* 359 * instead of playing games with moving completions around, 360 * remove failed request completely and end it when the 361 * request sense has completed 362 */ 363 goto end_request; 364 365 } else if (blk_fs_request(rq)) { 366 int do_end_request = 0; 367 368 /* Handle errors from READ and WRITE requests. */ 369 370 if (blk_noretry_request(rq)) 371 do_end_request = 1; 372 373 if (sense_key == NOT_READY) { 374 /* Tray open. */ 375 if (rq_data_dir(rq) == READ) { 376 cdrom_saw_media_change (drive); 377 378 /* Fail the request. */ 379 printk ("%s: tray open\n", drive->name); 380 do_end_request = 1; 381 } else { 382 struct cdrom_info *info = drive->driver_data; 383 384 /* allow the drive 5 seconds to recover, some 385 * devices will return this error while flushing 386 * data from cache */ 387 if (!rq->errors) 388 info->write_timeout = jiffies + ATAPI_WAIT_WRITE_BUSY; 389 rq->errors = 1; 390 if (time_after(jiffies, info->write_timeout)) 391 do_end_request = 1; 392 else { 393 unsigned long flags; 394 395 /* 396 * take a breather relying on the 397 * unplug timer to kick us again 398 */ 399 spin_lock_irqsave(&ide_lock, flags); 400 blk_plug_device(drive->queue); 401 spin_unlock_irqrestore(&ide_lock,flags); 402 return 1; 403 } 404 } 405 } else if (sense_key == UNIT_ATTENTION) { 406 /* Media change. */ 407 cdrom_saw_media_change (drive); 408 409 /* Arrange to retry the request. 410 But be sure to give up if we've retried 411 too many times. */ 412 if (++rq->errors > ERROR_MAX) 413 do_end_request = 1; 414 } else if (sense_key == ILLEGAL_REQUEST || 415 sense_key == DATA_PROTECT) { 416 /* No point in retrying after an illegal 417 request or data protect error.*/ 418 ide_dump_status_no_sense (drive, "command error", stat); 419 do_end_request = 1; 420 } else if (sense_key == MEDIUM_ERROR) { 421 /* No point in re-trying a zillion times on a bad 422 * sector... If we got here the error is not correctable */ 423 ide_dump_status_no_sense (drive, "media error (bad sector)", stat); 424 do_end_request = 1; 425 } else if (sense_key == BLANK_CHECK) { 426 /* Disk appears blank ?? */ 427 ide_dump_status_no_sense (drive, "media error (blank)", stat); 428 do_end_request = 1; 429 } else if ((err & ~ABRT_ERR) != 0) { 430 /* Go to the default handler 431 for other errors. */ 432 ide_error(drive, "cdrom_decode_status", stat); 433 return 1; 434 } else if ((++rq->errors > ERROR_MAX)) { 435 /* We've racked up too many retries. Abort. */ 436 do_end_request = 1; 437 } 438 439 /* End a request through request sense analysis when we have 440 sense data. We need this in order to perform end of media 441 processing */ 442 443 if (do_end_request) 444 goto end_request; 445 446 /* 447 * If we got a CHECK_CONDITION status, 448 * queue a request sense command. 449 */ 450 if (stat & ERR_STAT) 451 cdrom_queue_request_sense(drive, NULL, NULL); 452 } else { 453 blk_dump_rq_flags(rq, "ide-cd: bad rq"); 454 cdrom_end_request(drive, 0); 455 } 456 457 /* Retry, or handle the next request. */ 458 return 1; 459 460end_request: 461 if (stat & ERR_STAT) { 462 unsigned long flags; 463 464 spin_lock_irqsave(&ide_lock, flags); 465 blkdev_dequeue_request(rq); 466 HWGROUP(drive)->rq = NULL; 467 spin_unlock_irqrestore(&ide_lock, flags); 468 469 cdrom_queue_request_sense(drive, rq->sense, rq); 470 } else 471 cdrom_end_request(drive, 0); 472 473 return 1; 474} 475 476static int cdrom_timer_expiry(ide_drive_t *drive) 477{ 478 struct request *rq = HWGROUP(drive)->rq; 479 unsigned long wait = 0; 480 481 /* 482 * Some commands are *slow* and normally take a long time to 483 * complete. Usually we can use the ATAPI "disconnect" to bypass 484 * this, but not all commands/drives support that. Let 485 * ide_timer_expiry keep polling us for these. 486 */ 487 switch (rq->cmd[0]) { 488 case GPCMD_BLANK: 489 case GPCMD_FORMAT_UNIT: 490 case GPCMD_RESERVE_RZONE_TRACK: 491 case GPCMD_CLOSE_TRACK: 492 case GPCMD_FLUSH_CACHE: 493 wait = ATAPI_WAIT_PC; 494 break; 495 default: 496 if (!(rq->cmd_flags & REQ_QUIET)) 497 printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n", rq->cmd[0]); 498 wait = 0; 499 break; 500 } 501 return wait; 502} 503 504/* Set up the device registers for transferring a packet command on DEV, 505 expecting to later transfer XFERLEN bytes. HANDLER is the routine 506 which actually transfers the command to the drive. If this is a 507 drq_interrupt device, this routine will arrange for HANDLER to be 508 called when the interrupt from the drive arrives. Otherwise, HANDLER 509 will be called immediately after the drive is prepared for the transfer. */ 510 511static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive, 512 int xferlen, 513 ide_handler_t *handler) 514{ 515 ide_startstop_t startstop; 516 struct cdrom_info *info = drive->driver_data; 517 ide_hwif_t *hwif = drive->hwif; 518 519 /* Wait for the controller to be idle. */ 520 if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY)) 521 return startstop; 522 523 /* FIXME: for Virtual DMA we must check harder */ 524 if (info->dma) 525 info->dma = !hwif->dma_setup(drive); 526 527 /* Set up the controller registers. */ 528 ide_pktcmd_tf_load(drive, IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL | 529 IDE_TFLAG_NO_SELECT_MASK, xferlen, info->dma); 530 531 if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) { 532 /* waiting for CDB interrupt, not DMA yet. */ 533 if (info->dma) 534 drive->waiting_for_dma = 0; 535 536 /* packet command */ 537 ide_execute_command(drive, WIN_PACKETCMD, handler, ATAPI_WAIT_PC, cdrom_timer_expiry); 538 return ide_started; 539 } else { 540 unsigned long flags; 541 542 /* packet command */ 543 spin_lock_irqsave(&ide_lock, flags); 544 hwif->OUTBSYNC(drive, WIN_PACKETCMD, IDE_COMMAND_REG); 545 ndelay(400); 546 spin_unlock_irqrestore(&ide_lock, flags); 547 548 return (*handler) (drive); 549 } 550} 551 552/* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN. 553 The device registers must have already been prepared 554 by cdrom_start_packet_command. 555 HANDLER is the interrupt handler to call when the command completes 556 or there's data ready. */ 557#define ATAPI_MIN_CDB_BYTES 12 558static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive, 559 struct request *rq, 560 ide_handler_t *handler) 561{ 562 ide_hwif_t *hwif = drive->hwif; 563 int cmd_len; 564 struct cdrom_info *info = drive->driver_data; 565 ide_startstop_t startstop; 566 567 if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) { 568 /* Here we should have been called after receiving an interrupt 569 from the device. DRQ should how be set. */ 570 571 /* Check for errors. */ 572 if (cdrom_decode_status(drive, DRQ_STAT, NULL)) 573 return ide_stopped; 574 575 /* Ok, next interrupt will be DMA interrupt. */ 576 if (info->dma) 577 drive->waiting_for_dma = 1; 578 } else { 579 /* Otherwise, we must wait for DRQ to get set. */ 580 if (ide_wait_stat(&startstop, drive, DRQ_STAT, 581 BUSY_STAT, WAIT_READY)) 582 return startstop; 583 } 584 585 /* Arm the interrupt handler. */ 586 ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry); 587 588 /* ATAPI commands get padded out to 12 bytes minimum */ 589 cmd_len = COMMAND_SIZE(rq->cmd[0]); 590 if (cmd_len < ATAPI_MIN_CDB_BYTES) 591 cmd_len = ATAPI_MIN_CDB_BYTES; 592 593 /* Send the command to the device. */ 594 HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len); 595 596 /* Start the DMA if need be */ 597 if (info->dma) 598 hwif->dma_start(drive); 599 600 return ide_started; 601} 602 603/**************************************************************************** 604 * Block read functions. 605 */ 606 607static void ide_cd_pad_transfer(ide_drive_t *drive, xfer_func_t *xf, int len) 608{ 609 while (len > 0) { 610 int dum = 0; 611 xf(drive, &dum, sizeof(dum)); 612 len -= sizeof(dum); 613 } 614} 615 616static void ide_cd_drain_data(ide_drive_t *drive, int nsects) 617{ 618 while (nsects > 0) { 619 static char dum[SECTOR_SIZE]; 620 621 drive->hwif->atapi_input_bytes(drive, dum, sizeof(dum)); 622 nsects--; 623 } 624} 625 626/* 627 * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector 628 * buffer. Once the first sector is added, any subsequent sectors are 629 * assumed to be continuous (until the buffer is cleared). For the first 630 * sector added, SECTOR is its sector number. (SECTOR is then ignored until 631 * the buffer is cleared.) 632 */ 633static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector, 634 int sectors_to_transfer) 635{ 636 struct cdrom_info *info = drive->driver_data; 637 638 /* Number of sectors to read into the buffer. */ 639 int sectors_to_buffer = min_t(int, sectors_to_transfer, 640 (SECTOR_BUFFER_SIZE >> SECTOR_BITS) - 641 info->nsectors_buffered); 642 643 char *dest; 644 645 /* If we couldn't get a buffer, don't try to buffer anything... */ 646 if (info->buffer == NULL) 647 sectors_to_buffer = 0; 648 649 /* If this is the first sector in the buffer, remember its number. */ 650 if (info->nsectors_buffered == 0) 651 info->sector_buffered = sector; 652 653 /* Read the data into the buffer. */ 654 dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE; 655 while (sectors_to_buffer > 0) { 656 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE); 657 --sectors_to_buffer; 658 --sectors_to_transfer; 659 ++info->nsectors_buffered; 660 dest += SECTOR_SIZE; 661 } 662 663 /* Throw away any remaining data. */ 664 ide_cd_drain_data(drive, sectors_to_transfer); 665} 666 667/* 668 * Check the contents of the interrupt reason register from the cdrom 669 * and attempt to recover if there are problems. Returns 0 if everything's 670 * ok; nonzero if the request has been terminated. 671 */ 672static 673int ide_cd_check_ireason(ide_drive_t *drive, int len, int ireason, int rw) 674{ 675 /* 676 * ireason == 0: the drive wants to receive data from us 677 * ireason == 2: the drive is expecting to transfer data to us 678 */ 679 if (ireason == (!rw << 1)) 680 return 0; 681 else if (ireason == (rw << 1)) { 682 ide_hwif_t *hwif = drive->hwif; 683 xfer_func_t *xf; 684 685 /* Whoops... */ 686 printk(KERN_ERR "%s: %s: wrong transfer direction!\n", 687 drive->name, __FUNCTION__); 688 689 xf = rw ? hwif->atapi_output_bytes : hwif->atapi_input_bytes; 690 ide_cd_pad_transfer(drive, xf, len); 691 } else if (rw == 0 && ireason == 1) { 692 /* Some drives (ASUS) seem to tell us that status 693 * info is available. just get it and ignore. 694 */ 695 (void) HWIF(drive)->INB(IDE_STATUS_REG); 696 return 0; 697 } else { 698 /* Drive wants a command packet, or invalid ireason... */ 699 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n", 700 drive->name, __FUNCTION__, ireason); 701 } 702 703 cdrom_end_request(drive, 0); 704 return -1; 705} 706 707/* 708 * Assume that the drive will always provide data in multiples of at least 709 * SECTOR_SIZE, as it gets hairy to keep track of the transfers otherwise. 710 */ 711static int ide_cd_check_transfer_size(ide_drive_t *drive, int len) 712{ 713 struct cdrom_info *cd = drive->driver_data; 714 715 if ((len % SECTOR_SIZE) == 0) 716 return 0; 717 718 printk(KERN_ERR "%s: %s: Bad transfer size %d\n", 719 drive->name, __FUNCTION__, len); 720 721 if (cd->cd_flags & IDE_CD_FLAG_LIMIT_NFRAMES) 722 printk(KERN_ERR " This drive is not supported by " 723 "this version of the driver\n"); 724 else { 725 printk(KERN_ERR " Trying to limit transfer sizes\n"); 726 cd->cd_flags |= IDE_CD_FLAG_LIMIT_NFRAMES; 727 } 728 729 return 1; 730} 731 732/* 733 * Try to satisfy some of the current read request from our cached data. 734 * Returns nonzero if the request has been completed, zero otherwise. 735 */ 736static int cdrom_read_from_buffer (ide_drive_t *drive) 737{ 738 struct cdrom_info *info = drive->driver_data; 739 struct request *rq = HWGROUP(drive)->rq; 740 unsigned short sectors_per_frame; 741 742 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS; 743 744 /* Can't do anything if there's no buffer. */ 745 if (info->buffer == NULL) return 0; 746 747 /* Loop while this request needs data and the next block is present 748 in our cache. */ 749 while (rq->nr_sectors > 0 && 750 rq->sector >= info->sector_buffered && 751 rq->sector < info->sector_buffered + info->nsectors_buffered) { 752 if (rq->current_nr_sectors == 0) 753 cdrom_end_request(drive, 1); 754 755 memcpy (rq->buffer, 756 info->buffer + 757 (rq->sector - info->sector_buffered) * SECTOR_SIZE, 758 SECTOR_SIZE); 759 rq->buffer += SECTOR_SIZE; 760 --rq->current_nr_sectors; 761 --rq->nr_sectors; 762 ++rq->sector; 763 } 764 765 /* If we've satisfied the current request, 766 terminate it successfully. */ 767 if (rq->nr_sectors == 0) { 768 cdrom_end_request(drive, 1); 769 return -1; 770 } 771 772 /* Move on to the next buffer if needed. */ 773 if (rq->current_nr_sectors == 0) 774 cdrom_end_request(drive, 1); 775 776 /* If this condition does not hold, then the kluge i use to 777 represent the number of sectors to skip at the start of a transfer 778 will fail. I think that this will never happen, but let's be 779 paranoid and check. */ 780 if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) && 781 (rq->sector & (sectors_per_frame - 1))) { 782 printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n", 783 drive->name, (long)rq->sector); 784 cdrom_end_request(drive, 0); 785 return -1; 786 } 787 788 return 0; 789} 790 791static ide_startstop_t cdrom_newpc_intr(ide_drive_t *); 792 793/* 794 * Routine to send a read/write packet command to the drive. 795 * This is usually called directly from cdrom_start_{read,write}(). 796 * However, for drq_interrupt devices, it is called from an interrupt 797 * when the drive is ready to accept the command. 798 */ 799static ide_startstop_t cdrom_start_rw_cont(ide_drive_t *drive) 800{ 801 struct request *rq = HWGROUP(drive)->rq; 802 803 if (rq_data_dir(rq) == READ) { 804 unsigned short sectors_per_frame = 805 queue_hardsect_size(drive->queue) >> SECTOR_BITS; 806 int nskip = rq->sector & (sectors_per_frame - 1); 807 808 /* 809 * If the requested sector doesn't start on a frame boundary, 810 * we must adjust the start of the transfer so that it does, 811 * and remember to skip the first few sectors. 812 * 813 * If the rq->current_nr_sectors field is larger than the size 814 * of the buffer, it will mean that we're to skip a number of 815 * sectors equal to the amount by which rq->current_nr_sectors 816 * is larger than the buffer size. 817 */ 818 if (nskip > 0) { 819 /* Sanity check... */ 820 if (rq->current_nr_sectors != 821 bio_cur_sectors(rq->bio)) { 822 printk(KERN_ERR "%s: %s: buffer botch (%u)\n", 823 drive->name, __FUNCTION__, 824 rq->current_nr_sectors); 825 cdrom_end_request(drive, 0); 826 return ide_stopped; 827 } 828 rq->current_nr_sectors += nskip; 829 } 830 } 831#if 0 832 else 833 /* the immediate bit */ 834 rq->cmd[1] = 1 << 3; 835#endif 836 /* Set up the command */ 837 rq->timeout = ATAPI_WAIT_PC; 838 839 /* Send the command to the drive and return. */ 840 return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr); 841} 842 843#define IDECD_SEEK_THRESHOLD (1000) /* 1000 blocks */ 844#define IDECD_SEEK_TIMER (5 * WAIT_MIN_SLEEP) /* 100 ms */ 845#define IDECD_SEEK_TIMEOUT (2 * WAIT_CMD) /* 20 sec */ 846 847static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive) 848{ 849 struct cdrom_info *info = drive->driver_data; 850 int stat; 851 static int retry = 10; 852 853 if (cdrom_decode_status(drive, 0, &stat)) 854 return ide_stopped; 855 856 info->cd_flags |= IDE_CD_FLAG_SEEKING; 857 858 if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) { 859 if (--retry == 0) { 860 /* 861 * this condition is far too common, to bother 862 * users about it 863 */ 864 /* printk("%s: disabled DSC seek overlap\n", drive->name);*/ 865 drive->dsc_overlap = 0; 866 } 867 } 868 return ide_stopped; 869} 870 871static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive) 872{ 873 struct request *rq = HWGROUP(drive)->rq; 874 sector_t frame = rq->sector; 875 876 sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS); 877 878 memset(rq->cmd, 0, sizeof(rq->cmd)); 879 rq->cmd[0] = GPCMD_SEEK; 880 put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]); 881 882 rq->timeout = ATAPI_WAIT_PC; 883 return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr); 884} 885 886static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block) 887{ 888 struct cdrom_info *info = drive->driver_data; 889 890 info->dma = 0; 891 info->start_seek = jiffies; 892 return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation); 893} 894 895/* Fix up a possibly partially-processed request so that we can 896 start it over entirely, or even put it back on the request queue. */ 897static void restore_request (struct request *rq) 898{ 899 if (rq->buffer != bio_data(rq->bio)) { 900 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE; 901 902 rq->buffer = bio_data(rq->bio); 903 rq->nr_sectors += n; 904 rq->sector -= n; 905 } 906 rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio); 907 rq->hard_nr_sectors = rq->nr_sectors; 908 rq->hard_sector = rq->sector; 909 rq->q->prep_rq_fn(rq->q, rq); 910} 911 912/**************************************************************************** 913 * Execute all other packet commands. 914 */ 915 916static void ide_cd_request_sense_fixup(struct request *rq) 917{ 918 /* 919 * Some of the trailing request sense fields are optional, 920 * and some drives don't send them. Sigh. 921 */ 922 if (rq->cmd[0] == GPCMD_REQUEST_SENSE && 923 rq->data_len > 0 && rq->data_len <= 5) 924 while (rq->data_len > 0) { 925 *(u8 *)rq->data++ = 0; 926 --rq->data_len; 927 } 928} 929 930int ide_cd_queue_pc(ide_drive_t *drive, struct request *rq) 931{ 932 struct request_sense sense; 933 int retries = 10; 934 unsigned int flags = rq->cmd_flags; 935 936 if (rq->sense == NULL) 937 rq->sense = &sense; 938 939 /* Start of retry loop. */ 940 do { 941 int error; 942 unsigned long time = jiffies; 943 rq->cmd_flags = flags; 944 945 error = ide_do_drive_cmd(drive, rq, ide_wait); 946 time = jiffies - time; 947 948 /* FIXME: we should probably abort/retry or something 949 * in case of failure */ 950 if (rq->cmd_flags & REQ_FAILED) { 951 /* The request failed. Retry if it was due to a unit 952 attention status 953 (usually means media was changed). */ 954 struct request_sense *reqbuf = rq->sense; 955 956 if (reqbuf->sense_key == UNIT_ATTENTION) 957 cdrom_saw_media_change(drive); 958 else if (reqbuf->sense_key == NOT_READY && 959 reqbuf->asc == 4 && reqbuf->ascq != 4) { 960 /* The drive is in the process of loading 961 a disk. Retry, but wait a little to give 962 the drive time to complete the load. */ 963 ssleep(2); 964 } else { 965 /* Otherwise, don't retry. */ 966 retries = 0; 967 } 968 --retries; 969 } 970 971 /* End of retry loop. */ 972 } while ((rq->cmd_flags & REQ_FAILED) && retries >= 0); 973 974 /* Return an error if the command failed. */ 975 return (rq->cmd_flags & REQ_FAILED) ? -EIO : 0; 976} 977 978/* 979 * Called from blk_end_request_callback() after the data of the request 980 * is completed and before the request is completed. 981 * By returning value '1', blk_end_request_callback() returns immediately 982 * without completing the request. 983 */ 984static int cdrom_newpc_intr_dummy_cb(struct request *rq) 985{ 986 return 1; 987} 988 989static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive) 990{ 991 struct cdrom_info *info = drive->driver_data; 992 struct request *rq = HWGROUP(drive)->rq; 993 xfer_func_t *xferfunc; 994 ide_expiry_t *expiry = NULL; 995 int dma_error = 0, dma, stat, ireason, len, thislen, uptodate = 0; 996 int write = (rq_data_dir(rq) == WRITE) ? 1 : 0; 997 unsigned int timeout; 998 u8 lowcyl, highcyl; 999 1000 /* Check for errors. */ 1001 dma = info->dma; 1002 if (dma) { 1003 info->dma = 0; 1004 dma_error = HWIF(drive)->ide_dma_end(drive); 1005 if (dma_error) { 1006 printk(KERN_ERR "%s: DMA %s error\n", drive->name, 1007 write ? "write" : "read"); 1008 ide_dma_off(drive); 1009 } 1010 } 1011 1012 if (cdrom_decode_status(drive, 0, &stat)) 1013 return ide_stopped; 1014 1015 /* 1016 * using dma, transfer is complete now 1017 */ 1018 if (dma) { 1019 if (dma_error) 1020 return ide_error(drive, "dma error", stat); 1021 if (blk_fs_request(rq)) { 1022 ide_end_request(drive, 1, rq->nr_sectors); 1023 return ide_stopped; 1024 } 1025 goto end_request; 1026 } 1027 1028 /* 1029 * ok we fall to pio :/ 1030 */ 1031 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3; 1032 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG); 1033 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG); 1034 1035 len = lowcyl + (256 * highcyl); 1036 1037 thislen = blk_fs_request(rq) ? len : rq->data_len; 1038 if (thislen > len) 1039 thislen = len; 1040 1041 /* 1042 * If DRQ is clear, the command has completed. 1043 */ 1044 if ((stat & DRQ_STAT) == 0) { 1045 if (blk_fs_request(rq)) { 1046 /* 1047 * If we're not done reading/writing, complain. 1048 * Otherwise, complete the command normally. 1049 */ 1050 uptodate = 1; 1051 if (rq->current_nr_sectors > 0) { 1052 printk(KERN_ERR "%s: %s: data underrun " 1053 "(%d blocks)\n", 1054 drive->name, __FUNCTION__, 1055 rq->current_nr_sectors); 1056 if (!write) 1057 rq->cmd_flags |= REQ_FAILED; 1058 uptodate = 0; 1059 } 1060 cdrom_end_request(drive, uptodate); 1061 return ide_stopped; 1062 } else if (!blk_pc_request(rq)) { 1063 ide_cd_request_sense_fixup(rq); 1064 /* Complain if we still have data left to transfer. */ 1065 uptodate = rq->data_len ? 0 : 1; 1066 } 1067 goto end_request; 1068 } 1069 1070 /* 1071 * check which way to transfer data 1072 */ 1073 if (blk_fs_request(rq) || blk_pc_request(rq)) { 1074 if (ide_cd_check_ireason(drive, len, ireason, write)) 1075 return ide_stopped; 1076 1077 if (blk_fs_request(rq) && write == 0) { 1078 int nskip; 1079 1080 if (ide_cd_check_transfer_size(drive, len)) { 1081 cdrom_end_request(drive, 0); 1082 return ide_stopped; 1083 } 1084 1085 /* 1086 * First, figure out if we need to bit-bucket 1087 * any of the leading sectors. 1088 */ 1089 nskip = min_t(int, rq->current_nr_sectors 1090 - bio_cur_sectors(rq->bio), 1091 thislen >> 9); 1092 if (nskip > 0) { 1093 ide_cd_drain_data(drive, nskip); 1094 rq->current_nr_sectors -= nskip; 1095 thislen -= (nskip << 9); 1096 } 1097 } 1098 } 1099 1100 if (ireason == 0) { 1101 write = 1; 1102 xferfunc = HWIF(drive)->atapi_output_bytes; 1103 } else if (ireason == 2 || (ireason == 1 && 1104 (blk_fs_request(rq) || blk_pc_request(rq)))) { 1105 write = 0; 1106 xferfunc = HWIF(drive)->atapi_input_bytes; 1107 } else { 1108 printk(KERN_ERR "%s: %s: The drive " 1109 "appears confused (ireason = 0x%02x). " 1110 "Trying to recover by ending request.\n", 1111 drive->name, __FUNCTION__, ireason); 1112 goto end_request; 1113 } 1114 1115 /* 1116 * transfer data 1117 */ 1118 while (thislen > 0) { 1119 u8 *ptr = blk_fs_request(rq) ? NULL : rq->data; 1120 int blen = rq->data_len; 1121 1122 /* 1123 * bio backed? 1124 */ 1125 if (rq->bio) { 1126 if (blk_fs_request(rq)) { 1127 ptr = rq->buffer; 1128 blen = rq->current_nr_sectors << 9; 1129 } else { 1130 ptr = bio_data(rq->bio); 1131 blen = bio_iovec(rq->bio)->bv_len; 1132 } 1133 } 1134 1135 if (!ptr) { 1136 if (blk_fs_request(rq) && !write) 1137 /* 1138 * If the buffers are full, cache the rest 1139 * of the data in our internal buffer. 1140 */ 1141 cdrom_buffer_sectors(drive, rq->sector, 1142 thislen >> 9); 1143 else { 1144 printk(KERN_ERR "%s: confused, missing data\n", 1145 drive->name); 1146 blk_dump_rq_flags(rq, rq_data_dir(rq) 1147 ? "cdrom_newpc_intr, write" 1148 : "cdrom_newpc_intr, read"); 1149 } 1150 break; 1151 } 1152 1153 if (blen > thislen) 1154 blen = thislen; 1155 1156 xferfunc(drive, ptr, blen); 1157 1158 thislen -= blen; 1159 len -= blen; 1160 1161 if (blk_fs_request(rq)) { 1162 rq->buffer += blen; 1163 rq->nr_sectors -= (blen >> 9); 1164 rq->current_nr_sectors -= (blen >> 9); 1165 rq->sector += (blen >> 9); 1166 1167 if (rq->current_nr_sectors == 0 && rq->nr_sectors) 1168 cdrom_end_request(drive, 1); 1169 } else { 1170 rq->data_len -= blen; 1171 1172 /* 1173 * The request can't be completed until DRQ is cleared. 1174 * So complete the data, but don't complete the request 1175 * using the dummy function for the callback feature 1176 * of blk_end_request_callback(). 1177 */ 1178 if (rq->bio) 1179 blk_end_request_callback(rq, 0, blen, 1180 cdrom_newpc_intr_dummy_cb); 1181 else 1182 rq->data += blen; 1183 } 1184 } 1185 1186 if (write && blk_sense_request(rq)) 1187 rq->sense_len += thislen; 1188 1189 /* 1190 * pad, if necessary 1191 */ 1192 if (!blk_fs_request(rq) && len > 0) 1193 ide_cd_pad_transfer(drive, xferfunc, len); 1194 1195 if (blk_pc_request(rq)) { 1196 timeout = rq->timeout; 1197 } else { 1198 timeout = ATAPI_WAIT_PC; 1199 if (!blk_fs_request(rq)) 1200 expiry = cdrom_timer_expiry; 1201 } 1202 1203 ide_set_handler(drive, cdrom_newpc_intr, timeout, expiry); 1204 return ide_started; 1205 1206end_request: 1207 if (blk_pc_request(rq)) { 1208 unsigned long flags; 1209 1210 spin_lock_irqsave(&ide_lock, flags); 1211 if (__blk_end_request(rq, 0, rq->data_len)) 1212 BUG(); 1213 HWGROUP(drive)->rq = NULL; 1214 spin_unlock_irqrestore(&ide_lock, flags); 1215 } else { 1216 if (!uptodate) 1217 rq->cmd_flags |= REQ_FAILED; 1218 cdrom_end_request(drive, uptodate); 1219 } 1220 return ide_stopped; 1221} 1222 1223static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq) 1224{ 1225 struct cdrom_info *cd = drive->driver_data; 1226 int write = rq_data_dir(rq) == WRITE; 1227 unsigned short sectors_per_frame = 1228 queue_hardsect_size(drive->queue) >> SECTOR_BITS; 1229 1230 if (write) { 1231 /* 1232 * disk has become write protected 1233 */ 1234 if (cd->disk->policy) { 1235 cdrom_end_request(drive, 0); 1236 return ide_stopped; 1237 } 1238 } else { 1239 /* 1240 * We may be retrying this request after an error. Fix up any 1241 * weirdness which might be present in the request packet. 1242 */ 1243 restore_request(rq); 1244 1245 /* Satisfy whatever we can of this request from our cache. */ 1246 if (cdrom_read_from_buffer(drive)) 1247 return ide_stopped; 1248 } 1249 1250 /* 1251 * use DMA, if possible / writes *must* be hardware frame aligned 1252 */ 1253 if ((rq->nr_sectors & (sectors_per_frame - 1)) || 1254 (rq->sector & (sectors_per_frame - 1))) { 1255 if (write) { 1256 cdrom_end_request(drive, 0); 1257 return ide_stopped; 1258 } 1259 cd->dma = 0; 1260 } else 1261 cd->dma = drive->using_dma; 1262 1263 /* Clear the local sector buffer. */ 1264 cd->nsectors_buffered = 0; 1265 1266 if (write) 1267 cd->devinfo.media_written = 1; 1268 1269 /* Start sending the read/write request to the drive. */ 1270 return cdrom_start_packet_command(drive, 32768, cdrom_start_rw_cont); 1271} 1272 1273static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive) 1274{ 1275 struct request *rq = HWGROUP(drive)->rq; 1276 1277 if (!rq->timeout) 1278 rq->timeout = ATAPI_WAIT_PC; 1279 1280 return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr); 1281} 1282 1283static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq) 1284{ 1285 struct cdrom_info *info = drive->driver_data; 1286 1287 if (blk_pc_request(rq)) 1288 rq->cmd_flags |= REQ_QUIET; 1289 else 1290 rq->cmd_flags &= ~REQ_FAILED; 1291 1292 info->dma = 0; 1293 1294 /* 1295 * sg request 1296 */ 1297 if (rq->bio) { 1298 int mask = drive->queue->dma_alignment; 1299 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio)); 1300 1301 info->dma = drive->using_dma; 1302 1303 /* 1304 * check if dma is safe 1305 * 1306 * NOTE! The "len" and "addr" checks should possibly have 1307 * separate masks. 1308 */ 1309 if ((rq->data_len & 15) || (addr & mask)) 1310 info->dma = 0; 1311 } 1312 1313 /* Start sending the command to the drive. */ 1314 return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont); 1315} 1316 1317/**************************************************************************** 1318 * cdrom driver request routine. 1319 */ 1320static ide_startstop_t 1321ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block) 1322{ 1323 ide_startstop_t action; 1324 struct cdrom_info *info = drive->driver_data; 1325 1326 if (blk_fs_request(rq)) { 1327 if (info->cd_flags & IDE_CD_FLAG_SEEKING) { 1328 unsigned long elapsed = jiffies - info->start_seek; 1329 int stat = HWIF(drive)->INB(IDE_STATUS_REG); 1330 1331 if ((stat & SEEK_STAT) != SEEK_STAT) { 1332 if (elapsed < IDECD_SEEK_TIMEOUT) { 1333 ide_stall_queue(drive, IDECD_SEEK_TIMER); 1334 return ide_stopped; 1335 } 1336 printk (KERN_ERR "%s: DSC timeout\n", drive->name); 1337 } 1338 info->cd_flags &= ~IDE_CD_FLAG_SEEKING; 1339 } 1340 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) { 1341 action = cdrom_start_seek(drive, block); 1342 } else 1343 action = cdrom_start_rw(drive, rq); 1344 info->last_block = block; 1345 return action; 1346 } else if (blk_sense_request(rq) || blk_pc_request(rq) || 1347 rq->cmd_type == REQ_TYPE_ATA_PC) { 1348 return cdrom_do_block_pc(drive, rq); 1349 } else if (blk_special_request(rq)) { 1350 /* 1351 * right now this can only be a reset... 1352 */ 1353 cdrom_end_request(drive, 1); 1354 return ide_stopped; 1355 } 1356 1357 blk_dump_rq_flags(rq, "ide-cd bad flags"); 1358 cdrom_end_request(drive, 0); 1359 return ide_stopped; 1360} 1361 1362 1363 1364/**************************************************************************** 1365 * Ioctl handling. 1366 * 1367 * Routines which queue packet commands take as a final argument a pointer 1368 * to a request_sense struct. If execution of the command results 1369 * in an error with a CHECK CONDITION status, this structure will be filled 1370 * with the results of the subsequent request sense command. The pointer 1371 * can also be NULL, in which case no sense information is returned. 1372 */ 1373 1374static 1375void msf_from_bcd (struct atapi_msf *msf) 1376{ 1377 msf->minute = BCD2BIN(msf->minute); 1378 msf->second = BCD2BIN(msf->second); 1379 msf->frame = BCD2BIN(msf->frame); 1380} 1381 1382int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense) 1383{ 1384 struct request req; 1385 struct cdrom_info *info = drive->driver_data; 1386 struct cdrom_device_info *cdi = &info->devinfo; 1387 1388 ide_cd_init_rq(drive, &req); 1389 1390 req.sense = sense; 1391 req.cmd[0] = GPCMD_TEST_UNIT_READY; 1392 req.cmd_flags |= REQ_QUIET; 1393 1394 /* 1395 * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to 1396 * switch CDs instead of supporting the LOAD_UNLOAD opcode. 1397 */ 1398 req.cmd[7] = cdi->sanyo_slot % 3; 1399 1400 return ide_cd_queue_pc(drive, &req); 1401} 1402 1403static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity, 1404 unsigned long *sectors_per_frame, 1405 struct request_sense *sense) 1406{ 1407 struct { 1408 __u32 lba; 1409 __u32 blocklen; 1410 } capbuf; 1411 1412 int stat; 1413 struct request req; 1414 1415 ide_cd_init_rq(drive, &req); 1416 1417 req.sense = sense; 1418 req.cmd[0] = GPCMD_READ_CDVD_CAPACITY; 1419 req.data = (char *)&capbuf; 1420 req.data_len = sizeof(capbuf); 1421 req.cmd_flags |= REQ_QUIET; 1422 1423 stat = ide_cd_queue_pc(drive, &req); 1424 if (stat == 0) { 1425 *capacity = 1 + be32_to_cpu(capbuf.lba); 1426 *sectors_per_frame = 1427 be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS; 1428 } 1429 1430 return stat; 1431} 1432 1433static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag, 1434 int format, char *buf, int buflen, 1435 struct request_sense *sense) 1436{ 1437 struct request req; 1438 1439 ide_cd_init_rq(drive, &req); 1440 1441 req.sense = sense; 1442 req.data = buf; 1443 req.data_len = buflen; 1444 req.cmd_flags |= REQ_QUIET; 1445 req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP; 1446 req.cmd[6] = trackno; 1447 req.cmd[7] = (buflen >> 8); 1448 req.cmd[8] = (buflen & 0xff); 1449 req.cmd[9] = (format << 6); 1450 1451 if (msf_flag) 1452 req.cmd[1] = 2; 1453 1454 return ide_cd_queue_pc(drive, &req); 1455} 1456 1457/* Try to read the entire TOC for the disk into our internal buffer. */ 1458int ide_cd_read_toc(ide_drive_t *drive, struct request_sense *sense) 1459{ 1460 int stat, ntracks, i; 1461 struct cdrom_info *info = drive->driver_data; 1462 struct cdrom_device_info *cdi = &info->devinfo; 1463 struct atapi_toc *toc = info->toc; 1464 struct { 1465 struct atapi_toc_header hdr; 1466 struct atapi_toc_entry ent; 1467 } ms_tmp; 1468 long last_written; 1469 unsigned long sectors_per_frame = SECTORS_PER_FRAME; 1470 1471 if (toc == NULL) { 1472 /* Try to allocate space. */ 1473 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL); 1474 if (toc == NULL) { 1475 printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name); 1476 return -ENOMEM; 1477 } 1478 info->toc = toc; 1479 } 1480 1481 /* Check to see if the existing data is still valid. 1482 If it is, just return. */ 1483 (void) cdrom_check_status(drive, sense); 1484 1485 if (info->cd_flags & IDE_CD_FLAG_TOC_VALID) 1486 return 0; 1487 1488 /* Try to get the total cdrom capacity and sector size. */ 1489 stat = cdrom_read_capacity(drive, &toc->capacity, §ors_per_frame, 1490 sense); 1491 if (stat) 1492 toc->capacity = 0x1fffff; 1493 1494 set_capacity(info->disk, toc->capacity * sectors_per_frame); 1495 /* Save a private copy of te TOC capacity for error handling */ 1496 drive->probed_capacity = toc->capacity * sectors_per_frame; 1497 1498 blk_queue_hardsect_size(drive->queue, 1499 sectors_per_frame << SECTOR_BITS); 1500 1501 /* First read just the header, so we know how long the TOC is. */ 1502 stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr, 1503 sizeof(struct atapi_toc_header), sense); 1504 if (stat) 1505 return stat; 1506 1507 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) { 1508 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track); 1509 toc->hdr.last_track = BCD2BIN(toc->hdr.last_track); 1510 } 1511 1512 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1; 1513 if (ntracks <= 0) 1514 return -EIO; 1515 if (ntracks > MAX_TRACKS) 1516 ntracks = MAX_TRACKS; 1517 1518 /* Now read the whole schmeer. */ 1519 stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0, 1520 (char *)&toc->hdr, 1521 sizeof(struct atapi_toc_header) + 1522 (ntracks + 1) * 1523 sizeof(struct atapi_toc_entry), sense); 1524 1525 if (stat && toc->hdr.first_track > 1) { 1526 /* Cds with CDI tracks only don't have any TOC entries, 1527 despite of this the returned values are 1528 first_track == last_track = number of CDI tracks + 1, 1529 so that this case is indistinguishable from the same 1530 layout plus an additional audio track. 1531 If we get an error for the regular case, we assume 1532 a CDI without additional audio tracks. In this case 1533 the readable TOC is empty (CDI tracks are not included) 1534 and only holds the Leadout entry. Heiko Eißfeldt */ 1535 ntracks = 0; 1536 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0, 1537 (char *)&toc->hdr, 1538 sizeof(struct atapi_toc_header) + 1539 (ntracks + 1) * 1540 sizeof(struct atapi_toc_entry), 1541 sense); 1542 if (stat) 1543 return stat; 1544 1545 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) { 1546 toc->hdr.first_track = (u8)BIN2BCD(CDROM_LEADOUT); 1547 toc->hdr.last_track = (u8)BIN2BCD(CDROM_LEADOUT); 1548 } else { 1549 toc->hdr.first_track = CDROM_LEADOUT; 1550 toc->hdr.last_track = CDROM_LEADOUT; 1551 } 1552 } 1553 1554 if (stat) 1555 return stat; 1556 1557 toc->hdr.toc_length = ntohs (toc->hdr.toc_length); 1558 1559 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) { 1560 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track); 1561 toc->hdr.last_track = BCD2BIN(toc->hdr.last_track); 1562 } 1563 1564 for (i = 0; i <= ntracks; i++) { 1565 if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) { 1566 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) 1567 toc->ent[i].track = BCD2BIN(toc->ent[i].track); 1568 msf_from_bcd(&toc->ent[i].addr.msf); 1569 } 1570 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute, 1571 toc->ent[i].addr.msf.second, 1572 toc->ent[i].addr.msf.frame); 1573 } 1574 1575 /* Read the multisession information. */ 1576 if (toc->hdr.first_track != CDROM_LEADOUT) { 1577 /* Read the multisession information. */ 1578 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp, 1579 sizeof(ms_tmp), sense); 1580 if (stat) 1581 return stat; 1582 1583 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba); 1584 } else { 1585 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT; 1586 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */ 1587 } 1588 1589 if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) { 1590 /* Re-read multisession information using MSF format */ 1591 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp, 1592 sizeof(ms_tmp), sense); 1593 if (stat) 1594 return stat; 1595 1596 msf_from_bcd (&ms_tmp.ent.addr.msf); 1597 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute, 1598 ms_tmp.ent.addr.msf.second, 1599 ms_tmp.ent.addr.msf.frame); 1600 } 1601 1602 toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track); 1603 1604 /* Now try to get the total cdrom capacity. */ 1605 stat = cdrom_get_last_written(cdi, &last_written); 1606 if (!stat && (last_written > toc->capacity)) { 1607 toc->capacity = last_written; 1608 set_capacity(info->disk, toc->capacity * sectors_per_frame); 1609 drive->probed_capacity = toc->capacity * sectors_per_frame; 1610 } 1611 1612 /* Remember that we've read this stuff. */ 1613 info->cd_flags |= IDE_CD_FLAG_TOC_VALID; 1614 1615 return 0; 1616} 1617 1618int ide_cdrom_get_capabilities(ide_drive_t *drive, u8 *buf) 1619{ 1620 struct cdrom_info *info = drive->driver_data; 1621 struct cdrom_device_info *cdi = &info->devinfo; 1622 struct packet_command cgc; 1623 int stat, attempts = 3, size = ATAPI_CAPABILITIES_PAGE_SIZE; 1624 1625 if ((info->cd_flags & IDE_CD_FLAG_FULL_CAPS_PAGE) == 0) 1626 size -= ATAPI_CAPABILITIES_PAGE_PAD_SIZE; 1627 1628 init_cdrom_command(&cgc, buf, size, CGC_DATA_UNKNOWN); 1629 do { /* we seem to get stat=0x01,err=0x00 the first time (??) */ 1630 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0); 1631 if (!stat) 1632 break; 1633 } while (--attempts); 1634 return stat; 1635} 1636 1637void ide_cdrom_update_speed(ide_drive_t *drive, u8 *buf) 1638{ 1639 struct cdrom_info *cd = drive->driver_data; 1640 u16 curspeed, maxspeed; 1641 1642 curspeed = *(u16 *)&buf[8 + 14]; 1643 maxspeed = *(u16 *)&buf[8 + 8]; 1644 1645 if (cd->cd_flags & IDE_CD_FLAG_LE_SPEED_FIELDS) { 1646 curspeed = le16_to_cpu(curspeed); 1647 maxspeed = le16_to_cpu(maxspeed); 1648 } else { 1649 curspeed = be16_to_cpu(curspeed); 1650 maxspeed = be16_to_cpu(maxspeed); 1651 } 1652 1653 cd->current_speed = (curspeed + (176/2)) / 176; 1654 cd->max_speed = (maxspeed + (176/2)) / 176; 1655} 1656 1657#define IDE_CD_CAPABILITIES \ 1658 (CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | CDC_SELECT_SPEED | \ 1659 CDC_SELECT_DISC | CDC_MULTI_SESSION | CDC_MCN | CDC_MEDIA_CHANGED | \ 1660 CDC_PLAY_AUDIO | CDC_RESET | CDC_DRIVE_STATUS | CDC_CD_R | \ 1661 CDC_CD_RW | CDC_DVD | CDC_DVD_R | CDC_DVD_RAM | CDC_GENERIC_PACKET | \ 1662 CDC_MO_DRIVE | CDC_MRW | CDC_MRW_W | CDC_RAM) 1663 1664static struct cdrom_device_ops ide_cdrom_dops = { 1665 .open = ide_cdrom_open_real, 1666 .release = ide_cdrom_release_real, 1667 .drive_status = ide_cdrom_drive_status, 1668 .media_changed = ide_cdrom_check_media_change_real, 1669 .tray_move = ide_cdrom_tray_move, 1670 .lock_door = ide_cdrom_lock_door, 1671 .select_speed = ide_cdrom_select_speed, 1672 .get_last_session = ide_cdrom_get_last_session, 1673 .get_mcn = ide_cdrom_get_mcn, 1674 .reset = ide_cdrom_reset, 1675 .audio_ioctl = ide_cdrom_audio_ioctl, 1676 .capability = IDE_CD_CAPABILITIES, 1677 .generic_packet = ide_cdrom_packet, 1678}; 1679 1680static int ide_cdrom_register (ide_drive_t *drive, int nslots) 1681{ 1682 struct cdrom_info *info = drive->driver_data; 1683 struct cdrom_device_info *devinfo = &info->devinfo; 1684 1685 devinfo->ops = &ide_cdrom_dops; 1686 devinfo->speed = info->current_speed; 1687 devinfo->capacity = nslots; 1688 devinfo->handle = drive; 1689 strcpy(devinfo->name, drive->name); 1690 1691 if (info->cd_flags & IDE_CD_FLAG_NO_SPEED_SELECT) 1692 devinfo->mask |= CDC_SELECT_SPEED; 1693 1694 devinfo->disk = info->disk; 1695 return register_cdrom(devinfo); 1696} 1697 1698static 1699int ide_cdrom_probe_capabilities (ide_drive_t *drive) 1700{ 1701 struct cdrom_info *cd = drive->driver_data; 1702 struct cdrom_device_info *cdi = &cd->devinfo; 1703 u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE]; 1704 mechtype_t mechtype; 1705 int nslots = 1; 1706 1707 cdi->mask = (CDC_CD_R | CDC_CD_RW | CDC_DVD | CDC_DVD_R | 1708 CDC_DVD_RAM | CDC_SELECT_DISC | CDC_PLAY_AUDIO | 1709 CDC_MO_DRIVE | CDC_RAM); 1710 1711 if (drive->media == ide_optical) { 1712 cdi->mask &= ~(CDC_MO_DRIVE | CDC_RAM); 1713 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name); 1714 return nslots; 1715 } 1716 1717 if (cd->cd_flags & IDE_CD_FLAG_PRE_ATAPI12) { 1718 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT; 1719 cdi->mask &= ~CDC_PLAY_AUDIO; 1720 return nslots; 1721 } 1722 1723 /* 1724 * we have to cheat a little here. the packet will eventually 1725 * be queued with ide_cdrom_packet(), which extracts the 1726 * drive from cdi->handle. Since this device hasn't been 1727 * registered with the Uniform layer yet, it can't do this. 1728 * Same goes for cdi->ops. 1729 */ 1730 cdi->handle = drive; 1731 cdi->ops = &ide_cdrom_dops; 1732 1733 if (ide_cdrom_get_capabilities(drive, buf)) 1734 return 0; 1735 1736 if ((buf[8 + 6] & 0x01) == 0) 1737 cd->cd_flags |= IDE_CD_FLAG_NO_DOORLOCK; 1738 if (buf[8 + 6] & 0x08) 1739 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT; 1740 if (buf[8 + 3] & 0x01) 1741 cdi->mask &= ~CDC_CD_R; 1742 if (buf[8 + 3] & 0x02) 1743 cdi->mask &= ~(CDC_CD_RW | CDC_RAM); 1744 if (buf[8 + 2] & 0x38) 1745 cdi->mask &= ~CDC_DVD; 1746 if (buf[8 + 3] & 0x20) 1747 cdi->mask &= ~(CDC_DVD_RAM | CDC_RAM); 1748 if (buf[8 + 3] & 0x10) 1749 cdi->mask &= ~CDC_DVD_R; 1750 if ((buf[8 + 4] & 0x01) || (cd->cd_flags & IDE_CD_FLAG_PLAY_AUDIO_OK)) 1751 cdi->mask &= ~CDC_PLAY_AUDIO; 1752 1753 mechtype = buf[8 + 6] >> 5; 1754 if (mechtype == mechtype_caddy || mechtype == mechtype_popup) 1755 cdi->mask |= CDC_CLOSE_TRAY; 1756 1757 if (cdi->sanyo_slot > 0) { 1758 cdi->mask &= ~CDC_SELECT_DISC; 1759 nslots = 3; 1760 } else if (mechtype == mechtype_individual_changer || 1761 mechtype == mechtype_cartridge_changer) { 1762 nslots = cdrom_number_of_slots(cdi); 1763 if (nslots > 1) 1764 cdi->mask &= ~CDC_SELECT_DISC; 1765 } 1766 1767 ide_cdrom_update_speed(drive, buf); 1768 1769 printk(KERN_INFO "%s: ATAPI", drive->name); 1770 1771 /* don't print speed if the drive reported 0 */ 1772 if (cd->max_speed) 1773 printk(KERN_CONT " %dX", cd->max_speed); 1774 1775 printk(KERN_CONT " %s", (cdi->mask & CDC_DVD) ? "CD-ROM" : "DVD-ROM"); 1776 1777 if ((cdi->mask & CDC_DVD_R) == 0 || (cdi->mask & CDC_DVD_RAM) == 0) 1778 printk(KERN_CONT " DVD%s%s", 1779 (cdi->mask & CDC_DVD_R) ? "" : "-R", 1780 (cdi->mask & CDC_DVD_RAM) ? "" : "-RAM"); 1781 1782 if ((cdi->mask & CDC_CD_R) == 0 || (cdi->mask & CDC_CD_RW) == 0) 1783 printk(KERN_CONT " CD%s%s", 1784 (cdi->mask & CDC_CD_R) ? "" : "-R", 1785 (cdi->mask & CDC_CD_RW) ? "" : "/RW"); 1786 1787 if ((cdi->mask & CDC_SELECT_DISC) == 0) 1788 printk(KERN_CONT " changer w/%d slots", nslots); 1789 else 1790 printk(KERN_CONT " drive"); 1791 1792 printk(KERN_CONT ", %dkB Cache\n", be16_to_cpu(*(u16 *)&buf[8 + 12])); 1793 1794 return nslots; 1795} 1796 1797#ifdef CONFIG_IDE_PROC_FS 1798static void ide_cdrom_add_settings(ide_drive_t *drive) 1799{ 1800 ide_add_setting(drive, "dsc_overlap", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL); 1801} 1802#else 1803static inline void ide_cdrom_add_settings(ide_drive_t *drive) { ; } 1804#endif 1805 1806/* 1807 * standard prep_rq_fn that builds 10 byte cmds 1808 */ 1809static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq) 1810{ 1811 int hard_sect = queue_hardsect_size(q); 1812 long block = (long)rq->hard_sector / (hard_sect >> 9); 1813 unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9); 1814 1815 memset(rq->cmd, 0, sizeof(rq->cmd)); 1816 1817 if (rq_data_dir(rq) == READ) 1818 rq->cmd[0] = GPCMD_READ_10; 1819 else 1820 rq->cmd[0] = GPCMD_WRITE_10; 1821 1822 /* 1823 * fill in lba 1824 */ 1825 rq->cmd[2] = (block >> 24) & 0xff; 1826 rq->cmd[3] = (block >> 16) & 0xff; 1827 rq->cmd[4] = (block >> 8) & 0xff; 1828 rq->cmd[5] = block & 0xff; 1829 1830 /* 1831 * and transfer length 1832 */ 1833 rq->cmd[7] = (blocks >> 8) & 0xff; 1834 rq->cmd[8] = blocks & 0xff; 1835 rq->cmd_len = 10; 1836 return BLKPREP_OK; 1837} 1838 1839/* 1840 * Most of the SCSI commands are supported directly by ATAPI devices. 1841 * This transform handles the few exceptions. 1842 */ 1843static int ide_cdrom_prep_pc(struct request *rq) 1844{ 1845 u8 *c = rq->cmd; 1846 1847 /* 1848 * Transform 6-byte read/write commands to the 10-byte version 1849 */ 1850 if (c[0] == READ_6 || c[0] == WRITE_6) { 1851 c[8] = c[4]; 1852 c[5] = c[3]; 1853 c[4] = c[2]; 1854 c[3] = c[1] & 0x1f; 1855 c[2] = 0; 1856 c[1] &= 0xe0; 1857 c[0] += (READ_10 - READ_6); 1858 rq->cmd_len = 10; 1859 return BLKPREP_OK; 1860 } 1861 1862 /* 1863 * it's silly to pretend we understand 6-byte sense commands, just 1864 * reject with ILLEGAL_REQUEST and the caller should take the 1865 * appropriate action 1866 */ 1867 if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) { 1868 rq->errors = ILLEGAL_REQUEST; 1869 return BLKPREP_KILL; 1870 } 1871 1872 return BLKPREP_OK; 1873} 1874 1875static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq) 1876{ 1877 if (blk_fs_request(rq)) 1878 return ide_cdrom_prep_fs(q, rq); 1879 else if (blk_pc_request(rq)) 1880 return ide_cdrom_prep_pc(rq); 1881 1882 return 0; 1883} 1884 1885struct cd_list_entry { 1886 const char *id_model; 1887 const char *id_firmware; 1888 unsigned int cd_flags; 1889}; 1890 1891static const struct cd_list_entry ide_cd_quirks_list[] = { 1892 /* Limit transfer size per interrupt. */ 1893 { "SAMSUNG CD-ROM SCR-2430", NULL, IDE_CD_FLAG_LIMIT_NFRAMES }, 1894 { "SAMSUNG CD-ROM SCR-2432", NULL, IDE_CD_FLAG_LIMIT_NFRAMES }, 1895 /* SCR-3231 doesn't support the SET_CD_SPEED command. */ 1896 { "SAMSUNG CD-ROM SCR-3231", NULL, IDE_CD_FLAG_NO_SPEED_SELECT }, 1897 /* Old NEC260 (not R) was released before ATAPI 1.2 spec. */ 1898 { "NEC CD-ROM DRIVE:260", "1.01", IDE_CD_FLAG_TOCADDR_AS_BCD | 1899 IDE_CD_FLAG_PRE_ATAPI12, }, 1900 /* Vertos 300, some versions of this drive like to talk BCD. */ 1901 { "V003S0DS", NULL, IDE_CD_FLAG_VERTOS_300_SSD, }, 1902 /* Vertos 600 ESD. */ 1903 { "V006E0DS", NULL, IDE_CD_FLAG_VERTOS_600_ESD, }, 1904 /* 1905 * Sanyo 3 CD changer uses a non-standard command for CD changing 1906 * (by default standard ATAPI support for CD changers is used). 1907 */ 1908 { "CD-ROM CDR-C3 G", NULL, IDE_CD_FLAG_SANYO_3CD }, 1909 { "CD-ROM CDR-C3G", NULL, IDE_CD_FLAG_SANYO_3CD }, 1910 { "CD-ROM CDR_C36", NULL, IDE_CD_FLAG_SANYO_3CD }, 1911 /* Stingray 8X CD-ROM. */ 1912 { "STINGRAY 8422 IDE 8X CD-ROM 7-27-95", NULL, IDE_CD_FLAG_PRE_ATAPI12}, 1913 /* 1914 * ACER 50X CD-ROM and WPI 32X CD-ROM require the full spec length 1915 * mode sense page capabilities size, but older drives break. 1916 */ 1917 { "ATAPI CD ROM DRIVE 50X MAX", NULL, IDE_CD_FLAG_FULL_CAPS_PAGE }, 1918 { "WPI CDS-32X", NULL, IDE_CD_FLAG_FULL_CAPS_PAGE }, 1919 /* ACER/AOpen 24X CD-ROM has the speed fields byte-swapped. */ 1920 { "", "241N", IDE_CD_FLAG_LE_SPEED_FIELDS }, 1921 /* 1922 * Some drives used by Apple don't advertise audio play 1923 * but they do support reading TOC & audio datas. 1924 */ 1925 { "MATSHITADVD-ROM SR-8187", NULL, IDE_CD_FLAG_PLAY_AUDIO_OK }, 1926 { "MATSHITADVD-ROM SR-8186", NULL, IDE_CD_FLAG_PLAY_AUDIO_OK }, 1927 { "MATSHITADVD-ROM SR-8176", NULL, IDE_CD_FLAG_PLAY_AUDIO_OK }, 1928 { "MATSHITADVD-ROM SR-8174", NULL, IDE_CD_FLAG_PLAY_AUDIO_OK }, 1929 { NULL, NULL, 0 } 1930}; 1931 1932static unsigned int ide_cd_flags(struct hd_driveid *id) 1933{ 1934 const struct cd_list_entry *cle = ide_cd_quirks_list; 1935 1936 while (cle->id_model) { 1937 if (strcmp(cle->id_model, id->model) == 0 && 1938 (cle->id_firmware == NULL || 1939 strstr(id->fw_rev, cle->id_firmware))) 1940 return cle->cd_flags; 1941 cle++; 1942 } 1943 1944 return 0; 1945} 1946 1947static 1948int ide_cdrom_setup (ide_drive_t *drive) 1949{ 1950 struct cdrom_info *cd = drive->driver_data; 1951 struct cdrom_device_info *cdi = &cd->devinfo; 1952 struct hd_driveid *id = drive->id; 1953 int nslots; 1954 1955 blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn); 1956 blk_queue_dma_alignment(drive->queue, 31); 1957 drive->queue->unplug_delay = (1 * HZ) / 1000; 1958 if (!drive->queue->unplug_delay) 1959 drive->queue->unplug_delay = 1; 1960 1961 drive->special.all = 0; 1962 1963 cd->cd_flags = IDE_CD_FLAG_MEDIA_CHANGED | IDE_CD_FLAG_NO_EJECT | 1964 ide_cd_flags(id); 1965 1966 if ((id->config & 0x0060) == 0x20) 1967 cd->cd_flags |= IDE_CD_FLAG_DRQ_INTERRUPT; 1968 1969 if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_300_SSD) && 1970 id->fw_rev[4] == '1' && id->fw_rev[6] <= '2') 1971 cd->cd_flags |= (IDE_CD_FLAG_TOCTRACKS_AS_BCD | 1972 IDE_CD_FLAG_TOCADDR_AS_BCD); 1973 else if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_600_ESD) && 1974 id->fw_rev[4] == '1' && id->fw_rev[6] <= '2') 1975 cd->cd_flags |= IDE_CD_FLAG_TOCTRACKS_AS_BCD; 1976 else if (cd->cd_flags & IDE_CD_FLAG_SANYO_3CD) 1977 cdi->sanyo_slot = 3; /* 3 => use CD in slot 0 */ 1978 1979 nslots = ide_cdrom_probe_capabilities (drive); 1980 1981 /* 1982 * set correct block size 1983 */ 1984 blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE); 1985 1986 if (drive->autotune == IDE_TUNE_DEFAULT || 1987 drive->autotune == IDE_TUNE_AUTO) 1988 drive->dsc_overlap = (drive->next != drive); 1989 1990 if (ide_cdrom_register(drive, nslots)) { 1991 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name); 1992 cd->devinfo.handle = NULL; 1993 return 1; 1994 } 1995 ide_cdrom_add_settings(drive); 1996 return 0; 1997} 1998 1999#ifdef CONFIG_IDE_PROC_FS 2000static 2001sector_t ide_cdrom_capacity (ide_drive_t *drive) 2002{ 2003 unsigned long capacity, sectors_per_frame; 2004 2005 if (cdrom_read_capacity(drive, &capacity, §ors_per_frame, NULL)) 2006 return 0; 2007 2008 return capacity * sectors_per_frame; 2009} 2010#endif 2011 2012static void ide_cd_remove(ide_drive_t *drive) 2013{ 2014 struct cdrom_info *info = drive->driver_data; 2015 2016 ide_proc_unregister_driver(drive, info->driver); 2017 2018 del_gendisk(info->disk); 2019 2020 ide_cd_put(info); 2021} 2022 2023static void ide_cd_release(struct kref *kref) 2024{ 2025 struct cdrom_info *info = to_ide_cd(kref); 2026 struct cdrom_device_info *devinfo = &info->devinfo; 2027 ide_drive_t *drive = info->drive; 2028 struct gendisk *g = info->disk; 2029 2030 kfree(info->buffer); 2031 kfree(info->toc); 2032 if (devinfo->handle == drive && unregister_cdrom(devinfo)) 2033 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom " 2034 "driver.\n", __FUNCTION__, drive->name); 2035 drive->dsc_overlap = 0; 2036 drive->driver_data = NULL; 2037 blk_queue_prep_rq(drive->queue, NULL); 2038 g->private_data = NULL; 2039 put_disk(g); 2040 kfree(info); 2041} 2042 2043static int ide_cd_probe(ide_drive_t *); 2044 2045#ifdef CONFIG_IDE_PROC_FS 2046static int proc_idecd_read_capacity 2047 (char *page, char **start, off_t off, int count, int *eof, void *data) 2048{ 2049 ide_drive_t *drive = data; 2050 int len; 2051 2052 len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive)); 2053 PROC_IDE_READ_RETURN(page,start,off,count,eof,len); 2054} 2055 2056static ide_proc_entry_t idecd_proc[] = { 2057 { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL }, 2058 { NULL, 0, NULL, NULL } 2059}; 2060#endif 2061 2062static ide_driver_t ide_cdrom_driver = { 2063 .gen_driver = { 2064 .owner = THIS_MODULE, 2065 .name = "ide-cdrom", 2066 .bus = &ide_bus_type, 2067 }, 2068 .probe = ide_cd_probe, 2069 .remove = ide_cd_remove, 2070 .version = IDECD_VERSION, 2071 .media = ide_cdrom, 2072 .supports_dsc_overlap = 1, 2073 .do_request = ide_do_rw_cdrom, 2074 .end_request = ide_end_request, 2075 .error = __ide_error, 2076 .abort = __ide_abort, 2077#ifdef CONFIG_IDE_PROC_FS 2078 .proc = idecd_proc, 2079#endif 2080}; 2081 2082static int idecd_open(struct inode * inode, struct file * file) 2083{ 2084 struct gendisk *disk = inode->i_bdev->bd_disk; 2085 struct cdrom_info *info; 2086 int rc = -ENOMEM; 2087 2088 if (!(info = ide_cd_get(disk))) 2089 return -ENXIO; 2090 2091 if (!info->buffer) 2092 info->buffer = kmalloc(SECTOR_BUFFER_SIZE, GFP_KERNEL|__GFP_REPEAT); 2093 2094 if (info->buffer) 2095 rc = cdrom_open(&info->devinfo, inode, file); 2096 2097 if (rc < 0) 2098 ide_cd_put(info); 2099 2100 return rc; 2101} 2102 2103static int idecd_release(struct inode * inode, struct file * file) 2104{ 2105 struct gendisk *disk = inode->i_bdev->bd_disk; 2106 struct cdrom_info *info = ide_cd_g(disk); 2107 2108 cdrom_release (&info->devinfo, file); 2109 2110 ide_cd_put(info); 2111 2112 return 0; 2113} 2114 2115static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg) 2116{ 2117 struct packet_command cgc; 2118 char buffer[16]; 2119 int stat; 2120 char spindown; 2121 2122 if (copy_from_user(&spindown, (void __user *)arg, sizeof(char))) 2123 return -EFAULT; 2124 2125 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN); 2126 2127 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0); 2128 if (stat) 2129 return stat; 2130 2131 buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f); 2132 return cdrom_mode_select(cdi, &cgc); 2133} 2134 2135static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg) 2136{ 2137 struct packet_command cgc; 2138 char buffer[16]; 2139 int stat; 2140 char spindown; 2141 2142 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN); 2143 2144 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0); 2145 if (stat) 2146 return stat; 2147 2148 spindown = buffer[11] & 0x0f; 2149 if (copy_to_user((void __user *)arg, &spindown, sizeof (char))) 2150 return -EFAULT; 2151 return 0; 2152} 2153 2154static int idecd_ioctl (struct inode *inode, struct file *file, 2155 unsigned int cmd, unsigned long arg) 2156{ 2157 struct block_device *bdev = inode->i_bdev; 2158 struct cdrom_info *info = ide_cd_g(bdev->bd_disk); 2159 int err; 2160 2161 switch (cmd) { 2162 case CDROMSETSPINDOWN: 2163 return idecd_set_spindown(&info->devinfo, arg); 2164 case CDROMGETSPINDOWN: 2165 return idecd_get_spindown(&info->devinfo, arg); 2166 default: 2167 break; 2168 } 2169 2170 err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg); 2171 if (err == -EINVAL) 2172 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg); 2173 2174 return err; 2175} 2176 2177static int idecd_media_changed(struct gendisk *disk) 2178{ 2179 struct cdrom_info *info = ide_cd_g(disk); 2180 return cdrom_media_changed(&info->devinfo); 2181} 2182 2183static int idecd_revalidate_disk(struct gendisk *disk) 2184{ 2185 struct cdrom_info *info = ide_cd_g(disk); 2186 struct request_sense sense; 2187 2188 ide_cd_read_toc(info->drive, &sense); 2189 2190 return 0; 2191} 2192 2193static struct block_device_operations idecd_ops = { 2194 .owner = THIS_MODULE, 2195 .open = idecd_open, 2196 .release = idecd_release, 2197 .ioctl = idecd_ioctl, 2198 .media_changed = idecd_media_changed, 2199 .revalidate_disk= idecd_revalidate_disk 2200}; 2201 2202/* options */ 2203static char *ignore = NULL; 2204 2205module_param(ignore, charp, 0400); 2206MODULE_DESCRIPTION("ATAPI CD-ROM Driver"); 2207 2208static int ide_cd_probe(ide_drive_t *drive) 2209{ 2210 struct cdrom_info *info; 2211 struct gendisk *g; 2212 struct request_sense sense; 2213 2214 if (!strstr("ide-cdrom", drive->driver_req)) 2215 goto failed; 2216 if (!drive->present) 2217 goto failed; 2218 if (drive->media != ide_cdrom && drive->media != ide_optical) 2219 goto failed; 2220 /* skip drives that we were told to ignore */ 2221 if (ignore != NULL) { 2222 if (strstr(ignore, drive->name)) { 2223 printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name); 2224 goto failed; 2225 } 2226 } 2227 if (drive->scsi) { 2228 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name); 2229 goto failed; 2230 } 2231 info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL); 2232 if (info == NULL) { 2233 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name); 2234 goto failed; 2235 } 2236 2237 g = alloc_disk(1 << PARTN_BITS); 2238 if (!g) 2239 goto out_free_cd; 2240 2241 ide_init_disk(g, drive); 2242 2243 ide_proc_register_driver(drive, &ide_cdrom_driver); 2244 2245 kref_init(&info->kref); 2246 2247 info->drive = drive; 2248 info->driver = &ide_cdrom_driver; 2249 info->disk = g; 2250 2251 g->private_data = &info->driver; 2252 2253 drive->driver_data = info; 2254 2255 g->minors = 1; 2256 g->driverfs_dev = &drive->gendev; 2257 g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE; 2258 if (ide_cdrom_setup(drive)) { 2259 ide_proc_unregister_driver(drive, &ide_cdrom_driver); 2260 ide_cd_release(&info->kref); 2261 goto failed; 2262 } 2263 2264 ide_cd_read_toc(drive, &sense); 2265 g->fops = &idecd_ops; 2266 g->flags |= GENHD_FL_REMOVABLE; 2267 add_disk(g); 2268 return 0; 2269 2270out_free_cd: 2271 kfree(info); 2272failed: 2273 return -ENODEV; 2274} 2275 2276static void __exit ide_cdrom_exit(void) 2277{ 2278 driver_unregister(&ide_cdrom_driver.gen_driver); 2279} 2280 2281static int __init ide_cdrom_init(void) 2282{ 2283 return driver_register(&ide_cdrom_driver.gen_driver); 2284} 2285 2286MODULE_ALIAS("ide:*m-cdrom*"); 2287MODULE_ALIAS("ide-cd"); 2288module_init(ide_cdrom_init); 2289module_exit(ide_cdrom_exit); 2290MODULE_LICENSE("GPL"); 2291