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