linux/drivers/ide/ide-atapi.c
<<
>>
Prefs
   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
  27static 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 */
  36int 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}
  77EXPORT_SYMBOL_GPL(ide_check_atapi_device);
  78
  79void ide_init_pc(struct ide_atapi_pc *pc)
  80{
  81        memset(pc, 0, sizeof(*pc));
  82}
  83EXPORT_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 */
  89int 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_WAIT);
  96        rq->cmd_type = REQ_TYPE_SPECIAL;
  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);
 110put_req:
 111        blk_put_request(rq);
 112        return error;
 113}
 114EXPORT_SYMBOL_GPL(ide_queue_pc_tail);
 115
 116int 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}
 125EXPORT_SYMBOL_GPL(ide_do_test_unit_ready);
 126
 127int 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}
 140EXPORT_SYMBOL_GPL(ide_do_start_stop);
 141
 142int 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}
 155EXPORT_SYMBOL_GPL(ide_set_media_lock);
 156
 157void 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}
 169EXPORT_SYMBOL_GPL(ide_create_request_sense_cmd);
 170
 171void 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_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_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}
 221EXPORT_SYMBOL_GPL(ide_prep_sense);
 222
 223int 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}
 240EXPORT_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 */
 247void 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}
 274EXPORT_SYMBOL_GPL(ide_retry_pc);
 275
 276int 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}
 306EXPORT_SYMBOL_GPL(ide_cd_expiry);
 307
 308int 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_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}
 321EXPORT_SYMBOL_GPL(ide_cd_get_xferlen);
 322
 323void 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}
 333EXPORT_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 */
 343int 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}
 382EXPORT_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 */
 389static 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_SPECIAL) {
 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
 530static 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
 542static 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
 551static 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
 573static 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
 582static 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
 669ide_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}
 729EXPORT_SYMBOL_GPL(ide_issue_pc);
 730
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.