Merge branch 'master'
authorJeff Garzik <jgarzik@pobox.com>
Fri, 28 Oct 2005 16:29:23 +0000 (12:29 -0400)
committerJeff Garzik <jgarzik@pobox.com>
Fri, 28 Oct 2005 16:29:23 +0000 (12:29 -0400)
1  2 
drivers/scsi/ahci.c
drivers/scsi/libata-core.c
drivers/scsi/libata-scsi.c
drivers/scsi/pdc_adma.c
drivers/scsi/sata_mv.c
drivers/scsi/sata_qstor.c
drivers/scsi/sata_sil24.c
drivers/scsi/sata_sx4.c
include/linux/libata.h

diff --combined drivers/scsi/ahci.c
index f0d8f89b5d403b6b72cc8c537aa69b63dc8b6061,fe8187d6f58be248bdcf2f5ab053ff997ecb2dac..cbab5868ffdf5efeaabf97031b6fe00480b01b13
@@@ -216,7 -216,7 +216,7 @@@ static Scsi_Host_Template ahci_sht = 
        .ordered_flush          = 1,
  };
  
- static struct ata_port_operations ahci_ops = {
+ static const struct ata_port_operations ahci_ops = {
        .port_disable           = ata_port_disable,
  
        .check_status           = ahci_check_status,
@@@ -314,15 -314,8 +314,15 @@@ static int ahci_port_start(struct ata_p
                return -ENOMEM;
        memset(pp, 0, sizeof(*pp));
  
 +      ap->pad = dma_alloc_coherent(dev, ATA_DMA_PAD_BUF_SZ, &ap->pad_dma, GFP_KERNEL);
 +      if (!ap->pad) {
 +              kfree(pp);
 +              return -ENOMEM;
 +      }
 +
        mem = dma_alloc_coherent(dev, AHCI_PORT_PRIV_DMA_SZ, &mem_dma, GFP_KERNEL);
        if (!mem) {
 +              dma_free_coherent(dev, ATA_DMA_PAD_BUF_SZ, ap->pad, ap->pad_dma);
                kfree(pp);
                return -ENOMEM;
        }
@@@ -398,7 -391,6 +398,7 @@@ static void ahci_port_stop(struct ata_p
        ap->private_data = NULL;
        dma_free_coherent(dev, AHCI_PORT_PRIV_DMA_SZ,
                          pp->cmd_slot, pp->cmd_slot_dma);
 +      dma_free_coherent(dev, ATA_DMA_PAD_BUF_SZ, ap->pad, ap->pad_dma);
        kfree(pp);
  }
  
@@@ -415,7 -407,7 +415,7 @@@ static u32 ahci_scr_read (struct ata_po
                return 0xffffffffU;
        }
  
-       return readl((void *) ap->ioaddr.scr_addr + (sc_reg * 4));
+       return readl((void __iomem *) ap->ioaddr.scr_addr + (sc_reg * 4));
  }
  
  
@@@ -433,7 -425,7 +433,7 @@@ static void ahci_scr_write (struct ata_
                return;
        }
  
-       writel(val, (void *) ap->ioaddr.scr_addr + (sc_reg * 4));
+       writel(val, (void __iomem *) ap->ioaddr.scr_addr + (sc_reg * 4));
  }
  
  static void ahci_phy_reset(struct ata_port *ap)
  
  static u8 ahci_check_status(struct ata_port *ap)
  {
-       void *mmio = (void *) ap->ioaddr.cmd_addr;
+       void __iomem *mmio = (void __iomem *) ap->ioaddr.cmd_addr;
  
        return readl(mmio + PORT_TFDATA) & 0xFF;
  }
  
  static u8 ahci_check_err(struct ata_port *ap)
  {
-       void *mmio = (void *) ap->ioaddr.cmd_addr;
+       void __iomem *mmio = (void __iomem *) ap->ioaddr.cmd_addr;
  
        return (readl(mmio + PORT_TFDATA) >> 8) & 0xFF;
  }
@@@ -484,23 -476,23 +484,23 @@@ static void ahci_tf_read(struct ata_por
  static void ahci_fill_sg(struct ata_queued_cmd *qc)
  {
        struct ahci_port_priv *pp = qc->ap->private_data;
 -      unsigned int i;
 +      struct scatterlist *sg;
 +      struct ahci_sg *ahci_sg;
  
        VPRINTK("ENTER\n");
  
        /*
         * Next, the S/G list.
         */
 -      for (i = 0; i < qc->n_elem; i++) {
 -              u32 sg_len;
 -              dma_addr_t addr;
 -
 -              addr = sg_dma_address(&qc->sg[i]);
 -              sg_len = sg_dma_len(&qc->sg[i]);
 -
 -              pp->cmd_tbl_sg[i].addr = cpu_to_le32(addr & 0xffffffff);
 -              pp->cmd_tbl_sg[i].addr_hi = cpu_to_le32((addr >> 16) >> 16);
 -              pp->cmd_tbl_sg[i].flags_size = cpu_to_le32(sg_len - 1);
 +      ahci_sg = pp->cmd_tbl_sg;
 +      ata_for_each_sg(sg, qc) {
 +              dma_addr_t addr = sg_dma_address(sg);
 +              u32 sg_len = sg_dma_len(sg);
 +
 +              ahci_sg->addr = cpu_to_le32(addr & 0xffffffff);
 +              ahci_sg->addr_hi = cpu_to_le32((addr >> 16) >> 16);
 +              ahci_sg->flags_size = cpu_to_le32(sg_len - 1);
 +              ahci_sg++;
        }
  }
  
index c5e663fefdf7a7aee17cafa44add1b02e65ecc2c,f53d7b8ac33f41fcd488cdfb34ec88b3b0658339..64f30bf5931537694db42967e9b990c92b724319
@@@ -67,9 -67,9 +67,9 @@@ static void ata_dev_reread_id(struct at
  static void ata_dev_init_params(struct ata_port *ap, struct ata_device *dev);
  static void ata_set_mode(struct ata_port *ap);
  static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev);
- static unsigned int ata_get_mode_mask(struct ata_port *ap, int shift);
+ static unsigned int ata_get_mode_mask(const struct ata_port *ap, int shift);
  static int fgb(u32 bitmap);
- static int ata_choose_xfer_mode(struct ata_port *ap,
+ static int ata_choose_xfer_mode(const struct ata_port *ap,
                                u8 *xfer_mode_out,
                                unsigned int *xfer_shift_out);
  static void __ata_qc_complete(struct ata_queued_cmd *qc);
@@@ -87,7 -87,7 +87,7 @@@ MODULE_LICENSE("GPL")
  MODULE_VERSION(DRV_VERSION);
  
  /**
-  *    ata_tf_load - send taskfile registers to host controller
+  *    ata_tf_load_pio - send taskfile registers to host controller
   *    @ap: Port to which output is sent
   *    @tf: ATA taskfile register set
   *
@@@ -97,7 -97,7 +97,7 @@@
   *    Inherited from caller.
   */
  
- static void ata_tf_load_pio(struct ata_port *ap, struct ata_taskfile *tf)
+ static void ata_tf_load_pio(struct ata_port *ap, const struct ata_taskfile *tf)
  {
        struct ata_ioports *ioaddr = &ap->ioaddr;
        unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
   *    Inherited from caller.
   */
  
- static void ata_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf)
+ static void ata_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
  {
        struct ata_ioports *ioaddr = &ap->ioaddr;
        unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
   *    LOCKING:
   *    Inherited from caller.
   */
- void ata_tf_load(struct ata_port *ap, struct ata_taskfile *tf)
+ void ata_tf_load(struct ata_port *ap, const struct ata_taskfile *tf)
  {
        if (ap->flags & ATA_FLAG_MMIO)
                ata_tf_load_mmio(ap, tf);
   *    spin_lock_irqsave(host_set lock)
   */
  
- static void ata_exec_command_pio(struct ata_port *ap, struct ata_taskfile *tf)
+ static void ata_exec_command_pio(struct ata_port *ap, const struct ata_taskfile *tf)
  {
        DPRINTK("ata%u: cmd 0x%X\n", ap->id, tf->command);
  
   *    spin_lock_irqsave(host_set lock)
   */
  
- static void ata_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf)
+ static void ata_exec_command_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
  {
        DPRINTK("ata%u: cmd 0x%X\n", ap->id, tf->command);
  
   *    LOCKING:
   *    spin_lock_irqsave(host_set lock)
   */
- void ata_exec_command(struct ata_port *ap, struct ata_taskfile *tf)
+ void ata_exec_command(struct ata_port *ap, const struct ata_taskfile *tf)
  {
        if (ap->flags & ATA_FLAG_MMIO)
                ata_exec_command_mmio(ap, tf);
   *    Obtains host_set lock.
   */
  
- static inline void ata_exec(struct ata_port *ap, struct ata_taskfile *tf)
+ static inline void ata_exec(struct ata_port *ap, const struct ata_taskfile *tf)
  {
        unsigned long flags;
  
   *    Obtains host_set lock.
   */
  
- static void ata_tf_to_host(struct ata_port *ap, struct ata_taskfile *tf)
+ static void ata_tf_to_host(struct ata_port *ap, const struct ata_taskfile *tf)
  {
        ap->ops->tf_load(ap, tf);
  
   *    spin_lock_irqsave(host_set lock)
   */
  
- void ata_tf_to_host_nolock(struct ata_port *ap, struct ata_taskfile *tf)
+ void ata_tf_to_host_nolock(struct ata_port *ap, const struct ata_taskfile *tf)
  {
        ap->ops->tf_load(ap, tf);
        ap->ops->exec_command(ap, tf);
@@@ -558,7 -558,7 +558,7 @@@ u8 ata_chk_err(struct ata_port *ap
   *    Inherited from caller.
   */
  
- void ata_tf_to_fis(struct ata_taskfile *tf, u8 *fis, u8 pmp)
+ void ata_tf_to_fis(const struct ata_taskfile *tf, u8 *fis, u8 pmp)
  {
        fis[0] = 0x27;  /* Register - Host to Device FIS */
        fis[1] = (pmp & 0xf) | (1 << 7); /* Port multiplier number,
   *    Inherited from caller.
   */
  
- void ata_tf_from_fis(u8 *fis, struct ata_taskfile *tf)
+ void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf)
  {
        tf->command     = fis[2];       /* status */
        tf->feature     = fis[3];       /* error */
@@@ -845,7 -845,7 +845,7 @@@ static unsigned int ata_devchk(struct a
   *    the event of failure.
   */
  
- unsigned int ata_dev_classify(struct ata_taskfile *tf)
+ unsigned int ata_dev_classify(const struct ata_taskfile *tf)
  {
        /* Apple's open source Darwin code hints that some devices only
         * put a proper signature into the LBA mid/high registers,
@@@ -937,7 -937,7 +937,7 @@@ static u8 ata_dev_try_classify(struct a
   *    caller.
   */
  
- void ata_dev_id_string(u16 *id, unsigned char *s,
+ void ata_dev_id_string(const u16 *id, unsigned char *s,
                       unsigned int ofs, unsigned int len)
  {
        unsigned int c;
@@@ -1054,7 -1054,7 +1054,7 @@@ void ata_dev_select(struct ata_port *ap
   *    caller.
   */
  
- static inline void ata_dump_id(struct ata_device *dev)
+ static inline void ata_dump_id(const struct ata_device *dev)
  {
        DPRINTK("49==0x%04x  "
                "53==0x%04x  "
                dev->id[93]);
  }
  
+ /*
+  *    Compute the PIO modes available for this device. This is not as
+  *    trivial as it seems if we must consider early devices correctly.
+  *
+  *    FIXME: pre IDE drive timing (do we care ?). 
+  */
+ static unsigned int ata_pio_modes(const struct ata_device *adev)
+ {
+       u16 modes;
+       /* Usual case. Word 53 indicates word 88 is valid */
+       if (adev->id[ATA_ID_FIELD_VALID] & (1 << 2)) {
+               modes = adev->id[ATA_ID_PIO_MODES] & 0x03;
+               modes <<= 3;
+               modes |= 0x7;
+               return modes;
+       }
+       /* If word 88 isn't valid then Word 51 holds the PIO timing number
+          for the maximum. Turn it into a mask and return it */
+       modes = (2 << (adev->id[ATA_ID_OLD_PIO_MODES] & 0xFF)) - 1 ;
+       return modes;
+ }
  /**
   *    ata_dev_identify - obtain IDENTIFY x DEVICE page
   *    @ap: port on which device we wish to probe resides
@@@ -1215,10 -1240,8 +1240,8 @@@ retry
        xfer_modes = dev->id[ATA_ID_UDMA_MODES];
        if (!xfer_modes)
                xfer_modes = (dev->id[ATA_ID_MWDMA_MODES]) << ATA_SHIFT_MWDMA;
-       if (!xfer_modes) {
-               xfer_modes = (dev->id[ATA_ID_PIO_MODES]) << (ATA_SHIFT_PIO + 3);
-               xfer_modes |= (0x7 << ATA_SHIFT_PIO);
-       }
+       if (!xfer_modes)
+               xfer_modes = ata_pio_modes(dev);
  
        ata_dump_id(dev);
  
@@@ -1329,7 -1352,7 +1352,7 @@@ err_out
  }
  
  
- static inline u8 ata_dev_knobble(struct ata_port *ap)
+ static inline u8 ata_dev_knobble(const struct ata_port *ap)
  {
        return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(ap->device->id)));
  }
@@@ -1515,7 -1538,153 +1538,153 @@@ void ata_port_disable(struct ata_port *
        ap->flags |= ATA_FLAG_PORT_DISABLED;
  }
  
- static struct {
+ /*
+  * This mode timing computation functionality is ported over from
+  * drivers/ide/ide-timing.h and was originally written by Vojtech Pavlik
+  */
+ /*
+  * PIO 0-5, MWDMA 0-2 and UDMA 0-6 timings (in nanoseconds).
+  * These were taken from ATA/ATAPI-6 standard, rev 0a, except
+  * for PIO 5, which is a nonstandard extension and UDMA6, which
+  * is currently supported only by Maxtor drives. 
+  */
+ static const struct ata_timing ata_timing[] = {
+       { XFER_UDMA_6,     0,   0,   0,   0,   0,   0,   0,  15 },
+       { XFER_UDMA_5,     0,   0,   0,   0,   0,   0,   0,  20 },
+       { XFER_UDMA_4,     0,   0,   0,   0,   0,   0,   0,  30 },
+       { XFER_UDMA_3,     0,   0,   0,   0,   0,   0,   0,  45 },
+       { XFER_UDMA_2,     0,   0,   0,   0,   0,   0,   0,  60 },
+       { XFER_UDMA_1,     0,   0,   0,   0,   0,   0,   0,  80 },
+       { XFER_UDMA_0,     0,   0,   0,   0,   0,   0,   0, 120 },
+ /*    { XFER_UDMA_SLOW,  0,   0,   0,   0,   0,   0,   0, 150 }, */
+                                           
+       { XFER_MW_DMA_2,  25,   0,   0,   0,  70,  25, 120,   0 },
+       { XFER_MW_DMA_1,  45,   0,   0,   0,  80,  50, 150,   0 },
+       { XFER_MW_DMA_0,  60,   0,   0,   0, 215, 215, 480,   0 },
+                                           
+       { XFER_SW_DMA_2,  60,   0,   0,   0, 120, 120, 240,   0 },
+       { XFER_SW_DMA_1,  90,   0,   0,   0, 240, 240, 480,   0 },
+       { XFER_SW_DMA_0, 120,   0,   0,   0, 480, 480, 960,   0 },
+ /*    { XFER_PIO_5,     20,  50,  30, 100,  50,  30, 100,   0 }, */
+       { XFER_PIO_4,     25,  70,  25, 120,  70,  25, 120,   0 },
+       { XFER_PIO_3,     30,  80,  70, 180,  80,  70, 180,   0 },
+       { XFER_PIO_2,     30, 290,  40, 330, 100,  90, 240,   0 },
+       { XFER_PIO_1,     50, 290,  93, 383, 125, 100, 383,   0 },
+       { XFER_PIO_0,     70, 290, 240, 600, 165, 150, 600,   0 },
+ /*    { XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 960,   0 }, */
+       { 0xFF }
+ };
+ #define ENOUGH(v,unit)                (((v)-1)/(unit)+1)
+ #define EZ(v,unit)            ((v)?ENOUGH(v,unit):0)
+ static void ata_timing_quantize(const struct ata_timing *t, struct ata_timing *q, int T, int UT)
+ {
+       q->setup   = EZ(t->setup   * 1000,  T);
+       q->act8b   = EZ(t->act8b   * 1000,  T);
+       q->rec8b   = EZ(t->rec8b   * 1000,  T);
+       q->cyc8b   = EZ(t->cyc8b   * 1000,  T);
+       q->active  = EZ(t->active  * 1000,  T);
+       q->recover = EZ(t->recover * 1000,  T);
+       q->cycle   = EZ(t->cycle   * 1000,  T);
+       q->udma    = EZ(t->udma    * 1000, UT);
+ }
+ void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b,
+                     struct ata_timing *m, unsigned int what)
+ {
+       if (what & ATA_TIMING_SETUP  ) m->setup   = max(a->setup,   b->setup);
+       if (what & ATA_TIMING_ACT8B  ) m->act8b   = max(a->act8b,   b->act8b);
+       if (what & ATA_TIMING_REC8B  ) m->rec8b   = max(a->rec8b,   b->rec8b);
+       if (what & ATA_TIMING_CYC8B  ) m->cyc8b   = max(a->cyc8b,   b->cyc8b);
+       if (what & ATA_TIMING_ACTIVE ) m->active  = max(a->active,  b->active);
+       if (what & ATA_TIMING_RECOVER) m->recover = max(a->recover, b->recover);
+       if (what & ATA_TIMING_CYCLE  ) m->cycle   = max(a->cycle,   b->cycle);
+       if (what & ATA_TIMING_UDMA   ) m->udma    = max(a->udma,    b->udma);
+ }
+ static const struct ata_timing* ata_timing_find_mode(unsigned short speed)
+ {
+       const struct ata_timing *t;
+       for (t = ata_timing; t->mode != speed; t++)
+               if (t->mode == 0xFF)
+                       return NULL;
+       return t; 
+ }
+ int ata_timing_compute(struct ata_device *adev, unsigned short speed,
+                      struct ata_timing *t, int T, int UT)
+ {
+       const struct ata_timing *s;
+       struct ata_timing p;
+       /*
+        * Find the mode. 
+       */
+       if (!(s = ata_timing_find_mode(speed)))
+               return -EINVAL;
+       /*
+        * If the drive is an EIDE drive, it can tell us it needs extended
+        * PIO/MW_DMA cycle timing.
+        */
+       if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE drive */
+               memset(&p, 0, sizeof(p));
+               if(speed >= XFER_PIO_0 && speed <= XFER_SW_DMA_0) {
+                       if (speed <= XFER_PIO_2) p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO];
+                                           else p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO_IORDY];
+               } else if(speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2) {
+                       p.cycle = adev->id[ATA_ID_EIDE_DMA_MIN];
+               }
+               ata_timing_merge(&p, t, t, ATA_TIMING_CYCLE | ATA_TIMING_CYC8B);
+       }
+       /*
+        * Convert the timing to bus clock counts.
+        */
+       ata_timing_quantize(s, t, T, UT);
+       /*
+        * Even in DMA/UDMA modes we still use PIO access for IDENTIFY, S.M.A.R.T
+        * and some other commands. We have to ensure that the DMA cycle timing is
+        * slower/equal than the fastest PIO timing.
+        */
+       if (speed > XFER_PIO_4) {
+               ata_timing_compute(adev, adev->pio_mode, &p, T, UT);
+               ata_timing_merge(&p, t, t, ATA_TIMING_ALL);
+       }
+       /*
+        * Lenghten active & recovery time so that cycle time is correct.
+        */
+       if (t->act8b + t->rec8b < t->cyc8b) {
+               t->act8b += (t->cyc8b - (t->act8b + t->rec8b)) / 2;
+               t->rec8b = t->cyc8b - t->act8b;
+       }
+       if (t->active + t->recover < t->cycle) {
+               t->active += (t->cycle - (t->active + t->recover)) / 2;
+               t->recover = t->cycle - t->active;
+       }
+       return 0;
+ }
+ static const struct {
        unsigned int shift;
        u8 base;
  } xfer_mode_classes[] = {
@@@ -1924,7 -2093,8 +2093,8 @@@ err_out
        DPRINTK("EXIT\n");
  }
  
- static void ata_pr_blacklisted(struct ata_port *ap, struct ata_device *dev)
+ static void ata_pr_blacklisted(const struct ata_port *ap,
+                              const struct ata_device *dev)
  {
        printk(KERN_WARNING "ata%u: dev %u is on DMA blacklist, disabling DMA\n",
                ap->id, dev->devno);
@@@ -1962,7 -2132,7 +2132,7 @@@ static const char * ata_dma_blacklist [
        "_NEC DV5800A",
  };
  
- static int ata_dma_blacklisted(struct ata_port *ap, struct ata_device *dev)
+ static int ata_dma_blacklisted(const struct ata_device *dev)
  {
        unsigned char model_num[40];
        char *s;
        return 0;
  }
  
- static unsigned int ata_get_mode_mask(struct ata_port *ap, int shift)
+ static unsigned int ata_get_mode_mask(const struct ata_port *ap, int shift)
  {
-       struct ata_device *master, *slave;
+       const struct ata_device *master, *slave;
        unsigned int mask;
  
        master = &ap->device[0];
                mask = ap->udma_mask;
                if (ata_dev_present(master)) {
                        mask &= (master->id[ATA_ID_UDMA_MODES] & 0xff);
-                       if (ata_dma_blacklisted(ap, master)) {
+                       if (ata_dma_blacklisted(master)) {
                                mask = 0;
                                ata_pr_blacklisted(ap, master);
                        }
                }
                if (ata_dev_present(slave)) {
                        mask &= (slave->id[ATA_ID_UDMA_MODES] & 0xff);
-                       if (ata_dma_blacklisted(ap, slave)) {
+                       if (ata_dma_blacklisted(slave)) {
                                mask = 0;
                                ata_pr_blacklisted(ap, slave);
                        }
                mask = ap->mwdma_mask;
                if (ata_dev_present(master)) {
                        mask &= (master->id[ATA_ID_MWDMA_MODES] & 0x07);
-                       if (ata_dma_blacklisted(ap, master)) {
+                       if (ata_dma_blacklisted(master)) {
                                mask = 0;
                                ata_pr_blacklisted(ap, master);
                        }
                }
                if (ata_dev_present(slave)) {
                        mask &= (slave->id[ATA_ID_MWDMA_MODES] & 0x07);
-                       if (ata_dma_blacklisted(ap, slave)) {
+                       if (ata_dma_blacklisted(slave)) {
                                mask = 0;
                                ata_pr_blacklisted(ap, slave);
                        }
@@@ -2089,7 -2259,7 +2259,7 @@@ static int fgb(u32 bitmap
   *    Zero on success, negative on error.
   */
  
- static int ata_choose_xfer_mode(struct ata_port *ap,
+ static int ata_choose_xfer_mode(const struct ata_port *ap,
                                u8 *xfer_mode_out,
                                unsigned int *xfer_shift_out)
  {
@@@ -2274,9 -2444,8 +2444,9 @@@ static void ata_dev_init_params(struct 
  static void ata_sg_clean(struct ata_queued_cmd *qc)
  {
        struct ata_port *ap = qc->ap;
 -      struct scatterlist *sg = qc->sg;
 +      struct scatterlist *sg = qc->__sg;
        int dir = qc->dma_dir;
 +      void *pad_buf = NULL;
  
        assert(qc->flags & ATA_QCFLAG_DMAMAP);
        assert(sg != NULL);
  
        DPRINTK("unmapping %u sg elements\n", qc->n_elem);
  
 -      if (qc->flags & ATA_QCFLAG_SG)
 +      /* if we padded the buffer out to 32-bit bound, and data
 +       * xfer direction is from-device, we must copy from the
 +       * pad buffer back into the supplied buffer
 +       */
 +      if (qc->pad_len && !(qc->tf.flags & ATA_TFLAG_WRITE))
 +              pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
 +
 +      if (qc->flags & ATA_QCFLAG_SG) {
                dma_unmap_sg(ap->host_set->dev, sg, qc->n_elem, dir);
 -      else
 +              /* restore last sg */
 +              sg[qc->orig_n_elem - 1].length += qc->pad_len;
 +              if (pad_buf) {
 +                      struct scatterlist *psg = &qc->pad_sgent;
 +                      void *addr = kmap_atomic(psg->page, KM_IRQ0);
 +                      memcpy(addr + psg->offset, pad_buf, qc->pad_len);
 +                      kunmap_atomic(psg->page, KM_IRQ0);
 +              }
 +      } else {
                dma_unmap_single(ap->host_set->dev, sg_dma_address(&sg[0]),
                                 sg_dma_len(&sg[0]), dir);
 +              /* restore sg */
 +              sg->length += qc->pad_len;
 +              if (pad_buf)
 +                      memcpy(qc->buf_virt + sg->length - qc->pad_len,
 +                             pad_buf, qc->pad_len);
 +      }
  
        qc->flags &= ~ATA_QCFLAG_DMAMAP;
 -      qc->sg = NULL;
 +      qc->__sg = NULL;
  }
  
  /**
   */
  static void ata_fill_sg(struct ata_queued_cmd *qc)
  {
 -      struct scatterlist *sg = qc->sg;
        struct ata_port *ap = qc->ap;
 -      unsigned int idx, nelem;
 +      struct scatterlist *sg;
 +      unsigned int idx;
  
 -      assert(sg != NULL);
 +      assert(qc->__sg != NULL);
        assert(qc->n_elem > 0);
  
        idx = 0;
 -      for (nelem = qc->n_elem; nelem; nelem--,sg++) {
 +      ata_for_each_sg(sg, qc) {
                u32 addr, offset;
                u32 sg_len, len;
  
@@@ -2429,12 -2577,11 +2599,12 @@@ void ata_sg_init_one(struct ata_queued_
        qc->flags |= ATA_QCFLAG_SINGLE;
  
        memset(&qc->sgent, 0, sizeof(qc->sgent));
 -      qc->sg = &qc->sgent;
 +      qc->__sg = &qc->sgent;
        qc->n_elem = 1;
 +      qc->orig_n_elem = 1;
        qc->buf_virt = buf;
  
 -      sg = qc->sg;
 +      sg = qc->__sg;
        sg->page = virt_to_page(buf);
        sg->offset = (unsigned long) buf & ~PAGE_MASK;
        sg->length = buflen;
@@@ -2458,9 -2605,8 +2628,9 @@@ void ata_sg_init(struct ata_queued_cmd 
                 unsigned int n_elem)
  {
        qc->flags |= ATA_QCFLAG_SG;
 -      qc->sg = sg;
 +      qc->__sg = sg;
        qc->n_elem = n_elem;
 +      qc->orig_n_elem = n_elem;
  }
  
  /**
@@@ -2480,32 -2626,9 +2650,32 @@@ static int ata_sg_setup_one(struct ata_
  {
        struct ata_port *ap = qc->ap;
        int dir = qc->dma_dir;
 -      struct scatterlist *sg = qc->sg;
 +      struct scatterlist *sg = qc->__sg;
        dma_addr_t dma_address;
  
 +      /* we must lengthen transfers to end on a 32-bit boundary */
 +      qc->pad_len = sg->length & 3;
 +      if (qc->pad_len) {
 +              void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
 +              struct scatterlist *psg = &qc->pad_sgent;
 +
 +              assert(qc->dev->class == ATA_DEV_ATAPI);
 +
 +              memset(pad_buf, 0, ATA_DMA_PAD_SZ);
 +
 +              if (qc->tf.flags & ATA_TFLAG_WRITE)
 +                      memcpy(pad_buf, qc->buf_virt + sg->length - qc->pad_len,
 +                             qc->pad_len);
 +
 +              sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
 +              sg_dma_len(psg) = ATA_DMA_PAD_SZ;
 +              /* trim sg */
 +              sg->length -= qc->pad_len;
 +
 +              DPRINTK("padding done, sg->length=%u pad_len=%u\n",
 +                      sg->length, qc->pad_len);
 +      }
 +
        dma_address = dma_map_single(ap->host_set->dev, qc->buf_virt,
                                     sg->length, dir);
        if (dma_mapping_error(dma_address))
  static int ata_sg_setup(struct ata_queued_cmd *qc)
  {
        struct ata_port *ap = qc->ap;
 -      struct scatterlist *sg = qc->sg;
 +      struct scatterlist *sg = qc->__sg;
 +      struct scatterlist *lsg = &sg[qc->n_elem - 1];
        int n_elem, dir;
  
        VPRINTK("ENTER, ata%u\n", ap->id);
        assert(qc->flags & ATA_QCFLAG_SG);
  
 +      /* we must lengthen transfers to end on a 32-bit boundary */
 +      qc->pad_len = lsg->length & 3;
 +      if (qc->pad_len) {
 +              void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
 +              struct scatterlist *psg = &qc->pad_sgent;
 +              unsigned int offset;
 +
 +              assert(qc->dev->class == ATA_DEV_ATAPI);
 +
 +              memset(pad_buf, 0, ATA_DMA_PAD_SZ);
 +
 +              /*
 +               * psg->page/offset are used to copy to-be-written
 +               * data in this function or read data in ata_sg_clean.
 +               */
 +              offset = lsg->offset + lsg->length - qc->pad_len;
 +              psg->page = nth_page(lsg->page, offset >> PAGE_SHIFT);
 +              psg->offset = offset_in_page(offset);
 +
 +              if (qc->tf.flags & ATA_TFLAG_WRITE) {
 +                      void *addr = kmap_atomic(psg->page, KM_IRQ0);
 +                      memcpy(pad_buf, addr + psg->offset, qc->pad_len);
 +                      kunmap_atomic(psg->page, KM_IRQ0);
 +              }
 +
 +              sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
 +              sg_dma_len(psg) = ATA_DMA_PAD_SZ;
 +              /* trim last sg */
 +              lsg->length -= qc->pad_len;
 +
 +              DPRINTK("padding done, sg[%d].length=%u pad_len=%u\n",
 +                      qc->n_elem - 1, lsg->length, qc->pad_len);
 +      }
 +
        dir = qc->dma_dir;
        n_elem = dma_map_sg(ap->host_set->dev, sg, qc->n_elem, dir);
        if (n_elem < 1)
@@@ -2613,13 -2701,13 +2783,13 @@@ void ata_poll_qc_complete(struct ata_qu
  
  /**
   *    ata_pio_poll -
-  *    @ap:
+  *    @ap: the target ata_port
   *
   *    LOCKING:
   *    None.  (executing in kernel thread context)
   *
   *    RETURNS:
-  *
+  *    timeout value to use
   */
  
  static unsigned long ata_pio_poll(struct ata_port *ap)
  }
  
  /**
-  *    ata_pio_complete -
-  *    @ap:
+  *    ata_pio_complete - check if drive is busy or idle
+  *    @ap: the target ata_port
   *
   *    LOCKING:
   *    None.  (executing in kernel thread context)
@@@ -2713,7 -2801,7 +2883,7 @@@ static int ata_pio_complete (struct ata
  
  
  /**
-  *    swap_buf_le16 -
+  *    swap_buf_le16 - swap halves of 16-words in place
   *    @buf:  Buffer to swap
   *    @buf_words:  Number of 16-bit words in buffer.
   *
   *    vice-versa.
   *
   *    LOCKING:
+  *    Inherited from caller.
   */
  void swap_buf_le16(u16 *buf, unsigned int buf_words)
  {
   *
   *    LOCKING:
   *    Inherited from caller.
-  *
   */
  
  static void ata_mmio_data_xfer(struct ata_port *ap, unsigned char *buf,
   *
   *    LOCKING:
   *    Inherited from caller.
-  *
   */
  
  static void ata_pio_data_xfer(struct ata_port *ap, unsigned char *buf,
   *
   *    LOCKING:
   *    Inherited from caller.
-  *
   */
  
  static void ata_data_xfer(struct ata_port *ap, unsigned char *buf,
  static void ata_pio_sector(struct ata_queued_cmd *qc)
  {
        int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
 -      struct scatterlist *sg = qc->sg;
 +      struct scatterlist *sg = qc->__sg;
        struct ata_port *ap = qc->ap;
        struct page *page;
        unsigned int offset;
  static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes)
  {
        int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
 -      struct scatterlist *sg = qc->sg;
 +      struct scatterlist *sg = qc->__sg;
        struct ata_port *ap = qc->ap;
        struct page *page;
        unsigned char *buf;
@@@ -2938,7 -3024,7 +3106,7 @@@ next_sg
                return;
        }
  
 -      sg = &qc->sg[qc->cursg];
 +      sg = &qc->__sg[qc->cursg];
  
        page = sg->page;
        offset = sg->offset + qc->cursg_ofs;
   *
   *    LOCKING:
   *    Inherited from caller.
-  *
   */
  
  static void atapi_pio_bytes(struct ata_queued_cmd *qc)
@@@ -3019,8 -3104,8 +3186,8 @@@ err_out
  }
  
  /**
-  *    ata_pio_sector -
-  *    @ap:
+  *    ata_pio_block - start PIO on a block
+  *    @ap: the target ata_port
   *
   *    LOCKING:
   *    None.  (executing in kernel thread context)
@@@ -3032,7 -3117,7 +3199,7 @@@ static void ata_pio_block(struct ata_po
        u8 status;
  
        /*
-        * This is purely hueristic.  This is a fast path.
+        * This is purely heuristic.  This is a fast path.
         * Sometimes when we enter, BSY will be cleared in
         * a chk-status or two.  If not, the drive is probably seeking
         * or something.  Snooze for a couple msecs, then
@@@ -3299,7 -3384,7 +3466,7 @@@ struct ata_queued_cmd *ata_qc_new_init(
  
        qc = ata_qc_new(ap);
        if (qc) {
 -              qc->sg = NULL;
 +              qc->__sg = NULL;
                qc->flags = 0;
                qc->scsicmd = NULL;
                qc->ap = ap;
@@@ -3352,7 -3437,6 +3519,6 @@@ static void __ata_qc_complete(struct at
   *
   *    LOCKING:
   *    spin_lock_irqsave(host_set lock)
-  *
   */
  void ata_qc_free(struct ata_queued_cmd *qc)
  {
   *
   *    LOCKING:
   *    spin_lock_irqsave(host_set lock)
-  *
   */
  
  void ata_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
@@@ -3866,7 -3949,6 +4031,6 @@@ idle_irq
   *
   *    RETURNS:
   *    IRQ_NONE or IRQ_HANDLED.
-  *
   */
  
  irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
@@@ -3978,6 -4060,7 +4142,7 @@@ err_out
   *    May be used as the port_start() entry in ata_port_operations.
   *
   *    LOCKING:
+  *    Inherited from caller.
   */
  
  int ata_port_start (struct ata_port *ap)
        if (!ap->prd)
                return -ENOMEM;
  
 +      ap->pad = dma_alloc_coherent(dev, ATA_DMA_PAD_BUF_SZ, &ap->pad_dma, GFP_KERNEL);
 +      if (!ap->pad) {
 +              dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
 +              return -ENOMEM;
 +      }
 +
        DPRINTK("prd alloc, virt %p, dma %llx\n", ap->prd, (unsigned long long) ap->prd_dma);
  
        return 0;
   *    May be used as the port_stop() entry in ata_port_operations.
   *
   *    LOCKING:
+  *    Inherited from caller.
   */
  
  void ata_port_stop (struct ata_port *ap)
        struct device *dev = ap->host_set->dev;
  
        dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
 +      dma_free_coherent(dev, ATA_DMA_PAD_BUF_SZ, ap->pad, ap->pad_dma);
  }
  
  void ata_host_stop (struct ata_host_set *host_set)
   *    @do_unregister: 1 if we fully unregister, 0 to just stop the port
   *
   *    LOCKING:
+  *    Inherited from caller.
   */
  
  static void ata_host_remove(struct ata_port *ap, unsigned int do_unregister)
   *
   *    LOCKING:
   *    Inherited from caller.
-  *
   */
  
  static void ata_host_init(struct ata_port *ap, struct Scsi_Host *host,
                          struct ata_host_set *host_set,
-                         struct ata_probe_ent *ent, unsigned int port_no)
+                         const struct ata_probe_ent *ent, unsigned int port_no)
  {
        unsigned int i;
  
   *
   *    RETURNS:
   *    New ata_port on success, for NULL on error.
-  *
   */
  
- static struct ata_port * ata_host_add(struct ata_probe_ent *ent,
+ static struct ata_port * ata_host_add(const struct ata_probe_ent *ent,
                                      struct ata_host_set *host_set,
                                      unsigned int port_no)
  {
@@@ -4168,10 -4244,9 +4333,9 @@@ err_out
   *
   *    RETURNS:
   *    Number of ports registered.  Zero on error (no ports registered).
-  *
   */
  
- int ata_device_add(struct ata_probe_ent *ent)
+ int ata_device_add(const struct ata_probe_ent *ent)
  {
        unsigned int count = 0, i;
        struct device *dev = ent->dev;
@@@ -4300,7 -4375,6 +4464,6 @@@ err_out
   *    Inherited from calling layer (may sleep).
   */
  
  void ata_host_set_remove(struct ata_host_set *host_set)
  {
        struct ata_port *ap;
@@@ -4390,7 -4464,7 +4553,7 @@@ void ata_std_ports(struct ata_ioports *
  }
  
  static struct ata_probe_ent *
- ata_probe_ent_alloc(struct device *dev, struct ata_port_info *port)
+ ata_probe_ent_alloc(struct device *dev, const struct ata_port_info *port)
  {
        struct ata_probe_ent *probe_ent;
  
@@@ -4490,7 -4564,6 +4653,6 @@@ static struct ata_probe_ent *ata_pci_in
        if (!probe_ent)
                return NULL;
  
-       
        probe_ent->legacy_mode = 1;
        probe_ent->n_ports = 1;
        probe_ent->hard_port_no = port_num;
   *
   *    RETURNS:
   *    Zero on success, negative on errno-based value on error.
-  *
   */
  
  int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
@@@ -4682,7 -4754,7 +4843,7 @@@ err_out
   *    @pdev: PCI device that was removed
   *
   *    PCI layer indicates to libata via this hook that
-  *    hot-unplug or module unload event has occured.
+  *    hot-unplug or module unload event has occurred.
   *    Handle this by unregistering all objects associated
   *    with this PCI device.  Free those objects.  Then finally
   *    release PCI resources and disable device.
@@@ -4703,7 -4775,7 +4864,7 @@@ void ata_pci_remove_one (struct pci_de
  }
  
  /* move to PCI subsystem */
- int pci_test_config_bits(struct pci_dev *pdev, struct pci_bits *bits)
+ int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits)
  {
        unsigned long tmp = 0;
  
@@@ -4830,6 -4902,9 +4991,9 @@@ EXPORT_SYMBOL_GPL(ata_dev_id_string)
  EXPORT_SYMBOL_GPL(ata_dev_config);
  EXPORT_SYMBOL_GPL(ata_scsi_simulate);
  
+ EXPORT_SYMBOL_GPL(ata_timing_compute);
+ EXPORT_SYMBOL_GPL(ata_timing_merge);
  #ifdef CONFIG_PCI
  EXPORT_SYMBOL_GPL(pci_test_config_bits);
  EXPORT_SYMBOL_GPL(ata_pci_host_stop);
index 9944adbe5a1d1b5176a996721516c7c5c7092579,58858886d751c8886fb4c5af8d354c57ff3069fc..a68c0341dc82f1dcabc5906f749595527270e5a2
@@@ -44,9 -44,9 +44,9 @@@
  
  #include "libata.h"
  
- typedef unsigned int (*ata_xlat_func_t)(struct ata_queued_cmd *qc, u8 *scsicmd);
+ typedef unsigned int (*ata_xlat_func_t)(struct ata_queued_cmd *qc, const u8 *scsicmd);
  static struct ata_device *
- ata_scsi_find_dev(struct ata_port *ap, struct scsi_device *scsidev);
+ ata_scsi_find_dev(struct ata_port *ap, const struct scsi_device *scsidev);
  
  
  static void ata_scsi_invalid_field(struct scsi_cmnd *cmd,
@@@ -158,10 -158,10 +158,10 @@@ struct ata_queued_cmd *ata_scsi_qc_new(
                qc->scsidone = done;
  
                if (cmd->use_sg) {
 -                      qc->sg = (struct scatterlist *) cmd->request_buffer;
 +                      qc->__sg = (struct scatterlist *) cmd->request_buffer;
                        qc->n_elem = cmd->use_sg;
                } else {
 -                      qc->sg = &qc->sgent;
 +                      qc->__sg = &qc->sgent;
                        qc->n_elem = 1;
                }
        } else {
@@@ -362,16 -362,6 +362,16 @@@ int ata_scsi_slave_config(struct scsi_d
                         */
                        blk_queue_max_sectors(sdev->request_queue, 2048);
                }
 +
 +              /*
 +               * SATA DMA transfers must be multiples of 4 byte, so
 +               * we need to pad ATAPI transfers using an extra sg.
 +               * Decrement max hw segments accordingly.
 +               */
 +              if (dev->class == ATA_DEV_ATAPI) {
 +                      request_queue_t *q = sdev->request_queue;
 +                      blk_queue_max_hw_segments(q, q->max_hw_segments - 1);
 +              }
        }
  
        return 0;       /* scsi layer doesn't check return value, sigh */
@@@ -428,7 -418,7 +428,7 @@@ int ata_scsi_error(struct Scsi_Host *ho
   */
  
  static unsigned int ata_scsi_start_stop_xlat(struct ata_queued_cmd *qc,
-                                            u8 *scsicmd)
+                                            const u8 *scsicmd)
  {
        struct ata_taskfile *tf = &qc->tf;
  
@@@ -495,7 -485,7 +495,7 @@@ invalid_fld
   *    Zero on success, non-zero on error.
   */
  
- static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
+ static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd *qc, const u8 *scsicmd)
  {
        struct ata_taskfile *tf = &qc->tf;
  
   *    @plen: the transfer length
   */
  
- static void scsi_6_lba_len(u8 *scsicmd, u64 *plba, u32 *plen)
+ static void scsi_6_lba_len(const u8 *scsicmd, u64 *plba, u32 *plen)
  {
        u64 lba = 0;
        u32 len = 0;
   *    @plen: the transfer length
   */
  
- static void scsi_10_lba_len(u8 *scsicmd, u64 *plba, u32 *plen)
+ static void scsi_10_lba_len(const u8 *scsicmd, u64 *plba, u32 *plen)
  {
        u64 lba = 0;
        u32 len = 0;
   *    @plen: the transfer length
   */
  
- static void scsi_16_lba_len(u8 *scsicmd, u64 *plba, u32 *plen)
+ static void scsi_16_lba_len(const u8 *scsicmd, u64 *plba, u32 *plen)
  {
        u64 lba = 0;
        u32 len = 0;
   *    Zero on success, non-zero on error.
   */
  
- static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
+ static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc, const u8 *scsicmd)
  {
        struct ata_taskfile *tf = &qc->tf;
        struct ata_device *dev = qc->dev;
@@@ -744,7 -734,7 +744,7 @@@ nothing_to_do
   *    Zero on success, non-zero on error.
   */
  
- static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
+ static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, const u8 *scsicmd)
  {
        struct ata_taskfile *tf = &qc->tf;
        struct ata_device *dev = qc->dev;
@@@ -1698,7 -1688,7 +1698,7 @@@ static int atapi_qc_complete(struct ata
   *    Zero on success, non-zero on failure.
   */
  
- static unsigned int atapi_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
+ static unsigned int atapi_xlat(struct ata_queued_cmd *qc, const u8 *scsicmd)
  {
        struct scsi_cmnd *cmd = qc->scsicmd;
        struct ata_device *dev = qc->dev;
   */
  
  static struct ata_device *
- ata_scsi_find_dev(struct ata_port *ap, struct scsi_device *scsidev)
+ ata_scsi_find_dev(struct ata_port *ap, const struct scsi_device *scsidev)
  {
        struct ata_device *dev;
  
@@@ -1924,7 -1914,7 +1924,7 @@@ void ata_scsi_simulate(u16 *id
                      void (*done)(struct scsi_cmnd *))
  {
        struct ata_scsi_args args;
-       u8 *scsicmd = cmd->cmnd;
+       const u8 *scsicmd = cmd->cmnd;
  
        args.id = id;
        args.cmd = cmd;
diff --combined drivers/scsi/pdc_adma.c
index c6825da6ae20a875832031b2bbc96cc60131118d,9820f272f889291680f0771c7c84afd3ae6b5f39..85ec5b1d7aa9f47b4c9aee26b206797fac94e2ca
@@@ -158,7 -158,7 +158,7 @@@ static Scsi_Host_Template adma_ata_sht 
        .bios_param             = ata_std_bios_param,
  };
  
- static struct ata_port_operations adma_ata_ops = {
+ static const struct ata_port_operations adma_ata_ops = {
        .port_disable           = ata_port_disable,
        .tf_load                = ata_tf_load,
        .tf_read                = ata_tf_read,
@@@ -293,14 -293,14 +293,14 @@@ static void adma_eng_timeout(struct ata
  
  static int adma_fill_sg(struct ata_queued_cmd *qc)
  {
 -      struct scatterlist *sg = qc->sg;
 +      struct scatterlist *sg;
        struct ata_port *ap = qc->ap;
        struct adma_port_priv *pp = ap->private_data;
        u8  *buf = pp->pkt;
 -      int nelem, i = (2 + buf[3]) * 8;
 +      int i = (2 + buf[3]) * 8;
        u8 pFLAGS = pORD | ((qc->tf.flags & ATA_TFLAG_WRITE) ? pDIRO : 0);
  
 -      for (nelem = 0; nelem < qc->n_elem; nelem++,sg++) {
 +      ata_for_each_sg(sg, qc) {
                u32 addr;
                u32 len;
  
                *(__le32 *)(buf + i) = cpu_to_le32(len);
                i += 4;
  
 -              if ((nelem + 1) == qc->n_elem)
 +              if (ata_sg_is_last(sg, qc))
                        pFLAGS |= pEND;
                buf[i++] = pFLAGS;
                buf[i++] = qc->dev->dma_mode & 0xf;
diff --combined drivers/scsi/sata_mv.c
index be7c378dcd365ae6162b6e119e002051e475ad4d,422e0b6f603ac5b8960073def04a2757f8ed79e8..1d6d0c9e76f6e13e90f0a1d2e39d1503885a1ed9
@@@ -35,7 -35,7 +35,7 @@@
  #include <asm/io.h>
  
  #define DRV_NAME      "sata_mv"
- #define DRV_VERSION   "0.24"
+ #define DRV_VERSION   "0.25"
  
  enum {
        /* BAR's are enumerated in terms of pci_resource_start() terms */
@@@ -290,7 -290,7 +290,7 @@@ static Scsi_Host_Template mv_sht = 
        .ordered_flush          = 1,
  };
  
- static struct ata_port_operations mv_ops = {
+ static const struct ata_port_operations mv_ops = {
        .port_disable           = ata_port_disable,
  
        .tf_load                = ata_tf_load,
@@@ -785,24 -785,23 +785,24 @@@ static void mv_port_stop(struct ata_por
  static void mv_fill_sg(struct ata_queued_cmd *qc)
  {
        struct mv_port_priv *pp = qc->ap->private_data;
 -      unsigned int i;
 +      unsigned int i = 0;
 +      struct scatterlist *sg;
  
 -      for (i = 0; i < qc->n_elem; i++) {
 +      ata_for_each_sg(sg, qc) {
                u32 sg_len;
                dma_addr_t addr;
  
 -              addr = sg_dma_address(&qc->sg[i]);
 -              sg_len = sg_dma_len(&qc->sg[i]);
 +              addr = sg_dma_address(sg);
 +              sg_len = sg_dma_len(sg);
  
                pp->sg_tbl[i].addr = cpu_to_le32(addr & 0xffffffff);
                pp->sg_tbl[i].addr_hi = cpu_to_le32((addr >> 16) >> 16);
                assert(0 == (sg_len & ~MV_DMA_BOUNDARY));
                pp->sg_tbl[i].flags_size = cpu_to_le32(sg_len);
 -      }
 -      if (0 < qc->n_elem) {
 -              pp->sg_tbl[qc->n_elem - 1].flags_size |= 
 -                      cpu_to_le32(EPRD_FLAG_END_OF_TBL);
 +              if (ata_sg_is_last(sg, qc))
 +                      pp->sg_tbl[i].flags_size |= cpu_to_le32(EPRD_FLAG_END_OF_TBL);
 +
 +              i++;
        }
  }
  
index 69a9b1cf6f9cb56fed4742ae27dce2e14b0ea5a6,250dafa6bc363721f189ceeaf030522356ad8242..de3f266d67b35a8509821f49f57641e9fc5313ba
@@@ -51,8 -51,6 +51,6 @@@ enum 
        QS_PRD_BYTES            = QS_MAX_PRD * 16,
        QS_PKT_BYTES            = QS_CPB_BYTES + QS_PRD_BYTES,
  
-       QS_DMA_BOUNDARY         = ~0UL,
        /* global register offsets */
        QS_HCF_CNFG3            = 0x0003, /* host configuration offset */
        QS_HID_HPHY             = 0x0004, /* host physical interface info */
        board_2068_idx          = 0,    /* QStor 4-port SATA/RAID */
  };
  
+ enum {
+       QS_DMA_BOUNDARY         = ~0UL
+ };
  typedef enum { qs_state_idle, qs_state_pkt, qs_state_mmio } qs_state_t;
  
  struct qs_port_priv {
@@@ -145,7 -147,7 +147,7 @@@ static Scsi_Host_Template qs_ata_sht = 
        .bios_param             = ata_std_bios_param,
  };
  
- static struct ata_port_operations qs_ata_ops = {
+ static const struct ata_port_operations qs_ata_ops = {
        .port_disable           = ata_port_disable,
        .tf_load                = ata_tf_load,
        .tf_read                = ata_tf_read,
@@@ -268,17 -270,16 +270,17 @@@ static void qs_scr_write (struct ata_po
  
  static void qs_fill_sg(struct ata_queued_cmd *qc)
  {
 -      struct scatterlist *sg = qc->sg;
 +      struct scatterlist *sg;
        struct ata_port *ap = qc->ap;
        struct qs_port_priv *pp = ap->private_data;
        unsigned int nelem;
        u8 *prd = pp->pkt + QS_CPB_BYTES;
  
 -      assert(sg != NULL);
 +      assert(qc->__sg != NULL);
        assert(qc->n_elem > 0);
  
 -      for (nelem = 0; nelem < qc->n_elem; nelem++,sg++) {
 +      nelem = 0;
 +      ata_for_each_sg(sg, qc) {
                u64 addr;
                u32 len;
  
  
                VPRINTK("PRD[%u] = (0x%llX, 0x%X)\n", nelem,
                                        (unsigned long long)addr, len);
 +              nelem++;
        }
  }
  
index e16d1815cda0ebf253f312dbbd68dc7db6699567,32d730bd5bb605468b3ba67f07420a8ef2480fca..e0d27a0fbad0ed58bd596abaca125e154bdef9de
@@@ -275,7 -275,7 +275,7 @@@ static Scsi_Host_Template sil24_sht = 
        .ordered_flush          = 1, /* NCQ not supported yet */
  };
  
- static struct ata_port_operations sil24_ops = {
+ static const struct ata_port_operations sil24_ops = {
        .port_disable           = ata_port_disable,
  
        .check_status           = sil24_check_status,
@@@ -416,20 -416,15 +416,20 @@@ static void sil24_phy_reset(struct ata_
  static inline void sil24_fill_sg(struct ata_queued_cmd *qc,
                                 struct sil24_cmd_block *cb)
  {
 -      struct scatterlist *sg = qc->sg;
        struct sil24_sge *sge = cb->sge;
 -      unsigned i;
 +      struct scatterlist *sg;
 +      unsigned int idx = 0;
  
 -      for (i = 0; i < qc->n_elem; i++, sg++, sge++) {
 +      ata_for_each_sg(sg, qc) {
                sge->addr = cpu_to_le64(sg_dma_address(sg));
                sge->cnt = cpu_to_le32(sg_dma_len(sg));
 -              sge->flags = 0;
 -              sge->flags = i < qc->n_elem - 1 ? 0 : cpu_to_le32(SGE_TRM);
 +              if (ata_sg_is_last(sg, qc))
 +                      sge->flags = cpu_to_le32(SGE_TRM);
 +              else
 +                      sge->flags = 0;
 +
 +              sge++;
 +              idx++;
        }
  }
  
diff --combined drivers/scsi/sata_sx4.c
index 79fdbbab513e87b433def9b5761bb671b24bd971,af08f4f650c1ef6da8526b3524259a4b031fa159..8710d0f14f93bb96d9cbfd04f4427a920bacc853
@@@ -137,7 -137,7 +137,7 @@@ struct pdc_port_priv 
  };
  
  struct pdc_host_priv {
-       void                    *dimm_mmio;
+       void                    __iomem *dimm_mmio;
  
        unsigned int            doing_hdma;
        unsigned int            hdma_prod;
@@@ -157,8 -157,8 +157,8 @@@ static void pdc_20621_phy_reset (struc
  static int pdc_port_start(struct ata_port *ap);
  static void pdc_port_stop(struct ata_port *ap);
  static void pdc20621_qc_prep(struct ata_queued_cmd *qc);
- static void pdc_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf);
- static void pdc_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf);
+ static void pdc_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf);
+ static void pdc_exec_command_mmio(struct ata_port *ap, const struct ata_taskfile *tf);
  static void pdc20621_host_stop(struct ata_host_set *host_set);
  static unsigned int pdc20621_dimm_init(struct ata_probe_ent *pe);
  static int pdc20621_detect_dimm(struct ata_probe_ent *pe);
@@@ -196,7 -196,7 +196,7 @@@ static Scsi_Host_Template pdc_sata_sht 
        .ordered_flush          = 1,
  };
  
- static struct ata_port_operations pdc_20621_ops = {
+ static const struct ata_port_operations pdc_20621_ops = {
        .port_disable           = ata_port_disable,
        .tf_load                = pdc_tf_load_mmio,
        .tf_read                = ata_tf_read,
@@@ -247,7 -247,7 +247,7 @@@ static void pdc20621_host_stop(struct a
  {
        struct pci_dev *pdev = to_pci_dev(host_set->dev);
        struct pdc_host_priv *hpriv = host_set->private_data;
-       void *dimm_mmio = hpriv->dimm_mmio;
+       void __iomem *dimm_mmio = hpriv->dimm_mmio;
  
        pci_iounmap(pdev, dimm_mmio);
        kfree(hpriv);
@@@ -449,14 -449,14 +449,14 @@@ static inline void pdc20621_host_pkt(st
  
  static void pdc20621_dma_prep(struct ata_queued_cmd *qc)
  {
 -      struct scatterlist *sg = qc->sg;
 +      struct scatterlist *sg;
        struct ata_port *ap = qc->ap;
        struct pdc_port_priv *pp = ap->private_data;
        void __iomem *mmio = ap->host_set->mmio_base;
        struct pdc_host_priv *hpriv = ap->host_set->private_data;
        void __iomem *dimm_mmio = hpriv->dimm_mmio;
        unsigned int portno = ap->port_no;
 -      unsigned int i, last, idx, total_len = 0, sgt_len;
 +      unsigned int i, idx, total_len = 0, sgt_len;
        u32 *buf = (u32 *) &pp->dimm_buf[PDC_DIMM_HEADER_SZ];
  
        assert(qc->flags & ATA_QCFLAG_DMAMAP);
        /*
         * Build S/G table
         */
 -      last = qc->n_elem;
        idx = 0;
 -      for (i = 0; i < last; i++) {
 -              buf[idx++] = cpu_to_le32(sg_dma_address(&sg[i]));
 -              buf[idx++] = cpu_to_le32(sg_dma_len(&sg[i]));
 -              total_len += sg_dma_len(&sg[i]);
 +      ata_for_each_sg(sg, qc) {
 +              buf[idx++] = cpu_to_le32(sg_dma_address(sg));
 +              buf[idx++] = cpu_to_le32(sg_dma_len(sg));
 +              total_len += sg_dma_len(sg);
        }
        buf[idx - 1] |= cpu_to_le32(ATA_PRD_EOT);
        sgt_len = idx * 4;
@@@ -668,8 -669,8 +668,8 @@@ static void pdc20621_packet_start(struc
                readl(mmio + PDC_20621_SEQCTL + (seq * 4));     /* flush */
  
                writel(port_ofs + PDC_DIMM_ATA_PKT,
-                      (void *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
-               readl((void *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
+                      (void __iomem *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
+               readl((void __iomem *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
                VPRINTK("submitted ofs 0x%x (%u), seq %u\n",
                        port_ofs + PDC_DIMM_ATA_PKT,
                        port_ofs + PDC_DIMM_ATA_PKT,
@@@ -746,8 -747,8 +746,8 @@@ static inline unsigned int pdc20621_hos
                        writel(0x00000001, mmio + PDC_20621_SEQCTL + (seq * 4));
                        readl(mmio + PDC_20621_SEQCTL + (seq * 4));
                        writel(port_ofs + PDC_DIMM_ATA_PKT,
-                              (void *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
-                       readl((void *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
+                              (void __iomem *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
+                       readl((void __iomem *) ap->ioaddr.cmd_addr + PDC_PKT_SUBMIT);
                }
  
                /* step two - execute ATA command */
@@@ -898,7 -899,7 +898,7 @@@ out
        DPRINTK("EXIT\n");
  }
  
- static void pdc_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf)
+ static void pdc_tf_load_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
  {
        WARN_ON (tf->protocol == ATA_PROT_DMA ||
                 tf->protocol == ATA_PROT_NODATA);
  }
  
  
- static void pdc_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf)
+ static void pdc_exec_command_mmio(struct ata_port *ap, const struct ata_taskfile *tf)
  {
        WARN_ON (tf->protocol == ATA_PROT_DMA ||
                 tf->protocol == ATA_PROT_NODATA);
@@@ -1013,7 -1014,7 +1013,7 @@@ static void pdc20621_put_to_dimm(struc
        idx++;
        dist = ((long)(s32)(window_size - (offset + size))) >= 0 ? size :
                (long) (window_size - offset);
-       memcpy_toio((char *) (dimm_mmio + offset / 4), (char *) psource, dist);
+       memcpy_toio(dimm_mmio + offset / 4, psource, dist);
        writel(0x01, mmio + PDC_GENERAL_CTLR);
        readl(mmio + PDC_GENERAL_CTLR);
  
        for (; (long) size >= (long) window_size ;) {
                writel(((idx) << page_mask), mmio + PDC_DIMM_WINDOW_CTLR);
                readl(mmio + PDC_DIMM_WINDOW_CTLR);
-               memcpy_toio((char *) (dimm_mmio), (char *) psource,
-                           window_size / 4);
+               memcpy_toio(dimm_mmio, psource, window_size / 4);
                writel(0x01, mmio + PDC_GENERAL_CTLR);
                readl(mmio + PDC_GENERAL_CTLR);
                psource += window_size;
        if (size) {
                writel(((idx) << page_mask), mmio + PDC_DIMM_WINDOW_CTLR);
                readl(mmio + PDC_DIMM_WINDOW_CTLR);
-               memcpy_toio((char *) (dimm_mmio), (char *) psource, size / 4);
+               memcpy_toio(dimm_mmio, psource, size / 4);
                writel(0x01, mmio + PDC_GENERAL_CTLR);
                readl(mmio + PDC_GENERAL_CTLR);
        }
diff --combined include/linux/libata.h
index d3dfefefabece15cb9ffded87297966da842b943,00a8a5738858bd4e3a13e53cd93c3ec03196f22b..5f17203520cbbebd20f9caf5c37d2eca647cac3c
@@@ -91,7 -91,7 +91,7 @@@ enum 
        ATA_SHT_EMULATED        = 1,
        ATA_SHT_CMD_PER_LUN     = 1,
        ATA_SHT_THIS_ID         = -1,
-       ATA_SHT_USE_CLUSTERING  = 0,
+       ATA_SHT_USE_CLUSTERING  = 1,
  
        /* struct ata_device stuff */
        ATA_DFLAG_LBA48         = (1 << 0), /* device supports LBA48 */
        ATA_SHIFT_UDMA          = 0,
        ATA_SHIFT_MWDMA         = 8,
        ATA_SHIFT_PIO           = 11,
 +
 +      /* size of buffer to pad xfers ending on unaligned boundaries */
 +      ATA_DMA_PAD_SZ          = 4,
 +      ATA_DMA_PAD_BUF_SZ      = ATA_DMA_PAD_SZ * ATA_MAX_QUEUE,
        
        /* Masks for port functions */
        ATA_PORT_PRIMARY        = (1 << 0),
@@@ -206,7 -202,7 +206,7 @@@ struct ata_ioports 
  struct ata_probe_ent {
        struct list_head        node;
        struct device           *dev;
-       struct ata_port_operations      *port_ops;
+       const struct ata_port_operations *port_ops;
        Scsi_Host_Template      *sht;
        struct ata_ioports      port[ATA_MAX_PORTS];
        unsigned int            n_ports;
@@@ -229,7 -225,7 +229,7 @@@ struct ata_host_set 
        void __iomem            *mmio_base;
        unsigned int            n_ports;
        void                    *private_data;
-       struct ata_port_operations *ops;
+       const struct ata_port_operations *ops;
        struct ata_port *       ports[0];
  };
  
@@@ -246,12 -242,9 +246,12 @@@ struct ata_queued_cmd 
        unsigned long           flags;          /* ATA_QCFLAG_xxx */
        unsigned int            tag;
        unsigned int            n_elem;
 +      unsigned int            orig_n_elem;
  
        int                     dma_dir;
  
 +      unsigned int            pad_len;
 +
        unsigned int            nsect;
        unsigned int            cursect;
  
        unsigned int            cursg_ofs;
  
        struct scatterlist      sgent;
 +      struct scatterlist      pad_sgent;
        void                    *buf_virt;
  
 -      struct scatterlist      *sg;
 +      /* DO NOT iterate over __sg manually, use ata_for_each_sg() */
 +      struct scatterlist      *__sg;
  
        ata_qc_cb_t             complete_fn;
  
@@@ -303,7 -294,7 +303,7 @@@ struct ata_device 
  
  struct ata_port {
        struct Scsi_Host        *host;  /* our co-allocated scsi host */
-       struct ata_port_operations      *ops;
+       const struct ata_port_operations *ops;
        unsigned long           flags;  /* ATA_FLAG_xxx */
        unsigned int            id;     /* unique id req'd by scsi midlyr */
        unsigned int            port_no; /* unique port #; from zero */
        struct ata_prd          *prd;    /* our SG list */
        dma_addr_t              prd_dma; /* and its DMA mapping */
  
 +      void                    *pad;   /* array of DMA pad buffers */
 +      dma_addr_t              pad_dma;
 +
        struct ata_ioports      ioaddr; /* ATA cmd/ctl/dma register blocks */
  
        u8                      ctl;    /* cache of ATA control register */
@@@ -353,10 -341,10 +353,10 @@@ struct ata_port_operations 
        void (*set_piomode) (struct ata_port *, struct ata_device *);
        void (*set_dmamode) (struct ata_port *, struct ata_device *);
  
-       void (*tf_load) (struct ata_port *ap, struct ata_taskfile *tf);
+       void (*tf_load) (struct ata_port *ap, const struct ata_taskfile *tf);
        void (*tf_read) (struct ata_port *ap, struct ata_taskfile *tf);
  
-       void (*exec_command)(struct ata_port *ap, struct ata_taskfile *tf);
+       void (*exec_command)(struct ata_port *ap, const struct ata_taskfile *tf);
        u8   (*check_status)(struct ata_port *ap);
        u8   (*check_altstatus)(struct ata_port *ap);
        u8   (*check_err)(struct ata_port *ap);
@@@ -397,9 -385,22 +397,22 @@@ struct ata_port_info 
        unsigned long           pio_mask;
        unsigned long           mwdma_mask;
        unsigned long           udma_mask;
-       struct ata_port_operations      *port_ops;
+       const struct ata_port_operations *port_ops;
  };
  
+ struct ata_timing {
+       unsigned short mode;            /* ATA mode */
+       unsigned short setup;           /* t1 */
+       unsigned short act8b;           /* t2 for 8-bit I/O */
+       unsigned short rec8b;           /* t2i for 8-bit I/O */
+       unsigned short cyc8b;           /* t0 for 8-bit I/O */
+       unsigned short active;          /* t2 or tD */
+       unsigned short recover;         /* t2i or tK */
+       unsigned short cycle;           /* t0 */
+       unsigned short udma;            /* t2CYCTYP/2 */
+ };
+ #define FIT(v,vmin,vmax)      max_t(short,min_t(short,v,vmax),vmin)
  
  extern void ata_port_probe(struct ata_port *);
  extern void __sata_phy_reset(struct ata_port *ap);
@@@ -412,7 -413,7 +425,7 @@@ extern int ata_pci_init_one (struct pci
                             unsigned int n_ports);
  extern void ata_pci_remove_one (struct pci_dev *pdev);
  #endif /* CONFIG_PCI */
- extern int ata_device_add(struct ata_probe_ent *ent);
+ 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_ioctl(struct scsi_device *dev, int cmd, void __user *arg);
@@@ -425,16 -426,16 +438,16 @@@ extern int ata_ratelimit(void)
  /*
   * Default driver ops implementations
   */
- extern void ata_tf_load(struct ata_port *ap, struct ata_taskfile *tf);
+ extern void ata_tf_load(struct ata_port *ap, const struct ata_taskfile *tf);
  extern void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
- extern void ata_tf_to_fis(struct ata_taskfile *tf, u8 *fis, u8 pmp);
- extern void ata_tf_from_fis(u8 *fis, struct ata_taskfile *tf);
+ extern void ata_tf_to_fis(const struct ata_taskfile *tf, u8 *fis, u8 pmp);
+ extern void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf);
  extern void ata_noop_dev_select (struct ata_port *ap, unsigned int device);
  extern void ata_std_dev_select (struct ata_port *ap, unsigned int device);
  extern u8 ata_check_status(struct ata_port *ap);
  extern u8 ata_altstatus(struct ata_port *ap);
  extern u8 ata_chk_err(struct ata_port *ap);
- extern void ata_exec_command(struct ata_port *ap, struct ata_taskfile *tf);
+ extern void ata_exec_command(struct ata_port *ap, const struct ata_taskfile *tf);
  extern int ata_port_start (struct ata_port *ap);
  extern void ata_port_stop (struct ata_port *ap);
  extern void ata_host_stop (struct ata_host_set *host_set);
@@@ -445,8 -446,8 +458,8 @@@ extern void ata_sg_init_one(struct ata_
                unsigned int buflen);
  extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
                 unsigned int n_elem);
- extern unsigned int ata_dev_classify(struct ata_taskfile *tf);
- extern void ata_dev_id_string(u16 *id, unsigned char *s,
+ extern unsigned int ata_dev_classify(const struct ata_taskfile *tf);
+ extern void ata_dev_id_string(const u16 *id, unsigned char *s,
                              unsigned int ofs, unsigned int len);
  extern void ata_dev_config(struct ata_port *ap, unsigned int i);
  extern void ata_bmdma_setup (struct ata_queued_cmd *qc);
@@@ -463,6 -464,32 +476,32 @@@ extern int ata_std_bios_param(struct sc
                              sector_t capacity, int geom[]);
  extern int ata_scsi_slave_config(struct scsi_device *sdev);
  
+ /*
+  * Timing helpers
+  */
+ extern int ata_timing_compute(struct ata_device *, unsigned short,
+                             struct ata_timing *, int, int);
+ extern void ata_timing_merge(const struct ata_timing *,
+                            const struct ata_timing *, struct ata_timing *,
+                            unsigned int);
+ enum {
+       ATA_TIMING_SETUP        = (1 << 0),
+       ATA_TIMING_ACT8B        = (1 << 1),
+       ATA_TIMING_REC8B        = (1 << 2),
+       ATA_TIMING_CYC8B        = (1 << 3),
+       ATA_TIMING_8BIT         = ATA_TIMING_ACT8B | ATA_TIMING_REC8B |
+                                 ATA_TIMING_CYC8B,
+       ATA_TIMING_ACTIVE       = (1 << 4),
+       ATA_TIMING_RECOVER      = (1 << 5),
+       ATA_TIMING_CYCLE        = (1 << 6),
+       ATA_TIMING_UDMA         = (1 << 7),
+       ATA_TIMING_ALL          = ATA_TIMING_SETUP | ATA_TIMING_ACT8B |
+                                 ATA_TIMING_REC8B | ATA_TIMING_CYC8B |
+                                 ATA_TIMING_ACTIVE | ATA_TIMING_RECOVER |
+                                 ATA_TIMING_CYCLE | ATA_TIMING_UDMA,
+ };
  
  #ifdef CONFIG_PCI
  struct pci_bits {
  extern void ata_pci_host_stop (struct ata_host_set *host_set);
  extern struct ata_probe_ent *
  ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port, int portmask);
- extern int pci_test_config_bits(struct pci_dev *pdev, struct pci_bits *bits);
+ extern int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits);
  
  #endif /* CONFIG_PCI */
  
  
 +static inline int
 +ata_sg_is_last(struct scatterlist *sg, struct ata_queued_cmd *qc)
 +{
 +      if (sg == &qc->pad_sgent)
 +              return 1;
 +      if (qc->pad_len)
 +              return 0;
 +      if (((sg - qc->__sg) + 1) == qc->n_elem)
 +              return 1;
 +      return 0;
 +}
 +
 +static inline struct scatterlist *
 +ata_qc_next_sg(struct scatterlist *sg, struct ata_queued_cmd *qc)
 +{
 +      if (sg == &qc->pad_sgent)
 +              return NULL;
 +      if (++sg - qc->__sg < qc->n_elem)
 +              return sg;
 +      return qc->pad_len ? &qc->pad_sgent : NULL;
 +}
 +
 +#define ata_for_each_sg(sg, qc) \
 +      for (sg = qc->__sg; sg; sg = ata_qc_next_sg(sg, qc))
 +
  static inline unsigned int ata_tag_valid(unsigned int tag)
  {
        return (tag < ATA_MAX_QUEUE) ? 1 : 0;
  }
  
- static inline unsigned int ata_dev_present(struct ata_device *dev)
+ static inline unsigned int ata_dev_present(const struct ata_device *dev)
  {
        return ((dev->class == ATA_DEV_ATA) ||
                (dev->class == ATA_DEV_ATAPI));
@@@ -709,7 -711,7 +748,7 @@@ static inline unsigned int sata_dev_pre
        return ((scr_read(ap, SCR_STATUS) & 0xf) == 0x3) ? 1 : 0;
  }
  
- static inline int ata_try_flush_cache(struct ata_device *dev)
+ static inline int ata_try_flush_cache(const struct ata_device *dev)
  {
        return ata_id_wcache_enabled(dev->id) ||
               ata_id_has_flush(dev->id) ||