1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * ATAPI support. 4 */ 5 6#include <linux/kernel.h> 7#include <linux/cdrom.h> 8#include <linux/delay.h> 9#include <linux/export.h> 10#include <linux/ide.h> 11#include <linux/scatterlist.h> 12#include <linux/gfp.h> 13 14#include <scsi/scsi.h> 15 16#define DRV_NAME "ide-atapi" 17#define PFX DRV_NAME ": " 18 19#ifdef DEBUG 20#define debug_log(fmt, args...) \ 21 printk(KERN_INFO "ide: " fmt, ## args) 22#else 23#define debug_log(fmt, args...) do {} while (0) 24#endif 25 26#define ATAPI_MIN_CDB_BYTES 12 27 28static inline int dev_is_idecd(ide_drive_t *drive) 29{ 30 return drive->media == ide_cdrom || drive->media == ide_optical; 31} 32 33/* 34 * Check whether we can support a device, 35 * based on the ATAPI IDENTIFY command results. 36 */ 37int ide_check_atapi_device(ide_drive_t *drive, const char *s) 38{ 39 u16 *id = drive->id; 40 u8 gcw[2], protocol, device_type, removable, drq_type, packet_size; 41 42 *((u16 *)&gcw) = id[ATA_ID_CONFIG]; 43 44 protocol = (gcw[1] & 0xC0) >> 6; 45 device_type = gcw[1] & 0x1F; 46 removable = (gcw[0] & 0x80) >> 7; 47 drq_type = (gcw[0] & 0x60) >> 5; 48 packet_size = gcw[0] & 0x03; 49 50#ifdef CONFIG_PPC 51 /* kludge for Apple PowerBook internal zip */ 52 if (drive->media == ide_floppy && device_type == 5 && 53 !strstr((char *)&id[ATA_ID_PROD], "CD-ROM") && 54 strstr((char *)&id[ATA_ID_PROD], "ZIP")) 55 device_type = 0; 56#endif 57 58 if (protocol != 2) 59 printk(KERN_ERR "%s: %s: protocol (0x%02x) is not ATAPI\n", 60 s, drive->name, protocol); 61 else if ((drive->media == ide_floppy && device_type != 0) || 62 (drive->media == ide_tape && device_type != 1)) 63 printk(KERN_ERR "%s: %s: invalid device type (0x%02x)\n", 64 s, drive->name, device_type); 65 else if (removable == 0) 66 printk(KERN_ERR "%s: %s: the removable flag is not set\n", 67 s, drive->name); 68 else if (drive->media == ide_floppy && drq_type == 3) 69 printk(KERN_ERR "%s: %s: sorry, DRQ type (0x%02x) not " 70 "supported\n", s, drive->name, drq_type); 71 else if (packet_size != 0) 72 printk(KERN_ERR "%s: %s: packet size (0x%02x) is not 12 " 73 "bytes\n", s, drive->name, packet_size); 74 else 75 return 1; 76 return 0; 77} 78EXPORT_SYMBOL_GPL(ide_check_atapi_device); 79 80void ide_init_pc(struct ide_atapi_pc *pc) 81{ 82 memset(pc, 0, sizeof(*pc)); 83} 84EXPORT_SYMBOL_GPL(ide_init_pc); 85 86/* 87 * Add a special packet command request to the tail of the request queue, 88 * and wait for it to be serviced. 89 */ 90int ide_queue_pc_tail(ide_drive_t *drive, struct gendisk *disk, 91 struct ide_atapi_pc *pc, void *buf, unsigned int bufflen) 92{ 93 struct request *rq; 94 int error; 95 96 rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, 0); 97 ide_req(rq)->type = ATA_PRIV_MISC; 98 ide_req(rq)->special = pc; 99 100 if (buf && bufflen) { 101 error = blk_rq_map_kern(drive->queue, rq, buf, bufflen, 102 GFP_NOIO); 103 if (error) 104 goto put_req; 105 } 106 107 memcpy(scsi_req(rq)->cmd, pc->c, 12); 108 if (drive->media == ide_tape) 109 scsi_req(rq)->cmd[13] = REQ_IDETAPE_PC1; 110 blk_execute_rq(drive->queue, disk, rq, 0); 111 error = scsi_req(rq)->result ? -EIO : 0; 112put_req: 113 blk_put_request(rq); 114 return error; 115} 116EXPORT_SYMBOL_GPL(ide_queue_pc_tail); 117 118int ide_do_test_unit_ready(ide_drive_t *drive, struct gendisk *disk) 119{ 120 struct ide_atapi_pc pc; 121 122 ide_init_pc(&pc); 123 pc.c[0] = TEST_UNIT_READY; 124 125 return ide_queue_pc_tail(drive, disk, &pc, NULL, 0); 126} 127EXPORT_SYMBOL_GPL(ide_do_test_unit_ready); 128 129int ide_do_start_stop(ide_drive_t *drive, struct gendisk *disk, int start) 130{ 131 struct ide_atapi_pc pc; 132 133 ide_init_pc(&pc); 134 pc.c[0] = START_STOP; 135 pc.c[4] = start; 136 137 if (drive->media == ide_tape) 138 pc.flags |= PC_FLAG_WAIT_FOR_DSC; 139 140 return ide_queue_pc_tail(drive, disk, &pc, NULL, 0); 141} 142EXPORT_SYMBOL_GPL(ide_do_start_stop); 143 144int ide_set_media_lock(ide_drive_t *drive, struct gendisk *disk, int on) 145{ 146 struct ide_atapi_pc pc; 147 148 if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) == 0) 149 return 0; 150 151 ide_init_pc(&pc); 152 pc.c[0] = ALLOW_MEDIUM_REMOVAL; 153 pc.c[4] = on; 154 155 return ide_queue_pc_tail(drive, disk, &pc, NULL, 0); 156} 157EXPORT_SYMBOL_GPL(ide_set_media_lock); 158 159void ide_create_request_sense_cmd(ide_drive_t *drive, struct ide_atapi_pc *pc) 160{ 161 ide_init_pc(pc); 162 pc->c[0] = REQUEST_SENSE; 163 if (drive->media == ide_floppy) { 164 pc->c[4] = 255; 165 pc->req_xfer = 18; 166 } else { 167 pc->c[4] = 20; 168 pc->req_xfer = 20; 169 } 170} 171EXPORT_SYMBOL_GPL(ide_create_request_sense_cmd); 172 173void ide_prep_sense(ide_drive_t *drive, struct request *rq) 174{ 175 struct request_sense *sense = &drive->sense_data; 176 struct request *sense_rq; 177 struct scsi_request *req; 178 unsigned int cmd_len, sense_len; 179 int err; 180 181 switch (drive->media) { 182 case ide_floppy: 183 cmd_len = 255; 184 sense_len = 18; 185 break; 186 case ide_tape: 187 cmd_len = 20; 188 sense_len = 20; 189 break; 190 default: 191 cmd_len = 18; 192 sense_len = 18; 193 } 194 195 BUG_ON(sense_len > sizeof(*sense)); 196 197 if (ata_sense_request(rq) || drive->sense_rq_armed) 198 return; 199 200 sense_rq = drive->sense_rq; 201 if (!sense_rq) { 202 sense_rq = blk_mq_alloc_request(drive->queue, REQ_OP_DRV_IN, 203 BLK_MQ_REQ_RESERVED | BLK_MQ_REQ_NOWAIT); 204 drive->sense_rq = sense_rq; 205 } 206 req = scsi_req(sense_rq); 207 208 memset(sense, 0, sizeof(*sense)); 209 210 scsi_req_init(req); 211 212 err = blk_rq_map_kern(drive->queue, sense_rq, sense, sense_len, 213 GFP_NOIO); 214 if (unlikely(err)) { 215 if (printk_ratelimit()) 216 printk(KERN_WARNING PFX "%s: failed to map sense " 217 "buffer\n", drive->name); 218 blk_mq_free_request(sense_rq); 219 drive->sense_rq = NULL; 220 return; 221 } 222 223 sense_rq->rq_disk = rq->rq_disk; 224 sense_rq->cmd_flags = REQ_OP_DRV_IN; 225 ide_req(sense_rq)->type = ATA_PRIV_SENSE; 226 227 req->cmd[0] = GPCMD_REQUEST_SENSE; 228 req->cmd[4] = cmd_len; 229 if (drive->media == ide_tape) 230 req->cmd[13] = REQ_IDETAPE_PC1; 231 232 drive->sense_rq_armed = true; 233} 234EXPORT_SYMBOL_GPL(ide_prep_sense); 235 236int ide_queue_sense_rq(ide_drive_t *drive, void *special) 237{ 238 ide_hwif_t *hwif = drive->hwif; 239 struct request *sense_rq; 240 unsigned long flags; 241 242 spin_lock_irqsave(&hwif->lock, flags); 243 244 /* deferred failure from ide_prep_sense() */ 245 if (!drive->sense_rq_armed) { 246 printk(KERN_WARNING PFX "%s: error queuing a sense request\n", 247 drive->name); 248 spin_unlock_irqrestore(&hwif->lock, flags); 249 return -ENOMEM; 250 } 251 252 sense_rq = drive->sense_rq; 253 ide_req(sense_rq)->special = special; 254 drive->sense_rq_armed = false; 255 256 drive->hwif->rq = NULL; 257 258 ide_insert_request_head(drive, sense_rq); 259 spin_unlock_irqrestore(&hwif->lock, flags); 260 return 0; 261} 262EXPORT_SYMBOL_GPL(ide_queue_sense_rq); 263 264/* 265 * Called when an error was detected during the last packet command. 266 * We queue a request sense packet command at the head of the request 267 * queue. 268 */ 269void ide_retry_pc(ide_drive_t *drive) 270{ 271 struct request *failed_rq = drive->hwif->rq; 272 struct request *sense_rq = drive->sense_rq; 273 struct ide_atapi_pc *pc = &drive->request_sense_pc; 274 275 (void)ide_read_error(drive); 276 277 /* init pc from sense_rq */ 278 ide_init_pc(pc); 279 memcpy(pc->c, scsi_req(sense_rq)->cmd, 12); 280 281 if (drive->media == ide_tape) 282 drive->atapi_flags |= IDE_AFLAG_IGNORE_DSC; 283 284 /* 285 * Push back the failed request and put request sense on top 286 * of it. The failed command will be retried after sense data 287 * is acquired. 288 */ 289 drive->hwif->rq = NULL; 290 ide_requeue_and_plug(drive, failed_rq); 291 if (ide_queue_sense_rq(drive, pc)) 292 ide_complete_rq(drive, BLK_STS_IOERR, blk_rq_bytes(failed_rq)); 293} 294EXPORT_SYMBOL_GPL(ide_retry_pc); 295 296int ide_cd_expiry(ide_drive_t *drive) 297{ 298 struct request *rq = drive->hwif->rq; 299 unsigned long wait = 0; 300 301 debug_log("%s: scsi_req(rq)->cmd[0]: 0x%x\n", __func__, scsi_req(rq)->cmd[0]); 302 303 /* 304 * Some commands are *slow* and normally take a long time to complete. 305 * Usually we can use the ATAPI "disconnect" to bypass this, but not all 306 * commands/drives support that. Let ide_timer_expiry keep polling us 307 * for these. 308 */ 309 switch (scsi_req(rq)->cmd[0]) { 310 case GPCMD_BLANK: 311 case GPCMD_FORMAT_UNIT: 312 case GPCMD_RESERVE_RZONE_TRACK: 313 case GPCMD_CLOSE_TRACK: 314 case GPCMD_FLUSH_CACHE: 315 wait = ATAPI_WAIT_PC; 316 break; 317 default: 318 if (!(rq->rq_flags & RQF_QUIET)) 319 printk(KERN_INFO PFX "cmd 0x%x timed out\n", 320 scsi_req(rq)->cmd[0]); 321 wait = 0; 322 break; 323 } 324 return wait; 325} 326EXPORT_SYMBOL_GPL(ide_cd_expiry); 327 328int ide_cd_get_xferlen(struct request *rq) 329{ 330 switch (req_op(rq)) { 331 default: 332 return 32768; 333 case REQ_OP_SCSI_IN: 334 case REQ_OP_SCSI_OUT: 335 return blk_rq_bytes(rq); 336 case REQ_OP_DRV_IN: 337 case REQ_OP_DRV_OUT: 338 switch (ide_req(rq)->type) { 339 case ATA_PRIV_PC: 340 case ATA_PRIV_SENSE: 341 return blk_rq_bytes(rq); 342 default: 343 return 0; 344 } 345 } 346} 347EXPORT_SYMBOL_GPL(ide_cd_get_xferlen); 348 349void ide_read_bcount_and_ireason(ide_drive_t *drive, u16 *bcount, u8 *ireason) 350{ 351 struct ide_taskfile tf; 352 353 drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_NSECT | 354 IDE_VALID_LBAM | IDE_VALID_LBAH); 355 356 *bcount = (tf.lbah << 8) | tf.lbam; 357 *ireason = tf.nsect & 3; 358} 359EXPORT_SYMBOL_GPL(ide_read_bcount_and_ireason); 360 361/* 362 * Check the contents of the interrupt reason register and attempt to recover if 363 * there are problems. 364 * 365 * Returns: 366 * - 0 if everything's ok 367 * - 1 if the request has to be terminated. 368 */ 369int ide_check_ireason(ide_drive_t *drive, struct request *rq, int len, 370 int ireason, int rw) 371{ 372 ide_hwif_t *hwif = drive->hwif; 373 374 debug_log("ireason: 0x%x, rw: 0x%x\n", ireason, rw); 375 376 if (ireason == (!rw << 1)) 377 return 0; 378 else if (ireason == (rw << 1)) { 379 printk(KERN_ERR PFX "%s: %s: wrong transfer direction!\n", 380 drive->name, __func__); 381 382 if (dev_is_idecd(drive)) 383 ide_pad_transfer(drive, rw, len); 384 } else if (!rw && ireason == ATAPI_COD) { 385 if (dev_is_idecd(drive)) { 386 /* 387 * Some drives (ASUS) seem to tell us that status info 388 * is available. Just get it and ignore. 389 */ 390 (void)hwif->tp_ops->read_status(hwif); 391 return 0; 392 } 393 } else { 394 if (ireason & ATAPI_COD) 395 printk(KERN_ERR PFX "%s: CoD != 0 in %s\n", drive->name, 396 __func__); 397 398 /* drive wants a command packet, or invalid ireason... */ 399 printk(KERN_ERR PFX "%s: %s: bad interrupt reason 0x%02x\n", 400 drive->name, __func__, ireason); 401 } 402 403 if (dev_is_idecd(drive) && ata_pc_request(rq)) 404 rq->rq_flags |= RQF_FAILED; 405 406 return 1; 407} 408EXPORT_SYMBOL_GPL(ide_check_ireason); 409 410/* 411 * This is the usual interrupt handler which will be called during a packet 412 * command. We will transfer some of the data (as requested by the drive) 413 * and will re-point interrupt handler to us. 414 */ 415static ide_startstop_t ide_pc_intr(ide_drive_t *drive) 416{ 417 struct ide_atapi_pc *pc = drive->pc; 418 ide_hwif_t *hwif = drive->hwif; 419 struct ide_cmd *cmd = &hwif->cmd; 420 struct request *rq = hwif->rq; 421 const struct ide_tp_ops *tp_ops = hwif->tp_ops; 422 unsigned int timeout, done; 423 u16 bcount; 424 u8 stat, ireason, dsc = 0; 425 u8 write = !!(pc->flags & PC_FLAG_WRITING); 426 427 debug_log("Enter %s - interrupt handler\n", __func__); 428 429 timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD 430 : WAIT_TAPE_CMD; 431 432 /* Clear the interrupt */ 433 stat = tp_ops->read_status(hwif); 434 435 if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) { 436 int rc; 437 438 drive->waiting_for_dma = 0; 439 rc = hwif->dma_ops->dma_end(drive); 440 ide_dma_unmap_sg(drive, cmd); 441 442 if (rc || (drive->media == ide_tape && (stat & ATA_ERR))) { 443 if (drive->media == ide_floppy) 444 printk(KERN_ERR PFX "%s: DMA %s error\n", 445 drive->name, rq_data_dir(pc->rq) 446 ? "write" : "read"); 447 pc->flags |= PC_FLAG_DMA_ERROR; 448 } else 449 scsi_req(rq)->resid_len = 0; 450 debug_log("%s: DMA finished\n", drive->name); 451 } 452 453 /* No more interrupts */ 454 if ((stat & ATA_DRQ) == 0) { 455 int uptodate; 456 blk_status_t error; 457 458 debug_log("Packet command completed, %d bytes transferred\n", 459 blk_rq_bytes(rq)); 460 461 pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS; 462 463 local_irq_enable_in_hardirq(); 464 465 if (drive->media == ide_tape && 466 (stat & ATA_ERR) && scsi_req(rq)->cmd[0] == REQUEST_SENSE) 467 stat &= ~ATA_ERR; 468 469 if ((stat & ATA_ERR) || (pc->flags & PC_FLAG_DMA_ERROR)) { 470 /* Error detected */ 471 debug_log("%s: I/O error\n", drive->name); 472 473 if (drive->media != ide_tape) 474 scsi_req(pc->rq)->result++; 475 476 if (scsi_req(rq)->cmd[0] == REQUEST_SENSE) { 477 printk(KERN_ERR PFX "%s: I/O error in request " 478 "sense command\n", drive->name); 479 return ide_do_reset(drive); 480 } 481 482 debug_log("[cmd %x]: check condition\n", scsi_req(rq)->cmd[0]); 483 484 /* Retry operation */ 485 ide_retry_pc(drive); 486 487 /* queued, but not started */ 488 return ide_stopped; 489 } 490 pc->error = 0; 491 492 if ((pc->flags & PC_FLAG_WAIT_FOR_DSC) && (stat & ATA_DSC) == 0) 493 dsc = 1; 494 495 /* 496 * ->pc_callback() might change rq->data_len for 497 * residual count, cache total length. 498 */ 499 done = blk_rq_bytes(rq); 500 501 /* Command finished - Call the callback function */ 502 uptodate = drive->pc_callback(drive, dsc); 503 504 if (uptodate == 0) 505 drive->failed_pc = NULL; 506 507 if (ata_misc_request(rq)) { 508 scsi_req(rq)->result = 0; 509 error = BLK_STS_OK; 510 } else { 511 512 if (blk_rq_is_passthrough(rq) && uptodate <= 0) { 513 if (scsi_req(rq)->result == 0) 514 scsi_req(rq)->result = -EIO; 515 } 516 517 error = uptodate ? BLK_STS_OK : BLK_STS_IOERR; 518 } 519 520 ide_complete_rq(drive, error, blk_rq_bytes(rq)); 521 return ide_stopped; 522 } 523 524 if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) { 525 pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS; 526 printk(KERN_ERR PFX "%s: The device wants to issue more " 527 "interrupts in DMA mode\n", drive->name); 528 ide_dma_off(drive); 529 return ide_do_reset(drive); 530 } 531 532 /* Get the number of bytes to transfer on this interrupt. */ 533 ide_read_bcount_and_ireason(drive, &bcount, &ireason); 534 535 if (ide_check_ireason(drive, rq, bcount, ireason, write)) 536 return ide_do_reset(drive); 537 538 done = min_t(unsigned int, bcount, cmd->nleft); 539 ide_pio_bytes(drive, cmd, write, done); 540 541 /* Update transferred byte count */ 542 scsi_req(rq)->resid_len -= done; 543 544 bcount -= done; 545 546 if (bcount) 547 ide_pad_transfer(drive, write, bcount); 548 549 debug_log("[cmd %x] transferred %d bytes, padded %d bytes, resid: %u\n", 550 scsi_req(rq)->cmd[0], done, bcount, scsi_req(rq)->resid_len); 551 552 /* And set the interrupt handler again */ 553 ide_set_handler(drive, ide_pc_intr, timeout); 554 return ide_started; 555} 556 557static void ide_init_packet_cmd(struct ide_cmd *cmd, u8 valid_tf, 558 u16 bcount, u8 dma) 559{ 560 cmd->protocol = dma ? ATAPI_PROT_DMA : ATAPI_PROT_PIO; 561 cmd->valid.out.tf = IDE_VALID_LBAH | IDE_VALID_LBAM | 562 IDE_VALID_FEATURE | valid_tf; 563 cmd->tf.command = ATA_CMD_PACKET; 564 cmd->tf.feature = dma; /* Use PIO/DMA */ 565 cmd->tf.lbam = bcount & 0xff; 566 cmd->tf.lbah = (bcount >> 8) & 0xff; 567} 568 569static u8 ide_read_ireason(ide_drive_t *drive) 570{ 571 struct ide_taskfile tf; 572 573 drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_NSECT); 574 575 return tf.nsect & 3; 576} 577 578static u8 ide_wait_ireason(ide_drive_t *drive, u8 ireason) 579{ 580 int retries = 100; 581 582 while (retries-- && ((ireason & ATAPI_COD) == 0 || 583 (ireason & ATAPI_IO))) { 584 printk(KERN_ERR PFX "%s: (IO,CoD != (0,1) while issuing " 585 "a packet command, retrying\n", drive->name); 586 udelay(100); 587 ireason = ide_read_ireason(drive); 588 if (retries == 0) { 589 printk(KERN_ERR PFX "%s: (IO,CoD != (0,1) while issuing" 590 " a packet command, ignoring\n", 591 drive->name); 592 ireason |= ATAPI_COD; 593 ireason &= ~ATAPI_IO; 594 } 595 } 596 597 return ireason; 598} 599 600static int ide_delayed_transfer_pc(ide_drive_t *drive) 601{ 602 /* Send the actual packet */ 603 drive->hwif->tp_ops->output_data(drive, NULL, drive->pc->c, 12); 604 605 /* Timeout for the packet command */ 606 return WAIT_FLOPPY_CMD; 607} 608 609static ide_startstop_t ide_transfer_pc(ide_drive_t *drive) 610{ 611 struct ide_atapi_pc *pc; 612 ide_hwif_t *hwif = drive->hwif; 613 struct request *rq = hwif->rq; 614 ide_expiry_t *expiry; 615 unsigned int timeout; 616 int cmd_len; 617 ide_startstop_t startstop; 618 u8 ireason; 619 620 if (ide_wait_stat(&startstop, drive, ATA_DRQ, ATA_BUSY, WAIT_READY)) { 621 printk(KERN_ERR PFX "%s: Strange, packet command initiated yet " 622 "DRQ isn't asserted\n", drive->name); 623 return startstop; 624 } 625 626 if (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT) { 627 if (drive->dma) 628 drive->waiting_for_dma = 1; 629 } 630 631 if (dev_is_idecd(drive)) { 632 /* ATAPI commands get padded out to 12 bytes minimum */ 633 cmd_len = COMMAND_SIZE(scsi_req(rq)->cmd[0]); 634 if (cmd_len < ATAPI_MIN_CDB_BYTES) 635 cmd_len = ATAPI_MIN_CDB_BYTES; 636 637 timeout = rq->timeout; 638 expiry = ide_cd_expiry; 639 } else { 640 pc = drive->pc; 641 642 cmd_len = ATAPI_MIN_CDB_BYTES; 643 644 /* 645 * If necessary schedule the packet transfer to occur 'timeout' 646 * milliseconds later in ide_delayed_transfer_pc() after the 647 * device says it's ready for a packet. 648 */ 649 if (drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) { 650 timeout = drive->pc_delay; 651 expiry = &ide_delayed_transfer_pc; 652 } else { 653 timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD 654 : WAIT_TAPE_CMD; 655 expiry = NULL; 656 } 657 658 ireason = ide_read_ireason(drive); 659 if (drive->media == ide_tape) 660 ireason = ide_wait_ireason(drive, ireason); 661 662 if ((ireason & ATAPI_COD) == 0 || (ireason & ATAPI_IO)) { 663 printk(KERN_ERR PFX "%s: (IO,CoD) != (0,1) while " 664 "issuing a packet command\n", drive->name); 665 666 return ide_do_reset(drive); 667 } 668 } 669 670 hwif->expiry = expiry; 671 672 /* Set the interrupt routine */ 673 ide_set_handler(drive, 674 (dev_is_idecd(drive) ? drive->irq_handler 675 : ide_pc_intr), 676 timeout); 677 678 /* Send the actual packet */ 679 if ((drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) == 0) 680 hwif->tp_ops->output_data(drive, NULL, scsi_req(rq)->cmd, cmd_len); 681 682 /* Begin DMA, if necessary */ 683 if (dev_is_idecd(drive)) { 684 if (drive->dma) 685 hwif->dma_ops->dma_start(drive); 686 } else { 687 if (pc->flags & PC_FLAG_DMA_OK) { 688 pc->flags |= PC_FLAG_DMA_IN_PROGRESS; 689 hwif->dma_ops->dma_start(drive); 690 } 691 } 692 693 return ide_started; 694} 695 696ide_startstop_t ide_issue_pc(ide_drive_t *drive, struct ide_cmd *cmd) 697{ 698 struct ide_atapi_pc *pc; 699 ide_hwif_t *hwif = drive->hwif; 700 ide_expiry_t *expiry = NULL; 701 struct request *rq = hwif->rq; 702 unsigned int timeout, bytes; 703 u16 bcount; 704 u8 valid_tf; 705 u8 drq_int = !!(drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT); 706 707 if (dev_is_idecd(drive)) { 708 valid_tf = IDE_VALID_NSECT | IDE_VALID_LBAL; 709 bcount = ide_cd_get_xferlen(rq); 710 expiry = ide_cd_expiry; 711 timeout = ATAPI_WAIT_PC; 712 713 if (drive->dma) 714 drive->dma = !ide_dma_prepare(drive, cmd); 715 } else { 716 pc = drive->pc; 717 718 valid_tf = IDE_VALID_DEVICE; 719 bytes = blk_rq_bytes(rq); 720 bcount = ((drive->media == ide_tape) ? bytes 721 : min_t(unsigned int, 722 bytes, 63 * 1024)); 723 724 /* We haven't transferred any data yet */ 725 scsi_req(rq)->resid_len = bcount; 726 727 if (pc->flags & PC_FLAG_DMA_ERROR) { 728 pc->flags &= ~PC_FLAG_DMA_ERROR; 729 ide_dma_off(drive); 730 } 731 732 if (pc->flags & PC_FLAG_DMA_OK) 733 drive->dma = !ide_dma_prepare(drive, cmd); 734 735 if (!drive->dma) 736 pc->flags &= ~PC_FLAG_DMA_OK; 737 738 timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD 739 : WAIT_TAPE_CMD; 740 } 741 742 ide_init_packet_cmd(cmd, valid_tf, bcount, drive->dma); 743 744 (void)do_rw_taskfile(drive, cmd); 745 746 if (drq_int) { 747 if (drive->dma) 748 drive->waiting_for_dma = 0; 749 hwif->expiry = expiry; 750 } 751 752 ide_execute_command(drive, cmd, ide_transfer_pc, timeout); 753 754 return drq_int ? ide_started : ide_transfer_pc(drive); 755} 756EXPORT_SYMBOL_GPL(ide_issue_pc); 757