drivers/ide/ide-atapi.c

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