ide-cd.c revision bcd88ac3b2ff2eae3d0fa57a6b02d4fce5392f32
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 = ide_read_status(drive); 299 300 if (stat_ret) 301 *stat_ret = stat; 302 303 if (OK_STAT(stat, good_stat, BAD_R_STAT)) 304 return 0; 305 306 /* Get the IDE error register. */ 307 err = ide_read_error(drive); 308 sense_key = err >> 4; 309 310 if (rq == NULL) { 311 printk("%s: missing rq in cdrom_decode_status\n", drive->name); 312 return 1; 313 } 314 315 if (blk_sense_request(rq)) { 316 /* We got an error trying to get sense info 317 from the drive (probably while trying 318 to recover from a former error). Just give up. */ 319 320 rq->cmd_flags |= REQ_FAILED; 321 cdrom_end_request(drive, 0); 322 ide_error(drive, "request sense failure", stat); 323 return 1; 324 325 } else if (blk_pc_request(rq) || rq->cmd_type == REQ_TYPE_ATA_PC) { 326 /* All other functions, except for READ. */ 327 328 /* 329 * if we have an error, pass back CHECK_CONDITION as the 330 * scsi status byte 331 */ 332 if (blk_pc_request(rq) && !rq->errors) 333 rq->errors = SAM_STAT_CHECK_CONDITION; 334 335 /* Check for tray open. */ 336 if (sense_key == NOT_READY) { 337 cdrom_saw_media_change (drive); 338 } else if (sense_key == UNIT_ATTENTION) { 339 /* Check for media change. */ 340 cdrom_saw_media_change (drive); 341 /*printk("%s: media changed\n",drive->name);*/ 342 return 0; 343 } else if ((sense_key == ILLEGAL_REQUEST) && 344 (rq->cmd[0] == GPCMD_START_STOP_UNIT)) { 345 /* 346 * Don't print error message for this condition-- 347 * SFF8090i indicates that 5/24/00 is the correct 348 * response to a request to close the tray if the 349 * drive doesn't have that capability. 350 * cdrom_log_sense() knows this! 351 */ 352 } else if (!(rq->cmd_flags & REQ_QUIET)) { 353 /* Otherwise, print an error. */ 354 ide_dump_status(drive, "packet command error", stat); 355 } 356 357 rq->cmd_flags |= REQ_FAILED; 358 359 /* 360 * instead of playing games with moving completions around, 361 * remove failed request completely and end it when the 362 * request sense has completed 363 */ 364 goto end_request; 365 366 } else if (blk_fs_request(rq)) { 367 int do_end_request = 0; 368 369 /* Handle errors from READ and WRITE requests. */ 370 371 if (blk_noretry_request(rq)) 372 do_end_request = 1; 373 374 if (sense_key == NOT_READY) { 375 /* Tray open. */ 376 if (rq_data_dir(rq) == READ) { 377 cdrom_saw_media_change (drive); 378 379 /* Fail the request. */ 380 printk ("%s: tray open\n", drive->name); 381 do_end_request = 1; 382 } else { 383 struct cdrom_info *info = drive->driver_data; 384 385 /* allow the drive 5 seconds to recover, some 386 * devices will return this error while flushing 387 * data from cache */ 388 if (!rq->errors) 389 info->write_timeout = jiffies + ATAPI_WAIT_WRITE_BUSY; 390 rq->errors = 1; 391 if (time_after(jiffies, info->write_timeout)) 392 do_end_request = 1; 393 else { 394 unsigned long flags; 395 396 /* 397 * take a breather relying on the 398 * unplug timer to kick us again 399 */ 400 spin_lock_irqsave(&ide_lock, flags); 401 blk_plug_device(drive->queue); 402 spin_unlock_irqrestore(&ide_lock,flags); 403 return 1; 404 } 405 } 406 } else if (sense_key == UNIT_ATTENTION) { 407 /* Media change. */ 408 cdrom_saw_media_change (drive); 409 410 /* Arrange to retry the request. 411 But be sure to give up if we've retried 412 too many times. */ 413 if (++rq->errors > ERROR_MAX) 414 do_end_request = 1; 415 } else if (sense_key == ILLEGAL_REQUEST || 416 sense_key == DATA_PROTECT) { 417 /* No point in retrying after an illegal 418 request or data protect error.*/ 419 ide_dump_status_no_sense (drive, "command error", stat); 420 do_end_request = 1; 421 } else if (sense_key == MEDIUM_ERROR) { 422 /* No point in re-trying a zillion times on a bad 423 * sector... If we got here the error is not correctable */ 424 ide_dump_status_no_sense (drive, "media error (bad sector)", stat); 425 do_end_request = 1; 426 } else if (sense_key == BLANK_CHECK) { 427 /* Disk appears blank ?? */ 428 ide_dump_status_no_sense (drive, "media error (blank)", stat); 429 do_end_request = 1; 430 } else if ((err & ~ABRT_ERR) != 0) { 431 /* Go to the default handler 432 for other errors. */ 433 ide_error(drive, "cdrom_decode_status", stat); 434 return 1; 435 } else if ((++rq->errors > ERROR_MAX)) { 436 /* We've racked up too many retries. Abort. */ 437 do_end_request = 1; 438 } 439 440 /* End a request through request sense analysis when we have 441 sense data. We need this in order to perform end of media 442 processing */ 443 444 if (do_end_request) 445 goto end_request; 446 447 /* 448 * If we got a CHECK_CONDITION status, 449 * queue a request sense command. 450 */ 451 if (stat & ERR_STAT) 452 cdrom_queue_request_sense(drive, NULL, NULL); 453 } else { 454 blk_dump_rq_flags(rq, "ide-cd: bad rq"); 455 cdrom_end_request(drive, 0); 456 } 457 458 /* Retry, or handle the next request. */ 459 return 1; 460 461end_request: 462 if (stat & ERR_STAT) { 463 unsigned long flags; 464 465 spin_lock_irqsave(&ide_lock, flags); 466 blkdev_dequeue_request(rq); 467 HWGROUP(drive)->rq = NULL; 468 spin_unlock_irqrestore(&ide_lock, flags); 469 470 cdrom_queue_request_sense(drive, rq->sense, rq); 471 } else 472 cdrom_end_request(drive, 0); 473 474 return 1; 475} 476 477static int cdrom_timer_expiry(ide_drive_t *drive) 478{ 479 struct request *rq = HWGROUP(drive)->rq; 480 unsigned long wait = 0; 481 482 /* 483 * Some commands are *slow* and normally take a long time to 484 * complete. Usually we can use the ATAPI "disconnect" to bypass 485 * this, but not all commands/drives support that. Let 486 * ide_timer_expiry keep polling us for these. 487 */ 488 switch (rq->cmd[0]) { 489 case GPCMD_BLANK: 490 case GPCMD_FORMAT_UNIT: 491 case GPCMD_RESERVE_RZONE_TRACK: 492 case GPCMD_CLOSE_TRACK: 493 case GPCMD_FLUSH_CACHE: 494 wait = ATAPI_WAIT_PC; 495 break; 496 default: 497 if (!(rq->cmd_flags & REQ_QUIET)) 498 printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n", rq->cmd[0]); 499 wait = 0; 500 break; 501 } 502 return wait; 503} 504 505/* Set up the device registers for transferring a packet command on DEV, 506 expecting to later transfer XFERLEN bytes. HANDLER is the routine 507 which actually transfers the command to the drive. If this is a 508 drq_interrupt device, this routine will arrange for HANDLER to be 509 called when the interrupt from the drive arrives. Otherwise, HANDLER 510 will be called immediately after the drive is prepared for the transfer. */ 511 512static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive, 513 int xferlen, 514 ide_handler_t *handler) 515{ 516 ide_startstop_t startstop; 517 struct cdrom_info *info = drive->driver_data; 518 ide_hwif_t *hwif = drive->hwif; 519 520 /* Wait for the controller to be idle. */ 521 if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY)) 522 return startstop; 523 524 /* FIXME: for Virtual DMA we must check harder */ 525 if (info->dma) 526 info->dma = !hwif->dma_setup(drive); 527 528 /* Set up the controller registers. */ 529 ide_pktcmd_tf_load(drive, IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL | 530 IDE_TFLAG_NO_SELECT_MASK, xferlen, info->dma); 531 532 if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) { 533 /* waiting for CDB interrupt, not DMA yet. */ 534 if (info->dma) 535 drive->waiting_for_dma = 0; 536 537 /* packet command */ 538 ide_execute_command(drive, WIN_PACKETCMD, handler, ATAPI_WAIT_PC, cdrom_timer_expiry); 539 return ide_started; 540 } else { 541 unsigned long flags; 542 543 /* packet command */ 544 spin_lock_irqsave(&ide_lock, flags); 545 hwif->OUTBSYNC(drive, WIN_PACKETCMD, IDE_COMMAND_REG); 546 ndelay(400); 547 spin_unlock_irqrestore(&ide_lock, flags); 548 549 return (*handler) (drive); 550 } 551} 552 553/* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN. 554 The device registers must have already been prepared 555 by cdrom_start_packet_command. 556 HANDLER is the interrupt handler to call when the command completes 557 or there's data ready. */ 558#define ATAPI_MIN_CDB_BYTES 12 559static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive, 560 struct request *rq, 561 ide_handler_t *handler) 562{ 563 ide_hwif_t *hwif = drive->hwif; 564 int cmd_len; 565 struct cdrom_info *info = drive->driver_data; 566 ide_startstop_t startstop; 567 568 if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) { 569 /* Here we should have been called after receiving an interrupt 570 from the device. DRQ should how be set. */ 571 572 /* Check for errors. */ 573 if (cdrom_decode_status(drive, DRQ_STAT, NULL)) 574 return ide_stopped; 575 576 /* Ok, next interrupt will be DMA interrupt. */ 577 if (info->dma) 578 drive->waiting_for_dma = 1; 579 } else { 580 /* Otherwise, we must wait for DRQ to get set. */ 581 if (ide_wait_stat(&startstop, drive, DRQ_STAT, 582 BUSY_STAT, WAIT_READY)) 583 return startstop; 584 } 585 586 /* Arm the interrupt handler. */ 587 ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry); 588 589 /* ATAPI commands get padded out to 12 bytes minimum */ 590 cmd_len = COMMAND_SIZE(rq->cmd[0]); 591 if (cmd_len < ATAPI_MIN_CDB_BYTES) 592 cmd_len = ATAPI_MIN_CDB_BYTES; 593 594 /* Send the command to the device. */ 595 HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len); 596 597 /* Start the DMA if need be */ 598 if (info->dma) 599 hwif->dma_start(drive); 600 601 return ide_started; 602} 603 604/**************************************************************************** 605 * Block read functions. 606 */ 607 608static void ide_cd_pad_transfer(ide_drive_t *drive, xfer_func_t *xf, int len) 609{ 610 while (len > 0) { 611 int dum = 0; 612 xf(drive, &dum, sizeof(dum)); 613 len -= sizeof(dum); 614 } 615} 616 617static void ide_cd_drain_data(ide_drive_t *drive, int nsects) 618{ 619 while (nsects > 0) { 620 static char dum[SECTOR_SIZE]; 621 622 drive->hwif->atapi_input_bytes(drive, dum, sizeof(dum)); 623 nsects--; 624 } 625} 626 627/* 628 * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector 629 * buffer. Once the first sector is added, any subsequent sectors are 630 * assumed to be continuous (until the buffer is cleared). For the first 631 * sector added, SECTOR is its sector number. (SECTOR is then ignored until 632 * the buffer is cleared.) 633 */ 634static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector, 635 int sectors_to_transfer) 636{ 637 struct cdrom_info *info = drive->driver_data; 638 639 /* Number of sectors to read into the buffer. */ 640 int sectors_to_buffer = min_t(int, sectors_to_transfer, 641 (SECTOR_BUFFER_SIZE >> SECTOR_BITS) - 642 info->nsectors_buffered); 643 644 char *dest; 645 646 /* If we couldn't get a buffer, don't try to buffer anything... */ 647 if (info->buffer == NULL) 648 sectors_to_buffer = 0; 649 650 /* If this is the first sector in the buffer, remember its number. */ 651 if (info->nsectors_buffered == 0) 652 info->sector_buffered = sector; 653 654 /* Read the data into the buffer. */ 655 dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE; 656 while (sectors_to_buffer > 0) { 657 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE); 658 --sectors_to_buffer; 659 --sectors_to_transfer; 660 ++info->nsectors_buffered; 661 dest += SECTOR_SIZE; 662 } 663 664 /* Throw away any remaining data. */ 665 ide_cd_drain_data(drive, sectors_to_transfer); 666} 667 668/* 669 * Check the contents of the interrupt reason register from the cdrom 670 * and attempt to recover if there are problems. Returns 0 if everything's 671 * ok; nonzero if the request has been terminated. 672 */ 673static int ide_cd_check_ireason(ide_drive_t *drive, struct request *rq, 674 int len, int ireason, int rw) 675{ 676 /* 677 * ireason == 0: the drive wants to receive data from us 678 * ireason == 2: the drive is expecting to transfer data to us 679 */ 680 if (ireason == (!rw << 1)) 681 return 0; 682 else if (ireason == (rw << 1)) { 683 ide_hwif_t *hwif = drive->hwif; 684 xfer_func_t *xf; 685 686 /* Whoops... */ 687 printk(KERN_ERR "%s: %s: wrong transfer direction!\n", 688 drive->name, __FUNCTION__); 689 690 xf = rw ? hwif->atapi_output_bytes : hwif->atapi_input_bytes; 691 ide_cd_pad_transfer(drive, xf, len); 692 } else if (rw == 0 && ireason == 1) { 693 /* Some drives (ASUS) seem to tell us that status 694 * info is available. just get it and ignore. 695 */ 696 (void)ide_read_status(drive); 697 return 0; 698 } else { 699 /* Drive wants a command packet, or invalid ireason... */ 700 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n", 701 drive->name, __FUNCTION__, ireason); 702 } 703 704 if (rq->cmd_type == REQ_TYPE_ATA_PC) 705 rq->cmd_flags |= REQ_FAILED; 706 707 cdrom_end_request(drive, 0); 708 return -1; 709} 710 711/* 712 * Assume that the drive will always provide data in multiples of at least 713 * SECTOR_SIZE, as it gets hairy to keep track of the transfers otherwise. 714 */ 715static int ide_cd_check_transfer_size(ide_drive_t *drive, int len) 716{ 717 struct cdrom_info *cd = drive->driver_data; 718 719 if ((len % SECTOR_SIZE) == 0) 720 return 0; 721 722 printk(KERN_ERR "%s: %s: Bad transfer size %d\n", 723 drive->name, __FUNCTION__, len); 724 725 if (cd->cd_flags & IDE_CD_FLAG_LIMIT_NFRAMES) 726 printk(KERN_ERR " This drive is not supported by " 727 "this version of the driver\n"); 728 else { 729 printk(KERN_ERR " Trying to limit transfer sizes\n"); 730 cd->cd_flags |= IDE_CD_FLAG_LIMIT_NFRAMES; 731 } 732 733 return 1; 734} 735 736/* 737 * Try to satisfy some of the current read request from our cached data. 738 * Returns nonzero if the request has been completed, zero otherwise. 739 */ 740static int cdrom_read_from_buffer (ide_drive_t *drive) 741{ 742 struct cdrom_info *info = drive->driver_data; 743 struct request *rq = HWGROUP(drive)->rq; 744 unsigned short sectors_per_frame; 745 746 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS; 747 748 /* Can't do anything if there's no buffer. */ 749 if (info->buffer == NULL) return 0; 750 751 /* Loop while this request needs data and the next block is present 752 in our cache. */ 753 while (rq->nr_sectors > 0 && 754 rq->sector >= info->sector_buffered && 755 rq->sector < info->sector_buffered + info->nsectors_buffered) { 756 if (rq->current_nr_sectors == 0) 757 cdrom_end_request(drive, 1); 758 759 memcpy (rq->buffer, 760 info->buffer + 761 (rq->sector - info->sector_buffered) * SECTOR_SIZE, 762 SECTOR_SIZE); 763 rq->buffer += SECTOR_SIZE; 764 --rq->current_nr_sectors; 765 --rq->nr_sectors; 766 ++rq->sector; 767 } 768 769 /* If we've satisfied the current request, 770 terminate it successfully. */ 771 if (rq->nr_sectors == 0) { 772 cdrom_end_request(drive, 1); 773 return -1; 774 } 775 776 /* Move on to the next buffer if needed. */ 777 if (rq->current_nr_sectors == 0) 778 cdrom_end_request(drive, 1); 779 780 /* If this condition does not hold, then the kluge i use to 781 represent the number of sectors to skip at the start of a transfer 782 will fail. I think that this will never happen, but let's be 783 paranoid and check. */ 784 if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) && 785 (rq->sector & (sectors_per_frame - 1))) { 786 printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n", 787 drive->name, (long)rq->sector); 788 cdrom_end_request(drive, 0); 789 return -1; 790 } 791 792 return 0; 793} 794 795static ide_startstop_t cdrom_newpc_intr(ide_drive_t *); 796 797/* 798 * Routine to send a read/write packet command to the drive. 799 * This is usually called directly from cdrom_start_{read,write}(). 800 * However, for drq_interrupt devices, it is called from an interrupt 801 * when the drive is ready to accept the command. 802 */ 803static ide_startstop_t cdrom_start_rw_cont(ide_drive_t *drive) 804{ 805 struct request *rq = HWGROUP(drive)->rq; 806 807 if (rq_data_dir(rq) == READ) { 808 unsigned short sectors_per_frame = 809 queue_hardsect_size(drive->queue) >> SECTOR_BITS; 810 int nskip = rq->sector & (sectors_per_frame - 1); 811 812 /* 813 * If the requested sector doesn't start on a frame boundary, 814 * we must adjust the start of the transfer so that it does, 815 * and remember to skip the first few sectors. 816 * 817 * If the rq->current_nr_sectors field is larger than the size 818 * of the buffer, it will mean that we're to skip a number of 819 * sectors equal to the amount by which rq->current_nr_sectors 820 * is larger than the buffer size. 821 */ 822 if (nskip > 0) { 823 /* Sanity check... */ 824 if (rq->current_nr_sectors != 825 bio_cur_sectors(rq->bio)) { 826 printk(KERN_ERR "%s: %s: buffer botch (%u)\n", 827 drive->name, __FUNCTION__, 828 rq->current_nr_sectors); 829 cdrom_end_request(drive, 0); 830 return ide_stopped; 831 } 832 rq->current_nr_sectors += nskip; 833 } 834 } 835#if 0 836 else 837 /* the immediate bit */ 838 rq->cmd[1] = 1 << 3; 839#endif 840 /* Set up the command */ 841 rq->timeout = ATAPI_WAIT_PC; 842 843 /* Send the command to the drive and return. */ 844 return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr); 845} 846 847#define IDECD_SEEK_THRESHOLD (1000) /* 1000 blocks */ 848#define IDECD_SEEK_TIMER (5 * WAIT_MIN_SLEEP) /* 100 ms */ 849#define IDECD_SEEK_TIMEOUT (2 * WAIT_CMD) /* 20 sec */ 850 851static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive) 852{ 853 struct cdrom_info *info = drive->driver_data; 854 int stat; 855 static int retry = 10; 856 857 if (cdrom_decode_status(drive, 0, &stat)) 858 return ide_stopped; 859 860 info->cd_flags |= IDE_CD_FLAG_SEEKING; 861 862 if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) { 863 if (--retry == 0) { 864 /* 865 * this condition is far too common, to bother 866 * users about it 867 */ 868 /* printk("%s: disabled DSC seek overlap\n", drive->name);*/ 869 drive->dsc_overlap = 0; 870 } 871 } 872 return ide_stopped; 873} 874 875static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive) 876{ 877 struct request *rq = HWGROUP(drive)->rq; 878 sector_t frame = rq->sector; 879 880 sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS); 881 882 memset(rq->cmd, 0, sizeof(rq->cmd)); 883 rq->cmd[0] = GPCMD_SEEK; 884 put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]); 885 886 rq->timeout = ATAPI_WAIT_PC; 887 return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr); 888} 889 890static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block) 891{ 892 struct cdrom_info *info = drive->driver_data; 893 894 info->dma = 0; 895 info->start_seek = jiffies; 896 return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation); 897} 898 899/* Fix up a possibly partially-processed request so that we can 900 start it over entirely, or even put it back on the request queue. */ 901static void restore_request (struct request *rq) 902{ 903 if (rq->buffer != bio_data(rq->bio)) { 904 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE; 905 906 rq->buffer = bio_data(rq->bio); 907 rq->nr_sectors += n; 908 rq->sector -= n; 909 } 910 rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio); 911 rq->hard_nr_sectors = rq->nr_sectors; 912 rq->hard_sector = rq->sector; 913 rq->q->prep_rq_fn(rq->q, rq); 914} 915 916/**************************************************************************** 917 * Execute all other packet commands. 918 */ 919 920static void ide_cd_request_sense_fixup(struct request *rq) 921{ 922 /* 923 * Some of the trailing request sense fields are optional, 924 * and some drives don't send them. Sigh. 925 */ 926 if (rq->cmd[0] == GPCMD_REQUEST_SENSE && 927 rq->data_len > 0 && rq->data_len <= 5) 928 while (rq->data_len > 0) { 929 *(u8 *)rq->data++ = 0; 930 --rq->data_len; 931 } 932} 933 934int ide_cd_queue_pc(ide_drive_t *drive, struct request *rq) 935{ 936 struct request_sense sense; 937 int retries = 10; 938 unsigned int flags = rq->cmd_flags; 939 940 if (rq->sense == NULL) 941 rq->sense = &sense; 942 943 /* Start of retry loop. */ 944 do { 945 int error; 946 unsigned long time = jiffies; 947 rq->cmd_flags = flags; 948 949 error = ide_do_drive_cmd(drive, rq, ide_wait); 950 time = jiffies - time; 951 952 /* FIXME: we should probably abort/retry or something 953 * in case of failure */ 954 if (rq->cmd_flags & REQ_FAILED) { 955 /* The request failed. Retry if it was due to a unit 956 attention status 957 (usually means media was changed). */ 958 struct request_sense *reqbuf = rq->sense; 959 960 if (reqbuf->sense_key == UNIT_ATTENTION) 961 cdrom_saw_media_change(drive); 962 else if (reqbuf->sense_key == NOT_READY && 963 reqbuf->asc == 4 && reqbuf->ascq != 4) { 964 /* The drive is in the process of loading 965 a disk. Retry, but wait a little to give 966 the drive time to complete the load. */ 967 ssleep(2); 968 } else { 969 /* Otherwise, don't retry. */ 970 retries = 0; 971 } 972 --retries; 973 } 974 975 /* End of retry loop. */ 976 } while ((rq->cmd_flags & REQ_FAILED) && retries >= 0); 977 978 /* Return an error if the command failed. */ 979 return (rq->cmd_flags & REQ_FAILED) ? -EIO : 0; 980} 981 982/* 983 * Called from blk_end_request_callback() after the data of the request 984 * is completed and before the request is completed. 985 * By returning value '1', blk_end_request_callback() returns immediately 986 * without completing the request. 987 */ 988static int cdrom_newpc_intr_dummy_cb(struct request *rq) 989{ 990 return 1; 991} 992 993static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive) 994{ 995 struct cdrom_info *info = drive->driver_data; 996 struct request *rq = HWGROUP(drive)->rq; 997 xfer_func_t *xferfunc; 998 ide_expiry_t *expiry = NULL; 999 int dma_error = 0, dma, stat, ireason, len, thislen, uptodate = 0; 1000 int write = (rq_data_dir(rq) == WRITE) ? 1 : 0; 1001 unsigned int timeout; 1002 u8 lowcyl, highcyl; 1003 1004 /* Check for errors. */ 1005 dma = info->dma; 1006 if (dma) { 1007 info->dma = 0; 1008 dma_error = HWIF(drive)->ide_dma_end(drive); 1009 if (dma_error) { 1010 printk(KERN_ERR "%s: DMA %s error\n", drive->name, 1011 write ? "write" : "read"); 1012 ide_dma_off(drive); 1013 } 1014 } 1015 1016 if (cdrom_decode_status(drive, 0, &stat)) 1017 return ide_stopped; 1018 1019 /* 1020 * using dma, transfer is complete now 1021 */ 1022 if (dma) { 1023 if (dma_error) 1024 return ide_error(drive, "dma error", stat); 1025 if (blk_fs_request(rq)) { 1026 ide_end_request(drive, 1, rq->nr_sectors); 1027 return ide_stopped; 1028 } 1029 goto end_request; 1030 } 1031 1032 /* 1033 * ok we fall to pio :/ 1034 */ 1035 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3; 1036 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG); 1037 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG); 1038 1039 len = lowcyl + (256 * highcyl); 1040 1041 thislen = blk_fs_request(rq) ? len : rq->data_len; 1042 if (thislen > len) 1043 thislen = len; 1044 1045 /* 1046 * If DRQ is clear, the command has completed. 1047 */ 1048 if ((stat & DRQ_STAT) == 0) { 1049 if (blk_fs_request(rq)) { 1050 /* 1051 * If we're not done reading/writing, complain. 1052 * Otherwise, complete the command normally. 1053 */ 1054 uptodate = 1; 1055 if (rq->current_nr_sectors > 0) { 1056 printk(KERN_ERR "%s: %s: data underrun " 1057 "(%d blocks)\n", 1058 drive->name, __FUNCTION__, 1059 rq->current_nr_sectors); 1060 if (!write) 1061 rq->cmd_flags |= REQ_FAILED; 1062 uptodate = 0; 1063 } 1064 cdrom_end_request(drive, uptodate); 1065 return ide_stopped; 1066 } else if (!blk_pc_request(rq)) { 1067 ide_cd_request_sense_fixup(rq); 1068 /* Complain if we still have data left to transfer. */ 1069 uptodate = rq->data_len ? 0 : 1; 1070 } 1071 goto end_request; 1072 } 1073 1074 /* 1075 * check which way to transfer data 1076 */ 1077 if (ide_cd_check_ireason(drive, rq, len, ireason, write)) 1078 return ide_stopped; 1079 1080 if (blk_fs_request(rq)) { 1081 if (write == 0) { 1082 int nskip; 1083 1084 if (ide_cd_check_transfer_size(drive, len)) { 1085 cdrom_end_request(drive, 0); 1086 return ide_stopped; 1087 } 1088 1089 /* 1090 * First, figure out if we need to bit-bucket 1091 * any of the leading sectors. 1092 */ 1093 nskip = min_t(int, rq->current_nr_sectors 1094 - bio_cur_sectors(rq->bio), 1095 thislen >> 9); 1096 if (nskip > 0) { 1097 ide_cd_drain_data(drive, nskip); 1098 rq->current_nr_sectors -= nskip; 1099 thislen -= (nskip << 9); 1100 } 1101 } 1102 } 1103 1104 if (ireason == 0) { 1105 write = 1; 1106 xferfunc = HWIF(drive)->atapi_output_bytes; 1107 } else { 1108 write = 0; 1109 xferfunc = HWIF(drive)->atapi_input_bytes; 1110 } 1111 1112 /* 1113 * transfer data 1114 */ 1115 while (thislen > 0) { 1116 u8 *ptr = blk_fs_request(rq) ? NULL : rq->data; 1117 int blen = rq->data_len; 1118 1119 /* 1120 * bio backed? 1121 */ 1122 if (rq->bio) { 1123 if (blk_fs_request(rq)) { 1124 ptr = rq->buffer; 1125 blen = rq->current_nr_sectors << 9; 1126 } else { 1127 ptr = bio_data(rq->bio); 1128 blen = bio_iovec(rq->bio)->bv_len; 1129 } 1130 } 1131 1132 if (!ptr) { 1133 if (blk_fs_request(rq) && !write) 1134 /* 1135 * If the buffers are full, cache the rest 1136 * of the data in our internal buffer. 1137 */ 1138 cdrom_buffer_sectors(drive, rq->sector, 1139 thislen >> 9); 1140 else { 1141 printk(KERN_ERR "%s: confused, missing data\n", 1142 drive->name); 1143 blk_dump_rq_flags(rq, rq_data_dir(rq) 1144 ? "cdrom_newpc_intr, write" 1145 : "cdrom_newpc_intr, read"); 1146 } 1147 break; 1148 } 1149 1150 if (blen > thislen) 1151 blen = thislen; 1152 1153 xferfunc(drive, ptr, blen); 1154 1155 thislen -= blen; 1156 len -= blen; 1157 1158 if (blk_fs_request(rq)) { 1159 rq->buffer += blen; 1160 rq->nr_sectors -= (blen >> 9); 1161 rq->current_nr_sectors -= (blen >> 9); 1162 rq->sector += (blen >> 9); 1163 1164 if (rq->current_nr_sectors == 0 && rq->nr_sectors) 1165 cdrom_end_request(drive, 1); 1166 } else { 1167 rq->data_len -= blen; 1168 1169 /* 1170 * The request can't be completed until DRQ is cleared. 1171 * So complete the data, but don't complete the request 1172 * using the dummy function for the callback feature 1173 * of blk_end_request_callback(). 1174 */ 1175 if (rq->bio) 1176 blk_end_request_callback(rq, 0, blen, 1177 cdrom_newpc_intr_dummy_cb); 1178 else 1179 rq->data += blen; 1180 } 1181 if (!write && blk_sense_request(rq)) 1182 rq->sense_len += blen; 1183 } 1184 1185 /* 1186 * pad, if necessary 1187 */ 1188 if (!blk_fs_request(rq) && len > 0) 1189 ide_cd_pad_transfer(drive, xferfunc, len); 1190 1191 if (blk_pc_request(rq)) { 1192 timeout = rq->timeout; 1193 } else { 1194 timeout = ATAPI_WAIT_PC; 1195 if (!blk_fs_request(rq)) 1196 expiry = cdrom_timer_expiry; 1197 } 1198 1199 ide_set_handler(drive, cdrom_newpc_intr, timeout, expiry); 1200 return ide_started; 1201 1202end_request: 1203 if (blk_pc_request(rq)) { 1204 unsigned long flags; 1205 unsigned int dlen = rq->data_len; 1206 1207 if (dma) 1208 rq->data_len = 0; 1209 1210 spin_lock_irqsave(&ide_lock, flags); 1211 if (__blk_end_request(rq, 0, dlen)) 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 = ide_read_status(drive); 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 = be16_to_cpu(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 { "Optiarc DVD RW AD-5200A", NULL, IDE_CD_FLAG_PLAY_AUDIO_OK }, 1930 { NULL, NULL, 0 } 1931}; 1932 1933static unsigned int ide_cd_flags(struct hd_driveid *id) 1934{ 1935 const struct cd_list_entry *cle = ide_cd_quirks_list; 1936 1937 while (cle->id_model) { 1938 if (strcmp(cle->id_model, id->model) == 0 && 1939 (cle->id_firmware == NULL || 1940 strstr(id->fw_rev, cle->id_firmware))) 1941 return cle->cd_flags; 1942 cle++; 1943 } 1944 1945 return 0; 1946} 1947 1948static 1949int ide_cdrom_setup (ide_drive_t *drive) 1950{ 1951 struct cdrom_info *cd = drive->driver_data; 1952 struct cdrom_device_info *cdi = &cd->devinfo; 1953 struct hd_driveid *id = drive->id; 1954 int nslots; 1955 1956 blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn); 1957 blk_queue_dma_alignment(drive->queue, 31); 1958 drive->queue->unplug_delay = (1 * HZ) / 1000; 1959 if (!drive->queue->unplug_delay) 1960 drive->queue->unplug_delay = 1; 1961 1962 drive->special.all = 0; 1963 1964 cd->cd_flags = IDE_CD_FLAG_MEDIA_CHANGED | IDE_CD_FLAG_NO_EJECT | 1965 ide_cd_flags(id); 1966 1967 if ((id->config & 0x0060) == 0x20) 1968 cd->cd_flags |= IDE_CD_FLAG_DRQ_INTERRUPT; 1969 1970 if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_300_SSD) && 1971 id->fw_rev[4] == '1' && id->fw_rev[6] <= '2') 1972 cd->cd_flags |= (IDE_CD_FLAG_TOCTRACKS_AS_BCD | 1973 IDE_CD_FLAG_TOCADDR_AS_BCD); 1974 else if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_600_ESD) && 1975 id->fw_rev[4] == '1' && id->fw_rev[6] <= '2') 1976 cd->cd_flags |= IDE_CD_FLAG_TOCTRACKS_AS_BCD; 1977 else if (cd->cd_flags & IDE_CD_FLAG_SANYO_3CD) 1978 cdi->sanyo_slot = 3; /* 3 => use CD in slot 0 */ 1979 1980 nslots = ide_cdrom_probe_capabilities (drive); 1981 1982 /* 1983 * set correct block size 1984 */ 1985 blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE); 1986 1987 if (drive->autotune == IDE_TUNE_DEFAULT || 1988 drive->autotune == IDE_TUNE_AUTO) 1989 drive->dsc_overlap = (drive->next != drive); 1990 1991 if (ide_cdrom_register(drive, nslots)) { 1992 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name); 1993 cd->devinfo.handle = NULL; 1994 return 1; 1995 } 1996 ide_cdrom_add_settings(drive); 1997 return 0; 1998} 1999 2000#ifdef CONFIG_IDE_PROC_FS 2001static 2002sector_t ide_cdrom_capacity (ide_drive_t *drive) 2003{ 2004 unsigned long capacity, sectors_per_frame; 2005 2006 if (cdrom_read_capacity(drive, &capacity, §ors_per_frame, NULL)) 2007 return 0; 2008 2009 return capacity * sectors_per_frame; 2010} 2011#endif 2012 2013static void ide_cd_remove(ide_drive_t *drive) 2014{ 2015 struct cdrom_info *info = drive->driver_data; 2016 2017 ide_proc_unregister_driver(drive, info->driver); 2018 2019 del_gendisk(info->disk); 2020 2021 ide_cd_put(info); 2022} 2023 2024static void ide_cd_release(struct kref *kref) 2025{ 2026 struct cdrom_info *info = to_ide_cd(kref); 2027 struct cdrom_device_info *devinfo = &info->devinfo; 2028 ide_drive_t *drive = info->drive; 2029 struct gendisk *g = info->disk; 2030 2031 kfree(info->buffer); 2032 kfree(info->toc); 2033 if (devinfo->handle == drive && unregister_cdrom(devinfo)) 2034 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom " 2035 "driver.\n", __FUNCTION__, drive->name); 2036 drive->dsc_overlap = 0; 2037 drive->driver_data = NULL; 2038 blk_queue_prep_rq(drive->queue, NULL); 2039 g->private_data = NULL; 2040 put_disk(g); 2041 kfree(info); 2042} 2043 2044static int ide_cd_probe(ide_drive_t *); 2045 2046#ifdef CONFIG_IDE_PROC_FS 2047static int proc_idecd_read_capacity 2048 (char *page, char **start, off_t off, int count, int *eof, void *data) 2049{ 2050 ide_drive_t *drive = data; 2051 int len; 2052 2053 len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive)); 2054 PROC_IDE_READ_RETURN(page,start,off,count,eof,len); 2055} 2056 2057static ide_proc_entry_t idecd_proc[] = { 2058 { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL }, 2059 { NULL, 0, NULL, NULL } 2060}; 2061#endif 2062 2063static ide_driver_t ide_cdrom_driver = { 2064 .gen_driver = { 2065 .owner = THIS_MODULE, 2066 .name = "ide-cdrom", 2067 .bus = &ide_bus_type, 2068 }, 2069 .probe = ide_cd_probe, 2070 .remove = ide_cd_remove, 2071 .version = IDECD_VERSION, 2072 .media = ide_cdrom, 2073 .supports_dsc_overlap = 1, 2074 .do_request = ide_do_rw_cdrom, 2075 .end_request = ide_end_request, 2076 .error = __ide_error, 2077 .abort = __ide_abort, 2078#ifdef CONFIG_IDE_PROC_FS 2079 .proc = idecd_proc, 2080#endif 2081}; 2082 2083static int idecd_open(struct inode * inode, struct file * file) 2084{ 2085 struct gendisk *disk = inode->i_bdev->bd_disk; 2086 struct cdrom_info *info; 2087 int rc = -ENOMEM; 2088 2089 if (!(info = ide_cd_get(disk))) 2090 return -ENXIO; 2091 2092 if (!info->buffer) 2093 info->buffer = kmalloc(SECTOR_BUFFER_SIZE, GFP_KERNEL|__GFP_REPEAT); 2094 2095 if (info->buffer) 2096 rc = cdrom_open(&info->devinfo, inode, file); 2097 2098 if (rc < 0) 2099 ide_cd_put(info); 2100 2101 return rc; 2102} 2103 2104static int idecd_release(struct inode * inode, struct file * file) 2105{ 2106 struct gendisk *disk = inode->i_bdev->bd_disk; 2107 struct cdrom_info *info = ide_cd_g(disk); 2108 2109 cdrom_release (&info->devinfo, file); 2110 2111 ide_cd_put(info); 2112 2113 return 0; 2114} 2115 2116static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg) 2117{ 2118 struct packet_command cgc; 2119 char buffer[16]; 2120 int stat; 2121 char spindown; 2122 2123 if (copy_from_user(&spindown, (void __user *)arg, sizeof(char))) 2124 return -EFAULT; 2125 2126 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN); 2127 2128 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0); 2129 if (stat) 2130 return stat; 2131 2132 buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f); 2133 return cdrom_mode_select(cdi, &cgc); 2134} 2135 2136static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg) 2137{ 2138 struct packet_command cgc; 2139 char buffer[16]; 2140 int stat; 2141 char spindown; 2142 2143 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN); 2144 2145 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0); 2146 if (stat) 2147 return stat; 2148 2149 spindown = buffer[11] & 0x0f; 2150 if (copy_to_user((void __user *)arg, &spindown, sizeof (char))) 2151 return -EFAULT; 2152 return 0; 2153} 2154 2155static int idecd_ioctl (struct inode *inode, struct file *file, 2156 unsigned int cmd, unsigned long arg) 2157{ 2158 struct block_device *bdev = inode->i_bdev; 2159 struct cdrom_info *info = ide_cd_g(bdev->bd_disk); 2160 int err; 2161 2162 switch (cmd) { 2163 case CDROMSETSPINDOWN: 2164 return idecd_set_spindown(&info->devinfo, arg); 2165 case CDROMGETSPINDOWN: 2166 return idecd_get_spindown(&info->devinfo, arg); 2167 default: 2168 break; 2169 } 2170 2171 err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg); 2172 if (err == -EINVAL) 2173 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg); 2174 2175 return err; 2176} 2177 2178static int idecd_media_changed(struct gendisk *disk) 2179{ 2180 struct cdrom_info *info = ide_cd_g(disk); 2181 return cdrom_media_changed(&info->devinfo); 2182} 2183 2184static int idecd_revalidate_disk(struct gendisk *disk) 2185{ 2186 struct cdrom_info *info = ide_cd_g(disk); 2187 struct request_sense sense; 2188 2189 ide_cd_read_toc(info->drive, &sense); 2190 2191 return 0; 2192} 2193 2194static struct block_device_operations idecd_ops = { 2195 .owner = THIS_MODULE, 2196 .open = idecd_open, 2197 .release = idecd_release, 2198 .ioctl = idecd_ioctl, 2199 .media_changed = idecd_media_changed, 2200 .revalidate_disk= idecd_revalidate_disk 2201}; 2202 2203/* options */ 2204static char *ignore = NULL; 2205 2206module_param(ignore, charp, 0400); 2207MODULE_DESCRIPTION("ATAPI CD-ROM Driver"); 2208 2209static int ide_cd_probe(ide_drive_t *drive) 2210{ 2211 struct cdrom_info *info; 2212 struct gendisk *g; 2213 struct request_sense sense; 2214 2215 if (!strstr("ide-cdrom", drive->driver_req)) 2216 goto failed; 2217 if (!drive->present) 2218 goto failed; 2219 if (drive->media != ide_cdrom && drive->media != ide_optical) 2220 goto failed; 2221 /* skip drives that we were told to ignore */ 2222 if (ignore != NULL) { 2223 if (strstr(ignore, drive->name)) { 2224 printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name); 2225 goto failed; 2226 } 2227 } 2228 if (drive->scsi) { 2229 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name); 2230 goto failed; 2231 } 2232 info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL); 2233 if (info == NULL) { 2234 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name); 2235 goto failed; 2236 } 2237 2238 g = alloc_disk(1 << PARTN_BITS); 2239 if (!g) 2240 goto out_free_cd; 2241 2242 ide_init_disk(g, drive); 2243 2244 ide_proc_register_driver(drive, &ide_cdrom_driver); 2245 2246 kref_init(&info->kref); 2247 2248 info->drive = drive; 2249 info->driver = &ide_cdrom_driver; 2250 info->disk = g; 2251 2252 g->private_data = &info->driver; 2253 2254 drive->driver_data = info; 2255 2256 g->minors = 1; 2257 g->driverfs_dev = &drive->gendev; 2258 g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE; 2259 if (ide_cdrom_setup(drive)) { 2260 ide_proc_unregister_driver(drive, &ide_cdrom_driver); 2261 ide_cd_release(&info->kref); 2262 goto failed; 2263 } 2264 2265 ide_cd_read_toc(drive, &sense); 2266 g->fops = &idecd_ops; 2267 g->flags |= GENHD_FL_REMOVABLE; 2268 add_disk(g); 2269 return 0; 2270 2271out_free_cd: 2272 kfree(info); 2273failed: 2274 return -ENODEV; 2275} 2276 2277static void __exit ide_cdrom_exit(void) 2278{ 2279 driver_unregister(&ide_cdrom_driver.gen_driver); 2280} 2281 2282static int __init ide_cdrom_init(void) 2283{ 2284 return driver_register(&ide_cdrom_driver.gen_driver); 2285} 2286 2287MODULE_ALIAS("ide:*m-cdrom*"); 2288MODULE_ALIAS("ide-cd"); 2289module_init(ide_cdrom_init); 2290module_exit(ide_cdrom_exit); 2291MODULE_LICENSE("GPL"); 2292