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-2009 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.rst for usage information. 13 * 14 * Suggestions are welcome. Patches that work are more welcome though. ;-) 15 * 16 * Documentation: 17 * Mt. Fuji (SFF8090 version 4) and ATAPI (SFF-8020i rev 2.6) standards. 18 * 19 * For historical changelog please see: 20 * Documentation/ide/ChangeLog.ide-cd.1994-2004 21 */ 22 23#define DRV_NAME "ide-cd" 24#define PFX DRV_NAME ": " 25 26#define IDECD_VERSION "5.00" 27 28#include <linux/compat.h> 29#include <linux/module.h> 30#include <linux/types.h> 31#include <linux/kernel.h> 32#include <linux/sched/task_stack.h> 33#include <linux/delay.h> 34#include <linux/timer.h> 35#include <linux/seq_file.h> 36#include <linux/slab.h> 37#include <linux/interrupt.h> 38#include <linux/errno.h> 39#include <linux/cdrom.h> 40#include <linux/ide.h> 41#include <linux/completion.h> 42#include <linux/mutex.h> 43#include <linux/bcd.h> 44 45/* For SCSI -> ATAPI command conversion */ 46#include <scsi/scsi.h> 47 48#include <linux/io.h> 49#include <asm/byteorder.h> 50#include <linux/uaccess.h> 51#include <asm/unaligned.h> 52 53#include "ide-cd.h" 54 55static DEFINE_MUTEX(ide_cd_mutex); 56static DEFINE_MUTEX(idecd_ref_mutex); 57 58static void ide_cd_release(struct device *); 59 60static struct cdrom_info *ide_cd_get(struct gendisk *disk) 61{ 62 struct cdrom_info *cd = NULL; 63 64 mutex_lock(&idecd_ref_mutex); 65 cd = ide_drv_g(disk, cdrom_info); 66 if (cd) { 67 if (ide_device_get(cd->drive)) 68 cd = NULL; 69 else 70 get_device(&cd->dev); 71 72 } 73 mutex_unlock(&idecd_ref_mutex); 74 return cd; 75} 76 77static void ide_cd_put(struct cdrom_info *cd) 78{ 79 ide_drive_t *drive = cd->drive; 80 81 mutex_lock(&idecd_ref_mutex); 82 put_device(&cd->dev); 83 ide_device_put(drive); 84 mutex_unlock(&idecd_ref_mutex); 85} 86 87/* 88 * Generic packet command support and error handling routines. 89 */ 90 91/* Mark that we've seen a media change and invalidate our internal buffers. */ 92static void cdrom_saw_media_change(ide_drive_t *drive) 93{ 94 drive->dev_flags |= IDE_DFLAG_MEDIA_CHANGED; 95 drive->atapi_flags &= ~IDE_AFLAG_TOC_VALID; 96} 97 98static int cdrom_log_sense(ide_drive_t *drive, struct request *rq) 99{ 100 struct request_sense *sense = &drive->sense_data; 101 int log = 0; 102 103 if (!sense || !rq || (rq->rq_flags & RQF_QUIET)) 104 return 0; 105 106 ide_debug_log(IDE_DBG_SENSE, "sense_key: 0x%x", sense->sense_key); 107 108 switch (sense->sense_key) { 109 case NO_SENSE: 110 case RECOVERED_ERROR: 111 break; 112 case NOT_READY: 113 /* 114 * don't care about tray state messages for e.g. capacity 115 * commands or in-progress or becoming ready 116 */ 117 if (sense->asc == 0x3a || sense->asc == 0x04) 118 break; 119 log = 1; 120 break; 121 case ILLEGAL_REQUEST: 122 /* 123 * don't log START_STOP unit with LoEj set, since we cannot 124 * reliably check if drive can auto-close 125 */ 126 if (scsi_req(rq)->cmd[0] == GPCMD_START_STOP_UNIT && sense->asc == 0x24) 127 break; 128 log = 1; 129 break; 130 case UNIT_ATTENTION: 131 /* 132 * Make good and sure we've seen this potential media change. 133 * Some drives (i.e. Creative) fail to present the correct sense 134 * key in the error register. 135 */ 136 cdrom_saw_media_change(drive); 137 break; 138 default: 139 log = 1; 140 break; 141 } 142 return log; 143} 144 145static void cdrom_analyze_sense_data(ide_drive_t *drive, 146 struct request *failed_command) 147{ 148 struct request_sense *sense = &drive->sense_data; 149 struct cdrom_info *info = drive->driver_data; 150 unsigned long sector; 151 unsigned long bio_sectors; 152 153 ide_debug_log(IDE_DBG_SENSE, "error_code: 0x%x, sense_key: 0x%x", 154 sense->error_code, sense->sense_key); 155 156 if (failed_command) 157 ide_debug_log(IDE_DBG_SENSE, "failed cmd: 0x%x", 158 failed_command->cmd[0]); 159 160 if (!cdrom_log_sense(drive, failed_command)) 161 return; 162 163 /* 164 * If a read toc is executed for a CD-R or CD-RW medium where the first 165 * toc has not been recorded yet, it will fail with 05/24/00 (which is a 166 * confusing error) 167 */ 168 if (failed_command && scsi_req(failed_command)->cmd[0] == GPCMD_READ_TOC_PMA_ATIP) 169 if (sense->sense_key == 0x05 && sense->asc == 0x24) 170 return; 171 172 /* current error */ 173 if (sense->error_code == 0x70) { 174 switch (sense->sense_key) { 175 case MEDIUM_ERROR: 176 case VOLUME_OVERFLOW: 177 case ILLEGAL_REQUEST: 178 if (!sense->valid) 179 break; 180 if (failed_command == NULL || 181 blk_rq_is_passthrough(failed_command)) 182 break; 183 sector = (sense->information[0] << 24) | 184 (sense->information[1] << 16) | 185 (sense->information[2] << 8) | 186 (sense->information[3]); 187 188 if (queue_logical_block_size(drive->queue) == 2048) 189 /* device sector size is 2K */ 190 sector <<= 2; 191 192 bio_sectors = max(bio_sectors(failed_command->bio), 4U); 193 sector &= ~(bio_sectors - 1); 194 195 /* 196 * The SCSI specification allows for the value 197 * returned by READ CAPACITY to be up to 75 2K 198 * sectors past the last readable block. 199 * Therefore, if we hit a medium error within the 200 * last 75 2K sectors, we decrease the saved size 201 * value. 202 */ 203 if (sector < get_capacity(info->disk) && 204 drive->probed_capacity - sector < 4 * 75) 205 set_capacity(info->disk, sector); 206 } 207 } 208 209 ide_cd_log_error(drive->name, failed_command, sense); 210} 211 212static void ide_cd_complete_failed_rq(ide_drive_t *drive, struct request *rq) 213{ 214 /* 215 * For ATA_PRIV_SENSE, "ide_req(rq)->special" points to the original 216 * failed request. Also, the sense data should be read 217 * directly from rq which might be different from the original 218 * sense buffer if it got copied during mapping. 219 */ 220 struct request *failed = ide_req(rq)->special; 221 void *sense = bio_data(rq->bio); 222 223 if (failed) { 224 /* 225 * Sense is always read into drive->sense_data, copy back to the 226 * original request. 227 */ 228 memcpy(scsi_req(failed)->sense, sense, 18); 229 scsi_req(failed)->sense_len = scsi_req(rq)->sense_len; 230 cdrom_analyze_sense_data(drive, failed); 231 232 if (ide_end_rq(drive, failed, BLK_STS_IOERR, blk_rq_bytes(failed))) 233 BUG(); 234 } else 235 cdrom_analyze_sense_data(drive, NULL); 236} 237 238 239/* 240 * Allow the drive 5 seconds to recover; some devices will return NOT_READY 241 * while flushing data from cache. 242 * 243 * returns: 0 failed (write timeout expired) 244 * 1 success 245 */ 246static int ide_cd_breathe(ide_drive_t *drive, struct request *rq) 247{ 248 249 struct cdrom_info *info = drive->driver_data; 250 251 if (!scsi_req(rq)->result) 252 info->write_timeout = jiffies + ATAPI_WAIT_WRITE_BUSY; 253 254 scsi_req(rq)->result = 1; 255 256 if (time_after(jiffies, info->write_timeout)) 257 return 0; 258 else { 259 /* 260 * take a breather 261 */ 262 blk_mq_requeue_request(rq, false); 263 blk_mq_delay_kick_requeue_list(drive->queue, 1); 264 return 1; 265 } 266} 267 268static void ide_cd_free_sense(ide_drive_t *drive) 269{ 270 if (!drive->sense_rq) 271 return; 272 273 blk_mq_free_request(drive->sense_rq); 274 drive->sense_rq = NULL; 275 drive->sense_rq_armed = false; 276} 277 278/** 279 * Returns: 280 * 0: if the request should be continued. 281 * 1: if the request will be going through error recovery. 282 * 2: if the request should be ended. 283 */ 284static int cdrom_decode_status(ide_drive_t *drive, u8 stat) 285{ 286 ide_hwif_t *hwif = drive->hwif; 287 struct request *rq = hwif->rq; 288 int err, sense_key, do_end_request = 0; 289 290 /* get the IDE error register */ 291 err = ide_read_error(drive); 292 sense_key = err >> 4; 293 294 ide_debug_log(IDE_DBG_RQ, "cmd: 0x%x, rq->cmd_type: 0x%x, err: 0x%x, " 295 "stat 0x%x", 296 rq->cmd[0], rq->cmd_type, err, stat); 297 298 if (ata_sense_request(rq)) { 299 /* 300 * We got an error trying to get sense info from the drive 301 * (probably while trying to recover from a former error). 302 * Just give up. 303 */ 304 rq->rq_flags |= RQF_FAILED; 305 return 2; 306 } 307 308 /* if we have an error, pass CHECK_CONDITION as the SCSI status byte */ 309 if (blk_rq_is_scsi(rq) && !scsi_req(rq)->result) 310 scsi_req(rq)->result = SAM_STAT_CHECK_CONDITION; 311 312 if (blk_noretry_request(rq)) 313 do_end_request = 1; 314 315 switch (sense_key) { 316 case NOT_READY: 317 if (req_op(rq) == REQ_OP_WRITE) { 318 if (ide_cd_breathe(drive, rq)) 319 return 1; 320 } else { 321 cdrom_saw_media_change(drive); 322 323 if (!blk_rq_is_passthrough(rq) && 324 !(rq->rq_flags & RQF_QUIET)) 325 printk(KERN_ERR PFX "%s: tray open\n", 326 drive->name); 327 } 328 do_end_request = 1; 329 break; 330 case UNIT_ATTENTION: 331 cdrom_saw_media_change(drive); 332 333 if (blk_rq_is_passthrough(rq)) 334 return 0; 335 336 /* 337 * Arrange to retry the request but be sure to give up if we've 338 * retried too many times. 339 */ 340 if (++scsi_req(rq)->result > ERROR_MAX) 341 do_end_request = 1; 342 break; 343 case ILLEGAL_REQUEST: 344 /* 345 * Don't print error message for this condition -- SFF8090i 346 * indicates that 5/24/00 is the correct response to a request 347 * to close the tray if the drive doesn't have that capability. 348 * 349 * cdrom_log_sense() knows this! 350 */ 351 if (scsi_req(rq)->cmd[0] == GPCMD_START_STOP_UNIT) 352 break; 353 fallthrough; 354 case DATA_PROTECT: 355 /* 356 * No point in retrying after an illegal request or data 357 * protect error. 358 */ 359 if (!(rq->rq_flags & RQF_QUIET)) 360 ide_dump_status(drive, "command error", stat); 361 do_end_request = 1; 362 break; 363 case MEDIUM_ERROR: 364 /* 365 * No point in re-trying a zillion times on a bad sector. 366 * If we got here the error is not correctable. 367 */ 368 if (!(rq->rq_flags & RQF_QUIET)) 369 ide_dump_status(drive, "media error " 370 "(bad sector)", stat); 371 do_end_request = 1; 372 break; 373 case BLANK_CHECK: 374 /* disk appears blank? */ 375 if (!(rq->rq_flags & RQF_QUIET)) 376 ide_dump_status(drive, "media error (blank)", 377 stat); 378 do_end_request = 1; 379 break; 380 default: 381 if (blk_rq_is_passthrough(rq)) 382 break; 383 if (err & ~ATA_ABORTED) { 384 /* go to the default handler for other errors */ 385 ide_error(drive, "cdrom_decode_status", stat); 386 return 1; 387 } else if (++scsi_req(rq)->result > ERROR_MAX) 388 /* we've racked up too many retries, abort */ 389 do_end_request = 1; 390 } 391 392 if (blk_rq_is_passthrough(rq)) { 393 rq->rq_flags |= RQF_FAILED; 394 do_end_request = 1; 395 } 396 397 /* 398 * End a request through request sense analysis when we have sense data. 399 * We need this in order to perform end of media processing. 400 */ 401 if (do_end_request) 402 goto end_request; 403 404 /* if we got a CHECK_CONDITION status, queue a request sense command */ 405 if (stat & ATA_ERR) 406 return ide_queue_sense_rq(drive, NULL) ? 2 : 1; 407 return 1; 408 409end_request: 410 if (stat & ATA_ERR) { 411 hwif->rq = NULL; 412 return ide_queue_sense_rq(drive, rq) ? 2 : 1; 413 } else 414 return 2; 415} 416 417static void ide_cd_request_sense_fixup(ide_drive_t *drive, struct ide_cmd *cmd) 418{ 419 struct request *rq = cmd->rq; 420 421 ide_debug_log(IDE_DBG_FUNC, "rq->cmd[0]: 0x%x", rq->cmd[0]); 422 423 /* 424 * Some of the trailing request sense fields are optional, 425 * and some drives don't send them. Sigh. 426 */ 427 if (scsi_req(rq)->cmd[0] == GPCMD_REQUEST_SENSE && 428 cmd->nleft > 0 && cmd->nleft <= 5) 429 cmd->nleft = 0; 430} 431 432int ide_cd_queue_pc(ide_drive_t *drive, const unsigned char *cmd, 433 int write, void *buffer, unsigned *bufflen, 434 struct scsi_sense_hdr *sshdr, int timeout, 435 req_flags_t rq_flags) 436{ 437 struct cdrom_info *info = drive->driver_data; 438 struct scsi_sense_hdr local_sshdr; 439 int retries = 10; 440 bool failed; 441 442 ide_debug_log(IDE_DBG_PC, "cmd[0]: 0x%x, write: 0x%x, timeout: %d, " 443 "rq_flags: 0x%x", 444 cmd[0], write, timeout, rq_flags); 445 446 if (!sshdr) 447 sshdr = &local_sshdr; 448 449 /* start of retry loop */ 450 do { 451 struct request *rq; 452 int error; 453 bool delay = false; 454 455 rq = blk_get_request(drive->queue, 456 write ? REQ_OP_DRV_OUT : REQ_OP_DRV_IN, 0); 457 memcpy(scsi_req(rq)->cmd, cmd, BLK_MAX_CDB); 458 ide_req(rq)->type = ATA_PRIV_PC; 459 rq->rq_flags |= rq_flags; 460 rq->timeout = timeout; 461 if (buffer) { 462 error = blk_rq_map_kern(drive->queue, rq, buffer, 463 *bufflen, GFP_NOIO); 464 if (error) { 465 blk_put_request(rq); 466 return error; 467 } 468 } 469 470 blk_execute_rq(drive->queue, info->disk, rq, 0); 471 error = scsi_req(rq)->result ? -EIO : 0; 472 473 if (buffer) 474 *bufflen = scsi_req(rq)->resid_len; 475 scsi_normalize_sense(scsi_req(rq)->sense, 476 scsi_req(rq)->sense_len, sshdr); 477 478 /* 479 * FIXME: we should probably abort/retry or something in case of 480 * failure. 481 */ 482 failed = (rq->rq_flags & RQF_FAILED) != 0; 483 if (failed) { 484 /* 485 * The request failed. Retry if it was due to a unit 486 * attention status (usually means media was changed). 487 */ 488 if (sshdr->sense_key == UNIT_ATTENTION) 489 cdrom_saw_media_change(drive); 490 else if (sshdr->sense_key == NOT_READY && 491 sshdr->asc == 4 && sshdr->ascq != 4) { 492 /* 493 * The drive is in the process of loading 494 * a disk. Retry, but wait a little to give 495 * the drive time to complete the load. 496 */ 497 delay = true; 498 } else { 499 /* otherwise, don't retry */ 500 retries = 0; 501 } 502 --retries; 503 } 504 blk_put_request(rq); 505 if (delay) 506 ssleep(2); 507 } while (failed && retries >= 0); 508 509 /* return an error if the command failed */ 510 return failed ? -EIO : 0; 511} 512 513/* 514 * returns true if rq has been completed 515 */ 516static bool ide_cd_error_cmd(ide_drive_t *drive, struct ide_cmd *cmd) 517{ 518 unsigned int nr_bytes = cmd->nbytes - cmd->nleft; 519 520 if (cmd->tf_flags & IDE_TFLAG_WRITE) 521 nr_bytes -= cmd->last_xfer_len; 522 523 if (nr_bytes > 0) { 524 ide_complete_rq(drive, BLK_STS_OK, nr_bytes); 525 return true; 526 } 527 528 return false; 529} 530 531/* standard prep_rq that builds 10 byte cmds */ 532static bool ide_cdrom_prep_fs(struct request_queue *q, struct request *rq) 533{ 534 int hard_sect = queue_logical_block_size(q); 535 long block = (long)blk_rq_pos(rq) / (hard_sect >> 9); 536 unsigned long blocks = blk_rq_sectors(rq) / (hard_sect >> 9); 537 struct scsi_request *req = scsi_req(rq); 538 539 if (rq_data_dir(rq) == READ) 540 req->cmd[0] = GPCMD_READ_10; 541 else 542 req->cmd[0] = GPCMD_WRITE_10; 543 544 /* 545 * fill in lba 546 */ 547 req->cmd[2] = (block >> 24) & 0xff; 548 req->cmd[3] = (block >> 16) & 0xff; 549 req->cmd[4] = (block >> 8) & 0xff; 550 req->cmd[5] = block & 0xff; 551 552 /* 553 * and transfer length 554 */ 555 req->cmd[7] = (blocks >> 8) & 0xff; 556 req->cmd[8] = blocks & 0xff; 557 req->cmd_len = 10; 558 return true; 559} 560 561/* 562 * Most of the SCSI commands are supported directly by ATAPI devices. 563 * This transform handles the few exceptions. 564 */ 565static bool ide_cdrom_prep_pc(struct request *rq) 566{ 567 u8 *c = scsi_req(rq)->cmd; 568 569 /* transform 6-byte read/write commands to the 10-byte version */ 570 if (c[0] == READ_6 || c[0] == WRITE_6) { 571 c[8] = c[4]; 572 c[5] = c[3]; 573 c[4] = c[2]; 574 c[3] = c[1] & 0x1f; 575 c[2] = 0; 576 c[1] &= 0xe0; 577 c[0] += (READ_10 - READ_6); 578 scsi_req(rq)->cmd_len = 10; 579 return true; 580 } 581 582 /* 583 * it's silly to pretend we understand 6-byte sense commands, just 584 * reject with ILLEGAL_REQUEST and the caller should take the 585 * appropriate action 586 */ 587 if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) { 588 scsi_req(rq)->result = ILLEGAL_REQUEST; 589 return false; 590 } 591 592 return true; 593} 594 595static bool ide_cdrom_prep_rq(ide_drive_t *drive, struct request *rq) 596{ 597 if (!blk_rq_is_passthrough(rq)) { 598 scsi_req_init(scsi_req(rq)); 599 600 return ide_cdrom_prep_fs(drive->queue, rq); 601 } else if (blk_rq_is_scsi(rq)) 602 return ide_cdrom_prep_pc(rq); 603 604 return true; 605} 606 607static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive) 608{ 609 ide_hwif_t *hwif = drive->hwif; 610 struct ide_cmd *cmd = &hwif->cmd; 611 struct request *rq = hwif->rq; 612 ide_expiry_t *expiry = NULL; 613 int dma_error = 0, dma, thislen, uptodate = 0; 614 int write = (rq_data_dir(rq) == WRITE) ? 1 : 0, rc = 0; 615 int sense = ata_sense_request(rq); 616 unsigned int timeout; 617 u16 len; 618 u8 ireason, stat; 619 620 ide_debug_log(IDE_DBG_PC, "cmd: 0x%x, write: 0x%x", rq->cmd[0], write); 621 622 /* check for errors */ 623 dma = drive->dma; 624 if (dma) { 625 drive->dma = 0; 626 drive->waiting_for_dma = 0; 627 dma_error = hwif->dma_ops->dma_end(drive); 628 ide_dma_unmap_sg(drive, cmd); 629 if (dma_error) { 630 printk(KERN_ERR PFX "%s: DMA %s error\n", drive->name, 631 write ? "write" : "read"); 632 ide_dma_off(drive); 633 } 634 } 635 636 /* check status */ 637 stat = hwif->tp_ops->read_status(hwif); 638 639 if (!OK_STAT(stat, 0, BAD_R_STAT)) { 640 rc = cdrom_decode_status(drive, stat); 641 if (rc) { 642 if (rc == 2) 643 goto out_end; 644 return ide_stopped; 645 } 646 } 647 648 /* using dma, transfer is complete now */ 649 if (dma) { 650 if (dma_error) 651 return ide_error(drive, "dma error", stat); 652 uptodate = 1; 653 goto out_end; 654 } 655 656 ide_read_bcount_and_ireason(drive, &len, &ireason); 657 658 thislen = !blk_rq_is_passthrough(rq) ? len : cmd->nleft; 659 if (thislen > len) 660 thislen = len; 661 662 ide_debug_log(IDE_DBG_PC, "DRQ: stat: 0x%x, thislen: %d", 663 stat, thislen); 664 665 /* If DRQ is clear, the command has completed. */ 666 if ((stat & ATA_DRQ) == 0) { 667 switch (req_op(rq)) { 668 default: 669 /* 670 * If we're not done reading/writing, complain. 671 * Otherwise, complete the command normally. 672 */ 673 uptodate = 1; 674 if (cmd->nleft > 0) { 675 printk(KERN_ERR PFX "%s: %s: data underrun " 676 "(%u bytes)\n", drive->name, __func__, 677 cmd->nleft); 678 if (!write) 679 rq->rq_flags |= RQF_FAILED; 680 uptodate = 0; 681 } 682 goto out_end; 683 case REQ_OP_DRV_IN: 684 case REQ_OP_DRV_OUT: 685 ide_cd_request_sense_fixup(drive, cmd); 686 687 uptodate = cmd->nleft ? 0 : 1; 688 689 /* 690 * suck out the remaining bytes from the drive in an 691 * attempt to complete the data xfer. (see BZ#13399) 692 */ 693 if (!(stat & ATA_ERR) && !uptodate && thislen) { 694 ide_pio_bytes(drive, cmd, write, thislen); 695 uptodate = cmd->nleft ? 0 : 1; 696 } 697 698 if (!uptodate) 699 rq->rq_flags |= RQF_FAILED; 700 goto out_end; 701 case REQ_OP_SCSI_IN: 702 case REQ_OP_SCSI_OUT: 703 goto out_end; 704 } 705 } 706 707 rc = ide_check_ireason(drive, rq, len, ireason, write); 708 if (rc) 709 goto out_end; 710 711 cmd->last_xfer_len = 0; 712 713 ide_debug_log(IDE_DBG_PC, "data transfer, rq->cmd_type: 0x%x, " 714 "ireason: 0x%x", 715 rq->cmd_type, ireason); 716 717 /* transfer data */ 718 while (thislen > 0) { 719 int blen = min_t(int, thislen, cmd->nleft); 720 721 if (cmd->nleft == 0) 722 break; 723 724 ide_pio_bytes(drive, cmd, write, blen); 725 cmd->last_xfer_len += blen; 726 727 thislen -= blen; 728 len -= blen; 729 730 if (sense && write == 0) 731 scsi_req(rq)->sense_len += blen; 732 } 733 734 /* pad, if necessary */ 735 if (len > 0) { 736 if (blk_rq_is_passthrough(rq) || write == 0) 737 ide_pad_transfer(drive, write, len); 738 else { 739 printk(KERN_ERR PFX "%s: confused, missing data\n", 740 drive->name); 741 blk_dump_rq_flags(rq, "cdrom_newpc_intr"); 742 } 743 } 744 745 switch (req_op(rq)) { 746 case REQ_OP_SCSI_IN: 747 case REQ_OP_SCSI_OUT: 748 timeout = rq->timeout; 749 break; 750 case REQ_OP_DRV_IN: 751 case REQ_OP_DRV_OUT: 752 expiry = ide_cd_expiry; 753 fallthrough; 754 default: 755 timeout = ATAPI_WAIT_PC; 756 break; 757 } 758 759 hwif->expiry = expiry; 760 ide_set_handler(drive, cdrom_newpc_intr, timeout); 761 return ide_started; 762 763out_end: 764 if (blk_rq_is_scsi(rq) && rc == 0) { 765 scsi_req(rq)->resid_len = 0; 766 blk_mq_end_request(rq, BLK_STS_OK); 767 hwif->rq = NULL; 768 } else { 769 if (sense && uptodate) 770 ide_cd_complete_failed_rq(drive, rq); 771 772 if (!blk_rq_is_passthrough(rq)) { 773 if (cmd->nleft == 0) 774 uptodate = 1; 775 } else { 776 if (uptodate <= 0 && scsi_req(rq)->result == 0) 777 scsi_req(rq)->result = -EIO; 778 } 779 780 if (uptodate == 0 && rq->bio) 781 if (ide_cd_error_cmd(drive, cmd)) 782 return ide_stopped; 783 784 /* make sure it's fully ended */ 785 if (blk_rq_is_passthrough(rq)) { 786 scsi_req(rq)->resid_len -= cmd->nbytes - cmd->nleft; 787 if (uptodate == 0 && (cmd->tf_flags & IDE_TFLAG_WRITE)) 788 scsi_req(rq)->resid_len += cmd->last_xfer_len; 789 } 790 791 ide_complete_rq(drive, uptodate ? BLK_STS_OK : BLK_STS_IOERR, blk_rq_bytes(rq)); 792 793 if (sense && rc == 2) 794 ide_error(drive, "request sense failure", stat); 795 } 796 797 ide_cd_free_sense(drive); 798 return ide_stopped; 799} 800 801static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq) 802{ 803 struct cdrom_info *cd = drive->driver_data; 804 struct request_queue *q = drive->queue; 805 int write = rq_data_dir(rq) == WRITE; 806 unsigned short sectors_per_frame = 807 queue_logical_block_size(q) >> SECTOR_SHIFT; 808 809 ide_debug_log(IDE_DBG_RQ, "rq->cmd[0]: 0x%x, rq->cmd_flags: 0x%x, " 810 "secs_per_frame: %u", 811 rq->cmd[0], rq->cmd_flags, sectors_per_frame); 812 813 if (write) { 814 /* disk has become write protected */ 815 if (get_disk_ro(cd->disk)) 816 return ide_stopped; 817 } else { 818 /* 819 * We may be retrying this request after an error. Fix up any 820 * weirdness which might be present in the request packet. 821 */ 822 ide_cdrom_prep_rq(drive, rq); 823 } 824 825 /* fs requests *must* be hardware frame aligned */ 826 if ((blk_rq_sectors(rq) & (sectors_per_frame - 1)) || 827 (blk_rq_pos(rq) & (sectors_per_frame - 1))) 828 return ide_stopped; 829 830 /* use DMA, if possible */ 831 drive->dma = !!(drive->dev_flags & IDE_DFLAG_USING_DMA); 832 833 if (write) 834 cd->devinfo.media_written = 1; 835 836 rq->timeout = ATAPI_WAIT_PC; 837 838 return ide_started; 839} 840 841static void cdrom_do_block_pc(ide_drive_t *drive, struct request *rq) 842{ 843 844 ide_debug_log(IDE_DBG_PC, "rq->cmd[0]: 0x%x, rq->cmd_type: 0x%x", 845 rq->cmd[0], rq->cmd_type); 846 847 if (blk_rq_is_scsi(rq)) 848 rq->rq_flags |= RQF_QUIET; 849 else 850 rq->rq_flags &= ~RQF_FAILED; 851 852 drive->dma = 0; 853 854 /* sg request */ 855 if (rq->bio) { 856 struct request_queue *q = drive->queue; 857 char *buf = bio_data(rq->bio); 858 unsigned int alignment; 859 860 drive->dma = !!(drive->dev_flags & IDE_DFLAG_USING_DMA); 861 862 /* 863 * check if dma is safe 864 * 865 * NOTE! The "len" and "addr" checks should possibly have 866 * separate masks. 867 */ 868 alignment = queue_dma_alignment(q) | q->dma_pad_mask; 869 if ((unsigned long)buf & alignment 870 || blk_rq_bytes(rq) & q->dma_pad_mask 871 || object_is_on_stack(buf)) 872 drive->dma = 0; 873 } 874} 875 876static ide_startstop_t ide_cd_do_request(ide_drive_t *drive, struct request *rq, 877 sector_t block) 878{ 879 struct ide_cmd cmd; 880 int uptodate = 0; 881 unsigned int nsectors; 882 883 ide_debug_log(IDE_DBG_RQ, "cmd: 0x%x, block: %llu", 884 rq->cmd[0], (unsigned long long)block); 885 886 if (drive->debug_mask & IDE_DBG_RQ) 887 blk_dump_rq_flags(rq, "ide_cd_do_request"); 888 889 switch (req_op(rq)) { 890 default: 891 if (cdrom_start_rw(drive, rq) == ide_stopped) 892 goto out_end; 893 break; 894 case REQ_OP_SCSI_IN: 895 case REQ_OP_SCSI_OUT: 896 handle_pc: 897 if (!rq->timeout) 898 rq->timeout = ATAPI_WAIT_PC; 899 cdrom_do_block_pc(drive, rq); 900 break; 901 case REQ_OP_DRV_IN: 902 case REQ_OP_DRV_OUT: 903 switch (ide_req(rq)->type) { 904 case ATA_PRIV_MISC: 905 /* right now this can only be a reset... */ 906 uptodate = 1; 907 goto out_end; 908 case ATA_PRIV_SENSE: 909 case ATA_PRIV_PC: 910 goto handle_pc; 911 default: 912 BUG(); 913 } 914 } 915 916 /* prepare sense request for this command */ 917 ide_prep_sense(drive, rq); 918 919 memset(&cmd, 0, sizeof(cmd)); 920 921 if (rq_data_dir(rq)) 922 cmd.tf_flags |= IDE_TFLAG_WRITE; 923 924 cmd.rq = rq; 925 926 if (!blk_rq_is_passthrough(rq) || blk_rq_bytes(rq)) { 927 ide_init_sg_cmd(&cmd, blk_rq_bytes(rq)); 928 ide_map_sg(drive, &cmd); 929 } 930 931 return ide_issue_pc(drive, &cmd); 932out_end: 933 nsectors = blk_rq_sectors(rq); 934 935 if (nsectors == 0) 936 nsectors = 1; 937 938 ide_complete_rq(drive, uptodate ? BLK_STS_OK : BLK_STS_IOERR, nsectors << 9); 939 940 return ide_stopped; 941} 942 943/* 944 * Ioctl handling. 945 * 946 * Routines which queue packet commands take as a final argument a pointer to a 947 * request_sense struct. If execution of the command results in an error with a 948 * CHECK CONDITION status, this structure will be filled with the results of the 949 * subsequent request sense command. The pointer can also be NULL, in which case 950 * no sense information is returned. 951 */ 952static void msf_from_bcd(struct atapi_msf *msf) 953{ 954 msf->minute = bcd2bin(msf->minute); 955 msf->second = bcd2bin(msf->second); 956 msf->frame = bcd2bin(msf->frame); 957} 958 959int cdrom_check_status(ide_drive_t *drive, struct scsi_sense_hdr *sshdr) 960{ 961 struct cdrom_info *info = drive->driver_data; 962 struct cdrom_device_info *cdi; 963 unsigned char cmd[BLK_MAX_CDB]; 964 965 ide_debug_log(IDE_DBG_FUNC, "enter"); 966 967 if (!info) 968 return -EIO; 969 970 cdi = &info->devinfo; 971 972 memset(cmd, 0, BLK_MAX_CDB); 973 cmd[0] = GPCMD_TEST_UNIT_READY; 974 975 /* 976 * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to switch CDs 977 * instead of supporting the LOAD_UNLOAD opcode. 978 */ 979 cmd[7] = cdi->sanyo_slot % 3; 980 981 return ide_cd_queue_pc(drive, cmd, 0, NULL, NULL, sshdr, 0, RQF_QUIET); 982} 983 984static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity, 985 unsigned long *sectors_per_frame) 986{ 987 struct { 988 __be32 lba; 989 __be32 blocklen; 990 } capbuf; 991 992 int stat; 993 unsigned char cmd[BLK_MAX_CDB]; 994 unsigned len = sizeof(capbuf); 995 u32 blocklen; 996 997 ide_debug_log(IDE_DBG_FUNC, "enter"); 998 999 memset(cmd, 0, BLK_MAX_CDB); 1000 cmd[0] = GPCMD_READ_CDVD_CAPACITY; 1001 1002 stat = ide_cd_queue_pc(drive, cmd, 0, &capbuf, &len, NULL, 0, 1003 RQF_QUIET); 1004 if (stat) 1005 return stat; 1006 1007 /* 1008 * Sanity check the given block size, in so far as making 1009 * sure the sectors_per_frame we give to the caller won't 1010 * end up being bogus. 1011 */ 1012 blocklen = be32_to_cpu(capbuf.blocklen); 1013 blocklen = (blocklen >> SECTOR_SHIFT) << SECTOR_SHIFT; 1014 switch (blocklen) { 1015 case 512: 1016 case 1024: 1017 case 2048: 1018 case 4096: 1019 break; 1020 default: 1021 printk_once(KERN_ERR PFX "%s: weird block size %u; " 1022 "setting default block size to 2048\n", 1023 drive->name, blocklen); 1024 blocklen = 2048; 1025 break; 1026 } 1027 1028 *capacity = 1 + be32_to_cpu(capbuf.lba); 1029 *sectors_per_frame = blocklen >> SECTOR_SHIFT; 1030 1031 ide_debug_log(IDE_DBG_PROBE, "cap: %lu, sectors_per_frame: %lu", 1032 *capacity, *sectors_per_frame); 1033 1034 return 0; 1035} 1036 1037static int ide_cdrom_read_tocentry(ide_drive_t *drive, int trackno, 1038 int msf_flag, int format, char *buf, int buflen) 1039{ 1040 unsigned char cmd[BLK_MAX_CDB]; 1041 1042 ide_debug_log(IDE_DBG_FUNC, "enter"); 1043 1044 memset(cmd, 0, BLK_MAX_CDB); 1045 1046 cmd[0] = GPCMD_READ_TOC_PMA_ATIP; 1047 cmd[6] = trackno; 1048 cmd[7] = (buflen >> 8); 1049 cmd[8] = (buflen & 0xff); 1050 cmd[9] = (format << 6); 1051 1052 if (msf_flag) 1053 cmd[1] = 2; 1054 1055 return ide_cd_queue_pc(drive, cmd, 0, buf, &buflen, NULL, 0, RQF_QUIET); 1056} 1057 1058/* Try to read the entire TOC for the disk into our internal buffer. */ 1059int ide_cd_read_toc(ide_drive_t *drive) 1060{ 1061 int stat, ntracks, i; 1062 struct cdrom_info *info = drive->driver_data; 1063 struct cdrom_device_info *cdi = &info->devinfo; 1064 struct atapi_toc *toc = info->toc; 1065 struct { 1066 struct atapi_toc_header hdr; 1067 struct atapi_toc_entry ent; 1068 } ms_tmp; 1069 long last_written; 1070 unsigned long sectors_per_frame = SECTORS_PER_FRAME; 1071 1072 ide_debug_log(IDE_DBG_FUNC, "enter"); 1073 1074 if (toc == NULL) { 1075 /* try to allocate space */ 1076 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL); 1077 if (toc == NULL) { 1078 printk(KERN_ERR PFX "%s: No cdrom TOC buffer!\n", 1079 drive->name); 1080 return -ENOMEM; 1081 } 1082 info->toc = toc; 1083 } 1084 1085 /* 1086 * Check to see if the existing data is still valid. If it is, 1087 * just return. 1088 */ 1089 (void) cdrom_check_status(drive, NULL); 1090 1091 if (drive->atapi_flags & IDE_AFLAG_TOC_VALID) 1092 return 0; 1093 1094 /* try to get the total cdrom capacity and sector size */ 1095 stat = cdrom_read_capacity(drive, &toc->capacity, §ors_per_frame); 1096 if (stat) 1097 toc->capacity = 0x1fffff; 1098 1099 set_capacity(info->disk, toc->capacity * sectors_per_frame); 1100 /* save a private copy of the TOC capacity for error handling */ 1101 drive->probed_capacity = toc->capacity * sectors_per_frame; 1102 1103 blk_queue_logical_block_size(drive->queue, 1104 sectors_per_frame << SECTOR_SHIFT); 1105 1106 /* first read just the header, so we know how long the TOC is */ 1107 stat = ide_cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr, 1108 sizeof(struct atapi_toc_header)); 1109 if (stat) 1110 return stat; 1111 1112 if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD) { 1113 toc->hdr.first_track = bcd2bin(toc->hdr.first_track); 1114 toc->hdr.last_track = bcd2bin(toc->hdr.last_track); 1115 } 1116 1117 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1; 1118 if (ntracks <= 0) 1119 return -EIO; 1120 if (ntracks > MAX_TRACKS) 1121 ntracks = MAX_TRACKS; 1122 1123 /* now read the whole schmeer */ 1124 stat = ide_cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0, 1125 (char *)&toc->hdr, 1126 sizeof(struct atapi_toc_header) + 1127 (ntracks + 1) * 1128 sizeof(struct atapi_toc_entry)); 1129 1130 if (stat && toc->hdr.first_track > 1) { 1131 /* 1132 * Cds with CDI tracks only don't have any TOC entries, despite 1133 * of this the returned values are 1134 * first_track == last_track = number of CDI tracks + 1, 1135 * so that this case is indistinguishable from the same layout 1136 * plus an additional audio track. If we get an error for the 1137 * regular case, we assume a CDI without additional audio 1138 * tracks. In this case the readable TOC is empty (CDI tracks 1139 * are not included) and only holds the Leadout entry. 1140 * 1141 * Heiko Eißfeldt. 1142 */ 1143 ntracks = 0; 1144 stat = ide_cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0, 1145 (char *)&toc->hdr, 1146 sizeof(struct atapi_toc_header) + 1147 (ntracks + 1) * 1148 sizeof(struct atapi_toc_entry)); 1149 if (stat) 1150 return stat; 1151 1152 if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD) { 1153 toc->hdr.first_track = (u8)bin2bcd(CDROM_LEADOUT); 1154 toc->hdr.last_track = (u8)bin2bcd(CDROM_LEADOUT); 1155 } else { 1156 toc->hdr.first_track = CDROM_LEADOUT; 1157 toc->hdr.last_track = CDROM_LEADOUT; 1158 } 1159 } 1160 1161 if (stat) 1162 return stat; 1163 1164 toc->hdr.toc_length = be16_to_cpu(toc->hdr.toc_length); 1165 1166 if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD) { 1167 toc->hdr.first_track = bcd2bin(toc->hdr.first_track); 1168 toc->hdr.last_track = bcd2bin(toc->hdr.last_track); 1169 } 1170 1171 for (i = 0; i <= ntracks; i++) { 1172 if (drive->atapi_flags & IDE_AFLAG_TOCADDR_AS_BCD) { 1173 if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD) 1174 toc->ent[i].track = bcd2bin(toc->ent[i].track); 1175 msf_from_bcd(&toc->ent[i].addr.msf); 1176 } 1177 toc->ent[i].addr.lba = msf_to_lba(toc->ent[i].addr.msf.minute, 1178 toc->ent[i].addr.msf.second, 1179 toc->ent[i].addr.msf.frame); 1180 } 1181 1182 if (toc->hdr.first_track != CDROM_LEADOUT) { 1183 /* read the multisession information */ 1184 stat = ide_cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp, 1185 sizeof(ms_tmp)); 1186 if (stat) 1187 return stat; 1188 1189 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba); 1190 } else { 1191 ms_tmp.hdr.last_track = CDROM_LEADOUT; 1192 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track; 1193 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */ 1194 } 1195 1196 if (drive->atapi_flags & IDE_AFLAG_TOCADDR_AS_BCD) { 1197 /* re-read multisession information using MSF format */ 1198 stat = ide_cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp, 1199 sizeof(ms_tmp)); 1200 if (stat) 1201 return stat; 1202 1203 msf_from_bcd(&ms_tmp.ent.addr.msf); 1204 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute, 1205 ms_tmp.ent.addr.msf.second, 1206 ms_tmp.ent.addr.msf.frame); 1207 } 1208 1209 toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track); 1210 1211 /* now try to get the total cdrom capacity */ 1212 stat = cdrom_get_last_written(cdi, &last_written); 1213 if (!stat && (last_written > toc->capacity)) { 1214 toc->capacity = last_written; 1215 set_capacity(info->disk, toc->capacity * sectors_per_frame); 1216 drive->probed_capacity = toc->capacity * sectors_per_frame; 1217 } 1218 1219 /* Remember that we've read this stuff. */ 1220 drive->atapi_flags |= IDE_AFLAG_TOC_VALID; 1221 1222 return 0; 1223} 1224 1225int ide_cdrom_get_capabilities(ide_drive_t *drive, u8 *buf) 1226{ 1227 struct cdrom_info *info = drive->driver_data; 1228 struct cdrom_device_info *cdi = &info->devinfo; 1229 struct packet_command cgc; 1230 int stat, attempts = 3, size = ATAPI_CAPABILITIES_PAGE_SIZE; 1231 1232 ide_debug_log(IDE_DBG_FUNC, "enter"); 1233 1234 if ((drive->atapi_flags & IDE_AFLAG_FULL_CAPS_PAGE) == 0) 1235 size -= ATAPI_CAPABILITIES_PAGE_PAD_SIZE; 1236 1237 init_cdrom_command(&cgc, buf, size, CGC_DATA_UNKNOWN); 1238 do { 1239 /* we seem to get stat=0x01,err=0x00 the first time (??) */ 1240 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0); 1241 if (!stat) 1242 break; 1243 } while (--attempts); 1244 return stat; 1245} 1246 1247void ide_cdrom_update_speed(ide_drive_t *drive, u8 *buf) 1248{ 1249 struct cdrom_info *cd = drive->driver_data; 1250 u16 curspeed, maxspeed; 1251 1252 ide_debug_log(IDE_DBG_FUNC, "enter"); 1253 1254 if (drive->atapi_flags & IDE_AFLAG_LE_SPEED_FIELDS) { 1255 curspeed = le16_to_cpup((__le16 *)&buf[8 + 14]); 1256 maxspeed = le16_to_cpup((__le16 *)&buf[8 + 8]); 1257 } else { 1258 curspeed = be16_to_cpup((__be16 *)&buf[8 + 14]); 1259 maxspeed = be16_to_cpup((__be16 *)&buf[8 + 8]); 1260 } 1261 1262 ide_debug_log(IDE_DBG_PROBE, "curspeed: %u, maxspeed: %u", 1263 curspeed, maxspeed); 1264 1265 cd->current_speed = DIV_ROUND_CLOSEST(curspeed, 176); 1266 cd->max_speed = DIV_ROUND_CLOSEST(maxspeed, 176); 1267} 1268 1269#define IDE_CD_CAPABILITIES \ 1270 (CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | CDC_SELECT_SPEED | \ 1271 CDC_SELECT_DISC | CDC_MULTI_SESSION | CDC_MCN | CDC_MEDIA_CHANGED | \ 1272 CDC_PLAY_AUDIO | CDC_RESET | CDC_DRIVE_STATUS | CDC_CD_R | \ 1273 CDC_CD_RW | CDC_DVD | CDC_DVD_R | CDC_DVD_RAM | CDC_GENERIC_PACKET | \ 1274 CDC_MO_DRIVE | CDC_MRW | CDC_MRW_W | CDC_RAM) 1275 1276static const struct cdrom_device_ops ide_cdrom_dops = { 1277 .open = ide_cdrom_open_real, 1278 .release = ide_cdrom_release_real, 1279 .drive_status = ide_cdrom_drive_status, 1280 .check_events = ide_cdrom_check_events_real, 1281 .tray_move = ide_cdrom_tray_move, 1282 .lock_door = ide_cdrom_lock_door, 1283 .select_speed = ide_cdrom_select_speed, 1284 .get_last_session = ide_cdrom_get_last_session, 1285 .get_mcn = ide_cdrom_get_mcn, 1286 .reset = ide_cdrom_reset, 1287 .audio_ioctl = ide_cdrom_audio_ioctl, 1288 .capability = IDE_CD_CAPABILITIES, 1289 .generic_packet = ide_cdrom_packet, 1290}; 1291 1292static int ide_cdrom_register(ide_drive_t *drive, int nslots) 1293{ 1294 struct cdrom_info *info = drive->driver_data; 1295 struct cdrom_device_info *devinfo = &info->devinfo; 1296 1297 ide_debug_log(IDE_DBG_PROBE, "nslots: %d", nslots); 1298 1299 devinfo->ops = &ide_cdrom_dops; 1300 devinfo->speed = info->current_speed; 1301 devinfo->capacity = nslots; 1302 devinfo->handle = drive; 1303 strcpy(devinfo->name, drive->name); 1304 1305 if (drive->atapi_flags & IDE_AFLAG_NO_SPEED_SELECT) 1306 devinfo->mask |= CDC_SELECT_SPEED; 1307 1308 return register_cdrom(info->disk, devinfo); 1309} 1310 1311static int ide_cdrom_probe_capabilities(ide_drive_t *drive) 1312{ 1313 struct cdrom_info *cd = drive->driver_data; 1314 struct cdrom_device_info *cdi = &cd->devinfo; 1315 u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE]; 1316 mechtype_t mechtype; 1317 int nslots = 1; 1318 1319 ide_debug_log(IDE_DBG_PROBE, "media: 0x%x, atapi_flags: 0x%lx", 1320 drive->media, drive->atapi_flags); 1321 1322 cdi->mask = (CDC_CD_R | CDC_CD_RW | CDC_DVD | CDC_DVD_R | 1323 CDC_DVD_RAM | CDC_SELECT_DISC | CDC_PLAY_AUDIO | 1324 CDC_MO_DRIVE | CDC_RAM); 1325 1326 if (drive->media == ide_optical) { 1327 cdi->mask &= ~(CDC_MO_DRIVE | CDC_RAM); 1328 printk(KERN_ERR PFX "%s: ATAPI magneto-optical drive\n", 1329 drive->name); 1330 return nslots; 1331 } 1332 1333 if (drive->atapi_flags & IDE_AFLAG_PRE_ATAPI12) { 1334 drive->atapi_flags &= ~IDE_AFLAG_NO_EJECT; 1335 cdi->mask &= ~CDC_PLAY_AUDIO; 1336 return nslots; 1337 } 1338 1339 /* 1340 * We have to cheat a little here. the packet will eventually be queued 1341 * with ide_cdrom_packet(), which extracts the drive from cdi->handle. 1342 * Since this device hasn't been registered with the Uniform layer yet, 1343 * it can't do this. Same goes for cdi->ops. 1344 */ 1345 cdi->handle = drive; 1346 cdi->ops = &ide_cdrom_dops; 1347 1348 if (ide_cdrom_get_capabilities(drive, buf)) 1349 return 0; 1350 1351 if ((buf[8 + 6] & 0x01) == 0) 1352 drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING; 1353 if (buf[8 + 6] & 0x08) 1354 drive->atapi_flags &= ~IDE_AFLAG_NO_EJECT; 1355 if (buf[8 + 3] & 0x01) 1356 cdi->mask &= ~CDC_CD_R; 1357 if (buf[8 + 3] & 0x02) 1358 cdi->mask &= ~(CDC_CD_RW | CDC_RAM); 1359 if (buf[8 + 2] & 0x38) 1360 cdi->mask &= ~CDC_DVD; 1361 if (buf[8 + 3] & 0x20) 1362 cdi->mask &= ~(CDC_DVD_RAM | CDC_RAM); 1363 if (buf[8 + 3] & 0x10) 1364 cdi->mask &= ~CDC_DVD_R; 1365 if ((buf[8 + 4] & 0x01) || (drive->atapi_flags & IDE_AFLAG_PLAY_AUDIO_OK)) 1366 cdi->mask &= ~CDC_PLAY_AUDIO; 1367 1368 mechtype = buf[8 + 6] >> 5; 1369 if (mechtype == mechtype_caddy || 1370 mechtype == mechtype_popup || 1371 (drive->atapi_flags & IDE_AFLAG_NO_AUTOCLOSE)) 1372 cdi->mask |= CDC_CLOSE_TRAY; 1373 1374 if (cdi->sanyo_slot > 0) { 1375 cdi->mask &= ~CDC_SELECT_DISC; 1376 nslots = 3; 1377 } else if (mechtype == mechtype_individual_changer || 1378 mechtype == mechtype_cartridge_changer) { 1379 nslots = cdrom_number_of_slots(cdi); 1380 if (nslots > 1) 1381 cdi->mask &= ~CDC_SELECT_DISC; 1382 } 1383 1384 ide_cdrom_update_speed(drive, buf); 1385 1386 printk(KERN_INFO PFX "%s: ATAPI", drive->name); 1387 1388 /* don't print speed if the drive reported 0 */ 1389 if (cd->max_speed) 1390 printk(KERN_CONT " %dX", cd->max_speed); 1391 1392 printk(KERN_CONT " %s", (cdi->mask & CDC_DVD) ? "CD-ROM" : "DVD-ROM"); 1393 1394 if ((cdi->mask & CDC_DVD_R) == 0 || (cdi->mask & CDC_DVD_RAM) == 0) 1395 printk(KERN_CONT " DVD%s%s", 1396 (cdi->mask & CDC_DVD_R) ? "" : "-R", 1397 (cdi->mask & CDC_DVD_RAM) ? "" : "/RAM"); 1398 1399 if ((cdi->mask & CDC_CD_R) == 0 || (cdi->mask & CDC_CD_RW) == 0) 1400 printk(KERN_CONT " CD%s%s", 1401 (cdi->mask & CDC_CD_R) ? "" : "-R", 1402 (cdi->mask & CDC_CD_RW) ? "" : "/RW"); 1403 1404 if ((cdi->mask & CDC_SELECT_DISC) == 0) 1405 printk(KERN_CONT " changer w/%d slots", nslots); 1406 else 1407 printk(KERN_CONT " drive"); 1408 1409 printk(KERN_CONT ", %dkB Cache\n", 1410 be16_to_cpup((__be16 *)&buf[8 + 12])); 1411 1412 return nslots; 1413} 1414 1415struct cd_list_entry { 1416 const char *id_model; 1417 const char *id_firmware; 1418 unsigned int cd_flags; 1419}; 1420 1421#ifdef CONFIG_IDE_PROC_FS 1422static sector_t ide_cdrom_capacity(ide_drive_t *drive) 1423{ 1424 unsigned long capacity, sectors_per_frame; 1425 1426 if (cdrom_read_capacity(drive, &capacity, §ors_per_frame)) 1427 return 0; 1428 1429 return capacity * sectors_per_frame; 1430} 1431 1432static int idecd_capacity_proc_show(struct seq_file *m, void *v) 1433{ 1434 ide_drive_t *drive = m->private; 1435 1436 seq_printf(m, "%llu\n", (long long)ide_cdrom_capacity(drive)); 1437 return 0; 1438} 1439 1440static ide_proc_entry_t idecd_proc[] = { 1441 { "capacity", S_IFREG|S_IRUGO, idecd_capacity_proc_show }, 1442 {} 1443}; 1444 1445static ide_proc_entry_t *ide_cd_proc_entries(ide_drive_t *drive) 1446{ 1447 return idecd_proc; 1448} 1449 1450static const struct ide_proc_devset *ide_cd_proc_devsets(ide_drive_t *drive) 1451{ 1452 return NULL; 1453} 1454#endif 1455 1456static const struct cd_list_entry ide_cd_quirks_list[] = { 1457 /* SCR-3231 doesn't support the SET_CD_SPEED command. */ 1458 { "SAMSUNG CD-ROM SCR-3231", NULL, IDE_AFLAG_NO_SPEED_SELECT }, 1459 /* Old NEC260 (not R) was released before ATAPI 1.2 spec. */ 1460 { "NEC CD-ROM DRIVE:260", "1.01", IDE_AFLAG_TOCADDR_AS_BCD | 1461 IDE_AFLAG_PRE_ATAPI12, }, 1462 /* Vertos 300, some versions of this drive like to talk BCD. */ 1463 { "V003S0DS", NULL, IDE_AFLAG_VERTOS_300_SSD, }, 1464 /* Vertos 600 ESD. */ 1465 { "V006E0DS", NULL, IDE_AFLAG_VERTOS_600_ESD, }, 1466 /* 1467 * Sanyo 3 CD changer uses a non-standard command for CD changing 1468 * (by default standard ATAPI support for CD changers is used). 1469 */ 1470 { "CD-ROM CDR-C3 G", NULL, IDE_AFLAG_SANYO_3CD }, 1471 { "CD-ROM CDR-C3G", NULL, IDE_AFLAG_SANYO_3CD }, 1472 { "CD-ROM CDR_C36", NULL, IDE_AFLAG_SANYO_3CD }, 1473 /* Stingray 8X CD-ROM. */ 1474 { "STINGRAY 8422 IDE 8X CD-ROM 7-27-95", NULL, IDE_AFLAG_PRE_ATAPI12 }, 1475 /* 1476 * ACER 50X CD-ROM and WPI 32X CD-ROM require the full spec length 1477 * mode sense page capabilities size, but older drives break. 1478 */ 1479 { "ATAPI CD ROM DRIVE 50X MAX", NULL, IDE_AFLAG_FULL_CAPS_PAGE }, 1480 { "WPI CDS-32X", NULL, IDE_AFLAG_FULL_CAPS_PAGE }, 1481 /* ACER/AOpen 24X CD-ROM has the speed fields byte-swapped. */ 1482 { "", "241N", IDE_AFLAG_LE_SPEED_FIELDS }, 1483 /* 1484 * Some drives used by Apple don't advertise audio play 1485 * but they do support reading TOC & audio datas. 1486 */ 1487 { "MATSHITADVD-ROM SR-8187", NULL, IDE_AFLAG_PLAY_AUDIO_OK }, 1488 { "MATSHITADVD-ROM SR-8186", NULL, IDE_AFLAG_PLAY_AUDIO_OK }, 1489 { "MATSHITADVD-ROM SR-8176", NULL, IDE_AFLAG_PLAY_AUDIO_OK }, 1490 { "MATSHITADVD-ROM SR-8174", NULL, IDE_AFLAG_PLAY_AUDIO_OK }, 1491 { "Optiarc DVD RW AD-5200A", NULL, IDE_AFLAG_PLAY_AUDIO_OK }, 1492 { "Optiarc DVD RW AD-7200A", NULL, IDE_AFLAG_PLAY_AUDIO_OK }, 1493 { "Optiarc DVD RW AD-7543A", NULL, IDE_AFLAG_NO_AUTOCLOSE }, 1494 { "TEAC CD-ROM CD-224E", NULL, IDE_AFLAG_NO_AUTOCLOSE }, 1495 { NULL, NULL, 0 } 1496}; 1497 1498static unsigned int ide_cd_flags(u16 *id) 1499{ 1500 const struct cd_list_entry *cle = ide_cd_quirks_list; 1501 1502 while (cle->id_model) { 1503 if (strcmp(cle->id_model, (char *)&id[ATA_ID_PROD]) == 0 && 1504 (cle->id_firmware == NULL || 1505 strstr((char *)&id[ATA_ID_FW_REV], cle->id_firmware))) 1506 return cle->cd_flags; 1507 cle++; 1508 } 1509 1510 return 0; 1511} 1512 1513static int ide_cdrom_setup(ide_drive_t *drive) 1514{ 1515 struct cdrom_info *cd = drive->driver_data; 1516 struct cdrom_device_info *cdi = &cd->devinfo; 1517 struct request_queue *q = drive->queue; 1518 u16 *id = drive->id; 1519 char *fw_rev = (char *)&id[ATA_ID_FW_REV]; 1520 int nslots; 1521 1522 ide_debug_log(IDE_DBG_PROBE, "enter"); 1523 1524 drive->prep_rq = ide_cdrom_prep_rq; 1525 blk_queue_dma_alignment(q, 31); 1526 blk_queue_update_dma_pad(q, 15); 1527 1528 drive->dev_flags |= IDE_DFLAG_MEDIA_CHANGED; 1529 drive->atapi_flags = IDE_AFLAG_NO_EJECT | ide_cd_flags(id); 1530 1531 if ((drive->atapi_flags & IDE_AFLAG_VERTOS_300_SSD) && 1532 fw_rev[4] == '1' && fw_rev[6] <= '2') 1533 drive->atapi_flags |= (IDE_AFLAG_TOCTRACKS_AS_BCD | 1534 IDE_AFLAG_TOCADDR_AS_BCD); 1535 else if ((drive->atapi_flags & IDE_AFLAG_VERTOS_600_ESD) && 1536 fw_rev[4] == '1' && fw_rev[6] <= '2') 1537 drive->atapi_flags |= IDE_AFLAG_TOCTRACKS_AS_BCD; 1538 else if (drive->atapi_flags & IDE_AFLAG_SANYO_3CD) 1539 /* 3 => use CD in slot 0 */ 1540 cdi->sanyo_slot = 3; 1541 1542 nslots = ide_cdrom_probe_capabilities(drive); 1543 1544 blk_queue_logical_block_size(q, CD_FRAMESIZE); 1545 1546 if (ide_cdrom_register(drive, nslots)) { 1547 printk(KERN_ERR PFX "%s: %s failed to register device with the" 1548 " cdrom driver.\n", drive->name, __func__); 1549 cd->devinfo.handle = NULL; 1550 return 1; 1551 } 1552 1553 ide_proc_register_driver(drive, cd->driver); 1554 return 0; 1555} 1556 1557static void ide_cd_remove(ide_drive_t *drive) 1558{ 1559 struct cdrom_info *info = drive->driver_data; 1560 1561 ide_debug_log(IDE_DBG_FUNC, "enter"); 1562 1563 ide_proc_unregister_driver(drive, info->driver); 1564 device_del(&info->dev); 1565 del_gendisk(info->disk); 1566 1567 mutex_lock(&idecd_ref_mutex); 1568 put_device(&info->dev); 1569 mutex_unlock(&idecd_ref_mutex); 1570} 1571 1572static void ide_cd_release(struct device *dev) 1573{ 1574 struct cdrom_info *info = to_ide_drv(dev, cdrom_info); 1575 struct cdrom_device_info *devinfo = &info->devinfo; 1576 ide_drive_t *drive = info->drive; 1577 struct gendisk *g = info->disk; 1578 1579 ide_debug_log(IDE_DBG_FUNC, "enter"); 1580 1581 kfree(info->toc); 1582 if (devinfo->handle == drive) 1583 unregister_cdrom(devinfo); 1584 drive->driver_data = NULL; 1585 drive->prep_rq = NULL; 1586 g->private_data = NULL; 1587 put_disk(g); 1588 kfree(info); 1589} 1590 1591static int ide_cd_probe(ide_drive_t *); 1592 1593static struct ide_driver ide_cdrom_driver = { 1594 .gen_driver = { 1595 .owner = THIS_MODULE, 1596 .name = "ide-cdrom", 1597 .bus = &ide_bus_type, 1598 }, 1599 .probe = ide_cd_probe, 1600 .remove = ide_cd_remove, 1601 .version = IDECD_VERSION, 1602 .do_request = ide_cd_do_request, 1603#ifdef CONFIG_IDE_PROC_FS 1604 .proc_entries = ide_cd_proc_entries, 1605 .proc_devsets = ide_cd_proc_devsets, 1606#endif 1607}; 1608 1609static int idecd_open(struct block_device *bdev, fmode_t mode) 1610{ 1611 struct cdrom_info *info; 1612 int rc = -ENXIO; 1613 1614 if (bdev_check_media_change(bdev)) { 1615 info = ide_drv_g(bdev->bd_disk, cdrom_info); 1616 1617 ide_cd_read_toc(info->drive); 1618 } 1619 1620 mutex_lock(&ide_cd_mutex); 1621 info = ide_cd_get(bdev->bd_disk); 1622 if (!info) 1623 goto out; 1624 1625 rc = cdrom_open(&info->devinfo, bdev, mode); 1626 if (rc < 0) 1627 ide_cd_put(info); 1628out: 1629 mutex_unlock(&ide_cd_mutex); 1630 return rc; 1631} 1632 1633static void idecd_release(struct gendisk *disk, fmode_t mode) 1634{ 1635 struct cdrom_info *info = ide_drv_g(disk, cdrom_info); 1636 1637 mutex_lock(&ide_cd_mutex); 1638 cdrom_release(&info->devinfo, mode); 1639 1640 ide_cd_put(info); 1641 mutex_unlock(&ide_cd_mutex); 1642} 1643 1644static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg) 1645{ 1646 struct packet_command cgc; 1647 char buffer[16]; 1648 int stat; 1649 char spindown; 1650 1651 if (copy_from_user(&spindown, (void __user *)arg, sizeof(char))) 1652 return -EFAULT; 1653 1654 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN); 1655 1656 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0); 1657 if (stat) 1658 return stat; 1659 1660 buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f); 1661 return cdrom_mode_select(cdi, &cgc); 1662} 1663 1664static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg) 1665{ 1666 struct packet_command cgc; 1667 char buffer[16]; 1668 int stat; 1669 char spindown; 1670 1671 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN); 1672 1673 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0); 1674 if (stat) 1675 return stat; 1676 1677 spindown = buffer[11] & 0x0f; 1678 if (copy_to_user((void __user *)arg, &spindown, sizeof(char))) 1679 return -EFAULT; 1680 return 0; 1681} 1682 1683static int idecd_locked_ioctl(struct block_device *bdev, fmode_t mode, 1684 unsigned int cmd, unsigned long arg) 1685{ 1686 struct cdrom_info *info = ide_drv_g(bdev->bd_disk, cdrom_info); 1687 int err; 1688 1689 switch (cmd) { 1690 case CDROMSETSPINDOWN: 1691 return idecd_set_spindown(&info->devinfo, arg); 1692 case CDROMGETSPINDOWN: 1693 return idecd_get_spindown(&info->devinfo, arg); 1694 default: 1695 break; 1696 } 1697 1698 err = generic_ide_ioctl(info->drive, bdev, cmd, arg); 1699 if (err == -EINVAL) 1700 err = cdrom_ioctl(&info->devinfo, bdev, mode, cmd, arg); 1701 1702 return err; 1703} 1704 1705static int idecd_ioctl(struct block_device *bdev, fmode_t mode, 1706 unsigned int cmd, unsigned long arg) 1707{ 1708 int ret; 1709 1710 mutex_lock(&ide_cd_mutex); 1711 ret = idecd_locked_ioctl(bdev, mode, cmd, arg); 1712 mutex_unlock(&ide_cd_mutex); 1713 1714 return ret; 1715} 1716 1717static int idecd_locked_compat_ioctl(struct block_device *bdev, fmode_t mode, 1718 unsigned int cmd, unsigned long arg) 1719{ 1720 struct cdrom_info *info = ide_drv_g(bdev->bd_disk, cdrom_info); 1721 void __user *argp = compat_ptr(arg); 1722 int err; 1723 1724 switch (cmd) { 1725 case CDROMSETSPINDOWN: 1726 return idecd_set_spindown(&info->devinfo, (unsigned long)argp); 1727 case CDROMGETSPINDOWN: 1728 return idecd_get_spindown(&info->devinfo, (unsigned long)argp); 1729 default: 1730 break; 1731 } 1732 1733 err = generic_ide_ioctl(info->drive, bdev, cmd, arg); 1734 if (err == -EINVAL) 1735 err = cdrom_ioctl(&info->devinfo, bdev, mode, cmd, 1736 (unsigned long)argp); 1737 1738 return err; 1739} 1740 1741static int idecd_compat_ioctl(struct block_device *bdev, fmode_t mode, 1742 unsigned int cmd, unsigned long arg) 1743{ 1744 int ret; 1745 1746 mutex_lock(&ide_cd_mutex); 1747 ret = idecd_locked_compat_ioctl(bdev, mode, cmd, arg); 1748 mutex_unlock(&ide_cd_mutex); 1749 1750 return ret; 1751} 1752 1753static unsigned int idecd_check_events(struct gendisk *disk, 1754 unsigned int clearing) 1755{ 1756 struct cdrom_info *info = ide_drv_g(disk, cdrom_info); 1757 return cdrom_check_events(&info->devinfo, clearing); 1758} 1759 1760static const struct block_device_operations idecd_ops = { 1761 .owner = THIS_MODULE, 1762 .open = idecd_open, 1763 .release = idecd_release, 1764 .ioctl = idecd_ioctl, 1765 .compat_ioctl = IS_ENABLED(CONFIG_COMPAT) ? 1766 idecd_compat_ioctl : NULL, 1767 .check_events = idecd_check_events, 1768}; 1769 1770/* module options */ 1771static unsigned long debug_mask; 1772module_param(debug_mask, ulong, 0644); 1773 1774MODULE_DESCRIPTION("ATAPI CD-ROM Driver"); 1775 1776static int ide_cd_probe(ide_drive_t *drive) 1777{ 1778 struct cdrom_info *info; 1779 struct gendisk *g; 1780 1781 ide_debug_log(IDE_DBG_PROBE, "driver_req: %s, media: 0x%x", 1782 drive->driver_req, drive->media); 1783 1784 if (!strstr("ide-cdrom", drive->driver_req)) 1785 goto failed; 1786 1787 if (drive->media != ide_cdrom && drive->media != ide_optical) 1788 goto failed; 1789 1790 drive->debug_mask = debug_mask; 1791 drive->irq_handler = cdrom_newpc_intr; 1792 1793 info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL); 1794 if (info == NULL) { 1795 printk(KERN_ERR PFX "%s: Can't allocate a cdrom structure\n", 1796 drive->name); 1797 goto failed; 1798 } 1799 1800 g = alloc_disk(1 << PARTN_BITS); 1801 if (!g) 1802 goto out_free_cd; 1803 1804 ide_init_disk(g, drive); 1805 1806 info->dev.parent = &drive->gendev; 1807 info->dev.release = ide_cd_release; 1808 dev_set_name(&info->dev, "%s", dev_name(&drive->gendev)); 1809 1810 if (device_register(&info->dev)) 1811 goto out_free_disk; 1812 1813 info->drive = drive; 1814 info->driver = &ide_cdrom_driver; 1815 info->disk = g; 1816 1817 g->private_data = &info->driver; 1818 1819 drive->driver_data = info; 1820 1821 g->minors = 1; 1822 g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE; 1823 if (ide_cdrom_setup(drive)) { 1824 put_device(&info->dev); 1825 goto failed; 1826 } 1827 1828 ide_cd_read_toc(drive); 1829 g->fops = &idecd_ops; 1830 g->flags |= GENHD_FL_REMOVABLE | GENHD_FL_BLOCK_EVENTS_ON_EXCL_WRITE; 1831 g->events = DISK_EVENT_MEDIA_CHANGE; 1832 device_add_disk(&drive->gendev, g, NULL); 1833 return 0; 1834 1835out_free_disk: 1836 put_disk(g); 1837out_free_cd: 1838 kfree(info); 1839failed: 1840 return -ENODEV; 1841} 1842 1843static void __exit ide_cdrom_exit(void) 1844{ 1845 driver_unregister(&ide_cdrom_driver.gen_driver); 1846} 1847 1848static int __init ide_cdrom_init(void) 1849{ 1850 printk(KERN_INFO DRV_NAME " driver " IDECD_VERSION "\n"); 1851 return driver_register(&ide_cdrom_driver.gen_driver); 1852} 1853 1854MODULE_ALIAS("ide:*m-cdrom*"); 1855MODULE_ALIAS("ide-cd"); 1856module_init(ide_cdrom_init); 1857module_exit(ide_cdrom_exit); 1858MODULE_LICENSE("GPL"); 1859