Merge branch 'upstream'
authorJeff Garzik <jgarzik@pobox.com>
Wed, 9 Nov 2005 06:20:26 +0000 (01:20 -0500)
committerJeff Garzik <jgarzik@pobox.com>
Wed, 9 Nov 2005 06:20:26 +0000 (01:20 -0500)
1  2 
drivers/scsi/libata-core.c
drivers/scsi/pdc_adma.c
drivers/scsi/sata_mv.c
drivers/scsi/sata_nv.c
drivers/scsi/sata_promise.c
drivers/scsi/sata_qstor.c
drivers/scsi/sata_sx4.c
drivers/scsi/sata_vsc.c
include/linux/libata.h

index 01b8ccfaa9a3ce485249ed245c0cd4a63daf6182,f1942545a20d6cb3134e243c9a4df5856f44e0c3..ce18de9705c4189a9322af541f46690dfc209ef6
@@@ -51,8 -51,8 +51,8 @@@
  #include <linux/jiffies.h>
  #include <linux/scatterlist.h>
  #include <scsi/scsi.h>
- #include "scsi.h"
  #include "scsi_priv.h"
+ #include <scsi/scsi_cmnd.h>
  #include <scsi/scsi_host.h>
  #include <linux/libata.h>
  #include <asm/io.h>
@@@ -74,7 -74,6 +74,7 @@@ static int ata_choose_xfer_mode(const s
                                u8 *xfer_mode_out,
                                unsigned int *xfer_shift_out);
  static void __ata_qc_complete(struct ata_queued_cmd *qc);
 +static void ata_pio_error(struct ata_port *ap);
  
  static unsigned int ata_unique_id = 1;
  static struct workqueue_struct *ata_wq;
@@@ -1277,9 -1276,6 +1277,9 @@@ retry
                ap->cdb_len = (unsigned int) rc;
                ap->host->max_cmd_len = (unsigned char) ap->cdb_len;
  
 +              if (ata_id_cdb_intr(dev->id))
 +                      dev->flags |= ATA_DFLAG_CDB_INTR;
 +
                /* print device info to dmesg */
                printk(KERN_INFO "ata%u: dev %u ATAPI, max %s\n",
                       ap->id, device,
@@@ -2717,7 -2713,7 +2717,7 @@@ static int ata_sg_setup(struct ata_queu
  /**
   *    ata_poll_qc_complete - turn irq back on and finish qc
   *    @qc: Command to complete
-  *    @drv_stat: ATA status register content
+  *    @err_mask: ATA status register content
   *
   *    LOCKING:
   *    None.  (grabs host lock)
@@@ -2729,6 -2725,7 +2729,6 @@@ void ata_poll_qc_complete(struct ata_qu
        unsigned long flags;
  
        spin_lock_irqsave(&ap->host_set->lock, flags);
 -      ap->flags &= ~ATA_FLAG_NOINTR;
        ata_irq_on(ap);
        ata_qc_complete(qc, err_mask);
        spin_unlock_irqrestore(&ap->host_set->lock, flags);
@@@ -2992,23 -2989,7 +2992,23 @@@ static void ata_pio_sector(struct ata_q
        page = nth_page(page, (offset >> PAGE_SHIFT));
        offset %= PAGE_SIZE;
  
 -      buf = kmap(page) + offset;
 +      DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
 +
 +      if (PageHighMem(page)) {
 +              unsigned long flags;
 +
 +              local_irq_save(flags);
 +              buf = kmap_atomic(page, KM_IRQ0);
 +
 +              /* do the actual data transfer */
 +              ata_data_xfer(ap, buf + offset, ATA_SECT_SIZE, do_write);
 +
 +              kunmap_atomic(buf, KM_IRQ0);
 +              local_irq_restore(flags);
 +      } else {
 +              buf = page_address(page);
 +              ata_data_xfer(ap, buf + offset, ATA_SECT_SIZE, do_write);
 +      }
  
        qc->cursect++;
        qc->cursg_ofs++;
                qc->cursg++;
                qc->cursg_ofs = 0;
        }
 +}
  
 -      DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
 +/**
 + *    atapi_send_cdb - Write CDB bytes to hardware
 + *    @ap: Port to which ATAPI device is attached.
 + *    @qc: Taskfile currently active
 + *
 + *    When device has indicated its readiness to accept
 + *    a CDB, this function is called.  Send the CDB.
 + *
 + *    LOCKING:
 + *    caller.
 + */
 +
 +static void atapi_send_cdb(struct ata_port *ap, struct ata_queued_cmd *qc)
 +{
 +      /* send SCSI cdb */
 +      DPRINTK("send cdb\n");
 +      assert(ap->cdb_len >= 12);
 +
 +      ata_data_xfer(ap, qc->cdb, ap->cdb_len, 1);
 +      ata_altstatus(ap); /* flush */
 +
 +      switch (qc->tf.protocol) {
 +      case ATA_PROT_ATAPI:
 +              ap->hsm_task_state = HSM_ST;
 +              break;
 +      case ATA_PROT_ATAPI_NODATA:
 +              ap->hsm_task_state = HSM_ST_LAST;
 +              break;
 +      case ATA_PROT_ATAPI_DMA:
 +              ap->hsm_task_state = HSM_ST_LAST;
 +              /* initiate bmdma */
 +              ap->ops->bmdma_start(qc);
 +              break;
 +      }
 +}
 +
 +/**
 + *    ata_dataout_task - Write first data block to hardware
 + *    @_data: Port to which ATA/ATAPI device is attached.
 + *
 + *    When device has indicated its readiness to accept
 + *    the data, this function sends out the CDB or 
 + *    the first data block by PIO.
 + *    After this, 
 + *      - If polling, ata_pio_task() handles the rest.
 + *      - Otherwise, interrupt handler takes over.
 + *
 + *    LOCKING:
 + *    Kernel thread context (may sleep)
 + */
 +
 +static void ata_dataout_task(void *_data)
 +{
 +      struct ata_port *ap = _data;
 +      struct ata_queued_cmd *qc;
 +      u8 status;
 +      unsigned long flags;
 +
 +      qc = ata_qc_from_tag(ap, ap->active_tag);
 +      assert(qc != NULL);
 +      assert(qc->flags & ATA_QCFLAG_ACTIVE);
 +
 +      /* sleep-wait for BSY to clear */
 +      DPRINTK("busy wait\n");
 +      if (ata_busy_sleep(ap, ATA_TMOUT_DATAOUT_QUICK, ATA_TMOUT_DATAOUT))
 +              goto err_out;
  
 -      /* do the actual data transfer */
 -      do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
 -      ata_data_xfer(ap, buf, ATA_SECT_SIZE, do_write);
 +      /* make sure DRQ is set */
 +      status = ata_chk_status(ap);
 +      if ((status & (ATA_BUSY | ATA_DRQ)) != ATA_DRQ)
 +              goto err_out;
 +
 +      /* Send the CDB (atapi) or the first data block (ata pio out).
 +       * During the state transition, interrupt handler shouldn't
 +       * be invoked before the data transfer is complete and
 +       * hsm_task_state is changed. Hence, the following locking.
 +       */
 +      spin_lock_irqsave(&ap->host_set->lock, flags);
 +
 +      if (qc->tf.protocol == ATA_PROT_PIO) {
 +              /* PIO data out protocol.
 +               * send first data block.
 +               */
 +
 +              /* ata_pio_sector() might change the state to HSM_ST_LAST.
 +               * so, the state is changed here before ata_pio_sector().
 +               */
 +              ap->hsm_task_state = HSM_ST;
 +              ata_pio_sector(qc);
 +              ata_altstatus(ap); /* flush */
 +      } else
 +              /* send CDB */
 +              atapi_send_cdb(ap, qc);
 +
 +      /* if polling, ata_pio_task() handles the rest.
 +       * otherwise, interrupt handler takes over from here.
 +       */
 +      if (qc->tf.flags & ATA_TFLAG_POLLING)
 +              queue_work(ata_wq, &ap->pio_task);
 +
 +      spin_unlock_irqrestore(&ap->host_set->lock, flags);
  
 -      kunmap(page);
 +      return;
 +
 +err_out:
 +      ata_pio_error(ap);
  }
  
  /**
@@@ -3190,23 -3071,7 +3190,23 @@@ next_sg
        /* don't cross page boundaries */
        count = min(count, (unsigned int)PAGE_SIZE - offset);
  
 -      buf = kmap(page) + offset;
 +      DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
 +
 +      if (PageHighMem(page)) {
 +              unsigned long flags;
 +
 +              local_irq_save(flags);
 +              buf = kmap_atomic(page, KM_IRQ0);
 +
 +              /* do the actual data transfer */
 +              ata_data_xfer(ap, buf + offset, count, do_write);
 +
 +              kunmap_atomic(buf, KM_IRQ0);
 +              local_irq_restore(flags);
 +      } else {
 +              buf = page_address(page);
 +              ata_data_xfer(ap, buf + offset, count, do_write);
 +      }
  
        bytes -= count;
        qc->curbytes += count;
                qc->cursg_ofs = 0;
        }
  
 -      DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
 -
 -      /* do the actual data transfer */
 -      ata_data_xfer(ap, buf, count, do_write);
 -
 -      kunmap(page);
 -
        if (bytes)
                goto next_sg;
  }
@@@ -3253,8 -3125,6 +3253,8 @@@ static void atapi_pio_bytes(struct ata_
        if (do_write != i_write)
                goto err_out;
  
 +      VPRINTK("ata%u: xfering %d bytes\n", ap->id, bytes);
 +
        __atapi_pio_bytes(qc, bytes);
  
        return;
@@@ -3452,8 -3322,6 +3452,8 @@@ static void ata_qc_timeout(struct ata_q
                printk(KERN_ERR "ata%u: command 0x%x timeout, stat 0x%x host_stat 0x%x\n",
                       ap->id, qc->tf.command, drv_stat, host_stat);
  
 +              ap->hsm_task_state = HSM_ST_IDLE;
 +
                /* complete taskfile transaction */
                ata_qc_complete(qc, ac_err_mask(drv_stat));
                break;
@@@ -3610,7 -3478,7 +3610,7 @@@ void ata_qc_free(struct ata_queued_cmd 
  /**
   *    ata_qc_complete - Complete an active ATA command
   *    @qc: Command to complete
-  *    @drv_stat: ATA Status register contents
+  *    @err_mask: ATA Status register contents
   *
   *    Indicate to the mid and upper layers that an ATA
   *    command has completed, with either an ok or not-ok status.
@@@ -3739,103 -3607,43 +3739,103 @@@ int ata_qc_issue_prot(struct ata_queued
  {
        struct ata_port *ap = qc->ap;
  
 +      /* Use polling pio if the LLD doesn't handle
 +       * interrupt driven pio and atapi CDB interrupt.
 +       */
 +      if (ap->flags & ATA_FLAG_PIO_POLLING) {
 +              switch (qc->tf.protocol) {
 +              case ATA_PROT_PIO:
 +              case ATA_PROT_ATAPI:
 +              case ATA_PROT_ATAPI_NODATA:
 +                      qc->tf.flags |= ATA_TFLAG_POLLING;
 +                      break;
 +              case ATA_PROT_ATAPI_DMA:
 +                      if (qc->dev->flags & ATA_DFLAG_CDB_INTR)
 +                              BUG();
 +                      break;
 +              default:
 +                      break;
 +              }
 +      }
 +
 +      /* select the device */
        ata_dev_select(ap, qc->dev->devno, 1, 0);
  
 +      /* start the command */
        switch (qc->tf.protocol) {
        case ATA_PROT_NODATA:
 +              if (qc->tf.flags & ATA_TFLAG_POLLING)
 +                      ata_qc_set_polling(qc);
 +
                ata_tf_to_host(ap, &qc->tf);
 +              ap->hsm_task_state = HSM_ST_LAST;
 +
 +              if (qc->tf.flags & ATA_TFLAG_POLLING)
 +                      queue_work(ata_wq, &ap->pio_task);
 +
                break;
  
        case ATA_PROT_DMA:
 +              assert(!(qc->tf.flags & ATA_TFLAG_POLLING));
 +
                ap->ops->tf_load(ap, &qc->tf);   /* load tf registers */
                ap->ops->bmdma_setup(qc);           /* set up bmdma */
                ap->ops->bmdma_start(qc);           /* initiate bmdma */
 +              ap->hsm_task_state = HSM_ST_LAST;
                break;
  
 -      case ATA_PROT_PIO: /* load tf registers, initiate polling pio */
 -              ata_qc_set_polling(qc);
 -              ata_tf_to_host(ap, &qc->tf);
 -              ap->hsm_task_state = HSM_ST;
 -              queue_work(ata_wq, &ap->pio_task);
 -              break;
 +      case ATA_PROT_PIO:
 +              if (qc->tf.flags & ATA_TFLAG_POLLING)
 +                      ata_qc_set_polling(qc);
  
 -      case ATA_PROT_ATAPI:
 -              ata_qc_set_polling(qc);
                ata_tf_to_host(ap, &qc->tf);
 -              queue_work(ata_wq, &ap->packet_task);
 +
 +              if (qc->tf.flags & ATA_TFLAG_WRITE) {
 +                      /* PIO data out protocol */
 +                      ap->hsm_task_state = HSM_ST_FIRST;
 +                      queue_work(ata_wq, &ap->dataout_task);
 +
 +                      /* always send first data block using
 +                       * the ata_dataout_task() codepath.
 +                       */
 +              } else {
 +                      /* PIO data in protocol */
 +                      ap->hsm_task_state = HSM_ST;
 +
 +                      if (qc->tf.flags & ATA_TFLAG_POLLING)
 +                              queue_work(ata_wq, &ap->pio_task);
 +
 +                      /* if polling, ata_pio_task() handles the rest.
 +                       * otherwise, interrupt handler takes over from here.
 +                       */
 +              }
 +
                break;
  
 +      case ATA_PROT_ATAPI:
        case ATA_PROT_ATAPI_NODATA:
 -              ap->flags |= ATA_FLAG_NOINTR;
 +              if (qc->tf.flags & ATA_TFLAG_POLLING)
 +                      ata_qc_set_polling(qc);
 +
                ata_tf_to_host(ap, &qc->tf);
 -              queue_work(ata_wq, &ap->packet_task);
 +              ap->hsm_task_state = HSM_ST_FIRST;
 +
 +              /* send cdb by polling if no cdb interrupt */
 +              if ((!(qc->dev->flags & ATA_DFLAG_CDB_INTR)) ||
 +                  (qc->tf.flags & ATA_TFLAG_POLLING))
 +                      queue_work(ata_wq, &ap->dataout_task);
                break;
  
        case ATA_PROT_ATAPI_DMA:
 -              ap->flags |= ATA_FLAG_NOINTR;
 +              assert(!(qc->tf.flags & ATA_TFLAG_POLLING));
 +
                ap->ops->tf_load(ap, &qc->tf);   /* load tf registers */
                ap->ops->bmdma_setup(qc);           /* set up bmdma */
 -              queue_work(ata_wq, &ap->packet_task);
 +              ap->hsm_task_state = HSM_ST_FIRST;
 +
 +              /* send cdb by polling if no cdb interrupt */
 +              if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR))
 +                      queue_work(ata_wq, &ap->dataout_task);
                break;
  
        default:
@@@ -4096,142 -3904,47 +4096,142 @@@ void ata_bmdma_stop(struct ata_queued_c
  inline unsigned int ata_host_intr (struct ata_port *ap,
                                   struct ata_queued_cmd *qc)
  {
 -      u8 status, host_stat;
 -
 -      switch (qc->tf.protocol) {
 +      u8 status, host_stat = 0;
  
 -      case ATA_PROT_DMA:
 -      case ATA_PROT_ATAPI_DMA:
 -      case ATA_PROT_ATAPI:
 -              /* check status of DMA engine */
 -              host_stat = ap->ops->bmdma_status(ap);
 -              VPRINTK("ata%u: host_stat 0x%X\n", ap->id, host_stat);
 +      VPRINTK("ata%u: protocol %d task_state %d\n",
 +              ap->id, qc->tf.protocol, ap->hsm_task_state);
  
 -              /* if it's not our irq... */
 -              if (!(host_stat & ATA_DMA_INTR))
 +      /* Check whether we are expecting interrupt in this state */
 +      switch (ap->hsm_task_state) {
 +      case HSM_ST_FIRST:
 +              /* Check the ATA_DFLAG_CDB_INTR flag is enough here.
 +               * The flag was turned on only for atapi devices.
 +               * No need to check is_atapi_taskfile(&qc->tf) again.
 +               */
 +              if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR))
                        goto idle_irq;
 +              break;
 +      case HSM_ST_LAST:
 +              if (qc->tf.protocol == ATA_PROT_DMA ||
 +                  qc->tf.protocol == ATA_PROT_ATAPI_DMA) {
 +                      /* check status of DMA engine */
 +                      host_stat = ap->ops->bmdma_status(ap);
 +                      VPRINTK("ata%u: host_stat 0x%X\n", ap->id, host_stat);
 +
 +                      /* if it's not our irq... */
 +                      if (!(host_stat & ATA_DMA_INTR))
 +                              goto idle_irq;
 +
 +                      /* before we do anything else, clear DMA-Start bit */
 +                      ap->ops->bmdma_stop(qc);
 +              }
 +              break;
 +      case HSM_ST:
 +              break;
 +      default:
 +              goto idle_irq;
 +      }
  
 -              /* before we do anything else, clear DMA-Start bit */
 -              ap->ops->bmdma_stop(qc);
 +      /* check altstatus */
 +      status = ata_altstatus(ap);
 +      if (status & ATA_BUSY)
 +              goto idle_irq;
  
 -              /* fall through */
 +      /* check main status, clearing INTRQ */
 +      status = ata_chk_status(ap);
 +      if (unlikely(status & ATA_BUSY))
 +              goto idle_irq;
  
 -      case ATA_PROT_ATAPI_NODATA:
 -      case ATA_PROT_NODATA:
 -              /* check altstatus */
 -              status = ata_altstatus(ap);
 -              if (status & ATA_BUSY)
 -                      goto idle_irq;
 +      DPRINTK("ata%u: protocol %d task_state %d (dev_stat 0x%X)\n",
 +              ap->id, qc->tf.protocol, ap->hsm_task_state, status);
  
 -              /* check main status, clearing INTRQ */
 -              status = ata_chk_status(ap);
 -              if (unlikely(status & ATA_BUSY))
 -                      goto idle_irq;
 -              DPRINTK("ata%u: protocol %d (dev_stat 0x%X)\n",
 -                      ap->id, qc->tf.protocol, status);
 +      /* ack bmdma irq events */
 +      ap->ops->irq_clear(ap);
  
 -              /* ack bmdma irq events */
 -              ap->ops->irq_clear(ap);
 +      /* check error */
 +      if (unlikely((status & ATA_ERR) || (host_stat & ATA_DMA_ERR)))
 +              ap->hsm_task_state = HSM_ST_ERR;
 +
 +fsm_start:
 +      switch (ap->hsm_task_state) {
 +      case HSM_ST_FIRST:
 +              /* Some pre-ATAPI-4 devices assert INTRQ 
 +               * at this state when ready to receive CDB.
 +               */
 +
 +              /* check device status */
 +              if (unlikely((status & (ATA_BUSY | ATA_DRQ)) != ATA_DRQ)) {
 +                      /* Wrong status. Let EH handle this */
 +                      ap->hsm_task_state = HSM_ST_ERR;
 +                      goto fsm_start;
 +              }
 +
 +              atapi_send_cdb(ap, qc);
 +
 +              break;
 +
 +      case HSM_ST:
 +              /* complete command or read/write the data register */
 +              if (qc->tf.protocol == ATA_PROT_ATAPI) {
 +                      /* ATAPI PIO protocol */
 +                      if ((status & ATA_DRQ) == 0) {
 +                              /* no more data to transfer */
 +                              ap->hsm_task_state = HSM_ST_LAST;
 +                              goto fsm_start;
 +                      }
 +                      
 +                      atapi_pio_bytes(qc);
 +
 +                      if (unlikely(ap->hsm_task_state == HSM_ST_ERR))
 +                              /* bad ireason reported by device */
 +                              goto fsm_start;
 +
 +              } else {
 +                      /* ATA PIO protocol */
 +                      if (unlikely((status & ATA_DRQ) == 0)) {
 +                              /* handle BSY=0, DRQ=0 as error */
 +                              ap->hsm_task_state = HSM_ST_ERR;
 +                              goto fsm_start;
 +                      }
 +
 +                      ata_pio_sector(qc);
 +
 +                      if (ap->hsm_task_state == HSM_ST_LAST &&
 +                          (!(qc->tf.flags & ATA_TFLAG_WRITE))) {
 +                              /* all data read */
 +                              ata_altstatus(ap);
 +                              status = ata_chk_status(ap);
 +                              goto fsm_start;
 +                      }
 +              }
 +
 +              ata_altstatus(ap); /* flush */
 +              break;
 +
 +      case HSM_ST_LAST:
 +              if (unlikely(status & ATA_DRQ)) {
 +                      /* handle DRQ=1 as error */
 +                      ap->hsm_task_state = HSM_ST_ERR;
 +                      goto fsm_start;
 +              }
 +
 +              /* no more data to transfer */
 +              DPRINTK("ata%u: command complete, drv_stat 0x%x\n",
 +                      ap->id, status);
 +
 +              ap->hsm_task_state = HSM_ST_IDLE;
  
                /* complete taskfile transaction */
                ata_qc_complete(qc, ac_err_mask(status));
                break;
  
 +      case HSM_ST_ERR:
 +              printk(KERN_ERR "ata%u: command error, drv_stat 0x%x host_stat 0x%x\n",
 +                     ap->id, status, host_stat);
 +
 +              ap->hsm_task_state = HSM_ST_IDLE;
 +              ata_qc_complete(qc, status | ATA_ERR);
 +              break;
        default:
                goto idle_irq;
        }
@@@ -4282,11 -3995,11 +4282,11 @@@ irqreturn_t ata_interrupt (int irq, voi
  
                ap = host_set->ports[i];
                if (ap &&
 -                  !(ap->flags & (ATA_FLAG_PORT_DISABLED | ATA_FLAG_NOINTR))) {
 +                  !(ap->flags & ATA_FLAG_PORT_DISABLED)) {
                        struct ata_queued_cmd *qc;
  
                        qc = ata_qc_from_tag(ap, ap->active_tag);
 -                      if (qc && (!(qc->tf.ctl & ATA_NIEN)) &&
 +                      if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)) &&
                            (qc->flags & ATA_QCFLAG_ACTIVE))
                                handled |= ata_host_intr(ap, qc);
                }
        return IRQ_RETVAL(handled);
  }
  
 -/**
 - *    atapi_packet_task - Write CDB bytes to hardware
 - *    @_data: Port to which ATAPI device is attached.
 - *
 - *    When device has indicated its readiness to accept
 - *    a CDB, this function is called.  Send the CDB.
 - *    If DMA is to be performed, exit immediately.
 - *    Otherwise, we are in polling mode, so poll
 - *    status under operation succeeds or fails.
 - *
 - *    LOCKING:
 - *    Kernel thread context (may sleep)
 - */
 -
 -static void atapi_packet_task(void *_data)
 -{
 -      struct ata_port *ap = _data;
 -      struct ata_queued_cmd *qc;
 -      u8 status;
 -
 -      qc = ata_qc_from_tag(ap, ap->active_tag);
 -      assert(qc != NULL);
 -      assert(qc->flags & ATA_QCFLAG_ACTIVE);
 -
 -      /* sleep-wait for BSY to clear */
 -      DPRINTK("busy wait\n");
 -      if (ata_busy_sleep(ap, ATA_TMOUT_CDB_QUICK, ATA_TMOUT_CDB))
 -              goto err_out_status;
 -
 -      /* make sure DRQ is set */
 -      status = ata_chk_status(ap);
 -      if ((status & (ATA_BUSY | ATA_DRQ)) != ATA_DRQ)
 -              goto err_out;
 -
 -      /* send SCSI cdb */
 -      DPRINTK("send cdb\n");
 -      assert(ap->cdb_len >= 12);
 -
 -      if (qc->tf.protocol == ATA_PROT_ATAPI_DMA ||
 -          qc->tf.protocol == ATA_PROT_ATAPI_NODATA) {
 -              unsigned long flags;
 -
 -              /* Once we're done issuing command and kicking bmdma,
 -               * irq handler takes over.  To not lose irq, we need
 -               * to clear NOINTR flag before sending cdb, but
 -               * interrupt handler shouldn't be invoked before we're
 -               * finished.  Hence, the following locking.
 -               */
 -              spin_lock_irqsave(&ap->host_set->lock, flags);
 -              ap->flags &= ~ATA_FLAG_NOINTR;
 -              ata_data_xfer(ap, qc->cdb, ap->cdb_len, 1);
 -              if (qc->tf.protocol == ATA_PROT_ATAPI_DMA)
 -                      ap->ops->bmdma_start(qc);       /* initiate bmdma */
 -              spin_unlock_irqrestore(&ap->host_set->lock, flags);
 -      } else {
 -              ata_data_xfer(ap, qc->cdb, ap->cdb_len, 1);
 -
 -              /* PIO commands are handled by polling */
 -              ap->hsm_task_state = HSM_ST;
 -              queue_work(ata_wq, &ap->pio_task);
 -      }
 -
 -      return;
 -
 -err_out_status:
 -      status = ata_chk_status(ap);
 -err_out:
 -      ata_poll_qc_complete(qc, __ac_err_mask(status));
 -}
 -
 -
  /**
   *    ata_port_start - Set port up for dma.
   *    @ap: Port to initialize
@@@ -4423,7 -4207,7 +4423,7 @@@ static void ata_host_init(struct ata_po
        ap->active_tag = ATA_TAG_POISON;
        ap->last_ctl = 0xFF;
  
 -      INIT_WORK(&ap->packet_task, atapi_packet_task, ap);
 +      INIT_WORK(&ap->dataout_task, ata_dataout_task, ap);
        INIT_WORK(&ap->pio_task, ata_pio_task, ap);
  
        for (i = 0; i < ATA_MAX_DEVICES; i++)
diff --combined drivers/scsi/pdc_adma.c
index b48f1b5a0201f0625271dfea382185df0ed27b77,78b4ff117af65b1229875d94257a9566ba79ad5c..6b1c901c5e4b3f0a8439ebf2ebfec2f783a82dbc
@@@ -41,7 -41,6 +41,6 @@@
  #include <linux/interrupt.h>
  #include <linux/sched.h>
  #include <linux/device.h>
- #include "scsi.h"
  #include <scsi/scsi_host.h>
  #include <asm/io.h>
  #include <linux/libata.h>
@@@ -139,7 -138,7 +138,7 @@@ static u8 adma_bmdma_status(struct ata_
  static void adma_irq_clear(struct ata_port *ap);
  static void adma_eng_timeout(struct ata_port *ap);
  
- static Scsi_Host_Template adma_ata_sht = {
+ static struct scsi_host_template adma_ata_sht = {
        .module                 = THIS_MODULE,
        .name                   = DRV_NAME,
        .ioctl                  = ata_scsi_ioctl,
@@@ -458,13 -457,13 +457,13 @@@ static inline unsigned int adma_intr_pk
                        continue;
                handled = 1;
                adma_enter_reg_mode(ap);
 -              if (ap->flags & (ATA_FLAG_PORT_DISABLED | ATA_FLAG_NOINTR))
 +              if (ap->flags & ATA_FLAG_PORT_DISABLED)
                        continue;
                pp = ap->private_data;
                if (!pp || pp->state != adma_state_pkt)
                        continue;
                qc = ata_qc_from_tag(ap, ap->active_tag);
 -              if (qc && (!(qc->tf.ctl & ATA_NIEN))) {
 +              if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING))) {
                        unsigned int err_mask = 0;
  
                        if ((status & (aPERR | aPSD | aUIRQ)))
@@@ -485,13 -484,13 +484,13 @@@ static inline unsigned int adma_intr_mm
        for (port_no = 0; port_no < host_set->n_ports; ++port_no) {
                struct ata_port *ap;
                ap = host_set->ports[port_no];
 -              if (ap && (!(ap->flags & (ATA_FLAG_PORT_DISABLED | ATA_FLAG_NOINTR)))) {
 +              if (ap && (!(ap->flags & ATA_FLAG_PORT_DISABLED))) {
                        struct ata_queued_cmd *qc;
                        struct adma_port_priv *pp = ap->private_data;
                        if (!pp || pp->state != adma_state_mmio)
                                continue;
                        qc = ata_qc_from_tag(ap, ap->active_tag);
 -                      if (qc && (!(qc->tf.ctl & ATA_NIEN))) {
 +                      if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING))) {
  
                                /* check main status, clearing INTRQ */
                                u8 status = ata_check_status(ap);
diff --combined drivers/scsi/sata_mv.c
index a99dad510705c59fa16c13fe468e82c7da8dc662,93d55233af7be493363f366d204e367a727d10a5..f8976e3f6ada87af62f5407b0f633248d97062dc
@@@ -30,8 -30,8 +30,8 @@@
  #include <linux/sched.h>
  #include <linux/dma-mapping.h>
  #include <linux/device.h>
- #include "scsi.h"
  #include <scsi/scsi_host.h>
+ #include <scsi/scsi_cmnd.h>
  #include <linux/libata.h>
  #include <asm/io.h>
  
@@@ -88,8 -88,7 +88,8 @@@ enum 
        MV_FLAG_IRQ_COALESCE    = (1 << 29),  /* IRQ coalescing capability */
        MV_FLAG_GLBL_SFT_RST    = (1 << 28),  /* Global Soft Reset support */
        MV_COMMON_FLAGS         = (ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
 -                                 ATA_FLAG_SATA_RESET | ATA_FLAG_MMIO),
 +                                 ATA_FLAG_SATA_RESET | ATA_FLAG_MMIO |
 +                                 ATA_FLAG_PIO_POLLING),
        MV_6XXX_FLAGS           = (MV_FLAG_IRQ_COALESCE | 
                                   MV_FLAG_GLBL_SFT_RST),
  
@@@ -271,7 -270,7 +271,7 @@@ static irqreturn_t mv_interrupt(int irq
  static void mv_eng_timeout(struct ata_port *ap);
  static int mv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
  
- static Scsi_Host_Template mv_sht = {
+ static struct scsi_host_template mv_sht = {
        .module                 = THIS_MODULE,
        .name                   = DRV_NAME,
        .ioctl                  = ata_scsi_ioctl,
diff --combined drivers/scsi/sata_nv.c
index 5569d5797134e983de011f13da34586f8ea01f44,37a4fae95ed4ffe738dd5412ca240f6506d6eafa..5b7f7808add954fa8cfbdd3593307f1d746ebb97
@@@ -62,7 -62,6 +62,6 @@@
  #include <linux/delay.h>
  #include <linux/interrupt.h>
  #include <linux/device.h>
- #include "scsi.h"
  #include <scsi/scsi_host.h>
  #include <linux/libata.h>
  
@@@ -219,7 -218,7 +218,7 @@@ static struct pci_driver nv_pci_driver 
        .remove                 = ata_pci_remove_one,
  };
  
- static Scsi_Host_Template nv_sht = {
+ static struct scsi_host_template nv_sht = {
        .module                 = THIS_MODULE,
        .name                   = DRV_NAME,
        .ioctl                  = ata_scsi_ioctl,
@@@ -305,11 -304,11 +304,11 @@@ static irqreturn_t nv_interrupt (int ir
  
                ap = host_set->ports[i];
                if (ap &&
 -                  !(ap->flags & (ATA_FLAG_PORT_DISABLED | ATA_FLAG_NOINTR))) {
 +                  !(ap->flags & ATA_FLAG_PORT_DISABLED)) {
                        struct ata_queued_cmd *qc;
  
                        qc = ata_qc_from_tag(ap, ap->active_tag);
 -                      if (qc && (!(qc->tf.ctl & ATA_NIEN)))
 +                      if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)))
                                handled += ata_host_intr(ap, qc);
                }
  
index b2e2f1825edbc0bd4df6fb440d2dbe93e55658d5,9edc9d91efc3b73c970e710f228caa09d13df3ca..ac5b9cbebdd8b016fa5966b9ac7ddd19de382b88
@@@ -39,8 -39,8 +39,8 @@@
  #include <linux/interrupt.h>
  #include <linux/sched.h>
  #include <linux/device.h>
- #include "scsi.h"
  #include <scsi/scsi_host.h>
+ #include <scsi/scsi_cmnd.h>
  #include <linux/libata.h>
  #include <asm/io.h>
  #include "sata_promise.h"
@@@ -94,7 -94,7 +94,7 @@@ static void pdc_irq_clear(struct ata_po
  static int pdc_qc_issue_prot(struct ata_queued_cmd *qc);
  
  
- static Scsi_Host_Template pdc_ata_sht = {
+ static struct scsi_host_template pdc_ata_sht = {
        .module                 = THIS_MODULE,
        .name                   = DRV_NAME,
        .ioctl                  = ata_scsi_ioctl,
@@@ -163,8 -163,7 +163,8 @@@ static struct ata_port_info pdc_port_in
        {
                .sht            = &pdc_ata_sht,
                .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
 -                                ATA_FLAG_SRST | ATA_FLAG_MMIO,
 +                                ATA_FLAG_SRST | ATA_FLAG_MMIO |
 +                                ATA_FLAG_PIO_POLLING,
                .pio_mask       = 0x1f, /* pio0-4 */
                .mwdma_mask     = 0x07, /* mwdma0-2 */
                .udma_mask      = 0x7f, /* udma0-6 ; FIXME */
        {
                .sht            = &pdc_ata_sht,
                .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
 -                                ATA_FLAG_SRST | ATA_FLAG_MMIO,
 +                                ATA_FLAG_SRST | ATA_FLAG_MMIO |
 +                                ATA_FLAG_PIO_POLLING,
                .pio_mask       = 0x1f, /* pio0-4 */
                .mwdma_mask     = 0x07, /* mwdma0-2 */
                .udma_mask      = 0x7f, /* udma0-6 ; FIXME */
        {
                .sht            = &pdc_ata_sht,
                .host_flags     = ATA_FLAG_NO_LEGACY | ATA_FLAG_SRST |
 -                                ATA_FLAG_MMIO | ATA_FLAG_SLAVE_POSS,
 +                                ATA_FLAG_MMIO | ATA_FLAG_SLAVE_POSS |
 +                                ATA_FLAG_PIO_POLLING,
                .pio_mask       = 0x1f, /* pio0-4 */
                .mwdma_mask     = 0x07, /* mwdma0-2 */
                .udma_mask      = 0x7f, /* udma0-6 ; FIXME */
@@@ -499,11 -496,11 +499,11 @@@ static irqreturn_t pdc_interrupt (int i
                ap = host_set->ports[i];
                tmp = mask & (1 << (i + 1));
                if (tmp && ap &&
 -                  !(ap->flags & (ATA_FLAG_PORT_DISABLED | ATA_FLAG_NOINTR))) {
 +                  !(ap->flags & ATA_FLAG_PORT_DISABLED)) {
                        struct ata_queued_cmd *qc;
  
                        qc = ata_qc_from_tag(ap, ap->active_tag);
 -                      if (qc && (!(qc->tf.ctl & ATA_NIEN)))
 +                      if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)))
                                handled += pdc_host_intr(ap, qc);
                }
        }
index 3184178e4950d1d5002ce2a2ec0c836ec0e1562f,d274ab2357812924a1beb7aad481112cd17dcd4b..0e3468a8b73d2f9f63751026b46131d2687b1ee4
@@@ -36,7 -36,6 +36,6 @@@
  #include <linux/interrupt.h>
  #include <linux/sched.h>
  #include <linux/device.h>
- #include "scsi.h"
  #include <scsi/scsi_host.h>
  #include <asm/io.h>
  #include <linux/libata.h>
@@@ -128,7 -127,7 +127,7 @@@ static u8 qs_bmdma_status(struct ata_po
  static void qs_irq_clear(struct ata_port *ap);
  static void qs_eng_timeout(struct ata_port *ap);
  
- static Scsi_Host_Template qs_ata_sht = {
+ static struct scsi_host_template qs_ata_sht = {
        .module                 = THIS_MODULE,
        .name                   = DRV_NAME,
        .ioctl                  = ata_scsi_ioctl,
@@@ -178,7 -177,7 +177,7 @@@ static struct ata_port_info qs_port_inf
                .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
                                  ATA_FLAG_SATA_RESET |
                                  //FIXME ATA_FLAG_SRST |
 -                                ATA_FLAG_MMIO,
 +                                ATA_FLAG_MMIO | ATA_FLAG_PIO_POLLING,
                .pio_mask       = 0x10, /* pio4 */
                .udma_mask      = 0x7f, /* udma0-6 */
                .port_ops       = &qs_ata_ops,
@@@ -394,13 -393,14 +393,13 @@@ static inline unsigned int qs_intr_pkt(
                        DPRINTK("SFF=%08x%08x: sCHAN=%u sHST=%d sDST=%02x\n",
                                        sff1, sff0, port_no, sHST, sDST);
                        handled = 1;
 -                      if (ap && !(ap->flags &
 -                                  (ATA_FLAG_PORT_DISABLED|ATA_FLAG_NOINTR))) {
 +                      if (ap && !(ap->flags & ATA_FLAG_PORT_DISABLED)) {
                                struct ata_queued_cmd *qc;
                                struct qs_port_priv *pp = ap->private_data;
                                if (!pp || pp->state != qs_state_pkt)
                                        continue;
                                qc = ata_qc_from_tag(ap, ap->active_tag);
 -                              if (qc && (!(qc->tf.ctl & ATA_NIEN))) {
 +                              if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING))) {
                                        switch (sHST) {
                                        case 0: /* successful CPB */
                                        case 3: /* device error */
@@@ -427,13 -427,13 +426,13 @@@ static inline unsigned int qs_intr_mmio
                struct ata_port *ap;
                ap = host_set->ports[port_no];
                if (ap &&
 -                  !(ap->flags & (ATA_FLAG_PORT_DISABLED | ATA_FLAG_NOINTR))) {
 +                  !(ap->flags & ATA_FLAG_PORT_DISABLED)) {
                        struct ata_queued_cmd *qc;
                        struct qs_port_priv *pp = ap->private_data;
                        if (!pp || pp->state != qs_state_mmio)
                                continue;
                        qc = ata_qc_from_tag(ap, ap->active_tag);
 -                      if (qc && (!(qc->tf.ctl & ATA_NIEN))) {
 +                      if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING))) {
  
                                /* check main status, clearing INTRQ */
                                u8 status = ata_check_status(ap);
diff --combined drivers/scsi/sata_sx4.c
index 2bfede324eac2be01ff420b73089eb251f76dd53,d5a38784352b9bf7adfa396d279f2f27e71d6b6a..c42b2d3eeb6cb0df2eb609a2686658a97d48b660
@@@ -39,8 -39,8 +39,8 @@@
  #include <linux/interrupt.h>
  #include <linux/sched.h>
  #include <linux/device.h>
- #include "scsi.h"
  #include <scsi/scsi_host.h>
+ #include <scsi/scsi_cmnd.h>
  #include <linux/libata.h>
  #include <asm/io.h>
  #include "sata_promise.h"
@@@ -177,7 -177,7 +177,7 @@@ static void pdc20621_irq_clear(struct a
  static int pdc20621_qc_issue_prot(struct ata_queued_cmd *qc);
  
  
- static Scsi_Host_Template pdc_sata_sht = {
+ static struct scsi_host_template pdc_sata_sht = {
        .module                 = THIS_MODULE,
        .name                   = DRV_NAME,
        .ioctl                  = ata_scsi_ioctl,
@@@ -220,8 -220,7 +220,8 @@@ static struct ata_port_info pdc_port_in
        {
                .sht            = &pdc_sata_sht,
                .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
 -                                ATA_FLAG_SRST | ATA_FLAG_MMIO,
 +                                ATA_FLAG_SRST | ATA_FLAG_MMIO |
 +                                ATA_FLAG_PIO_POLLING,
                .pio_mask       = 0x1f, /* pio0-4 */
                .mwdma_mask     = 0x07, /* mwdma0-2 */
                .udma_mask      = 0x7f, /* udma0-6 ; FIXME */
@@@ -833,11 -832,11 +833,11 @@@ static irqreturn_t pdc20621_interrupt (
                tmp = mask & (1 << i);
                VPRINTK("seq %u, port_no %u, ap %p, tmp %x\n", i, port_no, ap, tmp);
                if (tmp && ap &&
 -                  !(ap->flags & (ATA_FLAG_PORT_DISABLED | ATA_FLAG_NOINTR))) {
 +                  !(ap->flags & ATA_FLAG_PORT_DISABLED)) {
                        struct ata_queued_cmd *qc;
  
                        qc = ata_qc_from_tag(ap, ap->active_tag);
 -                      if (qc && (!(qc->tf.ctl & ATA_NIEN)))
 +                      if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)))
                                handled += pdc20621_host_intr(ap, qc, (i > 4),
                                                              mmio_base);
                }
diff --combined drivers/scsi/sata_vsc.c
index 4349bc9193e38464be86edcfe22c1a63582c8114,ce8a2fd7da84d577b4c0154fe9e215323f1c828e..e819b2b4f298bb5c4879515f19e6ab82d265f98a
@@@ -43,7 -43,6 +43,6 @@@
  #include <linux/interrupt.h>
  #include <linux/dma-mapping.h>
  #include <linux/device.h>
- #include "scsi.h"
  #include <scsi/scsi_host.h>
  #include <linux/libata.h>
  
@@@ -202,12 -201,12 +201,12 @@@ static irqreturn_t vsc_sata_interrupt (
                        struct ata_port *ap;
  
                        ap = host_set->ports[i];
 -                      if (ap && !(ap->flags &
 -                                  (ATA_FLAG_PORT_DISABLED|ATA_FLAG_NOINTR))) {
 +                      if (ap &&
 +                          !(ap->flags & ATA_FLAG_PORT_DISABLED)) {
                                struct ata_queued_cmd *qc;
  
                                qc = ata_qc_from_tag(ap, ap->active_tag);
 -                              if (qc && (!(qc->tf.ctl & ATA_NIEN)))
 +                              if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)))
                                        handled += ata_host_intr(ap, qc);
                        }
                }
  }
  
  
- static Scsi_Host_Template vsc_sata_sht = {
+ static struct scsi_host_template vsc_sata_sht = {
        .module                 = THIS_MODULE,
        .name                   = DRV_NAME,
        .ioctl                  = ata_scsi_ioctl,
diff --combined include/linux/libata.h
index 4b4cf6cf4acca136f52e91245175c6aced5aeb01,6f0752219f64052018f9663b62930329c722b888..ad0451dfee158f831fe3cace948491c62518e060
@@@ -98,7 -98,6 +98,7 @@@ enum 
        ATA_DFLAG_PIO           = (1 << 1), /* device currently in PIO mode */
        ATA_DFLAG_LOCK_SECTORS  = (1 << 2), /* don't adjust max_sectors */
        ATA_DFLAG_LBA           = (1 << 3), /* device supports LBA */
 +      ATA_DFLAG_CDB_INTR      = (1 << 4), /* device asserts INTRQ when ready for CDB */
  
        ATA_DEV_UNKNOWN         = 0,    /* unknown device */
        ATA_DEV_ATA             = 1,    /* ATA device */
        ATA_FLAG_MMIO           = (1 << 6), /* use MMIO, not PIO */
        ATA_FLAG_SATA_RESET     = (1 << 7), /* use COMRESET */
        ATA_FLAG_PIO_DMA        = (1 << 8), /* PIO cmds via DMA */
 -      ATA_FLAG_NOINTR         = (1 << 9), /* FIXME: Remove this once
 -                                           * proper HSM is in place. */
 +      ATA_FLAG_PIO_POLLING    = (1 << 9), /* use polling PIO if LLD
 +                                           * doesn't handle PIO interrupts */
  
        ATA_QCFLAG_ACTIVE       = (1 << 1), /* cmd not yet ack'd to scsi lyer */
        ATA_QCFLAG_SG           = (1 << 3), /* have s/g table? */
        ATA_TMOUT_PIO           = 30 * HZ,
        ATA_TMOUT_BOOT          = 30 * HZ,      /* hueristic */
        ATA_TMOUT_BOOT_QUICK    = 7 * HZ,       /* hueristic */
 -      ATA_TMOUT_CDB           = 30 * HZ,
 -      ATA_TMOUT_CDB_QUICK     = 5 * HZ,
 +      ATA_TMOUT_DATAOUT       = 30 * HZ,
 +      ATA_TMOUT_DATAOUT_QUICK = 5 * HZ,
  
        /* ATA bus states */
        BUS_UNKNOWN             = 0,
  };
  
  enum hsm_task_states {
 -      HSM_ST_UNKNOWN,
 -      HSM_ST_IDLE,
 -      HSM_ST_POLL,
 -      HSM_ST_TMOUT,
 -      HSM_ST,
 -      HSM_ST_LAST,
 -      HSM_ST_LAST_POLL,
 -      HSM_ST_ERR,
 +      HSM_ST_UNKNOWN,         /* state unknown */
 +      HSM_ST_IDLE,            /* no command on going */
 +      HSM_ST_POLL,            /* same as HSM_ST, waits longer */
 +      HSM_ST_TMOUT,           /* timeout */
 +      HSM_ST,                 /* (waiting the device to) transfer data */
 +      HSM_ST_LAST,            /* (waiting the device to) complete command */
 +      HSM_ST_LAST_POLL,       /* same as HSM_ST_LAST, waits longer */
 +      HSM_ST_ERR,             /* error */
 +      HSM_ST_FIRST,           /* (waiting the device to)
 +                                 write CDB or first data block */
  };
  
  enum ata_completion_errors {
@@@ -217,7 -214,7 +217,7 @@@ struct ata_probe_ent 
        struct list_head        node;
        struct device           *dev;
        const struct ata_port_operations *port_ops;
-       Scsi_Host_Template      *sht;
+       struct scsi_host_template *sht;
        struct ata_ioports      port[ATA_MAX_PORTS];
        unsigned int            n_ports;
        unsigned int            hard_port_no;
@@@ -346,7 -343,7 +346,7 @@@ struct ata_port 
        struct ata_host_stats   stats;
        struct ata_host_set     *host_set;
  
 -      struct work_struct      packet_task;
 +      struct work_struct      dataout_task;
  
        struct work_struct      pio_task;
        unsigned int            hsm_task_state;
@@@ -401,7 -398,7 +401,7 @@@ struct ata_port_operations 
  };
  
  struct ata_port_info {
-       Scsi_Host_Template      *sht;
+       struct scsi_host_template *sht;
        unsigned long           host_flags;
        unsigned long           pio_mask;
        unsigned long           mwdma_mask;
@@@ -436,7 -433,7 +436,7 @@@ extern void ata_pci_remove_one (struct 
  #endif /* CONFIG_PCI */
  extern int ata_device_add(const struct ata_probe_ent *ent);
  extern void ata_host_set_remove(struct ata_host_set *host_set);
- extern int ata_scsi_detect(Scsi_Host_Template *sht);
+ extern int ata_scsi_detect(struct scsi_host_template *sht);
  extern int ata_scsi_ioctl(struct scsi_device *dev, int cmd, void __user *arg);
  extern int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *));
  extern int ata_scsi_error(struct Scsi_Host *host);