219 files changed, 15898 insertions, 4087 deletions

diff --git a/drivers/Kconfig b/drivers/Kconfig
index 707650ab77a7..3e1c442deff9 100644
--- a/drivers/Kconfig
+++ b/drivers/Kconfig
@@ -8,6 +8,8 @@ source "drivers/connector/Kconfig"
 
 source "drivers/mtd/Kconfig"
 
+source "drivers/of/Kconfig"
+
 source "drivers/parport/Kconfig"
 
 source "drivers/pnp/Kconfig"
diff --git a/drivers/Makefile b/drivers/Makefile
index 0ea8e3237c0d..a9e4c5f922a0 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -86,3 +86,4 @@ obj-$(CONFIG_GENERIC_TIME)	+= clocksource/
 obj-$(CONFIG_DMA_ENGINE)        += dma/
 obj-$(CONFIG_HID)               += hid/
 obj-$(CONFIG_PPC_PS3)           += ps3/
+obj-$(CONFIG_OF)                += of/
diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c
index 2e7ba615d760..00d53c2fd1e8 100644
--- a/drivers/acpi/osl.c
+++ b/drivers/acpi/osl.c
@@ -1098,7 +1098,7 @@ void acpi_os_release_lock(acpi_spinlock lockp, acpi_cpu_flags flags)
 acpi_status
 acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
 {
-        *cache = kmem_cache_create(name, size, 0, 0, NULL, NULL);
+        *cache = kmem_cache_create(name, size, 0, 0, NULL);
         if (*cache == NULL)
                 return AE_ERROR;
         else
diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index 11e4eb9f304e..06f212ff2b4f 100644
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -99,6 +99,7 @@ enum {
         HOST_CAP_SSC            = (1 << 14), /* Slumber capable */
         HOST_CAP_CLO            = (1 << 24), /* Command List Override support */
         HOST_CAP_SSS            = (1 << 27), /* Staggered Spin-up */
+        HOST_CAP_SNTF           = (1 << 29), /* SNotification register */
         HOST_CAP_NCQ            = (1 << 30), /* Native Command Queueing */
         HOST_CAP_64             = (1 << 31), /* PCI DAC (64-bit DMA) support */
 
@@ -113,11 +114,11 @@ enum {
         PORT_TFDATA             = 0x20, /* taskfile data */
         PORT_SIG                = 0x24, /* device TF signature */
         PORT_CMD_ISSUE          = 0x38, /* command issue */
-        PORT_SCR                = 0x28, /* SATA phy register block */
         PORT_SCR_STAT           = 0x28, /* SATA phy register: SStatus */
         PORT_SCR_CTL            = 0x2c, /* SATA phy register: SControl */
         PORT_SCR_ERR            = 0x30, /* SATA phy register: SError */
         PORT_SCR_ACT            = 0x34, /* SATA phy register: SActive */
+        PORT_SCR_NTF            = 0x3c, /* SATA phy register: SNotification */
 
         /* PORT_IRQ_{STAT,MASK} bits */
         PORT_IRQ_COLD_PRES      = (1 << 31), /* cold presence detect */
@@ -216,8 +217,8 @@ struct ahci_port_priv {
         unsigned int            ncq_saw_sdb:1;
 };
 
-static u32 ahci_scr_read (struct ata_port *ap, unsigned int sc_reg);
-static void ahci_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
+static int ahci_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val);
+static int ahci_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val);
 static int ahci_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
 static unsigned int ahci_qc_issue(struct ata_queued_cmd *qc);
 static void ahci_irq_clear(struct ata_port *ap);
@@ -417,7 +418,10 @@ static const struct pci_device_id ahci_pci_tbl[] = {
 
         /* ATI */
         { PCI_VDEVICE(ATI, 0x4380), board_ahci_sb600 }, /* ATI SB600 */
-        { PCI_VDEVICE(ATI, 0x4390), board_ahci_sb600 }, /* ATI SB700 */
+        { PCI_VDEVICE(ATI, 0x4390), board_ahci_sb600 }, /* ATI SB700 IDE */
+        { PCI_VDEVICE(ATI, 0x4391), board_ahci_sb600 }, /* ATI SB700 AHCI */
+        { PCI_VDEVICE(ATI, 0x4392), board_ahci_sb600 }, /* ATI SB700 nraid5 */
+        { PCI_VDEVICE(ATI, 0x4393), board_ahci_sb600 }, /* ATI SB700 raid5 */
 
         /* VIA */
         { PCI_VDEVICE(VIA, 0x3349), board_ahci_vt8251 }, /* VIA VT8251 */
@@ -545,13 +549,19 @@ static void ahci_save_initial_config(struct pci_dev *pdev,
         hpriv->saved_cap = cap = readl(mmio + HOST_CAP);
         hpriv->saved_port_map = port_map = readl(mmio + HOST_PORTS_IMPL);
 
-        /* some chips lie about 64bit support */
+        /* some chips have errata preventing 64bit use */
         if ((cap & HOST_CAP_64) && (pi->flags & AHCI_FLAG_32BIT_ONLY)) {
                 dev_printk(KERN_INFO, &pdev->dev,
                            "controller can't do 64bit DMA, forcing 32bit\n");
                 cap &= ~HOST_CAP_64;
         }
 
+        if ((cap & HOST_CAP_NCQ) && (pi->flags & AHCI_FLAG_NO_NCQ)) {
+                dev_printk(KERN_INFO, &pdev->dev,
+                           "controller can't do NCQ, turning off CAP_NCQ\n");
+                cap &= ~HOST_CAP_NCQ;
+        }
+
         /* fixup zero port_map */
         if (!port_map) {
                 port_map = (1 << ahci_nr_ports(cap)) - 1;
@@ -625,38 +635,45 @@ static void ahci_restore_initial_config(struct ata_host *host)
         (void) readl(mmio + HOST_PORTS_IMPL);   /* flush */
 }
 
-static u32 ahci_scr_read (struct ata_port *ap, unsigned int sc_reg_in)
+static unsigned ahci_scr_offset(struct ata_port *ap, unsigned int sc_reg)
 {
-        unsigned int sc_reg;
-
-        switch (sc_reg_in) {
-        case SCR_STATUS:        sc_reg = 0; break;
-        case SCR_CONTROL:       sc_reg = 1; break;
-        case SCR_ERROR:         sc_reg = 2; break;
-        case SCR_ACTIVE:        sc_reg = 3; break;
-        default:
-                return 0xffffffffU;
-        }
+        static const int offset[] = {
+                [SCR_STATUS]            = PORT_SCR_STAT,
+                [SCR_CONTROL]           = PORT_SCR_CTL,
+                [SCR_ERROR]             = PORT_SCR_ERR,
+                [SCR_ACTIVE]            = PORT_SCR_ACT,
+                [SCR_NOTIFICATION]      = PORT_SCR_NTF,
+        };
+        struct ahci_host_priv *hpriv = ap->host->private_data;
 
-        return readl(ap->ioaddr.scr_addr + (sc_reg * 4));
+        if (sc_reg < ARRAY_SIZE(offset) &&
+            (sc_reg != SCR_NOTIFICATION || (hpriv->cap & HOST_CAP_SNTF)))
+                return offset[sc_reg];
+        return 0;
 }
 
-
-static void ahci_scr_write (struct ata_port *ap, unsigned int sc_reg_in,
-                               u32 val)
+static int ahci_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val)
 {
-        unsigned int sc_reg;
-
-        switch (sc_reg_in) {
-        case SCR_STATUS:        sc_reg = 0; break;
-        case SCR_CONTROL:       sc_reg = 1; break;
-        case SCR_ERROR:         sc_reg = 2; break;
-        case SCR_ACTIVE:        sc_reg = 3; break;
-        default:
-                return;
+        void __iomem *port_mmio = ahci_port_base(ap);
+        int offset = ahci_scr_offset(ap, sc_reg);
+
+        if (offset) {
+                *val = readl(port_mmio + offset);
+                return 0;
         }
+        return -EINVAL;
+}
 
-        writel(val, ap->ioaddr.scr_addr + (sc_reg * 4));
+static int ahci_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val)
+{
+        void __iomem *port_mmio = ahci_port_base(ap);
+        int offset = ahci_scr_offset(ap, sc_reg);
+
+        if (offset) {
+                writel(val, port_mmio + offset);
+                return 0;
+        }
+        return -EINVAL;
 }
 
 static void ahci_start_engine(struct ata_port *ap)
@@ -948,37 +965,87 @@ static void ahci_fill_cmd_slot(struct ahci_port_priv *pp, unsigned int tag,
         pp->cmd_slot[tag].tbl_addr_hi = cpu_to_le32((cmd_tbl_dma >> 16) >> 16);
 }
 
-static int ahci_clo(struct ata_port *ap)
+static int ahci_kick_engine(struct ata_port *ap, int force_restart)
 {
         void __iomem *port_mmio = ap->ioaddr.cmd_addr;
         struct ahci_host_priv *hpriv = ap->host->private_data;
         u32 tmp;
+        int busy, rc;
+
+        /* do we need to kick the port? */
+        busy = ahci_check_status(ap) & (ATA_BUSY | ATA_DRQ);
+        if (!busy && !force_restart)
+                return 0;
+
+        /* stop engine */
+        rc = ahci_stop_engine(ap);
+        if (rc)
+                goto out_restart;
 
-        if (!(hpriv->cap & HOST_CAP_CLO))
-                return -EOPNOTSUPP;
+        /* need to do CLO? */
+        if (!busy) {
+                rc = 0;
+                goto out_restart;
+        }
 
+        if (!(hpriv->cap & HOST_CAP_CLO)) {
+                rc = -EOPNOTSUPP;
+                goto out_restart;
+        }
+
+        /* perform CLO */
         tmp = readl(port_mmio + PORT_CMD);
         tmp |= PORT_CMD_CLO;
         writel(tmp, port_mmio + PORT_CMD);
 
+        rc = 0;
         tmp = ata_wait_register(port_mmio + PORT_CMD,
                                 PORT_CMD_CLO, PORT_CMD_CLO, 1, 500);
         if (tmp & PORT_CMD_CLO)
-                return -EIO;
+                rc = -EIO;
 
-        return 0;
+        /* restart engine */
+ out_restart:
+        ahci_start_engine(ap);
+        return rc;
 }
 
-static int ahci_softreset(struct ata_port *ap, unsigned int *class,
-                          unsigned long deadline)
+static int ahci_exec_polled_cmd(struct ata_port *ap, int pmp,
+                                struct ata_taskfile *tf, int is_cmd, u16 flags,
+                                unsigned long timeout_msec)
 {
+        const u32 cmd_fis_len = 5; /* five dwords */
         struct ahci_port_priv *pp = ap->private_data;
         void __iomem *port_mmio = ahci_port_base(ap);
-        const u32 cmd_fis_len = 5; /* five dwords */
+        u8 *fis = pp->cmd_tbl;
+        u32 tmp;
+
+        /* prep the command */
+        ata_tf_to_fis(tf, pmp, is_cmd, fis);
+        ahci_fill_cmd_slot(pp, 0, cmd_fis_len | flags | (pmp << 12));
+
+        /* issue & wait */
+        writel(1, port_mmio + PORT_CMD_ISSUE);
+
+        if (timeout_msec) {
+                tmp = ata_wait_register(port_mmio + PORT_CMD_ISSUE, 0x1, 0x1,
+                                        1, timeout_msec);
+                if (tmp & 0x1) {
+                        ahci_kick_engine(ap, 1);
+                        return -EBUSY;
+                }
+        } else
+                readl(port_mmio + PORT_CMD_ISSUE);      /* flush */
+
+        return 0;
+}
+
+static int ahci_do_softreset(struct ata_port *ap, unsigned int *class,
+                             int pmp, unsigned long deadline)
+{
         const char *reason = NULL;
+        unsigned long now, msecs;
         struct ata_taskfile tf;
-        u32 tmp;
-        u8 *fis;
         int rc;
 
         DPRINTK("ENTER\n");
@@ -990,43 +1057,22 @@ static int ahci_softreset(struct ata_port *ap, unsigned int *class,
         }
 
         /* prepare for SRST (AHCI-1.1 10.4.1) */
-        rc = ahci_stop_engine(ap);
-        if (rc) {
-                reason = "failed to stop engine";
-                goto fail_restart;
-        }
-
-        /* check BUSY/DRQ, perform Command List Override if necessary */
-        if (ahci_check_status(ap) & (ATA_BUSY | ATA_DRQ)) {
-                rc = ahci_clo(ap);
-
-                if (rc == -EOPNOTSUPP) {
-                        reason = "port busy but CLO unavailable";
-                        goto fail_restart;
-                } else if (rc) {
-                        reason = "port busy but CLO failed";
-                        goto fail_restart;
-                }
-        }
-
-        /* restart engine */
-        ahci_start_engine(ap);
+        rc = ahci_kick_engine(ap, 1);
+        if (rc)
+                ata_port_printk(ap, KERN_WARNING,
+                                "failed to reset engine (errno=%d)", rc);
 
         ata_tf_init(ap->device, &tf);
-        fis = pp->cmd_tbl;
 
         /* issue the first D2H Register FIS */
-        ahci_fill_cmd_slot(pp, 0,
-                           cmd_fis_len | AHCI_CMD_RESET | AHCI_CMD_CLR_BUSY);
+        msecs = 0;
+        now = jiffies;
+        if (time_after(now, deadline))
+                msecs = jiffies_to_msecs(deadline - now);
 
         tf.ctl |= ATA_SRST;
-        ata_tf_to_fis(&tf, fis, 0);
-        fis[1] &= ~(1 << 7);    /* turn off Command FIS bit */
-
-        writel(1, port_mmio + PORT_CMD_ISSUE);
-
-        tmp = ata_wait_register(port_mmio + PORT_CMD_ISSUE, 0x1, 0x1, 1, 500);
-        if (tmp & 0x1) {
+        if (ahci_exec_polled_cmd(ap, pmp, &tf, 0,
+                                 AHCI_CMD_RESET | AHCI_CMD_CLR_BUSY, msecs)) {
                 rc = -EIO;
                 reason = "1st FIS failed";
                 goto fail;
@@ -1036,14 +1082,8 @@ static int ahci_softreset(struct ata_port *ap, unsigned int *class,
         msleep(1);
 
         /* issue the second D2H Register FIS */
-        ahci_fill_cmd_slot(pp, 0, cmd_fis_len);
-
         tf.ctl &= ~ATA_SRST;
-        ata_tf_to_fis(&tf, fis, 0);
-        fis[1] &= ~(1 << 7);    /* turn off Command FIS bit */
-
-        writel(1, port_mmio + PORT_CMD_ISSUE);
-        readl(port_mmio + PORT_CMD_ISSUE);      /* flush */
+        ahci_exec_polled_cmd(ap, pmp, &tf, 0, 0, 0);
 
         /* spec mandates ">= 2ms" before checking status.
          * We wait 150ms, because that was the magic delay used for
@@ -1066,13 +1106,17 @@ static int ahci_softreset(struct ata_port *ap, unsigned int *class,
         DPRINTK("EXIT, class=%u\n", *class);
         return 0;
 
- fail_restart:
-        ahci_start_engine(ap);
  fail:
         ata_port_printk(ap, KERN_ERR, "softreset failed (%s)\n", reason);
         return rc;
 }
 
+static int ahci_softreset(struct ata_port *ap, unsigned int *class,
+                          unsigned long deadline)
+{
+        return ahci_do_softreset(ap, class, 0, deadline);
+}
+
 static int ahci_hardreset(struct ata_port *ap, unsigned int *class,
                           unsigned long deadline)
 {
@@ -1088,7 +1132,7 @@ static int ahci_hardreset(struct ata_port *ap, unsigned int *class,
         /* clear D2H reception area to properly wait for D2H FIS */
         ata_tf_init(ap->device, &tf);
         tf.command = 0x80;
-        ata_tf_to_fis(&tf, d2h_fis, 0);
+        ata_tf_to_fis(&tf, 0, 0, d2h_fis);
 
         rc = sata_std_hardreset(ap, class, deadline);
 
@@ -1106,6 +1150,7 @@ static int ahci_hardreset(struct ata_port *ap, unsigned int *class,
 static int ahci_vt8251_hardreset(struct ata_port *ap, unsigned int *class,
                                  unsigned long deadline)
 {
+        u32 serror;
         int rc;
 
         DPRINTK("ENTER\n");
@@ -1116,7 +1161,8 @@ static int ahci_vt8251_hardreset(struct ata_port *ap, unsigned int *class,
                                  deadline);
 
         /* vt8251 needs SError cleared for the port to operate */
-        ahci_scr_write(ap, SCR_ERROR, ahci_scr_read(ap, SCR_ERROR));
+        ahci_scr_read(ap, SCR_ERROR, &serror);
+        ahci_scr_write(ap, SCR_ERROR, serror);
 
         ahci_start_engine(ap);
 
@@ -1205,7 +1251,7 @@ static void ahci_qc_prep(struct ata_queued_cmd *qc)
          */
         cmd_tbl = pp->cmd_tbl + qc->tag * AHCI_CMD_TBL_SZ;
 
-        ata_tf_to_fis(&qc->tf, cmd_tbl, 0);
+        ata_tf_to_fis(&qc->tf, 0, 1, cmd_tbl);
         if (is_atapi) {
                 memset(cmd_tbl + AHCI_CMD_TBL_CDB, 0, 32);
                 memcpy(cmd_tbl + AHCI_CMD_TBL_CDB, qc->cdb, qc->dev->cdb_len);
@@ -1238,7 +1284,7 @@ static void ahci_error_intr(struct ata_port *ap, u32 irq_stat)
         ata_ehi_clear_desc(ehi);
 
         /* AHCI needs SError cleared; otherwise, it might lock up */
-        serror = ahci_scr_read(ap, SCR_ERROR);
+        ahci_scr_read(ap, SCR_ERROR, &serror);
         ahci_scr_write(ap, SCR_ERROR, serror);
 
         /* analyze @irq_stat */
@@ -1262,12 +1308,12 @@ static void ahci_error_intr(struct ata_port *ap, u32 irq_stat)
         if (irq_stat & PORT_IRQ_IF_ERR) {
                 err_mask |= AC_ERR_ATA_BUS;
                 action |= ATA_EH_SOFTRESET;
-                ata_ehi_push_desc(ehi, ", interface fatal error");
+                ata_ehi_push_desc(ehi, "interface fatal error");
         }
 
         if (irq_stat & (PORT_IRQ_CONNECT | PORT_IRQ_PHYRDY)) {
                 ata_ehi_hotplugged(ehi);
-                ata_ehi_push_desc(ehi, ", %s", irq_stat & PORT_IRQ_CONNECT ?
+                ata_ehi_push_desc(ehi, "%s", irq_stat & PORT_IRQ_CONNECT ?
                         "connection status changed" : "PHY RDY changed");
         }
 
@@ -1276,7 +1322,7 @@ static void ahci_error_intr(struct ata_port *ap, u32 irq_stat)
 
                 err_mask |= AC_ERR_HSM;
                 action |= ATA_EH_SOFTRESET;
-                ata_ehi_push_desc(ehi, ", unknown FIS %08x %08x %08x %08x",
+                ata_ehi_push_desc(ehi, "unknown FIS %08x %08x %08x %08x",
                                   unk[0], unk[1], unk[2], unk[3]);
         }
 
@@ -1512,11 +1558,17 @@ static void ahci_post_internal_cmd(struct ata_queued_cmd *qc)
 {
         struct ata_port *ap = qc->ap;
 
-        if (qc->flags & ATA_QCFLAG_FAILED) {
-                /* make DMA engine forget about the failed command */
-                ahci_stop_engine(ap);
-                ahci_start_engine(ap);
-        }
+        /* make DMA engine forget about the failed command */
+        if (qc->flags & ATA_QCFLAG_FAILED)
+                ahci_kick_engine(ap, 1);
+}
+
+static int ahci_port_resume(struct ata_port *ap)
+{
+        ahci_power_up(ap);
+        ahci_start_port(ap);
+
+        return 0;
 }
 
 #ifdef CONFIG_PM
@@ -1536,14 +1588,6 @@ static int ahci_port_suspend(struct ata_port *ap, pm_message_t mesg)
         return rc;
 }
 
-static int ahci_port_resume(struct ata_port *ap)
-{
-        ahci_power_up(ap);
-        ahci_start_port(ap);
-
-        return 0;
-}
-
 static int ahci_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg)
 {
         struct ata_host *host = dev_get_drvdata(&pdev->dev);
@@ -1734,12 +1778,13 @@ static void ahci_print_info(struct ata_host *host)
 
         dev_printk(KERN_INFO, &pdev->dev,
                 "flags: "
-                "%s%s%s%s%s%s"
-                "%s%s%s%s%s%s%s\n"
+                "%s%s%s%s%s%s%s"
+                "%s%s%s%s%s%s%s\n"
                 ,
 
                 cap & (1 << 31) ? "64bit " : "",
                 cap & (1 << 30) ? "ncq " : "",
+                cap & (1 << 29) ? "sntf " : "",
                 cap & (1 << 28) ? "ilck " : "",
                 cap & (1 << 27) ? "stag " : "",
                 cap & (1 << 26) ? "pm " : "",
@@ -1794,7 +1839,7 @@ static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         ahci_save_initial_config(pdev, &pi, hpriv);
 
         /* prepare host */
-        if (!(pi.flags & AHCI_FLAG_NO_NCQ) && (hpriv->cap & HOST_CAP_NCQ))
+        if (hpriv->cap & HOST_CAP_NCQ)
                 pi.flags |= ATA_FLAG_NCQ;
 
         host = ata_host_alloc_pinfo(&pdev->dev, ppi, fls(hpriv->port_map));
@@ -1808,10 +1853,8 @@ static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
                 void __iomem *port_mmio = ahci_port_base(ap);
 
                 /* standard SATA port setup */
-                if (hpriv->port_map & (1 << i)) {
+                if (hpriv->port_map & (1 << i))
                         ap->ioaddr.cmd_addr = port_mmio;
-                        ap->ioaddr.scr_addr = port_mmio + PORT_SCR;
-                }
 
                 /* disabled/not-implemented port */
                 else
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 88e2dd0983b5..6001aae0b884 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -111,8 +111,9 @@ MODULE_VERSION(DRV_VERSION);
 /**
  *      ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure
  *      @tf: Taskfile to convert
- *      @fis: Buffer into which data will output
  *      @pmp: Port multiplier port
+ *      @is_cmd: This FIS is for command
+ *      @fis: Buffer into which data will output
  *
  *      Converts a standard ATA taskfile to a Serial ATA
  *      FIS structure (Register - Host to Device).
@@ -120,12 +121,13 @@ MODULE_VERSION(DRV_VERSION);
  *      LOCKING:
  *      Inherited from caller.
  */
-
-void ata_tf_to_fis(const struct ata_taskfile *tf, u8 *fis, u8 pmp)
+void ata_tf_to_fis(const struct ata_taskfile *tf, u8 pmp, int is_cmd, u8 *fis)
 {
-        fis[0] = 0x27;  /* Register - Host to Device FIS */
-        fis[1] = (pmp & 0xf) | (1 << 7); /* Port multiplier number,
-                                            bit 7 indicates Command FIS */
+        fis[0] = 0x27;                  /* Register - Host to Device FIS */
+        fis[1] = pmp & 0xf;             /* Port multiplier number*/
+        if (is_cmd)
+                fis[1] |= (1 << 7);     /* bit 7 indicates Command FIS */
+
         fis[2] = tf->command;
         fis[3] = tf->feature;
 
@@ -2387,21 +2389,35 @@ int sata_down_spd_limit(struct ata_port *ap)
         u32 sstatus, spd, mask;
         int rc, highbit;
 
+        if (!sata_scr_valid(ap))
+                return -EOPNOTSUPP;
+
+        /* If SCR can be read, use it to determine the current SPD.
+         * If not, use cached value in ap->sata_spd.
+         */
         rc = sata_scr_read(ap, SCR_STATUS, &sstatus);
-        if (rc)
-                return rc;
+        if (rc == 0)
+                spd = (sstatus >> 4) & 0xf;
+        else
+                spd = ap->sata_spd;
 
         mask = ap->sata_spd_limit;
         if (mask <= 1)
                 return -EINVAL;
+
+        /* unconditionally mask off the highest bit */
         highbit = fls(mask) - 1;
         mask &= ~(1 << highbit);
 
-        spd = (sstatus >> 4) & 0xf;
-        if (spd <= 1)
-                return -EINVAL;
-        spd--;
-        mask &= (1 << spd) - 1;
+        /* Mask off all speeds higher than or equal to the current
+         * one.  Force 1.5Gbps if current SPD is not available.
+         */
+        if (spd > 1)
+                mask &= (1 << (spd - 1)) - 1;
+        else
+                mask &= 1;
+
+        /* were we already at the bottom? */
         if (!mask)
                 return -EINVAL;
 
@@ -3251,9 +3267,11 @@ int sata_phy_debounce(struct ata_port *ap, const unsigned long *params,
                 last = cur;
                 last_jiffies = jiffies;
 
-                /* check deadline */
+                /* Check deadline.  If debouncing failed, return
+                 * -EPIPE to tell upper layer to lower link speed.
+                 */
                 if (time_after(jiffies, deadline))
-                        return -EBUSY;
+                        return -EPIPE;
         }
 }
 
@@ -3769,6 +3787,7 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
         { "Hitachi HTS541616J9SA00", "SB4OC70P", ATA_HORKAGE_NONCQ, },
         { "WDC WD740ADFD-00NLR1", NULL,         ATA_HORKAGE_NONCQ, },
         { "FUJITSU MHV2080BH",  "00840028",     ATA_HORKAGE_NONCQ, },
+        { "ST9160821AS",        "3.CLF",        ATA_HORKAGE_NONCQ, },
 
         /* Devices with NCQ limits */
 
@@ -5729,10 +5748,8 @@ int sata_scr_valid(struct ata_port *ap)
  */
 int sata_scr_read(struct ata_port *ap, int reg, u32 *val)
 {
-        if (sata_scr_valid(ap)) {
-                *val = ap->ops->scr_read(ap, reg);
-                return 0;
-        }
+        if (sata_scr_valid(ap))
+                return ap->ops->scr_read(ap, reg, val);
         return -EOPNOTSUPP;
 }
 
@@ -5754,10 +5771,8 @@ int sata_scr_read(struct ata_port *ap, int reg, u32 *val)
  */
 int sata_scr_write(struct ata_port *ap, int reg, u32 val)
 {
-        if (sata_scr_valid(ap)) {
-                ap->ops->scr_write(ap, reg, val);
-                return 0;
-        }
+        if (sata_scr_valid(ap))
+                return ap->ops->scr_write(ap, reg, val);
         return -EOPNOTSUPP;
 }
 
@@ -5778,10 +5793,13 @@ int sata_scr_write(struct ata_port *ap, int reg, u32 val)
  */
 int sata_scr_write_flush(struct ata_port *ap, int reg, u32 val)
 {
+        int rc;
+
         if (sata_scr_valid(ap)) {
-                ap->ops->scr_write(ap, reg, val);
-                ap->ops->scr_read(ap, reg);
-                return 0;
+                rc = ap->ops->scr_write(ap, reg, val);
+                if (rc == 0)
+                        rc = ap->ops->scr_read(ap, reg, &val);
+                return rc;
         }
         return -EOPNOTSUPP;
 }
@@ -5993,6 +6011,7 @@ void ata_dev_init(struct ata_device *dev)
 
         /* SATA spd limit is bound to the first device */
         ap->sata_spd_limit = ap->hw_sata_spd_limit;
+        ap->sata_spd = 0;
 
         /* High bits of dev->flags are used to record warm plug
          * requests which occur asynchronously.  Synchronize using
@@ -6058,6 +6077,9 @@ struct ata_port *ata_port_alloc(struct ata_host *host)
         INIT_WORK(&ap->scsi_rescan_task, ata_scsi_dev_rescan);
         INIT_LIST_HEAD(&ap->eh_done_q);
         init_waitqueue_head(&ap->eh_wait_q);
+        init_timer_deferrable(&ap->fastdrain_timer);
+        ap->fastdrain_timer.function = ata_eh_fastdrain_timerfn;
+        ap->fastdrain_timer.data = (unsigned long)ap;
 
         ap->cbl = ATA_CBL_NONE;
 
@@ -6434,7 +6456,7 @@ int ata_host_register(struct ata_host *host, struct scsi_host_template *sht)
         for (i = 0; i < host->n_ports; i++) {
                 struct ata_port *ap = host->ports[i];
 
-                ata_scsi_scan_host(ap);
+                ata_scsi_scan_host(ap, 1);
         }
 
         return 0;
@@ -6942,6 +6964,9 @@ EXPORT_SYMBOL_GPL(ata_pci_default_filter);
 EXPORT_SYMBOL_GPL(ata_pci_clear_simplex);
 #endif /* CONFIG_PCI */
 
+EXPORT_SYMBOL_GPL(__ata_ehi_push_desc);
+EXPORT_SYMBOL_GPL(ata_ehi_push_desc);
+EXPORT_SYMBOL_GPL(ata_ehi_clear_desc);
 EXPORT_SYMBOL_GPL(ata_eng_timeout);
 EXPORT_SYMBOL_GPL(ata_port_schedule_eh);
 EXPORT_SYMBOL_GPL(ata_port_abort);
diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c
index 9aa62a0754f6..ac6ceed4bb60 100644
--- a/drivers/ata/libata-eh.c
+++ b/drivers/ata/libata-eh.c
@@ -56,6 +56,7 @@ enum {
  */
 enum {
         ATA_EH_PRERESET_TIMEOUT         = 10 * HZ,
+        ATA_EH_FASTDRAIN_INTERVAL       = 3 * HZ,
 };
 
 /* The following table determines how we sequence resets.  Each entry
@@ -85,6 +86,71 @@ static void ata_eh_handle_port_resume(struct ata_port *ap)
 { }
 #endif /* CONFIG_PM */
 
+static void __ata_ehi_pushv_desc(struct ata_eh_info *ehi, const char *fmt,
+                                 va_list args)
+{
+        ehi->desc_len += vscnprintf(ehi->desc + ehi->desc_len,
+                                     ATA_EH_DESC_LEN - ehi->desc_len,
+                                     fmt, args);
+}
+
+/**
+ *      __ata_ehi_push_desc - push error description without adding separator
+ *      @ehi: target EHI
+ *      @fmt: printf format string
+ *
+ *      Format string according to @fmt and append it to @ehi->desc.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host lock)
+ */
+void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
+{
+        va_list args;
+
+        va_start(args, fmt);
+        __ata_ehi_pushv_desc(ehi, fmt, args);
+        va_end(args);
+}
+
+/**
+ *      ata_ehi_push_desc - push error description with separator
+ *      @ehi: target EHI
+ *      @fmt: printf format string
+ *
+ *      Format string according to @fmt and append it to @ehi->desc.
+ *      If @ehi->desc is not empty, ", " is added in-between.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host lock)
+ */
+void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
+{
+        va_list args;
+
+        if (ehi->desc_len)
+                __ata_ehi_push_desc(ehi, ", ");
+
+        va_start(args, fmt);
+        __ata_ehi_pushv_desc(ehi, fmt, args);
+        va_end(args);
+}
+
+/**
+ *      ata_ehi_clear_desc - clean error description
+ *      @ehi: target EHI
+ *
+ *      Clear @ehi->desc.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host lock)
+ */
+void ata_ehi_clear_desc(struct ata_eh_info *ehi)
+{
+        ehi->desc[0] = '\0';
+        ehi->desc_len = 0;
+}
+
 static void ata_ering_record(struct ata_ering *ering, int is_io,
                              unsigned int err_mask)
 {
@@ -296,6 +362,9 @@ void ata_scsi_error(struct Scsi_Host *host)
  repeat:
         /* invoke error handler */
         if (ap->ops->error_handler) {
+                /* kill fast drain timer */
+                del_timer_sync(&ap->fastdrain_timer);
+
                 /* process port resume request */
                 ata_eh_handle_port_resume(ap);
 
@@ -511,6 +580,94 @@ void ata_eng_timeout(struct ata_port *ap)
         DPRINTK("EXIT\n");
 }
 
+static int ata_eh_nr_in_flight(struct ata_port *ap)
+{
+        unsigned int tag;
+        int nr = 0;
+
+        /* count only non-internal commands */
+        for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++)
+                if (ata_qc_from_tag(ap, tag))
+                        nr++;
+
+        return nr;
+}
+
+void ata_eh_fastdrain_timerfn(unsigned long arg)
+{
+        struct ata_port *ap = (void *)arg;
+        unsigned long flags;
+        int cnt;
+
+        spin_lock_irqsave(ap->lock, flags);
+
+        cnt = ata_eh_nr_in_flight(ap);
+
+        /* are we done? */
+        if (!cnt)
+                goto out_unlock;
+
+        if (cnt == ap->fastdrain_cnt) {
+                unsigned int tag;
+
+                /* No progress during the last interval, tag all
+                 * in-flight qcs as timed out and freeze the port.
+                 */
+                for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++) {
+                        struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
+                        if (qc)
+                                qc->err_mask |= AC_ERR_TIMEOUT;
+                }
+
+                ata_port_freeze(ap);
+        } else {
+                /* some qcs have finished, give it another chance */
+                ap->fastdrain_cnt = cnt;
+                ap->fastdrain_timer.expires =
+                        jiffies + ATA_EH_FASTDRAIN_INTERVAL;
+                add_timer(&ap->fastdrain_timer);
+        }
+
+ out_unlock:
+        spin_unlock_irqrestore(ap->lock, flags);
+}
+
+/**
+ *      ata_eh_set_pending - set ATA_PFLAG_EH_PENDING and activate fast drain
+ *      @ap: target ATA port
+ *      @fastdrain: activate fast drain
+ *
+ *      Set ATA_PFLAG_EH_PENDING and activate fast drain if @fastdrain
+ *      is non-zero and EH wasn't pending before.  Fast drain ensures
+ *      that EH kicks in in timely manner.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host lock)
+ */
+static void ata_eh_set_pending(struct ata_port *ap, int fastdrain)
+{
+        int cnt;
+
+        /* already scheduled? */
+        if (ap->pflags & ATA_PFLAG_EH_PENDING)
+                return;
+
+        ap->pflags |= ATA_PFLAG_EH_PENDING;
+
+        if (!fastdrain)
+                return;
+
+        /* do we have in-flight qcs? */
+        cnt = ata_eh_nr_in_flight(ap);
+        if (!cnt)
+                return;
+
+        /* activate fast drain */
+        ap->fastdrain_cnt = cnt;
+        ap->fastdrain_timer.expires = jiffies + ATA_EH_FASTDRAIN_INTERVAL;
+        add_timer(&ap->fastdrain_timer);
+}
+
 /**
  *      ata_qc_schedule_eh - schedule qc for error handling
  *      @qc: command to schedule error handling for
@@ -528,7 +685,7 @@ void ata_qc_schedule_eh(struct ata_queued_cmd *qc)
         WARN_ON(!ap->ops->error_handler);
 
         qc->flags |= ATA_QCFLAG_FAILED;
-        qc->ap->pflags |= ATA_PFLAG_EH_PENDING;
+        ata_eh_set_pending(ap, 1);
 
         /* The following will fail if timeout has already expired.
          * ata_scsi_error() takes care of such scmds on EH entry.
@@ -555,7 +712,7 @@ void ata_port_schedule_eh(struct ata_port *ap)
         if (ap->pflags & ATA_PFLAG_INITIALIZING)
                 return;
 
-        ap->pflags |= ATA_PFLAG_EH_PENDING;
+        ata_eh_set_pending(ap, 1);
         scsi_schedule_eh(ap->scsi_host);
 
         DPRINTK("port EH scheduled\n");
@@ -579,6 +736,9 @@ int ata_port_abort(struct ata_port *ap)
 
         WARN_ON(!ap->ops->error_handler);
 
+        /* we're gonna abort all commands, no need for fast drain */
+        ata_eh_set_pending(ap, 0);
+
         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
                 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
 
@@ -1130,7 +1290,7 @@ static void ata_eh_analyze_ncq_error(struct ata_port *ap)
         /* we've got the perpetrator, condemn it */
         qc = __ata_qc_from_tag(ap, tag);
         memcpy(&qc->result_tf, &tf, sizeof(tf));
-        qc->err_mask |= AC_ERR_DEV;
+        qc->err_mask |= AC_ERR_DEV | AC_ERR_NCQ;
         ehc->i.err_mask &= ~AC_ERR_DEV;
 }
 
@@ -1413,8 +1573,12 @@ static void ata_eh_autopsy(struct ata_port *ap)
         if (rc == 0) {
                 ehc->i.serror |= serror;
                 ata_eh_analyze_serror(ap);
-        } else if (rc != -EOPNOTSUPP)
+        } else if (rc != -EOPNOTSUPP) {
+                /* SError read failed, force hardreset and probing */
+                ata_ehi_schedule_probe(&ehc->i);
                 ehc->i.action |= ATA_EH_HARDRESET;
+                ehc->i.err_mask |= AC_ERR_OTHER;
+        }
 
         /* analyze NCQ failure */
         ata_eh_analyze_ncq_error(ap);
@@ -1524,14 +1688,14 @@ static void ata_eh_report(struct ata_port *ap)
                                ehc->i.err_mask, ap->sactive, ehc->i.serror,
                                ehc->i.action, frozen);
                 if (desc)
-                        ata_dev_printk(ehc->i.dev, KERN_ERR, "(%s)\n", desc);
+                        ata_dev_printk(ehc->i.dev, KERN_ERR, "%s\n", desc);
         } else {
                 ata_port_printk(ap, KERN_ERR, "exception Emask 0x%x "
                                 "SAct 0x%x SErr 0x%x action 0x%x%s\n",
                                 ehc->i.err_mask, ap->sactive, ehc->i.serror,
                                 ehc->i.action, frozen);
                 if (desc)
-                        ata_port_printk(ap, KERN_ERR, "(%s)\n", desc);
+                        ata_port_printk(ap, KERN_ERR, "%s\n", desc);
         }
 
         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
@@ -1551,7 +1715,7 @@ static void ata_eh_report(struct ata_port *ap)
                         "cmd %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
                         "tag %d cdb 0x%x data %u %s\n         "
                         "res %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
-                        "Emask 0x%x (%s)\n",
+                        "Emask 0x%x (%s)%s\n",
                         cmd->command, cmd->feature, cmd->nsect,
                         cmd->lbal, cmd->lbam, cmd->lbah,
                         cmd->hob_feature, cmd->hob_nsect,
@@ -1562,7 +1726,8 @@ static void ata_eh_report(struct ata_port *ap)
                         res->lbal, res->lbam, res->lbah,
                         res->hob_feature, res->hob_nsect,
                         res->hob_lbal, res->hob_lbam, res->hob_lbah,
-                        res->device, qc->err_mask, ata_err_string(qc->err_mask));
+                        res->device, qc->err_mask, ata_err_string(qc->err_mask),
+                        qc->err_mask & AC_ERR_NCQ ? " <F>" : "");
         }
 }
 
@@ -1648,7 +1813,7 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
                         } else
                                 ata_port_printk(ap, KERN_ERR,
                                         "prereset failed (errno=%d)\n", rc);
-                        return rc;
+                        goto out;
                 }
         }
 
@@ -1661,7 +1826,8 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
                 /* prereset told us not to reset, bang classes and return */
                 for (i = 0; i < ATA_MAX_DEVICES; i++)
                         classes[i] = ATA_DEV_NONE;
-                return 0;
+                rc = 0;
+                goto out;
         }
 
         /* did prereset() screw up?  if so, fix up to avoid oopsing */
@@ -1697,7 +1863,8 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
                         ata_port_printk(ap, KERN_ERR,
                                         "follow-up softreset required "
                                         "but no softreset avaliable\n");
-                        return -EINVAL;
+                        rc = -EINVAL;
+                        goto out;
                 }
 
                 ata_eh_about_to_do(ap, NULL, ATA_EH_RESET_MASK);
@@ -1707,7 +1874,8 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
                     classes[0] == ATA_DEV_UNKNOWN) {
                         ata_port_printk(ap, KERN_ERR,
                                         "classification failed\n");
-                        return -EINVAL;
+                        rc = -EINVAL;
+                        goto out;
                 }
         }
 
@@ -1724,7 +1892,7 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
                         schedule_timeout_uninterruptible(delta);
                 }
 
-                if (reset == hardreset &&
+                if (rc == -EPIPE ||
                     try == ARRAY_SIZE(ata_eh_reset_timeouts) - 1)
                         sata_down_spd_limit(ap);
                 if (hardreset)
@@ -1733,12 +1901,18 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
         }
 
         if (rc == 0) {
+                u32 sstatus;
+
                 /* After the reset, the device state is PIO 0 and the
                  * controller state is undefined.  Record the mode.
                  */
                 for (i = 0; i < ATA_MAX_DEVICES; i++)
                         ap->device[i].pio_mode = XFER_PIO_0;
 
+                /* record current link speed */
+                if (sata_scr_read(ap, SCR_STATUS, &sstatus) == 0)
+                        ap->sata_spd = (sstatus >> 4) & 0xf;
+
                 if (postreset)
                         postreset(ap, classes);
 
@@ -1746,7 +1920,9 @@ static int ata_eh_reset(struct ata_port *ap, int classify,
                 ata_eh_done(ap, NULL, ehc->i.action & ATA_EH_RESET_MASK);
                 ehc->i.action |= ATA_EH_REVALIDATE;
         }
-
+ out:
+        /* clear hotplug flag */
+        ehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
         return rc;
 }
 
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index cfde22da07ac..12ac0b511f79 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -2947,17 +2947,22 @@ int ata_scsi_add_hosts(struct ata_host *host, struct scsi_host_template *sht)
         return rc;
 }
 
-void ata_scsi_scan_host(struct ata_port *ap)
+void ata_scsi_scan_host(struct ata_port *ap, int sync)
 {
+        int tries = 5;
+        struct ata_device *last_failed_dev = NULL;
+        struct ata_device *dev;
         unsigned int i;
 
         if (ap->flags & ATA_FLAG_DISABLED)
                 return;
 
+ repeat:
         for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
                 struct scsi_device *sdev;
 
+                dev = &ap->device[i];
+
                 if (!ata_dev_enabled(dev) || dev->sdev)
                         continue;
 
@@ -2967,6 +2972,45 @@ void ata_scsi_scan_host(struct ata_port *ap)
                         scsi_device_put(sdev);
                 }
         }
+
+        /* If we scanned while EH was in progress or allocation
+         * failure occurred, scan would have failed silently.  Check
+         * whether all devices are attached.
+         */
+        for (i = 0; i < ATA_MAX_DEVICES; i++) {
+                dev = &ap->device[i];
+                if (ata_dev_enabled(dev) && !dev->sdev)
+                        break;
+        }
+        if (i == ATA_MAX_DEVICES)
+                return;
+
+        /* we're missing some SCSI devices */
+        if (sync) {
+                /* If caller requested synchrnous scan && we've made
+                 * any progress, sleep briefly and repeat.
+                 */
+                if (dev != last_failed_dev) {
+                        msleep(100);
+                        last_failed_dev = dev;
+                        goto repeat;
+                }
+
+                /* We might be failing to detect boot device, give it
+                 * a few more chances.
+                 */
+                if (--tries) {
+                        msleep(100);
+                        goto repeat;
+                }
+
+                ata_port_printk(ap, KERN_ERR, "WARNING: synchronous SCSI scan "
+                                "failed without making any progress,\n"
+                                "                  switching to async\n");
+        }
+
+        queue_delayed_work(ata_aux_wq, &ap->hotplug_task,
+                           round_jiffies_relative(HZ));
 }
 
 /**
@@ -3093,20 +3137,7 @@ void ata_scsi_hotplug(struct work_struct *work)
         }
 
         /* scan for new ones */
-        ata_scsi_scan_host(ap);
-
-        /* If we scanned while EH was in progress, scan would have
-         * failed silently.  Requeue if there are enabled but
-         * unattached devices.
-         */
-        for (i = 0; i < ATA_MAX_DEVICES; i++) {
-                struct ata_device *dev = &ap->device[i];
-                if (ata_dev_enabled(dev) && !dev->sdev) {
-                        queue_delayed_work(ata_aux_wq, &ap->hotplug_task,
-                                round_jiffies_relative(HZ));
-                        break;
-                }
-        }
+        ata_scsi_scan_host(ap, 0);
 
         DPRINTK("EXIT\n");
 }
diff --git a/drivers/ata/libata-sff.c b/drivers/ata/libata-sff.c
index ca7d2245d684..6c289c7b1322 100644
--- a/drivers/ata/libata-sff.c
+++ b/drivers/ata/libata-sff.c
@@ -1,5 +1,5 @@
 /*
- *  libata-bmdma.c - helper library for PCI IDE BMDMA
+ *  libata-sff.c - helper library for PCI IDE BMDMA
  *
  *  Maintained by:  Jeff Garzik <jgarzik@pobox.com>
  *                  Please ALWAYS copy linux-ide@vger.kernel.org
@@ -211,6 +211,8 @@ void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
                 tf->hob_lbal = ioread8(ioaddr->lbal_addr);
                 tf->hob_lbam = ioread8(ioaddr->lbam_addr);
                 tf->hob_lbah = ioread8(ioaddr->lbah_addr);
+                iowrite8(tf->ctl, ioaddr->ctl_addr);
+                ap->last_ctl = tf->ctl;
         }
 }
 
diff --git a/drivers/ata/libata.h b/drivers/ata/libata.h
index ba17fc5f2e99..564cd234c805 100644
--- a/drivers/ata/libata.h
+++ b/drivers/ata/libata.h
@@ -112,7 +112,7 @@ static inline int ata_acpi_on_devcfg(struct ata_device *adev) { return 0; }
 /* libata-scsi.c */
 extern int ata_scsi_add_hosts(struct ata_host *host,
                               struct scsi_host_template *sht);
-extern void ata_scsi_scan_host(struct ata_port *ap);
+extern void ata_scsi_scan_host(struct ata_port *ap, int sync);
 extern int ata_scsi_offline_dev(struct ata_device *dev);
 extern void ata_scsi_hotplug(struct work_struct *work);
 extern unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf,
@@ -151,6 +151,7 @@ extern int ata_bus_probe(struct ata_port *ap);
 extern enum scsi_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd);
 extern void ata_scsi_error(struct Scsi_Host *host);
 extern void ata_port_wait_eh(struct ata_port *ap);
+extern void ata_eh_fastdrain_timerfn(unsigned long arg);
 extern void ata_qc_schedule_eh(struct ata_queued_cmd *qc);
 
 /* libata-sff.c */
diff --git a/drivers/ata/pata_cs5520.c b/drivers/ata/pata_cs5520.c
index 6bf037d82b5a..7dc76e71bd55 100644
--- a/drivers/ata/pata_cs5520.c
+++ b/drivers/ata/pata_cs5520.c
@@ -275,7 +275,7 @@ static int __devinit cs5520_init_one(struct pci_dev *pdev, const struct pci_devi
 
         for (i = 0; i < 2; i++) {
                 static const int irq[] = { 14, 15 };
-                struct ata_port *ap = host->ports[0];
+                struct ata_port *ap = host->ports[i];
 
                 if (ata_port_is_dummy(ap))
                         continue;
diff --git a/drivers/ata/pata_pcmcia.c b/drivers/ata/pata_pcmcia.c
index a56257c98fe5..6da23feed039 100644
--- a/drivers/ata/pata_pcmcia.c
+++ b/drivers/ata/pata_pcmcia.c
@@ -382,6 +382,7 @@ static struct pcmcia_device_id pcmcia_devices[] = {
         PCMCIA_DEVICE_PROD_ID12("HITACHI", "microdrive", 0xf4f43949, 0xa6d76178),
         PCMCIA_DEVICE_PROD_ID12("IBM", "microdrive", 0xb569a6e5, 0xa6d76178),
         PCMCIA_DEVICE_PROD_ID12("IBM", "IBM17JSSFP20", 0xb569a6e5, 0xf2508753),
+        PCMCIA_DEVICE_PROD_ID12("KINGSTON", "CF8GB", 0x2e6d1829, 0xacbe682e),
         PCMCIA_DEVICE_PROD_ID12("IO DATA", "CBIDE2      ", 0x547e66dc, 0x8671043b),
         PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDE", 0x547e66dc, 0x5c5ab149),
         PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDEII", 0x547e66dc, 0xb3662674),
diff --git a/drivers/ata/pata_platform.c b/drivers/ata/pata_platform.c
index 79f841bca593..a909f793ffc1 100644
--- a/drivers/ata/pata_platform.c
+++ b/drivers/ata/pata_platform.c
@@ -213,8 +213,9 @@ static int __devinit pata_platform_probe(struct platform_device *pdev)
         pata_platform_setup_port(&ap->ioaddr, pp_info);
 
         /* activate */
-        return ata_host_activate(host, platform_get_irq(pdev, 0), ata_interrupt,
-                                 pp_info->irq_flags, &pata_platform_sht);
+        return ata_host_activate(host, platform_get_irq(pdev, 0),
+                                 ata_interrupt, pp_info ? pp_info->irq_flags
+                                 : 0, &pata_platform_sht);
 }
 
 /**
diff --git a/drivers/ata/pata_scc.c b/drivers/ata/pata_scc.c
index c55667e0eb65..36cdbd2b0bd5 100644
--- a/drivers/ata/pata_scc.c
+++ b/drivers/ata/pata_scc.c
@@ -238,12 +238,6 @@ static void scc_set_dmamode (struct ata_port *ap, struct ata_device *adev)
         else
                 offset = 0;     /* 100MHz */
 
-        /* errata A308 workaround: limit ATAPI UDMA mode to UDMA4 */
-        if (adev->class == ATA_DEV_ATAPI && speed > XFER_UDMA_4) {
-                printk(KERN_INFO "%s: limit ATAPI UDMA to UDMA4\n", DRV_NAME);
-                speed = XFER_UDMA_4;
-        }
-
         if (speed >= XFER_UDMA_0)
                 idx = speed - XFER_UDMA_0;
         else
@@ -264,6 +258,17 @@ static void scc_set_dmamode (struct ata_port *ap, struct ata_device *adev)
                  JCTSStbl[offset][idx] << 16 | JCENVTtbl[offset][idx]);
 }
 
+unsigned long scc_mode_filter(struct ata_device *adev, unsigned long mask)
+{
+        /* errata A308 workaround: limit ATAPI UDMA mode to UDMA4 */
+        if (adev->class == ATA_DEV_ATAPI &&
+            (mask & (0xE0 << ATA_SHIFT_UDMA))) {
+                printk(KERN_INFO "%s: limit ATAPI UDMA to UDMA4\n", DRV_NAME);
+                mask &= ~(0xE0 << ATA_SHIFT_UDMA);
+        }
+        return ata_pci_default_filter(adev, mask);
+}
+
 /**
  *      scc_tf_load - send taskfile registers to host controller
  *      @ap: Port to which output is sent
@@ -358,6 +363,8 @@ static void scc_tf_read (struct ata_port *ap, struct ata_taskfile *tf)
                 tf->hob_lbal = in_be32(ioaddr->lbal_addr);
                 tf->hob_lbam = in_be32(ioaddr->lbam_addr);
                 tf->hob_lbah = in_be32(ioaddr->lbah_addr);
+                out_be32(ioaddr->ctl_addr, tf->ctl);
+                ap->last_ctl = tf->ctl;
         }
 }
 
@@ -741,7 +748,7 @@ static u8 scc_bmdma_status (struct ata_port *ap)
                 return host_stat;
 
         /* errata A252,A308 workaround: Step4 */
-        if (ata_altstatus(ap) & ATA_ERR && int_status & INTSTS_INTRQ)
+        if ((ata_altstatus(ap) & ATA_ERR) && (int_status & INTSTS_INTRQ))
                 return (host_stat | ATA_DMA_INTR);
 
         /* errata A308 workaround Step5 */
@@ -752,11 +759,11 @@ static u8 scc_bmdma_status (struct ata_port *ap)
                 if ((qc->tf.protocol == ATA_PROT_DMA &&
                      qc->dev->xfer_mode > XFER_UDMA_4)) {
                         if (!(int_status & INTSTS_ACTEINT)) {
-                                printk(KERN_WARNING "ata%u: data lost occurred. (ACTEINT==0, retry:%d)\n",
-                                       ap->print_id, retry);
+                                printk(KERN_WARNING "ata%u: operation failed (transfer data loss)\n",
+                                       ap->print_id);
                                 host_stat |= ATA_DMA_ERR;
                                 if (retry++)
-                                        ap->udma_mask >>= 1;
+                                        ap->udma_mask &= ~(1 << qc->dev->xfer_mode);
                         } else
                                 retry = 0;
                 }
@@ -1016,7 +1023,7 @@ static const struct ata_port_operations scc_pata_ops = {
         .port_disable           = ata_port_disable,
         .set_piomode            = scc_set_piomode,
         .set_dmamode            = scc_set_dmamode,
-        .mode_filter            = ata_pci_default_filter,
+        .mode_filter            = scc_mode_filter,
 
         .tf_load                = scc_tf_load,
         .tf_read                = scc_tf_read,
diff --git a/drivers/ata/sata_inic162x.c b/drivers/ata/sata_inic162x.c
index 3de183461c3c..a9c948d7604a 100644
--- a/drivers/ata/sata_inic162x.c
+++ b/drivers/ata/sata_inic162x.c
@@ -190,34 +190,34 @@ static void inic_reset_port(void __iomem *port_base)
         writew(ctl, idma_ctl);
 }
 
-static u32 inic_scr_read(struct ata_port *ap, unsigned sc_reg)
+static int inic_scr_read(struct ata_port *ap, unsigned sc_reg, u32 *val)
 {
         void __iomem *scr_addr = ap->ioaddr.scr_addr;
         void __iomem *addr;
-        u32 val;
 
         if (unlikely(sc_reg >= ARRAY_SIZE(scr_map)))
-                return 0xffffffffU;
+                return -EINVAL;
 
         addr = scr_addr + scr_map[sc_reg] * 4;
-        val = readl(scr_addr + scr_map[sc_reg] * 4);
+        *val = readl(scr_addr + scr_map[sc_reg] * 4);
 
         /* this controller has stuck DIAG.N, ignore it */
         if (sc_reg == SCR_ERROR)
-                val &= ~SERR_PHYRDY_CHG;
-        return val;
+                *val &= ~SERR_PHYRDY_CHG;
+        return 0;
 }
 
-static void inic_scr_write(struct ata_port *ap, unsigned sc_reg, u32 val)
+static int inic_scr_write(struct ata_port *ap, unsigned sc_reg, u32 val)
 {
         void __iomem *scr_addr = ap->ioaddr.scr_addr;
         void __iomem *addr;
 
         if (unlikely(sc_reg >= ARRAY_SIZE(scr_map)))
-                return;
+                return -EINVAL;
 
         addr = scr_addr + scr_map[sc_reg] * 4;
         writel(val, scr_addr + scr_map[sc_reg] * 4);
+        return 0;
 }
 
 /*
diff --git a/drivers/ata/sata_mv.c b/drivers/ata/sata_mv.c
index fb8a749423ca..8ec520885b95 100644
--- a/drivers/ata/sata_mv.c
+++ b/drivers/ata/sata_mv.c
@@ -35,8 +35,6 @@
 
   6) Add port multiplier support (intermediate)
 
-  7) Test and verify 3.0 Gbps support
-
   8) Develop a low-power-consumption strategy, and implement it.
 
   9) [Experiment, low priority] See if ATAPI can be supported using
@@ -227,26 +225,26 @@ enum {
 
         EDMA_ERR_IRQ_CAUSE_OFS  = 0x8,
         EDMA_ERR_IRQ_MASK_OFS   = 0xc,
-        EDMA_ERR_D_PAR          = (1 << 0),
-        EDMA_ERR_PRD_PAR        = (1 << 1),
-        EDMA_ERR_DEV            = (1 << 2),
-        EDMA_ERR_DEV_DCON       = (1 << 3),
-        EDMA_ERR_DEV_CON        = (1 << 4),
-        EDMA_ERR_SERR           = (1 << 5),
+        EDMA_ERR_D_PAR          = (1 << 0),     /* UDMA data parity err */
+        EDMA_ERR_PRD_PAR        = (1 << 1),     /* UDMA PRD parity err */
+        EDMA_ERR_DEV            = (1 << 2),     /* device error */
+        EDMA_ERR_DEV_DCON       = (1 << 3),     /* device disconnect */
+        EDMA_ERR_DEV_CON        = (1 << 4),     /* device connected */
+        EDMA_ERR_SERR           = (1 << 5),     /* SError bits [WBDST] raised */
         EDMA_ERR_SELF_DIS       = (1 << 7),     /* Gen II/IIE self-disable */
         EDMA_ERR_SELF_DIS_5     = (1 << 8),     /* Gen I self-disable */
-        EDMA_ERR_BIST_ASYNC     = (1 << 8),
+        EDMA_ERR_BIST_ASYNC     = (1 << 8),     /* BIST FIS or Async Notify */
         EDMA_ERR_TRANS_IRQ_7    = (1 << 8),     /* Gen IIE transprt layer irq */
-        EDMA_ERR_CRBQ_PAR       = (1 << 9),
-        EDMA_ERR_CRPB_PAR       = (1 << 10),
-        EDMA_ERR_INTRL_PAR      = (1 << 11),
-        EDMA_ERR_IORDY          = (1 << 12),
-        EDMA_ERR_LNK_CTRL_RX    = (0xf << 13),
+        EDMA_ERR_CRQB_PAR       = (1 << 9),     /* CRQB parity error */
+        EDMA_ERR_CRPB_PAR       = (1 << 10),    /* CRPB parity error */
+        EDMA_ERR_INTRL_PAR      = (1 << 11),    /* internal parity error */
+        EDMA_ERR_IORDY          = (1 << 12),    /* IORdy timeout */
+        EDMA_ERR_LNK_CTRL_RX    = (0xf << 13),  /* link ctrl rx error */
         EDMA_ERR_LNK_CTRL_RX_2  = (1 << 15),
-        EDMA_ERR_LNK_DATA_RX    = (0xf << 17),
-        EDMA_ERR_LNK_CTRL_TX    = (0x1f << 21),
-        EDMA_ERR_LNK_DATA_TX    = (0x1f << 26),
-        EDMA_ERR_TRANS_PROTO    = (1 << 31),
+        EDMA_ERR_LNK_DATA_RX    = (0xf << 17),  /* link data rx error */
+        EDMA_ERR_LNK_CTRL_TX    = (0x1f << 21), /* link ctrl tx error */
+        EDMA_ERR_LNK_DATA_TX    = (0x1f << 26), /* link data tx error */
+        EDMA_ERR_TRANS_PROTO    = (1 << 31),    /* transport protocol error */
         EDMA_ERR_OVERRUN_5      = (1 << 5),
         EDMA_ERR_UNDERRUN_5     = (1 << 6),
         EDMA_EH_FREEZE          = EDMA_ERR_D_PAR |
@@ -255,7 +253,7 @@ enum {
                                   EDMA_ERR_DEV_CON |
                                   EDMA_ERR_SERR |
                                   EDMA_ERR_SELF_DIS |
-                                  EDMA_ERR_CRBQ_PAR |
+                                  EDMA_ERR_CRQB_PAR |
                                   EDMA_ERR_CRPB_PAR |
                                   EDMA_ERR_INTRL_PAR |
                                   EDMA_ERR_IORDY |
@@ -270,7 +268,7 @@ enum {
                                   EDMA_ERR_OVERRUN_5 |
                                   EDMA_ERR_UNDERRUN_5 |
                                   EDMA_ERR_SELF_DIS_5 |
-                                  EDMA_ERR_CRBQ_PAR |
+                                  EDMA_ERR_CRQB_PAR |
                                   EDMA_ERR_CRPB_PAR |
                                   EDMA_ERR_INTRL_PAR |
                                   EDMA_ERR_IORDY,
@@ -286,10 +284,10 @@ enum {
         EDMA_RSP_Q_OUT_PTR_OFS  = 0x24,         /* also contains BASE_LO */
         EDMA_RSP_Q_PTR_SHIFT    = 3,
 
-        EDMA_CMD_OFS            = 0x28,
-        EDMA_EN                 = (1 << 0),
-        EDMA_DS                 = (1 << 1),
-        ATA_RST                 = (1 << 2),
+        EDMA_CMD_OFS            = 0x28,         /* EDMA command register */
+        EDMA_EN                 = (1 << 0),     /* enable EDMA */
+        EDMA_DS                 = (1 << 1),     /* disable EDMA; self-negated */
+        ATA_RST                 = (1 << 2),     /* reset trans/link/phy */
 
         EDMA_IORDY_TMOUT        = 0x34,
         EDMA_ARB_CFG            = 0x38,
@@ -301,14 +299,13 @@ enum {
         MV_HP_ERRATA_60X1B2     = (1 << 3),
         MV_HP_ERRATA_60X1C0     = (1 << 4),
         MV_HP_ERRATA_XX42A0     = (1 << 5),
-        MV_HP_GEN_I             = (1 << 6),
-        MV_HP_GEN_II            = (1 << 7),
-        MV_HP_GEN_IIE           = (1 << 8),
+        MV_HP_GEN_I             = (1 << 6),     /* Generation I: 50xx */
+        MV_HP_GEN_II            = (1 << 7),     /* Generation II: 60xx */
+        MV_HP_GEN_IIE           = (1 << 8),     /* Generation IIE: 6042/7042 */
 
         /* Port private flags (pp_flags) */
-        MV_PP_FLAG_EDMA_EN      = (1 << 0),
-        MV_PP_FLAG_EDMA_DS_ACT  = (1 << 1),
-        MV_PP_FLAG_HAD_A_RESET  = (1 << 2),
+        MV_PP_FLAG_EDMA_EN      = (1 << 0),     /* is EDMA engine enabled? */
+        MV_PP_FLAG_HAD_A_RESET  = (1 << 2),     /* 1st hard reset complete? */
 };
 
 #define IS_GEN_I(hpriv) ((hpriv)->hp_flags & MV_HP_GEN_I)
@@ -318,8 +315,12 @@ enum {
 enum {
         MV_DMA_BOUNDARY         = 0xffffffffU,
 
+        /* mask of register bits containing lower 32 bits
+         * of EDMA request queue DMA address
+         */
         EDMA_REQ_Q_BASE_LO_MASK = 0xfffffc00U,
 
+        /* ditto, for response queue */
         EDMA_RSP_Q_BASE_LO_MASK = 0xffffff00U,
 };
 
@@ -403,10 +404,10 @@ struct mv_host_priv {
 };
 
 static void mv_irq_clear(struct ata_port *ap);
-static u32 mv_scr_read(struct ata_port *ap, unsigned int sc_reg_in);
-static void mv_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val);
-static u32 mv5_scr_read(struct ata_port *ap, unsigned int sc_reg_in);
-static void mv5_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val);
+static int mv_scr_read(struct ata_port *ap, unsigned int sc_reg_in, u32 *val);
+static int mv_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val);
+static int mv5_scr_read(struct ata_port *ap, unsigned int sc_reg_in, u32 *val);
+static int mv5_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val);
 static int mv_port_start(struct ata_port *ap);
 static void mv_port_stop(struct ata_port *ap);
 static void mv_qc_prep(struct ata_queued_cmd *qc);
@@ -823,7 +824,7 @@ static void mv_start_dma(void __iomem *base, struct mv_host_priv *hpriv,
 }
 
 /**
- *      mv_stop_dma - Disable eDMA engine
+ *      __mv_stop_dma - Disable eDMA engine
  *      @ap: ATA channel to manipulate
  *
  *      Verify the local cache of the eDMA state is accurate with a
@@ -832,7 +833,7 @@ static void mv_start_dma(void __iomem *base, struct mv_host_priv *hpriv,
  *      LOCKING:
  *      Inherited from caller.
  */
-static int mv_stop_dma(struct ata_port *ap)
+static int __mv_stop_dma(struct ata_port *ap)
 {
         void __iomem *port_mmio = mv_ap_base(ap);
         struct mv_port_priv *pp = ap->private_data;
@@ -865,6 +866,18 @@ static int mv_stop_dma(struct ata_port *ap)
         return err;
 }
 
+static int mv_stop_dma(struct ata_port *ap)
+{
+        unsigned long flags;
+        int rc;
+
+        spin_lock_irqsave(&ap->host->lock, flags);
+        rc = __mv_stop_dma(ap);
+        spin_unlock_irqrestore(&ap->host->lock, flags);
+
+        return rc;
+}
+
 #ifdef ATA_DEBUG
 static void mv_dump_mem(void __iomem *start, unsigned bytes)
 {
@@ -961,22 +974,26 @@ static unsigned int mv_scr_offset(unsigned int sc_reg_in)
         return ofs;
 }
 
-static u32 mv_scr_read(struct ata_port *ap, unsigned int sc_reg_in)
+static int mv_scr_read(struct ata_port *ap, unsigned int sc_reg_in, u32 *val)
 {
         unsigned int ofs = mv_scr_offset(sc_reg_in);
 
-        if (0xffffffffU != ofs)
-                return readl(mv_ap_base(ap) + ofs);
-        else
-                return (u32) ofs;
+        if (ofs != 0xffffffffU) {
+                *val = readl(mv_ap_base(ap) + ofs);
+                return 0;
+        } else
+                return -EINVAL;
 }
 
-static void mv_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val)
+static int mv_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val)
 {
         unsigned int ofs = mv_scr_offset(sc_reg_in);
 
-        if (0xffffffffU != ofs)
+        if (ofs != 0xffffffffU) {
                 writelfl(val, mv_ap_base(ap) + ofs);
+                return 0;
+        } else
+                return -EINVAL;
 }
 
 static void mv_edma_cfg(struct ata_port *ap, struct mv_host_priv *hpriv,
@@ -1029,6 +1046,7 @@ static int mv_port_start(struct ata_port *ap)
         void __iomem *port_mmio = mv_ap_base(ap);
         void *mem;
         dma_addr_t mem_dma;
+        unsigned long flags;
         int rc;
 
         pp = devm_kzalloc(dev, sizeof(*pp), GFP_KERNEL);
@@ -1067,10 +1085,14 @@ static int mv_port_start(struct ata_port *ap)
         pp->sg_tbl = mem;
         pp->sg_tbl_dma = mem_dma;
 
+        spin_lock_irqsave(&ap->host->lock, flags);
+
         mv_edma_cfg(ap, hpriv, port_mmio);
 
         mv_set_edma_ptrs(port_mmio, hpriv, pp);
 
+        spin_unlock_irqrestore(&ap->host->lock, flags);
+
         /* Don't turn on EDMA here...do it before DMA commands only.  Else
          * we'll be unable to send non-data, PIO, etc due to restricted access
          * to shadow regs.
@@ -1090,11 +1112,7 @@ static int mv_port_start(struct ata_port *ap)
  */
 static void mv_port_stop(struct ata_port *ap)
 {
-        unsigned long flags;
-
-        spin_lock_irqsave(&ap->host->lock, flags);
         mv_stop_dma(ap);
-        spin_unlock_irqrestore(&ap->host->lock, flags);
 }
 
 /**
@@ -1325,7 +1343,7 @@ static unsigned int mv_qc_issue(struct ata_queued_cmd *qc)
                  * port.  Turn off EDMA so there won't be problems accessing
                  * shadow block, etc registers.
                  */
-                mv_stop_dma(ap);
+                __mv_stop_dma(ap);
                 return ata_qc_issue_prot(qc);
         }
 
@@ -1393,16 +1411,16 @@ static void mv_err_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
         if (edma_err_cause & EDMA_ERR_DEV)
                 err_mask |= AC_ERR_DEV;
         if (edma_err_cause & (EDMA_ERR_D_PAR | EDMA_ERR_PRD_PAR |
-                        EDMA_ERR_CRBQ_PAR | EDMA_ERR_CRPB_PAR |
+                        EDMA_ERR_CRQB_PAR | EDMA_ERR_CRPB_PAR |
                         EDMA_ERR_INTRL_PAR)) {
                 err_mask |= AC_ERR_ATA_BUS;
                 action |= ATA_EH_HARDRESET;
-                ata_ehi_push_desc(ehi, ", parity error");
+                ata_ehi_push_desc(ehi, "parity error");
         }
         if (edma_err_cause & (EDMA_ERR_DEV_DCON | EDMA_ERR_DEV_CON)) {
                 ata_ehi_hotplugged(ehi);
                 ata_ehi_push_desc(ehi, edma_err_cause & EDMA_ERR_DEV_DCON ?
-                        ", dev disconnect" : ", dev connect");
+                        "dev disconnect" : "dev connect");
         }
 
         if (IS_GEN_I(hpriv)) {
@@ -1411,7 +1429,7 @@ static void mv_err_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
                 if (edma_err_cause & EDMA_ERR_SELF_DIS_5) {
                         struct mv_port_priv *pp = ap->private_data;
                         pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
-                        ata_ehi_push_desc(ehi, ", EDMA self-disable");
+                        ata_ehi_push_desc(ehi, "EDMA self-disable");
                 }
         } else {
                 eh_freeze_mask = EDMA_EH_FREEZE;
@@ -1419,7 +1437,7 @@ static void mv_err_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
                 if (edma_err_cause & EDMA_ERR_SELF_DIS) {
                         struct mv_port_priv *pp = ap->private_data;
                         pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
-                        ata_ehi_push_desc(ehi, ", EDMA self-disable");
+                        ata_ehi_push_desc(ehi, "EDMA self-disable");
                 }
 
                 if (edma_err_cause & EDMA_ERR_SERR) {
@@ -1489,33 +1507,30 @@ static void mv_intr_edma(struct ata_port *ap)
 
         while (1) {
                 u16 status;
+                unsigned int tag;
 
                 /* get s/w response queue last-read pointer, and compare */
                 out_index = pp->resp_idx & MV_MAX_Q_DEPTH_MASK;
                 if (in_index == out_index)
                         break;
 
-                 
                 /* 50xx: get active ATA command */
-                if (IS_GEN_I(hpriv)) 
-                        qc = ata_qc_from_tag(ap, ap->active_tag);
+                if (IS_GEN_I(hpriv))
+                        tag = ap->active_tag;
 
-                /* 60xx: get active ATA command via tag, to enable support
-                 * for queueing.  this works transparently for queued and
-                 * non-queued modes.
+                /* Gen II/IIE: get active ATA command via tag, to enable
+                 * support for queueing.  this works transparently for
+                 * queued and non-queued modes.
                  */
-                else {
-                        unsigned int tag;
+                else if (IS_GEN_II(hpriv))
+                        tag = (le16_to_cpu(pp->crpb[out_index].id)
+                                >> CRPB_IOID_SHIFT_6) & 0x3f;
 
-                        if (IS_GEN_II(hpriv))
-                                tag = (le16_to_cpu(pp->crpb[out_index].id)
-                                        >> CRPB_IOID_SHIFT_6) & 0x3f;
-                        else
-                                tag = (le16_to_cpu(pp->crpb[out_index].id)
-                                        >> CRPB_IOID_SHIFT_7) & 0x3f;
+                else /* IS_GEN_IIE */
+                        tag = (le16_to_cpu(pp->crpb[out_index].id)
+                                >> CRPB_IOID_SHIFT_7) & 0x3f;
 
-                        qc = ata_qc_from_tag(ap, tag);
-                }
+                qc = ata_qc_from_tag(ap, tag);
 
                 /* lower 8 bits of status are EDMA_ERR_IRQ_CAUSE_OFS
                  * bits (WARNING: might not necessarily be associated
@@ -1535,7 +1550,7 @@ static void mv_intr_edma(struct ata_port *ap)
                         ata_qc_complete(qc);
                 }
 
-                /* advance software response queue pointer, to 
+                /* advance software response queue pointer, to
                  * indicate (after the loop completes) to hardware
                  * that we have consumed a response queue entry.
                  */
@@ -1741,26 +1756,30 @@ static unsigned int mv5_scr_offset(unsigned int sc_reg_in)
         return ofs;
 }
 
-static u32 mv5_scr_read(struct ata_port *ap, unsigned int sc_reg_in)
+static int mv5_scr_read(struct ata_port *ap, unsigned int sc_reg_in, u32 *val)
 {
         void __iomem *mmio = ap->host->iomap[MV_PRIMARY_BAR];
         void __iomem *addr = mv5_phy_base(mmio, ap->port_no);
         unsigned int ofs = mv5_scr_offset(sc_reg_in);
 
-        if (ofs != 0xffffffffU)
-                return readl(addr + ofs);
-        else
-                return (u32) ofs;
+        if (ofs != 0xffffffffU) {
+                *val = readl(addr + ofs);
+                return 0;
+        } else
+                return -EINVAL;
 }
 
-static void mv5_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val)
+static int mv5_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val)
 {
         void __iomem *mmio = ap->host->iomap[MV_PRIMARY_BAR];
         void __iomem *addr = mv5_phy_base(mmio, ap->port_no);
         unsigned int ofs = mv5_scr_offset(sc_reg_in);
 
-        if (ofs != 0xffffffffU)
+        if (ofs != 0xffffffffU) {
                 writelfl(val, addr + ofs);
+                return 0;
+        } else
+                return -EINVAL;
 }
 
 static void mv5_reset_bus(struct pci_dev *pdev, void __iomem *mmio)
@@ -2138,9 +2157,17 @@ static void mv_phy_reset(struct ata_port *ap, unsigned int *class,
 
         VPRINTK("ENTER, port %u, mmio 0x%p\n", ap->port_no, port_mmio);
 
-        DPRINTK("S-regs after ATA_RST: SStat 0x%08x SErr 0x%08x "
-                "SCtrl 0x%08x\n", mv_scr_read(ap, SCR_STATUS),
-                mv_scr_read(ap, SCR_ERROR), mv_scr_read(ap, SCR_CONTROL));
+#ifdef DEBUG
+        {
+                u32 sstatus, serror, scontrol;
+
+                mv_scr_read(ap, SCR_STATUS, &sstatus);
+                mv_scr_read(ap, SCR_ERROR, &serror);
+                mv_scr_read(ap, SCR_CONTROL, &scontrol);
+                DPRINTK("S-regs after ATA_RST: SStat 0x%08x SErr 0x%08x "
+                        "SCtrl 0x%08x\n", status, serror, scontrol);
+        }
+#endif
 
         /* Issue COMRESET via SControl */
 comreset_retry:
@@ -2164,9 +2191,17 @@ comreset_retry:
             (retry-- > 0))
                 goto comreset_retry;
 
-        DPRINTK("S-regs after PHY wake: SStat 0x%08x SErr 0x%08x "
-                "SCtrl 0x%08x\n", mv_scr_read(ap, SCR_STATUS),
-                mv_scr_read(ap, SCR_ERROR), mv_scr_read(ap, SCR_CONTROL));
+#ifdef DEBUG
+        {
+                u32 sstatus, serror, scontrol;
+
+                mv_scr_read(ap, SCR_STATUS, &sstatus);
+                mv_scr_read(ap, SCR_ERROR, &serror);
+                mv_scr_read(ap, SCR_CONTROL, &scontrol);
+                DPRINTK("S-regs after PHY wake: SStat 0x%08x SErr 0x%08x "
+                        "SCtrl 0x%08x\n", sstatus, serror, scontrol);
+        }
+#endif
 
         if (ata_port_offline(ap)) {
                 *class = ATA_DEV_NONE;
@@ -2209,7 +2244,7 @@ static int mv_prereset(struct ata_port *ap, unsigned long deadline)
         struct mv_port_priv *pp = ap->private_data;
         struct ata_eh_context *ehc = &ap->eh_context;
         int rc;
-        
+
         rc = mv_stop_dma(ap);
         if (rc)
                 ehc->i.action |= ATA_EH_HARDRESET;
diff --git a/drivers/ata/sata_nv.c b/drivers/ata/sata_nv.c
index db81e3efa5ec..0b58c4df6fd2 100644
--- a/drivers/ata/sata_nv.c
+++ b/drivers/ata/sata_nv.c
@@ -236,8 +236,8 @@ static void nv_ck804_host_stop(struct ata_host *host);
 static irqreturn_t nv_generic_interrupt(int irq, void *dev_instance);
 static irqreturn_t nv_nf2_interrupt(int irq, void *dev_instance);
 static irqreturn_t nv_ck804_interrupt(int irq, void *dev_instance);
-static u32 nv_scr_read (struct ata_port *ap, unsigned int sc_reg);
-static void nv_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
+static int nv_scr_read (struct ata_port *ap, unsigned int sc_reg, u32 *val);
+static int nv_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
 
 static void nv_nf2_freeze(struct ata_port *ap);
 static void nv_nf2_thaw(struct ata_port *ap);
@@ -715,19 +715,20 @@ static int nv_adma_check_cpb(struct ata_port *ap, int cpb_num, int force_err)
                 int freeze = 0;
 
                 ata_ehi_clear_desc(ehi);
-                ata_ehi_push_desc(ehi, "CPB resp_flags 0x%x", flags );
+                __ata_ehi_push_desc(ehi, "CPB resp_flags 0x%x: ", flags );
                 if (flags & NV_CPB_RESP_ATA_ERR) {
-                        ata_ehi_push_desc(ehi, ": ATA error");
+                        ata_ehi_push_desc(ehi, "ATA error");
                         ehi->err_mask |= AC_ERR_DEV;
                 } else if (flags & NV_CPB_RESP_CMD_ERR) {
-                        ata_ehi_push_desc(ehi, ": CMD error");
+                        ata_ehi_push_desc(ehi, "CMD error");
                         ehi->err_mask |= AC_ERR_DEV;
                 } else if (flags & NV_CPB_RESP_CPB_ERR) {
-                        ata_ehi_push_desc(ehi, ": CPB error");
+                        ata_ehi_push_desc(ehi, "CPB error");
                         ehi->err_mask |= AC_ERR_SYSTEM;
                         freeze = 1;
                 } else {
                         /* notifier error, but no error in CPB flags? */
+                        ata_ehi_push_desc(ehi, "unknown");
                         ehi->err_mask |= AC_ERR_OTHER;
                         freeze = 1;
                 }
@@ -854,20 +855,21 @@ static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance)
                                 struct ata_eh_info *ehi = &ap->eh_info;
 
                                 ata_ehi_clear_desc(ehi);
-                                ata_ehi_push_desc(ehi, "ADMA status 0x%08x", status );
+                                __ata_ehi_push_desc(ehi, "ADMA status 0x%08x: ", status );
                                 if (status & NV_ADMA_STAT_TIMEOUT) {
                                         ehi->err_mask |= AC_ERR_SYSTEM;
-                                        ata_ehi_push_desc(ehi, ": timeout");
+                                        ata_ehi_push_desc(ehi, "timeout");
                                 } else if (status & NV_ADMA_STAT_HOTPLUG) {
                                         ata_ehi_hotplugged(ehi);
-                                        ata_ehi_push_desc(ehi, ": hotplug");
+                                        ata_ehi_push_desc(ehi, "hotplug");
                                 } else if (status & NV_ADMA_STAT_HOTUNPLUG) {
                                         ata_ehi_hotplugged(ehi);
-                                        ata_ehi_push_desc(ehi, ": hot unplug");
+                                        ata_ehi_push_desc(ehi, "hot unplug");
                                 } else if (status & NV_ADMA_STAT_SERROR) {
                                         /* let libata analyze SError and figure out the cause */
-                                        ata_ehi_push_desc(ehi, ": SError");
-                                }
+                                        ata_ehi_push_desc(ehi, "SError");
+                                } else
+                                        ata_ehi_push_desc(ehi, "unknown");
                                 ata_port_freeze(ap);
                                 continue;
                         }
@@ -1391,20 +1393,22 @@ static irqreturn_t nv_ck804_interrupt(int irq, void *dev_instance)
         return ret;
 }
 
-static u32 nv_scr_read (struct ata_port *ap, unsigned int sc_reg)
+static int nv_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val)
 {
         if (sc_reg > SCR_CONTROL)
-                return 0xffffffffU;
+                return -EINVAL;
 
-        return ioread32(ap->ioaddr.scr_addr + (sc_reg * 4));
+        *val = ioread32(ap->ioaddr.scr_addr + (sc_reg * 4));
+        return 0;
 }
 
-static void nv_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
+static int nv_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val)
 {
         if (sc_reg > SCR_CONTROL)
-                return;
+                return -EINVAL;
 
         iowrite32(val, ap->ioaddr.scr_addr + (sc_reg * 4));
+        return 0;
 }
 
 static void nv_nf2_freeze(struct ata_port *ap)
diff --git a/drivers/ata/sata_promise.c b/drivers/ata/sata_promise.c
index d2fcb9a6bec2..d39ebc23c4a9 100644
--- a/drivers/ata/sata_promise.c
+++ b/drivers/ata/sata_promise.c
@@ -128,8 +128,8 @@ struct pdc_port_priv {
         dma_addr_t              pkt_dma;
 };
 
-static u32 pdc_sata_scr_read (struct ata_port *ap, unsigned int sc_reg);
-static void pdc_sata_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
+static int pdc_sata_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val);
+static int pdc_sata_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val);
 static int pdc_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
 static int pdc_common_port_start(struct ata_port *ap);
 static int pdc_sata_port_start(struct ata_port *ap);
@@ -427,19 +427,20 @@ static int pdc_sata_cable_detect(struct ata_port *ap)
         return ATA_CBL_SATA;
 }
 
-static u32 pdc_sata_scr_read (struct ata_port *ap, unsigned int sc_reg)
+static int pdc_sata_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val)
 {
         if (sc_reg > SCR_CONTROL)
-                return 0xffffffffU;
-        return readl(ap->ioaddr.scr_addr + (sc_reg * 4));
+                return -EINVAL;
+        *val = readl(ap->ioaddr.scr_addr + (sc_reg * 4));
+        return 0;
 }
 
-static void pdc_sata_scr_write (struct ata_port *ap, unsigned int sc_reg,
-                               u32 val)
+static int pdc_sata_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val)
 {
         if (sc_reg > SCR_CONTROL)
-                return;
+                return -EINVAL;
         writel(val, ap->ioaddr.scr_addr + (sc_reg * 4));
+        return 0;
 }
 
 static void pdc_atapi_pkt(struct ata_queued_cmd *qc)
@@ -642,8 +643,12 @@ static void pdc_error_intr(struct ata_port *ap, struct ata_queued_cmd *qc,
                            | PDC_PCI_SYS_ERR | PDC1_PCI_PARITY_ERR))
                 ac_err_mask |= AC_ERR_HOST_BUS;
 
-        if (sata_scr_valid(ap))
-                ehi->serror |= pdc_sata_scr_read(ap, SCR_ERROR);
+        if (sata_scr_valid(ap)) {
+                u32 serror;
+
+                pdc_sata_scr_read(ap, SCR_ERROR, &serror);
+                ehi->serror |= serror;
+        }
 
         qc->err_mask |= ac_err_mask;
 
diff --git a/drivers/ata/sata_qstor.c b/drivers/ata/sata_qstor.c
index 9ab554da89bf..c8f9242e7f44 100644
--- a/drivers/ata/sata_qstor.c
+++ b/drivers/ata/sata_qstor.c
@@ -111,8 +111,8 @@ struct qs_port_priv {
         qs_state_t              state;
 };
 
-static u32 qs_scr_read (struct ata_port *ap, unsigned int sc_reg);
-static void qs_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
+static int qs_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val);
+static int qs_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val);
 static int qs_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
 static int qs_port_start(struct ata_port *ap);
 static void qs_host_stop(struct ata_host *host);
@@ -255,18 +255,20 @@ static void qs_eng_timeout(struct ata_port *ap)
         ata_eng_timeout(ap);
 }
 
-static u32 qs_scr_read (struct ata_port *ap, unsigned int sc_reg)
+static int qs_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val)
 {
         if (sc_reg > SCR_CONTROL)
-                return ~0U;
-        return readl(ap->ioaddr.scr_addr + (sc_reg * 8));
+                return -EINVAL;
+        *val = readl(ap->ioaddr.scr_addr + (sc_reg * 8));
+        return 0;
 }
 
-static void qs_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
+static int qs_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val)
 {
         if (sc_reg > SCR_CONTROL)
-                return;
+                return -EINVAL;
         writel(val, ap->ioaddr.scr_addr + (sc_reg * 8));
+        return 0;
 }
 
 static unsigned int qs_fill_sg(struct ata_queued_cmd *qc)
@@ -337,7 +339,7 @@ static void qs_qc_prep(struct ata_queued_cmd *qc)
         buf[28] = dflags;
 
         /* frame information structure (FIS) */
-        ata_tf_to_fis(&qc->tf, &buf[32], 0);
+        ata_tf_to_fis(&qc->tf, 0, 1, &buf[32]);
 }
 
 static inline void qs_packet_start(struct ata_queued_cmd *qc)
diff --git a/drivers/ata/sata_sil.c b/drivers/ata/sata_sil.c
index 2a86dc4598d0..db6763758952 100644
--- a/drivers/ata/sata_sil.c
+++ b/drivers/ata/sata_sil.c
@@ -115,8 +115,8 @@ static int sil_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
 static int sil_pci_device_resume(struct pci_dev *pdev);
 #endif
 static void sil_dev_config(struct ata_device *dev);
-static u32 sil_scr_read (struct ata_port *ap, unsigned int sc_reg);
-static void sil_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
+static int sil_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val);
+static int sil_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val);
 static int sil_set_mode (struct ata_port *ap, struct ata_device **r_failed);
 static void sil_freeze(struct ata_port *ap);
 static void sil_thaw(struct ata_port *ap);
@@ -350,19 +350,26 @@ static inline void __iomem *sil_scr_addr(struct ata_port *ap, unsigned int sc_re
         return NULL;
 }
 
-static u32 sil_scr_read (struct ata_port *ap, unsigned int sc_reg)
+static int sil_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val)
 {
         void __iomem *mmio = sil_scr_addr(ap, sc_reg);
-        if (mmio)
-                return readl(mmio);
-        return 0xffffffffU;
+
+        if (mmio) {
+                *val = readl(mmio);
+                return 0;
+        }
+        return -EINVAL;
 }
 
-static void sil_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
+static int sil_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val)
 {
         void __iomem *mmio = sil_scr_addr(ap, sc_reg);
-        if (mmio)
+
+        if (mmio) {
                 writel(val, mmio);
+                return 0;
+        }
+        return -EINVAL;
 }
 
 static void sil_host_intr(struct ata_port *ap, u32 bmdma2)
@@ -378,7 +385,7 @@ static void sil_host_intr(struct ata_port *ap, u32 bmdma2)
                  * controllers continue to assert IRQ as long as
                  * SError bits are pending.  Clear SError immediately.
                  */
-                serror = sil_scr_read(ap, SCR_ERROR);
+                sil_scr_read(ap, SCR_ERROR, &serror);
                 sil_scr_write(ap, SCR_ERROR, serror);
 
                 /* Trigger hotplug and accumulate SError only if the
diff --git a/drivers/ata/sata_sil24.c b/drivers/ata/sata_sil24.c
index ac43a30ebe29..46fbbe7f121c 100644
--- a/drivers/ata/sata_sil24.c
+++ b/drivers/ata/sata_sil24.c
@@ -326,8 +326,8 @@ struct sil24_port_priv {
 
 static void sil24_dev_config(struct ata_device *dev);
 static u8 sil24_check_status(struct ata_port *ap);
-static u32 sil24_scr_read(struct ata_port *ap, unsigned sc_reg);
-static void sil24_scr_write(struct ata_port *ap, unsigned sc_reg, u32 val);
+static int sil24_scr_read(struct ata_port *ap, unsigned sc_reg, u32 *val);
+static int sil24_scr_write(struct ata_port *ap, unsigned sc_reg, u32 val);
 static void sil24_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
 static void sil24_qc_prep(struct ata_queued_cmd *qc);
 static unsigned int sil24_qc_issue(struct ata_queued_cmd *qc);
@@ -464,15 +464,15 @@ static void sil24_dev_config(struct ata_device *dev)
                 writel(PORT_CS_CDB16, port + PORT_CTRL_CLR);
 }
 
-static inline void sil24_update_tf(struct ata_port *ap)
+static void sil24_read_tf(struct ata_port *ap, int tag, struct ata_taskfile *tf)
 {
-        struct sil24_port_priv *pp = ap->private_data;
         void __iomem *port = ap->ioaddr.cmd_addr;
-        struct sil24_prb __iomem *prb = port;
+        struct sil24_prb __iomem *prb;
         u8 fis[6 * 4];
 
-        memcpy_fromio(fis, prb->fis, 6 * 4);
-        ata_tf_from_fis(fis, &pp->tf);
+        prb = port + PORT_LRAM + sil24_tag(tag) * PORT_LRAM_SLOT_SZ;
+        memcpy_fromio(fis, prb->fis, sizeof(fis));
+        ata_tf_from_fis(fis, tf);
 }
 
 static u8 sil24_check_status(struct ata_port *ap)
@@ -488,25 +488,30 @@ static int sil24_scr_map[] = {
         [SCR_ACTIVE]    = 3,
 };
 
-static u32 sil24_scr_read(struct ata_port *ap, unsigned sc_reg)
+static int sil24_scr_read(struct ata_port *ap, unsigned sc_reg, u32 *val)
 {
         void __iomem *scr_addr = ap->ioaddr.scr_addr;
+
         if (sc_reg < ARRAY_SIZE(sil24_scr_map)) {
                 void __iomem *addr;
                 addr = scr_addr + sil24_scr_map[sc_reg] * 4;
-                return readl(scr_addr + sil24_scr_map[sc_reg] * 4);
+                *val = readl(scr_addr + sil24_scr_map[sc_reg] * 4);
+                return 0;
         }
-        return 0xffffffffU;
+        return -EINVAL;
 }
 
-static void sil24_scr_write(struct ata_port *ap, unsigned sc_reg, u32 val)
+static int sil24_scr_write(struct ata_port *ap, unsigned sc_reg, u32 val)
 {
         void __iomem *scr_addr = ap->ioaddr.scr_addr;
+
         if (sc_reg < ARRAY_SIZE(sil24_scr_map)) {
                 void __iomem *addr;
                 addr = scr_addr + sil24_scr_map[sc_reg] * 4;
                 writel(val, scr_addr + sil24_scr_map[sc_reg] * 4);
+                return 0;
         }
+        return -EINVAL;
 }
 
 static void sil24_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
@@ -531,15 +536,60 @@ static int sil24_init_port(struct ata_port *ap)
         return 0;
 }
 
-static int sil24_softreset(struct ata_port *ap, unsigned int *class,
-                           unsigned long deadline)
+static int sil24_exec_polled_cmd(struct ata_port *ap, int pmp,
+                                 const struct ata_taskfile *tf,
+                                 int is_cmd, u32 ctrl,
+                                 unsigned long timeout_msec)
 {
         void __iomem *port = ap->ioaddr.cmd_addr;
         struct sil24_port_priv *pp = ap->private_data;
         struct sil24_prb *prb = &pp->cmd_block[0].ata.prb;
         dma_addr_t paddr = pp->cmd_block_dma;
-        u32 mask, irq_stat;
+        u32 irq_enabled, irq_mask, irq_stat;
+        int rc;
+
+        prb->ctrl = cpu_to_le16(ctrl);
+        ata_tf_to_fis(tf, pmp, is_cmd, prb->fis);
+
+        /* temporarily plug completion and error interrupts */
+        irq_enabled = readl(port + PORT_IRQ_ENABLE_SET);
+        writel(PORT_IRQ_COMPLETE | PORT_IRQ_ERROR, port + PORT_IRQ_ENABLE_CLR);
+
+        writel((u32)paddr, port + PORT_CMD_ACTIVATE);
+        writel((u64)paddr >> 32, port + PORT_CMD_ACTIVATE + 4);
+
+        irq_mask = (PORT_IRQ_COMPLETE | PORT_IRQ_ERROR) << PORT_IRQ_RAW_SHIFT;
+        irq_stat = ata_wait_register(port + PORT_IRQ_STAT, irq_mask, 0x0,
+                                     10, timeout_msec);
+
+        writel(irq_mask, port + PORT_IRQ_STAT); /* clear IRQs */
+        irq_stat >>= PORT_IRQ_RAW_SHIFT;
+
+        if (irq_stat & PORT_IRQ_COMPLETE)
+                rc = 0;
+        else {
+                /* force port into known state */
+                sil24_init_port(ap);
+
+                if (irq_stat & PORT_IRQ_ERROR)
+                        rc = -EIO;
+                else
+                        rc = -EBUSY;
+        }
+
+        /* restore IRQ enabled */
+        writel(irq_enabled, port + PORT_IRQ_ENABLE_SET);
+
+        return rc;
+}
+
+static int sil24_do_softreset(struct ata_port *ap, unsigned int *class,
+                              int pmp, unsigned long deadline)
+{
+        unsigned long timeout_msec = 0;
+        struct ata_taskfile tf;
         const char *reason;
+        int rc;
 
         DPRINTK("ENTER\n");
 
@@ -556,29 +606,22 @@ static int sil24_softreset(struct ata_port *ap, unsigned int *class,
         }
 
         /* do SRST */
-        prb->ctrl = cpu_to_le16(PRB_CTRL_SRST);
-        prb->fis[1] = 0; /* no PMP yet */
-
-        writel((u32)paddr, port + PORT_CMD_ACTIVATE);
-        writel((u64)paddr >> 32, port + PORT_CMD_ACTIVATE + 4);
-
-        mask = (PORT_IRQ_COMPLETE | PORT_IRQ_ERROR) << PORT_IRQ_RAW_SHIFT;
-        irq_stat = ata_wait_register(port + PORT_IRQ_STAT, mask, 0x0,
-                                     100, jiffies_to_msecs(deadline - jiffies));
-
-        writel(irq_stat, port + PORT_IRQ_STAT); /* clear IRQs */
-        irq_stat >>= PORT_IRQ_RAW_SHIFT;
-
-        if (!(irq_stat & PORT_IRQ_COMPLETE)) {
-                if (irq_stat & PORT_IRQ_ERROR)
-                        reason = "SRST command error";
-                else
-                        reason = "timeout";
+        if (time_after(deadline, jiffies))
+                timeout_msec = jiffies_to_msecs(deadline - jiffies);
+
+        ata_tf_init(ap->device, &tf);   /* doesn't really matter */
+        rc = sil24_exec_polled_cmd(ap, pmp, &tf, 0, PRB_CTRL_SRST,
+                                   timeout_msec);
+        if (rc == -EBUSY) {
+                reason = "timeout";
+                goto err;
+        } else if (rc) {
+                reason = "SRST command error";
                 goto err;
         }
 
-        sil24_update_tf(ap);
-        *class = ata_dev_classify(&pp->tf);
+        sil24_read_tf(ap, 0, &tf);
+        *class = ata_dev_classify(&tf);
 
         if (*class == ATA_DEV_UNKNOWN)
                 *class = ATA_DEV_NONE;
@@ -592,6 +635,12 @@ static int sil24_softreset(struct ata_port *ap, unsigned int *class,
         return -EIO;
 }
 
+static int sil24_softreset(struct ata_port *ap, unsigned int *class,
+                           unsigned long deadline)
+{
+        return sil24_do_softreset(ap, class, 0, deadline);
+}
+
 static int sil24_hardreset(struct ata_port *ap, unsigned int *class,
                            unsigned long deadline)
 {
@@ -699,7 +748,7 @@ static void sil24_qc_prep(struct ata_queued_cmd *qc)
         }
 
         prb->ctrl = cpu_to_le16(ctrl);
-        ata_tf_to_fis(&qc->tf, prb->fis, 0);
+        ata_tf_to_fis(&qc->tf, 0, 1, prb->fis);
 
         if (qc->flags & ATA_QCFLAG_DMAMAP)
                 sil24_fill_sg(qc, sge);
@@ -754,6 +803,7 @@ static void sil24_thaw(struct ata_port *ap)
 static void sil24_error_intr(struct ata_port *ap)
 {
         void __iomem *port = ap->ioaddr.cmd_addr;
+        struct sil24_port_priv *pp = ap->private_data;
         struct ata_eh_info *ehi = &ap->eh_info;
         int freeze = 0;
         u32 irq_stat;
@@ -769,16 +819,16 @@ static void sil24_error_intr(struct ata_port *ap)
 
         if (irq_stat & (PORT_IRQ_PHYRDY_CHG | PORT_IRQ_DEV_XCHG)) {
                 ata_ehi_hotplugged(ehi);
-                ata_ehi_push_desc(ehi, ", %s",
-                               irq_stat & PORT_IRQ_PHYRDY_CHG ?
-                               "PHY RDY changed" : "device exchanged");
+                ata_ehi_push_desc(ehi, "%s",
+                                  irq_stat & PORT_IRQ_PHYRDY_CHG ?
+                                  "PHY RDY changed" : "device exchanged");
                 freeze = 1;
         }
 
         if (irq_stat & PORT_IRQ_UNK_FIS) {
                 ehi->err_mask |= AC_ERR_HSM;
                 ehi->action |= ATA_EH_SOFTRESET;
-                ata_ehi_push_desc(ehi , ", unknown FIS");
+                ata_ehi_push_desc(ehi, "unknown FIS");
                 freeze = 1;
         }
 
@@ -797,18 +847,18 @@ static void sil24_error_intr(struct ata_port *ap)
                 if (ci && ci->desc) {
                         err_mask |= ci->err_mask;
                         action |= ci->action;
-                        ata_ehi_push_desc(ehi, ", %s", ci->desc);
+                        ata_ehi_push_desc(ehi, "%s", ci->desc);
                 } else {
                         err_mask |= AC_ERR_OTHER;
                         action |= ATA_EH_SOFTRESET;
-                        ata_ehi_push_desc(ehi, ", unknown command error %d",
+                        ata_ehi_push_desc(ehi, "unknown command error %d",
                                           cerr);
                 }
 
                 /* record error info */
                 qc = ata_qc_from_tag(ap, ap->active_tag);
                 if (qc) {
-                        sil24_update_tf(ap);
+                        sil24_read_tf(ap, qc->tag, &pp->tf);
                         qc->err_mask |= err_mask;
                 } else
                         ehi->err_mask |= err_mask;
@@ -825,8 +875,11 @@ static void sil24_error_intr(struct ata_port *ap)
 
 static void sil24_finish_qc(struct ata_queued_cmd *qc)
 {
+        struct ata_port *ap = qc->ap;
+        struct sil24_port_priv *pp = ap->private_data;
+
         if (qc->flags & ATA_QCFLAG_RESULT_TF)
-                sil24_update_tf(qc->ap);
+                sil24_read_tf(ap, qc->tag, &pp->tf);
 }
 
 static inline void sil24_host_intr(struct ata_port *ap)
diff --git a/drivers/ata/sata_sis.c b/drivers/ata/sata_sis.c
index 33716b00c6b7..31a2f55aae66 100644
--- a/drivers/ata/sata_sis.c
+++ b/drivers/ata/sata_sis.c
@@ -64,8 +64,8 @@ enum {
 };
 
 static int sis_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
-static u32 sis_scr_read (struct ata_port *ap, unsigned int sc_reg);
-static void sis_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
+static int sis_scr_read (struct ata_port *ap, unsigned int sc_reg, u32 *val);
+static int sis_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
 
 static const struct pci_device_id sis_pci_tbl[] = {
         { PCI_VDEVICE(SI, 0x0180), sis_180 },           /* SiS 964/180 */
@@ -207,36 +207,37 @@ static void sis_scr_cfg_write (struct ata_port *ap, unsigned int sc_reg, u32 val
                 pci_write_config_dword(pdev, cfg_addr+0x10, val);
 }
 
-static u32 sis_scr_read (struct ata_port *ap, unsigned int sc_reg)
+static int sis_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val)
 {
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
-        u32 val, val2 = 0;
         u8 pmr;
 
         if (sc_reg > SCR_CONTROL)
-                return 0xffffffffU;
+                return -EINVAL;
 
         if (ap->flags & SIS_FLAG_CFGSCR)
                 return sis_scr_cfg_read(ap, sc_reg);
 
         pci_read_config_byte(pdev, SIS_PMR, &pmr);
 
-        val = ioread32(ap->ioaddr.scr_addr + (sc_reg * 4));
+        *val = ioread32(ap->ioaddr.scr_addr + (sc_reg * 4));
 
         if ((pdev->device == 0x0182) || (pdev->device == 0x0183) ||
             (pdev->device == 0x1182) || (pmr & SIS_PMR_COMBINED))
-                val2 = ioread32(ap->ioaddr.scr_addr + (sc_reg * 4) + 0x10);
+                *val |= ioread32(ap->ioaddr.scr_addr + (sc_reg * 4) + 0x10);
+
+        *val &= 0xfffffffb;
 
-        return (val | val2) &  0xfffffffb;
+        return 0;
 }
 
-static void sis_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
+static int sis_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val)
 {
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
         u8 pmr;
 
         if (sc_reg > SCR_CONTROL)
-                return;
+                return -EINVAL;
 
         pci_read_config_byte(pdev, SIS_PMR, &pmr);
 
@@ -248,6 +249,7 @@ static void sis_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
                     (pdev->device == 0x1182) || (pmr & SIS_PMR_COMBINED))
                         iowrite32(val, ap->ioaddr.scr_addr + (sc_reg * 4)+0x10);
         }
+        return 0;
 }
 
 static int sis_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
diff --git a/drivers/ata/sata_svw.c b/drivers/ata/sata_svw.c
index 63fe99afd59f..92e877075037 100644
--- a/drivers/ata/sata_svw.c
+++ b/drivers/ata/sata_svw.c
@@ -103,20 +103,21 @@ static int k2_sata_check_atapi_dma(struct ata_queued_cmd *qc)
         return 0;
 }
 
-static u32 k2_sata_scr_read (struct ata_port *ap, unsigned int sc_reg)
+static int k2_sata_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val)
 {
         if (sc_reg > SCR_CONTROL)
-                return 0xffffffffU;
-        return readl(ap->ioaddr.scr_addr + (sc_reg * 4));
+                return -EINVAL;
+        *val = readl(ap->ioaddr.scr_addr + (sc_reg * 4));
+        return 0;
 }
 
 
-static void k2_sata_scr_write (struct ata_port *ap, unsigned int sc_reg,
-                               u32 val)
+static int k2_sata_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val)
 {
         if (sc_reg > SCR_CONTROL)
-                return;
+                return -EINVAL;
         writel(val, ap->ioaddr.scr_addr + (sc_reg * 4));
+        return 0;
 }
 
 
diff --git a/drivers/ata/sata_uli.c b/drivers/ata/sata_uli.c
index b52f83ab056a..78c28512f01c 100644
--- a/drivers/ata/sata_uli.c
+++ b/drivers/ata/sata_uli.c
@@ -57,8 +57,8 @@ struct uli_priv {
 };
 
 static int uli_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
-static u32 uli_scr_read (struct ata_port *ap, unsigned int sc_reg);
-static void uli_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
+static int uli_scr_read (struct ata_port *ap, unsigned int sc_reg, u32 *val);
+static int uli_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
 
 static const struct pci_device_id uli_pci_tbl[] = {
         { PCI_VDEVICE(AL, 0x5289), uli_5289 },
@@ -164,20 +164,22 @@ static void uli_scr_cfg_write (struct ata_port *ap, unsigned int scr, u32 val)
         pci_write_config_dword(pdev, cfg_addr, val);
 }
 
-static u32 uli_scr_read (struct ata_port *ap, unsigned int sc_reg)
+static int uli_scr_read (struct ata_port *ap, unsigned int sc_reg, u32 *val)
 {
         if (sc_reg > SCR_CONTROL)
-                return 0xffffffffU;
+                return -EINVAL;
 
-        return uli_scr_cfg_read(ap, sc_reg);
+        *val = uli_scr_cfg_read(ap, sc_reg);
+        return 0;
 }
 
-static void uli_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
+static int uli_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
 {
         if (sc_reg > SCR_CONTROL)       //SCR_CONTROL=2, SCR_ERROR=1, SCR_STATUS=0
-                return;
+                return -EINVAL;
 
         uli_scr_cfg_write(ap, sc_reg, val);
+        return 0;
 }
 
 static int uli_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
diff --git a/drivers/ata/sata_via.c b/drivers/ata/sata_via.c
index c4124475f754..86b7bfc17324 100644
--- a/drivers/ata/sata_via.c
+++ b/drivers/ata/sata_via.c
@@ -72,8 +72,8 @@ enum {
 };
 
 static int svia_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
-static u32 svia_scr_read (struct ata_port *ap, unsigned int sc_reg);
-static void svia_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
+static int svia_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val);
+static int svia_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val);
 static void svia_noop_freeze(struct ata_port *ap);
 static void vt6420_error_handler(struct ata_port *ap);
 static int vt6421_pata_cable_detect(struct ata_port *ap);
@@ -249,18 +249,20 @@ MODULE_LICENSE("GPL");
 MODULE_DEVICE_TABLE(pci, svia_pci_tbl);
 MODULE_VERSION(DRV_VERSION);
 
-static u32 svia_scr_read (struct ata_port *ap, unsigned int sc_reg)
+static int svia_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val)
 {
         if (sc_reg > SCR_CONTROL)
-                return 0xffffffffU;
-        return ioread32(ap->ioaddr.scr_addr + (4 * sc_reg));
+                return -EINVAL;
+        *val = ioread32(ap->ioaddr.scr_addr + (4 * sc_reg));
+        return 0;
 }
 
-static void svia_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
+static int svia_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val)
 {
         if (sc_reg > SCR_CONTROL)
-                return;
+                return -EINVAL;
         iowrite32(val, ap->ioaddr.scr_addr + (4 * sc_reg));
+        return 0;
 }
 
 static void svia_noop_freeze(struct ata_port *ap)
@@ -305,18 +307,19 @@ static int vt6420_prereset(struct ata_port *ap, unsigned long deadline)
 
         /* Resume phy.  This is the old SATA resume sequence */
         svia_scr_write(ap, SCR_CONTROL, 0x300);
-        svia_scr_read(ap, SCR_CONTROL); /* flush */
+        svia_scr_read(ap, SCR_CONTROL, &scontrol); /* flush */
 
         /* wait for phy to become ready, if necessary */
         do {
                 msleep(200);
-                if ((svia_scr_read(ap, SCR_STATUS) & 0xf) != 1)
+                svia_scr_read(ap, SCR_STATUS, &sstatus);
+                if ((sstatus & 0xf) != 1)
                         break;
         } while (time_before(jiffies, timeout));
 
         /* open code sata_print_link_status() */
-        sstatus = svia_scr_read(ap, SCR_STATUS);
-        scontrol = svia_scr_read(ap, SCR_CONTROL);
+        svia_scr_read(ap, SCR_STATUS, &sstatus);
+        svia_scr_read(ap, SCR_CONTROL, &scontrol);
 
         online = (sstatus & 0xf) == 0x3;
 
@@ -325,7 +328,7 @@ static int vt6420_prereset(struct ata_port *ap, unsigned long deadline)
                         online ? "up" : "down", sstatus, scontrol);
 
         /* SStatus is read one more time */
-        svia_scr_read(ap, SCR_STATUS);
+        svia_scr_read(ap, SCR_STATUS, &sstatus);
 
         if (!online) {
                 /* tell EH to bail */
diff --git a/drivers/ata/sata_vsc.c b/drivers/ata/sata_vsc.c
index 1b5d81faa102..24344d0d0575 100644
--- a/drivers/ata/sata_vsc.c
+++ b/drivers/ata/sata_vsc.c
@@ -98,20 +98,21 @@ enum {
                               VSC_SATA_INT_PHY_CHANGE),
 };
 
-static u32 vsc_sata_scr_read (struct ata_port *ap, unsigned int sc_reg)
+static int vsc_sata_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val)
 {
         if (sc_reg > SCR_CONTROL)
-                return 0xffffffffU;
-        return readl(ap->ioaddr.scr_addr + (sc_reg * 4));
+                return -EINVAL;
+        *val = readl(ap->ioaddr.scr_addr + (sc_reg * 4));
+        return 0;
 }
 
 
-static void vsc_sata_scr_write (struct ata_port *ap, unsigned int sc_reg,
-                               u32 val)
+static int vsc_sata_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val)
 {
         if (sc_reg > SCR_CONTROL)
-                return;
+                return -EINVAL;
         writel(val, ap->ioaddr.scr_addr + (sc_reg * 4));
+        return 0;
 }
 
 
diff --git a/drivers/block/aoe/aoeblk.c b/drivers/block/aoe/aoeblk.c
index 478489c568a4..4f598270fa31 100644
--- a/drivers/block/aoe/aoeblk.c
+++ b/drivers/block/aoe/aoeblk.c
@@ -257,9 +257,9 @@ aoeblk_exit(void)
 int __init
 aoeblk_init(void)
 {
-        buf_pool_cache = kmem_cache_create("aoe_bufs", 
+        buf_pool_cache = kmem_cache_create("aoe_bufs",
                                            sizeof(struct buf),
-                                           0, 0, NULL, NULL);
+                                           0, 0, NULL);
         if (buf_pool_cache == NULL)
                 return -ENOMEM;
 
diff --git a/drivers/block/sunvdc.c b/drivers/block/sunvdc.c
index 2288b55d916f..d50b82381155 100644
--- a/drivers/block/sunvdc.c
+++ b/drivers/block/sunvdc.c
@@ -64,7 +64,6 @@ struct vdc_port {
         u64                     operations;
         u32                     vdisk_size;
         u8                      vdisk_type;
-        u8                      dev_no;
 
         char                    disk_name[32];
 
@@ -703,7 +702,7 @@ static int probe_disk(struct vdc_port *port)
         blk_queue_max_phys_segments(q, port->ring_cookies);
         blk_queue_max_sectors(q, port->max_xfer_size);
         g->major = vdc_major;
-        g->first_minor = port->dev_no << PARTITION_SHIFT;
+        g->first_minor = port->vio.vdev->dev_no << PARTITION_SHIFT;
         strcpy(g->disk_name, port->disk_name);
 
         g->fops = &vdc_fops;
@@ -747,21 +746,16 @@ static int __devinit vdc_port_probe(struct vio_dev *vdev,
 {
         struct mdesc_handle *hp;
         struct vdc_port *port;
-        const u64 *port_id;
         int err;
 
         print_version();
 
         hp = mdesc_grab();
 
-        port_id = mdesc_get_property(hp, vdev->mp, "id", NULL);
         err = -ENODEV;
-        if (!port_id) {
-                printk(KERN_ERR PFX "Port lacks id property.\n");
-                goto err_out_release_mdesc;
-        }
-        if ((*port_id << PARTITION_SHIFT) & ~(u64)MINORMASK) {
-                printk(KERN_ERR PFX "Port id [%lu] too large.\n", *port_id);
+        if ((vdev->dev_no << PARTITION_SHIFT) & ~(u64)MINORMASK) {
+                printk(KERN_ERR PFX "Port id [%lu] too large.\n",
+                       vdev->dev_no);
                 goto err_out_release_mdesc;
         }
 
@@ -772,16 +766,14 @@ static int __devinit vdc_port_probe(struct vio_dev *vdev,
                 goto err_out_release_mdesc;
         }
 
-        port->dev_no = *port_id;
-
-        if (port->dev_no >= 26)
+        if (vdev->dev_no >= 26)
                 snprintf(port->disk_name, sizeof(port->disk_name),
                          VDCBLK_NAME "%c%c",
-                         'a' + (port->dev_no / 26) - 1,
-                         'a' + (port->dev_no % 26));
+                         'a' + ((int)vdev->dev_no / 26) - 1,
+                         'a' + ((int)vdev->dev_no % 26));
         else
                 snprintf(port->disk_name, sizeof(port->disk_name),
-                         VDCBLK_NAME "%c", 'a' + (port->dev_no % 26));
+                         VDCBLK_NAME "%c", 'a' + ((int)vdev->dev_no % 26));
 
         err = vio_driver_init(&port->vio, vdev, VDEV_DISK,
                               vdc_versions, ARRAY_SIZE(vdc_versions),
@@ -849,7 +841,7 @@ static struct vio_device_id vdc_port_match[] = {
         },
         {},
 };
-MODULE_DEVICE_TABLE(vio, vdc_match);
+MODULE_DEVICE_TABLE(vio, vdc_port_match);
 
 static struct vio_driver vdc_port_driver = {
         .id_table       = vdc_port_match,
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 9e8f21410d2d..4373d7cdc5d2 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -185,7 +185,7 @@ config ESPSERIAL
 
 config MOXA_INTELLIO
         tristate "Moxa Intellio support"
-        depends on SERIAL_NONSTANDARD
+        depends on SERIAL_NONSTANDARD && (ISA || EISA || PCI)
         help
           Say Y here if you have a Moxa Intellio multiport serial card.
 
@@ -241,7 +241,7 @@ config SYNCLINK
 
 config SYNCLINKMP
         tristate "SyncLink Multiport support"
-        depends on SERIAL_NONSTANDARD
+        depends on SERIAL_NONSTANDARD && PCI
         help
           Enable support for the SyncLink Multiport (2 or 4 ports)
           serial adapter, running asynchronous and HDLC communications up
diff --git a/drivers/char/random.c b/drivers/char/random.c
index 7f5271272f91..397c714cf2ba 100644
--- a/drivers/char/random.c
+++ b/drivers/char/random.c
@@ -693,9 +693,14 @@ static void xfer_secondary_pool(struct entropy_store *r, size_t nbytes)
 
         if (r->pull && r->entropy_count < nbytes * 8 &&
             r->entropy_count < r->poolinfo->POOLBITS) {
-                int bytes = max_t(int, random_read_wakeup_thresh / 8,
-                                min_t(int, nbytes, sizeof(tmp)));
+                /* If we're limited, always leave two wakeup worth's BITS */
                 int rsvd = r->limit ? 0 : random_read_wakeup_thresh/4;
+                int bytes = nbytes;
+
+                /* pull at least as many as BYTES as wakeup BITS */
+                bytes = max_t(int, bytes, random_read_wakeup_thresh / 8);
+                /* but never more than the buffer size */
+                bytes = min_t(int, bytes, sizeof(tmp));
 
                 DEBUG_ENT("going to reseed %s with %d bits "
                           "(%d of %d requested)\n",
diff --git a/drivers/char/serial167.c b/drivers/char/serial167.c
index c585b4738f86..f1497cecffd8 100644
--- a/drivers/char/serial167.c
+++ b/drivers/char/serial167.c
@@ -2573,16 +2573,10 @@ static struct tty_driver *serial167_console_device(struct console *c,
         return cy_serial_driver;
 }
 
-static int __init serial167_console_setup(struct console *co, char *options)
-{
-        return 0;
-}
-
 static struct console sercons = {
         .name = "ttyS",
         .write = serial167_console_write,
         .device = serial167_console_device,
-        .setup = serial167_console_setup,
         .flags = CON_PRINTBUFFER,
         .index = -1,
 };
diff --git a/drivers/char/tpm/tpm_bios.c b/drivers/char/tpm/tpm_bios.c
index 4eba32b23b29..8677fc6a545e 100644
--- a/drivers/char/tpm/tpm_bios.c
+++ b/drivers/char/tpm/tpm_bios.c
@@ -427,7 +427,7 @@ static int tpm_ascii_bios_measurements_open(struct inode *inode,
                 return -ENOMEM;
 
         if ((err = read_log(log)))
-                return err;
+                goto out_free;
 
         /* now register seq file */
         err = seq_open(file, &tpm_ascii_b_measurments_seqops);
@@ -435,10 +435,15 @@ static int tpm_ascii_bios_measurements_open(struct inode *inode,
                 seq = file->private_data;
                 seq->private = log;
         } else {
-                kfree(log->bios_event_log);
-                kfree(log);
+                goto out_free;
         }
+
+out:
         return err;
+out_free:
+        kfree(log->bios_event_log);
+        kfree(log);
+        goto out;
 }
 
 const struct file_operations tpm_ascii_bios_measurements_ops = {
@@ -460,7 +465,7 @@ static int tpm_binary_bios_measurements_open(struct inode *inode,
                 return -ENOMEM;
 
         if ((err = read_log(log)))
-                return err;
+                goto out_free;
 
         /* now register seq file */
         err = seq_open(file, &tpm_binary_b_measurments_seqops);
@@ -468,10 +473,15 @@ static int tpm_binary_bios_measurements_open(struct inode *inode,
                 seq = file->private_data;
                 seq->private = log;
         } else {
-                kfree(log->bios_event_log);
-                kfree(log);
+                goto out_free;
         }
+
+out:
         return err;
+out_free:
+        kfree(log->bios_event_log);
+        kfree(log);
+        goto out;
 }
 
 const struct file_operations tpm_binary_bios_measurements_ops = {
diff --git a/drivers/char/vme_scc.c b/drivers/char/vme_scc.c
index bef6d886d4fb..e122a0e87bb0 100644
--- a/drivers/char/vme_scc.c
+++ b/drivers/char/vme_scc.c
@@ -1013,18 +1013,10 @@ static struct tty_driver *scc_console_device(struct console *c, int *index)
         return scc_driver;
 }
 
-
-static int __init scc_console_setup(struct console *co, char *options)
-{
-        return 0;
-}
-
-
 static struct console sercons = {
         .name           = "ttyS",
         .write          = scc_console_write,
         .device         = scc_console_device,
-        .setup          = scc_console_setup,
         .flags          = CON_PRINTBUFFER,
         .index          = -1,
 };
diff --git a/drivers/char/watchdog/Kconfig b/drivers/char/watchdog/Kconfig
index 2f48ba329961..ad5cc5f6862f 100644
--- a/drivers/char/watchdog/Kconfig
+++ b/drivers/char/watchdog/Kconfig
@@ -602,7 +602,7 @@ config ZVM_WATCHDOG
 
 config SH_WDT
         tristate "SuperH Watchdog"
-        depends on SUPERH
+        depends on SUPERH && (CPU_SH3 || CPU_SH4)
         help
           This driver adds watchdog support for the integrated watchdog in the
           SuperH processors. If you have one of these processors and wish
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index 13eea47dceb3..dbdca6f10e46 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -29,17 +29,34 @@ config HWMON_VID
         default n
 
 config SENSORS_ABITUGURU
-        tristate "Abit uGuru"
+        tristate "Abit uGuru (rev 1 & 2)"
         depends on EXPERIMENTAL
         help
-          If you say yes here you get support for the Abit uGuru chips
-          sensor part. The voltage and frequency control parts of the Abit
-          uGuru are not supported. The Abit uGuru chip can be found on Abit
-          uGuru featuring motherboards (most modern Abit motherboards).
+          If you say yes here you get support for the sensor part of the first
+          and second revision of the Abit uGuru chip. The voltage and frequency
+          control parts of the Abit uGuru are not supported. The Abit uGuru
+          chip can be found on Abit uGuru featuring motherboards (most modern
+          Abit motherboards from before end 2005). For more info and a list
+          of which motherboards have which revision see
+          Documentation/hwmon/abituguru
 
           This driver can also be built as a module.  If so, the module
           will be called abituguru.
 
+config SENSORS_ABITUGURU3
+        tristate "Abit uGuru (rev 3)"
+        depends on HWMON && EXPERIMENTAL
+        help
+          If you say yes here you get support for the sensor part of the
+          third revision of the Abit uGuru chip. Only reading the sensors
+          and their settings is supported. The third revision of the Abit
+          uGuru chip can be found on recent Abit motherboards (since end
+          2005). For more info and a list of which motherboards have which
+          revision see Documentation/hwmon/abituguru3
+
+          This driver can also be built as a module.  If so, the module
+          will be called abituguru3.
+
 config SENSORS_AD7418
         tristate "Analog Devices AD7416, AD7417 and AD7418"
         depends on I2C && EXPERIMENTAL
@@ -250,12 +267,10 @@ config SENSORS_CORETEMP
 
 config SENSORS_IT87
         tristate "ITE IT87xx and compatibles"
-        depends on I2C
-        select I2C_ISA
         select HWMON_VID
         help
           If you say yes here you get support for ITE IT8705F, IT8712F,
-          IT8716F and IT8718F sensor chips, and the SiS960 clone.
+          IT8716F, IT8718F and IT8726F sensor chips, and the SiS960 clone.
 
           This driver can also be built as a module.  If so, the module
           will be called it87.
@@ -365,8 +380,8 @@ config SENSORS_LM90
         depends on I2C
         help
           If you say yes here you get support for National Semiconductor LM90,
-          LM86, LM89 and LM99, Analog Devices ADM1032 and Maxim MAX6657 and
-          MAX6658 sensor chips.
+          LM86, LM89 and LM99, Analog Devices ADM1032 and Maxim MAX6657,
+          MAX6658, MAX6659, MAX6680 and MAX6681 sensor chips.
 
           The Analog Devices ADT7461 sensor chip is also supported, but only
           if found in ADM1032 compatibility mode.
@@ -384,6 +399,17 @@ config SENSORS_LM92
           This driver can also be built as a module.  If so, the module
           will be called lm92.
 
+config SENSORS_LM93
+        tristate "National Semiconductor LM93 and compatibles"
+        depends on HWMON && I2C
+        select HWMON_VID
+        help
+          If you say yes here you get support for National Semiconductor LM93
+          sensor chips.
+
+          This driver can also be built as a module.  If so, the module
+          will be called lm93.
+
 config SENSORS_MAX1619
         tristate "Maxim MAX1619 sensor chip"
         depends on I2C
@@ -405,8 +431,6 @@ config SENSORS_MAX6650
 
 config SENSORS_PC87360
         tristate "National Semiconductor PC87360 family"
-        depends on I2C && EXPERIMENTAL
-        select I2C_ISA
         select HWMON_VID
         help
           If you say yes here you get access to the hardware monitoring
@@ -433,8 +457,7 @@ config SENSORS_PC87427
 
 config SENSORS_SIS5595
         tristate "Silicon Integrated Systems Corp. SiS5595"
-        depends on I2C && PCI && EXPERIMENTAL
-        select I2C_ISA
+        depends on PCI
         help
           If you say yes here you get support for the integrated sensors in
           SiS5595 South Bridges.
@@ -442,6 +465,18 @@ config SENSORS_SIS5595
           This driver can also be built as a module.  If so, the module
           will be called sis5595.
 
+config SENSORS_DME1737
+        tristate "SMSC DME1737 and compatibles"
+        depends on I2C && EXPERIMENTAL
+        select HWMON_VID
+        help
+          If you say yes here you get support for the hardware monitoring
+          and fan control features of the SMSC DME1737 (and compatibles
+          like the Asus A8000) Super-I/O chip.
+
+          This driver can also be built as a module.  If so, the module
+          will be called dme1737.
+
 config SENSORS_SMSC47M1
         tristate "SMSC LPC47M10x and compatibles"
         help
@@ -487,8 +522,7 @@ config SENSORS_SMSC47B397
 
 config SENSORS_VIA686A
         tristate "VIA686A"
-        depends on I2C && PCI
-        select I2C_ISA
+        depends on PCI
         help
           If you say yes here you get support for the integrated sensors in
           Via 686A/B South Bridges.
@@ -509,9 +543,8 @@ config SENSORS_VT1211
 
 config SENSORS_VT8231
         tristate "VIA VT8231"
-        depends on I2C && PCI && EXPERIMENTAL
+        depends on PCI
         select HWMON_VID
-        select I2C_ISA
         help
           If you say yes here then you get support for the integrated sensors
           in the VIA VT8231 device.
@@ -584,17 +617,16 @@ config SENSORS_W83627HF
           will be called w83627hf.
 
 config SENSORS_W83627EHF
-        tristate "Winbond W83627EHF"
-        depends on I2C && EXPERIMENTAL
-        select I2C_ISA
+        tristate "Winbond W83627EHF/DHG"
+        select HWMON_VID
         help
-          If you say yes here you get preliminary support for the hardware
+          If you say yes here you get support for the hardware
           monitoring functionality of the Winbond W83627EHF Super-I/O chip.
-          Only fan and temperature inputs are supported at the moment, while
-          the chip does much more than that.
 
           This driver also supports the W83627EHG, which is the lead-free
-          version of the W83627EHF.
+          version of the W83627EHF, and the W83627DHG, which is a similar
+          chip suited for specific Intel processors that use PECI such as
+          the Core 2 Duo.
 
           This driver can also be built as a module.  If so, the module
           will be called w83627ehf.
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index cfaf338919dd..59f81fae40a0 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -14,6 +14,7 @@ obj-$(CONFIG_SENSORS_W83781D)	+= w83781d.o
 obj-$(CONFIG_SENSORS_W83791D)   += w83791d.o
 
 obj-$(CONFIG_SENSORS_ABITUGURU) += abituguru.o
+obj-$(CONFIG_SENSORS_ABITUGURU3)+= abituguru3.o
 obj-$(CONFIG_SENSORS_AD7418)    += ad7418.o
 obj-$(CONFIG_SENSORS_ADM1021)   += adm1021.o
 obj-$(CONFIG_SENSORS_ADM1025)   += adm1025.o
@@ -25,6 +26,7 @@ obj-$(CONFIG_SENSORS_APPLESMC)	+= applesmc.o
 obj-$(CONFIG_SENSORS_AMS)       += ams/
 obj-$(CONFIG_SENSORS_ATXP1)     += atxp1.o
 obj-$(CONFIG_SENSORS_CORETEMP)  += coretemp.o
+obj-$(CONFIG_SENSORS_DME1737)   += dme1737.o
 obj-$(CONFIG_SENSORS_DS1621)    += ds1621.o
 obj-$(CONFIG_SENSORS_F71805F)   += f71805f.o
 obj-$(CONFIG_SENSORS_FSCHER)    += fscher.o
@@ -45,6 +47,7 @@ obj-$(CONFIG_SENSORS_LM85)	+= lm85.o
 obj-$(CONFIG_SENSORS_LM87)      += lm87.o
 obj-$(CONFIG_SENSORS_LM90)      += lm90.o
 obj-$(CONFIG_SENSORS_LM92)      += lm92.o
+obj-$(CONFIG_SENSORS_LM93)      += lm93.o
 obj-$(CONFIG_SENSORS_MAX1619)   += max1619.o
 obj-$(CONFIG_SENSORS_MAX6650)   += max6650.o
 obj-$(CONFIG_SENSORS_PC87360)   += pc87360.o
diff --git a/drivers/hwmon/abituguru.c b/drivers/hwmon/abituguru.c
index bede4d990ea6..d575ee958de5 100644
--- a/drivers/hwmon/abituguru.c
+++ b/drivers/hwmon/abituguru.c
@@ -16,9 +16,9 @@
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 /*
-    This driver supports the sensor part of the custom Abit uGuru chip found
-    on Abit uGuru motherboards. Note: because of lack of specs the CPU / RAM /
-    etc voltage & frequency control is not supported!
+    This driver supports the sensor part of the first and second revision of
+    the custom Abit uGuru chip found on Abit uGuru motherboards. Note: because
+    of lack of specs the CPU/RAM voltage & frequency control is not supported!
 */
 #include <linux/module.h>
 #include <linux/sched.h>
@@ -31,6 +31,7 @@
 #include <linux/platform_device.h>
 #include <linux/hwmon.h>
 #include <linux/hwmon-sysfs.h>
+#include <linux/dmi.h>
 #include <asm/io.h>
 
 /* Banks */
@@ -418,7 +419,7 @@ static int __devinit
 abituguru_detect_bank1_sensor_type(struct abituguru_data *data,
                                    u8 sensor_addr)
 {
-        u8 val, buf[3];
+        u8 val, test_flag, buf[3];
         int i, ret = -ENODEV; /* error is the most common used retval :| */
 
         /* If overriden by the user return the user selected type */
@@ -436,7 +437,7 @@ abituguru_detect_bank1_sensor_type(struct abituguru_data *data,
                 return -ENODEV;
 
         /* Test val is sane / usable for sensor type detection. */
-        if ((val < 10u) || (val > 240u)) {
+        if ((val < 10u) || (val > 250u)) {
                 printk(KERN_WARNING ABIT_UGURU_NAME
                         ": bank1-sensor: %d reading (%d) too close to limits, "
                         "unable to determine sensor type, skipping sensor\n",
@@ -449,10 +450,20 @@ abituguru_detect_bank1_sensor_type(struct abituguru_data *data,
 
         ABIT_UGURU_DEBUG(2, "testing bank1 sensor %d\n", (int)sensor_addr);
         /* Volt sensor test, enable volt low alarm, set min value ridicously
-           high. If its a volt sensor this should always give us an alarm. */
-        buf[0] = ABIT_UGURU_VOLT_LOW_ALARM_ENABLE;
-        buf[1] = 245;
-        buf[2] = 250;
+           high, or vica versa if the reading is very high. If its a volt
+           sensor this should always give us an alarm. */
+        if (val <= 240u) {
+                buf[0] = ABIT_UGURU_VOLT_LOW_ALARM_ENABLE;
+                buf[1] = 245;
+                buf[2] = 250;
+                test_flag = ABIT_UGURU_VOLT_LOW_ALARM_FLAG;
+        } else {
+                buf[0] = ABIT_UGURU_VOLT_HIGH_ALARM_ENABLE;
+                buf[1] = 5;
+                buf[2] = 10;
+                test_flag = ABIT_UGURU_VOLT_HIGH_ALARM_FLAG;
+        }
+
         if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK1 + 2, sensor_addr,
                         buf, 3) != 3)
                 goto abituguru_detect_bank1_sensor_type_exit;
@@ -469,13 +480,13 @@ abituguru_detect_bank1_sensor_type(struct abituguru_data *data,
                                 sensor_addr, buf, 3,
                                 ABIT_UGURU_MAX_RETRIES) != 3)
                         goto abituguru_detect_bank1_sensor_type_exit;
-                if (buf[0] & ABIT_UGURU_VOLT_LOW_ALARM_FLAG) {
+                if (buf[0] & test_flag) {
                         ABIT_UGURU_DEBUG(2, "  found volt sensor\n");
                         ret = ABIT_UGURU_IN_SENSOR;
                         goto abituguru_detect_bank1_sensor_type_exit;
                 } else
                         ABIT_UGURU_DEBUG(2, "  alarm raised during volt "
-                                "sensor test, but volt low flag not set\n");
+                                "sensor test, but volt range flag not set\n");
         } else
                 ABIT_UGURU_DEBUG(2, "  alarm not raised during volt sensor "
                         "test\n");
@@ -1287,6 +1298,7 @@ abituguru_probe_error:
         for (i = 0; i < ARRAY_SIZE(abituguru_sysfs_attr); i++)
                 device_remove_file(&pdev->dev,
                         &abituguru_sysfs_attr[i].dev_attr);
+        platform_set_drvdata(pdev, NULL);
         kfree(data);
         return res;
 }
@@ -1296,13 +1308,13 @@ static int __devexit abituguru_remove(struct platform_device *pdev)
         int i;
         struct abituguru_data *data = platform_get_drvdata(pdev);
 
-        platform_set_drvdata(pdev, NULL);
         hwmon_device_unregister(data->class_dev);
         for (i = 0; data->sysfs_attr[i].dev_attr.attr.name; i++)
                 device_remove_file(&pdev->dev, &data->sysfs_attr[i].dev_attr);
         for (i = 0; i < ARRAY_SIZE(abituguru_sysfs_attr); i++)
                 device_remove_file(&pdev->dev,
                         &abituguru_sysfs_attr[i].dev_attr);
+        platform_set_drvdata(pdev, NULL);
         kfree(data);
 
         return 0;
@@ -1436,6 +1448,15 @@ static int __init abituguru_init(void)
         int address, err;
         struct resource res = { .flags = IORESOURCE_IO };
 
+#ifdef CONFIG_DMI
+        char *board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
+
+        /* safety check, refuse to load on non Abit motherboards */
+        if (!force && (!board_vendor ||
+                        strcmp(board_vendor, "http://www.abit.com.tw/")))
+                return -ENODEV;
+#endif
+
         address = abituguru_detect();
         if (address < 0)
                 return address;
diff --git a/drivers/hwmon/abituguru3.c b/drivers/hwmon/abituguru3.c
new file mode 100644
index 000000000000..a003d104ca45
--- /dev/null
+++ b/drivers/hwmon/abituguru3.c
@@ -0,0 +1,1140 @@
+/*
+    abituguru3.c Copyright (c) 2006 Hans de Goede <j.w.r.degoede@hhs.nl>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+/*
+    This driver supports the sensor part of revision 3 of the custom Abit uGuru
+    chip found on newer Abit uGuru motherboards. Note: because of lack of specs
+    only reading the sensors and their settings is supported.
+*/
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/jiffies.h>
+#include <linux/mutex.h>
+#include <linux/err.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <asm/io.h>
+
+/* uGuru3 bank addresses */
+#define ABIT_UGURU3_SETTINGS_BANK               0x01
+#define ABIT_UGURU3_SENSORS_BANK                0x08
+#define ABIT_UGURU3_MISC_BANK                   0x09
+#define ABIT_UGURU3_ALARMS_START                0x1E
+#define ABIT_UGURU3_SETTINGS_START              0x24
+#define ABIT_UGURU3_VALUES_START                0x80
+#define ABIT_UGURU3_BOARD_ID                    0x0A
+/* uGuru3 sensor bank flags */                       /* Alarm if: */
+#define ABIT_UGURU3_TEMP_HIGH_ALARM_ENABLE      0x01 /*  temp over warn */
+#define ABIT_UGURU3_VOLT_HIGH_ALARM_ENABLE      0x02 /*  volt over max */
+#define ABIT_UGURU3_VOLT_LOW_ALARM_ENABLE       0x04 /*  volt under min */
+#define ABIT_UGURU3_TEMP_HIGH_ALARM_FLAG        0x10 /* temp is over warn */
+#define ABIT_UGURU3_VOLT_HIGH_ALARM_FLAG        0x20 /* volt is over max */
+#define ABIT_UGURU3_VOLT_LOW_ALARM_FLAG         0x40 /* volt is under min */
+#define ABIT_UGURU3_FAN_LOW_ALARM_ENABLE        0x01 /*   fan under min */
+#define ABIT_UGURU3_BEEP_ENABLE                 0x08 /* beep if alarm */
+#define ABIT_UGURU3_SHUTDOWN_ENABLE             0x80 /* shutdown if alarm */
+/* sensor types */
+#define ABIT_UGURU3_IN_SENSOR                   0
+#define ABIT_UGURU3_TEMP_SENSOR                 1
+#define ABIT_UGURU3_FAN_SENSOR                  2
+
+/* Timeouts / Retries, if these turn out to need a lot of fiddling we could
+   convert them to params. Determined by trial and error. I assume this is
+   cpu-speed independent, since the ISA-bus and not the CPU should be the
+   bottleneck. */
+#define ABIT_UGURU3_WAIT_TIMEOUT                250
+/* Normally the 0xAC at the end of synchronize() is reported after the
+   first read, but sometimes not and we need to poll */
+#define ABIT_UGURU3_SYNCHRONIZE_TIMEOUT         5
+/* utility macros */
+#define ABIT_UGURU3_NAME                        "abituguru3"
+#define ABIT_UGURU3_DEBUG(format, arg...)       \
+        if (verbose)                            \
+                printk(KERN_DEBUG ABIT_UGURU3_NAME ": " format , ## arg)
+
+/* Macros to help calculate the sysfs_names array length */
+#define ABIT_UGURU3_MAX_NO_SENSORS 26
+/* sum of strlen +1 of: in??_input\0, in??_{min,max}\0, in??_{min,max}_alarm\0,
+   in??_{min,max}_alarm_enable\0, in??_beep\0, in??_shutdown\0, in??_label\0 */
+#define ABIT_UGURU3_IN_NAMES_LENGTH (11 + 2 * 9 + 2 * 15 + 2 * 22 + 10 + 14 + 11)
+/* sum of strlen +1 of: temp??_input\0, temp??_max\0, temp??_crit\0,
+   temp??_alarm\0, temp??_alarm_enable\0, temp??_beep\0, temp??_shutdown\0,
+   temp??_label\0 */
+#define ABIT_UGURU3_TEMP_NAMES_LENGTH (13 + 11 + 12 + 13 + 20 + 12 + 16 + 13)
+/* sum of strlen +1 of: fan??_input\0, fan??_min\0, fan??_alarm\0,
+   fan??_alarm_enable\0, fan??_beep\0, fan??_shutdown\0, fan??_label\0 */
+#define ABIT_UGURU3_FAN_NAMES_LENGTH (12 + 10 + 12 + 19 + 11 + 15 + 12)
+/* Worst case scenario 16 in sensors (longest names_length) and the rest
+   temp sensors (second longest names_length). */
+#define ABIT_UGURU3_SYSFS_NAMES_LENGTH (16 * ABIT_UGURU3_IN_NAMES_LENGTH + \
+        (ABIT_UGURU3_MAX_NO_SENSORS - 16) * ABIT_UGURU3_TEMP_NAMES_LENGTH)
+
+/* All the macros below are named identical to the openguru2 program
+   reverse engineered by Louis Kruger, hence the names might not be 100%
+   logical. I could come up with better names, but I prefer keeping the names
+   identical so that this driver can be compared with his work more easily. */
+/* Two i/o-ports are used by uGuru */
+#define ABIT_UGURU3_BASE                        0x00E0
+#define ABIT_UGURU3_CMD                         0x00
+#define ABIT_UGURU3_DATA                        0x04
+#define ABIT_UGURU3_REGION_LENGTH               5
+/* The wait_xxx functions return this on success and the last contents
+   of the DATA register (0-255) on failure. */
+#define ABIT_UGURU3_SUCCESS                     -1
+/* uGuru status flags */
+#define ABIT_UGURU3_STATUS_READY_FOR_READ       0x01
+#define ABIT_UGURU3_STATUS_BUSY                 0x02
+
+
+/* Structures */
+struct abituguru3_sensor_info {
+        const char* name;
+        int port;
+        int type;
+        int multiplier;
+        int divisor;
+        int offset;
+};
+
+struct abituguru3_motherboard_info {
+        u16 id;
+        const char *name;
+        /* + 1 -> end of sensors indicated by a sensor with name == NULL */
+        struct abituguru3_sensor_info sensors[ABIT_UGURU3_MAX_NO_SENSORS + 1];
+};
+
+/* For the Abit uGuru, we need to keep some data in memory.
+   The structure is dynamically allocated, at the same time when a new
+   abituguru3 device is allocated. */
+struct abituguru3_data {
+        struct class_device *class_dev; /* hwmon registered device */
+        struct mutex update_lock;       /* protect access to data and uGuru */
+        unsigned short addr;            /* uguru base address */
+        char valid;                     /* !=0 if following fields are valid */
+        unsigned long last_updated;     /* In jiffies */
+
+        /* For convenience the sysfs attr and their names are generated
+           automatically. We have max 10 entries per sensor (for in sensors) */
+        struct sensor_device_attribute_2 sysfs_attr[ABIT_UGURU3_MAX_NO_SENSORS
+                * 10];
+
+        /* Buffer to store the dynamically generated sysfs names */
+        char sysfs_names[ABIT_UGURU3_SYSFS_NAMES_LENGTH];
+
+        /* Pointer to the sensors info for the detected motherboard */
+        const struct abituguru3_sensor_info *sensors;
+
+        /* The abituguru3 supports upto 48 sensors, and thus has registers
+           sets for 48 sensors, for convienence reasons / simplicity of the
+           code we always read and store all registers for all 48 sensors */
+
+        /* Alarms for all 48 sensors (1 bit per sensor) */
+        u8 alarms[48/8];
+
+        /* Value of all 48 sensors */
+        u8 value[48];
+
+        /* Settings of all 48 sensors, note in and temp sensors (the first 32
+           sensors) have 3 bytes of settings, while fans only have 2 bytes,
+           for convenience we use 3 bytes for all sensors */
+        u8 settings[48][3];
+};
+
+
+/* Constants */
+static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
+        { 0x000C, "unknown", {
+                { "CPU Core",            0, 0, 10, 1, 0 },
+                { "DDR",                 1, 0, 10, 1, 0 },
+                { "DDR VTT",             2, 0, 10, 1, 0 },
+                { "CPU VTT 1.2V",        3, 0, 10, 1, 0 },
+                { "MCH & PCIE 1.5V",     4, 0, 10, 1, 0 },
+                { "MCH 2.5V",            5, 0, 20, 1, 0 },
+                { "ICH 1.05V",           6, 0, 10, 1, 0 },
+                { "ATX +12V (24-Pin)",   7, 0, 60, 1, 0 },
+                { "ATX +12V (4-pin)",    8, 0, 60, 1, 0 },
+                { "ATX +5V",             9, 0, 30, 1, 0 },
+                { "+3.3V",              10, 0, 20, 1, 0 },
+                { "5VSB",               11, 0, 30, 1, 0 },
+                { "CPU",                24, 1, 1, 1, 0 },
+                { "System ",            25, 1, 1, 1, 0 },
+                { "PWM",                26, 1, 1, 1, 0 },
+                { "CPU Fan",            32, 2, 60, 1, 0 },
+                { "NB Fan",             33, 2, 60, 1, 0 },
+                { "SYS FAN",            34, 2, 60, 1, 0 },
+                { "AUX1 Fan",           35, 2, 60, 1, 0 },
+                { NULL, 0, 0, 0, 0, 0 } }
+        },
+        { 0x000D, "Abit AW8", {
+                { "CPU Core",            0, 0, 10, 1, 0 },
+                { "DDR",                 1, 0, 10, 1, 0 },
+                { "DDR VTT",             2, 0, 10, 1, 0 },
+                { "CPU VTT 1.2V",        3, 0, 10, 1, 0 },
+                { "MCH & PCIE 1.5V",     4, 0, 10, 1, 0 },
+                { "MCH 2.5V",            5, 0, 20, 1, 0 },
+                { "ICH 1.05V",           6, 0, 10, 1, 0 },
+                { "ATX +12V (24-Pin)",   7, 0, 60, 1, 0 },
+                { "ATX +12V (4-pin)",    8, 0, 60, 1, 0 },
+                { "ATX +5V",             9, 0, 30, 1, 0 },
+                { "+3.3V",              10, 0, 20, 1, 0 },
+                { "5VSB",               11, 0, 30, 1, 0 },
+                { "CPU",                24, 1, 1, 1, 0 },
+                { "System ",            25, 1, 1, 1, 0 },
+                { "PWM1",               26, 1, 1, 1, 0 },
+                { "PWM2",               27, 1, 1, 1, 0 },
+                { "PWM3",               28, 1, 1, 1, 0 },
+                { "PWM4",               29, 1, 1, 1, 0 },
+                { "CPU Fan",            32, 2, 60, 1, 0 },
+                { "NB Fan",             33, 2, 60, 1, 0 },
+                { "SYS Fan",            34, 2, 60, 1, 0 },
+                { "AUX1 Fan",           35, 2, 60, 1, 0 },
+                { "AUX2 Fan",           36, 2, 60, 1, 0 },
+                { "AUX3 Fan",           37, 2, 60, 1, 0 },
+                { "AUX4 Fan",           38, 2, 60, 1, 0 },
+                { "AUX5 Fan",           39, 2, 60, 1, 0 },
+                { NULL, 0, 0, 0, 0, 0 } }
+        },
+        { 0x000E, "AL-8", {
+                { "CPU Core",            0, 0, 10, 1, 0 },
+                { "DDR",                 1, 0, 10, 1, 0 },
+                { "DDR VTT",             2, 0, 10, 1, 0 },
+                { "CPU VTT 1.2V",        3, 0, 10, 1, 0 },
+                { "MCH & PCIE 1.5V",     4, 0, 10, 1, 0 },
+                { "MCH 2.5V",            5, 0, 20, 1, 0 },
+                { "ICH 1.05V",           6, 0, 10, 1, 0 },
+                { "ATX +12V (24-Pin)",   7, 0, 60, 1, 0 },
+                { "ATX +12V (4-pin)",    8, 0, 60, 1, 0 },
+                { "ATX +5V",             9, 0, 30, 1, 0 },
+                { "+3.3V",              10, 0, 20, 1, 0 },
+                { "5VSB",               11, 0, 30, 1, 0 },
+                { "CPU",                24, 1, 1, 1, 0 },
+                { "System ",            25, 1, 1, 1, 0 },
+                { "PWM",                26, 1, 1, 1, 0 },
+                { "CPU Fan",            32, 2, 60, 1, 0 },
+                { "NB Fan",             33, 2, 60, 1, 0 },
+                { "SYS Fan",            34, 2, 60, 1, 0 },
+                { NULL, 0, 0, 0, 0, 0 } }
+        },
+        { 0x000F, "unknown", {
+                { "CPU Core",            0, 0, 10, 1, 0 },
+                { "DDR",                 1, 0, 10, 1, 0 },
+                { "DDR VTT",             2, 0, 10, 1, 0 },
+                { "CPU VTT 1.2V",        3, 0, 10, 1, 0 },
+                { "MCH & PCIE 1.5V",     4, 0, 10, 1, 0 },
+                { "MCH 2.5V",            5, 0, 20, 1, 0 },
+                { "ICH 1.05V",           6, 0, 10, 1, 0 },
+                { "ATX +12V (24-Pin)",   7, 0, 60, 1, 0 },
+                { "ATX +12V (4-pin)",    8, 0, 60, 1, 0 },
+                { "ATX +5V",             9, 0, 30, 1, 0 },
+                { "+3.3V",              10, 0, 20, 1, 0 },
+                { "5VSB",               11, 0, 30, 1, 0 },
+                { "CPU",                24, 1, 1, 1, 0 },
+                { "System ",            25, 1, 1, 1, 0 },
+                { "PWM",                26, 1, 1, 1, 0 },
+                { "CPU Fan",            32, 2, 60, 1, 0 },
+                { "NB Fan",             33, 2, 60, 1, 0 },
+                { "SYS Fan",            34, 2, 60, 1, 0 },
+                { NULL, 0, 0, 0, 0, 0 } }
+        },
+        { 0x0010, "Abit NI8 SLI GR", {
+                { "CPU Core",            0, 0, 10, 1, 0 },
+                { "DDR",                 1, 0, 10, 1, 0 },
+                { "DDR VTT",             2, 0, 10, 1, 0 },
+                { "CPU VTT 1.2V",        3, 0, 10, 1, 0 },
+                { "NB 1.4V",             4, 0, 10, 1, 0 },
+                { "SB 1.5V",             6, 0, 10, 1, 0 },
+                { "ATX +12V (24-Pin)",   7, 0, 60, 1, 0 },
+                { "ATX +12V (4-pin)",    8, 0, 60, 1, 0 },
+                { "ATX +5V",             9, 0, 30, 1, 0 },
+                { "+3.3V",              10, 0, 20, 1, 0 },
+                { "5VSB",               11, 0, 30, 1, 0 },
+                { "CPU",                24, 1, 1, 1, 0 },
+                { "SYS",                25, 1, 1, 1, 0 },
+                { "PWM",                26, 1, 1, 1, 0 },
+                { "CPU Fan",            32, 2, 60, 1, 0 },
+                { "NB Fan",             33, 2, 60, 1, 0 },
+                { "SYS Fan",            34, 2, 60, 1, 0 },
+                { "AUX1 Fan",           35, 2, 60, 1, 0 },
+                { "OTES1 Fan",          36, 2, 60, 1, 0 },
+                { NULL, 0, 0, 0, 0, 0 } }
+        },
+        { 0x0011, "Abit AT8 32X", {
+                { "CPU Core",            0, 0, 10, 1, 0 },
+                { "DDR",                 1, 0, 20, 1, 0 },
+                { "DDR VTT",             2, 0, 10, 1, 0 },
+                { "CPU VDDA 2.5V",       6, 0, 20, 1, 0 },
+                { "NB 1.8V",             4, 0, 10, 1, 0 },
+                { "NB 1.8V Dual",        5, 0, 10, 1, 0 },
+                { "HTV 1.2",             3, 0, 10, 1, 0 },
+                { "PCIE 1.2V",          12, 0, 10, 1, 0 },
+                { "NB 1.2V",            13, 0, 10, 1, 0 },
+                { "ATX +12V (24-Pin)",   7, 0, 60, 1, 0 },
+                { "ATX +12V (4-pin)",    8, 0, 60, 1, 0 },
+                { "ATX +5V",             9, 0, 30, 1, 0 },
+                { "+3.3V",              10, 0, 20, 1, 0 },
+                { "5VSB",               11, 0, 30, 1, 0 },
+                { "CPU",                24, 1, 1, 1, 0 },
+                { "NB",                 25, 1, 1, 1, 0 },
+                { "System",             26, 1, 1, 1, 0 },
+                { "PWM",                27, 1, 1, 1, 0 },
+                { "CPU Fan",            32, 2, 60, 1, 0 },
+                { "NB Fan",             33, 2, 60, 1, 0 },
+                { "SYS Fan",            34, 2, 60, 1, 0 },
+                { "AUX1 Fan",           35, 2, 60, 1, 0 },
+                { "AUX2 Fan",           36, 2, 60, 1, 0 },
+                { NULL, 0, 0, 0, 0, 0 } }
+        },
+        { 0x0012, "Abit AN8 32X", {
+                { "CPU Core",            0, 0, 10, 1, 0 },
+                { "DDR",                 1, 0, 20, 1, 0 },
+                { "DDR VTT",             2, 0, 10, 1, 0 },
+                { "HyperTransport",      3, 0, 10, 1, 0 },
+                { "CPU VDDA 2.5V",       5, 0, 20, 1, 0 },
+                { "NB",                  4, 0, 10, 1, 0 },
+                { "SB",                  6, 0, 10, 1, 0 },
+                { "ATX +12V (24-Pin)",   7, 0, 60, 1, 0 },
+                { "ATX +12V (4-pin)",    8, 0, 60, 1, 0 },
+                { "ATX +5V",             9, 0, 30, 1, 0 },
+                { "+3.3V",              10, 0, 20, 1, 0 },
+                { "5VSB",               11, 0, 30, 1, 0 },
+                { "CPU",                24, 1, 1, 1, 0 },
+                { "SYS",                25, 1, 1, 1, 0 },
+                { "PWM",                26, 1, 1, 1, 0 },
+                { "CPU Fan",            32, 2, 60, 1, 0 },
+                { "NB Fan",             33, 2, 60, 1, 0 },
+                { "SYS Fan",            34, 2, 60, 1, 0 },
+                { "AUX1 Fan",           36, 2, 60, 1, 0 },
+                { NULL, 0, 0, 0, 0, 0 } }
+        },
+        { 0x0013, "unknown", {
+                { "CPU Core",            0, 0, 10, 1, 0 },
+                { "DDR",                 1, 0, 10, 1, 0 },
+                { "DDR VTT",             2, 0, 10, 1, 0 },
+                { "CPU VTT 1.2V",        3, 0, 10, 1, 0 },
+                { "MCH & PCIE 1.5V",     4, 0, 10, 1, 0 },
+                { "MCH 2.5V",            5, 0, 20, 1, 0 },
+                { "ICH 1.05V",           6, 0, 10, 1, 0 },
+                { "ATX +12V (24-Pin)",   7, 0, 60, 1, 0 },
+                { "ATX +12V (4-pin)",    8, 0, 60, 1, 0 },
+                { "ATX +5V",             9, 0, 30, 1, 0 },
+                { "+3.3V",              10, 0, 20, 1, 0 },
+                { "5VSB",               11, 0, 30, 1, 0 },
+                { "CPU",                24, 1, 1, 1, 0 },
+                { "System ",            25, 1, 1, 1, 0 },
+                { "PWM1",               26, 1, 1, 1, 0 },
+                { "PWM2",               27, 1, 1, 1, 0 },
+                { "PWM3",               28, 1, 1, 1, 0 },
+                { "PWM4",               29, 1, 1, 1, 0 },
+                { "CPU Fan",            32, 2, 60, 1, 0 },
+                { "NB Fan",             33, 2, 60, 1, 0 },
+                { "SYS Fan",            34, 2, 60, 1, 0 },
+                { "AUX1 Fan",           35, 2, 60, 1, 0 },
+                { "AUX2 Fan",           36, 2, 60, 1, 0 },
+                { "AUX3 Fan",           37, 2, 60, 1, 0 },
+                { "AUX4 Fan",           38, 2, 60, 1, 0 },
+                { NULL, 0, 0, 0, 0, 0 } }
+        },
+        { 0x0014, "Abit AB9 Pro", {
+                { "CPU Core",            0, 0, 10, 1, 0 },
+                { "DDR",                 1, 0, 10, 1, 0 },
+                { "DDR VTT",             2, 0, 10, 1, 0 },
+                { "CPU VTT 1.2V",        3, 0, 10, 1, 0 },
+                { "MCH & PCIE 1.5V",     4, 0, 10, 1, 0 },
+                { "MCH 2.5V",            5, 0, 20, 1, 0 },
+                { "ICH 1.05V",           6, 0, 10, 1, 0 },
+                { "ATX +12V (24-Pin)",   7, 0, 60, 1, 0 },
+                { "ATX +12V (4-pin)",    8, 0, 60, 1, 0 },
+                { "ATX +5V",             9, 0, 30, 1, 0 },
+                { "+3.3V",              10, 0, 20, 1, 0 },
+                { "5VSB",               11, 0, 30, 1, 0 },
+                { "CPU",                24, 1, 1, 1, 0 },
+                { "System ",            25, 1, 1, 1, 0 },
+                { "PWM",                26, 1, 1, 1, 0 },
+                { "CPU Fan",            32, 2, 60, 1, 0 },
+                { "NB Fan",             33, 2, 60, 1, 0 },
+                { "SYS Fan",            34, 2, 60, 1, 0 },
+                { NULL, 0, 0, 0, 0, 0 } }
+        },
+        { 0x0015, "unknown", {
+                { "CPU Core",            0, 0, 10, 1, 0 },
+                { "DDR",                 1, 0, 20, 1, 0 },
+                { "DDR VTT",             2, 0, 10, 1, 0 },
+                { "HyperTransport",      3, 0, 10, 1, 0 },
+                { "CPU VDDA 2.5V",       5, 0, 20, 1, 0 },
+                { "NB",                  4, 0, 10, 1, 0 },
+                { "SB",                  6, 0, 10, 1, 0 },
+                { "ATX +12V (24-Pin)",   7, 0, 60, 1, 0 },
+                { "ATX +12V (4-pin)",    8, 0, 60, 1, 0 },
+                { "ATX +5V",             9, 0, 30, 1, 0 },
+                { "+3.3V",              10, 0, 20, 1, 0 },
+                { "5VSB",               11, 0, 30, 1, 0 },
+                { "CPU",                24, 1, 1, 1, 0 },
+                { "SYS",                25, 1, 1, 1, 0 },
+                { "PWM",                26, 1, 1, 1, 0 },
+                { "CPU Fan",            32, 2, 60, 1, 0 },
+                { "NB Fan",             33, 2, 60, 1, 0 },
+                { "SYS Fan",            34, 2, 60, 1, 0 },
+                { "AUX1 Fan",           33, 2, 60, 1, 0 },
+                { "AUX2 Fan",           35, 2, 60, 1, 0 },
+                { "AUX3 Fan",           36, 2, 60, 1, 0 },
+                { NULL, 0, 0, 0, 0, 0 } }
+        },
+        { 0x0016, "AW9D-MAX", {
+                { "CPU Core",            0, 0, 10, 1, 0 },
+                { "DDR2",                1, 0, 20, 1, 0 },
+                { "DDR2 VTT",            2, 0, 10, 1, 0 },
+                { "CPU VTT 1.2V",        3, 0, 10, 1, 0 },
+                { "MCH & PCIE 1.5V",     4, 0, 10, 1, 0 },
+                { "MCH 2.5V",            5, 0, 20, 1, 0 },
+                { "ICH 1.05V",           6, 0, 10, 1, 0 },
+                { "ATX +12V (24-Pin)",   7, 0, 60, 1, 0 },
+                { "ATX +12V (4-pin)",    8, 0, 60, 1, 0 },
+                { "ATX +5V",             9, 0, 30, 1, 0 },
+                { "+3.3V",              10, 0, 20, 1, 0 },
+                { "5VSB",               11, 0, 30, 1, 0 },
+                { "CPU",                24, 1, 1, 1, 0 },
+                { "System ",            25, 1, 1, 1, 0 },
+                { "PWM1",               26, 1, 1, 1, 0 },
+                { "PWM2",               27, 1, 1, 1, 0 },
+                { "PWM3",               28, 1, 1, 1, 0 },
+                { "PWM4",               29, 1, 1, 1, 0 },
+                { "CPU Fan",            32, 2, 60, 1, 0 },
+                { "NB Fan",             33, 2, 60, 1, 0 },
+                { "SYS Fan",            34, 2, 60, 1, 0 },
+                { "AUX1 Fan",           35, 2, 60, 1, 0 },
+                { "AUX2 Fan",           36, 2, 60, 1, 0 },
+                { "AUX3 Fan",           37, 2, 60, 1, 0 },
+                { "OTES1 Fan",          38, 2, 60, 1, 0 },
+                { NULL, 0, 0, 0, 0, 0 } }
+        },
+        { 0x0017, "unknown", {
+                { "CPU Core",            0, 0, 10, 1, 0 },
+                { "DDR2",                1, 0, 20, 1, 0 },
+                { "DDR2 VTT",            2, 0, 10, 1, 0 },
+                { "HyperTransport",      3, 0, 10, 1, 0 },
+                { "CPU VDDA 2.5V",       6, 0, 20, 1, 0 },
+                { "NB 1.8V",             4, 0, 10, 1, 0 },
+                { "NB 1.2V ",           13, 0, 10, 1, 0 },
+                { "SB 1.2V",             5, 0, 10, 1, 0 },
+                { "PCIE 1.2V",          12, 0, 10, 1, 0 },
+                { "ATX +12V (24-Pin)",   7, 0, 60, 1, 0 },
+                { "ATX +12V (4-pin)",    8, 0, 60, 1, 0 },
+                { "ATX +5V",             9, 0, 30, 1, 0 },
+                { "ATX +3.3V",          10, 0, 20, 1, 0 },
+                { "ATX 5VSB",           11, 0, 30, 1, 0 },
+                { "CPU",                24, 1, 1, 1, 0 },
+                { "System ",            26, 1, 1, 1, 0 },
+                { "PWM",                27, 1, 1, 1, 0 },
+                { "CPU FAN",            32, 2, 60, 1, 0 },
+                { "SYS FAN",            34, 2, 60, 1, 0 },
+                { "AUX1 FAN",           35, 2, 60, 1, 0 },
+                { "AUX2 FAN",           36, 2, 60, 1, 0 },
+                { "AUX3 FAN",           37, 2, 60, 1, 0 },
+                { NULL, 0, 0, 0, 0, 0 } }
+        },
+        { 0x0018, "unknown", {
+                { "CPU Core",            0, 0, 10, 1, 0 },
+                { "DDR2",                1, 0, 20, 1, 0 },
+                { "DDR2 VTT",            2, 0, 10, 1, 0 },
+                { "CPU VTT",             3, 0, 10, 1, 0 },
+                { "MCH 1.25V",           4, 0, 10, 1, 0 },
+                { "ICHIO 1.5V",          5, 0, 10, 1, 0 },
+                { "ICH 1.05V",           6, 0, 10, 1, 0 },
+                { "ATX +12V (24-Pin)",   7, 0, 60, 1, 0 },
+                { "ATX +12V (4-pin)",    8, 0, 60, 1, 0 },
+                { "ATX +5V",             9, 0, 30, 1, 0 },
+                { "+3.3V",              10, 0, 20, 1, 0 },
+                { "5VSB",               11, 0, 30, 1, 0 },
+                { "CPU",                24, 1, 1, 1, 0 },
+                { "System ",            25, 1, 1, 1, 0 },
+                { "PWM Phase1",         26, 1, 1, 1, 0 },
+                { "PWM Phase2",         27, 1, 1, 1, 0 },
+                { "PWM Phase3",         28, 1, 1, 1, 0 },
+                { "PWM Phase4",         29, 1, 1, 1, 0 },
+                { "PWM Phase5",         30, 1, 1, 1, 0 },
+                { "CPU Fan",            32, 2, 60, 1, 0 },
+                { "SYS Fan",            34, 2, 60, 1, 0 },
+                { "AUX1 Fan",           33, 2, 60, 1, 0 },
+                { "AUX2 Fan",           35, 2, 60, 1, 0 },
+                { "AUX3 Fan",           36, 2, 60, 1, 0 },
+                { NULL, 0, 0, 0, 0, 0 } }
+        },
+        { 0x0019, "unknown", {
+                { "CPU Core",            7, 0, 10, 1, 0 },
+                { "DDR2",               13, 0, 20, 1, 0 },
+                { "DDR2 VTT",           14, 0, 10, 1, 0 },
+                { "CPU VTT",             3, 0, 20, 1, 0 },
+                { "NB 1.2V ",            4, 0, 10, 1, 0 },
+                { "SB 1.5V",             6, 0, 10, 1, 0 },
+                { "HyperTransport",      5, 0, 10, 1, 0 },
+                { "ATX +12V (24-Pin)",  12, 0, 60, 1, 0 },
+                { "ATX +12V (4-pin)",    8, 0, 60, 1, 0 },
+                { "ATX +5V",             9, 0, 30, 1, 0 },
+                { "ATX +3.3V",          10, 0, 20, 1, 0 },
+                { "ATX 5VSB",           11, 0, 30, 1, 0 },
+                { "CPU",                24, 1, 1, 1, 0 },
+                { "System ",            25, 1, 1, 1, 0 },
+                { "PWM Phase1",         26, 1, 1, 1, 0 },
+                { "PWM Phase2",         27, 1, 1, 1, 0 },
+                { "PWM Phase3",         28, 1, 1, 1, 0 },
+                { "PWM Phase4",         29, 1, 1, 1, 0 },
+                { "PWM Phase5",         30, 1, 1, 1, 0 },
+                { "CPU FAN",            32, 2, 60, 1, 0 },
+                { "SYS FAN",            34, 2, 60, 1, 0 },
+                { "AUX1 FAN",           33, 2, 60, 1, 0 },
+                { "AUX2 FAN",           35, 2, 60, 1, 0 },
+                { "AUX3 FAN",           36, 2, 60, 1, 0 },
+                { NULL, 0, 0, 0, 0, 0 } }
+        },
+        { 0x001A, "unknown", {
+                { "CPU Core",            0, 0, 10, 1, 0 },
+                { "DDR2",                1, 0, 20, 1, 0 },
+                { "DDR2 VTT",            2, 0, 10, 1, 0 },
+                { "CPU VTT 1.2V",        3, 0, 10, 1, 0 },
+                { "MCH 1.25V",           4, 0, 10, 1, 0 },
+                { "ICHIO 1.5V",          5, 0, 10, 1, 0 },
+                { "ICH 1.05V",           6, 0, 10, 1, 0 },
+                { "ATX +12V (24-Pin)",   7, 0, 60, 1, 0 },
+                { "ATX +12V (8-pin)",    8, 0, 60, 1, 0 },
+                { "ATX +5V",             9, 0, 30, 1, 0 },
+                { "+3.3V",              10, 0, 20, 1, 0 },
+                { "5VSB",               11, 0, 30, 1, 0 },
+                { "CPU",                24, 1, 1, 1, 0 },
+                { "System ",            25, 1, 1, 1, 0 },
+                { "PWM ",               26, 1, 1, 1, 0 },
+                { "PWM Phase2",         27, 1, 1, 1, 0 },
+                { "PWM Phase3",         28, 1, 1, 1, 0 },
+                { "PWM Phase4",         29, 1, 1, 1, 0 },
+                { "PWM Phase5",         30, 1, 1, 1, 0 },
+                { "CPU Fan",            32, 2, 60, 1, 0 },
+                { "SYS Fan",            34, 2, 60, 1, 0 },
+                { "AUX1 Fan",           33, 2, 60, 1, 0 },
+                { "AUX2 Fan",           35, 2, 60, 1, 0 },
+                { "AUX3 Fan",           36, 2, 60, 1, 0 },
+                { NULL, 0, 0, 0, 0, 0 } }
+        },
+        { 0x0000, NULL, { { NULL, 0, 0, 0, 0, 0 } } }
+};
+
+
+/* Insmod parameters */
+static int force;
+module_param(force, bool, 0);
+MODULE_PARM_DESC(force, "Set to one to force detection.");
+/* Default verbose is 1, since this driver is still in the testing phase */
+static int verbose = 1;
+module_param(verbose, bool, 0644);
+MODULE_PARM_DESC(verbose, "Enable/disable verbose error reporting");
+
+
+/* wait while the uguru is busy (usually after a write) */
+static int abituguru3_wait_while_busy(struct abituguru3_data *data)
+{
+        u8 x;
+        int timeout = ABIT_UGURU3_WAIT_TIMEOUT;
+
+        while ((x = inb_p(data->addr + ABIT_UGURU3_DATA)) &
+                        ABIT_UGURU3_STATUS_BUSY) {
+                timeout--;
+                if (timeout == 0)
+                        return x;
+                /* sleep a bit before our last try, to give the uGuru3 one
+                   last chance to respond. */
+                if (timeout == 1)
+                        msleep(1);
+        }
+        return ABIT_UGURU3_SUCCESS;
+}
+
+/* wait till uguru is ready to be read */
+static int abituguru3_wait_for_read(struct abituguru3_data *data)
+{
+        u8 x;
+        int timeout = ABIT_UGURU3_WAIT_TIMEOUT;
+
+        while (!((x = inb_p(data->addr + ABIT_UGURU3_DATA)) &
+                        ABIT_UGURU3_STATUS_READY_FOR_READ)) {
+                timeout--;
+                if (timeout == 0)
+                        return x;
+                /* sleep a bit before our last try, to give the uGuru3 one
+                   last chance to respond. */
+                if (timeout == 1)
+                        msleep(1);
+        }
+        return ABIT_UGURU3_SUCCESS;
+}
+
+/* This synchronizes us with the uGuru3's protocol state machine, this
+   must be done before each command. */
+static int abituguru3_synchronize(struct abituguru3_data *data)
+{
+        int x, timeout = ABIT_UGURU3_SYNCHRONIZE_TIMEOUT;
+
+        if ((x = abituguru3_wait_while_busy(data)) != ABIT_UGURU3_SUCCESS) {
+                ABIT_UGURU3_DEBUG("synchronize timeout during initial busy "
+                        "wait, status: 0x%02x\n", x);
+                return -EIO;
+        }
+
+        outb(0x20, data->addr + ABIT_UGURU3_DATA);
+        if ((x = abituguru3_wait_while_busy(data)) != ABIT_UGURU3_SUCCESS) {
+                ABIT_UGURU3_DEBUG("synchronize timeout after sending 0x20, "
+                        "status: 0x%02x\n", x);
+                return -EIO;
+        }
+
+        outb(0x10, data->addr + ABIT_UGURU3_CMD);
+        if ((x = abituguru3_wait_while_busy(data)) != ABIT_UGURU3_SUCCESS) {
+                ABIT_UGURU3_DEBUG("synchronize timeout after sending 0x10, "
+                        "status: 0x%02x\n", x);
+                return -EIO;
+        }
+
+        outb(0x00, data->addr + ABIT_UGURU3_CMD);
+        if ((x = abituguru3_wait_while_busy(data)) != ABIT_UGURU3_SUCCESS) {
+                ABIT_UGURU3_DEBUG("synchronize timeout after sending 0x00, "
+                        "status: 0x%02x\n", x);
+                return -EIO;
+        }
+
+        if ((x = abituguru3_wait_for_read(data)) != ABIT_UGURU3_SUCCESS) {
+                ABIT_UGURU3_DEBUG("synchronize timeout waiting for read, "
+                        "status: 0x%02x\n", x);
+                return -EIO;
+        }
+
+        while ((x = inb(data->addr + ABIT_UGURU3_CMD)) != 0xAC) {
+                timeout--;
+                if (timeout == 0) {
+                        ABIT_UGURU3_DEBUG("synchronize timeout cmd does not "
+                                "hold 0xAC after synchronize, cmd: 0x%02x\n",
+                                x);
+                        return -EIO;
+                }
+                msleep(1);
+        }
+        return 0;
+}
+
+/* Read count bytes from sensor sensor_addr in bank bank_addr and store the
+   result in buf */
+static int abituguru3_read(struct abituguru3_data *data, u8 bank, u8 offset,
+        u8 count, u8 *buf)
+{
+        int i, x;
+
+        if ((x = abituguru3_synchronize(data)))
+                return x;
+
+        outb(0x1A, data->addr + ABIT_UGURU3_DATA);
+        if ((x = abituguru3_wait_while_busy(data)) != ABIT_UGURU3_SUCCESS) {
+                ABIT_UGURU3_DEBUG("read from 0x%02x:0x%02x timed out after "
+                        "sending 0x1A, status: 0x%02x\n", (unsigned int)bank,
+                        (unsigned int)offset, x);
+                return -EIO;
+        }
+
+        outb(bank, data->addr + ABIT_UGURU3_CMD);
+        if ((x = abituguru3_wait_while_busy(data)) != ABIT_UGURU3_SUCCESS) {
+                ABIT_UGURU3_DEBUG("read from 0x%02x:0x%02x timed out after "
+                        "sending the bank, status: 0x%02x\n",
+                        (unsigned int)bank, (unsigned int)offset, x);
+                return -EIO;
+        }
+
+        outb(offset, data->addr + ABIT_UGURU3_CMD);
+        if ((x = abituguru3_wait_while_busy(data)) != ABIT_UGURU3_SUCCESS) {
+                ABIT_UGURU3_DEBUG("read from 0x%02x:0x%02x timed out after "
+                        "sending the offset, status: 0x%02x\n",
+                        (unsigned int)bank, (unsigned int)offset, x);
+                return -EIO;
+        }
+
+        outb(count, data->addr + ABIT_UGURU3_CMD);
+        if ((x = abituguru3_wait_while_busy(data)) != ABIT_UGURU3_SUCCESS) {
+                ABIT_UGURU3_DEBUG("read from 0x%02x:0x%02x timed out after "
+                        "sending the count, status: 0x%02x\n",
+                        (unsigned int)bank, (unsigned int)offset, x);
+                return -EIO;
+        }
+
+        for (i = 0; i < count; i++) {
+                if ((x = abituguru3_wait_for_read(data)) !=
+                                ABIT_UGURU3_SUCCESS) {
+                        ABIT_UGURU3_DEBUG("timeout reading byte %d from "
+                                "0x%02x:0x%02x, status: 0x%02x\n", i,
+                                (unsigned int)bank, (unsigned int)offset, x);
+                        break;
+                }
+                buf[i] = inb(data->addr + ABIT_UGURU3_CMD);
+        }
+        return i;
+}
+
+/* Sensor settings are stored 1 byte per offset with the bytes
+   placed add consecutive offsets. */
+int abituguru3_read_increment_offset(struct abituguru3_data *data, u8 bank,
+        u8 offset, u8 count, u8 *buf, int offset_count)
+{
+        int i, x;
+
+        for (i = 0; i < offset_count; i++)
+                if ((x = abituguru3_read(data, bank, offset + i, count,
+                                buf + i * count)) != count)
+                        return i * count + (i && (x < 0)) ? 0 : x;
+
+        return i * count;
+}
+
+/* Following are the sysfs callback functions. These functions expect:
+   sensor_device_attribute_2->index:   index into the data->sensors array
+   sensor_device_attribute_2->nr:      register offset, bitmask or NA. */
+static struct abituguru3_data *abituguru3_update_device(struct device *dev);
+
+static ssize_t show_value(struct device *dev,
+        struct device_attribute *devattr, char *buf)
+{
+        int value;
+        struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
+        struct abituguru3_data *data = abituguru3_update_device(dev);
+        const struct abituguru3_sensor_info *sensor;
+
+        if (!data)
+                return -EIO;
+
+        sensor = &data->sensors[attr->index];
+
+        /* are we reading a setting, or is this a normal read? */
+        if (attr->nr)
+                value = data->settings[sensor->port][attr->nr];
+        else
+                value = data->value[sensor->port];
+
+        /* convert the value */
+        value = (value * sensor->multiplier) / sensor->divisor +
+                sensor->offset;
+
+        /* alternatively we could update the sensors settings struct for this,
+           but then its contents would differ from the windows sw ini files */
+        if (sensor->type == ABIT_UGURU3_TEMP_SENSOR)
+                value *= 1000;
+
+        return sprintf(buf, "%d\n", value);
+}
+
+static ssize_t show_alarm(struct device *dev,
+        struct device_attribute *devattr, char *buf)
+{
+        int port;
+        struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
+        struct abituguru3_data *data = abituguru3_update_device(dev);
+
+        if (!data)
+                return -EIO;
+
+        port = data->sensors[attr->index].port;
+
+        /* See if the alarm bit for this sensor is set and if a bitmask is
+           given in attr->nr also check if the alarm matches the type of alarm
+           we're looking for (for volt it can be either low or high). The type
+           is stored in a few readonly bits in the settings of the sensor. */
+        if ((data->alarms[port / 8] & (0x01 << (port % 8))) &&
+                        (!attr->nr || (data->settings[port][0] & attr->nr)))
+                return sprintf(buf, "1\n");
+        else
+                return sprintf(buf, "0\n");
+}
+
+static ssize_t show_mask(struct device *dev,
+        struct device_attribute *devattr, char *buf)
+{
+        struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
+        struct abituguru3_data *data = dev_get_drvdata(dev);
+
+        if (data->settings[data->sensors[attr->index].port][0] & attr->nr)
+                return sprintf(buf, "1\n");
+        else
+                return sprintf(buf, "0\n");
+}
+
+static ssize_t show_label(struct device *dev,
+        struct device_attribute *devattr, char *buf)
+{
+        struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
+        struct abituguru3_data *data = dev_get_drvdata(dev);
+
+        return sprintf(buf, "%s\n", data->sensors[attr->index].name);
+}
+
+static ssize_t show_name(struct device *dev,
+        struct device_attribute *devattr, char *buf)
+{
+        return sprintf(buf, "%s\n", ABIT_UGURU3_NAME);
+}
+
+/* Sysfs attr templates, the real entries are generated automatically. */
+static const
+struct sensor_device_attribute_2 abituguru3_sysfs_templ[3][10] = { {
+        SENSOR_ATTR_2(in%d_input, 0444, show_value, NULL, 0, 0),
+        SENSOR_ATTR_2(in%d_min, 0444, show_value, NULL, 1, 0),
+        SENSOR_ATTR_2(in%d_max, 0444, show_value, NULL, 2, 0),
+        SENSOR_ATTR_2(in%d_min_alarm, 0444, show_alarm, NULL,
+                ABIT_UGURU3_VOLT_LOW_ALARM_FLAG, 0),
+        SENSOR_ATTR_2(in%d_max_alarm, 0444, show_alarm, NULL,
+                ABIT_UGURU3_VOLT_HIGH_ALARM_FLAG, 0),
+        SENSOR_ATTR_2(in%d_beep, 0444, show_mask, NULL,
+                ABIT_UGURU3_BEEP_ENABLE, 0),
+        SENSOR_ATTR_2(in%d_shutdown, 0444, show_mask, NULL,
+                ABIT_UGURU3_SHUTDOWN_ENABLE, 0),
+        SENSOR_ATTR_2(in%d_min_alarm_enable, 0444, show_mask, NULL,
+                ABIT_UGURU3_VOLT_LOW_ALARM_ENABLE, 0),
+        SENSOR_ATTR_2(in%d_max_alarm_enable, 0444, show_mask, NULL,
+                ABIT_UGURU3_VOLT_HIGH_ALARM_ENABLE, 0),
+        SENSOR_ATTR_2(in%d_label, 0444, show_label, NULL, 0, 0)
+        }, {
+        SENSOR_ATTR_2(temp%d_input, 0444, show_value, NULL, 0, 0),
+        SENSOR_ATTR_2(temp%d_max, 0444, show_value, NULL, 1, 0),
+        SENSOR_ATTR_2(temp%d_crit, 0444, show_value, NULL, 2, 0),
+        SENSOR_ATTR_2(temp%d_alarm, 0444, show_alarm, NULL, 0, 0),
+        SENSOR_ATTR_2(temp%d_beep, 0444, show_mask, NULL,
+                ABIT_UGURU3_BEEP_ENABLE, 0),
+        SENSOR_ATTR_2(temp%d_shutdown, 0444, show_mask, NULL,
+                ABIT_UGURU3_SHUTDOWN_ENABLE, 0),
+        SENSOR_ATTR_2(temp%d_alarm_enable, 0444, show_mask, NULL,
+                ABIT_UGURU3_TEMP_HIGH_ALARM_ENABLE, 0),
+        SENSOR_ATTR_2(temp%d_label, 0444, show_label, NULL, 0, 0)
+        }, {
+        SENSOR_ATTR_2(fan%d_input, 0444, show_value, NULL, 0, 0),
+        SENSOR_ATTR_2(fan%d_min, 0444, show_value, NULL, 1, 0),
+        SENSOR_ATTR_2(fan%d_alarm, 0444, show_alarm, NULL, 0, 0),
+        SENSOR_ATTR_2(fan%d_beep, 0444, show_mask, NULL,
+                ABIT_UGURU3_BEEP_ENABLE, 0),
+        SENSOR_ATTR_2(fan%d_shutdown, 0444, show_mask, NULL,
+                ABIT_UGURU3_SHUTDOWN_ENABLE, 0),
+        SENSOR_ATTR_2(fan%d_alarm_enable, 0444, show_mask, NULL,
+                ABIT_UGURU3_FAN_LOW_ALARM_ENABLE, 0),
+        SENSOR_ATTR_2(fan%d_label, 0444, show_label, NULL, 0, 0)
+} };
+
+static struct sensor_device_attribute_2 abituguru3_sysfs_attr[] = {
+        SENSOR_ATTR_2(name, 0444, show_name, NULL, 0, 0),
+};
+
+static int __devinit abituguru3_probe(struct platform_device *pdev)
+{
+        const int no_sysfs_attr[3] = { 10, 8, 7 };
+        int sensor_index[3] = { 0, 1, 1 };
+        struct abituguru3_data *data;
+        int i, j, type, used, sysfs_names_free, sysfs_attr_i, res = -ENODEV;
+        char *sysfs_filename;
+        u8 buf[2];
+        u16 id;
+
+        if (!(data = kzalloc(sizeof(struct abituguru3_data), GFP_KERNEL)))
+                return -ENOMEM;
+
+        data->addr = platform_get_resource(pdev, IORESOURCE_IO, 0)->start;
+        mutex_init(&data->update_lock);
+        platform_set_drvdata(pdev, data);
+
+        /* Read the motherboard ID */
+        if ((i = abituguru3_read(data, ABIT_UGURU3_MISC_BANK,
+                        ABIT_UGURU3_BOARD_ID, 2, buf)) != 2) {
+                goto abituguru3_probe_error;
+        }
+
+        /* Completely read the uGuru to see if one really is there */
+        if (!abituguru3_update_device(&pdev->dev))
+                goto abituguru3_probe_error;
+
+        /* lookup the ID in our motherboard table */
+        id = ((u16)buf[0] << 8) | (u16)buf[1];
+        for (i = 0; abituguru3_motherboards[i].id; i++)
+                if (abituguru3_motherboards[i].id == id)
+                        break;
+        if (!abituguru3_motherboards[i].id) {
+                printk(KERN_ERR ABIT_UGURU3_NAME ": error unknown motherboard "
+                        "ID: %04X. Please report this to the abituguru3 "
+                        "maintainer (see MAINTAINERS)\n", (unsigned int)id);
+                goto abituguru3_probe_error;
+        }
+        data->sensors = abituguru3_motherboards[i].sensors;
+        printk(KERN_INFO ABIT_UGURU3_NAME ": found Abit uGuru3, motherboard "
+                "ID: %04X (%s)\n", (unsigned int)id,
+                abituguru3_motherboards[i].name);
+
+        /* Fill the sysfs attr array */
+        sysfs_attr_i = 0;
+        sysfs_filename = data->sysfs_names;
+        sysfs_names_free = ABIT_UGURU3_SYSFS_NAMES_LENGTH;
+        for (i = 0; data->sensors[i].name; i++) {
+                /* Fail safe check, this should never happen! */
+                if (i >= ABIT_UGURU3_MAX_NO_SENSORS) {
+                        printk(KERN_ERR ABIT_UGURU3_NAME
+                                ": Fatal error motherboard has more sensors "
+                                "then ABIT_UGURU3_MAX_NO_SENSORS. This should "
+                                "never happen please report to the abituguru3 "
+                                "maintainer (see MAINTAINERS)\n");
+                        res = -ENAMETOOLONG;
+                        goto abituguru3_probe_error;
+                }
+                type = data->sensors[i].type;
+                for (j = 0; j < no_sysfs_attr[type]; j++) {
+                        used = snprintf(sysfs_filename, sysfs_names_free,
+                                abituguru3_sysfs_templ[type][j].dev_attr.attr.
+                                name, sensor_index[type]) + 1;
+                        data->sysfs_attr[sysfs_attr_i] =
+                                abituguru3_sysfs_templ[type][j];
+                        data->sysfs_attr[sysfs_attr_i].dev_attr.attr.name =
+                                sysfs_filename;
+                        data->sysfs_attr[sysfs_attr_i].index = i;
+                        sysfs_filename += used;
+                        sysfs_names_free -= used;
+                        sysfs_attr_i++;
+                }
+                sensor_index[type]++;
+        }
+        /* Fail safe check, this should never happen! */
+        if (sysfs_names_free < 0) {
+                printk(KERN_ERR ABIT_UGURU3_NAME
+                        ": Fatal error ran out of space for sysfs attr names. "
+                        "This should never happen please report to the "
+                        "abituguru3 maintainer (see MAINTAINERS)\n");
+                res = -ENAMETOOLONG;
+                goto abituguru3_probe_error;
+        }
+
+        /* Register sysfs hooks */
+        for (i = 0; i < sysfs_attr_i; i++)
+                if (device_create_file(&pdev->dev,
+                                &data->sysfs_attr[i].dev_attr))
+                        goto abituguru3_probe_error;
+        for (i = 0; i < ARRAY_SIZE(abituguru3_sysfs_attr); i++)
+                if (device_create_file(&pdev->dev,
+                                &abituguru3_sysfs_attr[i].dev_attr))
+                        goto abituguru3_probe_error;
+
+        data->class_dev = hwmon_device_register(&pdev->dev);
+        if (IS_ERR(data->class_dev)) {
+                res = PTR_ERR(data->class_dev);
+                goto abituguru3_probe_error;
+        }
+
+        return 0; /* success */
+
+abituguru3_probe_error:
+        for (i = 0; data->sysfs_attr[i].dev_attr.attr.name; i++)
+                device_remove_file(&pdev->dev, &data->sysfs_attr[i].dev_attr);
+        for (i = 0; i < ARRAY_SIZE(abituguru3_sysfs_attr); i++)
+                device_remove_file(&pdev->dev,
+                        &abituguru3_sysfs_attr[i].dev_attr);
+        kfree(data);
+        return res;
+}
+
+static int __devexit abituguru3_remove(struct platform_device *pdev)
+{
+        int i;
+        struct abituguru3_data *data = platform_get_drvdata(pdev);
+
+        platform_set_drvdata(pdev, NULL);
+        hwmon_device_unregister(data->class_dev);
+        for (i = 0; data->sysfs_attr[i].dev_attr.attr.name; i++)
+                device_remove_file(&pdev->dev, &data->sysfs_attr[i].dev_attr);
+        for (i = 0; i < ARRAY_SIZE(abituguru3_sysfs_attr); i++)
+                device_remove_file(&pdev->dev,
+                        &abituguru3_sysfs_attr[i].dev_attr);
+        kfree(data);
+
+        return 0;
+}
+
+static struct abituguru3_data *abituguru3_update_device(struct device *dev)
+{
+        int i;
+        struct abituguru3_data *data = dev_get_drvdata(dev);
+
+        mutex_lock(&data->update_lock);
+        if (!data->valid || time_after(jiffies, data->last_updated + HZ)) {
+                /* Clear data->valid while updating */
+                data->valid = 0;
+                /* Read alarms */
+                if (abituguru3_read_increment_offset(data,
+                                ABIT_UGURU3_SETTINGS_BANK,
+                                ABIT_UGURU3_ALARMS_START,
+                                1, data->alarms, 48/8) != (48/8))
+                        goto LEAVE_UPDATE;
+                /* Read in and temp sensors (3 byte settings / sensor) */
+                for (i = 0; i < 32; i++) {
+                        if (abituguru3_read(data, ABIT_UGURU3_SENSORS_BANK,
+                                        ABIT_UGURU3_VALUES_START + i,
+                                        1, &data->value[i]) != 1)
+                                goto LEAVE_UPDATE;
+                        if (abituguru3_read_increment_offset(data,
+                                        ABIT_UGURU3_SETTINGS_BANK,
+                                        ABIT_UGURU3_SETTINGS_START + i * 3,
+                                        1,
+                                        data->settings[i], 3) != 3)
+                                goto LEAVE_UPDATE;
+                }
+                /* Read temp sensors (2 byte settings / sensor) */
+                for (i = 0; i < 16; i++) {
+                        if (abituguru3_read(data, ABIT_UGURU3_SENSORS_BANK,
+                                        ABIT_UGURU3_VALUES_START + 32 + i,
+                                        1, &data->value[32 + i]) != 1)
+                                goto LEAVE_UPDATE;
+                        if (abituguru3_read_increment_offset(data,
+                                        ABIT_UGURU3_SETTINGS_BANK,
+                                        ABIT_UGURU3_SETTINGS_START + 32 * 3 +
+                                                i * 2, 1,
+                                        data->settings[32 + i], 2) != 2)
+                                goto LEAVE_UPDATE;
+                }
+                data->last_updated = jiffies;
+                data->valid = 1;
+        }
+LEAVE_UPDATE:
+        mutex_unlock(&data->update_lock);
+        if (data->valid)
+                return data;
+        else
+                return NULL;
+}
+
+#ifdef CONFIG_PM
+static int abituguru3_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct abituguru3_data *data = platform_get_drvdata(pdev);
+        /* make sure all communications with the uguru3 are done and no new
+           ones are started */
+        mutex_lock(&data->update_lock);
+        return 0;
+}
+
+static int abituguru3_resume(struct platform_device *pdev)
+{
+        struct abituguru3_data *data = platform_get_drvdata(pdev);
+        mutex_unlock(&data->update_lock);
+        return 0;
+}
+#else
+#define abituguru3_suspend      NULL
+#define abituguru3_resume       NULL
+#endif /* CONFIG_PM */
+
+static struct platform_driver abituguru3_driver = {
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = ABIT_UGURU3_NAME,
+        },
+        .probe  = abituguru3_probe,
+        .remove = __devexit_p(abituguru3_remove),
+        .suspend = abituguru3_suspend,
+        .resume = abituguru3_resume
+};
+
+static int __init abituguru3_detect(void)
+{
+        /* See if there is an uguru3 there. An idle uGuru3 will hold 0x00 or
+           0x08 at DATA and 0xAC at CMD. Sometimes the uGuru3 will hold 0x05
+           at CMD instead, why is unknown. So we test for 0x05 too. */
+        u8 data_val = inb_p(ABIT_UGURU3_BASE + ABIT_UGURU3_DATA);
+        u8 cmd_val = inb_p(ABIT_UGURU3_BASE + ABIT_UGURU3_CMD);
+        if (((data_val == 0x00) || (data_val == 0x08)) &&
+                        ((cmd_val == 0xAC) || (cmd_val == 0x05)))
+                return ABIT_UGURU3_BASE;
+
+        ABIT_UGURU3_DEBUG("no Abit uGuru3 found, data = 0x%02X, cmd = "
+                "0x%02X\n", (unsigned int)data_val, (unsigned int)cmd_val);
+
+        if (force) {
+                printk(KERN_INFO ABIT_UGURU3_NAME ": Assuming Abit uGuru3 is "
+                                "present because of \"force\" parameter\n");
+                return ABIT_UGURU3_BASE;
+        }
+
+        /* No uGuru3 found */
+        return -ENODEV;
+}
+
+static struct platform_device *abituguru3_pdev;
+
+static int __init abituguru3_init(void)
+{
+        int address, err;
+        struct resource res = { .flags = IORESOURCE_IO };
+
+        address = abituguru3_detect();
+        if (address < 0)
+                return address;
+
+        err = platform_driver_register(&abituguru3_driver);
+        if (err)
+                goto exit;
+
+        abituguru3_pdev = platform_device_alloc(ABIT_UGURU3_NAME, address);
+        if (!abituguru3_pdev) {
+                printk(KERN_ERR ABIT_UGURU3_NAME
+                        ": Device allocation failed\n");
+                err = -ENOMEM;
+                goto exit_driver_unregister;
+        }
+
+        res.start = address;
+        res.end = address + ABIT_UGURU3_REGION_LENGTH - 1;
+        res.name = ABIT_UGURU3_NAME;
+
+        err = platform_device_add_resources(abituguru3_pdev, &res, 1);
+        if (err) {
+                printk(KERN_ERR ABIT_UGURU3_NAME
+                        ": Device resource addition failed (%d)\n", err);
+                goto exit_device_put;
+        }
+
+        err = platform_device_add(abituguru3_pdev);
+        if (err) {
+                printk(KERN_ERR ABIT_UGURU3_NAME
+                        ": Device addition failed (%d)\n", err);
+                goto exit_device_put;
+        }
+
+        return 0;
+
+exit_device_put:
+        platform_device_put(abituguru3_pdev);
+exit_driver_unregister:
+        platform_driver_unregister(&abituguru3_driver);
+exit:
+        return err;
+}
+
+static void __exit abituguru3_exit(void)
+{
+        platform_device_unregister(abituguru3_pdev);
+        platform_driver_unregister(&abituguru3_driver);
+}
+
+MODULE_AUTHOR("Hans de Goede <j.w.r.degoede@hhs.nl>");
+MODULE_DESCRIPTION("Abit uGuru3 Sensor device");
+MODULE_LICENSE("GPL");
+
+module_init(abituguru3_init);
+module_exit(abituguru3_exit);
diff --git a/drivers/hwmon/coretemp.c b/drivers/hwmon/coretemp.c
index 6d54c8caed79..7c1795225b06 100644
--- a/drivers/hwmon/coretemp.c
+++ b/drivers/hwmon/coretemp.c
@@ -318,7 +318,7 @@ exit:
 }
 
 #ifdef CONFIG_HOTPLUG_CPU
-void coretemp_device_remove(unsigned int cpu)
+static void coretemp_device_remove(unsigned int cpu)
 {
         struct pdev_entry *p, *n;
         mutex_lock(&pdev_list_mutex);
diff --git a/drivers/hwmon/dme1737.c b/drivers/hwmon/dme1737.c
new file mode 100644
index 000000000000..be3aaa5d0b91
--- /dev/null
+++ b/drivers/hwmon/dme1737.c
@@ -0,0 +1,2080 @@
+/*
+ * dme1737.c - driver for the SMSC DME1737 and Asus A8000 Super-I/O chips
+ *             integrated hardware monitoring features.
+ * Copyright (c) 2007 Juerg Haefliger <juergh@gmail.com>
+ *
+ * This driver is based on the LM85 driver. The hardware monitoring
+ * capabilities of the DME1737 are very similar to the LM85 with some
+ * additional features. Even though the DME1737 is a Super-I/O chip, the
+ * hardware monitoring registers are only accessible via SMBus.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/jiffies.h>
+#include <linux/i2c.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/hwmon-vid.h>
+#include <linux/err.h>
+#include <linux/mutex.h>
+#include <asm/io.h>
+
+/* Module load parameters */
+static int force_start;
+module_param(force_start, bool, 0);
+MODULE_PARM_DESC(force_start, "Force the chip to start monitoring inputs");
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = {0x2c, 0x2d, 0x2e, I2C_CLIENT_END};
+
+/* Insmod parameters */
+I2C_CLIENT_INSMOD_1(dme1737);
+
+/* ---------------------------------------------------------------------
+ * Registers
+ *
+ * The sensors are defined as follows:
+ *
+ * Voltages                          Temperatures
+ * --------                          ------------
+ * in0   +5VTR (+5V stdby)           temp1   Remote diode 1
+ * in1   Vccp  (proc core)           temp2   Internal temp
+ * in2   VCC   (internal +3.3V)      temp3   Remote diode 2
+ * in3   +5V
+ * in4   +12V
+ * in5   VTR   (+3.3V stby)
+ * in6   Vbat
+ *
+ * --------------------------------------------------------------------- */
+
+/* Voltages (in) numbered 0-6 (ix) */
+#define DME1737_REG_IN(ix)              ((ix) < 5 ? 0x20 + (ix) \
+                                                  : 0x94 + (ix))
+#define DME1737_REG_IN_MIN(ix)          ((ix) < 5 ? 0x44 + (ix) * 2 \
+                                                  : 0x91 + (ix) * 2)
+#define DME1737_REG_IN_MAX(ix)          ((ix) < 5 ? 0x45 + (ix) * 2 \
+                                                  : 0x92 + (ix) * 2)
+
+/* Temperatures (temp) numbered 0-2 (ix) */
+#define DME1737_REG_TEMP(ix)            (0x25 + (ix))
+#define DME1737_REG_TEMP_MIN(ix)        (0x4e + (ix) * 2)
+#define DME1737_REG_TEMP_MAX(ix)        (0x4f + (ix) * 2)
+#define DME1737_REG_TEMP_OFFSET(ix)     ((ix) == 0 ? 0x1f \
+                                                   : 0x1c + (ix))
+
+/* Voltage and temperature LSBs
+ * The LSBs (4 bits each) are stored in 5 registers with the following layouts:
+ *    IN_TEMP_LSB(0) = [in5, in6]
+ *    IN_TEMP_LSB(1) = [temp3, temp1]
+ *    IN_TEMP_LSB(2) = [in4, temp2]
+ *    IN_TEMP_LSB(3) = [in3, in0]
+ *    IN_TEMP_LSB(4) = [in2, in1] */
+#define DME1737_REG_IN_TEMP_LSB(ix)     (0x84 + (ix))
+static const u8 DME1737_REG_IN_LSB[] = {3, 4, 4, 3, 2, 0, 0};
+static const u8 DME1737_REG_IN_LSB_SHL[] = {4, 4, 0, 0, 0, 0, 4};
+static const u8 DME1737_REG_TEMP_LSB[] = {1, 2, 1};
+static const u8 DME1737_REG_TEMP_LSB_SHL[] = {4, 4, 0};
+
+/* Fans numbered 0-5 (ix) */
+#define DME1737_REG_FAN(ix)             ((ix) < 4 ? 0x28 + (ix) * 2 \
+                                                  : 0xa1 + (ix) * 2)
+#define DME1737_REG_FAN_MIN(ix)         ((ix) < 4 ? 0x54 + (ix) * 2 \
+                                                  : 0xa5 + (ix) * 2)
+#define DME1737_REG_FAN_OPT(ix)         ((ix) < 4 ? 0x90 + (ix) \
+                                                  : 0xb2 + (ix))
+#define DME1737_REG_FAN_MAX(ix)         (0xb4 + (ix)) /* only for fan[4-5] */
+
+/* PWMs numbered 0-2, 4-5 (ix) */
+#define DME1737_REG_PWM(ix)             ((ix) < 3 ? 0x30 + (ix) \
+                                                  : 0xa1 + (ix))
+#define DME1737_REG_PWM_CONFIG(ix)      (0x5c + (ix)) /* only for pwm[0-2] */
+#define DME1737_REG_PWM_MIN(ix)         (0x64 + (ix)) /* only for pwm[0-2] */
+#define DME1737_REG_PWM_FREQ(ix)        ((ix) < 3 ? 0x5f + (ix) \
+                                                  : 0xa3 + (ix))
+/* The layout of the ramp rate registers is different from the other pwm
+ * registers. The bits for the 3 PWMs are stored in 2 registers:
+ *    PWM_RR(0) = [OFF3, OFF2,  OFF1,  RES,   RR1E, RR1-2, RR1-1, RR1-0]
+ *    PWM_RR(1) = [RR2E, RR2-2, RR2-1, RR2-0, RR3E, RR3-2, RR3-1, RR3-0] */
+#define DME1737_REG_PWM_RR(ix)          (0x62 + (ix)) /* only for pwm[0-2] */
+
+/* Thermal zones 0-2 */
+#define DME1737_REG_ZONE_LOW(ix)        (0x67 + (ix))
+#define DME1737_REG_ZONE_ABS(ix)        (0x6a + (ix))
+/* The layout of the hysteresis registers is different from the other zone
+ * registers. The bits for the 3 zones are stored in 2 registers:
+ *    ZONE_HYST(0) = [H1-3,  H1-2,  H1-1, H1-0, H2-3, H2-2, H2-1, H2-0]
+ *    ZONE_HYST(1) = [H3-3,  H3-2,  H3-1, H3-0, RES,  RES,  RES,  RES] */
+#define DME1737_REG_ZONE_HYST(ix)       (0x6d + (ix))
+
+/* Alarm registers and bit mapping
+ * The 3 8-bit alarm registers will be concatenated to a single 32-bit
+ * alarm value [0, ALARM3, ALARM2, ALARM1]. */
+#define DME1737_REG_ALARM1              0x41
+#define DME1737_REG_ALARM2              0x42
+#define DME1737_REG_ALARM3              0x83
+static const u8 DME1737_BIT_ALARM_IN[] = {0, 1, 2, 3, 8, 16, 17};
+static const u8 DME1737_BIT_ALARM_TEMP[] = {4, 5, 6};
+static const u8 DME1737_BIT_ALARM_FAN[] = {10, 11, 12, 13, 22, 23};
+
+/* Miscellaneous registers */
+#define DME1737_REG_COMPANY             0x3e
+#define DME1737_REG_VERSTEP             0x3f
+#define DME1737_REG_CONFIG              0x40
+#define DME1737_REG_CONFIG2             0x7f
+#define DME1737_REG_VID                 0x43
+#define DME1737_REG_TACH_PWM            0x81
+
+/* ---------------------------------------------------------------------
+ * Misc defines
+ * --------------------------------------------------------------------- */
+
+/* Chip identification */
+#define DME1737_COMPANY_SMSC    0x5c
+#define DME1737_VERSTEP         0x88
+#define DME1737_VERSTEP_MASK    0xf8
+
+/* ---------------------------------------------------------------------
+ * Data structures and manipulation thereof
+ * --------------------------------------------------------------------- */
+
+struct dme1737_data {
+        struct i2c_client client;
+        struct class_device *class_dev;
+
+        struct mutex update_lock;
+        int valid;                      /* !=0 if following fields are valid */
+        unsigned long last_update;      /* in jiffies */
+        unsigned long last_vbat;        /* in jiffies */
+
+        u8 vid;
+        u8 pwm_rr_en;
+        u8 has_pwm;
+        u8 has_fan;
+
+        /* Register values */
+        u16 in[7];
+        u8  in_min[7];
+        u8  in_max[7];
+        s16 temp[3];
+        s8  temp_min[3];
+        s8  temp_max[3];
+        s8  temp_offset[3];
+        u8  config;
+        u8  config2;
+        u8  vrm;
+        u16 fan[6];
+        u16 fan_min[6];
+        u8  fan_max[2];
+        u8  fan_opt[6];
+        u8  pwm[6];
+        u8  pwm_min[3];
+        u8  pwm_config[3];
+        u8  pwm_acz[3];
+        u8  pwm_freq[6];
+        u8  pwm_rr[2];
+        u8  zone_low[3];
+        u8  zone_abs[3];
+        u8  zone_hyst[2];
+        u32 alarms;
+};
+
+/* Nominal voltage values */
+static const int IN_NOMINAL[] = {5000, 2250, 3300, 5000, 12000, 3300, 3300};
+
+/* Voltage input
+ * Voltage inputs have 16 bits resolution, limit values have 8 bits
+ * resolution. */
+static inline int IN_FROM_REG(int reg, int ix, int res)
+{
+        return (reg * IN_NOMINAL[ix] + (3 << (res - 3))) / (3 << (res - 2));
+}
+
+static inline int IN_TO_REG(int val, int ix)
+{
+        return SENSORS_LIMIT((val * 192 + IN_NOMINAL[ix] / 2) /
+                             IN_NOMINAL[ix], 0, 255);
+}
+
+/* Temperature input
+ * The register values represent temperatures in 2's complement notation from
+ * -127 degrees C to +127 degrees C. Temp inputs have 16 bits resolution, limit
+ * values have 8 bits resolution. */
+static inline int TEMP_FROM_REG(int reg, int res)
+{
+        return (reg * 1000) >> (res - 8);
+}
+
+static inline int TEMP_TO_REG(int val)
+{
+        return SENSORS_LIMIT((val < 0 ? val - 500 : val + 500) / 1000,
+                             -128, 127);
+}
+
+/* Temperature range */
+static const int TEMP_RANGE[] = {2000, 2500, 3333, 4000, 5000, 6666, 8000,
+                                 10000, 13333, 16000, 20000, 26666, 32000,
+                                 40000, 53333, 80000};
+
+static inline int TEMP_RANGE_FROM_REG(int reg)
+{
+        return TEMP_RANGE[(reg >> 4) & 0x0f];
+}
+
+static int TEMP_RANGE_TO_REG(int val, int reg)
+{
+        int i;
+
+        for (i = 15; i > 0; i--) {
+                if (val > (TEMP_RANGE[i] + TEMP_RANGE[i - 1] + 1) / 2) {
+                        break;
+                }
+        }
+
+        return (reg & 0x0f) | (i << 4);
+}
+
+/* Temperature hysteresis
+ * Register layout:
+ *    reg[0] = [H1-3, H1-2, H1-1, H1-0, H2-3, H2-2, H2-1, H2-0]
+ *    reg[1] = [H3-3, H3-2, H3-1, H3-0, xxxx, xxxx, xxxx, xxxx] */
+static inline int TEMP_HYST_FROM_REG(int reg, int ix)
+{
+        return (((ix == 1) ? reg : reg >> 4) & 0x0f) * 1000;
+}
+
+static inline int TEMP_HYST_TO_REG(int val, int ix, int reg)
+{
+        int hyst = SENSORS_LIMIT((val + 500) / 1000, 0, 15);
+
+        return (ix == 1) ? (reg & 0xf0) | hyst : (reg & 0x0f) | (hyst << 4);
+}
+
+/* Fan input RPM */
+static inline int FAN_FROM_REG(int reg, int tpc)
+{
+        return (reg == 0 || reg == 0xffff) ? 0 :
+                (tpc == 0) ? 90000 * 60 / reg : tpc * reg;
+}
+
+static inline int FAN_TO_REG(int val, int tpc)
+{
+        return SENSORS_LIMIT((tpc == 0) ? 90000 * 60 / val : val / tpc,
+                             0, 0xffff);
+}
+
+/* Fan TPC (tach pulse count)
+ * Converts a register value to a TPC multiplier or returns 0 if the tachometer
+ * is configured in legacy (non-tpc) mode */
+static inline int FAN_TPC_FROM_REG(int reg)
+{
+        return (reg & 0x20) ? 0 : 60 >> (reg & 0x03);
+}
+
+/* Fan type
+ * The type of a fan is expressed in number of pulses-per-revolution that it
+ * emits */
+static inline int FAN_TYPE_FROM_REG(int reg)
+{
+        int edge = (reg >> 1) & 0x03;
+
+        return (edge > 0) ? 1 << (edge - 1) : 0;
+}
+
+static inline int FAN_TYPE_TO_REG(int val, int reg)
+{
+        int edge = (val == 4) ? 3 : val;
+
+        return (reg & 0xf9) | (edge << 1);
+}
+
+/* Fan max RPM */
+static const int FAN_MAX[] = {0x54, 0x38, 0x2a, 0x21, 0x1c, 0x18, 0x15, 0x12,
+                              0x11, 0x0f, 0x0e};
+
+static int FAN_MAX_FROM_REG(int reg)
+{
+        int i;
+
+        for (i = 10; i > 0; i--) {
+                if (reg == FAN_MAX[i]) {
+                        break;
+                }
+        }
+
+        return 1000 + i * 500;
+}
+
+static int FAN_MAX_TO_REG(int val)
+{
+        int i;
+
+        for (i = 10; i > 0; i--) {
+                if (val > (1000 + (i - 1) * 500)) {
+                        break;
+                }
+        }
+
+        return FAN_MAX[i];
+}
+
+/* PWM enable
+ * Register to enable mapping:
+ * 000:  2  fan on zone 1 auto
+ * 001:  2  fan on zone 2 auto
+ * 010:  2  fan on zone 3 auto
+ * 011:  0  fan full on
+ * 100: -1  fan disabled
+ * 101:  2  fan on hottest of zones 2,3 auto
+ * 110:  2  fan on hottest of zones 1,2,3 auto
+ * 111:  1  fan in manual mode */
+static inline int PWM_EN_FROM_REG(int reg)
+{
+        static const int en[] = {2, 2, 2, 0, -1, 2, 2, 1};
+
+        return en[(reg >> 5) & 0x07];
+}
+
+static inline int PWM_EN_TO_REG(int val, int reg)
+{
+        int en = (val == 1) ? 7 : 3;
+
+        return (reg & 0x1f) | ((en & 0x07) << 5);
+}
+
+/* PWM auto channels zone
+ * Register to auto channels zone mapping (ACZ is a bitfield with bit x
+ * corresponding to zone x+1):
+ * 000: 001  fan on zone 1 auto
+ * 001: 010  fan on zone 2 auto
+ * 010: 100  fan on zone 3 auto
+ * 011: 000  fan full on
+ * 100: 000  fan disabled
+ * 101: 110  fan on hottest of zones 2,3 auto
+ * 110: 111  fan on hottest of zones 1,2,3 auto
+ * 111: 000  fan in manual mode */
+static inline int PWM_ACZ_FROM_REG(int reg)
+{
+        static const int acz[] = {1, 2, 4, 0, 0, 6, 7, 0};
+
+        return acz[(reg >> 5) & 0x07];
+}
+
+static inline int PWM_ACZ_TO_REG(int val, int reg)
+{
+        int acz = (val == 4) ? 2 : val - 1;
+
+        return (reg & 0x1f) | ((acz & 0x07) << 5);
+}
+
+/* PWM frequency */
+static const int PWM_FREQ[] = {11, 15, 22, 29, 35, 44, 59, 88,
+                               15000, 20000, 30000, 25000, 0, 0, 0, 0};
+
+static inline int PWM_FREQ_FROM_REG(int reg)
+{
+        return PWM_FREQ[reg & 0x0f];
+}
+
+static int PWM_FREQ_TO_REG(int val, int reg)
+{
+        int i;
+
+        /* the first two cases are special - stupid chip design! */
+        if (val > 27500) {
+                i = 10;
+        } else if (val > 22500) {
+                i = 11;
+        } else {
+                for (i = 9; i > 0; i--) {
+                        if (val > (PWM_FREQ[i] + PWM_FREQ[i - 1] + 1) / 2) {
+                                break;
+                        }
+                }
+        }
+
+        return (reg & 0xf0) | i;
+}
+
+/* PWM ramp rate
+ * Register layout:
+ *    reg[0] = [OFF3,  OFF2,  OFF1,  RES,   RR1-E, RR1-2, RR1-1, RR1-0]
+ *    reg[1] = [RR2-E, RR2-2, RR2-1, RR2-0, RR3-E, RR3-2, RR3-1, RR3-0] */
+static const u8 PWM_RR[] = {206, 104, 69, 41, 26, 18, 10, 5};
+
+static inline int PWM_RR_FROM_REG(int reg, int ix)
+{
+        int rr = (ix == 1) ? reg >> 4 : reg;
+
+        return (rr & 0x08) ? PWM_RR[rr & 0x07] : 0;
+}
+
+static int PWM_RR_TO_REG(int val, int ix, int reg)
+{
+        int i;
+
+        for (i = 0; i < 7; i++) {
+                if (val > (PWM_RR[i] + PWM_RR[i + 1] + 1) / 2) {
+                        break;
+                }
+        }
+
+        return (ix == 1) ? (reg & 0x8f) | (i << 4) : (reg & 0xf8) | i;
+}
+
+/* PWM ramp rate enable */
+static inline int PWM_RR_EN_FROM_REG(int reg, int ix)
+{
+        return PWM_RR_FROM_REG(reg, ix) ? 1 : 0;
+}
+
+static inline int PWM_RR_EN_TO_REG(int val, int ix, int reg)
+{
+        int en = (ix == 1) ? 0x80 : 0x08;
+
+        return val ? reg | en : reg & ~en;
+}
+
+/* PWM min/off
+ * The PWM min/off bits are part of the PMW ramp rate register 0 (see above for
+ * the register layout). */
+static inline int PWM_OFF_FROM_REG(int reg, int ix)
+{
+        return (reg >> (ix + 5)) & 0x01;
+}
+
+static inline int PWM_OFF_TO_REG(int val, int ix, int reg)
+{
+        return (reg & ~(1 << (ix + 5))) | ((val & 0x01) << (ix + 5));
+}
+
+/* ---------------------------------------------------------------------
+ * Device I/O access
+ * --------------------------------------------------------------------- */
+
+static u8 dme1737_read(struct i2c_client *client, u8 reg)
+{
+        s32 val = i2c_smbus_read_byte_data(client, reg);
+
+        if (val < 0) {
+                dev_warn(&client->dev, "Read from register 0x%02x failed! "
+                         "Please report to the driver maintainer.\n", reg);
+        }
+
+        return val;
+}
+
+static s32 dme1737_write(struct i2c_client *client, u8 reg, u8 value)
+{
+        s32 res = i2c_smbus_write_byte_data(client, reg, value);
+
+        if (res < 0) {
+                dev_warn(&client->dev, "Write to register 0x%02x failed! "
+                         "Please report to the driver maintainer.\n", reg);
+        }
+
+        return res;
+}
+
+static struct dme1737_data *dme1737_update_device(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct dme1737_data *data = i2c_get_clientdata(client);
+        int ix;
+        u8 lsb[5];
+
+        mutex_lock(&data->update_lock);
+
+        /* Enable a Vbat monitoring cycle every 10 mins */
+        if (time_after(jiffies, data->last_vbat + 600 * HZ) || !data->valid) {
+                dme1737_write(client, DME1737_REG_CONFIG, dme1737_read(client,
+                                                DME1737_REG_CONFIG) | 0x10);
+                data->last_vbat = jiffies;
+        }
+
+        /* Sample register contents every 1 sec */
+        if (time_after(jiffies, data->last_update + HZ) || !data->valid) {
+                data->vid = dme1737_read(client, DME1737_REG_VID) & 0x3f;
+
+                /* In (voltage) registers */
+                for (ix = 0; ix < ARRAY_SIZE(data->in); ix++) {
+                        /* Voltage inputs are stored as 16 bit values even
+                         * though they have only 12 bits resolution. This is
+                         * to make it consistent with the temp inputs. */
+                        data->in[ix] = dme1737_read(client,
+                                        DME1737_REG_IN(ix)) << 8;
+                        data->in_min[ix] = dme1737_read(client,
+                                        DME1737_REG_IN_MIN(ix));
+                        data->in_max[ix] = dme1737_read(client,
+                                        DME1737_REG_IN_MAX(ix));
+                }
+
+                /* Temp registers */
+                for (ix = 0; ix < ARRAY_SIZE(data->temp); ix++) {
+                        /* Temp inputs are stored as 16 bit values even
+                         * though they have only 12 bits resolution. This is
+                         * to take advantage of implicit conversions between
+                         * register values (2's complement) and temp values
+                         * (signed decimal). */
+                        data->temp[ix] = dme1737_read(client,
+                                        DME1737_REG_TEMP(ix)) << 8;
+                        data->temp_min[ix] = dme1737_read(client,
+                                        DME1737_REG_TEMP_MIN(ix));
+                        data->temp_max[ix] = dme1737_read(client,
+                                        DME1737_REG_TEMP_MAX(ix));
+                        data->temp_offset[ix] = dme1737_read(client,
+                                        DME1737_REG_TEMP_OFFSET(ix));
+                }
+
+                /* In and temp LSB registers
+                 * The LSBs are latched when the MSBs are read, so the order in
+                 * which the registers are read (MSB first, then LSB) is
+                 * important! */
+                for (ix = 0; ix < ARRAY_SIZE(lsb); ix++) {
+                        lsb[ix] = dme1737_read(client,
+                                        DME1737_REG_IN_TEMP_LSB(ix));
+                }
+                for (ix = 0; ix < ARRAY_SIZE(data->in); ix++) {
+                        data->in[ix] |= (lsb[DME1737_REG_IN_LSB[ix]] <<
+                                        DME1737_REG_IN_LSB_SHL[ix]) & 0xf0;
+                }
+                for (ix = 0; ix < ARRAY_SIZE(data->temp); ix++) {
+                        data->temp[ix] |= (lsb[DME1737_REG_TEMP_LSB[ix]] <<
+                                        DME1737_REG_TEMP_LSB_SHL[ix]) & 0xf0;
+                }
+
+                /* Fan registers */
+                for (ix = 0; ix < ARRAY_SIZE(data->fan); ix++) {
+                        /* Skip reading registers if optional fans are not
+                         * present */
+                        if (!(data->has_fan & (1 << ix))) {
+                                continue;
+                        }
+                        data->fan[ix] = dme1737_read(client,
+                                        DME1737_REG_FAN(ix));
+                        data->fan[ix] |= dme1737_read(client,
+                                        DME1737_REG_FAN(ix) + 1) << 8;
+                        data->fan_min[ix] = dme1737_read(client,
+                                        DME1737_REG_FAN_MIN(ix));
+                        data->fan_min[ix] |= dme1737_read(client,
+                                        DME1737_REG_FAN_MIN(ix) + 1) << 8;
+                        data->fan_opt[ix] = dme1737_read(client,
+                                        DME1737_REG_FAN_OPT(ix));
+                        /* fan_max exists only for fan[5-6] */
+                        if (ix > 3) {
+                                data->fan_max[ix - 4] = dme1737_read(client,
+                                        DME1737_REG_FAN_MAX(ix));
+                        }
+                }
+
+                /* PWM registers */
+                for (ix = 0; ix < ARRAY_SIZE(data->pwm); ix++) {
+                        /* Skip reading registers if optional PWMs are not
+                         * present */
+                        if (!(data->has_pwm & (1 << ix))) {
+                                continue;
+                        }
+                        data->pwm[ix] = dme1737_read(client,
+                                        DME1737_REG_PWM(ix));
+                        data->pwm_freq[ix] = dme1737_read(client,
+                                        DME1737_REG_PWM_FREQ(ix));
+                        /* pwm_config and pwm_min exist only for pwm[1-3] */
+                        if (ix < 3) {
+                                data->pwm_config[ix] = dme1737_read(client,
+                                                DME1737_REG_PWM_CONFIG(ix));
+                                data->pwm_min[ix] = dme1737_read(client,
+                                                DME1737_REG_PWM_MIN(ix));
+                        }
+                }
+                for (ix = 0; ix < ARRAY_SIZE(data->pwm_rr); ix++) {
+                        data->pwm_rr[ix] = dme1737_read(client,
+                                                DME1737_REG_PWM_RR(ix));
+                }
+
+                /* Thermal zone registers */
+                for (ix = 0; ix < ARRAY_SIZE(data->zone_low); ix++) {
+                        data->zone_low[ix] = dme1737_read(client,
+                                        DME1737_REG_ZONE_LOW(ix));
+                        data->zone_abs[ix] = dme1737_read(client,
+                                        DME1737_REG_ZONE_ABS(ix));
+                }
+                for (ix = 0; ix < ARRAY_SIZE(data->zone_hyst); ix++) {
+                        data->zone_hyst[ix] = dme1737_read(client,
+                                                DME1737_REG_ZONE_HYST(ix));
+                }
+
+                /* Alarm registers */
+                data->alarms = dme1737_read(client,
+                                                DME1737_REG_ALARM1);
+                /* Bit 7 tells us if the other alarm registers are non-zero and
+                 * therefore also need to be read */
+                if (data->alarms & 0x80) {
+                        data->alarms |= dme1737_read(client,
+                                                DME1737_REG_ALARM2) << 8;
+                        data->alarms |= dme1737_read(client,
+                                                DME1737_REG_ALARM3) << 16;
+                }
+
+                data->last_update = jiffies;
+                data->valid = 1;
+        }
+
+        mutex_unlock(&data->update_lock);
+
+        return data;
+}
+
+/* ---------------------------------------------------------------------
+ * Voltage sysfs attributes
+ * ix = [0-5]
+ * --------------------------------------------------------------------- */
+
+#define SYS_IN_INPUT    0
+#define SYS_IN_MIN      1
+#define SYS_IN_MAX      2
+#define SYS_IN_ALARM    3
+
+static ssize_t show_in(struct device *dev, struct device_attribute *attr,
+                       char *buf)
+{
+        struct dme1737_data *data = dme1737_update_device(dev);
+        struct sensor_device_attribute_2
+                *sensor_attr_2 = to_sensor_dev_attr_2(attr);
+        int ix = sensor_attr_2->index;
+        int fn = sensor_attr_2->nr;
+        int res;
+
+        switch (fn) {
+        case SYS_IN_INPUT:
+                res = IN_FROM_REG(data->in[ix], ix, 16);
+                break;
+        case SYS_IN_MIN:
+                res = IN_FROM_REG(data->in_min[ix], ix, 8);
+                break;
+        case SYS_IN_MAX:
+                res = IN_FROM_REG(data->in_max[ix], ix, 8);
+                break;
+        case SYS_IN_ALARM:
+                res = (data->alarms >> DME1737_BIT_ALARM_IN[ix]) & 0x01;
+                break;
+        default:
+                res = 0;
+                dev_dbg(dev, "Unknown attr fetch (%d)\n", fn);
+        }
+
+        return sprintf(buf, "%d\n", res);
+}
+
+static ssize_t set_in(struct device *dev, struct device_attribute *attr,
+                      const char *buf, size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct dme1737_data *data = i2c_get_clientdata(client);
+        struct sensor_device_attribute_2
+                *sensor_attr_2 = to_sensor_dev_attr_2(attr);
+        int ix = sensor_attr_2->index;
+        int fn = sensor_attr_2->nr;
+        long val = simple_strtol(buf, NULL, 10);
+
+        mutex_lock(&data->update_lock);
+        switch (fn) {
+        case SYS_IN_MIN:
+                data->in_min[ix] = IN_TO_REG(val, ix);
+                dme1737_write(client, DME1737_REG_IN_MIN(ix),
+                              data->in_min[ix]);
+                break;
+        case SYS_IN_MAX:
+                data->in_max[ix] = IN_TO_REG(val, ix);
+                dme1737_write(client, DME1737_REG_IN_MAX(ix),
+                              data->in_max[ix]);
+                break;
+        default:
+                dev_dbg(dev, "Unknown attr fetch (%d)\n", fn);
+        }
+        mutex_unlock(&data->update_lock);
+
+        return count;
+}
+
+/* ---------------------------------------------------------------------
+ * Temperature sysfs attributes
+ * ix = [0-2]
+ * --------------------------------------------------------------------- */
+
+#define SYS_TEMP_INPUT                  0
+#define SYS_TEMP_MIN                    1
+#define SYS_TEMP_MAX                    2
+#define SYS_TEMP_OFFSET                 3
+#define SYS_TEMP_ALARM                  4
+#define SYS_TEMP_FAULT                  5
+
+static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
+                         char *buf)
+{
+        struct dme1737_data *data = dme1737_update_device(dev);
+        struct sensor_device_attribute_2
+                *sensor_attr_2 = to_sensor_dev_attr_2(attr);
+        int ix = sensor_attr_2->index;
+        int fn = sensor_attr_2->nr;
+        int res;
+
+        switch (fn) {
+        case SYS_TEMP_INPUT:
+                res = TEMP_FROM_REG(data->temp[ix], 16);
+                break;
+        case SYS_TEMP_MIN:
+                res = TEMP_FROM_REG(data->temp_min[ix], 8);
+                break;
+        case SYS_TEMP_MAX:
+                res = TEMP_FROM_REG(data->temp_max[ix], 8);
+                break;
+        case SYS_TEMP_OFFSET:
+                res = TEMP_FROM_REG(data->temp_offset[ix], 8);
+                break;
+        case SYS_TEMP_ALARM:
+                res = (data->alarms >> DME1737_BIT_ALARM_TEMP[ix]) & 0x01;
+                break;
+        case SYS_TEMP_FAULT:
+                res = (data->temp[ix] == 0x0800);
+                break;
+        default:
+                res = 0;
+                dev_dbg(dev, "Unknown attr fetch (%d)\n", fn);
+        }
+
+        return sprintf(buf, "%d\n", res);
+}
+
+static ssize_t set_temp(struct device *dev, struct device_attribute *attr,
+                        const char *buf, size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct dme1737_data *data = i2c_get_clientdata(client);
+        struct sensor_device_attribute_2
+                *sensor_attr_2 = to_sensor_dev_attr_2(attr);
+        int ix = sensor_attr_2->index;
+        int fn = sensor_attr_2->nr;
+        long val = simple_strtol(buf, NULL, 10);
+
+        mutex_lock(&data->update_lock);
+        switch (fn) {
+        case SYS_TEMP_MIN:
+                data->temp_min[ix] = TEMP_TO_REG(val);
+                dme1737_write(client, DME1737_REG_TEMP_MIN(ix),
+                              data->temp_min[ix]);
+                break;
+        case SYS_TEMP_MAX:
+                data->temp_max[ix] = TEMP_TO_REG(val);
+                dme1737_write(client, DME1737_REG_TEMP_MAX(ix),
+                              data->temp_max[ix]);
+                break;
+        case SYS_TEMP_OFFSET:
+                data->temp_offset[ix] = TEMP_TO_REG(val);
+                dme1737_write(client, DME1737_REG_TEMP_OFFSET(ix),
+                              data->temp_offset[ix]);
+                break;
+        default:
+                dev_dbg(dev, "Unknown attr fetch (%d)\n", fn);
+        }
+        mutex_unlock(&data->update_lock);
+
+        return count;
+}
+
+/* ---------------------------------------------------------------------
+ * Zone sysfs attributes
+ * ix = [0-2]
+ * --------------------------------------------------------------------- */
+
+#define SYS_ZONE_AUTO_CHANNELS_TEMP     0
+#define SYS_ZONE_AUTO_POINT1_TEMP_HYST  1
+#define SYS_ZONE_AUTO_POINT1_TEMP       2
+#define SYS_ZONE_AUTO_POINT2_TEMP       3
+#define SYS_ZONE_AUTO_POINT3_TEMP       4
+
+static ssize_t show_zone(struct device *dev, struct device_attribute *attr,
+                         char *buf)
+{
+        struct dme1737_data *data = dme1737_update_device(dev);
+        struct sensor_device_attribute_2
+                *sensor_attr_2 = to_sensor_dev_attr_2(attr);
+        int ix = sensor_attr_2->index;
+        int fn = sensor_attr_2->nr;
+        int res;
+
+        switch (fn) {
+        case SYS_ZONE_AUTO_CHANNELS_TEMP:
+                /* check config2 for non-standard temp-to-zone mapping */
+                if ((ix == 1) && (data->config2 & 0x02)) {
+                        res = 4;
+                } else {
+                        res = 1 << ix;
+                }
+                break;
+        case SYS_ZONE_AUTO_POINT1_TEMP_HYST:
+                res = TEMP_FROM_REG(data->zone_low[ix], 8) -
+                      TEMP_HYST_FROM_REG(data->zone_hyst[ix == 2], ix);
+                break;
+        case SYS_ZONE_AUTO_POINT1_TEMP:
+                res = TEMP_FROM_REG(data->zone_low[ix], 8);
+                break;
+        case SYS_ZONE_AUTO_POINT2_TEMP:
+                /* pwm_freq holds the temp range bits in the upper nibble */
+                res = TEMP_FROM_REG(data->zone_low[ix], 8) +
+                      TEMP_RANGE_FROM_REG(data->pwm_freq[ix]);
+                break;
+        case SYS_ZONE_AUTO_POINT3_TEMP:
+                res = TEMP_FROM_REG(data->zone_abs[ix], 8);
+                break;
+        default:
+                res = 0;
+                dev_dbg(dev, "Unknown attr fetch (%d)\n", fn);
+        }
+
+        return sprintf(buf, "%d\n", res);
+}
+
+static ssize_t set_zone(struct device *dev, struct device_attribute *attr,
+                        const char *buf, size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct dme1737_data *data = i2c_get_clientdata(client);
+        struct sensor_device_attribute_2
+                *sensor_attr_2 = to_sensor_dev_attr_2(attr);
+        int ix = sensor_attr_2->index;
+        int fn = sensor_attr_2->nr;
+        long val = simple_strtol(buf, NULL, 10);
+
+        mutex_lock(&data->update_lock);
+        switch (fn) {
+        case SYS_ZONE_AUTO_POINT1_TEMP_HYST:
+                /* Refresh the cache */
+                data->zone_low[ix] = dme1737_read(client,
+                                                  DME1737_REG_ZONE_LOW(ix));
+                /* Modify the temp hyst value */
+                data->zone_hyst[ix == 2] = TEMP_HYST_TO_REG(
+                                        TEMP_FROM_REG(data->zone_low[ix], 8) -
+                                        val, ix, dme1737_read(client,
+                                        DME1737_REG_ZONE_HYST(ix == 2)));
+                dme1737_write(client, DME1737_REG_ZONE_HYST(ix == 2),
+                              data->zone_hyst[ix == 2]);
+                break;
+        case SYS_ZONE_AUTO_POINT1_TEMP:
+                data->zone_low[ix] = TEMP_TO_REG(val);
+                dme1737_write(client, DME1737_REG_ZONE_LOW(ix),
+                              data->zone_low[ix]);
+                break;
+        case SYS_ZONE_AUTO_POINT2_TEMP:
+                /* Refresh the cache */
+                data->zone_low[ix] = dme1737_read(client,
+                                                  DME1737_REG_ZONE_LOW(ix));
+                /* Modify the temp range value (which is stored in the upper
+                 * nibble of the pwm_freq register) */
+                data->pwm_freq[ix] = TEMP_RANGE_TO_REG(val -
+                                        TEMP_FROM_REG(data->zone_low[ix], 8),
+                                        dme1737_read(client,
+                                        DME1737_REG_PWM_FREQ(ix)));
+                dme1737_write(client, DME1737_REG_PWM_FREQ(ix),
+                              data->pwm_freq[ix]);
+                break;
+        case SYS_ZONE_AUTO_POINT3_TEMP:
+                data->zone_abs[ix] = TEMP_TO_REG(val);
+                dme1737_write(client, DME1737_REG_ZONE_ABS(ix),
+                              data->zone_abs[ix]);
+                break;
+        default:
+                dev_dbg(dev, "Unknown attr fetch (%d)\n", fn);
+        }
+        mutex_unlock(&data->update_lock);
+
+        return count;
+}
+
+/* ---------------------------------------------------------------------
+ * Fan sysfs attributes
+ * ix = [0-5]
+ * --------------------------------------------------------------------- */
+
+#define SYS_FAN_INPUT   0
+#define SYS_FAN_MIN     1
+#define SYS_FAN_MAX     2
+#define SYS_FAN_ALARM   3
+#define SYS_FAN_TYPE    4
+
+static ssize_t show_fan(struct device *dev, struct device_attribute *attr,
+                        char *buf)
+{
+        struct dme1737_data *data = dme1737_update_device(dev);
+        struct sensor_device_attribute_2
+                *sensor_attr_2 = to_sensor_dev_attr_2(attr);
+        int ix = sensor_attr_2->index;
+        int fn = sensor_attr_2->nr;
+        int res;
+
+        switch (fn) {
+        case SYS_FAN_INPUT:
+                res = FAN_FROM_REG(data->fan[ix],
+                                   ix < 4 ? 0 :
+                                   FAN_TPC_FROM_REG(data->fan_opt[ix]));
+                break;
+        case SYS_FAN_MIN:
+                res = FAN_FROM_REG(data->fan_min[ix],
+                                   ix < 4 ? 0 :
+                                   FAN_TPC_FROM_REG(data->fan_opt[ix]));
+                break;
+        case SYS_FAN_MAX:
+                /* only valid for fan[5-6] */
+                res = FAN_MAX_FROM_REG(data->fan_max[ix - 4]);
+                break;
+        case SYS_FAN_ALARM:
+                res = (data->alarms >> DME1737_BIT_ALARM_FAN[ix]) & 0x01;
+                break;
+        case SYS_FAN_TYPE:
+                /* only valid for fan[1-4] */
+                res = FAN_TYPE_FROM_REG(data->fan_opt[ix]);
+                break;
+        default:
+                res = 0;
+                dev_dbg(dev, "Unknown attr fetch (%d)\n", fn);
+        }
+
+        return sprintf(buf, "%d\n", res);
+}
+
+static ssize_t set_fan(struct device *dev, struct device_attribute *attr,
+                       const char *buf, size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct dme1737_data *data = i2c_get_clientdata(client);
+        struct sensor_device_attribute_2
+                *sensor_attr_2 = to_sensor_dev_attr_2(attr);
+        int ix = sensor_attr_2->index;
+        int fn = sensor_attr_2->nr;
+        long val = simple_strtol(buf, NULL, 10);
+
+        mutex_lock(&data->update_lock);
+        switch (fn) {
+        case SYS_FAN_MIN:
+                if (ix < 4) {
+                        data->fan_min[ix] = FAN_TO_REG(val, 0);
+                } else {
+                        /* Refresh the cache */
+                        data->fan_opt[ix] = dme1737_read(client,
+                                                DME1737_REG_FAN_OPT(ix));
+                        /* Modify the fan min value */
+                        data->fan_min[ix] = FAN_TO_REG(val,
+                                        FAN_TPC_FROM_REG(data->fan_opt[ix]));
+                }
+                dme1737_write(client, DME1737_REG_FAN_MIN(ix),
+                              data->fan_min[ix] & 0xff);
+                dme1737_write(client, DME1737_REG_FAN_MIN(ix) + 1,
+                              data->fan_min[ix] >> 8);
+                break;
+        case SYS_FAN_MAX:
+                /* Only valid for fan[5-6] */
+                data->fan_max[ix - 4] = FAN_MAX_TO_REG(val);
+                dme1737_write(client, DME1737_REG_FAN_MAX(ix),
+                              data->fan_max[ix - 4]);
+                break;
+        case SYS_FAN_TYPE:
+                /* Only valid for fan[1-4] */
+                if (!(val == 1 || val == 2 || val == 4)) {
+                        count = -EINVAL;
+                        dev_warn(&client->dev, "Fan type value %ld not "
+                                 "supported. Choose one of 1, 2, or 4.\n",
+                                 val);
+                        goto exit;
+                }
+                data->fan_opt[ix] = FAN_TYPE_TO_REG(val, dme1737_read(client,
+                                        DME1737_REG_FAN_OPT(ix)));
+                dme1737_write(client, DME1737_REG_FAN_OPT(ix),
+                              data->fan_opt[ix]);
+                break;
+        default:
+                dev_dbg(dev, "Unknown attr fetch (%d)\n", fn);
+        }
+exit:
+        mutex_unlock(&data->update_lock);
+
+        return count;
+}
+
+/* ---------------------------------------------------------------------
+ * PWM sysfs attributes
+ * ix = [0-4]
+ * --------------------------------------------------------------------- */
+
+#define SYS_PWM                         0
+#define SYS_PWM_FREQ                    1
+#define SYS_PWM_ENABLE                  2
+#define SYS_PWM_RAMP_RATE               3
+#define SYS_PWM_AUTO_CHANNELS_ZONE      4
+#define SYS_PWM_AUTO_PWM_MIN            5
+#define SYS_PWM_AUTO_POINT1_PWM         6
+#define SYS_PWM_AUTO_POINT2_PWM         7
+
+static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
+                        char *buf)
+{
+        struct dme1737_data *data = dme1737_update_device(dev);
+        struct sensor_device_attribute_2
+                *sensor_attr_2 = to_sensor_dev_attr_2(attr);
+        int ix = sensor_attr_2->index;
+        int fn = sensor_attr_2->nr;
+        int res;
+
+        switch (fn) {
+        case SYS_PWM:
+                if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 0) {
+                        res = 255;
+                } else {
+                        res = data->pwm[ix];
+                }
+                break;
+        case SYS_PWM_FREQ:
+                res = PWM_FREQ_FROM_REG(data->pwm_freq[ix]);
+                break;
+        case SYS_PWM_ENABLE:
+                if (ix > 3) {
+                        res = 1; /* pwm[5-6] hard-wired to manual mode */
+                } else {
+                        res = PWM_EN_FROM_REG(data->pwm_config[ix]);
+                }
+                break;
+        case SYS_PWM_RAMP_RATE:
+                /* Only valid for pwm[1-3] */
+                res = PWM_RR_FROM_REG(data->pwm_rr[ix > 0], ix);
+                break;
+        case SYS_PWM_AUTO_CHANNELS_ZONE:
+                /* Only valid for pwm[1-3] */
+                if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 2) {
+                        res = PWM_ACZ_FROM_REG(data->pwm_config[ix]);
+                } else {
+                        res = data->pwm_acz[ix];
+                }
+                break;
+        case SYS_PWM_AUTO_PWM_MIN:
+                /* Only valid for pwm[1-3] */
+                if (PWM_OFF_FROM_REG(data->pwm_rr[0], ix)) {
+                        res = data->pwm_min[ix];
+                } else {
+                        res = 0;
+                }
+                break;
+        case SYS_PWM_AUTO_POINT1_PWM:
+                /* Only valid for pwm[1-3] */
+                res = data->pwm_min[ix];
+                break;
+        case SYS_PWM_AUTO_POINT2_PWM:
+                /* Only valid for pwm[1-3] */
+                res = 255; /* hard-wired */
+                break;
+        default:
+                res = 0;
+                dev_dbg(dev, "Unknown attr fetch (%d)\n", fn);
+        }
+
+        return sprintf(buf, "%d\n", res);
+}
+
+static struct attribute *dme1737_attr_pwm[];
+static void dme1737_chmod_file(struct i2c_client*, struct attribute*, mode_t);
+
+static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
+                       const char *buf, size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct dme1737_data *data = i2c_get_clientdata(client);
+        struct sensor_device_attribute_2
+                *sensor_attr_2 = to_sensor_dev_attr_2(attr);
+        int ix = sensor_attr_2->index;
+        int fn = sensor_attr_2->nr;
+        long val = simple_strtol(buf, NULL, 10);
+
+        mutex_lock(&data->update_lock);
+        switch (fn) {
+        case SYS_PWM:
+                data->pwm[ix] = SENSORS_LIMIT(val, 0, 255);
+                dme1737_write(client, DME1737_REG_PWM(ix), data->pwm[ix]);
+                break;
+        case SYS_PWM_FREQ:
+                data->pwm_freq[ix] = PWM_FREQ_TO_REG(val, dme1737_read(client,
+                                                DME1737_REG_PWM_FREQ(ix)));
+                dme1737_write(client, DME1737_REG_PWM_FREQ(ix),
+                              data->pwm_freq[ix]);
+                break;
+        case SYS_PWM_ENABLE:
+                /* Only valid for pwm[1-3] */
+                if (val < 0 || val > 2) {
+                        count = -EINVAL;
+                        dev_warn(&client->dev, "PWM enable %ld not "
+                                 "supported. Choose one of 0, 1, or 2.\n",
+                                 val);
+                        goto exit;
+                }
+                /* Refresh the cache */
+                data->pwm_config[ix] = dme1737_read(client,
+                                                DME1737_REG_PWM_CONFIG(ix));
+                if (val == PWM_EN_FROM_REG(data->pwm_config[ix])) {
+                        /* Bail out if no change */
+                        goto exit;
+                }
+                /* Do some housekeeping if we are currently in auto mode */
+                if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 2) {
+                        /* Save the current zone channel assignment */
+                        data->pwm_acz[ix] = PWM_ACZ_FROM_REG(
+                                                        data->pwm_config[ix]);
+                        /* Save the current ramp rate state and disable it */
+                        data->pwm_rr[ix > 0] = dme1737_read(client,
+                                                DME1737_REG_PWM_RR(ix > 0));
+                        data->pwm_rr_en &= ~(1 << ix);
+                        if (PWM_RR_EN_FROM_REG(data->pwm_rr[ix > 0], ix)) {
+                                data->pwm_rr_en |= (1 << ix);
+                                data->pwm_rr[ix > 0] = PWM_RR_EN_TO_REG(0, ix,
+                                                        data->pwm_rr[ix > 0]);
+                                dme1737_write(client,
+                                              DME1737_REG_PWM_RR(ix > 0),
+                                              data->pwm_rr[ix > 0]);
+                        }
+                }
+                /* Set the new PWM mode */
+                switch (val) {
+                case 0:
+                        /* Change permissions of pwm[ix] to read-only */
+                        dme1737_chmod_file(client, dme1737_attr_pwm[ix],
+                                           S_IRUGO);
+                        /* Turn fan fully on */
+                        data->pwm_config[ix] = PWM_EN_TO_REG(0,
+                                                        data->pwm_config[ix]);
+                        dme1737_write(client, DME1737_REG_PWM_CONFIG(ix),
+                                      data->pwm_config[ix]);
+                        break;
+                case 1:
+                        /* Turn on manual mode */
+                        data->pwm_config[ix] = PWM_EN_TO_REG(1,
+                                                        data->pwm_config[ix]);
+                        dme1737_write(client, DME1737_REG_PWM_CONFIG(ix),
+                                      data->pwm_config[ix]);
+                        /* Change permissions of pwm[ix] to read-writeable */
+                        dme1737_chmod_file(client, dme1737_attr_pwm[ix],
+                                           S_IRUGO | S_IWUSR);
+                        break;
+                case 2:
+                        /* Change permissions of pwm[ix] to read-only */
+                        dme1737_chmod_file(client, dme1737_attr_pwm[ix],
+                                           S_IRUGO);
+                        /* Turn on auto mode using the saved zone channel
+                         * assignment */
+                        data->pwm_config[ix] = PWM_ACZ_TO_REG(
+                                                        data->pwm_acz[ix],
+                                                        data->pwm_config[ix]);
+                        dme1737_write(client, DME1737_REG_PWM_CONFIG(ix),
+                                      data->pwm_config[ix]);
+                        /* Enable PWM ramp rate if previously enabled */
+                        if (data->pwm_rr_en & (1 << ix)) {
+                                data->pwm_rr[ix > 0] = PWM_RR_EN_TO_REG(1, ix,
+                                                dme1737_read(client,
+                                                DME1737_REG_PWM_RR(ix > 0)));
+                                dme1737_write(client,
+                                              DME1737_REG_PWM_RR(ix > 0),
+                                              data->pwm_rr[ix > 0]);
+                        }
+                        break;
+                }
+                break;
+        case SYS_PWM_RAMP_RATE:
+                /* Only valid for pwm[1-3] */
+                /* Refresh the cache */
+                data->pwm_config[ix] = dme1737_read(client,
+                                                DME1737_REG_PWM_CONFIG(ix));
+                data->pwm_rr[ix > 0] = dme1737_read(client,
+                                                DME1737_REG_PWM_RR(ix > 0));
+                /* Set the ramp rate value */
+                if (val > 0) {
+                        data->pwm_rr[ix > 0] = PWM_RR_TO_REG(val, ix,
+                                                        data->pwm_rr[ix > 0]);
+                }
+                /* Enable/disable the feature only if the associated PWM
+                 * output is in automatic mode. */
+                if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 2) {
+                        data->pwm_rr[ix > 0] = PWM_RR_EN_TO_REG(val > 0, ix,
+                                                        data->pwm_rr[ix > 0]);
+                }
+                dme1737_write(client, DME1737_REG_PWM_RR(ix > 0),
+                              data->pwm_rr[ix > 0]);
+                break;
+        case SYS_PWM_AUTO_CHANNELS_ZONE:
+                /* Only valid for pwm[1-3] */
+                if (!(val == 1 || val == 2 || val == 4 ||
+                      val == 6 || val == 7)) {
+                        count = -EINVAL;
+                        dev_warn(&client->dev, "PWM auto channels zone %ld "
+                                 "not supported. Choose one of 1, 2, 4, 6, "
+                                 "or 7.\n", val);
+                        goto exit;
+                }
+                /* Refresh the cache */
+                data->pwm_config[ix] = dme1737_read(client,
+                                                DME1737_REG_PWM_CONFIG(ix));
+                if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 2) {
+                        /* PWM is already in auto mode so update the temp
+                         * channel assignment */
+                        data->pwm_config[ix] = PWM_ACZ_TO_REG(val,
+                                                data->pwm_config[ix]);
+                        dme1737_write(client, DME1737_REG_PWM_CONFIG(ix),
+                                      data->pwm_config[ix]);
+                } else {
+                        /* PWM is not in auto mode so we save the temp
+                         * channel assignment for later use */
+                        data->pwm_acz[ix] = val;
+                }
+                break;
+        case SYS_PWM_AUTO_PWM_MIN:
+                /* Only valid for pwm[1-3] */
+                /* Refresh the cache */
+                data->pwm_min[ix] = dme1737_read(client,
+                                                DME1737_REG_PWM_MIN(ix));
+                /* There are only 2 values supported for the auto_pwm_min
+                 * value: 0 or auto_point1_pwm. So if the temperature drops
+                 * below the auto_point1_temp_hyst value, the fan either turns
+                 * off or runs at auto_point1_pwm duty-cycle. */
+                if (val > ((data->pwm_min[ix] + 1) / 2)) {
+                        data->pwm_rr[0] = PWM_OFF_TO_REG(1, ix,
+                                                dme1737_read(client,
+                                                DME1737_REG_PWM_RR(0)));
+
+                } else {
+                        data->pwm_rr[0] = PWM_OFF_TO_REG(0, ix,
+                                                dme1737_read(client,
+                                                DME1737_REG_PWM_RR(0)));
+
+                }
+                dme1737_write(client, DME1737_REG_PWM_RR(0),
+                              data->pwm_rr[0]);
+                break;
+        case SYS_PWM_AUTO_POINT1_PWM:
+                /* Only valid for pwm[1-3] */
+                data->pwm_min[ix] = SENSORS_LIMIT(val, 0, 255);
+                dme1737_write(client, DME1737_REG_PWM_MIN(ix),
+                              data->pwm_min[ix]);
+                break;
+        default:
+                dev_dbg(dev, "Unknown attr fetch (%d)\n", fn);
+        }
+exit:
+        mutex_unlock(&data->update_lock);
+
+        return count;
+}
+
+/* ---------------------------------------------------------------------
+ * Miscellaneous sysfs attributes
+ * --------------------------------------------------------------------- */
+
+static ssize_t show_vrm(struct device *dev, struct device_attribute *attr,
+                        char *buf)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct dme1737_data *data = i2c_get_clientdata(client);
+
+        return sprintf(buf, "%d\n", data->vrm);
+}
+
+static ssize_t set_vrm(struct device *dev, struct device_attribute *attr,
+                       const char *buf, size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct dme1737_data *data = i2c_get_clientdata(client);
+        long val = simple_strtol(buf, NULL, 10);
+
+        data->vrm = val;
+        return count;
+}
+
+static ssize_t show_vid(struct device *dev, struct device_attribute *attr,
+                        char *buf)
+{
+        struct dme1737_data *data = dme1737_update_device(dev);
+
+        return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
+}
+
+/* ---------------------------------------------------------------------
+ * Sysfs device attribute defines and structs
+ * --------------------------------------------------------------------- */
+
+/* Voltages 0-6 */
+
+#define SENSOR_DEVICE_ATTR_IN(ix) \
+static SENSOR_DEVICE_ATTR_2(in##ix##_input, S_IRUGO, \
+        show_in, NULL, SYS_IN_INPUT, ix); \
+static SENSOR_DEVICE_ATTR_2(in##ix##_min, S_IRUGO | S_IWUSR, \
+        show_in, set_in, SYS_IN_MIN, ix); \
+static SENSOR_DEVICE_ATTR_2(in##ix##_max, S_IRUGO | S_IWUSR, \
+        show_in, set_in, SYS_IN_MAX, ix); \
+static SENSOR_DEVICE_ATTR_2(in##ix##_alarm, S_IRUGO, \
+        show_in, NULL, SYS_IN_ALARM, ix)
+
+SENSOR_DEVICE_ATTR_IN(0);
+SENSOR_DEVICE_ATTR_IN(1);
+SENSOR_DEVICE_ATTR_IN(2);
+SENSOR_DEVICE_ATTR_IN(3);
+SENSOR_DEVICE_ATTR_IN(4);
+SENSOR_DEVICE_ATTR_IN(5);
+SENSOR_DEVICE_ATTR_IN(6);
+
+/* Temperatures 1-3 */
+
+#define SENSOR_DEVICE_ATTR_TEMP(ix) \
+static SENSOR_DEVICE_ATTR_2(temp##ix##_input, S_IRUGO, \
+        show_temp, NULL, SYS_TEMP_INPUT, ix-1); \
+static SENSOR_DEVICE_ATTR_2(temp##ix##_min, S_IRUGO | S_IWUSR, \
+        show_temp, set_temp, SYS_TEMP_MIN, ix-1); \
+static SENSOR_DEVICE_ATTR_2(temp##ix##_max, S_IRUGO | S_IWUSR, \
+        show_temp, set_temp, SYS_TEMP_MAX, ix-1); \
+static SENSOR_DEVICE_ATTR_2(temp##ix##_offset, S_IRUGO, \
+        show_temp, set_temp, SYS_TEMP_OFFSET, ix-1); \
+static SENSOR_DEVICE_ATTR_2(temp##ix##_alarm, S_IRUGO, \
+        show_temp, NULL, SYS_TEMP_ALARM, ix-1); \
+static SENSOR_DEVICE_ATTR_2(temp##ix##_fault, S_IRUGO, \
+        show_temp, NULL, SYS_TEMP_FAULT, ix-1)
+
+SENSOR_DEVICE_ATTR_TEMP(1);
+SENSOR_DEVICE_ATTR_TEMP(2);
+SENSOR_DEVICE_ATTR_TEMP(3);
+
+/* Zones 1-3 */
+
+#define SENSOR_DEVICE_ATTR_ZONE(ix) \
+static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_channels_temp, S_IRUGO, \
+        show_zone, NULL, SYS_ZONE_AUTO_CHANNELS_TEMP, ix-1); \
+static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_point1_temp_hyst, S_IRUGO, \
+        show_zone, set_zone, SYS_ZONE_AUTO_POINT1_TEMP_HYST, ix-1); \
+static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_point1_temp, S_IRUGO, \
+        show_zone, set_zone, SYS_ZONE_AUTO_POINT1_TEMP, ix-1); \
+static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_point2_temp, S_IRUGO, \
+        show_zone, set_zone, SYS_ZONE_AUTO_POINT2_TEMP, ix-1); \
+static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_point3_temp, S_IRUGO, \
+        show_zone, set_zone, SYS_ZONE_AUTO_POINT3_TEMP, ix-1)
+
+SENSOR_DEVICE_ATTR_ZONE(1);
+SENSOR_DEVICE_ATTR_ZONE(2);
+SENSOR_DEVICE_ATTR_ZONE(3);
+
+/* Fans 1-4 */
+
+#define SENSOR_DEVICE_ATTR_FAN_1TO4(ix) \
+static SENSOR_DEVICE_ATTR_2(fan##ix##_input, S_IRUGO, \
+        show_fan, NULL, SYS_FAN_INPUT, ix-1); \
+static SENSOR_DEVICE_ATTR_2(fan##ix##_min, S_IRUGO | S_IWUSR, \
+        show_fan, set_fan, SYS_FAN_MIN, ix-1); \
+static SENSOR_DEVICE_ATTR_2(fan##ix##_alarm, S_IRUGO, \
+        show_fan, NULL, SYS_FAN_ALARM, ix-1); \
+static SENSOR_DEVICE_ATTR_2(fan##ix##_type, S_IRUGO | S_IWUSR, \
+        show_fan, set_fan, SYS_FAN_TYPE, ix-1)
+
+SENSOR_DEVICE_ATTR_FAN_1TO4(1);
+SENSOR_DEVICE_ATTR_FAN_1TO4(2);
+SENSOR_DEVICE_ATTR_FAN_1TO4(3);
+SENSOR_DEVICE_ATTR_FAN_1TO4(4);
+
+/* Fans 5-6 */
+
+#define SENSOR_DEVICE_ATTR_FAN_5TO6(ix) \
+static SENSOR_DEVICE_ATTR_2(fan##ix##_input, S_IRUGO, \
+        show_fan, NULL, SYS_FAN_INPUT, ix-1); \
+static SENSOR_DEVICE_ATTR_2(fan##ix##_min, S_IRUGO | S_IWUSR, \
+        show_fan, set_fan, SYS_FAN_MIN, ix-1); \
+static SENSOR_DEVICE_ATTR_2(fan##ix##_alarm, S_IRUGO, \
+        show_fan, NULL, SYS_FAN_ALARM, ix-1); \
+static SENSOR_DEVICE_ATTR_2(fan##ix##_max, S_IRUGO | S_IWUSR, \
+        show_fan, set_fan, SYS_FAN_MAX, ix-1)
+
+SENSOR_DEVICE_ATTR_FAN_5TO6(5);
+SENSOR_DEVICE_ATTR_FAN_5TO6(6);
+
+/* PWMs 1-3 */
+
+#define SENSOR_DEVICE_ATTR_PWM_1TO3(ix) \
+static SENSOR_DEVICE_ATTR_2(pwm##ix, S_IRUGO, \
+        show_pwm, set_pwm, SYS_PWM, ix-1); \
+static SENSOR_DEVICE_ATTR_2(pwm##ix##_freq, S_IRUGO, \
+        show_pwm, set_pwm, SYS_PWM_FREQ, ix-1); \
+static SENSOR_DEVICE_ATTR_2(pwm##ix##_enable, S_IRUGO, \
+        show_pwm, set_pwm, SYS_PWM_ENABLE, ix-1); \
+static SENSOR_DEVICE_ATTR_2(pwm##ix##_ramp_rate, S_IRUGO, \
+        show_pwm, set_pwm, SYS_PWM_RAMP_RATE, ix-1); \
+static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_channels_zone, S_IRUGO, \
+        show_pwm, set_pwm, SYS_PWM_AUTO_CHANNELS_ZONE, ix-1); \
+static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_pwm_min, S_IRUGO, \
+        show_pwm, set_pwm, SYS_PWM_AUTO_PWM_MIN, ix-1); \
+static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_point1_pwm, S_IRUGO, \
+        show_pwm, set_pwm, SYS_PWM_AUTO_POINT1_PWM, ix-1); \
+static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_point2_pwm, S_IRUGO, \
+        show_pwm, NULL, SYS_PWM_AUTO_POINT2_PWM, ix-1)
+
+SENSOR_DEVICE_ATTR_PWM_1TO3(1);
+SENSOR_DEVICE_ATTR_PWM_1TO3(2);
+SENSOR_DEVICE_ATTR_PWM_1TO3(3);
+
+/* PWMs 5-6 */
+
+#define SENSOR_DEVICE_ATTR_PWM_5TO6(ix) \
+static SENSOR_DEVICE_ATTR_2(pwm##ix, S_IRUGO | S_IWUSR, \
+        show_pwm, set_pwm, SYS_PWM, ix-1); \
+static SENSOR_DEVICE_ATTR_2(pwm##ix##_freq, S_IRUGO | S_IWUSR, \
+        show_pwm, set_pwm, SYS_PWM_FREQ, ix-1); \
+static SENSOR_DEVICE_ATTR_2(pwm##ix##_enable, S_IRUGO, \
+        show_pwm, NULL, SYS_PWM_ENABLE, ix-1)
+
+SENSOR_DEVICE_ATTR_PWM_5TO6(5);
+SENSOR_DEVICE_ATTR_PWM_5TO6(6);
+
+/* Misc */
+
+static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm, set_vrm);
+static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
+
+#define SENSOR_DEV_ATTR_IN(ix) \
+&sensor_dev_attr_in##ix##_input.dev_attr.attr, \
+&sensor_dev_attr_in##ix##_min.dev_attr.attr, \
+&sensor_dev_attr_in##ix##_max.dev_attr.attr, \
+&sensor_dev_attr_in##ix##_alarm.dev_attr.attr
+
+/* These attributes are read-writeable only if the chip is *not* locked */
+#define SENSOR_DEV_ATTR_TEMP_LOCK(ix) \
+&sensor_dev_attr_temp##ix##_offset.dev_attr.attr
+
+#define SENSOR_DEV_ATTR_TEMP(ix) \
+SENSOR_DEV_ATTR_TEMP_LOCK(ix), \
+&sensor_dev_attr_temp##ix##_input.dev_attr.attr, \
+&sensor_dev_attr_temp##ix##_min.dev_attr.attr, \
+&sensor_dev_attr_temp##ix##_max.dev_attr.attr, \
+&sensor_dev_attr_temp##ix##_alarm.dev_attr.attr, \
+&sensor_dev_attr_temp##ix##_fault.dev_attr.attr
+
+/* These attributes are read-writeable only if the chip is *not* locked */
+#define SENSOR_DEV_ATTR_ZONE_LOCK(ix) \
+&sensor_dev_attr_zone##ix##_auto_point1_temp_hyst.dev_attr.attr, \
+&sensor_dev_attr_zone##ix##_auto_point1_temp.dev_attr.attr, \
+&sensor_dev_attr_zone##ix##_auto_point2_temp.dev_attr.attr, \
+&sensor_dev_attr_zone##ix##_auto_point3_temp.dev_attr.attr
+
+#define SENSOR_DEV_ATTR_ZONE(ix) \
+SENSOR_DEV_ATTR_ZONE_LOCK(ix), \
+&sensor_dev_attr_zone##ix##_auto_channels_temp.dev_attr.attr
+
+#define SENSOR_DEV_ATTR_FAN_1TO4(ix) \
+&sensor_dev_attr_fan##ix##_input.dev_attr.attr, \
+&sensor_dev_attr_fan##ix##_min.dev_attr.attr, \
+&sensor_dev_attr_fan##ix##_alarm.dev_attr.attr, \
+&sensor_dev_attr_fan##ix##_type.dev_attr.attr
+
+#define SENSOR_DEV_ATTR_FAN_5TO6(ix) \
+&sensor_dev_attr_fan##ix##_input.dev_attr.attr, \
+&sensor_dev_attr_fan##ix##_min.dev_attr.attr, \
+&sensor_dev_attr_fan##ix##_alarm.dev_attr.attr, \
+&sensor_dev_attr_fan##ix##_max.dev_attr.attr
+
+/* These attributes are read-writeable only if the chip is *not* locked */
+#define SENSOR_DEV_ATTR_PWM_1TO3_LOCK(ix) \
+&sensor_dev_attr_pwm##ix##_freq.dev_attr.attr, \
+&sensor_dev_attr_pwm##ix##_enable.dev_attr.attr, \
+&sensor_dev_attr_pwm##ix##_ramp_rate.dev_attr.attr, \
+&sensor_dev_attr_pwm##ix##_auto_channels_zone.dev_attr.attr, \
+&sensor_dev_attr_pwm##ix##_auto_pwm_min.dev_attr.attr, \
+&sensor_dev_attr_pwm##ix##_auto_point1_pwm.dev_attr.attr
+
+#define SENSOR_DEV_ATTR_PWM_1TO3(ix) \
+SENSOR_DEV_ATTR_PWM_1TO3_LOCK(ix), \
+&sensor_dev_attr_pwm##ix.dev_attr.attr, \
+&sensor_dev_attr_pwm##ix##_auto_point2_pwm.dev_attr.attr
+
+/* These attributes are read-writeable only if the chip is *not* locked */
+#define SENSOR_DEV_ATTR_PWM_5TO6_LOCK(ix) \
+&sensor_dev_attr_pwm##ix.dev_attr.attr, \
+&sensor_dev_attr_pwm##ix##_freq.dev_attr.attr
+
+#define SENSOR_DEV_ATTR_PWM_5TO6(ix) \
+SENSOR_DEV_ATTR_PWM_5TO6_LOCK(ix), \
+&sensor_dev_attr_pwm##ix##_enable.dev_attr.attr
+
+/* This struct holds all the attributes that are always present and need to be
+ * created unconditionally. The attributes that need modification of their
+ * permissions are created read-only and write permissions are added or removed
+ * on the fly when required */
+static struct attribute *dme1737_attr[] ={
+        /* Voltages */
+        SENSOR_DEV_ATTR_IN(0),
+        SENSOR_DEV_ATTR_IN(1),
+        SENSOR_DEV_ATTR_IN(2),
+        SENSOR_DEV_ATTR_IN(3),
+        SENSOR_DEV_ATTR_IN(4),
+        SENSOR_DEV_ATTR_IN(5),
+        SENSOR_DEV_ATTR_IN(6),
+        /* Temperatures */
+        SENSOR_DEV_ATTR_TEMP(1),
+        SENSOR_DEV_ATTR_TEMP(2),
+        SENSOR_DEV_ATTR_TEMP(3),
+        /* Zones */
+        SENSOR_DEV_ATTR_ZONE(1),
+        SENSOR_DEV_ATTR_ZONE(2),
+        SENSOR_DEV_ATTR_ZONE(3),
+        /* Misc */
+        &dev_attr_vrm.attr,
+        &dev_attr_cpu0_vid.attr,
+        NULL
+};
+
+static const struct attribute_group dme1737_group = {
+        .attrs = dme1737_attr,
+};
+
+/* The following structs hold the PWM attributes, some of which are optional.
+ * Their creation depends on the chip configuration which is determined during
+ * module load. */
+static struct attribute *dme1737_attr_pwm1[] = {
+        SENSOR_DEV_ATTR_PWM_1TO3(1),
+        NULL
+};
+static struct attribute *dme1737_attr_pwm2[] = {
+        SENSOR_DEV_ATTR_PWM_1TO3(2),
+        NULL
+};
+static struct attribute *dme1737_attr_pwm3[] = {
+        SENSOR_DEV_ATTR_PWM_1TO3(3),
+        NULL
+};
+static struct attribute *dme1737_attr_pwm5[] = {
+        SENSOR_DEV_ATTR_PWM_5TO6(5),
+        NULL
+};
+static struct attribute *dme1737_attr_pwm6[] = {
+        SENSOR_DEV_ATTR_PWM_5TO6(6),
+        NULL
+};
+
+static const struct attribute_group dme1737_pwm_group[] = {
+        { .attrs = dme1737_attr_pwm1 },
+        { .attrs = dme1737_attr_pwm2 },
+        { .attrs = dme1737_attr_pwm3 },
+        { .attrs = NULL },
+        { .attrs = dme1737_attr_pwm5 },
+        { .attrs = dme1737_attr_pwm6 },
+};
+
+/* The following structs hold the fan attributes, some of which are optional.
+ * Their creation depends on the chip configuration which is determined during
+ * module load. */
+static struct attribute *dme1737_attr_fan1[] = {
+        SENSOR_DEV_ATTR_FAN_1TO4(1),
+        NULL
+};
+static struct attribute *dme1737_attr_fan2[] = {
+        SENSOR_DEV_ATTR_FAN_1TO4(2),
+        NULL
+};
+static struct attribute *dme1737_attr_fan3[] = {
+        SENSOR_DEV_ATTR_FAN_1TO4(3),
+        NULL
+};
+static struct attribute *dme1737_attr_fan4[] = {
+        SENSOR_DEV_ATTR_FAN_1TO4(4),
+        NULL
+};
+static struct attribute *dme1737_attr_fan5[] = {
+        SENSOR_DEV_ATTR_FAN_5TO6(5),
+        NULL
+};
+static struct attribute *dme1737_attr_fan6[] = {
+        SENSOR_DEV_ATTR_FAN_5TO6(6),
+        NULL
+};
+
+static const struct attribute_group dme1737_fan_group[] = {
+        { .attrs = dme1737_attr_fan1 },
+        { .attrs = dme1737_attr_fan2 },
+        { .attrs = dme1737_attr_fan3 },
+        { .attrs = dme1737_attr_fan4 },
+        { .attrs = dme1737_attr_fan5 },
+        { .attrs = dme1737_attr_fan6 },
+};
+
+/* The permissions of all of the following attributes are changed to read-
+ * writeable if the chip is *not* locked. Otherwise they stay read-only. */
+static struct attribute *dme1737_attr_lock[] = {
+        /* Temperatures */
+        SENSOR_DEV_ATTR_TEMP_LOCK(1),
+        SENSOR_DEV_ATTR_TEMP_LOCK(2),
+        SENSOR_DEV_ATTR_TEMP_LOCK(3),
+        /* Zones */
+        SENSOR_DEV_ATTR_ZONE_LOCK(1),
+        SENSOR_DEV_ATTR_ZONE_LOCK(2),
+        SENSOR_DEV_ATTR_ZONE_LOCK(3),
+        NULL
+};
+
+static const struct attribute_group dme1737_lock_group = {
+        .attrs = dme1737_attr_lock,
+};
+
+/* The permissions of the following PWM attributes are changed to read-
+ * writeable if the chip is *not* locked and the respective PWM is available.
+ * Otherwise they stay read-only. */
+static struct attribute *dme1737_attr_pwm1_lock[] = {
+        SENSOR_DEV_ATTR_PWM_1TO3_LOCK(1),
+        NULL
+};
+static struct attribute *dme1737_attr_pwm2_lock[] = {
+        SENSOR_DEV_ATTR_PWM_1TO3_LOCK(2),
+        NULL
+};
+static struct attribute *dme1737_attr_pwm3_lock[] = {
+        SENSOR_DEV_ATTR_PWM_1TO3_LOCK(3),
+        NULL
+};
+static struct attribute *dme1737_attr_pwm5_lock[] = {
+        SENSOR_DEV_ATTR_PWM_5TO6_LOCK(5),
+        NULL
+};
+static struct attribute *dme1737_attr_pwm6_lock[] = {
+        SENSOR_DEV_ATTR_PWM_5TO6_LOCK(6),
+        NULL
+};
+
+static const struct attribute_group dme1737_pwm_lock_group[] = {
+        { .attrs = dme1737_attr_pwm1_lock },
+        { .attrs = dme1737_attr_pwm2_lock },
+        { .attrs = dme1737_attr_pwm3_lock },
+        { .attrs = NULL },
+        { .attrs = dme1737_attr_pwm5_lock },
+        { .attrs = dme1737_attr_pwm6_lock },
+};
+
+/* Pwm[1-3] are read-writeable if the associated pwm is in manual mode and the
+ * chip is not locked. Otherwise they are read-only. */
+static struct attribute *dme1737_attr_pwm[] = {
+        &sensor_dev_attr_pwm1.dev_attr.attr,
+        &sensor_dev_attr_pwm2.dev_attr.attr,
+        &sensor_dev_attr_pwm3.dev_attr.attr,
+};
+
+/* ---------------------------------------------------------------------
+ * Super-IO functions
+ * --------------------------------------------------------------------- */
+
+static inline int dme1737_sio_inb(int sio_cip, int reg)
+{
+        outb(reg, sio_cip);
+        return inb(sio_cip + 1);
+}
+
+static inline void dme1737_sio_outb(int sio_cip, int reg, int val)
+{
+        outb(reg, sio_cip);
+        outb(val, sio_cip + 1);
+}
+
+static int dme1737_sio_get_features(int sio_cip, struct i2c_client *client)
+{
+        struct dme1737_data *data = i2c_get_clientdata(client);
+        int err = 0, reg;
+        u16 addr;
+
+        /* Enter configuration mode */
+        outb(0x55, sio_cip);
+
+        /* Check device ID
+         * The DME1737 can return either 0x78 or 0x77 as its device ID. */
+        reg = dme1737_sio_inb(sio_cip, 0x20);
+        if (!(reg == 0x77 || reg == 0x78)) {
+                err = -ENODEV;
+                goto exit;
+        }
+
+        /* Select logical device A (runtime registers) */
+        dme1737_sio_outb(sio_cip, 0x07, 0x0a);
+
+        /* Get the base address of the runtime registers */
+        if (!(addr = (dme1737_sio_inb(sio_cip, 0x60) << 8) |
+                      dme1737_sio_inb(sio_cip, 0x61))) {
+                err = -ENODEV;
+                goto exit;
+        }
+
+        /* Read the runtime registers to determine which optional features
+         * are enabled and available. Bits [3:2] of registers 0x43-0x46 are set
+         * to '10' if the respective feature is enabled. */
+        if ((inb(addr + 0x43) & 0x0c) == 0x08) { /* fan6 */
+                data->has_fan |= (1 << 5);
+        }
+        if ((inb(addr + 0x44) & 0x0c) == 0x08) { /* pwm6 */
+                data->has_pwm |= (1 << 5);
+        }
+        if ((inb(addr + 0x45) & 0x0c) == 0x08) { /* fan5 */
+                data->has_fan |= (1 << 4);
+        }
+        if ((inb(addr + 0x46) & 0x0c) == 0x08) { /* pwm5 */
+                data->has_pwm |= (1 << 4);
+        }
+
+exit:
+        /* Exit configuration mode */
+        outb(0xaa, sio_cip);
+
+        return err;
+}
+
+/* ---------------------------------------------------------------------
+ * Device detection, registration and initialization
+ * --------------------------------------------------------------------- */
+
+static struct i2c_driver dme1737_driver;
+
+static void dme1737_chmod_file(struct i2c_client *client,
+                               struct attribute *attr, mode_t mode)
+{
+        if (sysfs_chmod_file(&client->dev.kobj, attr, mode)) {
+                dev_warn(&client->dev, "Failed to change permissions of %s.\n",
+                         attr->name);
+        }
+}
+
+static void dme1737_chmod_group(struct i2c_client *client,
+                                const struct attribute_group *group,
+                                mode_t mode)
+{
+        struct attribute **attr;
+
+        for (attr = group->attrs; *attr; attr++) {
+                dme1737_chmod_file(client, *attr, mode);
+        }
+}
+
+static int dme1737_init_client(struct i2c_client *client)
+{
+        struct dme1737_data *data = i2c_get_clientdata(client);
+        int ix;
+        u8 reg;
+
+        data->config = dme1737_read(client, DME1737_REG_CONFIG);
+        /* Inform if part is not monitoring/started */
+        if (!(data->config & 0x01)) {
+                if (!force_start) {
+                        dev_err(&client->dev, "Device is not monitoring. "
+                                "Use the force_start load parameter to "
+                                "override.\n");
+                        return -EFAULT;
+                }
+
+                /* Force monitoring */
+                data->config |= 0x01;
+                dme1737_write(client, DME1737_REG_CONFIG, data->config);
+        }
+        /* Inform if part is not ready */
+        if (!(data->config & 0x04)) {
+                dev_err(&client->dev, "Device is not ready.\n");
+                return -EFAULT;
+        }
+
+        data->config2 = dme1737_read(client, DME1737_REG_CONFIG2);
+        /* Check if optional fan3 input is enabled */
+        if (data->config2 & 0x04) {
+                data->has_fan |= (1 << 2);
+        }
+
+        /* Fan4 and pwm3 are only available if the client's I2C address
+         * is the default 0x2e. Otherwise the I/Os associated with these
+         * functions are used for addr enable/select. */
+        if (client->addr == 0x2e) {
+                data->has_fan |= (1 << 3);
+                data->has_pwm |= (1 << 2);
+        }
+
+        /* Determine if the optional fan[5-6] and/or pwm[5-6] are enabled.
+         * For this, we need to query the runtime registers through the
+         * Super-IO LPC interface. Try both config ports 0x2e and 0x4e. */
+        if (dme1737_sio_get_features(0x2e, client) &&
+            dme1737_sio_get_features(0x4e, client)) {
+                dev_warn(&client->dev, "Failed to query Super-IO for optional "
+                         "features.\n");
+        }
+
+        /* Fan1, fan2, pwm1, and pwm2 are always present */
+        data->has_fan |= 0x03;
+        data->has_pwm |= 0x03;
+
+        dev_info(&client->dev, "Optional features: pwm3=%s, pwm5=%s, pwm6=%s, "
+                 "fan3=%s, fan4=%s, fan5=%s, fan6=%s.\n",
+                 (data->has_pwm & (1 << 2)) ? "yes" : "no",
+                 (data->has_pwm & (1 << 4)) ? "yes" : "no",
+                 (data->has_pwm & (1 << 5)) ? "yes" : "no",
+                 (data->has_fan & (1 << 2)) ? "yes" : "no",
+                 (data->has_fan & (1 << 3)) ? "yes" : "no",
+                 (data->has_fan & (1 << 4)) ? "yes" : "no",
+                 (data->has_fan & (1 << 5)) ? "yes" : "no");
+
+        reg = dme1737_read(client, DME1737_REG_TACH_PWM);
+        /* Inform if fan-to-pwm mapping differs from the default */
+        if (reg != 0xa4) {
+                dev_warn(&client->dev, "Non-standard fan to pwm mapping: "
+                         "fan1->pwm%d, fan2->pwm%d, fan3->pwm%d, "
+                         "fan4->pwm%d. Please report to the driver "
+                         "maintainer.\n",
+                         (reg & 0x03) + 1, ((reg >> 2) & 0x03) + 1,
+                         ((reg >> 4) & 0x03) + 1, ((reg >> 6) & 0x03) + 1);
+        }
+
+        /* Switch pwm[1-3] to manual mode if they are currently disabled and
+         * set the duty-cycles to 0% (which is identical to the PWMs being
+         * disabled). */
+        if (!(data->config & 0x02)) {
+                for (ix = 0; ix < 3; ix++) {
+                        data->pwm_config[ix] = dme1737_read(client,
+                                                DME1737_REG_PWM_CONFIG(ix));
+                        if ((data->has_pwm & (1 << ix)) &&
+                            (PWM_EN_FROM_REG(data->pwm_config[ix]) == -1)) {
+                                dev_info(&client->dev, "Switching pwm%d to "
+                                         "manual mode.\n", ix + 1);
+                                data->pwm_config[ix] = PWM_EN_TO_REG(1,
+                                                        data->pwm_config[ix]);
+                                dme1737_write(client, DME1737_REG_PWM(ix), 0);
+                                dme1737_write(client,
+                                              DME1737_REG_PWM_CONFIG(ix),
+                                              data->pwm_config[ix]);
+                        }
+                }
+        }
+
+        /* Initialize the default PWM auto channels zone (acz) assignments */
+        data->pwm_acz[0] = 1;   /* pwm1 -> zone1 */
+        data->pwm_acz[1] = 2;   /* pwm2 -> zone2 */
+        data->pwm_acz[2] = 4;   /* pwm3 -> zone3 */
+
+        /* Set VRM */
+        data->vrm = vid_which_vrm();
+
+        return 0;
+}
+
+static int dme1737_detect(struct i2c_adapter *adapter, int address,
+                          int kind)
+{
+        u8 company, verstep = 0;
+        struct i2c_client *client;
+        struct dme1737_data *data;
+        int ix, err = 0;
+        const char *name;
+
+        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
+                goto exit;
+        }
+
+        if (!(data = kzalloc(sizeof(struct dme1737_data), GFP_KERNEL))) {
+                err = -ENOMEM;
+                goto exit;
+        }
+
+        client = &data->client;
+        i2c_set_clientdata(client, data);
+        client->addr = address;
+        client->adapter = adapter;
+        client->driver = &dme1737_driver;
+
+        /* A negative kind means that the driver was loaded with no force
+         * parameter (default), so we must identify the chip. */
+        if (kind < 0) {
+                company = dme1737_read(client, DME1737_REG_COMPANY);
+                verstep = dme1737_read(client, DME1737_REG_VERSTEP);
+
+                if (!((company == DME1737_COMPANY_SMSC) &&
+                      ((verstep & DME1737_VERSTEP_MASK) == DME1737_VERSTEP))) {
+                        err = -ENODEV;
+                        goto exit_kfree;
+                }
+        }
+
+        kind = dme1737;
+        name = "dme1737";
+
+        /* Fill in the remaining client fields and put it into the global
+         * list */
+        strlcpy(client->name, name, I2C_NAME_SIZE);
+        mutex_init(&data->update_lock);
+
+        /* Tell the I2C layer a new client has arrived */
+        if ((err = i2c_attach_client(client))) {
+                goto exit_kfree;
+        }
+
+        /* Initialize the DME1737 chip */
+        if ((err = dme1737_init_client(client))) {
+                goto exit_detach;
+        }
+
+        /* Create standard sysfs attributes */
+        if ((err = sysfs_create_group(&client->dev.kobj, &dme1737_group))) {
+                goto exit_detach;
+        }
+
+        /* Create fan sysfs attributes */
+        for (ix = 0; ix < ARRAY_SIZE(dme1737_fan_group); ix++) {
+                if (data->has_fan & (1 << ix)) {
+                        if ((err = sysfs_create_group(&client->dev.kobj,
+                                                &dme1737_fan_group[ix]))) {
+                                goto exit_remove;
+                        }
+                }
+        }
+
+        /* Create PWM sysfs attributes */
+        for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_group); ix++) {
+                if (data->has_pwm & (1 << ix)) {
+                        if ((err = sysfs_create_group(&client->dev.kobj,
+                                                &dme1737_pwm_group[ix]))) {
+                                goto exit_remove;
+                        }
+                }
+        }
+
+        /* Inform if the device is locked. Otherwise change the permissions of
+         * selected attributes from read-only to read-writeable. */
+        if (data->config & 0x02) {
+                dev_info(&client->dev, "Device is locked. Some attributes "
+                         "will be read-only.\n");
+        } else {
+                /* Change permissions of standard attributes */
+                dme1737_chmod_group(client, &dme1737_lock_group,
+                                    S_IRUGO | S_IWUSR);
+
+                /* Change permissions of PWM attributes */
+                for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_lock_group); ix++) {
+                        if (data->has_pwm & (1 << ix)) {
+                                dme1737_chmod_group(client,
+                                                &dme1737_pwm_lock_group[ix],
+                                                S_IRUGO | S_IWUSR);
+                        }
+                }
+
+                /* Change permissions of pwm[1-3] if in manual mode */
+                for (ix = 0; ix < 3; ix++) {
+                        if ((data->has_pwm & (1 << ix)) &&
+                            (PWM_EN_FROM_REG(data->pwm_config[ix]) == 1)) {
+                                dme1737_chmod_file(client,
+                                                   dme1737_attr_pwm[ix],
+                                                   S_IRUGO | S_IWUSR);
+                        }
+                }
+        }
+
+        /* Register device */
+        data->class_dev = hwmon_device_register(&client->dev);
+        if (IS_ERR(data->class_dev)) {
+                err = PTR_ERR(data->class_dev);
+                goto exit_remove;
+        }
+
+        dev_info(&adapter->dev, "Found a DME1737 chip at 0x%02x "
+                 "(rev 0x%02x)\n", client->addr, verstep);
+
+        return 0;
+
+exit_remove:
+        for (ix = 0; ix < ARRAY_SIZE(dme1737_fan_group); ix++) {
+                if (data->has_fan & (1 << ix)) {
+                        sysfs_remove_group(&client->dev.kobj,
+                                           &dme1737_fan_group[ix]);
+                }
+        }
+        for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_group); ix++) {
+                if (data->has_pwm & (1 << ix)) {
+                        sysfs_remove_group(&client->dev.kobj,
+                                           &dme1737_pwm_group[ix]);
+                }
+        }
+        sysfs_remove_group(&client->dev.kobj, &dme1737_group);
+exit_detach:
+        i2c_detach_client(client);
+exit_kfree:
+        kfree(data);
+exit:
+        return err;
+}
+
+static int dme1737_attach_adapter(struct i2c_adapter *adapter)
+{
+        if (!(adapter->class & I2C_CLASS_HWMON)) {
+                return 0;
+        }
+
+        return i2c_probe(adapter, &addr_data, dme1737_detect);
+}
+
+static int dme1737_detach_client(struct i2c_client *client)
+{
+        struct dme1737_data *data = i2c_get_clientdata(client);
+        int ix, err;
+
+        hwmon_device_unregister(data->class_dev);
+
+        for (ix = 0; ix < ARRAY_SIZE(dme1737_fan_group); ix++) {
+                if (data->has_fan & (1 << ix)) {
+                        sysfs_remove_group(&client->dev.kobj,
+                                           &dme1737_fan_group[ix]);
+                }
+        }
+        for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_group); ix++) {
+                if (data->has_pwm & (1 << ix)) {
+                        sysfs_remove_group(&client->dev.kobj,
+                                           &dme1737_pwm_group[ix]);
+                }
+        }
+        sysfs_remove_group(&client->dev.kobj, &dme1737_group);
+
+        if ((err = i2c_detach_client(client))) {
+                return err;
+        }
+
+        kfree(data);
+        return 0;
+}
+
+static struct i2c_driver dme1737_driver = {
+        .driver = {
+                .name = "dme1737",
+        },
+        .attach_adapter = dme1737_attach_adapter,
+        .detach_client = dme1737_detach_client,
+};
+
+static int __init dme1737_init(void)
+{
+        return i2c_add_driver(&dme1737_driver);
+}
+
+static void __exit dme1737_exit(void)
+{
+        i2c_del_driver(&dme1737_driver);
+}
+
+MODULE_AUTHOR("Juerg Haefliger <juergh@gmail.com>");
+MODULE_DESCRIPTION("DME1737 sensors");
+MODULE_LICENSE("GPL");
+
+module_init(dme1737_init);
+module_exit(dme1737_exit);
diff --git a/drivers/hwmon/ds1621.c b/drivers/hwmon/ds1621.c
index d5ac422d73b2..1212d6b7f316 100644
--- a/drivers/hwmon/ds1621.c
+++ b/drivers/hwmon/ds1621.c
@@ -27,6 +27,7 @@
 #include <linux/jiffies.h>
 #include <linux/i2c.h>
 #include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
 #include <linux/err.h>
 #include <linux/mutex.h>
 #include <linux/sysfs.h>
@@ -52,9 +53,11 @@ MODULE_PARM_DESC(polarity, "Output's polarity: 0 = active high, 1 = active low")
 #define DS1621_REG_CONFIG_DONE          0x80
 
 /* The DS1621 registers */
-#define DS1621_REG_TEMP                 0xAA /* word, RO */
-#define DS1621_REG_TEMP_MIN             0xA2 /* word, RW */
-#define DS1621_REG_TEMP_MAX             0xA1 /* word, RW */
+static const u8 DS1621_REG_TEMP[3] = {
+        0xAA,           /* input, word, RO */
+        0xA2,           /* min, word, RW */
+        0xA1,           /* max, word, RW */
+};
 #define DS1621_REG_CONF                 0xAC /* byte, RW */
 #define DS1621_COM_START                0xEE /* no data */
 #define DS1621_COM_STOP                 0x22 /* no data */
@@ -63,10 +66,7 @@ MODULE_PARM_DESC(polarity, "Output's polarity: 0 = active high, 1 = active low")
 #define DS1621_ALARM_TEMP_HIGH          0x40
 #define DS1621_ALARM_TEMP_LOW           0x20
 
-/* Conversions. Rounding and limit checking is only done on the TO_REG
-   variants. Note that you should be a bit careful with which arguments
-   these macros are called: arguments may be evaluated more than once.
-   Fixing this is just not worth it. */
+/* Conversions */
 #define ALARMS_FROM_REG(val) ((val) & \
                               (DS1621_ALARM_TEMP_HIGH | DS1621_ALARM_TEMP_LOW))
 
@@ -78,7 +78,7 @@ struct ds1621_data {
         char valid;                     /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
 
-        u16 temp, temp_min, temp_max;   /* Register values, word */
+        u16 temp[3];                    /* Register values, word */
         u8 conf;                        /* Register encoding, combined */
 };
 
@@ -101,7 +101,7 @@ static struct i2c_driver ds1621_driver = {
 
 /* All registers are word-sized, except for the configuration register.
    DS1621 uses a high-byte first convention, which is exactly opposite to
-   the usual practice. */
+   the SMBus standard. */
 static int ds1621_read_value(struct i2c_client *client, u8 reg)
 {
         if (reg == DS1621_REG_CONF)
@@ -110,9 +110,6 @@ static int ds1621_read_value(struct i2c_client *client, u8 reg)
                 return swab16(i2c_smbus_read_word_data(client, reg));
 }
 
-/* All registers are word-sized, except for the configuration register.
-   DS1621 uses a high-byte first convention, which is exactly opposite to
-   the usual practice. */
 static int ds1621_write_value(struct i2c_client *client, u8 reg, u16 value)
 {
         if (reg == DS1621_REG_CONF)
@@ -139,50 +136,61 @@ static void ds1621_init_client(struct i2c_client *client)
         i2c_smbus_write_byte(client, DS1621_COM_START);
 }
 
-#define show(value)                                                     \
-static ssize_t show_##value(struct device *dev, struct device_attribute *attr, char *buf)               \
-{                                                                       \
-        struct ds1621_data *data = ds1621_update_client(dev);           \
-        return sprintf(buf, "%d\n", LM75_TEMP_FROM_REG(data->value));   \
+static ssize_t show_temp(struct device *dev, struct device_attribute *da,
+                         char *buf)
+{
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        struct ds1621_data *data = ds1621_update_client(dev);
+        return sprintf(buf, "%d\n",
+                       LM75_TEMP_FROM_REG(data->temp[attr->index]));
 }
 
-show(temp);
-show(temp_min);
-show(temp_max);
-
-#define set_temp(suffix, value, reg)                                    \
-static ssize_t set_temp_##suffix(struct device *dev, struct device_attribute *attr, const char *buf,    \
-                                 size_t count)                          \
-{                                                                       \
-        struct i2c_client *client = to_i2c_client(dev);                 \
-        struct ds1621_data *data = ds1621_update_client(dev);           \
-        u16 val = LM75_TEMP_TO_REG(simple_strtoul(buf, NULL, 10));      \
-                                                                        \
-        mutex_lock(&data->update_lock);                                 \
-        data->value = val;                                              \
-        ds1621_write_value(client, reg, data->value);                   \
-        mutex_unlock(&data->update_lock);                               \
-        return count;                                                   \
-}
+static ssize_t set_temp(struct device *dev, struct device_attribute *da,
+                        const char *buf, size_t count)
+{
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        struct i2c_client *client = to_i2c_client(dev);
+        struct ds1621_data *data = ds1621_update_client(dev);
+        u16 val = LM75_TEMP_TO_REG(simple_strtoul(buf, NULL, 10));
 
-set_temp(min, temp_min, DS1621_REG_TEMP_MIN);
-set_temp(max, temp_max, DS1621_REG_TEMP_MAX);
+        mutex_lock(&data->update_lock);
+        data->temp[attr->index] = val;
+        ds1621_write_value(client, DS1621_REG_TEMP[attr->index],
+                           data->temp[attr->index]);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
 
-static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t show_alarms(struct device *dev, struct device_attribute *da,
+                           char *buf)
 {
         struct ds1621_data *data = ds1621_update_client(dev);
         return sprintf(buf, "%d\n", ALARMS_FROM_REG(data->conf));
 }
 
+static ssize_t show_alarm(struct device *dev, struct device_attribute *da,
+                          char *buf)
+{
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        struct ds1621_data *data = ds1621_update_client(dev);
+        return sprintf(buf, "%d\n", !!(data->conf & attr->index));
+}
+
 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
-static DEVICE_ATTR(temp1_input, S_IRUGO , show_temp, NULL);
-static DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO , show_temp_min, set_temp_min);
-static DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max, set_temp_max);
+static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp, set_temp, 1);
+static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp, set_temp, 2);
+static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL,
+                DS1621_ALARM_TEMP_LOW);
+static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL,
+                DS1621_ALARM_TEMP_HIGH);
 
 static struct attribute *ds1621_attributes[] = {
-        &dev_attr_temp1_input.attr,
-        &dev_attr_temp1_min.attr,
-        &dev_attr_temp1_max.attr,
+        &sensor_dev_attr_temp1_input.dev_attr.attr,
+        &sensor_dev_attr_temp1_min.dev_attr.attr,
+        &sensor_dev_attr_temp1_max.dev_attr.attr,
+        &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
         &dev_attr_alarms.attr,
         NULL
 };
@@ -204,9 +212,9 @@ static int ds1621_detect(struct i2c_adapter *adapter, int address,
                          int kind)
 {
         int conf, temp;
-        struct i2c_client *new_client;
+        struct i2c_client *client;
         struct ds1621_data *data;
-        int err = 0;
+        int i, err = 0;
 
         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA 
                                      | I2C_FUNC_SMBUS_WORD_DATA 
@@ -221,55 +229,44 @@ static int ds1621_detect(struct i2c_adapter *adapter, int address,
                 goto exit;
         }
         
-        new_client = &data->client;
-        i2c_set_clientdata(new_client, data);
-        new_client->addr = address;
-        new_client->adapter = adapter;
-        new_client->driver = &ds1621_driver;
-        new_client->flags = 0;
-
+        client = &data->client;
+        i2c_set_clientdata(client, data);
+        client->addr = address;
+        client->adapter = adapter;
+        client->driver = &ds1621_driver;
 
         /* Now, we do the remaining detection. It is lousy. */
         if (kind < 0) {
                 /* The NVB bit should be low if no EEPROM write has been 
                    requested during the latest 10ms, which is highly 
                    improbable in our case. */
-                conf = ds1621_read_value(new_client, DS1621_REG_CONF);
+                conf = ds1621_read_value(client, DS1621_REG_CONF);
                 if (conf & DS1621_REG_CONFIG_NVB)
                         goto exit_free;
                 /* The 7 lowest bits of a temperature should always be 0. */
-                temp = ds1621_read_value(new_client, DS1621_REG_TEMP);
-                if (temp & 0x007f)
-                        goto exit_free;
-                temp = ds1621_read_value(new_client, DS1621_REG_TEMP_MIN);
-                if (temp & 0x007f)
-                        goto exit_free;
-                temp = ds1621_read_value(new_client, DS1621_REG_TEMP_MAX);
-                if (temp & 0x007f)
-                        goto exit_free;
+                for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
+                        temp = ds1621_read_value(client, DS1621_REG_TEMP[i]);
+                        if (temp & 0x007f)
+                                goto exit_free;
+                }
         }
 
-        /* Determine the chip type - only one kind supported! */
-        if (kind <= 0)
-                kind = ds1621;
-
         /* Fill in remaining client fields and put it into the global list */
-        strlcpy(new_client->name, "ds1621", I2C_NAME_SIZE);
-        data->valid = 0;
+        strlcpy(client->name, "ds1621", I2C_NAME_SIZE);
         mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
-        if ((err = i2c_attach_client(new_client)))
+        if ((err = i2c_attach_client(client)))
                 goto exit_free;
 
         /* Initialize the DS1621 chip */
-        ds1621_init_client(new_client);
+        ds1621_init_client(client);
 
         /* Register sysfs hooks */
-        if ((err = sysfs_create_group(&new_client->dev.kobj, &ds1621_group)))
+        if ((err = sysfs_create_group(&client->dev.kobj, &ds1621_group)))
                 goto exit_detach;
 
-        data->class_dev = hwmon_device_register(&new_client->dev);
+        data->class_dev = hwmon_device_register(&client->dev);
         if (IS_ERR(data->class_dev)) {
                 err = PTR_ERR(data->class_dev);
                 goto exit_remove_files;
@@ -278,9 +275,9 @@ static int ds1621_detect(struct i2c_adapter *adapter, int address,
         return 0;
 
       exit_remove_files:
-        sysfs_remove_group(&new_client->dev.kobj, &ds1621_group);
+        sysfs_remove_group(&client->dev.kobj, &ds1621_group);
       exit_detach:
-        i2c_detach_client(new_client);
+        i2c_detach_client(client);
       exit_free:
         kfree(data);
       exit:
@@ -314,23 +311,21 @@ static struct ds1621_data *ds1621_update_client(struct device *dev)
 
         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
             || !data->valid) {
+                int i;
 
                 dev_dbg(&client->dev, "Starting ds1621 update\n");
 
                 data->conf = ds1621_read_value(client, DS1621_REG_CONF);
 
-                data->temp = ds1621_read_value(client, DS1621_REG_TEMP);
-                
-                data->temp_min = ds1621_read_value(client,
-                                                    DS1621_REG_TEMP_MIN);
-                data->temp_max = ds1621_read_value(client,
-                                                    DS1621_REG_TEMP_MAX);
+                for (i = 0; i < ARRAY_SIZE(data->temp); i++)
+                        data->temp[i] = ds1621_read_value(client,
+                                                          DS1621_REG_TEMP[i]);
 
                 /* reset alarms if necessary */
                 new_conf = data->conf;
-                if (data->temp > data->temp_min)
+                if (data->temp[0] > data->temp[1])      /* input > min */
                         new_conf &= ~DS1621_ALARM_TEMP_LOW;
-                if (data->temp < data->temp_max)
+                if (data->temp[0] < data->temp[2])      /* input < max */
                         new_conf &= ~DS1621_ALARM_TEMP_HIGH;
                 if (data->conf != new_conf)
                         ds1621_write_value(client, DS1621_REG_CONF,
diff --git a/drivers/hwmon/f71805f.c b/drivers/hwmon/f71805f.c
index cdbe309b8fc4..6f60715f34f8 100644
--- a/drivers/hwmon/f71805f.c
+++ b/drivers/hwmon/f71805f.c
@@ -127,6 +127,13 @@ superio_exit(int base)
 #define F71805F_REG_TEMP_HIGH(nr)       (0x54 + 2 * (nr))
 #define F71805F_REG_TEMP_HYST(nr)       (0x55 + 2 * (nr))
 #define F71805F_REG_TEMP_MODE           0x01
+/* pwm/fan pwmnr from 0 to 2, auto point apnr from 0 to 2 */
+/* map Fintek numbers to our numbers as follows: 9->0, 5->1, 1->2 */
+#define F71805F_REG_PWM_AUTO_POINT_TEMP(pwmnr, apnr) \
+                                        (0xA0 + 0x10 * (pwmnr) + (2 - (apnr)))
+#define F71805F_REG_PWM_AUTO_POINT_FAN(pwmnr, apnr) \
+                                        (0xA4 + 0x10 * (pwmnr) + \
+                                                2 * (2 - (apnr)))
 
 #define F71805F_REG_START               0x00
 /* status nr from 0 to 2 */
@@ -144,6 +151,11 @@ superio_exit(int base)
  * Data structures and manipulation thereof
  */
 
+struct f71805f_auto_point {
+        u8 temp[3];
+        u16 fan[3];
+};
+
 struct f71805f_data {
         unsigned short addr;
         const char *name;
@@ -170,6 +182,7 @@ struct f71805f_data {
         u8 temp_hyst[3];
         u8 temp_mode;
         unsigned long alarms;
+        struct f71805f_auto_point auto_points[3];
 };
 
 struct f71805f_sio_data {
@@ -312,7 +325,7 @@ static void f71805f_write16(struct f71805f_data *data, u8 reg, u16 val)
 static struct f71805f_data *f71805f_update_device(struct device *dev)
 {
         struct f71805f_data *data = dev_get_drvdata(dev);
-        int nr;
+        int nr, apnr;
 
         mutex_lock(&data->update_lock);
 
@@ -342,6 +355,18 @@ static struct f71805f_data *f71805f_update_device(struct device *dev)
                                               F71805F_REG_TEMP_HYST(nr));
                 }
                 data->temp_mode = f71805f_read8(data, F71805F_REG_TEMP_MODE);
+                for (nr = 0; nr < 3; nr++) {
+                        for (apnr = 0; apnr < 3; apnr++) {
+                                data->auto_points[nr].temp[apnr] =
+                                        f71805f_read8(data,
+                                        F71805F_REG_PWM_AUTO_POINT_TEMP(nr,
+                                                                        apnr));
+                                data->auto_points[nr].fan[apnr] =
+                                        f71805f_read16(data,
+                                        F71805F_REG_PWM_AUTO_POINT_FAN(nr,
+                                                                       apnr));
+                        }
+                }
 
                 data->last_limits = jiffies;
         }
@@ -705,6 +730,70 @@ static ssize_t set_pwm_freq(struct device *dev, struct device_attribute
         return count;
 }
 
+static ssize_t show_pwm_auto_point_temp(struct device *dev,
+                                        struct device_attribute *devattr,
+                                        char* buf)
+{
+        struct f71805f_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
+        int pwmnr = attr->nr;
+        int apnr = attr->index;
+
+        return sprintf(buf, "%ld\n",
+                       temp_from_reg(data->auto_points[pwmnr].temp[apnr]));
+}
+
+static ssize_t set_pwm_auto_point_temp(struct device *dev,
+                                       struct device_attribute *devattr,
+                                       const char* buf, size_t count)
+{
+        struct f71805f_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
+        int pwmnr = attr->nr;
+        int apnr = attr->index;
+        unsigned long val = simple_strtol(buf, NULL, 10);
+
+        mutex_lock(&data->update_lock);
+        data->auto_points[pwmnr].temp[apnr] = temp_to_reg(val);
+        f71805f_write8(data, F71805F_REG_PWM_AUTO_POINT_TEMP(pwmnr, apnr),
+                       data->auto_points[pwmnr].temp[apnr]);
+        mutex_unlock(&data->update_lock);
+
+        return count;
+}
+
+static ssize_t show_pwm_auto_point_fan(struct device *dev,
+                                       struct device_attribute *devattr,
+                                       char* buf)
+{
+        struct f71805f_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
+        int pwmnr = attr->nr;
+        int apnr = attr->index;
+
+        return sprintf(buf, "%ld\n",
+                       fan_from_reg(data->auto_points[pwmnr].fan[apnr]));
+}
+
+static ssize_t set_pwm_auto_point_fan(struct device *dev,
+                                      struct device_attribute *devattr,
+                                      const char* buf, size_t count)
+{
+        struct f71805f_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
+        int pwmnr = attr->nr;
+        int apnr = attr->index;
+        unsigned long val = simple_strtoul(buf, NULL, 10);
+
+        mutex_lock(&data->update_lock);
+        data->auto_points[pwmnr].fan[apnr] = fan_to_reg(val);
+        f71805f_write16(data, F71805F_REG_PWM_AUTO_POINT_FAN(pwmnr, apnr),
+                        data->auto_points[pwmnr].fan[apnr]);
+        mutex_unlock(&data->update_lock);
+
+        return count;
+}
+
 static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
                          char *buf)
 {
@@ -932,6 +1021,63 @@ static SENSOR_DEVICE_ATTR(pwm3_freq, S_IRUGO | S_IWUSR,
                           show_pwm_freq, set_pwm_freq, 2);
 static SENSOR_DEVICE_ATTR(pwm3_mode, S_IRUGO, show_pwm_mode, NULL, 2);
 
+static SENSOR_DEVICE_ATTR_2(pwm1_auto_point1_temp, S_IRUGO | S_IWUSR,
+                            show_pwm_auto_point_temp, set_pwm_auto_point_temp,
+                            0, 0);
+static SENSOR_DEVICE_ATTR_2(pwm1_auto_point1_fan, S_IRUGO | S_IWUSR,
+                            show_pwm_auto_point_fan, set_pwm_auto_point_fan,
+                            0, 0);
+static SENSOR_DEVICE_ATTR_2(pwm1_auto_point2_temp, S_IRUGO | S_IWUSR,
+                            show_pwm_auto_point_temp, set_pwm_auto_point_temp,
+                            0, 1);
+static SENSOR_DEVICE_ATTR_2(pwm1_auto_point2_fan, S_IRUGO | S_IWUSR,
+                            show_pwm_auto_point_fan, set_pwm_auto_point_fan,
+                            0, 1);
+static SENSOR_DEVICE_ATTR_2(pwm1_auto_point3_temp, S_IRUGO | S_IWUSR,
+                            show_pwm_auto_point_temp, set_pwm_auto_point_temp,
+                            0, 2);
+static SENSOR_DEVICE_ATTR_2(pwm1_auto_point3_fan, S_IRUGO | S_IWUSR,
+                            show_pwm_auto_point_fan, set_pwm_auto_point_fan,
+                            0, 2);
+
+static SENSOR_DEVICE_ATTR_2(pwm2_auto_point1_temp, S_IRUGO | S_IWUSR,
+                            show_pwm_auto_point_temp, set_pwm_auto_point_temp,
+                            1, 0);
+static SENSOR_DEVICE_ATTR_2(pwm2_auto_point1_fan, S_IRUGO | S_IWUSR,
+                            show_pwm_auto_point_fan, set_pwm_auto_point_fan,
+                            1, 0);
+static SENSOR_DEVICE_ATTR_2(pwm2_auto_point2_temp, S_IRUGO | S_IWUSR,
+                            show_pwm_auto_point_temp, set_pwm_auto_point_temp,
+                            1, 1);
+static SENSOR_DEVICE_ATTR_2(pwm2_auto_point2_fan, S_IRUGO | S_IWUSR,
+                            show_pwm_auto_point_fan, set_pwm_auto_point_fan,
+                            1, 1);
+static SENSOR_DEVICE_ATTR_2(pwm2_auto_point3_temp, S_IRUGO | S_IWUSR,
+                            show_pwm_auto_point_temp, set_pwm_auto_point_temp,
+                            1, 2);
+static SENSOR_DEVICE_ATTR_2(pwm2_auto_point3_fan, S_IRUGO | S_IWUSR,
+                            show_pwm_auto_point_fan, set_pwm_auto_point_fan,
+                            1, 2);
+
+static SENSOR_DEVICE_ATTR_2(pwm3_auto_point1_temp, S_IRUGO | S_IWUSR,
+                            show_pwm_auto_point_temp, set_pwm_auto_point_temp,
+                            2, 0);
+static SENSOR_DEVICE_ATTR_2(pwm3_auto_point1_fan, S_IRUGO | S_IWUSR,
+                            show_pwm_auto_point_fan, set_pwm_auto_point_fan,
+                            2, 0);
+static SENSOR_DEVICE_ATTR_2(pwm3_auto_point2_temp, S_IRUGO | S_IWUSR,
+                            show_pwm_auto_point_temp, set_pwm_auto_point_temp,
+                            2, 1);
+static SENSOR_DEVICE_ATTR_2(pwm3_auto_point2_fan, S_IRUGO | S_IWUSR,
+                            show_pwm_auto_point_fan, set_pwm_auto_point_fan,
+                            2, 1);
+static SENSOR_DEVICE_ATTR_2(pwm3_auto_point3_temp, S_IRUGO | S_IWUSR,
+                            show_pwm_auto_point_temp, set_pwm_auto_point_temp,
+                            2, 2);
+static SENSOR_DEVICE_ATTR_2(pwm3_auto_point3_fan, S_IRUGO | S_IWUSR,
+                            show_pwm_auto_point_fan, set_pwm_auto_point_fan,
+                            2, 2);
+
 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
@@ -1014,6 +1160,25 @@ static struct attribute *f71805f_attributes[] = {
         &sensor_dev_attr_temp3_max_hyst.dev_attr.attr,
         &sensor_dev_attr_temp3_type.dev_attr.attr,
 
+        &sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr,
+        &sensor_dev_attr_pwm1_auto_point1_fan.dev_attr.attr,
+        &sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr,
+        &sensor_dev_attr_pwm1_auto_point2_fan.dev_attr.attr,
+        &sensor_dev_attr_pwm1_auto_point3_temp.dev_attr.attr,
+        &sensor_dev_attr_pwm1_auto_point3_fan.dev_attr.attr,
+        &sensor_dev_attr_pwm2_auto_point1_temp.dev_attr.attr,
+        &sensor_dev_attr_pwm2_auto_point1_fan.dev_attr.attr,
+        &sensor_dev_attr_pwm2_auto_point2_temp.dev_attr.attr,
+        &sensor_dev_attr_pwm2_auto_point2_fan.dev_attr.attr,
+        &sensor_dev_attr_pwm2_auto_point3_temp.dev_attr.attr,
+        &sensor_dev_attr_pwm2_auto_point3_fan.dev_attr.attr,
+        &sensor_dev_attr_pwm3_auto_point1_temp.dev_attr.attr,
+        &sensor_dev_attr_pwm3_auto_point1_fan.dev_attr.attr,
+        &sensor_dev_attr_pwm3_auto_point2_temp.dev_attr.attr,
+        &sensor_dev_attr_pwm3_auto_point2_fan.dev_attr.attr,
+        &sensor_dev_attr_pwm3_auto_point3_temp.dev_attr.attr,
+        &sensor_dev_attr_pwm3_auto_point3_fan.dev_attr.attr,
+
         &sensor_dev_attr_in0_alarm.dev_attr.attr,
         &sensor_dev_attr_in1_alarm.dev_attr.attr,
         &sensor_dev_attr_in2_alarm.dev_attr.attr,
@@ -1242,12 +1407,12 @@ static int __devexit f71805f_remove(struct platform_device *pdev)
         struct resource *res;
         int i;
 
-        platform_set_drvdata(pdev, NULL);
         hwmon_device_unregister(data->class_dev);
         sysfs_remove_group(&pdev->dev.kobj, &f71805f_group);
         for (i = 0; i < 4; i++)
                 sysfs_remove_group(&pdev->dev.kobj, &f71805f_group_optin[i]);
         sysfs_remove_group(&pdev->dev.kobj, &f71805f_group_pwm_freq);
+        platform_set_drvdata(pdev, NULL);
         kfree(data);
 
         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
@@ -1290,15 +1455,12 @@ static int __init f71805f_device_add(unsigned short address,
                 goto exit_device_put;
         }
 
-        pdev->dev.platform_data = kmalloc(sizeof(struct f71805f_sio_data),
-                                          GFP_KERNEL);
-        if (!pdev->dev.platform_data) {
-                err = -ENOMEM;
+        err = platform_device_add_data(pdev, sio_data,
+                                       sizeof(struct f71805f_sio_data));
+        if (err) {
                 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
                 goto exit_device_put;
         }
-        memcpy(pdev->dev.platform_data, sio_data,
-               sizeof(struct f71805f_sio_data));
 
         err = platform_device_add(pdev);
         if (err) {
diff --git a/drivers/hwmon/it87.c b/drivers/hwmon/it87.c
index 62afc63708a5..eff6036e15c0 100644
--- a/drivers/hwmon/it87.c
+++ b/drivers/hwmon/it87.c
@@ -6,6 +6,7 @@
               IT8712F  Super I/O chip w/LPC interface
               IT8716F  Super I/O chip w/LPC interface
               IT8718F  Super I/O chip w/LPC interface
+              IT8726F  Super I/O chip w/LPC interface
               Sis950   A clone of the IT8705F
 
     Copyright (C) 2001 Chris Gauthron <chrisg@0-in.com> 
@@ -30,8 +31,7 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/jiffies.h>
-#include <linux/i2c.h>
-#include <linux/i2c-isa.h>
+#include <linux/platform_device.h>
 #include <linux/hwmon.h>
 #include <linux/hwmon-sysfs.h>
 #include <linux/hwmon-vid.h>
@@ -40,10 +40,12 @@
 #include <linux/sysfs.h>
 #include <asm/io.h>
 
+#define DRVNAME "it87"
 
-static unsigned short isa_address;
 enum chips { it87, it8712, it8716, it8718 };
 
+static struct platform_device *pdev;
+
 #define REG     0x2e    /* The register to read/write */
 #define DEV     0x07    /* Register: Logical device select */
 #define VAL     0x2f    /* The value to read/write */
@@ -97,6 +99,7 @@ superio_exit(void)
 #define IT8705F_DEVID 0x8705
 #define IT8716F_DEVID 0x8716
 #define IT8718F_DEVID 0x8718
+#define IT8726F_DEVID 0x8726
 #define IT87_ACT_REG  0x30
 #define IT87_BASE_REG 0x60
 
@@ -110,10 +113,6 @@ static int update_vbat;
 /* Not all BIOSes properly configure the PWM registers */
 static int fix_pwm_polarity;
 
-/* Values read from Super-I/O config space */
-static u16 chip_type;
-static u8 vid_value;
-
 /* Many IT87 constants specified below */
 
 /* Length of ISA address segment */
@@ -214,13 +213,20 @@ static const unsigned int pwm_freq[8] = {
 };
 
 
+struct it87_sio_data {
+        enum chips type;
+        /* Values read from Super-I/O config space */
+        u8 vid_value;
+};
+
 /* For each registered chip, we need to keep some data in memory.
    The structure is dynamically allocated. */
 struct it87_data {
-        struct i2c_client client;
         struct class_device *class_dev;
         enum chips type;
 
+        unsigned short addr;
+        const char *name;
         struct mutex update_lock;
         char valid;             /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
@@ -245,26 +251,25 @@ struct it87_data {
 };
 
 
-static int it87_detect(struct i2c_adapter *adapter);
-static int it87_detach_client(struct i2c_client *client);
+static int it87_probe(struct platform_device *pdev);
+static int it87_remove(struct platform_device *pdev);
 
-static int it87_read_value(struct i2c_client *client, u8 reg);
-static void it87_write_value(struct i2c_client *client, u8 reg, u8 value);
+static int it87_read_value(struct it87_data *data, u8 reg);
+static void it87_write_value(struct it87_data *data, u8 reg, u8 value);
 static struct it87_data *it87_update_device(struct device *dev);
-static int it87_check_pwm(struct i2c_client *client);
-static void it87_init_client(struct i2c_client *client, struct it87_data *data);
+static int it87_check_pwm(struct device *dev);
+static void it87_init_device(struct platform_device *pdev);
 
 
-static struct i2c_driver it87_isa_driver = {
+static struct platform_driver it87_driver = {
         .driver = {
                 .owner  = THIS_MODULE,
-                .name   = "it87-isa",
+                .name   = DRVNAME,
         },
-        .attach_adapter = it87_detect,
-        .detach_client  = it87_detach_client,
+        .probe  = it87_probe,
+        .remove = __devexit_p(it87_remove),
 };
 
-
 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
                 char *buf)
 {
@@ -301,13 +306,12 @@ static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
         int nr = sensor_attr->index;
 
-        struct i2c_client *client = to_i2c_client(dev);
-        struct it87_data *data = i2c_get_clientdata(client);
+        struct it87_data *data = dev_get_drvdata(dev);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->in_min[nr] = IN_TO_REG(val);
-        it87_write_value(client, IT87_REG_VIN_MIN(nr), 
+        it87_write_value(data, IT87_REG_VIN_MIN(nr),
                         data->in_min[nr]);
         mutex_unlock(&data->update_lock);
         return count;
@@ -318,13 +322,12 @@ static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
         int nr = sensor_attr->index;
 
-        struct i2c_client *client = to_i2c_client(dev);
-        struct it87_data *data = i2c_get_clientdata(client);
+        struct it87_data *data = dev_get_drvdata(dev);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->in_max[nr] = IN_TO_REG(val);
-        it87_write_value(client, IT87_REG_VIN_MAX(nr), 
+        it87_write_value(data, IT87_REG_VIN_MAX(nr),
                         data->in_max[nr]);
         mutex_unlock(&data->update_lock);
         return count;
@@ -392,13 +395,12 @@ static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
         int nr = sensor_attr->index;
 
-        struct i2c_client *client = to_i2c_client(dev);
-        struct it87_data *data = i2c_get_clientdata(client);
+        struct it87_data *data = dev_get_drvdata(dev);
         int val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->temp_high[nr] = TEMP_TO_REG(val);
-        it87_write_value(client, IT87_REG_TEMP_HIGH(nr), data->temp_high[nr]);
+        it87_write_value(data, IT87_REG_TEMP_HIGH(nr), data->temp_high[nr]);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -408,13 +410,12 @@ static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
         int nr = sensor_attr->index;
 
-        struct i2c_client *client = to_i2c_client(dev);
-        struct it87_data *data = i2c_get_clientdata(client);
+        struct it87_data *data = dev_get_drvdata(dev);
         int val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->temp_low[nr] = TEMP_TO_REG(val);
-        it87_write_value(client, IT87_REG_TEMP_LOW(nr), data->temp_low[nr]);
+        it87_write_value(data, IT87_REG_TEMP_LOW(nr), data->temp_low[nr]);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -451,8 +452,7 @@ static ssize_t set_sensor(struct device *dev, struct device_attribute *attr,
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
         int nr = sensor_attr->index;
 
-        struct i2c_client *client = to_i2c_client(dev);
-        struct it87_data *data = i2c_get_clientdata(client);
+        struct it87_data *data = dev_get_drvdata(dev);
         int val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
@@ -468,7 +468,7 @@ static ssize_t set_sensor(struct device *dev, struct device_attribute *attr,
                 mutex_unlock(&data->update_lock);
                 return -EINVAL;
         }
-        it87_write_value(client, IT87_REG_TEMP_ENABLE, data->sensor);
+        it87_write_value(data, IT87_REG_TEMP_ENABLE, data->sensor);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -542,13 +542,12 @@ static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
         int nr = sensor_attr->index;
 
-        struct i2c_client *client = to_i2c_client(dev);
-        struct it87_data *data = i2c_get_clientdata(client);
+        struct it87_data *data = dev_get_drvdata(dev);
         int val = simple_strtol(buf, NULL, 10);
         u8 reg;
 
         mutex_lock(&data->update_lock);
-        reg = it87_read_value(client, IT87_REG_FAN_DIV);
+        reg = it87_read_value(data, IT87_REG_FAN_DIV);
         switch (nr) {
         case 0: data->fan_div[nr] = reg & 0x07; break;
         case 1: data->fan_div[nr] = (reg >> 3) & 0x07; break;
@@ -556,7 +555,7 @@ static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
         }
 
         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
-        it87_write_value(client, IT87_REG_FAN_MIN(nr), data->fan_min[nr]);
+        it87_write_value(data, IT87_REG_FAN_MIN(nr), data->fan_min[nr]);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -566,14 +565,13 @@ static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
         int nr = sensor_attr->index;
 
-        struct i2c_client *client = to_i2c_client(dev);
-        struct it87_data *data = i2c_get_clientdata(client);
+        struct it87_data *data = dev_get_drvdata(dev);
         unsigned long val = simple_strtoul(buf, NULL, 10);
         int min;
         u8 old;
 
         mutex_lock(&data->update_lock);
-        old = it87_read_value(client, IT87_REG_FAN_DIV);
+        old = it87_read_value(data, IT87_REG_FAN_DIV);
 
         /* Save fan min limit */
         min = FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr]));
@@ -594,11 +592,11 @@ static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
         val |= (data->fan_div[1] & 0x07) << 3;
         if (data->fan_div[2] == 3)
                 val |= 0x1 << 6;
-        it87_write_value(client, IT87_REG_FAN_DIV, val);
+        it87_write_value(data, IT87_REG_FAN_DIV, val);
 
         /* Restore fan min limit */
         data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
-        it87_write_value(client, IT87_REG_FAN_MIN(nr), data->fan_min[nr]);
+        it87_write_value(data, IT87_REG_FAN_MIN(nr), data->fan_min[nr]);
 
         mutex_unlock(&data->update_lock);
         return count;
@@ -609,8 +607,7 @@ static ssize_t set_pwm_enable(struct device *dev,
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
         int nr = sensor_attr->index;
 
-        struct i2c_client *client = to_i2c_client(dev);
-        struct it87_data *data = i2c_get_clientdata(client);
+        struct it87_data *data = dev_get_drvdata(dev);
         int val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
@@ -618,17 +615,17 @@ static ssize_t set_pwm_enable(struct device *dev,
         if (val == 0) {
                 int tmp;
                 /* make sure the fan is on when in on/off mode */
-                tmp = it87_read_value(client, IT87_REG_FAN_CTL);
-                it87_write_value(client, IT87_REG_FAN_CTL, tmp | (1 << nr));
+                tmp = it87_read_value(data, IT87_REG_FAN_CTL);
+                it87_write_value(data, IT87_REG_FAN_CTL, tmp | (1 << nr));
                 /* set on/off mode */
                 data->fan_main_ctrl &= ~(1 << nr);
-                it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
+                it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
         } else if (val == 1) {
                 /* set SmartGuardian mode */
                 data->fan_main_ctrl |= (1 << nr);
-                it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
+                it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
                 /* set saved pwm value, clear FAN_CTLX PWM mode bit */
-                it87_write_value(client, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
+                it87_write_value(data, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
         } else {
                 mutex_unlock(&data->update_lock);
                 return -EINVAL;
@@ -643,8 +640,7 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
         int nr = sensor_attr->index;
 
-        struct i2c_client *client = to_i2c_client(dev);
-        struct it87_data *data = i2c_get_clientdata(client);
+        struct it87_data *data = dev_get_drvdata(dev);
         int val = simple_strtol(buf, NULL, 10);
 
         if (val < 0 || val > 255)
@@ -653,15 +649,14 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
         mutex_lock(&data->update_lock);
         data->manual_pwm_ctl[nr] = val;
         if (data->fan_main_ctrl & (1 << nr))
-                it87_write_value(client, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
+                it87_write_value(data, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
         mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t set_pwm_freq(struct device *dev,
                 struct device_attribute *attr, const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct it87_data *data = i2c_get_clientdata(client);
+        struct it87_data *data = dev_get_drvdata(dev);
         unsigned long val = simple_strtoul(buf, NULL, 10);
         int i;
 
@@ -672,9 +667,9 @@ static ssize_t set_pwm_freq(struct device *dev,
         }
 
         mutex_lock(&data->update_lock);
-        data->fan_ctl = it87_read_value(client, IT87_REG_FAN_CTL) & 0x8f;
+        data->fan_ctl = it87_read_value(data, IT87_REG_FAN_CTL) & 0x8f;
         data->fan_ctl |= i << 4;
-        it87_write_value(client, IT87_REG_FAN_CTL, data->fan_ctl);
+        it87_write_value(data, IT87_REG_FAN_CTL, data->fan_ctl);
         mutex_unlock(&data->update_lock);
 
         return count;
@@ -729,15 +724,14 @@ static ssize_t set_fan16_min(struct device *dev, struct device_attribute *attr,
 {
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
         int nr = sensor_attr->index;
-        struct i2c_client *client = to_i2c_client(dev);
-        struct it87_data *data = i2c_get_clientdata(client);
+        struct it87_data *data = dev_get_drvdata(dev);
         int val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->fan_min[nr] = FAN16_TO_REG(val);
-        it87_write_value(client, IT87_REG_FAN_MIN(nr),
+        it87_write_value(data, IT87_REG_FAN_MIN(nr),
                          data->fan_min[nr] & 0xff);
-        it87_write_value(client, IT87_REG_FANX_MIN(nr),
+        it87_write_value(data, IT87_REG_FANX_MIN(nr),
                          data->fan_min[nr] >> 8);
         mutex_unlock(&data->update_lock);
         return count;
@@ -775,8 +769,7 @@ show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
 static ssize_t
 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct it87_data *data = i2c_get_clientdata(client);
+        struct it87_data *data = dev_get_drvdata(dev);
         u32 val;
 
         val = simple_strtoul(buf, NULL, 10);
@@ -794,6 +787,14 @@ show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
 }
 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
 
+static ssize_t show_name(struct device *dev, struct device_attribute
+                         *devattr, char *buf)
+{
+        struct it87_data *data = dev_get_drvdata(dev);
+        return sprintf(buf, "%s\n", data->name);
+}
+static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
+
 static struct attribute *it87_attributes[] = {
         &sensor_dev_attr_in0_input.dev_attr.attr,
         &sensor_dev_attr_in1_input.dev_attr.attr,
@@ -835,6 +836,7 @@ static struct attribute *it87_attributes[] = {
         &sensor_dev_attr_temp3_type.dev_attr.attr,
 
         &dev_attr_alarms.attr,
+        &dev_attr_name.attr,
         NULL
 };
 
@@ -877,17 +879,36 @@ static const struct attribute_group it87_group_opt = {
 };
 
 /* SuperIO detection - will change isa_address if a chip is found */
-static int __init it87_find(unsigned short *address)
+static int __init it87_find(unsigned short *address,
+        struct it87_sio_data *sio_data)
 {
         int err = -ENODEV;
+        u16 chip_type;
 
         superio_enter();
         chip_type = superio_inw(DEVID);
-        if (chip_type != IT8712F_DEVID
-         && chip_type != IT8716F_DEVID
-         && chip_type != IT8718F_DEVID
-         && chip_type != IT8705F_DEVID)
-                goto exit;
+
+        switch (chip_type) {
+        case IT8705F_DEVID:
+                sio_data->type = it87;
+                break;
+        case IT8712F_DEVID:
+                sio_data->type = it8712;
+                break;
+        case IT8716F_DEVID:
+        case IT8726F_DEVID:
+                sio_data->type = it8716;
+                break;
+        case IT8718F_DEVID:
+                sio_data->type = it8718;
+                break;
+        case 0xffff:    /* No device at all */
+                goto exit;
+        default:
+                pr_debug(DRVNAME ": Unsupported chip (DEVID=0x%x)\n",
+                         chip_type);
+                goto exit;
+        }
 
         superio_select(PME);
         if (!(superio_inb(IT87_ACT_REG) & 0x01)) {
@@ -911,7 +932,7 @@ static int __init it87_find(unsigned short *address)
 
                 superio_select(GPIO);
                 if (chip_type == it8718)
-                        vid_value = superio_inb(IT87_SIO_VID_REG);
+                        sio_data->vid_value = superio_inb(IT87_SIO_VID_REG);
 
                 reg = superio_inb(IT87_SIO_PINX2_REG);
                 if (reg & (1 << 0))
@@ -925,18 +946,26 @@ exit:
         return err;
 }
 
-/* This function is called by i2c_probe */
-static int it87_detect(struct i2c_adapter *adapter)
+static int __devinit it87_probe(struct platform_device *pdev)
 {
-        struct i2c_client *new_client;
         struct it87_data *data;
+        struct resource *res;
+        struct device *dev = &pdev->dev;
+        struct it87_sio_data *sio_data = dev->platform_data;
         int err = 0;
-        const char *name;
         int enable_pwm_interface;
-
-        /* Reserve the ISA region */
-        if (!request_region(isa_address, IT87_EXTENT,
-                            it87_isa_driver.driver.name)){
+        static const char *names[] = {
+                "it87",
+                "it8712",
+                "it8716",
+                "it8718",
+        };
+
+        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
+        if (!request_region(res->start, IT87_EXTENT, DRVNAME)) {
+                dev_err(dev, "Failed to request region 0x%lx-0x%lx\n",
+                        (unsigned long)res->start,
+                        (unsigned long)(res->start + IT87_EXTENT - 1));
                 err = -EBUSY;
                 goto ERROR0;
         }
@@ -946,129 +975,104 @@ static int it87_detect(struct i2c_adapter *adapter)
                 goto ERROR1;
         }
 
-        new_client = &data->client;
-        i2c_set_clientdata(new_client, data);
-        new_client->addr = isa_address;
-        new_client->adapter = adapter;
-        new_client->driver = &it87_isa_driver;
+        data->addr = res->start;
+        data->type = sio_data->type;
+        data->name = names[sio_data->type];
 
         /* Now, we do the remaining detection. */
-        if ((it87_read_value(new_client, IT87_REG_CONFIG) & 0x80)
-         || it87_read_value(new_client, IT87_REG_CHIPID) != 0x90) {
+        if ((it87_read_value(data, IT87_REG_CONFIG) & 0x80)
+         || it87_read_value(data, IT87_REG_CHIPID) != 0x90) {
                 err = -ENODEV;
                 goto ERROR2;
         }
 
-        /* Determine the chip type. */
-        switch (chip_type) {
-        case IT8712F_DEVID:
-                data->type = it8712;
-                name = "it8712";
-                break;
-        case IT8716F_DEVID:
-                data->type = it8716;
-                name = "it8716";
-                break;
-        case IT8718F_DEVID:
-                data->type = it8718;
-                name = "it8718";
-                break;
-        default:
-                data->type = it87;
-                name = "it87";
-        }
+        platform_set_drvdata(pdev, data);
 
-        /* Fill in the remaining client fields and put it into the global list */
-        strlcpy(new_client->name, name, I2C_NAME_SIZE);
         mutex_init(&data->update_lock);
 
-        /* Tell the I2C layer a new client has arrived */
-        if ((err = i2c_attach_client(new_client)))
-                goto ERROR2;
-
         /* Check PWM configuration */
-        enable_pwm_interface = it87_check_pwm(new_client);
+        enable_pwm_interface = it87_check_pwm(dev);
 
         /* Initialize the IT87 chip */
-        it87_init_client(new_client, data);
+        it87_init_device(pdev);
 
         /* Register sysfs hooks */
-        if ((err = sysfs_create_group(&new_client->dev.kobj, &it87_group)))
-                goto ERROR3;
+        if ((err = sysfs_create_group(&dev->kobj, &it87_group)))
+                goto ERROR2;
 
         /* Do not create fan files for disabled fans */
         if (data->type == it8716 || data->type == it8718) {
                 /* 16-bit tachometers */
                 if (data->has_fan & (1 << 0)) {
-                        if ((err = device_create_file(&new_client->dev,
+                        if ((err = device_create_file(dev,
                              &sensor_dev_attr_fan1_input16.dev_attr))
-                         || (err = device_create_file(&new_client->dev,
+                         || (err = device_create_file(dev,
                              &sensor_dev_attr_fan1_min16.dev_attr)))
                                 goto ERROR4;
                 }
                 if (data->has_fan & (1 << 1)) {
-                        if ((err = device_create_file(&new_client->dev,
+                        if ((err = device_create_file(dev,
                              &sensor_dev_attr_fan2_input16.dev_attr))
-                         || (err = device_create_file(&new_client->dev,
+                         || (err = device_create_file(dev,
                              &sensor_dev_attr_fan2_min16.dev_attr)))
                                 goto ERROR4;
                 }
                 if (data->has_fan & (1 << 2)) {
-                        if ((err = device_create_file(&new_client->dev,
+                        if ((err = device_create_file(dev,
                              &sensor_dev_attr_fan3_input16.dev_attr))
-                         || (err = device_create_file(&new_client->dev,
+                         || (err = device_create_file(dev,
                              &sensor_dev_attr_fan3_min16.dev_attr)))
                                 goto ERROR4;
                 }
         } else {
                 /* 8-bit tachometers with clock divider */
                 if (data->has_fan & (1 << 0)) {
-                        if ((err = device_create_file(&new_client->dev,
+                        if ((err = device_create_file(dev,
                              &sensor_dev_attr_fan1_input.dev_attr))
-                         || (err = device_create_file(&new_client->dev,
+                         || (err = device_create_file(dev,
                              &sensor_dev_attr_fan1_min.dev_attr))
-                         || (err = device_create_file(&new_client->dev,
+                         || (err = device_create_file(dev,
                              &sensor_dev_attr_fan1_div.dev_attr)))
                                 goto ERROR4;
                 }
                 if (data->has_fan & (1 << 1)) {
-                        if ((err = device_create_file(&new_client->dev,
+                        if ((err = device_create_file(dev,
                              &sensor_dev_attr_fan2_input.dev_attr))
-                         || (err = device_create_file(&new_client->dev,
+                         || (err = device_create_file(dev,
                              &sensor_dev_attr_fan2_min.dev_attr))
-                         || (err = device_create_file(&new_client->dev,
+                         || (err = device_create_file(dev,
                              &sensor_dev_attr_fan2_div.dev_attr)))
                                 goto ERROR4;
                 }
                 if (data->has_fan & (1 << 2)) {
-                        if ((err = device_create_file(&new_client->dev,
+                        if ((err = device_create_file(dev,
                              &sensor_dev_attr_fan3_input.dev_attr))
-                         || (err = device_create_file(&new_client->dev,
+                         || (err = device_create_file(dev,
                              &sensor_dev_attr_fan3_min.dev_attr))
-                         || (err = device_create_file(&new_client->dev,
+                         || (err = device_create_file(dev,
                              &sensor_dev_attr_fan3_div.dev_attr)))
                                 goto ERROR4;
                 }
         }
 
         if (enable_pwm_interface) {
-                if ((err = device_create_file(&new_client->dev,
+                if ((err = device_create_file(dev,
                      &sensor_dev_attr_pwm1_enable.dev_attr))
-                 || (err = device_create_file(&new_client->dev,
+                 || (err = device_create_file(dev,
                      &sensor_dev_attr_pwm2_enable.dev_attr))
-                 || (err = device_create_file(&new_client->dev,
+                 || (err = device_create_file(dev,
                      &sensor_dev_attr_pwm3_enable.dev_attr))
-                 || (err = device_create_file(&new_client->dev,
+                 || (err = device_create_file(dev,
                      &sensor_dev_attr_pwm1.dev_attr))
-                 || (err = device_create_file(&new_client->dev,
+                 || (err = device_create_file(dev,
                      &sensor_dev_attr_pwm2.dev_attr))
-                 || (err = device_create_file(&new_client->dev,
+                 || (err = device_create_file(dev,
                      &sensor_dev_attr_pwm3.dev_attr))
-                 || (err = device_create_file(&new_client->dev,
+                 || (err = device_create_file(dev,
                      &dev_attr_pwm1_freq))
-                 || (err = device_create_file(&new_client->dev,
+                 || (err = device_create_file(dev,
                      &dev_attr_pwm2_freq))
-                 || (err = device_create_file(&new_client->dev,
+                 || (err = device_create_file(dev,
                      &dev_attr_pwm3_freq)))
                         goto ERROR4;
         }
@@ -1077,15 +1081,15 @@ static int it87_detect(struct i2c_adapter *adapter)
          || data->type == it8718) {
                 data->vrm = vid_which_vrm();
                 /* VID reading from Super-I/O config space if available */
-                data->vid = vid_value;
-                if ((err = device_create_file(&new_client->dev,
+                data->vid = sio_data->vid_value;
+                if ((err = device_create_file(dev,
                      &dev_attr_vrm))
-                 || (err = device_create_file(&new_client->dev,
+                 || (err = device_create_file(dev,
                      &dev_attr_cpu0_vid)))
                         goto ERROR4;
         }
 
-        data->class_dev = hwmon_device_register(&new_client->dev);
+        data->class_dev = hwmon_device_register(dev);
         if (IS_ERR(data->class_dev)) {
                 err = PTR_ERR(data->class_dev);
                 goto ERROR4;
@@ -1094,31 +1098,27 @@ static int it87_detect(struct i2c_adapter *adapter)
         return 0;
 
 ERROR4:
-        sysfs_remove_group(&new_client->dev.kobj, &it87_group);
-        sysfs_remove_group(&new_client->dev.kobj, &it87_group_opt);
-ERROR3:
-        i2c_detach_client(new_client);
+        sysfs_remove_group(&dev->kobj, &it87_group);
+        sysfs_remove_group(&dev->kobj, &it87_group_opt);
 ERROR2:
+        platform_set_drvdata(pdev, NULL);
         kfree(data);
 ERROR1:
-        release_region(isa_address, IT87_EXTENT);
+        release_region(res->start, IT87_EXTENT);
 ERROR0:
         return err;
 }
 
-static int it87_detach_client(struct i2c_client *client)
+static int __devexit it87_remove(struct platform_device *pdev)
 {
-        struct it87_data *data = i2c_get_clientdata(client);
-        int err;
+        struct it87_data *data = platform_get_drvdata(pdev);
 
         hwmon_device_unregister(data->class_dev);
-        sysfs_remove_group(&client->dev.kobj, &it87_group);
-        sysfs_remove_group(&client->dev.kobj, &it87_group_opt);
+        sysfs_remove_group(&pdev->dev.kobj, &it87_group);
+        sysfs_remove_group(&pdev->dev.kobj, &it87_group_opt);
 
-        if ((err = i2c_detach_client(client)))
-                return err;
-
-        release_region(client->addr, IT87_EXTENT);
+        release_region(data->addr, IT87_EXTENT);
+        platform_set_drvdata(pdev, NULL);
         kfree(data);
 
         return 0;
@@ -1127,28 +1127,29 @@ static int it87_detach_client(struct i2c_client *client)
 /* Must be called with data->update_lock held, except during initialization.
    We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
    would slow down the IT87 access and should not be necessary. */
-static int it87_read_value(struct i2c_client *client, u8 reg)
+static int it87_read_value(struct it87_data *data, u8 reg)
 {
-        outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
-        return inb_p(client->addr + IT87_DATA_REG_OFFSET);
+        outb_p(reg, data->addr + IT87_ADDR_REG_OFFSET);
+        return inb_p(data->addr + IT87_DATA_REG_OFFSET);
 }
 
 /* Must be called with data->update_lock held, except during initialization.
    We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
    would slow down the IT87 access and should not be necessary. */
-static void it87_write_value(struct i2c_client *client, u8 reg, u8 value)
+static void it87_write_value(struct it87_data *data, u8 reg, u8 value)
 {
-        outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
-        outb_p(value, client->addr + IT87_DATA_REG_OFFSET);
+        outb_p(reg, data->addr + IT87_ADDR_REG_OFFSET);
+        outb_p(value, data->addr + IT87_DATA_REG_OFFSET);
 }
 
 /* Return 1 if and only if the PWM interface is safe to use */
-static int it87_check_pwm(struct i2c_client *client)
+static int __devinit it87_check_pwm(struct device *dev)
 {
+        struct it87_data *data = dev_get_drvdata(dev);
         /* Some BIOSes fail to correctly configure the IT87 fans. All fans off
          * and polarity set to active low is sign that this is the case so we
          * disable pwm control to protect the user. */
-        int tmp = it87_read_value(client, IT87_REG_FAN_CTL);
+        int tmp = it87_read_value(data, IT87_REG_FAN_CTL);
         if ((tmp & 0x87) == 0) {
                 if (fix_pwm_polarity) {
                         /* The user asks us to attempt a chip reconfiguration.
@@ -1158,7 +1159,7 @@ static int it87_check_pwm(struct i2c_client *client)
                         u8 pwm[3];
 
                         for (i = 0; i < 3; i++)
-                                pwm[i] = it87_read_value(client,
+                                pwm[i] = it87_read_value(data,
                                                          IT87_REG_PWM(i));
 
                         /* If any fan is in automatic pwm mode, the polarity
@@ -1166,26 +1167,26 @@ static int it87_check_pwm(struct i2c_client *client)
                          * better don't change anything (but still disable the
                          * PWM interface). */
                         if (!((pwm[0] | pwm[1] | pwm[2]) & 0x80)) {
-                                dev_info(&client->dev, "Reconfiguring PWM to "
+                                dev_info(dev, "Reconfiguring PWM to "
                                          "active high polarity\n");
-                                it87_write_value(client, IT87_REG_FAN_CTL,
+                                it87_write_value(data, IT87_REG_FAN_CTL,
                                                  tmp | 0x87);
                                 for (i = 0; i < 3; i++)
-                                        it87_write_value(client,
+                                        it87_write_value(data,
                                                          IT87_REG_PWM(i),
                                                          0x7f & ~pwm[i]);
                                 return 1;
                         }
 
-                        dev_info(&client->dev, "PWM configuration is "
+                        dev_info(dev, "PWM configuration is "
                                  "too broken to be fixed\n");
                 }
 
-                dev_info(&client->dev, "Detected broken BIOS "
+                dev_info(dev, "Detected broken BIOS "
                          "defaults, disabling PWM interface\n");
                 return 0;
         } else if (fix_pwm_polarity) {
-                dev_info(&client->dev, "PWM configuration looks "
+                dev_info(dev, "PWM configuration looks "
                          "sane, won't touch\n");
         }
 
@@ -1193,8 +1194,9 @@ static int it87_check_pwm(struct i2c_client *client)
 }
 
 /* Called when we have found a new IT87. */
-static void it87_init_client(struct i2c_client *client, struct it87_data *data)
+static void __devinit it87_init_device(struct platform_device *pdev)
 {
+        struct it87_data *data = platform_get_drvdata(pdev);
         int tmp, i;
 
         /* initialize to sane defaults:
@@ -1214,48 +1216,48 @@ static void it87_init_client(struct i2c_client *client, struct it87_data *data)
          * means -1 degree C, which surprisingly doesn't trigger an alarm,
          * but is still confusing, so change to 127 degrees C. */
         for (i = 0; i < 8; i++) {
-                tmp = it87_read_value(client, IT87_REG_VIN_MIN(i));
+                tmp = it87_read_value(data, IT87_REG_VIN_MIN(i));
                 if (tmp == 0xff)
-                        it87_write_value(client, IT87_REG_VIN_MIN(i), 0);
+                        it87_write_value(data, IT87_REG_VIN_MIN(i), 0);
         }
         for (i = 0; i < 3; i++) {
-                tmp = it87_read_value(client, IT87_REG_TEMP_HIGH(i));
+                tmp = it87_read_value(data, IT87_REG_TEMP_HIGH(i));
                 if (tmp == 0xff)
-                        it87_write_value(client, IT87_REG_TEMP_HIGH(i), 127);
+                        it87_write_value(data, IT87_REG_TEMP_HIGH(i), 127);
         }
 
         /* Check if temperature channnels are reset manually or by some reason */
-        tmp = it87_read_value(client, IT87_REG_TEMP_ENABLE);
+        tmp = it87_read_value(data, IT87_REG_TEMP_ENABLE);
         if ((tmp & 0x3f) == 0) {
                 /* Temp1,Temp3=thermistor; Temp2=thermal diode */
                 tmp = (tmp & 0xc0) | 0x2a;
-                it87_write_value(client, IT87_REG_TEMP_ENABLE, tmp);
+                it87_write_value(data, IT87_REG_TEMP_ENABLE, tmp);
         }
         data->sensor = tmp;
 
         /* Check if voltage monitors are reset manually or by some reason */
-        tmp = it87_read_value(client, IT87_REG_VIN_ENABLE);
+        tmp = it87_read_value(data, IT87_REG_VIN_ENABLE);
         if ((tmp & 0xff) == 0) {
                 /* Enable all voltage monitors */
-                it87_write_value(client, IT87_REG_VIN_ENABLE, 0xff);
+                it87_write_value(data, IT87_REG_VIN_ENABLE, 0xff);
         }
 
         /* Check if tachometers are reset manually or by some reason */
-        data->fan_main_ctrl = it87_read_value(client, IT87_REG_FAN_MAIN_CTRL);
+        data->fan_main_ctrl = it87_read_value(data, IT87_REG_FAN_MAIN_CTRL);
         if ((data->fan_main_ctrl & 0x70) == 0) {
                 /* Enable all fan tachometers */
                 data->fan_main_ctrl |= 0x70;
-                it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
+                it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
         }
         data->has_fan = (data->fan_main_ctrl >> 4) & 0x07;
 
         /* Set tachometers to 16-bit mode if needed */
         if (data->type == it8716 || data->type == it8718) {
-                tmp = it87_read_value(client, IT87_REG_FAN_16BIT);
+                tmp = it87_read_value(data, IT87_REG_FAN_16BIT);
                 if (~tmp & 0x07 & data->has_fan) {
-                        dev_dbg(&client->dev,
+                        dev_dbg(&pdev->dev,
                                 "Setting fan1-3 to 16-bit mode\n");
-                        it87_write_value(client, IT87_REG_FAN_16BIT,
+                        it87_write_value(data, IT87_REG_FAN_16BIT,
                                          tmp | 0x07);
                 }
         }
@@ -1265,7 +1267,7 @@ static void it87_init_client(struct i2c_client *client, struct it87_data *data)
         for (i = 0; i < 3; i++) {
                 if (data->fan_main_ctrl & (1 << i)) {
                         /* pwm mode */
-                        tmp = it87_read_value(client, IT87_REG_PWM(i));
+                        tmp = it87_read_value(data, IT87_REG_PWM(i));
                         if (tmp & 0x80) {
                                 /* automatic pwm - not yet implemented, but
                                  * leave the settings made by the BIOS alone
@@ -1279,15 +1281,14 @@ static void it87_init_client(struct i2c_client *client, struct it87_data *data)
         }
 
         /* Start monitoring */
-        it87_write_value(client, IT87_REG_CONFIG,
-                         (it87_read_value(client, IT87_REG_CONFIG) & 0x36)
+        it87_write_value(data, IT87_REG_CONFIG,
+                         (it87_read_value(data, IT87_REG_CONFIG) & 0x36)
                          | (update_vbat ? 0x41 : 0x01));
 }
 
 static struct it87_data *it87_update_device(struct device *dev)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct it87_data *data = i2c_get_clientdata(client);
+        struct it87_data *data = dev_get_drvdata(dev);
         int i;
 
         mutex_lock(&data->update_lock);
@@ -1298,20 +1299,20 @@ static struct it87_data *it87_update_device(struct device *dev)
                 if (update_vbat) {
                         /* Cleared after each update, so reenable.  Value
                           returned by this read will be previous value */       
-                        it87_write_value(client, IT87_REG_CONFIG,
-                           it87_read_value(client, IT87_REG_CONFIG) | 0x40);
+                        it87_write_value(data, IT87_REG_CONFIG,
+                           it87_read_value(data, IT87_REG_CONFIG) | 0x40);
                 }
                 for (i = 0; i <= 7; i++) {
                         data->in[i] =
-                            it87_read_value(client, IT87_REG_VIN(i));
+                            it87_read_value(data, IT87_REG_VIN(i));
                         data->in_min[i] =
-                            it87_read_value(client, IT87_REG_VIN_MIN(i));
+                            it87_read_value(data, IT87_REG_VIN_MIN(i));
                         data->in_max[i] =
-                            it87_read_value(client, IT87_REG_VIN_MAX(i));
+                            it87_read_value(data, IT87_REG_VIN_MAX(i));
                 }
                 /* in8 (battery) has no limit registers */
                 data->in[8] =
-                    it87_read_value(client, IT87_REG_VIN(8));
+                    it87_read_value(data, IT87_REG_VIN(8));
 
                 for (i = 0; i < 3; i++) {
                         /* Skip disabled fans */
@@ -1319,46 +1320,47 @@ static struct it87_data *it87_update_device(struct device *dev)
                                 continue;
 
                         data->fan_min[i] =
-                            it87_read_value(client, IT87_REG_FAN_MIN(i));
-                        data->fan[i] = it87_read_value(client,
+                            it87_read_value(data, IT87_REG_FAN_MIN(i));
+                        data->fan[i] = it87_read_value(data,
                                        IT87_REG_FAN(i));
                         /* Add high byte if in 16-bit mode */
                         if (data->type == it8716 || data->type == it8718) {
-                                data->fan[i] |= it87_read_value(client,
+                                data->fan[i] |= it87_read_value(data,
                                                 IT87_REG_FANX(i)) << 8;
-                                data->fan_min[i] |= it87_read_value(client,
+                                data->fan_min[i] |= it87_read_value(data,
                                                 IT87_REG_FANX_MIN(i)) << 8;
                         }
                 }
                 for (i = 0; i < 3; i++) {
                         data->temp[i] =
-                            it87_read_value(client, IT87_REG_TEMP(i));
+                            it87_read_value(data, IT87_REG_TEMP(i));
                         data->temp_high[i] =
-                            it87_read_value(client, IT87_REG_TEMP_HIGH(i));
+                            it87_read_value(data, IT87_REG_TEMP_HIGH(i));
                         data->temp_low[i] =
-                            it87_read_value(client, IT87_REG_TEMP_LOW(i));
+                            it87_read_value(data, IT87_REG_TEMP_LOW(i));
                 }
 
                 /* Newer chips don't have clock dividers */
                 if ((data->has_fan & 0x07) && data->type != it8716
                  && data->type != it8718) {
-                        i = it87_read_value(client, IT87_REG_FAN_DIV);
+                        i = it87_read_value(data, IT87_REG_FAN_DIV);
                         data->fan_div[0] = i & 0x07;
                         data->fan_div[1] = (i >> 3) & 0x07;
                         data->fan_div[2] = (i & 0x40) ? 3 : 1;
                 }
 
                 data->alarms =
-                        it87_read_value(client, IT87_REG_ALARM1) |
-                        (it87_read_value(client, IT87_REG_ALARM2) << 8) |
-                        (it87_read_value(client, IT87_REG_ALARM3) << 16);
-                data->fan_main_ctrl = it87_read_value(client, IT87_REG_FAN_MAIN_CTRL);
-                data->fan_ctl = it87_read_value(client, IT87_REG_FAN_CTL);
-
-                data->sensor = it87_read_value(client, IT87_REG_TEMP_ENABLE);
+                        it87_read_value(data, IT87_REG_ALARM1) |
+                        (it87_read_value(data, IT87_REG_ALARM2) << 8) |
+                        (it87_read_value(data, IT87_REG_ALARM3) << 16);
+                data->fan_main_ctrl = it87_read_value(data,
+                                IT87_REG_FAN_MAIN_CTRL);
+                data->fan_ctl = it87_read_value(data, IT87_REG_FAN_CTL);
+
+                data->sensor = it87_read_value(data, IT87_REG_TEMP_ENABLE);
                 /* The 8705 does not have VID capability */
                 if (data->type == it8712 || data->type == it8716) {
-                        data->vid = it87_read_value(client, IT87_REG_VID);
+                        data->vid = it87_read_value(data, IT87_REG_VID);
                         /* The older IT8712F revisions had only 5 VID pins,
                            but we assume it is always safe to read 6 bits. */
                         data->vid &= 0x3f;
@@ -1372,24 +1374,85 @@ static struct it87_data *it87_update_device(struct device *dev)
         return data;
 }
 
+static int __init it87_device_add(unsigned short address,
+                                  const struct it87_sio_data *sio_data)
+{
+        struct resource res = {
+                .start  = address ,
+                .end    = address + IT87_EXTENT - 1,
+                .name   = DRVNAME,
+                .flags  = IORESOURCE_IO,
+        };
+        int err;
+
+        pdev = platform_device_alloc(DRVNAME, address);
+        if (!pdev) {
+                err = -ENOMEM;
+                printk(KERN_ERR DRVNAME ": Device allocation failed\n");
+                goto exit;
+        }
+
+        err = platform_device_add_resources(pdev, &res, 1);
+        if (err) {
+                printk(KERN_ERR DRVNAME ": Device resource addition failed "
+                       "(%d)\n", err);
+                goto exit_device_put;
+        }
+
+        err = platform_device_add_data(pdev, sio_data,
+                                       sizeof(struct it87_sio_data));
+        if (err) {
+                printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
+                goto exit_device_put;
+        }
+
+        err = platform_device_add(pdev);
+        if (err) {
+                printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
+                       err);
+                goto exit_device_put;
+        }
+
+        return 0;
+
+exit_device_put:
+        platform_device_put(pdev);
+exit:
+        return err;
+}
+
 static int __init sm_it87_init(void)
 {
-        int res;
+        int err;
+        unsigned short isa_address=0;
+        struct it87_sio_data sio_data;
+
+        err = it87_find(&isa_address, &sio_data);
+        if (err)
+                return err;
+        err = platform_driver_register(&it87_driver);
+        if (err)
+                return err;
 
-        if ((res = it87_find(&isa_address)))
-                return res;
-        return i2c_isa_add_driver(&it87_isa_driver);
+        err = it87_device_add(isa_address, &sio_data);
+        if (err){
+                platform_driver_unregister(&it87_driver);
+                return err;
+        }
+
+        return 0;
 }
 
 static void __exit sm_it87_exit(void)
 {
-        i2c_isa_del_driver(&it87_isa_driver);
+        platform_device_unregister(pdev);
+        platform_driver_unregister(&it87_driver);
 }
 
 
 MODULE_AUTHOR("Chris Gauthron <chrisg@0-in.com>, "
               "Jean Delvare <khali@linux-fr.org>");
-MODULE_DESCRIPTION("IT8705F/8712F/8716F/8718F, SiS950 driver");
+MODULE_DESCRIPTION("IT8705F/8712F/8716F/8718F/8726F, SiS950 driver");
 module_param(update_vbat, bool, 0);
 MODULE_PARM_DESC(update_vbat, "Update vbat if set else return powerup value");
 module_param(fix_pwm_polarity, bool, 0);
diff --git a/drivers/hwmon/lm63.c b/drivers/hwmon/lm63.c
index d69f3cf07122..2162d69a8c06 100644
--- a/drivers/hwmon/lm63.c
+++ b/drivers/hwmon/lm63.c
@@ -364,7 +364,7 @@ static DEVICE_ATTR(temp2_crit_hyst, S_IWUSR | S_IRUGO, show_temp2_crit_hyst,
 /* Individual alarm files */
 static SENSOR_DEVICE_ATTR(fan1_min_alarm, S_IRUGO, show_alarm, NULL, 0);
 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 1);
-static SENSOR_DEVICE_ATTR(temp2_input_fault, S_IRUGO, show_alarm, NULL, 2);
+static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2);
 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4);
 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
@@ -383,7 +383,7 @@ static struct attribute *lm63_attributes[] = {
         &dev_attr_temp2_crit_hyst.attr,
 
         &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
-        &sensor_dev_attr_temp2_input_fault.dev_attr.attr,
+        &sensor_dev_attr_temp2_fault.dev_attr.attr,
         &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
         &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
         &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
diff --git a/drivers/hwmon/lm83.c b/drivers/hwmon/lm83.c
index feb87b41e986..654c0f73464d 100644
--- a/drivers/hwmon/lm83.c
+++ b/drivers/hwmon/lm83.c
@@ -223,14 +223,14 @@ static SENSOR_DEVICE_ATTR(temp4_crit, S_IRUGO, show_temp, NULL, 8);
 /* Individual alarm files */
 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 0);
 static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 1);
-static SENSOR_DEVICE_ATTR(temp3_input_fault, S_IRUGO, show_alarm, NULL, 2);
+static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 2);
 static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 4);
 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 8);
 static SENSOR_DEVICE_ATTR(temp4_crit_alarm, S_IRUGO, show_alarm, NULL, 9);
-static SENSOR_DEVICE_ATTR(temp4_input_fault, S_IRUGO, show_alarm, NULL, 10);
+static SENSOR_DEVICE_ATTR(temp4_fault, S_IRUGO, show_alarm, NULL, 10);
 static SENSOR_DEVICE_ATTR(temp4_max_alarm, S_IRUGO, show_alarm, NULL, 12);
-static SENSOR_DEVICE_ATTR(temp2_input_fault, S_IRUGO, show_alarm, NULL, 13);
+static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 13);
 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 15);
 /* Raw alarm file for compatibility */
 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
@@ -245,7 +245,7 @@ static struct attribute *lm83_attributes[] = {
 
         &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
         &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
-        &sensor_dev_attr_temp3_input_fault.dev_attr.attr,
+        &sensor_dev_attr_temp3_fault.dev_attr.attr,
         &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
         &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
         &dev_attr_alarms.attr,
@@ -266,9 +266,9 @@ static struct attribute *lm83_attributes_opt[] = {
 
         &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
         &sensor_dev_attr_temp4_crit_alarm.dev_attr.attr,
-        &sensor_dev_attr_temp4_input_fault.dev_attr.attr,
+        &sensor_dev_attr_temp4_fault.dev_attr.attr,
         &sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
-        &sensor_dev_attr_temp2_input_fault.dev_attr.attr,
+        &sensor_dev_attr_temp2_fault.dev_attr.attr,
         &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
         NULL
 };
diff --git a/drivers/hwmon/lm90.c b/drivers/hwmon/lm90.c
index 6882ce75feee..48833fff4920 100644
--- a/drivers/hwmon/lm90.c
+++ b/drivers/hwmon/lm90.c
@@ -43,6 +43,13 @@
  * variants. The extra address and features of the MAX6659 are not
  * supported by this driver.
  *
+ * This driver also supports the MAX6680 and MAX6681, two other sensor
+ * chips made by Maxim. These are quite similar to the other Maxim
+ * chips. Complete datasheet can be obtained at:
+ *   http://www.maxim-ic.com/quick_view2.cfm/qv_pk/3370
+ * The MAX6680 and MAX6681 only differ in the pinout so they can be
+ * treated identically.
+ *
  * This driver also supports the ADT7461 chip from Analog Devices but
  * only in its "compatability mode". If an ADT7461 chip is found but
  * is configured in non-compatible mode (where its temperature
@@ -84,20 +91,25 @@
 /*
  * Addresses to scan
  * Address is fully defined internally and cannot be changed except for
- * MAX6659.
+ * MAX6659, MAX6680 and MAX6681.
  * LM86, LM89, LM90, LM99, ADM1032, ADM1032-1, ADT7461, MAX6657 and MAX6658
  * have address 0x4c.
  * ADM1032-2, ADT7461-2, LM89-1, and LM99-1 have address 0x4d.
  * MAX6659 can have address 0x4c, 0x4d or 0x4e (unsupported).
+ * MAX6680 and MAX6681 can have address 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b,
+ * 0x4c, 0x4d or 0x4e.
  */
 
-static unsigned short normal_i2c[] = { 0x4c, 0x4d, I2C_CLIENT_END };
+static unsigned short normal_i2c[] = { 0x18, 0x19, 0x1a,
+                                       0x29, 0x2a, 0x2b,
+                                       0x4c, 0x4d, 0x4e,
+                                       I2C_CLIENT_END };
 
 /*
  * Insmod parameters
  */
 
-I2C_CLIENT_INSMOD_6(lm90, adm1032, lm99, lm86, max6657, adt7461);
+I2C_CLIENT_INSMOD_7(lm90, adm1032, lm99, lm86, max6657, adt7461, max6680);
 
 /*
  * The LM90 registers
@@ -359,7 +371,7 @@ static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 4);
 /* Individual alarm files */
 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 0);
 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 1);
-static SENSOR_DEVICE_ATTR(temp2_input_fault, S_IRUGO, show_alarm, NULL, 2);
+static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2);
 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4);
 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 5);
@@ -381,7 +393,7 @@ static struct attribute *lm90_attributes[] = {
 
         &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
         &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
-        &sensor_dev_attr_temp2_input_fault.dev_attr.attr,
+        &sensor_dev_attr_temp2_fault.dev_attr.attr,
         &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
         &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
         &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
@@ -429,7 +441,7 @@ static DEVICE_ATTR(pec, S_IWUSR | S_IRUGO, show_pec, set_pec);
  */
 
 /* The ADM1032 supports PEC but not on write byte transactions, so we need
-   to explicitely ask for a transaction without PEC. */
+   to explicitly ask for a transaction without PEC. */
 static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value)
 {
         return i2c_smbus_xfer(client->adapter, client->addr,
@@ -525,7 +537,8 @@ static int lm90_detect(struct i2c_adapter *adapter, int address, int kind)
                                   &reg_convrate) < 0)
                         goto exit_free;
                 
-                if (man_id == 0x01) { /* National Semiconductor */
+                if ((address == 0x4C || address == 0x4D)
+                 && man_id == 0x01) { /* National Semiconductor */
                         u8 reg_config2;
 
                         if (lm90_read_reg(new_client, LM90_REG_R_CONFIG2,
@@ -548,7 +561,8 @@ static int lm90_detect(struct i2c_adapter *adapter, int address, int kind)
                                 }
                         }
                 } else
-                if (man_id == 0x41) { /* Analog Devices */
+                if ((address == 0x4C || address == 0x4D)
+                 && man_id == 0x41) { /* Analog Devices */
                         if ((chip_id & 0xF0) == 0x40 /* ADM1032 */
                          && (reg_config1 & 0x3F) == 0x00
                          && reg_convrate <= 0x0A) {
@@ -562,18 +576,30 @@ static int lm90_detect(struct i2c_adapter *adapter, int address, int kind)
                 } else
                 if (man_id == 0x4D) { /* Maxim */
                         /*
-                         * The Maxim variants do NOT have a chip_id register.
-                         * Reading from that address will return the last read
-                         * value, which in our case is those of the man_id
-                         * register. Likewise, the config1 register seems to
-                         * lack a low nibble, so the value will be those of the
-                         * previous read, so in our case those of the man_id
-                         * register.
+                         * The MAX6657, MAX6658 and MAX6659 do NOT have a
+                         * chip_id register. Reading from that address will
+                         * return the last read value, which in our case is
+                         * those of the man_id register. Likewise, the config1
+                         * register seems to lack a low nibble, so the value
+                         * will be those of the previous read, so in our case
+                         * those of the man_id register.
                          */
                         if (chip_id == man_id
+                         && (address == 0x4F || address == 0x4D)
                          && (reg_config1 & 0x1F) == (man_id & 0x0F)
                          && reg_convrate <= 0x09) {
                                 kind = max6657;
+                        } else
+                        /* The chip_id register of the MAX6680 and MAX6681
+                         * holds the revision of the chip.
+                         * the lowest bit of the config1 register is unused
+                         * and should return zero when read, so should the
+                         * second to last bit of config1 (software reset)
+                         */
+                        if (chip_id == 0x01
+                         && (reg_config1 & 0x03) == 0x00
+                         && reg_convrate <= 0x07) {
+                                kind = max6680;
                         }
                 }
 
@@ -599,6 +625,8 @@ static int lm90_detect(struct i2c_adapter *adapter, int address, int kind)
                 name = "lm86";
         } else if (kind == max6657) {
                 name = "max6657";
+        } else if (kind == max6680) {
+                name = "max6680";
         } else if (kind == adt7461) {
                 name = "adt7461";
         }
@@ -646,7 +674,8 @@ exit:
 
 static void lm90_init_client(struct i2c_client *client)
 {
-        u8 config;
+        u8 config, config_orig;
+        struct lm90_data *data = i2c_get_clientdata(client);
 
         /*
          * Start the conversions.
@@ -657,9 +686,20 @@ static void lm90_init_client(struct i2c_client *client)
                 dev_warn(&client->dev, "Initialization failed!\n");
                 return;
         }
-        if (config & 0x40)
-                i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,
-                                          config & 0xBF); /* run */
+        config_orig = config;
+
+        /*
+         * Put MAX6680/MAX8881 into extended resolution (bit 0x10,
+         * 0.125 degree resolution) and range (0x08, extend range
+         * to -64 degree) mode for the remote temperature sensor.
+         */
+        if (data->kind == max6680) {
+                config |= 0x18;
+        }
+
+        config &= 0xBF; /* run */
+        if (config != config_orig) /* Only write if changed */
+                i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1, config);
 }
 
 static int lm90_detach_client(struct i2c_client *client)
diff --git a/drivers/hwmon/lm93.c b/drivers/hwmon/lm93.c
new file mode 100644
index 000000000000..23edf4fe4221
--- /dev/null
+++ b/drivers/hwmon/lm93.c
@@ -0,0 +1,2655 @@
+/*
+    lm93.c - Part of lm_sensors, Linux kernel modules for hardware monitoring
+
+    Author/Maintainer: Mark M. Hoffman <mhoffman@lightlink.com>
+        Copyright (c) 2004 Utilitek Systems, Inc.
+
+    derived in part from lm78.c:
+        Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
+
+    derived in part from lm85.c:
+        Copyright (c) 2002, 2003 Philip Pokorny <ppokorny@penguincomputing.com>
+        Copyright (c) 2003       Margit Schubert-While <margitsw@t-online.de>
+
+    derived in part from w83l785ts.c:
+        Copyright (c) 2003-2004 Jean Delvare <khali@linux-fr.org>
+
+    Ported to Linux 2.6 by Eric J. Bowersox <ericb@aspsys.com>
+        Copyright (c) 2005 Aspen Systems, Inc.
+
+    Adapted to 2.6.20 by Carsten Emde <cbe@osadl.org>
+        Copyright (c) 2006 Carsten Emde, Open Source Automation Development Lab
+
+    Modified for mainline integration by Hans J. Koch <hjk@linutronix.de>
+        Copyright (c) 2007 Hans J. Koch, Linutronix GmbH
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/hwmon-vid.h>
+#include <linux/err.h>
+#include <linux/delay.h>
+
+/* LM93 REGISTER ADDRESSES */
+
+/* miscellaneous */
+#define LM93_REG_MFR_ID                 0x3e
+#define LM93_REG_VER                    0x3f
+#define LM93_REG_STATUS_CONTROL         0xe2
+#define LM93_REG_CONFIG                 0xe3
+#define LM93_REG_SLEEP_CONTROL          0xe4
+
+/* alarm values start here */
+#define LM93_REG_HOST_ERROR_1           0x48
+
+/* voltage inputs: in1-in16 (nr => 0-15) */
+#define LM93_REG_IN(nr)                 (0x56 + (nr))
+#define LM93_REG_IN_MIN(nr)             (0x90 + (nr) * 2)
+#define LM93_REG_IN_MAX(nr)             (0x91 + (nr) * 2)
+
+/* temperature inputs: temp1-temp4 (nr => 0-3) */
+#define LM93_REG_TEMP(nr)               (0x50 + (nr))
+#define LM93_REG_TEMP_MIN(nr)           (0x78 + (nr) * 2)
+#define LM93_REG_TEMP_MAX(nr)           (0x79 + (nr) * 2)
+
+/* temp[1-4]_auto_boost (nr => 0-3) */
+#define LM93_REG_BOOST(nr)              (0x80 + (nr))
+
+/* #PROCHOT inputs: prochot1-prochot2 (nr => 0-1) */
+#define LM93_REG_PROCHOT_CUR(nr)        (0x67 + (nr) * 2)
+#define LM93_REG_PROCHOT_AVG(nr)        (0x68 + (nr) * 2)
+#define LM93_REG_PROCHOT_MAX(nr)        (0xb0 + (nr))
+
+/* fan tach inputs: fan1-fan4 (nr => 0-3) */
+#define LM93_REG_FAN(nr)                (0x6e + (nr) * 2)
+#define LM93_REG_FAN_MIN(nr)            (0xb4 + (nr) * 2)
+
+/* pwm outputs: pwm1-pwm2 (nr => 0-1, reg => 0-3) */
+#define LM93_REG_PWM_CTL(nr,reg)        (0xc8 + (reg) + (nr) * 4)
+#define LM93_PWM_CTL1   0x0
+#define LM93_PWM_CTL2   0x1
+#define LM93_PWM_CTL3   0x2
+#define LM93_PWM_CTL4   0x3
+
+/* GPIO input state */
+#define LM93_REG_GPI                    0x6b
+
+/* vid inputs: vid1-vid2 (nr => 0-1) */
+#define LM93_REG_VID(nr)                (0x6c + (nr))
+
+/* vccp1 & vccp2: VID relative inputs (nr => 0-1) */
+#define LM93_REG_VCCP_LIMIT_OFF(nr)     (0xb2 + (nr))
+
+/* temp[1-4]_auto_boost_hyst */
+#define LM93_REG_BOOST_HYST_12          0xc0
+#define LM93_REG_BOOST_HYST_34          0xc1
+#define LM93_REG_BOOST_HYST(nr)         (0xc0 + (nr)/2)
+
+/* temp[1-4]_auto_pwm_[min|hyst] */
+#define LM93_REG_PWM_MIN_HYST_12        0xc3
+#define LM93_REG_PWM_MIN_HYST_34        0xc4
+#define LM93_REG_PWM_MIN_HYST(nr)       (0xc3 + (nr)/2)
+
+/* prochot_override & prochot_interval */
+#define LM93_REG_PROCHOT_OVERRIDE       0xc6
+#define LM93_REG_PROCHOT_INTERVAL       0xc7
+
+/* temp[1-4]_auto_base (nr => 0-3) */
+#define LM93_REG_TEMP_BASE(nr)          (0xd0 + (nr))
+
+/* temp[1-4]_auto_offsets (step => 0-11) */
+#define LM93_REG_TEMP_OFFSET(step)      (0xd4 + (step))
+
+/* #PROCHOT & #VRDHOT PWM ramp control */
+#define LM93_REG_PWM_RAMP_CTL           0xbf
+
+/* miscellaneous */
+#define LM93_REG_SFC1           0xbc
+#define LM93_REG_SFC2           0xbd
+#define LM93_REG_GPI_VID_CTL    0xbe
+#define LM93_REG_SF_TACH_TO_PWM 0xe0
+
+/* error masks */
+#define LM93_REG_GPI_ERR_MASK   0xec
+#define LM93_REG_MISC_ERR_MASK  0xed
+
+/* LM93 REGISTER VALUES */
+#define LM93_MFR_ID             0x73
+#define LM93_MFR_ID_PROTOTYPE   0x72
+
+/* SMBus capabilities */
+#define LM93_SMBUS_FUNC_FULL (I2C_FUNC_SMBUS_BYTE_DATA | \
+                I2C_FUNC_SMBUS_WORD_DATA | I2C_FUNC_SMBUS_BLOCK_DATA)
+#define LM93_SMBUS_FUNC_MIN  (I2C_FUNC_SMBUS_BYTE_DATA | \
+                I2C_FUNC_SMBUS_WORD_DATA)
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
+
+/* Insmod parameters */
+I2C_CLIENT_INSMOD_1(lm93);
+
+static int disable_block;
+module_param(disable_block, bool, 0);
+MODULE_PARM_DESC(disable_block,
+        "Set to non-zero to disable SMBus block data transactions.");
+
+static int init;
+module_param(init, bool, 0);
+MODULE_PARM_DESC(init, "Set to non-zero to force chip initialization.");
+
+static int vccp_limit_type[2] = {0,0};
+module_param_array(vccp_limit_type, int, NULL, 0);
+MODULE_PARM_DESC(vccp_limit_type, "Configures in7 and in8 limit modes.");
+
+static int vid_agtl;
+module_param(vid_agtl, int, 0);
+MODULE_PARM_DESC(vid_agtl, "Configures VID pin input thresholds.");
+
+/* Driver data */
+static struct i2c_driver lm93_driver;
+
+/* LM93 BLOCK READ COMMANDS */
+static const struct { u8 cmd; u8 len; } lm93_block_read_cmds[12] = {
+        { 0xf2,  8 },
+        { 0xf3,  8 },
+        { 0xf4,  6 },
+        { 0xf5, 16 },
+        { 0xf6,  4 },
+        { 0xf7,  8 },
+        { 0xf8, 12 },
+        { 0xf9, 32 },
+        { 0xfa,  8 },
+        { 0xfb,  8 },
+        { 0xfc, 16 },
+        { 0xfd,  9 },
+};
+
+/* ALARMS: SYSCTL format described further below
+   REG: 64 bits in 8 registers, as immediately below */
+struct block1_t {
+        u8 host_status_1;
+        u8 host_status_2;
+        u8 host_status_3;
+        u8 host_status_4;
+        u8 p1_prochot_status;
+        u8 p2_prochot_status;
+        u8 gpi_status;
+        u8 fan_status;
+};
+
+/*
+ * Client-specific data
+ */
+struct lm93_data {
+        struct i2c_client client;
+        struct class_device *class_dev;
+
+        struct mutex update_lock;
+        unsigned long last_updated;     /* In jiffies */
+
+        /* client update function */
+        void (*update)(struct lm93_data *, struct i2c_client *);
+
+        char valid; /* !=0 if following fields are valid */
+
+        /* register values, arranged by block read groups */
+        struct block1_t block1;
+
+        /* temp1 - temp4: unfiltered readings
+           temp1 - temp2: filtered readings */
+        u8 block2[6];
+
+        /* vin1 - vin16: readings */
+        u8 block3[16];
+
+        /* prochot1 - prochot2: readings */
+        struct {
+                u8 cur;
+                u8 avg;
+        } block4[2];
+
+        /* fan counts 1-4 => 14-bits, LE, *left* justified */
+        u16 block5[4];
+
+        /* block6 has a lot of data we don't need */
+        struct {
+                u8 min;
+                u8 max;
+        } temp_lim[3];
+
+        /* vin1 - vin16: low and high limits */
+        struct {
+                u8 min;
+                u8 max;
+        } block7[16];
+
+        /* fan count limits 1-4 => same format as block5 */
+        u16 block8[4];
+
+        /* pwm control registers (2 pwms, 4 regs) */
+        u8 block9[2][4];
+
+        /* auto/pwm base temp and offset temp registers */
+        struct {
+                u8 base[4];
+                u8 offset[12];
+        } block10;
+
+        /* master config register */
+        u8 config;
+
+        /* VID1 & VID2 => register format, 6-bits, right justified */
+        u8 vid[2];
+
+        /* prochot1 - prochot2: limits */
+        u8 prochot_max[2];
+
+        /* vccp1 & vccp2 (in7 & in8): VID relative limits (register format) */
+        u8 vccp_limits[2];
+
+        /* GPIO input state (register format, i.e. inverted) */
+        u8 gpi;
+
+        /* #PROCHOT override (register format) */
+        u8 prochot_override;
+
+        /* #PROCHOT intervals (register format) */
+        u8 prochot_interval;
+
+        /* Fan Boost Temperatures (register format) */
+        u8 boost[4];
+
+        /* Fan Boost Hysteresis (register format) */
+        u8 boost_hyst[2];
+
+        /* Temperature Zone Min. PWM & Hysteresis (register format) */
+        u8 auto_pwm_min_hyst[2];
+
+        /* #PROCHOT & #VRDHOT PWM Ramp Control */
+        u8 pwm_ramp_ctl;
+
+        /* miscellaneous setup regs */
+        u8 sfc1;
+        u8 sfc2;
+        u8 sf_tach_to_pwm;
+
+        /* The two PWM CTL2  registers can read something other than what was
+           last written for the OVR_DC field (duty cycle override).  So, we
+           save the user-commanded value here. */
+        u8 pwm_override[2];
+};
+
+/* VID: mV
+   REG: 6-bits, right justified, *always* using Intel VRM/VRD 10 */
+static int LM93_VID_FROM_REG(u8 reg)
+{
+        return vid_from_reg((reg & 0x3f), 100);
+}
+
+/* min, max, and nominal register values, per channel (u8) */
+static const u8 lm93_vin_reg_min[16] = {
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xae,
+};
+static const u8 lm93_vin_reg_max[16] = {
+        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+        0xff, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1,
+};
+/* Values from the datasheet. They're here for documentation only.
+static const u8 lm93_vin_reg_nom[16] = {
+        0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0,
+        0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x40, 0xc0,
+};
+*/
+
+/* min, max, and nominal voltage readings, per channel (mV)*/
+static const unsigned long lm93_vin_val_min[16] = {
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 3000,
+};
+
+static const unsigned long lm93_vin_val_max[16] = {
+        1236, 1236, 1236, 1600, 2000, 2000, 1600, 1600,
+        4400, 6500, 3333, 2625, 1312, 1312, 1236, 3600,
+};
+/* Values from the datasheet. They're here for documentation only.
+static const unsigned long lm93_vin_val_nom[16] = {
+         927,  927,  927, 1200, 1500, 1500, 1200, 1200,
+        3300, 5000, 2500, 1969,  984,  984,  309, 3300,
+};
+*/
+
+static unsigned LM93_IN_FROM_REG(int nr, u8 reg)
+{
+        const long uV_max = lm93_vin_val_max[nr] * 1000;
+        const long uV_min = lm93_vin_val_min[nr] * 1000;
+
+        const long slope = (uV_max - uV_min) /
+                (lm93_vin_reg_max[nr] - lm93_vin_reg_min[nr]);
+        const long intercept = uV_min - slope * lm93_vin_reg_min[nr];
+
+        return (slope * reg + intercept + 500) / 1000;
+}
+
+/* IN: mV, limits determined by channel nr
+   REG: scaling determined by channel nr */
+static u8 LM93_IN_TO_REG(int nr, unsigned val)
+{
+        /* range limit */
+        const long mV = SENSORS_LIMIT(val,
+                lm93_vin_val_min[nr], lm93_vin_val_max[nr]);
+
+        /* try not to lose too much precision here */
+        const long uV = mV * 1000;
+        const long uV_max = lm93_vin_val_max[nr] * 1000;
+        const long uV_min = lm93_vin_val_min[nr] * 1000;
+
+        /* convert */
+        const long slope = (uV_max - uV_min) /
+                (lm93_vin_reg_max[nr] - lm93_vin_reg_min[nr]);
+        const long intercept = uV_min - slope * lm93_vin_reg_min[nr];
+
+        u8 result = ((uV - intercept + (slope/2)) / slope);
+        result = SENSORS_LIMIT(result,
+                        lm93_vin_reg_min[nr], lm93_vin_reg_max[nr]);
+        return result;
+}
+
+/* vid in mV, upper == 0 indicates low limit, otherwise upper limit */
+static unsigned LM93_IN_REL_FROM_REG(u8 reg, int upper, int vid)
+{
+        const long uV_offset = upper ? (((reg >> 4 & 0x0f) + 1) * 12500) :
+                                (((reg >> 0 & 0x0f) + 1) * -25000);
+        const long uV_vid = vid * 1000;
+        return (uV_vid + uV_offset + 5000) / 10000;
+}
+
+#define LM93_IN_MIN_FROM_REG(reg,vid)   LM93_IN_REL_FROM_REG(reg,0,vid)
+#define LM93_IN_MAX_FROM_REG(reg,vid)   LM93_IN_REL_FROM_REG(reg,1,vid)
+
+/* vid in mV , upper == 0 indicates low limit, otherwise upper limit
+   upper also determines which nibble of the register is returned
+   (the other nibble will be 0x0) */
+static u8 LM93_IN_REL_TO_REG(unsigned val, int upper, int vid)
+{
+        long uV_offset = vid * 1000 - val * 10000;
+        if (upper) {
+                uV_offset = SENSORS_LIMIT(uV_offset, 12500, 200000);
+                return (u8)((uV_offset /  12500 - 1) << 4);
+        } else {
+                uV_offset = SENSORS_LIMIT(uV_offset, -400000, -25000);
+                return (u8)((uV_offset / -25000 - 1) << 0);
+        }
+}
+
+/* TEMP: 1/1000 degrees C (-128C to +127C)
+   REG: 1C/bit, two's complement */
+static int LM93_TEMP_FROM_REG(u8 reg)
+{
+        return (s8)reg * 1000;
+}
+
+#define LM93_TEMP_MIN (-128000)
+#define LM93_TEMP_MAX ( 127000)
+
+/* TEMP: 1/1000 degrees C (-128C to +127C)
+   REG: 1C/bit, two's complement */
+static u8 LM93_TEMP_TO_REG(int temp)
+{
+        int ntemp = SENSORS_LIMIT(temp, LM93_TEMP_MIN, LM93_TEMP_MAX);
+        ntemp += (ntemp<0 ? -500 : 500);
+        return (u8)(ntemp / 1000);
+}
+
+/* Determine 4-bit temperature offset resolution */
+static int LM93_TEMP_OFFSET_MODE_FROM_REG(u8 sfc2, int nr)
+{
+        /* mode: 0 => 1C/bit, nonzero => 0.5C/bit */
+        return sfc2 & (nr < 2 ? 0x10 : 0x20);
+}
+
+/* This function is common to all 4-bit temperature offsets
+   reg is 4 bits right justified
+   mode 0 => 1C/bit, mode !0 => 0.5C/bit */
+static int LM93_TEMP_OFFSET_FROM_REG(u8 reg, int mode)
+{
+        return (reg & 0x0f) * (mode ? 5 : 10);
+}
+
+#define LM93_TEMP_OFFSET_MIN  (  0)
+#define LM93_TEMP_OFFSET_MAX0 (150)
+#define LM93_TEMP_OFFSET_MAX1 ( 75)
+
+/* This function is common to all 4-bit temperature offsets
+   returns 4 bits right justified
+   mode 0 => 1C/bit, mode !0 => 0.5C/bit */
+static u8 LM93_TEMP_OFFSET_TO_REG(int off, int mode)
+{
+        int factor = mode ? 5 : 10;
+
+        off = SENSORS_LIMIT(off, LM93_TEMP_OFFSET_MIN,
+                mode ? LM93_TEMP_OFFSET_MAX1 : LM93_TEMP_OFFSET_MAX0);
+        return (u8)((off + factor/2) / factor);
+}
+
+/* 0 <= nr <= 3 */
+static int LM93_TEMP_AUTO_OFFSET_FROM_REG(u8 reg, int nr, int mode)
+{
+        /* temp1-temp2 (nr=0,1) use lower nibble */
+        if (nr < 2)
+                return LM93_TEMP_OFFSET_FROM_REG(reg & 0x0f, mode);
+
+        /* temp3-temp4 (nr=2,3) use upper nibble */
+        else
+                return LM93_TEMP_OFFSET_FROM_REG(reg >> 4 & 0x0f, mode);
+}
+
+/* TEMP: 1/10 degrees C (0C to +15C (mode 0) or +7.5C (mode non-zero))
+   REG: 1.0C/bit (mode 0) or 0.5C/bit (mode non-zero)
+   0 <= nr <= 3 */
+static u8 LM93_TEMP_AUTO_OFFSET_TO_REG(u8 old, int off, int nr, int mode)
+{
+        u8 new = LM93_TEMP_OFFSET_TO_REG(off, mode);
+
+        /* temp1-temp2 (nr=0,1) use lower nibble */
+        if (nr < 2)
+                return (old & 0xf0) | (new & 0x0f);
+
+        /* temp3-temp4 (nr=2,3) use upper nibble */
+        else
+                return (new << 4 & 0xf0) | (old & 0x0f);
+}
+
+static int LM93_AUTO_BOOST_HYST_FROM_REGS(struct lm93_data *data, int nr,
+                int mode)
+{
+        u8 reg;
+
+        switch (nr) {
+        case 0:
+                reg = data->boost_hyst[0] & 0x0f;
+                break;
+        case 1:
+                reg = data->boost_hyst[0] >> 4 & 0x0f;
+                break;
+        case 2:
+                reg = data->boost_hyst[1] & 0x0f;
+                break;
+        case 3:
+        default:
+                reg = data->boost_hyst[1] >> 4 & 0x0f;
+                break;
+        }
+
+        return LM93_TEMP_FROM_REG(data->boost[nr]) -
+                        LM93_TEMP_OFFSET_FROM_REG(reg, mode);
+}
+
+static u8 LM93_AUTO_BOOST_HYST_TO_REG(struct lm93_data *data, long hyst,
+                int nr, int mode)
+{
+        u8 reg = LM93_TEMP_OFFSET_TO_REG(
+                        (LM93_TEMP_FROM_REG(data->boost[nr]) - hyst), mode);
+
+        switch (nr) {
+        case 0:
+                reg = (data->boost_hyst[0] & 0xf0) | (reg & 0x0f);
+                break;
+        case 1:
+                reg = (reg << 4 & 0xf0) | (data->boost_hyst[0] & 0x0f);
+                break;
+        case 2:
+                reg = (data->boost_hyst[1] & 0xf0) | (reg & 0x0f);
+                break;
+        case 3:
+        default:
+                reg = (reg << 4 & 0xf0) | (data->boost_hyst[1] & 0x0f);
+                break;
+        }
+
+        return reg;
+}
+
+/* PWM: 0-255 per sensors documentation
+   REG: 0-13 as mapped below... right justified */
+typedef enum { LM93_PWM_MAP_HI_FREQ, LM93_PWM_MAP_LO_FREQ } pwm_freq_t;
+static int lm93_pwm_map[2][16] = {
+        {
+                0x00, /*   0.00% */ 0x40, /*  25.00% */
+                0x50, /*  31.25% */ 0x60, /*  37.50% */
+                0x70, /*  43.75% */ 0x80, /*  50.00% */
+                0x90, /*  56.25% */ 0xa0, /*  62.50% */
+                0xb0, /*  68.75% */ 0xc0, /*  75.00% */
+                0xd0, /*  81.25% */ 0xe0, /*  87.50% */
+                0xf0, /*  93.75% */ 0xff, /* 100.00% */
+                0xff, 0xff, /* 14, 15 are reserved and should never occur */
+        },
+        {
+                0x00, /*   0.00% */ 0x40, /*  25.00% */
+                0x49, /*  28.57% */ 0x52, /*  32.14% */
+                0x5b, /*  35.71% */ 0x64, /*  39.29% */
+                0x6d, /*  42.86% */ 0x76, /*  46.43% */
+                0x80, /*  50.00% */ 0x89, /*  53.57% */
+                0x92, /*  57.14% */ 0xb6, /*  71.43% */
+                0xdb, /*  85.71% */ 0xff, /* 100.00% */
+                0xff, 0xff, /* 14, 15 are reserved and should never occur */
+        },
+};
+
+static int LM93_PWM_FROM_REG(u8 reg, pwm_freq_t freq)
+{
+        return lm93_pwm_map[freq][reg & 0x0f];
+}
+
+/* round up to nearest match */
+static u8 LM93_PWM_TO_REG(int pwm, pwm_freq_t freq)
+{
+        int i;
+        for (i = 0; i < 13; i++)
+                if (pwm <= lm93_pwm_map[freq][i])
+                        break;
+
+        /* can fall through with i==13 */
+        return (u8)i;
+}
+
+static int LM93_FAN_FROM_REG(u16 regs)
+{
+        const u16 count = le16_to_cpu(regs) >> 2;
+        return count==0 ? -1 : count==0x3fff ? 0: 1350000 / count;
+}
+
+/*
+ * RPM: (82.5 to 1350000)
+ * REG: 14-bits, LE, *left* justified
+ */
+static u16 LM93_FAN_TO_REG(long rpm)
+{
+        u16 count, regs;
+
+        if (rpm == 0) {
+                count = 0x3fff;
+        } else {
+                rpm = SENSORS_LIMIT(rpm, 1, 1000000);
+                count = SENSORS_LIMIT((1350000 + rpm) / rpm, 1, 0x3ffe);
+        }
+
+        regs = count << 2;
+        return cpu_to_le16(regs);
+}
+
+/* PWM FREQ: HZ
+   REG: 0-7 as mapped below */
+static int lm93_pwm_freq_map[8] = {
+        22500, 96, 84, 72, 60, 48, 36, 12
+};
+
+static int LM93_PWM_FREQ_FROM_REG(u8 reg)
+{
+        return lm93_pwm_freq_map[reg & 0x07];
+}
+
+/* round up to nearest match */
+static u8 LM93_PWM_FREQ_TO_REG(int freq)
+{
+        int i;
+        for (i = 7; i > 0; i--)
+                if (freq <= lm93_pwm_freq_map[i])
+                        break;
+
+        /* can fall through with i==0 */
+        return (u8)i;
+}
+
+/* TIME: 1/100 seconds
+ * REG: 0-7 as mapped below */
+static int lm93_spinup_time_map[8] = {
+        0, 10, 25, 40, 70, 100, 200, 400,
+};
+
+static int LM93_SPINUP_TIME_FROM_REG(u8 reg)
+{
+        return lm93_spinup_time_map[reg >> 5 & 0x07];
+}
+
+/* round up to nearest match */
+static u8 LM93_SPINUP_TIME_TO_REG(int time)
+{
+        int i;
+        for (i = 0; i < 7; i++)
+                if (time <= lm93_spinup_time_map[i])
+                        break;
+
+        /* can fall through with i==8 */
+        return (u8)i;
+}
+
+#define LM93_RAMP_MIN 0
+#define LM93_RAMP_MAX 75
+
+static int LM93_RAMP_FROM_REG(u8 reg)
+{
+        return (reg & 0x0f) * 5;
+}
+
+/* RAMP: 1/100 seconds
+   REG: 50mS/bit 4-bits right justified */
+static u8 LM93_RAMP_TO_REG(int ramp)
+{
+        ramp = SENSORS_LIMIT(ramp, LM93_RAMP_MIN, LM93_RAMP_MAX);
+        return (u8)((ramp + 2) / 5);
+}
+
+/* PROCHOT: 0-255, 0 => 0%, 255 => > 96.6%
+ * REG: (same) */
+static u8 LM93_PROCHOT_TO_REG(long prochot)
+{
+        prochot = SENSORS_LIMIT(prochot, 0, 255);
+        return (u8)prochot;
+}
+
+/* PROCHOT-INTERVAL: 73 - 37200 (1/100 seconds)
+ * REG: 0-9 as mapped below */
+static int lm93_interval_map[10] = {
+        73, 146, 290, 580, 1170, 2330, 4660, 9320, 18600, 37200,
+};
+
+static int LM93_INTERVAL_FROM_REG(u8 reg)
+{
+        return lm93_interval_map[reg & 0x0f];
+}
+
+/* round up to nearest match */
+static u8 LM93_INTERVAL_TO_REG(long interval)
+{
+        int i;
+        for (i = 0; i < 9; i++)
+                if (interval <= lm93_interval_map[i])
+                        break;
+
+        /* can fall through with i==9 */
+        return (u8)i;
+}
+
+/* GPIO: 0-255, GPIO0 is LSB
+ * REG: inverted */
+static unsigned LM93_GPI_FROM_REG(u8 reg)
+{
+        return ~reg & 0xff;
+}
+
+/* alarm bitmask definitions
+   The LM93 has nearly 64 bits of error status... I've pared that down to
+   what I think is a useful subset in order to fit it into 32 bits.
+
+   Especially note that the #VRD_HOT alarms are missing because we provide
+   that information as values in another sysfs file.
+
+   If libsensors is extended to support 64 bit values, this could be revisited.
+*/
+#define LM93_ALARM_IN1          0x00000001
+#define LM93_ALARM_IN2          0x00000002
+#define LM93_ALARM_IN3          0x00000004
+#define LM93_ALARM_IN4          0x00000008
+#define LM93_ALARM_IN5          0x00000010
+#define LM93_ALARM_IN6          0x00000020
+#define LM93_ALARM_IN7          0x00000040
+#define LM93_ALARM_IN8          0x00000080
+#define LM93_ALARM_IN9          0x00000100
+#define LM93_ALARM_IN10         0x00000200
+#define LM93_ALARM_IN11         0x00000400
+#define LM93_ALARM_IN12         0x00000800
+#define LM93_ALARM_IN13         0x00001000
+#define LM93_ALARM_IN14         0x00002000
+#define LM93_ALARM_IN15         0x00004000
+#define LM93_ALARM_IN16         0x00008000
+#define LM93_ALARM_FAN1         0x00010000
+#define LM93_ALARM_FAN2         0x00020000
+#define LM93_ALARM_FAN3         0x00040000
+#define LM93_ALARM_FAN4         0x00080000
+#define LM93_ALARM_PH1_ERR      0x00100000
+#define LM93_ALARM_PH2_ERR      0x00200000
+#define LM93_ALARM_SCSI1_ERR    0x00400000
+#define LM93_ALARM_SCSI2_ERR    0x00800000
+#define LM93_ALARM_DVDDP1_ERR   0x01000000
+#define LM93_ALARM_DVDDP2_ERR   0x02000000
+#define LM93_ALARM_D1_ERR       0x04000000
+#define LM93_ALARM_D2_ERR       0x08000000
+#define LM93_ALARM_TEMP1        0x10000000
+#define LM93_ALARM_TEMP2        0x20000000
+#define LM93_ALARM_TEMP3        0x40000000
+
+static unsigned LM93_ALARMS_FROM_REG(struct block1_t b1)
+{
+        unsigned result;
+        result  = b1.host_status_2 & 0x3f;
+
+        if (vccp_limit_type[0])
+                result |= (b1.host_status_4 & 0x10) << 2;
+        else
+                result |= b1.host_status_2 & 0x40;
+
+        if (vccp_limit_type[1])
+                result |= (b1.host_status_4 & 0x20) << 2;
+        else
+                result |= b1.host_status_2 & 0x80;
+
+        result |= b1.host_status_3 << 8;
+        result |= (b1.fan_status & 0x0f) << 16;
+        result |= (b1.p1_prochot_status & 0x80) << 13;
+        result |= (b1.p2_prochot_status & 0x80) << 14;
+        result |= (b1.host_status_4 & 0xfc) << 20;
+        result |= (b1.host_status_1 & 0x07) << 28;
+        return result;
+}
+
+#define MAX_RETRIES 5
+
+static u8 lm93_read_byte(struct i2c_client *client, u8 reg)
+{
+        int value, i;
+
+        /* retry in case of read errors */
+        for (i=1; i<=MAX_RETRIES; i++) {
+                if ((value = i2c_smbus_read_byte_data(client, reg)) >= 0) {
+                        return value;
+                } else {
+                        dev_warn(&client->dev,"lm93: read byte data failed, "
+                                "address 0x%02x.\n", reg);
+                        mdelay(i + 3);
+                }
+
+        }
+
+        /* <TODO> what to return in case of error? */
+        dev_err(&client->dev,"lm93: All read byte retries failed!!\n");
+        return 0;
+}
+
+static int lm93_write_byte(struct i2c_client *client, u8 reg, u8 value)
+{
+        int result;
+
+        /* <TODO> how to handle write errors? */
+        result = i2c_smbus_write_byte_data(client, reg, value);
+
+        if (result < 0)
+                dev_warn(&client->dev,"lm93: write byte data failed, "
+                         "0x%02x at address 0x%02x.\n", value, reg);
+
+        return result;
+}
+
+static u16 lm93_read_word(struct i2c_client *client, u8 reg)
+{
+        int value, i;
+
+        /* retry in case of read errors */
+        for (i=1; i<=MAX_RETRIES; i++) {
+                if ((value = i2c_smbus_read_word_data(client, reg)) >= 0) {
+                        return value;
+                } else {
+                        dev_warn(&client->dev,"lm93: read word data failed, "
+                                 "address 0x%02x.\n", reg);
+                        mdelay(i + 3);
+                }
+
+        }
+
+        /* <TODO> what to return in case of error? */
+        dev_err(&client->dev,"lm93: All read word retries failed!!\n");
+        return 0;
+}
+
+static int lm93_write_word(struct i2c_client *client, u8 reg, u16 value)
+{
+        int result;
+
+        /* <TODO> how to handle write errors? */
+        result = i2c_smbus_write_word_data(client, reg, value);
+
+        if (result < 0)
+                dev_warn(&client->dev,"lm93: write word data failed, "
+                         "0x%04x at address 0x%02x.\n", value, reg);
+
+        return result;
+}
+
+static u8 lm93_block_buffer[I2C_SMBUS_BLOCK_MAX];
+
+/*
+        read block data into values, retry if not expected length
+        fbn => index to lm93_block_read_cmds table
+                (Fixed Block Number - section 14.5.2 of LM93 datasheet)
+*/
+static void lm93_read_block(struct i2c_client *client, u8 fbn, u8 *values)
+{
+        int i, result=0;
+
+        for (i = 1; i <= MAX_RETRIES; i++) {
+                result = i2c_smbus_read_block_data(client,
+                        lm93_block_read_cmds[fbn].cmd, lm93_block_buffer);
+
+                if (result == lm93_block_read_cmds[fbn].len) {
+                        break;
+                } else {
+                        dev_warn(&client->dev,"lm93: block read data failed, "
+                                 "command 0x%02x.\n",
+                                 lm93_block_read_cmds[fbn].cmd);
+                        mdelay(i + 3);
+                }
+        }
+
+        if (result == lm93_block_read_cmds[fbn].len) {
+                memcpy(values,lm93_block_buffer,lm93_block_read_cmds[fbn].len);
+        } else {
+                /* <TODO> what to do in case of error? */
+        }
+}
+
+static struct lm93_data *lm93_update_device(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        const unsigned long interval = HZ + (HZ / 2);
+
+        mutex_lock(&data->update_lock);
+
+        if (time_after(jiffies, data->last_updated + interval) ||
+                !data->valid) {
+
+                data->update(data, client);
+                data->last_updated = jiffies;
+                data->valid = 1;
+        }
+
+        mutex_unlock(&data->update_lock);
+        return data;
+}
+
+/* update routine for data that has no corresponding SMBus block command */
+static void lm93_update_client_common(struct lm93_data *data,
+                                      struct i2c_client *client)
+{
+        int i;
+        u8 *ptr;
+
+        /* temp1 - temp4: limits */
+        for (i = 0; i < 4; i++) {
+                data->temp_lim[i].min =
+                        lm93_read_byte(client, LM93_REG_TEMP_MIN(i));
+                data->temp_lim[i].max =
+                        lm93_read_byte(client, LM93_REG_TEMP_MAX(i));
+        }
+
+        /* config register */
+        data->config = lm93_read_byte(client, LM93_REG_CONFIG);
+
+        /* vid1 - vid2: values */
+        for (i = 0; i < 2; i++)
+                data->vid[i] = lm93_read_byte(client, LM93_REG_VID(i));
+
+        /* prochot1 - prochot2: limits */
+        for (i = 0; i < 2; i++)
+                data->prochot_max[i] = lm93_read_byte(client,
+                                LM93_REG_PROCHOT_MAX(i));
+
+        /* vccp1 - vccp2: VID relative limits */
+        for (i = 0; i < 2; i++)
+                data->vccp_limits[i] = lm93_read_byte(client,
+                                LM93_REG_VCCP_LIMIT_OFF(i));
+
+        /* GPIO input state */
+        data->gpi = lm93_read_byte(client, LM93_REG_GPI);
+
+        /* #PROCHOT override state */
+        data->prochot_override = lm93_read_byte(client,
+                        LM93_REG_PROCHOT_OVERRIDE);
+
+        /* #PROCHOT intervals */
+        data->prochot_interval = lm93_read_byte(client,
+                        LM93_REG_PROCHOT_INTERVAL);
+
+        /* Fan Boost Termperature registers */
+        for (i = 0; i < 4; i++)
+                data->boost[i] = lm93_read_byte(client, LM93_REG_BOOST(i));
+
+        /* Fan Boost Temperature Hyst. registers */
+        data->boost_hyst[0] = lm93_read_byte(client, LM93_REG_BOOST_HYST_12);
+        data->boost_hyst[1] = lm93_read_byte(client, LM93_REG_BOOST_HYST_34);
+
+        /* Temperature Zone Min. PWM & Hysteresis registers */
+        data->auto_pwm_min_hyst[0] =
+                        lm93_read_byte(client, LM93_REG_PWM_MIN_HYST_12);
+        data->auto_pwm_min_hyst[1] =
+                        lm93_read_byte(client, LM93_REG_PWM_MIN_HYST_34);
+
+        /* #PROCHOT & #VRDHOT PWM Ramp Control register */
+        data->pwm_ramp_ctl = lm93_read_byte(client, LM93_REG_PWM_RAMP_CTL);
+
+        /* misc setup registers */
+        data->sfc1 = lm93_read_byte(client, LM93_REG_SFC1);
+        data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
+        data->sf_tach_to_pwm = lm93_read_byte(client,
+                        LM93_REG_SF_TACH_TO_PWM);
+
+        /* write back alarm values to clear */
+        for (i = 0, ptr = (u8 *)(&data->block1); i < 8; i++)
+                lm93_write_byte(client, LM93_REG_HOST_ERROR_1 + i, *(ptr + i));
+}
+
+/* update routine which uses SMBus block data commands */
+static void lm93_update_client_full(struct lm93_data *data,
+                                    struct i2c_client *client)
+{
+        dev_dbg(&client->dev,"starting device update (block data enabled)\n");
+
+        /* in1 - in16: values & limits */
+        lm93_read_block(client, 3, (u8 *)(data->block3));
+        lm93_read_block(client, 7, (u8 *)(data->block7));
+
+        /* temp1 - temp4: values */
+        lm93_read_block(client, 2, (u8 *)(data->block2));
+
+        /* prochot1 - prochot2: values */
+        lm93_read_block(client, 4, (u8 *)(data->block4));
+
+        /* fan1 - fan4: values & limits */
+        lm93_read_block(client, 5, (u8 *)(data->block5));
+        lm93_read_block(client, 8, (u8 *)(data->block8));
+
+        /* pmw control registers */
+        lm93_read_block(client, 9, (u8 *)(data->block9));
+
+        /* alarm values */
+        lm93_read_block(client, 1, (u8 *)(&data->block1));
+
+        /* auto/pwm registers */
+        lm93_read_block(client, 10, (u8 *)(&data->block10));
+
+        lm93_update_client_common(data, client);
+}
+
+/* update routine which uses SMBus byte/word data commands only */
+static void lm93_update_client_min(struct lm93_data *data,
+                                   struct i2c_client *client)
+{
+        int i,j;
+        u8 *ptr;
+
+        dev_dbg(&client->dev,"starting device update (block data disabled)\n");
+
+        /* in1 - in16: values & limits */
+        for (i = 0; i < 16; i++) {
+                data->block3[i] =
+                        lm93_read_byte(client, LM93_REG_IN(i));
+                data->block7[i].min =
+                        lm93_read_byte(client, LM93_REG_IN_MIN(i));
+                data->block7[i].max =
+                        lm93_read_byte(client, LM93_REG_IN_MAX(i));
+        }
+
+        /* temp1 - temp4: values */
+        for (i = 0; i < 4; i++) {
+                data->block2[i] =
+                        lm93_read_byte(client, LM93_REG_TEMP(i));
+        }
+
+        /* prochot1 - prochot2: values */
+        for (i = 0; i < 2; i++) {
+                data->block4[i].cur =
+                        lm93_read_byte(client, LM93_REG_PROCHOT_CUR(i));
+                data->block4[i].avg =
+                        lm93_read_byte(client, LM93_REG_PROCHOT_AVG(i));
+        }
+
+        /* fan1 - fan4: values & limits */
+        for (i = 0; i < 4; i++) {
+                data->block5[i] =
+                        lm93_read_word(client, LM93_REG_FAN(i));
+                data->block8[i] =
+                        lm93_read_word(client, LM93_REG_FAN_MIN(i));
+        }
+
+        /* pwm control registers */
+        for (i = 0; i < 2; i++) {
+                for (j = 0; j < 4; j++) {
+                        data->block9[i][j] =
+                                lm93_read_byte(client, LM93_REG_PWM_CTL(i,j));
+                }
+        }
+
+        /* alarm values */
+        for (i = 0, ptr = (u8 *)(&data->block1); i < 8; i++) {
+                *(ptr + i) =
+                        lm93_read_byte(client, LM93_REG_HOST_ERROR_1 + i);
+        }
+
+        /* auto/pwm (base temp) registers */
+        for (i = 0; i < 4; i++) {
+                data->block10.base[i] =
+                        lm93_read_byte(client, LM93_REG_TEMP_BASE(i));
+        }
+
+        /* auto/pwm (offset temp) registers */
+        for (i = 0; i < 12; i++) {
+                data->block10.offset[i] =
+                        lm93_read_byte(client, LM93_REG_TEMP_OFFSET(i));
+        }
+
+        lm93_update_client_common(data, client);
+}
+
+/* following are the sysfs callback functions */
+static ssize_t show_in(struct device *dev, struct device_attribute *attr,
+                        char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+
+        struct lm93_data *data = lm93_update_device(dev);
+        return sprintf(buf, "%d\n", LM93_IN_FROM_REG(nr, data->block3[nr]));
+}
+
+static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in, NULL, 0);
+static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in, NULL, 1);
+static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in, NULL, 2);
+static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_in, NULL, 3);
+static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, show_in, NULL, 4);
+static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, show_in, NULL, 5);
+static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, show_in, NULL, 6);
+static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, show_in, NULL, 7);
+static SENSOR_DEVICE_ATTR(in9_input, S_IRUGO, show_in, NULL, 8);
+static SENSOR_DEVICE_ATTR(in10_input, S_IRUGO, show_in, NULL, 9);
+static SENSOR_DEVICE_ATTR(in11_input, S_IRUGO, show_in, NULL, 10);
+static SENSOR_DEVICE_ATTR(in12_input, S_IRUGO, show_in, NULL, 11);
+static SENSOR_DEVICE_ATTR(in13_input, S_IRUGO, show_in, NULL, 12);
+static SENSOR_DEVICE_ATTR(in14_input, S_IRUGO, show_in, NULL, 13);
+static SENSOR_DEVICE_ATTR(in15_input, S_IRUGO, show_in, NULL, 14);
+static SENSOR_DEVICE_ATTR(in16_input, S_IRUGO, show_in, NULL, 15);
+
+static ssize_t show_in_min(struct device *dev,
+                        struct device_attribute *attr, char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+        int vccp = nr - 6;
+        long rc, vid;
+
+        if ((nr==6 || nr==7) && (vccp_limit_type[vccp])) {
+                vid = LM93_VID_FROM_REG(data->vid[vccp]);
+                rc = LM93_IN_MIN_FROM_REG(data->vccp_limits[vccp], vid);
+        }
+        else {
+                rc = LM93_IN_FROM_REG(nr, data->block7[nr].min); \
+        }
+        return sprintf(buf, "%ld\n", rc); \
+}
+
+static ssize_t store_in_min(struct device *dev, struct device_attribute *attr,
+                            const char *buf, size_t count)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+        int vccp = nr - 6;
+        long vid;
+
+        mutex_lock(&data->update_lock);
+        if ((nr==6 || nr==7) && (vccp_limit_type[vccp])) {
+                vid = LM93_VID_FROM_REG(data->vid[vccp]);
+                data->vccp_limits[vccp] = (data->vccp_limits[vccp] & 0xf0) |
+                                LM93_IN_REL_TO_REG(val, 0, vid);
+                lm93_write_byte(client, LM93_REG_VCCP_LIMIT_OFF(vccp),
+                                data->vccp_limits[vccp]);
+        }
+        else {
+                data->block7[nr].min = LM93_IN_TO_REG(nr,val);
+                lm93_write_byte(client, LM93_REG_IN_MIN(nr),
+                                data->block7[nr].min);
+        }
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(in1_min, S_IWUSR | S_IRUGO,
+                          show_in_min, store_in_min, 0);
+static SENSOR_DEVICE_ATTR(in2_min, S_IWUSR | S_IRUGO,
+                          show_in_min, store_in_min, 1);
+static SENSOR_DEVICE_ATTR(in3_min, S_IWUSR | S_IRUGO,
+                          show_in_min, store_in_min, 2);
+static SENSOR_DEVICE_ATTR(in4_min, S_IWUSR | S_IRUGO,
+                          show_in_min, store_in_min, 3);
+static SENSOR_DEVICE_ATTR(in5_min, S_IWUSR | S_IRUGO,
+                          show_in_min, store_in_min, 4);
+static SENSOR_DEVICE_ATTR(in6_min, S_IWUSR | S_IRUGO,
+                          show_in_min, store_in_min, 5);
+static SENSOR_DEVICE_ATTR(in7_min, S_IWUSR | S_IRUGO,
+                          show_in_min, store_in_min, 6);
+static SENSOR_DEVICE_ATTR(in8_min, S_IWUSR | S_IRUGO,
+                          show_in_min, store_in_min, 7);
+static SENSOR_DEVICE_ATTR(in9_min, S_IWUSR | S_IRUGO,
+                          show_in_min, store_in_min, 8);
+static SENSOR_DEVICE_ATTR(in10_min, S_IWUSR | S_IRUGO,
+                          show_in_min, store_in_min, 9);
+static SENSOR_DEVICE_ATTR(in11_min, S_IWUSR | S_IRUGO,
+                          show_in_min, store_in_min, 10);
+static SENSOR_DEVICE_ATTR(in12_min, S_IWUSR | S_IRUGO,
+                          show_in_min, store_in_min, 11);
+static SENSOR_DEVICE_ATTR(in13_min, S_IWUSR | S_IRUGO,
+                          show_in_min, store_in_min, 12);
+static SENSOR_DEVICE_ATTR(in14_min, S_IWUSR | S_IRUGO,
+                          show_in_min, store_in_min, 13);
+static SENSOR_DEVICE_ATTR(in15_min, S_IWUSR | S_IRUGO,
+                          show_in_min, store_in_min, 14);
+static SENSOR_DEVICE_ATTR(in16_min, S_IWUSR | S_IRUGO,
+                          show_in_min, store_in_min, 15);
+
+static ssize_t show_in_max(struct device *dev,
+                           struct device_attribute *attr, char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+        int vccp = nr - 6;
+        long rc, vid;
+
+        if ((nr==6 || nr==7) && (vccp_limit_type[vccp])) {
+                vid = LM93_VID_FROM_REG(data->vid[vccp]);
+                rc = LM93_IN_MAX_FROM_REG(data->vccp_limits[vccp],vid);
+        }
+        else {
+                rc = LM93_IN_FROM_REG(nr,data->block7[nr].max); \
+        }
+        return sprintf(buf,"%ld\n",rc); \
+}
+
+static ssize_t store_in_max(struct device *dev, struct device_attribute *attr,
+                            const char *buf, size_t count)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+        int vccp = nr - 6;
+        long vid;
+
+        mutex_lock(&data->update_lock);
+        if ((nr==6 || nr==7) && (vccp_limit_type[vccp])) {
+                vid = LM93_VID_FROM_REG(data->vid[vccp]);
+                data->vccp_limits[vccp] = (data->vccp_limits[vccp] & 0x0f) |
+                                LM93_IN_REL_TO_REG(val, 1, vid);
+                lm93_write_byte(client, LM93_REG_VCCP_LIMIT_OFF(vccp),
+                                data->vccp_limits[vccp]);
+        }
+        else {
+                data->block7[nr].max = LM93_IN_TO_REG(nr,val);
+                lm93_write_byte(client, LM93_REG_IN_MAX(nr),
+                                data->block7[nr].max);
+        }
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(in1_max, S_IWUSR | S_IRUGO,
+                          show_in_max, store_in_max, 0);
+static SENSOR_DEVICE_ATTR(in2_max, S_IWUSR | S_IRUGO,
+                          show_in_max, store_in_max, 1);
+static SENSOR_DEVICE_ATTR(in3_max, S_IWUSR | S_IRUGO,
+                          show_in_max, store_in_max, 2);
+static SENSOR_DEVICE_ATTR(in4_max, S_IWUSR | S_IRUGO,
+                          show_in_max, store_in_max, 3);
+static SENSOR_DEVICE_ATTR(in5_max, S_IWUSR | S_IRUGO,
+                          show_in_max, store_in_max, 4);
+static SENSOR_DEVICE_ATTR(in6_max, S_IWUSR | S_IRUGO,
+                          show_in_max, store_in_max, 5);
+static SENSOR_DEVICE_ATTR(in7_max, S_IWUSR | S_IRUGO,
+                          show_in_max, store_in_max, 6);
+static SENSOR_DEVICE_ATTR(in8_max, S_IWUSR | S_IRUGO,
+                          show_in_max, store_in_max, 7);
+static SENSOR_DEVICE_ATTR(in9_max, S_IWUSR | S_IRUGO,
+                          show_in_max, store_in_max, 8);
+static SENSOR_DEVICE_ATTR(in10_max, S_IWUSR | S_IRUGO,
+                          show_in_max, store_in_max, 9);
+static SENSOR_DEVICE_ATTR(in11_max, S_IWUSR | S_IRUGO,
+                          show_in_max, store_in_max, 10);
+static SENSOR_DEVICE_ATTR(in12_max, S_IWUSR | S_IRUGO,
+                          show_in_max, store_in_max, 11);
+static SENSOR_DEVICE_ATTR(in13_max, S_IWUSR | S_IRUGO,
+                          show_in_max, store_in_max, 12);
+static SENSOR_DEVICE_ATTR(in14_max, S_IWUSR | S_IRUGO,
+                          show_in_max, store_in_max, 13);
+static SENSOR_DEVICE_ATTR(in15_max, S_IWUSR | S_IRUGO,
+                          show_in_max, store_in_max, 14);
+static SENSOR_DEVICE_ATTR(in16_max, S_IWUSR | S_IRUGO,
+                          show_in_max, store_in_max, 15);
+
+static ssize_t show_temp(struct device *dev,
+                         struct device_attribute *attr, char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+        return sprintf(buf,"%d\n",LM93_TEMP_FROM_REG(data->block2[nr]));
+}
+
+static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
+static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
+
+static ssize_t show_temp_min(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+        return sprintf(buf,"%d\n",LM93_TEMP_FROM_REG(data->temp_lim[nr].min));
+}
+
+static ssize_t store_temp_min(struct device *dev, struct device_attribute *attr,
+                              const char *buf, size_t count)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+
+        mutex_lock(&data->update_lock);
+        data->temp_lim[nr].min = LM93_TEMP_TO_REG(val);
+        lm93_write_byte(client, LM93_REG_TEMP_MIN(nr), data->temp_lim[nr].min);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO,
+                          show_temp_min, store_temp_min, 0);
+static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO,
+                          show_temp_min, store_temp_min, 1);
+static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO,
+                          show_temp_min, store_temp_min, 2);
+
+static ssize_t show_temp_max(struct device *dev,
+                             struct device_attribute *attr, char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+        return sprintf(buf,"%d\n",LM93_TEMP_FROM_REG(data->temp_lim[nr].max));
+}
+
+static ssize_t store_temp_max(struct device *dev, struct device_attribute *attr,
+                              const char *buf, size_t count)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+
+        mutex_lock(&data->update_lock);
+        data->temp_lim[nr].max = LM93_TEMP_TO_REG(val);
+        lm93_write_byte(client, LM93_REG_TEMP_MAX(nr), data->temp_lim[nr].max);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
+                          show_temp_max, store_temp_max, 0);
+static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO,
+                          show_temp_max, store_temp_max, 1);
+static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO,
+                          show_temp_max, store_temp_max, 2);
+
+static ssize_t show_temp_auto_base(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+        return sprintf(buf,"%d\n",LM93_TEMP_FROM_REG(data->block10.base[nr]));
+}
+
+static ssize_t store_temp_auto_base(struct device *dev,
+                                        struct device_attribute *attr,
+                                        const char *buf, size_t count)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+
+        mutex_lock(&data->update_lock);
+        data->block10.base[nr] = LM93_TEMP_TO_REG(val);
+        lm93_write_byte(client, LM93_REG_TEMP_BASE(nr), data->block10.base[nr]);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(temp1_auto_base, S_IWUSR | S_IRUGO,
+                          show_temp_auto_base, store_temp_auto_base, 0);
+static SENSOR_DEVICE_ATTR(temp2_auto_base, S_IWUSR | S_IRUGO,
+                          show_temp_auto_base, store_temp_auto_base, 1);
+static SENSOR_DEVICE_ATTR(temp3_auto_base, S_IWUSR | S_IRUGO,
+                          show_temp_auto_base, store_temp_auto_base, 2);
+
+static ssize_t show_temp_auto_boost(struct device *dev,
+                                    struct device_attribute *attr,char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+        return sprintf(buf,"%d\n",LM93_TEMP_FROM_REG(data->boost[nr]));
+}
+
+static ssize_t store_temp_auto_boost(struct device *dev,
+                                     struct device_attribute *attr,
+                                     const char *buf, size_t count)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+
+        mutex_lock(&data->update_lock);
+        data->boost[nr] = LM93_TEMP_TO_REG(val);
+        lm93_write_byte(client, LM93_REG_BOOST(nr), data->boost[nr]);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(temp1_auto_boost, S_IWUSR | S_IRUGO,
+                          show_temp_auto_boost, store_temp_auto_boost, 0);
+static SENSOR_DEVICE_ATTR(temp2_auto_boost, S_IWUSR | S_IRUGO,
+                          show_temp_auto_boost, store_temp_auto_boost, 1);
+static SENSOR_DEVICE_ATTR(temp3_auto_boost, S_IWUSR | S_IRUGO,
+                          show_temp_auto_boost, store_temp_auto_boost, 2);
+
+static ssize_t show_temp_auto_boost_hyst(struct device *dev,
+                                         struct device_attribute *attr,
+                                         char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+        int mode = LM93_TEMP_OFFSET_MODE_FROM_REG(data->sfc2, nr);
+        return sprintf(buf,"%d\n",
+                       LM93_AUTO_BOOST_HYST_FROM_REGS(data, nr, mode));
+}
+
+static ssize_t store_temp_auto_boost_hyst(struct device *dev,
+                                          struct device_attribute *attr,
+                                          const char *buf, size_t count)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+
+        mutex_lock(&data->update_lock);
+        /* force 0.5C/bit mode */
+        data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
+        data->sfc2 |= ((nr < 2) ? 0x10 : 0x20);
+        lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
+        data->boost_hyst[nr/2] = LM93_AUTO_BOOST_HYST_TO_REG(data, val, nr, 1);
+        lm93_write_byte(client, LM93_REG_BOOST_HYST(nr),
+                        data->boost_hyst[nr/2]);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(temp1_auto_boost_hyst, S_IWUSR | S_IRUGO,
+                          show_temp_auto_boost_hyst,
+                          store_temp_auto_boost_hyst, 0);
+static SENSOR_DEVICE_ATTR(temp2_auto_boost_hyst, S_IWUSR | S_IRUGO,
+                          show_temp_auto_boost_hyst,
+                          store_temp_auto_boost_hyst, 1);
+static SENSOR_DEVICE_ATTR(temp3_auto_boost_hyst, S_IWUSR | S_IRUGO,
+                          show_temp_auto_boost_hyst,
+                          store_temp_auto_boost_hyst, 2);
+
+static ssize_t show_temp_auto_offset(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct sensor_device_attribute_2 *s_attr = to_sensor_dev_attr_2(attr);
+        int nr = s_attr->index;
+        int ofs = s_attr->nr;
+        struct lm93_data *data = lm93_update_device(dev);
+        int mode = LM93_TEMP_OFFSET_MODE_FROM_REG(data->sfc2, nr);
+        return sprintf(buf,"%d\n",
+               LM93_TEMP_AUTO_OFFSET_FROM_REG(data->block10.offset[ofs],
+                                              nr,mode));
+}
+
+static ssize_t store_temp_auto_offset(struct device *dev,
+                                        struct device_attribute *attr,
+                                        const char *buf, size_t count)
+{
+        struct sensor_device_attribute_2 *s_attr = to_sensor_dev_attr_2(attr);
+        int nr = s_attr->index;
+        int ofs = s_attr->nr;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+
+        mutex_lock(&data->update_lock);
+        /* force 0.5C/bit mode */
+        data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
+        data->sfc2 |= ((nr < 2) ? 0x10 : 0x20);
+        lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
+        data->block10.offset[ofs] = LM93_TEMP_AUTO_OFFSET_TO_REG(
+                        data->block10.offset[ofs], val, nr, 1);
+        lm93_write_byte(client, LM93_REG_TEMP_OFFSET(ofs),
+                        data->block10.offset[ofs]);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR_2(temp1_auto_offset1, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 0, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_auto_offset2, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 1, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_auto_offset3, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 2, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_auto_offset4, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 3, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_auto_offset5, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 4, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_auto_offset6, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 5, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_auto_offset7, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 6, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_auto_offset8, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 7, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_auto_offset9, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 8, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_auto_offset10, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 9, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_auto_offset11, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 10, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_auto_offset12, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 11, 0);
+static SENSOR_DEVICE_ATTR_2(temp2_auto_offset1, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 0, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_auto_offset2, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 1, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_auto_offset3, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 2, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_auto_offset4, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 3, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_auto_offset5, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 4, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_auto_offset6, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 5, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_auto_offset7, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 6, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_auto_offset8, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 7, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_auto_offset9, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 8, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_auto_offset10, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 9, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_auto_offset11, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 10, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_auto_offset12, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 11, 1);
+static SENSOR_DEVICE_ATTR_2(temp3_auto_offset1, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 0, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_auto_offset2, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 1, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_auto_offset3, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 2, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_auto_offset4, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 3, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_auto_offset5, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 4, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_auto_offset6, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 5, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_auto_offset7, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 6, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_auto_offset8, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 7, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_auto_offset9, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 8, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_auto_offset10, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 9, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_auto_offset11, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 10, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_auto_offset12, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset, store_temp_auto_offset, 11, 2);
+
+static ssize_t show_temp_auto_pwm_min(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        u8 reg, ctl4;
+        struct lm93_data *data = lm93_update_device(dev);
+        reg = data->auto_pwm_min_hyst[nr/2] >> 4 & 0x0f;
+        ctl4 = data->block9[nr][LM93_PWM_CTL4];
+        return sprintf(buf,"%d\n",LM93_PWM_FROM_REG(reg, (ctl4 & 0x07) ?
+                                LM93_PWM_MAP_LO_FREQ : LM93_PWM_MAP_HI_FREQ));
+}
+
+static ssize_t store_temp_auto_pwm_min(struct device *dev,
+                                        struct device_attribute *attr,
+                                        const char *buf, size_t count)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+        u8 reg, ctl4;
+
+        mutex_lock(&data->update_lock);
+        reg = lm93_read_byte(client, LM93_REG_PWM_MIN_HYST(nr));
+        ctl4 = lm93_read_byte(client, LM93_REG_PWM_CTL(nr,LM93_PWM_CTL4));
+        reg = (reg & 0x0f) |
+                LM93_PWM_TO_REG(val, (ctl4 & 0x07) ?
+                                LM93_PWM_MAP_LO_FREQ :
+                                LM93_PWM_MAP_HI_FREQ) << 4;
+        data->auto_pwm_min_hyst[nr/2] = reg;
+        lm93_write_byte(client, LM93_REG_PWM_MIN_HYST(nr), reg);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(temp1_auto_pwm_min, S_IWUSR | S_IRUGO,
+                          show_temp_auto_pwm_min,
+                          store_temp_auto_pwm_min, 0);
+static SENSOR_DEVICE_ATTR(temp2_auto_pwm_min, S_IWUSR | S_IRUGO,
+                          show_temp_auto_pwm_min,
+                          store_temp_auto_pwm_min, 1);
+static SENSOR_DEVICE_ATTR(temp3_auto_pwm_min, S_IWUSR | S_IRUGO,
+                          show_temp_auto_pwm_min,
+                          store_temp_auto_pwm_min, 2);
+
+static ssize_t show_temp_auto_offset_hyst(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+        int mode = LM93_TEMP_OFFSET_MODE_FROM_REG(data->sfc2, nr);
+        return sprintf(buf,"%d\n",LM93_TEMP_OFFSET_FROM_REG(
+                                        data->auto_pwm_min_hyst[nr/2], mode));
+}
+
+static ssize_t store_temp_auto_offset_hyst(struct device *dev,
+                                                struct device_attribute *attr,
+                                                const char *buf, size_t count)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+        u8 reg;
+
+        mutex_lock(&data->update_lock);
+        /* force 0.5C/bit mode */
+        data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
+        data->sfc2 |= ((nr < 2) ? 0x10 : 0x20);
+        lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
+        reg = data->auto_pwm_min_hyst[nr/2];
+        reg = (reg & 0xf0) | (LM93_TEMP_OFFSET_TO_REG(val, 1) & 0x0f);
+        data->auto_pwm_min_hyst[nr/2] = reg;
+        lm93_write_byte(client, LM93_REG_PWM_MIN_HYST(nr), reg);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(temp1_auto_offset_hyst, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset_hyst,
+                          store_temp_auto_offset_hyst, 0);
+static SENSOR_DEVICE_ATTR(temp2_auto_offset_hyst, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset_hyst,
+                          store_temp_auto_offset_hyst, 1);
+static SENSOR_DEVICE_ATTR(temp3_auto_offset_hyst, S_IWUSR | S_IRUGO,
+                          show_temp_auto_offset_hyst,
+                          store_temp_auto_offset_hyst, 2);
+
+static ssize_t show_fan_input(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        struct sensor_device_attribute *s_attr = to_sensor_dev_attr(attr);
+        int nr = s_attr->index;
+        struct lm93_data *data = lm93_update_device(dev);
+
+        return sprintf(buf,"%d\n",LM93_FAN_FROM_REG(data->block5[nr]));
+}
+
+static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan_input, NULL, 0);
+static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan_input, NULL, 1);
+static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan_input, NULL, 2);
+static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan_input, NULL, 3);
+
+static ssize_t show_fan_min(struct device *dev,
+                              struct device_attribute *attr, char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+
+        return sprintf(buf,"%d\n",LM93_FAN_FROM_REG(data->block8[nr]));
+}
+
+static ssize_t store_fan_min(struct device *dev, struct device_attribute *attr,
+                                const char *buf, size_t count)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+
+        mutex_lock(&data->update_lock);
+        data->block8[nr] = LM93_FAN_TO_REG(val);
+        lm93_write_word(client,LM93_REG_FAN_MIN(nr),data->block8[nr]);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO,
+                          show_fan_min, store_fan_min, 0);
+static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO,
+                          show_fan_min, store_fan_min, 1);
+static SENSOR_DEVICE_ATTR(fan3_min, S_IWUSR | S_IRUGO,
+                          show_fan_min, store_fan_min, 2);
+static SENSOR_DEVICE_ATTR(fan4_min, S_IWUSR | S_IRUGO,
+                          show_fan_min, store_fan_min, 3);
+
+/* some tedious bit-twiddling here to deal with the register format:
+
+        data->sf_tach_to_pwm: (tach to pwm mapping bits)
+
+                bit |  7  |  6  |  5  |  4  |  3  |  2  |  1  |  0
+                     T4:P2 T4:P1 T3:P2 T3:P1 T2:P2 T2:P1 T1:P2 T1:P1
+
+        data->sfc2: (enable bits)
+
+                bit |  3  |  2  |  1  |  0
+                       T4    T3    T2    T1
+*/
+
+static ssize_t show_fan_smart_tach(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+        long rc = 0;
+        int mapping;
+
+        /* extract the relevant mapping */
+        mapping = (data->sf_tach_to_pwm >> (nr * 2)) & 0x03;
+
+        /* if there's a mapping and it's enabled */
+        if (mapping && ((data->sfc2 >> nr) & 0x01))
+                rc = mapping;
+        return sprintf(buf,"%ld\n",rc);
+}
+
+/* helper function - must grab data->update_lock before calling
+   fan is 0-3, indicating fan1-fan4 */
+static void lm93_write_fan_smart_tach(struct i2c_client *client,
+        struct lm93_data *data, int fan, long value)
+{
+        /* insert the new mapping and write it out */
+        data->sf_tach_to_pwm = lm93_read_byte(client, LM93_REG_SF_TACH_TO_PWM);
+        data->sf_tach_to_pwm &= ~(0x3 << fan * 2);
+        data->sf_tach_to_pwm |= value << fan * 2;
+        lm93_write_byte(client, LM93_REG_SF_TACH_TO_PWM, data->sf_tach_to_pwm);
+
+        /* insert the enable bit and write it out */
+        data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
+        if (value)
+                data->sfc2 |= 1 << fan;
+        else
+                data->sfc2 &= ~(1 << fan);
+        lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
+}
+
+static ssize_t store_fan_smart_tach(struct device *dev,
+                                        struct device_attribute *attr,
+                                        const char *buf, size_t count)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+
+        mutex_lock(&data->update_lock);
+        /* sanity test, ignore the write otherwise */
+        if (0 <= val && val <= 2) {
+                /* can't enable if pwm freq is 22.5KHz */
+                if (val) {
+                        u8 ctl4 = lm93_read_byte(client,
+                                LM93_REG_PWM_CTL(val-1,LM93_PWM_CTL4));
+                        if ((ctl4 & 0x07) == 0)
+                                val = 0;
+                }
+                lm93_write_fan_smart_tach(client, data, nr, val);
+        }
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(fan1_smart_tach, S_IWUSR | S_IRUGO,
+                          show_fan_smart_tach, store_fan_smart_tach, 0);
+static SENSOR_DEVICE_ATTR(fan2_smart_tach, S_IWUSR | S_IRUGO,
+                          show_fan_smart_tach, store_fan_smart_tach, 1);
+static SENSOR_DEVICE_ATTR(fan3_smart_tach, S_IWUSR | S_IRUGO,
+                          show_fan_smart_tach, store_fan_smart_tach, 2);
+static SENSOR_DEVICE_ATTR(fan4_smart_tach, S_IWUSR | S_IRUGO,
+                          show_fan_smart_tach, store_fan_smart_tach, 3);
+
+static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
+                        char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+        u8 ctl2, ctl4;
+        long rc;
+
+        ctl2 = data->block9[nr][LM93_PWM_CTL2];
+        ctl4 = data->block9[nr][LM93_PWM_CTL4];
+        if (ctl2 & 0x01) /* show user commanded value if enabled */
+                rc = data->pwm_override[nr];
+        else /* show present h/w value if manual pwm disabled */
+                rc = LM93_PWM_FROM_REG(ctl2 >> 4, (ctl4 & 0x07) ?
+                        LM93_PWM_MAP_LO_FREQ : LM93_PWM_MAP_HI_FREQ);
+        return sprintf(buf,"%ld\n",rc);
+}
+
+static ssize_t store_pwm(struct device *dev, struct device_attribute *attr,
+                                const char *buf, size_t count)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+        u8 ctl2, ctl4;
+
+        mutex_lock(&data->update_lock);
+        ctl2 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr,LM93_PWM_CTL2));
+        ctl4 = lm93_read_byte(client, LM93_REG_PWM_CTL(nr,LM93_PWM_CTL4));
+        ctl2 = (ctl2 & 0x0f) | LM93_PWM_TO_REG(val,(ctl4 & 0x07) ?
+                        LM93_PWM_MAP_LO_FREQ : LM93_PWM_MAP_HI_FREQ) << 4;
+        /* save user commanded value */
+        data->pwm_override[nr] = LM93_PWM_FROM_REG(ctl2 >> 4,
+                        (ctl4 & 0x07) ?  LM93_PWM_MAP_LO_FREQ :
+                        LM93_PWM_MAP_HI_FREQ);
+        lm93_write_byte(client,LM93_REG_PWM_CTL(nr,LM93_PWM_CTL2),ctl2);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 0);
+static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 1);
+
+static ssize_t show_pwm_enable(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+        u8 ctl2;
+        long rc;
+
+        ctl2 = data->block9[nr][LM93_PWM_CTL2];
+        if (ctl2 & 0x01) /* manual override enabled ? */
+                rc = ((ctl2 & 0xF0) == 0xF0) ? 0 : 1;
+        else
+                rc = 2;
+        return sprintf(buf,"%ld\n",rc);
+}
+
+static ssize_t store_pwm_enable(struct device *dev,
+                                struct device_attribute *attr,
+                                const char *buf, size_t count)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+        u8 ctl2;
+
+        mutex_lock(&data->update_lock);
+        ctl2 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr,LM93_PWM_CTL2));
+
+        switch (val) {
+        case 0:
+                ctl2 |= 0xF1; /* enable manual override, set PWM to max */
+                break;
+        case 1: ctl2 |= 0x01; /* enable manual override */
+                break;
+        case 2: ctl2 &= ~0x01; /* disable manual override */
+                break;
+        default:
+                mutex_unlock(&data->update_lock);
+                return -EINVAL;
+        }
+
+        lm93_write_byte(client,LM93_REG_PWM_CTL(nr,LM93_PWM_CTL2),ctl2);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
+                                show_pwm_enable, store_pwm_enable, 0);
+static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO,
+                                show_pwm_enable, store_pwm_enable, 1);
+
+static ssize_t show_pwm_freq(struct device *dev, struct device_attribute *attr,
+                                char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+        u8 ctl4;
+
+        ctl4 = data->block9[nr][LM93_PWM_CTL4];
+        return sprintf(buf,"%d\n",LM93_PWM_FREQ_FROM_REG(ctl4));
+}
+
+/* helper function - must grab data->update_lock before calling
+   pwm is 0-1, indicating pwm1-pwm2
+   this disables smart tach for all tach channels bound to the given pwm */
+static void lm93_disable_fan_smart_tach(struct i2c_client *client,
+        struct lm93_data *data, int pwm)
+{
+        int mapping = lm93_read_byte(client, LM93_REG_SF_TACH_TO_PWM);
+        int mask;
+
+        /* collapse the mapping into a mask of enable bits */
+        mapping = (mapping >> pwm) & 0x55;
+        mask = mapping & 0x01;
+        mask |= (mapping & 0x04) >> 1;
+        mask |= (mapping & 0x10) >> 2;
+        mask |= (mapping & 0x40) >> 3;
+
+        /* disable smart tach according to the mask */
+        data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
+        data->sfc2 &= ~mask;
+        lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
+}
+
+static ssize_t store_pwm_freq(struct device *dev,
+                                struct device_attribute *attr,
+                                const char *buf, size_t count)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+        u8 ctl4;
+
+        mutex_lock(&data->update_lock);
+        ctl4 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr,LM93_PWM_CTL4));
+        ctl4 = (ctl4 & 0xf8) | LM93_PWM_FREQ_TO_REG(val);
+        data->block9[nr][LM93_PWM_CTL4] = ctl4;
+        /* ctl4 == 0 -> 22.5KHz -> disable smart tach */
+        if (!ctl4)
+                lm93_disable_fan_smart_tach(client, data, nr);
+        lm93_write_byte(client, LM93_REG_PWM_CTL(nr,LM93_PWM_CTL4), ctl4);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(pwm1_freq, S_IWUSR | S_IRUGO,
+                          show_pwm_freq, store_pwm_freq, 0);
+static SENSOR_DEVICE_ATTR(pwm2_freq, S_IWUSR | S_IRUGO,
+                          show_pwm_freq, store_pwm_freq, 1);
+
+static ssize_t show_pwm_auto_channels(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+        return sprintf(buf,"%d\n",data->block9[nr][LM93_PWM_CTL1]);
+}
+
+static ssize_t store_pwm_auto_channels(struct device *dev,
+                                        struct device_attribute *attr,
+                                        const char *buf, size_t count)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+
+        mutex_lock(&data->update_lock);
+        data->block9[nr][LM93_PWM_CTL1] = SENSORS_LIMIT(val, 0, 255);
+        lm93_write_byte(client, LM93_REG_PWM_CTL(nr,LM93_PWM_CTL1),
+                                data->block9[nr][LM93_PWM_CTL1]);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(pwm1_auto_channels, S_IWUSR | S_IRUGO,
+                          show_pwm_auto_channels, store_pwm_auto_channels, 0);
+static SENSOR_DEVICE_ATTR(pwm2_auto_channels, S_IWUSR | S_IRUGO,
+                          show_pwm_auto_channels, store_pwm_auto_channels, 1);
+
+static ssize_t show_pwm_auto_spinup_min(struct device *dev,
+                                struct device_attribute *attr,char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+        u8 ctl3, ctl4;
+
+        ctl3 = data->block9[nr][LM93_PWM_CTL3];
+        ctl4 = data->block9[nr][LM93_PWM_CTL4];
+        return sprintf(buf,"%d\n",
+                       LM93_PWM_FROM_REG(ctl3 & 0x0f, (ctl4 & 0x07) ?
+                        LM93_PWM_MAP_LO_FREQ : LM93_PWM_MAP_HI_FREQ));
+}
+
+static ssize_t store_pwm_auto_spinup_min(struct device *dev,
+                                                struct device_attribute *attr,
+                                                const char *buf, size_t count)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+        u8 ctl3, ctl4;
+
+        mutex_lock(&data->update_lock);
+        ctl3 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr, LM93_PWM_CTL3));
+        ctl4 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr, LM93_PWM_CTL4));
+        ctl3 = (ctl3 & 0xf0) |  LM93_PWM_TO_REG(val, (ctl4 & 0x07) ?
+                        LM93_PWM_MAP_LO_FREQ :
+                        LM93_PWM_MAP_HI_FREQ);
+        data->block9[nr][LM93_PWM_CTL3] = ctl3;
+        lm93_write_byte(client,LM93_REG_PWM_CTL(nr, LM93_PWM_CTL3), ctl3);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(pwm1_auto_spinup_min, S_IWUSR | S_IRUGO,
+                          show_pwm_auto_spinup_min,
+                          store_pwm_auto_spinup_min, 0);
+static SENSOR_DEVICE_ATTR(pwm2_auto_spinup_min, S_IWUSR | S_IRUGO,
+                          show_pwm_auto_spinup_min,
+                          store_pwm_auto_spinup_min, 1);
+
+static ssize_t show_pwm_auto_spinup_time(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+        return sprintf(buf,"%d\n",LM93_SPINUP_TIME_FROM_REG(
+                                data->block9[nr][LM93_PWM_CTL3]));
+}
+
+static ssize_t store_pwm_auto_spinup_time(struct device *dev,
+                                                struct device_attribute *attr,
+                                                const char *buf, size_t count)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+        u8 ctl3;
+
+        mutex_lock(&data->update_lock);
+        ctl3 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr, LM93_PWM_CTL3));
+        ctl3 = (ctl3 & 0x1f) | (LM93_SPINUP_TIME_TO_REG(val) << 5 & 0xe0);
+        data->block9[nr][LM93_PWM_CTL3] = ctl3;
+        lm93_write_byte(client,LM93_REG_PWM_CTL(nr, LM93_PWM_CTL3), ctl3);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(pwm1_auto_spinup_time, S_IWUSR | S_IRUGO,
+                          show_pwm_auto_spinup_time,
+                          store_pwm_auto_spinup_time, 0);
+static SENSOR_DEVICE_ATTR(pwm2_auto_spinup_time, S_IWUSR | S_IRUGO,
+                          show_pwm_auto_spinup_time,
+                          store_pwm_auto_spinup_time, 1);
+
+static ssize_t show_pwm_auto_prochot_ramp(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct lm93_data *data = lm93_update_device(dev);
+        return sprintf(buf,"%d\n",
+                       LM93_RAMP_FROM_REG(data->pwm_ramp_ctl >> 4 & 0x0f));
+}
+
+static ssize_t store_pwm_auto_prochot_ramp(struct device *dev,
+                                                struct device_attribute *attr,
+                                                const char *buf, size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+        u8 ramp;
+
+        mutex_lock(&data->update_lock);
+        ramp = lm93_read_byte(client, LM93_REG_PWM_RAMP_CTL);
+        ramp = (ramp & 0x0f) | (LM93_RAMP_TO_REG(val) << 4 & 0xf0);
+        lm93_write_byte(client, LM93_REG_PWM_RAMP_CTL, ramp);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static DEVICE_ATTR(pwm_auto_prochot_ramp, S_IRUGO | S_IWUSR,
+                        show_pwm_auto_prochot_ramp,
+                        store_pwm_auto_prochot_ramp);
+
+static ssize_t show_pwm_auto_vrdhot_ramp(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct lm93_data *data = lm93_update_device(dev);
+        return sprintf(buf,"%d\n",
+                       LM93_RAMP_FROM_REG(data->pwm_ramp_ctl & 0x0f));
+}
+
+static ssize_t store_pwm_auto_vrdhot_ramp(struct device *dev,
+                                                struct device_attribute *attr,
+                                                const char *buf, size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+        u8 ramp;
+
+        mutex_lock(&data->update_lock);
+        ramp = lm93_read_byte(client, LM93_REG_PWM_RAMP_CTL);
+        ramp = (ramp & 0xf0) | (LM93_RAMP_TO_REG(val) & 0x0f);
+        lm93_write_byte(client, LM93_REG_PWM_RAMP_CTL, ramp);
+        mutex_unlock(&data->update_lock);
+        return 0;
+}
+
+static DEVICE_ATTR(pwm_auto_vrdhot_ramp, S_IRUGO | S_IWUSR,
+                        show_pwm_auto_vrdhot_ramp,
+                        store_pwm_auto_vrdhot_ramp);
+
+static ssize_t show_vid(struct device *dev, struct device_attribute *attr,
+                        char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+        return sprintf(buf,"%d\n",LM93_VID_FROM_REG(data->vid[nr]));
+}
+
+static SENSOR_DEVICE_ATTR(vid1, S_IRUGO, show_vid, NULL, 0);
+static SENSOR_DEVICE_ATTR(vid2, S_IRUGO, show_vid, NULL, 1);
+
+static ssize_t show_prochot(struct device *dev, struct device_attribute *attr,
+                                char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+        return sprintf(buf,"%d\n",data->block4[nr].cur);
+}
+
+static SENSOR_DEVICE_ATTR(prochot1, S_IRUGO, show_prochot, NULL, 0);
+static SENSOR_DEVICE_ATTR(prochot2, S_IRUGO, show_prochot, NULL, 1);
+
+static ssize_t show_prochot_avg(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+        return sprintf(buf,"%d\n",data->block4[nr].avg);
+}
+
+static SENSOR_DEVICE_ATTR(prochot1_avg, S_IRUGO, show_prochot_avg, NULL, 0);
+static SENSOR_DEVICE_ATTR(prochot2_avg, S_IRUGO, show_prochot_avg, NULL, 1);
+
+static ssize_t show_prochot_max(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+        return sprintf(buf,"%d\n",data->prochot_max[nr]);
+}
+
+static ssize_t store_prochot_max(struct device *dev,
+                                        struct device_attribute *attr,
+                                        const char *buf, size_t count)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+
+        mutex_lock(&data->update_lock);
+        data->prochot_max[nr] = LM93_PROCHOT_TO_REG(val);
+        lm93_write_byte(client, LM93_REG_PROCHOT_MAX(nr),
+                        data->prochot_max[nr]);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(prochot1_max, S_IWUSR | S_IRUGO,
+                          show_prochot_max, store_prochot_max, 0);
+static SENSOR_DEVICE_ATTR(prochot2_max, S_IWUSR | S_IRUGO,
+                          show_prochot_max, store_prochot_max, 1);
+
+static const u8 prochot_override_mask[] = { 0x80, 0x40 };
+
+static ssize_t show_prochot_override(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+        return sprintf(buf,"%d\n",
+                (data->prochot_override & prochot_override_mask[nr]) ? 1 : 0);
+}
+
+static ssize_t store_prochot_override(struct device *dev,
+                                        struct device_attribute *attr,
+                                        const char *buf, size_t count)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+
+        mutex_lock(&data->update_lock);
+        if (val)
+                data->prochot_override |= prochot_override_mask[nr];
+        else
+                data->prochot_override &= (~prochot_override_mask[nr]);
+        lm93_write_byte(client, LM93_REG_PROCHOT_OVERRIDE,
+                        data->prochot_override);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(prochot1_override, S_IWUSR | S_IRUGO,
+                          show_prochot_override, store_prochot_override, 0);
+static SENSOR_DEVICE_ATTR(prochot2_override, S_IWUSR | S_IRUGO,
+                          show_prochot_override, store_prochot_override, 1);
+
+static ssize_t show_prochot_interval(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+        u8 tmp;
+        if (nr==1)
+                tmp = (data->prochot_interval & 0xf0) >> 4;
+        else
+                tmp = data->prochot_interval & 0x0f;
+        return sprintf(buf,"%d\n",LM93_INTERVAL_FROM_REG(tmp));
+}
+
+static ssize_t store_prochot_interval(struct device *dev,
+                                        struct device_attribute *attr,
+                                        const char *buf, size_t count)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+        u8 tmp;
+
+        mutex_lock(&data->update_lock);
+        tmp = lm93_read_byte(client, LM93_REG_PROCHOT_INTERVAL);
+        if (nr==1)
+                tmp = (tmp & 0x0f) | (LM93_INTERVAL_TO_REG(val) << 4);
+        else
+                tmp = (tmp & 0xf0) | LM93_INTERVAL_TO_REG(val);
+        data->prochot_interval = tmp;
+        lm93_write_byte(client, LM93_REG_PROCHOT_INTERVAL, tmp);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(prochot1_interval, S_IWUSR | S_IRUGO,
+                          show_prochot_interval, store_prochot_interval, 0);
+static SENSOR_DEVICE_ATTR(prochot2_interval, S_IWUSR | S_IRUGO,
+                          show_prochot_interval, store_prochot_interval, 1);
+
+static ssize_t show_prochot_override_duty_cycle(struct device *dev,
+                                                struct device_attribute *attr,
+                                                char *buf)
+{
+        struct lm93_data *data = lm93_update_device(dev);
+        return sprintf(buf,"%d\n",data->prochot_override & 0x0f);
+}
+
+static ssize_t store_prochot_override_duty_cycle(struct device *dev,
+                                                struct device_attribute *attr,
+                                                const char *buf, size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+
+        mutex_lock(&data->update_lock);
+        data->prochot_override = (data->prochot_override & 0xf0) |
+                                        SENSORS_LIMIT(val, 0, 15);
+        lm93_write_byte(client, LM93_REG_PROCHOT_OVERRIDE,
+                        data->prochot_override);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static DEVICE_ATTR(prochot_override_duty_cycle, S_IRUGO | S_IWUSR,
+                        show_prochot_override_duty_cycle,
+                        store_prochot_override_duty_cycle);
+
+static ssize_t show_prochot_short(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct lm93_data *data = lm93_update_device(dev);
+        return sprintf(buf,"%d\n",(data->config & 0x10) ? 1 : 0);
+}
+
+static ssize_t store_prochot_short(struct device *dev,
+                                        struct device_attribute *attr,
+                                        const char *buf, size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm93_data *data = i2c_get_clientdata(client);
+        u32 val = simple_strtoul(buf, NULL, 10);
+
+        mutex_lock(&data->update_lock);
+        if (val)
+                data->config |= 0x10;
+        else
+                data->config &= ~0x10;
+        lm93_write_byte(client, LM93_REG_CONFIG, data->config);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static DEVICE_ATTR(prochot_short, S_IRUGO | S_IWUSR,
+                   show_prochot_short, store_prochot_short);
+
+static ssize_t show_vrdhot(struct device *dev, struct device_attribute *attr,
+                                char *buf)
+{
+        int nr = (to_sensor_dev_attr(attr))->index;
+        struct lm93_data *data = lm93_update_device(dev);
+        return sprintf(buf,"%d\n",
+                       data->block1.host_status_1 & (1 << (nr+4)) ? 1 : 0);
+}
+
+static SENSOR_DEVICE_ATTR(vrdhot1, S_IRUGO, show_vrdhot, NULL, 0);
+static SENSOR_DEVICE_ATTR(vrdhot2, S_IRUGO, show_vrdhot, NULL, 1);
+
+static ssize_t show_gpio(struct device *dev, struct device_attribute *attr,
+                                char *buf)
+{
+        struct lm93_data *data = lm93_update_device(dev);
+        return sprintf(buf,"%d\n",LM93_GPI_FROM_REG(data->gpi));
+}
+
+static DEVICE_ATTR(gpio, S_IRUGO, show_gpio, NULL);
+
+static ssize_t show_alarms(struct device *dev, struct device_attribute *attr,
+                                char *buf)
+{
+        struct lm93_data *data = lm93_update_device(dev);
+        return sprintf(buf,"%d\n",LM93_ALARMS_FROM_REG(data->block1));
+}
+
+static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
+
+static struct attribute *lm93_attrs[] = {
+        &sensor_dev_attr_in1_input.dev_attr.attr,
+        &sensor_dev_attr_in2_input.dev_attr.attr,
+        &sensor_dev_attr_in3_input.dev_attr.attr,
+        &sensor_dev_attr_in4_input.dev_attr.attr,
+        &sensor_dev_attr_in5_input.dev_attr.attr,
+        &sensor_dev_attr_in6_input.dev_attr.attr,
+        &sensor_dev_attr_in7_input.dev_attr.attr,
+        &sensor_dev_attr_in8_input.dev_attr.attr,
+        &sensor_dev_attr_in9_input.dev_attr.attr,
+        &sensor_dev_attr_in10_input.dev_attr.attr,
+        &sensor_dev_attr_in11_input.dev_attr.attr,
+        &sensor_dev_attr_in12_input.dev_attr.attr,
+        &sensor_dev_attr_in13_input.dev_attr.attr,
+        &sensor_dev_attr_in14_input.dev_attr.attr,
+        &sensor_dev_attr_in15_input.dev_attr.attr,
+        &sensor_dev_attr_in16_input.dev_attr.attr,
+        &sensor_dev_attr_in1_min.dev_attr.attr,
+        &sensor_dev_attr_in2_min.dev_attr.attr,
+        &sensor_dev_attr_in3_min.dev_attr.attr,
+        &sensor_dev_attr_in4_min.dev_attr.attr,
+        &sensor_dev_attr_in5_min.dev_attr.attr,
+        &sensor_dev_attr_in6_min.dev_attr.attr,
+        &sensor_dev_attr_in7_min.dev_attr.attr,
+        &sensor_dev_attr_in8_min.dev_attr.attr,
+        &sensor_dev_attr_in9_min.dev_attr.attr,
+        &sensor_dev_attr_in10_min.dev_attr.attr,
+        &sensor_dev_attr_in11_min.dev_attr.attr,
+        &sensor_dev_attr_in12_min.dev_attr.attr,
+        &sensor_dev_attr_in13_min.dev_attr.attr,
+        &sensor_dev_attr_in14_min.dev_attr.attr,
+        &sensor_dev_attr_in15_min.dev_attr.attr,
+        &sensor_dev_attr_in16_min.dev_attr.attr,
+        &sensor_dev_attr_in1_max.dev_attr.attr,
+        &sensor_dev_attr_in2_max.dev_attr.attr,
+        &sensor_dev_attr_in3_max.dev_attr.attr,
+        &sensor_dev_attr_in4_max.dev_attr.attr,
+        &sensor_dev_attr_in5_max.dev_attr.attr,
+        &sensor_dev_attr_in6_max.dev_attr.attr,
+        &sensor_dev_attr_in7_max.dev_attr.attr,
+        &sensor_dev_attr_in8_max.dev_attr.attr,
+        &sensor_dev_attr_in9_max.dev_attr.attr,
+        &sensor_dev_attr_in10_max.dev_attr.attr,
+        &sensor_dev_attr_in11_max.dev_attr.attr,
+        &sensor_dev_attr_in12_max.dev_attr.attr,
+        &sensor_dev_attr_in13_max.dev_attr.attr,
+        &sensor_dev_attr_in14_max.dev_attr.attr,
+        &sensor_dev_attr_in15_max.dev_attr.attr,
+        &sensor_dev_attr_in16_max.dev_attr.attr,
+        &sensor_dev_attr_temp1_input.dev_attr.attr,
+        &sensor_dev_attr_temp2_input.dev_attr.attr,
+        &sensor_dev_attr_temp3_input.dev_attr.attr,
+        &sensor_dev_attr_temp1_min.dev_attr.attr,
+        &sensor_dev_attr_temp2_min.dev_attr.attr,
+        &sensor_dev_attr_temp3_min.dev_attr.attr,
+        &sensor_dev_attr_temp1_max.dev_attr.attr,
+        &sensor_dev_attr_temp2_max.dev_attr.attr,
+        &sensor_dev_attr_temp3_max.dev_attr.attr,
+        &sensor_dev_attr_temp1_auto_base.dev_attr.attr,
+        &sensor_dev_attr_temp2_auto_base.dev_attr.attr,
+        &sensor_dev_attr_temp3_auto_base.dev_attr.attr,
+        &sensor_dev_attr_temp1_auto_boost.dev_attr.attr,
+        &sensor_dev_attr_temp2_auto_boost.dev_attr.attr,
+        &sensor_dev_attr_temp3_auto_boost.dev_attr.attr,
+        &sensor_dev_attr_temp1_auto_boost_hyst.dev_attr.attr,
+        &sensor_dev_attr_temp2_auto_boost_hyst.dev_attr.attr,
+        &sensor_dev_attr_temp3_auto_boost_hyst.dev_attr.attr,
+        &sensor_dev_attr_temp1_auto_offset1.dev_attr.attr,
+        &sensor_dev_attr_temp1_auto_offset2.dev_attr.attr,
+        &sensor_dev_attr_temp1_auto_offset3.dev_attr.attr,
+        &sensor_dev_attr_temp1_auto_offset4.dev_attr.attr,
+        &sensor_dev_attr_temp1_auto_offset5.dev_attr.attr,
+        &sensor_dev_attr_temp1_auto_offset6.dev_attr.attr,
+        &sensor_dev_attr_temp1_auto_offset7.dev_attr.attr,
+        &sensor_dev_attr_temp1_auto_offset8.dev_attr.attr,
+        &sensor_dev_attr_temp1_auto_offset9.dev_attr.attr,
+        &sensor_dev_attr_temp1_auto_offset10.dev_attr.attr,
+        &sensor_dev_attr_temp1_auto_offset11.dev_attr.attr,
+        &sensor_dev_attr_temp1_auto_offset12.dev_attr.attr,
+        &sensor_dev_attr_temp2_auto_offset1.dev_attr.attr,
+        &sensor_dev_attr_temp2_auto_offset2.dev_attr.attr,
+        &sensor_dev_attr_temp2_auto_offset3.dev_attr.attr,
+        &sensor_dev_attr_temp2_auto_offset4.dev_attr.attr,
+        &sensor_dev_attr_temp2_auto_offset5.dev_attr.attr,
+        &sensor_dev_attr_temp2_auto_offset6.dev_attr.attr,
+        &sensor_dev_attr_temp2_auto_offset7.dev_attr.attr,
+        &sensor_dev_attr_temp2_auto_offset8.dev_attr.attr,
+        &sensor_dev_attr_temp2_auto_offset9.dev_attr.attr,
+        &sensor_dev_attr_temp2_auto_offset10.dev_attr.attr,
+        &sensor_dev_attr_temp2_auto_offset11.dev_attr.attr,
+        &sensor_dev_attr_temp2_auto_offset12.dev_attr.attr,
+        &sensor_dev_attr_temp3_auto_offset1.dev_attr.attr,
+        &sensor_dev_attr_temp3_auto_offset2.dev_attr.attr,
+        &sensor_dev_attr_temp3_auto_offset3.dev_attr.attr,
+        &sensor_dev_attr_temp3_auto_offset4.dev_attr.attr,
+        &sensor_dev_attr_temp3_auto_offset5.dev_attr.attr,
+        &sensor_dev_attr_temp3_auto_offset6.dev_attr.attr,
+        &sensor_dev_attr_temp3_auto_offset7.dev_attr.attr,
+        &sensor_dev_attr_temp3_auto_offset8.dev_attr.attr,
+        &sensor_dev_attr_temp3_auto_offset9.dev_attr.attr,
+        &sensor_dev_attr_temp3_auto_offset10.dev_attr.attr,
+        &sensor_dev_attr_temp3_auto_offset11.dev_attr.attr,
+        &sensor_dev_attr_temp3_auto_offset12.dev_attr.attr,
+        &sensor_dev_attr_temp1_auto_pwm_min.dev_attr.attr,
+        &sensor_dev_attr_temp2_auto_pwm_min.dev_attr.attr,
+        &sensor_dev_attr_temp3_auto_pwm_min.dev_attr.attr,
+        &sensor_dev_attr_temp1_auto_offset_hyst.dev_attr.attr,
+        &sensor_dev_attr_temp2_auto_offset_hyst.dev_attr.attr,
+        &sensor_dev_attr_temp3_auto_offset_hyst.dev_attr.attr,
+        &sensor_dev_attr_fan1_input.dev_attr.attr,
+        &sensor_dev_attr_fan2_input.dev_attr.attr,
+        &sensor_dev_attr_fan3_input.dev_attr.attr,
+        &sensor_dev_attr_fan4_input.dev_attr.attr,
+        &sensor_dev_attr_fan1_min.dev_attr.attr,
+        &sensor_dev_attr_fan2_min.dev_attr.attr,
+        &sensor_dev_attr_fan3_min.dev_attr.attr,
+        &sensor_dev_attr_fan4_min.dev_attr.attr,
+        &sensor_dev_attr_fan1_smart_tach.dev_attr.attr,
+        &sensor_dev_attr_fan2_smart_tach.dev_attr.attr,
+        &sensor_dev_attr_fan3_smart_tach.dev_attr.attr,
+        &sensor_dev_attr_fan4_smart_tach.dev_attr.attr,
+        &sensor_dev_attr_pwm1.dev_attr.attr,
+        &sensor_dev_attr_pwm2.dev_attr.attr,
+        &sensor_dev_attr_pwm1_enable.dev_attr.attr,
+        &sensor_dev_attr_pwm2_enable.dev_attr.attr,
+        &sensor_dev_attr_pwm1_freq.dev_attr.attr,
+        &sensor_dev_attr_pwm2_freq.dev_attr.attr,
+        &sensor_dev_attr_pwm1_auto_channels.dev_attr.attr,
+        &sensor_dev_attr_pwm2_auto_channels.dev_attr.attr,
+        &sensor_dev_attr_pwm1_auto_spinup_min.dev_attr.attr,
+        &sensor_dev_attr_pwm2_auto_spinup_min.dev_attr.attr,
+        &sensor_dev_attr_pwm1_auto_spinup_time.dev_attr.attr,
+        &sensor_dev_attr_pwm2_auto_spinup_time.dev_attr.attr,
+        &dev_attr_pwm_auto_prochot_ramp.attr,
+        &dev_attr_pwm_auto_vrdhot_ramp.attr,
+        &sensor_dev_attr_vid1.dev_attr.attr,
+        &sensor_dev_attr_vid2.dev_attr.attr,
+        &sensor_dev_attr_prochot1.dev_attr.attr,
+        &sensor_dev_attr_prochot2.dev_attr.attr,
+        &sensor_dev_attr_prochot1_avg.dev_attr.attr,
+        &sensor_dev_attr_prochot2_avg.dev_attr.attr,
+        &sensor_dev_attr_prochot1_max.dev_attr.attr,
+        &sensor_dev_attr_prochot2_max.dev_attr.attr,
+        &sensor_dev_attr_prochot1_override.dev_attr.attr,
+        &sensor_dev_attr_prochot2_override.dev_attr.attr,
+        &sensor_dev_attr_prochot1_interval.dev_attr.attr,
+        &sensor_dev_attr_prochot2_interval.dev_attr.attr,
+        &dev_attr_prochot_override_duty_cycle.attr,
+        &dev_attr_prochot_short.attr,
+        &sensor_dev_attr_vrdhot1.dev_attr.attr,
+        &sensor_dev_attr_vrdhot2.dev_attr.attr,
+        &dev_attr_gpio.attr,
+        &dev_attr_alarms.attr,
+        NULL
+};
+
+static struct attribute_group lm93_attr_grp = {
+        .attrs = lm93_attrs,
+};
+
+static void lm93_init_client(struct i2c_client *client)
+{
+        int i;
+        u8 reg;
+
+        /* configure VID pin input thresholds */
+        reg = lm93_read_byte(client, LM93_REG_GPI_VID_CTL);
+        lm93_write_byte(client, LM93_REG_GPI_VID_CTL,
+                        reg | (vid_agtl ? 0x03 : 0x00));
+
+        if (init) {
+                /* enable #ALERT pin */
+                reg = lm93_read_byte(client, LM93_REG_CONFIG);
+                lm93_write_byte(client, LM93_REG_CONFIG, reg | 0x08);
+
+                /* enable ASF mode for BMC status registers */
+                reg = lm93_read_byte(client, LM93_REG_STATUS_CONTROL);
+                lm93_write_byte(client, LM93_REG_STATUS_CONTROL, reg | 0x02);
+
+                /* set sleep state to S0 */
+                lm93_write_byte(client, LM93_REG_SLEEP_CONTROL, 0);
+
+                /* unmask #VRDHOT and dynamic VCCP (if nec) error events */
+                reg = lm93_read_byte(client, LM93_REG_MISC_ERR_MASK);
+                reg &= ~0x03;
+                reg &= ~(vccp_limit_type[0] ? 0x10 : 0);
+                reg &= ~(vccp_limit_type[1] ? 0x20 : 0);
+                lm93_write_byte(client, LM93_REG_MISC_ERR_MASK, reg);
+        }
+
+        /* start monitoring */
+        reg = lm93_read_byte(client, LM93_REG_CONFIG);
+        lm93_write_byte(client, LM93_REG_CONFIG, reg | 0x01);
+
+        /* spin until ready */
+        for (i=0; i<20; i++) {
+                msleep(10);
+                if ((lm93_read_byte(client, LM93_REG_CONFIG) & 0x80) == 0x80)
+                        return;
+        }
+
+        dev_warn(&client->dev,"timed out waiting for sensor "
+                 "chip to signal ready!\n");
+}
+
+static int lm93_detect(struct i2c_adapter *adapter, int address, int kind)
+{
+        struct lm93_data *data;
+        struct i2c_client *client;
+
+        int err = -ENODEV, func;
+        void (*update)(struct lm93_data *, struct i2c_client *);
+
+        /* choose update routine based on bus capabilities */
+        func = i2c_get_functionality(adapter);
+        if ( ((LM93_SMBUS_FUNC_FULL & func) == LM93_SMBUS_FUNC_FULL) &&
+                        (!disable_block) ) {
+                dev_dbg(&adapter->dev,"using SMBus block data transactions\n");
+                update = lm93_update_client_full;
+        } else if ((LM93_SMBUS_FUNC_MIN & func) == LM93_SMBUS_FUNC_MIN) {
+                dev_dbg(&adapter->dev,"disabled SMBus block data "
+                        "transactions\n");
+                update = lm93_update_client_min;
+        } else {
+                dev_dbg(&adapter->dev,"detect failed, "
+                        "smbus byte and/or word data not supported!\n");
+                goto err_out;
+        }
+
+        /* OK. For now, we presume we have a valid client. We now create the
+           client structure, even though we cannot fill it completely yet.
+           But it allows us to access lm78_{read,write}_value. */
+
+        if ( !(data = kzalloc(sizeof(struct lm93_data), GFP_KERNEL))) {
+                dev_dbg(&adapter->dev,"out of memory!\n");
+                err = -ENOMEM;
+                goto err_out;
+        }
+
+        client = &data->client;
+        i2c_set_clientdata(client, data);
+        client->addr = address;
+        client->adapter = adapter;
+        client->driver = &lm93_driver;
+
+        /* detection */
+        if (kind < 0) {
+                int mfr = lm93_read_byte(client, LM93_REG_MFR_ID);
+
+                if (mfr != 0x01) {
+                        dev_dbg(&adapter->dev,"detect failed, "
+                                "bad manufacturer id 0x%02x!\n", mfr);
+                        goto err_free;
+                }
+        }
+
+        if (kind <= 0) {
+                int ver = lm93_read_byte(client, LM93_REG_VER);
+
+                if ((ver == LM93_MFR_ID) || (ver == LM93_MFR_ID_PROTOTYPE)) {
+                        kind = lm93;
+                } else {
+                        dev_dbg(&adapter->dev,"detect failed, "
+                                "bad version id 0x%02x!\n", ver);
+                        if (kind == 0)
+                                dev_dbg(&adapter->dev,
+                                        "(ignored 'force' parameter)\n");
+                        goto err_free;
+                }
+        }
+
+        /* fill in remaining client fields */
+        strlcpy(client->name, "lm93", I2C_NAME_SIZE);
+        dev_dbg(&adapter->dev,"loading %s at %d,0x%02x\n",
+                client->name, i2c_adapter_id(client->adapter),
+                client->addr);
+
+        /* housekeeping */
+        data->valid = 0;
+        data->update = update;
+        mutex_init(&data->update_lock);
+
+        /* tell the I2C layer a new client has arrived */
+        if ((err = i2c_attach_client(client)))
+                goto err_free;
+
+        /* initialize the chip */
+        lm93_init_client(client);
+
+        err = sysfs_create_group(&client->dev.kobj, &lm93_attr_grp);
+        if (err)
+                goto err_detach;
+
+        /* Register hwmon driver class */
+        data->class_dev = hwmon_device_register(&client->dev);
+        if ( !IS_ERR(data->class_dev))
+                return 0;
+
+        err = PTR_ERR(data->class_dev);
+        dev_err(&client->dev, "error registering hwmon device.\n");
+        sysfs_remove_group(&client->dev.kobj, &lm93_attr_grp);
+err_detach:
+        i2c_detach_client(client);
+err_free:
+        kfree(data);
+err_out:
+        return err;
+}
+
+/* This function is called when:
+     * lm93_driver is inserted (when this module is loaded), for each
+       available adapter
+     * when a new adapter is inserted (and lm93_driver is still present) */
+static int lm93_attach_adapter(struct i2c_adapter *adapter)
+{
+        return i2c_probe(adapter, &addr_data, lm93_detect);
+}
+
+static int lm93_detach_client(struct i2c_client *client)
+{
+        struct lm93_data *data = i2c_get_clientdata(client);
+        int err = 0;
+
+        hwmon_device_unregister(data->class_dev);
+        sysfs_remove_group(&client->dev.kobj, &lm93_attr_grp);
+
+        err = i2c_detach_client(client);
+        if (!err)
+                kfree(data);
+        return err;
+}
+
+static struct i2c_driver lm93_driver = {
+        .driver = {
+                .name   = "lm93",
+        },
+        .attach_adapter = lm93_attach_adapter,
+        .detach_client  = lm93_detach_client,
+};
+
+static int __init lm93_init(void)
+{
+        return i2c_add_driver(&lm93_driver);
+}
+
+static void __exit lm93_exit(void)
+{
+        i2c_del_driver(&lm93_driver);
+}
+
+MODULE_AUTHOR("Mark M. Hoffman <mhoffman@lightlink.com>, "
+                "Hans J. Koch <hjk@linutronix.de");
+MODULE_DESCRIPTION("LM93 driver");
+MODULE_LICENSE("GPL");
+
+module_init(lm93_init);
+module_exit(lm93_exit);
diff --git a/drivers/hwmon/pc87360.c b/drivers/hwmon/pc87360.c
index c8a21be09d87..cb72526c346a 100644
--- a/drivers/hwmon/pc87360.c
+++ b/drivers/hwmon/pc87360.c
@@ -1,7 +1,7 @@
 /*
  *  pc87360.c - Part of lm_sensors, Linux kernel modules
  *              for hardware monitoring
- *  Copyright (C) 2004 Jean Delvare <khali@linux-fr.org>
+ *  Copyright (C) 2004, 2007 Jean Delvare <khali@linux-fr.org>
  *
  *  Copied from smsc47m1.c:
  *  Copyright (C) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
@@ -37,8 +37,7 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/jiffies.h>
-#include <linux/i2c.h>
-#include <linux/i2c-isa.h>
+#include <linux/platform_device.h>
 #include <linux/hwmon.h>
 #include <linux/hwmon-sysfs.h>
 #include <linux/hwmon-vid.h>
@@ -47,12 +46,10 @@
 #include <asm/io.h>
 
 static u8 devid;
-static unsigned short address;
+static struct platform_device *pdev;
 static unsigned short extra_isa[3];
 static u8 confreg[4];
 
-enum chips { any_chip, pc87360, pc87363, pc87364, pc87365, pc87366 };
-
 static int init = 1;
 module_param(init, int, 0);
 MODULE_PARM_DESC(init,
@@ -178,11 +175,11 @@ static inline u8 PWM_TO_REG(int val, int inv)
                                          ((val) + 500) / 1000)
 
 /*
- * Client data (each client gets its own)
+ * Device data
  */
 
 struct pc87360_data {
-        struct i2c_client client;
+        const char *name;
         struct class_device *class_dev;
         struct mutex lock;
         struct mutex update_lock;
@@ -222,27 +219,28 @@ struct pc87360_data {
  * Functions declaration
  */
 
-static int pc87360_detect(struct i2c_adapter *adapter);
-static int pc87360_detach_client(struct i2c_client *client);
+static int pc87360_probe(struct platform_device *pdev);
+static int pc87360_remove(struct platform_device *pdev);
 
 static int pc87360_read_value(struct pc87360_data *data, u8 ldi, u8 bank,
                               u8 reg);
 static void pc87360_write_value(struct pc87360_data *data, u8 ldi, u8 bank,
                                 u8 reg, u8 value);
-static void pc87360_init_client(struct i2c_client *client, int use_thermistors);
+static void pc87360_init_device(struct platform_device *pdev,
+                                int use_thermistors);
 static struct pc87360_data *pc87360_update_device(struct device *dev);
 
 /*
- * Driver data (common to all clients)
+ * Driver data
  */
 
-static struct i2c_driver pc87360_driver = {
+static struct platform_driver pc87360_driver = {
         .driver = {
                 .owner  = THIS_MODULE,
                 .name   = "pc87360",
         },
-        .attach_adapter = pc87360_detect,
-        .detach_client  = pc87360_detach_client,
+        .probe          = pc87360_probe,
+        .remove         = __devexit_p(pc87360_remove),
 };
 
 /*
@@ -281,8 +279,7 @@ static ssize_t set_fan_min(struct device *dev, struct device_attribute *devattr,
         size_t count)
 {
         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
-        struct i2c_client *client = to_i2c_client(dev);
-        struct pc87360_data *data = i2c_get_clientdata(client);
+        struct pc87360_data *data = dev_get_drvdata(dev);
         long fan_min = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
@@ -347,8 +344,7 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr, con
         size_t count)
 {
         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
-        struct i2c_client *client = to_i2c_client(dev);
-        struct pc87360_data *data = i2c_get_clientdata(client);
+        struct pc87360_data *data = dev_get_drvdata(dev);
         long val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
@@ -410,8 +406,7 @@ static ssize_t set_in_min(struct device *dev, struct device_attribute *devattr,
         size_t count)
 {
         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
-        struct i2c_client *client = to_i2c_client(dev);
-        struct pc87360_data *data = i2c_get_clientdata(client);
+        struct pc87360_data *data = dev_get_drvdata(dev);
         long val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
@@ -425,8 +420,7 @@ static ssize_t set_in_max(struct device *dev, struct device_attribute *devattr,
         size_t count)
 {
         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
-        struct i2c_client *client = to_i2c_client(dev);
-        struct pc87360_data *data = i2c_get_clientdata(client);
+        struct pc87360_data *data = dev_get_drvdata(dev);
         long val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
@@ -511,8 +505,7 @@ static ssize_t show_vrm(struct device *dev, struct device_attribute *attr, char
 }
 static ssize_t set_vrm(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct pc87360_data *data = i2c_get_clientdata(client);
+        struct pc87360_data *data = dev_get_drvdata(dev);
         data->vrm = simple_strtoul(buf, NULL, 10);
         return count;
 }
@@ -584,8 +577,7 @@ static ssize_t set_therm_min(struct device *dev, struct device_attribute *devatt
         size_t count)
 {
         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
-        struct i2c_client *client = to_i2c_client(dev);
-        struct pc87360_data *data = i2c_get_clientdata(client);
+        struct pc87360_data *data = dev_get_drvdata(dev);
         long val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
@@ -599,8 +591,7 @@ static ssize_t set_therm_max(struct device *dev, struct device_attribute *devatt
         size_t count)
 {
         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
-        struct i2c_client *client = to_i2c_client(dev);
-        struct pc87360_data *data = i2c_get_clientdata(client);
+        struct pc87360_data *data = dev_get_drvdata(dev);
         long val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
@@ -614,8 +605,7 @@ static ssize_t set_therm_crit(struct device *dev, struct device_attribute *devat
         size_t count)
 {
         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
-        struct i2c_client *client = to_i2c_client(dev);
-        struct pc87360_data *data = i2c_get_clientdata(client);
+        struct pc87360_data *data = dev_get_drvdata(dev);
         long val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
@@ -715,8 +705,7 @@ static ssize_t set_temp_min(struct device *dev, struct device_attribute *devattr
         size_t count)
 {
         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
-        struct i2c_client *client = to_i2c_client(dev);
-        struct pc87360_data *data = i2c_get_clientdata(client);
+        struct pc87360_data *data = dev_get_drvdata(dev);
         long val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
@@ -730,8 +719,7 @@ static ssize_t set_temp_max(struct device *dev, struct device_attribute *devattr
         size_t count)
 {
         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
-        struct i2c_client *client = to_i2c_client(dev);
-        struct pc87360_data *data = i2c_get_clientdata(client);
+        struct pc87360_data *data = dev_get_drvdata(dev);
         long val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
@@ -745,8 +733,7 @@ static ssize_t set_temp_crit(struct device *dev, struct device_attribute *devatt
         size_t count)
 {
         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
-        struct i2c_client *client = to_i2c_client(dev);
-        struct pc87360_data *data = i2c_get_clientdata(client);
+        struct pc87360_data *data = dev_get_drvdata(dev);
         long val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
@@ -818,6 +805,14 @@ static const struct attribute_group pc8736x_temp_group = {
         .attrs = pc8736x_temp_attr_array,
 };
 
+static ssize_t show_name(struct device *dev, struct device_attribute
+                         *devattr, char *buf)
+{
+        struct pc87360_data *data = dev_get_drvdata(dev);
+        return sprintf(buf, "%s\n", data->name);
+}
+static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
+
 /*
  * Device detection, registration and update
  */
@@ -912,28 +907,18 @@ static int __init pc87360_find(int sioaddr, u8 *devid, unsigned short *addresses
         return 0;
 }
 
-static int pc87360_detect(struct i2c_adapter *adapter)
+static int __devinit pc87360_probe(struct platform_device *pdev)
 {
         int i;
-        struct i2c_client *client;
         struct pc87360_data *data;
         int err = 0;
         const char *name = "pc87360";
         int use_thermistors = 0;
-        struct device *dev;
+        struct device *dev = &pdev->dev;
 
         if (!(data = kzalloc(sizeof(struct pc87360_data), GFP_KERNEL)))
                 return -ENOMEM;
 
-        client = &data->client;
-        dev = &client->dev;
-        i2c_set_clientdata(client, data);
-        client->addr = address;
-        mutex_init(&data->lock);
-        client->adapter = adapter;
-        client->driver = &pc87360_driver;
-        client->flags = 0;
-
         data->fannr = 2;
         data->innr = 0;
         data->tempnr = 0;
@@ -960,15 +945,17 @@ static int pc87360_detect(struct i2c_adapter *adapter)
                 break;
         }
 
-        strlcpy(client->name, name, sizeof(client->name));
+        data->name = name;
         data->valid = 0;
+        mutex_init(&data->lock);
         mutex_init(&data->update_lock);
+        platform_set_drvdata(pdev, data);
 
         for (i = 0; i < 3; i++) {
                 if (((data->address[i] = extra_isa[i]))
                  && !request_region(extra_isa[i], PC87360_EXTENT,
                                     pc87360_driver.driver.name)) {
-                        dev_err(&client->dev, "Region 0x%x-0x%x already "
+                        dev_err(dev, "Region 0x%x-0x%x already "
                                 "in use!\n", extra_isa[i],
                                 extra_isa[i]+PC87360_EXTENT-1);
                         for (i--; i >= 0; i--)
@@ -982,9 +969,6 @@ static int pc87360_detect(struct i2c_adapter *adapter)
         if (data->fannr)
                 data->fan_conf = confreg[0] | (confreg[1] << 8);
 
-        if ((err = i2c_attach_client(client)))
-                goto ERROR2;
-
         /* Use the correct reference voltage
            Unless both the VLM and the TMS logical devices agree to
            use an external Vref, the internal one is used. */
@@ -996,7 +980,7 @@ static int pc87360_detect(struct i2c_adapter *adapter)
                                                 PC87365_REG_TEMP_CONFIG);
                 }
                 data->in_vref = (i&0x02) ? 3025 : 2966;
-                dev_dbg(&client->dev, "Using %s reference voltage\n",
+                dev_dbg(dev, "Using %s reference voltage\n",
                         (i&0x02) ? "external" : "internal");
 
                 data->vid_conf = confreg[3];
@@ -1015,18 +999,18 @@ static int pc87360_detect(struct i2c_adapter *adapter)
                 if (devid == 0xe9 && data->address[1]) /* PC87366 */
                         use_thermistors = confreg[2] & 0x40;
 
-                pc87360_init_client(client, use_thermistors);
+                pc87360_init_device(pdev, use_thermistors);
         }
 
         /* Register all-or-nothing sysfs groups */
 
         if (data->innr &&
-            (err = sysfs_create_group(&client->dev.kobj,
+            (err = sysfs_create_group(&dev->kobj,
                                       &pc8736x_vin_group)))
                 goto ERROR3;
 
         if (data->innr == 14 &&
-            (err = sysfs_create_group(&client->dev.kobj,
+            (err = sysfs_create_group(&dev->kobj,
                                       &pc8736x_therm_group)))
                 goto ERROR3;
 
@@ -1067,7 +1051,10 @@ static int pc87360_detect(struct i2c_adapter *adapter)
                         goto ERROR3;
         }
 
-        data->class_dev = hwmon_device_register(&client->dev);
+        if ((err = device_create_file(dev, &dev_attr_name)))
+                goto ERROR3;
+
+        data->class_dev = hwmon_device_register(dev);
         if (IS_ERR(data->class_dev)) {
                 err = PTR_ERR(data->class_dev);
                 goto ERROR3;
@@ -1075,14 +1062,12 @@ static int pc87360_detect(struct i2c_adapter *adapter)
         return 0;
 
 ERROR3:
+        device_remove_file(dev, &dev_attr_name);
         /* can still remove groups whose members were added individually */
-        sysfs_remove_group(&client->dev.kobj, &pc8736x_temp_group);
-        sysfs_remove_group(&client->dev.kobj, &pc8736x_fan_group);
-        sysfs_remove_group(&client->dev.kobj, &pc8736x_therm_group);
-        sysfs_remove_group(&client->dev.kobj, &pc8736x_vin_group);
-
-        i2c_detach_client(client);
-ERROR2:
+        sysfs_remove_group(&dev->kobj, &pc8736x_temp_group);
+        sysfs_remove_group(&dev->kobj, &pc8736x_fan_group);
+        sysfs_remove_group(&dev->kobj, &pc8736x_therm_group);
+        sysfs_remove_group(&dev->kobj, &pc8736x_vin_group);
         for (i = 0; i < 3; i++) {
                 if (data->address[i]) {
                         release_region(data->address[i], PC87360_EXTENT);
@@ -1093,20 +1078,18 @@ ERROR1:
         return err;
 }
 
-static int pc87360_detach_client(struct i2c_client *client)
+static int __devexit pc87360_remove(struct platform_device *pdev)
 {
-        struct pc87360_data *data = i2c_get_clientdata(client);
+        struct pc87360_data *data = platform_get_drvdata(pdev);
         int i;
 
         hwmon_device_unregister(data->class_dev);
 
-        sysfs_remove_group(&client->dev.kobj, &pc8736x_temp_group);
-        sysfs_remove_group(&client->dev.kobj, &pc8736x_fan_group);
-        sysfs_remove_group(&client->dev.kobj, &pc8736x_therm_group);
-        sysfs_remove_group(&client->dev.kobj, &pc8736x_vin_group);
-
-        if ((i = i2c_detach_client(client)))
-                return i;
+        device_remove_file(&pdev->dev, &dev_attr_name);
+        sysfs_remove_group(&pdev->dev.kobj, &pc8736x_temp_group);
+        sysfs_remove_group(&pdev->dev.kobj, &pc8736x_fan_group);
+        sysfs_remove_group(&pdev->dev.kobj, &pc8736x_therm_group);
+        sysfs_remove_group(&pdev->dev.kobj, &pc8736x_vin_group);
 
         for (i = 0; i < 3; i++) {
                 if (data->address[i]) {
@@ -1144,9 +1127,10 @@ static void pc87360_write_value(struct pc87360_data *data, u8 ldi, u8 bank,
         mutex_unlock(&(data->lock));
 }
 
-static void pc87360_init_client(struct i2c_client *client, int use_thermistors)
+static void pc87360_init_device(struct platform_device *pdev,
+                                int use_thermistors)
 {
-        struct pc87360_data *data = i2c_get_clientdata(client);
+        struct pc87360_data *data = platform_get_drvdata(pdev);
         int i, nr;
         const u8 init_in[14] = { 2, 2, 2, 2, 2, 2, 2, 1, 1, 3, 1, 2, 2, 2 };
         const u8 init_temp[3] = { 2, 2, 1 };
@@ -1155,7 +1139,7 @@ static void pc87360_init_client(struct i2c_client *client, int use_thermistors)
         if (init >= 2 && data->innr) {
                 reg = pc87360_read_value(data, LD_IN, NO_BANK,
                                          PC87365_REG_IN_CONVRATE);
-                dev_info(&client->dev, "VLM conversion set to "
+                dev_info(&pdev->dev, "VLM conversion set to "
                          "1s period, 160us delay\n");
                 pc87360_write_value(data, LD_IN, NO_BANK,
                                     PC87365_REG_IN_CONVRATE,
@@ -1169,7 +1153,7 @@ static void pc87360_init_client(struct i2c_client *client, int use_thermistors)
                         reg = pc87360_read_value(data, LD_IN, i,
                                                  PC87365_REG_IN_STATUS);
                         if (!(reg & 0x01)) {
-                                dev_dbg(&client->dev, "Forcibly "
+                                dev_dbg(&pdev->dev, "Forcibly "
                                         "enabling in%d\n", i);
                                 pc87360_write_value(data, LD_IN, i,
                                                     PC87365_REG_IN_STATUS,
@@ -1193,7 +1177,7 @@ static void pc87360_init_client(struct i2c_client *client, int use_thermistors)
                         reg = pc87360_read_value(data, LD_TEMP, i,
                                                  PC87365_REG_TEMP_STATUS);
                         if (!(reg & 0x01)) {
-                                dev_dbg(&client->dev, "Forcibly "
+                                dev_dbg(&pdev->dev, "Forcibly "
                                         "enabling temp%d\n", i+1);
                                 pc87360_write_value(data, LD_TEMP, i,
                                                     PC87365_REG_TEMP_STATUS,
@@ -1210,7 +1194,7 @@ static void pc87360_init_client(struct i2c_client *client, int use_thermistors)
                                 reg = pc87360_read_value(data, LD_TEMP,
                                       (i-11)/2, PC87365_REG_TEMP_STATUS);
                                 if (reg & 0x01) {
-                                        dev_dbg(&client->dev, "Skipping "
+                                        dev_dbg(&pdev->dev, "Skipping "
                                                 "temp%d, pin already in use "
                                                 "by temp%d\n", i-7, (i-11)/2);
                                         continue;
@@ -1220,7 +1204,7 @@ static void pc87360_init_client(struct i2c_client *client, int use_thermistors)
                                 reg = pc87360_read_value(data, LD_IN, i,
                                                          PC87365_REG_IN_STATUS);
                                 if (!(reg & 0x01)) {
-                                        dev_dbg(&client->dev, "Forcibly "
+                                        dev_dbg(&pdev->dev, "Forcibly "
                                                 "enabling temp%d\n", i-7);
                                         pc87360_write_value(data, LD_IN, i,
                                                 PC87365_REG_TEMP_STATUS,
@@ -1234,7 +1218,7 @@ static void pc87360_init_client(struct i2c_client *client, int use_thermistors)
                 reg = pc87360_read_value(data, LD_IN, NO_BANK,
                                          PC87365_REG_IN_CONFIG);
                 if (reg & 0x01) {
-                        dev_dbg(&client->dev, "Forcibly "
+                        dev_dbg(&pdev->dev, "Forcibly "
                                 "enabling monitoring (VLM)\n");
                         pc87360_write_value(data, LD_IN, NO_BANK,
                                             PC87365_REG_IN_CONFIG,
@@ -1246,7 +1230,7 @@ static void pc87360_init_client(struct i2c_client *client, int use_thermistors)
                 reg = pc87360_read_value(data, LD_TEMP, NO_BANK,
                                          PC87365_REG_TEMP_CONFIG);
                 if (reg & 0x01) {
-                        dev_dbg(&client->dev, "Forcibly enabling "
+                        dev_dbg(&pdev->dev, "Forcibly enabling "
                                 "monitoring (TMS)\n");
                         pc87360_write_value(data, LD_TEMP, NO_BANK,
                                             PC87365_REG_TEMP_CONFIG,
@@ -1268,9 +1252,9 @@ static void pc87360_init_client(struct i2c_client *client, int use_thermistors)
         }
 }
 
-static void pc87360_autodiv(struct i2c_client *client, int nr)
+static void pc87360_autodiv(struct device *dev, int nr)
 {
-        struct pc87360_data *data = i2c_get_clientdata(client);
+        struct pc87360_data *data = dev_get_drvdata(dev);
         u8 old_min = data->fan_min[nr];
 
         /* Increase clock divider if needed and possible */
@@ -1280,7 +1264,7 @@ static void pc87360_autodiv(struct i2c_client *client, int nr)
                         data->fan_status[nr] += 0x20;
                         data->fan_min[nr] >>= 1;
                         data->fan[nr] >>= 1;
-                        dev_dbg(&client->dev, "Increasing "
+                        dev_dbg(dev, "Increasing "
                                 "clock divider to %d for fan %d\n",
                                 FAN_DIV_FROM_REG(data->fan_status[nr]), nr+1);
                 }
@@ -1292,7 +1276,7 @@ static void pc87360_autodiv(struct i2c_client *client, int nr)
                         data->fan_status[nr] -= 0x20;
                         data->fan_min[nr] <<= 1;
                         data->fan[nr] <<= 1;
-                        dev_dbg(&client->dev, "Decreasing "
+                        dev_dbg(dev, "Decreasing "
                                 "clock divider to %d for fan %d\n",
                                 FAN_DIV_FROM_REG(data->fan_status[nr]),
                                 nr+1);
@@ -1309,14 +1293,13 @@ static void pc87360_autodiv(struct i2c_client *client, int nr)
 
 static struct pc87360_data *pc87360_update_device(struct device *dev)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct pc87360_data *data = i2c_get_clientdata(client);
+        struct pc87360_data *data = dev_get_drvdata(dev);
         u8 i;
 
         mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
-                dev_dbg(&client->dev, "Data update\n");
+                dev_dbg(dev, "Data update\n");
 
                 /* Fans */
                 for (i = 0; i < data->fannr; i++) {
@@ -1330,7 +1313,7 @@ static struct pc87360_data *pc87360_update_device(struct device *dev)
                                                    LD_FAN, NO_BANK,
                                                    PC87360_REG_FAN_MIN(i));
                                 /* Change clock divider if needed */
-                                pc87360_autodiv(client, i);
+                                pc87360_autodiv(dev, i);
                                 /* Clear bits and write new divider */
                                 pc87360_write_value(data, LD_FAN, NO_BANK,
                                                     PC87360_REG_FAN_STATUS(i),
@@ -1418,9 +1401,53 @@ static struct pc87360_data *pc87360_update_device(struct device *dev)
         return data;
 }
 
+static int __init pc87360_device_add(unsigned short address)
+{
+        struct resource res = {
+                .name   = "pc87360",
+                .flags  = IORESOURCE_IO,
+        };
+        int err, i;
+
+        pdev = platform_device_alloc("pc87360", address);
+        if (!pdev) {
+                err = -ENOMEM;
+                printk(KERN_ERR "pc87360: Device allocation failed\n");
+                goto exit;
+        }
+
+        for (i = 0; i < 3; i++) {
+                if (!extra_isa[i])
+                        continue;
+                res.start = extra_isa[i];
+                res.end = extra_isa[i] + PC87360_EXTENT - 1;
+                err = platform_device_add_resources(pdev, &res, 1);
+                if (err) {
+                        printk(KERN_ERR "pc87360: Device resource[%d] "
+                               "addition failed (%d)\n", i, err);
+                        goto exit_device_put;
+                }
+        }
+
+        err = platform_device_add(pdev);
+        if (err) {
+                printk(KERN_ERR "pc87360: Device addition failed (%d)\n",
+                       err);
+                goto exit_device_put;
+        }
+
+        return 0;
+
+exit_device_put:
+        platform_device_put(pdev);
+exit:
+        return err;
+}
+
 static int __init pc87360_init(void)
 {
-        int i;
+        int err, i;
+        unsigned short address = 0;
 
         if (pc87360_find(0x2e, &devid, extra_isa)
          && pc87360_find(0x4e, &devid, extra_isa)) {
@@ -1443,12 +1470,27 @@ static int __init pc87360_init(void)
                 return -ENODEV;
         }
 
-        return i2c_isa_add_driver(&pc87360_driver);
+        err = platform_driver_register(&pc87360_driver);
+        if (err)
+                goto exit;
+
+        /* Sets global pdev as a side effect */
+        err = pc87360_device_add(address);
+        if (err)
+                goto exit_driver;
+
+        return 0;
+
+ exit_driver:
+        platform_driver_unregister(&pc87360_driver);
+ exit:
+        return err;
 }
 
 static void __exit pc87360_exit(void)
 {
-        i2c_isa_del_driver(&pc87360_driver);
+        platform_device_unregister(pdev);
+        platform_driver_unregister(&pc87360_driver);
 }
 
 
diff --git a/drivers/hwmon/pc87427.c b/drivers/hwmon/pc87427.c
index 29354fa26f81..2915bc4ad0d5 100644
--- a/drivers/hwmon/pc87427.c
+++ b/drivers/hwmon/pc87427.c
@@ -484,7 +484,6 @@ static int __devexit pc87427_remove(struct platform_device *pdev)
         struct resource *res;
         int i;
 
-        platform_set_drvdata(pdev, NULL);
         hwmon_device_unregister(data->class_dev);
         device_remove_file(&pdev->dev, &dev_attr_name);
         for (i = 0; i < 8; i++) {
@@ -492,6 +491,7 @@ static int __devexit pc87427_remove(struct platform_device *pdev)
                         continue;
                 sysfs_remove_group(&pdev->dev.kobj, &pc87427_group_fan[i]);
         }
+        platform_set_drvdata(pdev, NULL);
         kfree(data);
 
         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
diff --git a/drivers/hwmon/sis5595.c b/drivers/hwmon/sis5595.c
index 3f400263fc0f..83321b28cf0e 100644
--- a/drivers/hwmon/sis5595.c
+++ b/drivers/hwmon/sis5595.c
@@ -54,9 +54,9 @@
 #include <linux/slab.h>
 #include <linux/ioport.h>
 #include <linux/pci.h>
-#include <linux/i2c.h>
-#include <linux/i2c-isa.h>
+#include <linux/platform_device.h>
 #include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
 #include <linux/err.h>
 #include <linux/init.h>
 #include <linux/jiffies.h>
@@ -72,17 +72,13 @@ module_param(force_addr, ushort, 0);
 MODULE_PARM_DESC(force_addr,
                  "Initialize the base address of the sensors");
 
-/* Device address
-   Note that we can't determine the ISA address until we have initialized
-   our module */
-static unsigned short address;
+static struct platform_device *pdev;
 
 /* Many SIS5595 constants specified below */
 
 /* Length of ISA address segment */
 #define SIS5595_EXTENT 8
 /* PCI Config Registers */
-#define SIS5595_REVISION_REG 0x08
 #define SIS5595_BASE_REG 0x68
 #define SIS5595_PIN_REG 0x7A
 #define SIS5595_ENABLE_REG 0x7B
@@ -165,7 +161,8 @@ static inline u8 DIV_TO_REG(int val)
 /* For each registered chip, we need to keep some data in memory.
    The structure is dynamically allocated. */
 struct sis5595_data {
-        struct i2c_client client;
+        unsigned short addr;
+        const char *name;
         struct class_device *class_dev;
         struct mutex lock;
 
@@ -189,102 +186,88 @@ struct sis5595_data {
 
 static struct pci_dev *s_bridge;        /* pointer to the (only) sis5595 */
 
-static int sis5595_detect(struct i2c_adapter *adapter);
-static int sis5595_detach_client(struct i2c_client *client);
+static int sis5595_probe(struct platform_device *pdev);
+static int sis5595_remove(struct platform_device *pdev);
 
-static int sis5595_read_value(struct i2c_client *client, u8 reg);
-static int sis5595_write_value(struct i2c_client *client, u8 reg, u8 value);
+static int sis5595_read_value(struct sis5595_data *data, u8 reg);
+static void sis5595_write_value(struct sis5595_data *data, u8 reg, u8 value);
 static struct sis5595_data *sis5595_update_device(struct device *dev);
-static void sis5595_init_client(struct i2c_client *client);
+static void sis5595_init_device(struct sis5595_data *data);
 
-static struct i2c_driver sis5595_driver = {
+static struct platform_driver sis5595_driver = {
         .driver = {
                 .owner  = THIS_MODULE,
                 .name   = "sis5595",
         },
-        .attach_adapter = sis5595_detect,
-        .detach_client  = sis5595_detach_client,
+        .probe          = sis5595_probe,
+        .remove         = __devexit_p(sis5595_remove),
 };
 
 /* 4 Voltages */
-static ssize_t show_in(struct device *dev, char *buf, int nr)
+static ssize_t show_in(struct device *dev, struct device_attribute *da,
+                       char *buf)
 {
         struct sis5595_data *data = sis5595_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
 }
 
-static ssize_t show_in_min(struct device *dev, char *buf, int nr)
+static ssize_t show_in_min(struct device *dev, struct device_attribute *da,
+                           char *buf)
 {
         struct sis5595_data *data = sis5595_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
 }
 
-static ssize_t show_in_max(struct device *dev, char *buf, int nr)
+static ssize_t show_in_max(struct device *dev, struct device_attribute *da,
+                           char *buf)
 {
         struct sis5595_data *data = sis5595_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
 }
 
-static ssize_t set_in_min(struct device *dev, const char *buf,
-               size_t count, int nr)
+static ssize_t set_in_min(struct device *dev, struct device_attribute *da,
+                          const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct sis5595_data *data = i2c_get_clientdata(client);
+        struct sis5595_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->in_min[nr] = IN_TO_REG(val);
-        sis5595_write_value(client, SIS5595_REG_IN_MIN(nr), data->in_min[nr]);
+        sis5595_write_value(data, SIS5595_REG_IN_MIN(nr), data->in_min[nr]);
         mutex_unlock(&data->update_lock);
         return count;
 }
 
-static ssize_t set_in_max(struct device *dev, const char *buf,
-               size_t count, int nr)
+static ssize_t set_in_max(struct device *dev, struct device_attribute *da,
+                          const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct sis5595_data *data = i2c_get_clientdata(client);
+        struct sis5595_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->in_max[nr] = IN_TO_REG(val);
-        sis5595_write_value(client, SIS5595_REG_IN_MAX(nr), data->in_max[nr]);
+        sis5595_write_value(data, SIS5595_REG_IN_MAX(nr), data->in_max[nr]);
         mutex_unlock(&data->update_lock);
         return count;
 }
 
 #define show_in_offset(offset)                                  \
-static ssize_t                                                  \
-        show_in##offset (struct device *dev, struct device_attribute *attr, char *buf)          \
-{                                                               \
-        return show_in(dev, buf, offset);                       \
-}                                                               \
-static DEVICE_ATTR(in##offset##_input, S_IRUGO,                 \
-                show_in##offset, NULL);                         \
-static ssize_t                                                  \
-        show_in##offset##_min (struct device *dev, struct device_attribute *attr, char *buf)    \
-{                                                               \
-        return show_in_min(dev, buf, offset);                   \
-}                                                               \
-static ssize_t                                                  \
-        show_in##offset##_max (struct device *dev, struct device_attribute *attr, char *buf)    \
-{                                                               \
-        return show_in_max(dev, buf, offset);                   \
-}                                                               \
-static ssize_t set_in##offset##_min (struct device *dev, struct device_attribute *attr, \
-                const char *buf, size_t count)                  \
-{                                                               \
-        return set_in_min(dev, buf, count, offset);             \
-}                                                               \
-static ssize_t set_in##offset##_max (struct device *dev, struct device_attribute *attr, \
-                const char *buf, size_t count)                  \
-{                                                               \
-        return set_in_max(dev, buf, count, offset);             \
-}                                                               \
-static DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,         \
-                show_in##offset##_min, set_in##offset##_min);   \
-static DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,         \
-                show_in##offset##_max, set_in##offset##_max);
+static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO,          \
+                show_in, NULL, offset);                         \
+static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,  \
+                show_in_min, set_in_min, offset);               \
+static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,  \
+                show_in_max, set_in_max, offset);
 
 show_in_offset(0);
 show_in_offset(1);
@@ -307,13 +290,12 @@ static ssize_t show_temp_over(struct device *dev, struct device_attribute *attr,
 
 static ssize_t set_temp_over(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct sis5595_data *data = i2c_get_clientdata(client);
+        struct sis5595_data *data = dev_get_drvdata(dev);
         long val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->temp_over = TEMP_TO_REG(val);
-        sis5595_write_value(client, SIS5595_REG_TEMP_OVER, data->temp_over);
+        sis5595_write_value(data, SIS5595_REG_TEMP_OVER, data->temp_over);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -326,13 +308,12 @@ static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *attr,
 
 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct sis5595_data *data = i2c_get_clientdata(client);
+        struct sis5595_data *data = dev_get_drvdata(dev);
         long val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->temp_hyst = TEMP_TO_REG(val);
-        sis5595_write_value(client, SIS5595_REG_TEMP_HYST, data->temp_hyst);
+        sis5595_write_value(data, SIS5595_REG_TEMP_HYST, data->temp_hyst);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -344,37 +325,47 @@ static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
                 show_temp_hyst, set_temp_hyst);
 
 /* 2 Fans */
-static ssize_t show_fan(struct device *dev, char *buf, int nr)
+static ssize_t show_fan(struct device *dev, struct device_attribute *da,
+                        char *buf)
 {
         struct sis5595_data *data = sis5595_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
                 DIV_FROM_REG(data->fan_div[nr])) );
 }
 
-static ssize_t show_fan_min(struct device *dev, char *buf, int nr)
+static ssize_t show_fan_min(struct device *dev, struct device_attribute *da,
+                            char *buf)
 {
         struct sis5595_data *data = sis5595_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr],
                 DIV_FROM_REG(data->fan_div[nr])) );
 }
 
-static ssize_t set_fan_min(struct device *dev, const char *buf,
-                size_t count, int nr)
+static ssize_t set_fan_min(struct device *dev, struct device_attribute *da,
+                           const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct sis5595_data *data = i2c_get_clientdata(client);
+        struct sis5595_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
-        sis5595_write_value(client, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
+        sis5595_write_value(data, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
         mutex_unlock(&data->update_lock);
         return count;
 }
 
-static ssize_t show_fan_div(struct device *dev, char *buf, int nr)
+static ssize_t show_fan_div(struct device *dev, struct device_attribute *da,
+                            char *buf)
 {
         struct sis5595_data *data = sis5595_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]) );
 }
 
@@ -382,11 +373,12 @@ static ssize_t show_fan_div(struct device *dev, char *buf, int nr)
    determined in part by the fan divisor.  This follows the principle of
    least surprise; the user doesn't expect the fan minimum to change just
    because the divisor changed. */
-static ssize_t set_fan_div(struct device *dev, const char *buf,
-        size_t count, int nr)
+static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
+                           const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct sis5595_data *data = i2c_get_clientdata(client);
+        struct sis5595_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         unsigned long min;
         unsigned long val = simple_strtoul(buf, NULL, 10);
         int reg;
@@ -394,7 +386,7 @@ static ssize_t set_fan_div(struct device *dev, const char *buf,
         mutex_lock(&data->update_lock);
         min = FAN_FROM_REG(data->fan_min[nr],
                         DIV_FROM_REG(data->fan_div[nr]));
-        reg = sis5595_read_value(client, SIS5595_REG_FANDIV);
+        reg = sis5595_read_value(data, SIS5595_REG_FANDIV);
 
         switch (val) {
         case 1: data->fan_div[nr] = 0; break;
@@ -402,7 +394,7 @@ static ssize_t set_fan_div(struct device *dev, const char *buf,
         case 4: data->fan_div[nr] = 2; break;
         case 8: data->fan_div[nr] = 3; break;
         default:
-                dev_err(&client->dev, "fan_div value %ld not "
+                dev_err(dev, "fan_div value %ld not "
                         "supported. Choose one of 1, 2, 4 or 8!\n", val);
                 mutex_unlock(&data->update_lock);
                 return -EINVAL;
@@ -416,55 +408,25 @@ static ssize_t set_fan_div(struct device *dev, const char *buf,
                 reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
                 break;
         }
-        sis5595_write_value(client, SIS5595_REG_FANDIV, reg);
+        sis5595_write_value(data, SIS5595_REG_FANDIV, reg);
         data->fan_min[nr] =
                 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
-        sis5595_write_value(client, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
+        sis5595_write_value(data, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
         mutex_unlock(&data->update_lock);
         return count;
 }
 
 #define show_fan_offset(offset)                                         \
-static ssize_t show_fan_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
-{                                                                       \
-        return show_fan(dev, buf, offset - 1);                  \
-}                                                                       \
-static ssize_t show_fan_##offset##_min (struct device *dev, struct device_attribute *attr, char *buf)   \
-{                                                                       \
-        return show_fan_min(dev, buf, offset - 1);                      \
-}                                                                       \
-static ssize_t show_fan_##offset##_div (struct device *dev, struct device_attribute *attr, char *buf)   \
-{                                                                       \
-        return show_fan_div(dev, buf, offset - 1);                      \
-}                                                                       \
-static ssize_t set_fan_##offset##_min (struct device *dev, struct device_attribute *attr,               \
-                const char *buf, size_t count)                          \
-{                                                                       \
-        return set_fan_min(dev, buf, count, offset - 1);                \
-}                                                                       \
-static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan_##offset, NULL);\
-static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,                \
-                show_fan_##offset##_min, set_fan_##offset##_min);
+static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO,                 \
+                show_fan, NULL, offset - 1);                            \
+static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,         \
+                show_fan_min, set_fan_min, offset - 1);                 \
+static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR,         \
+                show_fan_div, set_fan_div, offset - 1);
 
 show_fan_offset(1);
 show_fan_offset(2);
 
-static ssize_t set_fan_1_div(struct device *dev, struct device_attribute *attr, const char *buf,
-                size_t count)
-{
-        return set_fan_div(dev, buf, count, 0) ;
-}
-
-static ssize_t set_fan_2_div(struct device *dev, struct device_attribute *attr, const char *buf,
-                size_t count)
-{
-        return set_fan_div(dev, buf, count, 1) ;
-}
-static DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
-                show_fan_1_div, set_fan_1_div);
-static DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
-                show_fan_2_div, set_fan_2_div);
-
 /* Alarms */
 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
 {
@@ -473,28 +435,37 @@ static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, ch
 }
 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 
+static ssize_t show_name(struct device *dev, struct device_attribute *attr,
+                         char *buf)
+{
+        struct sis5595_data *data = dev_get_drvdata(dev);
+        return sprintf(buf, "%s\n", data->name);
+}
+static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
+
 static struct attribute *sis5595_attributes[] = {
-        &dev_attr_in0_input.attr,
-        &dev_attr_in0_min.attr,
-        &dev_attr_in0_max.attr,
-        &dev_attr_in1_input.attr,
-        &dev_attr_in1_min.attr,
-        &dev_attr_in1_max.attr,
-        &dev_attr_in2_input.attr,
-        &dev_attr_in2_min.attr,
-        &dev_attr_in2_max.attr,
-        &dev_attr_in3_input.attr,
-        &dev_attr_in3_min.attr,
-        &dev_attr_in3_max.attr,
-
-        &dev_attr_fan1_input.attr,
-        &dev_attr_fan1_min.attr,
-        &dev_attr_fan1_div.attr,
-        &dev_attr_fan2_input.attr,
-        &dev_attr_fan2_min.attr,
-        &dev_attr_fan2_div.attr,
+        &sensor_dev_attr_in0_input.dev_attr.attr,
+        &sensor_dev_attr_in0_min.dev_attr.attr,
+        &sensor_dev_attr_in0_max.dev_attr.attr,
+        &sensor_dev_attr_in1_input.dev_attr.attr,
+        &sensor_dev_attr_in1_min.dev_attr.attr,
+        &sensor_dev_attr_in1_max.dev_attr.attr,
+        &sensor_dev_attr_in2_input.dev_attr.attr,
+        &sensor_dev_attr_in2_min.dev_attr.attr,
+        &sensor_dev_attr_in2_max.dev_attr.attr,
+        &sensor_dev_attr_in3_input.dev_attr.attr,
+        &sensor_dev_attr_in3_min.dev_attr.attr,
+        &sensor_dev_attr_in3_max.dev_attr.attr,
+
+        &sensor_dev_attr_fan1_input.dev_attr.attr,
+        &sensor_dev_attr_fan1_min.dev_attr.attr,
+        &sensor_dev_attr_fan1_div.dev_attr.attr,
+        &sensor_dev_attr_fan2_input.dev_attr.attr,
+        &sensor_dev_attr_fan2_min.dev_attr.attr,
+        &sensor_dev_attr_fan2_div.dev_attr.attr,
 
         &dev_attr_alarms.attr,
+        &dev_attr_name.attr,
         NULL
 };
 
@@ -503,9 +474,9 @@ static const struct attribute_group sis5595_group = {
 };
 
 static struct attribute *sis5595_attributes_opt[] = {
-        &dev_attr_in4_input.attr,
-        &dev_attr_in4_min.attr,
-        &dev_attr_in4_max.attr,
+        &sensor_dev_attr_in4_input.dev_attr.attr,
+        &sensor_dev_attr_in4_min.dev_attr.attr,
+        &sensor_dev_attr_in4_max.dev_attr.attr,
 
         &dev_attr_temp1_input.attr,
         &dev_attr_temp1_max.attr,
@@ -518,68 +489,35 @@ static const struct attribute_group sis5595_group_opt = {
 };
  
 /* This is called when the module is loaded */
-static int sis5595_detect(struct i2c_adapter *adapter)
+static int __devinit sis5595_probe(struct platform_device *pdev)
 {
         int err = 0;
         int i;
-        struct i2c_client *new_client;
         struct sis5595_data *data;
+        struct resource *res;
         char val;
-        u16 a;
 
-        if (force_addr)
-                address = force_addr & ~(SIS5595_EXTENT - 1);
         /* Reserve the ISA region */
-        if (!request_region(address, SIS5595_EXTENT,
+        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
+        if (!request_region(res->start, SIS5595_EXTENT,
                             sis5595_driver.driver.name)) {
                 err = -EBUSY;
                 goto exit;
         }
-        if (force_addr) {
-                dev_warn(&adapter->dev, "forcing ISA address 0x%04X\n", address);
-                if (PCIBIOS_SUCCESSFUL !=
-                    pci_write_config_word(s_bridge, SIS5595_BASE_REG, address))
-                        goto exit_release;
-                if (PCIBIOS_SUCCESSFUL !=
-                    pci_read_config_word(s_bridge, SIS5595_BASE_REG, &a))
-                        goto exit_release;
-                if ((a & ~(SIS5595_EXTENT - 1)) != address)
-                        /* doesn't work for some chips? */
-                        goto exit_release;
-        }
-
-        if (PCIBIOS_SUCCESSFUL !=
-            pci_read_config_byte(s_bridge, SIS5595_ENABLE_REG, &val)) {
-                goto exit_release;
-        }
-        if ((val & 0x80) == 0) {
-                if (PCIBIOS_SUCCESSFUL !=
-                    pci_write_config_byte(s_bridge, SIS5595_ENABLE_REG,
-                                          val | 0x80))
-                        goto exit_release;
-                if (PCIBIOS_SUCCESSFUL !=
-                    pci_read_config_byte(s_bridge, SIS5595_ENABLE_REG, &val))
-                        goto exit_release;
-                if ((val & 0x80) == 0) 
-                        /* doesn't work for some chips! */
-                        goto exit_release;
-        }
 
         if (!(data = kzalloc(sizeof(struct sis5595_data), GFP_KERNEL))) {
                 err = -ENOMEM;
                 goto exit_release;
         }
 
-        new_client = &data->client;
-        new_client->addr = address;
         mutex_init(&data->lock);
-        i2c_set_clientdata(new_client, data);
-        new_client->adapter = adapter;
-        new_client->driver = &sis5595_driver;
-        new_client->flags = 0;
+        mutex_init(&data->update_lock);
+        data->addr = res->start;
+        data->name = "sis5595";
+        platform_set_drvdata(pdev, data);
 
         /* Check revision and pin registers to determine whether 4 or 5 voltages */
-        pci_read_config_byte(s_bridge, SIS5595_REVISION_REG, &(data->revision));
+        pci_read_config_byte(s_bridge, PCI_REVISION_ID, &data->revision);
         /* 4 voltages, 1 temp */
         data->maxins = 3;
         if (data->revision >= REV2MIN) {
@@ -589,47 +527,37 @@ static int sis5595_detect(struct i2c_adapter *adapter)
                         data->maxins = 4;
         }
         
-        /* Fill in the remaining client fields and put it into the global list */
-        strlcpy(new_client->name, "sis5595", I2C_NAME_SIZE);
-
-        data->valid = 0;
-        mutex_init(&data->update_lock);
-
-        /* Tell the I2C layer a new client has arrived */
-        if ((err = i2c_attach_client(new_client)))
-                goto exit_free;
-        
         /* Initialize the SIS5595 chip */
-        sis5595_init_client(new_client);
+        sis5595_init_device(data);
 
         /* A few vars need to be filled upon startup */
         for (i = 0; i < 2; i++) {
-                data->fan_min[i] = sis5595_read_value(new_client,
+                data->fan_min[i] = sis5595_read_value(data,
                                         SIS5595_REG_FAN_MIN(i));
         }
 
         /* Register sysfs hooks */
-        if ((err = sysfs_create_group(&new_client->dev.kobj, &sis5595_group)))
-                goto exit_detach;
+        if ((err = sysfs_create_group(&pdev->dev.kobj, &sis5595_group)))
+                goto exit_free;
         if (data->maxins == 4) {
-                if ((err = device_create_file(&new_client->dev,
-                                              &dev_attr_in4_input))
-                 || (err = device_create_file(&new_client->dev,
-                                              &dev_attr_in4_min))
-                 || (err = device_create_file(&new_client->dev,
-                                              &dev_attr_in4_max)))
+                if ((err = device_create_file(&pdev->dev,
+                                        &sensor_dev_attr_in4_input.dev_attr))
+                 || (err = device_create_file(&pdev->dev,
+                                        &sensor_dev_attr_in4_min.dev_attr))
+                 || (err = device_create_file(&pdev->dev,
+                                        &sensor_dev_attr_in4_max.dev_attr)))
                         goto exit_remove_files;
         } else {
-                if ((err = device_create_file(&new_client->dev,
+                if ((err = device_create_file(&pdev->dev,
                                               &dev_attr_temp1_input))
-                 || (err = device_create_file(&new_client->dev,
+                 || (err = device_create_file(&pdev->dev,
                                               &dev_attr_temp1_max))
-                 || (err = device_create_file(&new_client->dev,
+                 || (err = device_create_file(&pdev->dev,
                                               &dev_attr_temp1_max_hyst)))
                         goto exit_remove_files;
         }
 
-        data->class_dev = hwmon_device_register(&new_client->dev);
+        data->class_dev = hwmon_device_register(&pdev->dev);
         if (IS_ERR(data->class_dev)) {
                 err = PTR_ERR(data->class_dev);
                 goto exit_remove_files;
@@ -638,32 +566,26 @@ static int sis5595_detect(struct i2c_adapter *adapter)
         return 0;
 
 exit_remove_files:
-        sysfs_remove_group(&new_client->dev.kobj, &sis5595_group);
-        sysfs_remove_group(&new_client->dev.kobj, &sis5595_group_opt);
-exit_detach:
-        i2c_detach_client(new_client);
+        sysfs_remove_group(&pdev->dev.kobj, &sis5595_group);
+        sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_opt);
 exit_free:
         kfree(data);
 exit_release:
-        release_region(address, SIS5595_EXTENT);
+        release_region(res->start, SIS5595_EXTENT);
 exit:
         return err;
 }
 
-static int sis5595_detach_client(struct i2c_client *client)
+static int __devexit sis5595_remove(struct platform_device *pdev)
 {
-        struct sis5595_data *data = i2c_get_clientdata(client);
-        int err;
+        struct sis5595_data *data = platform_get_drvdata(pdev);
 
         hwmon_device_unregister(data->class_dev);
-        sysfs_remove_group(&client->dev.kobj, &sis5595_group);
-        sysfs_remove_group(&client->dev.kobj, &sis5595_group_opt);
-
-        if ((err = i2c_detach_client(client)))
-                return err;
-
-        release_region(client->addr, SIS5595_EXTENT);
+        sysfs_remove_group(&pdev->dev.kobj, &sis5595_group);
+        sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_opt);
 
+        release_region(data->addr, SIS5595_EXTENT);
+        platform_set_drvdata(pdev, NULL);
         kfree(data);
 
         return 0;
@@ -671,41 +593,37 @@ static int sis5595_detach_client(struct i2c_client *client)
 
 
 /* ISA access must be locked explicitly. */
-static int sis5595_read_value(struct i2c_client *client, u8 reg)
+static int sis5595_read_value(struct sis5595_data *data, u8 reg)
 {
         int res;
 
-        struct sis5595_data *data = i2c_get_clientdata(client);
         mutex_lock(&data->lock);
-        outb_p(reg, client->addr + SIS5595_ADDR_REG_OFFSET);
-        res = inb_p(client->addr + SIS5595_DATA_REG_OFFSET);
+        outb_p(reg, data->addr + SIS5595_ADDR_REG_OFFSET);
+        res = inb_p(data->addr + SIS5595_DATA_REG_OFFSET);
         mutex_unlock(&data->lock);
         return res;
 }
 
-static int sis5595_write_value(struct i2c_client *client, u8 reg, u8 value)
+static void sis5595_write_value(struct sis5595_data *data, u8 reg, u8 value)
 {
-        struct sis5595_data *data = i2c_get_clientdata(client);
         mutex_lock(&data->lock);
-        outb_p(reg, client->addr + SIS5595_ADDR_REG_OFFSET);
-        outb_p(value, client->addr + SIS5595_DATA_REG_OFFSET);
+        outb_p(reg, data->addr + SIS5595_ADDR_REG_OFFSET);
+        outb_p(value, data->addr + SIS5595_DATA_REG_OFFSET);
         mutex_unlock(&data->lock);
-        return 0;
 }
 
 /* Called when we have found a new SIS5595. */
-static void sis5595_init_client(struct i2c_client *client)
+static void __devinit sis5595_init_device(struct sis5595_data *data)
 {
-        u8 config = sis5595_read_value(client, SIS5595_REG_CONFIG);
+        u8 config = sis5595_read_value(data, SIS5595_REG_CONFIG);
         if (!(config & 0x01))
-                sis5595_write_value(client, SIS5595_REG_CONFIG,
+                sis5595_write_value(data, SIS5595_REG_CONFIG,
                                 (config & 0xf7) | 0x01);
 }
 
 static struct sis5595_data *sis5595_update_device(struct device *dev)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct sis5595_data *data = i2c_get_clientdata(client);
+        struct sis5595_data *data = dev_get_drvdata(dev);
         int i;
 
         mutex_lock(&data->update_lock);
@@ -715,35 +633,35 @@ static struct sis5595_data *sis5595_update_device(struct device *dev)
 
                 for (i = 0; i <= data->maxins; i++) {
                         data->in[i] =
-                            sis5595_read_value(client, SIS5595_REG_IN(i));
+                            sis5595_read_value(data, SIS5595_REG_IN(i));
                         data->in_min[i] =
-                            sis5595_read_value(client,
+                            sis5595_read_value(data,
                                                SIS5595_REG_IN_MIN(i));
                         data->in_max[i] =
-                            sis5595_read_value(client,
+                            sis5595_read_value(data,
                                                SIS5595_REG_IN_MAX(i));
                 }
                 for (i = 0; i < 2; i++) {
                         data->fan[i] =
-                            sis5595_read_value(client, SIS5595_REG_FAN(i));
+                            sis5595_read_value(data, SIS5595_REG_FAN(i));
                         data->fan_min[i] =
-                            sis5595_read_value(client,
+                            sis5595_read_value(data,
                                                SIS5595_REG_FAN_MIN(i));
                 }
                 if (data->maxins == 3) {
                         data->temp =
-                            sis5595_read_value(client, SIS5595_REG_TEMP);
+                            sis5595_read_value(data, SIS5595_REG_TEMP);
                         data->temp_over =
-                            sis5595_read_value(client, SIS5595_REG_TEMP_OVER);
+                            sis5595_read_value(data, SIS5595_REG_TEMP_OVER);
                         data->temp_hyst =
-                            sis5595_read_value(client, SIS5595_REG_TEMP_HYST);
+                            sis5595_read_value(data, SIS5595_REG_TEMP_HYST);
                 }
-                i = sis5595_read_value(client, SIS5595_REG_FANDIV);
+                i = sis5595_read_value(data, SIS5595_REG_FANDIV);
                 data->fan_div[0] = (i >> 4) & 0x03;
                 data->fan_div[1] = i >> 6;
                 data->alarms =
-                    sis5595_read_value(client, SIS5595_REG_ALARM1) |
-                    (sis5595_read_value(client, SIS5595_REG_ALARM2) << 8);
+                    sis5595_read_value(data, SIS5595_REG_ALARM1) |
+                    (sis5595_read_value(data, SIS5595_REG_ALARM2) << 8);
                 data->last_updated = jiffies;
                 data->valid = 1;
         }
@@ -774,10 +692,50 @@ static int blacklist[] __devinitdata = {
         PCI_DEVICE_ID_SI_5598,
         0 };
 
+static int __devinit sis5595_device_add(unsigned short address)
+{
+        struct resource res = {
+                .start  = address,
+                .end    = address + SIS5595_EXTENT - 1,
+                .name   = "sis5595",
+                .flags  = IORESOURCE_IO,
+        };
+        int err;
+
+        pdev = platform_device_alloc("sis5595", address);
+        if (!pdev) {
+                err = -ENOMEM;
+                printk(KERN_ERR "sis5595: Device allocation failed\n");
+                goto exit;
+        }
+
+        err = platform_device_add_resources(pdev, &res, 1);
+        if (err) {
+                printk(KERN_ERR "sis5595: Device resource addition failed "
+                       "(%d)\n", err);
+                goto exit_device_put;
+        }
+
+        err = platform_device_add(pdev);
+        if (err) {
+                printk(KERN_ERR "sis5595: Device addition failed (%d)\n",
+                       err);
+                goto exit_device_put;
+        }
+
+        return 0;
+
+exit_device_put:
+        platform_device_put(pdev);
+exit:
+        return err;
+}
+
 static int __devinit sis5595_pci_probe(struct pci_dev *dev,
                                        const struct pci_device_id *id)
 {
-        u16 val;
+        u16 address;
+        u8 enable;
         int *i;
 
         for (i = blacklist; *i != 0; i++) {
@@ -790,27 +748,68 @@ static int __devinit sis5595_pci_probe(struct pci_dev *dev,
                 }
         }
         
+        force_addr &= ~(SIS5595_EXTENT - 1);
+        if (force_addr) {
+                dev_warn(&dev->dev, "Forcing ISA address 0x%x\n", force_addr);
+                pci_write_config_word(dev, SIS5595_BASE_REG, force_addr);
+        }
+
         if (PCIBIOS_SUCCESSFUL !=
-            pci_read_config_word(dev, SIS5595_BASE_REG, &val))
+            pci_read_config_word(dev, SIS5595_BASE_REG, &address)) {
+                dev_err(&dev->dev, "Failed to read ISA address\n");
                 return -ENODEV;
+        }
         
-        address = val & ~(SIS5595_EXTENT - 1);
-        if (address == 0 && force_addr == 0) {
+        address &= ~(SIS5595_EXTENT - 1);
+        if (!address) {
                 dev_err(&dev->dev, "Base address not set - upgrade BIOS or use force_addr=0xaddr\n");
                 return -ENODEV;
         }
+        if (force_addr && address != force_addr) {
+                /* doesn't work for some chips? */
+                dev_err(&dev->dev, "Failed to force ISA address\n");
+                return -ENODEV;
+        }
 
-        s_bridge = pci_dev_get(dev);
-        if (i2c_isa_add_driver(&sis5595_driver)) {
-                pci_dev_put(s_bridge);
-                s_bridge = NULL;
+        if (PCIBIOS_SUCCESSFUL !=
+            pci_read_config_byte(dev, SIS5595_ENABLE_REG, &enable)) {
+                dev_err(&dev->dev, "Failed to read enable register\n");
+                return -ENODEV;
+        }
+        if (!(enable & 0x80)) {
+                if ((PCIBIOS_SUCCESSFUL !=
+                     pci_write_config_byte(dev, SIS5595_ENABLE_REG,
+                                           enable | 0x80))
+                 || (PCIBIOS_SUCCESSFUL !=
+                     pci_read_config_byte(dev, SIS5595_ENABLE_REG, &enable))
+                 || (!(enable & 0x80))) {
+                        /* doesn't work for some chips! */
+                        dev_err(&dev->dev, "Failed to enable HWM device\n");
+                        return -ENODEV;
+                }
         }
 
+        if (platform_driver_register(&sis5595_driver)) {
+                dev_dbg(&dev->dev, "Failed to register sis5595 driver\n");
+                goto exit;
+        }
+
+        s_bridge = pci_dev_get(dev);
+        /* Sets global pdev as a side effect */
+        if (sis5595_device_add(address))
+                goto exit_unregister;
+
         /* Always return failure here.  This is to allow other drivers to bind
          * to this pci device.  We don't really want to have control over the
          * pci device, we only wanted to read as few register values from it.
          */
         return -ENODEV;
+
+exit_unregister:
+        pci_dev_put(dev);
+        platform_driver_unregister(&sis5595_driver);
+exit:
+        return -ENODEV;
 }
 
 static struct pci_driver sis5595_pci_driver = {
@@ -828,7 +827,8 @@ static void __exit sm_sis5595_exit(void)
 {
         pci_unregister_driver(&sis5595_pci_driver);
         if (s_bridge != NULL) {
-                i2c_isa_del_driver(&sis5595_driver);
+                platform_device_unregister(pdev);
+                platform_driver_unregister(&sis5595_driver);
                 pci_dev_put(s_bridge);
                 s_bridge = NULL;
         }
diff --git a/drivers/hwmon/smsc47b397.c b/drivers/hwmon/smsc47b397.c
index 943abbd95ab5..45266b30ce1d 100644
--- a/drivers/hwmon/smsc47b397.c
+++ b/drivers/hwmon/smsc47b397.c
@@ -174,6 +174,8 @@ static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3);
    REG: count of 90kHz pulses / revolution */
 static int fan_from_reg(u16 reg)
 {
+        if (reg == 0 || reg == 0xffff)
+                return 0;
         return 90000 * 60 / reg;
 }
 
@@ -333,7 +335,7 @@ static int __init smsc47b397_find(unsigned short *addr)
         superio_enter();
         id = superio_inb(SUPERIO_REG_DEVID);
 
-        if ((id != 0x6f) && (id != 0x81)) {
+        if ((id != 0x6f) && (id != 0x81) && (id != 0x85)) {
                 superio_exit();
                 return -ENODEV;
         }
@@ -346,7 +348,8 @@ static int __init smsc47b397_find(unsigned short *addr)
 
         printk(KERN_INFO DRVNAME ": found SMSC %s "
                 "(base address 0x%04x, revision %u)\n",
-                id == 0x81 ? "SCH5307-NS" : "LPC47B397-NC", *addr, rev);
+                id == 0x81 ? "SCH5307-NS" : id == 0x85 ? "SCH5317" :
+               "LPC47B397-NC", *addr, rev);
 
         superio_exit();
         return 0;
diff --git a/drivers/hwmon/smsc47m1.c b/drivers/hwmon/smsc47m1.c
index 1e21c8cc948f..1de2f2be8708 100644
--- a/drivers/hwmon/smsc47m1.c
+++ b/drivers/hwmon/smsc47m1.c
@@ -597,6 +597,7 @@ static int __devinit smsc47m1_probe(struct platform_device *pdev)
 error_remove_files:
         sysfs_remove_group(&dev->kobj, &smsc47m1_group);
 error_free:
+        platform_set_drvdata(pdev, NULL);
         kfree(data);
 error_release:
         release_region(res->start, SMSC_EXTENT);
@@ -608,12 +609,12 @@ static int __devexit smsc47m1_remove(struct platform_device *pdev)
         struct smsc47m1_data *data = platform_get_drvdata(pdev);
         struct resource *res;
 
-        platform_set_drvdata(pdev, NULL);
         hwmon_device_unregister(data->class_dev);
         sysfs_remove_group(&pdev->dev.kobj, &smsc47m1_group);
 
         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
         release_region(res->start, SMSC_EXTENT);
+        platform_set_drvdata(pdev, NULL);
         kfree(data);
 
         return 0;
@@ -693,15 +694,12 @@ static int __init smsc47m1_device_add(unsigned short address,
                 goto exit_device_put;
         }
 
-        pdev->dev.platform_data = kmalloc(sizeof(struct smsc47m1_sio_data),
-                                          GFP_KERNEL);
-        if (!pdev->dev.platform_data) {
-                err = -ENOMEM;
+        err = platform_device_add_data(pdev, sio_data,
+                                       sizeof(struct smsc47m1_sio_data));
+        if (err) {
                 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
                 goto exit_device_put;
         }
-        memcpy(pdev->dev.platform_data, sio_data,
-               sizeof(struct smsc47m1_sio_data));
 
         err = platform_device_add(pdev);
         if (err) {
diff --git a/drivers/hwmon/smsc47m192.c b/drivers/hwmon/smsc47m192.c
index a012f396f354..d3a3ba04cb0f 100644
--- a/drivers/hwmon/smsc47m192.c
+++ b/drivers/hwmon/smsc47m192.c
@@ -31,6 +31,7 @@
 #include <linux/hwmon-vid.h>
 #include <linux/err.h>
 #include <linux/sysfs.h>
+#include <linux/mutex.h>
 
 /* Addresses to scan */
 static unsigned short normal_i2c[] = { 0x2c, 0x2d, I2C_CLIENT_END };
@@ -97,7 +98,7 @@ static inline int TEMP_FROM_REG(s8 val)
 struct smsc47m192_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid;             /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
 
@@ -164,11 +165,11 @@ static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
         struct smsc47m192_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_min[nr] = IN_TO_REG(val, nr);
         i2c_smbus_write_byte_data(client, SMSC47M192_REG_IN_MIN(nr),
                                                         data->in_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -181,11 +182,11 @@ static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
         struct smsc47m192_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_max[nr] = IN_TO_REG(val, nr);
         i2c_smbus_write_byte_data(client, SMSC47M192_REG_IN_MAX(nr),
                                                         data->in_max[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -243,11 +244,11 @@ static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
         struct smsc47m192_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_min[nr] = TEMP_TO_REG(val);
         i2c_smbus_write_byte_data(client, SMSC47M192_REG_TEMP_MIN[nr],
                                                 data->temp_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -260,11 +261,11 @@ static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
         struct smsc47m192_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_max[nr] = TEMP_TO_REG(val);
         i2c_smbus_write_byte_data(client, SMSC47M192_REG_TEMP_MAX[nr],
                                                 data->temp_max[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -287,7 +288,7 @@ static ssize_t set_temp_offset(struct device *dev, struct device_attribute
         u8 sfr = i2c_smbus_read_byte_data(client, SMSC47M192_REG_SFR);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_offset[nr] = TEMP_TO_REG(val);
         if (nr>1)
                 i2c_smbus_write_byte_data(client,
@@ -303,7 +304,7 @@ static ssize_t set_temp_offset(struct device *dev, struct device_attribute
         } else if ((sfr & 0x10) == (nr==0 ? 0x10 : 0))
                 i2c_smbus_write_byte_data(client,
                                         SMSC47M192_REG_TEMP_OFFSET(nr), 0);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -360,8 +361,8 @@ static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 0x0010);
 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 0x0020);
 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 0x0040);
-static SENSOR_DEVICE_ATTR(temp2_input_fault, S_IRUGO, show_alarm, NULL, 0x4000);
-static SENSOR_DEVICE_ATTR(temp3_input_fault, S_IRUGO, show_alarm, NULL, 0x8000);
+static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 0x4000);
+static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 0x8000);
 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0x0001);
 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 0x0002);
 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 0x0004);
@@ -411,13 +412,13 @@ static struct attribute *smsc47m192_attributes[] = {
         &sensor_dev_attr_temp2_min.dev_attr.attr,
         &sensor_dev_attr_temp2_offset.dev_attr.attr,
         &sensor_dev_attr_temp2_alarm.dev_attr.attr,
-        &sensor_dev_attr_temp2_input_fault.dev_attr.attr,
+        &sensor_dev_attr_temp2_fault.dev_attr.attr,
         &sensor_dev_attr_temp3_input.dev_attr.attr,
         &sensor_dev_attr_temp3_max.dev_attr.attr,
         &sensor_dev_attr_temp3_min.dev_attr.attr,
         &sensor_dev_attr_temp3_offset.dev_attr.attr,
         &sensor_dev_attr_temp3_alarm.dev_attr.attr,
-        &sensor_dev_attr_temp3_input_fault.dev_attr.attr,
+        &sensor_dev_attr_temp3_fault.dev_attr.attr,
 
         &dev_attr_cpu0_vid.attr,
         &dev_attr_vrm.attr,
@@ -531,7 +532,7 @@ static int smsc47m192_detect(struct i2c_adapter *adapter, int address,
         /* Fill in the remaining client fields and put into the global list */
         strlcpy(client->name, "smsc47m192", I2C_NAME_SIZE);
         data->vrm = vid_which_vrm();
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(client)))
@@ -594,7 +595,7 @@ static struct smsc47m192_data *smsc47m192_update_device(struct device *dev)
         struct smsc47m192_data *data = i2c_get_clientdata(client);
         int i, config;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
          || !data->valid) {
@@ -645,7 +646,7 @@ static struct smsc47m192_data *smsc47m192_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/via686a.c b/drivers/hwmon/via686a.c
index 9a440c8cc520..24a6851491d0 100644
--- a/drivers/hwmon/via686a.c
+++ b/drivers/hwmon/via686a.c
@@ -34,9 +34,9 @@
 #include <linux/slab.h>
 #include <linux/pci.h>
 #include <linux/jiffies.h>
-#include <linux/i2c.h>
-#include <linux/i2c-isa.h>
+#include <linux/platform_device.h>
 #include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
 #include <linux/err.h>
 #include <linux/init.h>
 #include <linux/mutex.h>
@@ -51,10 +51,7 @@ module_param(force_addr, ushort, 0);
 MODULE_PARM_DESC(force_addr,
                  "Initialize the base address of the sensors");
 
-/* Device address
-   Note that we can't determine the ISA address until we have initialized
-   our module */
-static unsigned short address;
+static struct platform_device *pdev;
 
 /*
    The Via 686a southbridge has a LM78-like chip integrated on the same IC.
@@ -295,7 +292,8 @@ static inline long TEMP_FROM_REG10(u16 val)
 /* For each registered chip, we need to keep some data in memory.
    The structure is dynamically allocated. */
 struct via686a_data {
-        struct i2c_client client;
+        unsigned short addr;
+        const char *name;
         struct class_device *class_dev;
         struct mutex update_lock;
         char valid;             /* !=0 if following fields are valid */
@@ -315,98 +313,85 @@ struct via686a_data {
 
 static struct pci_dev *s_bridge;        /* pointer to the (only) via686a */
 
-static int via686a_detect(struct i2c_adapter *adapter);
-static int via686a_detach_client(struct i2c_client *client);
+static int via686a_probe(struct platform_device *pdev);
+static int via686a_remove(struct platform_device *pdev);
 
-static inline int via686a_read_value(struct i2c_client *client, u8 reg)
+static inline int via686a_read_value(struct via686a_data *data, u8 reg)
 {
-        return (inb_p(client->addr + reg));
+        return inb_p(data->addr + reg);
 }
 
-static inline void via686a_write_value(struct i2c_client *client, u8 reg,
+static inline void via686a_write_value(struct via686a_data *data, u8 reg,
                                        u8 value)
 {
-        outb_p(value, client->addr + reg);
+        outb_p(value, data->addr + reg);
 }
 
 static struct via686a_data *via686a_update_device(struct device *dev);
-static void via686a_init_client(struct i2c_client *client);
+static void via686a_init_device(struct via686a_data *data);
 
 /* following are the sysfs callback functions */
 
 /* 7 voltage sensors */
-static ssize_t show_in(struct device *dev, char *buf, int nr) {
+static ssize_t show_in(struct device *dev, struct device_attribute *da,
+                char *buf) {
         struct via686a_data *data = via686a_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         return sprintf(buf, "%ld\n", IN_FROM_REG(data->in[nr], nr));
 }
 
-static ssize_t show_in_min(struct device *dev, char *buf, int nr) {
+static ssize_t show_in_min(struct device *dev, struct device_attribute *da,
+                char *buf) {
         struct via686a_data *data = via686a_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         return sprintf(buf, "%ld\n", IN_FROM_REG(data->in_min[nr], nr));
 }
 
-static ssize_t show_in_max(struct device *dev, char *buf, int nr) {
+static ssize_t show_in_max(struct device *dev, struct device_attribute *da,
+                char *buf) {
         struct via686a_data *data = via686a_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         return sprintf(buf, "%ld\n", IN_FROM_REG(data->in_max[nr], nr));
 }
 
-static ssize_t set_in_min(struct device *dev, const char *buf,
-                size_t count, int nr) {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct via686a_data *data = i2c_get_clientdata(client);
+static ssize_t set_in_min(struct device *dev, struct device_attribute *da,
+                const char *buf, size_t count) {
+        struct via686a_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->in_min[nr] = IN_TO_REG(val, nr);
-        via686a_write_value(client, VIA686A_REG_IN_MIN(nr),
+        via686a_write_value(data, VIA686A_REG_IN_MIN(nr),
                         data->in_min[nr]);
         mutex_unlock(&data->update_lock);
         return count;
 }
-static ssize_t set_in_max(struct device *dev, const char *buf,
-                size_t count, int nr) {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct via686a_data *data = i2c_get_clientdata(client);
+static ssize_t set_in_max(struct device *dev, struct device_attribute *da,
+                const char *buf, size_t count) {
+        struct via686a_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->in_max[nr] = IN_TO_REG(val, nr);
-        via686a_write_value(client, VIA686A_REG_IN_MAX(nr),
+        via686a_write_value(data, VIA686A_REG_IN_MAX(nr),
                         data->in_max[nr]);
         mutex_unlock(&data->update_lock);
         return count;
 }
 #define show_in_offset(offset)                                  \
-static ssize_t                                                  \
-        show_in##offset (struct device *dev, struct device_attribute *attr, char *buf)          \
-{                                                               \
-        return show_in(dev, buf, offset);                       \
-}                                                               \
-static ssize_t                                                  \
-        show_in##offset##_min (struct device *dev, struct device_attribute *attr, char *buf)    \
-{                                                               \
-        return show_in_min(dev, buf, offset);           \
-}                                                               \
-static ssize_t                                                  \
-        show_in##offset##_max (struct device *dev, struct device_attribute *attr, char *buf)    \
-{                                                               \
-        return show_in_max(dev, buf, offset);           \
-}                                                               \
-static ssize_t set_in##offset##_min (struct device *dev, struct device_attribute *attr,         \
-                const char *buf, size_t count)                  \
-{                                                               \
-        return set_in_min(dev, buf, count, offset);             \
-}                                                               \
-static ssize_t set_in##offset##_max (struct device *dev, struct device_attribute *attr, \
-                        const char *buf, size_t count)          \
-{                                                               \
-        return set_in_max(dev, buf, count, offset);             \
-}                                                               \
-static DEVICE_ATTR(in##offset##_input, S_IRUGO, show_in##offset, NULL);\
-static DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,         \
-                show_in##offset##_min, set_in##offset##_min);   \
-static DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,         \
-                show_in##offset##_max, set_in##offset##_max);
+static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO,          \
+                show_in, NULL, offset);                         \
+static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,  \
+                show_in_min, set_in_min, offset);               \
+static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,  \
+                show_in_max, set_in_max, offset);
 
 show_in_offset(0);
 show_in_offset(1);
@@ -415,150 +400,128 @@ show_in_offset(3);
 show_in_offset(4);
 
 /* 3 temperatures */
-static ssize_t show_temp(struct device *dev, char *buf, int nr) {
+static ssize_t show_temp(struct device *dev, struct device_attribute *da,
+                char *buf) {
         struct via686a_data *data = via686a_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         return sprintf(buf, "%ld\n", TEMP_FROM_REG10(data->temp[nr]));
 }
-static ssize_t show_temp_over(struct device *dev, char *buf, int nr) {
+static ssize_t show_temp_over(struct device *dev, struct device_attribute *da,
+                char *buf) {
         struct via686a_data *data = via686a_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         return sprintf(buf, "%ld\n", TEMP_FROM_REG(data->temp_over[nr]));
 }
-static ssize_t show_temp_hyst(struct device *dev, char *buf, int nr) {
+static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *da,
+                char *buf) {
         struct via686a_data *data = via686a_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         return sprintf(buf, "%ld\n", TEMP_FROM_REG(data->temp_hyst[nr]));
 }
-static ssize_t set_temp_over(struct device *dev, const char *buf,
-                size_t count, int nr) {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct via686a_data *data = i2c_get_clientdata(client);
+static ssize_t set_temp_over(struct device *dev, struct device_attribute *da,
+                const char *buf, size_t count) {
+        struct via686a_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         int val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->temp_over[nr] = TEMP_TO_REG(val);
-        via686a_write_value(client, VIA686A_REG_TEMP_OVER[nr],
+        via686a_write_value(data, VIA686A_REG_TEMP_OVER[nr],
                             data->temp_over[nr]);
         mutex_unlock(&data->update_lock);
         return count;
 }
-static ssize_t set_temp_hyst(struct device *dev, const char *buf,
-                size_t count, int nr) {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct via686a_data *data = i2c_get_clientdata(client);
+static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *da,
+                const char *buf, size_t count) {
+        struct via686a_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         int val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->temp_hyst[nr] = TEMP_TO_REG(val);
-        via686a_write_value(client, VIA686A_REG_TEMP_HYST[nr],
+        via686a_write_value(data, VIA686A_REG_TEMP_HYST[nr],
                             data->temp_hyst[nr]);
         mutex_unlock(&data->update_lock);
         return count;
 }
 #define show_temp_offset(offset)                                        \
-static ssize_t show_temp_##offset (struct device *dev, struct device_attribute *attr, char *buf)        \
-{                                                                       \
-        return show_temp(dev, buf, offset - 1);                         \
-}                                                                       \
-static ssize_t                                                          \
-show_temp_##offset##_over (struct device *dev, struct device_attribute *attr, char *buf)                \
-{                                                                       \
-        return show_temp_over(dev, buf, offset - 1);                    \
-}                                                                       \
-static ssize_t                                                          \
-show_temp_##offset##_hyst (struct device *dev, struct device_attribute *attr, char *buf)                \
-{                                                                       \
-        return show_temp_hyst(dev, buf, offset - 1);                    \
-}                                                                       \
-static ssize_t set_temp_##offset##_over (struct device *dev, struct device_attribute *attr,             \
-                const char *buf, size_t count)                          \
-{                                                                       \
-        return set_temp_over(dev, buf, count, offset - 1);              \
-}                                                                       \
-static ssize_t set_temp_##offset##_hyst (struct device *dev, struct device_attribute *attr,             \
-                const char *buf, size_t count)                          \
-{                                                                       \
-        return set_temp_hyst(dev, buf, count, offset - 1);              \
-}                                                                       \
-static DEVICE_ATTR(temp##offset##_input, S_IRUGO, show_temp_##offset, NULL);\
-static DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR,               \
-                show_temp_##offset##_over, set_temp_##offset##_over);   \
-static DEVICE_ATTR(temp##offset##_max_hyst, S_IRUGO | S_IWUSR,          \
-                show_temp_##offset##_hyst, set_temp_##offset##_hyst);
+static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO,                \
+                show_temp, NULL, offset - 1);                           \
+static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR,        \
+                show_temp_over, set_temp_over, offset - 1);             \
+static SENSOR_DEVICE_ATTR(temp##offset##_max_hyst, S_IRUGO | S_IWUSR,   \
+                show_temp_hyst, set_temp_hyst, offset - 1);
 
 show_temp_offset(1);
 show_temp_offset(2);
 show_temp_offset(3);
 
 /* 2 Fans */
-static ssize_t show_fan(struct device *dev, char *buf, int nr) {
+static ssize_t show_fan(struct device *dev, struct device_attribute *da,
+                char *buf) {
         struct via686a_data *data = via686a_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
                                 DIV_FROM_REG(data->fan_div[nr])) );
 }
-static ssize_t show_fan_min(struct device *dev, char *buf, int nr) {
+static ssize_t show_fan_min(struct device *dev, struct device_attribute *da,
+                char *buf) {
         struct via686a_data *data = via686a_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         return sprintf(buf, "%d\n",
                 FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr])) );
 }
-static ssize_t show_fan_div(struct device *dev, char *buf, int nr) {
+static ssize_t show_fan_div(struct device *dev, struct device_attribute *da,
+                char *buf) {
         struct via686a_data *data = via686a_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]) );
 }
-static ssize_t set_fan_min(struct device *dev, const char *buf,
-                size_t count, int nr) {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct via686a_data *data = i2c_get_clientdata(client);
+static ssize_t set_fan_min(struct device *dev, struct device_attribute *da,
+                const char *buf, size_t count) {
+        struct via686a_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         int val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
-        via686a_write_value(client, VIA686A_REG_FAN_MIN(nr+1), data->fan_min[nr]);
+        via686a_write_value(data, VIA686A_REG_FAN_MIN(nr+1), data->fan_min[nr]);
         mutex_unlock(&data->update_lock);
         return count;
 }
-static ssize_t set_fan_div(struct device *dev, const char *buf,
-                size_t count, int nr) {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct via686a_data *data = i2c_get_clientdata(client);
+static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
+                const char *buf, size_t count) {
+        struct via686a_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        int nr = attr->index;
         int val = simple_strtol(buf, NULL, 10);
         int old;
 
         mutex_lock(&data->update_lock);
-        old = via686a_read_value(client, VIA686A_REG_FANDIV);
+        old = via686a_read_value(data, VIA686A_REG_FANDIV);
         data->fan_div[nr] = DIV_TO_REG(val);
         old = (old & 0x0f) | (data->fan_div[1] << 6) | (data->fan_div[0] << 4);
-        via686a_write_value(client, VIA686A_REG_FANDIV, old);
+        via686a_write_value(data, VIA686A_REG_FANDIV, old);
         mutex_unlock(&data->update_lock);
         return count;
 }
 
 #define show_fan_offset(offset)                                         \
-static ssize_t show_fan_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
-{                                                                       \
-        return show_fan(dev, buf, offset - 1);                          \
-}                                                                       \
-static ssize_t show_fan_##offset##_min (struct device *dev, struct device_attribute *attr, char *buf)   \
-{                                                                       \
-        return show_fan_min(dev, buf, offset - 1);                      \
-}                                                                       \
-static ssize_t show_fan_##offset##_div (struct device *dev, struct device_attribute *attr, char *buf)   \
-{                                                                       \
-        return show_fan_div(dev, buf, offset - 1);                      \
-}                                                                       \
-static ssize_t set_fan_##offset##_min (struct device *dev, struct device_attribute *attr,               \
-        const char *buf, size_t count)                                  \
-{                                                                       \
-        return set_fan_min(dev, buf, count, offset - 1);                \
-}                                                                       \
-static ssize_t set_fan_##offset##_div (struct device *dev, struct device_attribute *attr,               \
-                const char *buf, size_t count)                          \
-{                                                                       \
-        return set_fan_div(dev, buf, count, offset - 1);                \
-}                                                                       \
-static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan_##offset, NULL);\
-static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,                \
-                show_fan_##offset##_min, set_fan_##offset##_min);       \
-static DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR,                \
-                show_fan_##offset##_div, set_fan_##offset##_div);
+static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO,                 \
+                show_fan, NULL, offset - 1);                            \
+static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,         \
+                show_fan_min, set_fan_min, offset - 1);                 \
+static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR,         \
+                show_fan_div, set_fan_div, offset - 1);
 
 show_fan_offset(1);
 show_fan_offset(2);
@@ -570,41 +533,50 @@ static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, ch
 }
 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 
+static ssize_t show_name(struct device *dev, struct device_attribute
+                         *devattr, char *buf)
+{
+        struct via686a_data *data = dev_get_drvdata(dev);
+        return sprintf(buf, "%s\n", data->name);
+}
+static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
+
 static struct attribute *via686a_attributes[] = {
-        &dev_attr_in0_input.attr,
-        &dev_attr_in1_input.attr,
-        &dev_attr_in2_input.attr,
-        &dev_attr_in3_input.attr,
-        &dev_attr_in4_input.attr,
-        &dev_attr_in0_min.attr,
-        &dev_attr_in1_min.attr,
-        &dev_attr_in2_min.attr,
-        &dev_attr_in3_min.attr,
-        &dev_attr_in4_min.attr,
-        &dev_attr_in0_max.attr,
-        &dev_attr_in1_max.attr,
-        &dev_attr_in2_max.attr,
-        &dev_attr_in3_max.attr,
-        &dev_attr_in4_max.attr,
-
-        &dev_attr_temp1_input.attr,
-        &dev_attr_temp2_input.attr,
-        &dev_attr_temp3_input.attr,
-        &dev_attr_temp1_max.attr,
-        &dev_attr_temp2_max.attr,
-        &dev_attr_temp3_max.attr,
-        &dev_attr_temp1_max_hyst.attr,
-        &dev_attr_temp2_max_hyst.attr,
-        &dev_attr_temp3_max_hyst.attr,
-
-        &dev_attr_fan1_input.attr,
-        &dev_attr_fan2_input.attr,
-        &dev_attr_fan1_min.attr,
-        &dev_attr_fan2_min.attr,
-        &dev_attr_fan1_div.attr,
-        &dev_attr_fan2_div.attr,
+        &sensor_dev_attr_in0_input.dev_attr.attr,
+        &sensor_dev_attr_in1_input.dev_attr.attr,
+        &sensor_dev_attr_in2_input.dev_attr.attr,
+        &sensor_dev_attr_in3_input.dev_attr.attr,
+        &sensor_dev_attr_in4_input.dev_attr.attr,
+        &sensor_dev_attr_in0_min.dev_attr.attr,
+        &sensor_dev_attr_in1_min.dev_attr.attr,
+        &sensor_dev_attr_in2_min.dev_attr.attr,
+        &sensor_dev_attr_in3_min.dev_attr.attr,
+        &sensor_dev_attr_in4_min.dev_attr.attr,
+        &sensor_dev_attr_in0_max.dev_attr.attr,
+        &sensor_dev_attr_in1_max.dev_attr.attr,
+        &sensor_dev_attr_in2_max.dev_attr.attr,
+        &sensor_dev_attr_in3_max.dev_attr.attr,
+        &sensor_dev_attr_in4_max.dev_attr.attr,
+
+        &sensor_dev_attr_temp1_input.dev_attr.attr,
+        &sensor_dev_attr_temp2_input.dev_attr.attr,
+        &sensor_dev_attr_temp3_input.dev_attr.attr,
+        &sensor_dev_attr_temp1_max.dev_attr.attr,
+        &sensor_dev_attr_temp2_max.dev_attr.attr,
+        &sensor_dev_attr_temp3_max.dev_attr.attr,
+        &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
+        &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
+        &sensor_dev_attr_temp3_max_hyst.dev_attr.attr,
+
+        &sensor_dev_attr_fan1_input.dev_attr.attr,
+        &sensor_dev_attr_fan2_input.dev_attr.attr,
+        &sensor_dev_attr_fan1_min.dev_attr.attr,
+        &sensor_dev_attr_fan2_min.dev_attr.attr,
+        &sensor_dev_attr_fan1_div.dev_attr.attr,
+        &sensor_dev_attr_fan2_div.dev_attr.attr,
 
         &dev_attr_alarms.attr,
+        &dev_attr_name.attr,
         NULL
 };
 
@@ -612,58 +584,29 @@ static const struct attribute_group via686a_group = {
         .attrs = via686a_attributes,
 };
 
-/* The driver. I choose to use type i2c_driver, as at is identical to both
-   smbus_driver and isa_driver, and clients could be of either kind */
-static struct i2c_driver via686a_driver = {
+static struct platform_driver via686a_driver = {
         .driver = {
                 .owner  = THIS_MODULE,
                 .name   = "via686a",
         },
-        .attach_adapter = via686a_detect,
-        .detach_client  = via686a_detach_client,
+        .probe          = via686a_probe,
+        .remove         = __devexit_p(via686a_remove),
 };
 
 
 /* This is called when the module is loaded */
-static int via686a_detect(struct i2c_adapter *adapter)
+static int __devinit via686a_probe(struct platform_device *pdev)
 {
-        struct i2c_client *new_client;
         struct via686a_data *data;
-        int err = 0;
-        const char client_name[] = "via686a";
-        u16 val;
-
-        /* 8231 requires multiple of 256, we enforce that on 686 as well */
-        if (force_addr) {
-                address = force_addr & 0xFF00;
-                dev_warn(&adapter->dev, "forcing ISA address 0x%04X\n",
-                         address);
-                if (PCIBIOS_SUCCESSFUL !=
-                    pci_write_config_word(s_bridge, VIA686A_BASE_REG, address))
-                        return -ENODEV;
-        }
-        if (PCIBIOS_SUCCESSFUL !=
-            pci_read_config_word(s_bridge, VIA686A_ENABLE_REG, &val))
-                return -ENODEV;
-        if (!(val & 0x0001)) {
-                if (force_addr) {
-                        dev_info(&adapter->dev, "enabling sensors\n");
-                        if (PCIBIOS_SUCCESSFUL !=
-                            pci_write_config_word(s_bridge, VIA686A_ENABLE_REG,
-                                                  val | 0x0001))
-                                return -ENODEV;
-                } else {
-                        dev_warn(&adapter->dev, "sensors disabled - enable "
-                                 "with force_addr=0x%x\n", address);
-                        return -ENODEV;
-                }
-        }
+        struct resource *res;
+        int err;
 
         /* Reserve the ISA region */
-        if (!request_region(address, VIA686A_EXTENT,
+        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
+        if (!request_region(res->start, VIA686A_EXTENT,
                             via686a_driver.driver.name)) {
-                dev_err(&adapter->dev, "region 0x%x already in use!\n",
-                        address);
+                dev_err(&pdev->dev, "Region 0x%lx-0x%lx already in use!\n",
+                        (unsigned long)res->start, (unsigned long)res->end);
                 return -ENODEV;
         }
 
@@ -672,30 +615,19 @@ static int via686a_detect(struct i2c_adapter *adapter)
                 goto exit_release;
         }
 
-        new_client = &data->client;
-        i2c_set_clientdata(new_client, data);
-        new_client->addr = address;
-        new_client->adapter = adapter;
-        new_client->driver = &via686a_driver;
-        new_client->flags = 0;
-
-        /* Fill in the remaining client fields and put into the global list */
-        strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
-
-        data->valid = 0;
+        platform_set_drvdata(pdev, data);
+        data->addr = res->start;
+        data->name = "via686a";
         mutex_init(&data->update_lock);
-        /* Tell the I2C layer a new client has arrived */
-        if ((err = i2c_attach_client(new_client)))
-                goto exit_free;
 
         /* Initialize the VIA686A chip */
-        via686a_init_client(new_client);
+        via686a_init_device(data);
 
         /* Register sysfs hooks */
-        if ((err = sysfs_create_group(&new_client->dev.kobj, &via686a_group)))
-                goto exit_detach;
+        if ((err = sysfs_create_group(&pdev->dev.kobj, &via686a_group)))
+                goto exit_free;
 
-        data->class_dev = hwmon_device_register(&new_client->dev);
+        data->class_dev = hwmon_device_register(&pdev->dev);
         if (IS_ERR(data->class_dev)) {
                 err = PTR_ERR(data->class_dev);
                 goto exit_remove_files;
@@ -704,51 +636,46 @@ static int via686a_detect(struct i2c_adapter *adapter)
         return 0;
 
 exit_remove_files:
-        sysfs_remove_group(&new_client->dev.kobj, &via686a_group);
-exit_detach:
-        i2c_detach_client(new_client);
+        sysfs_remove_group(&pdev->dev.kobj, &via686a_group);
 exit_free:
         kfree(data);
 exit_release:
-        release_region(address, VIA686A_EXTENT);
+        release_region(res->start, VIA686A_EXTENT);
         return err;
 }
 
-static int via686a_detach_client(struct i2c_client *client)
+static int __devexit via686a_remove(struct platform_device *pdev)
 {
-        struct via686a_data *data = i2c_get_clientdata(client);
-        int err;
+        struct via686a_data *data = platform_get_drvdata(pdev);
 
         hwmon_device_unregister(data->class_dev);
-        sysfs_remove_group(&client->dev.kobj, &via686a_group);
+        sysfs_remove_group(&pdev->dev.kobj, &via686a_group);
 
-        if ((err = i2c_detach_client(client)))
-                return err;
-
-        release_region(client->addr, VIA686A_EXTENT);
+        release_region(data->addr, VIA686A_EXTENT);
+        platform_set_drvdata(pdev, NULL);
         kfree(data);
 
         return 0;
 }
 
-static void via686a_init_client(struct i2c_client *client)
+static void __devinit via686a_init_device(struct via686a_data *data)
 {
         u8 reg;
 
         /* Start monitoring */
-        reg = via686a_read_value(client, VIA686A_REG_CONFIG);
-        via686a_write_value(client, VIA686A_REG_CONFIG, (reg|0x01)&0x7F);
+        reg = via686a_read_value(data, VIA686A_REG_CONFIG);
+        via686a_write_value(data, VIA686A_REG_CONFIG, (reg | 0x01) & 0x7F);
 
         /* Configure temp interrupt mode for continuous-interrupt operation */
-        via686a_write_value(client, VIA686A_REG_TEMP_MODE,
-                            via686a_read_value(client, VIA686A_REG_TEMP_MODE) &
-                            !(VIA686A_TEMP_MODE_MASK | VIA686A_TEMP_MODE_CONTINUOUS));
+        reg = via686a_read_value(data, VIA686A_REG_TEMP_MODE);
+        via686a_write_value(data, VIA686A_REG_TEMP_MODE,
+                            (reg & ~VIA686A_TEMP_MODE_MASK)
+                            | VIA686A_TEMP_MODE_CONTINUOUS);
 }
 
 static struct via686a_data *via686a_update_device(struct device *dev)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct via686a_data *data = i2c_get_clientdata(client);
+        struct via686a_data *data = dev_get_drvdata(dev);
         int i;
 
         mutex_lock(&data->update_lock);
@@ -757,27 +684,27 @@ static struct via686a_data *via686a_update_device(struct device *dev)
             || !data->valid) {
                 for (i = 0; i <= 4; i++) {
                         data->in[i] =
-                            via686a_read_value(client, VIA686A_REG_IN(i));
-                        data->in_min[i] = via686a_read_value(client,
+                            via686a_read_value(data, VIA686A_REG_IN(i));
+                        data->in_min[i] = via686a_read_value(data,
                                                              VIA686A_REG_IN_MIN
                                                              (i));
                         data->in_max[i] =
-                            via686a_read_value(client, VIA686A_REG_IN_MAX(i));
+                            via686a_read_value(data, VIA686A_REG_IN_MAX(i));
                 }
                 for (i = 1; i <= 2; i++) {
                         data->fan[i - 1] =
-                            via686a_read_value(client, VIA686A_REG_FAN(i));
-                        data->fan_min[i - 1] = via686a_read_value(client,
+                            via686a_read_value(data, VIA686A_REG_FAN(i));
+                        data->fan_min[i - 1] = via686a_read_value(data,
                                                      VIA686A_REG_FAN_MIN(i));
                 }
                 for (i = 0; i <= 2; i++) {
-                        data->temp[i] = via686a_read_value(client,
+                        data->temp[i] = via686a_read_value(data,
                                                  VIA686A_REG_TEMP[i]) << 2;
                         data->temp_over[i] =
-                            via686a_read_value(client,
+                            via686a_read_value(data,
                                                VIA686A_REG_TEMP_OVER[i]);
                         data->temp_hyst[i] =
-                            via686a_read_value(client,
+                            via686a_read_value(data,
                                                VIA686A_REG_TEMP_HYST[i]);
                 }
                 /* add in lower 2 bits
@@ -785,23 +712,23 @@ static struct via686a_data *via686a_update_device(struct device *dev)
                    temp2 uses bits 5-4 of VIA686A_REG_TEMP_LOW23
                    temp3 uses bits 7-6 of VIA686A_REG_TEMP_LOW23
                  */
-                data->temp[0] |= (via686a_read_value(client,
+                data->temp[0] |= (via686a_read_value(data,
                                                      VIA686A_REG_TEMP_LOW1)
                                   & 0xc0) >> 6;
                 data->temp[1] |=
-                    (via686a_read_value(client, VIA686A_REG_TEMP_LOW23) &
+                    (via686a_read_value(data, VIA686A_REG_TEMP_LOW23) &
                      0x30) >> 4;
                 data->temp[2] |=
-                    (via686a_read_value(client, VIA686A_REG_TEMP_LOW23) &
+                    (via686a_read_value(data, VIA686A_REG_TEMP_LOW23) &
                      0xc0) >> 6;
 
-                i = via686a_read_value(client, VIA686A_REG_FANDIV);
+                i = via686a_read_value(data, VIA686A_REG_FANDIV);
                 data->fan_div[0] = (i >> 4) & 0x03;
                 data->fan_div[1] = i >> 6;
                 data->alarms =
-                    via686a_read_value(client,
+                    via686a_read_value(data,
                                        VIA686A_REG_ALARM1) |
-                    (via686a_read_value(client, VIA686A_REG_ALARM2) << 8);
+                    (via686a_read_value(data, VIA686A_REG_ALARM2) << 8);
                 data->last_updated = jiffies;
                 data->valid = 1;
         }
@@ -818,32 +745,102 @@ static struct pci_device_id via686a_pci_ids[] = {
 
 MODULE_DEVICE_TABLE(pci, via686a_pci_ids);
 
+static int __devinit via686a_device_add(unsigned short address)
+{
+        struct resource res = {
+                .start  = address,
+                .end    = address + VIA686A_EXTENT - 1,
+                .name   = "via686a",
+                .flags  = IORESOURCE_IO,
+        };
+        int err;
+
+        pdev = platform_device_alloc("via686a", address);
+        if (!pdev) {
+                err = -ENOMEM;
+                printk(KERN_ERR "via686a: Device allocation failed\n");
+                goto exit;
+        }
+
+        err = platform_device_add_resources(pdev, &res, 1);
+        if (err) {
+                printk(KERN_ERR "via686a: Device resource addition failed "
+                       "(%d)\n", err);
+                goto exit_device_put;
+        }
+
+        err = platform_device_add(pdev);
+        if (err) {
+                printk(KERN_ERR "via686a: Device addition failed (%d)\n",
+                       err);
+                goto exit_device_put;
+        }
+
+        return 0;
+
+exit_device_put:
+        platform_device_put(pdev);
+exit:
+        return err;
+}
+
 static int __devinit via686a_pci_probe(struct pci_dev *dev,
                                        const struct pci_device_id *id)
 {
-        u16 val;
+        u16 address, val;
 
+        if (force_addr) {
+                address = force_addr & ~(VIA686A_EXTENT - 1);
+                dev_warn(&dev->dev, "Forcing ISA address 0x%x\n", address);
+                if (PCIBIOS_SUCCESSFUL !=
+                    pci_write_config_word(dev, VIA686A_BASE_REG, address | 1))
+                        return -ENODEV;
+        }
         if (PCIBIOS_SUCCESSFUL !=
             pci_read_config_word(dev, VIA686A_BASE_REG, &val))
                 return -ENODEV;
 
         address = val & ~(VIA686A_EXTENT - 1);
-        if (address == 0 && force_addr == 0) {
+        if (address == 0) {
                 dev_err(&dev->dev, "base address not set - upgrade BIOS "
                         "or use force_addr=0xaddr\n");
                 return -ENODEV;
         }
 
-        s_bridge = pci_dev_get(dev);
-        if (i2c_isa_add_driver(&via686a_driver)) {
-                pci_dev_put(s_bridge);
-                s_bridge = NULL;
+        if (PCIBIOS_SUCCESSFUL !=
+            pci_read_config_word(dev, VIA686A_ENABLE_REG, &val))
+                return -ENODEV;
+        if (!(val & 0x0001)) {
+                if (!force_addr) {
+                        dev_warn(&dev->dev, "Sensors disabled, enable "
+                                 "with force_addr=0x%x\n", address);
+                        return -ENODEV;
+                }
+
+                dev_warn(&dev->dev, "Enabling sensors\n");
+                if (PCIBIOS_SUCCESSFUL !=
+                    pci_write_config_word(dev, VIA686A_ENABLE_REG,
+                                          val | 0x0001))
+                        return -ENODEV;
         }
 
+        if (platform_driver_register(&via686a_driver))
+                goto exit;
+
+        /* Sets global pdev as a side effect */
+        if (via686a_device_add(address))
+                goto exit_unregister;
+
         /* Always return failure here.  This is to allow other drivers to bind
          * to this pci device.  We don't really want to have control over the
          * pci device, we only wanted to read as few register values from it.
          */
+        s_bridge = pci_dev_get(dev);
+        return -ENODEV;
+
+exit_unregister:
+        platform_driver_unregister(&via686a_driver);
+exit:
         return -ENODEV;
 }
 
@@ -862,7 +859,8 @@ static void __exit sm_via686a_exit(void)
 {
         pci_unregister_driver(&via686a_pci_driver);
         if (s_bridge != NULL) {
-                i2c_isa_del_driver(&via686a_driver);
+                platform_device_unregister(pdev);
+                platform_driver_unregister(&via686a_driver);
                 pci_dev_put(s_bridge);
                 s_bridge = NULL;
         }
diff --git a/drivers/hwmon/vt8231.c b/drivers/hwmon/vt8231.c
index a6a4aa0eee16..c604972f0186 100644
--- a/drivers/hwmon/vt8231.c
+++ b/drivers/hwmon/vt8231.c
@@ -29,8 +29,7 @@
 #include <linux/slab.h>
 #include <linux/pci.h>
 #include <linux/jiffies.h>
-#include <linux/i2c.h>
-#include <linux/i2c-isa.h>
+#include <linux/platform_device.h>
 #include <linux/hwmon.h>
 #include <linux/hwmon-sysfs.h>
 #include <linux/hwmon-vid.h>
@@ -42,10 +41,7 @@ static int force_addr;
 module_param(force_addr, int, 0);
 MODULE_PARM_DESC(force_addr, "Initialize the base address of the sensors");
 
-/* Device address
-   Note that we can't determine the ISA address until we have initialized
-   our module */
-static unsigned short isa_address;
+static struct platform_device *pdev;
 
 #define VT8231_EXTENT 0x80
 #define VT8231_BASE_REG 0x70
@@ -148,7 +144,9 @@ static inline u8 FAN_TO_REG(long rpm, int div)
 #define FAN_FROM_REG(val, div) ((val) == 0 ? 0 : 1310720 / ((val) * (div)))
 
 struct vt8231_data {
-        struct i2c_client client;
+        unsigned short addr;
+        const char *name;
+
         struct mutex update_lock;
         struct class_device *class_dev;
         char valid;             /* !=0 if following fields are valid */
@@ -168,20 +166,20 @@ struct vt8231_data {
 };
 
 static struct pci_dev *s_bridge;
-static int vt8231_detect(struct i2c_adapter *adapter);
-static int vt8231_detach_client(struct i2c_client *client);
+static int vt8231_probe(struct platform_device *pdev);
+static int vt8231_remove(struct platform_device *pdev);
 static struct vt8231_data *vt8231_update_device(struct device *dev);
-static void vt8231_init_client(struct i2c_client *client);
+static void vt8231_init_device(struct vt8231_data *data);
 
-static inline int vt8231_read_value(struct i2c_client *client, u8 reg)
+static inline int vt8231_read_value(struct vt8231_data *data, u8 reg)
 {
-        return inb_p(client->addr + reg);
+        return inb_p(data->addr + reg);
 }
 
-static inline void vt8231_write_value(struct i2c_client *client, u8 reg,
+static inline void vt8231_write_value(struct vt8231_data *data, u8 reg,
                                         u8 value)
 {
-        outb_p(value, client->addr + reg);
+        outb_p(value, data->addr + reg);
 }
 
 /* following are the sysfs callback functions */
@@ -220,13 +218,12 @@ static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
 {
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
         int nr = sensor_attr->index;
-        struct i2c_client *client = to_i2c_client(dev);
-        struct vt8231_data *data = i2c_get_clientdata(client);
+        struct vt8231_data *data = dev_get_drvdata(dev);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->in_min[nr] = SENSORS_LIMIT(((val * 958) / 10000) + 3, 0, 255);
-        vt8231_write_value(client, regvoltmin[nr], data->in_min[nr]);
+        vt8231_write_value(data, regvoltmin[nr], data->in_min[nr]);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -236,13 +233,12 @@ static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
 {
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
         int nr = sensor_attr->index;
-        struct i2c_client *client = to_i2c_client(dev);
-        struct vt8231_data *data = i2c_get_clientdata(client);
+        struct vt8231_data *data = dev_get_drvdata(dev);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->in_max[nr] = SENSORS_LIMIT(((val * 958) / 10000) + 3, 0, 255);
-        vt8231_write_value(client, regvoltmax[nr], data->in_max[nr]);
+        vt8231_write_value(data, regvoltmax[nr], data->in_max[nr]);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -278,14 +274,13 @@ static ssize_t show_in5_max(struct device *dev, struct device_attribute *attr,
 static ssize_t set_in5_min(struct device *dev, struct device_attribute *attr,
                 const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct vt8231_data *data = i2c_get_clientdata(client);
+        struct vt8231_data *data = dev_get_drvdata(dev);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->in_min[5] = SENSORS_LIMIT(((val * 958 * 34) / (10000 * 54)) + 3,
                                         0, 255);
-        vt8231_write_value(client, regvoltmin[5], data->in_min[5]);
+        vt8231_write_value(data, regvoltmin[5], data->in_min[5]);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -293,14 +288,13 @@ static ssize_t set_in5_min(struct device *dev, struct device_attribute *attr,
 static ssize_t set_in5_max(struct device *dev, struct device_attribute *attr,
                 const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct vt8231_data *data = i2c_get_clientdata(client);
+        struct vt8231_data *data = dev_get_drvdata(dev);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->in_max[5] = SENSORS_LIMIT(((val * 958 * 34) / (10000 * 54)) + 3,
                                         0, 255);
-        vt8231_write_value(client, regvoltmax[5], data->in_max[5]);
+        vt8231_write_value(data, regvoltmax[5], data->in_max[5]);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -348,26 +342,24 @@ static ssize_t show_temp0_min(struct device *dev, struct device_attribute *attr,
 static ssize_t set_temp0_max(struct device *dev, struct device_attribute *attr,
                 const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct vt8231_data *data = i2c_get_clientdata(client);
+        struct vt8231_data *data = dev_get_drvdata(dev);
         int val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->temp_max[0] = SENSORS_LIMIT((val + 500) / 1000, 0, 255);
-        vt8231_write_value(client, regtempmax[0], data->temp_max[0]);
+        vt8231_write_value(data, regtempmax[0], data->temp_max[0]);
         mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t set_temp0_min(struct device *dev, struct device_attribute *attr,
                 const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct vt8231_data *data = i2c_get_clientdata(client);
+        struct vt8231_data *data = dev_get_drvdata(dev);
         int val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->temp_min[0] = SENSORS_LIMIT((val + 500) / 1000, 0, 255);
-        vt8231_write_value(client, regtempmin[0], data->temp_min[0]);
+        vt8231_write_value(data, regtempmin[0], data->temp_min[0]);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -404,13 +396,12 @@ static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
 {
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
         int nr = sensor_attr->index;
-        struct i2c_client *client = to_i2c_client(dev);
-        struct vt8231_data *data = i2c_get_clientdata(client);
+        struct vt8231_data *data = dev_get_drvdata(dev);
         int val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->temp_max[nr] = SENSORS_LIMIT(TEMP_MAXMIN_TO_REG(val), 0, 255);
-        vt8231_write_value(client, regtempmax[nr], data->temp_max[nr]);
+        vt8231_write_value(data, regtempmax[nr], data->temp_max[nr]);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -419,13 +410,12 @@ static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
 {
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
         int nr = sensor_attr->index;
-        struct i2c_client *client = to_i2c_client(dev);
-        struct vt8231_data *data = i2c_get_clientdata(client);
+        struct vt8231_data *data = dev_get_drvdata(dev);
         int val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->temp_min[nr] = SENSORS_LIMIT(TEMP_MAXMIN_TO_REG(val), 0, 255);
-        vt8231_write_value(client, regtempmin[nr], data->temp_min[nr]);
+        vt8231_write_value(data, regtempmin[nr], data->temp_min[nr]);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -486,13 +476,12 @@ static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
 {
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
         int nr = sensor_attr->index;
-        struct i2c_client *client = to_i2c_client(dev);
-        struct vt8231_data *data = i2c_get_clientdata(client);
+        struct vt8231_data *data = dev_get_drvdata(dev);
         int val = simple_strtoul(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
-        vt8231_write_value(client, VT8231_REG_FAN_MIN(nr), data->fan_min[nr]);
+        vt8231_write_value(data, VT8231_REG_FAN_MIN(nr), data->fan_min[nr]);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -500,12 +489,11 @@ static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
                 const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct vt8231_data *data = i2c_get_clientdata(client);
+        struct vt8231_data *data = dev_get_drvdata(dev);
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
         unsigned long val = simple_strtoul(buf, NULL, 10);
         int nr = sensor_attr->index;
-        int old = vt8231_read_value(client, VT8231_REG_FANDIV);
+        int old = vt8231_read_value(data, VT8231_REG_FANDIV);
         long min = FAN_FROM_REG(data->fan_min[nr],
                                  DIV_FROM_REG(data->fan_div[nr]));
 
@@ -516,7 +504,7 @@ static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
         case 4: data->fan_div[nr] = 2; break;
         case 8: data->fan_div[nr] = 3; break;
         default:
-                dev_err(&client->dev, "fan_div value %ld not supported."
+                dev_err(dev, "fan_div value %ld not supported."
                         "Choose one of 1, 2, 4 or 8!\n", val);
                 mutex_unlock(&data->update_lock);
                 return -EINVAL;
@@ -524,10 +512,10 @@ static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
 
         /* Correct the fan minimum speed */
         data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
-        vt8231_write_value(client, VT8231_REG_FAN_MIN(nr), data->fan_min[nr]);
+        vt8231_write_value(data, VT8231_REG_FAN_MIN(nr), data->fan_min[nr]);
 
         old = (old & 0x0f) | (data->fan_div[1] << 6) | (data->fan_div[0] << 4);
-        vt8231_write_value(client, VT8231_REG_FANDIV, old);
+        vt8231_write_value(data, VT8231_REG_FANDIV, old);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -551,9 +539,16 @@ static ssize_t show_alarms(struct device *dev, struct device_attribute *attr,
         struct vt8231_data *data = vt8231_update_device(dev);
         return sprintf(buf, "%d\n", data->alarms);
 }
-
 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 
+static ssize_t show_name(struct device *dev, struct device_attribute
+                         *devattr, char *buf)
+{
+        struct vt8231_data *data = dev_get_drvdata(dev);
+        return sprintf(buf, "%s\n", data->name);
+}
+static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
+
 static struct attribute *vt8231_attributes_temps[6][4] = {
         {
                 &dev_attr_temp1_input.attr,
@@ -648,6 +643,7 @@ static struct attribute *vt8231_attributes[] = {
         &sensor_dev_attr_fan1_div.dev_attr.attr,
         &sensor_dev_attr_fan2_div.dev_attr.attr,
         &dev_attr_alarms.attr,
+        &dev_attr_name.attr,
         NULL
 };
 
@@ -655,13 +651,13 @@ static const struct attribute_group vt8231_group = {
         .attrs = vt8231_attributes,
 };
 
-static struct i2c_driver vt8231_driver = {
+static struct platform_driver vt8231_driver = {
         .driver = {
                 .owner  = THIS_MODULE,
                 .name   = "vt8231",
         },
-        .attach_adapter = vt8231_detect,
-        .detach_client  = vt8231_detach_client,
+        .probe  = vt8231_probe,
+        .remove = __devexit_p(vt8231_remove),
 };
 
 static struct pci_device_id vt8231_pci_ids[] = {
@@ -680,40 +676,18 @@ static struct pci_driver vt8231_pci_driver = {
         .probe          = vt8231_pci_probe,
 };
 
-int vt8231_detect(struct i2c_adapter *adapter)
+int vt8231_probe(struct platform_device *pdev)
 {
-        struct i2c_client *client;
+        struct resource *res;
         struct vt8231_data *data;
         int err = 0, i;
-        u16 val;
-
-        /* 8231 requires multiple of 256 */
-        if (force_addr) {
-                isa_address = force_addr & 0xFF00;
-                dev_warn(&adapter->dev, "forcing ISA address 0x%04X\n",
-                                 isa_address);
-                if (PCIBIOS_SUCCESSFUL != pci_write_config_word(s_bridge,
-                                                VT8231_BASE_REG, isa_address))
-                        return -ENODEV;
-        }
-
-        if (PCIBIOS_SUCCESSFUL !=
-                pci_read_config_word(s_bridge, VT8231_ENABLE_REG, &val))
-                return -ENODEV;
-
-        if (!(val & 0x0001)) {
-                dev_warn(&adapter->dev, "enabling sensors\n");
-                if (PCIBIOS_SUCCESSFUL !=
-                        pci_write_config_word(s_bridge, VT8231_ENABLE_REG,
-                                                          val | 0x0001))
-                        return -ENODEV;
-        }
 
         /* Reserve the ISA region */
-        if (!request_region(isa_address, VT8231_EXTENT,
-                            vt8231_pci_driver.name)) {
-                dev_err(&adapter->dev, "region 0x%x already in use!\n",
-                           isa_address);
+        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
+        if (!request_region(res->start, VT8231_EXTENT,
+                            vt8231_driver.driver.name)) {
+                dev_err(&pdev->dev, "Region 0x%lx-0x%lx already in use!\n",
+                        (unsigned long)res->start, (unsigned long)res->end);
                 return -ENODEV;
         }
 
@@ -722,33 +696,23 @@ int vt8231_detect(struct i2c_adapter *adapter)
                 goto exit_release;
         }
 
-        client = &data->client;
-        i2c_set_clientdata(client, data);
-        client->addr = isa_address;
-        client->adapter = adapter;
-        client->driver = &vt8231_driver;
-
-        /* Fill in the remaining client fields and put into the global list */
-        strlcpy(client->name, "vt8231", I2C_NAME_SIZE);
+        platform_set_drvdata(pdev, data);
+        data->addr = res->start;
+        data->name = "vt8231";
 
         mutex_init(&data->update_lock);
-
-        /* Tell the I2C layer a new client has arrived */
-        if ((err = i2c_attach_client(client)))
-                goto exit_free;
-
-        vt8231_init_client(client);
+        vt8231_init_device(data);
 
         /* Register sysfs hooks */
-        if ((err = sysfs_create_group(&client->dev.kobj, &vt8231_group)))
-                goto exit_detach;
+        if ((err = sysfs_create_group(&pdev->dev.kobj, &vt8231_group)))
+                goto exit_free;
 
         /* Must update device information to find out the config field */
-        data->uch_config = vt8231_read_value(client, VT8231_REG_UCH_CONFIG);
+        data->uch_config = vt8231_read_value(data, VT8231_REG_UCH_CONFIG);
 
         for (i = 0; i < ARRAY_SIZE(vt8231_group_temps); i++) {
                 if (ISTEMP(i, data->uch_config)) {
-                        if ((err = sysfs_create_group(&client->dev.kobj,
+                        if ((err = sysfs_create_group(&pdev->dev.kobj,
                                         &vt8231_group_temps[i])))
                                 goto exit_remove_files;
                 }
@@ -756,13 +720,13 @@ int vt8231_detect(struct i2c_adapter *adapter)
 
         for (i = 0; i < ARRAY_SIZE(vt8231_group_volts); i++) {
                 if (ISVOLT(i, data->uch_config)) {
-                        if ((err = sysfs_create_group(&client->dev.kobj,
+                        if ((err = sysfs_create_group(&pdev->dev.kobj,
                                         &vt8231_group_volts[i])))
                                 goto exit_remove_files;
                 }
         }
 
-        data->class_dev = hwmon_device_register(&client->dev);
+        data->class_dev = hwmon_device_register(&pdev->dev);
         if (IS_ERR(data->class_dev)) {
                 err = PTR_ERR(data->class_dev);
                 goto exit_remove_files;
@@ -771,56 +735,52 @@ int vt8231_detect(struct i2c_adapter *adapter)
 
 exit_remove_files:
         for (i = 0; i < ARRAY_SIZE(vt8231_group_volts); i++)
-                sysfs_remove_group(&client->dev.kobj, &vt8231_group_volts[i]);
+                sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_volts[i]);
 
         for (i = 0; i < ARRAY_SIZE(vt8231_group_temps); i++)
-                sysfs_remove_group(&client->dev.kobj, &vt8231_group_temps[i]);
+                sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_temps[i]);
+
+        sysfs_remove_group(&pdev->dev.kobj, &vt8231_group);
 
-        sysfs_remove_group(&client->dev.kobj, &vt8231_group);
-exit_detach:
-        i2c_detach_client(client);
 exit_free:
+        platform_set_drvdata(pdev, NULL);
         kfree(data);
+
 exit_release:
-        release_region(isa_address, VT8231_EXTENT);
+        release_region(res->start, VT8231_EXTENT);
         return err;
 }
 
-static int vt8231_detach_client(struct i2c_client *client)
+static int vt8231_remove(struct platform_device *pdev)
 {
-        struct vt8231_data *data = i2c_get_clientdata(client);
-        int err, i;
+        struct vt8231_data *data = platform_get_drvdata(pdev);
+        int i;
 
         hwmon_device_unregister(data->class_dev);
 
         for (i = 0; i < ARRAY_SIZE(vt8231_group_volts); i++)
-                sysfs_remove_group(&client->dev.kobj, &vt8231_group_volts[i]);
+                sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_volts[i]);
 
         for (i = 0; i < ARRAY_SIZE(vt8231_group_temps); i++)
-                sysfs_remove_group(&client->dev.kobj, &vt8231_group_temps[i]);
+                sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_temps[i]);
 
-        sysfs_remove_group(&client->dev.kobj, &vt8231_group);
+        sysfs_remove_group(&pdev->dev.kobj, &vt8231_group);
 
-        if ((err = i2c_detach_client(client))) {
-                return err;
-        }
-
-        release_region(client->addr, VT8231_EXTENT);
+        release_region(data->addr, VT8231_EXTENT);
+        platform_set_drvdata(pdev, NULL);
         kfree(data);
-
         return 0;
 }
 
-static void vt8231_init_client(struct i2c_client *client)
+static void vt8231_init_device(struct vt8231_data *data)
 {
-        vt8231_write_value(client, VT8231_REG_TEMP1_CONFIG, 0);
-        vt8231_write_value(client, VT8231_REG_TEMP2_CONFIG, 0);
+        vt8231_write_value(data, VT8231_REG_TEMP1_CONFIG, 0);
+        vt8231_write_value(data, VT8231_REG_TEMP2_CONFIG, 0);
 }
 
 static struct vt8231_data *vt8231_update_device(struct device *dev)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct vt8231_data *data = i2c_get_clientdata(client);
+        struct vt8231_data *data = dev_get_drvdata(dev);
         int i;
         u16 low;
 
@@ -830,41 +790,41 @@ static struct vt8231_data *vt8231_update_device(struct device *dev)
             || !data->valid) {
                 for (i = 0; i < 6; i++) {
                         if (ISVOLT(i, data->uch_config)) {
-                                data->in[i] = vt8231_read_value(client,
+                                data->in[i] = vt8231_read_value(data,
                                                 regvolt[i]);
-                                data->in_min[i] = vt8231_read_value(client,
+                                data->in_min[i] = vt8231_read_value(data,
                                                 regvoltmin[i]);
-                                data->in_max[i] = vt8231_read_value(client,
+                                data->in_max[i] = vt8231_read_value(data,
                                                 regvoltmax[i]);
                         }
                 }
                 for (i = 0; i < 2; i++) {
-                        data->fan[i] = vt8231_read_value(client,
+                        data->fan[i] = vt8231_read_value(data,
                                                 VT8231_REG_FAN(i));
-                        data->fan_min[i] = vt8231_read_value(client,
+                        data->fan_min[i] = vt8231_read_value(data,
                                                 VT8231_REG_FAN_MIN(i));
                 }
 
-                low = vt8231_read_value(client, VT8231_REG_TEMP_LOW01);
+                low = vt8231_read_value(data, VT8231_REG_TEMP_LOW01);
                 low = (low >> 6) | ((low & 0x30) >> 2)
-                    | (vt8231_read_value(client, VT8231_REG_TEMP_LOW25) << 4);
+                    | (vt8231_read_value(data, VT8231_REG_TEMP_LOW25) << 4);
                 for (i = 0; i < 6; i++) {
                         if (ISTEMP(i, data->uch_config)) {
-                                data->temp[i] = (vt8231_read_value(client,
+                                data->temp[i] = (vt8231_read_value(data,
                                                        regtemp[i]) << 2)
                                                 | ((low >> (2 * i)) & 0x03);
-                                data->temp_max[i] = vt8231_read_value(client,
+                                data->temp_max[i] = vt8231_read_value(data,
                                                       regtempmax[i]);
-                                data->temp_min[i] = vt8231_read_value(client,
+                                data->temp_min[i] = vt8231_read_value(data,
                                                       regtempmin[i]);
                         }
                 }
 
-                i = vt8231_read_value(client, VT8231_REG_FANDIV);
+                i = vt8231_read_value(data, VT8231_REG_FANDIV);
                 data->fan_div[0] = (i >> 4) & 0x03;
                 data->fan_div[1] = i >> 6;
-                data->alarms = vt8231_read_value(client, VT8231_REG_ALARM1) |
-                        (vt8231_read_value(client, VT8231_REG_ALARM2) << 8);
+                data->alarms = vt8231_read_value(data, VT8231_REG_ALARM1) |
+                        (vt8231_read_value(data, VT8231_REG_ALARM2) << 8);
 
                 /* Set alarm flags correctly */
                 if (!data->fan[0] && data->fan_min[0]) {
@@ -888,33 +848,102 @@ static struct vt8231_data *vt8231_update_device(struct device *dev)
         return data;
 }
 
+static int __devinit vt8231_device_add(unsigned short address)
+{
+        struct resource res = {
+                .start  = address,
+                .end    = address + VT8231_EXTENT - 1,
+                .name   = "vt8231",
+                .flags  = IORESOURCE_IO,
+        };
+        int err;
+
+        pdev = platform_device_alloc("vt8231", address);
+        if (!pdev) {
+                err = -ENOMEM;
+                printk(KERN_ERR "vt8231: Device allocation failed\n");
+                goto exit;
+        }
+
+        err = platform_device_add_resources(pdev, &res, 1);
+        if (err) {
+                printk(KERN_ERR "vt8231: Device resource addition failed "
+                       "(%d)\n", err);
+                goto exit_device_put;
+        }
+
+        err = platform_device_add(pdev);
+        if (err) {
+                printk(KERN_ERR "vt8231: Device addition failed (%d)\n",
+                       err);
+                goto exit_device_put;
+        }
+
+        return 0;
+
+exit_device_put:
+        platform_device_put(pdev);
+exit:
+        return err;
+}
+
 static int __devinit vt8231_pci_probe(struct pci_dev *dev,
                                 const struct pci_device_id *id)
 {
-        u16 val;
+        u16 address, val;
+        if (force_addr) {
+                address = force_addr & 0xff00;
+                dev_warn(&dev->dev, "Forcing ISA address 0x%x\n",
+                         address);
+
+                if (PCIBIOS_SUCCESSFUL !=
+                    pci_write_config_word(dev, VT8231_BASE_REG, address | 1))
+                        return -ENODEV;
+        }
 
         if (PCIBIOS_SUCCESSFUL != pci_read_config_word(dev, VT8231_BASE_REG,
                                                         &val))
                 return -ENODEV;
 
-        isa_address = val & ~(VT8231_EXTENT - 1);
-        if (isa_address == 0 && force_addr == 0) {
+        address = val & ~(VT8231_EXTENT - 1);
+        if (address == 0) {
                 dev_err(&dev->dev, "base address not set -\
                                  upgrade BIOS or use force_addr=0xaddr\n");
                 return -ENODEV;
         }
 
-        s_bridge = pci_dev_get(dev);
+        if (PCIBIOS_SUCCESSFUL != pci_read_config_word(dev, VT8231_ENABLE_REG,
+                                                        &val))
+                return -ENODEV;
 
-        if (i2c_isa_add_driver(&vt8231_driver)) {
-                pci_dev_put(s_bridge);
-                s_bridge = NULL;
+        if (!(val & 0x0001)) {
+                dev_warn(&dev->dev, "enabling sensors\n");
+                if (PCIBIOS_SUCCESSFUL !=
+                        pci_write_config_word(dev, VT8231_ENABLE_REG,
+                                                        val | 0x0001))
+                        return -ENODEV;
         }
 
+        if (platform_driver_register(&vt8231_driver))
+                goto exit;
+
+        /* Sets global pdev as a side effect */
+        if (vt8231_device_add(address))
+                goto exit_unregister;
+
         /* Always return failure here.  This is to allow other drivers to bind
          * to this pci device.  We don't really want to have control over the
          * pci device, we only wanted to read as few register values from it.
          */
+
+        /* We do, however, mark ourselves as using the PCI device to stop it
+           getting unloaded. */
+        s_bridge = pci_dev_get(dev);
+        return -ENODEV;
+
+exit_unregister:
+        platform_driver_unregister(&vt8231_driver);
+exit:
         return -ENODEV;
 }
 
@@ -927,7 +956,8 @@ static void __exit sm_vt8231_exit(void)
 {
         pci_unregister_driver(&vt8231_pci_driver);
         if (s_bridge != NULL) {
-                i2c_isa_del_driver(&vt8231_driver);
+                platform_device_unregister(pdev);
+                platform_driver_unregister(&vt8231_driver);
                 pci_dev_put(s_bridge);
                 s_bridge = NULL;
         }
diff --git a/drivers/hwmon/w83627ehf.c b/drivers/hwmon/w83627ehf.c
index 30a76404f0af..c51ae2e17758 100644
--- a/drivers/hwmon/w83627ehf.c
+++ b/drivers/hwmon/w83627ehf.c
@@ -41,41 +41,39 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/slab.h>
-#include <linux/i2c.h>
-#include <linux/i2c-isa.h>
+#include <linux/jiffies.h>
+#include <linux/platform_device.h>
 #include <linux/hwmon.h>
 #include <linux/hwmon-sysfs.h>
+#include <linux/hwmon-vid.h>
 #include <linux/err.h>
 #include <linux/mutex.h>
 #include <asm/io.h>
 #include "lm75.h"
 
-/* The actual ISA address is read from Super-I/O configuration space */
-static unsigned short address;
+enum kinds { w83627ehf, w83627dhg };
 
-/*
- * Super-I/O constants and functions
- */
+/* used to set data->name = w83627ehf_device_names[data->sio_kind] */
+static const char * w83627ehf_device_names[] = {
+        "w83627ehf",
+        "w83627dhg",
+};
+
+#define DRVNAME "w83627ehf"
 
 /*
- * The three following globals are initialized in w83627ehf_find(), before
- * the i2c-isa device is created. Otherwise, they could be stored in
- * w83627ehf_data. This is ugly, but necessary, and when the driver is next
- * updated to become a platform driver, the globals will disappear.
+ * Super-I/O constants and functions
  */
-static int REG;         /* The register to read/write */
-static int VAL;         /* The value to read/write */
-/* The w83627ehf/ehg have 10 voltage inputs, but the w83627dhg has 9. This
- * value is also used in w83627ehf_detect() to export a device name in sysfs
- * (e.g. w83627ehf or w83627dhg) */
-static int w83627ehf_num_in;
 
 #define W83627EHF_LD_HWM        0x0b
 
 #define SIO_REG_LDSEL           0x07    /* Logical device select */
 #define SIO_REG_DEVID           0x20    /* Device ID (2 bytes) */
+#define SIO_REG_EN_VRM10        0x2C    /* GPIO3, GPIO4 selection */
 #define SIO_REG_ENABLE          0x30    /* Logical device enable */
 #define SIO_REG_ADDR            0x60    /* Logical device address (2 bytes) */
+#define SIO_REG_VID_CTRL        0xF0    /* VID control */
+#define SIO_REG_VID_DATA        0xF1    /* VID data */
 
 #define SIO_W83627EHF_ID        0x8850
 #define SIO_W83627EHG_ID        0x8860
@@ -83,38 +81,38 @@ static int w83627ehf_num_in;
 #define SIO_ID_MASK             0xFFF0
 
 static inline void
-superio_outb(int reg, int val)
+superio_outb(int ioreg, int reg, int val)
 {
-        outb(reg, REG);
-        outb(val, VAL);
+        outb(reg, ioreg);
+        outb(val, ioreg + 1);
 }
 
 static inline int
-superio_inb(int reg)
+superio_inb(int ioreg, int reg)
 {
-        outb(reg, REG);
-        return inb(VAL);
+        outb(reg, ioreg);
+        return inb(ioreg + 1);
 }
 
 static inline void
-superio_select(int ld)
+superio_select(int ioreg, int ld)
 {
-        outb(SIO_REG_LDSEL, REG);
-        outb(ld, VAL);
+        outb(SIO_REG_LDSEL, ioreg);
+        outb(ld, ioreg + 1);
 }
 
 static inline void
-superio_enter(void)
+superio_enter(int ioreg)
 {
-        outb(0x87, REG);
-        outb(0x87, REG);
+        outb(0x87, ioreg);
+        outb(0x87, ioreg);
 }
 
 static inline void
-superio_exit(void)
+superio_exit(int ioreg)
 {
-        outb(0x02, REG);
-        outb(0x02, VAL);
+        outb(0x02, ioreg);
+        outb(0x02, ioreg + 1);
 }
 
 /*
@@ -124,8 +122,8 @@ superio_exit(void)
 #define IOREGION_ALIGNMENT      ~7
 #define IOREGION_OFFSET         5
 #define IOREGION_LENGTH         2
-#define ADDR_REG_OFFSET         5
-#define DATA_REG_OFFSET         6
+#define ADDR_REG_OFFSET         0
+#define DATA_REG_OFFSET         1
 
 #define W83627EHF_REG_BANK              0x4E
 #define W83627EHF_REG_CONFIG            0x40
@@ -255,7 +253,9 @@ static inline u8 in_to_reg(u32 val, u8 nr)
  */
 
 struct w83627ehf_data {
-        struct i2c_client client;
+        int addr;       /* IO base of hw monitor block */
+        const char *name;
+
         struct class_device *class_dev;
         struct mutex lock;
 
@@ -264,6 +264,7 @@ struct w83627ehf_data {
         unsigned long last_updated;     /* In jiffies */
 
         /* Register values */
+        u8 in_num;              /* number of in inputs we have */
         u8 in[10];              /* Register value */
         u8 in_max[10];          /* Register value */
         u8 in_min[10];          /* Register value */
@@ -271,6 +272,7 @@ struct w83627ehf_data {
         u8 fan_min[5];
         u8 fan_div[5];
         u8 has_fan;             /* some fan inputs can be disabled */
+        u8 temp_type[3];
         s8 temp1;
         s8 temp1_max;
         s8 temp1_max_hyst;
@@ -288,6 +290,14 @@ struct w83627ehf_data {
 
         u8 fan_min_output[4]; /* minimum fan speed */
         u8 fan_stop_time[4];
+
+        u8 vid;
+        u8 vrm;
+};
+
+struct w83627ehf_sio_data {
+        int sioreg;
+        enum kinds kind;
 };
 
 static inline int is_word_sized(u16 reg)
@@ -303,156 +313,152 @@ static inline int is_word_sized(u16 reg)
    nothing for registers which live in bank 0. For others, they respectively
    set the bank register to the correct value (before the register is
    accessed), and back to 0 (afterwards). */
-static inline void w83627ehf_set_bank(struct i2c_client *client, u16 reg)
+static inline void w83627ehf_set_bank(struct w83627ehf_data *data, u16 reg)
 {
         if (reg & 0xff00) {
-                outb_p(W83627EHF_REG_BANK, client->addr + ADDR_REG_OFFSET);
-                outb_p(reg >> 8, client->addr + DATA_REG_OFFSET);
+                outb_p(W83627EHF_REG_BANK, data->addr + ADDR_REG_OFFSET);
+                outb_p(reg >> 8, data->addr + DATA_REG_OFFSET);
         }
 }
 
-static inline void w83627ehf_reset_bank(struct i2c_client *client, u16 reg)
+static inline void w83627ehf_reset_bank(struct w83627ehf_data *data, u16 reg)
 {
         if (reg & 0xff00) {
-                outb_p(W83627EHF_REG_BANK, client->addr + ADDR_REG_OFFSET);
-                outb_p(0, client->addr + DATA_REG_OFFSET);
+                outb_p(W83627EHF_REG_BANK, data->addr + ADDR_REG_OFFSET);
+                outb_p(0, data->addr + DATA_REG_OFFSET);
         }
 }
 
-static u16 w83627ehf_read_value(struct i2c_client *client, u16 reg)
+static u16 w83627ehf_read_value(struct w83627ehf_data *data, u16 reg)
 {
-        struct w83627ehf_data *data = i2c_get_clientdata(client);
         int res, word_sized = is_word_sized(reg);
 
         mutex_lock(&data->lock);
 
-        w83627ehf_set_bank(client, reg);
-        outb_p(reg & 0xff, client->addr + ADDR_REG_OFFSET);
-        res = inb_p(client->addr + DATA_REG_OFFSET);
+        w83627ehf_set_bank(data, reg);
+        outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET);
+        res = inb_p(data->addr + DATA_REG_OFFSET);
         if (word_sized) {
                 outb_p((reg & 0xff) + 1,
-                       client->addr + ADDR_REG_OFFSET);
-                res = (res << 8) + inb_p(client->addr + DATA_REG_OFFSET);
+                       data->addr + ADDR_REG_OFFSET);
+                res = (res << 8) + inb_p(data->addr + DATA_REG_OFFSET);
         }
-        w83627ehf_reset_bank(client, reg);
+        w83627ehf_reset_bank(data, reg);
 
         mutex_unlock(&data->lock);
 
         return res;
 }
 
-static int w83627ehf_write_value(struct i2c_client *client, u16 reg, u16 value)
+static int w83627ehf_write_value(struct w83627ehf_data *data, u16 reg, u16 value)
 {
-        struct w83627ehf_data *data = i2c_get_clientdata(client);
         int word_sized = is_word_sized(reg);
 
         mutex_lock(&data->lock);
 
-        w83627ehf_set_bank(client, reg);
-        outb_p(reg & 0xff, client->addr + ADDR_REG_OFFSET);
+        w83627ehf_set_bank(data, reg);
+        outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET);
         if (word_sized) {
-                outb_p(value >> 8, client->addr + DATA_REG_OFFSET);
+                outb_p(value >> 8, data->addr + DATA_REG_OFFSET);
                 outb_p((reg & 0xff) + 1,
-                       client->addr + ADDR_REG_OFFSET);
+                       data->addr + ADDR_REG_OFFSET);
         }
-        outb_p(value & 0xff, client->addr + DATA_REG_OFFSET);
-        w83627ehf_reset_bank(client, reg);
+        outb_p(value & 0xff, data->addr + DATA_REG_OFFSET);
+        w83627ehf_reset_bank(data, reg);
 
         mutex_unlock(&data->lock);
         return 0;
 }
 
 /* This function assumes that the caller holds data->update_lock */
-static void w83627ehf_write_fan_div(struct i2c_client *client, int nr)
+static void w83627ehf_write_fan_div(struct w83627ehf_data *data, int nr)
 {
-        struct w83627ehf_data *data = i2c_get_clientdata(client);
         u8 reg;
 
         switch (nr) {
         case 0:
-                reg = (w83627ehf_read_value(client, W83627EHF_REG_FANDIV1) & 0xcf)
+                reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV1) & 0xcf)
                     | ((data->fan_div[0] & 0x03) << 4);
                 /* fan5 input control bit is write only, compute the value */
                 reg |= (data->has_fan & (1 << 4)) ? 1 : 0;
-                w83627ehf_write_value(client, W83627EHF_REG_FANDIV1, reg);
-                reg = (w83627ehf_read_value(client, W83627EHF_REG_VBAT) & 0xdf)
+                w83627ehf_write_value(data, W83627EHF_REG_FANDIV1, reg);
+                reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0xdf)
                     | ((data->fan_div[0] & 0x04) << 3);
-                w83627ehf_write_value(client, W83627EHF_REG_VBAT, reg);
+                w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg);
                 break;
         case 1:
-                reg = (w83627ehf_read_value(client, W83627EHF_REG_FANDIV1) & 0x3f)
+                reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV1) & 0x3f)
                     | ((data->fan_div[1] & 0x03) << 6);
                 /* fan5 input control bit is write only, compute the value */
                 reg |= (data->has_fan & (1 << 4)) ? 1 : 0;
-                w83627ehf_write_value(client, W83627EHF_REG_FANDIV1, reg);
-                reg = (w83627ehf_read_value(client, W83627EHF_REG_VBAT) & 0xbf)
+                w83627ehf_write_value(data, W83627EHF_REG_FANDIV1, reg);
+                reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0xbf)
                     | ((data->fan_div[1] & 0x04) << 4);
-                w83627ehf_write_value(client, W83627EHF_REG_VBAT, reg);
+                w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg);
                 break;
         case 2:
-                reg = (w83627ehf_read_value(client, W83627EHF_REG_FANDIV2) & 0x3f)
+                reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV2) & 0x3f)
                     | ((data->fan_div[2] & 0x03) << 6);
-                w83627ehf_write_value(client, W83627EHF_REG_FANDIV2, reg);
-                reg = (w83627ehf_read_value(client, W83627EHF_REG_VBAT) & 0x7f)
+                w83627ehf_write_value(data, W83627EHF_REG_FANDIV2, reg);
+                reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0x7f)
                     | ((data->fan_div[2] & 0x04) << 5);
-                w83627ehf_write_value(client, W83627EHF_REG_VBAT, reg);
+                w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg);
                 break;
         case 3:
-                reg = (w83627ehf_read_value(client, W83627EHF_REG_DIODE) & 0xfc)
+                reg = (w83627ehf_read_value(data, W83627EHF_REG_DIODE) & 0xfc)
                     | (data->fan_div[3] & 0x03);
-                w83627ehf_write_value(client, W83627EHF_REG_DIODE, reg);
-                reg = (w83627ehf_read_value(client, W83627EHF_REG_SMI_OVT) & 0x7f)
+                w83627ehf_write_value(data, W83627EHF_REG_DIODE, reg);
+                reg = (w83627ehf_read_value(data, W83627EHF_REG_SMI_OVT) & 0x7f)
                     | ((data->fan_div[3] & 0x04) << 5);
-                w83627ehf_write_value(client, W83627EHF_REG_SMI_OVT, reg);
+                w83627ehf_write_value(data, W83627EHF_REG_SMI_OVT, reg);
                 break;
         case 4:
-                reg = (w83627ehf_read_value(client, W83627EHF_REG_DIODE) & 0x73)
+                reg = (w83627ehf_read_value(data, W83627EHF_REG_DIODE) & 0x73)
                     | ((data->fan_div[4] & 0x03) << 2)
                     | ((data->fan_div[4] & 0x04) << 5);
-                w83627ehf_write_value(client, W83627EHF_REG_DIODE, reg);
+                w83627ehf_write_value(data, W83627EHF_REG_DIODE, reg);
                 break;
         }
 }
 
 static struct w83627ehf_data *w83627ehf_update_device(struct device *dev)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct w83627ehf_data *data = i2c_get_clientdata(client);
+        struct w83627ehf_data *data = dev_get_drvdata(dev);
         int pwmcfg = 0, tolerance = 0; /* shut up the compiler */
         int i;
 
         mutex_lock(&data->update_lock);
 
-        if (time_after(jiffies, data->last_updated + HZ)
+        if (time_after(jiffies, data->last_updated + HZ + HZ/2)
          || !data->valid) {
                 /* Fan clock dividers */
-                i = w83627ehf_read_value(client, W83627EHF_REG_FANDIV1);
+                i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV1);
                 data->fan_div[0] = (i >> 4) & 0x03;
                 data->fan_div[1] = (i >> 6) & 0x03;
-                i = w83627ehf_read_value(client, W83627EHF_REG_FANDIV2);
+                i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV2);
                 data->fan_div[2] = (i >> 6) & 0x03;
-                i = w83627ehf_read_value(client, W83627EHF_REG_VBAT);
+                i = w83627ehf_read_value(data, W83627EHF_REG_VBAT);
                 data->fan_div[0] |= (i >> 3) & 0x04;
                 data->fan_div[1] |= (i >> 4) & 0x04;
                 data->fan_div[2] |= (i >> 5) & 0x04;
                 if (data->has_fan & ((1 << 3) | (1 << 4))) {
-                        i = w83627ehf_read_value(client, W83627EHF_REG_DIODE);
+                        i = w83627ehf_read_value(data, W83627EHF_REG_DIODE);
                         data->fan_div[3] = i & 0x03;
                         data->fan_div[4] = ((i >> 2) & 0x03)
                                          | ((i >> 5) & 0x04);
                 }
                 if (data->has_fan & (1 << 3)) {
-                        i = w83627ehf_read_value(client, W83627EHF_REG_SMI_OVT);
+                        i = w83627ehf_read_value(data, W83627EHF_REG_SMI_OVT);
                         data->fan_div[3] |= (i >> 5) & 0x04;
                 }
 
                 /* Measured voltages and limits */
-                for (i = 0; i < w83627ehf_num_in; i++) {
-                        data->in[i] = w83627ehf_read_value(client,
+                for (i = 0; i < data->in_num; i++) {
+                        data->in[i] = w83627ehf_read_value(data,
                                       W83627EHF_REG_IN(i));
-                        data->in_min[i] = w83627ehf_read_value(client,
+                        data->in_min[i] = w83627ehf_read_value(data,
                                           W83627EHF_REG_IN_MIN(i));
-                        data->in_max[i] = w83627ehf_read_value(client,
+                        data->in_max[i] = w83627ehf_read_value(data,
                                           W83627EHF_REG_IN_MAX(i));
                 }
 
@@ -461,9 +467,9 @@ static struct w83627ehf_data *w83627ehf_update_device(struct device *dev)
                         if (!(data->has_fan & (1 << i)))
                                 continue;
 
-                        data->fan[i] = w83627ehf_read_value(client,
+                        data->fan[i] = w83627ehf_read_value(data,
                                        W83627EHF_REG_FAN[i]);
-                        data->fan_min[i] = w83627ehf_read_value(client,
+                        data->fan_min[i] = w83627ehf_read_value(data,
                                            W83627EHF_REG_FAN_MIN[i]);
 
                         /* If we failed to measure the fan speed and clock
@@ -471,16 +477,16 @@ static struct w83627ehf_data *w83627ehf_update_device(struct device *dev)
                            time */
                         if (data->fan[i] == 0xff
                          && data->fan_div[i] < 0x07) {
-                                dev_dbg(&client->dev, "Increasing fan%d "
+                                dev_dbg(dev, "Increasing fan%d "
                                         "clock divider from %u to %u\n",
                                         i + 1, div_from_reg(data->fan_div[i]),
                                         div_from_reg(data->fan_div[i] + 1));
                                 data->fan_div[i]++;
-                                w83627ehf_write_fan_div(client, i);
+                                w83627ehf_write_fan_div(data, i);
                                 /* Preserve min limit if possible */
                                 if (data->fan_min[i] >= 2
                                  && data->fan_min[i] != 255)
-                                        w83627ehf_write_value(client,
+                                        w83627ehf_write_value(data,
                                                 W83627EHF_REG_FAN_MIN[i],
                                                 (data->fan_min[i] /= 2));
                         }
@@ -489,9 +495,9 @@ static struct w83627ehf_data *w83627ehf_update_device(struct device *dev)
                 for (i = 0; i < 4; i++) {
                         /* pwmcfg, tolarance mapped for i=0, i=1 to same reg */
                         if (i != 1) {
-                                pwmcfg = w83627ehf_read_value(client,
+                                pwmcfg = w83627ehf_read_value(data,
                                                 W83627EHF_REG_PWM_ENABLE[i]);
-                                tolerance = w83627ehf_read_value(client,
+                                tolerance = w83627ehf_read_value(data,
                                                 W83627EHF_REG_TOLERANCE[i]);
                         }
                         data->pwm_mode[i] =
@@ -500,14 +506,14 @@ static struct w83627ehf_data *w83627ehf_update_device(struct device *dev)
                         data->pwm_enable[i] =
                                         ((pwmcfg >> W83627EHF_PWM_ENABLE_SHIFT[i])
                                                 & 3) + 1;
-                        data->pwm[i] = w83627ehf_read_value(client,
+                        data->pwm[i] = w83627ehf_read_value(data,
                                                 W83627EHF_REG_PWM[i]);
-                        data->fan_min_output[i] = w83627ehf_read_value(client,
+                        data->fan_min_output[i] = w83627ehf_read_value(data,
                                                 W83627EHF_REG_FAN_MIN_OUTPUT[i]);
-                        data->fan_stop_time[i] = w83627ehf_read_value(client,
+                        data->fan_stop_time[i] = w83627ehf_read_value(data,
                                                 W83627EHF_REG_FAN_STOP_TIME[i]);
                         data->target_temp[i] =
-                                w83627ehf_read_value(client,
+                                w83627ehf_read_value(data,
                                         W83627EHF_REG_TARGET[i]) &
                                         (data->pwm_mode[i] == 1 ? 0x7f : 0xff);
                         data->tolerance[i] = (tolerance >> (i == 1 ? 4 : 0))
@@ -515,26 +521,26 @@ static struct w83627ehf_data *w83627ehf_update_device(struct device *dev)
                 }
 
                 /* Measured temperatures and limits */
-                data->temp1 = w83627ehf_read_value(client,
+                data->temp1 = w83627ehf_read_value(data,
                               W83627EHF_REG_TEMP1);
-                data->temp1_max = w83627ehf_read_value(client,
+                data->temp1_max = w83627ehf_read_value(data,
                                   W83627EHF_REG_TEMP1_OVER);
-                data->temp1_max_hyst = w83627ehf_read_value(client,
+                data->temp1_max_hyst = w83627ehf_read_value(data,
                                        W83627EHF_REG_TEMP1_HYST);
                 for (i = 0; i < 2; i++) {
-                        data->temp[i] = w83627ehf_read_value(client,
+                        data->temp[i] = w83627ehf_read_value(data,
                                         W83627EHF_REG_TEMP[i]);
-                        data->temp_max[i] = w83627ehf_read_value(client,
+                        data->temp_max[i] = w83627ehf_read_value(data,
                                             W83627EHF_REG_TEMP_OVER[i]);
-                        data->temp_max_hyst[i] = w83627ehf_read_value(client,
+                        data->temp_max_hyst[i] = w83627ehf_read_value(data,
                                                  W83627EHF_REG_TEMP_HYST[i]);
                 }
 
-                data->alarms = w83627ehf_read_value(client,
+                data->alarms = w83627ehf_read_value(data,
                                         W83627EHF_REG_ALARM1) |
-                               (w83627ehf_read_value(client,
+                               (w83627ehf_read_value(data,
                                         W83627EHF_REG_ALARM2) << 8) |
-                               (w83627ehf_read_value(client,
+                               (w83627ehf_read_value(data,
                                         W83627EHF_REG_ALARM3) << 16);
 
                 data->last_updated = jiffies;
@@ -567,15 +573,14 @@ static ssize_t \
 store_in_##reg (struct device *dev, struct device_attribute *attr, \
                         const char *buf, size_t count) \
 { \
-        struct i2c_client *client = to_i2c_client(dev); \
-        struct w83627ehf_data *data = i2c_get_clientdata(client); \
+        struct w83627ehf_data *data = dev_get_drvdata(dev); \
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
         int nr = sensor_attr->index; \
         u32 val = simple_strtoul(buf, NULL, 10); \
  \
         mutex_lock(&data->update_lock); \
         data->in_##reg[nr] = in_to_reg(val, nr); \
-        w83627ehf_write_value(client, W83627EHF_REG_IN_##REG(nr), \
+        w83627ehf_write_value(data, W83627EHF_REG_IN_##REG(nr), \
                               data->in_##reg[nr]); \
         mutex_unlock(&data->update_lock); \
         return count; \
@@ -673,8 +678,7 @@ static ssize_t
 store_fan_min(struct device *dev, struct device_attribute *attr,
               const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct w83627ehf_data *data = i2c_get_clientdata(client);
+        struct w83627ehf_data *data = dev_get_drvdata(dev);
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
         int nr = sensor_attr->index;
         unsigned int val = simple_strtoul(buf, NULL, 10);
@@ -716,18 +720,25 @@ store_fan_min(struct device *dev, struct device_attribute *attr,
         /* Write both the fan clock divider (if it changed) and the new
            fan min (unconditionally) */
         if (new_div != data->fan_div[nr]) {
-                if (new_div > data->fan_div[nr])
-                        data->fan[nr] >>= (data->fan_div[nr] - new_div);
-                else
-                        data->fan[nr] <<= (new_div - data->fan_div[nr]);
+                /* Preserve the fan speed reading */
+                if (data->fan[nr] != 0xff) {
+                        if (new_div > data->fan_div[nr])
+                                data->fan[nr] >>= new_div - data->fan_div[nr];
+                        else if (data->fan[nr] & 0x80)
+                                data->fan[nr] = 0xff;
+                        else
+                                data->fan[nr] <<= data->fan_div[nr] - new_div;
+                }
 
                 dev_dbg(dev, "fan%u clock divider changed from %u to %u\n",
                         nr + 1, div_from_reg(data->fan_div[nr]),
                         div_from_reg(new_div));
                 data->fan_div[nr] = new_div;
-                w83627ehf_write_fan_div(client, nr);
+                w83627ehf_write_fan_div(data, nr);
+                /* Give the chip time to sample a new speed value */
+                data->last_updated = jiffies;
         }
-        w83627ehf_write_value(client, W83627EHF_REG_FAN_MIN[nr],
+        w83627ehf_write_value(data, W83627EHF_REG_FAN_MIN[nr],
                               data->fan_min[nr]);
         mutex_unlock(&data->update_lock);
 
@@ -788,13 +799,12 @@ static ssize_t \
 store_temp1_##reg(struct device *dev, struct device_attribute *attr, \
                   const char *buf, size_t count) \
 { \
-        struct i2c_client *client = to_i2c_client(dev); \
-        struct w83627ehf_data *data = i2c_get_clientdata(client); \
+        struct w83627ehf_data *data = dev_get_drvdata(dev); \
         u32 val = simple_strtoul(buf, NULL, 10); \
  \
         mutex_lock(&data->update_lock); \
         data->temp1_##reg = temp1_to_reg(val, -128000, 127000); \
-        w83627ehf_write_value(client, W83627EHF_REG_TEMP1_##REG, \
+        w83627ehf_write_value(data, W83627EHF_REG_TEMP1_##REG, \
                               data->temp1_##reg); \
         mutex_unlock(&data->update_lock); \
         return count; \
@@ -822,15 +832,14 @@ static ssize_t \
 store_##reg(struct device *dev, struct device_attribute *attr, \
             const char *buf, size_t count) \
 { \
-        struct i2c_client *client = to_i2c_client(dev); \
-        struct w83627ehf_data *data = i2c_get_clientdata(client); \
+        struct w83627ehf_data *data = dev_get_drvdata(dev); \
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
         int nr = sensor_attr->index; \
         u32 val = simple_strtoul(buf, NULL, 10); \
  \
         mutex_lock(&data->update_lock); \
         data->reg[nr] = LM75_TEMP_TO_REG(val); \
-        w83627ehf_write_value(client, W83627EHF_REG_TEMP_##REG[nr], \
+        w83627ehf_write_value(data, W83627EHF_REG_TEMP_##REG[nr], \
                               data->reg[nr]); \
         mutex_unlock(&data->update_lock); \
         return count; \
@@ -838,6 +847,15 @@ store_##reg(struct device *dev, struct device_attribute *attr, \
 store_temp_reg(OVER, temp_max);
 store_temp_reg(HYST, temp_max_hyst);
 
+static ssize_t
+show_temp_type(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct w83627ehf_data *data = w83627ehf_update_device(dev);
+        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+        int nr = sensor_attr->index;
+        return sprintf(buf, "%d\n", (int)data->temp_type[nr]);
+}
+
 static struct sensor_device_attribute sda_temp[] = {
         SENSOR_ATTR(temp1_input, S_IRUGO, show_temp1, NULL, 0),
         SENSOR_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 0),
@@ -857,6 +875,9 @@ static struct sensor_device_attribute sda_temp[] = {
         SENSOR_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4),
         SENSOR_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5),
         SENSOR_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13),
+        SENSOR_ATTR(temp1_type, S_IRUGO, show_temp_type, NULL, 0),
+        SENSOR_ATTR(temp2_type, S_IRUGO, show_temp_type, NULL, 1),
+        SENSOR_ATTR(temp3_type, S_IRUGO, show_temp_type, NULL, 2),
 };
 
 #define show_pwm_reg(reg) \
@@ -877,8 +898,7 @@ static ssize_t
 store_pwm_mode(struct device *dev, struct device_attribute *attr,
                         const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct w83627ehf_data *data = i2c_get_clientdata(client);
+        struct w83627ehf_data *data = dev_get_drvdata(dev);
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
         int nr = sensor_attr->index;
         u32 val = simple_strtoul(buf, NULL, 10);
@@ -887,12 +907,12 @@ store_pwm_mode(struct device *dev, struct device_attribute *attr,
         if (val > 1)
                 return -EINVAL;
         mutex_lock(&data->update_lock);
-        reg = w83627ehf_read_value(client, W83627EHF_REG_PWM_ENABLE[nr]);
+        reg = w83627ehf_read_value(data, W83627EHF_REG_PWM_ENABLE[nr]);
         data->pwm_mode[nr] = val;
         reg &= ~(1 << W83627EHF_PWM_MODE_SHIFT[nr]);
         if (!val)
                 reg |= 1 << W83627EHF_PWM_MODE_SHIFT[nr];
-        w83627ehf_write_value(client, W83627EHF_REG_PWM_ENABLE[nr], reg);
+        w83627ehf_write_value(data, W83627EHF_REG_PWM_ENABLE[nr], reg);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -901,15 +921,14 @@ static ssize_t
 store_pwm(struct device *dev, struct device_attribute *attr,
                         const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct w83627ehf_data *data = i2c_get_clientdata(client);
+        struct w83627ehf_data *data = dev_get_drvdata(dev);
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
         int nr = sensor_attr->index;
         u32 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 255);
 
         mutex_lock(&data->update_lock);
         data->pwm[nr] = val;
-        w83627ehf_write_value(client, W83627EHF_REG_PWM[nr], val);
+        w83627ehf_write_value(data, W83627EHF_REG_PWM[nr], val);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -918,8 +937,7 @@ static ssize_t
 store_pwm_enable(struct device *dev, struct device_attribute *attr,
                         const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct w83627ehf_data *data = i2c_get_clientdata(client);
+        struct w83627ehf_data *data = dev_get_drvdata(dev);
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
         int nr = sensor_attr->index;
         u32 val = simple_strtoul(buf, NULL, 10);
@@ -928,11 +946,11 @@ store_pwm_enable(struct device *dev, struct device_attribute *attr,
         if (!val || (val > 2))  /* only modes 1 and 2 are supported */
                 return -EINVAL;
         mutex_lock(&data->update_lock);
-        reg = w83627ehf_read_value(client, W83627EHF_REG_PWM_ENABLE[nr]);
+        reg = w83627ehf_read_value(data, W83627EHF_REG_PWM_ENABLE[nr]);
         data->pwm_enable[nr] = val;
         reg &= ~(0x03 << W83627EHF_PWM_ENABLE_SHIFT[nr]);
         reg |= (val - 1) << W83627EHF_PWM_ENABLE_SHIFT[nr];
-        w83627ehf_write_value(client, W83627EHF_REG_PWM_ENABLE[nr], reg);
+        w83627ehf_write_value(data, W83627EHF_REG_PWM_ENABLE[nr], reg);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -955,15 +973,14 @@ static ssize_t
 store_target_temp(struct device *dev, struct device_attribute *attr,
                         const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct w83627ehf_data *data = i2c_get_clientdata(client);
+        struct w83627ehf_data *data = dev_get_drvdata(dev);
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
         int nr = sensor_attr->index;
         u8 val = temp1_to_reg(simple_strtoul(buf, NULL, 10), 0, 127000);
 
         mutex_lock(&data->update_lock);
         data->target_temp[nr] = val;
-        w83627ehf_write_value(client, W83627EHF_REG_TARGET[nr], val);
+        w83627ehf_write_value(data, W83627EHF_REG_TARGET[nr], val);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -972,8 +989,7 @@ static ssize_t
 store_tolerance(struct device *dev, struct device_attribute *attr,
                         const char *buf, size_t count)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        struct w83627ehf_data *data = i2c_get_clientdata(client);
+        struct w83627ehf_data *data = dev_get_drvdata(dev);
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
         int nr = sensor_attr->index;
         u16 reg;
@@ -981,13 +997,13 @@ store_tolerance(struct device *dev, struct device_attribute *attr,
         u8 val = temp1_to_reg(simple_strtoul(buf, NULL, 10), 0, 15000);
 
         mutex_lock(&data->update_lock);
-        reg = w83627ehf_read_value(client, W83627EHF_REG_TOLERANCE[nr]);
+        reg = w83627ehf_read_value(data, W83627EHF_REG_TOLERANCE[nr]);
         data->tolerance[nr] = val;
         if (nr == 1)
                 reg = (reg & 0x0f) | (val << 4);
         else
                 reg = (reg & 0xf0) | val;
-        w83627ehf_write_value(client, W83627EHF_REG_TOLERANCE[nr], reg);
+        w83627ehf_write_value(data, W83627EHF_REG_TOLERANCE[nr], reg);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -1058,14 +1074,13 @@ static ssize_t \
 store_##reg(struct device *dev, struct device_attribute *attr, \
                             const char *buf, size_t count) \
 {\
-        struct i2c_client *client = to_i2c_client(dev); \
-        struct w83627ehf_data *data = i2c_get_clientdata(client); \
+        struct w83627ehf_data *data = dev_get_drvdata(dev); \
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
         int nr = sensor_attr->index; \
         u32 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 1, 255); \
         mutex_lock(&data->update_lock); \
         data->reg[nr] = val; \
-        w83627ehf_write_value(client, W83627EHF_REG_##REG[nr],  val); \
+        w83627ehf_write_value(data, W83627EHF_REG_##REG[nr], val); \
         mutex_unlock(&data->update_lock); \
         return count; \
 }
@@ -1087,21 +1102,28 @@ static ssize_t \
 store_##reg(struct device *dev, struct device_attribute *attr, \
                         const char *buf, size_t count) \
 { \
-        struct i2c_client *client = to_i2c_client(dev); \
-        struct w83627ehf_data *data = i2c_get_clientdata(client); \
+        struct w83627ehf_data *data = dev_get_drvdata(dev); \
         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
         int nr = sensor_attr->index; \
         u8 val = step_time_to_reg(simple_strtoul(buf, NULL, 10), \
                                         data->pwm_mode[nr]); \
         mutex_lock(&data->update_lock); \
         data->reg[nr] = val; \
-        w83627ehf_write_value(client, W83627EHF_REG_##REG[nr], val); \
+        w83627ehf_write_value(data, W83627EHF_REG_##REG[nr], val); \
         mutex_unlock(&data->update_lock); \
         return count; \
 } \
 
 fan_time_functions(fan_stop_time, FAN_STOP_TIME)
 
+static ssize_t show_name(struct device *dev, struct device_attribute *attr,
+                         char *buf)
+{
+        struct w83627ehf_data *data = dev_get_drvdata(dev);
+
+        return sprintf(buf, "%s\n", data->name);
+}
+static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 
 static struct sensor_device_attribute sda_sf3_arrays_fan4[] = {
         SENSOR_ATTR(pwm4_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
@@ -1125,8 +1147,16 @@ static struct sensor_device_attribute sda_sf3_arrays[] = {
                     store_fan_min_output, 2),
 };
 
+static ssize_t
+show_vid(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct w83627ehf_data *data = dev_get_drvdata(dev);
+        return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
+}
+static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
+
 /*
- * Driver and client management
+ * Driver and device management
  */
 
 static void w83627ehf_device_remove_files(struct device *dev)
@@ -1134,12 +1164,13 @@ static void w83627ehf_device_remove_files(struct device *dev)
         /* some entries in the following arrays may not have been used in
          * device_create_file(), but device_remove_file() will ignore them */
         int i;
+        struct w83627ehf_data *data = dev_get_drvdata(dev);
 
         for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++)
                 device_remove_file(dev, &sda_sf3_arrays[i].dev_attr);
         for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++)
                 device_remove_file(dev, &sda_sf3_arrays_fan4[i].dev_attr);
-        for (i = 0; i < w83627ehf_num_in; i++) {
+        for (i = 0; i < data->in_num; i++) {
                 device_remove_file(dev, &sda_in_input[i].dev_attr);
                 device_remove_file(dev, &sda_in_alarm[i].dev_attr);
                 device_remove_file(dev, &sda_in_min[i].dev_attr);
@@ -1160,43 +1191,64 @@ static void w83627ehf_device_remove_files(struct device *dev)
         }
         for (i = 0; i < ARRAY_SIZE(sda_temp); i++)
                 device_remove_file(dev, &sda_temp[i].dev_attr);
-}
 
-static struct i2c_driver w83627ehf_driver;
+        device_remove_file(dev, &dev_attr_name);
+        if (data->vid != 0x3f)
+                device_remove_file(dev, &dev_attr_cpu0_vid);
+}
 
-static void w83627ehf_init_client(struct i2c_client *client)
+/* Get the monitoring functions started */
+static inline void __devinit w83627ehf_init_device(struct w83627ehf_data *data)
 {
         int i;
-        u8 tmp;
+        u8 tmp, diode;
 
         /* Start monitoring is needed */
-        tmp = w83627ehf_read_value(client, W83627EHF_REG_CONFIG);
+        tmp = w83627ehf_read_value(data, W83627EHF_REG_CONFIG);
         if (!(tmp & 0x01))
-                w83627ehf_write_value(client, W83627EHF_REG_CONFIG,
+                w83627ehf_write_value(data, W83627EHF_REG_CONFIG,
                                       tmp | 0x01);
 
         /* Enable temp2 and temp3 if needed */
         for (i = 0; i < 2; i++) {
-                tmp = w83627ehf_read_value(client,
+                tmp = w83627ehf_read_value(data,
                                            W83627EHF_REG_TEMP_CONFIG[i]);
                 if (tmp & 0x01)
-                        w83627ehf_write_value(client,
+                        w83627ehf_write_value(data,
                                               W83627EHF_REG_TEMP_CONFIG[i],
                                               tmp & 0xfe);
         }
+
+        /* Enable VBAT monitoring if needed */
+        tmp = w83627ehf_read_value(data, W83627EHF_REG_VBAT);
+        if (!(tmp & 0x01))
+                w83627ehf_write_value(data, W83627EHF_REG_VBAT, tmp | 0x01);
+
+        /* Get thermal sensor types */
+        diode = w83627ehf_read_value(data, W83627EHF_REG_DIODE);
+        for (i = 0; i < 3; i++) {
+                if ((tmp & (0x02 << i)))
+                        data->temp_type[i] = (diode & (0x10 << i)) ? 1 : 2;
+                else
+                        data->temp_type[i] = 4; /* thermistor */
+        }
 }
 
-static int w83627ehf_detect(struct i2c_adapter *adapter)
+static int __devinit w83627ehf_probe(struct platform_device *pdev)
 {
-        struct i2c_client *client;
+        struct device *dev = &pdev->dev;
+        struct w83627ehf_sio_data *sio_data = dev->platform_data;
         struct w83627ehf_data *data;
-        struct device *dev;
-        u8 fan4pin, fan5pin;
+        struct resource *res;
+        u8 fan4pin, fan5pin, en_vrm10;
         int i, err = 0;
 
-        if (!request_region(address + IOREGION_OFFSET, IOREGION_LENGTH,
-                            w83627ehf_driver.driver.name)) {
+        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
+        if (!request_region(res->start, IOREGION_LENGTH, DRVNAME)) {
                 err = -EBUSY;
+                dev_err(dev, "Failed to request region 0x%lx-0x%lx\n",
+                        (unsigned long)res->start,
+                        (unsigned long)res->start + IOREGION_LENGTH - 1);
                 goto exit;
         }
 
@@ -1205,41 +1257,47 @@ static int w83627ehf_detect(struct i2c_adapter *adapter)
                 goto exit_release;
         }
 
-        client = &data->client;
-        i2c_set_clientdata(client, data);
-        client->addr = address;
+        data->addr = res->start;
         mutex_init(&data->lock);
-        client->adapter = adapter;
-        client->driver = &w83627ehf_driver;
-        client->flags = 0;
-        dev = &client->dev;
-
-        if (w83627ehf_num_in == 9)
-                strlcpy(client->name, "w83627dhg", I2C_NAME_SIZE);
-        else    /* just say ehf. 627EHG is 627EHF in lead-free packaging. */
-                strlcpy(client->name, "w83627ehf", I2C_NAME_SIZE);
-
-        data->valid = 0;
         mutex_init(&data->update_lock);
+        data->name = w83627ehf_device_names[sio_data->kind];
+        platform_set_drvdata(pdev, data);
 
-        /* Tell the i2c layer a new client has arrived */
-        if ((err = i2c_attach_client(client)))
-                goto exit_free;
+        /* 627EHG and 627EHF have 10 voltage inputs; DHG has 9 */
+        data->in_num = (sio_data->kind == w83627dhg) ? 9 : 10;
 
         /* Initialize the chip */
-        w83627ehf_init_client(client);
-
-        /* A few vars need to be filled upon startup */
-        for (i = 0; i < 5; i++)
-                data->fan_min[i] = w83627ehf_read_value(client,
-                                   W83627EHF_REG_FAN_MIN[i]);
+        w83627ehf_init_device(data);
+
+        data->vrm = vid_which_vrm();
+        superio_enter(sio_data->sioreg);
+        /* Set VID input sensibility if needed. In theory the BIOS should
+           have set it, but in practice it's not always the case. */
+        en_vrm10 = superio_inb(sio_data->sioreg, SIO_REG_EN_VRM10);
+        if ((en_vrm10 & 0x08) && data->vrm != 100) {
+                dev_warn(dev, "Setting VID input voltage to TTL\n");
+                superio_outb(sio_data->sioreg, SIO_REG_EN_VRM10,
+                             en_vrm10 & ~0x08);
+        } else if (!(en_vrm10 & 0x08) && data->vrm == 100) {
+                dev_warn(dev, "Setting VID input voltage to VRM10\n");
+                superio_outb(sio_data->sioreg, SIO_REG_EN_VRM10,
+                             en_vrm10 | 0x08);
+        }
+        /* Read VID value */
+        superio_select(sio_data->sioreg, W83627EHF_LD_HWM);
+        if (superio_inb(sio_data->sioreg, SIO_REG_VID_CTRL) & 0x80)
+                data->vid = superio_inb(sio_data->sioreg, SIO_REG_VID_DATA) & 0x3f;
+        else {
+                dev_info(dev, "VID pins in output mode, CPU VID not "
+                         "available\n");
+                data->vid = 0x3f;
+        }
 
         /* fan4 and fan5 share some pins with the GPIO and serial flash */
 
-        superio_enter();
-        fan5pin = superio_inb(0x24) & 0x2;
-        fan4pin = superio_inb(0x29) & 0x6;
-        superio_exit();
+        fan5pin = superio_inb(sio_data->sioreg, 0x24) & 0x2;
+        fan4pin = superio_inb(sio_data->sioreg, 0x29) & 0x6;
+        superio_exit(sio_data->sioreg);
 
         /* It looks like fan4 and fan5 pins can be alternatively used
            as fan on/off switches, but fan5 control is write only :/
@@ -1248,7 +1306,7 @@ static int w83627ehf_detect(struct i2c_adapter *adapter)
            is not the default. */
 
         data->has_fan = 0x07; /* fan1, fan2 and fan3 */
-        i = w83627ehf_read_value(client, W83627EHF_REG_FANDIV1);
+        i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV1);
         if ((i & (1 << 2)) && (!fan4pin))
                 data->has_fan |= (1 << 3);
         if (!(i & (1 << 1)) && (!fan5pin))
@@ -1268,7 +1326,7 @@ static int w83627ehf_detect(struct i2c_adapter *adapter)
                                 goto exit_remove;
                 }
 
-        for (i = 0; i < w83627ehf_num_in; i++)
+        for (i = 0; i < data->in_num; i++)
                 if ((err = device_create_file(dev, &sda_in_input[i].dev_attr))
                         || (err = device_create_file(dev,
                                 &sda_in_alarm[i].dev_attr))
@@ -1308,6 +1366,16 @@ static int w83627ehf_detect(struct i2c_adapter *adapter)
                 if ((err = device_create_file(dev, &sda_temp[i].dev_attr)))
                         goto exit_remove;
 
+        err = device_create_file(dev, &dev_attr_name);
+        if (err)
+                goto exit_remove;
+
+        if (data->vid != 0x3f) {
+                err = device_create_file(dev, &dev_attr_cpu0_vid);
+                if (err)
+                        goto exit_remove;
+        }
+
         data->class_dev = hwmon_device_register(dev);
         if (IS_ERR(data->class_dev)) {
                 err = PTR_ERR(data->class_dev);
@@ -1318,95 +1386,172 @@ static int w83627ehf_detect(struct i2c_adapter *adapter)
 
 exit_remove:
         w83627ehf_device_remove_files(dev);
-        i2c_detach_client(client);
-exit_free:
         kfree(data);
+        platform_set_drvdata(pdev, NULL);
 exit_release:
-        release_region(address + IOREGION_OFFSET, IOREGION_LENGTH);
+        release_region(res->start, IOREGION_LENGTH);
 exit:
         return err;
 }
 
-static int w83627ehf_detach_client(struct i2c_client *client)
+static int __devexit w83627ehf_remove(struct platform_device *pdev)
 {
-        struct w83627ehf_data *data = i2c_get_clientdata(client);
-        int err;
+        struct w83627ehf_data *data = platform_get_drvdata(pdev);
 
         hwmon_device_unregister(data->class_dev);
-        w83627ehf_device_remove_files(&client->dev);
-
-        if ((err = i2c_detach_client(client)))
-                return err;
-        release_region(client->addr + IOREGION_OFFSET, IOREGION_LENGTH);
+        w83627ehf_device_remove_files(&pdev->dev);
+        release_region(data->addr, IOREGION_LENGTH);
+        platform_set_drvdata(pdev, NULL);
         kfree(data);
 
         return 0;
 }
 
-static struct i2c_driver w83627ehf_driver = {
+static struct platform_driver w83627ehf_driver = {
         .driver = {
                 .owner  = THIS_MODULE,
-                .name   = "w83627ehf",
+                .name   = DRVNAME,
         },
-        .attach_adapter = w83627ehf_detect,
-        .detach_client  = w83627ehf_detach_client,
+        .probe          = w83627ehf_probe,
+        .remove         = __devexit_p(w83627ehf_remove),
 };
 
-static int __init w83627ehf_find(int sioaddr, unsigned short *addr)
+/* w83627ehf_find() looks for a '627 in the Super-I/O config space */
+static int __init w83627ehf_find(int sioaddr, unsigned short *addr,
+                                 struct w83627ehf_sio_data *sio_data)
 {
+        static const char __initdata sio_name_W83627EHF[] = "W83627EHF";
+        static const char __initdata sio_name_W83627EHG[] = "W83627EHG";
+        static const char __initdata sio_name_W83627DHG[] = "W83627DHG";
+
         u16 val;
+        const char *sio_name;
 
-        REG = sioaddr;
-        VAL = sioaddr + 1;
-        superio_enter();
+        superio_enter(sioaddr);
 
-        val = (superio_inb(SIO_REG_DEVID) << 8)
-            | superio_inb(SIO_REG_DEVID + 1);
+        val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8)
+            | superio_inb(sioaddr, SIO_REG_DEVID + 1);
         switch (val & SIO_ID_MASK) {
-        case SIO_W83627DHG_ID:
-                w83627ehf_num_in = 9;
-                break;
         case SIO_W83627EHF_ID:
+                sio_data->kind = w83627ehf;
+                sio_name = sio_name_W83627EHF;
+                break;
         case SIO_W83627EHG_ID:
-                w83627ehf_num_in = 10;
+                sio_data->kind = w83627ehf;
+                sio_name = sio_name_W83627EHG;
+                break;
+        case SIO_W83627DHG_ID:
+                sio_data->kind = w83627dhg;
+                sio_name = sio_name_W83627DHG;
                 break;
         default:
-                printk(KERN_WARNING "w83627ehf: unsupported chip ID: 0x%04x\n",
-                        val);
-                superio_exit();
+                if (val != 0xffff)
+                        pr_debug(DRVNAME ": unsupported chip ID: 0x%04x\n",
+                                 val);
+                superio_exit(sioaddr);
                 return -ENODEV;
         }
 
-        superio_select(W83627EHF_LD_HWM);
-        val = (superio_inb(SIO_REG_ADDR) << 8)
-            | superio_inb(SIO_REG_ADDR + 1);
+        /* We have a known chip, find the HWM I/O address */
+        superio_select(sioaddr, W83627EHF_LD_HWM);
+        val = (superio_inb(sioaddr, SIO_REG_ADDR) << 8)
+            | superio_inb(sioaddr, SIO_REG_ADDR + 1);
         *addr = val & IOREGION_ALIGNMENT;
         if (*addr == 0) {
-                superio_exit();
+                printk(KERN_ERR DRVNAME ": Refusing to enable a Super-I/O "
+                       "device with a base I/O port 0.\n");
+                superio_exit(sioaddr);
                 return -ENODEV;
         }
 
         /* Activate logical device if needed */
-        val = superio_inb(SIO_REG_ENABLE);
-        if (!(val & 0x01))
-                superio_outb(SIO_REG_ENABLE, val | 0x01);
+        val = superio_inb(sioaddr, SIO_REG_ENABLE);
+        if (!(val & 0x01)) {
+                printk(KERN_WARNING DRVNAME ": Forcibly enabling Super-I/O. "
+                       "Sensor is probably unusable.\n");
+                superio_outb(sioaddr, SIO_REG_ENABLE, val | 0x01);
+        }
+
+        superio_exit(sioaddr);
+        pr_info(DRVNAME ": Found %s chip at %#x\n", sio_name, *addr);
+        sio_data->sioreg = sioaddr;
 
-        superio_exit();
         return 0;
 }
 
+/* when Super-I/O functions move to a separate file, the Super-I/O
+ * bus will manage the lifetime of the device and this module will only keep
+ * track of the w83627ehf driver. But since we platform_device_alloc(), we
+ * must keep track of the device */
+static struct platform_device *pdev;
+
 static int __init sensors_w83627ehf_init(void)
 {
-        if (w83627ehf_find(0x2e, &address)
-         && w83627ehf_find(0x4e, &address))
+        int err;
+        unsigned short address;
+        struct resource res;
+        struct w83627ehf_sio_data sio_data;
+
+        /* initialize sio_data->kind and sio_data->sioreg.
+         *
+         * when Super-I/O functions move to a separate file, the Super-I/O
+         * driver will probe 0x2e and 0x4e and auto-detect the presence of a
+         * w83627ehf hardware monitor, and call probe() */
+        if (w83627ehf_find(0x2e, &address, &sio_data) &&
+            w83627ehf_find(0x4e, &address, &sio_data))
                 return -ENODEV;
 
-        return i2c_isa_add_driver(&w83627ehf_driver);
+        err = platform_driver_register(&w83627ehf_driver);
+        if (err)
+                goto exit;
+
+        if (!(pdev = platform_device_alloc(DRVNAME, address))) {
+                err = -ENOMEM;
+                printk(KERN_ERR DRVNAME ": Device allocation failed\n");
+                goto exit_unregister;
+        }
+
+        err = platform_device_add_data(pdev, &sio_data,
+                                       sizeof(struct w83627ehf_sio_data));
+        if (err) {
+                printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
+                goto exit_device_put;
+        }
+
+        memset(&res, 0, sizeof(res));
+        res.name = DRVNAME;
+        res.start = address + IOREGION_OFFSET;
+        res.end = address + IOREGION_OFFSET + IOREGION_LENGTH - 1;
+        res.flags = IORESOURCE_IO;
+        err = platform_device_add_resources(pdev, &res, 1);
+        if (err) {
+                printk(KERN_ERR DRVNAME ": Device resource addition failed "
+                       "(%d)\n", err);
+                goto exit_device_put;
+        }
+
+        /* platform_device_add calls probe() */
+        err = platform_device_add(pdev);
+        if (err) {
+                printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
+                       err);
+                goto exit_device_put;
+        }
+
+        return 0;
+
+exit_device_put:
+        platform_device_put(pdev);
+exit_unregister:
+        platform_driver_unregister(&w83627ehf_driver);
+exit:
+        return err;
 }
 
 static void __exit sensors_w83627ehf_exit(void)
 {
-        i2c_isa_del_driver(&w83627ehf_driver);
+        platform_device_unregister(pdev);
+        platform_driver_unregister(&w83627ehf_driver);
 }
 
 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
diff --git a/drivers/hwmon/w83627hf.c b/drivers/hwmon/w83627hf.c
index 12cb40a975de..1ce78179b005 100644
--- a/drivers/hwmon/w83627hf.c
+++ b/drivers/hwmon/w83627hf.c
@@ -220,6 +220,18 @@ static const u8 regpwm[] = { W83627THF_REG_PWM1, W83627THF_REG_PWM2,
 #define W836X7HF_REG_PWM(type, nr) (((type) == w83627hf) ? \
                                      regpwm_627hf[(nr) - 1] : regpwm[(nr) - 1])
 
+#define W83627HF_REG_PWM_FREQ           0x5C    /* Only for the 627HF */
+
+#define W83637HF_REG_PWM_FREQ1          0x00    /* 697HF/687THF too */
+#define W83637HF_REG_PWM_FREQ2          0x02    /* 697HF/687THF too */
+#define W83637HF_REG_PWM_FREQ3          0x10    /* 687THF too */
+
+static const u8 W83637HF_REG_PWM_FREQ[] = { W83637HF_REG_PWM_FREQ1,
+                                        W83637HF_REG_PWM_FREQ2,
+                                        W83637HF_REG_PWM_FREQ3 };
+
+#define W83627HF_BASE_PWM_FREQ  46870
+
 #define W83781D_REG_I2C_ADDR 0x48
 #define W83781D_REG_I2C_SUBADDR 0x4A
 
@@ -267,6 +279,49 @@ static int TEMP_FROM_REG(u8 reg)
 
 #define PWM_TO_REG(val) (SENSORS_LIMIT((val),0,255))
 
+static inline unsigned long pwm_freq_from_reg_627hf(u8 reg)
+{
+        unsigned long freq;
+        freq = W83627HF_BASE_PWM_FREQ >> reg;
+        return freq;
+}
+static inline u8 pwm_freq_to_reg_627hf(unsigned long val)
+{
+        u8 i;
+        /* Only 5 dividers (1 2 4 8 16)
+           Search for the nearest available frequency */
+        for (i = 0; i < 4; i++) {
+                if (val > (((W83627HF_BASE_PWM_FREQ >> i) +
+                            (W83627HF_BASE_PWM_FREQ >> (i+1))) / 2))
+                        break;
+        }
+        return i;
+}
+
+static inline unsigned long pwm_freq_from_reg(u8 reg)
+{
+        /* Clock bit 8 -> 180 kHz or 24 MHz */
+        unsigned long clock = (reg & 0x80) ? 180000UL : 24000000UL;
+
+        reg &= 0x7f;
+        /* This should not happen but anyway... */
+        if (reg == 0)
+                reg++;
+        return (clock / (reg << 8));
+}
+static inline u8 pwm_freq_to_reg(unsigned long val)
+{
+        /* Minimum divider value is 0x01 and maximum is 0x7F */
+        if (val >= 93750)       /* The highest we can do */
+                return 0x01;
+        if (val >= 720) /* Use 24 MHz clock */
+                return (24000000UL / (val << 8));
+        if (val < 6)            /* The lowest we can do */
+                return 0xFF;
+        else                    /* Use 180 kHz clock */
+                return (0x80 | (180000UL / (val << 8)));
+}
+
 #define BEEP_MASK_FROM_REG(val)          (val)
 #define BEEP_MASK_TO_REG(val)           ((val) & 0xffffff)
 #define BEEP_ENABLE_TO_REG(val)         ((val)?1:0)
@@ -316,6 +371,7 @@ struct w83627hf_data {
         u32 beep_mask;          /* Register encoding, combined */
         u8 beep_enable;         /* Boolean */
         u8 pwm[3];              /* Register value */
+        u8 pwm_freq[3];         /* Register value */
         u16 sens[3];            /* 782D/783S only.
                                    1 = pentium diode; 2 = 3904 diode;
                                    3000-5000 = thermistor beta.
@@ -852,6 +908,64 @@ sysfs_pwm(2);
 sysfs_pwm(3);
 
 static ssize_t
+show_pwm_freq_reg(struct device *dev, char *buf, int nr)
+{
+        struct w83627hf_data *data = w83627hf_update_device(dev);
+        if (data->type == w83627hf)
+                return sprintf(buf, "%ld\n",
+                        pwm_freq_from_reg_627hf(data->pwm_freq[nr - 1]));
+        else
+                return sprintf(buf, "%ld\n",
+                        pwm_freq_from_reg(data->pwm_freq[nr - 1]));
+}
+
+static ssize_t
+store_pwm_freq_reg(struct device *dev, const char *buf, size_t count, int nr)
+{
+        struct w83627hf_data *data = dev_get_drvdata(dev);
+        static const u8 mask[]={0xF8, 0x8F};
+        u32 val;
+
+        val = simple_strtoul(buf, NULL, 10);
+
+        mutex_lock(&data->update_lock);
+
+        if (data->type == w83627hf) {
+                data->pwm_freq[nr - 1] = pwm_freq_to_reg_627hf(val);
+                w83627hf_write_value(data, W83627HF_REG_PWM_FREQ,
+                                (data->pwm_freq[nr - 1] << ((nr - 1)*4)) |
+                                (w83627hf_read_value(data,
+                                W83627HF_REG_PWM_FREQ) & mask[nr - 1]));
+        } else {
+                data->pwm_freq[nr - 1] = pwm_freq_to_reg(val);
+                w83627hf_write_value(data, W83637HF_REG_PWM_FREQ[nr - 1],
+                                data->pwm_freq[nr - 1]);
+        }
+
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+#define sysfs_pwm_freq(offset) \
+static ssize_t show_regs_pwm_freq_##offset(struct device *dev, \
+                struct device_attribute *attr, char *buf) \
+{ \
+        return show_pwm_freq_reg(dev, buf, offset); \
+} \
+static ssize_t \
+store_regs_pwm_freq_##offset(struct device *dev, \
+                struct device_attribute *attr, const char *buf, size_t count) \
+{ \
+        return store_pwm_freq_reg(dev, buf, count, offset); \
+} \
+static DEVICE_ATTR(pwm##offset##_freq, S_IRUGO | S_IWUSR, \
+                  show_regs_pwm_freq_##offset, store_regs_pwm_freq_##offset);
+
+sysfs_pwm_freq(1);
+sysfs_pwm_freq(2);
+sysfs_pwm_freq(3);
+
+static ssize_t
 show_sensor_reg(struct device *dev, char *buf, int nr)
 {
         struct w83627hf_data *data = w83627hf_update_device(dev);
@@ -1077,6 +1191,9 @@ static struct attribute *w83627hf_attributes_opt[] = {
 
         &dev_attr_pwm3.attr,
 
+        &dev_attr_pwm1_freq.attr,
+        &dev_attr_pwm2_freq.attr,
+        &dev_attr_pwm3_freq.attr,
         NULL
 };
 
@@ -1139,7 +1256,9 @@ static int __devinit w83627hf_probe(struct platform_device *pdev)
                  || (err = device_create_file(dev, &dev_attr_in5_max))
                  || (err = device_create_file(dev, &dev_attr_in6_input))
                  || (err = device_create_file(dev, &dev_attr_in6_min))
-                 || (err = device_create_file(dev, &dev_attr_in6_max)))
+                 || (err = device_create_file(dev, &dev_attr_in6_max))
+                 || (err = device_create_file(dev, &dev_attr_pwm1_freq))
+                 || (err = device_create_file(dev, &dev_attr_pwm2_freq)))
                         goto ERROR4;
 
         if (data->type != w83697hf)
@@ -1169,6 +1288,12 @@ static int __devinit w83627hf_probe(struct platform_device *pdev)
                 if ((err = device_create_file(dev, &dev_attr_pwm3)))
                         goto ERROR4;
 
+        if (data->type == w83637hf || data->type == w83687thf)
+                if ((err = device_create_file(dev, &dev_attr_pwm1_freq))
+                 || (err = device_create_file(dev, &dev_attr_pwm2_freq))
+                 || (err = device_create_file(dev, &dev_attr_pwm3_freq)))
+                        goto ERROR4;
+
         data->class_dev = hwmon_device_register(dev);
         if (IS_ERR(data->class_dev)) {
                 err = PTR_ERR(data->class_dev);
@@ -1181,6 +1306,7 @@ static int __devinit w83627hf_probe(struct platform_device *pdev)
         sysfs_remove_group(&dev->kobj, &w83627hf_group);
         sysfs_remove_group(&dev->kobj, &w83627hf_group_opt);
       ERROR3:
+        platform_set_drvdata(pdev, NULL);
         kfree(data);
       ERROR1:
         release_region(res->start, WINB_REGION_SIZE);
@@ -1193,11 +1319,11 @@ static int __devexit w83627hf_remove(struct platform_device *pdev)
         struct w83627hf_data *data = platform_get_drvdata(pdev);
         struct resource *res;
 
-        platform_set_drvdata(pdev, NULL);
         hwmon_device_unregister(data->class_dev);
 
         sysfs_remove_group(&pdev->dev.kobj, &w83627hf_group);
         sysfs_remove_group(&pdev->dev.kobj, &w83627hf_group_opt);
+        platform_set_drvdata(pdev, NULL);
         kfree(data);
 
         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
@@ -1472,6 +1598,20 @@ static struct w83627hf_data *w83627hf_update_device(struct device *dev)
                            (data->type == w83627hf || data->type == w83697hf))
                                 break;
                 }
+                if (data->type == w83627hf) {
+                                u8 tmp = w83627hf_read_value(data,
+                                                W83627HF_REG_PWM_FREQ);
+                                data->pwm_freq[0] = tmp & 0x07;
+                                data->pwm_freq[1] = (tmp >> 4) & 0x07;
+                } else if (data->type != w83627thf) {
+                        for (i = 1; i <= 3; i++) {
+                                data->pwm_freq[i - 1] =
+                                        w83627hf_read_value(data,
+                                                W83637HF_REG_PWM_FREQ[i - 1]);
+                                if (i == 2 && (data->type == w83697hf))
+                                        break;
+                        }
+                }
 
                 data->temp = w83627hf_read_value(data, W83781D_REG_TEMP(1));
                 data->temp_max =
@@ -1548,15 +1688,12 @@ static int __init w83627hf_device_add(unsigned short address,
                 goto exit_device_put;
         }
 
-        pdev->dev.platform_data = kmalloc(sizeof(struct w83627hf_sio_data),
-                                          GFP_KERNEL);
-        if (!pdev->dev.platform_data) {
-                err = -ENOMEM;
+        err = platform_device_add_data(pdev, sio_data,
+                                       sizeof(struct w83627hf_sio_data));
+        if (err) {
                 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
                 goto exit_device_put;
         }
-        memcpy(pdev->dev.platform_data, sio_data,
-               sizeof(struct w83627hf_sio_data));
 
         err = platform_device_add(pdev);
         if (err) {
diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig
index 1c77e14480dc..da1647869f91 100644
--- a/drivers/i2c/busses/Kconfig
+++ b/drivers/i2c/busses/Kconfig
@@ -237,9 +237,6 @@ config I2C_IOP3XX
           This driver can also be built as a module.  If so, the module
           will be called i2c-iop3xx.
 
-config I2C_ISA
-        tristate
-
 config I2C_IXP4XX
         tristate "IXP4xx GPIO-Based I2C Interface (DEPRECATED)"
         depends on ARCH_IXP4XX
diff --git a/drivers/i2c/busses/Makefile b/drivers/i2c/busses/Makefile
index a6db4e38bda8..5b752e4e1918 100644
--- a/drivers/i2c/busses/Makefile
+++ b/drivers/i2c/busses/Makefile
@@ -18,7 +18,6 @@ obj-$(CONFIG_I2C_I801)		+= i2c-i801.o
 obj-$(CONFIG_I2C_I810)          += i2c-i810.o
 obj-$(CONFIG_I2C_IBM_IIC)       += i2c-ibm_iic.o
 obj-$(CONFIG_I2C_IOP3XX)        += i2c-iop3xx.o
-obj-$(CONFIG_I2C_ISA)           += i2c-isa.o
 obj-$(CONFIG_I2C_IXP2000)       += i2c-ixp2000.o
 obj-$(CONFIG_I2C_IXP4XX)        += i2c-ixp4xx.o
 obj-$(CONFIG_I2C_POWERMAC)      += i2c-powermac.o
diff --git a/drivers/i2c/busses/i2c-isa.c b/drivers/i2c/busses/i2c-isa.c
deleted file mode 100644
index b0e1370075de..000000000000
--- a/drivers/i2c/busses/i2c-isa.c
+++ /dev/null
@@ -1,192 +0,0 @@
-/*
-    i2c-isa.c - an i2c-core-like thing for ISA hardware monitoring chips
-    Copyright (C) 2005  Jean Delvare <khali@linux-fr.org>
-
-    Based on the i2c-isa pseudo-adapter from the lm_sensors project
-    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl> 
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-/* This implements an i2c-core-like thing for ISA hardware monitoring
-   chips. Such chips are linked to the i2c subsystem for historical
-   reasons (because the early ISA hardware monitoring chips such as the
-   LM78 had both an I2C and an ISA interface). They used to be
-   registered with the main i2c-core, but as a first step in the
-   direction of a clean separation between I2C and ISA chip drivers,
-   we now have this separate core for ISA ones. It is significantly
-   more simple than the real one, of course, because we don't have to
-   handle multiple busses: there is only one (fake) ISA adapter.
-   It is worth noting that we still rely on i2c-core for some things
-   at the moment - but hopefully this won't last. */
-
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/errno.h>
-#include <linux/i2c.h>
-#include <linux/i2c-isa.h>
-#include <linux/platform_device.h>
-#include <linux/completion.h>
-
-/* Exported by i2c-core for i2c-isa only */
-extern void i2c_adapter_dev_release(struct device *dev);
-extern struct class i2c_adapter_class;
-
-static u32 isa_func(struct i2c_adapter *adapter);
-
-/* This is the actual algorithm we define */
-static const struct i2c_algorithm isa_algorithm = {
-        .functionality  = isa_func,
-};
-
-/* There can only be one... */
-static struct i2c_adapter isa_adapter = {
-        .owner          = THIS_MODULE,
-        .id             = I2C_HW_ISA,
-        .class          = I2C_CLASS_HWMON,
-        .algo           = &isa_algorithm,
-        .name           = "ISA main adapter",
-};
-
-/* We can't do a thing... */
-static u32 isa_func(struct i2c_adapter *adapter)
-{
-        return 0;
-}
-
-
-/* We implement an interface which resembles i2c_{add,del}_driver,
-   but for i2c-isa drivers. We don't have to remember and handle lists
-   of drivers and adapters so this is much more simple, of course. */
-
-int i2c_isa_add_driver(struct i2c_driver *driver)
-{
-        int res;
-
-        /* Add the driver to the list of i2c drivers in the driver core */
-        driver->driver.bus = &i2c_bus_type;
-        res = driver_register(&driver->driver);
-        if (res)
-                return res;
-        dev_dbg(&isa_adapter.dev, "Driver %s registered\n", driver->driver.name);
-
-        /* Now look for clients */
-        res = driver->attach_adapter(&isa_adapter);
-        if (res) {
-                dev_dbg(&isa_adapter.dev,
-                        "Driver %s failed to attach adapter, unregistering\n",
-                        driver->driver.name);
-                driver_unregister(&driver->driver);
-        }
-        return res;
-}
-
-int i2c_isa_del_driver(struct i2c_driver *driver)
-{
-        struct list_head *item, *_n;
-        struct i2c_client *client;
-        int res;
-
-        /* Detach all clients belonging to this one driver */
-        list_for_each_safe(item, _n, &isa_adapter.clients) {
-                client = list_entry(item, struct i2c_client, list);
-                if (client->driver != driver)
-                        continue;
-                dev_dbg(&isa_adapter.dev, "Detaching client %s at 0x%x\n",
-                        client->name, client->addr);
-                if ((res = driver->detach_client(client))) {
-                        dev_err(&isa_adapter.dev, "Failed, driver "
-                                "%s not unregistered!\n",
-                                driver->driver.name);
-                        return res;
-                }
-        }
-
-        /* Get the driver off the core list */
-        driver_unregister(&driver->driver);
-        dev_dbg(&isa_adapter.dev, "Driver %s unregistered\n", driver->driver.name);
-
-        return 0;
-}
-
-
-static int __init i2c_isa_init(void)
-{
-        int err;
-
-        mutex_init(&isa_adapter.clist_lock);
-        INIT_LIST_HEAD(&isa_adapter.clients);
-
-        isa_adapter.nr = ANY_I2C_ISA_BUS;
-        isa_adapter.dev.parent = &platform_bus;
-        sprintf(isa_adapter.dev.bus_id, "i2c-%d", isa_adapter.nr);
-        isa_adapter.dev.release = &i2c_adapter_dev_release;
-        isa_adapter.dev.class = &i2c_adapter_class;
-        err = device_register(&isa_adapter.dev);
-        if (err) {
-                printk(KERN_ERR "i2c-isa: Failed to register device\n");
-                goto exit;
-        }
-
-        dev_dbg(&isa_adapter.dev, "%s registered\n", isa_adapter.name);
-
-        return 0;
-
-exit:
-        return err;
-}
-
-static void __exit i2c_isa_exit(void)
-{
-#ifdef DEBUG
-        struct list_head  *item, *_n;
-        struct i2c_client *client = NULL;
-#endif
-
-        /* There should be no more active client */
-#ifdef DEBUG
-        dev_dbg(&isa_adapter.dev, "Looking for clients\n");
-        list_for_each_safe(item, _n, &isa_adapter.clients) {
-                client = list_entry(item, struct i2c_client, list);
-                dev_err(&isa_adapter.dev, "Driver %s still has an active "
-                        "ISA client at 0x%x\n", client->driver->driver.name,
-                        client->addr);
-        }
-        if (client != NULL)
-                return;
-#endif
-
-        /* Clean up the sysfs representation */
-        dev_dbg(&isa_adapter.dev, "Unregistering from sysfs\n");
-        init_completion(&isa_adapter.dev_released);
-        device_unregister(&isa_adapter.dev);
-
-        /* Wait for sysfs to drop all references */
-        dev_dbg(&isa_adapter.dev, "Waiting for sysfs completion\n");
-        wait_for_completion(&isa_adapter.dev_released);
-
-        dev_dbg(&isa_adapter.dev, "%s unregistered\n", isa_adapter.name);
-}
-
-EXPORT_SYMBOL(i2c_isa_add_driver);
-EXPORT_SYMBOL(i2c_isa_del_driver);
-
-MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
-MODULE_DESCRIPTION("ISA bus access through i2c");
-MODULE_LICENSE("GPL");
-
-module_init(i2c_isa_init);
-module_exit(i2c_isa_exit);
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index 6971a62397db..d663e6960d93 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -288,7 +288,6 @@ void i2c_adapter_dev_release(struct device *dev)
         struct i2c_adapter *adap = to_i2c_adapter(dev);
         complete(&adap->dev_released);
 }
-EXPORT_SYMBOL_GPL(i2c_adapter_dev_release);     /* exported to i2c-isa */
 
 static ssize_t
 show_adapter_name(struct device *dev, struct device_attribute *attr, char *buf)
@@ -307,7 +306,6 @@ struct class i2c_adapter_class = {
         .name                   = "i2c-adapter",
         .dev_attrs              = i2c_adapter_attrs,
 };
-EXPORT_SYMBOL_GPL(i2c_adapter_class);           /* exported to i2c-isa */
 
 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
 {
diff --git a/drivers/ide/cris/ide-cris.c b/drivers/ide/cris/ide-cris.c
index 886091bc7db0..fbfea46a34f2 100644
--- a/drivers/ide/cris/ide-cris.c
+++ b/drivers/ide/cris/ide-cris.c
@@ -414,12 +414,6 @@ cris_ide_reset(unsigned val)
 #ifdef CONFIG_ETRAX_IDE_G27_RESET
         REG_SHADOW_SET(R_PORT_G_DATA, port_g_data_shadow, 27, val);
 #endif
-#ifdef CONFIG_ETRAX_IDE_CSE1_16_RESET
-        REG_SHADOW_SET(port_cse1_addr, port_cse1_shadow, 16, val);
-#endif
-#ifdef CONFIG_ETRAX_IDE_CSP0_8_RESET
-        REG_SHADOW_SET(port_csp0_addr, port_csp0_shadow, 8, val);
-#endif
 #ifdef CONFIG_ETRAX_IDE_PB7_RESET
         port_pb_dir_shadow = port_pb_dir_shadow |
                 IO_STATE(R_PORT_PB_DIR, dir7, output);
@@ -690,6 +684,8 @@ static void tune_cris_ide(ide_drive_t *drive, u8 pio)
 {
         int setup, strobe, hold;
 
+        pio = ide_get_best_pio_mode(drive, pio, 4);
+
         switch(pio)
         {
                 case 0:
@@ -820,6 +816,7 @@ init_e100_ide (void)
                 hwif->dma_host_on = &cris_dma_on;
                 hwif->dma_off_quietly = &cris_dma_off;
                 hwif->cbl = ATA_CBL_PATA40;
+                hwif->pio_mask = ATA_PIO4,
                 hwif->ultra_mask = cris_ultra_mask;
                 hwif->mwdma_mask = 0x07; /* Multiword DMA 0-2 */
                 hwif->autodma = 1;
diff --git a/drivers/ide/ide-floppy.c b/drivers/ide/ide-floppy.c
index a21f585b1caa..ae8e1a64b8ad 100644
--- a/drivers/ide/ide-floppy.c
+++ b/drivers/ide/ide-floppy.c
@@ -99,6 +99,8 @@
 #include <linux/bitops.h>
 #include <linux/mutex.h>
 
+#include <scsi/scsi_ioctl.h>
+
 #include <asm/byteorder.h>
 #include <asm/irq.h>
 #include <asm/uaccess.h>
@@ -2099,7 +2101,21 @@ static int idefloppy_ioctl(struct inode *inode, struct file *file,
         case IDEFLOPPY_IOCTL_FORMAT_GET_PROGRESS:
                 return idefloppy_get_format_progress(drive, argp);
         }
-        return generic_ide_ioctl(drive, file, bdev, cmd, arg);
+
+        /*
+         * skip SCSI_IOCTL_SEND_COMMAND (deprecated)
+         * and CDROM_SEND_PACKET (legacy) ioctls
+         */
+        if (cmd != CDROM_SEND_PACKET && cmd != SCSI_IOCTL_SEND_COMMAND)
+                err = scsi_cmd_ioctl(file, bdev->bd_disk->queue,
+                                        bdev->bd_disk, cmd, argp);
+        else
+                err = -ENOTTY;
+
+        if (err == -ENOTTY)
+                err = generic_ide_ioctl(drive, file, bdev, cmd, arg);
+
+        return err;
 }
 
 static int idefloppy_media_changed(struct gendisk *disk)
diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
index c5b5011da56e..484c50e71446 100644
--- a/drivers/ide/ide-io.c
+++ b/drivers/ide/ide-io.c
@@ -55,7 +55,7 @@
 #include <asm/bitops.h>
 
 static int __ide_end_request(ide_drive_t *drive, struct request *rq,
-                             int uptodate, int nr_sectors)
+                             int uptodate, unsigned int nr_bytes)
 {
         int ret = 1;
 
@@ -64,7 +64,7 @@ static int __ide_end_request(ide_drive_t *drive, struct request *rq,
          * complete the whole request right now
          */
         if (blk_noretry_request(rq) && end_io_error(uptodate))
-                nr_sectors = rq->hard_nr_sectors;
+                nr_bytes = rq->hard_nr_sectors << 9;
 
         if (!blk_fs_request(rq) && end_io_error(uptodate) && !rq->errors)
                 rq->errors = -EIO;
@@ -78,7 +78,7 @@ static int __ide_end_request(ide_drive_t *drive, struct request *rq,
                 HWGROUP(drive)->hwif->ide_dma_on(drive);
         }
 
-        if (!end_that_request_first(rq, uptodate, nr_sectors)) {
+        if (!end_that_request_chunk(rq, uptodate, nr_bytes)) {
                 add_disk_randomness(rq->rq_disk);
                 if (!list_empty(&rq->queuelist))
                         blkdev_dequeue_request(rq);
@@ -103,6 +103,7 @@ static int __ide_end_request(ide_drive_t *drive, struct request *rq,
 
 int ide_end_request (ide_drive_t *drive, int uptodate, int nr_sectors)
 {
+        unsigned int nr_bytes = nr_sectors << 9;
         struct request *rq;
         unsigned long flags;
         int ret = 1;
@@ -114,10 +115,14 @@ int ide_end_request (ide_drive_t *drive, int uptodate, int nr_sectors)
         spin_lock_irqsave(&ide_lock, flags);
         rq = HWGROUP(drive)->rq;
 
-        if (!nr_sectors)
-                nr_sectors = rq->hard_cur_sectors;
+        if (!nr_bytes) {
+                if (blk_pc_request(rq))
+                        nr_bytes = rq->data_len;
+                else
+                        nr_bytes = rq->hard_cur_sectors << 9;
+        }
 
-        ret = __ide_end_request(drive, rq, uptodate, nr_sectors);
+        ret = __ide_end_request(drive, rq, uptodate, nr_bytes);
 
         spin_unlock_irqrestore(&ide_lock, flags);
         return ret;
@@ -219,11 +224,12 @@ static ide_startstop_t ide_start_power_step(ide_drive_t *drive, struct request *
                  * we could be smarter and check for current xfer_speed
                  * in struct drive etc...
                  */
-                if ((drive->id->capability & 1) == 0)
-                        break;
                 if (drive->hwif->ide_dma_check == NULL)
                         break;
                 drive->hwif->dma_off_quietly(drive);
+                /*
+                 * TODO: respect ->using_dma setting
+                 */
                 ide_set_dma(drive);
                 break;
         }
diff --git a/drivers/ide/ide-lib.c b/drivers/ide/ide-lib.c
index 074bb32a4a40..92a6c7bcf527 100644
--- a/drivers/ide/ide-lib.c
+++ b/drivers/ide/ide-lib.c
@@ -249,12 +249,34 @@ static int ide_scan_pio_blacklist (char *model)
         return -1;
 }
 
+unsigned int ide_pio_cycle_time(ide_drive_t *drive, u8 pio)
+{
+        struct hd_driveid *id = drive->id;
+        int cycle_time = 0;
+
+        if (id->field_valid & 2) {
+                if (id->capability & 8)
+                        cycle_time = id->eide_pio_iordy;
+                else
+                        cycle_time = id->eide_pio;
+        }
+
+        /* conservative "downgrade" for all pre-ATA2 drives */
+        if (pio < 3) {
+                if (cycle_time && cycle_time < ide_pio_timings[pio].cycle_time)
+                        cycle_time = 0; /* use standard timing */
+        }
+
+        return cycle_time ? cycle_time : ide_pio_timings[pio].cycle_time;
+}
+
+EXPORT_SYMBOL_GPL(ide_pio_cycle_time);
+
 /**
  *      ide_get_best_pio_mode   -       get PIO mode from drive
  *      @drive: drive to consider
  *      @mode_wanted: preferred mode
  *      @max_mode: highest allowed mode
- *      @d: PIO data
  *
  *      This routine returns the recommended PIO settings for a given drive,
  *      based on the drive->id information and the ide_pio_blacklist[].
@@ -263,22 +285,18 @@ static int ide_scan_pio_blacklist (char *model)
  *      This is used by most chipset support modules when "auto-tuning".
  */
 
-u8 ide_get_best_pio_mode (ide_drive_t *drive, u8 mode_wanted, u8 max_mode, ide_pio_data_t *d)
+u8 ide_get_best_pio_mode (ide_drive_t *drive, u8 mode_wanted, u8 max_mode)
 {
         int pio_mode;
-        int cycle_time = 0;
-        int use_iordy = 0;
         struct hd_driveid* id = drive->id;
         int overridden  = 0;
 
-        if (mode_wanted != 255) {
-                pio_mode = mode_wanted;
-                use_iordy = (pio_mode > 2);
-        } else if (!drive->id) {
-                pio_mode = 0;
-        } else if ((pio_mode = ide_scan_pio_blacklist(id->model)) != -1) {
-                overridden = 1;
-                use_iordy = (pio_mode > 2);
+        if (mode_wanted != 255)
+                return min_t(u8, mode_wanted, max_mode);
+
+        if ((drive->hwif->host_flags & IDE_HFLAG_PIO_NO_BLACKLIST) == 0 &&
+            (pio_mode = ide_scan_pio_blacklist(id->model)) != -1) {
+                printk(KERN_INFO "%s: is on PIO blacklist\n", drive->name);
         } else {
                 pio_mode = id->tPIO;
                 if (pio_mode > 2) {     /* 2 is maximum allowed tPIO value */
@@ -286,9 +304,7 @@ u8 ide_get_best_pio_mode (ide_drive_t *drive, u8 mode_wanted, u8 max_mode, ide_p
                         overridden = 1;
                 }
                 if (id->field_valid & 2) {        /* drive implements ATA2? */
-                        if (id->capability & 8) { /* drive supports use_iordy? */
-                                use_iordy = 1;
-                                cycle_time = id->eide_pio_iordy;
+                        if (id->capability & 8) { /* IORDY supported? */
                                 if (id->eide_pio_modes & 7) {
                                         overridden = 0;
                                         if (id->eide_pio_modes & 4)
@@ -298,31 +314,27 @@ u8 ide_get_best_pio_mode (ide_drive_t *drive, u8 mode_wanted, u8 max_mode, ide_p
                                         else
                                                 pio_mode = 3;
                                 }
-                        } else {
-                                cycle_time = id->eide_pio;
                         }
                 }
 
+                if (overridden)
+                        printk(KERN_INFO "%s: tPIO > 2, assuming tPIO = 2\n",
+                                         drive->name);
+
                 /*
                  * Conservative "downgrade" for all pre-ATA2 drives
                  */
-                if (pio_mode && pio_mode < 4) {
+                if ((drive->hwif->host_flags & IDE_HFLAG_PIO_NO_DOWNGRADE) == 0 &&
+                    pio_mode && pio_mode < 4) {
                         pio_mode--;
-                        overridden = 1;
-                        if (cycle_time && cycle_time < ide_pio_timings[pio_mode].cycle_time)
-                                cycle_time = 0; /* use standard timing */
+                        printk(KERN_INFO "%s: applying conservative "
+                                         "PIO \"downgrade\"\n", drive->name);
                 }
         }
-        if (pio_mode > max_mode) {
+
+        if (pio_mode > max_mode)
                 pio_mode = max_mode;
-                cycle_time = 0;
-        }
-        if (d) {
-                d->pio_mode = pio_mode;
-                d->cycle_time = cycle_time ? cycle_time : ide_pio_timings[pio_mode].cycle_time;
-                d->use_iordy = use_iordy;
-                d->overridden = overridden;
-        }
+
         return pio_mode;
 }
 
diff --git a/drivers/ide/ide-timing.h b/drivers/ide/ide-timing.h
index e6cb8593b5ba..daffbb9797e1 100644
--- a/drivers/ide/ide-timing.h
+++ b/drivers/ide/ide-timing.h
@@ -106,23 +106,6 @@ static struct ide_timing ide_timing[] = {
 #define XFER_EPIO       0x01
 #define XFER_PIO        0x00
 
-static short ide_find_best_pio_mode(ide_drive_t *drive)
-{
-        struct hd_driveid *id = drive->id;
-        short best = 0;
-
-        if (id->field_valid & 2) {      /* EIDE PIO modes */
-
-                if ((best = (drive->id->eide_pio_modes & 4) ? XFER_PIO_5 :
-                            (drive->id->eide_pio_modes & 2) ? XFER_PIO_4 :
-                            (drive->id->eide_pio_modes & 1) ? XFER_PIO_3 : 0)) return best;
-        }
-        
-        return  (drive->id->tPIO == 2) ? XFER_PIO_2 :
-                (drive->id->tPIO == 1) ? XFER_PIO_1 :
-                (drive->id->tPIO == 0) ? XFER_PIO_0 : XFER_PIO_SLOW;
-}
-
 static void ide_timing_quantize(struct ide_timing *t, struct ide_timing *q, int T, int UT)
 {
         q->setup   = EZ(t->setup   * 1000,  T);
@@ -212,7 +195,8 @@ static int ide_timing_compute(ide_drive_t *drive, short speed, struct ide_timing
  */
 
         if ((speed & XFER_MODE) != XFER_PIO) {
-                ide_timing_compute(drive, ide_find_best_pio_mode(drive), &p, T, UT);
+                u8 pio = ide_get_best_pio_mode(drive, 255, 5);
+                ide_timing_compute(drive, XFER_PIO_0 + pio, &p, T, UT);
                 ide_timing_merge(&p, t, t, IDE_TIMING_ALL);
         }
 
diff --git a/drivers/ide/ide.c b/drivers/ide/ide.c
index 077fb674a96d..5e88a060df06 100644
--- a/drivers/ide/ide.c
+++ b/drivers/ide/ide.c
@@ -16,10 +16,6 @@
  *   (usually 14 & 15).
  * There can be up to two drives per interface, as per the ATA-2 spec.
  *
- * Primary:    ide0, port 0x1f0; major=3;  hda is minor=0; hdb is minor=64
- * Secondary:  ide1, port 0x170; major=22; hdc is minor=0; hdd is minor=64
- * Tertiary:   ide2, port 0x???; major=33; hde is minor=0; hdf is minor=64
- * Quaternary: ide3, port 0x???; major=34; hdg is minor=0; hdh is minor=64
  * ...
  *
  *  From hd.c:
@@ -47,80 +43,6 @@
  *  This was a rewrite of just about everything from hd.c, though some original
  *  code is still sprinkled about.  Think of it as a major evolution, with
  *  inspiration from lots of linux users, esp.  hamish@zot.apana.org.au
- *
- *  Version 1.0 ALPHA   initial code, primary i/f working okay
- *  Version 1.3 BETA    dual i/f on shared irq tested & working!
- *  Version 1.4 BETA    added auto probing for irq(s)
- *  Version 1.5 BETA    added ALPHA (untested) support for IDE cd-roms,
- *  ...
- * Version 5.50         allow values as small as 20 for idebus=
- * Version 5.51         force non io_32bit in drive_cmd_intr()
- *                      change delay_10ms() to delay_50ms() to fix problems
- * Version 5.52         fix incorrect invalidation of removable devices
- *                      add "hdx=slow" command line option
- * Version 5.60         start to modularize the driver; the disk and ATAPI
- *                       drivers can be compiled as loadable modules.
- *                      move IDE probe code to ide-probe.c
- *                      move IDE disk code to ide-disk.c
- *                      add support for generic IDE device subdrivers
- *                      add m68k code from Geert Uytterhoeven
- *                      probe all interfaces by default
- *                      add ioctl to (re)probe an interface
- * Version 6.00         use per device request queues
- *                      attempt to optimize shared hwgroup performance
- *                      add ioctl to manually adjust bandwidth algorithms
- *                      add kerneld support for the probe module
- *                      fix bug in ide_error()
- *                      fix bug in the first ide_get_lock() call for Atari
- *                      don't flush leftover data for ATAPI devices
- * Version 6.01         clear hwgroup->active while the hwgroup sleeps
- *                      support HDIO_GETGEO for floppies
- * Version 6.02         fix ide_ack_intr() call
- *                      check partition table on floppies
- * Version 6.03         handle bad status bit sequencing in ide_wait_stat()
- * Version 6.10         deleted old entries from this list of updates
- *                      replaced triton.c with ide-dma.c generic PCI DMA
- *                      added support for BIOS-enabled UltraDMA
- *                      rename all "promise" things to "pdc4030"
- *                      fix EZ-DRIVE handling on small disks
- * Version 6.11         fix probe error in ide_scan_devices()
- *                      fix ancient "jiffies" polling bugs
- *                      mask all hwgroup interrupts on each irq entry
- * Version 6.12         integrate ioctl and proc interfaces
- *                      fix parsing of "idex=" command line parameter
- * Version 6.13         add support for ide4/ide5 courtesy rjones@orchestream.com
- * Version 6.14         fixed IRQ sharing among PCI devices
- * Version 6.15         added SMP awareness to IDE drivers
- * Version 6.16         fixed various bugs; even more SMP friendly
- * Version 6.17         fix for newest EZ-Drive problem
- * Version 6.18         default unpartitioned-disk translation now "BIOS LBA"
- * Version 6.19         Re-design for a UNIFORM driver for all platforms,
- *                        model based on suggestions from Russell King and
- *                        Geert Uytterhoeven
- *                      Promise DC4030VL now supported.
- *                      add support for ide6/ide7
- *                      delay_50ms() changed to ide_delay_50ms() and exported.
- * Version 6.20         Added/Fixed Generic ATA-66 support and hwif detection.
- *                      Added hdx=flash to allow for second flash disk
- *                        detection w/o the hang loop.
- *                      Added support for ide8/ide9
- *                      Added idex=ata66 for the quirky chipsets that are
- *                        ATA-66 compliant, but have yet to determine a method
- *                        of verification of the 80c cable presence.
- *                        Specifically Promise's PDC20262 chipset.
- * Version 6.21         Fixing/Fixed SMP spinlock issue with insight from an old
- *                        hat that clarified original low level driver design.
- * Version 6.30         Added SMP support; fixed multmode issues.  -ml
- * Version 6.31         Debug Share INTR's and request queue streaming
- *                      Native ATA-100 support
- *                      Prep for Cascades Project
- * Version 7.00alpha    First named revision of ide rearrange
- *
- *  Some additional driver compile-time options are in ./include/linux/ide.h
- *
- *  To do, in likely order of completion:
- *      - modify kernel to obtain BIOS geometry for drives on 2nd/3rd/4th i/f
- *
  */
 
 #define REVISION        "Revision: 7.00alpha2"
@@ -455,6 +377,10 @@ static void ide_hwif_restore(ide_hwif_t *hwif, ide_hwif_t *tmp_hwif)
         hwif->straight8                 = tmp_hwif->straight8;
         hwif->bus_state                 = tmp_hwif->bus_state;
 
+        hwif->host_flags                = tmp_hwif->host_flags;
+
+        hwif->pio_mask                  = tmp_hwif->pio_mask;
+
         hwif->atapi_dma                 = tmp_hwif->atapi_dma;
         hwif->ultra_mask                = tmp_hwif->ultra_mask;
         hwif->mwdma_mask                = tmp_hwif->mwdma_mask;
@@ -1171,10 +1097,6 @@ int generic_ide_ioctl(ide_drive_t *drive, struct file *file, struct block_device
                         return 0;
                 }
 
-                case CDROMEJECT:
-                case CDROMCLOSETRAY:
-                        return scsi_cmd_ioctl(file, bdev->bd_disk->queue, bdev->bd_disk, cmd, p);
-
                 case HDIO_GET_BUSSTATE:
                         if (!capable(CAP_SYS_ADMIN))
                                 return -EACCES;
diff --git a/drivers/ide/legacy/ali14xx.c b/drivers/ide/legacy/ali14xx.c
index df17ed68c0bc..9b9c4761cb7d 100644
--- a/drivers/ide/legacy/ali14xx.c
+++ b/drivers/ide/legacy/ali14xx.c
@@ -115,13 +115,12 @@ static void ali14xx_tune_drive (ide_drive_t *drive, u8 pio)
         int time1, time2;
         u8 param1, param2, param3, param4;
         unsigned long flags;
-        ide_pio_data_t d;
         int bus_speed = system_bus_clock();
 
-        pio = ide_get_best_pio_mode(drive, pio, ALI_MAX_PIO, &d);
+        pio = ide_get_best_pio_mode(drive, pio, ALI_MAX_PIO);
 
         /* calculate timing, according to PIO mode */
-        time1 = d.cycle_time;
+        time1 = ide_pio_cycle_time(drive, pio);
         time2 = ide_pio_timings[pio].active_time;
         param3 = param1 = (time2 * bus_speed + 999) / 1000;
         param4 = param2 = (time1 * bus_speed + 999) / 1000 - param1;
@@ -212,10 +211,12 @@ static int __init ali14xx_probe(void)
         mate = &ide_hwifs[1];
 
         hwif->chipset = ide_ali14xx;
+        hwif->pio_mask = ATA_PIO4;
         hwif->tuneproc = &ali14xx_tune_drive;
         hwif->mate = mate;
 
         mate->chipset = ide_ali14xx;
+        mate->pio_mask = ATA_PIO4;
         mate->tuneproc = &ali14xx_tune_drive;
         mate->mate = hwif;
         mate->channel = 1;
diff --git a/drivers/ide/legacy/dtc2278.c b/drivers/ide/legacy/dtc2278.c
index 36a3f0ac6162..6c01d951d074 100644
--- a/drivers/ide/legacy/dtc2278.c
+++ b/drivers/ide/legacy/dtc2278.c
@@ -71,7 +71,7 @@ static void tune_dtc2278 (ide_drive_t *drive, u8 pio)
 {
         unsigned long flags;
 
-        pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+        pio = ide_get_best_pio_mode(drive, pio, 4);
 
         if (pio >= 3) {
                 spin_lock_irqsave(&ide_lock, flags);
@@ -123,6 +123,7 @@ static int __init dtc2278_probe(void)
 
         hwif->serialized = 1;
         hwif->chipset = ide_dtc2278;
+        hwif->pio_mask = ATA_PIO4;
         hwif->tuneproc = &tune_dtc2278;
         hwif->drives[0].no_unmask = 1;
         hwif->drives[1].no_unmask = 1;
diff --git a/drivers/ide/legacy/falconide.c b/drivers/ide/legacy/falconide.c
index e1e9d9d6893f..f0829b83e970 100644
--- a/drivers/ide/legacy/falconide.c
+++ b/drivers/ide/legacy/falconide.c
@@ -8,6 +8,7 @@
  *  more details.
  */
 
+#include <linux/module.h>
 #include <linux/types.h>
 #include <linux/mm.h>
 #include <linux/interrupt.h>
@@ -54,6 +55,7 @@ static int falconide_offsets[IDE_NR_PORTS] __initdata = {
      */
 
 int falconide_intr_lock;
+EXPORT_SYMBOL(falconide_intr_lock);
 
 
     /*
diff --git a/drivers/ide/legacy/ht6560b.c b/drivers/ide/legacy/ht6560b.c
index c8f353b1296f..bfaa2025173b 100644
--- a/drivers/ide/legacy/ht6560b.c
+++ b/drivers/ide/legacy/ht6560b.c
@@ -203,19 +203,21 @@ static u8 ht_pio2timings(ide_drive_t *drive, u8 pio)
 {
         int active_time, recovery_time;
         int active_cycles, recovery_cycles;
-        ide_pio_data_t d;
         int bus_speed = system_bus_clock();
         
         if (pio) {
-                pio = ide_get_best_pio_mode(drive, pio, 5, &d);
-                
+                unsigned int cycle_time;
+
+                pio = ide_get_best_pio_mode(drive, pio, 5);
+                cycle_time = ide_pio_cycle_time(drive, pio);
+
                 /*
                  *  Just like opti621.c we try to calculate the
                  *  actual cycle time for recovery and activity
                  *  according system bus speed.
                  */
                 active_time = ide_pio_timings[pio].active_time;
-                recovery_time = d.cycle_time 
+                recovery_time = cycle_time
                         - active_time
                         - ide_pio_timings[pio].setup_time;
                 /*
@@ -331,12 +333,14 @@ int __init ht6560b_init(void)
 
         hwif->chipset = ide_ht6560b;
         hwif->selectproc = &ht6560b_selectproc;
+        hwif->pio_mask = ATA_PIO5;
         hwif->tuneproc = &tune_ht6560b;
         hwif->serialized = 1;   /* is this needed? */
         hwif->mate = mate;
 
         mate->chipset = ide_ht6560b;
         mate->selectproc = &ht6560b_selectproc;
+        mate->pio_mask = ATA_PIO5;
         mate->tuneproc = &tune_ht6560b;
         mate->serialized = 1;   /* is this needed? */
         mate->mate = hwif;
diff --git a/drivers/ide/legacy/ide-cs.c b/drivers/ide/legacy/ide-cs.c
index 2f3977f195b7..4cdb519f9832 100644
--- a/drivers/ide/legacy/ide-cs.c
+++ b/drivers/ide/legacy/ide-cs.c
@@ -386,6 +386,7 @@ static struct pcmcia_device_id ide_ids[] = {
         PCMCIA_DEVICE_PROD_ID12("HITACHI", "microdrive", 0xf4f43949, 0xa6d76178),
         PCMCIA_DEVICE_PROD_ID12("IBM", "microdrive", 0xb569a6e5, 0xa6d76178),
         PCMCIA_DEVICE_PROD_ID12("IBM", "IBM17JSSFP20", 0xb569a6e5, 0xf2508753),
+        PCMCIA_DEVICE_PROD_ID12("KINGSTON", "CF8GB", 0x2e6d1829, 0xacbe682e),
         PCMCIA_DEVICE_PROD_ID12("IO DATA", "CBIDE2      ", 0x547e66dc, 0x8671043b),
         PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDE", 0x547e66dc, 0x5c5ab149),
         PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDEII", 0x547e66dc, 0xb3662674),
diff --git a/drivers/ide/legacy/qd65xx.c b/drivers/ide/legacy/qd65xx.c
index 7783745dd167..8b87a424094a 100644
--- a/drivers/ide/legacy/qd65xx.c
+++ b/drivers/ide/legacy/qd65xx.c
@@ -252,38 +252,38 @@ static void qd6500_tune_drive (ide_drive_t *drive, u8 pio)
 
 static void qd6580_tune_drive (ide_drive_t *drive, u8 pio)
 {
-        ide_pio_data_t d;
         int base = HWIF(drive)->select_data;
+        unsigned int cycle_time;
         int active_time   = 175;
         int recovery_time = 415; /* worst case values from the dos driver */
 
         if (drive->id && !qd_find_disk_type(drive, &active_time, &recovery_time)) {
-                pio = ide_get_best_pio_mode(drive, pio, 4, &d);
+                pio = ide_get_best_pio_mode(drive, pio, 4);
+                cycle_time = ide_pio_cycle_time(drive, pio);
 
                 switch (pio) {
                         case 0: break;
                         case 3:
-                                if (d.cycle_time >= 110) {
+                                if (cycle_time >= 110) {
                                         active_time = 86;
-                                        recovery_time = d.cycle_time - 102;
+                                        recovery_time = cycle_time - 102;
                                 } else
                                         printk(KERN_WARNING "%s: Strange recovery time !\n",drive->name);
                                 break;
                         case 4:
-                                if (d.cycle_time >= 69) {
+                                if (cycle_time >= 69) {
                                         active_time = 70;
-                                        recovery_time = d.cycle_time - 61;
+                                        recovery_time = cycle_time - 61;
                                 } else
                                         printk(KERN_WARNING "%s: Strange recovery time !\n",drive->name);
                                 break;
                         default:
-                                if (d.cycle_time >= 180) {
+                                if (cycle_time >= 180) {
                                         active_time = 110;
-                                        recovery_time = d.cycle_time - 120;
+                                        recovery_time = cycle_time - 120;
                                 } else {
                                         active_time = ide_pio_timings[pio].active_time;
-                                        recovery_time = d.cycle_time
-                                                        -active_time;
+                                        recovery_time = cycle_time - active_time;
                                 }
                 }
                 printk(KERN_INFO "%s: PIO mode%d\n", drive->name,pio);
@@ -346,6 +346,7 @@ static void __init qd_setup(ide_hwif_t *hwif, int base, int config,
         hwif->drives[1].drive_data = data1;
         hwif->drives[0].io_32bit =
         hwif->drives[1].io_32bit = 1;
+        hwif->pio_mask = ATA_PIO4;
         hwif->tuneproc = tuneproc;
         probe_hwif_init(hwif);
 }
diff --git a/drivers/ide/legacy/umc8672.c b/drivers/ide/legacy/umc8672.c
index ddc403a0bd82..d2862e638bc5 100644
--- a/drivers/ide/legacy/umc8672.c
+++ b/drivers/ide/legacy/umc8672.c
@@ -110,7 +110,7 @@ static void tune_umc (ide_drive_t *drive, u8 pio)
         unsigned long flags;
         ide_hwgroup_t *hwgroup = ide_hwifs[HWIF(drive)->index^1].hwgroup;
 
-        pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+        pio = ide_get_best_pio_mode(drive, pio, 4);
         printk("%s: setting umc8672 to PIO mode%d (speed %d)\n",
                 drive->name, pio, pio_to_umc[pio]);
         spin_lock_irqsave(&ide_lock, flags);
@@ -149,10 +149,12 @@ static int __init umc8672_probe(void)
         mate = &ide_hwifs[1];
 
         hwif->chipset = ide_umc8672;
+        hwif->pio_mask = ATA_PIO4;
         hwif->tuneproc = &tune_umc;
         hwif->mate = mate;
 
         mate->chipset = ide_umc8672;
+        mate->pio_mask = ATA_PIO4;
         mate->tuneproc = &tune_umc;
         mate->mate = hwif;
         mate->channel = 1;
diff --git a/drivers/ide/mips/au1xxx-ide.c b/drivers/ide/mips/au1xxx-ide.c
index 2e7013a2a7f6..2ba6a054b861 100644
--- a/drivers/ide/mips/au1xxx-ide.c
+++ b/drivers/ide/mips/au1xxx-ide.c
@@ -106,7 +106,7 @@ static void auide_tune_drive(ide_drive_t *drive, byte pio)
         u8 speed;
 
         /* get the best pio mode for the drive */
-        pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+        pio = ide_get_best_pio_mode(drive, pio, 4);
 
         printk(KERN_INFO "%s: setting Au1XXX IDE to PIO mode%d\n",
                drive->name, pio);
@@ -692,6 +692,8 @@ static int au_ide_probe(struct device *dev)
         hwif->swdma_mask                = 0x0;
 #endif
 
+        hwif->pio_mask = ATA_PIO4;
+
         hwif->noprobe = 0;
         hwif->drives[0].unmask          = 1;
         hwif->drives[1].unmask          = 1;
diff --git a/drivers/ide/pci/aec62xx.c b/drivers/ide/pci/aec62xx.c
index e5d09367627e..74432830abf7 100644
--- a/drivers/ide/pci/aec62xx.c
+++ b/drivers/ide/pci/aec62xx.c
@@ -142,7 +142,7 @@ static int aec6260_tune_chipset (ide_drive_t *drive, u8 xferspeed)
 
 static void aec62xx_tune_drive (ide_drive_t *drive, u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+        pio = ide_get_best_pio_mode(drive, pio, 4);
         (void) HWIF(drive)->speedproc(drive, pio + XFER_PIO_0);
 }
 
@@ -174,12 +174,6 @@ static unsigned int __devinit init_chipset_aec62xx(struct pci_dev *dev, const ch
 {
         int bus_speed = system_bus_clock();
 
-        if (dev->resource[PCI_ROM_RESOURCE].start) {
-                pci_write_config_dword(dev, PCI_ROM_ADDRESS, dev->resource[PCI_ROM_RESOURCE].start | PCI_ROM_ADDRESS_ENABLE);
-                printk(KERN_INFO "%s: ROM enabled at 0x%08lx\n", name,
-                        (unsigned long)dev->resource[PCI_ROM_RESOURCE].start);
-        }
-
         if (bus_speed <= 33)
                 pci_set_drvdata(dev, (void *) aec6xxx_33_base);
         else
@@ -271,48 +265,48 @@ static ide_pci_device_t aec62xx_chipsets[] __devinitdata = {
                 .init_setup     = init_setup_aec62xx,
                 .init_chipset   = init_chipset_aec62xx,
                 .init_hwif      = init_hwif_aec62xx,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .enablebits     = {{0x4a,0x02,0x02}, {0x4a,0x04,0x04}},
                 .bootable       = OFF_BOARD,
+                .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x07, /* udma0-2 */
         },{     /* 1 */
                 .name           = "AEC6260",
                 .init_setup     = init_setup_aec62xx,
                 .init_chipset   = init_chipset_aec62xx,
                 .init_hwif      = init_hwif_aec62xx,
-                .channels       = 2,
                 .autodma        = NOAUTODMA,
                 .bootable       = OFF_BOARD,
+                .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x1f, /* udma0-4 */
         },{     /* 2 */
                 .name           = "AEC6260R",
                 .init_setup     = init_setup_aec62xx,
                 .init_chipset   = init_chipset_aec62xx,
                 .init_hwif      = init_hwif_aec62xx,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .enablebits     = {{0x4a,0x02,0x02}, {0x4a,0x04,0x04}},
                 .bootable       = NEVER_BOARD,
+                .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x1f, /* udma0-4 */
         },{     /* 3 */
                 .name           = "AEC6280",
                 .init_setup     = init_setup_aec6x80,
                 .init_chipset   = init_chipset_aec62xx,
                 .init_hwif      = init_hwif_aec62xx,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .bootable       = OFF_BOARD,
+                .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x3f, /* udma0-5 */
         },{     /* 4 */
                 .name           = "AEC6280R",
                 .init_setup     = init_setup_aec6x80,
                 .init_chipset   = init_chipset_aec62xx,
                 .init_hwif      = init_hwif_aec62xx,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .enablebits     = {{0x4a,0x02,0x02}, {0x4a,0x04,0x04}},
                 .bootable       = OFF_BOARD,
+                .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x3f, /* udma0-5 */
         }
 };
diff --git a/drivers/ide/pci/alim15x3.c b/drivers/ide/pci/alim15x3.c
index ba0fb92b0417..5511c86733dc 100644
--- a/drivers/ide/pci/alim15x3.c
+++ b/drivers/ide/pci/alim15x3.c
@@ -295,7 +295,6 @@ static int ali_get_info (char *buffer, char **addr, off_t offset, int count)
  
 static u8 ali15x3_tune_pio (ide_drive_t *drive, u8 pio)
 {
-        ide_pio_data_t d;
         ide_hwif_t *hwif = HWIF(drive);
         struct pci_dev *dev = hwif->pci_dev;
         int s_time, a_time, c_time;
@@ -307,7 +306,7 @@ static u8 ali15x3_tune_pio (ide_drive_t *drive, u8 pio)
         u8 cd_dma_fifo = 0;
         int unit = drive->select.b.unit & 1;
 
-        pio = ide_get_best_pio_mode(drive, pio, 5, &d);
+        pio = ide_get_best_pio_mode(drive, pio, 5);
         s_time = ide_pio_timings[pio].setup_time;
         a_time = ide_pio_timings[pio].active_time;
         if ((s_clc = (s_time * bus_speed + 999) / 1000) >= 8)
@@ -817,9 +816,9 @@ static ide_pci_device_t ali15x3_chipset __devinitdata = {
         .init_chipset   = init_chipset_ali15x3,
         .init_hwif      = init_hwif_ali15x3,
         .init_dma       = init_dma_ali15x3,
-        .channels       = 2,
         .autodma        = AUTODMA,
         .bootable       = ON_BOARD,
+        .pio_mask       = ATA_PIO5,
 };
 
 /**
diff --git a/drivers/ide/pci/amd74xx.c b/drivers/ide/pci/amd74xx.c
index 8d30b99a54d8..06c15a6a3e7d 100644
--- a/drivers/ide/pci/amd74xx.c
+++ b/drivers/ide/pci/amd74xx.c
@@ -1,5 +1,5 @@
 /*
- * Version 2.20
+ * Version 2.21
  *
  * AMD 755/756/766/8111 and nVidia nForce/2/2s/3/3s/CK804/MCP04
  * IDE driver for Linux.
@@ -272,10 +272,8 @@ static int amd_set_drive(ide_drive_t *drive, u8 speed)
 
 static void amd74xx_tune_drive(ide_drive_t *drive, u8 pio)
 {
-        if (pio == 255) {
-                amd_set_drive(drive, ide_find_best_pio_mode(drive));
-                return;
-        }
+        if (pio == 255)
+                pio = ide_get_best_pio_mode(drive, 255, 5);
 
         amd_set_drive(drive, XFER_PIO_0 + min_t(byte, pio, 5));
 }
@@ -284,12 +282,14 @@ static int amd74xx_ide_dma_check(ide_drive_t *drive)
 {
         u8 speed = ide_max_dma_mode(drive);
 
-        if (speed == 0)
-                speed = ide_find_best_pio_mode(drive);
+        if (speed == 0) {
+                amd74xx_tune_drive(drive, 255);
+                return -1;
+        }
 
         amd_set_drive(drive, speed);
 
-        if (drive->autodma && (speed & XFER_MODE) != XFER_PIO)
+        if (drive->autodma)
                 return 0;
 
         return -1;
@@ -448,10 +448,12 @@ static void __devinit init_hwif_amd74xx(ide_hwif_t *hwif)
                 .name           = name_str,                             \
                 .init_chipset   = init_chipset_amd74xx,                 \
                 .init_hwif      = init_hwif_amd74xx,                    \
-                .channels       = 2,                                    \
                 .autodma        = AUTODMA,                              \
                 .enablebits     = {{0x40,0x02,0x02}, {0x40,0x01,0x01}}, \
                 .bootable       = ON_BOARD,                             \
+                .host_flags     = IDE_HFLAG_PIO_NO_BLACKLIST            \
+                                | IDE_HFLAG_PIO_NO_DOWNGRADE,           \
+                .pio_mask       = ATA_PIO5,                             \
         }
 
 #define DECLARE_NV_DEV(name_str)                                        \
@@ -459,10 +461,12 @@ static void __devinit init_hwif_amd74xx(ide_hwif_t *hwif)
                 .name           = name_str,                             \
                 .init_chipset   = init_chipset_amd74xx,                 \
                 .init_hwif      = init_hwif_amd74xx,                    \
-                .channels       = 2,                                    \
                 .autodma        = AUTODMA,                              \
                 .enablebits     = {{0x50,0x02,0x02}, {0x50,0x01,0x01}}, \
                 .bootable       = ON_BOARD,                             \
+                .host_flags     = IDE_HFLAG_PIO_NO_BLACKLIST            \
+                                | IDE_HFLAG_PIO_NO_DOWNGRADE,           \
+                .pio_mask       = ATA_PIO5,                             \
         }
 
 static ide_pci_device_t amd74xx_chipsets[] __devinitdata = {
diff --git a/drivers/ide/pci/atiixp.c b/drivers/ide/pci/atiixp.c
index 2761510309b3..1725aa402d98 100644
--- a/drivers/ide/pci/atiixp.c
+++ b/drivers/ide/pci/atiixp.c
@@ -1,9 +1,8 @@
 /*
- *  linux/drivers/ide/pci/atiixp.c      Version 0.01-bart2      Feb. 26, 2004
+ *  linux/drivers/ide/pci/atiixp.c      Version 0.02    Jun 16 2007
  *
  *  Copyright (C) 2003 ATI Inc. <hyu@ati.com>
- *  Copyright (C) 2004 Bartlomiej Zolnierkiewicz
- *
+ *  Copyright (C) 2004,2007 Bartlomiej Zolnierkiewicz
  */
 
 #include <linux/types.h>
@@ -123,14 +122,14 @@ static void atiixp_dma_host_off(ide_drive_t *drive)
 }
 
 /**
- *      atiixp_tune_drive               -       tune a drive attached to a ATIIXP
+ *      atiixp_tune_pio -       tune a drive attached to a ATIIXP
  *      @drive: drive to tune
  *      @pio: desired PIO mode
  *
  *      Set the interface PIO mode.
  */
 
-static void atiixp_tuneproc(ide_drive_t *drive, u8 pio)
+static void atiixp_tune_pio(ide_drive_t *drive, u8 pio)
 {
         struct pci_dev *dev = drive->hwif->pci_dev;
         unsigned long flags;
@@ -154,6 +153,13 @@ static void atiixp_tuneproc(ide_drive_t *drive, u8 pio)
         spin_unlock_irqrestore(&atiixp_lock, flags);
 }
 
+static void atiixp_tuneproc(ide_drive_t *drive, u8 pio)
+{
+        pio = ide_get_best_pio_mode(drive, pio, 4);
+        atiixp_tune_pio(drive, pio);
+        (void)ide_config_drive_speed(drive, XFER_PIO_0 + pio);
+}
+
 /**
  *      atiixp_tune_chipset     -       tune a ATIIXP interface
  *      @drive: IDE drive to tune
@@ -175,6 +181,11 @@ static int atiixp_speedproc(ide_drive_t *drive, u8 xferspeed)
 
         speed = ide_rate_filter(drive, xferspeed);
 
+        if (speed >= XFER_PIO_0 && speed <= XFER_PIO_4) {
+                atiixp_tune_pio(drive, speed - XFER_PIO_0);
+                return ide_config_drive_speed(drive, speed);
+        }
+
         spin_lock_irqsave(&atiixp_lock, flags);
 
         save_mdma_mode[drive->dn] = 0;
@@ -201,7 +212,7 @@ static int atiixp_speedproc(ide_drive_t *drive, u8 xferspeed)
         else
                 pio = speed - XFER_PIO_0;
 
-        atiixp_tuneproc(drive, pio);
+        atiixp_tune_pio(drive, pio);
 
         return ide_config_drive_speed(drive, speed);
 }
@@ -216,18 +227,13 @@ static int atiixp_speedproc(ide_drive_t *drive, u8 xferspeed)
 
 static int atiixp_dma_check(ide_drive_t *drive)
 {
-        u8 tspeed, speed;
-
         drive->init_speed = 0;
 
         if (ide_tune_dma(drive))
                 return 0;
 
-        if (ide_use_fast_pio(drive)) {
-                tspeed = ide_get_best_pio_mode(drive, 255, 5, NULL);
-                speed = atiixp_dma_2_pio(XFER_PIO_0 + tspeed) + XFER_PIO_0;
-                atiixp_speedproc(drive, speed);
-        }
+        if (ide_use_fast_pio(drive))
+                atiixp_tuneproc(drive, 255);
 
         return -1;
 }
@@ -285,17 +291,18 @@ static ide_pci_device_t atiixp_pci_info[] __devinitdata = {
         {       /* 0 */
                 .name           = "ATIIXP",
                 .init_hwif      = init_hwif_atiixp,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .enablebits     = {{0x48,0x01,0x00}, {0x48,0x08,0x00}},
                 .bootable       = ON_BOARD,
+                .pio_mask       = ATA_PIO4,
         },{     /* 1 */
                 .name           = "SB600_PATA",
                 .init_hwif      = init_hwif_atiixp,
-                .channels       = 1,
                 .autodma        = AUTODMA,
                 .enablebits     = {{0x48,0x01,0x00}, {0x00,0x00,0x00}},
                 .bootable       = ON_BOARD,
+                .host_flags     = IDE_HFLAG_SINGLE,
+                .pio_mask       = ATA_PIO4,
         },
 };
 
diff --git a/drivers/ide/pci/cmd640.c b/drivers/ide/pci/cmd640.c
index dc43f009acab..9689494efa24 100644
--- a/drivers/ide/pci/cmd640.c
+++ b/drivers/ide/pci/cmd640.c
@@ -633,9 +633,8 @@ static void cmd640_set_mode (unsigned int index, u8 pio_mode, unsigned int cycle
  */
 static void cmd640_tune_drive (ide_drive_t *drive, u8 mode_wanted)
 {
+        unsigned int index = 0, cycle_time;
         u8 b;
-        ide_pio_data_t  d;
-        unsigned int index = 0;
 
         while (drive != cmd_drives[index]) {
                 if (++index > 3) {
@@ -662,16 +661,14 @@ static void cmd640_tune_drive (ide_drive_t *drive, u8 mode_wanted)
                         return;
         }
 
-        (void) ide_get_best_pio_mode (drive, mode_wanted, 5, &d);
-        cmd640_set_mode (index, d.pio_mode, d.cycle_time);
+        mode_wanted = ide_get_best_pio_mode(drive, mode_wanted, 5);
+        cycle_time = ide_pio_cycle_time(drive, mode_wanted);
+        cmd640_set_mode(index, mode_wanted, cycle_time);
+
+        printk("%s: selected cmd640 PIO mode%d (%dns)",
+                drive->name, mode_wanted, cycle_time);
 
-        printk ("%s: selected cmd640 PIO mode%d (%dns)%s",
-                drive->name,
-                d.pio_mode,
-                d.cycle_time,
-                d.overridden ? " (overriding vendor mode)" : "");
         display_clocks(index);
-        return;
 }
 
 #endif /* CONFIG_BLK_DEV_CMD640_ENHANCED */
@@ -769,6 +766,7 @@ int __init ide_probe_for_cmd640x (void)
                cmd_hwif0->name, 'a' + cmd640_chip_version - 1, bus_type, cfr);
         cmd_hwif0->chipset = ide_cmd640;
 #ifdef CONFIG_BLK_DEV_CMD640_ENHANCED
+        cmd_hwif0->pio_mask = ATA_PIO5;
         cmd_hwif0->tuneproc = &cmd640_tune_drive;
 #endif /* CONFIG_BLK_DEV_CMD640_ENHANCED */
 
@@ -824,6 +822,7 @@ int __init ide_probe_for_cmd640x (void)
                 cmd_hwif1->mate = cmd_hwif0;
                 cmd_hwif1->channel = 1;
 #ifdef CONFIG_BLK_DEV_CMD640_ENHANCED
+                cmd_hwif1->pio_mask = ATA_PIO5;
                 cmd_hwif1->tuneproc = &cmd640_tune_drive;
 #endif /* CONFIG_BLK_DEV_CMD640_ENHANCED */
         }
diff --git a/drivers/ide/pci/cmd64x.c b/drivers/ide/pci/cmd64x.c
index 1e89dd6e5bbf..19633c5aba15 100644
--- a/drivers/ide/pci/cmd64x.c
+++ b/drivers/ide/pci/cmd64x.c
@@ -221,17 +221,18 @@ static u8 cmd64x_tune_pio (ide_drive_t *drive, u8 mode_wanted)
 {
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
-        ide_pio_data_t pio;
+        unsigned int cycle_time;
         u8 pio_mode, setup_count, arttim = 0;
         static const u8 setup_values[] = {0x40, 0x40, 0x40, 0x80, 0, 0xc0};
         static const u8 arttim_regs[4] = {ARTTIM0, ARTTIM1, ARTTIM23, ARTTIM23};
-        pio_mode = ide_get_best_pio_mode(drive, mode_wanted, 5, &pio);
 
-        cmdprintk("%s: PIO mode wanted %d, selected %d (%d ns)%s\n",
-                  drive->name, mode_wanted, pio_mode, pio.cycle_time,
-                  pio.overridden ? " (overriding vendor mode)" : "");
+        pio_mode = ide_get_best_pio_mode(drive, mode_wanted, 5);
+        cycle_time = ide_pio_cycle_time(drive, pio_mode);
 
-        program_cycle_times(drive, pio.cycle_time,
+        cmdprintk("%s: PIO mode wanted %d, selected %d (%d ns)\n",
+                  drive->name, mode_wanted, pio_mode, cycle_time);
+
+        program_cycle_times(drive, cycle_time,
                             ide_pio_timings[pio_mode].active_time);
 
         setup_count = quantize_timing(ide_pio_timings[pio_mode].setup_time,
@@ -618,40 +619,40 @@ static ide_pci_device_t cmd64x_chipsets[] __devinitdata = {
                 .init_setup     = init_setup_cmd64x,
                 .init_chipset   = init_chipset_cmd64x,
                 .init_hwif      = init_hwif_cmd64x,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .enablebits     = {{0x00,0x00,0x00}, {0x51,0x08,0x08}},
                 .bootable       = ON_BOARD,
+                .pio_mask       = ATA_PIO5,
                 .udma_mask      = 0x00, /* no udma */
         },{     /* 1 */
                 .name           = "CMD646",
                 .init_setup     = init_setup_cmd646,
                 .init_chipset   = init_chipset_cmd64x,
                 .init_hwif      = init_hwif_cmd64x,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .enablebits     = {{0x51,0x04,0x04}, {0x51,0x08,0x08}},
                 .bootable       = ON_BOARD,
+                .pio_mask       = ATA_PIO5,
                 .udma_mask      = 0x07, /* udma0-2 */
         },{     /* 2 */
                 .name           = "CMD648",
                 .init_setup     = init_setup_cmd64x,
                 .init_chipset   = init_chipset_cmd64x,
                 .init_hwif      = init_hwif_cmd64x,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .enablebits     = {{0x51,0x04,0x04}, {0x51,0x08,0x08}},
                 .bootable       = ON_BOARD,
+                .pio_mask       = ATA_PIO5,
                 .udma_mask      = 0x1f, /* udma0-4 */
         },{     /* 3 */
                 .name           = "CMD649",
                 .init_setup     = init_setup_cmd64x,
                 .init_chipset   = init_chipset_cmd64x,
                 .init_hwif      = init_hwif_cmd64x,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .enablebits     = {{0x51,0x04,0x04}, {0x51,0x08,0x08}},
                 .bootable       = ON_BOARD,
+                .pio_mask       = ATA_PIO5,
                 .udma_mask      = 0x3f, /* udma0-5 */
         }
 };
diff --git a/drivers/ide/pci/cs5520.c b/drivers/ide/pci/cs5520.c
index 3b88a3a56116..bccedf9b8b28 100644
--- a/drivers/ide/pci/cs5520.c
+++ b/drivers/ide/pci/cs5520.c
@@ -126,7 +126,7 @@ static int cs5520_tune_chipset(ide_drive_t *drive, u8 xferspeed)
         
 static void cs5520_tune_drive(ide_drive_t *drive, u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+        pio = ide_get_best_pio_mode(drive, pio, 4);
         cs5520_tune_chipset(drive, (XFER_PIO_0 + pio));
 }
 
@@ -194,10 +194,10 @@ static void __devinit init_hwif_cs5520(ide_hwif_t *hwif)
                 .name           = name_str,                     \
                 .init_setup_dma = cs5520_init_setup_dma,        \
                 .init_hwif      = init_hwif_cs5520,             \
-                .channels       = 2,                            \
                 .autodma        = AUTODMA,                      \
                 .bootable       = ON_BOARD,                     \
-                .flags          = IDEPCI_FLAG_ISA_PORTS,        \
+                .host_flags     = IDE_HFLAG_ISA_PORTS,          \
+                .pio_mask       = ATA_PIO4,                     \
         }
 
 static ide_pci_device_t cyrix_chipsets[] __devinitdata = {
diff --git a/drivers/ide/pci/cs5530.c b/drivers/ide/pci/cs5530.c
index b5c00d15a704..acaf71fd4c09 100644
--- a/drivers/ide/pci/cs5530.c
+++ b/drivers/ide/pci/cs5530.c
@@ -82,7 +82,7 @@ static void cs5530_tunepio(ide_drive_t *drive, u8 pio)
 
 static void cs5530_tuneproc (ide_drive_t *drive, u8 pio)        /* pio=255 means "autotune" */
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+        pio = ide_get_best_pio_mode(drive, pio, 4);
 
         if (cs5530_set_xfer_mode(drive, XFER_PIO_0 + pio) == 0)
                 cs5530_tunepio(drive, pio);
@@ -341,9 +341,9 @@ static ide_pci_device_t cs5530_chipset __devinitdata = {
         .name           = "CS5530",
         .init_chipset   = init_chipset_cs5530,
         .init_hwif      = init_hwif_cs5530,
-        .channels       = 2,
         .autodma        = AUTODMA,
         .bootable       = ON_BOARD,
+        .pio_mask       = ATA_PIO4,
 };
 
 static int __devinit cs5530_init_one(struct pci_dev *dev, const struct pci_device_id *id)
diff --git a/drivers/ide/pci/cs5535.c b/drivers/ide/pci/cs5535.c
index 10f61f38243c..ce44e38390aa 100644
--- a/drivers/ide/pci/cs5535.c
+++ b/drivers/ide/pci/cs5535.c
@@ -89,7 +89,7 @@ static void cs5535_set_speed(ide_drive_t *drive, u8 speed)
 
                 pioa = speed - XFER_PIO_0;
                 piob = ide_get_best_pio_mode(&(drive->hwif->drives[!unit]),
-                                                255, 4, NULL);
+                                                255, 4);
                 cmd = pioa < piob ? pioa : piob;
 
                 /* Write the speed of the current drive */
@@ -159,7 +159,7 @@ static void cs5535_tuneproc(ide_drive_t *drive, u8 xferspeed)
         /* cs5535 max pio is pio 4, best_pio will check the blacklist.
         i think we don't need to rate_filter the incoming xferspeed
         since we know we're only going to choose pio */
-        xferspeed = ide_get_best_pio_mode(drive, xferspeed, 4, NULL);
+        xferspeed = ide_get_best_pio_mode(drive, xferspeed, 4);
         ide_config_drive_speed(drive, modes[xferspeed]);
         cs5535_set_speed(drive, xferspeed);
 }
@@ -174,7 +174,7 @@ static int cs5535_dma_check(ide_drive_t *drive)
                 return 0;
 
         if (ide_use_fast_pio(drive)) {
-                speed = ide_get_best_pio_mode(drive, 255, 4, NULL);
+                speed = ide_get_best_pio_mode(drive, 255, 4);
                 cs5535_set_drive(drive, speed);
         }
 
@@ -228,9 +228,10 @@ static void __devinit init_hwif_cs5535(ide_hwif_t *hwif)
 static ide_pci_device_t cs5535_chipset __devinitdata = {
         .name           = "CS5535",
         .init_hwif      = init_hwif_cs5535,
-        .channels       = 1,
         .autodma        = AUTODMA,
         .bootable       = ON_BOARD,
+        .host_flags     = IDE_HFLAG_SINGLE,
+        .pio_mask       = ATA_PIO4,
 };
 
 static int __devinit cs5535_init_one(struct pci_dev *dev,
diff --git a/drivers/ide/pci/cy82c693.c b/drivers/ide/pci/cy82c693.c
index 103b9db97853..daa36fcbc8ef 100644
--- a/drivers/ide/pci/cy82c693.c
+++ b/drivers/ide/pci/cy82c693.c
@@ -330,7 +330,7 @@ static void cy82c693_tune_drive (ide_drive_t *drive, u8 pio)
 #endif /* CY82C693_DEBUG_LOGS */
 
         /* first let's calc the pio modes */
-        pio = ide_get_best_pio_mode(drive, pio, CY82C693_MAX_PIO, NULL);
+        pio = ide_get_best_pio_mode(drive, pio, CY82C693_MAX_PIO);
 
 #if CY82C693_DEBUG_INFO
         printk (KERN_INFO "%s: Selected PIO mode %d\n", drive->name, pio);
@@ -483,9 +483,10 @@ static ide_pci_device_t cy82c693_chipset __devinitdata = {
         .init_chipset   = init_chipset_cy82c693,
         .init_iops      = init_iops_cy82c693,
         .init_hwif      = init_hwif_cy82c693,
-        .channels       = 1,
         .autodma        = AUTODMA,
         .bootable       = ON_BOARD,
+        .host_flags     = IDE_HFLAG_SINGLE,
+        .pio_mask       = ATA_PIO4,
 };
 
 static int __devinit cy82c693_init_one(struct pci_dev *dev, const struct pci_device_id *id)
diff --git a/drivers/ide/pci/generic.c b/drivers/ide/pci/generic.c
index 0d51a11e81da..48caa468b762 100644
--- a/drivers/ide/pci/generic.c
+++ b/drivers/ide/pci/generic.c
@@ -95,92 +95,77 @@ static ide_pci_device_t generic_chipsets[] __devinitdata = {
         {       /* 0 */
                 .name           = "Unknown",
                 .init_hwif      = init_hwif_generic,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .bootable       = ON_BOARD,
         },{     /* 1 */
                 .name           = "NS87410",
                 .init_hwif      = init_hwif_generic,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .enablebits     = {{0x43,0x08,0x08}, {0x47,0x08,0x08}},
                 .bootable       = ON_BOARD,
         },{     /* 2 */
                 .name           = "SAMURAI",
                 .init_hwif      = init_hwif_generic,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .bootable       = ON_BOARD,
         },{     /* 3 */
                 .name           = "HT6565",
                 .init_hwif      = init_hwif_generic,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .bootable       = ON_BOARD,
         },{     /* 4 */
                 .name           = "UM8673F",
                 .init_hwif      = init_hwif_generic,
-                .channels       = 2,
                 .autodma        = NODMA,
                 .bootable       = ON_BOARD,
         },{     /* 5 */
                 .name           = "UM8886A",
                 .init_hwif      = init_hwif_generic,
-                .channels       = 2,
                 .autodma        = NODMA,
                 .bootable       = ON_BOARD,
         },{     /* 6 */
                 .name           = "UM8886BF",
                 .init_hwif      = init_hwif_generic,
-                .channels       = 2,
                 .autodma        = NODMA,
                 .bootable       = ON_BOARD,
         },{     /* 7 */
                 .name           = "HINT_IDE",
                 .init_hwif      = init_hwif_generic,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .bootable       = ON_BOARD,
         },{     /* 8 */
                 .name           = "VIA_IDE",
                 .init_hwif      = init_hwif_generic,
-                .channels       = 2,
                 .autodma        = NOAUTODMA,
                 .bootable       = ON_BOARD,
         },{     /* 9 */
                 .name           = "OPTI621V",
                 .init_hwif      = init_hwif_generic,
-                .channels       = 2,
                 .autodma        = NOAUTODMA,
                 .bootable       = ON_BOARD,
         },{     /* 10 */
                 .name           = "VIA8237SATA",
                 .init_hwif      = init_hwif_generic,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .bootable       = OFF_BOARD,
         },{     /* 11 */
                 .name           = "Piccolo0102",
                 .init_hwif      = init_hwif_generic,
-                .channels       = 2,
                 .autodma        = NOAUTODMA,
                 .bootable       = ON_BOARD,
         },{     /* 12 */
                 .name           = "Piccolo0103",
                 .init_hwif      = init_hwif_generic,
-                .channels       = 2,
                 .autodma        = NOAUTODMA,
                 .bootable       = ON_BOARD,
         },{     /* 13 */
                 .name           = "Piccolo0105",
                 .init_hwif      = init_hwif_generic,
-                .channels       = 2,
                 .autodma        = NOAUTODMA,
                 .bootable       = ON_BOARD,
         },{     /* 14 */
                 .name           = "Revolution",
                 .init_hwif      = init_hwif_generic,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .bootable       = OFF_BOARD,
         }
diff --git a/drivers/ide/pci/hpt34x.c b/drivers/ide/pci/hpt34x.c
index 2c24c3de8846..19778c5fe711 100644
--- a/drivers/ide/pci/hpt34x.c
+++ b/drivers/ide/pci/hpt34x.c
@@ -80,7 +80,7 @@ static int hpt34x_tune_chipset (ide_drive_t *drive, u8 xferspeed)
 
 static void hpt34x_tune_drive (ide_drive_t *drive, u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 5, NULL);
+        pio = ide_get_best_pio_mode(drive, pio, 5);
         (void) hpt34x_tune_chipset(drive, (XFER_PIO_0 + pio));
 }
 
@@ -120,17 +120,10 @@ static unsigned int __devinit init_chipset_hpt34x(struct pci_dev *dev, const cha
         pci_write_config_byte(dev, HPT34X_PCI_INIT_REG, 0x00);
         pci_read_config_word(dev, PCI_COMMAND, &cmd);
 
-        if (cmd & PCI_COMMAND_MEMORY) {
-                if (pci_resource_start(dev, PCI_ROM_RESOURCE)) {
-                        pci_write_config_dword(dev, PCI_ROM_ADDRESS,
-                                dev->resource[PCI_ROM_RESOURCE].start | PCI_ROM_ADDRESS_ENABLE);
-                        printk(KERN_INFO "HPT345: ROM enabled at 0x%08lx\n",
-                                (unsigned long)dev->resource[PCI_ROM_RESOURCE].start);
-                }
+        if (cmd & PCI_COMMAND_MEMORY)
                 pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0xF0);
-        } else {
+        else
                 pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0x20);
-        }
 
         /*
          * Since 20-23 can be assigned and are R/W, we correct them.
@@ -182,10 +175,10 @@ static ide_pci_device_t hpt34x_chipset __devinitdata = {
         .name           = "HPT34X",
         .init_chipset   = init_chipset_hpt34x,
         .init_hwif      = init_hwif_hpt34x,
-        .channels       = 2,
         .autodma        = NOAUTODMA,
         .bootable       = NEVER_BOARD,
-        .extra          = 16
+        .extra          = 16,
+        .pio_mask       = ATA_PIO5,
 };
 
 static int __devinit hpt34x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
diff --git a/drivers/ide/pci/hpt366.c b/drivers/ide/pci/hpt366.c
index e9b07a97c340..2cd74c345a6c 100644
--- a/drivers/ide/pci/hpt366.c
+++ b/drivers/ide/pci/hpt366.c
@@ -652,7 +652,7 @@ static int hpt3xx_tune_chipset(ide_drive_t *drive, u8 speed)
 
 static void hpt3xx_tune_drive(ide_drive_t *drive, u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+        pio = ide_get_best_pio_mode(drive, pio, 4);
         (void) hpt3xx_tune_chipset (drive, XFER_PIO_0 + pio);
 }
 
@@ -994,14 +994,6 @@ static unsigned int __devinit init_chipset_hpt366(struct pci_dev *dev, const cha
          */
         *info = *(struct hpt_info *)pci_get_drvdata(dev);
 
-        /*
-         * FIXME: Not portable. Also, why do we enable the ROM in the first place?
-         * We don't seem to be using it.
-         */
-        if (dev->resource[PCI_ROM_RESOURCE].start)
-                pci_write_config_dword(dev, PCI_ROM_ADDRESS,
-                        dev->resource[PCI_ROM_RESOURCE].start | PCI_ROM_ADDRESS_ENABLE);
-
         pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, (L1_CACHE_BYTES / 4));
         pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0x78);
         pci_write_config_byte(dev, PCI_MIN_GNT, 0x08);
@@ -1491,7 +1483,7 @@ static int __devinit init_setup_hpt366(struct pci_dev *dev, ide_pci_device_t *d)
                  * to both functions -- really stupid design decision... :-(
                  * Bit 4 is for the primary channel, bit 5 for the secondary.
                  */
-                d->channels = 1;
+                d->host_flags |= IDE_HFLAG_SINGLE;
                 d->enablebits[0].mask = d->enablebits[0].val = 0x10;
 
                 d->udma_mask = HPT366_ALLOW_ATA66_3 ?
@@ -1554,71 +1546,71 @@ static ide_pci_device_t hpt366_chipsets[] __devinitdata = {
                 .init_chipset   = init_chipset_hpt366,
                 .init_hwif      = init_hwif_hpt366,
                 .init_dma       = init_dma_hpt366,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .enablebits     = {{0x50,0x04,0x04}, {0x54,0x04,0x04}},
                 .bootable       = OFF_BOARD,
-                .extra          = 240
+                .extra          = 240,
+                .pio_mask       = ATA_PIO4,
         },{     /* 1 */
                 .name           = "HPT372A",
                 .init_setup     = init_setup_hpt372a,
                 .init_chipset   = init_chipset_hpt366,
                 .init_hwif      = init_hwif_hpt366,
                 .init_dma       = init_dma_hpt366,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .enablebits     = {{0x50,0x04,0x04}, {0x54,0x04,0x04}},
                 .udma_mask      = HPT372_ALLOW_ATA133_6 ? 0x7f : 0x3f,
                 .bootable       = OFF_BOARD,
-                .extra          = 240
+                .extra          = 240,
+                .pio_mask       = ATA_PIO4,
         },{     /* 2 */
                 .name           = "HPT302",
                 .init_setup     = init_setup_hpt302,
                 .init_chipset   = init_chipset_hpt366,
                 .init_hwif      = init_hwif_hpt366,
                 .init_dma       = init_dma_hpt366,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .enablebits     = {{0x50,0x04,0x04}, {0x54,0x04,0x04}},
                 .udma_mask      = HPT302_ALLOW_ATA133_6 ? 0x7f : 0x3f,
                 .bootable       = OFF_BOARD,
-                .extra          = 240
+                .extra          = 240,
+                .pio_mask       = ATA_PIO4,
         },{     /* 3 */
                 .name           = "HPT371",
                 .init_setup     = init_setup_hpt371,
                 .init_chipset   = init_chipset_hpt366,
                 .init_hwif      = init_hwif_hpt366,
                 .init_dma       = init_dma_hpt366,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .enablebits     = {{0x50,0x04,0x04}, {0x54,0x04,0x04}},
                 .udma_mask      = HPT371_ALLOW_ATA133_6 ? 0x7f : 0x3f,
                 .bootable       = OFF_BOARD,
-                .extra          = 240
+                .extra          = 240,
+                .pio_mask       = ATA_PIO4,
         },{     /* 4 */
                 .name           = "HPT374",
                 .init_setup     = init_setup_hpt374,
                 .init_chipset   = init_chipset_hpt366,
                 .init_hwif      = init_hwif_hpt366,
                 .init_dma       = init_dma_hpt366,
-                .channels       = 2,    /* 4 */
                 .autodma        = AUTODMA,
                 .enablebits     = {{0x50,0x04,0x04}, {0x54,0x04,0x04}},
                 .udma_mask      = 0x3f,
                 .bootable       = OFF_BOARD,
-                .extra          = 240
+                .extra          = 240,
+                .pio_mask       = ATA_PIO4,
         },{     /* 5 */
                 .name           = "HPT372N",
                 .init_setup     = init_setup_hpt372n,
                 .init_chipset   = init_chipset_hpt366,
                 .init_hwif      = init_hwif_hpt366,
                 .init_dma       = init_dma_hpt366,
-                .channels       = 2,    /* 4 */
                 .autodma        = AUTODMA,
                 .enablebits     = {{0x50,0x04,0x04}, {0x54,0x04,0x04}},
                 .udma_mask      = HPT372_ALLOW_ATA133_6 ? 0x7f : 0x3f,
                 .bootable       = OFF_BOARD,
-                .extra          = 240
+                .extra          = 240,
+                .pio_mask       = ATA_PIO4,
         }
 };
 
diff --git a/drivers/ide/pci/it8213.c b/drivers/ide/pci/it8213.c
index ff48c23e571e..95dbed7e6022 100644
--- a/drivers/ide/pci/it8213.c
+++ b/drivers/ide/pci/it8213.c
@@ -82,7 +82,7 @@ static void it8213_tuneproc (ide_drive_t *drive, u8 pio)
                                         { 2, 1 },
                                         { 2, 3 }, };
 
-        pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+        pio = ide_get_best_pio_mode(drive, pio, 4);
 
         spin_lock_irqsave(&tune_lock, flags);
         pci_read_config_word(dev, master_port, &master_data);
@@ -214,7 +214,7 @@ static int it8213_config_drive_for_dma (ide_drive_t *drive)
         if (ide_tune_dma(drive))
                 return 0;
 
-        pio = ide_get_best_pio_mode(drive, 255, 4, NULL);
+        pio = ide_get_best_pio_mode(drive, 255, 4);
         it8213_tune_chipset(drive, XFER_PIO_0 + pio);
 
         return -1;
@@ -272,10 +272,11 @@ static void __devinit init_hwif_it8213(ide_hwif_t *hwif)
         {                                               \
                 .name           = name_str,             \
                 .init_hwif      = init_hwif_it8213,     \
-                .channels       = 1,                    \
                 .autodma        = AUTODMA,              \
                 .enablebits     = {{0x41,0x80,0x80}}, \
                 .bootable       = ON_BOARD,             \
+                .host_flags     = IDE_HFLAG_SINGLE,     \
+                .pio_mask       = ATA_PIO4,             \
         }
 
 static ide_pci_device_t it8213_chipsets[] __devinitdata = {
diff --git a/drivers/ide/pci/it821x.c b/drivers/ide/pci/it821x.c
index 8197b653ba1e..9286c99e2ff0 100644
--- a/drivers/ide/pci/it821x.c
+++ b/drivers/ide/pci/it821x.c
@@ -255,7 +255,7 @@ static int it821x_tunepio(ide_drive_t *drive, u8 set_pio)
          * on the cable.
          */
         if (pair) {
-                u8 pair_pio = ide_get_best_pio_mode(pair, 255, 4, NULL);
+                u8 pair_pio = ide_get_best_pio_mode(pair, 255, 4);
                 /* trim PIO to the slowest of the master/slave */
                 if (pair_pio < set_pio)
                         set_pio = pair_pio;
@@ -276,7 +276,7 @@ static int it821x_tunepio(ide_drive_t *drive, u8 set_pio)
 
 static void it821x_tuneproc(ide_drive_t *drive, u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+        pio = ide_get_best_pio_mode(drive, pio, 4);
         (void)it821x_tunepio(drive, pio);
 }
 
@@ -718,10 +718,10 @@ static unsigned int __devinit init_chipset_it821x(struct pci_dev *dev, const cha
                 .name           = name_str,             \
                 .init_chipset   = init_chipset_it821x,  \
                 .init_hwif      = init_hwif_it821x,     \
-                .channels       = 2,                    \
                 .autodma        = AUTODMA,              \
                 .bootable       = ON_BOARD,             \
-                .fixup          = it821x_fixups         \
+                .fixup          = it821x_fixups,        \
+                .pio_mask       = ATA_PIO4,             \
         }
 
 static ide_pci_device_t it821x_chipsets[] __devinitdata = {
diff --git a/drivers/ide/pci/jmicron.c b/drivers/ide/pci/jmicron.c
index a6008f63e71e..d7ce9dd8de16 100644
--- a/drivers/ide/pci/jmicron.c
+++ b/drivers/ide/pci/jmicron.c
@@ -97,7 +97,7 @@ static void jmicron_tuneproc (ide_drive_t *drive, byte mode_wanted)
 
 static void config_jmicron_chipset_for_pio (ide_drive_t *drive, byte set_speed)
 {
-        u8 speed = XFER_PIO_0 + ide_get_best_pio_mode(drive, 255, 5, NULL);
+        u8 speed = XFER_PIO_0 + ide_get_best_pio_mode(drive, 255, 5);
         if (set_speed)
                 (void) ide_config_drive_speed(drive, speed);
 }
@@ -177,10 +177,10 @@ fallback:
         {                                               \
                 .name           = name_str,             \
                 .init_hwif      = init_hwif_jmicron,    \
-                .channels       = 2,                    \
                 .autodma        = AUTODMA,              \
                 .bootable       = ON_BOARD,             \
                 .enablebits     = { {0x40, 1, 1}, {0x40, 0x10, 0x10} }, \
+                .pio_mask       = ATA_PIO5,             \
         }
 
 static ide_pci_device_t jmicron_chipsets[] __devinitdata = {
diff --git a/drivers/ide/pci/ns87415.c b/drivers/ide/pci/ns87415.c
index b310c4f51077..09941f37d635 100644
--- a/drivers/ide/pci/ns87415.c
+++ b/drivers/ide/pci/ns87415.c
@@ -281,7 +281,6 @@ static ide_pci_device_t ns87415_chipset __devinitdata = {
         .init_iops      = init_iops_ns87415,
 #endif
         .init_hwif      = init_hwif_ns87415,
-        .channels       = 2,
         .autodma        = AUTODMA,
         .bootable       = ON_BOARD,
 };
diff --git a/drivers/ide/pci/opti621.c b/drivers/ide/pci/opti621.c
index aede7eee9246..3a2bb2723515 100644
--- a/drivers/ide/pci/opti621.c
+++ b/drivers/ide/pci/opti621.c
@@ -147,12 +147,12 @@ static void compute_pios(ide_drive_t *drive, u8 pio)
         int d;
         ide_hwif_t *hwif = HWIF(drive);
 
-        drive->drive_data = ide_get_best_pio_mode(drive, pio, OPTI621_MAX_PIO, NULL);
+        drive->drive_data = ide_get_best_pio_mode(drive, pio, OPTI621_MAX_PIO);
         for (d = 0; d < 2; ++d) {
                 drive = &hwif->drives[d];
                 if (drive->present) {
                         if (drive->drive_data == PIO_DONT_KNOW)
-                                drive->drive_data = ide_get_best_pio_mode(drive, 255, OPTI621_MAX_PIO, NULL);
+                                drive->drive_data = ide_get_best_pio_mode(drive, 255, OPTI621_MAX_PIO);
 #ifdef OPTI621_DEBUG
                         printk("%s: Selected PIO mode %d\n",
                                 drive->name, drive->drive_data);
@@ -350,17 +350,17 @@ static ide_pci_device_t opti621_chipsets[] __devinitdata = {
         {       /* 0 */
                 .name           = "OPTI621",
                 .init_hwif      = init_hwif_opti621,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .enablebits     = {{0x45,0x80,0x00}, {0x40,0x08,0x00}},
                 .bootable       = ON_BOARD,
+                .pio_mask       = ATA_PIO3,
         },{     /* 1 */
                 .name           = "OPTI621X",
                 .init_hwif      = init_hwif_opti621,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .enablebits     = {{0x45,0x80,0x00}, {0x40,0x08,0x00}},
                 .bootable       = ON_BOARD,
+                .pio_mask       = ATA_PIO3,
         }
 };
 
diff --git a/drivers/ide/pci/pdc202xx_new.c b/drivers/ide/pci/pdc202xx_new.c
index ee5020df005d..8a66a2871b3a 100644
--- a/drivers/ide/pci/pdc202xx_new.c
+++ b/drivers/ide/pci/pdc202xx_new.c
@@ -219,7 +219,7 @@ static int pdcnew_tune_chipset(ide_drive_t *drive, u8 speed)
 
 static void pdcnew_tune_drive(ide_drive_t *drive, u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+        pio = ide_get_best_pio_mode(drive, pio, 4);
         (void)pdcnew_tune_chipset(drive, XFER_PIO_0 + pio);
 }
 
@@ -378,13 +378,6 @@ static unsigned int __devinit init_chipset_pdcnew(struct pci_dev *dev, const cha
         int f, r;
         u8 pll_ctl0, pll_ctl1;
 
-        if (dev->resource[PCI_ROM_RESOURCE].start) {
-                pci_write_config_dword(dev, PCI_ROM_ADDRESS,
-                        dev->resource[PCI_ROM_RESOURCE].start | PCI_ROM_ADDRESS_ENABLE);
-                printk(KERN_INFO "%s: ROM enabled at 0x%08lx\n", name,
-                        (unsigned long)dev->resource[PCI_ROM_RESOURCE].start);
-        }
-
 #ifdef CONFIG_PPC_PMAC
         apple_kiwi_init(dev);
 #endif
@@ -573,63 +566,63 @@ static ide_pci_device_t pdcnew_chipsets[] __devinitdata = {
                 .init_setup     = init_setup_pdcnew,
                 .init_chipset   = init_chipset_pdcnew,
                 .init_hwif      = init_hwif_pdc202new,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .bootable       = OFF_BOARD,
+                .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x3f, /* udma0-5 */
         },{     /* 1 */
                 .name           = "PDC20269",
                 .init_setup     = init_setup_pdcnew,
                 .init_chipset   = init_chipset_pdcnew,
                 .init_hwif      = init_hwif_pdc202new,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .bootable       = OFF_BOARD,
+                .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x7f, /* udma0-6*/
         },{     /* 2 */
                 .name           = "PDC20270",
                 .init_setup     = init_setup_pdc20270,
                 .init_chipset   = init_chipset_pdcnew,
                 .init_hwif      = init_hwif_pdc202new,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .bootable       = OFF_BOARD,
+                .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x3f, /* udma0-5 */
         },{     /* 3 */
                 .name           = "PDC20271",
                 .init_setup     = init_setup_pdcnew,
                 .init_chipset   = init_chipset_pdcnew,
                 .init_hwif      = init_hwif_pdc202new,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .bootable       = OFF_BOARD,
+                .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x7f, /* udma0-6*/
         },{     /* 4 */
                 .name           = "PDC20275",
                 .init_setup     = init_setup_pdcnew,
                 .init_chipset   = init_chipset_pdcnew,
                 .init_hwif      = init_hwif_pdc202new,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .bootable       = OFF_BOARD,
+                .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x7f, /* udma0-6*/
         },{     /* 5 */
                 .name           = "PDC20276",
                 .init_setup     = init_setup_pdc20276,
                 .init_chipset   = init_chipset_pdcnew,
                 .init_hwif      = init_hwif_pdc202new,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .bootable       = OFF_BOARD,
+                .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x7f, /* udma0-6*/
         },{     /* 6 */
                 .name           = "PDC20277",
                 .init_setup     = init_setup_pdcnew,
                 .init_chipset   = init_chipset_pdcnew,
                 .init_hwif      = init_hwif_pdc202new,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .bootable       = OFF_BOARD,
+                .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x7f, /* udma0-6*/
         }
 };
diff --git a/drivers/ide/pci/pdc202xx_old.c b/drivers/ide/pci/pdc202xx_old.c
index 41ac4a94959f..fbcb0bb9c956 100644
--- a/drivers/ide/pci/pdc202xx_old.c
+++ b/drivers/ide/pci/pdc202xx_old.c
@@ -145,7 +145,7 @@ static int pdc202xx_tune_chipset (ide_drive_t *drive, u8 xferspeed)
 
 static void pdc202xx_tune_drive(ide_drive_t *drive, u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+        pio = ide_get_best_pio_mode(drive, pio, 4);
         pdc202xx_tune_chipset(drive, XFER_PIO_0 + pio);
 }
 
@@ -316,14 +316,6 @@ static void pdc202xx_reset (ide_drive_t *drive)
 static unsigned int __devinit init_chipset_pdc202xx(struct pci_dev *dev,
                                                         const char *name)
 {
-        /* This doesn't appear needed */
-        if (dev->resource[PCI_ROM_RESOURCE].start) {
-                pci_write_config_dword(dev, PCI_ROM_ADDRESS,
-                        dev->resource[PCI_ROM_RESOURCE].start | PCI_ROM_ADDRESS_ENABLE);
-                printk(KERN_INFO "%s: ROM enabled at 0x%08lx\n", name,
-                        (unsigned long)dev->resource[PCI_ROM_RESOURCE].start);
-        }
-
         return dev->irq;
 }
 
@@ -449,10 +441,10 @@ static ide_pci_device_t pdc202xx_chipsets[] __devinitdata = {
                 .init_chipset   = init_chipset_pdc202xx,
                 .init_hwif      = init_hwif_pdc202xx,
                 .init_dma       = init_dma_pdc202xx,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .bootable       = OFF_BOARD,
                 .extra          = 16,
+                .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x07, /* udma0-2 */
         },{     /* 1 */
                 .name           = "PDC20262",
@@ -460,10 +452,10 @@ static ide_pci_device_t pdc202xx_chipsets[] __devinitdata = {
                 .init_chipset   = init_chipset_pdc202xx,
                 .init_hwif      = init_hwif_pdc202xx,
                 .init_dma       = init_dma_pdc202xx,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .bootable       = OFF_BOARD,
                 .extra          = 48,
+                .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x1f, /* udma0-4 */
         },{     /* 2 */
                 .name           = "PDC20263",
@@ -471,10 +463,10 @@ static ide_pci_device_t pdc202xx_chipsets[] __devinitdata = {
                 .init_chipset   = init_chipset_pdc202xx,
                 .init_hwif      = init_hwif_pdc202xx,
                 .init_dma       = init_dma_pdc202xx,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .bootable       = OFF_BOARD,
                 .extra          = 48,
+                .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x1f, /* udma0-4 */
         },{     /* 3 */
                 .name           = "PDC20265",
@@ -482,10 +474,10 @@ static ide_pci_device_t pdc202xx_chipsets[] __devinitdata = {
                 .init_chipset   = init_chipset_pdc202xx,
                 .init_hwif      = init_hwif_pdc202xx,
                 .init_dma       = init_dma_pdc202xx,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .bootable       = OFF_BOARD,
                 .extra          = 48,
+                .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x3f, /* udma0-5 */
         },{     /* 4 */
                 .name           = "PDC20267",
@@ -493,10 +485,10 @@ static ide_pci_device_t pdc202xx_chipsets[] __devinitdata = {
                 .init_chipset   = init_chipset_pdc202xx,
                 .init_hwif      = init_hwif_pdc202xx,
                 .init_dma       = init_dma_pdc202xx,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .bootable       = OFF_BOARD,
                 .extra          = 48,
+                .pio_mask       = ATA_PIO4,
                 .udma_mask      = 0x3f, /* udma0-5 */
         }
 };
diff --git a/drivers/ide/pci/piix.c b/drivers/ide/pci/piix.c
index 1372c35be035..4f69cd067e5e 100644
--- a/drivers/ide/pci/piix.c
+++ b/drivers/ide/pci/piix.c
@@ -219,7 +219,7 @@ static void piix_tune_pio (ide_drive_t *drive, u8 pio)
  */
 static void piix_tune_drive (ide_drive_t *drive, u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+        pio = ide_get_best_pio_mode(drive, pio, 4);
         piix_tune_pio(drive, pio);
         (void) ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
@@ -495,10 +495,10 @@ static void __devinit init_hwif_piix(ide_hwif_t *hwif)
                 .name           = name_str,             \
                 .init_chipset   = init_chipset_piix,    \
                 .init_hwif      = init_hwif_piix,       \
-                .channels       = 2,                    \
                 .autodma        = AUTODMA,              \
                 .enablebits     = {{0x41,0x80,0x80}, {0x43,0x80,0x80}}, \
                 .bootable       = ON_BOARD,             \
+                .pio_mask       = ATA_PIO4,             \
                 .udma_mask      = udma,                 \
         }
 
@@ -514,11 +514,11 @@ static ide_pci_device_t piix_pci_info[] __devinitdata = {
                  */
                 .name           = "MPIIX",
                 .init_hwif      = init_hwif_piix,
-                .channels       = 2,
                 .autodma        = NODMA,
                 .enablebits     = {{0x6d,0xc0,0x80}, {0x6d,0xc0,0xc0}},
                 .bootable       = ON_BOARD,
-                .flags          = IDEPCI_FLAG_ISA_PORTS
+                .host_flags     = IDE_HFLAG_ISA_PORTS,
+                .pio_mask       = ATA_PIO4,
         },
 
         /*  3 */ DECLARE_PIIX_DEV("PIIX3", 0x00),       /* no udma */
diff --git a/drivers/ide/pci/rz1000.c b/drivers/ide/pci/rz1000.c
index f8c954690142..10e1ae7a4a02 100644
--- a/drivers/ide/pci/rz1000.c
+++ b/drivers/ide/pci/rz1000.c
@@ -52,7 +52,6 @@ static void __devinit init_hwif_rz1000 (ide_hwif_t *hwif)
 static ide_pci_device_t rz1000_chipset __devinitdata = {
         .name           = "RZ100x",
         .init_hwif      = init_hwif_rz1000,
-        .channels       = 2,
         .autodma        = NODMA,
         .bootable       = ON_BOARD,
 };
diff --git a/drivers/ide/pci/sc1200.c b/drivers/ide/pci/sc1200.c
index 523363c93794..9bdc9694d50d 100644
--- a/drivers/ide/pci/sc1200.c
+++ b/drivers/ide/pci/sc1200.c
@@ -1,5 +1,5 @@
 /*
- * linux/drivers/ide/pci/sc1200.c               Version 0.94    Mar 10 2007
+ * linux/drivers/ide/pci/sc1200.c               Version 0.95    Jun 16 2007
  *
  * Copyright (C) 2000-2002              Mark Lord <mlord@pobox.com>
  * Copyright (C)      2007              Bartlomiej Zolnierkiewicz
@@ -304,7 +304,7 @@ static void sc1200_tuneproc (ide_drive_t *drive, byte pio)	/* mode=255 means "au
                 return;
         }
 
-        pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+        pio = ide_get_best_pio_mode(drive, pio, 4);
         printk("SC1200: %s: setting PIO mode%d\n", drive->name, pio);
 
         if (sc1200_set_xfer_mode(drive, XFER_PIO_0 + pio) == 0)
@@ -390,7 +390,7 @@ static int sc1200_resume (struct pci_dev *dev)
         // loop over all interfaces that are part of this pci device:
         //
         while ((hwif = lookup_pci_dev(hwif, dev)) != NULL) {
-                unsigned int            basereg, r, d, format;
+                unsigned int            basereg, r;
                 sc1200_saved_state_t    *ss = (sc1200_saved_state_t *)hwif->config_data;
 
                 //
@@ -402,41 +402,6 @@ static int sc1200_resume (struct pci_dev *dev)
                                 pci_write_config_dword(hwif->pci_dev, basereg + (r<<2), ss->regs[r]);
                         }
                 }
-                //
-                // Re-program drive PIO modes
-                //
-                pci_read_config_dword(hwif->pci_dev, basereg+4, &format);
-                format = (format >> 31) & 1;
-                if (format)
-                        format += sc1200_get_pci_clock();
-                for (d = 0; d < 2; ++d) {
-                        ide_drive_t *drive = &(hwif->drives[d]);
-                        if (drive->present) {
-                                unsigned int pio, timings;
-                                pci_read_config_dword(hwif->pci_dev, basereg+(drive->select.b.unit << 3), &timings);
-                                for (pio = 0; pio <= 4; ++pio) {
-                                        if (sc1200_pio_timings[format][pio] == timings)
-                                                break;
-                                }
-                                if (pio > 4)
-                                        pio = 255; /* autotune */
-                                (void)sc1200_tuneproc(drive, pio);
-                        }
-                }
-                //
-                // Re-program drive DMA modes
-                //
-                for (d = 0; d < MAX_DRIVES; ++d) {
-                        ide_drive_t *drive = &(hwif->drives[d]);
-                        if (drive->present && !__ide_dma_bad_drive(drive)) {
-                                int enable_dma = drive->using_dma;
-                                hwif->dma_off_quietly(drive);
-                                if (sc1200_config_dma(drive))
-                                        enable_dma = 0;
-                                if (enable_dma)
-                                        hwif->dma_host_on(drive);
-                        }
-                }
         }
         return 0;
 }
@@ -471,9 +436,9 @@ static void __devinit init_hwif_sc1200 (ide_hwif_t *hwif)
 static ide_pci_device_t sc1200_chipset __devinitdata = {
         .name           = "SC1200",
         .init_hwif      = init_hwif_sc1200,
-        .channels       = 2,
         .autodma        = AUTODMA,
         .bootable       = ON_BOARD,
+        .pio_mask       = ATA_PIO4,
 };
 
 static int __devinit sc1200_init_one(struct pci_dev *dev, const struct pci_device_id *id)
diff --git a/drivers/ide/pci/scc_pata.c b/drivers/ide/pci/scc_pata.c
index 7b87488e3daa..f668d235e6be 100644
--- a/drivers/ide/pci/scc_pata.c
+++ b/drivers/ide/pci/scc_pata.c
@@ -165,9 +165,9 @@ scc_ide_outbsync(ide_drive_t * drive, u8 addr, unsigned long port)
         ide_hwif_t *hwif = HWIF(drive);
 
         out_be32((void*)port, addr);
-        __asm__ __volatile__("eieio":::"memory");
+        eieio();
         in_be32((void*)(hwif->dma_base + 0x01c));
-        __asm__ __volatile__("eieio":::"memory");
+        eieio();
 }
 
 static void
@@ -210,7 +210,7 @@ static void scc_tuneproc(ide_drive_t *drive, byte mode_wanted)
         unsigned char speed = XFER_PIO_0;
         int offset;
 
-        mode_wanted = ide_get_best_pio_mode(drive, mode_wanted, 4, NULL);
+        mode_wanted = ide_get_best_pio_mode(drive, mode_wanted, 4);
         switch (mode_wanted) {
         case 4:
                 speed = XFER_PIO_4;
@@ -401,6 +401,33 @@ static int scc_ide_dma_end(ide_drive_t * drive)
         ide_hwif_t *hwif = HWIF(drive);
         unsigned long intsts_port = hwif->dma_base + 0x014;
         u32 reg;
+        int dma_stat, data_loss = 0;
+        static int retry = 0;
+
+        /* errata A308 workaround: Step5 (check data loss) */
+        /* We don't check non ide_disk because it is limited to UDMA4 */
+        if (!(in_be32((void __iomem *)IDE_ALTSTATUS_REG) & ERR_STAT) &&
+            drive->media == ide_disk && drive->current_speed > XFER_UDMA_4) {
+                reg = in_be32((void __iomem *)intsts_port);
+                if (!(reg & INTSTS_ACTEINT)) {
+                        printk(KERN_WARNING "%s: operation failed (transfer data loss)\n",
+                               drive->name);
+                        data_loss = 1;
+                        if (retry++) {
+                                struct request *rq = HWGROUP(drive)->rq;
+                                int unit;
+                                /* ERROR_RESET and drive->crc_count are needed
+                                 * to reduce DMA transfer mode in retry process.
+                                 */
+                                if (rq)
+                                        rq->errors |= ERROR_RESET;
+                                for (unit = 0; unit < MAX_DRIVES; unit++) {
+                                        ide_drive_t *drive = &hwif->drives[unit];
+                                        drive->crc_count++;
+                                }
+                        }
+                }
+        }
 
         while (1) {
                 reg = in_be32((void __iomem *)intsts_port);
@@ -469,27 +496,25 @@ static int scc_ide_dma_end(ide_drive_t * drive)
                 break;
         }
 
-        return __ide_dma_end(drive);
+        dma_stat = __ide_dma_end(drive);
+        if (data_loss)
+                dma_stat |= 2; /* emulate DMA error (to retry command) */
+        return dma_stat;
 }
 
 /* returns 1 if dma irq issued, 0 otherwise */
 static int scc_dma_test_irq(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
-        u8 dma_stat             = hwif->INB(hwif->dma_status);
+        ide_hwif_t *hwif = HWIF(drive);
+        u32 int_stat = in_be32((void __iomem *)hwif->dma_base + 0x014);
 
-        /* return 1 if INTR asserted */
-        if ((dma_stat & 4) == 4)
+        /* SCC errata A252,A308 workaround: Step4 */
+        if ((in_be32((void __iomem *)IDE_ALTSTATUS_REG) & ERR_STAT) &&
+            (int_stat & INTSTS_INTRQ))
                 return 1;
 
-        /* Workaround for PTERADD: emulate DMA_INTR when
-         * - IDE_STATUS[ERR] = 1
-         * - INT_STATUS[INTRQ] = 1
-         * - DMA_STATUS[IORACTA] = 1
-         */
-        if (in_be32((void __iomem *)IDE_ALTSTATUS_REG) & ERR_STAT &&
-            in_be32((void __iomem *)(hwif->dma_base + 0x014)) & INTSTS_INTRQ &&
-                dma_stat & 1)
+        /* SCC errata A308 workaround: Step5 (polling IOIRQS) */
+        if (int_stat & INTSTS_IOIRQS)
                 return 1;
 
         if (!drive->waiting_for_dma)
@@ -498,6 +523,21 @@ static int scc_dma_test_irq(ide_drive_t *drive)
         return 0;
 }
 
+static u8 scc_udma_filter(ide_drive_t *drive)
+{
+        ide_hwif_t *hwif = drive->hwif;
+        u8 mask = hwif->ultra_mask;
+
+        /* errata A308 workaround: limit non ide_disk drive to UDMA4 */
+        if ((drive->media != ide_disk) && (mask & 0xE0)) {
+                printk(KERN_INFO "%s: limit %s to UDMA4\n",
+                       SCC_PATA_NAME, drive->name);
+                mask = 0x1F;
+        }
+
+        return mask;
+}
+
 /**
  *      setup_mmio_scc  -       map CTRL/BMID region
  *      @dev: PCI device we are configuring
@@ -702,6 +742,7 @@ static void __devinit init_hwif_scc(ide_hwif_t *hwif)
         hwif->tuneproc = scc_tuneproc;
         hwif->ide_dma_check = scc_config_drive_for_dma;
         hwif->ide_dma_test_irq = scc_dma_test_irq;
+        hwif->udma_filter = scc_udma_filter;
 
         hwif->drives[0].autotune = IDE_TUNE_AUTO;
         hwif->drives[1].autotune = IDE_TUNE_AUTO;
@@ -731,9 +772,10 @@ static void __devinit init_hwif_scc(ide_hwif_t *hwif)
       .init_setup       = init_setup_scc,               \
       .init_iops        = init_iops_scc,                \
       .init_hwif        = init_hwif_scc,                \
-      .channels = 1,                                    \
       .autodma  = AUTODMA,                              \
       .bootable = ON_BOARD,                             \
+      .host_flags       = IDE_HFLAG_SINGLE,             \
+      .pio_mask         = ATA_PIO4,                     \
   }
 
 static ide_pci_device_t scc_chipsets[] __devinitdata = {
diff --git a/drivers/ide/pci/serverworks.c b/drivers/ide/pci/serverworks.c
index ed04e0c8dd4c..9fead2e7d4c8 100644
--- a/drivers/ide/pci/serverworks.c
+++ b/drivers/ide/pci/serverworks.c
@@ -1,5 +1,5 @@
 /*
- * linux/drivers/ide/pci/serverworks.c          Version 0.20    Jun 3 2007
+ * linux/drivers/ide/pci/serverworks.c          Version 0.22    Jun 27 2007
  *
  * Copyright (C) 1998-2000 Michel Aubry
  * Copyright (C) 1998-2000 Andrzej Krzysztofowicz
@@ -123,23 +123,45 @@ static u8 svwks_csb_check (struct pci_dev *dev)
         }
         return 0;
 }
+
+static void svwks_tune_pio(ide_drive_t *drive, const u8 pio)
+{
+        static const u8 pio_modes[] = { 0x5d, 0x47, 0x34, 0x22, 0x20 };
+        static const u8 drive_pci[] = { 0x41, 0x40, 0x43, 0x42 };
+
+        struct pci_dev *dev = drive->hwif->pci_dev;
+
+        pci_write_config_byte(dev, drive_pci[drive->dn], pio_modes[pio]);
+
+        if (svwks_csb_check(dev)) {
+                u16 csb_pio = 0;
+
+                pci_read_config_word(dev, 0x4a, &csb_pio);
+
+                csb_pio &= ~(0x0f << (4 * drive->dn));
+                csb_pio |= (pio << (4 * drive->dn));
+
+                pci_write_config_word(dev, 0x4a, csb_pio);
+        }
+}
+
 static int svwks_tune_chipset (ide_drive_t *drive, u8 xferspeed)
 {
         static const u8 udma_modes[]            = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 };
         static const u8 dma_modes[]             = { 0x77, 0x21, 0x20 };
-        static const u8 pio_modes[]             = { 0x5d, 0x47, 0x34, 0x22, 0x20 };
-        static const u8 drive_pci[]             = { 0x41, 0x40, 0x43, 0x42 };
         static const u8 drive_pci2[]            = { 0x45, 0x44, 0x47, 0x46 };
 
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
         u8 speed                = ide_rate_filter(drive, xferspeed);
-        u8 pio                  = ide_get_best_pio_mode(drive, 255, 4, NULL);
         u8 unit                 = (drive->select.b.unit & 0x01);
-        u8 csb5                 = svwks_csb_check(dev);
-        u8 ultra_enable         = 0, ultra_timing = 0;
-        u8 dma_timing           = 0, pio_timing = 0;
-        u16 csb5_pio            = 0;
+
+        u8 ultra_enable  = 0, ultra_timing = 0, dma_timing = 0;
+
+        if (speed >= XFER_PIO_0 && speed <= XFER_PIO_4) {
+                svwks_tune_pio(drive, speed - XFER_PIO_0);
+                return ide_config_drive_speed(drive, speed);
+        }
 
         /* If we are about to put a disk into UDMA mode we screwed up.
            Our code assumes we never _ever_ do this on an OSB4 */
@@ -149,31 +171,15 @@ static int svwks_tune_chipset (ide_drive_t *drive, u8 xferspeed)
                         BUG();
 
         pci_read_config_byte(dev, (0x56|hwif->channel), &ultra_timing);
-        pci_read_config_word(dev, 0x4A, &csb5_pio);
         pci_read_config_byte(dev, 0x54, &ultra_enable);
 
         ultra_timing    &= ~(0x0F << (4*unit));
         ultra_enable    &= ~(0x01 << drive->dn);
-        csb5_pio        &= ~(0x0F << (4*drive->dn));
 
         switch(speed) {
-                case XFER_PIO_4:
-                case XFER_PIO_3:
-                case XFER_PIO_2:
-                case XFER_PIO_1:
-                case XFER_PIO_0:
-                        pio_timing |= pio_modes[speed - XFER_PIO_0];
-                        csb5_pio   |= ((speed - XFER_PIO_0) << (4*drive->dn));
-                        break;
-
                 case XFER_MW_DMA_2:
                 case XFER_MW_DMA_1:
                 case XFER_MW_DMA_0:
-                        /*
-                         * TODO: always setup PIO mode so this won't be needed
-                         */
-                        pio_timing |= pio_modes[pio];
-                        csb5_pio   |= (pio << (4*drive->dn));
                         dma_timing |= dma_modes[speed - XFER_MW_DMA_0];
                         break;
 
@@ -183,11 +189,6 @@ static int svwks_tune_chipset (ide_drive_t *drive, u8 xferspeed)
                 case XFER_UDMA_2:
                 case XFER_UDMA_1:
                 case XFER_UDMA_0:
-                        /*
-                         * TODO: always setup PIO mode so this won't be needed
-                         */
-                        pio_timing   |= pio_modes[pio];
-                        csb5_pio     |= (pio << (4*drive->dn));
                         dma_timing   |= dma_modes[2];
                         ultra_timing |= ((udma_modes[speed - XFER_UDMA_0]) << (4*unit));
                         ultra_enable |= (0x01 << drive->dn);
@@ -195,10 +196,6 @@ static int svwks_tune_chipset (ide_drive_t *drive, u8 xferspeed)
                         break;
         }
 
-        pci_write_config_byte(dev, drive_pci[drive->dn], pio_timing);
-        if (csb5)
-                pci_write_config_word(dev, 0x4A, csb5_pio);
-
         pci_write_config_byte(dev, drive_pci2[drive->dn], dma_timing);
         pci_write_config_byte(dev, (0x56|hwif->channel), ultra_timing);
         pci_write_config_byte(dev, 0x54, ultra_enable);
@@ -208,8 +205,9 @@ static int svwks_tune_chipset (ide_drive_t *drive, u8 xferspeed)
 
 static void svwks_tune_drive (ide_drive_t *drive, u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
-        (void)svwks_tune_chipset(drive, XFER_PIO_0 + pio);
+        pio = ide_get_best_pio_mode(drive, pio, 4);
+        svwks_tune_pio(drive, pio);
+        (void)ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
 
 static int svwks_config_drive_xfer_rate (ide_drive_t *drive)
@@ -389,8 +387,6 @@ static u8 __devinit ata66_svwks(ide_hwif_t *hwif)
 
 static void __devinit init_hwif_svwks (ide_hwif_t *hwif)
 {
-        u8 dma_stat = 0;
-
         if (!hwif->irq)
                 hwif->irq = hwif->channel ? 15 : 14;
 
@@ -407,11 +403,11 @@ static void __devinit init_hwif_svwks (ide_hwif_t *hwif)
 
         hwif->autodma = 0;
 
-        if (!hwif->dma_base) {
-                hwif->drives[0].autotune = 1;
-                hwif->drives[1].autotune = 1;
+        hwif->drives[0].autotune = 1;
+        hwif->drives[1].autotune = 1;
+
+        if (!hwif->dma_base)
                 return;
-        }
 
         hwif->ide_dma_check = &svwks_config_drive_xfer_rate;
         if (hwif->pci_dev->device != PCI_DEVICE_ID_SERVERWORKS_OSB4IDE) {
@@ -421,11 +417,7 @@ static void __devinit init_hwif_svwks (ide_hwif_t *hwif)
         if (!noautodma)
                 hwif->autodma = 1;
 
-        dma_stat = inb(hwif->dma_status);
-        hwif->drives[0].autodma = (dma_stat & 0x20);
-        hwif->drives[1].autodma = (dma_stat & 0x40);
-        hwif->drives[0].autotune = (!(dma_stat & 0x20));
-        hwif->drives[1].autotune = (!(dma_stat & 0x40));
+        hwif->drives[0].autodma = hwif->drives[1].autodma = 1;
 }
 
 static int __devinit init_setup_svwks (struct pci_dev *dev, ide_pci_device_t *d)
@@ -441,9 +433,12 @@ static int __devinit init_setup_csb6 (struct pci_dev *dev, ide_pci_device_t *d)
                         d->bootable = ON_BOARD;
         }
 
-        d->channels = ((dev->device == PCI_DEVICE_ID_SERVERWORKS_CSB6IDE ||
-                        dev->device == PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2) &&
-                       (!(PCI_FUNC(dev->devfn) & 1))) ? 1 : 2;
+        if ((dev->device == PCI_DEVICE_ID_SERVERWORKS_CSB6IDE ||
+            dev->device == PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2) &&
+            (!(PCI_FUNC(dev->devfn) & 1)))
+                d->host_flags |= IDE_HFLAG_SINGLE;
+        else
+                d->host_flags &= ~IDE_HFLAG_SINGLE;
 
         return ide_setup_pci_device(dev, d);
 }
@@ -454,41 +449,43 @@ static ide_pci_device_t serverworks_chipsets[] __devinitdata = {
                 .init_setup     = init_setup_svwks,
                 .init_chipset   = init_chipset_svwks,
                 .init_hwif      = init_hwif_svwks,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .bootable       = ON_BOARD,
+                .pio_mask       = ATA_PIO4,
         },{     /* 1 */
                 .name           = "SvrWks CSB5",
                 .init_setup     = init_setup_svwks,
                 .init_chipset   = init_chipset_svwks,
                 .init_hwif      = init_hwif_svwks,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .bootable       = ON_BOARD,
+                .pio_mask       = ATA_PIO4,
         },{     /* 2 */
                 .name           = "SvrWks CSB6",
                 .init_setup     = init_setup_csb6,
                 .init_chipset   = init_chipset_svwks,
                 .init_hwif      = init_hwif_svwks,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .bootable       = ON_BOARD,
+                .pio_mask       = ATA_PIO4,
         },{     /* 3 */
                 .name           = "SvrWks CSB6",
                 .init_setup     = init_setup_csb6,
                 .init_chipset   = init_chipset_svwks,
                 .init_hwif      = init_hwif_svwks,
-                .channels       = 1,    /* 2 */
                 .autodma        = AUTODMA,
                 .bootable       = ON_BOARD,
+                .host_flags     = IDE_HFLAG_SINGLE,
+                .pio_mask       = ATA_PIO4,
         },{     /* 4 */
                 .name           = "SvrWks HT1000",
                 .init_setup     = init_setup_svwks,
                 .init_chipset   = init_chipset_svwks,
                 .init_hwif      = init_hwif_svwks,
-                .channels       = 1,    /* 2 */
                 .autodma        = AUTODMA,
                 .bootable       = ON_BOARD,
+                .host_flags     = IDE_HFLAG_SINGLE,
+                .pio_mask       = ATA_PIO4,
         }
 };
 
diff --git a/drivers/ide/pci/sgiioc4.c b/drivers/ide/pci/sgiioc4.c
index d396b2929ed8..57145767c3df 100644
--- a/drivers/ide/pci/sgiioc4.c
+++ b/drivers/ide/pci/sgiioc4.c
@@ -586,6 +586,7 @@ ide_init_sgiioc4(ide_hwif_t * hwif)
         hwif->ultra_mask = 0x0; /* Disable Ultra DMA */
         hwif->mwdma_mask = 0x2; /* Multimode-2 DMA  */
         hwif->swdma_mask = 0x2;
+        hwif->pio_mask = 0x00;
         hwif->tuneproc = NULL;  /* Sets timing for PIO mode */
         hwif->speedproc = NULL; /* Sets timing for DMA &/or PIO modes */
         hwif->selectproc = NULL;/* Use the default routine to select drive */
@@ -724,10 +725,10 @@ static ide_pci_device_t sgiioc4_chipset __devinitdata = {
          .name = "SGIIOC4",
          .init_hwif = ide_init_sgiioc4,
          .init_dma = ide_dma_sgiioc4,
-         .channels = 1,
          .autodma = AUTODMA,
          /* SGI IOC4 doesn't have enablebits. */
          .bootable = ON_BOARD,
+         .host_flags = IDE_HFLAG_SINGLE,
 };
 
 int
diff --git a/drivers/ide/pci/siimage.c b/drivers/ide/pci/siimage.c
index 1c3e35487893..50f6d172ef77 100644
--- a/drivers/ide/pci/siimage.c
+++ b/drivers/ide/pci/siimage.c
@@ -1,9 +1,10 @@
 /*
- * linux/drivers/ide/pci/siimage.c              Version 1.12    Mar 10 2007
+ * linux/drivers/ide/pci/siimage.c              Version 1.15    Jun 29 2007
  *
  * Copyright (C) 2001-2002      Andre Hedrick <andre@linux-ide.org>
  * Copyright (C) 2003           Red Hat <alan@redhat.com>
  * Copyright (C) 2007           MontaVista Software, Inc.
+ * Copyright (C) 2007           Bartlomiej Zolnierkiewicz
  *
  *  May be copied or modified under the terms of the GNU General Public License
  *
@@ -31,6 +32,10 @@
  *  unplugging/replugging the virtual CD interface when the DRAC is reset.
  *  This often causes drivers/ide/siimage to panic but is ok with the rather
  *  smarter code in libata.
+ *
+ * TODO:
+ * - IORDY fixes
+ * - VDMA support
  */
 
 #include <linux/types.h>
@@ -160,82 +165,45 @@ out:
 }
 
 /**
- *      siimage_taskfile_timing -       turn timing data to a mode
- *      @hwif: interface to query
- *
- *      Read the timing data for the interface and return the 
- *      mode that is being used.
- */
- 
-static byte siimage_taskfile_timing (ide_hwif_t *hwif)
-{
-        u16 timing      = 0x328a;
-        unsigned long addr = siimage_selreg(hwif, 2);
-
-        if (hwif->mmio)
-                timing = hwif->INW(addr);
-        else
-                pci_read_config_word(hwif->pci_dev, addr, &timing);
-
-        switch (timing) {
-                case 0x10c1:    return 4;
-                case 0x10c3:    return 3;
-                case 0x1104:
-                case 0x1281:    return 2;
-                case 0x2283:    return 1;
-                case 0x328a:
-                default:        return 0;
-        }
-}
-
-/**
- *      simmage_tuneproc        -       tune a drive
+ *      sil_tune_pio    -       tune a drive
  *      @drive: drive to tune
- *      @mode_wanted: the target operating mode
+ *      @pio: the desired PIO mode
  *
  *      Load the timing settings for this device mode into the
  *      controller. If we are in PIO mode 3 or 4 turn on IORDY
  *      monitoring (bit 9). The TF timing is bits 31:16
  */
- 
-static void siimage_tuneproc (ide_drive_t *drive, byte mode_wanted)
+
+static void sil_tune_pio(ide_drive_t *drive, u8 pio)
 {
+        const u16 tf_speed[]    = { 0x328a, 0x2283, 0x1281, 0x10c3, 0x10c1 };
+        const u16 data_speed[]  = { 0x328a, 0x2283, 0x1104, 0x10c3, 0x10c1 };
+
         ide_hwif_t *hwif        = HWIF(drive);
+        ide_drive_t *pair       = &hwif->drives[drive->dn ^ 1];
         u32 speedt              = 0;
         u16 speedp              = 0;
         unsigned long addr      = siimage_seldev(drive, 0x04);
         unsigned long tfaddr    = siimage_selreg(hwif, 0x02);
-        
-        /* cheat for now and use the docs */
-        switch (mode_wanted) {
-        case 4:
-                speedp = 0x10c1;
-                speedt = 0x10c1;
-                break;
-        case 3:
-                speedp = 0x10c3;
-                speedt = 0x10c3;
-                break;
-        case 2:
-                speedp = 0x1104;
-                speedt = 0x1281;
-                break;
-        case 1:
-                speedp = 0x2283;
-                speedt = 0x2283;
-                break;
-        case 0:
-        default:
-                speedp = 0x328a;
-                speedt = 0x328a;
-                break;
+        u8 tf_pio               = pio;
+
+        /* trim *taskfile* PIO to the slowest of the master/slave */
+        if (pair->present) {
+                u8 pair_pio = ide_get_best_pio_mode(pair, 255, 4);
+
+                if (pair_pio < tf_pio)
+                        tf_pio = pair_pio;
         }
 
+        /* cheat for now and use the docs */
+        speedp = data_speed[pio];
+        speedt = tf_speed[tf_pio];
+
         if (hwif->mmio) {
                 hwif->OUTW(speedp, addr);
                 hwif->OUTW(speedt, tfaddr);
                 /* Now set up IORDY */
-                if(mode_wanted == 3 || mode_wanted == 4)
+                if (pio > 2)
                         hwif->OUTW(hwif->INW(tfaddr-2)|0x200, tfaddr-2);
                 else
                         hwif->OUTW(hwif->INW(tfaddr-2)&~0x200, tfaddr-2);
@@ -245,42 +213,17 @@ static void siimage_tuneproc (ide_drive_t *drive, byte mode_wanted)
                 pci_read_config_word(hwif->pci_dev, tfaddr-2, &speedp);
                 speedp &= ~0x200;
                 /* Set IORDY for mode 3 or 4 */
-                if(mode_wanted == 3 || mode_wanted == 4)
+                if (pio > 2)
                         speedp |= 0x200;
                 pci_write_config_word(hwif->pci_dev, tfaddr-2, speedp);
         }
 }
 
-/**
- *      config_siimage_chipset_for_pio  -       set drive timings
- *      @drive: drive to tune
- *      @speed we want
- *
- *      Compute the best pio mode we can for a given device. Also honour
- *      the timings for the driver when dealing with mixed devices. Some
- *      of this is ugly but its all wrapped up here
- *
- *      The SI680 can also do VDMA - we need to start using that
- *
- *      FIXME: we use the BIOS channel timings to avoid driving the task
- *      files too fast at the disk. We need to compute the master/slave
- *      drive PIO mode properly so that we can up the speed on a hotplug
- *      system.
- */
- 
-static void config_siimage_chipset_for_pio (ide_drive_t *drive, byte set_speed)
+static void sil_tuneproc(ide_drive_t *drive, u8 pio)
 {
-        u8 channel_timings      = siimage_taskfile_timing(HWIF(drive));
-        u8 speed = 0, set_pio   = ide_get_best_pio_mode(drive, 4, 5, NULL);
-
-        /* WARNING PIO timing mess is going to happen b/w devices, argh */
-        if ((channel_timings != set_pio) && (set_pio > channel_timings))
-                set_pio = channel_timings;
-
-        siimage_tuneproc(drive, set_pio);
-        speed = XFER_PIO_0 + set_pio;
-        if (set_speed)
-                (void) ide_config_drive_speed(drive, speed);
+        pio = ide_get_best_pio_mode(drive, pio, 4);
+        sil_tune_pio(drive, pio);
+        (void)ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
 
 /**
@@ -335,7 +278,7 @@ static int siimage_tune_chipset (ide_drive_t *drive, byte xferspeed)
                 case XFER_PIO_2:
                 case XFER_PIO_1:
                 case XFER_PIO_0:
-                        siimage_tuneproc(drive, (speed - XFER_PIO_0));
+                        sil_tune_pio(drive, speed - XFER_PIO_0);
                         mode |= ((unit) ? 0x10 : 0x01);
                         break;
                 case XFER_MW_DMA_2:
@@ -343,7 +286,6 @@ static int siimage_tune_chipset (ide_drive_t *drive, byte xferspeed)
                 case XFER_MW_DMA_0:
                         multi = dma[speed - XFER_MW_DMA_0];
                         mode |= ((unit) ? 0x20 : 0x02);
-                        config_siimage_chipset_for_pio(drive, 0);
                         break;
                 case XFER_UDMA_6:
                 case XFER_UDMA_5:
@@ -356,7 +298,6 @@ static int siimage_tune_chipset (ide_drive_t *drive, byte xferspeed)
                         ultra |= ((scsc) ? (ultra6[speed - XFER_UDMA_0]) :
                                            (ultra5[speed - XFER_UDMA_0]));
                         mode |= ((unit) ? 0x30 : 0x03);
-                        config_siimage_chipset_for_pio(drive, 0);
                         break;
                 default:
                         return 1;
@@ -390,7 +331,7 @@ static int siimage_config_drive_for_dma (ide_drive_t *drive)
                 return 0;
 
         if (ide_use_fast_pio(drive))
-                config_siimage_chipset_for_pio(drive, 1);
+                sil_tuneproc(drive, 255);
 
         return -1;
 }
@@ -961,7 +902,7 @@ static void __devinit init_hwif_siimage(ide_hwif_t *hwif)
         
         hwif->resetproc = &siimage_reset;
         hwif->speedproc = &siimage_tune_chipset;
-        hwif->tuneproc  = &siimage_tuneproc;
+        hwif->tuneproc  = &sil_tuneproc;
         hwif->reset_poll = &siimage_reset_poll;
         hwif->pre_reset = &siimage_pre_reset;
         hwif->udma_filter = &sil_udma_filter;
@@ -976,11 +917,11 @@ static void __devinit init_hwif_siimage(ide_hwif_t *hwif)
                         first = 0;
                 }
         }
-        if (!hwif->dma_base) {
-                hwif->drives[0].autotune = 1;
-                hwif->drives[1].autotune = 1;
+
+        hwif->drives[0].autotune = hwif->drives[1].autotune = 1;
+
+        if (hwif->dma_base == 0)
                 return;
-        }
 
         hwif->ultra_mask = 0x7f;
         hwif->mwdma_mask = 0x07;
@@ -1016,9 +957,9 @@ static void __devinit init_hwif_siimage(ide_hwif_t *hwif)
                 .init_iops      = init_iops_siimage,    \
                 .init_hwif      = init_hwif_siimage,    \
                 .fixup          = siimage_fixup,        \
-                .channels       = 2,                    \
                 .autodma        = AUTODMA,              \
                 .bootable       = ON_BOARD,             \
+                .pio_mask       = ATA_PIO4,             \
         }
 
 static ide_pci_device_t siimage_chipsets[] __devinitdata = {
diff --git a/drivers/ide/pci/sis5513.c b/drivers/ide/pci/sis5513.c
index 756a9b6eb462..63fbb79e8178 100644
--- a/drivers/ide/pci/sis5513.c
+++ b/drivers/ide/pci/sis5513.c
@@ -521,7 +521,7 @@ static void config_art_rwp_pio (ide_drive_t *drive, u8 pio)
 
 static int sis5513_tune_drive(ide_drive_t *drive, u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+        pio = ide_get_best_pio_mode(drive, pio, 4);
         config_art_rwp_pio(drive, pio);
         return ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
@@ -878,10 +878,10 @@ static ide_pci_device_t sis5513_chipset __devinitdata = {
         .name           = "SIS5513",
         .init_chipset   = init_chipset_sis5513,
         .init_hwif      = init_hwif_sis5513,
-        .channels       = 2,
         .autodma        = NOAUTODMA,
         .enablebits     = {{0x4a,0x02,0x02}, {0x4a,0x04,0x04}},
         .bootable       = ON_BOARD,
+        .pio_mask       = ATA_PIO4,
 };
 
 static int __devinit sis5513_init_one(struct pci_dev *dev, const struct pci_device_id *id)
diff --git a/drivers/ide/pci/sl82c105.c b/drivers/ide/pci/sl82c105.c
index a7323d278c49..0947cab00595 100644
--- a/drivers/ide/pci/sl82c105.c
+++ b/drivers/ide/pci/sl82c105.c
@@ -52,12 +52,13 @@
  * Convert a PIO mode and cycle time to the required on/off times
  * for the interface.  This has protection against runaway timings.
  */
-static unsigned int get_pio_timings(ide_pio_data_t *p)
+static unsigned int get_pio_timings(ide_drive_t *drive, u8 pio)
 {
         unsigned int cmd_on, cmd_off;
+        u8 iordy = 0;
 
-        cmd_on  = (ide_pio_timings[p->pio_mode].active_time + 29) / 30;
-        cmd_off = (p->cycle_time - 30 * cmd_on + 29) / 30;
+        cmd_on  = (ide_pio_timings[pio].active_time + 29) / 30;
+        cmd_off = (ide_pio_cycle_time(drive, pio) - 30 * cmd_on + 29) / 30;
 
         if (cmd_on == 0)
                 cmd_on = 1;
@@ -65,7 +66,10 @@ static unsigned int get_pio_timings(ide_pio_data_t *p)
         if (cmd_off == 0)
                 cmd_off = 1;
 
-        return (cmd_on - 1) << 8 | (cmd_off - 1) | (p->use_iordy ? 0x40 : 0x00);
+        if (pio > 2 || ide_dev_has_iordy(drive->id))
+                iordy = 0x40;
+
+        return (cmd_on - 1) << 8 | (cmd_off - 1) | iordy;
 }
 
 /*
@@ -75,14 +79,13 @@ static u8 sl82c105_tune_pio(ide_drive_t *drive, u8 pio)
 {
         struct pci_dev *dev     = HWIF(drive)->pci_dev;
         int reg                 = 0x44 + drive->dn * 4;
-        ide_pio_data_t p;
         u16 drv_ctrl;
 
         DBG(("sl82c105_tune_pio(drive:%s, pio:%u)\n", drive->name, pio));
 
-        pio = ide_get_best_pio_mode(drive, pio, 5, &p);
+        pio = ide_get_best_pio_mode(drive, pio, 5);
 
-        drv_ctrl = get_pio_timings(&p);
+        drv_ctrl = get_pio_timings(drive, pio);
 
         /*
          * Store the PIO timings so that we can restore them
@@ -101,7 +104,8 @@ static u8 sl82c105_tune_pio(ide_drive_t *drive, u8 pio)
         }
 
         printk(KERN_DEBUG "%s: selected %s (%dns) (%04X)\n", drive->name,
-               ide_xfer_verbose(pio + XFER_PIO_0), p.cycle_time, drv_ctrl);
+                          ide_xfer_verbose(pio + XFER_PIO_0),
+                          ide_pio_cycle_time(drive, pio), drv_ctrl);
 
         return pio;
 }
@@ -449,10 +453,10 @@ static ide_pci_device_t sl82c105_chipset __devinitdata = {
         .name           = "W82C105",
         .init_chipset   = init_chipset_sl82c105,
         .init_hwif      = init_hwif_sl82c105,
-        .channels       = 2,
         .autodma        = NOAUTODMA,
         .enablebits     = {{0x40,0x01,0x01}, {0x40,0x10,0x10}},
         .bootable       = ON_BOARD,
+        .pio_mask       = ATA_PIO5,
 };
 
 static int __devinit sl82c105_init_one(struct pci_dev *dev, const struct pci_device_id *id)
diff --git a/drivers/ide/pci/slc90e66.c b/drivers/ide/pci/slc90e66.c
index 575dbbd8b482..8e655f2db5cb 100644
--- a/drivers/ide/pci/slc90e66.c
+++ b/drivers/ide/pci/slc90e66.c
@@ -103,7 +103,7 @@ static void slc90e66_tune_pio (ide_drive_t *drive, u8 pio)
 
 static void slc90e66_tune_drive (ide_drive_t *drive, u8 pio)
 {
-        pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+        pio = ide_get_best_pio_mode(drive, pio, 4);
         slc90e66_tune_pio(drive, pio);
         (void) ide_config_drive_speed(drive, XFER_PIO_0 + pio);
 }
@@ -214,10 +214,10 @@ static void __devinit init_hwif_slc90e66 (ide_hwif_t *hwif)
 static ide_pci_device_t slc90e66_chipset __devinitdata = {
         .name           = "SLC90E66",
         .init_hwif      = init_hwif_slc90e66,
-        .channels       = 2,
         .autodma        = AUTODMA,
         .enablebits     = {{0x41,0x80,0x80}, {0x43,0x80,0x80}},
         .bootable       = ON_BOARD,
+        .pio_mask       = ATA_PIO4,
 };
 
 static int __devinit slc90e66_init_one(struct pci_dev *dev, const struct pci_device_id *id)
diff --git a/drivers/ide/pci/tc86c001.c b/drivers/ide/pci/tc86c001.c
index 8de1f8e22494..ec79bacc30c2 100644
--- a/drivers/ide/pci/tc86c001.c
+++ b/drivers/ide/pci/tc86c001.c
@@ -47,7 +47,7 @@ static int tc86c001_tune_chipset(ide_drive_t *drive, u8 speed)
 
 static void tc86c001_tune_drive(ide_drive_t *drive, u8 pio)
 {
-        pio =  ide_get_best_pio_mode(drive, pio, 4, NULL);
+        pio = ide_get_best_pio_mode(drive, pio, 4);
         (void) tc86c001_tune_chipset(drive, XFER_PIO_0 + pio);
 }
 
@@ -248,9 +248,10 @@ static ide_pci_device_t tc86c001_chipset __devinitdata = {
         .name           = "TC86C001",
         .init_chipset   = init_chipset_tc86c001,
         .init_hwif      = init_hwif_tc86c001,
-        .channels       = 1,
         .autodma        = AUTODMA,
-        .bootable       = OFF_BOARD
+        .bootable       = OFF_BOARD,
+        .host_flags     = IDE_HFLAG_SINGLE,
+        .pio_mask       = ATA_PIO4,
 };
 
 static int __devinit tc86c001_init_one(struct pci_dev *dev,
diff --git a/drivers/ide/pci/triflex.c b/drivers/ide/pci/triflex.c
index 35e8c612638f..024bbfae0429 100644
--- a/drivers/ide/pci/triflex.c
+++ b/drivers/ide/pci/triflex.c
@@ -96,7 +96,7 @@ static int triflex_tune_chipset(ide_drive_t *drive, u8 xferspeed)
 
 static void triflex_tune_drive(ide_drive_t *drive, u8 pio)
 {
-        int use_pio = ide_get_best_pio_mode(drive, pio, 4, NULL);
+        int use_pio = ide_get_best_pio_mode(drive, pio, 4);
         (void) triflex_tune_chipset(drive, (XFER_PIO_0 + use_pio));
 }
 
@@ -129,10 +129,10 @@ static void __devinit init_hwif_triflex(ide_hwif_t *hwif)
 static ide_pci_device_t triflex_device __devinitdata = {
         .name           = "TRIFLEX",
         .init_hwif      = init_hwif_triflex,
-        .channels       = 2,
         .autodma        = AUTODMA,
         .enablebits     = {{0x80, 0x01, 0x01}, {0x80, 0x02, 0x02}},
         .bootable       = ON_BOARD,
+        .pio_mask       = ATA_PIO4,
 };
 
 static int __devinit triflex_init_one(struct pci_dev *dev, 
diff --git a/drivers/ide/pci/trm290.c b/drivers/ide/pci/trm290.c
index cbb1b11119a5..dc4f4e298e00 100644
--- a/drivers/ide/pci/trm290.c
+++ b/drivers/ide/pci/trm290.c
@@ -327,7 +327,6 @@ static void __devinit init_hwif_trm290(ide_hwif_t *hwif)
 static ide_pci_device_t trm290_chipset __devinitdata = {
         .name           = "TRM290",
         .init_hwif      = init_hwif_trm290,
-        .channels       = 2,
         .autodma        = NOAUTODMA,
         .bootable       = ON_BOARD,
 };
diff --git a/drivers/ide/pci/via82cxxx.c b/drivers/ide/pci/via82cxxx.c
index 27e92fb9f95e..581316f9581d 100644
--- a/drivers/ide/pci/via82cxxx.c
+++ b/drivers/ide/pci/via82cxxx.c
@@ -1,6 +1,6 @@
 /*
  *
- * Version 3.45
+ * Version 3.46
  *
  * VIA IDE driver for Linux. Supported southbridges:
  *
@@ -203,10 +203,8 @@ static int via_set_drive(ide_drive_t *drive, u8 speed)
 
 static void via82cxxx_tune_drive(ide_drive_t *drive, u8 pio)
 {
-        if (pio == 255) {
-                via_set_drive(drive, ide_find_best_pio_mode(drive));
-                return;
-        }
+        if (pio == 255)
+                pio = ide_get_best_pio_mode(drive, 255, 5);
 
         via_set_drive(drive, XFER_PIO_0 + min_t(u8, pio, 5));
 }
@@ -223,12 +221,14 @@ static int via82cxxx_ide_dma_check (ide_drive_t *drive)
 {
         u8 speed = ide_max_dma_mode(drive);
 
-        if (speed == 0)
-                speed = ide_find_best_pio_mode(drive);
+        if (speed == 0) {
+                via82cxxx_tune_drive(drive, 255);
+                return -1;
+        }
 
         via_set_drive(drive, speed);
 
-        if (drive->autodma && (speed & XFER_MODE) != XFER_PIO)
+        if (drive->autodma)
                 return 0;
 
         return -1;
@@ -498,18 +498,22 @@ static ide_pci_device_t via82cxxx_chipsets[] __devinitdata = {
                 .name           = "VP_IDE",
                 .init_chipset   = init_chipset_via82cxxx,
                 .init_hwif      = init_hwif_via82cxxx,
-                .channels       = 2,
                 .autodma        = NOAUTODMA,
                 .enablebits     = {{0x40,0x02,0x02}, {0x40,0x01,0x01}},
-                .bootable       = ON_BOARD
+                .bootable       = ON_BOARD,
+                .host_flags     = IDE_HFLAG_PIO_NO_BLACKLIST
+                                | IDE_HFLAG_PIO_NO_DOWNGRADE,
+                .pio_mask       = ATA_PIO5,
         },{     /* 1 */
                 .name           = "VP_IDE",
                 .init_chipset   = init_chipset_via82cxxx,
                 .init_hwif      = init_hwif_via82cxxx,
-                .channels       = 2,
                 .autodma        = AUTODMA,
                 .enablebits     = {{0x00,0x00,0x00}, {0x00,0x00,0x00}},
                 .bootable       = ON_BOARD,
+                .host_flags     = IDE_HFLAG_PIO_NO_BLACKLIST
+                                | IDE_HFLAG_PIO_NO_DOWNGRADE,
+                .pio_mask       = ATA_PIO5,
         }
 };
 
diff --git a/drivers/ide/ppc/mpc8xx.c b/drivers/ide/ppc/mpc8xx.c
index 82de2d781f2e..8859fe2f5ac2 100644
--- a/drivers/ide/ppc/mpc8xx.c
+++ b/drivers/ide/ppc/mpc8xx.c
@@ -316,6 +316,7 @@ m8xx_ide_init_hwif_ports(hw_regs_t *hw, unsigned long data_port,
         }
 
         /* register routine to tune PIO mode */
+        ide_hwifs[data_port].pio_mask = ATA_PIO4;
         ide_hwifs[data_port].tuneproc = m8xx_ide_tuneproc;
 
         hw->ack_intr = (ide_ack_intr_t *) ide_interrupt_ack;
@@ -402,6 +403,7 @@ void m8xx_ide_init_hwif_ports (hw_regs_t *hw,
         }
 
         /* register routine to tune PIO mode */
+        ide_hwifs[data_port].pio_mask = ATA_PIO4;
         ide_hwifs[data_port].tuneproc = m8xx_ide_tuneproc;
 
         hw->ack_intr = (ide_ack_intr_t *) ide_interrupt_ack;
@@ -431,13 +433,12 @@ void m8xx_ide_init_hwif_ports (hw_regs_t *hw,
 static void
 m8xx_ide_tuneproc(ide_drive_t *drive, u8 pio)
 {
-        ide_pio_data_t d;
 #if defined(CONFIG_IDE_8xx_PCCARD) || defined(CONFIG_IDE_8xx_DIRECT)
         volatile pcmconf8xx_t   *pcmp;
         ulong timing, mask, reg;
 #endif
 
-        pio = ide_get_best_pio_mode(drive, pio, 4, &d);
+        pio = ide_get_best_pio_mode(drive, pio, 4);
 
 #if 1
         printk("%s[%d] %s: best PIO mode: %d\n",
diff --git a/drivers/ide/ppc/pmac.c b/drivers/ide/ppc/pmac.c
index e46f47206542..33630ad3e794 100644
--- a/drivers/ide/ppc/pmac.c
+++ b/drivers/ide/ppc/pmac.c
@@ -615,24 +615,25 @@ out:
 static void
 pmac_ide_tuneproc(ide_drive_t *drive, u8 pio)
 {
-        ide_pio_data_t d;
         u32 *timings;
         unsigned accessTicks, recTicks;
         unsigned accessTime, recTime;
         pmac_ide_hwif_t* pmif = (pmac_ide_hwif_t *)HWIF(drive)->hwif_data;
-        
+        unsigned int cycle_time;
+
         if (pmif == NULL)
                 return;
                 
         /* which drive is it ? */
         timings = &pmif->timings[drive->select.b.unit & 0x01];
 
-        pio = ide_get_best_pio_mode(drive, pio, 4, &d);
+        pio = ide_get_best_pio_mode(drive, pio, 4);
+        cycle_time = ide_pio_cycle_time(drive, pio);
 
         switch (pmif->kind) {
         case controller_sh_ata6: {
                 /* 133Mhz cell */
-                u32 tr = kauai_lookup_timing(shasta_pio_timings, d.cycle_time);
+                u32 tr = kauai_lookup_timing(shasta_pio_timings, cycle_time);
                 if (tr == 0)
                         return;
                 *timings = ((*timings) & ~TR_133_PIOREG_PIO_MASK) | tr;
@@ -641,7 +642,7 @@ pmac_ide_tuneproc(ide_drive_t *drive, u8 pio)
         case controller_un_ata6:
         case controller_k2_ata6: {
                 /* 100Mhz cell */
-                u32 tr = kauai_lookup_timing(kauai_pio_timings, d.cycle_time);
+                u32 tr = kauai_lookup_timing(kauai_pio_timings, cycle_time);
                 if (tr == 0)
                         return;
                 *timings = ((*timings) & ~TR_100_PIOREG_PIO_MASK) | tr;
@@ -649,7 +650,7 @@ pmac_ide_tuneproc(ide_drive_t *drive, u8 pio)
                 }
         case controller_kl_ata4:
                 /* 66Mhz cell */
-                recTime = d.cycle_time - ide_pio_timings[pio].active_time
+                recTime = cycle_time - ide_pio_timings[pio].active_time
                                 - ide_pio_timings[pio].setup_time;
                 recTime = max(recTime, 150U);
                 accessTime = ide_pio_timings[pio].active_time;
@@ -665,7 +666,7 @@ pmac_ide_tuneproc(ide_drive_t *drive, u8 pio)
         default: {
                 /* 33Mhz cell */
                 int ebit = 0;
-                recTime = d.cycle_time - ide_pio_timings[pio].active_time
+                recTime = cycle_time - ide_pio_timings[pio].active_time
                                 - ide_pio_timings[pio].setup_time;
                 recTime = max(recTime, 150U);
                 accessTime = ide_pio_timings[pio].active_time;
@@ -1247,6 +1248,7 @@ pmac_ide_setup_device(pmac_ide_hwif_t *pmif, ide_hwif_t *hwif)
         hwif->cbl = pmif->cable_80 ? ATA_CBL_PATA80 : ATA_CBL_PATA40;
         hwif->drives[0].unmask = 1;
         hwif->drives[1].unmask = 1;
+        hwif->pio_mask = ATA_PIO4;
         hwif->tuneproc = pmac_ide_tuneproc;
         if (pmif->kind == controller_un_ata6
             || pmif->kind == controller_k2_ata6
diff --git a/drivers/ide/setup-pci.c b/drivers/ide/setup-pci.c
index c88d33225cf9..30e596c0f120 100644
--- a/drivers/ide/setup-pci.c
+++ b/drivers/ide/setup-pci.c
@@ -5,12 +5,6 @@
  *
  *  Copyright (c) 1995-1998  Mark Lord
  *  May be copied or modified under the terms of the GNU General Public License
- *
- *  Recent Changes
- *      Split the set up function into multiple functions
- *      Use pci_set_master
- *      Fix misreporting of I/O v MMIO problems
- *      Initial fixups for simplex devices
  */
 
 /*
@@ -407,7 +401,7 @@ static ide_hwif_t *ide_hwif_configure(struct pci_dev *dev, ide_pci_device_t *d,
         unsigned long ctl = 0, base = 0;
         ide_hwif_t *hwif;
 
-        if ((d->flags & IDEPCI_FLAG_ISA_PORTS) == 0) {
+        if ((d->host_flags & IDE_HFLAG_ISA_PORTS) == 0) {
                 /*  Possibly we should fail if these checks report true */
                 ide_pci_check_iomem(dev, d, 2*port);
                 ide_pci_check_iomem(dev, d, 2*port+1);
@@ -571,7 +565,7 @@ out:
  
 void ide_pci_setup_ports(struct pci_dev *dev, ide_pci_device_t *d, int pciirq, ata_index_t *index)
 {
-        int port;
+        int channels = (d->host_flags & IDE_HFLAG_SINGLE) ? 1 : 2, port;
         int at_least_one_hwif_enabled = 0;
         ide_hwif_t *hwif, *mate = NULL;
         u8 tmp;
@@ -582,16 +576,13 @@ void ide_pci_setup_ports(struct pci_dev *dev, ide_pci_device_t *d, int pciirq, a
          * Set up the IDE ports
          */
          
-        for (port = 0; port <= 1; ++port) {
+        for (port = 0; port < channels; ++port) {
                 ide_pci_enablebit_t *e = &(d->enablebits[port]);
         
                 if (e->reg && (pci_read_config_byte(dev, e->reg, &tmp) ||
                     (tmp & e->mask) != e->val))
                         continue;       /* port not enabled */
 
-                if (d->channels <= port)
-                        break;
-        
                 if ((hwif = ide_hwif_configure(dev, d, mate, port, pciirq)) == NULL)
                         continue;
 
@@ -616,6 +607,9 @@ void ide_pci_setup_ports(struct pci_dev *dev, ide_pci_device_t *d, int pciirq, a
                 else
                         ide_hwif_setup_dma(dev, d, hwif);
 bypass_legacy_dma:
+                hwif->host_flags = d->host_flags;
+                hwif->pio_mask = d->pio_mask;
+
                 if (d->init_hwif)
                         /* Call chipset-specific routine
                          * for each enabled hwif
diff --git a/drivers/ieee1394/eth1394.c b/drivers/ieee1394/eth1394.c
index 93362eed94ed..3a9d7e2d4de6 100644
--- a/drivers/ieee1394/eth1394.c
+++ b/drivers/ieee1394/eth1394.c
@@ -1729,7 +1729,7 @@ static int __init ether1394_init_module(void)
 
         packet_task_cache = kmem_cache_create("packet_task",
                                               sizeof(struct packet_task),
-                                              0, 0, NULL, NULL);
+                                              0, 0, NULL);
         if (!packet_task_cache)
                 return -ENOMEM;
 
diff --git a/drivers/infiniband/core/mad.c b/drivers/infiniband/core/mad.c
index 6b8faca02f8a..bc547f1d34ba 100644
--- a/drivers/infiniband/core/mad.c
+++ b/drivers/infiniband/core/mad.c
@@ -2998,7 +2998,6 @@ static int __init ib_mad_init_module(void)
                                          sizeof(struct ib_mad_private),
                                          0,
                                          SLAB_HWCACHE_ALIGN,
-                                         NULL,
                                          NULL);
         if (!ib_mad_cache) {
                 printk(KERN_ERR PFX "Couldn't create ib_mad cache\n");
diff --git a/drivers/infiniband/hw/amso1100/c2_vq.c b/drivers/infiniband/hw/amso1100/c2_vq.c
index 36620a22413c..cfdacb1ec279 100644
--- a/drivers/infiniband/hw/amso1100/c2_vq.c
+++ b/drivers/infiniband/hw/amso1100/c2_vq.c
@@ -85,7 +85,7 @@ int vq_init(struct c2_dev *c2dev)
                 (char) ('0' + c2dev->devnum));
         c2dev->host_msg_cache =
             kmem_cache_create(c2dev->vq_cache_name, c2dev->rep_vq.msg_size, 0,
-                              SLAB_HWCACHE_ALIGN, NULL, NULL);
+                              SLAB_HWCACHE_ALIGN, NULL);
         if (c2dev->host_msg_cache == NULL) {
                 return -ENOMEM;
         }
diff --git a/drivers/infiniband/hw/ehca/ehca_av.c b/drivers/infiniband/hw/ehca/ehca_av.c
index e53a97af1260..97d108634c58 100644
--- a/drivers/infiniband/hw/ehca/ehca_av.c
+++ b/drivers/infiniband/hw/ehca/ehca_av.c
@@ -259,7 +259,7 @@ int ehca_init_av_cache(void)
         av_cache = kmem_cache_create("ehca_cache_av",
                                    sizeof(struct ehca_av), 0,
                                    SLAB_HWCACHE_ALIGN,
-                                   NULL, NULL);
+                                   NULL);
         if (!av_cache)
                 return -ENOMEM;
         return 0;
diff --git a/drivers/infiniband/hw/ehca/ehca_cq.c b/drivers/infiniband/hw/ehca/ehca_cq.c
index 9e87883b561a..1e8ca3fca4aa 100644
--- a/drivers/infiniband/hw/ehca/ehca_cq.c
+++ b/drivers/infiniband/hw/ehca/ehca_cq.c
@@ -387,7 +387,7 @@ int ehca_init_cq_cache(void)
         cq_cache = kmem_cache_create("ehca_cache_cq",
                                      sizeof(struct ehca_cq), 0,
                                      SLAB_HWCACHE_ALIGN,
-                                     NULL, NULL);
+                                     NULL);
         if (!cq_cache)
                 return -ENOMEM;
         return 0;
diff --git a/drivers/infiniband/hw/ehca/ehca_main.c b/drivers/infiniband/hw/ehca/ehca_main.c
index 36377c6db3d4..04c324330b7c 100644
--- a/drivers/infiniband/hw/ehca/ehca_main.c
+++ b/drivers/infiniband/hw/ehca/ehca_main.c
@@ -163,7 +163,7 @@ static int ehca_create_slab_caches(void)
         ctblk_cache = kmem_cache_create("ehca_cache_ctblk",
                                         EHCA_PAGESIZE, H_CB_ALIGNMENT,
                                         SLAB_HWCACHE_ALIGN,
-                                        NULL, NULL);
+                                        NULL);
         if (!ctblk_cache) {
                 ehca_gen_err("Cannot create ctblk SLAB cache.");
                 ehca_cleanup_mrmw_cache();
diff --git a/drivers/infiniband/hw/ehca/ehca_mrmw.c b/drivers/infiniband/hw/ehca/ehca_mrmw.c
index 6262c5462d50..9f4c9d46e8ef 100644
--- a/drivers/infiniband/hw/ehca/ehca_mrmw.c
+++ b/drivers/infiniband/hw/ehca/ehca_mrmw.c
@@ -1950,13 +1950,13 @@ int ehca_init_mrmw_cache(void)
         mr_cache = kmem_cache_create("ehca_cache_mr",
                                      sizeof(struct ehca_mr), 0,
                                      SLAB_HWCACHE_ALIGN,
-                                     NULL, NULL);
+                                     NULL);
         if (!mr_cache)
                 return -ENOMEM;
         mw_cache = kmem_cache_create("ehca_cache_mw",
                                      sizeof(struct ehca_mw), 0,
                                      SLAB_HWCACHE_ALIGN,
-                                     NULL, NULL);
+                                     NULL);
         if (!mw_cache) {
                 kmem_cache_destroy(mr_cache);
                 mr_cache = NULL;
diff --git a/drivers/infiniband/hw/ehca/ehca_pd.c b/drivers/infiniband/hw/ehca/ehca_pd.c
index 79d0591a8043..c85312ad292b 100644
--- a/drivers/infiniband/hw/ehca/ehca_pd.c
+++ b/drivers/infiniband/hw/ehca/ehca_pd.c
@@ -100,7 +100,7 @@ int ehca_init_pd_cache(void)
         pd_cache = kmem_cache_create("ehca_cache_pd",
                                      sizeof(struct ehca_pd), 0,
                                      SLAB_HWCACHE_ALIGN,
-                                     NULL, NULL);
+                                     NULL);
         if (!pd_cache)
                 return -ENOMEM;
         return 0;
diff --git a/drivers/infiniband/hw/ehca/ehca_qp.c b/drivers/infiniband/hw/ehca/ehca_qp.c
index 48e9ceacd6fa..a3146e696c5d 100644
--- a/drivers/infiniband/hw/ehca/ehca_qp.c
+++ b/drivers/infiniband/hw/ehca/ehca_qp.c
@@ -1760,7 +1760,7 @@ int ehca_init_qp_cache(void)
         qp_cache = kmem_cache_create("ehca_cache_qp",
                                      sizeof(struct ehca_qp), 0,
                                      SLAB_HWCACHE_ALIGN,
-                                     NULL, NULL);
+                                     NULL);
         if (!qp_cache)
                 return -ENOMEM;
         return 0;
diff --git a/drivers/infiniband/ulp/iser/iscsi_iser.c b/drivers/infiniband/ulp/iser/iscsi_iser.c
index effdee299b0c..5db314380271 100644
--- a/drivers/infiniband/ulp/iser/iscsi_iser.c
+++ b/drivers/infiniband/ulp/iser/iscsi_iser.c
@@ -637,7 +637,7 @@ static int __init iser_init(void)
         ig.desc_cache = kmem_cache_create("iser_descriptors",
                                           sizeof (struct iser_desc),
                                           0, SLAB_HWCACHE_ALIGN,
-                                          NULL, NULL);
+                                          NULL);
         if (ig.desc_cache == NULL)
                 return -ENOMEM;
 
diff --git a/drivers/input/input.c b/drivers/input/input.c
index 75b4d2a83dd9..5fe755586623 100644
--- a/drivers/input/input.c
+++ b/drivers/input/input.c
@@ -471,37 +471,16 @@ static unsigned int input_proc_devices_poll(struct file *file, poll_table *wait)
         return 0;
 }
 
-static struct list_head *list_get_nth_element(struct list_head *list, loff_t *pos)
-{
-        struct list_head *node;
-        loff_t i = 0;
-
-        list_for_each(node, list)
-                if (i++ == *pos)
-                        return node;
-
-        return NULL;
-}
-
-static struct list_head *list_get_next_element(struct list_head *list, struct list_head *element, loff_t *pos)
-{
-        if (element->next == list)
-                return NULL;
-
-        ++(*pos);
-        return element->next;
-}
-
 static void *input_devices_seq_start(struct seq_file *seq, loff_t *pos)
 {
         /* acquire lock here ... Yes, we do need locking, I knowi, I know... */
 
-        return list_get_nth_element(&input_dev_list, pos);
+        return seq_list_start(&input_dev_list, *pos);
 }
 
 static void *input_devices_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 {
-        return list_get_next_element(&input_dev_list, v, pos);
+        return seq_list_next(v, &input_dev_list, pos);
 }
 
 static void input_devices_seq_stop(struct seq_file *seq, void *v)
@@ -592,13 +571,13 @@ static void *input_handlers_seq_start(struct seq_file *seq, loff_t *pos)
 {
         /* acquire lock here ... Yes, we do need locking, I knowi, I know... */
         seq->private = (void *)(unsigned long)*pos;
-        return list_get_nth_element(&input_handler_list, pos);
+        return seq_list_start(&input_handler_list, *pos);
 }
 
 static void *input_handlers_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 {
         seq->private = (void *)(unsigned long)(*pos + 1);
-        return list_get_next_element(&input_handler_list, v, pos);
+        return seq_list_next(v, &input_handler_list, pos);
 }
 
 static void input_handlers_seq_stop(struct seq_file *seq, void *v)
diff --git a/drivers/input/joystick/Kconfig b/drivers/input/joystick/Kconfig
index 12db72d83ea0..e2abe18e575d 100644
--- a/drivers/input/joystick/Kconfig
+++ b/drivers/input/joystick/Kconfig
@@ -275,4 +275,11 @@ config JOYSTICK_XPAD_FF
         ---help---
           Say Y here if you want to take advantage of xbox 360 rumble features.
 
+config JOYSTICK_XPAD_LEDS
+        bool "LED Support for Xbox360 controller 'BigX' LED"
+        depends on LEDS_CLASS && JOYSTICK_XPAD
+        ---help---
+          This option enables support for the LED which surrounds the Big X on
+          XBox 360 controller.
+
 endif
diff --git a/drivers/input/joystick/xpad.c b/drivers/input/joystick/xpad.c
index 244089c52650..28080395899c 100644
--- a/drivers/input/joystick/xpad.c
+++ b/drivers/input/joystick/xpad.c
@@ -191,13 +191,18 @@ struct usb_xpad {
         unsigned char *idata;           /* input data */
         dma_addr_t idata_dma;
 
-#ifdef CONFIG_JOYSTICK_XPAD_FF
+#if defined(CONFIG_JOYSTICK_XPAD_FF) || defined(CONFIG_JOYSTICK_XPAD_LEDS)
         struct urb *irq_out;            /* urb for interrupt out report */
         unsigned char *odata;           /* output data */
         dma_addr_t odata_dma;
+        struct mutex odata_mutex;
+#endif
+
+#if defined(CONFIG_JOYSTICK_XPAD_LEDS)
+        struct xpad_led *led;
 #endif
 
-        char phys[65];                  /* physical device path */
+        char phys[64];                  /* physical device path */
 
         int dpad_mapping;               /* map d-pad to buttons or to axes */
         int xtype;                      /* type of xbox device */
@@ -349,7 +354,7 @@ exit:
                      __FUNCTION__, retval);
 }
 
-#ifdef CONFIG_JOYSTICK_XPAD_FF
+#if defined(CONFIG_JOYSTICK_XPAD_FF) || defined(CONFIG_JOYSTICK_XPAD_LEDS)
 static void xpad_irq_out(struct urb *urb)
 {
         int retval;
@@ -376,29 +381,7 @@ exit:
                    __FUNCTION__, retval);
 }
 
-static int xpad_play_effect(struct input_dev *dev, void *data,
-                            struct ff_effect *effect)
-{
-        struct usb_xpad *xpad = input_get_drvdata(dev);
-
-        if (effect->type == FF_RUMBLE) {
-                __u16 strong = effect->u.rumble.strong_magnitude;
-                __u16 weak = effect->u.rumble.weak_magnitude;
-                xpad->odata[0] = 0x00;
-                xpad->odata[1] = 0x08;
-                xpad->odata[2] = 0x00;
-                xpad->odata[3] = strong / 256;
-                xpad->odata[4] = weak / 256;
-                xpad->odata[5] = 0x00;
-                xpad->odata[6] = 0x00;
-                xpad->odata[7] = 0x00;
-                usb_submit_urb(xpad->irq_out, GFP_KERNEL);
-        }
-
-        return 0;
-}
-
-static int xpad_init_ff(struct usb_interface *intf, struct usb_xpad *xpad)
+static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad)
 {
         struct usb_endpoint_descriptor *ep_irq_out;
         int error = -ENOMEM;
@@ -411,6 +394,8 @@ static int xpad_init_ff(struct usb_interface *intf, struct usb_xpad *xpad)
         if (!xpad->odata)
                 goto fail1;
 
+        mutex_init(&xpad->odata_mutex);
+
         xpad->irq_out = usb_alloc_urb(0, GFP_KERNEL);
         if (!xpad->irq_out)
                 goto fail2;
@@ -423,25 +408,19 @@ static int xpad_init_ff(struct usb_interface *intf, struct usb_xpad *xpad)
         xpad->irq_out->transfer_dma = xpad->odata_dma;
         xpad->irq_out->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 
-        input_set_capability(xpad->dev, EV_FF, FF_RUMBLE);
-
-        error = input_ff_create_memless(xpad->dev, NULL, xpad_play_effect);
-        if (error)
-                goto fail2;
-
         return 0;
 
  fail2: usb_buffer_free(xpad->udev, XPAD_PKT_LEN, xpad->odata, xpad->odata_dma);
  fail1: return error;
 }
 
-static void xpad_stop_ff(struct usb_xpad *xpad)
+static void xpad_stop_output(struct usb_xpad *xpad)
 {
         if (xpad->xtype == XTYPE_XBOX360)
                 usb_kill_urb(xpad->irq_out);
 }
 
-static void xpad_deinit_ff(struct usb_xpad *xpad)
+static void xpad_deinit_output(struct usb_xpad *xpad)
 {
         if (xpad->xtype == XTYPE_XBOX360) {
                 usb_free_urb(xpad->irq_out);
@@ -449,13 +428,130 @@ static void xpad_deinit_ff(struct usb_xpad *xpad)
                                 xpad->odata, xpad->odata_dma);
         }
 }
+#else
+static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad) { return 0; }
+static void xpad_deinit_output(struct usb_xpad *xpad) {}
+static void xpad_stop_output(struct usb_xpad *xpad) {}
+#endif
+
+#ifdef CONFIG_JOYSTICK_XPAD_FF
+static int xpad_play_effect(struct input_dev *dev, void *data,
+                            struct ff_effect *effect)
+{
+        struct usb_xpad *xpad = input_get_drvdata(dev);
 
+        if (effect->type == FF_RUMBLE) {
+                __u16 strong = effect->u.rumble.strong_magnitude;
+                __u16 weak = effect->u.rumble.weak_magnitude;
+                xpad->odata[0] = 0x00;
+                xpad->odata[1] = 0x08;
+                xpad->odata[2] = 0x00;
+                xpad->odata[3] = strong / 256;
+                xpad->odata[4] = weak / 256;
+                xpad->odata[5] = 0x00;
+                xpad->odata[6] = 0x00;
+                xpad->odata[7] = 0x00;
+                usb_submit_urb(xpad->irq_out, GFP_KERNEL);
+        }
+
+        return 0;
+}
+
+static int xpad_init_ff(struct usb_xpad *xpad)
+{
+        input_set_capability(xpad->dev, EV_FF, FF_RUMBLE);
+
+        return input_ff_create_memless(xpad->dev, NULL, xpad_play_effect);
+}
+
+#else
+static int xpad_init_ff(struct usb_xpad *xpad) { return 0; }
+#endif
+
+#if defined(CONFIG_JOYSTICK_XPAD_LEDS)
+#include <linux/leds.h>
+
+struct xpad_led {
+        char name[16];
+        struct led_classdev led_cdev;
+        struct usb_xpad *xpad;
+};
+
+static void xpad_send_led_command(struct usb_xpad *xpad, int command)
+{
+        if (command >= 0 && command < 14) {
+                mutex_lock(&xpad->odata_mutex);
+                xpad->odata[0] = 0x01;
+                xpad->odata[1] = 0x03;
+                xpad->odata[2] = command;
+                usb_submit_urb(xpad->irq_out, GFP_KERNEL);
+                mutex_unlock(&xpad->odata_mutex);
+        }
+}
+
+static void xpad_led_set(struct led_classdev *led_cdev,
+                         enum led_brightness value)
+{
+        struct xpad_led *xpad_led = container_of(led_cdev,
+                                                 struct xpad_led, led_cdev);
+
+        xpad_send_led_command(xpad_led->xpad, value);
+}
+
+static int xpad_led_probe(struct usb_xpad *xpad)
+{
+        static atomic_t led_seq = ATOMIC_INIT(0);
+        long led_no;
+        struct xpad_led *led;
+        struct led_classdev *led_cdev;
+        int error;
+
+        if (xpad->xtype != XTYPE_XBOX360)
+                return 0;
+
+        xpad->led = led = kzalloc(sizeof(struct xpad_led), GFP_KERNEL);
+        if (!led)
+                return -ENOMEM;
+
+        led_no = (long)atomic_inc_return(&led_seq) - 1;
+
+        snprintf(led->name, sizeof(led->name), "xpad%ld", led_no);
+        led->xpad = xpad;
+
+        led_cdev = &led->led_cdev;
+        led_cdev->name = led->name;
+        led_cdev->brightness_set = xpad_led_set;
+
+        error = led_classdev_register(&xpad->udev->dev, led_cdev);
+        if (error) {
+                kfree(led);
+                xpad->led = NULL;
+                return error;
+        }
+
+        /*
+         * Light up the segment corresponding to controller number
+         */
+        xpad_send_led_command(xpad, (led_no % 4) + 2);
+
+        return 0;
+}
+
+static void xpad_led_disconnect(struct usb_xpad *xpad)
+{
+        struct xpad_led *xpad_led = xpad->led;
+
+        if (xpad_led) {
+                led_classdev_unregister(&xpad_led->led_cdev);
+                kfree(xpad_led->name);
+        }
+}
 #else
-static int xpad_init_ff(struct usb_interface *intf, struct usb_xpad *xpad) { return 0; }
-static void xpad_stop_ff(struct usb_xpad *xpad) { }
-static void xpad_deinit_ff(struct usb_xpad *xpad) { }
+static int xpad_led_probe(struct usb_xpad *xpad) { return 0; }
+static void xpad_led_disconnect(struct usb_xpad *xpad) { }
 #endif
 
+
 static int xpad_open(struct input_dev *dev)
 {
         struct usb_xpad *xpad = input_get_drvdata(dev);
@@ -472,7 +568,7 @@ static void xpad_close(struct input_dev *dev)
         struct usb_xpad *xpad = input_get_drvdata(dev);
 
         usb_kill_urb(xpad->irq_in);
-        xpad_stop_ff(xpad);
+        xpad_stop_output(xpad);
 }
 
 static void xpad_set_up_abs(struct input_dev *input_dev, signed short abs)
@@ -564,10 +660,18 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
                 for (i = 0; xpad_abs_pad[i] >= 0; i++)
                     xpad_set_up_abs(input_dev, xpad_abs_pad[i]);
 
-        error = xpad_init_ff(intf, xpad);
+        error = xpad_init_output(intf, xpad);
         if (error)
                 goto fail2;
 
+        error = xpad_init_ff(xpad);
+        if (error)
+                goto fail3;
+
+        error = xpad_led_probe(xpad);
+        if (error)
+                goto fail3;
+
         ep_irq_in = &intf->cur_altsetting->endpoint[0].desc;
         usb_fill_int_urb(xpad->irq_in, udev,
                          usb_rcvintpipe(udev, ep_irq_in->bEndpointAddress),
@@ -578,12 +682,13 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
 
         error = input_register_device(xpad->dev);
         if (error)
-                goto fail3;
+                goto fail4;
 
         usb_set_intfdata(intf, xpad);
         return 0;
 
- fail3: usb_free_urb(xpad->irq_in);
+ fail4: usb_free_urb(xpad->irq_in);
+ fail3: xpad_deinit_output(xpad);
  fail2: usb_buffer_free(udev, XPAD_PKT_LEN, xpad->idata, xpad->idata_dma);
  fail1: input_free_device(input_dev);
         kfree(xpad);
@@ -597,8 +702,9 @@ static void xpad_disconnect(struct usb_interface *intf)
 
         usb_set_intfdata(intf, NULL);
         if (xpad) {
+                xpad_led_disconnect(xpad);
                 input_unregister_device(xpad->dev);
-                xpad_deinit_ff(xpad);
+                xpad_deinit_output(xpad);
                 usb_free_urb(xpad->irq_in);
                 usb_buffer_free(xpad->udev, XPAD_PKT_LEN,
                                 xpad->idata, xpad->idata_dma);
diff --git a/drivers/input/mouse/appletouch.c b/drivers/input/mouse/appletouch.c
index e3215267db11..2bea1b2c631c 100644
--- a/drivers/input/mouse/appletouch.c
+++ b/drivers/input/mouse/appletouch.c
@@ -155,6 +155,8 @@ struct atp {
         int                     xy_acc[ATP_XSENSORS + ATP_YSENSORS];
         int                     overflowwarn;   /* overflow warning printed? */
         int                     datalen;        /* size of an USB urb transfer */
+        int                     idlecount;      /* number of empty packets */
+        struct work_struct      work;
 };
 
 #define dbg_dump(msg, tab) \
@@ -208,6 +210,55 @@ static inline int atp_is_geyser_3(struct atp *dev)
                 (productId == GEYSER4_JIS_PRODUCT_ID);
 }
 
+/*
+ * By default Geyser 3 device sends standard USB HID mouse
+ * packets (Report ID 2). This code changes device mode, so it
+ * sends raw sensor reports (Report ID 5).
+ */
+static int atp_geyser3_init(struct usb_device *udev)
+{
+        char data[8];
+        int size;
+
+        size = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+                        ATP_GEYSER3_MODE_READ_REQUEST_ID,
+                        USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
+                        ATP_GEYSER3_MODE_REQUEST_VALUE,
+                        ATP_GEYSER3_MODE_REQUEST_INDEX, &data, 8, 5000);
+
+        if (size != 8) {
+                err("Could not do mode read request from device"
+                    " (Geyser 3 mode)");
+                return -EIO;
+        }
+
+        /* Apply the mode switch */
+        data[0] = ATP_GEYSER3_MODE_VENDOR_VALUE;
+
+        size = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                        ATP_GEYSER3_MODE_WRITE_REQUEST_ID,
+                        USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
+                        ATP_GEYSER3_MODE_REQUEST_VALUE,
+                        ATP_GEYSER3_MODE_REQUEST_INDEX, &data, 8, 5000);
+
+        if (size != 8) {
+                err("Could not do mode write request to device"
+                    " (Geyser 3 mode)");
+                return -EIO;
+        }
+        return 0;
+}
+
+/* Reinitialise the device if it's a geyser 3 */
+static void atp_reinit(struct work_struct *work)
+{
+        struct atp *dev = container_of(work, struct atp, work);
+        struct usb_device *udev = dev->udev;
+
+        dev->idlecount = 0;
+        atp_geyser3_init(udev);
+}
+
 static int atp_calculate_abs(int *xy_sensors, int nb_sensors, int fact,
                              int *z, int *fingers)
 {
@@ -439,8 +490,8 @@ static void atp_complete(struct urb* urb)
                 }
                 dev->x_old = x;
                 dev->y_old = y;
-        }
-        else if (!x && !y) {
+
+        } else if (!x && !y) {
 
                 dev->x_old = dev->y_old = -1;
                 input_report_key(dev->input, BTN_TOUCH, 0);
@@ -449,11 +500,21 @@ static void atp_complete(struct urb* urb)
 
                 /* reset the accumulator on release */
                 memset(dev->xy_acc, 0, sizeof(dev->xy_acc));
-        }
 
-        input_report_key(dev->input, BTN_LEFT,
-                         !!dev->data[dev->datalen - 1]);
+                /* Geyser 3 will continue to send packets continually after
+                   the first touch unless reinitialised. Do so if it's been
+                   idle for a while in order to avoid waking the kernel up
+                   several hundred times a second */
+                if (atp_is_geyser_3(dev)) {
+                        dev->idlecount++;
+                        if (dev->idlecount == 10) {
+                                dev->valid = 0;
+                                schedule_work(&dev->work);
+                        }
+                }
+        }
 
+        input_report_key(dev->input, BTN_LEFT, dev->data[dev->datalen - 1] & 1);
         input_sync(dev->input);
 
 exit:
@@ -480,6 +541,7 @@ static void atp_close(struct input_dev *input)
         struct atp *dev = input_get_drvdata(input);
 
         usb_kill_urb(dev->urb);
+        cancel_work_sync(&dev->work);
         dev->open = 0;
 }
 
@@ -528,40 +590,10 @@ static int atp_probe(struct usb_interface *iface, const struct usb_device_id *id
                 dev->datalen = 81;
 
         if (atp_is_geyser_3(dev)) {
-                /*
-                 * By default Geyser 3 device sends standard USB HID mouse
-                 * packets (Report ID 2). This code changes device mode, so it
-                 * sends raw sensor reports (Report ID 5).
-                 */
-                char data[8];
-                int size;
-
-                size = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
-                        ATP_GEYSER3_MODE_READ_REQUEST_ID,
-                        USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
-                        ATP_GEYSER3_MODE_REQUEST_VALUE,
-                        ATP_GEYSER3_MODE_REQUEST_INDEX, &data, 8, 5000);
-
-                if (size != 8) {
-                        err("Could not do mode read request from device"
-                                                        " (Geyser 3 mode)");
+                /* switch to raw sensor mode */
+                if (atp_geyser3_init(udev))
                         goto err_free_devs;
-                }
-
-                /* Apply the mode switch */
-                data[0] = ATP_GEYSER3_MODE_VENDOR_VALUE;
-
-                size = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
-                        ATP_GEYSER3_MODE_WRITE_REQUEST_ID,
-                        USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
-                        ATP_GEYSER3_MODE_REQUEST_VALUE,
-                        ATP_GEYSER3_MODE_REQUEST_INDEX, &data, 8, 5000);
 
-                if (size != 8) {
-                        err("Could not do mode write request to device"
-                                                        " (Geyser 3 mode)");
-                        goto err_free_devs;
-                }
                 printk("appletouch Geyser 3 inited.\n");
         }
 
@@ -636,6 +668,8 @@ static int atp_probe(struct usb_interface *iface, const struct usb_device_id *id
         /* save our data pointer in this interface device */
         usb_set_intfdata(iface, dev);
 
+        INIT_WORK(&dev->work, atp_reinit);
+
         return 0;
 
  err_free_buffer:
@@ -669,14 +703,17 @@ static void atp_disconnect(struct usb_interface *iface)
 static int atp_suspend(struct usb_interface *iface, pm_message_t message)
 {
         struct atp *dev = usb_get_intfdata(iface);
+
         usb_kill_urb(dev->urb);
         dev->valid = 0;
+
         return 0;
 }
 
 static int atp_resume(struct usb_interface *iface)
 {
         struct atp *dev = usb_get_intfdata(iface);
+
         if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC))
                 return -EIO;
 
diff --git a/drivers/input/mouse/lifebook.c b/drivers/input/mouse/lifebook.c
index 1740cadd9594..91109b49fde1 100644
--- a/drivers/input/mouse/lifebook.c
+++ b/drivers/input/mouse/lifebook.c
@@ -109,7 +109,7 @@ static psmouse_ret_t lifebook_process_byte(struct psmouse *psmouse)
 {
         struct lifebook_data *priv = psmouse->private;
         struct input_dev *dev1 = psmouse->dev;
-        struct input_dev *dev2 = priv->dev2;
+        struct input_dev *dev2 = priv ? priv->dev2 : NULL;
         unsigned char *packet = psmouse->packet;
         int relative_packet = packet[0] & 0x08;
 
diff --git a/drivers/input/serio/i8042-x86ia64io.h b/drivers/input/serio/i8042-x86ia64io.h
index 4fca1e7f2678..702a526cf45b 100644
--- a/drivers/input/serio/i8042-x86ia64io.h
+++ b/drivers/input/serio/i8042-x86ia64io.h
@@ -366,6 +366,7 @@ static void i8042_pnp_exit(void)
 static int __init i8042_pnp_init(void)
 {
         char kbd_irq_str[4] = { 0 }, aux_irq_str[4] = { 0 };
+        int pnp_data_busted = 0;
         int err;
 
         if (i8042_nopnp) {
@@ -413,27 +414,48 @@ static int __init i8042_pnp_init(void)
 #endif
 
         if (((i8042_pnp_data_reg & ~0xf) == (i8042_data_reg & ~0xf) &&
-              i8042_pnp_data_reg != i8042_data_reg) || !i8042_pnp_data_reg) {
-                printk(KERN_WARNING "PNP: PS/2 controller has invalid data port %#x; using default %#x\n",
+              i8042_pnp_data_reg != i8042_data_reg) ||
+            !i8042_pnp_data_reg) {
+                printk(KERN_WARNING
+                        "PNP: PS/2 controller has invalid data port %#x; "
+                        "using default %#x\n",
                         i8042_pnp_data_reg, i8042_data_reg);
                 i8042_pnp_data_reg = i8042_data_reg;
+                pnp_data_busted = 1;
         }
 
         if (((i8042_pnp_command_reg & ~0xf) == (i8042_command_reg & ~0xf) &&
-              i8042_pnp_command_reg != i8042_command_reg) || !i8042_pnp_command_reg) {
-                printk(KERN_WARNING "PNP: PS/2 controller has invalid command port %#x; using default %#x\n",
+              i8042_pnp_command_reg != i8042_command_reg) ||
+            !i8042_pnp_command_reg) {
+                printk(KERN_WARNING
+                        "PNP: PS/2 controller has invalid command port %#x; "
+                        "using default %#x\n",
                         i8042_pnp_command_reg, i8042_command_reg);
                 i8042_pnp_command_reg = i8042_command_reg;
+                pnp_data_busted = 1;
         }
 
         if (!i8042_nokbd && !i8042_pnp_kbd_irq) {
-                printk(KERN_WARNING "PNP: PS/2 controller doesn't have KBD irq; using default %d\n", i8042_kbd_irq);
+                printk(KERN_WARNING
+                        "PNP: PS/2 controller doesn't have KBD irq; "
+                        "using default %d\n", i8042_kbd_irq);
                 i8042_pnp_kbd_irq = i8042_kbd_irq;
+                pnp_data_busted = 1;
         }
 
         if (!i8042_noaux && !i8042_pnp_aux_irq) {
-                printk(KERN_WARNING "PNP: PS/2 controller doesn't have AUX irq; using default %d\n", i8042_aux_irq);
-                i8042_pnp_aux_irq = i8042_aux_irq;
+                if (!pnp_data_busted && i8042_pnp_kbd_irq) {
+                        printk(KERN_WARNING
+                                "PNP: PS/2 appears to have AUX port disabled, "
+                                "if this is incorrect please boot with "
+                                "i8042.nopnp\n");
+                        i8042_noaux = 1;
+                } else {
+                        printk(KERN_WARNING
+                                "PNP: PS/2 controller doesn't have AUX irq; "
+                                "using default %d\n", i8042_aux_irq);
+                        i8042_pnp_aux_irq = i8042_aux_irq;
+                }
         }
 
         i8042_data_reg = i8042_pnp_data_reg;
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index 69371779806a..f929fcdbae2e 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -54,6 +54,19 @@ config TOUCHSCREEN_CORGI
           To compile this driver as a module, choose M here: the
           module will be called corgi_ts.
 
+config TOUCHSCREEN_FUJITSU
+        tristate "Fujitsu serial touchscreen"
+        select SERIO
+        help
+          Say Y here if you have the Fujitsu touchscreen (such as one
+          installed in Lifebook P series laptop) connected to your
+          system.
+
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called fujitsu-ts.
+
 config TOUCHSCREEN_GUNZE
         tristate "Gunze AHL-51S touchscreen"
         select SERIO
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index 2f86d6ad06d3..5de8933c4993 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -9,6 +9,7 @@ obj-$(CONFIG_TOUCHSCREEN_BITSY)		+= h3600_ts_input.o
 obj-$(CONFIG_TOUCHSCREEN_CORGI)         += corgi_ts.o
 obj-$(CONFIG_TOUCHSCREEN_GUNZE)         += gunze.o
 obj-$(CONFIG_TOUCHSCREEN_ELO)           += elo.o
+obj-$(CONFIG_TOUCHSCREEN_FUJITSU)       += fujitsu_ts.o
 obj-$(CONFIG_TOUCHSCREEN_MTOUCH)        += mtouch.o
 obj-$(CONFIG_TOUCHSCREEN_MK712)         += mk712.o
 obj-$(CONFIG_TOUCHSCREEN_HP600)         += hp680_ts_input.o
diff --git a/drivers/input/touchscreen/ads7846.c b/drivers/input/touchscreen/ads7846.c
index 1c9069cd3bae..96581d08774f 100644
--- a/drivers/input/touchscreen/ads7846.c
+++ b/drivers/input/touchscreen/ads7846.c
@@ -95,7 +95,7 @@ struct ads7846 {
         u16                     dummy;          /* for the pwrdown read */
         struct ts_event         tc;
 
-        struct spi_transfer     xfer[10];
+        struct spi_transfer     xfer[18];
         struct spi_message      msg[5];
         struct spi_message      *last_msg;
         int                     msg_idx;
@@ -107,6 +107,8 @@ struct ads7846 {
         u16                     debounce_tol;
         u16                     debounce_rep;
 
+        u16                     penirq_recheck_delay_usecs;
+
         spinlock_t              lock;
         struct hrtimer          timer;
         unsigned                pendown:1;      /* P: lock */
@@ -553,6 +555,15 @@ static void ads7846_rx(void *ads)
                 return;
         }
 
+        /* Maybe check the pendown state before reporting. This discards
+         * false readings when the pen is lifted.
+         */
+        if (ts->penirq_recheck_delay_usecs) {
+                udelay(ts->penirq_recheck_delay_usecs);
+                if (!ts->get_pendown_state())
+                        Rt = 0;
+        }
+
         /* NOTE: We can't rely on the pressure to determine the pen down
          * state, even this controller has a pressure sensor.  The pressure
          * value can fluctuate for quite a while after lifting the pen and
@@ -896,6 +907,10 @@ static int __devinit ads7846_probe(struct spi_device *spi)
                 ts->filter = ads7846_no_filter;
         ts->get_pendown_state = pdata->get_pendown_state;
 
+        if (pdata->penirq_recheck_delay_usecs)
+                ts->penirq_recheck_delay_usecs =
+                                pdata->penirq_recheck_delay_usecs;
+
         snprintf(ts->phys, sizeof(ts->phys), "%s/input0", spi->dev.bus_id);
 
         input_dev->name = "ADS784x Touchscreen";
@@ -936,6 +951,24 @@ static int __devinit ads7846_probe(struct spi_device *spi)
         x->len = 2;
         spi_message_add_tail(x, m);
 
+        /* the first sample after switching drivers can be low quality;
+         * optionally discard it, using a second one after the signals
+         * have had enough time to stabilize.
+         */
+        if (pdata->settle_delay_usecs) {
+                x->delay_usecs = pdata->settle_delay_usecs;
+
+                x++;
+                x->tx_buf = &ts->read_y;
+                x->len = 1;
+                spi_message_add_tail(x, m);
+
+                x++;
+                x->rx_buf = &ts->tc.y;
+                x->len = 2;
+                spi_message_add_tail(x, m);
+        }
+
         m->complete = ads7846_rx_val;
         m->context = ts;
 
@@ -954,6 +987,21 @@ static int __devinit ads7846_probe(struct spi_device *spi)
         x->len = 2;
         spi_message_add_tail(x, m);
 
+        /* ... maybe discard first sample ... */
+        if (pdata->settle_delay_usecs) {
+                x->delay_usecs = pdata->settle_delay_usecs;
+
+                x++;
+                x->tx_buf = &ts->read_x;
+                x->len = 1;
+                spi_message_add_tail(x, m);
+
+                x++;
+                x->rx_buf = &ts->tc.x;
+                x->len = 2;
+                spi_message_add_tail(x, m);
+        }
+
         m->complete = ads7846_rx_val;
         m->context = ts;
 
@@ -973,6 +1021,21 @@ static int __devinit ads7846_probe(struct spi_device *spi)
                 x->len = 2;
                 spi_message_add_tail(x, m);
 
+                /* ... maybe discard first sample ... */
+                if (pdata->settle_delay_usecs) {
+                        x->delay_usecs = pdata->settle_delay_usecs;
+
+                        x++;
+                        x->tx_buf = &ts->read_z1;
+                        x->len = 1;
+                        spi_message_add_tail(x, m);
+
+                        x++;
+                        x->rx_buf = &ts->tc.z1;
+                        x->len = 2;
+                        spi_message_add_tail(x, m);
+                }
+
                 m->complete = ads7846_rx_val;
                 m->context = ts;
 
@@ -990,6 +1053,21 @@ static int __devinit ads7846_probe(struct spi_device *spi)
                 x->len = 2;
                 spi_message_add_tail(x, m);
 
+                /* ... maybe discard first sample ... */
+                if (pdata->settle_delay_usecs) {
+                        x->delay_usecs = pdata->settle_delay_usecs;
+
+                        x++;
+                        x->tx_buf = &ts->read_z2;
+                        x->len = 1;
+                        spi_message_add_tail(x, m);
+
+                        x++;
+                        x->rx_buf = &ts->tc.z2;
+                        x->len = 2;
+                        spi_message_add_tail(x, m);
+                }
+
                 m->complete = ads7846_rx_val;
                 m->context = ts;
         }
diff --git a/drivers/input/touchscreen/fujitsu_ts.c b/drivers/input/touchscreen/fujitsu_ts.c
new file mode 100644
index 000000000000..daf7a4afc935
--- /dev/null
+++ b/drivers/input/touchscreen/fujitsu_ts.c
@@ -0,0 +1,189 @@
+/*
+ * Fujitsu serial touchscreen driver
+ *
+ * Copyright (c) Dmitry Torokhov <dtor@mail.ru>
+ */
+
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published
+ * by the Free Software Foundation.
+ */
+
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/serio.h>
+#include <linux/init.h>
+
+#define DRIVER_DESC     "Fujitsu serial touchscreen driver"
+
+MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>");
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
+
+#define FUJITSU_LENGTH 5
+
+/*
+ * Per-touchscreen data.
+ */
+struct fujitsu {
+        struct input_dev *dev;
+        struct serio *serio;
+        int idx;
+        unsigned char data[FUJITSU_LENGTH];
+        char phys[32];
+};
+
+/*
+ * Decode serial data (5 bytes per packet)
+ * First byte
+ * 1 C 0 0 R S S S
+ * Where C is 1 while in calibration mode (which we don't use)
+ * R is 1 when no coordinate corection was done.
+ * S are button state
+ */
+static irqreturn_t fujitsu_interrupt(struct serio *serio,
+                                     unsigned char data, unsigned int flags)
+{
+        struct fujitsu *fujitsu = serio_get_drvdata(serio);
+        struct input_dev *dev = fujitsu->dev;
+
+        if (fujitsu->idx == 0) {
+                /* resync skip until start of frame */
+                if ((data & 0xf0) != 0x80)
+                        return IRQ_HANDLED;
+        } else {
+                /* resync skip garbage */
+                if (data & 0x80) {
+                        fujitsu->idx = 0;
+                        return IRQ_HANDLED;
+                }
+        }
+
+        fujitsu->data[fujitsu->idx++] = data;
+        if (fujitsu->idx == FUJITSU_LENGTH) {
+                input_report_abs(dev, ABS_X,
+                                 (fujitsu->data[2] << 7) | fujitsu->data[1]);
+                input_report_abs(dev, ABS_Y,
+                                 (fujitsu->data[4] << 7) | fujitsu->data[3]);
+                input_report_key(dev, BTN_TOUCH,
+                                 (fujitsu->data[0] & 0x03) != 2);
+                input_sync(dev);
+                fujitsu->idx = 0;
+        }
+
+        return IRQ_HANDLED;
+}
+
+/*
+ * fujitsu_disconnect() is the opposite of fujitsu_connect()
+ */
+static void fujitsu_disconnect(struct serio *serio)
+{
+        struct fujitsu *fujitsu = serio_get_drvdata(serio);
+
+        input_get_device(fujitsu->dev);
+        input_unregister_device(fujitsu->dev);
+        serio_close(serio);
+        serio_set_drvdata(serio, NULL);
+        input_put_device(fujitsu->dev);
+        kfree(fujitsu);
+}
+
+/*
+ * fujitsu_connect() is the routine that is called when someone adds a
+ * new serio device that supports the Fujitsu protocol and registers it
+ * as input device.
+ */
+static int fujitsu_connect(struct serio *serio, struct serio_driver *drv)
+{
+        struct fujitsu *fujitsu;
+        struct input_dev *input_dev;
+        int err;
+
+        fujitsu = kzalloc(sizeof(struct fujitsu), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!fujitsu || !input_dev) {
+                err = -ENOMEM;
+                goto fail1;
+        }
+
+        fujitsu->serio = serio;
+        fujitsu->dev = input_dev;
+        snprintf(fujitsu->phys, sizeof(fujitsu->phys),
+                 "%s/input0", serio->phys);
+
+        input_dev->name = "Fujitsu Serial Touchscreen";
+        input_dev->phys = fujitsu->phys;
+        input_dev->id.bustype = BUS_RS232;
+        input_dev->id.vendor = SERIO_FUJITSU;
+        input_dev->id.product = 0;
+        input_dev->id.version = 0x0100;
+        input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);
+        input_dev->keybit[LONG(BTN_TOUCH)] = BIT(BTN_TOUCH);
+
+        input_set_abs_params(input_dev, ABS_X, 0, 4096, 0, 0);
+        input_set_abs_params(input_dev, ABS_Y, 0, 4096, 0, 0);
+        serio_set_drvdata(serio, fujitsu);
+
+        err = serio_open(serio, drv);
+        if (err)
+                goto fail2;
+
+        err = input_register_device(fujitsu->dev);
+        if (err)
+                goto fail3;
+
+        return 0;
+
+ fail3:
+        serio_close(serio);
+ fail2:
+        serio_set_drvdata(serio, NULL);
+ fail1:
+        input_free_device(input_dev);
+        kfree(fujitsu);
+        return err;
+}
+
+/*
+ * The serio driver structure.
+ */
+static struct serio_device_id fujitsu_serio_ids[] = {
+        {
+                .type   = SERIO_RS232,
+                .proto  = SERIO_FUJITSU,
+                .id     = SERIO_ANY,
+                .extra  = SERIO_ANY,
+        },
+        { 0 }
+};
+
+MODULE_DEVICE_TABLE(serio, fujitsu_serio_ids);
+
+static struct serio_driver fujitsu_drv = {
+        .driver         = {
+                .name   = "fujitsu_ts",
+        },
+        .description    = DRIVER_DESC,
+        .id_table       = fujitsu_serio_ids,
+        .interrupt      = fujitsu_interrupt,
+        .connect        = fujitsu_connect,
+        .disconnect     = fujitsu_disconnect,
+};
+
+static int __init fujitsu_init(void)
+{
+        return serio_register_driver(&fujitsu_drv);
+}
+
+static void __exit fujitsu_exit(void)
+{
+        serio_unregister_driver(&fujitsu_drv);
+}
+
+module_init(fujitsu_init);
+module_exit(fujitsu_exit);
diff --git a/drivers/kvm/Kconfig b/drivers/kvm/Kconfig
index 33fa28a8c199..2f661e5f0dae 100644
--- a/drivers/kvm/Kconfig
+++ b/drivers/kvm/Kconfig
@@ -11,7 +11,6 @@ if VIRTUALIZATION
 config KVM
         tristate "Kernel-based Virtual Machine (KVM) support"
         depends on X86 && EXPERIMENTAL
-        depends on X86_CMPXCHG64 || 64BIT
         ---help---
           Support hosting fully virtualized guest machines using hardware
           virtualization extensions.  You will need a fairly recent
diff --git a/drivers/kvm/kvm.h b/drivers/kvm/kvm.h
index a7c5e6bee034..3ac9cbce3369 100644
--- a/drivers/kvm/kvm.h
+++ b/drivers/kvm/kvm.h
@@ -121,7 +121,7 @@ struct kvm_pte_chain {
  *   bits 4:7 - page table level for this shadow (1-4)
  *   bits 8:9 - page table quadrant for 2-level guests
  *   bit   16 - "metaphysical" - gfn is not a real page (huge page/real mode)
- *   bits 17:18 - "access" - the user and writable bits of a huge page pde
+ *   bits 17:19 - "access" - the user, writable, and nx bits of a huge page pde
  */
 union kvm_mmu_page_role {
         unsigned word;
@@ -131,7 +131,7 @@ union kvm_mmu_page_role {
                 unsigned quadrant : 2;
                 unsigned pad_for_nice_hex_output : 6;
                 unsigned metaphysical : 1;
-                unsigned hugepage_access : 2;
+                unsigned hugepage_access : 3;
         };
 };
 
@@ -535,8 +535,8 @@ int kvm_mmu_create(struct kvm_vcpu *vcpu);
 int kvm_mmu_setup(struct kvm_vcpu *vcpu);
 
 int kvm_mmu_reset_context(struct kvm_vcpu *vcpu);
-void kvm_mmu_slot_remove_write_access(struct kvm_vcpu *vcpu, int slot);
-void kvm_mmu_zap_all(struct kvm_vcpu *vcpu);
+void kvm_mmu_slot_remove_write_access(struct kvm *kvm, int slot);
+void kvm_mmu_zap_all(struct kvm *kvm);
 
 hpa_t gpa_to_hpa(struct kvm_vcpu *vcpu, gpa_t gpa);
 #define HPA_MSB ((sizeof(hpa_t) * 8) - 1)
@@ -569,6 +569,8 @@ void realmode_lmsw(struct kvm_vcpu *vcpu, unsigned long msw,
 unsigned long realmode_get_cr(struct kvm_vcpu *vcpu, int cr);
 void realmode_set_cr(struct kvm_vcpu *vcpu, int cr, unsigned long value,
                      unsigned long *rflags);
+int kvm_get_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 *data);
+int kvm_set_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 data);
 
 struct x86_emulate_ctxt;
 
diff --git a/drivers/kvm/kvm_main.c b/drivers/kvm/kvm_main.c
index 1b206f197c6b..bcbe6835beb4 100644
--- a/drivers/kvm/kvm_main.c
+++ b/drivers/kvm/kvm_main.c
@@ -238,23 +238,6 @@ static void vcpu_load(struct kvm_vcpu *vcpu)
         kvm_arch_ops->vcpu_load(vcpu);
 }
 
-/*
- * Switches to specified vcpu, until a matching vcpu_put(). Will return NULL
- * if the slot is not populated.
- */
-static struct kvm_vcpu *vcpu_load_slot(struct kvm *kvm, int slot)
-{
-        struct kvm_vcpu *vcpu = &kvm->vcpus[slot];
-
-        mutex_lock(&vcpu->mutex);
-        if (!vcpu->vmcs) {
-                mutex_unlock(&vcpu->mutex);
-                return NULL;
-        }
-        kvm_arch_ops->vcpu_load(vcpu);
-        return vcpu;
-}
-
 static void vcpu_put(struct kvm_vcpu *vcpu)
 {
         kvm_arch_ops->vcpu_put(vcpu);
@@ -663,13 +646,6 @@ void fx_init(struct kvm_vcpu *vcpu)
 }
 EXPORT_SYMBOL_GPL(fx_init);
 
-static void do_remove_write_access(struct kvm_vcpu *vcpu, int slot)
-{
-        spin_lock(&vcpu->kvm->lock);
-        kvm_mmu_slot_remove_write_access(vcpu, slot);
-        spin_unlock(&vcpu->kvm->lock);
-}
-
 /*
  * Allocate some memory and give it an address in the guest physical address
  * space.
@@ -792,19 +768,10 @@ raced:
         *memslot = new;
         ++kvm->memory_config_version;
 
-        spin_unlock(&kvm->lock);
-
-        for (i = 0; i < KVM_MAX_VCPUS; ++i) {
-                struct kvm_vcpu *vcpu;
+        kvm_mmu_slot_remove_write_access(kvm, mem->slot);
+        kvm_flush_remote_tlbs(kvm);
 
-                vcpu = vcpu_load_slot(kvm, i);
-                if (!vcpu)
-                        continue;
-                if (new.flags & KVM_MEM_LOG_DIRTY_PAGES)
-                        do_remove_write_access(vcpu, mem->slot);
-                kvm_mmu_reset_context(vcpu);
-                vcpu_put(vcpu);
-        }
+        spin_unlock(&kvm->lock);
 
         kvm_free_physmem_slot(&old, &new);
         return 0;
@@ -826,7 +793,6 @@ static int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
         struct kvm_memory_slot *memslot;
         int r, i;
         int n;
-        int cleared;
         unsigned long any = 0;
 
         spin_lock(&kvm->lock);
@@ -855,23 +821,11 @@ static int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
         if (copy_to_user(log->dirty_bitmap, memslot->dirty_bitmap, n))
                 goto out;
 
-        if (any) {
-                cleared = 0;
-                for (i = 0; i < KVM_MAX_VCPUS; ++i) {
-                        struct kvm_vcpu *vcpu;
-
-                        vcpu = vcpu_load_slot(kvm, i);
-                        if (!vcpu)
-                                continue;
-                        if (!cleared) {
-                                do_remove_write_access(vcpu, log->slot);
-                                memset(memslot->dirty_bitmap, 0, n);
-                                cleared = 1;
-                        }
-                        kvm_arch_ops->tlb_flush(vcpu);
-                        vcpu_put(vcpu);
-                }
-        }
+        spin_lock(&kvm->lock);
+        kvm_mmu_slot_remove_write_access(kvm, log->slot);
+        kvm_flush_remote_tlbs(kvm);
+        memset(memslot->dirty_bitmap, 0, n);
+        spin_unlock(&kvm->lock);
 
         r = 0;
 
@@ -920,13 +874,9 @@ static int kvm_vm_ioctl_set_memory_alias(struct kvm *kvm,
                         break;
         kvm->naliases = n;
 
-        spin_unlock(&kvm->lock);
+        kvm_mmu_zap_all(kvm);
 
-        vcpu_load(&kvm->vcpus[0]);
-        spin_lock(&kvm->lock);
-        kvm_mmu_zap_all(&kvm->vcpus[0]);
         spin_unlock(&kvm->lock);
-        vcpu_put(&kvm->vcpus[0]);
 
         return 0;
 
@@ -1567,7 +1517,7 @@ EXPORT_SYMBOL_GPL(kvm_get_msr_common);
  * Returns 0 on success, non-0 otherwise.
  * Assumes vcpu_load() was already called.
  */
-static int get_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 *pdata)
+int kvm_get_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 *pdata)
 {
         return kvm_arch_ops->get_msr(vcpu, msr_index, pdata);
 }
@@ -1645,7 +1595,7 @@ EXPORT_SYMBOL_GPL(kvm_set_msr_common);
  * Returns 0 on success, non-0 otherwise.
  * Assumes vcpu_load() was already called.
  */
-static int set_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 data)
+int kvm_set_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 data)
 {
         return kvm_arch_ops->set_msr(vcpu, msr_index, data);
 }
@@ -2183,7 +2133,7 @@ static __init void kvm_init_msr_list(void)
  */
 static int do_set_msr(struct kvm_vcpu *vcpu, unsigned index, u64 *data)
 {
-        return set_msr(vcpu, index, *data);
+        return kvm_set_msr(vcpu, index, *data);
 }
 
 /*
@@ -2667,7 +2617,7 @@ static long kvm_vcpu_ioctl(struct file *filp,
                 break;
         }
         case KVM_GET_MSRS:
-                r = msr_io(vcpu, argp, get_msr, 1);
+                r = msr_io(vcpu, argp, kvm_get_msr, 1);
                 break;
         case KVM_SET_MSRS:
                 r = msr_io(vcpu, argp, do_set_msr, 0);
diff --git a/drivers/kvm/mmu.c b/drivers/kvm/mmu.c
index b297a6b111ac..d99d2fe53dca 100644
--- a/drivers/kvm/mmu.c
+++ b/drivers/kvm/mmu.c
@@ -154,7 +154,6 @@ struct kvm_rmap_desc {
 
 static struct kmem_cache *pte_chain_cache;
 static struct kmem_cache *rmap_desc_cache;
-static struct kmem_cache *mmu_page_cache;
 static struct kmem_cache *mmu_page_header_cache;
 
 static int is_write_protection(struct kvm_vcpu *vcpu)
@@ -225,6 +224,29 @@ static void mmu_free_memory_cache(struct kvm_mmu_memory_cache *mc)
                 kfree(mc->objects[--mc->nobjs]);
 }
 
+static int mmu_topup_memory_cache_page(struct kvm_mmu_memory_cache *cache,
+                                       int min, gfp_t gfp_flags)
+{
+        struct page *page;
+
+        if (cache->nobjs >= min)
+                return 0;
+        while (cache->nobjs < ARRAY_SIZE(cache->objects)) {
+                page = alloc_page(gfp_flags);
+                if (!page)
+                        return -ENOMEM;
+                set_page_private(page, 0);
+                cache->objects[cache->nobjs++] = page_address(page);
+        }
+        return 0;
+}
+
+static void mmu_free_memory_cache_page(struct kvm_mmu_memory_cache *mc)
+{
+        while (mc->nobjs)
+                __free_page(mc->objects[--mc->nobjs]);
+}
+
 static int __mmu_topup_memory_caches(struct kvm_vcpu *vcpu, gfp_t gfp_flags)
 {
         int r;
@@ -237,8 +259,7 @@ static int __mmu_topup_memory_caches(struct kvm_vcpu *vcpu, gfp_t gfp_flags)
                                    rmap_desc_cache, 1, gfp_flags);
         if (r)
                 goto out;
-        r = mmu_topup_memory_cache(&vcpu->mmu_page_cache,
-                                   mmu_page_cache, 4, gfp_flags);
+        r = mmu_topup_memory_cache_page(&vcpu->mmu_page_cache, 4, gfp_flags);
         if (r)
                 goto out;
         r = mmu_topup_memory_cache(&vcpu->mmu_page_header_cache,
@@ -266,7 +287,7 @@ static void mmu_free_memory_caches(struct kvm_vcpu *vcpu)
 {
         mmu_free_memory_cache(&vcpu->mmu_pte_chain_cache);
         mmu_free_memory_cache(&vcpu->mmu_rmap_desc_cache);
-        mmu_free_memory_cache(&vcpu->mmu_page_cache);
+        mmu_free_memory_cache_page(&vcpu->mmu_page_cache);
         mmu_free_memory_cache(&vcpu->mmu_page_header_cache);
 }
 
@@ -281,24 +302,15 @@ static void *mmu_memory_cache_alloc(struct kvm_mmu_memory_cache *mc,
         return p;
 }
 
-static void mmu_memory_cache_free(struct kvm_mmu_memory_cache *mc, void *obj)
-{
-        if (mc->nobjs < KVM_NR_MEM_OBJS)
-                mc->objects[mc->nobjs++] = obj;
-        else
-                kfree(obj);
-}
-
 static struct kvm_pte_chain *mmu_alloc_pte_chain(struct kvm_vcpu *vcpu)
 {
         return mmu_memory_cache_alloc(&vcpu->mmu_pte_chain_cache,
                                       sizeof(struct kvm_pte_chain));
 }
 
-static void mmu_free_pte_chain(struct kvm_vcpu *vcpu,
-                               struct kvm_pte_chain *pc)
+static void mmu_free_pte_chain(struct kvm_pte_chain *pc)
 {
-        mmu_memory_cache_free(&vcpu->mmu_pte_chain_cache, pc);
+        kfree(pc);
 }
 
 static struct kvm_rmap_desc *mmu_alloc_rmap_desc(struct kvm_vcpu *vcpu)
@@ -307,10 +319,9 @@ static struct kvm_rmap_desc *mmu_alloc_rmap_desc(struct kvm_vcpu *vcpu)
                                       sizeof(struct kvm_rmap_desc));
 }
 
-static void mmu_free_rmap_desc(struct kvm_vcpu *vcpu,
-                               struct kvm_rmap_desc *rd)
+static void mmu_free_rmap_desc(struct kvm_rmap_desc *rd)
 {
-        mmu_memory_cache_free(&vcpu->mmu_rmap_desc_cache, rd);
+        kfree(rd);
 }
 
 /*
@@ -355,8 +366,7 @@ static void rmap_add(struct kvm_vcpu *vcpu, u64 *spte)
         }
 }
 
-static void rmap_desc_remove_entry(struct kvm_vcpu *vcpu,
-                                   struct page *page,
+static void rmap_desc_remove_entry(struct page *page,
                                    struct kvm_rmap_desc *desc,
                                    int i,
                                    struct kvm_rmap_desc *prev_desc)
@@ -376,10 +386,10 @@ static void rmap_desc_remove_entry(struct kvm_vcpu *vcpu,
                         prev_desc->more = desc->more;
                 else
                         set_page_private(page,(unsigned long)desc->more | 1);
-        mmu_free_rmap_desc(vcpu, desc);
+        mmu_free_rmap_desc(desc);
 }
 
-static void rmap_remove(struct kvm_vcpu *vcpu, u64 *spte)
+static void rmap_remove(u64 *spte)
 {
         struct page *page;
         struct kvm_rmap_desc *desc;
@@ -407,7 +417,7 @@ static void rmap_remove(struct kvm_vcpu *vcpu, u64 *spte)
                 while (desc) {
                         for (i = 0; i < RMAP_EXT && desc->shadow_ptes[i]; ++i)
                                 if (desc->shadow_ptes[i] == spte) {
-                                        rmap_desc_remove_entry(vcpu, page,
+                                        rmap_desc_remove_entry(page,
                                                                desc, i,
                                                                prev_desc);
                                         return;
@@ -442,7 +452,7 @@ static void rmap_write_protect(struct kvm_vcpu *vcpu, u64 gfn)
                 BUG_ON(!(*spte & PT_PRESENT_MASK));
                 BUG_ON(!(*spte & PT_WRITABLE_MASK));
                 rmap_printk("rmap_write_protect: spte %p %llx\n", spte, *spte);
-                rmap_remove(vcpu, spte);
+                rmap_remove(spte);
                 set_shadow_pte(spte, *spte & ~PT_WRITABLE_MASK);
                 kvm_flush_remote_tlbs(vcpu->kvm);
         }
@@ -464,14 +474,14 @@ static int is_empty_shadow_page(u64 *spt)
 }
 #endif
 
-static void kvm_mmu_free_page(struct kvm_vcpu *vcpu,
+static void kvm_mmu_free_page(struct kvm *kvm,
                               struct kvm_mmu_page *page_head)
 {
         ASSERT(is_empty_shadow_page(page_head->spt));
         list_del(&page_head->link);
-        mmu_memory_cache_free(&vcpu->mmu_page_cache, page_head->spt);
-        mmu_memory_cache_free(&vcpu->mmu_page_header_cache, page_head);
-        ++vcpu->kvm->n_free_mmu_pages;
+        __free_page(virt_to_page(page_head->spt));
+        kfree(page_head);
+        ++kvm->n_free_mmu_pages;
 }
 
 static unsigned kvm_page_table_hashfn(gfn_t gfn)
@@ -537,8 +547,7 @@ static void mmu_page_add_parent_pte(struct kvm_vcpu *vcpu,
         pte_chain->parent_ptes[0] = parent_pte;
 }
 
-static void mmu_page_remove_parent_pte(struct kvm_vcpu *vcpu,
-                                       struct kvm_mmu_page *page,
+static void mmu_page_remove_parent_pte(struct kvm_mmu_page *page,
                                        u64 *parent_pte)
 {
         struct kvm_pte_chain *pte_chain;
@@ -565,7 +574,7 @@ static void mmu_page_remove_parent_pte(struct kvm_vcpu *vcpu,
                         pte_chain->parent_ptes[i] = NULL;
                         if (i == 0) {
                                 hlist_del(&pte_chain->link);
-                                mmu_free_pte_chain(vcpu, pte_chain);
+                                mmu_free_pte_chain(pte_chain);
                                 if (hlist_empty(&page->parent_ptes)) {
                                         page->multimapped = 0;
                                         page->parent_pte = NULL;
@@ -643,7 +652,7 @@ static struct kvm_mmu_page *kvm_mmu_get_page(struct kvm_vcpu *vcpu,
         return page;
 }
 
-static void kvm_mmu_page_unlink_children(struct kvm_vcpu *vcpu,
+static void kvm_mmu_page_unlink_children(struct kvm *kvm,
                                          struct kvm_mmu_page *page)
 {
         unsigned i;
@@ -655,10 +664,10 @@ static void kvm_mmu_page_unlink_children(struct kvm_vcpu *vcpu,
         if (page->role.level == PT_PAGE_TABLE_LEVEL) {
                 for (i = 0; i < PT64_ENT_PER_PAGE; ++i) {
                         if (pt[i] & PT_PRESENT_MASK)
-                                rmap_remove(vcpu, &pt[i]);
+                                rmap_remove(&pt[i]);
                         pt[i] = 0;
                 }
-                kvm_flush_remote_tlbs(vcpu->kvm);
+                kvm_flush_remote_tlbs(kvm);
                 return;
         }
 
@@ -669,19 +678,18 @@ static void kvm_mmu_page_unlink_children(struct kvm_vcpu *vcpu,
                 if (!(ent & PT_PRESENT_MASK))
                         continue;
                 ent &= PT64_BASE_ADDR_MASK;
-                mmu_page_remove_parent_pte(vcpu, page_header(ent), &pt[i]);
+                mmu_page_remove_parent_pte(page_header(ent), &pt[i]);
         }
-        kvm_flush_remote_tlbs(vcpu->kvm);
+        kvm_flush_remote_tlbs(kvm);
 }
 
-static void kvm_mmu_put_page(struct kvm_vcpu *vcpu,
-                             struct kvm_mmu_page *page,
+static void kvm_mmu_put_page(struct kvm_mmu_page *page,
                              u64 *parent_pte)
 {
-        mmu_page_remove_parent_pte(vcpu, page, parent_pte);
+        mmu_page_remove_parent_pte(page, parent_pte);
 }
 
-static void kvm_mmu_zap_page(struct kvm_vcpu *vcpu,
+static void kvm_mmu_zap_page(struct kvm *kvm,
                              struct kvm_mmu_page *page)
 {
         u64 *parent_pte;
@@ -697,15 +705,15 @@ static void kvm_mmu_zap_page(struct kvm_vcpu *vcpu,
                         parent_pte = chain->parent_ptes[0];
                 }
                 BUG_ON(!parent_pte);
-                kvm_mmu_put_page(vcpu, page, parent_pte);
+                kvm_mmu_put_page(page, parent_pte);
                 set_shadow_pte(parent_pte, 0);
         }
-        kvm_mmu_page_unlink_children(vcpu, page);
+        kvm_mmu_page_unlink_children(kvm, page);
         if (!page->root_count) {
                 hlist_del(&page->hash_link);
-                kvm_mmu_free_page(vcpu, page);
+                kvm_mmu_free_page(kvm, page);
         } else
-                list_move(&page->link, &vcpu->kvm->active_mmu_pages);
+                list_move(&page->link, &kvm->active_mmu_pages);
 }
 
 static int kvm_mmu_unprotect_page(struct kvm_vcpu *vcpu, gfn_t gfn)
@@ -724,7 +732,7 @@ static int kvm_mmu_unprotect_page(struct kvm_vcpu *vcpu, gfn_t gfn)
                 if (page->gfn == gfn && !page->role.metaphysical) {
                         pgprintk("%s: gfn %lx role %x\n", __FUNCTION__, gfn,
                                  page->role.word);
-                        kvm_mmu_zap_page(vcpu, page);
+                        kvm_mmu_zap_page(vcpu->kvm, page);
                         r = 1;
                 }
         return r;
@@ -737,7 +745,7 @@ static void mmu_unshadow(struct kvm_vcpu *vcpu, gfn_t gfn)
         while ((page = kvm_mmu_lookup_page(vcpu, gfn)) != NULL) {
                 pgprintk("%s: zap %lx %x\n",
                          __FUNCTION__, gfn, page->role.word);
-                kvm_mmu_zap_page(vcpu, page);
+                kvm_mmu_zap_page(vcpu->kvm, page);
         }
 }
 
@@ -1089,10 +1097,10 @@ static void mmu_pte_write_zap_pte(struct kvm_vcpu *vcpu,
         pte = *spte;
         if (is_present_pte(pte)) {
                 if (page->role.level == PT_PAGE_TABLE_LEVEL)
-                        rmap_remove(vcpu, spte);
+                        rmap_remove(spte);
                 else {
                         child = page_header(pte & PT64_BASE_ADDR_MASK);
-                        mmu_page_remove_parent_pte(vcpu, child, spte);
+                        mmu_page_remove_parent_pte(child, spte);
                 }
         }
         *spte = 0;
@@ -1161,7 +1169,7 @@ void kvm_mmu_pte_write(struct kvm_vcpu *vcpu, gpa_t gpa,
                          */
                         pgprintk("misaligned: gpa %llx bytes %d role %x\n",
                                  gpa, bytes, page->role.word);
-                        kvm_mmu_zap_page(vcpu, page);
+                        kvm_mmu_zap_page(vcpu->kvm, page);
                         continue;
                 }
                 page_offset = offset;
@@ -1207,7 +1215,7 @@ void kvm_mmu_free_some_pages(struct kvm_vcpu *vcpu)
 
                 page = container_of(vcpu->kvm->active_mmu_pages.prev,
                                     struct kvm_mmu_page, link);
-                kvm_mmu_zap_page(vcpu, page);
+                kvm_mmu_zap_page(vcpu->kvm, page);
         }
 }
 EXPORT_SYMBOL_GPL(kvm_mmu_free_some_pages);
@@ -1219,7 +1227,7 @@ static void free_mmu_pages(struct kvm_vcpu *vcpu)
         while (!list_empty(&vcpu->kvm->active_mmu_pages)) {
                 page = container_of(vcpu->kvm->active_mmu_pages.next,
                                     struct kvm_mmu_page, link);
-                kvm_mmu_zap_page(vcpu, page);
+                kvm_mmu_zap_page(vcpu->kvm, page);
         }
         free_page((unsigned long)vcpu->mmu.pae_root);
 }
@@ -1277,9 +1285,8 @@ void kvm_mmu_destroy(struct kvm_vcpu *vcpu)
         mmu_free_memory_caches(vcpu);
 }
 
-void kvm_mmu_slot_remove_write_access(struct kvm_vcpu *vcpu, int slot)
+void kvm_mmu_slot_remove_write_access(struct kvm *kvm, int slot)
 {
-        struct kvm *kvm = vcpu->kvm;
         struct kvm_mmu_page *page;
 
         list_for_each_entry(page, &kvm->active_mmu_pages, link) {
@@ -1293,27 +1300,20 @@ void kvm_mmu_slot_remove_write_access(struct kvm_vcpu *vcpu, int slot)
                 for (i = 0; i < PT64_ENT_PER_PAGE; ++i)
                         /* avoid RMW */
                         if (pt[i] & PT_WRITABLE_MASK) {
-                                rmap_remove(vcpu, &pt[i]);
+                                rmap_remove(&pt[i]);
                                 pt[i] &= ~PT_WRITABLE_MASK;
                         }
         }
 }
 
-void kvm_mmu_zap_all(struct kvm_vcpu *vcpu)
+void kvm_mmu_zap_all(struct kvm *kvm)
 {
-        destroy_kvm_mmu(vcpu);
-
-        while (!list_empty(&vcpu->kvm->active_mmu_pages)) {
-                struct kvm_mmu_page *page;
+        struct kvm_mmu_page *page, *node;
 
-                page = container_of(vcpu->kvm->active_mmu_pages.next,
-                                    struct kvm_mmu_page, link);
-                kvm_mmu_zap_page(vcpu, page);
-        }
+        list_for_each_entry_safe(page, node, &kvm->active_mmu_pages, link)
+                kvm_mmu_zap_page(kvm, page);
 
-        mmu_free_memory_caches(vcpu);
-        kvm_flush_remote_tlbs(vcpu->kvm);
-        init_kvm_mmu(vcpu);
+        kvm_flush_remote_tlbs(kvm);
 }
 
 void kvm_mmu_module_exit(void)
@@ -1322,8 +1322,6 @@ void kvm_mmu_module_exit(void)
                 kmem_cache_destroy(pte_chain_cache);
         if (rmap_desc_cache)
                 kmem_cache_destroy(rmap_desc_cache);
-        if (mmu_page_cache)
-                kmem_cache_destroy(mmu_page_cache);
         if (mmu_page_header_cache)
                 kmem_cache_destroy(mmu_page_header_cache);
 }
@@ -1332,24 +1330,18 @@ int kvm_mmu_module_init(void)
 {
         pte_chain_cache = kmem_cache_create("kvm_pte_chain",
                                             sizeof(struct kvm_pte_chain),
-                                            0, 0, NULL, NULL);
+                                            0, 0, NULL);
         if (!pte_chain_cache)
                 goto nomem;
         rmap_desc_cache = kmem_cache_create("kvm_rmap_desc",
                                             sizeof(struct kvm_rmap_desc),
-                                            0, 0, NULL, NULL);
+                                            0, 0, NULL);
         if (!rmap_desc_cache)
                 goto nomem;
 
-        mmu_page_cache = kmem_cache_create("kvm_mmu_page",
-                                           PAGE_SIZE,
-                                           PAGE_SIZE, 0, NULL, NULL);
-        if (!mmu_page_cache)
-                goto nomem;
-
         mmu_page_header_cache = kmem_cache_create("kvm_mmu_page_header",
                                                   sizeof(struct kvm_mmu_page),
-                                                  0, 0, NULL, NULL);
+                                                  0, 0, NULL);
         if (!mmu_page_header_cache)
                 goto nomem;
 
diff --git a/drivers/kvm/paging_tmpl.h b/drivers/kvm/paging_tmpl.h
index a7c5cb0319ea..4b5391c717f8 100644
--- a/drivers/kvm/paging_tmpl.h
+++ b/drivers/kvm/paging_tmpl.h
@@ -366,6 +366,8 @@ static u64 *FNAME(fetch)(struct kvm_vcpu *vcpu, gva_t addr,
                         metaphysical = 1;
                         hugepage_access = *guest_ent;
                         hugepage_access &= PT_USER_MASK | PT_WRITABLE_MASK;
+                        if (*guest_ent & PT64_NX_MASK)
+                                hugepage_access |= (1 << 2);
                         hugepage_access >>= PT_WRITABLE_SHIFT;
                         table_gfn = (*guest_ent & PT_BASE_ADDR_MASK)
                                 >> PAGE_SHIFT;
diff --git a/drivers/kvm/x86_emulate.c b/drivers/kvm/x86_emulate.c
index f60012d62610..1b800fc00342 100644
--- a/drivers/kvm/x86_emulate.c
+++ b/drivers/kvm/x86_emulate.c
@@ -163,7 +163,7 @@ static u16 twobyte_table[256] = {
         ModRM | ImplicitOps, ModRM, ModRM | ImplicitOps, ModRM, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0,
         /* 0x30 - 0x3F */
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        ImplicitOps, 0, ImplicitOps, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         /* 0x40 - 0x47 */
         DstReg | SrcMem | ModRM | Mov, DstReg | SrcMem | ModRM | Mov,
         DstReg | SrcMem | ModRM | Mov, DstReg | SrcMem | ModRM | Mov,
@@ -486,6 +486,7 @@ x86_emulate_memop(struct x86_emulate_ctxt *ctxt, struct x86_emulate_ops *ops)
         unsigned long modrm_ea;
         int use_modrm_ea, index_reg = 0, base_reg = 0, scale, rip_relative = 0;
         int no_wb = 0;
+        u64 msr_data;
 
         /* Shadow copy of register state. Committed on successful emulation. */
         unsigned long _regs[NR_VCPU_REGS];
@@ -1344,6 +1345,29 @@ twobyte_special_insn:
                         goto cannot_emulate;
                 realmode_set_cr(ctxt->vcpu, modrm_reg, modrm_val, &_eflags);
                 break;
+        case 0x30:
+                /* wrmsr */
+                msr_data = (u32)_regs[VCPU_REGS_RAX]
+                        | ((u64)_regs[VCPU_REGS_RDX] << 32);
+                rc = kvm_set_msr(ctxt->vcpu, _regs[VCPU_REGS_RCX], msr_data);
+                if (rc) {
+                        kvm_arch_ops->inject_gp(ctxt->vcpu, 0);
+                        _eip = ctxt->vcpu->rip;
+                }
+                rc = X86EMUL_CONTINUE;
+                break;
+        case 0x32:
+                /* rdmsr */
+                rc = kvm_get_msr(ctxt->vcpu, _regs[VCPU_REGS_RCX], &msr_data);
+                if (rc) {
+                        kvm_arch_ops->inject_gp(ctxt->vcpu, 0);
+                        _eip = ctxt->vcpu->rip;
+                } else {
+                        _regs[VCPU_REGS_RAX] = (u32)msr_data;
+                        _regs[VCPU_REGS_RDX] = msr_data >> 32;
+                }
+                rc = X86EMUL_CONTINUE;
+                break;
         case 0xc7:              /* Grp9 (cmpxchg8b) */
                 {
                         u64 old, new;
diff --git a/drivers/lguest/interrupts_and_traps.c b/drivers/lguest/interrupts_and_traps.c
index d9de5bbc613f..bee029bb2c7b 100644
--- a/drivers/lguest/interrupts_and_traps.c
+++ b/drivers/lguest/interrupts_and_traps.c
@@ -38,12 +38,12 @@ static void set_guest_interrupt(struct lguest *lg, u32 lo, u32 hi, int has_err)
                 ss = lg->regs->ss;
         }
 
-        /* We use IF bit in eflags to indicate whether irqs were disabled
-           (it's always 0, since irqs are enabled when guest is running). */
+        /* We use IF bit in eflags to indicate whether irqs were enabled
+           (it's always 1, since irqs are enabled when guest is running). */
         eflags = lg->regs->eflags;
-        if (get_user(irq_enable, &lg->lguest_data->irq_enabled))
-                irq_enable = 0;
-        eflags |= (irq_enable & X86_EFLAGS_IF);
+        if (get_user(irq_enable, &lg->lguest_data->irq_enabled) == 0
+            && !(irq_enable & X86_EFLAGS_IF))
+                eflags &= ~X86_EFLAGS_IF;
 
         push_guest_stack(lg, &gstack, eflags);
         push_guest_stack(lg, &gstack, lg->regs->cs);
diff --git a/drivers/lguest/io.c b/drivers/lguest/io.c
index 06bdba2337ef..c8eb79266991 100644
--- a/drivers/lguest/io.c
+++ b/drivers/lguest/io.c
@@ -187,7 +187,7 @@ static u32 copy_data(struct lguest *srclg,
                 /* FIXME: This is not completely portable, since
                    archs do different things for copy_to_user_page. */
                 if (copy_from_user(maddr + (dst->addr[di] + dstoff)%PAGE_SIZE,
-                                   (void *__user)src->addr[si], len) != 0) {
+                                   (void __user *)src->addr[si], len) != 0) {
                         kill_guest(srclg, "bad address in sending DMA");
                         totlen = 0;
                         break;
diff --git a/drivers/lguest/lguest.c b/drivers/lguest/lguest.c
index b9a58b78c990..434fea1e82f7 100644
--- a/drivers/lguest/lguest.c
+++ b/drivers/lguest/lguest.c
@@ -39,7 +39,6 @@
 #include <asm/e820.h>
 #include <asm/mce.h>
 #include <asm/io.h>
-//#include <asm/sched-clock.h>
 
 /* Declarations for definitions in lguest_guest.S */
 extern char lguest_noirq_start[], lguest_noirq_end[];
@@ -57,6 +56,7 @@ struct lguest_data lguest_data = {
         .blocked_interrupts = { 1 }, /* Block timer interrupts */
 };
 struct lguest_device_desc *lguest_devices;
+static cycle_t clock_base;
 
 static enum paravirt_lazy_mode lazy_mode;
 static void lguest_lazy_mode(enum paravirt_lazy_mode mode)
@@ -363,6 +363,11 @@ static struct clocksource lguest_clock = {
         .read           = lguest_clock_read,
 };
 
+static unsigned long long lguest_sched_clock(void)
+{
+        return cyc2ns(&lguest_clock, lguest_clock_read() - clock_base);
+}
+
 /* We also need a "struct clock_event_device": Linux asks us to set it to go
  * off some time in the future.  Actually, James Morris figured all this out, I
  * just applied the patch. */
@@ -439,6 +444,7 @@ static void lguest_time_init(void)
                 lguest_clock.mult = (((u64)NSEC_PER_SEC<<8)/ACTHZ) << 8;
                 lguest_clock.mask = CLOCKSOURCE_MASK(32);
         }
+        clock_base = lguest_clock_read();
         clocksource_register(&lguest_clock);
 
         /* We can't set cpumask in the initializer: damn C limitations! */
@@ -584,6 +590,7 @@ __init void lguest_init(void *boot)
         paravirt_ops.time_init = lguest_time_init;
         paravirt_ops.set_lazy_mode = lguest_lazy_mode;
         paravirt_ops.wbinvd = lguest_wbinvd;
+        paravirt_ops.sched_clock = lguest_sched_clock;
 
         hcall(LHCALL_LGUEST_INIT, __pa(&lguest_data), 0, 0);
 
diff --git a/drivers/lguest/lguest_asm.S b/drivers/lguest/lguest_asm.S
index 00046c57b5ba..a3dbf22ee365 100644
--- a/drivers/lguest/lguest_asm.S
+++ b/drivers/lguest/lguest_asm.S
@@ -2,9 +2,7 @@
 #include <linux/lguest.h>
 #include <asm/asm-offsets.h>
 #include <asm/thread_info.h>
-
-/* FIXME: Once asm/processor-flags.h goes in, include that */
-#define X86_EFLAGS_IF 0x00000200
+#include <asm/processor-flags.h>
 
 /*
  * This is where we begin: we have a magic signature which the launcher looks
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 0b66afef2d82..d90ee145effe 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -493,12 +493,12 @@ async_copy_data(int frombio, struct bio *bio, struct page *page,
                         if (frombio)
                                 tx = async_memcpy(page, bio_page, page_offset,
                                         b_offset, clen,
-                                        ASYNC_TX_DEP_ACK | ASYNC_TX_KMAP_SRC,
+                                        ASYNC_TX_DEP_ACK,
                                         tx, NULL, NULL);
                         else
                                 tx = async_memcpy(bio_page, page, b_offset,
                                         page_offset, clen,
-                                        ASYNC_TX_DEP_ACK | ASYNC_TX_KMAP_DST,
+                                        ASYNC_TX_DEP_ACK,
                                         tx, NULL, NULL);
                 }
                 if (clen < len) /* hit end of page */
@@ -951,7 +951,7 @@ static int grow_stripes(raid5_conf_t *conf, int num)
         conf->active_name = 0;
         sc = kmem_cache_create(conf->cache_name[conf->active_name],
                                sizeof(struct stripe_head)+(devs-1)*sizeof(struct r5dev),
-                               0, 0, NULL, NULL);
+                               0, 0, NULL);
         if (!sc)
                 return 1;
         conf->slab_cache = sc;
@@ -1003,7 +1003,7 @@ static int resize_stripes(raid5_conf_t *conf, int newsize)
         /* Step 1 */
         sc = kmem_cache_create(conf->cache_name[1-conf->active_name],
                                sizeof(struct stripe_head)+(newsize-1)*sizeof(struct r5dev),
-                               0, 0, NULL, NULL);
+                               0, 0, NULL);
         if (!sc)
                 return -ENOMEM;
 
diff --git a/drivers/message/i2o/i2o_block.c b/drivers/message/i2o/i2o_block.c
index 64a52bd7544a..988c8ce47f58 100644
--- a/drivers/message/i2o/i2o_block.c
+++ b/drivers/message/i2o/i2o_block.c
@@ -1171,8 +1171,7 @@ static int __init i2o_block_init(void)
         /* Allocate request mempool and slab */
         size = sizeof(struct i2o_block_request);
         i2o_blk_req_pool.slab = kmem_cache_create("i2o_block_req", size, 0,
-                                                  SLAB_HWCACHE_ALIGN, NULL,
-                                                  NULL);
+                                                  SLAB_HWCACHE_ALIGN, NULL);
         if (!i2o_blk_req_pool.slab) {
                 osm_err("can't init request slab\n");
                 rc = -ENOMEM;
diff --git a/drivers/mtd/ubi/eba.c b/drivers/mtd/ubi/eba.c
index 8aff9385613f..7c5e29eaf118 100644
--- a/drivers/mtd/ubi/eba.c
+++ b/drivers/mtd/ubi/eba.c
@@ -1149,7 +1149,7 @@ int ubi_eba_init_scan(struct ubi_device *ubi, struct ubi_scan_info *si)
         if (ubi_devices_cnt == 0) {
                 ltree_slab = kmem_cache_create("ubi_ltree_slab",
                                                sizeof(struct ltree_entry), 0,
-                                               0, &ltree_entry_ctor, NULL);
+                                               0, &ltree_entry_ctor);
                 if (!ltree_slab)
                         return -ENOMEM;
         }
diff --git a/drivers/mtd/ubi/wl.c b/drivers/mtd/ubi/wl.c
index 9de953762097..a5a9b8d87302 100644
--- a/drivers/mtd/ubi/wl.c
+++ b/drivers/mtd/ubi/wl.c
@@ -1452,7 +1452,7 @@ int ubi_wl_init_scan(struct ubi_device *ubi, struct ubi_scan_info *si)
         if (ubi_devices_cnt == 0) {
                 wl_entries_slab = kmem_cache_create("ubi_wl_entry_slab",
                                                     sizeof(struct ubi_wl_entry),
-                                                    0, 0, NULL, NULL);
+                                                    0, 0, NULL);
                 if (!wl_entries_slab)
                         return -ENOMEM;
         }
diff --git a/drivers/net/mac89x0.c b/drivers/net/mac89x0.c
index 26a3b45a4a34..62c1c6262feb 100644
--- a/drivers/net/mac89x0.c
+++ b/drivers/net/mac89x0.c
@@ -608,7 +608,7 @@ module_param(debug, int, 0);
 MODULE_PARM_DESC(debug, "CS89[02]0 debug level (0-5)");
 MODULE_LICENSE("GPL");
 
-int
+int __init
 init_module(void)
 {
         net_debug = debug;
diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c
index a2f32151559e..13f08a390e1f 100644
--- a/drivers/net/sky2.c
+++ b/drivers/net/sky2.c
@@ -692,6 +692,7 @@ static void sky2_mac_init(struct sky2_hw *hw, unsigned port)
 {
         struct sky2_port *sky2 = netdev_priv(hw->dev[port]);
         u16 reg;
+        u32 rx_reg;
         int i;
         const u8 *addr = hw->dev[port]->dev_addr;
 
@@ -768,11 +769,11 @@ static void sky2_mac_init(struct sky2_hw *hw, unsigned port)
 
         /* Configure Rx MAC FIFO */
         sky2_write8(hw, SK_REG(port, RX_GMF_CTRL_T), GMF_RST_CLR);
-        reg = GMF_OPER_ON | GMF_RX_F_FL_ON;
+        rx_reg = GMF_OPER_ON | GMF_RX_F_FL_ON;
         if (hw->chip_id == CHIP_ID_YUKON_EX)
-                reg |= GMF_RX_OVER_ON;
+                rx_reg |= GMF_RX_OVER_ON;
 
-        sky2_write32(hw, SK_REG(port, RX_GMF_CTRL_T), reg);
+        sky2_write32(hw, SK_REG(port, RX_GMF_CTRL_T), rx_reg);
 
         /* Flush Rx MAC FIFO on any flow control or error */
         sky2_write16(hw, SK_REG(port, RX_GMF_FL_MSK), GMR_FS_ANY_ERR);
diff --git a/drivers/net/sunvnet.c b/drivers/net/sunvnet.c
index b801e3b3a11a..ef0066bab2cf 100644
--- a/drivers/net/sunvnet.c
+++ b/drivers/net/sunvnet.c
@@ -1136,7 +1136,7 @@ static struct vio_device_id vnet_port_match[] = {
         },
         {},
 };
-MODULE_DEVICE_TABLE(vio, vnet_match);
+MODULE_DEVICE_TABLE(vio, vnet_port_match);
 
 static struct vio_driver vnet_port_driver = {
         .id_table       = vnet_port_match,
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index 5ee14764fd74..887b9a5cfe48 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -64,8 +64,8 @@
 
 #define DRV_MODULE_NAME         "tg3"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_MODULE_VERSION      "3.78"
-#define DRV_MODULE_RELDATE      "July 11, 2007"
+#define DRV_MODULE_VERSION      "3.79"
+#define DRV_MODULE_RELDATE      "July 18, 2007"
 
 #define TG3_DEF_MAC_MODE        0
 #define TG3_DEF_RX_MODE         0
@@ -4847,6 +4847,59 @@ static int tg3_poll_fw(struct tg3 *tp)
         return 0;
 }
 
+/* Save PCI command register before chip reset */
+static void tg3_save_pci_state(struct tg3 *tp)
+{
+        u32 val;
+
+        pci_read_config_dword(tp->pdev, TG3PCI_COMMAND, &val);
+        tp->pci_cmd = val;
+}
+
+/* Restore PCI state after chip reset */
+static void tg3_restore_pci_state(struct tg3 *tp)
+{
+        u32 val;
+
+        /* Re-enable indirect register accesses. */
+        pci_write_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL,
+                               tp->misc_host_ctrl);
+
+        /* Set MAX PCI retry to zero. */
+        val = (PCISTATE_ROM_ENABLE | PCISTATE_ROM_RETRY_ENABLE);
+        if (tp->pci_chip_rev_id == CHIPREV_ID_5704_A0 &&
+            (tp->tg3_flags & TG3_FLAG_PCIX_MODE))
+                val |= PCISTATE_RETRY_SAME_DMA;
+        pci_write_config_dword(tp->pdev, TG3PCI_PCISTATE, val);
+
+        pci_write_config_dword(tp->pdev, TG3PCI_COMMAND, tp->pci_cmd);
+
+        /* Make sure PCI-X relaxed ordering bit is clear. */
+        pci_read_config_dword(tp->pdev, TG3PCI_X_CAPS, &val);
+        val &= ~PCIX_CAPS_RELAXED_ORDERING;
+        pci_write_config_dword(tp->pdev, TG3PCI_X_CAPS, val);
+
+        if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS) {
+                u32 val;
+
+                /* Chip reset on 5780 will reset MSI enable bit,
+                 * so need to restore it.
+                 */
+                if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
+                        u16 ctrl;
+
+                        pci_read_config_word(tp->pdev,
+                                             tp->msi_cap + PCI_MSI_FLAGS,
+                                             &ctrl);
+                        pci_write_config_word(tp->pdev,
+                                              tp->msi_cap + PCI_MSI_FLAGS,
+                                              ctrl | PCI_MSI_FLAGS_ENABLE);
+                        val = tr32(MSGINT_MODE);
+                        tw32(MSGINT_MODE, val | MSGINT_MODE_ENABLE);
+                }
+        }
+}
+
 static void tg3_stop_fw(struct tg3 *);
 
 /* tp->lock is held. */
@@ -4863,6 +4916,12 @@ static int tg3_chip_reset(struct tg3 *tp)
          */
         tp->nvram_lock_cnt = 0;
 
+        /* GRC_MISC_CFG core clock reset will clear the memory
+         * enable bit in PCI register 4 and the MSI enable bit
+         * on some chips, so we save relevant registers here.
+         */
+        tg3_save_pci_state(tp);
+
         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752 ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787)
@@ -4961,50 +5020,14 @@ static int tg3_chip_reset(struct tg3 *tp)
                 pci_write_config_dword(tp->pdev, 0xd8, 0xf5000);
         }
 
-        /* Re-enable indirect register accesses. */
-        pci_write_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL,
-                               tp->misc_host_ctrl);
-
-        /* Set MAX PCI retry to zero. */
-        val = (PCISTATE_ROM_ENABLE | PCISTATE_ROM_RETRY_ENABLE);
-        if (tp->pci_chip_rev_id == CHIPREV_ID_5704_A0 &&
-            (tp->tg3_flags & TG3_FLAG_PCIX_MODE))
-                val |= PCISTATE_RETRY_SAME_DMA;
-        pci_write_config_dword(tp->pdev, TG3PCI_PCISTATE, val);
-
-        pci_restore_state(tp->pdev);
+        tg3_restore_pci_state(tp);
 
         tp->tg3_flags &= ~TG3_FLAG_CHIP_RESETTING;
 
-        /* Make sure PCI-X relaxed ordering bit is clear. */
-        pci_read_config_dword(tp->pdev, TG3PCI_X_CAPS, &val);
-        val &= ~PCIX_CAPS_RELAXED_ORDERING;
-        pci_write_config_dword(tp->pdev, TG3PCI_X_CAPS, val);
-
-        if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS) {
-                u32 val;
-
-                /* Chip reset on 5780 will reset MSI enable bit,
-                 * so need to restore it.
-                 */
-                if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
-                        u16 ctrl;
-
-                        pci_read_config_word(tp->pdev,
-                                             tp->msi_cap + PCI_MSI_FLAGS,
-                                             &ctrl);
-                        pci_write_config_word(tp->pdev,
-                                              tp->msi_cap + PCI_MSI_FLAGS,
-                                              ctrl | PCI_MSI_FLAGS_ENABLE);
-                        val = tr32(MSGINT_MODE);
-                        tw32(MSGINT_MODE, val | MSGINT_MODE_ENABLE);
-                }
-
+        val = 0;
+        if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)
                 val = tr32(MEMARB_MODE);
-                tw32(MEMARB_MODE, val | MEMARB_MODE_ENABLE);
-
-        } else
-                tw32(MEMARB_MODE, MEMARB_MODE_ENABLE);
+        tw32(MEMARB_MODE, val | MEMARB_MODE_ENABLE);
 
         if (tp->pci_chip_rev_id == CHIPREV_ID_5750_A3) {
                 tg3_stop_fw(tp);
@@ -11978,7 +12001,6 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
          */
         if ((tr32(HOSTCC_MODE) & HOSTCC_MODE_ENABLE) ||
             (tr32(WDMAC_MODE) & WDMAC_MODE_ENABLE)) {
-                pci_save_state(tp->pdev);
                 tw32(MEMARB_MODE, MEMARB_MODE_ENABLE);
                 tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
         }
@@ -12007,12 +12029,6 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
 
         tg3_init_coal(tp);
 
-        /* Now that we have fully setup the chip, save away a snapshot
-         * of the PCI config space.  We need to restore this after
-         * GRC_MISC_CFG core clock resets and some resume events.
-         */
-        pci_save_state(tp->pdev);
-
         pci_set_drvdata(pdev, dev);
 
         err = register_netdev(dev);
diff --git a/drivers/net/tg3.h b/drivers/net/tg3.h
index d84e75e7365d..5c21f49026c9 100644
--- a/drivers/net/tg3.h
+++ b/drivers/net/tg3.h
@@ -2345,6 +2345,7 @@ struct tg3 {
 #define PHY_REV_BCM5411_X0              0x1 /* Found on Netgear GA302T */
 
         u32                             led_ctrl;
+        u32                             pci_cmd;
 
         char                            board_part_number[24];
         char                            fw_ver[16];
diff --git a/drivers/of/Kconfig b/drivers/of/Kconfig
new file mode 100644
index 000000000000..c03072b12f42
--- /dev/null
+++ b/drivers/of/Kconfig
@@ -0,0 +1,3 @@
+config OF_DEVICE
+        def_bool y
+        depends on OF && (SPARC || PPC_OF)
diff --git a/drivers/of/Makefile b/drivers/of/Makefile
new file mode 100644
index 000000000000..ab9be5d5255b
--- /dev/null
+++ b/drivers/of/Makefile
@@ -0,0 +1,2 @@
+obj-y = base.o
+obj-$(CONFIG_OF_DEVICE) += device.o platform.o
diff --git a/drivers/of/base.c b/drivers/of/base.c
new file mode 100644
index 000000000000..9377f3bc410a
--- /dev/null
+++ b/drivers/of/base.c
@@ -0,0 +1,275 @@
+/*
+ * Procedures for creating, accessing and interpreting the device tree.
+ *
+ * Paul Mackerras       August 1996.
+ * Copyright (C) 1996-2005 Paul Mackerras.
+ *
+ *  Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
+ *    {engebret|bergner}@us.ibm.com
+ *
+ *  Adapted for sparc and sparc64 by David S. Miller davem@davemloft.net
+ *
+ *  Reconsolidated from arch/x/kernel/prom.c by Stephen Rothwell.
+ *
+ *      This program is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU General Public License
+ *      as published by the Free Software Foundation; either version
+ *      2 of the License, or (at your option) any later version.
+ */
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/spinlock.h>
+
+struct device_node *allnodes;
+
+/* use when traversing tree through the allnext, child, sibling,
+ * or parent members of struct device_node.
+ */
+DEFINE_RWLOCK(devtree_lock);
+
+int of_n_addr_cells(struct device_node *np)
+{
+        const int *ip;
+
+        do {
+                if (np->parent)
+                        np = np->parent;
+                ip = of_get_property(np, "#address-cells", NULL);
+                if (ip)
+                        return *ip;
+        } while (np->parent);
+        /* No #address-cells property for the root node */
+        return OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
+}
+EXPORT_SYMBOL(of_n_addr_cells);
+
+int of_n_size_cells(struct device_node *np)
+{
+        const int *ip;
+
+        do {
+                if (np->parent)
+                        np = np->parent;
+                ip = of_get_property(np, "#size-cells", NULL);
+                if (ip)
+                        return *ip;
+        } while (np->parent);
+        /* No #size-cells property for the root node */
+        return OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
+}
+EXPORT_SYMBOL(of_n_size_cells);
+
+struct property *of_find_property(const struct device_node *np,
+                                  const char *name,
+                                  int *lenp)
+{
+        struct property *pp;
+
+        read_lock(&devtree_lock);
+        for (pp = np->properties; pp != 0; pp = pp->next) {
+                if (of_prop_cmp(pp->name, name) == 0) {
+                        if (lenp != 0)
+                                *lenp = pp->length;
+                        break;
+                }
+        }
+        read_unlock(&devtree_lock);
+
+        return pp;
+}
+EXPORT_SYMBOL(of_find_property);
+
+/*
+ * Find a property with a given name for a given node
+ * and return the value.
+ */
+const void *of_get_property(const struct device_node *np, const char *name,
+                         int *lenp)
+{
+        struct property *pp = of_find_property(np, name, lenp);
+
+        return pp ? pp->value : NULL;
+}
+EXPORT_SYMBOL(of_get_property);
+
+/** Checks if the given "compat" string matches one of the strings in
+ * the device's "compatible" property
+ */
+int of_device_is_compatible(const struct device_node *device,
+                const char *compat)
+{
+        const char* cp;
+        int cplen, l;
+
+        cp = of_get_property(device, "compatible", &cplen);
+        if (cp == NULL)
+                return 0;
+        while (cplen > 0) {
+                if (of_compat_cmp(cp, compat, strlen(compat)) == 0)
+                        return 1;
+                l = strlen(cp) + 1;
+                cp += l;
+                cplen -= l;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL(of_device_is_compatible);
+
+/**
+ *      of_get_parent - Get a node's parent if any
+ *      @node:  Node to get parent
+ *
+ *      Returns a node pointer with refcount incremented, use
+ *      of_node_put() on it when done.
+ */
+struct device_node *of_get_parent(const struct device_node *node)
+{
+        struct device_node *np;
+
+        if (!node)
+                return NULL;
+
+        read_lock(&devtree_lock);
+        np = of_node_get(node->parent);
+        read_unlock(&devtree_lock);
+        return np;
+}
+EXPORT_SYMBOL(of_get_parent);
+
+/**
+ *      of_get_next_child - Iterate a node childs
+ *      @node:  parent node
+ *      @prev:  previous child of the parent node, or NULL to get first
+ *
+ *      Returns a node pointer with refcount incremented, use
+ *      of_node_put() on it when done.
+ */
+struct device_node *of_get_next_child(const struct device_node *node,
+        struct device_node *prev)
+{
+        struct device_node *next;
+
+        read_lock(&devtree_lock);
+        next = prev ? prev->sibling : node->child;
+        for (; next; next = next->sibling)
+                if (of_node_get(next))
+                        break;
+        of_node_put(prev);
+        read_unlock(&devtree_lock);
+        return next;
+}
+EXPORT_SYMBOL(of_get_next_child);
+
+/**
+ *      of_find_node_by_path - Find a node matching a full OF path
+ *      @path:  The full path to match
+ *
+ *      Returns a node pointer with refcount incremented, use
+ *      of_node_put() on it when done.
+ */
+struct device_node *of_find_node_by_path(const char *path)
+{
+        struct device_node *np = allnodes;
+
+        read_lock(&devtree_lock);
+        for (; np; np = np->allnext) {
+                if (np->full_name && (of_node_cmp(np->full_name, path) == 0)
+                    && of_node_get(np))
+                        break;
+        }
+        read_unlock(&devtree_lock);
+        return np;
+}
+EXPORT_SYMBOL(of_find_node_by_path);
+
+/**
+ *      of_find_node_by_name - Find a node by its "name" property
+ *      @from:  The node to start searching from or NULL, the node
+ *              you pass will not be searched, only the next one
+ *              will; typically, you pass what the previous call
+ *              returned. of_node_put() will be called on it
+ *      @name:  The name string to match against
+ *
+ *      Returns a node pointer with refcount incremented, use
+ *      of_node_put() on it when done.
+ */
+struct device_node *of_find_node_by_name(struct device_node *from,
+        const char *name)
+{
+        struct device_node *np;
+
+        read_lock(&devtree_lock);
+        np = from ? from->allnext : allnodes;
+        for (; np; np = np->allnext)
+                if (np->name && (of_node_cmp(np->name, name) == 0)
+                    && of_node_get(np))
+                        break;
+        of_node_put(from);
+        read_unlock(&devtree_lock);
+        return np;
+}
+EXPORT_SYMBOL(of_find_node_by_name);
+
+/**
+ *      of_find_node_by_type - Find a node by its "device_type" property
+ *      @from:  The node to start searching from, or NULL to start searching
+ *              the entire device tree. The node you pass will not be
+ *              searched, only the next one will; typically, you pass
+ *              what the previous call returned. of_node_put() will be
+ *              called on from for you.
+ *      @type:  The type string to match against
+ *
+ *      Returns a node pointer with refcount incremented, use
+ *      of_node_put() on it when done.
+ */
+struct device_node *of_find_node_by_type(struct device_node *from,
+        const char *type)
+{
+        struct device_node *np;
+
+        read_lock(&devtree_lock);
+        np = from ? from->allnext : allnodes;
+        for (; np; np = np->allnext)
+                if (np->type && (of_node_cmp(np->type, type) == 0)
+                    && of_node_get(np))
+                        break;
+        of_node_put(from);
+        read_unlock(&devtree_lock);
+        return np;
+}
+EXPORT_SYMBOL(of_find_node_by_type);
+
+/**
+ *      of_find_compatible_node - Find a node based on type and one of the
+ *                                tokens in its "compatible" property
+ *      @from:          The node to start searching from or NULL, the node
+ *                      you pass will not be searched, only the next one
+ *                      will; typically, you pass what the previous call
+ *                      returned. of_node_put() will be called on it
+ *      @type:          The type string to match "device_type" or NULL to ignore
+ *      @compatible:    The string to match to one of the tokens in the device
+ *                      "compatible" list.
+ *
+ *      Returns a node pointer with refcount incremented, use
+ *      of_node_put() on it when done.
+ */
+struct device_node *of_find_compatible_node(struct device_node *from,
+        const char *type, const char *compatible)
+{
+        struct device_node *np;
+
+        read_lock(&devtree_lock);
+        np = from ? from->allnext : allnodes;
+        for (; np; np = np->allnext) {
+                if (type
+                    && !(np->type && (of_node_cmp(np->type, type) == 0)))
+                        continue;
+                if (of_device_is_compatible(np, compatible) && of_node_get(np))
+                        break;
+        }
+        of_node_put(from);
+        read_unlock(&devtree_lock);
+        return np;
+}
+EXPORT_SYMBOL(of_find_compatible_node);
diff --git a/drivers/of/device.c b/drivers/of/device.c
new file mode 100644
index 000000000000..6245f060fb77
--- /dev/null
+++ b/drivers/of/device.c
@@ -0,0 +1,131 @@
+#include <linux/string.h>
+#include <linux/kernel.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/mod_devicetable.h>
+#include <linux/slab.h>
+
+#include <asm/errno.h>
+
+/**
+ * of_match_node - Tell if an device_node has a matching of_match structure
+ * @ids: array of of device match structures to search in
+ * @node: the of device structure to match against
+ *
+ * Low level utility function used by device matching.
+ */
+const struct of_device_id *of_match_node(const struct of_device_id *matches,
+                                         const struct device_node *node)
+{
+        while (matches->name[0] || matches->type[0] || matches->compatible[0]) {
+                int match = 1;
+                if (matches->name[0])
+                        match &= node->name
+                                && !strcmp(matches->name, node->name);
+                if (matches->type[0])
+                        match &= node->type
+                                && !strcmp(matches->type, node->type);
+                if (matches->compatible[0])
+                        match &= of_device_is_compatible(node,
+                                                matches->compatible);
+                if (match)
+                        return matches;
+                matches++;
+        }
+        return NULL;
+}
+EXPORT_SYMBOL(of_match_node);
+
+/**
+ * of_match_device - Tell if an of_device structure has a matching
+ * of_match structure
+ * @ids: array of of device match structures to search in
+ * @dev: the of device structure to match against
+ *
+ * Used by a driver to check whether an of_device present in the
+ * system is in its list of supported devices.
+ */
+const struct of_device_id *of_match_device(const struct of_device_id *matches,
+                                        const struct of_device *dev)
+{
+        if (!dev->node)
+                return NULL;
+        return of_match_node(matches, dev->node);
+}
+EXPORT_SYMBOL(of_match_device);
+
+struct of_device *of_dev_get(struct of_device *dev)
+{
+        struct device *tmp;
+
+        if (!dev)
+                return NULL;
+        tmp = get_device(&dev->dev);
+        if (tmp)
+                return to_of_device(tmp);
+        else
+                return NULL;
+}
+EXPORT_SYMBOL(of_dev_get);
+
+void of_dev_put(struct of_device *dev)
+{
+        if (dev)
+                put_device(&dev->dev);
+}
+EXPORT_SYMBOL(of_dev_put);
+
+static ssize_t dev_show_devspec(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct of_device *ofdev;
+
+        ofdev = to_of_device(dev);
+        return sprintf(buf, "%s", ofdev->node->full_name);
+}
+
+static DEVICE_ATTR(devspec, S_IRUGO, dev_show_devspec, NULL);
+
+/**
+ * of_release_dev - free an of device structure when all users of it are finished.
+ * @dev: device that's been disconnected
+ *
+ * Will be called only by the device core when all users of this of device are
+ * done.
+ */
+void of_release_dev(struct device *dev)
+{
+        struct of_device *ofdev;
+
+        ofdev = to_of_device(dev);
+        of_node_put(ofdev->node);
+        kfree(ofdev);
+}
+EXPORT_SYMBOL(of_release_dev);
+
+int of_device_register(struct of_device *ofdev)
+{
+        int rc;
+
+        BUG_ON(ofdev->node == NULL);
+
+        rc = device_register(&ofdev->dev);
+        if (rc)
+                return rc;
+
+        rc = device_create_file(&ofdev->dev, &dev_attr_devspec);
+        if (rc)
+                device_unregister(&ofdev->dev);
+
+        return rc;
+}
+EXPORT_SYMBOL(of_device_register);
+
+void of_device_unregister(struct of_device *ofdev)
+{
+        device_remove_file(&ofdev->dev, &dev_attr_devspec);
+        device_unregister(&ofdev->dev);
+}
+EXPORT_SYMBOL(of_device_unregister);
diff --git a/drivers/of/platform.c b/drivers/of/platform.c
new file mode 100644
index 000000000000..864f09fd9f86
--- /dev/null
+++ b/drivers/of/platform.c
@@ -0,0 +1,96 @@
+/*
+ *    Copyright (C) 2006 Benjamin Herrenschmidt, IBM Corp.
+ *                       <benh@kernel.crashing.org>
+ *    and                Arnd Bergmann, IBM Corp.
+ *    Merged from powerpc/kernel/of_platform.c and
+ *    sparc{,64}/kernel/of_device.c by Stephen Rothwell
+ *
+ *  This program is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public License
+ *  as published by the Free Software Foundation; either version
+ *  2 of the License, or (at your option) any later version.
+ *
+ */
+#include <linux/errno.h>
+#include <linux/device.h>
+#include <linux/of_device.h>
+#include <linux/of_platform.h>
+
+static int of_platform_bus_match(struct device *dev, struct device_driver *drv)
+{
+        struct of_device *of_dev = to_of_device(dev);
+        struct of_platform_driver *of_drv = to_of_platform_driver(drv);
+        const struct of_device_id *matches = of_drv->match_table;
+
+        if (!matches)
+                return 0;
+
+        return of_match_device(matches, of_dev) != NULL;
+}
+
+static int of_platform_device_probe(struct device *dev)
+{
+        int error = -ENODEV;
+        struct of_platform_driver *drv;
+        struct of_device *of_dev;
+        const struct of_device_id *match;
+
+        drv = to_of_platform_driver(dev->driver);
+        of_dev = to_of_device(dev);
+
+        if (!drv->probe)
+                return error;
+
+        of_dev_get(of_dev);
+
+        match = of_match_device(drv->match_table, of_dev);
+        if (match)
+                error = drv->probe(of_dev, match);
+        if (error)
+                of_dev_put(of_dev);
+
+        return error;
+}
+
+static int of_platform_device_remove(struct device *dev)
+{
+        struct of_device *of_dev = to_of_device(dev);
+        struct of_platform_driver *drv = to_of_platform_driver(dev->driver);
+
+        if (dev->driver && drv->remove)
+                drv->remove(of_dev);
+        return 0;
+}
+
+static int of_platform_device_suspend(struct device *dev, pm_message_t state)
+{
+        struct of_device *of_dev = to_of_device(dev);
+        struct of_platform_driver *drv = to_of_platform_driver(dev->driver);
+        int error = 0;
+
+        if (dev->driver && drv->suspend)
+                error = drv->suspend(of_dev, state);
+        return error;
+}
+
+static int of_platform_device_resume(struct device * dev)
+{
+        struct of_device *of_dev = to_of_device(dev);
+        struct of_platform_driver *drv = to_of_platform_driver(dev->driver);
+        int error = 0;
+
+        if (dev->driver && drv->resume)
+                error = drv->resume(of_dev);
+        return error;
+}
+
+int of_bus_type_init(struct bus_type *bus, const char *name)
+{
+        bus->name = name;
+        bus->match = of_platform_bus_match;
+        bus->probe = of_platform_device_probe;
+        bus->remove = of_platform_device_remove;
+        bus->suspend = of_platform_device_suspend;
+        bus->resume = of_platform_device_resume;
+        return bus_register(bus);
+}
diff --git a/drivers/parport/Kconfig b/drivers/parport/Kconfig
index 09c93ff932b1..d449b150930e 100644
--- a/drivers/parport/Kconfig
+++ b/drivers/parport/Kconfig
@@ -35,7 +35,7 @@ if PARPORT
 
 config PARPORT_PC
         tristate "PC-style hardware"
-        depends on (!SPARC64 || PCI) && !SPARC32 && !M32R && !FRV
+        depends on (!SPARC64 || PCI) && !SPARC32 && !M32R && !FRV && (!M68K || ISA)
         ---help---
           You should say Y here if you have a PC-style parallel port. All
           IBM PC compatible computers and some Alphas have PC-style
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index cea401feb0f3..35f34665e3c4 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -394,7 +394,7 @@ config RTC_DRV_SA1100
 
 config RTC_DRV_SH
         tristate "SuperH On-Chip RTC"
-        depends on RTC_CLASS && SUPERH
+        depends on RTC_CLASS && SUPERH && (CPU_SH3 || CPU_SH4)
         help
           Say Y here to enable support for the on-chip RTC found in
           most SuperH processors.
diff --git a/drivers/s390/block/dasd_devmap.c b/drivers/s390/block/dasd_devmap.c
index 6a89cefe99bb..0c67258fb9ec 100644
--- a/drivers/s390/block/dasd_devmap.c
+++ b/drivers/s390/block/dasd_devmap.c
@@ -291,7 +291,7 @@ dasd_parse_keyword( char *parsestring ) {
                 dasd_page_cache =
                         kmem_cache_create("dasd_page_cache", PAGE_SIZE,
                                           PAGE_SIZE, SLAB_CACHE_DMA,
-                                          NULL, NULL );
+                                          NULL);
                 if (!dasd_page_cache)
                         MESSAGE(KERN_WARNING, "%s", "Failed to create slab, "
                                 "fixed buffer mode disabled.");
diff --git a/drivers/s390/scsi/zfcp_aux.c b/drivers/s390/scsi/zfcp_aux.c
index a1db95925138..9726261c367d 100644
--- a/drivers/s390/scsi/zfcp_aux.c
+++ b/drivers/s390/scsi/zfcp_aux.c
@@ -259,21 +259,21 @@ zfcp_module_init(void)
         size = sizeof(struct zfcp_fsf_req_qtcb);
         align = calc_alignment(size);
         zfcp_data.fsf_req_qtcb_cache =
-                kmem_cache_create("zfcp_fsf", size, align, 0, NULL, NULL);
+                kmem_cache_create("zfcp_fsf", size, align, 0, NULL);
         if (!zfcp_data.fsf_req_qtcb_cache)
                 goto out;
 
         size = sizeof(struct fsf_status_read_buffer);
         align = calc_alignment(size);
         zfcp_data.sr_buffer_cache =
-                kmem_cache_create("zfcp_sr", size, align, 0, NULL, NULL);
+                kmem_cache_create("zfcp_sr", size, align, 0, NULL);
         if (!zfcp_data.sr_buffer_cache)
                 goto out_sr_cache;
 
         size = sizeof(struct zfcp_gid_pn_data);
         align = calc_alignment(size);
         zfcp_data.gid_pn_cache =
-                kmem_cache_create("zfcp_gid", size, align, 0, NULL, NULL);
+                kmem_cache_create("zfcp_gid", size, align, 0, NULL);
         if (!zfcp_data.gid_pn_cache)
                 goto out_gid_cache;
 
diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig
index 372723161c97..a947257b8964 100644
--- a/drivers/scsi/Kconfig
+++ b/drivers/scsi/Kconfig
@@ -483,7 +483,7 @@ source "drivers/scsi/aic94xx/Kconfig"
 # All the I2O code and drivers do not seem to be 64bit safe.
 config SCSI_DPT_I2O
         tristate "Adaptec I2O RAID support "
-        depends on !64BIT && SCSI && PCI
+        depends on !64BIT && SCSI && PCI && VIRT_TO_BUS
         help
           This driver supports all of Adaptec's I2O based RAID controllers as 
           well as the DPT SmartRaid V cards.  This is an Adaptec maintained
diff --git a/drivers/scsi/NCR53C9x.c b/drivers/scsi/NCR53C9x.c
index 773d11dd9953..79b4df158140 100644
--- a/drivers/scsi/NCR53C9x.c
+++ b/drivers/scsi/NCR53C9x.c
@@ -95,6 +95,8 @@ enum {
 /* The master ring of all esp hosts we are managing in this driver. */
 static struct NCR_ESP *espchain;
 int nesps = 0, esps_in_use = 0, esps_running = 0;
+EXPORT_SYMBOL(nesps);
+EXPORT_SYMBOL(esps_running);
 
 irqreturn_t esp_intr(int irq, void *dev_id);
 
@@ -524,6 +526,7 @@ void esp_bootup_reset(struct NCR_ESP *esp, struct ESP_regs *eregs)
         /* Eat any bitrot in the chip and we are done... */
         trash = esp_read(eregs->esp_intrpt);
 }
+EXPORT_SYMBOL(esp_bootup_reset);
 
 /* Allocate structure and insert basic data such as SCSI chip frequency
  * data and a pointer to the device
@@ -772,6 +775,7 @@ const char *esp_info(struct Scsi_Host *host)
                 panic("Bogon ESP revision");
         };
 }
+EXPORT_SYMBOL(esp_info);
 
 /* From Wolfgang Stanglmeier's NCR scsi driver. */
 struct info_str
@@ -902,6 +906,7 @@ int esp_proc_info(struct Scsi_Host *shost, char *buffer, char **start, off_t off
                 *start = buffer;
         return esp_host_info(esp, buffer, offset, length);
 }
+EXPORT_SYMBOL(esp_proc_info);
 
 static void esp_get_dmabufs(struct NCR_ESP *esp, Scsi_Cmnd *sp)
 {
@@ -3535,6 +3540,7 @@ state_machine:
         if(esp->dma_irq_exit)
                 esp->dma_irq_exit(esp);
 }
+EXPORT_SYMBOL(esp_handle);
 
 #ifndef CONFIG_SMP
 irqreturn_t esp_intr(int irq, void *dev_id)
@@ -3631,6 +3637,7 @@ void esp_release(void)
         esps_in_use--;
         esps_running = esps_in_use;
 }
+EXPORT_SYMBOL(esp_release);
 #endif
 
 EXPORT_SYMBOL(esp_abort);
diff --git a/drivers/scsi/aic94xx/aic94xx_init.c b/drivers/scsi/aic94xx/aic94xx_init.c
index 1c0d7578e791..b8c6810090d5 100644
--- a/drivers/scsi/aic94xx/aic94xx_init.c
+++ b/drivers/scsi/aic94xx/aic94xx_init.c
@@ -462,7 +462,7 @@ static int asd_create_global_caches(void)
                                             sizeof(struct asd_dma_tok),
                                             0,
                                             SLAB_HWCACHE_ALIGN,
-                                            NULL, NULL);
+                                            NULL);
                 if (!asd_dma_token_cache) {
                         asd_printk("couldn't create dma token cache\n");
                         return -ENOMEM;
@@ -474,7 +474,7 @@ static int asd_create_global_caches(void)
                                                    sizeof(struct asd_ascb),
                                                    0,
                                                    SLAB_HWCACHE_ALIGN,
-                                                   NULL, NULL);
+                                                   NULL);
                 if (!asd_ascb_cache) {
                         asd_printk("couldn't create ascb cache\n");
                         goto Err;
diff --git a/drivers/scsi/iscsi_tcp.c b/drivers/scsi/iscsi_tcp.c
index aebcd5fcdc55..7829ab1e2fb4 100644
--- a/drivers/scsi/iscsi_tcp.c
+++ b/drivers/scsi/iscsi_tcp.c
@@ -1885,7 +1885,7 @@ static int iscsi_tcp_get_addr(struct iscsi_conn *conn, struct socket *sock,
         struct sockaddr_in *sin;
         int rc = 0, len;
 
-        addr = kmalloc(GFP_KERNEL, sizeof(*addr));
+        addr = kmalloc(sizeof(*addr), GFP_KERNEL);
         if (!addr)
                 return -ENOMEM;
 
diff --git a/drivers/scsi/libsas/sas_init.c b/drivers/scsi/libsas/sas_init.c
index 965698c8b7bf..1396c83b0c9c 100644
--- a/drivers/scsi/libsas/sas_init.c
+++ b/drivers/scsi/libsas/sas_init.c
@@ -292,7 +292,7 @@ EXPORT_SYMBOL_GPL(sas_domain_release_transport);
 static int __init sas_class_init(void)
 {
         sas_task_cache = kmem_cache_create("sas_task", sizeof(struct sas_task),
-                                           0, SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                           0, SLAB_HWCACHE_ALIGN, NULL);
         if (!sas_task_cache)
                 return -ENOMEM;
 
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index b5a77b0c0deb..92376f9dfdd5 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -2723,7 +2723,7 @@ qla2x00_module_init(void)
 
         /* Allocate cache for SRBs. */
         srb_cachep = kmem_cache_create("qla2xxx_srbs", sizeof(srb_t), 0,
-            SLAB_HWCACHE_ALIGN, NULL, NULL);
+            SLAB_HWCACHE_ALIGN, NULL);
         if (srb_cachep == NULL) {
                 printk(KERN_ERR
                     "qla2xxx: Unable to allocate SRB cache...Failing load!\n");
diff --git a/drivers/scsi/qla4xxx/ql4_os.c b/drivers/scsi/qla4xxx/ql4_os.c
index e69160a7bc60..b1d565c12c5b 100644
--- a/drivers/scsi/qla4xxx/ql4_os.c
+++ b/drivers/scsi/qla4xxx/ql4_os.c
@@ -1677,7 +1677,7 @@ static int __init qla4xxx_module_init(void)
 
         /* Allocate cache for SRBs. */
         srb_cachep = kmem_cache_create("qla4xxx_srbs", sizeof(struct srb), 0,
-                                       SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                       SLAB_HWCACHE_ALIGN, NULL);
         if (srb_cachep == NULL) {
                 printk(KERN_ERR
                        "%s: Unable to allocate SRB cache..."
diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index a691dda40d2c..a5de1a829a76 100644
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -288,7 +288,7 @@ int scsi_setup_command_freelist(struct Scsi_Host *shost)
         if (!pool->users) {
                 pool->slab = kmem_cache_create(pool->name,
                                 sizeof(struct scsi_cmnd), 0,
-                                pool->slab_flags, NULL, NULL);
+                                pool->slab_flags, NULL);
                 if (!pool->slab)
                         goto fail;
         }
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 1f5a07bf2a75..da63c544919b 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -1661,7 +1661,7 @@ int __init scsi_init_queue(void)
 
         scsi_io_context_cache = kmem_cache_create("scsi_io_context",
                                         sizeof(struct scsi_io_context),
-                                        0, 0, NULL, NULL);
+                                        0, 0, NULL);
         if (!scsi_io_context_cache) {
                 printk(KERN_ERR "SCSI: can't init scsi io context cache\n");
                 return -ENOMEM;
@@ -1672,7 +1672,7 @@ int __init scsi_init_queue(void)
                 int size = sgp->size * sizeof(struct scatterlist);
 
                 sgp->slab = kmem_cache_create(sgp->name, size, 0,
-                                SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                SLAB_HWCACHE_ALIGN, NULL);
                 if (!sgp->slab) {
                         printk(KERN_ERR "SCSI: can't init sg slab %s\n",
                                         sgp->name);
diff --git a/drivers/scsi/scsi_tgt_lib.c b/drivers/scsi/scsi_tgt_lib.c
index 2570f48a69c7..371b69c110bc 100644
--- a/drivers/scsi/scsi_tgt_lib.c
+++ b/drivers/scsi/scsi_tgt_lib.c
@@ -585,7 +585,7 @@ static int __init scsi_tgt_init(void)
 
         scsi_tgt_cmd_cache = kmem_cache_create("scsi_tgt_cmd",
                                                sizeof(struct scsi_tgt_cmd),
-                                               0, 0, NULL, NULL);
+                                               0, 0, NULL);
         if (!scsi_tgt_cmd_cache)
                 return -ENOMEM;
 
diff --git a/drivers/usb/atm/cxacru.c b/drivers/usb/atm/cxacru.c
index 1bc884051e0f..02c52f8d5dbf 100644
--- a/drivers/usb/atm/cxacru.c
+++ b/drivers/usb/atm/cxacru.c
@@ -456,7 +456,7 @@ static int cxacru_start_wait_urb(struct urb *urb, struct completion *done,
                                  int* actual_length)
 {
         struct timer_list timer;
-        int status;
+        int status = urb->status;
 
         init_timer(&timer);
         timer.expires = jiffies + msecs_to_jiffies(CMD_TIMEOUT);
@@ -464,7 +464,6 @@ static int cxacru_start_wait_urb(struct urb *urb, struct completion *done,
         timer.function = cxacru_timeout_kill;
         add_timer(&timer);
         wait_for_completion(done);
-        status = urb->status;
         del_timer_sync(&timer);
 
         if (actual_length)
diff --git a/drivers/usb/atm/speedtch.c b/drivers/usb/atm/speedtch.c
index 638b8009b3bc..eb0615abff68 100644
--- a/drivers/usb/atm/speedtch.c
+++ b/drivers/usb/atm/speedtch.c
@@ -612,7 +612,8 @@ static void speedtch_handle_int(struct urb *int_urb)
         struct speedtch_instance_data *instance = int_urb->context;
         struct usbatm_data *usbatm = instance->usbatm;
         unsigned int count = int_urb->actual_length;
-        int ret = int_urb->status;
+        int status = int_urb->status;
+        int ret;
 
         /* The magic interrupt for "up state" */
         static const unsigned char up_int[6]   = { 0xa1, 0x00, 0x01, 0x00, 0x00, 0x00 };
@@ -621,8 +622,8 @@ static void speedtch_handle_int(struct urb *int_urb)
 
         atm_dbg(usbatm, "%s entered\n", __func__);
 
-        if (ret < 0) {
-                atm_dbg(usbatm, "%s: nonzero urb status %d!\n", __func__, ret);
+        if (status < 0) {
+                atm_dbg(usbatm, "%s: nonzero urb status %d!\n", __func__, status);
                 goto fail;
         }
 
diff --git a/drivers/usb/atm/ueagle-atm.c b/drivers/usb/atm/ueagle-atm.c
index 8f046659b4e9..a1a1c9d467e0 100644
--- a/drivers/usb/atm/ueagle-atm.c
+++ b/drivers/usb/atm/ueagle-atm.c
@@ -1308,11 +1308,13 @@ static void uea_intr(struct urb *urb)
 {
         struct uea_softc *sc = urb->context;
         struct intr_pkt *intr = urb->transfer_buffer;
+        int status = urb->status;
+
         uea_enters(INS_TO_USBDEV(sc));
 
-        if (unlikely(urb->status < 0)) {
+        if (unlikely(status < 0)) {
                 uea_err(INS_TO_USBDEV(sc), "uea_intr() failed with %d\n",
-                       urb->status);
+                       status);
                 return;
         }
 
diff --git a/drivers/usb/atm/usbatm.c b/drivers/usb/atm/usbatm.c
index 11e9b15ca45a..e717f5b1caee 100644
--- a/drivers/usb/atm/usbatm.c
+++ b/drivers/usb/atm/usbatm.c
@@ -257,9 +257,10 @@ static void usbatm_complete(struct urb *urb)
 {
         struct usbatm_channel *channel = urb->context;
         unsigned long flags;
+        int status = urb->status;
 
         vdbg("%s: urb 0x%p, status %d, actual_length %d",
-             __func__, urb, urb->status, urb->actual_length);
+             __func__, urb, status, urb->actual_length);
 
         /* usually in_interrupt(), but not always */
         spin_lock_irqsave(&channel->lock, flags);
@@ -269,16 +270,16 @@ static void usbatm_complete(struct urb *urb)
 
         spin_unlock_irqrestore(&channel->lock, flags);
 
-        if (unlikely(urb->status) &&
+        if (unlikely(status) &&
                         (!(channel->usbatm->flags & UDSL_IGNORE_EILSEQ) ||
-                         urb->status != -EILSEQ ))
+                         status != -EILSEQ ))
         {
-                if (urb->status == -ESHUTDOWN)
+                if (status == -ESHUTDOWN)
                         return;
 
                 if (printk_ratelimit())
                         atm_warn(channel->usbatm, "%s: urb 0x%p failed (%d)!\n",
-                                __func__, urb, urb->status);
+                                __func__, urb, status);
                 /* throttle processing in case of an error */
                 mod_timer(&channel->delay, jiffies + msecs_to_jiffies(THROTTLE_MSECS));
         } else
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index cd51520c7e72..fe940e0536e0 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -257,9 +257,10 @@ static void acm_ctrl_irq(struct urb *urb)
         struct usb_cdc_notification *dr = urb->transfer_buffer;
         unsigned char *data;
         int newctrl;
-        int status;
+        int retval;
+        int status = urb->status;
 
-        switch (urb->status) {
+        switch (status) {
         case 0:
                 /* success */
                 break;
@@ -267,10 +268,10 @@ static void acm_ctrl_irq(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
+                dbg("%s - urb shutting down with status: %d", __FUNCTION__, status);
                 return;
         default:
-                dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
+                dbg("%s - nonzero urb status received: %d", __FUNCTION__, status);
                 goto exit;
         }
 
@@ -311,10 +312,10 @@ static void acm_ctrl_irq(struct urb *urb)
                         break;
         }
 exit:
-        status = usb_submit_urb (urb, GFP_ATOMIC);
-        if (status)
+        retval = usb_submit_urb (urb, GFP_ATOMIC);
+        if (retval)
                 err ("%s - usb_submit_urb failed with result %d",
-                     __FUNCTION__, status);
+                     __FUNCTION__, retval);
 }
 
 /* data interface returns incoming bytes, or we got unthrottled */
@@ -324,7 +325,8 @@ static void acm_read_bulk(struct urb *urb)
         struct acm_ru *rcv = urb->context;
         struct acm *acm = rcv->instance;
         int status = urb->status;
-        dbg("Entering acm_read_bulk with status %d", urb->status);
+
+        dbg("Entering acm_read_bulk with status %d", status);
 
         if (!ACM_READY(acm))
                 return;
diff --git a/drivers/usb/class/usblp.c b/drivers/usb/class/usblp.c
index 9a1478972bf5..5192cd9356de 100644
--- a/drivers/usb/class/usblp.c
+++ b/drivers/usb/class/usblp.c
@@ -289,16 +289,17 @@ static int proto_bias = -1;
 static void usblp_bulk_read(struct urb *urb)
 {
         struct usblp *usblp = urb->context;
+        int status = urb->status;
 
         if (usblp->present && usblp->used) {
-                if (urb->status)
+                if (status)
                         printk(KERN_WARNING "usblp%d: "
                             "nonzero read bulk status received: %d\n",
-                            usblp->minor, urb->status);
+                            usblp->minor, status);
         }
         spin_lock(&usblp->lock);
-        if (urb->status < 0)
-                usblp->rstatus = urb->status;
+        if (status < 0)
+                usblp->rstatus = status;
         else
                 usblp->rstatus = urb->actual_length;
         usblp->rcomplete = 1;
@@ -311,16 +312,17 @@ static void usblp_bulk_read(struct urb *urb)
 static void usblp_bulk_write(struct urb *urb)
 {
         struct usblp *usblp = urb->context;
+        int status = urb->status;
 
         if (usblp->present && usblp->used) {
-                if (urb->status)
+                if (status)
                         printk(KERN_WARNING "usblp%d: "
                             "nonzero write bulk status received: %d\n",
-                            usblp->minor, urb->status);
+                            usblp->minor, status);
         }
         spin_lock(&usblp->lock);
-        if (urb->status < 0)
-                usblp->wstatus = urb->status;
+        if (status < 0)
+                usblp->wstatus = status;
         else
                 usblp->wstatus = urb->actual_length;
         usblp->wcomplete = 1;
@@ -741,10 +743,11 @@ static ssize_t usblp_write(struct file *file, const char __user *buffer, size_t
                  */
                 rv = usblp_wwait(usblp, !!(file->f_flags&O_NONBLOCK));
                 if (rv < 0) {
-                        /*
-                         * If interrupted, we simply leave the URB to dangle,
-                         * so the ->release will call usb_kill_urb().
-                         */
+                        if (rv == -EAGAIN) {
+                                /* Presume that it's going to complete well. */
+                                writecount += transfer_length;
+                        }
+                        /* Leave URB dangling, to be cleaned on close. */
                         goto collect_error;
                 }
 
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 963520fbef90..42ef1d5f6c8a 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -99,12 +99,17 @@ EXPORT_SYMBOL_GPL (usb_bus_list_lock);
 /* used for controlling access to virtual root hubs */
 static DEFINE_SPINLOCK(hcd_root_hub_lock);
 
-/* used when updating hcd data */
-static DEFINE_SPINLOCK(hcd_data_lock);
+/* used when updating an endpoint's URB list */
+static DEFINE_SPINLOCK(hcd_urb_list_lock);
 
 /* wait queue for synchronous unlinks */
 DECLARE_WAIT_QUEUE_HEAD(usb_kill_urb_queue);
 
+static inline int is_root_hub(struct usb_device *udev)
+{
+        return (udev->parent == NULL);
+}
+
 /*-------------------------------------------------------------------------*/
 
 /*
@@ -906,14 +911,13 @@ EXPORT_SYMBOL (usb_calc_bus_time);
 static void urb_unlink(struct usb_hcd *hcd, struct urb *urb)
 {
         unsigned long           flags;
-        int at_root_hub = (urb->dev == hcd->self.root_hub);
 
         /* clear all state linking urb to this dev (and hcd) */
-        spin_lock_irqsave (&hcd_data_lock, flags);
+        spin_lock_irqsave(&hcd_urb_list_lock, flags);
         list_del_init (&urb->urb_list);
-        spin_unlock_irqrestore (&hcd_data_lock, flags);
+        spin_unlock_irqrestore(&hcd_urb_list_lock, flags);
 
-        if (hcd->self.uses_dma && !at_root_hub) {
+        if (hcd->self.uses_dma && !is_root_hub(urb->dev)) {
                 if (usb_pipecontrol (urb->pipe)
                         && !(urb->transfer_flags & URB_NO_SETUP_DMA_MAP))
                         dma_unmap_single (hcd->self.controller, urb->setup_dma,
@@ -955,7 +959,7 @@ int usb_hcd_submit_urb (struct urb *urb, gfp_t mem_flags)
 
         // FIXME:  verify that quiescing hc works right (RH cleans up)
 
-        spin_lock_irqsave (&hcd_data_lock, flags);
+        spin_lock_irqsave(&hcd_urb_list_lock, flags);
         ep = (usb_pipein(urb->pipe) ? urb->dev->ep_in : urb->dev->ep_out)
                         [usb_pipeendpoint(urb->pipe)];
         if (unlikely (!ep))
@@ -972,7 +976,7 @@ int usb_hcd_submit_urb (struct urb *urb, gfp_t mem_flags)
                 status = -ESHUTDOWN;
                 break;
         }
-        spin_unlock_irqrestore (&hcd_data_lock, flags);
+        spin_unlock_irqrestore(&hcd_urb_list_lock, flags);
         if (status) {
                 INIT_LIST_HEAD (&urb->urb_list);
                 usbmon_urb_submit_error(&hcd->self, urb, status);
@@ -986,7 +990,7 @@ int usb_hcd_submit_urb (struct urb *urb, gfp_t mem_flags)
         urb = usb_get_urb (urb);
         atomic_inc (&urb->use_count);
 
-        if (urb->dev == hcd->self.root_hub) {
+        if (is_root_hub(urb->dev)) {
                 /* NOTE:  requirement on hub callers (usbfs and the hub
                  * driver, for now) that URBs' urb->transfer_buffer be
                  * valid and usb_buffer_{sync,unmap}() not be needed, since
@@ -1033,18 +1037,6 @@ done:
 
 /*-------------------------------------------------------------------------*/
 
-/* called in any context */
-int usb_hcd_get_frame_number (struct usb_device *udev)
-{
-        struct usb_hcd  *hcd = bus_to_hcd(udev->bus);
-
-        if (!HC_IS_RUNNING (hcd->state))
-                return -ESHUTDOWN;
-        return hcd->driver->get_frame_number (hcd);
-}
-
-/*-------------------------------------------------------------------------*/
-
 /* this makes the hcd giveback() the urb more quickly, by kicking it
  * off hardware queues (which may take a while) and returning it as
  * soon as practical.  we've already set up the urb's return status,
@@ -1055,7 +1047,7 @@ unlink1 (struct usb_hcd *hcd, struct urb *urb)
 {
         int             value;
 
-        if (urb->dev == hcd->self.root_hub)
+        if (is_root_hub(urb->dev))
                 value = usb_rh_urb_dequeue (hcd, urb);
         else {
 
@@ -1103,11 +1095,11 @@ int usb_hcd_unlink_urb (struct urb *urb, int status)
          * that it was submitted.  But as a rule it can't know whether or
          * not it's already been unlinked ... so we respect the reversed
          * lock sequence needed for the usb_hcd_giveback_urb() code paths
-         * (urb lock, then hcd_data_lock) in case some other CPU is now
+         * (urb lock, then hcd_urb_list_lock) in case some other CPU is now
          * unlinking it.
          */
         spin_lock_irqsave (&urb->lock, flags);
-        spin_lock (&hcd_data_lock);
+        spin_lock(&hcd_urb_list_lock);
 
         sys = &urb->dev->dev;
         hcd = bus_to_hcd(urb->dev->bus);
@@ -1139,17 +1131,16 @@ int usb_hcd_unlink_urb (struct urb *urb, int status)
          * finish unlinking the initial failed usb_set_address()
          * or device descriptor fetch.
          */
-        if (!test_bit(HCD_FLAG_SAW_IRQ, &hcd->flags)
-            && hcd->self.root_hub != urb->dev) {
+        if (!test_bit(HCD_FLAG_SAW_IRQ, &hcd->flags) &&
+                        !is_root_hub(urb->dev)) {
                 dev_warn (hcd->self.controller, "Unlink after no-IRQ?  "
-                        "Controller is probably using the wrong IRQ."
-                        "\n");
+                        "Controller is probably using the wrong IRQ.\n");
                 set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
         }
 
         urb->status = status;
 
-        spin_unlock (&hcd_data_lock);
+        spin_unlock(&hcd_urb_list_lock);
         spin_unlock_irqrestore (&urb->lock, flags);
 
         retval = unlink1 (hcd, urb);
@@ -1158,7 +1149,7 @@ int usb_hcd_unlink_urb (struct urb *urb, int status)
         return retval;
 
 done:
-        spin_unlock (&hcd_data_lock);
+        spin_unlock(&hcd_urb_list_lock);
         spin_unlock_irqrestore (&urb->lock, flags);
         if (retval != -EIDRM && sys && sys->driver)
                 dev_dbg (sys, "hcd_unlink_urb %p fail %d\n", urb, retval);
@@ -1167,6 +1158,35 @@ done:
 
 /*-------------------------------------------------------------------------*/
 
+/**
+ * usb_hcd_giveback_urb - return URB from HCD to device driver
+ * @hcd: host controller returning the URB
+ * @urb: urb being returned to the USB device driver.
+ * Context: in_interrupt()
+ *
+ * This hands the URB from HCD to its USB device driver, using its
+ * completion function.  The HCD has freed all per-urb resources
+ * (and is done using urb->hcpriv).  It also released all HCD locks;
+ * the device driver won't cause problems if it frees, modifies,
+ * or resubmits this URB.
+ */
+void usb_hcd_giveback_urb (struct usb_hcd *hcd, struct urb *urb)
+{
+        urb_unlink(hcd, urb);
+        usbmon_urb_complete (&hcd->self, urb);
+        usb_unanchor_urb(urb);
+
+        /* pass ownership to the completion handler */
+        urb->complete (urb);
+        atomic_dec (&urb->use_count);
+        if (unlikely (urb->reject))
+                wake_up (&usb_kill_urb_queue);
+        usb_put_urb (urb);
+}
+EXPORT_SYMBOL (usb_hcd_giveback_urb);
+
+/*-------------------------------------------------------------------------*/
+
 /* disables the endpoint: cancels any pending urbs, then synchronizes with
  * the hcd to make sure all endpoint state is gone from hardware, and then
  * waits until the endpoint's queue is completely drained. use for
@@ -1186,7 +1206,7 @@ void usb_hcd_endpoint_disable (struct usb_device *udev,
 
         /* ep is already gone from udev->ep_{in,out}[]; no more submits */
 rescan:
-        spin_lock (&hcd_data_lock);
+        spin_lock(&hcd_urb_list_lock);
         list_for_each_entry (urb, &ep->urb_list, urb_list) {
                 int     tmp;
 
@@ -1194,7 +1214,7 @@ rescan:
                 if (urb->status != -EINPROGRESS)
                         continue;
                 usb_get_urb (urb);
-                spin_unlock (&hcd_data_lock);
+                spin_unlock(&hcd_urb_list_lock);
 
                 spin_lock (&urb->lock);
                 tmp = urb->status;
@@ -1223,7 +1243,7 @@ rescan:
                 /* list contents may have changed */
                 goto rescan;
         }
-        spin_unlock (&hcd_data_lock);
+        spin_unlock(&hcd_urb_list_lock);
         local_irq_enable ();
 
         /* synchronize with the hardware, so old configuration state
@@ -1240,7 +1260,7 @@ rescan:
          * endpoint_disable methods.
          */
         while (!list_empty (&ep->urb_list)) {
-                spin_lock_irq (&hcd_data_lock);
+                spin_lock_irq(&hcd_urb_list_lock);
 
                 /* The list may have changed while we acquired the spinlock */
                 urb = NULL;
@@ -1249,7 +1269,7 @@ rescan:
                                         urb_list);
                         usb_get_urb (urb);
                 }
-                spin_unlock_irq (&hcd_data_lock);
+                spin_unlock_irq(&hcd_urb_list_lock);
 
                 if (urb) {
                         usb_kill_urb (urb);
@@ -1260,6 +1280,18 @@ rescan:
 
 /*-------------------------------------------------------------------------*/
 
+/* called in any context */
+int usb_hcd_get_frame_number (struct usb_device *udev)
+{
+        struct usb_hcd  *hcd = bus_to_hcd(udev->bus);
+
+        if (!HC_IS_RUNNING (hcd->state))
+                return -ESHUTDOWN;
+        return hcd->driver->get_frame_number (hcd);
+}
+
+/*-------------------------------------------------------------------------*/
+
 #ifdef  CONFIG_PM
 
 int hcd_bus_suspend(struct usb_device *rhdev)
@@ -1395,35 +1427,6 @@ EXPORT_SYMBOL (usb_bus_start_enum);
 /*-------------------------------------------------------------------------*/
 
 /**
- * usb_hcd_giveback_urb - return URB from HCD to device driver
- * @hcd: host controller returning the URB
- * @urb: urb being returned to the USB device driver.
- * Context: in_interrupt()
- *
- * This hands the URB from HCD to its USB device driver, using its
- * completion function.  The HCD has freed all per-urb resources
- * (and is done using urb->hcpriv).  It also released all HCD locks;
- * the device driver won't cause problems if it frees, modifies,
- * or resubmits this URB.
- */
-void usb_hcd_giveback_urb (struct usb_hcd *hcd, struct urb *urb)
-{
-        urb_unlink(hcd, urb);
-        usbmon_urb_complete (&hcd->self, urb);
-        usb_unanchor_urb(urb);
-
-        /* pass ownership to the completion handler */
-        urb->complete (urb);
-        atomic_dec (&urb->use_count);
-        if (unlikely (urb->reject))
-                wake_up (&usb_kill_urb_queue);
-        usb_put_urb (urb);
-}
-EXPORT_SYMBOL (usb_hcd_giveback_urb);
-
-/*-------------------------------------------------------------------------*/
-
-/**
  * usb_hcd_irq - hook IRQs to HCD framework (bus glue)
  * @irq: the IRQ being raised
  * @__hcd: pointer to the HCD whose IRQ is being signaled
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index fd74c50b1804..e341a1da517f 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -1335,6 +1335,10 @@ int usb_new_device(struct usb_device *udev)
         udev->dev.devt = MKDEV(USB_DEVICE_MAJOR,
                         (((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
 
+        /* Increment the parent's count of unsuspended children */
+        if (udev->parent)
+                usb_autoresume_device(udev->parent);
+
         /* Register the device.  The device driver is responsible
          * for adding the device files to sysfs and for configuring
          * the device.
@@ -1342,13 +1346,11 @@ int usb_new_device(struct usb_device *udev)
         err = device_add(&udev->dev);
         if (err) {
                 dev_err(&udev->dev, "can't device_add, error %d\n", err);
+                if (udev->parent)
+                        usb_autosuspend_device(udev->parent);
                 goto fail;
         }
 
-        /* Increment the parent's count of unsuspended children */
-        if (udev->parent)
-                usb_autoresume_device(udev->parent);
-
 exit:
         return err;
 
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index 530e854961ce..25f63f1096b4 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -34,13 +34,14 @@ static int usb_start_wait_urb(struct urb *urb, int timeout, int *actual_length)
 { 
         struct completion done;
         unsigned long expire;
-        int status;
+        int retval;
+        int status = urb->status;
 
         init_completion(&done);         
         urb->context = &done;
         urb->actual_length = 0;
-        status = usb_submit_urb(urb, GFP_NOIO);
-        if (unlikely(status))
+        retval = usb_submit_urb(urb, GFP_NOIO);
+        if (unlikely(retval))
                 goto out;
 
         expire = timeout ? msecs_to_jiffies(timeout) : MAX_SCHEDULE_TIMEOUT;
@@ -55,15 +56,15 @@ static int usb_start_wait_urb(struct urb *urb, int timeout, int *actual_length)
                         urb->transfer_buffer_length);
 
                 usb_kill_urb(urb);
-                status = urb->status == -ENOENT ? -ETIMEDOUT : urb->status;
+                retval = status == -ENOENT ? -ETIMEDOUT : status;
         } else
-                status = urb->status;
+                retval = status;
 out:
         if (actual_length)
                 *actual_length = urb->actual_length;
 
         usb_free_urb(urb);
-        return status;
+        return retval;
 }
 
 /*-------------------------------------------------------------------*/
@@ -250,6 +251,7 @@ static void sg_clean (struct usb_sg_request *io)
 static void sg_complete (struct urb *urb)
 {
         struct usb_sg_request   *io = urb->context;
+        int status = urb->status;
 
         spin_lock (&io->lock);
 
@@ -265,21 +267,21 @@ static void sg_complete (struct urb *urb)
          */
         if (io->status
                         && (io->status != -ECONNRESET
-                                || urb->status != -ECONNRESET)
+                                || status != -ECONNRESET)
                         && urb->actual_length) {
                 dev_err (io->dev->bus->controller,
                         "dev %s ep%d%s scatterlist error %d/%d\n",
                         io->dev->devpath,
                         usb_pipeendpoint (urb->pipe),
                         usb_pipein (urb->pipe) ? "in" : "out",
-                        urb->status, io->status);
+                        status, io->status);
                 // BUG ();
         }
 
-        if (io->status == 0 && urb->status && urb->status != -ECONNRESET) {
-                int             i, found, status;
+        if (io->status == 0 && status && status != -ECONNRESET) {
+                int i, found, retval;
 
-                io->status = urb->status;
+                io->status = status;
 
                 /* the previous urbs, and this one, completed already.
                  * unlink pending urbs so they won't rx/tx bad data.
@@ -290,13 +292,13 @@ static void sg_complete (struct urb *urb)
                         if (!io->urbs [i] || !io->urbs [i]->dev)
                                 continue;
                         if (found) {
-                                status = usb_unlink_urb (io->urbs [i]);
-                                if (status != -EINPROGRESS
-                                                && status != -ENODEV
-                                                && status != -EBUSY)
+                                retval = usb_unlink_urb (io->urbs [i]);
+                                if (retval != -EINPROGRESS &&
+                                    retval != -ENODEV &&
+                                    retval != -EBUSY)
                                         dev_err (&io->dev->dev,
                                                 "%s, unlink --> %d\n",
-                                                __FUNCTION__, status);
+                                                __FUNCTION__, retval);
                         } else if (urb == io->urbs [i])
                                 found = 1;
                 }
diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
index d47ae89154a7..2ab222be8fd1 100644
--- a/drivers/usb/core/sysfs.c
+++ b/drivers/usb/core/sysfs.c
@@ -441,6 +441,54 @@ static struct attribute_group dev_attr_grp = {
         .attrs = dev_attrs,
 };
 
+/* Binary descriptors */
+
+static ssize_t
+read_descriptors(struct kobject *kobj, struct bin_attribute *attr,
+                char *buf, loff_t off, size_t count)
+{
+        struct usb_device *udev = to_usb_device(
+                        container_of(kobj, struct device, kobj));
+        size_t nleft = count;
+        size_t srclen, n;
+
+        usb_lock_device(udev);
+
+        /* The binary attribute begins with the device descriptor */
+        srclen = sizeof(struct usb_device_descriptor);
+        if (off < srclen) {
+                n = min_t(size_t, nleft, srclen - off);
+                memcpy(buf, off + (char *) &udev->descriptor, n);
+                nleft -= n;
+                buf += n;
+                off = 0;
+        } else {
+                off -= srclen;
+        }
+
+        /* Then follows the raw descriptor entry for the current
+         * configuration (config plus subsidiary descriptors).
+         */
+        if (udev->actconfig) {
+                int cfgno = udev->actconfig - udev->config;
+
+                srclen = __le16_to_cpu(udev->actconfig->desc.wTotalLength);
+                if (off < srclen) {
+                        n = min_t(size_t, nleft, srclen - off);
+                        memcpy(buf, off + udev->rawdescriptors[cfgno], n);
+                        nleft -= n;
+                }
+        }
+        usb_unlock_device(udev);
+        return count - nleft;
+}
+
+static struct bin_attribute dev_bin_attr_descriptors = {
+        .attr = {.name = "descriptors", .mode = 0444},
+        .read = read_descriptors,
+        .size = 18 + 65535,     /* dev descr + max-size raw descriptor */
+};
+
 int usb_create_sysfs_dev_files(struct usb_device *udev)
 {
         struct device *dev = &udev->dev;
@@ -450,6 +498,10 @@ int usb_create_sysfs_dev_files(struct usb_device *udev)
         if (retval)
                 return retval;
 
+        retval = device_create_bin_file(dev, &dev_bin_attr_descriptors);
+        if (retval)
+                goto error;
+
         retval = add_persist_attributes(dev);
         if (retval)
                 goto error;
@@ -492,6 +544,7 @@ void usb_remove_sysfs_dev_files(struct usb_device *udev)
         device_remove_file(dev, &dev_attr_serial);
         remove_power_attributes(dev);
         remove_persist_attributes(dev);
+        device_remove_bin_file(dev, &dev_bin_attr_descriptors);
         sysfs_remove_group(&dev->kobj, &dev_attr_grp);
 }
 
diff --git a/drivers/usb/core/urb.c b/drivers/usb/core/urb.c
index 52ec44b828f3..be630228461c 100644
--- a/drivers/usb/core/urb.c
+++ b/drivers/usb/core/urb.c
@@ -440,55 +440,57 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
  * @urb: pointer to urb describing a previously submitted request,
  *      may be NULL
  *
- * This routine cancels an in-progress request.  URBs complete only
- * once per submission, and may be canceled only once per submission.
- * Successful cancellation means the requests's completion handler will
- * be called with a status code indicating that the request has been
- * canceled (rather than any other code) and will quickly be removed
- * from host controller data structures.
- *
- * This request is always asynchronous.
- * Success is indicated by returning -EINPROGRESS,
- * at which time the URB will normally have been unlinked but not yet
- * given back to the device driver.  When it is called, the completion
- * function will see urb->status == -ECONNRESET.  Failure is indicated
- * by any other return value.  Unlinking will fail when the URB is not
- * currently "linked" (i.e., it was never submitted, or it was unlinked
- * before, or the hardware is already finished with it), even if the
- * completion handler has not yet run.
+ * This routine cancels an in-progress request.  URBs complete only once
+ * per submission, and may be canceled only once per submission.
+ * Successful cancellation means termination of @urb will be expedited
+ * and the completion handler will be called with a status code
+ * indicating that the request has been canceled (rather than any other
+ * code).
+ *
+ * This request is always asynchronous.  Success is indicated by
+ * returning -EINPROGRESS, at which time the URB will probably not yet
+ * have been given back to the device driver.  When it is eventually
+ * called, the completion function will see @urb->status == -ECONNRESET.
+ * Failure is indicated by usb_unlink_urb() returning any other value.
+ * Unlinking will fail when @urb is not currently "linked" (i.e., it was
+ * never submitted, or it was unlinked before, or the hardware is already
+ * finished with it), even if the completion handler has not yet run.
  *
  * Unlinking and Endpoint Queues:
  *
+ * [The behaviors and guarantees described below do not apply to virtual
+ * root hubs but only to endpoint queues for physical USB devices.]
+ *
  * Host Controller Drivers (HCDs) place all the URBs for a particular
  * endpoint in a queue.  Normally the queue advances as the controller
  * hardware processes each request.  But when an URB terminates with an
- * error its queue stops, at least until that URB's completion routine
- * returns.  It is guaranteed that the queue will not restart until all
- * its unlinked URBs have been fully retired, with their completion
- * routines run, even if that's not until some time after the original
- * completion handler returns.  Normally the same behavior and guarantees
- * apply when an URB terminates because it was unlinked; however if an
- * URB is unlinked before the hardware has started to execute it, then
- * its queue is not guaranteed to stop until all the preceding URBs have
- * completed.
- *
- * This means that USB device drivers can safely build deep queues for
- * large or complex transfers, and clean them up reliably after any sort
- * of aborted transfer by unlinking all pending URBs at the first fault.
- *
- * Note that an URB terminating early because a short packet was received
- * will count as an error if and only if the URB_SHORT_NOT_OK flag is set.
- * Also, that all unlinks performed in any URB completion handler must
- * be asynchronous.
- *
- * Queues for isochronous endpoints are treated differently, because they
- * advance at fixed rates.  Such queues do not stop when an URB is unlinked.
- * An unlinked URB may leave a gap in the stream of packets.  It is undefined
- * whether such gaps can be filled in.
- *
- * When a control URB terminates with an error, it is likely that the
- * status stage of the transfer will not take place, even if it is merely
- * a soft error resulting from a short-packet with URB_SHORT_NOT_OK set.
+ * error its queue generally stops (see below), at least until that URB's
+ * completion routine returns.  It is guaranteed that a stopped queue
+ * will not restart until all its unlinked URBs have been fully retired,
+ * with their completion routines run, even if that's not until some time
+ * after the original completion handler returns.  The same behavior and
+ * guarantee apply when an URB terminates because it was unlinked.
+ *
+ * Bulk and interrupt endpoint queues are guaranteed to stop whenever an
+ * URB terminates with any sort of error, including -ECONNRESET, -ENOENT,
+ * and -EREMOTEIO.  Control endpoint queues behave the same way except
+ * that they are not guaranteed to stop for -EREMOTEIO errors.  Queues
+ * for isochronous endpoints are treated differently, because they must
+ * advance at fixed rates.  Such queues do not stop when an URB
+ * encounters an error or is unlinked.  An unlinked isochronous URB may
+ * leave a gap in the stream of packets; it is undefined whether such
+ * gaps can be filled in.
+ *
+ * Note that early termination of an URB because a short packet was
+ * received will generate a -EREMOTEIO error if and only if the
+ * URB_SHORT_NOT_OK flag is set.  By setting this flag, USB device
+ * drivers can build deep queues for large or complex bulk transfers
+ * and clean them up reliably after any sort of aborted transfer by
+ * unlinking all pending URBs at the first fault.
+ *
+ * When a control URB terminates with an error other than -EREMOTEIO, it
+ * is quite likely that the status stage of the transfer will not take
+ * place.
  */
 int usb_unlink_urb(struct urb *urb)
 {
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index 45e01e289455..767aed5b4bea 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -82,6 +82,27 @@ choice
            Many controller drivers are platform-specific; these
            often need board-specific hooks.
 
+config USB_GADGET_AMD5536UDC
+        boolean "AMD5536 UDC"
+        depends on PCI
+        select USB_GADGET_DUALSPEED
+        help
+           The AMD5536 UDC is part of the AMD Geode CS5536, an x86 southbridge.
+           It is a USB Highspeed DMA capable USB device controller. Beside ep0
+           it provides 4 IN and 4 OUT endpoints (bulk or interrupt type).
+           The UDC port supports OTG operation, and may be used as a host port
+           if it's not being used to implement peripheral or OTG roles.
+
+           Say "y" to link the driver statically, or "m" to build a
+           dynamically linked module called "amd5536udc" and force all
+           gadget drivers to also be dynamically linked.
+
+config USB_AMD5536UDC
+        tristate
+        depends on USB_GADGET_AMD5536UDC
+        default USB_GADGET
+        select USB_GADGET_SELECTED
+
 config USB_GADGET_FSL_USB2
         boolean "Freescale Highspeed USB DR Peripheral Controller"
         depends on MPC834x || PPC_MPC831x
@@ -156,6 +177,24 @@ config USB_PXA2XX_SMALL
         default y if USB_ETH
         default y if USB_G_SERIAL
 
+config USB_GADGET_M66592
+        boolean "Renesas M66592 USB Peripheral Controller"
+        select USB_GADGET_DUALSPEED
+        help
+           M66592 is a discrete USB peripheral controller chip that
+           supports both full and high speed USB 2.0 data transfers.
+           It has seven configurable endpoints, and endpoint zero.
+
+           Say "y" to link the driver statically, or "m" to build a
+           dynamically linked module called "m66592_udc" and force all
+           gadget drivers to also be dynamically linked.
+
+config USB_M66592
+        tristate
+        depends on USB_GADGET_M66592
+        default USB_GADGET
+        select USB_GADGET_SELECTED
+
 config USB_GADGET_GOKU
         boolean "Toshiba TC86C001 'Goku-S'"
         depends on PCI
@@ -261,24 +300,6 @@ config USB_AT91
         depends on USB_GADGET_AT91
         default USB_GADGET
 
-config USB_GADGET_M66592
-        boolean "M66592 driver"
-        select USB_GADGET_DUALSPEED
-        help
-           M66592 is a USB 2.0 peripheral controller.
-
-           It has seven configurable endpoints, and endpoint zero.
-
-           Say "y" to link the driver statically, or "m" to build a
-           dynamically linked module called "m66592_udc" and force all
-           gadget drivers to also be dynamically linked.
-
-config USB_M66592
-        tristate
-        depends on USB_GADGET_M66592
-        default USB_GADGET
-        select USB_GADGET_SELECTED
-
 config USB_GADGET_DUMMY_HCD
         boolean "Dummy HCD (DEVELOPMENT)"
         depends on (USB=y || (USB=m && USB_GADGET=m)) && EXPERIMENTAL
diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
index 8ae76f738635..1bc0f03550ce 100644
--- a/drivers/usb/gadget/Makefile
+++ b/drivers/usb/gadget/Makefile
@@ -7,6 +7,7 @@ endif
 
 obj-$(CONFIG_USB_DUMMY_HCD)     += dummy_hcd.o
 obj-$(CONFIG_USB_NET2280)       += net2280.o
+obj-$(CONFIG_USB_AMD5536UDC)    += amd5536udc.o
 obj-$(CONFIG_USB_PXA2XX)        += pxa2xx_udc.o
 obj-$(CONFIG_USB_GOKU)          += goku_udc.o
 obj-$(CONFIG_USB_OMAP)          += omap_udc.o
diff --git a/drivers/usb/gadget/amd5536udc.c b/drivers/usb/gadget/amd5536udc.c
new file mode 100644
index 000000000000..714156ca8fe4
--- /dev/null
+++ b/drivers/usb/gadget/amd5536udc.c
@@ -0,0 +1,3454 @@
+/*
+ * amd5536.c -- AMD 5536 UDC high/full speed USB device controller
+ *
+ * Copyright (C) 2005-2007 AMD (http://www.amd.com)
+ * Author: Thomas Dahlmann
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+/*
+ * The AMD5536 UDC is part of the x86 southbridge AMD Geode CS5536.
+ * It is a USB Highspeed DMA capable USB device controller. Beside ep0 it
+ * provides 4 IN and 4 OUT endpoints (bulk or interrupt type).
+ *
+ * Make sure that UDC is assigned to port 4 by BIOS settings (port can also
+ * be used as host port) and UOC bits PAD_EN and APU are set (should be done
+ * by BIOS init).
+ *
+ * UDC DMA requires 32-bit aligned buffers so DMA with gadget ether does not
+ * work without updating NET_IP_ALIGN. Or PIO mode (module param "use_dma=0")
+ * can be used with gadget ether.
+ */
+
+/* debug control */
+/* #define UDC_VERBOSE */
+
+/* Driver strings */
+#define UDC_MOD_DESCRIPTION             "AMD 5536 UDC - USB Device Controller"
+#define UDC_DRIVER_VERSION_STRING       "01.00.0206 - $Revision: #3 $"
+
+/* system */
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/kernel.h>
+#include <linux/version.h>
+#include <linux/delay.h>
+#include <linux/ioport.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/smp_lock.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/timer.h>
+#include <linux/list.h>
+#include <linux/interrupt.h>
+#include <linux/ioctl.h>
+#include <linux/fs.h>
+#include <linux/dmapool.h>
+#include <linux/moduleparam.h>
+#include <linux/device.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+
+#include <asm/byteorder.h>
+#include <asm/system.h>
+#include <asm/unaligned.h>
+
+/* gadget stack */
+#include <linux/usb/ch9.h>
+#include <linux/usb_gadget.h>
+
+/* udc specific */
+#include "amd5536udc.h"
+
+
+static void udc_tasklet_disconnect(unsigned long);
+static void empty_req_queue(struct udc_ep *);
+static int udc_probe(struct udc *dev);
+static void udc_basic_init(struct udc *dev);
+static void udc_setup_endpoints(struct udc *dev);
+static void udc_soft_reset(struct udc *dev);
+static struct udc_request *udc_alloc_bna_dummy(struct udc_ep *ep);
+static void udc_free_request(struct usb_ep *usbep, struct usb_request *usbreq);
+static int udc_free_dma_chain(struct udc *dev, struct udc_request *req);
+static int udc_create_dma_chain(struct udc_ep *ep, struct udc_request *req,
+                                unsigned long buf_len, gfp_t gfp_flags);
+static int udc_remote_wakeup(struct udc *dev);
+static int udc_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id);
+static void udc_pci_remove(struct pci_dev *pdev);
+
+/* description */
+static const char mod_desc[] = UDC_MOD_DESCRIPTION;
+static const char name[] = "amd5536udc";
+
+/* structure to hold endpoint function pointers */
+static const struct usb_ep_ops udc_ep_ops;
+
+/* received setup data */
+static union udc_setup_data setup_data;
+
+/* pointer to device object */
+static struct udc *udc;
+
+/* irq spin lock for soft reset */
+static DEFINE_SPINLOCK(udc_irq_spinlock);
+/* stall spin lock */
+static DEFINE_SPINLOCK(udc_stall_spinlock);
+
+/*
+* slave mode: pending bytes in rx fifo after nyet,
+* used if EPIN irq came but no req was available
+*/
+static unsigned int udc_rxfifo_pending;
+
+/* count soft resets after suspend to avoid loop */
+static int soft_reset_occured;
+static int soft_reset_after_usbreset_occured;
+
+/* timer */
+static struct timer_list udc_timer;
+static int stop_timer;
+
+/* set_rde -- Is used to control enabling of RX DMA. Problem is
+ * that UDC has only one bit (RDE) to enable/disable RX DMA for
+ * all OUT endpoints. So we have to handle race conditions like
+ * when OUT data reaches the fifo but no request was queued yet.
+ * This cannot be solved by letting the RX DMA disabled until a
+ * request gets queued because there may be other OUT packets
+ * in the FIFO (important for not blocking control traffic).
+ * The value of set_rde controls the correspondig timer.
+ *
+ * set_rde -1 == not used, means it is alloed to be set to 0 or 1
+ * set_rde  0 == do not touch RDE, do no start the RDE timer
+ * set_rde  1 == timer function will look whether FIFO has data
+ * set_rde  2 == set by timer function to enable RX DMA on next call
+ */
+static int set_rde = -1;
+
+static DECLARE_COMPLETION(on_exit);
+static struct timer_list udc_pollstall_timer;
+static int stop_pollstall_timer;
+static DECLARE_COMPLETION(on_pollstall_exit);
+
+/* tasklet for usb disconnect */
+static DECLARE_TASKLET(disconnect_tasklet, udc_tasklet_disconnect,
+                (unsigned long) &udc);
+
+
+/* endpoint names used for print */
+static const char ep0_string[] = "ep0in";
+static const char *ep_string[] = {
+        ep0_string,
+        "ep1in-int", "ep2in-bulk", "ep3in-bulk", "ep4in-bulk", "ep5in-bulk",
+        "ep6in-bulk", "ep7in-bulk", "ep8in-bulk", "ep9in-bulk", "ep10in-bulk",
+        "ep11in-bulk", "ep12in-bulk", "ep13in-bulk", "ep14in-bulk",
+        "ep15in-bulk", "ep0out", "ep1out-bulk", "ep2out-bulk", "ep3out-bulk",
+        "ep4out-bulk", "ep5out-bulk", "ep6out-bulk", "ep7out-bulk",
+        "ep8out-bulk", "ep9out-bulk", "ep10out-bulk", "ep11out-bulk",
+        "ep12out-bulk", "ep13out-bulk", "ep14out-bulk", "ep15out-bulk"
+};
+
+/* DMA usage flag */
+static int use_dma = 1;
+/* packet per buffer dma */
+static int use_dma_ppb = 1;
+/* with per descr. update */
+static int use_dma_ppb_du;
+/* buffer fill mode */
+static int use_dma_bufferfill_mode;
+/* full speed only mode */
+static int use_fullspeed;
+/* tx buffer size for high speed */
+static unsigned long hs_tx_buf = UDC_EPIN_BUFF_SIZE;
+
+/* module parameters */
+module_param(use_dma, bool, S_IRUGO);
+MODULE_PARM_DESC(use_dma, "true for DMA");
+module_param(use_dma_ppb, bool, S_IRUGO);
+MODULE_PARM_DESC(use_dma_ppb, "true for DMA in packet per buffer mode");
+module_param(use_dma_ppb_du, bool, S_IRUGO);
+MODULE_PARM_DESC(use_dma_ppb_du,
+        "true for DMA in packet per buffer mode with descriptor update");
+module_param(use_fullspeed, bool, S_IRUGO);
+MODULE_PARM_DESC(use_fullspeed, "true for fullspeed only");
+
+/*---------------------------------------------------------------------------*/
+/* Prints UDC device registers and endpoint irq registers */
+static void print_regs(struct udc *dev)
+{
+        DBG(dev, "------- Device registers -------\n");
+        DBG(dev, "dev config     = %08x\n", readl(&dev->regs->cfg));
+        DBG(dev, "dev control    = %08x\n", readl(&dev->regs->ctl));
+        DBG(dev, "dev status     = %08x\n", readl(&dev->regs->sts));
+        DBG(dev, "\n");
+        DBG(dev, "dev int's      = %08x\n", readl(&dev->regs->irqsts));
+        DBG(dev, "dev intmask    = %08x\n", readl(&dev->regs->irqmsk));
+        DBG(dev, "\n");
+        DBG(dev, "dev ep int's   = %08x\n", readl(&dev->regs->ep_irqsts));
+        DBG(dev, "dev ep intmask = %08x\n", readl(&dev->regs->ep_irqmsk));
+        DBG(dev, "\n");
+        DBG(dev, "USE DMA        = %d\n", use_dma);
+        if (use_dma && use_dma_ppb && !use_dma_ppb_du) {
+                DBG(dev, "DMA mode       = PPBNDU (packet per buffer "
+                        "WITHOUT desc. update)\n");
+                dev_info(&dev->pdev->dev, "DMA mode (%s)\n", "PPBNDU");
+        } else if (use_dma && use_dma_ppb_du && use_dma_ppb_du) {
+                DBG(dev, "DMA mode       = PPBDU (packet per buffer "
+                        "WITH desc. update)\n");
+                dev_info(&dev->pdev->dev, "DMA mode (%s)\n", "PPBDU");
+        }
+        if (use_dma && use_dma_bufferfill_mode) {
+                DBG(dev, "DMA mode       = BF (buffer fill mode)\n");
+                dev_info(&dev->pdev->dev, "DMA mode (%s)\n", "BF");
+        }
+        if (!use_dma) {
+                dev_info(&dev->pdev->dev, "FIFO mode\n");
+        }
+        DBG(dev, "-------------------------------------------------------\n");
+}
+
+/* Masks unused interrupts */
+static int udc_mask_unused_interrupts(struct udc *dev)
+{
+        u32 tmp;
+
+        /* mask all dev interrupts */
+        tmp =   AMD_BIT(UDC_DEVINT_SVC) |
+                AMD_BIT(UDC_DEVINT_ENUM) |
+                AMD_BIT(UDC_DEVINT_US) |
+                AMD_BIT(UDC_DEVINT_UR) |
+                AMD_BIT(UDC_DEVINT_ES) |
+                AMD_BIT(UDC_DEVINT_SI) |
+                AMD_BIT(UDC_DEVINT_SOF)|
+                AMD_BIT(UDC_DEVINT_SC);
+        writel(tmp, &dev->regs->irqmsk);
+
+        /* mask all ep interrupts */
+        writel(UDC_EPINT_MSK_DISABLE_ALL, &dev->regs->ep_irqmsk);
+
+        return 0;
+}
+
+/* Enables endpoint 0 interrupts */
+static int udc_enable_ep0_interrupts(struct udc *dev)
+{
+        u32 tmp;
+
+        DBG(dev, "udc_enable_ep0_interrupts()\n");
+
+        /* read irq mask */
+        tmp = readl(&dev->regs->ep_irqmsk);
+        /* enable ep0 irq's */
+        tmp &= AMD_UNMASK_BIT(UDC_EPINT_IN_EP0)
+                & AMD_UNMASK_BIT(UDC_EPINT_OUT_EP0);
+        writel(tmp, &dev->regs->ep_irqmsk);
+
+        return 0;
+}
+
+/* Enables device interrupts for SET_INTF and SET_CONFIG */
+static int udc_enable_dev_setup_interrupts(struct udc *dev)
+{
+        u32 tmp;
+
+        DBG(dev, "enable device interrupts for setup data\n");
+
+        /* read irq mask */
+        tmp = readl(&dev->regs->irqmsk);
+
+        /* enable SET_INTERFACE, SET_CONFIG and other needed irq's */
+        tmp &= AMD_UNMASK_BIT(UDC_DEVINT_SI)
+                & AMD_UNMASK_BIT(UDC_DEVINT_SC)
+                & AMD_UNMASK_BIT(UDC_DEVINT_UR)
+                & AMD_UNMASK_BIT(UDC_DEVINT_SVC)
+                & AMD_UNMASK_BIT(UDC_DEVINT_ENUM);
+        writel(tmp, &dev->regs->irqmsk);
+
+        return 0;
+}
+
+/* Calculates fifo start of endpoint based on preceeding endpoints */
+static int udc_set_txfifo_addr(struct udc_ep *ep)
+{
+        struct udc      *dev;
+        u32 tmp;
+        int i;
+
+        if (!ep || !(ep->in))
+                return -EINVAL;
+
+        dev = ep->dev;
+        ep->txfifo = dev->txfifo;
+
+        /* traverse ep's */
+        for (i = 0; i < ep->num; i++) {
+                if (dev->ep[i].regs) {
+                        /* read fifo size */
+                        tmp = readl(&dev->ep[i].regs->bufin_framenum);
+                        tmp = AMD_GETBITS(tmp, UDC_EPIN_BUFF_SIZE);
+                        ep->txfifo += tmp;
+                }
+        }
+        return 0;
+}
+
+/* CNAK pending field: bit0 = ep0in, bit16 = ep0out */
+static u32 cnak_pending;
+
+static void UDC_QUEUE_CNAK(struct udc_ep *ep, unsigned num)
+{
+        if (readl(&ep->regs->ctl) & AMD_BIT(UDC_EPCTL_NAK)) {
+                DBG(ep->dev, "NAK could not be cleared for ep%d\n", num);
+                cnak_pending |= 1 << (num);
+                ep->naking = 1;
+        } else
+                cnak_pending = cnak_pending & (~(1 << (num)));
+}
+
+
+/* Enables endpoint, is called by gadget driver */
+static int
+udc_ep_enable(struct usb_ep *usbep, const struct usb_endpoint_descriptor *desc)
+{
+        struct udc_ep           *ep;
+        struct udc              *dev;
+        u32                     tmp;
+        unsigned long           iflags;
+        u8 udc_csr_epix;
+
+        if (!usbep
+                        || usbep->name == ep0_string
+                        || !desc
+                        || desc->bDescriptorType != USB_DT_ENDPOINT)
+                return -EINVAL;
+
+        ep = container_of(usbep, struct udc_ep, ep);
+        dev = ep->dev;
+
+        DBG(dev, "udc_ep_enable() ep %d\n", ep->num);
+
+        if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
+                return -ESHUTDOWN;
+
+        spin_lock_irqsave(&dev->lock, iflags);
+        ep->desc = desc;
+
+        ep->halted = 0;
+
+        /* set traffic type */
+        tmp = readl(&dev->ep[ep->num].regs->ctl);
+        tmp = AMD_ADDBITS(tmp, desc->bmAttributes, UDC_EPCTL_ET);
+        writel(tmp, &dev->ep[ep->num].regs->ctl);
+
+        /* set max packet size */
+        tmp = readl(&dev->ep[ep->num].regs->bufout_maxpkt);
+        tmp = AMD_ADDBITS(tmp, desc->wMaxPacketSize, UDC_EP_MAX_PKT_SIZE);
+        ep->ep.maxpacket = desc->wMaxPacketSize;
+        writel(tmp, &dev->ep[ep->num].regs->bufout_maxpkt);
+
+        /* IN ep */
+        if (ep->in) {
+
+                /* ep ix in UDC CSR register space */
+                udc_csr_epix = ep->num;
+
+                /* set buffer size (tx fifo entries) */
+                tmp = readl(&dev->ep[ep->num].regs->bufin_framenum);
+                /* double buffering: fifo size = 2 x max packet size */
+                tmp = AMD_ADDBITS(
+                                tmp,
+                                desc->wMaxPacketSize * UDC_EPIN_BUFF_SIZE_MULT
+                                                / UDC_DWORD_BYTES,
+                                UDC_EPIN_BUFF_SIZE);
+                writel(tmp, &dev->ep[ep->num].regs->bufin_framenum);
+
+                /* calc. tx fifo base addr */
+                udc_set_txfifo_addr(ep);
+
+                /* flush fifo */
+                tmp = readl(&ep->regs->ctl);
+                tmp |= AMD_BIT(UDC_EPCTL_F);
+                writel(tmp, &ep->regs->ctl);
+
+        /* OUT ep */
+        } else {
+                /* ep ix in UDC CSR register space */
+                udc_csr_epix = ep->num - UDC_CSR_EP_OUT_IX_OFS;
+
+                /* set max packet size UDC CSR  */
+                tmp = readl(&dev->csr->ne[ep->num - UDC_CSR_EP_OUT_IX_OFS]);
+                tmp = AMD_ADDBITS(tmp, desc->wMaxPacketSize,
+                                        UDC_CSR_NE_MAX_PKT);
+                writel(tmp, &dev->csr->ne[ep->num - UDC_CSR_EP_OUT_IX_OFS]);
+
+                if (use_dma && !ep->in) {
+                        /* alloc and init BNA dummy request */
+                        ep->bna_dummy_req = udc_alloc_bna_dummy(ep);
+                        ep->bna_occurred = 0;
+                }
+
+                if (ep->num != UDC_EP0OUT_IX)
+                        dev->data_ep_enabled = 1;
+        }
+
+        /* set ep values */
+        tmp = readl(&dev->csr->ne[udc_csr_epix]);
+        /* max packet */
+        tmp = AMD_ADDBITS(tmp, desc->wMaxPacketSize, UDC_CSR_NE_MAX_PKT);
+        /* ep number */
+        tmp = AMD_ADDBITS(tmp, desc->bEndpointAddress, UDC_CSR_NE_NUM);
+        /* ep direction */
+        tmp = AMD_ADDBITS(tmp, ep->in, UDC_CSR_NE_DIR);
+        /* ep type */
+        tmp = AMD_ADDBITS(tmp, desc->bmAttributes, UDC_CSR_NE_TYPE);
+        /* ep config */
+        tmp = AMD_ADDBITS(tmp, ep->dev->cur_config, UDC_CSR_NE_CFG);
+        /* ep interface */
+        tmp = AMD_ADDBITS(tmp, ep->dev->cur_intf, UDC_CSR_NE_INTF);
+        /* ep alt */
+        tmp = AMD_ADDBITS(tmp, ep->dev->cur_alt, UDC_CSR_NE_ALT);
+        /* write reg */
+        writel(tmp, &dev->csr->ne[udc_csr_epix]);
+
+        /* enable ep irq */
+        tmp = readl(&dev->regs->ep_irqmsk);
+        tmp &= AMD_UNMASK_BIT(ep->num);
+        writel(tmp, &dev->regs->ep_irqmsk);
+
+        /*
+         * clear NAK by writing CNAK
+         * avoid BNA for OUT DMA, don't clear NAK until DMA desc. written
+         */
+        if (!use_dma || ep->in) {
+                tmp = readl(&ep->regs->ctl);
+                tmp |= AMD_BIT(UDC_EPCTL_CNAK);
+                writel(tmp, &ep->regs->ctl);
+                ep->naking = 0;
+                UDC_QUEUE_CNAK(ep, ep->num);
+        }
+        tmp = desc->bEndpointAddress;
+        DBG(dev, "%s enabled\n", usbep->name);
+
+        spin_unlock_irqrestore(&dev->lock, iflags);
+        return 0;
+}
+
+/* Resets endpoint */
+static void ep_init(struct udc_regs __iomem *regs, struct udc_ep *ep)
+{
+        u32             tmp;
+
+        VDBG(ep->dev, "ep-%d reset\n", ep->num);
+        ep->desc = NULL;
+        ep->ep.ops = &udc_ep_ops;
+        INIT_LIST_HEAD(&ep->queue);
+
+        ep->ep.maxpacket = (u16) ~0;
+        /* set NAK */
+        tmp = readl(&ep->regs->ctl);
+        tmp |= AMD_BIT(UDC_EPCTL_SNAK);
+        writel(tmp, &ep->regs->ctl);
+        ep->naking = 1;
+
+        /* disable interrupt */
+        tmp = readl(&regs->ep_irqmsk);
+        tmp |= AMD_BIT(ep->num);
+        writel(tmp, &regs->ep_irqmsk);
+
+        if (ep->in) {
+                /* unset P and IN bit of potential former DMA */
+                tmp = readl(&ep->regs->ctl);
+                tmp &= AMD_UNMASK_BIT(UDC_EPCTL_P);
+                writel(tmp, &ep->regs->ctl);
+
+                tmp = readl(&ep->regs->sts);
+                tmp |= AMD_BIT(UDC_EPSTS_IN);
+                writel(tmp, &ep->regs->sts);
+
+                /* flush the fifo */
+                tmp = readl(&ep->regs->ctl);
+                tmp |= AMD_BIT(UDC_EPCTL_F);
+                writel(tmp, &ep->regs->ctl);
+
+        }
+        /* reset desc pointer */
+        writel(0, &ep->regs->desptr);
+}
+
+/* Disables endpoint, is called by gadget driver */
+static int udc_ep_disable(struct usb_ep *usbep)
+{
+        struct udc_ep   *ep = NULL;
+        unsigned long   iflags;
+
+        if (!usbep)
+                return -EINVAL;
+
+        ep = container_of(usbep, struct udc_ep, ep);
+        if (usbep->name == ep0_string || !ep->desc)
+                return -EINVAL;
+
+        DBG(ep->dev, "Disable ep-%d\n", ep->num);
+
+        spin_lock_irqsave(&ep->dev->lock, iflags);
+        udc_free_request(&ep->ep, &ep->bna_dummy_req->req);
+        empty_req_queue(ep);
+        ep_init(ep->dev->regs, ep);
+        spin_unlock_irqrestore(&ep->dev->lock, iflags);
+
+        return 0;
+}
+
+/* Allocates request packet, called by gadget driver */
+static struct usb_request *
+udc_alloc_request(struct usb_ep *usbep, gfp_t gfp)
+{
+        struct udc_request      *req;
+        struct udc_data_dma     *dma_desc;
+        struct udc_ep   *ep;
+
+        if (!usbep)
+                return NULL;
+
+        ep = container_of(usbep, struct udc_ep, ep);
+
+        VDBG(ep->dev, "udc_alloc_req(): ep%d\n", ep->num);
+        req = kzalloc(sizeof(struct udc_request), gfp);
+        if (!req)
+                return NULL;
+
+        req->req.dma = DMA_DONT_USE;
+        INIT_LIST_HEAD(&req->queue);
+
+        if (ep->dma) {
+                /* ep0 in requests are allocated from data pool here */
+                dma_desc = pci_pool_alloc(ep->dev->data_requests, gfp,
+                                                &req->td_phys);
+                if (!dma_desc) {
+                        kfree(req);
+                        return NULL;
+                }
+
+                VDBG(ep->dev, "udc_alloc_req: req = %p dma_desc = %p, "
+                                "td_phys = %lx\n",
+                                req, dma_desc,
+                                (unsigned long)req->td_phys);
+                /* prevent from using desc. - set HOST BUSY */
+                dma_desc->status = AMD_ADDBITS(dma_desc->status,
+                                                UDC_DMA_STP_STS_BS_HOST_BUSY,
+                                                UDC_DMA_STP_STS_BS);
+                dma_desc->bufptr = __constant_cpu_to_le32(DMA_DONT_USE);
+                req->td_data = dma_desc;
+                req->td_data_last = NULL;
+                req->chain_len = 1;
+        }
+
+        return &req->req;
+}
+
+/* Frees request packet, called by gadget driver */
+static void
+udc_free_request(struct usb_ep *usbep, struct usb_request *usbreq)
+{
+        struct udc_ep   *ep;
+        struct udc_request      *req;
+
+        if (!usbep || !usbreq)
+                return;
+
+        ep = container_of(usbep, struct udc_ep, ep);
+        req = container_of(usbreq, struct udc_request, req);
+        VDBG(ep->dev, "free_req req=%p\n", req);
+        BUG_ON(!list_empty(&req->queue));
+        if (req->td_data) {
+                VDBG(ep->dev, "req->td_data=%p\n", req->td_data);
+
+                /* free dma chain if created */
+                if (req->chain_len > 1) {
+                        udc_free_dma_chain(ep->dev, req);
+                }
+
+                pci_pool_free(ep->dev->data_requests, req->td_data,
+                                                        req->td_phys);
+        }
+        kfree(req);
+}
+
+/* Init BNA dummy descriptor for HOST BUSY and pointing to itself */
+static void udc_init_bna_dummy(struct udc_request *req)
+{
+        if (req) {
+                /* set last bit */
+                req->td_data->status |= AMD_BIT(UDC_DMA_IN_STS_L);
+                /* set next pointer to itself */
+                req->td_data->next = req->td_phys;
+                /* set HOST BUSY */
+                req->td_data->status
+                        = AMD_ADDBITS(req->td_data->status,
+                                        UDC_DMA_STP_STS_BS_DMA_DONE,
+                                        UDC_DMA_STP_STS_BS);
+#ifdef UDC_VERBOSE
+                pr_debug("bna desc = %p, sts = %08x\n",
+                        req->td_data, req->td_data->status);
+#endif
+        }
+}
+
+/* Allocate BNA dummy descriptor */
+static struct udc_request *udc_alloc_bna_dummy(struct udc_ep *ep)
+{
+        struct udc_request *req = NULL;
+        struct usb_request *_req = NULL;
+
+        /* alloc the dummy request */
+        _req = udc_alloc_request(&ep->ep, GFP_ATOMIC);
+        if (_req) {
+                req = container_of(_req, struct udc_request, req);
+                ep->bna_dummy_req = req;
+                udc_init_bna_dummy(req);
+        }
+        return req;
+}
+
+/* Write data to TX fifo for IN packets */
+static void
+udc_txfifo_write(struct udc_ep *ep, struct usb_request *req)
+{
+        u8                      *req_buf;
+        u32                     *buf;
+        int                     i, j;
+        unsigned                bytes = 0;
+        unsigned                remaining = 0;
+
+        if (!req || !ep)
+                return;
+
+        req_buf = req->buf + req->actual;
+        prefetch(req_buf);
+        remaining = req->length - req->actual;
+
+        buf = (u32 *) req_buf;
+
+        bytes = ep->ep.maxpacket;
+        if (bytes > remaining)
+                bytes = remaining;
+
+        /* dwords first */
+        for (i = 0; i < bytes / UDC_DWORD_BYTES; i++) {
+                writel(*(buf + i), ep->txfifo);
+        }
+
+        /* remaining bytes must be written by byte access */
+        for (j = 0; j < bytes % UDC_DWORD_BYTES; j++) {
+                writeb((u8)(*(buf + i) >> (j << UDC_BITS_PER_BYTE_SHIFT)),
+                                                        ep->txfifo);
+        }
+
+        /* dummy write confirm */
+        writel(0, &ep->regs->confirm);
+}
+
+/* Read dwords from RX fifo for OUT transfers */
+static int udc_rxfifo_read_dwords(struct udc *dev, u32 *buf, int dwords)
+{
+        int i;
+
+        VDBG(dev, "udc_read_dwords(): %d dwords\n", dwords);
+
+        for (i = 0; i < dwords; i++) {
+                *(buf + i) = readl(dev->rxfifo);
+        }
+        return 0;
+}
+
+/* Read bytes from RX fifo for OUT transfers */
+static int udc_rxfifo_read_bytes(struct udc *dev, u8 *buf, int bytes)
+{
+        int i, j;
+        u32 tmp;
+
+        VDBG(dev, "udc_read_bytes(): %d bytes\n", bytes);
+
+        /* dwords first */
+        for (i = 0; i < bytes / UDC_DWORD_BYTES; i++) {
+                *((u32 *)(buf + (i<<2))) = readl(dev->rxfifo);
+        }
+
+        /* remaining bytes must be read by byte access */
+        if (bytes % UDC_DWORD_BYTES) {
+                tmp = readl(dev->rxfifo);
+                for (j = 0; j < bytes % UDC_DWORD_BYTES; j++) {
+                        *(buf + (i<<2) + j) = (u8)(tmp & UDC_BYTE_MASK);
+                        tmp = tmp >> UDC_BITS_PER_BYTE;
+                }
+        }
+
+        return 0;
+}
+
+/* Read data from RX fifo for OUT transfers */
+static int
+udc_rxfifo_read(struct udc_ep *ep, struct udc_request *req)
+{
+        u8 *buf;
+        unsigned buf_space;
+        unsigned bytes = 0;
+        unsigned finished = 0;
+
+        /* received number bytes */
+        bytes = readl(&ep->regs->sts);
+        bytes = AMD_GETBITS(bytes, UDC_EPSTS_RX_PKT_SIZE);
+
+        buf_space = req->req.length - req->req.actual;
+        buf = req->req.buf + req->req.actual;
+        if (bytes > buf_space) {
+                if ((buf_space % ep->ep.maxpacket) != 0) {
+                        DBG(ep->dev,
+                                "%s: rx %d bytes, rx-buf space = %d bytesn\n",
+                                ep->ep.name, bytes, buf_space);
+                        req->req.status = -EOVERFLOW;
+                }
+                bytes = buf_space;
+        }
+        req->req.actual += bytes;
+
+        /* last packet ? */
+        if (((bytes % ep->ep.maxpacket) != 0) || (!bytes)
+                || ((req->req.actual == req->req.length) && !req->req.zero))
+                finished = 1;
+
+        /* read rx fifo bytes */
+        VDBG(ep->dev, "ep %s: rxfifo read %d bytes\n", ep->ep.name, bytes);
+        udc_rxfifo_read_bytes(ep->dev, buf, bytes);
+
+        return finished;
+}
+
+/* create/re-init a DMA descriptor or a DMA descriptor chain */
+static int prep_dma(struct udc_ep *ep, struct udc_request *req, gfp_t gfp)
+{
+        int     retval = 0;
+        u32     tmp;
+
+        VDBG(ep->dev, "prep_dma\n");
+        VDBG(ep->dev, "prep_dma ep%d req->td_data=%p\n",
+                        ep->num, req->td_data);
+
+        /* set buffer pointer */
+        req->td_data->bufptr = req->req.dma;
+
+        /* set last bit */
+        req->td_data->status |= AMD_BIT(UDC_DMA_IN_STS_L);
+
+        /* build/re-init dma chain if maxpkt scatter mode, not for EP0 */
+        if (use_dma_ppb) {
+
+                retval = udc_create_dma_chain(ep, req, ep->ep.maxpacket, gfp);
+                if (retval != 0) {
+                        if (retval == -ENOMEM)
+                                DBG(ep->dev, "Out of DMA memory\n");
+                        return retval;
+                }
+                if (ep->in) {
+                        if (req->req.length == ep->ep.maxpacket) {
+                                /* write tx bytes */
+                                req->td_data->status =
+                                        AMD_ADDBITS(req->td_data->status,
+                                                ep->ep.maxpacket,
+                                                UDC_DMA_IN_STS_TXBYTES);
+
+                        }
+                }
+
+        }
+
+        if (ep->in) {
+                VDBG(ep->dev, "IN: use_dma_ppb=%d req->req.len=%d "
+                                "maxpacket=%d ep%d\n",
+                                use_dma_ppb, req->req.length,
+                                ep->ep.maxpacket, ep->num);
+                /*
+                 * if bytes < max packet then tx bytes must
+                 * be written in packet per buffer mode
+                 */
+                if (!use_dma_ppb || req->req.length < ep->ep.maxpacket
+                                || ep->num == UDC_EP0OUT_IX
+                                || ep->num == UDC_EP0IN_IX) {
+                        /* write tx bytes */
+                        req->td_data->status =
+                                AMD_ADDBITS(req->td_data->status,
+                                                req->req.length,
+                                                UDC_DMA_IN_STS_TXBYTES);
+                        /* reset frame num */
+                        req->td_data->status =
+                                AMD_ADDBITS(req->td_data->status,
+                                                0,
+                                                UDC_DMA_IN_STS_FRAMENUM);
+                }
+                /* set HOST BUSY */
+                req->td_data->status =
+                        AMD_ADDBITS(req->td_data->status,
+                                UDC_DMA_STP_STS_BS_HOST_BUSY,
+                                UDC_DMA_STP_STS_BS);
+        } else {
+                VDBG(ep->dev, "OUT set host ready\n");
+                /* set HOST READY */
+                req->td_data->status =
+                        AMD_ADDBITS(req->td_data->status,
+                                UDC_DMA_STP_STS_BS_HOST_READY,
+                                UDC_DMA_STP_STS_BS);
+
+
+                        /* clear NAK by writing CNAK */
+                        if (ep->naking) {
+                                tmp = readl(&ep->regs->ctl);
+                                tmp |= AMD_BIT(UDC_EPCTL_CNAK);
+                                writel(tmp, &ep->regs->ctl);
+                                ep->naking = 0;
+                                UDC_QUEUE_CNAK(ep, ep->num);
+                        }
+
+        }
+
+        return retval;
+}
+
+/* Completes request packet ... caller MUST hold lock */
+static void
+complete_req(struct udc_ep *ep, struct udc_request *req, int sts)
+__releases(ep->dev->lock)
+__acquires(ep->dev->lock)
+{
+        struct udc              *dev;
+        unsigned                halted;
+
+        VDBG(ep->dev, "complete_req(): ep%d\n", ep->num);
+
+        dev = ep->dev;
+        /* unmap DMA */
+        if (req->dma_mapping) {
+                if (ep->in)
+                        pci_unmap_single(dev->pdev,
+                                        req->req.dma,
+                                        req->req.length,
+                                        PCI_DMA_TODEVICE);
+                else
+                        pci_unmap_single(dev->pdev,
+                                        req->req.dma,
+                                        req->req.length,
+                                        PCI_DMA_FROMDEVICE);
+                req->dma_mapping = 0;
+                req->req.dma = DMA_DONT_USE;
+        }
+
+        halted = ep->halted;
+        ep->halted = 1;
+
+        /* set new status if pending */
+        if (req->req.status == -EINPROGRESS)
+                req->req.status = sts;
+
+        /* remove from ep queue */
+        list_del_init(&req->queue);
+
+        VDBG(ep->dev, "req %p => complete %d bytes at %s with sts %d\n",
+                &req->req, req->req.length, ep->ep.name, sts);
+
+        spin_unlock(&dev->lock);
+        req->req.complete(&ep->ep, &req->req);
+        spin_lock(&dev->lock);
+        ep->halted = halted;
+}
+
+/* frees pci pool descriptors of a DMA chain */
+static int udc_free_dma_chain(struct udc *dev, struct udc_request *req)
+{
+
+        int ret_val = 0;
+        struct udc_data_dma     *td;
+        struct udc_data_dma     *td_last = NULL;
+        unsigned int i;
+
+        DBG(dev, "free chain req = %p\n", req);
+
+        /* do not free first desc., will be done by free for request */
+        td_last = req->td_data;
+        td = phys_to_virt(td_last->next);
+
+        for (i = 1; i < req->chain_len; i++) {
+
+                pci_pool_free(dev->data_requests, td,
+                                (dma_addr_t) td_last->next);
+                td_last = td;
+                td = phys_to_virt(td_last->next);
+        }
+
+        return ret_val;
+}
+
+/* Iterates to the end of a DMA chain and returns last descriptor */
+static struct udc_data_dma *udc_get_last_dma_desc(struct udc_request *req)
+{
+        struct udc_data_dma     *td;
+
+        td = req->td_data;
+        while (td && !(td->status & AMD_BIT(UDC_DMA_IN_STS_L))) {
+                td = phys_to_virt(td->next);
+        }
+
+        return td;
+
+}
+
+/* Iterates to the end of a DMA chain and counts bytes received */
+static u32 udc_get_ppbdu_rxbytes(struct udc_request *req)
+{
+        struct udc_data_dma     *td;
+        u32 count;
+
+        td = req->td_data;
+        /* received number bytes */
+        count = AMD_GETBITS(td->status, UDC_DMA_OUT_STS_RXBYTES);
+
+        while (td && !(td->status & AMD_BIT(UDC_DMA_IN_STS_L))) {
+                td = phys_to_virt(td->next);
+                /* received number bytes */
+                if (td) {
+                        count += AMD_GETBITS(td->status,
+                                UDC_DMA_OUT_STS_RXBYTES);
+                }
+        }
+
+        return count;
+
+}
+
+/* Creates or re-inits a DMA chain */
+static int udc_create_dma_chain(
+        struct udc_ep *ep,
+        struct udc_request *req,
+        unsigned long buf_len, gfp_t gfp_flags
+)
+{
+        unsigned long bytes = req->req.length;
+        unsigned int i;
+        dma_addr_t dma_addr;
+        struct udc_data_dma     *td = NULL;
+        struct udc_data_dma     *last = NULL;
+        unsigned long txbytes;
+        unsigned create_new_chain = 0;
+        unsigned len;
+
+        VDBG(ep->dev, "udc_create_dma_chain: bytes=%ld buf_len=%ld\n",
+                        bytes, buf_len);
+        dma_addr = DMA_DONT_USE;
+
+        /* unset L bit in first desc for OUT */
+        if (!ep->in) {
+                req->td_data->status &= AMD_CLEAR_BIT(UDC_DMA_IN_STS_L);
+        }
+
+        /* alloc only new desc's if not already available */
+        len = req->req.length / ep->ep.maxpacket;
+        if (req->req.length % ep->ep.maxpacket) {
+                len++;
+        }
+
+        if (len > req->chain_len) {
+                /* shorter chain already allocated before */
+                if (req->chain_len > 1) {
+                        udc_free_dma_chain(ep->dev, req);
+                }
+                req->chain_len = len;
+                create_new_chain = 1;
+        }
+
+        td = req->td_data;
+        /* gen. required number of descriptors and buffers */
+        for (i = buf_len; i < bytes; i += buf_len) {
+                /* create or determine next desc. */
+                if (create_new_chain) {
+
+                        td = pci_pool_alloc(ep->dev->data_requests,
+                                        gfp_flags, &dma_addr);
+                        if (!td)
+                                return -ENOMEM;
+
+                        td->status = 0;
+                } else if (i == buf_len) {
+                        /* first td */
+                        td = (struct udc_data_dma *) phys_to_virt(
+                                                req->td_data->next);
+                        td->status = 0;
+                } else {
+                        td = (struct udc_data_dma *) phys_to_virt(last->next);
+                        td->status = 0;
+                }
+
+
+                if (td)
+                        td->bufptr = req->req.dma + i; /* assign buffer */
+                else
+                        break;
+
+                /* short packet ? */
+                if ((bytes - i) >= buf_len) {
+                        txbytes = buf_len;
+                } else {
+                        /* short packet */
+                        txbytes = bytes - i;
+                }
+
+                /* link td and assign tx bytes */
+                if (i == buf_len) {
+                        if (create_new_chain) {
+                                req->td_data->next = dma_addr;
+                        } else {
+                                /* req->td_data->next = virt_to_phys(td); */
+                        }
+                        /* write tx bytes */
+                        if (ep->in) {
+                                /* first desc */
+                                req->td_data->status =
+                                        AMD_ADDBITS(req->td_data->status,
+                                                        ep->ep.maxpacket,
+                                                        UDC_DMA_IN_STS_TXBYTES);
+                                /* second desc */
+                                td->status = AMD_ADDBITS(td->status,
+                                                        txbytes,
+                                                        UDC_DMA_IN_STS_TXBYTES);
+                        }
+                } else {
+                        if (create_new_chain) {
+                                last->next = dma_addr;
+                        } else {
+                                /* last->next = virt_to_phys(td); */
+                        }
+                        if (ep->in) {
+                                /* write tx bytes */
+                                td->status = AMD_ADDBITS(td->status,
+                                                        txbytes,
+                                                        UDC_DMA_IN_STS_TXBYTES);
+                        }
+                }
+                last = td;
+        }
+        /* set last bit */
+        if (td) {
+                td->status |= AMD_BIT(UDC_DMA_IN_STS_L);
+                /* last desc. points to itself */
+                req->td_data_last = td;
+        }
+
+        return 0;
+}
+
+/* Enabling RX DMA */
+static void udc_set_rde(struct udc *dev)
+{
+        u32 tmp;
+
+        VDBG(dev, "udc_set_rde()\n");
+        /* stop RDE timer */
+        if (timer_pending(&udc_timer)) {
+                set_rde = 0;
+                mod_timer(&udc_timer, jiffies - 1);
+        }
+        /* set RDE */
+        tmp = readl(&dev->regs->ctl);
+        tmp |= AMD_BIT(UDC_DEVCTL_RDE);
+        writel(tmp, &dev->regs->ctl);
+}
+
+/* Queues a request packet, called by gadget driver */
+static int
+udc_queue(struct usb_ep *usbep, struct usb_request *usbreq, gfp_t gfp)
+{
+        int                     retval = 0;
+        u8                      open_rxfifo = 0;
+        unsigned long           iflags;
+        struct udc_ep           *ep;
+        struct udc_request      *req;
+        struct udc              *dev;
+        u32                     tmp;
+
+        /* check the inputs */
+        req = container_of(usbreq, struct udc_request, req);
+
+        if (!usbep || !usbreq || !usbreq->complete || !usbreq->buf
+                        || !list_empty(&req->queue))
+                return -EINVAL;
+
+        ep = container_of(usbep, struct udc_ep, ep);
+        if (!ep->desc && (ep->num != 0 && ep->num != UDC_EP0OUT_IX))
+                return -EINVAL;
+
+        VDBG(ep->dev, "udc_queue(): ep%d-in=%d\n", ep->num, ep->in);
+        dev = ep->dev;
+
+        if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
+                return -ESHUTDOWN;
+
+        /* map dma (usually done before) */
+        if (ep->dma && usbreq->length != 0
+                        && (usbreq->dma == DMA_DONT_USE || usbreq->dma == 0)) {
+                VDBG(dev, "DMA map req %p\n", req);
+                if (ep->in)
+                        usbreq->dma = pci_map_single(dev->pdev,
+                                                usbreq->buf,
+                                                usbreq->length,
+                                                PCI_DMA_TODEVICE);
+                else
+                        usbreq->dma = pci_map_single(dev->pdev,
+                                                usbreq->buf,
+                                                usbreq->length,
+                                                PCI_DMA_FROMDEVICE);
+                req->dma_mapping = 1;
+        }
+
+        VDBG(dev, "%s queue req %p, len %d req->td_data=%p buf %p\n",
+                        usbep->name, usbreq, usbreq->length,
+                        req->td_data, usbreq->buf);
+
+        spin_lock_irqsave(&dev->lock, iflags);
+        usbreq->actual = 0;
+        usbreq->status = -EINPROGRESS;
+        req->dma_done = 0;
+
+        /* on empty queue just do first transfer */
+        if (list_empty(&ep->queue)) {
+                /* zlp */
+                if (usbreq->length == 0) {
+                        /* IN zlp's are handled by hardware */
+                        complete_req(ep, req, 0);
+                        VDBG(dev, "%s: zlp\n", ep->ep.name);
+                        /*
+                         * if set_config or set_intf is waiting for ack by zlp
+                         * then set CSR_DONE
+                         */
+                        if (dev->set_cfg_not_acked) {
+                                tmp = readl(&dev->regs->ctl);
+                                tmp |= AMD_BIT(UDC_DEVCTL_CSR_DONE);
+                                writel(tmp, &dev->regs->ctl);
+                                dev->set_cfg_not_acked = 0;
+                        }
+                        /* setup command is ACK'ed now by zlp */
+                        if (dev->waiting_zlp_ack_ep0in) {
+                                /* clear NAK by writing CNAK in EP0_IN */
+                                tmp = readl(&dev->ep[UDC_EP0IN_IX].regs->ctl);
+                                tmp |= AMD_BIT(UDC_EPCTL_CNAK);
+                                writel(tmp, &dev->ep[UDC_EP0IN_IX].regs->ctl);
+                                dev->ep[UDC_EP0IN_IX].naking = 0;
+                                UDC_QUEUE_CNAK(&dev->ep[UDC_EP0IN_IX],
+                                                        UDC_EP0IN_IX);
+                                dev->waiting_zlp_ack_ep0in = 0;
+                        }
+                        goto finished;
+                }
+                if (ep->dma) {
+                        retval = prep_dma(ep, req, gfp);
+                        if (retval != 0)
+                                goto finished;
+                        /* write desc pointer to enable DMA */
+                        if (ep->in) {
+                                /* set HOST READY */
+                                req->td_data->status =
+                                        AMD_ADDBITS(req->td_data->status,
+                                                UDC_DMA_IN_STS_BS_HOST_READY,
+                                                UDC_DMA_IN_STS_BS);
+                        }
+
+                        /* disabled rx dma while descriptor update */
+                        if (!ep->in) {
+                                /* stop RDE timer */
+                                if (timer_pending(&udc_timer)) {
+                                        set_rde = 0;
+                                        mod_timer(&udc_timer, jiffies - 1);
+                                }
+                                /* clear RDE */
+                                tmp = readl(&dev->regs->ctl);
+                                tmp &= AMD_UNMASK_BIT(UDC_DEVCTL_RDE);
+                                writel(tmp, &dev->regs->ctl);
+                                open_rxfifo = 1;
+
+                                /*
+                                 * if BNA occurred then let BNA dummy desc.
+                                 * point to current desc.
+                                 */
+                                if (ep->bna_occurred) {
+                                        VDBG(dev, "copy to BNA dummy desc.\n");
+                                        memcpy(ep->bna_dummy_req->td_data,
+                                                req->td_data,
+                                                sizeof(struct udc_data_dma));
+                                }
+                        }
+                        /* write desc pointer */
+                        writel(req->td_phys, &ep->regs->desptr);
+
+                        /* clear NAK by writing CNAK */
+                        if (ep->naking) {
+                                tmp = readl(&ep->regs->ctl);
+                                tmp |= AMD_BIT(UDC_EPCTL_CNAK);
+                                writel(tmp, &ep->regs->ctl);
+                                ep->naking = 0;
+                                UDC_QUEUE_CNAK(ep, ep->num);
+                        }
+
+                        if (ep->in) {
+                                /* enable ep irq */
+                                tmp = readl(&dev->regs->ep_irqmsk);
+                                tmp &= AMD_UNMASK_BIT(ep->num);
+                                writel(tmp, &dev->regs->ep_irqmsk);
+                        }
+                }
+
+        } else if (ep->dma) {
+
+                /*
+                 * prep_dma not used for OUT ep's, this is not possible
+                 * for PPB modes, because of chain creation reasons
+                 */
+                if (ep->in) {
+                        retval = prep_dma(ep, req, gfp);
+                        if (retval != 0)
+                                goto finished;
+                }
+        }
+        VDBG(dev, "list_add\n");
+        /* add request to ep queue */
+        if (req) {
+
+                list_add_tail(&req->queue, &ep->queue);
+
+                /* open rxfifo if out data queued */
+                if (open_rxfifo) {
+                        /* enable DMA */
+                        req->dma_going = 1;
+                        udc_set_rde(dev);
+                        if (ep->num != UDC_EP0OUT_IX)
+                                dev->data_ep_queued = 1;
+                }
+                /* stop OUT naking */
+                if (!ep->in) {
+                        if (!use_dma && udc_rxfifo_pending) {
+                                DBG(dev, "udc_queue(): pending bytes in"
+                                        "rxfifo after nyet\n");
+                                /*
+                                 * read pending bytes afer nyet:
+                                 * referring to isr
+                                 */
+                                if (udc_rxfifo_read(ep, req)) {
+                                        /* finish */
+                                        complete_req(ep, req, 0);
+                                }
+                                udc_rxfifo_pending = 0;
+
+                        }
+                }
+        }
+
+finished:
+        spin_unlock_irqrestore(&dev->lock, iflags);
+        return retval;
+}
+
+/* Empty request queue of an endpoint; caller holds spinlock */
+static void empty_req_queue(struct udc_ep *ep)
+{
+        struct udc_request      *req;
+
+        ep->halted = 1;
+        while (!list_empty(&ep->queue)) {
+                req = list_entry(ep->queue.next,
+                        struct udc_request,
+                        queue);
+                complete_req(ep, req, -ESHUTDOWN);
+        }
+}
+
+/* Dequeues a request packet, called by gadget driver */
+static int udc_dequeue(struct usb_ep *usbep, struct usb_request *usbreq)
+{
+        struct udc_ep           *ep;
+        struct udc_request      *req;
+        unsigned                halted;
+        unsigned long           iflags;
+
+        ep = container_of(usbep, struct udc_ep, ep);
+        if (!usbep || !usbreq || (!ep->desc && (ep->num != 0
+                                && ep->num != UDC_EP0OUT_IX)))
+                return -EINVAL;
+
+        req = container_of(usbreq, struct udc_request, req);
+
+        spin_lock_irqsave(&ep->dev->lock, iflags);
+        halted = ep->halted;
+        ep->halted = 1;
+        /* request in processing or next one */
+        if (ep->queue.next == &req->queue) {
+                if (ep->dma && req->dma_going) {
+                        if (ep->in)
+                                ep->cancel_transfer = 1;
+                        else {
+                                u32 tmp;
+                                u32 dma_sts;
+                                /* stop potential receive DMA */
+                                tmp = readl(&udc->regs->ctl);
+                                writel(tmp & AMD_UNMASK_BIT(UDC_DEVCTL_RDE),
+                                                        &udc->regs->ctl);
+                                /*
+                                 * Cancel transfer later in ISR
+                                 * if descriptor was touched.
+                                 */
+                                dma_sts = AMD_GETBITS(req->td_data->status,
+                                                        UDC_DMA_OUT_STS_BS);
+                                if (dma_sts != UDC_DMA_OUT_STS_BS_HOST_READY)
+                                        ep->cancel_transfer = 1;
+                                else {
+                                        udc_init_bna_dummy(ep->req);
+                                        writel(ep->bna_dummy_req->td_phys,
+                                                &ep->regs->desptr);
+                                }
+                                writel(tmp, &udc->regs->ctl);
+                        }
+                }
+        }
+        complete_req(ep, req, -ECONNRESET);
+        ep->halted = halted;
+
+        spin_unlock_irqrestore(&ep->dev->lock, iflags);
+        return 0;
+}
+
+/* Halt or clear halt of endpoint */
+static int
+udc_set_halt(struct usb_ep *usbep, int halt)
+{
+        struct udc_ep   *ep;
+        u32 tmp;
+        unsigned long iflags;
+        int retval = 0;
+
+        if (!usbep)
+                return -EINVAL;
+
+        pr_debug("set_halt %s: halt=%d\n", usbep->name, halt);
+
+        ep = container_of(usbep, struct udc_ep, ep);
+        if (!ep->desc && (ep->num != 0 && ep->num != UDC_EP0OUT_IX))
+                return -EINVAL;
+        if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
+                return -ESHUTDOWN;
+
+        spin_lock_irqsave(&udc_stall_spinlock, iflags);
+        /* halt or clear halt */
+        if (halt) {
+                if (ep->num == 0)
+                        ep->dev->stall_ep0in = 1;
+                else {
+                        /*
+                         * set STALL
+                         * rxfifo empty not taken into acount
+                         */
+                        tmp = readl(&ep->regs->ctl);
+                        tmp |= AMD_BIT(UDC_EPCTL_S);
+                        writel(tmp, &ep->regs->ctl);
+                        ep->halted = 1;
+
+                        /* setup poll timer */
+                        if (!timer_pending(&udc_pollstall_timer)) {
+                                udc_pollstall_timer.expires = jiffies +
+                                        HZ * UDC_POLLSTALL_TIMER_USECONDS
+                                        / (1000 * 1000);
+                                if (!stop_pollstall_timer) {
+                                        DBG(ep->dev, "start polltimer\n");
+                                        add_timer(&udc_pollstall_timer);
+                                }
+                        }
+                }
+        } else {
+                /* ep is halted by set_halt() before */
+                if (ep->halted) {
+                        tmp = readl(&ep->regs->ctl);
+                        /* clear stall bit */
+                        tmp = tmp & AMD_CLEAR_BIT(UDC_EPCTL_S);
+                        /* clear NAK by writing CNAK */
+                        tmp |= AMD_BIT(UDC_EPCTL_CNAK);
+                        writel(tmp, &ep->regs->ctl);
+                        ep->halted = 0;
+                        UDC_QUEUE_CNAK(ep, ep->num);
+                }
+        }
+        spin_unlock_irqrestore(&udc_stall_spinlock, iflags);
+        return retval;
+}
+
+/* gadget interface */
+static const struct usb_ep_ops udc_ep_ops = {
+        .enable         = udc_ep_enable,
+        .disable        = udc_ep_disable,
+
+        .alloc_request  = udc_alloc_request,
+        .free_request   = udc_free_request,
+
+        .queue          = udc_queue,
+        .dequeue        = udc_dequeue,
+
+        .set_halt       = udc_set_halt,
+        /* fifo ops not implemented */
+};
+
+/*-------------------------------------------------------------------------*/
+
+/* Get frame counter (not implemented) */
+static int udc_get_frame(struct usb_gadget *gadget)
+{
+        return -EOPNOTSUPP;
+}
+
+/* Remote wakeup gadget interface */
+static int udc_wakeup(struct usb_gadget *gadget)
+{
+        struct udc              *dev;
+
+        if (!gadget)
+                return -EINVAL;
+        dev = container_of(gadget, struct udc, gadget);
+        udc_remote_wakeup(dev);
+
+        return 0;
+}
+
+/* gadget operations */
+static const struct usb_gadget_ops udc_ops = {
+        .wakeup         = udc_wakeup,
+        .get_frame      = udc_get_frame,
+};
+
+/* Setups endpoint parameters, adds endpoints to linked list */
+static void make_ep_lists(struct udc *dev)
+{
+        /* make gadget ep lists */
+        INIT_LIST_HEAD(&dev->gadget.ep_list);
+        list_add_tail(&dev->ep[UDC_EPIN_STATUS_IX].ep.ep_list,
+                                                &dev->gadget.ep_list);
+        list_add_tail(&dev->ep[UDC_EPIN_IX].ep.ep_list,
+                                                &dev->gadget.ep_list);
+        list_add_tail(&dev->ep[UDC_EPOUT_IX].ep.ep_list,
+                                                &dev->gadget.ep_list);
+
+        /* fifo config */
+        dev->ep[UDC_EPIN_STATUS_IX].fifo_depth = UDC_EPIN_SMALLINT_BUFF_SIZE;
+        if (dev->gadget.speed == USB_SPEED_FULL)
+                dev->ep[UDC_EPIN_IX].fifo_depth = UDC_FS_EPIN_BUFF_SIZE;
+        else if (dev->gadget.speed == USB_SPEED_HIGH)
+                dev->ep[UDC_EPIN_IX].fifo_depth = hs_tx_buf;
+        dev->ep[UDC_EPOUT_IX].fifo_depth = UDC_RXFIFO_SIZE;
+}
+
+/* init registers at driver load time */
+static int startup_registers(struct udc *dev)
+{
+        u32 tmp;
+
+        /* init controller by soft reset */
+        udc_soft_reset(dev);
+
+        /* mask not needed interrupts */
+        udc_mask_unused_interrupts(dev);
+
+        /* put into initial config */
+        udc_basic_init(dev);
+        /* link up all endpoints */
+        udc_setup_endpoints(dev);
+
+        /* program speed */
+        tmp = readl(&dev->regs->cfg);
+        if (use_fullspeed) {
+                tmp = AMD_ADDBITS(tmp, UDC_DEVCFG_SPD_FS, UDC_DEVCFG_SPD);
+        } else {
+                tmp = AMD_ADDBITS(tmp, UDC_DEVCFG_SPD_HS, UDC_DEVCFG_SPD);
+        }
+        writel(tmp, &dev->regs->cfg);
+
+        return 0;
+}
+
+/* Inits UDC context */
+static void udc_basic_init(struct udc *dev)
+{
+        u32     tmp;
+
+        DBG(dev, "udc_basic_init()\n");
+
+        dev->gadget.speed = USB_SPEED_UNKNOWN;
+
+        /* stop RDE timer */
+        if (timer_pending(&udc_timer)) {
+                set_rde = 0;
+                mod_timer(&udc_timer, jiffies - 1);
+        }
+        /* stop poll stall timer */
+        if (timer_pending(&udc_pollstall_timer)) {
+                mod_timer(&udc_pollstall_timer, jiffies - 1);
+        }
+        /* disable DMA */
+        tmp = readl(&dev->regs->ctl);
+        tmp &= AMD_UNMASK_BIT(UDC_DEVCTL_RDE);
+        tmp &= AMD_UNMASK_BIT(UDC_DEVCTL_TDE);
+        writel(tmp, &dev->regs->ctl);
+
+        /* enable dynamic CSR programming */
+        tmp = readl(&dev->regs->cfg);
+        tmp |= AMD_BIT(UDC_DEVCFG_CSR_PRG);
+        /* set self powered */
+        tmp |= AMD_BIT(UDC_DEVCFG_SP);
+        /* set remote wakeupable */
+        tmp |= AMD_BIT(UDC_DEVCFG_RWKP);
+        writel(tmp, &dev->regs->cfg);
+
+        make_ep_lists(dev);
+
+        dev->data_ep_enabled = 0;
+        dev->data_ep_queued = 0;
+}
+
+/* Sets initial endpoint parameters */
+static void udc_setup_endpoints(struct udc *dev)
+{
+        struct udc_ep   *ep;
+        u32     tmp;
+        u32     reg;
+
+        DBG(dev, "udc_setup_endpoints()\n");
+
+        /* read enum speed */
+        tmp = readl(&dev->regs->sts);
+        tmp = AMD_GETBITS(tmp, UDC_DEVSTS_ENUM_SPEED);
+        if (tmp == UDC_DEVSTS_ENUM_SPEED_HIGH) {
+                dev->gadget.speed = USB_SPEED_HIGH;
+        } else if (tmp == UDC_DEVSTS_ENUM_SPEED_FULL) {
+                dev->gadget.speed = USB_SPEED_FULL;
+        }
+
+        /* set basic ep parameters */
+        for (tmp = 0; tmp < UDC_EP_NUM; tmp++) {
+                ep = &dev->ep[tmp];
+                ep->dev = dev;
+                ep->ep.name = ep_string[tmp];
+                ep->num = tmp;
+                /* txfifo size is calculated at enable time */
+                ep->txfifo = dev->txfifo;
+
+                /* fifo size */
+                if (tmp < UDC_EPIN_NUM) {
+                        ep->fifo_depth = UDC_TXFIFO_SIZE;
+                        ep->in = 1;
+                } else {
+                        ep->fifo_depth = UDC_RXFIFO_SIZE;
+                        ep->in = 0;
+
+                }
+                ep->regs = &dev->ep_regs[tmp];
+                /*
+                 * ep will be reset only if ep was not enabled before to avoid
+                 * disabling ep interrupts when ENUM interrupt occurs but ep is
+                 * not enabled by gadget driver
+                 */
+                if (!ep->desc) {
+                        ep_init(dev->regs, ep);
+                }
+
+                if (use_dma) {
+                        /*
+                         * ep->dma is not really used, just to indicate that
+                         * DMA is active: remove this
+                         * dma regs = dev control regs
+                         */
+                        ep->dma = &dev->regs->ctl;
+
+                        /* nak OUT endpoints until enable - not for ep0 */
+                        if (tmp != UDC_EP0IN_IX && tmp != UDC_EP0OUT_IX
+                                                && tmp > UDC_EPIN_NUM) {
+                                /* set NAK */
+                                reg = readl(&dev->ep[tmp].regs->ctl);
+                                reg |= AMD_BIT(UDC_EPCTL_SNAK);
+                                writel(reg, &dev->ep[tmp].regs->ctl);
+                                dev->ep[tmp].naking = 1;
+
+                        }
+                }
+        }
+        /* EP0 max packet */
+        if (dev->gadget.speed == USB_SPEED_FULL) {
+                dev->ep[UDC_EP0IN_IX].ep.maxpacket = UDC_FS_EP0IN_MAX_PKT_SIZE;
+                dev->ep[UDC_EP0OUT_IX].ep.maxpacket =
+                                                UDC_FS_EP0OUT_MAX_PKT_SIZE;
+        } else if (dev->gadget.speed == USB_SPEED_HIGH) {
+                dev->ep[UDC_EP0IN_IX].ep.maxpacket = UDC_EP0IN_MAX_PKT_SIZE;
+                dev->ep[UDC_EP0OUT_IX].ep.maxpacket = UDC_EP0OUT_MAX_PKT_SIZE;
+        }
+
+        /*
+         * with suspend bug workaround, ep0 params for gadget driver
+         * are set at gadget driver bind() call
+         */
+        dev->gadget.ep0 = &dev->ep[UDC_EP0IN_IX].ep;
+        dev->ep[UDC_EP0IN_IX].halted = 0;
+        INIT_LIST_HEAD(&dev->gadget.ep0->ep_list);
+
+        /* init cfg/alt/int */
+        dev->cur_config = 0;
+        dev->cur_intf = 0;
+        dev->cur_alt = 0;
+}
+
+/* Bringup after Connect event, initial bringup to be ready for ep0 events */
+static void usb_connect(struct udc *dev)
+{
+
+        dev_info(&dev->pdev->dev, "USB Connect\n");
+
+        dev->connected = 1;
+
+        /* put into initial config */
+        udc_basic_init(dev);
+
+        /* enable device setup interrupts */
+        udc_enable_dev_setup_interrupts(dev);
+}
+
+/*
+ * Calls gadget with disconnect event and resets the UDC and makes
+ * initial bringup to be ready for ep0 events
+ */
+static void usb_disconnect(struct udc *dev)
+{
+
+        dev_info(&dev->pdev->dev, "USB Disconnect\n");
+
+        dev->connected = 0;
+
+        /* mask interrupts */
+        udc_mask_unused_interrupts(dev);
+
+        /* REVISIT there doesn't seem to be a point to having this
+         * talk to a tasklet ... do it directly, we already hold
+         * the spinlock needed to process the disconnect.
+         */
+
+        tasklet_schedule(&disconnect_tasklet);
+}
+
+/* Tasklet for disconnect to be outside of interrupt context */
+static void udc_tasklet_disconnect(unsigned long par)
+{
+        struct udc *dev = (struct udc *)(*((struct udc **) par));
+        u32 tmp;
+
+        DBG(dev, "Tasklet disconnect\n");
+        spin_lock_irq(&dev->lock);
+
+        if (dev->driver) {
+                spin_unlock(&dev->lock);
+                dev->driver->disconnect(&dev->gadget);
+                spin_lock(&dev->lock);
+
+                /* empty queues */
+                for (tmp = 0; tmp < UDC_EP_NUM; tmp++) {
+                        empty_req_queue(&dev->ep[tmp]);
+                }
+
+        }
+
+        /* disable ep0 */
+        ep_init(dev->regs,
+                        &dev->ep[UDC_EP0IN_IX]);
+
+
+        if (!soft_reset_occured) {
+                /* init controller by soft reset */
+                udc_soft_reset(dev);
+                soft_reset_occured++;
+        }
+
+        /* re-enable dev interrupts */
+        udc_enable_dev_setup_interrupts(dev);
+        /* back to full speed ? */
+        if (use_fullspeed) {
+                tmp = readl(&dev->regs->cfg);
+                tmp = AMD_ADDBITS(tmp, UDC_DEVCFG_SPD_FS, UDC_DEVCFG_SPD);
+                writel(tmp, &dev->regs->cfg);
+        }
+
+        spin_unlock_irq(&dev->lock);
+}
+
+/* Reset the UDC core */
+static void udc_soft_reset(struct udc *dev)
+{
+        unsigned long   flags;
+
+        DBG(dev, "Soft reset\n");
+        /*
+         * reset possible waiting interrupts, because int.
+         * status is lost after soft reset,
+         * ep int. status reset
+         */
+        writel(UDC_EPINT_MSK_DISABLE_ALL, &dev->regs->ep_irqsts);
+        /* device int. status reset */
+        writel(UDC_DEV_MSK_DISABLE, &dev->regs->irqsts);
+
+        spin_lock_irqsave(&udc_irq_spinlock, flags);
+        writel(AMD_BIT(UDC_DEVCFG_SOFTRESET), &dev->regs->cfg);
+        readl(&dev->regs->cfg);
+        spin_unlock_irqrestore(&udc_irq_spinlock, flags);
+
+}
+
+/* RDE timer callback to set RDE bit */
+static void udc_timer_function(unsigned long v)
+{
+        u32 tmp;
+
+        spin_lock_irq(&udc_irq_spinlock);
+
+        if (set_rde > 0) {
+                /*
+                 * open the fifo if fifo was filled on last timer call
+                 * conditionally
+                 */
+                if (set_rde > 1) {
+                        /* set RDE to receive setup data */
+                        tmp = readl(&udc->regs->ctl);
+                        tmp |= AMD_BIT(UDC_DEVCTL_RDE);
+                        writel(tmp, &udc->regs->ctl);
+                        set_rde = -1;
+                } else if (readl(&udc->regs->sts)
+                                & AMD_BIT(UDC_DEVSTS_RXFIFO_EMPTY)) {
+                        /*
+                         * if fifo empty setup polling, do not just
+                         * open the fifo
+                         */
+                        udc_timer.expires = jiffies + HZ/UDC_RDE_TIMER_DIV;
+                        if (!stop_timer) {
+                                add_timer(&udc_timer);
+                        }
+                } else {
+                        /*
+                         * fifo contains data now, setup timer for opening
+                         * the fifo when timer expires to be able to receive
+                         * setup packets, when data packets gets queued by
+                         * gadget layer then timer will forced to expire with
+                         * set_rde=0 (RDE is set in udc_queue())
+                         */
+                        set_rde++;
+                        /* debug: lhadmot_timer_start = 221070 */
+                        udc_timer.expires = jiffies + HZ*UDC_RDE_TIMER_SECONDS;
+                        if (!stop_timer) {
+                                add_timer(&udc_timer);
+                        }
+                }
+
+        } else
+                set_rde = -1; /* RDE was set by udc_queue() */
+        spin_unlock_irq(&udc_irq_spinlock);
+        if (stop_timer)
+                complete(&on_exit);
+
+}
+
+/* Handle halt state, used in stall poll timer */
+static void udc_handle_halt_state(struct udc_ep *ep)
+{
+        u32 tmp;
+        /* set stall as long not halted */
+        if (ep->halted == 1) {
+                tmp = readl(&ep->regs->ctl);
+                /* STALL cleared ? */
+                if (!(tmp & AMD_BIT(UDC_EPCTL_S))) {
+                        /*
+                         * FIXME: MSC spec requires that stall remains
+                         * even on receivng of CLEAR_FEATURE HALT. So
+                         * we would set STALL again here to be compliant.
+                         * But with current mass storage drivers this does
+                         * not work (would produce endless host retries).
+                         * So we clear halt on CLEAR_FEATURE.
+                         *
+                        DBG(ep->dev, "ep %d: set STALL again\n", ep->num);
+                        tmp |= AMD_BIT(UDC_EPCTL_S);
+                        writel(tmp, &ep->regs->ctl);*/
+
+                        /* clear NAK by writing CNAK */
+                        tmp |= AMD_BIT(UDC_EPCTL_CNAK);
+                        writel(tmp, &ep->regs->ctl);
+                        ep->halted = 0;
+                        UDC_QUEUE_CNAK(ep, ep->num);
+                }
+        }
+}
+
+/* Stall timer callback to poll S bit and set it again after */
+static void udc_pollstall_timer_function(unsigned long v)
+{
+        struct udc_ep *ep;
+        int halted = 0;
+
+        spin_lock_irq(&udc_stall_spinlock);
+        /*
+         * only one IN and OUT endpoints are handled
+         * IN poll stall
+         */
+        ep = &udc->ep[UDC_EPIN_IX];
+        udc_handle_halt_state(ep);
+        if (ep->halted)
+                halted = 1;
+        /* OUT poll stall */
+        ep = &udc->ep[UDC_EPOUT_IX];
+        udc_handle_halt_state(ep);
+        if (ep->halted)
+                halted = 1;
+
+        /* setup timer again when still halted */
+        if (!stop_pollstall_timer && halted) {
+                udc_pollstall_timer.expires = jiffies +
+                                        HZ * UDC_POLLSTALL_TIMER_USECONDS
+                                        / (1000 * 1000);
+                add_timer(&udc_pollstall_timer);
+        }
+        spin_unlock_irq(&udc_stall_spinlock);
+
+        if (stop_pollstall_timer)
+                complete(&on_pollstall_exit);
+}
+
+/* Inits endpoint 0 so that SETUP packets are processed */
+static void activate_control_endpoints(struct udc *dev)
+{
+        u32 tmp;
+
+        DBG(dev, "activate_control_endpoints\n");
+
+        /* flush fifo */
+        tmp = readl(&dev->ep[UDC_EP0IN_IX].regs->ctl);
+        tmp |= AMD_BIT(UDC_EPCTL_F);
+        writel(tmp, &dev->ep[UDC_EP0IN_IX].regs->ctl);
+
+        /* set ep0 directions */
+        dev->ep[UDC_EP0IN_IX].in = 1;
+        dev->ep[UDC_EP0OUT_IX].in = 0;
+
+        /* set buffer size (tx fifo entries) of EP0_IN */
+        tmp = readl(&dev->ep[UDC_EP0IN_IX].regs->bufin_framenum);
+        if (dev->gadget.speed == USB_SPEED_FULL)
+                tmp = AMD_ADDBITS(tmp, UDC_FS_EPIN0_BUFF_SIZE,
+                                        UDC_EPIN_BUFF_SIZE);
+        else if (dev->gadget.speed == USB_SPEED_HIGH)
+                tmp = AMD_ADDBITS(tmp, UDC_EPIN0_BUFF_SIZE,
+                                        UDC_EPIN_BUFF_SIZE);
+        writel(tmp, &dev->ep[UDC_EP0IN_IX].regs->bufin_framenum);
+
+        /* set max packet size of EP0_IN */
+        tmp = readl(&dev->ep[UDC_EP0IN_IX].regs->bufout_maxpkt);
+        if (dev->gadget.speed == USB_SPEED_FULL)
+                tmp = AMD_ADDBITS(tmp, UDC_FS_EP0IN_MAX_PKT_SIZE,
+                                        UDC_EP_MAX_PKT_SIZE);
+        else if (dev->gadget.speed == USB_SPEED_HIGH)
+                tmp = AMD_ADDBITS(tmp, UDC_EP0IN_MAX_PKT_SIZE,
+                                UDC_EP_MAX_PKT_SIZE);
+        writel(tmp, &dev->ep[UDC_EP0IN_IX].regs->bufout_maxpkt);
+
+        /* set max packet size of EP0_OUT */
+        tmp = readl(&dev->ep[UDC_EP0OUT_IX].regs->bufout_maxpkt);
+        if (dev->gadget.speed == USB_SPEED_FULL)
+                tmp = AMD_ADDBITS(tmp, UDC_FS_EP0OUT_MAX_PKT_SIZE,
+                                        UDC_EP_MAX_PKT_SIZE);
+        else if (dev->gadget.speed == USB_SPEED_HIGH)
+                tmp = AMD_ADDBITS(tmp, UDC_EP0OUT_MAX_PKT_SIZE,
+                                        UDC_EP_MAX_PKT_SIZE);
+        writel(tmp, &dev->ep[UDC_EP0OUT_IX].regs->bufout_maxpkt);
+
+        /* set max packet size of EP0 in UDC CSR */
+        tmp = readl(&dev->csr->ne[0]);
+        if (dev->gadget.speed == USB_SPEED_FULL)
+                tmp = AMD_ADDBITS(tmp, UDC_FS_EP0OUT_MAX_PKT_SIZE,
+                                        UDC_CSR_NE_MAX_PKT);
+        else if (dev->gadget.speed == USB_SPEED_HIGH)
+                tmp = AMD_ADDBITS(tmp, UDC_EP0OUT_MAX_PKT_SIZE,
+                                        UDC_CSR_NE_MAX_PKT);
+        writel(tmp, &dev->csr->ne[0]);
+
+        if (use_dma) {
+                dev->ep[UDC_EP0OUT_IX].td->status |=
+                        AMD_BIT(UDC_DMA_OUT_STS_L);
+                /* write dma desc address */
+                writel(dev->ep[UDC_EP0OUT_IX].td_stp_dma,
+                        &dev->ep[UDC_EP0OUT_IX].regs->subptr);
+                writel(dev->ep[UDC_EP0OUT_IX].td_phys,
+                        &dev->ep[UDC_EP0OUT_IX].regs->desptr);
+                /* stop RDE timer */
+                if (timer_pending(&udc_timer)) {
+                        set_rde = 0;
+                        mod_timer(&udc_timer, jiffies - 1);
+                }
+                /* stop pollstall timer */
+                if (timer_pending(&udc_pollstall_timer)) {
+                        mod_timer(&udc_pollstall_timer, jiffies - 1);
+                }
+                /* enable DMA */
+                tmp = readl(&dev->regs->ctl);
+                tmp |= AMD_BIT(UDC_DEVCTL_MODE)
+                                | AMD_BIT(UDC_DEVCTL_RDE)
+                                | AMD_BIT(UDC_DEVCTL_TDE);
+                if (use_dma_bufferfill_mode) {
+                        tmp |= AMD_BIT(UDC_DEVCTL_BF);
+                } else if (use_dma_ppb_du) {
+                        tmp |= AMD_BIT(UDC_DEVCTL_DU);
+                }
+                writel(tmp, &dev->regs->ctl);
+        }
+
+        /* clear NAK by writing CNAK for EP0IN */
+        tmp = readl(&dev->ep[UDC_EP0IN_IX].regs->ctl);
+        tmp |= AMD_BIT(UDC_EPCTL_CNAK);
+        writel(tmp, &dev->ep[UDC_EP0IN_IX].regs->ctl);
+        dev->ep[UDC_EP0IN_IX].naking = 0;
+        UDC_QUEUE_CNAK(&dev->ep[UDC_EP0IN_IX], UDC_EP0IN_IX);
+
+        /* clear NAK by writing CNAK for EP0OUT */
+        tmp = readl(&dev->ep[UDC_EP0OUT_IX].regs->ctl);
+        tmp |= AMD_BIT(UDC_EPCTL_CNAK);
+        writel(tmp, &dev->ep[UDC_EP0OUT_IX].regs->ctl);
+        dev->ep[UDC_EP0OUT_IX].naking = 0;
+        UDC_QUEUE_CNAK(&dev->ep[UDC_EP0OUT_IX], UDC_EP0OUT_IX);
+}
+
+/* Make endpoint 0 ready for control traffic */
+static int setup_ep0(struct udc *dev)
+{
+        activate_control_endpoints(dev);
+        /* enable ep0 interrupts */
+        udc_enable_ep0_interrupts(dev);
+        /* enable device setup interrupts */
+        udc_enable_dev_setup_interrupts(dev);
+
+        return 0;
+}
+
+/* Called by gadget driver to register itself */
+int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+{
+        struct udc              *dev = udc;
+        int                     retval;
+        u32 tmp;
+
+        if (!driver || !driver->bind || !driver->setup
+                        || driver->speed != USB_SPEED_HIGH)
+                return -EINVAL;
+        if (!dev)
+                return -ENODEV;
+        if (dev->driver)
+                return -EBUSY;
+
+        driver->driver.bus = NULL;
+        dev->driver = driver;
+        dev->gadget.dev.driver = &driver->driver;
+
+        retval = driver->bind(&dev->gadget);
+
+        /* Some gadget drivers use both ep0 directions.
+         * NOTE: to gadget driver, ep0 is just one endpoint...
+         */
+        dev->ep[UDC_EP0OUT_IX].ep.driver_data =
+                dev->ep[UDC_EP0IN_IX].ep.driver_data;
+
+        if (retval) {
+                DBG(dev, "binding to %s returning %d\n",
+                                driver->driver.name, retval);
+                dev->driver = NULL;
+                dev->gadget.dev.driver = NULL;
+                return retval;
+        }
+
+        /* get ready for ep0 traffic */
+        setup_ep0(dev);
+
+        /* clear SD */
+        tmp = readl(&dev->regs->ctl);
+        tmp = tmp & AMD_CLEAR_BIT(UDC_DEVCTL_SD);
+        writel(tmp, &dev->regs->ctl);
+
+        usb_connect(dev);
+
+        return 0;
+}
+EXPORT_SYMBOL(usb_gadget_register_driver);
+
+/* shutdown requests and disconnect from gadget */
+static void
+shutdown(struct udc *dev, struct usb_gadget_driver *driver)
+__releases(dev->lock)
+__acquires(dev->lock)
+{
+        int tmp;
+
+        /* empty queues and init hardware */
+        udc_basic_init(dev);
+        for (tmp = 0; tmp < UDC_EP_NUM; tmp++) {
+                empty_req_queue(&dev->ep[tmp]);
+        }
+
+        if (dev->gadget.speed != USB_SPEED_UNKNOWN) {
+                spin_unlock(&dev->lock);
+                driver->disconnect(&dev->gadget);
+                spin_lock(&dev->lock);
+        }
+        /* init */
+        udc_setup_endpoints(dev);
+}
+
+/* Called by gadget driver to unregister itself */
+int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
+{
+        struct udc      *dev = udc;
+        unsigned long   flags;
+        u32 tmp;
+
+        if (!dev)
+                return -ENODEV;
+        if (!driver || driver != dev->driver || !driver->unbind)
+                return -EINVAL;
+
+        spin_lock_irqsave(&dev->lock, flags);
+        udc_mask_unused_interrupts(dev);
+        shutdown(dev, driver);
+        spin_unlock_irqrestore(&dev->lock, flags);
+
+        driver->unbind(&dev->gadget);
+        dev->driver = NULL;
+
+        /* set SD */
+        tmp = readl(&dev->regs->ctl);
+        tmp |= AMD_BIT(UDC_DEVCTL_SD);
+        writel(tmp, &dev->regs->ctl);
+
+
+        DBG(dev, "%s: unregistered\n", driver->driver.name);
+
+        return 0;
+}
+EXPORT_SYMBOL(usb_gadget_unregister_driver);
+
+
+/* Clear pending NAK bits */
+static void udc_process_cnak_queue(struct udc *dev)
+{
+        u32 tmp;
+        u32 reg;
+
+        /* check epin's */
+        DBG(dev, "CNAK pending queue processing\n");
+        for (tmp = 0; tmp < UDC_EPIN_NUM_USED; tmp++) {
+                if (cnak_pending & (1 << tmp)) {
+                        DBG(dev, "CNAK pending for ep%d\n", tmp);
+                        /* clear NAK by writing CNAK */
+                        reg = readl(&dev->ep[tmp].regs->ctl);
+                        reg |= AMD_BIT(UDC_EPCTL_CNAK);
+                        writel(reg, &dev->ep[tmp].regs->ctl);
+                        dev->ep[tmp].naking = 0;
+                        UDC_QUEUE_CNAK(&dev->ep[tmp], dev->ep[tmp].num);
+                }
+        }
+        /* ...  and ep0out */
+        if (cnak_pending & (1 << UDC_EP0OUT_IX)) {
+                DBG(dev, "CNAK pending for ep%d\n", UDC_EP0OUT_IX);
+                /* clear NAK by writing CNAK */
+                reg = readl(&dev->ep[UDC_EP0OUT_IX].regs->ctl);
+                reg |= AMD_BIT(UDC_EPCTL_CNAK);
+                writel(reg, &dev->ep[UDC_EP0OUT_IX].regs->ctl);
+                dev->ep[UDC_EP0OUT_IX].naking = 0;
+                UDC_QUEUE_CNAK(&dev->ep[UDC_EP0OUT_IX],
+                                dev->ep[UDC_EP0OUT_IX].num);
+        }
+}
+
+/* Enabling RX DMA after setup packet */
+static void udc_ep0_set_rde(struct udc *dev)
+{
+        if (use_dma) {
+                /*
+                 * only enable RXDMA when no data endpoint enabled
+                 * or data is queued
+                 */
+                if (!dev->data_ep_enabled || dev->data_ep_queued) {
+                        udc_set_rde(dev);
+                } else {
+                        /*
+                         * setup timer for enabling RDE (to not enable
+                         * RXFIFO DMA for data endpoints to early)
+                         */
+                        if (set_rde != 0 && !timer_pending(&udc_timer)) {
+                                udc_timer.expires =
+                                        jiffies + HZ/UDC_RDE_TIMER_DIV;
+                                set_rde = 1;
+                                if (!stop_timer) {
+                                        add_timer(&udc_timer);
+                                }
+                        }
+                }
+        }
+}
+
+
+/* Interrupt handler for data OUT traffic */
+static irqreturn_t udc_data_out_isr(struct udc *dev, int ep_ix)
+{
+        irqreturn_t             ret_val = IRQ_NONE;
+        u32                     tmp;
+        struct udc_ep           *ep;
+        struct udc_request      *req;
+        unsigned int            count;
+        struct udc_data_dma     *td = NULL;
+        unsigned                dma_done;
+
+        VDBG(dev, "ep%d irq\n", ep_ix);
+        ep = &dev->ep[ep_ix];
+
+        tmp = readl(&ep->regs->sts);
+        if (use_dma) {
+                /* BNA event ? */
+                if (tmp & AMD_BIT(UDC_EPSTS_BNA)) {
+                        DBG(dev, "BNA ep%dout occured - DESPTR = %x \n",
+                                        ep->num, readl(&ep->regs->desptr));
+                        /* clear BNA */
+                        writel(tmp | AMD_BIT(UDC_EPSTS_BNA), &ep->regs->sts);
+                        if (!ep->cancel_transfer)
+                                ep->bna_occurred = 1;
+                        else
+                                ep->cancel_transfer = 0;
+                        ret_val = IRQ_HANDLED;
+                        goto finished;
+                }
+        }
+        /* HE event ? */
+        if (tmp & AMD_BIT(UDC_EPSTS_HE)) {
+                dev_err(&dev->pdev->dev, "HE ep%dout occured\n", ep->num);
+
+                /* clear HE */
+                writel(tmp | AMD_BIT(UDC_EPSTS_HE), &ep->regs->sts);
+                ret_val = IRQ_HANDLED;
+                goto finished;
+        }
+
+        if (!list_empty(&ep->queue)) {
+
+                /* next request */
+                req = list_entry(ep->queue.next,
+                        struct udc_request, queue);
+        } else {
+                req = NULL;
+                udc_rxfifo_pending = 1;
+        }
+        VDBG(dev, "req = %p\n", req);
+        /* fifo mode */
+        if (!use_dma) {
+
+                /* read fifo */
+                if (req && udc_rxfifo_read(ep, req)) {
+                        ret_val = IRQ_HANDLED;
+
+                        /* finish */
+                        complete_req(ep, req, 0);
+                        /* next request */
+                        if (!list_empty(&ep->queue) && !ep->halted) {
+                                req = list_entry(ep->queue.next,
+                                        struct udc_request, queue);
+                        } else
+                                req = NULL;
+                }
+
+        /* DMA */
+        } else if (!ep->cancel_transfer && req != NULL) {
+                ret_val = IRQ_HANDLED;
+
+                /* check for DMA done */
+                if (!use_dma_ppb) {
+                        dma_done = AMD_GETBITS(req->td_data->status,
+                                                UDC_DMA_OUT_STS_BS);
+                /* packet per buffer mode - rx bytes */
+                } else {
+                        /*
+                         * if BNA occurred then recover desc. from
+                         * BNA dummy desc.
+                         */
+                        if (ep->bna_occurred) {
+                                VDBG(dev, "Recover desc. from BNA dummy\n");
+                                memcpy(req->td_data, ep->bna_dummy_req->td_data,
+                                                sizeof(struct udc_data_dma));
+                                ep->bna_occurred = 0;
+                                udc_init_bna_dummy(ep->req);
+                        }
+                        td = udc_get_last_dma_desc(req);
+                        dma_done = AMD_GETBITS(td->status, UDC_DMA_OUT_STS_BS);
+                }
+                if (dma_done == UDC_DMA_OUT_STS_BS_DMA_DONE) {
+                        /* buffer fill mode - rx bytes */
+                        if (!use_dma_ppb) {
+                                /* received number bytes */
+                                count = AMD_GETBITS(req->td_data->status,
+                                                UDC_DMA_OUT_STS_RXBYTES);
+                                VDBG(dev, "rx bytes=%u\n", count);
+                        /* packet per buffer mode - rx bytes */
+                        } else {
+                                VDBG(dev, "req->td_data=%p\n", req->td_data);
+                                VDBG(dev, "last desc = %p\n", td);
+                                /* received number bytes */
+                                if (use_dma_ppb_du) {
+                                        /* every desc. counts bytes */
+                                        count = udc_get_ppbdu_rxbytes(req);
+                                } else {
+                                        /* last desc. counts bytes */
+                                        count = AMD_GETBITS(td->status,
+                                                UDC_DMA_OUT_STS_RXBYTES);
+                                        if (!count && req->req.length
+                                                == UDC_DMA_MAXPACKET) {
+                                                /*
+                                                 * on 64k packets the RXBYTES
+                                                 * field is zero
+                                                 */
+                                                count = UDC_DMA_MAXPACKET;
+                                        }
+                                }
+                                VDBG(dev, "last desc rx bytes=%u\n", count);
+                        }
+
+                        tmp = req->req.length - req->req.actual;
+                        if (count > tmp) {
+                                if ((tmp % ep->ep.maxpacket) != 0) {
+                                        DBG(dev, "%s: rx %db, space=%db\n",
+                                                ep->ep.name, count, tmp);
+                                        req->req.status = -EOVERFLOW;
+                                }
+                                count = tmp;
+                        }
+                        req->req.actual += count;
+                        req->dma_going = 0;
+                        /* complete request */
+                        complete_req(ep, req, 0);
+
+                        /* next request */
+                        if (!list_empty(&ep->queue) && !ep->halted) {
+                                req = list_entry(ep->queue.next,
+                                        struct udc_request,
+                                        queue);
+                                /*
+                                 * DMA may be already started by udc_queue()
+                                 * called by gadget drivers completion
+                                 * routine. This happens when queue
+                                 * holds one request only.
+                                 */
+                                if (req->dma_going == 0) {
+                                        /* next dma */
+                                        if (prep_dma(ep, req, GFP_ATOMIC) != 0)
+                                                goto finished;
+                                        /* write desc pointer */
+                                        writel(req->td_phys,
+                                                &ep->regs->desptr);
+                                        req->dma_going = 1;
+                                        /* enable DMA */
+                                        udc_set_rde(dev);
+                                }
+                        } else {
+                                /*
+                                 * implant BNA dummy descriptor to allow
+                                 * RXFIFO opening by RDE
+                                 */
+                                if (ep->bna_dummy_req) {
+                                        /* write desc pointer */
+                                        writel(ep->bna_dummy_req->td_phys,
+                                                &ep->regs->desptr);
+                                        ep->bna_occurred = 0;
+                                }
+
+                                /*
+                                 * schedule timer for setting RDE if queue
+                                 * remains empty to allow ep0 packets pass
+                                 * through
+                                 */
+                                if (set_rde != 0
+                                                && !timer_pending(&udc_timer)) {
+                                        udc_timer.expires =
+                                                jiffies
+                                                + HZ*UDC_RDE_TIMER_SECONDS;
+                                        set_rde = 1;
+                                        if (!stop_timer) {
+                                                add_timer(&udc_timer);
+                                        }
+                                }
+                                if (ep->num != UDC_EP0OUT_IX)
+                                        dev->data_ep_queued = 0;
+                        }
+
+                } else {
+                        /*
+                        * RX DMA must be reenabled for each desc in PPBDU mode
+                        * and must be enabled for PPBNDU mode in case of BNA
+                        */
+                        udc_set_rde(dev);
+                }
+
+        } else if (ep->cancel_transfer) {
+                ret_val = IRQ_HANDLED;
+                ep->cancel_transfer = 0;
+        }
+
+        /* check pending CNAKS */
+        if (cnak_pending) {
+                /* CNAk processing when rxfifo empty only */
+                if (readl(&dev->regs->sts) & AMD_BIT(UDC_DEVSTS_RXFIFO_EMPTY)) {
+                        udc_process_cnak_queue(dev);
+                }
+        }
+
+        /* clear OUT bits in ep status */
+        writel(UDC_EPSTS_OUT_CLEAR, &ep->regs->sts);
+finished:
+        return ret_val;
+}
+
+/* Interrupt handler for data IN traffic */
+static irqreturn_t udc_data_in_isr(struct udc *dev, int ep_ix)
+{
+        irqreturn_t ret_val = IRQ_NONE;
+        u32 tmp;
+        u32 epsts;
+        struct udc_ep *ep;
+        struct udc_request *req;
+        struct udc_data_dma *td;
+        unsigned dma_done;
+        unsigned len;
+
+        ep = &dev->ep[ep_ix];
+
+        epsts = readl(&ep->regs->sts);
+        if (use_dma) {
+                /* BNA ? */
+                if (epsts & AMD_BIT(UDC_EPSTS_BNA)) {
+                        dev_err(&dev->pdev->dev,
+                                "BNA ep%din occured - DESPTR = %08lx \n",
+                                ep->num,
+                                (unsigned long) readl(&ep->regs->desptr));
+
+                        /* clear BNA */
+                        writel(epsts, &ep->regs->sts);
+                        ret_val = IRQ_HANDLED;
+                        goto finished;
+                }
+        }
+        /* HE event ? */
+        if (epsts & AMD_BIT(UDC_EPSTS_HE)) {
+                dev_err(&dev->pdev->dev,
+                        "HE ep%dn occured - DESPTR = %08lx \n",
+                        ep->num, (unsigned long) readl(&ep->regs->desptr));
+
+                /* clear HE */
+                writel(epsts | AMD_BIT(UDC_EPSTS_HE), &ep->regs->sts);
+                ret_val = IRQ_HANDLED;
+                goto finished;
+        }
+
+        /* DMA completion */
+        if (epsts & AMD_BIT(UDC_EPSTS_TDC)) {
+                VDBG(dev, "TDC set- completion\n");
+                ret_val = IRQ_HANDLED;
+                if (!ep->cancel_transfer && !list_empty(&ep->queue)) {
+                        req = list_entry(ep->queue.next,
+                                        struct udc_request, queue);
+                        if (req) {
+                                /*
+                                 * length bytes transfered
+                                 * check dma done of last desc. in PPBDU mode
+                                 */
+                                if (use_dma_ppb_du) {
+                                        td = udc_get_last_dma_desc(req);
+                                        if (td) {
+                                                dma_done =
+                                                        AMD_GETBITS(td->status,
+                                                        UDC_DMA_IN_STS_BS);
+                                                /* don't care DMA done */
+                                                req->req.actual =
+                                                        req->req.length;
+                                        }
+                                } else {
+                                        /* assume all bytes transferred */
+                                        req->req.actual = req->req.length;
+                                }
+
+                                if (req->req.actual == req->req.length) {
+                                        /* complete req */
+                                        complete_req(ep, req, 0);
+                                        req->dma_going = 0;
+                                        /* further request available ? */
+                                        if (list_empty(&ep->queue)) {
+                                                /* disable interrupt */
+                                                tmp = readl(
+                                                        &dev->regs->ep_irqmsk);
+                                                tmp |= AMD_BIT(ep->num);
+                                                writel(tmp,
+                                                        &dev->regs->ep_irqmsk);
+                                        }
+
+                                }
+                        }
+                }
+                ep->cancel_transfer = 0;
+
+        }
+        /*
+         * status reg has IN bit set and TDC not set (if TDC was handled,
+         * IN must not be handled (UDC defect) ?
+         */
+        if ((epsts & AMD_BIT(UDC_EPSTS_IN))
+                        && !(epsts & AMD_BIT(UDC_EPSTS_TDC))) {
+                ret_val = IRQ_HANDLED;
+                if (!list_empty(&ep->queue)) {
+                        /* next request */
+                        req = list_entry(ep->queue.next,
+                                        struct udc_request, queue);
+                        /* FIFO mode */
+                        if (!use_dma) {
+                                /* write fifo */
+                                udc_txfifo_write(ep, &req->req);
+                                len = req->req.length - req->req.actual;
+                                                if (len > ep->ep.maxpacket)
+                                                        len = ep->ep.maxpacket;
+                                                req->req.actual += len;
+                                if (req->req.actual == req->req.length
+                                        || (len != ep->ep.maxpacket)) {
+                                        /* complete req */
+                                        complete_req(ep, req, 0);
+                                }
+                        /* DMA */
+                        } else if (req && !req->dma_going) {
+                                VDBG(dev, "IN DMA : req=%p req->td_data=%p\n",
+                                        req, req->td_data);
+                                if (req->td_data) {
+
+                                        req->dma_going = 1;
+
+                                        /*
+                                         * unset L bit of first desc.
+                                         * for chain
+                                         */
+                                        if (use_dma_ppb && req->req.length >
+                                                        ep->ep.maxpacket) {
+                                                req->td_data->status &=
+                                                        AMD_CLEAR_BIT(
+                                                        UDC_DMA_IN_STS_L);
+                                        }
+
+                                        /* write desc pointer */
+                                        writel(req->td_phys, &ep->regs->desptr);
+
+                                        /* set HOST READY */
+                                        req->td_data->status =
+                                                AMD_ADDBITS(
+                                                req->td_data->status,
+                                                UDC_DMA_IN_STS_BS_HOST_READY,
+                                                UDC_DMA_IN_STS_BS);
+
+                                        /* set poll demand bit */
+                                        tmp = readl(&ep->regs->ctl);
+                                        tmp |= AMD_BIT(UDC_EPCTL_P);
+                                        writel(tmp, &ep->regs->ctl);
+                                }
+                        }
+
+                }
+        }
+        /* clear status bits */
+        writel(epsts, &ep->regs->sts);
+
+finished:
+        return ret_val;
+
+}
+
+/* Interrupt handler for Control OUT traffic */
+static irqreturn_t udc_control_out_isr(struct udc *dev)
+__releases(dev->lock)
+__acquires(dev->lock)
+{
+        irqreturn_t ret_val = IRQ_NONE;
+        u32 tmp;
+        int setup_supported;
+        u32 count;
+        int set = 0;
+        struct udc_ep   *ep;
+        struct udc_ep   *ep_tmp;
+
+        ep = &dev->ep[UDC_EP0OUT_IX];
+
+        /* clear irq */
+        writel(AMD_BIT(UDC_EPINT_OUT_EP0), &dev->regs->ep_irqsts);
+
+        tmp = readl(&dev->ep[UDC_EP0OUT_IX].regs->sts);
+        /* check BNA and clear if set */
+        if (tmp & AMD_BIT(UDC_EPSTS_BNA)) {
+                VDBG(dev, "ep0: BNA set\n");
+                writel(AMD_BIT(UDC_EPSTS_BNA),
+                        &dev->ep[UDC_EP0OUT_IX].regs->sts);
+                ep->bna_occurred = 1;
+                ret_val = IRQ_HANDLED;
+                goto finished;
+        }
+
+        /* type of data: SETUP or DATA 0 bytes */
+        tmp = AMD_GETBITS(tmp, UDC_EPSTS_OUT);
+        VDBG(dev, "data_typ = %x\n", tmp);
+
+        /* setup data */
+        if (tmp == UDC_EPSTS_OUT_SETUP) {
+                ret_val = IRQ_HANDLED;
+
+                ep->dev->stall_ep0in = 0;
+                dev->waiting_zlp_ack_ep0in = 0;
+
+                /* set NAK for EP0_IN */
+                tmp = readl(&dev->ep[UDC_EP0IN_IX].regs->ctl);
+                tmp |= AMD_BIT(UDC_EPCTL_SNAK);
+                writel(tmp, &dev->ep[UDC_EP0IN_IX].regs->ctl);
+                dev->ep[UDC_EP0IN_IX].naking = 1;
+                /* get setup data */
+                if (use_dma) {
+
+                        /* clear OUT bits in ep status */
+                        writel(UDC_EPSTS_OUT_CLEAR,
+                                &dev->ep[UDC_EP0OUT_IX].regs->sts);
+
+                        setup_data.data[0] =
+                                dev->ep[UDC_EP0OUT_IX].td_stp->data12;
+                        setup_data.data[1] =
+                                dev->ep[UDC_EP0OUT_IX].td_stp->data34;
+                        /* set HOST READY */
+                        dev->ep[UDC_EP0OUT_IX].td_stp->status =
+                                        UDC_DMA_STP_STS_BS_HOST_READY;
+                } else {
+                        /* read fifo */
+                        udc_rxfifo_read_dwords(dev, setup_data.data, 2);
+                }
+
+                /* determine direction of control data */
+                if ((setup_data.request.bRequestType & USB_DIR_IN) != 0) {
+                        dev->gadget.ep0 = &dev->ep[UDC_EP0IN_IX].ep;
+                        /* enable RDE */
+                        udc_ep0_set_rde(dev);
+                        set = 0;
+                } else {
+                        dev->gadget.ep0 = &dev->ep[UDC_EP0OUT_IX].ep;
+                        /*
+                         * implant BNA dummy descriptor to allow RXFIFO opening
+                         * by RDE
+                         */
+                        if (ep->bna_dummy_req) {
+                                /* write desc pointer */
+                                writel(ep->bna_dummy_req->td_phys,
+                                        &dev->ep[UDC_EP0OUT_IX].regs->desptr);
+                                ep->bna_occurred = 0;
+                        }
+
+                        set = 1;
+                        dev->ep[UDC_EP0OUT_IX].naking = 1;
+                        /*
+                         * setup timer for enabling RDE (to not enable
+                         * RXFIFO DMA for data to early)
+                         */
+                        set_rde = 1;
+                        if (!timer_pending(&udc_timer)) {
+                                udc_timer.expires = jiffies +
+                                                        HZ/UDC_RDE_TIMER_DIV;
+                                if (!stop_timer) {
+                                        add_timer(&udc_timer);
+                                }
+                        }
+                }
+
+                /*
+                 * mass storage reset must be processed here because
+                 * next packet may be a CLEAR_FEATURE HALT which would not
+                 * clear the stall bit when no STALL handshake was received
+                 * before (autostall can cause this)
+                 */
+                if (setup_data.data[0] == UDC_MSCRES_DWORD0
+                                && setup_data.data[1] == UDC_MSCRES_DWORD1) {
+                        DBG(dev, "MSC Reset\n");
+                        /*
+                         * clear stall bits
+                         * only one IN and OUT endpoints are handled
+                         */
+                        ep_tmp = &udc->ep[UDC_EPIN_IX];
+                        udc_set_halt(&ep_tmp->ep, 0);
+                        ep_tmp = &udc->ep[UDC_EPOUT_IX];
+                        udc_set_halt(&ep_tmp->ep, 0);
+                }
+
+                /* call gadget with setup data received */
+                spin_unlock(&dev->lock);
+                setup_supported = dev->driver->setup(&dev->gadget,
+                                                &setup_data.request);
+                spin_lock(&dev->lock);
+
+                tmp = readl(&dev->ep[UDC_EP0IN_IX].regs->ctl);
+                /* ep0 in returns data (not zlp) on IN phase */
+                if (setup_supported >= 0 && setup_supported <
+                                UDC_EP0IN_MAXPACKET) {
+                        /* clear NAK by writing CNAK in EP0_IN */
+                        tmp |= AMD_BIT(UDC_EPCTL_CNAK);
+                        writel(tmp, &dev->ep[UDC_EP0IN_IX].regs->ctl);
+                        dev->ep[UDC_EP0IN_IX].naking = 0;
+                        UDC_QUEUE_CNAK(&dev->ep[UDC_EP0IN_IX], UDC_EP0IN_IX);
+
+                /* if unsupported request then stall */
+                } else if (setup_supported < 0) {
+                        tmp |= AMD_BIT(UDC_EPCTL_S);
+                        writel(tmp, &dev->ep[UDC_EP0IN_IX].regs->ctl);
+                } else
+                        dev->waiting_zlp_ack_ep0in = 1;
+
+
+                /* clear NAK by writing CNAK in EP0_OUT */
+                if (!set) {
+                        tmp = readl(&dev->ep[UDC_EP0OUT_IX].regs->ctl);
+                        tmp |= AMD_BIT(UDC_EPCTL_CNAK);
+                        writel(tmp, &dev->ep[UDC_EP0OUT_IX].regs->ctl);
+                        dev->ep[UDC_EP0OUT_IX].naking = 0;
+                        UDC_QUEUE_CNAK(&dev->ep[UDC_EP0OUT_IX], UDC_EP0OUT_IX);
+                }
+
+                if (!use_dma) {
+                        /* clear OUT bits in ep status */
+                        writel(UDC_EPSTS_OUT_CLEAR,
+                                &dev->ep[UDC_EP0OUT_IX].regs->sts);
+                }
+
+        /* data packet 0 bytes */
+        } else if (tmp == UDC_EPSTS_OUT_DATA) {
+                /* clear OUT bits in ep status */
+                writel(UDC_EPSTS_OUT_CLEAR, &dev->ep[UDC_EP0OUT_IX].regs->sts);
+
+                /* get setup data: only 0 packet */
+                if (use_dma) {
+                        /* no req if 0 packet, just reactivate */
+                        if (list_empty(&dev->ep[UDC_EP0OUT_IX].queue)) {
+                                VDBG(dev, "ZLP\n");
+
+                                /* set HOST READY */
+                                dev->ep[UDC_EP0OUT_IX].td->status =
+                                        AMD_ADDBITS(
+                                        dev->ep[UDC_EP0OUT_IX].td->status,
+                                        UDC_DMA_OUT_STS_BS_HOST_READY,
+                                        UDC_DMA_OUT_STS_BS);
+                                /* enable RDE */
+                                udc_ep0_set_rde(dev);
+                                ret_val = IRQ_HANDLED;
+
+                        } else {
+                                /* control write */
+                                ret_val |= udc_data_out_isr(dev, UDC_EP0OUT_IX);
+                                /* re-program desc. pointer for possible ZLPs */
+                                writel(dev->ep[UDC_EP0OUT_IX].td_phys,
+                                        &dev->ep[UDC_EP0OUT_IX].regs->desptr);
+                                /* enable RDE */
+                                udc_ep0_set_rde(dev);
+                        }
+                } else {
+
+                        /* received number bytes */
+                        count = readl(&dev->ep[UDC_EP0OUT_IX].regs->sts);
+                        count = AMD_GETBITS(count, UDC_EPSTS_RX_PKT_SIZE);
+                        /* out data for fifo mode not working */
+                        count = 0;
+
+                        /* 0 packet or real data ? */
+                        if (count != 0) {
+                                ret_val |= udc_data_out_isr(dev, UDC_EP0OUT_IX);
+                        } else {
+                                /* dummy read confirm */
+                                readl(&dev->ep[UDC_EP0OUT_IX].regs->confirm);
+                                ret_val = IRQ_HANDLED;
+                        }
+                }
+        }
+
+        /* check pending CNAKS */
+        if (cnak_pending) {
+                /* CNAk processing when rxfifo empty only */
+                if (readl(&dev->regs->sts) & AMD_BIT(UDC_DEVSTS_RXFIFO_EMPTY)) {
+                        udc_process_cnak_queue(dev);
+                }
+        }
+
+finished:
+        return ret_val;
+}
+
+/* Interrupt handler for Control IN traffic */
+static irqreturn_t udc_control_in_isr(struct udc *dev)
+{
+        irqreturn_t ret_val = IRQ_NONE;
+        u32 tmp;
+        struct udc_ep *ep;
+        struct udc_request *req;
+        unsigned len;
+
+        ep = &dev->ep[UDC_EP0IN_IX];
+
+        /* clear irq */
+        writel(AMD_BIT(UDC_EPINT_IN_EP0), &dev->regs->ep_irqsts);
+
+        tmp = readl(&dev->ep[UDC_EP0IN_IX].regs->sts);
+        /* DMA completion */
+        if (tmp & AMD_BIT(UDC_EPSTS_TDC)) {
+                VDBG(dev, "isr: TDC clear \n");
+                ret_val = IRQ_HANDLED;
+
+                /* clear TDC bit */
+                writel(AMD_BIT(UDC_EPSTS_TDC),
+                                &dev->ep[UDC_EP0IN_IX].regs->sts);
+
+        /* status reg has IN bit set ? */
+        } else if (tmp & AMD_BIT(UDC_EPSTS_IN)) {
+                ret_val = IRQ_HANDLED;
+
+                if (ep->dma) {
+                        /* clear IN bit */
+                        writel(AMD_BIT(UDC_EPSTS_IN),
+                                &dev->ep[UDC_EP0IN_IX].regs->sts);
+                }
+                if (dev->stall_ep0in) {
+                        DBG(dev, "stall ep0in\n");
+                        /* halt ep0in */
+                        tmp = readl(&ep->regs->ctl);
+                        tmp |= AMD_BIT(UDC_EPCTL_S);
+                        writel(tmp, &ep->regs->ctl);
+                } else {
+                        if (!list_empty(&ep->queue)) {
+                                /* next request */
+                                req = list_entry(ep->queue.next,
+                                                struct udc_request, queue);
+
+                                if (ep->dma) {
+                                        /* write desc pointer */
+                                        writel(req->td_phys, &ep->regs->desptr);
+                                        /* set HOST READY */
+                                        req->td_data->status =
+                                                AMD_ADDBITS(
+                                                req->td_data->status,
+                                                UDC_DMA_STP_STS_BS_HOST_READY,
+                                                UDC_DMA_STP_STS_BS);
+
+                                        /* set poll demand bit */
+                                        tmp =
+                                        readl(&dev->ep[UDC_EP0IN_IX].regs->ctl);
+                                        tmp |= AMD_BIT(UDC_EPCTL_P);
+                                        writel(tmp,
+                                        &dev->ep[UDC_EP0IN_IX].regs->ctl);
+
+                                        /* all bytes will be transferred */
+                                        req->req.actual = req->req.length;
+
+                                        /* complete req */
+                                        complete_req(ep, req, 0);
+
+                                } else {
+                                        /* write fifo */
+                                        udc_txfifo_write(ep, &req->req);
+
+                                        /* lengh bytes transfered */
+                                        len = req->req.length - req->req.actual;
+                                        if (len > ep->ep.maxpacket)
+                                                len = ep->ep.maxpacket;
+
+                                        req->req.actual += len;
+                                        if (req->req.actual == req->req.length
+                                                || (len != ep->ep.maxpacket)) {
+                                                /* complete req */
+                                                complete_req(ep, req, 0);
+                                        }
+                                }
+
+                        }
+                }
+                ep->halted = 0;
+                dev->stall_ep0in = 0;
+                if (!ep->dma) {
+                        /* clear IN bit */
+                        writel(AMD_BIT(UDC_EPSTS_IN),
+                                &dev->ep[UDC_EP0IN_IX].regs->sts);
+                }
+        }
+
+        return ret_val;
+}
+
+
+/* Interrupt handler for global device events */
+static irqreturn_t udc_dev_isr(struct udc *dev, u32 dev_irq)
+__releases(dev->lock)
+__acquires(dev->lock)
+{
+        irqreturn_t ret_val = IRQ_NONE;
+        u32 tmp;
+        u32 cfg;
+        struct udc_ep *ep;
+        u16 i;
+        u8 udc_csr_epix;
+
+        /* SET_CONFIG irq ? */
+        if (dev_irq & AMD_BIT(UDC_DEVINT_SC)) {
+                ret_val = IRQ_HANDLED;
+
+                /* read config value */
+                tmp = readl(&dev->regs->sts);
+                cfg = AMD_GETBITS(tmp, UDC_DEVSTS_CFG);
+                DBG(dev, "SET_CONFIG interrupt: config=%d\n", cfg);
+                dev->cur_config = cfg;
+                dev->set_cfg_not_acked = 1;
+
+                /* make usb request for gadget driver */
+                memset(&setup_data, 0 , sizeof(union udc_setup_data));
+                setup_data.request.bRequest = USB_REQ_SET_CONFIGURATION;
+                setup_data.request.wValue = dev->cur_config;
+
+                /* programm the NE registers */
+                for (i = 0; i < UDC_EP_NUM; i++) {
+                        ep = &dev->ep[i];
+                        if (ep->in) {
+
+                                /* ep ix in UDC CSR register space */
+                                udc_csr_epix = ep->num;
+
+
+                        /* OUT ep */
+                        } else {
+                                /* ep ix in UDC CSR register space */
+                                udc_csr_epix = ep->num - UDC_CSR_EP_OUT_IX_OFS;
+                        }
+
+                        tmp = readl(&dev->csr->ne[udc_csr_epix]);
+                        /* ep cfg */
+                        tmp = AMD_ADDBITS(tmp, ep->dev->cur_config,
+                                                UDC_CSR_NE_CFG);
+                        /* write reg */
+                        writel(tmp, &dev->csr->ne[udc_csr_epix]);
+
+                        /* clear stall bits */
+                        ep->halted = 0;
+                        tmp = readl(&ep->regs->ctl);
+                        tmp = tmp & AMD_CLEAR_BIT(UDC_EPCTL_S);
+                        writel(tmp, &ep->regs->ctl);
+                }
+                /* call gadget zero with setup data received */
+                spin_unlock(&dev->lock);
+                tmp = dev->driver->setup(&dev->gadget, &setup_data.request);
+                spin_lock(&dev->lock);
+
+        } /* SET_INTERFACE ? */
+        if (dev_irq & AMD_BIT(UDC_DEVINT_SI)) {
+                ret_val = IRQ_HANDLED;
+
+                dev->set_cfg_not_acked = 1;
+                /* read interface and alt setting values */
+                tmp = readl(&dev->regs->sts);
+                dev->cur_alt = AMD_GETBITS(tmp, UDC_DEVSTS_ALT);
+                dev->cur_intf = AMD_GETBITS(tmp, UDC_DEVSTS_INTF);
+
+                /* make usb request for gadget driver */
+                memset(&setup_data, 0 , sizeof(union udc_setup_data));
+                setup_data.request.bRequest = USB_REQ_SET_INTERFACE;
+                setup_data.request.bRequestType = USB_RECIP_INTERFACE;
+                setup_data.request.wValue = dev->cur_alt;
+                setup_data.request.wIndex = dev->cur_intf;
+
+                DBG(dev, "SET_INTERFACE interrupt: alt=%d intf=%d\n",
+                                dev->cur_alt, dev->cur_intf);
+
+                /* programm the NE registers */
+                for (i = 0; i < UDC_EP_NUM; i++) {
+                        ep = &dev->ep[i];
+                        if (ep->in) {
+
+                                /* ep ix in UDC CSR register space */
+                                udc_csr_epix = ep->num;
+
+
+                        /* OUT ep */
+                        } else {
+                                /* ep ix in UDC CSR register space */
+                                udc_csr_epix = ep->num - UDC_CSR_EP_OUT_IX_OFS;
+                        }
+
+                        /* UDC CSR reg */
+                        /* set ep values */
+                        tmp = readl(&dev->csr->ne[udc_csr_epix]);
+                        /* ep interface */
+                        tmp = AMD_ADDBITS(tmp, ep->dev->cur_intf,
+                                                UDC_CSR_NE_INTF);
+                        /* tmp = AMD_ADDBITS(tmp, 2, UDC_CSR_NE_INTF); */
+                        /* ep alt */
+                        tmp = AMD_ADDBITS(tmp, ep->dev->cur_alt,
+                                                UDC_CSR_NE_ALT);
+                        /* write reg */
+                        writel(tmp, &dev->csr->ne[udc_csr_epix]);
+
+                        /* clear stall bits */
+                        ep->halted = 0;
+                        tmp = readl(&ep->regs->ctl);
+                        tmp = tmp & AMD_CLEAR_BIT(UDC_EPCTL_S);
+                        writel(tmp, &ep->regs->ctl);
+                }
+
+                /* call gadget zero with setup data received */
+                spin_unlock(&dev->lock);
+                tmp = dev->driver->setup(&dev->gadget, &setup_data.request);
+                spin_lock(&dev->lock);
+
+        } /* USB reset */
+        if (dev_irq & AMD_BIT(UDC_DEVINT_UR)) {
+                DBG(dev, "USB Reset interrupt\n");
+                ret_val = IRQ_HANDLED;
+
+                /* allow soft reset when suspend occurs */
+                soft_reset_occured = 0;
+
+                dev->waiting_zlp_ack_ep0in = 0;
+                dev->set_cfg_not_acked = 0;
+
+                /* mask not needed interrupts */
+                udc_mask_unused_interrupts(dev);
+
+                /* call gadget to resume and reset configs etc. */
+                spin_unlock(&dev->lock);
+                if (dev->sys_suspended && dev->driver->resume) {
+                        dev->driver->resume(&dev->gadget);
+                        dev->sys_suspended = 0;
+                }
+                dev->driver->disconnect(&dev->gadget);
+                spin_lock(&dev->lock);
+
+                /* disable ep0 to empty req queue */
+                empty_req_queue(&dev->ep[UDC_EP0IN_IX]);
+                ep_init(dev->regs, &dev->ep[UDC_EP0IN_IX]);
+
+                /* soft reset when rxfifo not empty */
+                tmp = readl(&dev->regs->sts);
+                if (!(tmp & AMD_BIT(UDC_DEVSTS_RXFIFO_EMPTY))
+                                && !soft_reset_after_usbreset_occured) {
+                        udc_soft_reset(dev);
+                        soft_reset_after_usbreset_occured++;
+                }
+
+                /*
+                 * DMA reset to kill potential old DMA hw hang,
+                 * POLL bit is already reset by ep_init() through
+                 * disconnect()
+                 */
+                DBG(dev, "DMA machine reset\n");
+                tmp = readl(&dev->regs->cfg);
+                writel(tmp | AMD_BIT(UDC_DEVCFG_DMARST), &dev->regs->cfg);
+                writel(tmp, &dev->regs->cfg);
+
+                /* put into initial config */
+                udc_basic_init(dev);
+
+                /* enable device setup interrupts */
+                udc_enable_dev_setup_interrupts(dev);
+
+                /* enable suspend interrupt */
+                tmp = readl(&dev->regs->irqmsk);
+                tmp &= AMD_UNMASK_BIT(UDC_DEVINT_US);
+                writel(tmp, &dev->regs->irqmsk);
+
+        } /* USB suspend */
+        if (dev_irq & AMD_BIT(UDC_DEVINT_US)) {
+                DBG(dev, "USB Suspend interrupt\n");
+                ret_val = IRQ_HANDLED;
+                if (dev->driver->suspend) {
+                        spin_unlock(&dev->lock);
+                        dev->sys_suspended = 1;
+                        dev->driver->suspend(&dev->gadget);
+                        spin_lock(&dev->lock);
+                }
+        } /* new speed ? */
+        if (dev_irq & AMD_BIT(UDC_DEVINT_ENUM)) {
+                DBG(dev, "ENUM interrupt\n");
+                ret_val = IRQ_HANDLED;
+                soft_reset_after_usbreset_occured = 0;
+
+                /* disable ep0 to empty req queue */
+                empty_req_queue(&dev->ep[UDC_EP0IN_IX]);
+                ep_init(dev->regs, &dev->ep[UDC_EP0IN_IX]);
+
+                /* link up all endpoints */
+                udc_setup_endpoints(dev);
+                if (dev->gadget.speed == USB_SPEED_HIGH) {
+                        dev_info(&dev->pdev->dev, "Connect: speed = %s\n",
+                                "high");
+                } else if (dev->gadget.speed == USB_SPEED_FULL) {
+                        dev_info(&dev->pdev->dev, "Connect: speed = %s\n",
+                                "full");
+                }
+
+                /* init ep 0 */
+                activate_control_endpoints(dev);
+
+                /* enable ep0 interrupts */
+                udc_enable_ep0_interrupts(dev);
+        }
+        /* session valid change interrupt */
+        if (dev_irq & AMD_BIT(UDC_DEVINT_SVC)) {
+                DBG(dev, "USB SVC interrupt\n");
+                ret_val = IRQ_HANDLED;
+
+                /* check that session is not valid to detect disconnect */
+                tmp = readl(&dev->regs->sts);
+                if (!(tmp & AMD_BIT(UDC_DEVSTS_SESSVLD))) {
+                        /* disable suspend interrupt */
+                        tmp = readl(&dev->regs->irqmsk);
+                        tmp |= AMD_BIT(UDC_DEVINT_US);
+                        writel(tmp, &dev->regs->irqmsk);
+                        DBG(dev, "USB Disconnect (session valid low)\n");
+                        /* cleanup on disconnect */
+                        usb_disconnect(udc);
+                }
+
+        }
+
+        return ret_val;
+}
+
+/* Interrupt Service Routine, see Linux Kernel Doc for parameters */
+static irqreturn_t udc_irq(int irq, void *pdev)
+{
+        struct udc *dev = pdev;
+        u32 reg;
+        u16 i;
+        u32 ep_irq;
+        irqreturn_t ret_val = IRQ_NONE;
+
+        spin_lock(&dev->lock);
+
+        /* check for ep irq */
+        reg = readl(&dev->regs->ep_irqsts);
+        if (reg) {
+                if (reg & AMD_BIT(UDC_EPINT_OUT_EP0))
+                        ret_val |= udc_control_out_isr(dev);
+                if (reg & AMD_BIT(UDC_EPINT_IN_EP0))
+                        ret_val |= udc_control_in_isr(dev);
+
+                /*
+                 * data endpoint
+                 * iterate ep's
+                 */
+                for (i = 1; i < UDC_EP_NUM; i++) {
+                        ep_irq = 1 << i;
+                        if (!(reg & ep_irq) || i == UDC_EPINT_OUT_EP0)
+                                continue;
+
+                        /* clear irq status */
+                        writel(ep_irq, &dev->regs->ep_irqsts);
+
+                        /* irq for out ep ? */
+                        if (i > UDC_EPIN_NUM)
+                                ret_val |= udc_data_out_isr(dev, i);
+                        else
+                                ret_val |= udc_data_in_isr(dev, i);
+                }
+
+        }
+
+
+        /* check for dev irq */
+        reg = readl(&dev->regs->irqsts);
+        if (reg) {
+                /* clear irq */
+                writel(reg, &dev->regs->irqsts);
+                ret_val |= udc_dev_isr(dev, reg);
+        }
+
+
+        spin_unlock(&dev->lock);
+        return ret_val;
+}
+
+/* Tears down device */
+static void gadget_release(struct device *pdev)
+{
+        struct amd5536udc *dev = dev_get_drvdata(pdev);
+        kfree(dev);
+}
+
+/* Cleanup on device remove */
+static void udc_remove(struct udc *dev)
+{
+        /* remove timer */
+        stop_timer++;
+        if (timer_pending(&udc_timer))
+                wait_for_completion(&on_exit);
+        if (udc_timer.data)
+                del_timer_sync(&udc_timer);
+        /* remove pollstall timer */
+        stop_pollstall_timer++;
+        if (timer_pending(&udc_pollstall_timer))
+                wait_for_completion(&on_pollstall_exit);
+        if (udc_pollstall_timer.data)
+                del_timer_sync(&udc_pollstall_timer);
+        udc = NULL;
+}
+
+/* Reset all pci context */
+static void udc_pci_remove(struct pci_dev *pdev)
+{
+        struct udc              *dev;
+
+        dev = pci_get_drvdata(pdev);
+
+        /* gadget driver must not be registered */
+        BUG_ON(dev->driver != NULL);
+
+        /* dma pool cleanup */
+        if (dev->data_requests)
+                pci_pool_destroy(dev->data_requests);
+
+        if (dev->stp_requests) {
+                /* cleanup DMA desc's for ep0in */
+                pci_pool_free(dev->stp_requests,
+                        dev->ep[UDC_EP0OUT_IX].td_stp,
+                        dev->ep[UDC_EP0OUT_IX].td_stp_dma);
+                pci_pool_free(dev->stp_requests,
+                        dev->ep[UDC_EP0OUT_IX].td,
+                        dev->ep[UDC_EP0OUT_IX].td_phys);
+
+                pci_pool_destroy(dev->stp_requests);
+        }
+
+        /* reset controller */
+        writel(AMD_BIT(UDC_DEVCFG_SOFTRESET), &dev->regs->cfg);
+        if (dev->irq_registered)
+                free_irq(pdev->irq, dev);
+        if (dev->regs)
+                iounmap(dev->regs);
+        if (dev->mem_region)
+                release_mem_region(pci_resource_start(pdev, 0),
+                                pci_resource_len(pdev, 0));
+        if (dev->active)
+                pci_disable_device(pdev);
+
+        device_unregister(&dev->gadget.dev);
+        pci_set_drvdata(pdev, NULL);
+
+        udc_remove(dev);
+}
+
+/* create dma pools on init */
+static int init_dma_pools(struct udc *dev)
+{
+        struct udc_stp_dma      *td_stp;
+        struct udc_data_dma     *td_data;
+        int retval;
+
+        /* consistent DMA mode setting ? */
+        if (use_dma_ppb) {
+                use_dma_bufferfill_mode = 0;
+        } else {
+                use_dma_ppb_du = 0;
+                use_dma_bufferfill_mode = 1;
+        }
+
+        /* DMA setup */
+        dev->data_requests = dma_pool_create("data_requests", NULL,
+                sizeof(struct udc_data_dma), 0, 0);
+        if (!dev->data_requests) {
+                DBG(dev, "can't get request data pool\n");
+                retval = -ENOMEM;
+                goto finished;
+        }
+
+        /* EP0 in dma regs = dev control regs */
+        dev->ep[UDC_EP0IN_IX].dma = &dev->regs->ctl;
+
+        /* dma desc for setup data */
+        dev->stp_requests = dma_pool_create("setup requests", NULL,
+                sizeof(struct udc_stp_dma), 0, 0);
+        if (!dev->stp_requests) {
+                DBG(dev, "can't get stp request pool\n");
+                retval = -ENOMEM;
+                goto finished;
+        }
+        /* setup */
+        td_stp = dma_pool_alloc(dev->stp_requests, GFP_KERNEL,
+                                &dev->ep[UDC_EP0OUT_IX].td_stp_dma);
+        if (td_stp == NULL) {
+                retval = -ENOMEM;
+                goto finished;
+        }
+        dev->ep[UDC_EP0OUT_IX].td_stp = td_stp;
+
+        /* data: 0 packets !? */
+        td_data = dma_pool_alloc(dev->stp_requests, GFP_KERNEL,
+                                &dev->ep[UDC_EP0OUT_IX].td_phys);
+        if (td_data == NULL) {
+                retval = -ENOMEM;
+                goto finished;
+        }
+        dev->ep[UDC_EP0OUT_IX].td = td_data;
+        return 0;
+
+finished:
+        return retval;
+}
+
+/* Called by pci bus driver to init pci context */
+static int udc_pci_probe(
+        struct pci_dev *pdev,
+        const struct pci_device_id *id
+)
+{
+        struct udc              *dev;
+        unsigned long           resource;
+        unsigned long           len;
+        int                     retval = 0;
+
+        /* one udc only */
+        if (udc) {
+                dev_dbg(&pdev->dev, "already probed\n");
+                return -EBUSY;
+        }
+
+        /* init */
+        dev = kzalloc(sizeof(struct udc), GFP_KERNEL);
+        if (!dev) {
+                retval = -ENOMEM;
+                goto finished;
+        }
+        memset(dev, 0, sizeof(struct udc));
+
+        /* pci setup */
+        if (pci_enable_device(pdev) < 0) {
+                retval = -ENODEV;
+                goto finished;
+        }
+        dev->active = 1;
+
+        /* PCI resource allocation */
+        resource = pci_resource_start(pdev, 0);
+        len = pci_resource_len(pdev, 0);
+
+        if (!request_mem_region(resource, len, name)) {
+                dev_dbg(&pdev->dev, "pci device used already\n");
+                retval = -EBUSY;
+                goto finished;
+        }
+        dev->mem_region = 1;
+
+        dev->virt_addr = ioremap_nocache(resource, len);
+        if (dev->virt_addr == NULL) {
+                dev_dbg(&pdev->dev, "start address cannot be mapped\n");
+                retval = -EFAULT;
+                goto finished;
+        }
+
+        if (!pdev->irq) {
+                dev_err(&dev->pdev->dev, "irq not set\n");
+                retval = -ENODEV;
+                goto finished;
+        }
+
+        if (request_irq(pdev->irq, udc_irq, IRQF_SHARED, name, dev) != 0) {
+                dev_dbg(&dev->pdev->dev, "request_irq(%d) fail\n", pdev->irq);
+                retval = -EBUSY;
+                goto finished;
+        }
+        dev->irq_registered = 1;
+
+        pci_set_drvdata(pdev, dev);
+
+        /* chip revision */
+        dev->chiprev = 0;
+
+        pci_set_master(pdev);
+        pci_set_mwi(pdev);
+
+        /* chip rev for Hs AMD5536 */
+        pci_read_config_byte(pdev, PCI_REVISION_ID, (u8 *) &dev->chiprev);
+        /* init dma pools */
+        if (use_dma) {
+                retval = init_dma_pools(dev);
+                if (retval != 0)
+                        goto finished;
+        }
+
+        dev->phys_addr = resource;
+        dev->irq = pdev->irq;
+        dev->pdev = pdev;
+        dev->gadget.dev.parent = &pdev->dev;
+        dev->gadget.dev.dma_mask = pdev->dev.dma_mask;
+
+        /* general probing */
+        if (udc_probe(dev) == 0)
+                return 0;
+
+finished:
+        if (dev)
+                udc_pci_remove(pdev);
+        return retval;
+}
+
+/* general probe */
+static int udc_probe(struct udc *dev)
+{
+        char            tmp[128];
+        u32             reg;
+        int             retval;
+
+        /* mark timer as not initialized */
+        udc_timer.data = 0;
+        udc_pollstall_timer.data = 0;
+
+        /* device struct setup */
+        spin_lock_init(&dev->lock);
+        dev->gadget.ops = &udc_ops;
+
+        strcpy(dev->gadget.dev.bus_id, "gadget");
+        dev->gadget.dev.release = gadget_release;
+        dev->gadget.name = name;
+        dev->gadget.name = name;
+        dev->gadget.is_dualspeed = 1;
+
+        /* udc csr registers base */
+        dev->csr = dev->virt_addr + UDC_CSR_ADDR;
+        /* dev registers base */
+        dev->regs = dev->virt_addr + UDC_DEVCFG_ADDR;
+        /* ep registers base */
+        dev->ep_regs = dev->virt_addr + UDC_EPREGS_ADDR;
+        /* fifo's base */
+        dev->rxfifo = (u32 __iomem *)(dev->virt_addr + UDC_RXFIFO_ADDR);
+        dev->txfifo = (u32 __iomem *)(dev->virt_addr + UDC_TXFIFO_ADDR);
+
+        /* init registers, interrupts, ... */
+        startup_registers(dev);
+
+        dev_info(&dev->pdev->dev, "%s\n", mod_desc);
+
+        snprintf(tmp, sizeof tmp, "%d", dev->irq);
+        dev_info(&dev->pdev->dev,
+                "irq %s, pci mem %08lx, chip rev %02x(Geode5536 %s)\n",
+                tmp, dev->phys_addr, dev->chiprev,
+                (dev->chiprev == UDC_HSA0_REV) ? "A0" : "B1");
+        strcpy(tmp, UDC_DRIVER_VERSION_STRING);
+        if (dev->chiprev == UDC_HSA0_REV) {
+                dev_err(&dev->pdev->dev, "chip revision is A0; too old\n");
+                retval = -ENODEV;
+                goto finished;
+        }
+        dev_info(&dev->pdev->dev,
+                "driver version: %s(for Geode5536 B1)\n", tmp);
+        udc = dev;
+
+        retval = device_register(&dev->gadget.dev);
+        if (retval)
+                goto finished;
+
+        /* timer init */
+        init_timer(&udc_timer);
+        udc_timer.function = udc_timer_function;
+        udc_timer.data = 1;
+        /* timer pollstall init */
+        init_timer(&udc_pollstall_timer);
+        udc_pollstall_timer.function = udc_pollstall_timer_function;
+        udc_pollstall_timer.data = 1;
+
+        /* set SD */
+        reg = readl(&dev->regs->ctl);
+        reg |= AMD_BIT(UDC_DEVCTL_SD);
+        writel(reg, &dev->regs->ctl);
+
+        /* print dev register info */
+        print_regs(dev);
+
+        return 0;
+
+finished:
+        return retval;
+}
+
+/* Initiates a remote wakeup */
+static int udc_remote_wakeup(struct udc *dev)
+{
+        unsigned long flags;
+        u32 tmp;
+
+        DBG(dev, "UDC initiates remote wakeup\n");
+
+        spin_lock_irqsave(&dev->lock, flags);
+
+        tmp = readl(&dev->regs->ctl);
+        tmp |= AMD_BIT(UDC_DEVCTL_RES);
+        writel(tmp, &dev->regs->ctl);
+        tmp &= AMD_CLEAR_BIT(UDC_DEVCTL_RES);
+        writel(tmp, &dev->regs->ctl);
+
+        spin_unlock_irqrestore(&dev->lock, flags);
+        return 0;
+}
+
+/* PCI device parameters */
+static const struct pci_device_id pci_id[] = {
+        {
+                PCI_DEVICE(PCI_VENDOR_ID_AMD, 0x2096),
+                .class =        (PCI_CLASS_SERIAL_USB << 8) | 0xfe,
+                .class_mask =   0xffffffff,
+        },
+        {},
+};
+MODULE_DEVICE_TABLE(pci, pci_id);
+
+/* PCI functions */
+static struct pci_driver udc_pci_driver = {
+        .name =         (char *) name,
+        .id_table =     pci_id,
+        .probe =        udc_pci_probe,
+        .remove =       udc_pci_remove,
+};
+
+/* Inits driver */
+static int __init init(void)
+{
+        return pci_register_driver(&udc_pci_driver);
+}
+module_init(init);
+
+/* Cleans driver */
+static void __exit cleanup(void)
+{
+        pci_unregister_driver(&udc_pci_driver);
+}
+module_exit(cleanup);
+
+MODULE_DESCRIPTION(UDC_MOD_DESCRIPTION);
+MODULE_AUTHOR("Thomas Dahlmann");
+MODULE_LICENSE("GPL");
+
diff --git a/drivers/usb/gadget/amd5536udc.h b/drivers/usb/gadget/amd5536udc.h
new file mode 100644
index 000000000000..4bbabbbfc93f
--- /dev/null
+++ b/drivers/usb/gadget/amd5536udc.h
@@ -0,0 +1,626 @@
+/*
+ * amd5536.h -- header for AMD 5536 UDC high/full speed USB device controller
+ *
+ * Copyright (C) 2007 AMD (http://www.amd.com)
+ * Author: Thomas Dahlmann
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef AMD5536UDC_H
+#define AMD5536UDC_H
+
+/* various constants */
+#define UDC_RDE_TIMER_SECONDS           1
+#define UDC_RDE_TIMER_DIV               10
+#define UDC_POLLSTALL_TIMER_USECONDS    500
+
+/* Hs AMD5536 chip rev. */
+#define UDC_HSA0_REV 1
+#define UDC_HSB1_REV 2
+
+/*
+ * SETUP usb commands
+ * needed, because some SETUP's are handled in hw, but must be passed to
+ * gadget driver above
+ * SET_CONFIG
+ */
+#define UDC_SETCONFIG_DWORD0                    0x00000900
+#define UDC_SETCONFIG_DWORD0_VALUE_MASK         0xffff0000
+#define UDC_SETCONFIG_DWORD0_VALUE_OFS          16
+
+#define UDC_SETCONFIG_DWORD1                    0x00000000
+
+/* SET_INTERFACE */
+#define UDC_SETINTF_DWORD0                      0x00000b00
+#define UDC_SETINTF_DWORD0_ALT_MASK             0xffff0000
+#define UDC_SETINTF_DWORD0_ALT_OFS              16
+
+#define UDC_SETINTF_DWORD1                      0x00000000
+#define UDC_SETINTF_DWORD1_INTF_MASK            0x0000ffff
+#define UDC_SETINTF_DWORD1_INTF_OFS             0
+
+/* Mass storage reset */
+#define UDC_MSCRES_DWORD0                       0x0000ff21
+#define UDC_MSCRES_DWORD1                       0x00000000
+
+/* Global CSR's -------------------------------------------------------------*/
+#define UDC_CSR_ADDR                            0x500
+
+/* EP NE bits */
+/* EP number */
+#define UDC_CSR_NE_NUM_MASK                     0x0000000f
+#define UDC_CSR_NE_NUM_OFS                      0
+/* EP direction */
+#define UDC_CSR_NE_DIR_MASK                     0x00000010
+#define UDC_CSR_NE_DIR_OFS                      4
+/* EP type */
+#define UDC_CSR_NE_TYPE_MASK                    0x00000060
+#define UDC_CSR_NE_TYPE_OFS                     5
+/* EP config number */
+#define UDC_CSR_NE_CFG_MASK                     0x00000780
+#define UDC_CSR_NE_CFG_OFS                      7
+/* EP interface number */
+#define UDC_CSR_NE_INTF_MASK                    0x00007800
+#define UDC_CSR_NE_INTF_OFS                     11
+/* EP alt setting */
+#define UDC_CSR_NE_ALT_MASK                     0x00078000
+#define UDC_CSR_NE_ALT_OFS                      15
+
+/* max pkt */
+#define UDC_CSR_NE_MAX_PKT_MASK                 0x3ff80000
+#define UDC_CSR_NE_MAX_PKT_OFS                  19
+
+/* Device Config Register ---------------------------------------------------*/
+#define UDC_DEVCFG_ADDR                         0x400
+
+#define UDC_DEVCFG_SOFTRESET                    31
+#define UDC_DEVCFG_HNPSFEN                      30
+#define UDC_DEVCFG_DMARST                       29
+#define UDC_DEVCFG_SET_DESC                     18
+#define UDC_DEVCFG_CSR_PRG                      17
+#define UDC_DEVCFG_STATUS                       7
+#define UDC_DEVCFG_DIR                          6
+#define UDC_DEVCFG_PI                           5
+#define UDC_DEVCFG_SS                           4
+#define UDC_DEVCFG_SP                           3
+#define UDC_DEVCFG_RWKP                         2
+
+#define UDC_DEVCFG_SPD_MASK                     0x3
+#define UDC_DEVCFG_SPD_OFS                      0
+#define UDC_DEVCFG_SPD_HS                       0x0
+#define UDC_DEVCFG_SPD_FS                       0x1
+#define UDC_DEVCFG_SPD_LS                       0x2
+/*#define UDC_DEVCFG_SPD_FS                     0x3*/
+
+
+/* Device Control Register --------------------------------------------------*/
+#define UDC_DEVCTL_ADDR                         0x404
+
+#define UDC_DEVCTL_THLEN_MASK                   0xff000000
+#define UDC_DEVCTL_THLEN_OFS                    24
+
+#define UDC_DEVCTL_BRLEN_MASK                   0x00ff0000
+#define UDC_DEVCTL_BRLEN_OFS                    16
+
+#define UDC_DEVCTL_CSR_DONE                     13
+#define UDC_DEVCTL_DEVNAK                       12
+#define UDC_DEVCTL_SD                           10
+#define UDC_DEVCTL_MODE                         9
+#define UDC_DEVCTL_BREN                         8
+#define UDC_DEVCTL_THE                          7
+#define UDC_DEVCTL_BF                           6
+#define UDC_DEVCTL_BE                           5
+#define UDC_DEVCTL_DU                           4
+#define UDC_DEVCTL_TDE                          3
+#define UDC_DEVCTL_RDE                          2
+#define UDC_DEVCTL_RES                          0
+
+
+/* Device Status Register ---------------------------------------------------*/
+#define UDC_DEVSTS_ADDR                         0x408
+
+#define UDC_DEVSTS_TS_MASK                      0xfffc0000
+#define UDC_DEVSTS_TS_OFS                       18
+
+#define UDC_DEVSTS_SESSVLD                      17
+#define UDC_DEVSTS_PHY_ERROR                    16
+#define UDC_DEVSTS_RXFIFO_EMPTY                 15
+
+#define UDC_DEVSTS_ENUM_SPEED_MASK              0x00006000
+#define UDC_DEVSTS_ENUM_SPEED_OFS               13
+#define UDC_DEVSTS_ENUM_SPEED_FULL              1
+#define UDC_DEVSTS_ENUM_SPEED_HIGH              0
+
+#define UDC_DEVSTS_SUSP                         12
+
+#define UDC_DEVSTS_ALT_MASK                     0x00000f00
+#define UDC_DEVSTS_ALT_OFS                      8
+
+#define UDC_DEVSTS_INTF_MASK                    0x000000f0
+#define UDC_DEVSTS_INTF_OFS                     4
+
+#define UDC_DEVSTS_CFG_MASK                     0x0000000f
+#define UDC_DEVSTS_CFG_OFS                      0
+
+
+/* Device Interrupt Register ------------------------------------------------*/
+#define UDC_DEVINT_ADDR                         0x40c
+
+#define UDC_DEVINT_SVC                          7
+#define UDC_DEVINT_ENUM                         6
+#define UDC_DEVINT_SOF                          5
+#define UDC_DEVINT_US                           4
+#define UDC_DEVINT_UR                           3
+#define UDC_DEVINT_ES                           2
+#define UDC_DEVINT_SI                           1
+#define UDC_DEVINT_SC                           0
+
+/* Device Interrupt Mask Register -------------------------------------------*/
+#define UDC_DEVINT_MSK_ADDR                     0x410
+
+#define UDC_DEVINT_MSK                          0x7f
+
+/* Endpoint Interrupt Register ----------------------------------------------*/
+#define UDC_EPINT_ADDR                          0x414
+
+#define UDC_EPINT_OUT_MASK                      0xffff0000
+#define UDC_EPINT_OUT_OFS                       16
+#define UDC_EPINT_IN_MASK                       0x0000ffff
+#define UDC_EPINT_IN_OFS                        0
+
+#define UDC_EPINT_IN_EP0                        0
+#define UDC_EPINT_IN_EP1                        1
+#define UDC_EPINT_IN_EP2                        2
+#define UDC_EPINT_IN_EP3                        3
+#define UDC_EPINT_OUT_EP0                       16
+#define UDC_EPINT_OUT_EP1                       17
+#define UDC_EPINT_OUT_EP2                       18
+#define UDC_EPINT_OUT_EP3                       19
+
+#define UDC_EPINT_EP0_ENABLE_MSK                0x001e001e
+
+/* Endpoint Interrupt Mask Register -----------------------------------------*/
+#define UDC_EPINT_MSK_ADDR                      0x418
+
+#define UDC_EPINT_OUT_MSK_MASK                  0xffff0000
+#define UDC_EPINT_OUT_MSK_OFS                   16
+#define UDC_EPINT_IN_MSK_MASK                   0x0000ffff
+#define UDC_EPINT_IN_MSK_OFS                    0
+
+#define UDC_EPINT_MSK_DISABLE_ALL               0xffffffff
+/* mask non-EP0 endpoints */
+#define UDC_EPDATAINT_MSK_DISABLE               0xfffefffe
+/* mask all dev interrupts */
+#define UDC_DEV_MSK_DISABLE                     0x7f
+
+/* Endpoint-specific CSR's --------------------------------------------------*/
+#define UDC_EPREGS_ADDR                         0x0
+#define UDC_EPIN_REGS_ADDR                      0x0
+#define UDC_EPOUT_REGS_ADDR                     0x200
+
+#define UDC_EPCTL_ADDR                          0x0
+
+#define UDC_EPCTL_RRDY                          9
+#define UDC_EPCTL_CNAK                          8
+#define UDC_EPCTL_SNAK                          7
+#define UDC_EPCTL_NAK                           6
+
+#define UDC_EPCTL_ET_MASK                       0x00000030
+#define UDC_EPCTL_ET_OFS                        4
+#define UDC_EPCTL_ET_CONTROL                    0
+#define UDC_EPCTL_ET_ISO                        1
+#define UDC_EPCTL_ET_BULK                       2
+#define UDC_EPCTL_ET_INTERRUPT                  3
+
+#define UDC_EPCTL_P                             3
+#define UDC_EPCTL_SN                            2
+#define UDC_EPCTL_F                             1
+#define UDC_EPCTL_S                             0
+
+/* Endpoint Status Registers ------------------------------------------------*/
+#define UDC_EPSTS_ADDR                          0x4
+
+#define UDC_EPSTS_RX_PKT_SIZE_MASK              0x007ff800
+#define UDC_EPSTS_RX_PKT_SIZE_OFS               11
+
+#define UDC_EPSTS_TDC                           10
+#define UDC_EPSTS_HE                            9
+#define UDC_EPSTS_BNA                           7
+#define UDC_EPSTS_IN                            6
+
+#define UDC_EPSTS_OUT_MASK                      0x00000030
+#define UDC_EPSTS_OUT_OFS                       4
+#define UDC_EPSTS_OUT_DATA                      1
+#define UDC_EPSTS_OUT_DATA_CLEAR                0x10
+#define UDC_EPSTS_OUT_SETUP                     2
+#define UDC_EPSTS_OUT_SETUP_CLEAR               0x20
+#define UDC_EPSTS_OUT_CLEAR                     0x30
+
+/* Endpoint Buffer Size IN/ Receive Packet Frame Number OUT Registers ------*/
+#define UDC_EPIN_BUFF_SIZE_ADDR                 0x8
+#define UDC_EPOUT_FRAME_NUMBER_ADDR             0x8
+
+#define UDC_EPIN_BUFF_SIZE_MASK                 0x0000ffff
+#define UDC_EPIN_BUFF_SIZE_OFS                  0
+/* EP0in txfifo = 128 bytes*/
+#define UDC_EPIN0_BUFF_SIZE                     32
+/* EP0in fullspeed txfifo = 128 bytes*/
+#define UDC_FS_EPIN0_BUFF_SIZE                  32
+
+/* fifo size mult = fifo size / max packet */
+#define UDC_EPIN_BUFF_SIZE_MULT                 2
+
+/* EPin data fifo size = 1024 bytes DOUBLE BUFFERING */
+#define UDC_EPIN_BUFF_SIZE                      256
+/* EPin small INT data fifo size = 128 bytes */
+#define UDC_EPIN_SMALLINT_BUFF_SIZE             32
+
+/* EPin fullspeed data fifo size = 128 bytes DOUBLE BUFFERING */
+#define UDC_FS_EPIN_BUFF_SIZE                   32
+
+#define UDC_EPOUT_FRAME_NUMBER_MASK             0x0000ffff
+#define UDC_EPOUT_FRAME_NUMBER_OFS              0
+
+/* Endpoint Buffer Size OUT/Max Packet Size Registers -----------------------*/
+#define UDC_EPOUT_BUFF_SIZE_ADDR                0x0c
+#define UDC_EP_MAX_PKT_SIZE_ADDR                0x0c
+
+#define UDC_EPOUT_BUFF_SIZE_MASK                0xffff0000
+#define UDC_EPOUT_BUFF_SIZE_OFS                 16
+#define UDC_EP_MAX_PKT_SIZE_MASK                0x0000ffff
+#define UDC_EP_MAX_PKT_SIZE_OFS                 0
+/* EP0in max packet size = 64 bytes */
+#define UDC_EP0IN_MAX_PKT_SIZE                  64
+/* EP0out max packet size = 64 bytes */
+#define UDC_EP0OUT_MAX_PKT_SIZE                 64
+/* EP0in fullspeed max packet size = 64 bytes */
+#define UDC_FS_EP0IN_MAX_PKT_SIZE               64
+/* EP0out fullspeed max packet size = 64 bytes */
+#define UDC_FS_EP0OUT_MAX_PKT_SIZE              64
+
+/*
+ * Endpoint dma descriptors ------------------------------------------------
+ *
+ * Setup data, Status dword
+ */
+#define UDC_DMA_STP_STS_CFG_MASK                0x0fff0000
+#define UDC_DMA_STP_STS_CFG_OFS                 16
+#define UDC_DMA_STP_STS_CFG_ALT_MASK            0x000f0000
+#define UDC_DMA_STP_STS_CFG_ALT_OFS             16
+#define UDC_DMA_STP_STS_CFG_INTF_MASK           0x00f00000
+#define UDC_DMA_STP_STS_CFG_INTF_OFS            20
+#define UDC_DMA_STP_STS_CFG_NUM_MASK            0x0f000000
+#define UDC_DMA_STP_STS_CFG_NUM_OFS             24
+#define UDC_DMA_STP_STS_RX_MASK                 0x30000000
+#define UDC_DMA_STP_STS_RX_OFS                  28
+#define UDC_DMA_STP_STS_BS_MASK                 0xc0000000
+#define UDC_DMA_STP_STS_BS_OFS                  30
+#define UDC_DMA_STP_STS_BS_HOST_READY           0
+#define UDC_DMA_STP_STS_BS_DMA_BUSY             1
+#define UDC_DMA_STP_STS_BS_DMA_DONE             2
+#define UDC_DMA_STP_STS_BS_HOST_BUSY            3
+/* IN data, Status dword */
+#define UDC_DMA_IN_STS_TXBYTES_MASK             0x0000ffff
+#define UDC_DMA_IN_STS_TXBYTES_OFS              0
+#define UDC_DMA_IN_STS_FRAMENUM_MASK            0x07ff0000
+#define UDC_DMA_IN_STS_FRAMENUM_OFS             0
+#define UDC_DMA_IN_STS_L                        27
+#define UDC_DMA_IN_STS_TX_MASK                  0x30000000
+#define UDC_DMA_IN_STS_TX_OFS                   28
+#define UDC_DMA_IN_STS_BS_MASK                  0xc0000000
+#define UDC_DMA_IN_STS_BS_OFS                   30
+#define UDC_DMA_IN_STS_BS_HOST_READY            0
+#define UDC_DMA_IN_STS_BS_DMA_BUSY              1
+#define UDC_DMA_IN_STS_BS_DMA_DONE              2
+#define UDC_DMA_IN_STS_BS_HOST_BUSY             3
+/* OUT data, Status dword */
+#define UDC_DMA_OUT_STS_RXBYTES_MASK            0x0000ffff
+#define UDC_DMA_OUT_STS_RXBYTES_OFS             0
+#define UDC_DMA_OUT_STS_FRAMENUM_MASK           0x07ff0000
+#define UDC_DMA_OUT_STS_FRAMENUM_OFS            0
+#define UDC_DMA_OUT_STS_L                       27
+#define UDC_DMA_OUT_STS_RX_MASK                 0x30000000
+#define UDC_DMA_OUT_STS_RX_OFS                  28
+#define UDC_DMA_OUT_STS_BS_MASK                 0xc0000000
+#define UDC_DMA_OUT_STS_BS_OFS                  30
+#define UDC_DMA_OUT_STS_BS_HOST_READY           0
+#define UDC_DMA_OUT_STS_BS_DMA_BUSY             1
+#define UDC_DMA_OUT_STS_BS_DMA_DONE             2
+#define UDC_DMA_OUT_STS_BS_HOST_BUSY            3
+/* max ep0in packet */
+#define UDC_EP0IN_MAXPACKET                     1000
+/* max dma packet */
+#define UDC_DMA_MAXPACKET                       65536
+
+/* un-usable DMA address */
+#define DMA_DONT_USE                            (~(dma_addr_t) 0 )
+
+/* other Endpoint register addresses and values-----------------------------*/
+#define UDC_EP_SUBPTR_ADDR                      0x10
+#define UDC_EP_DESPTR_ADDR                      0x14
+#define UDC_EP_WRITE_CONFIRM_ADDR               0x1c
+
+/* EP number as layouted in AHB space */
+#define UDC_EP_NUM                              32
+#define UDC_EPIN_NUM                            16
+#define UDC_EPIN_NUM_USED                       5
+#define UDC_EPOUT_NUM                           16
+/* EP number of EP's really used = EP0 + 8 data EP's */
+#define UDC_USED_EP_NUM                         9
+/* UDC CSR regs are aligned but AHB regs not - offset for OUT EP's */
+#define UDC_CSR_EP_OUT_IX_OFS                   12
+
+#define UDC_EP0OUT_IX                           16
+#define UDC_EP0IN_IX                            0
+
+/* Rx fifo address and size = 1k -------------------------------------------*/
+#define UDC_RXFIFO_ADDR                         0x800
+#define UDC_RXFIFO_SIZE                         0x400
+
+/* Tx fifo address and size = 1.5k -----------------------------------------*/
+#define UDC_TXFIFO_ADDR                         0xc00
+#define UDC_TXFIFO_SIZE                         0x600
+
+/* default data endpoints --------------------------------------------------*/
+#define UDC_EPIN_STATUS_IX                      1
+#define UDC_EPIN_IX                             2
+#define UDC_EPOUT_IX                            18
+
+/* general constants -------------------------------------------------------*/
+#define UDC_DWORD_BYTES                         4
+#define UDC_BITS_PER_BYTE_SHIFT                 3
+#define UDC_BYTE_MASK                           0xff
+#define UDC_BITS_PER_BYTE                       8
+
+/*---------------------------------------------------------------------------*/
+/* UDC CSR's */
+struct udc_csrs {
+
+        /* sca - setup command address */
+        u32 sca;
+
+        /* ep ne's */
+        u32 ne[UDC_USED_EP_NUM];
+} __attribute__ ((packed));
+
+/* AHB subsystem CSR registers */
+struct udc_regs {
+
+        /* device configuration */
+        u32 cfg;
+
+        /* device control */
+        u32 ctl;
+
+        /* device status */
+        u32 sts;
+
+        /* device interrupt */
+        u32 irqsts;
+
+        /* device interrupt mask */
+        u32 irqmsk;
+
+        /* endpoint interrupt */
+        u32 ep_irqsts;
+
+        /* endpoint interrupt mask */
+        u32 ep_irqmsk;
+} __attribute__ ((packed));
+
+/* endpoint specific registers */
+struct udc_ep_regs {
+
+        /* endpoint control */
+        u32 ctl;
+
+        /* endpoint status */
+        u32 sts;
+
+        /* endpoint buffer size in/ receive packet frame number out */
+        u32 bufin_framenum;
+
+        /* endpoint buffer size out/max packet size */
+        u32 bufout_maxpkt;
+
+        /* endpoint setup buffer pointer */
+        u32 subptr;
+
+        /* endpoint data descriptor pointer */
+        u32 desptr;
+
+        /* reserverd */
+        u32 reserved;
+
+        /* write/read confirmation */
+        u32 confirm;
+
+} __attribute__ ((packed));
+
+/* control data DMA desc */
+struct udc_stp_dma {
+        /* status quadlet */
+        u32     status;
+        /* reserved */
+        u32     _reserved;
+        /* first setup word */
+        u32     data12;
+        /* second setup word */
+        u32     data34;
+} __attribute__ ((aligned (16)));
+
+/* normal data DMA desc */
+struct udc_data_dma {
+        /* status quadlet */
+        u32     status;
+        /* reserved */
+        u32     _reserved;
+        /* buffer pointer */
+        u32     bufptr;
+        /* next descriptor pointer */
+        u32     next;
+} __attribute__ ((aligned (16)));
+
+/* request packet */
+struct udc_request {
+        /* embedded gadget ep */
+        struct usb_request              req;
+
+        /* flags */
+        unsigned                        dma_going : 1,
+                                        dma_mapping : 1,
+                                        dma_done : 1;
+        /* phys. address */
+        dma_addr_t                      td_phys;
+        /* first dma desc. of chain */
+        struct udc_data_dma             *td_data;
+        /* last dma desc. of chain */
+        struct udc_data_dma             *td_data_last;
+        struct list_head                queue;
+
+        /* chain length */
+        unsigned                        chain_len;
+
+};
+
+/* UDC specific endpoint parameters */
+struct udc_ep {
+        struct usb_ep                   ep;
+        struct udc_ep_regs __iomem      *regs;
+        u32 __iomem                     *txfifo;
+        u32 __iomem                     *dma;
+        dma_addr_t                      td_phys;
+        dma_addr_t                      td_stp_dma;
+        struct udc_stp_dma              *td_stp;
+        struct udc_data_dma             *td;
+        /* temp request */
+        struct udc_request              *req;
+        unsigned                        req_used;
+        unsigned                        req_completed;
+        /* dummy DMA desc for BNA dummy */
+        struct udc_request              *bna_dummy_req;
+        unsigned                        bna_occurred;
+
+        /* NAK state */
+        unsigned                        naking;
+
+        struct udc                      *dev;
+
+        /* queue for requests */
+        struct list_head                queue;
+        const struct usb_endpoint_descriptor    *desc;
+        unsigned                        halted;
+        unsigned                        cancel_transfer;
+        unsigned                        num : 5,
+                                        fifo_depth : 14,
+                                        in : 1;
+};
+
+/* device struct */
+struct udc {
+        struct usb_gadget               gadget;
+        spinlock_t                      lock;   /* protects all state */
+        /* all endpoints */
+        struct udc_ep                   ep[UDC_EP_NUM];
+        struct usb_gadget_driver        *driver;
+        /* operational flags */
+        unsigned                        active : 1,
+                                        stall_ep0in : 1,
+                                        waiting_zlp_ack_ep0in : 1,
+                                        set_cfg_not_acked : 1,
+                                        irq_registered : 1,
+                                        data_ep_enabled : 1,
+                                        data_ep_queued : 1,
+                                        mem_region : 1,
+                                        sys_suspended : 1,
+                                        connected;
+
+        u16                             chiprev;
+
+        /* registers */
+        struct pci_dev                  *pdev;
+        struct udc_csrs __iomem         *csr;
+        struct udc_regs __iomem         *regs;
+        struct udc_ep_regs __iomem      *ep_regs;
+        u32 __iomem                     *rxfifo;
+        u32 __iomem                     *txfifo;
+
+        /* DMA desc pools */
+        struct pci_pool                 *data_requests;
+        struct pci_pool                 *stp_requests;
+
+        /* device data */
+        unsigned long                   phys_addr;
+        void __iomem                    *virt_addr;
+        unsigned                        irq;
+
+        /* states */
+        u16                             cur_config;
+        u16                             cur_intf;
+        u16                             cur_alt;
+};
+
+/* setup request data */
+union udc_setup_data {
+        u32                     data[2];
+        struct usb_ctrlrequest  request;
+};
+
+/*
+ *---------------------------------------------------------------------------
+ * SET and GET bitfields in u32 values
+ * via constants for mask/offset:
+ * <bit_field_stub_name> is the text between
+ * UDC_ and _MASK|_OFS of appropiate
+ * constant
+ *
+ * set bitfield value in u32 u32Val
+ */
+#define AMD_ADDBITS(u32Val, bitfield_val, bitfield_stub_name)           \
+        (((u32Val) & (((u32) ~((u32) bitfield_stub_name##_MASK))))      \
+        | (((bitfield_val) << ((u32) bitfield_stub_name##_OFS))         \
+                & ((u32) bitfield_stub_name##_MASK)))
+
+/*
+ * set bitfield value in zero-initialized u32 u32Val
+ * => bitfield bits in u32Val are all zero
+ */
+#define AMD_INIT_SETBITS(u32Val, bitfield_val, bitfield_stub_name)      \
+        ((u32Val)                                                       \
+        | (((bitfield_val) << ((u32) bitfield_stub_name##_OFS))         \
+                & ((u32) bitfield_stub_name##_MASK)))
+
+/* get bitfield value from u32 u32Val */
+#define AMD_GETBITS(u32Val, bitfield_stub_name)                         \
+        ((u32Val & ((u32) bitfield_stub_name##_MASK))                   \
+                >> ((u32) bitfield_stub_name##_OFS))
+
+/* SET and GET bits in u32 values ------------------------------------------*/
+#define AMD_BIT(bit_stub_name) (1 << bit_stub_name)
+#define AMD_UNMASK_BIT(bit_stub_name) (~AMD_BIT(bit_stub_name))
+#define AMD_CLEAR_BIT(bit_stub_name) (~AMD_BIT(bit_stub_name))
+
+/* debug macros ------------------------------------------------------------*/
+
+#define DBG(udc , args...)      dev_dbg(&(udc)->pdev->dev, args)
+
+#ifdef UDC_VERBOSE
+#define VDBG                    DBG
+#else
+#define VDBG(udc , args...)     do {} while (0)
+#endif
+
+#endif /* #ifdef AMD5536UDC_H */
diff --git a/drivers/usb/gadget/ether.c b/drivers/usb/gadget/ether.c
index dbaf867436df..a3376739a81b 100644
--- a/drivers/usb/gadget/ether.c
+++ b/drivers/usb/gadget/ether.c
@@ -305,6 +305,10 @@ MODULE_PARM_DESC(host_addr, "Host Ethernet Address");
 #define DEV_CONFIG_CDC
 #endif
 
+#ifdef CONFIG_USB_GADGET_AMD5536UDC
+#define DEV_CONFIG_CDC
+#endif
+
 
 /*-------------------------------------------------------------------------*/
 
diff --git a/drivers/usb/gadget/gadget_chips.h b/drivers/usb/gadget/gadget_chips.h
index 53e9139ba388..f7f159c1002b 100644
--- a/drivers/usb/gadget/gadget_chips.h
+++ b/drivers/usb/gadget/gadget_chips.h
@@ -17,6 +17,12 @@
 #define gadget_is_net2280(g)    0
 #endif
 
+#ifdef CONFIG_USB_GADGET_AMD5536UDC
+#define gadget_is_amd5536udc(g) !strcmp("amd5536udc", (g)->name)
+#else
+#define gadget_is_amd5536udc(g) 0
+#endif
+
 #ifdef CONFIG_USB_GADGET_DUMMY_HCD
 #define gadget_is_dummy(g)      !strcmp("dummy_udc", (g)->name)
 #else
@@ -202,7 +208,9 @@ static inline int usb_gadget_controller_number(struct usb_gadget *gadget)
                 return 0x18;
         else if (gadget_is_fsl_usb2(gadget))
                 return 0x19;
-        else if (gadget_is_m66592(gadget))
+        else if (gadget_is_amd5536udc(gadget))
                 return 0x20;
+        else if (gadget_is_m66592(gadget))
+                return 0x21;
         return -ENOENT;
 }
diff --git a/drivers/usb/gadget/m66592-udc.c b/drivers/usb/gadget/m66592-udc.c
index 0174a322e007..700dda8a9157 100644
--- a/drivers/usb/gadget/m66592-udc.c
+++ b/drivers/usb/gadget/m66592-udc.c
@@ -21,26 +21,18 @@
  */
 
 #include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/sched.h>
-#include <linux/smp_lock.h>
-#include <linux/errno.h>
-#include <linux/init.h>
-#include <linux/timer.h>
-#include <linux/delay.h>
-#include <linux/list.h>
 #include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/io.h>
 #include <linux/platform_device.h>
+
 #include <linux/usb/ch9.h>
 #include <linux/usb_gadget.h>
 
-#include <asm/io.h>
-#include <asm/irq.h>
-#include <asm/system.h>
-
 #include "m66592-udc.h"
 
-MODULE_DESCRIPTION("M66592 USB gadget driiver");
+
+MODULE_DESCRIPTION("M66592 USB gadget driver");
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Yoshihiro Shimoda");
 
@@ -49,16 +41,21 @@ MODULE_AUTHOR("Yoshihiro Shimoda");
 /* module parameters */
 static unsigned short clock = M66592_XTAL24;
 module_param(clock, ushort, 0644);
-MODULE_PARM_DESC(clock, "input clock: 48MHz=32768, 24MHz=16384, 12MHz=0(default=16384)");
+MODULE_PARM_DESC(clock, "input clock: 48MHz=32768, 24MHz=16384, 12MHz=0 "
+                "(default=16384)");
+
 static unsigned short vif = M66592_LDRV;
 module_param(vif, ushort, 0644);
-MODULE_PARM_DESC(vif, "input VIF: 3.3V=32768, 1.5V=0(default=32768)");
-static unsigned short endian = 0;
+MODULE_PARM_DESC(vif, "input VIF: 3.3V=32768, 1.5V=0 (default=32768)");
+
+static unsigned short endian;
 module_param(endian, ushort, 0644);
-MODULE_PARM_DESC(endian, "data endian: big=256, little=0(default=0)");
+MODULE_PARM_DESC(endian, "data endian: big=256, little=0 (default=0)");
+
 static unsigned short irq_sense = M66592_INTL;
 module_param(irq_sense, ushort, 0644);
-MODULE_PARM_DESC(irq_sense, "IRQ sense: low level=2, falling edge=0(default=2)");
+MODULE_PARM_DESC(irq_sense, "IRQ sense: low level=2, falling edge=0 "
+                "(default=2)");
 
 static const char udc_name[] = "m66592_udc";
 static const char *m66592_ep_name[] = {
@@ -72,8 +69,8 @@ static int m66592_queue(struct usb_ep *_ep, struct usb_request *_req,
                         gfp_t gfp_flags);
 
 static void transfer_complete(struct m66592_ep *ep,
-                              struct m66592_request *req,
-                              int status);
+                struct m66592_request *req, int status);
+
 /*-------------------------------------------------------------------------*/
 static inline u16 get_usb_speed(struct m66592 *m66592)
 {
@@ -81,25 +78,25 @@ static inline u16 get_usb_speed(struct m66592 *m66592)
 }
 
 static void enable_pipe_irq(struct m66592 *m66592, u16 pipenum,
-                            unsigned long reg)
+                unsigned long reg)
 {
         u16 tmp;
 
         tmp = m66592_read(m66592, M66592_INTENB0);
         m66592_bclr(m66592, M66592_BEMPE | M66592_NRDYE | M66592_BRDYE,
-                    M66592_INTENB0);
+                        M66592_INTENB0);
         m66592_bset(m66592, (1 << pipenum), reg);
         m66592_write(m66592, tmp, M66592_INTENB0);
 }
 
 static void disable_pipe_irq(struct m66592 *m66592, u16 pipenum,
-                             unsigned long reg)
+                unsigned long reg)
 {
         u16 tmp;
 
         tmp = m66592_read(m66592, M66592_INTENB0);
         m66592_bclr(m66592, M66592_BEMPE | M66592_NRDYE | M66592_BRDYE,
-                    M66592_INTENB0);
+                        M66592_INTENB0);
         m66592_bclr(m66592, (1 << pipenum), reg);
         m66592_write(m66592, tmp, M66592_INTENB0);
 }
@@ -108,17 +105,19 @@ static void m66592_usb_connect(struct m66592 *m66592)
 {
         m66592_bset(m66592, M66592_CTRE, M66592_INTENB0);
         m66592_bset(m66592, M66592_WDST | M66592_RDST | M66592_CMPL,
-                    M66592_INTENB0);
+                        M66592_INTENB0);
         m66592_bset(m66592, M66592_BEMPE | M66592_BRDYE, M66592_INTENB0);
 
         m66592_bset(m66592, M66592_DPRPU, M66592_SYSCFG);
 }
 
 static void m66592_usb_disconnect(struct m66592 *m66592)
+__releases(m66592->lock)
+__acquires(m66592->lock)
 {
         m66592_bclr(m66592, M66592_CTRE, M66592_INTENB0);
         m66592_bclr(m66592, M66592_WDST | M66592_RDST | M66592_CMPL,
-                    M66592_INTENB0);
+                        M66592_INTENB0);
         m66592_bclr(m66592, M66592_BEMPE | M66592_BRDYE, M66592_INTENB0);
         m66592_bclr(m66592, M66592_DPRPU, M66592_SYSCFG);
 
@@ -148,7 +147,7 @@ static inline u16 control_reg_get_pid(struct m66592 *m66592, u16 pipenum)
 }
 
 static inline void control_reg_set_pid(struct m66592 *m66592, u16 pipenum,
-                                       u16 pid)
+                u16 pid)
 {
         unsigned long offset;
 
@@ -250,7 +249,7 @@ static inline void pipe_change(struct m66592 *m66592, u16 pipenum)
 }
 
 static int pipe_buffer_setting(struct m66592 *m66592,
-                               struct m66592_pipe_info *info)
+                struct m66592_pipe_info *info)
 {
         u16 bufnum = 0, buf_bsize = 0;
         u16 pipecfg = 0;
@@ -287,7 +286,7 @@ static int pipe_buffer_setting(struct m66592 *m66592,
         }
         if (m66592->bi_bufnum > M66592_MAX_BUFNUM) {
                 printk(KERN_ERR "m66592 pipe memory is insufficient(%d)\n",
-                       m66592->bi_bufnum);
+                                m66592->bi_bufnum);
                 return -ENOMEM;
         }
 
@@ -328,7 +327,7 @@ static void pipe_buffer_release(struct m66592 *m66592,
                         m66592->bulk--;
         } else
                 printk(KERN_ERR "ep_release: unexpect pipenum (%d)\n",
-                       info->pipe);
+                                info->pipe);
 }
 
 static void pipe_initialize(struct m66592_ep *ep)
@@ -350,8 +349,8 @@ static void pipe_initialize(struct m66592_ep *ep)
 }
 
 static void m66592_ep_setting(struct m66592 *m66592, struct m66592_ep *ep,
-                              const struct usb_endpoint_descriptor *desc,
-                              u16 pipenum, int dma)
+                const struct usb_endpoint_descriptor *desc,
+                u16 pipenum, int dma)
 {
         if ((pipenum != 0) && dma) {
                 if (m66592->num_dma == 0) {
@@ -385,7 +384,7 @@ static void m66592_ep_setting(struct m66592 *m66592, struct m66592_ep *ep,
 
         ep->pipectr = get_pipectr_addr(pipenum);
         ep->pipenum = pipenum;
-        ep->ep.maxpacket = desc->wMaxPacketSize;
+        ep->ep.maxpacket = le16_to_cpu(desc->wMaxPacketSize);
         m66592->pipenum2ep[pipenum] = ep;
         m66592->epaddr2ep[desc->bEndpointAddress&USB_ENDPOINT_NUMBER_MASK] = ep;
         INIT_LIST_HEAD(&ep->queue);
@@ -407,7 +406,7 @@ static void m66592_ep_release(struct m66592_ep *ep)
 }
 
 static int alloc_pipe_config(struct m66592_ep *ep,
-                             const struct usb_endpoint_descriptor *desc)
+                const struct usb_endpoint_descriptor *desc)
 {
         struct m66592 *m66592 = ep->m66592;
         struct m66592_pipe_info info;
@@ -419,15 +418,15 @@ static int alloc_pipe_config(struct m66592_ep *ep,
 
         BUG_ON(ep->pipenum);
 
-        switch(desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
+        switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
         case USB_ENDPOINT_XFER_BULK:
                 if (m66592->bulk >= M66592_MAX_NUM_BULK) {
                         if (m66592->isochronous >= M66592_MAX_NUM_ISOC) {
                                 printk(KERN_ERR "bulk pipe is insufficient\n");
                                 return -ENODEV;
                         } else {
-                                info.pipe = M66592_BASE_PIPENUM_ISOC +
-                                            m66592->isochronous;
+                                info.pipe = M66592_BASE_PIPENUM_ISOC
+                                                + m66592->isochronous;
                                 counter = &m66592->isochronous;
                         }
                 } else {
@@ -462,7 +461,7 @@ static int alloc_pipe_config(struct m66592_ep *ep,
         ep->type = info.type;
 
         info.epnum = desc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
-        info.maxpacket = desc->wMaxPacketSize;
+        info.maxpacket = le16_to_cpu(desc->wMaxPacketSize);
         info.interval = desc->bInterval;
         if (desc->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
                 info.dir_in = 1;
@@ -525,8 +524,8 @@ static void start_ep0_write(struct m66592_ep *ep, struct m66592_request *req)
 
         pipe_change(m66592, ep->pipenum);
         m66592_mdfy(m66592, M66592_ISEL | M66592_PIPE0,
-                    (M66592_ISEL | M66592_CURPIPE),
-                    M66592_CFIFOSEL);
+                        (M66592_ISEL | M66592_CURPIPE),
+                        M66592_CFIFOSEL);
         m66592_write(m66592, M66592_BCLR, ep->fifoctr);
         if (req->req.length == 0) {
                 m66592_bset(m66592, M66592_BVAL, ep->fifoctr);
@@ -561,8 +560,8 @@ static void start_packet_read(struct m66592_ep *ep, struct m66592_request *req)
 
         if (ep->pipenum == 0) {
                 m66592_mdfy(m66592, M66592_PIPE0,
-                            (M66592_ISEL | M66592_CURPIPE),
-                            M66592_CFIFOSEL);
+                                (M66592_ISEL | M66592_CURPIPE),
+                                M66592_CFIFOSEL);
                 m66592_write(m66592, M66592_BCLR, ep->fifoctr);
                 pipe_start(m66592, pipenum);
                 pipe_irq_enable(m66592, pipenum);
@@ -572,8 +571,9 @@ static void start_packet_read(struct m66592_ep *ep, struct m66592_request *req)
                         pipe_change(m66592, pipenum);
                         m66592_bset(m66592, M66592_TRENB, ep->fifosel);
                         m66592_write(m66592,
-                                     (req->req.length + ep->ep.maxpacket - 1) /
-                                     ep->ep.maxpacket, ep->fifotrn);
+                                (req->req.length + ep->ep.maxpacket - 1)
+                                        / ep->ep.maxpacket,
+                                ep->fifotrn);
                 }
                 pipe_start(m66592, pipenum);    /* trigger once */
                 pipe_irq_enable(m66592, pipenum);
@@ -614,7 +614,7 @@ static void start_ep0(struct m66592_ep *ep, struct m66592_request *req)
 static void init_controller(struct m66592 *m66592)
 {
         m66592_bset(m66592, (vif & M66592_LDRV) | (endian & M66592_BIGEND),
-                    M66592_PINCFG);
+                        M66592_PINCFG);
         m66592_bset(m66592, M66592_HSE, M66592_SYSCFG);         /* High spd */
         m66592_mdfy(m66592, clock & M66592_XTAL, M66592_XTAL, M66592_SYSCFG);
 
@@ -634,7 +634,7 @@ static void init_controller(struct m66592 *m66592)
 
         m66592_bset(m66592, irq_sense & M66592_INTL, M66592_INTENB1);
         m66592_write(m66592, M66592_BURST | M66592_CPU_ADR_RD_WR,
-                     M66592_DMA0CFG);
+                        M66592_DMA0CFG);
 }
 
 static void disable_controller(struct m66592 *m66592)
@@ -659,8 +659,9 @@ static void m66592_start_xclock(struct m66592 *m66592)
 
 /*-------------------------------------------------------------------------*/
 static void transfer_complete(struct m66592_ep *ep,
-                              struct m66592_request *req,
-                              int status)
+                struct m66592_request *req, int status)
+__releases(m66592->lock)
+__acquires(m66592->lock)
 {
         int restart = 0;
 
@@ -680,8 +681,9 @@ static void transfer_complete(struct m66592_ep *ep,
         if (!list_empty(&ep->queue))
                 restart = 1;
 
-        if (likely(req->req.complete))
-                req->req.complete(&ep->ep, &req->req);
+        spin_unlock(&ep->m66592->lock);
+        req->req.complete(&ep->ep, &req->req);
+        spin_lock(&ep->m66592->lock);
 
         if (restart) {
                 req = list_entry(ep->queue.next, struct m66592_request, queue);
@@ -693,7 +695,7 @@ static void transfer_complete(struct m66592_ep *ep,
 static void irq_ep0_write(struct m66592_ep *ep, struct m66592_request *req)
 {
         int i;
-        volatile u16 tmp;
+        u16 tmp;
         unsigned bufsize;
         size_t size;
         void *buf;
@@ -731,8 +733,9 @@ static void irq_ep0_write(struct m66592_ep *ep, struct m66592_request *req)
         req->req.actual += size;
 
         /* check transfer finish */
-        if ((!req->req.zero && (req->req.actual == req->req.length)) ||
-            (size % ep->ep.maxpacket) || (size == 0)) {
+        if ((!req->req.zero && (req->req.actual == req->req.length))
+                        || (size % ep->ep.maxpacket)
+                        || (size == 0)) {
                 disable_irq_ready(m66592, pipenum);
                 disable_irq_empty(m66592, pipenum);
         } else {
@@ -768,16 +771,19 @@ static void irq_packet_write(struct m66592_ep *ep, struct m66592_request *req)
         /* write fifo */
         if (req->req.buf) {
                 m66592_write_fifo(m66592, ep->fifoaddr, buf, size);
-                if ((size == 0) || ((size % ep->ep.maxpacket) != 0) ||
-                    ((bufsize != ep->ep.maxpacket) && (bufsize > size)))
+                if ((size == 0)
+                                || ((size % ep->ep.maxpacket) != 0)
+                                || ((bufsize != ep->ep.maxpacket)
+                                        && (bufsize > size)))
                         m66592_bset(m66592, M66592_BVAL, ep->fifoctr);
         }
 
         /* update parameters */
         req->req.actual += size;
         /* check transfer finish */
-        if ((!req->req.zero && (req->req.actual == req->req.length)) ||
-            (size % ep->ep.maxpacket) || (size == 0)) {
+        if ((!req->req.zero && (req->req.actual == req->req.length))
+                        || (size % ep->ep.maxpacket)
+                        || (size == 0)) {
                 disable_irq_ready(m66592, pipenum);
                 enable_irq_empty(m66592, pipenum);
         } else {
@@ -821,8 +827,9 @@ static void irq_packet_read(struct m66592_ep *ep, struct m66592_request *req)
         req->req.actual += size;
 
         /* check transfer finish */
-        if ((!req->req.zero && (req->req.actual == req->req.length)) ||
-            (size % ep->ep.maxpacket) || (size == 0)) {
+        if ((!req->req.zero && (req->req.actual == req->req.length))
+                        || (size % ep->ep.maxpacket)
+                        || (size == 0)) {
                 pipe_stop(m66592, pipenum);
                 pipe_irq_disable(m66592, pipenum);
                 finish = 1;
@@ -850,7 +857,7 @@ static void irq_pipe_ready(struct m66592 *m66592, u16 status, u16 enb)
         if ((status & M66592_BRDY0) && (enb & M66592_BRDY0)) {
                 m66592_write(m66592, ~M66592_BRDY0, M66592_BRDYSTS);
                 m66592_mdfy(m66592, M66592_PIPE0, M66592_CURPIPE,
-                            M66592_CFIFOSEL);
+                                M66592_CFIFOSEL);
 
                 ep = &m66592->ep[0];
                 req = list_entry(ep->queue.next, struct m66592_request, queue);
@@ -909,23 +916,26 @@ static void irq_pipe_empty(struct m66592 *m66592, u16 status, u16 enb)
 }
 
 static void get_status(struct m66592 *m66592, struct usb_ctrlrequest *ctrl)
+__releases(m66592->lock)
+__acquires(m66592->lock)
 {
         struct m66592_ep *ep;
         u16 pid;
         u16 status = 0;
+        u16 w_index = le16_to_cpu(ctrl->wIndex);
 
         switch (ctrl->bRequestType & USB_RECIP_MASK) {
         case USB_RECIP_DEVICE:
-                status = 1;     /* selfpower */
+                status = 1 << USB_DEVICE_SELF_POWERED;
                 break;
         case USB_RECIP_INTERFACE:
                 status = 0;
                 break;
         case USB_RECIP_ENDPOINT:
-                ep = m66592->epaddr2ep[ctrl->wIndex&USB_ENDPOINT_NUMBER_MASK];
+                ep = m66592->epaddr2ep[w_index & USB_ENDPOINT_NUMBER_MASK];
                 pid = control_reg_get_pid(m66592, ep->pipenum);
                 if (pid == M66592_PID_STALL)
-                        status = 1;
+                        status = 1 << USB_ENDPOINT_HALT;
                 else
                         status = 0;
                 break;
@@ -934,11 +944,13 @@ static void get_status(struct m66592 *m66592, struct usb_ctrlrequest *ctrl)
                 return;         /* exit */
         }
 
-        *m66592->ep0_buf = status;
-        m66592->ep0_req->buf = m66592->ep0_buf;
+        m66592->ep0_data = cpu_to_le16(status);
+        m66592->ep0_req->buf = &m66592->ep0_data;
         m66592->ep0_req->length = 2;
         /* AV: what happens if we get called again before that gets through? */
+        spin_unlock(&m66592->lock);
         m66592_queue(m66592->gadget.ep0, m66592->ep0_req, GFP_KERNEL);
+        spin_lock(&m66592->lock);
 }
 
 static void clear_feature(struct m66592 *m66592, struct usb_ctrlrequest *ctrl)
@@ -953,8 +965,9 @@ static void clear_feature(struct m66592 *m66592, struct usb_ctrlrequest *ctrl)
         case USB_RECIP_ENDPOINT: {
                 struct m66592_ep *ep;
                 struct m66592_request *req;
+                u16 w_index = le16_to_cpu(ctrl->wIndex);
 
-                ep = m66592->epaddr2ep[ctrl->wIndex&USB_ENDPOINT_NUMBER_MASK];
+                ep = m66592->epaddr2ep[w_index & USB_ENDPOINT_NUMBER_MASK];
                 pipe_stop(m66592, ep->pipenum);
                 control_reg_sqclr(m66592, ep->pipenum);
 
@@ -989,8 +1002,9 @@ static void set_feature(struct m66592 *m66592, struct usb_ctrlrequest *ctrl)
                 break;
         case USB_RECIP_ENDPOINT: {
                 struct m66592_ep *ep;
+                u16 w_index = le16_to_cpu(ctrl->wIndex);
 
-                ep = m66592->epaddr2ep[ctrl->wIndex&USB_ENDPOINT_NUMBER_MASK];
+                ep = m66592->epaddr2ep[w_index & USB_ENDPOINT_NUMBER_MASK];
                 pipe_stall(m66592, ep->pipenum);
 
                 control_end(m66592, 1);
@@ -1066,14 +1080,16 @@ static void irq_device_state(struct m66592 *m66592)
         }
         if (m66592->old_dvsq == M66592_DS_CNFG && dvsq != M66592_DS_CNFG)
                 m66592_update_usb_speed(m66592);
-        if ((dvsq == M66592_DS_CNFG || dvsq == M66592_DS_ADDS) &&
-            m66592->gadget.speed == USB_SPEED_UNKNOWN)
+        if ((dvsq == M66592_DS_CNFG || dvsq == M66592_DS_ADDS)
+                        && m66592->gadget.speed == USB_SPEED_UNKNOWN)
                 m66592_update_usb_speed(m66592);
 
         m66592->old_dvsq = dvsq;
 }
 
 static void irq_control_stage(struct m66592 *m66592)
+__releases(m66592->lock)
+__acquires(m66592->lock)
 {
         struct usb_ctrlrequest ctrl;
         u16 ctsq;
@@ -1095,8 +1111,10 @@ static void irq_control_stage(struct m66592 *m66592)
         case M66592_CS_WRDS:
         case M66592_CS_WRND:
                 if (setup_packet(m66592, &ctrl)) {
+                        spin_unlock(&m66592->lock);
                         if (m66592->driver->setup(&m66592->gadget, &ctrl) < 0)
                                 pipe_stall(m66592, 0);
+                        spin_lock(&m66592->lock);
                 }
                 break;
         case M66592_CS_RDSS:
@@ -1119,6 +1137,8 @@ static irqreturn_t m66592_irq(int irq, void *_m66592)
         u16 savepipe;
         u16 mask0;
 
+        spin_lock(&m66592->lock);
+
         intsts0 = m66592_read(m66592, M66592_INTSTS0);
         intenb0 = m66592_read(m66592, M66592_INTENB0);
 
@@ -1134,27 +1154,27 @@ static irqreturn_t m66592_irq(int irq, void *_m66592)
                 bempenb = m66592_read(m66592, M66592_BEMPENB);
 
                 if (mask0 & M66592_VBINT) {
-                        m66592_write(m66592, (u16)~M66592_VBINT,
-                                     M66592_INTSTS0);
+                        m66592_write(m66592,  0xffff & ~M66592_VBINT,
+                                        M66592_INTSTS0);
                         m66592_start_xclock(m66592);
 
                         /* start vbus sampling */
                         m66592->old_vbus = m66592_read(m66592, M66592_INTSTS0)
-                                           & M66592_VBSTS;
+                                        & M66592_VBSTS;
                         m66592->scount = M66592_MAX_SAMPLING;
 
                         mod_timer(&m66592->timer,
-                                  jiffies + msecs_to_jiffies(50));
+                                        jiffies + msecs_to_jiffies(50));
                 }
                 if (intsts0 & M66592_DVSQ)
                         irq_device_state(m66592);
 
-                if ((intsts0 & M66592_BRDY) && (intenb0 & M66592_BRDYE) &&
-                    (brdysts & brdyenb)) {
+                if ((intsts0 & M66592_BRDY) && (intenb0 & M66592_BRDYE)
+                                && (brdysts & brdyenb)) {
                         irq_pipe_ready(m66592, brdysts, brdyenb);
                 }
-                if ((intsts0 & M66592_BEMP) && (intenb0 & M66592_BEMPE) &&
-                    (bempsts & bempenb)) {
+                if ((intsts0 & M66592_BEMP) && (intenb0 & M66592_BEMPE)
+                                && (bempsts & bempenb)) {
                         irq_pipe_empty(m66592, bempsts, bempenb);
                 }
 
@@ -1164,6 +1184,7 @@ static irqreturn_t m66592_irq(int irq, void *_m66592)
 
         m66592_write(m66592, savepipe, M66592_CFIFOSEL);
 
+        spin_unlock(&m66592->lock);
         return IRQ_HANDLED;
 }
 
@@ -1191,13 +1212,13 @@ static void m66592_timer(unsigned long _m66592)
                                         m66592_usb_disconnect(m66592);
                         } else {
                                 mod_timer(&m66592->timer,
-                                          jiffies + msecs_to_jiffies(50));
+                                        jiffies + msecs_to_jiffies(50));
                         }
                 } else {
                         m66592->scount = M66592_MAX_SAMPLING;
                         m66592->old_vbus = tmp;
                         mod_timer(&m66592->timer,
-                                  jiffies + msecs_to_jiffies(50));
+                                        jiffies + msecs_to_jiffies(50));
                 }
         }
         spin_unlock_irqrestore(&m66592->lock, flags);
@@ -1335,11 +1356,6 @@ out:
         return ret;
 }
 
-static int m66592_fifo_status(struct usb_ep *_ep)
-{
-        return -EOPNOTSUPP;
-}
-
 static void m66592_fifo_flush(struct usb_ep *_ep)
 {
         struct m66592_ep *ep;
@@ -1365,7 +1381,6 @@ static struct usb_ep_ops m66592_ep_ops = {
         .dequeue        = m66592_dequeue,
 
         .set_halt       = m66592_set_halt,
-        .fifo_status    = m66592_fifo_status,
         .fifo_flush     = m66592_fifo_flush,
 };
 
@@ -1377,11 +1392,10 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
         struct m66592 *m66592 = the_controller;
         int retval;
 
-        if (!driver ||
-            driver->speed != USB_SPEED_HIGH ||
-            !driver->bind ||
-            !driver->unbind ||
-            !driver->setup)
+        if (!driver
+                        || driver->speed != USB_SPEED_HIGH
+                        || !driver->bind
+                        || !driver->setup)
                 return -EINVAL;
         if (!m66592)
                 return -ENODEV;
@@ -1413,8 +1427,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
                 m66592->old_vbus = m66592_read(m66592,
                                          M66592_INTSTS0) & M66592_VBSTS;
                 m66592->scount = M66592_MAX_SAMPLING;
-                mod_timer(&m66592->timer,
-                          jiffies + msecs_to_jiffies(50));
+                mod_timer(&m66592->timer, jiffies + msecs_to_jiffies(50));
         }
 
         return 0;
@@ -1432,6 +1445,9 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
         struct m66592 *m66592 = the_controller;
         unsigned long flags;
 
+        if (driver != m66592->driver || !driver->unbind)
+                return -EINVAL;
+
         spin_lock_irqsave(&m66592->lock, flags);
         if (m66592->gadget.speed != USB_SPEED_UNKNOWN)
                 m66592_usb_disconnect(m66592);
@@ -1461,46 +1477,35 @@ static struct usb_gadget_ops m66592_gadget_ops = {
         .get_frame              = m66592_get_frame,
 };
 
-#if defined(CONFIG_PM)
-static int m66592_suspend(struct platform_device *pdev, pm_message_t state)
-{
-        pdev->dev.power.power_state = state;
-        return 0;
-}
-
-static int m66592_resume(struct platform_device *pdev)
-{
-        pdev->dev.power.power_state = PMSG_ON;
-        return 0;
-}
-#else   /* if defined(CONFIG_PM) */
-#define m66592_suspend          NULL
-#define m66592_resume           NULL
-#endif
-
-static int __init_or_module m66592_remove(struct platform_device *pdev)
+static int __exit m66592_remove(struct platform_device *pdev)
 {
         struct m66592           *m66592 = dev_get_drvdata(&pdev->dev);
 
         del_timer_sync(&m66592->timer);
         iounmap(m66592->reg);
         free_irq(platform_get_irq(pdev, 0), m66592);
+        m66592_free_request(&m66592->ep[0].ep, m66592->ep0_req);
         kfree(m66592);
         return 0;
 }
 
+static void nop_completion(struct usb_ep *ep, struct usb_request *r)
+{
+}
+
 #define resource_len(r) (((r)->end - (r)->start) + 1)
+
 static int __init m66592_probe(struct platform_device *pdev)
 {
-        struct resource *res = NULL;
-        int irq = -1;
+        struct resource *res;
+        int irq;
         void __iomem *reg = NULL;
         struct m66592 *m66592 = NULL;
         int ret = 0;
         int i;
 
         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
-                                           (char *)udc_name);
+                        (char *)udc_name);
         if (!res) {
                 ret = -ENODEV;
                 printk(KERN_ERR "platform_get_resource_byname error.\n");
@@ -1548,7 +1553,7 @@ static int __init m66592_probe(struct platform_device *pdev)
         m66592->bi_bufnum = M66592_BASE_BUFNUM;
 
         ret = request_irq(irq, m66592_irq, IRQF_DISABLED | IRQF_SHARED,
-                          udc_name, m66592);
+                        udc_name, m66592);
         if (ret < 0) {
                 printk(KERN_ERR "request_irq error (%d)\n", ret);
                 goto clean_up;
@@ -1563,7 +1568,7 @@ static int __init m66592_probe(struct platform_device *pdev)
                 if (i != 0) {
                         INIT_LIST_HEAD(&m66592->ep[i].ep.ep_list);
                         list_add_tail(&m66592->ep[i].ep.ep_list,
-                                      &m66592->gadget.ep_list);
+                                        &m66592->gadget.ep_list);
                 }
                 ep->m66592 = m66592;
                 INIT_LIST_HEAD(&ep->queue);
@@ -1583,20 +1588,18 @@ static int __init m66592_probe(struct platform_device *pdev)
 
         the_controller = m66592;
 
-        /* AV: leaks */
         m66592->ep0_req = m66592_alloc_request(&m66592->ep[0].ep, GFP_KERNEL);
         if (m66592->ep0_req == NULL)
-                goto clean_up;
-        /* AV: leaks, and do we really need it separately allocated? */
-        m66592->ep0_buf = kzalloc(2, GFP_KERNEL);
-        if (m66592->ep0_buf == NULL)
-                goto clean_up;
+                goto clean_up2;
+        m66592->ep0_req->complete = nop_completion;
 
         init_controller(m66592);
 
-        printk("driver %s, %s\n", udc_name, DRIVER_VERSION);
+        dev_info(&pdev->dev, "version %s\n", DRIVER_VERSION);
         return 0;
 
+clean_up2:
+        free_irq(irq, m66592);
 clean_up:
         if (m66592) {
                 if (m66592->ep0_req)
@@ -1611,10 +1614,7 @@ clean_up:
 
 /*-------------------------------------------------------------------------*/
 static struct platform_driver m66592_driver = {
-        .probe =        m66592_probe,
-        .remove =       m66592_remove,
-        .suspend =      m66592_suspend,
-        .resume =       m66592_resume,
+        .remove =       __exit_p(m66592_remove),
         .driver         = {
                 .name = (char *) udc_name,
         },
@@ -1622,7 +1622,7 @@ static struct platform_driver m66592_driver = {
 
 static int __init m66592_udc_init(void)
 {
-        return platform_driver_register(&m66592_driver);
+        return platform_driver_probe(&m66592_driver, m66592_probe);
 }
 module_init(m66592_udc_init);
 
@@ -1631,4 +1631,3 @@ static void __exit m66592_udc_cleanup(void)
         platform_driver_unregister(&m66592_driver);
 }
 module_exit(m66592_udc_cleanup);
-
diff --git a/drivers/usb/gadget/m66592-udc.h b/drivers/usb/gadget/m66592-udc.h
index 26b54f8b8945..bfa0c645f229 100644
--- a/drivers/usb/gadget/m66592-udc.h
+++ b/drivers/usb/gadget/m66592-udc.h
@@ -24,73 +24,73 @@
 #define __M66592_UDC_H__
 
 #define M66592_SYSCFG           0x00
-#define M66592_XTAL             0xC000  /* b15-14: Crystal selection */
-#define   M66592_XTAL48          0x8000           /* 48MHz */
-#define   M66592_XTAL24          0x4000           /* 24MHz */
-#define   M66592_XTAL12          0x0000           /* 12MHz */
-#define M66592_XCKE             0x2000  /* b13: External clock enable */
-#define M66592_RCKE             0x1000  /* b12: Register clock enable */
-#define M66592_PLLC             0x0800  /* b11: PLL control */
-#define M66592_SCKE             0x0400  /* b10: USB clock enable */
-#define M66592_ATCKM            0x0100  /* b8: Automatic supply functional enable */
-#define M66592_HSE              0x0080  /* b7: Hi-speed enable */
-#define M66592_DCFM             0x0040  /* b6: Controller function select  */
-#define M66592_DMRPD            0x0020  /* b5: D- pull down control */
-#define M66592_DPRPU            0x0010  /* b4: D+ pull up control */
-#define M66592_FSRPC            0x0004  /* b2: Full-speed receiver enable */
-#define M66592_PCUT             0x0002  /* b1: Low power sleep enable */
-#define M66592_USBE             0x0001  /* b0: USB module operation enable */
+#define M66592_XTAL             0xC000  /* b15-14: Crystal selection */
+#define   M66592_XTAL48          0x8000         /* 48MHz */
+#define   M66592_XTAL24          0x4000         /* 24MHz */
+#define   M66592_XTAL12          0x0000         /* 12MHz */
+#define M66592_XCKE             0x2000  /* b13: External clock enable */
+#define M66592_RCKE             0x1000  /* b12: Register clock enable */
+#define M66592_PLLC             0x0800  /* b11: PLL control */
+#define M66592_SCKE             0x0400  /* b10: USB clock enable */
+#define M66592_ATCKM            0x0100  /* b8: Automatic clock supply */
+#define M66592_HSE              0x0080  /* b7: Hi-speed enable */
+#define M66592_DCFM             0x0040  /* b6: Controller function select  */
+#define M66592_DMRPD            0x0020  /* b5: D- pull down control */
+#define M66592_DPRPU            0x0010  /* b4: D+ pull up control */
+#define M66592_FSRPC            0x0004  /* b2: Full-speed receiver enable */
+#define M66592_PCUT             0x0002  /* b1: Low power sleep enable */
+#define M66592_USBE             0x0001  /* b0: USB module operation enable */
 
 #define M66592_SYSSTS           0x02
-#define M66592_LNST             0x0003  /* b1-0: D+, D- line status */
-#define   M66592_SE1             0x0003           /* SE1 */
-#define   M66592_KSTS            0x0002           /* K State */
-#define   M66592_JSTS            0x0001           /* J State */
-#define   M66592_SE0             0x0000           /* SE0 */
+#define M66592_LNST             0x0003  /* b1-0: D+, D- line status */
+#define   M66592_SE1             0x0003         /* SE1 */
+#define   M66592_KSTS            0x0002         /* K State */
+#define   M66592_JSTS            0x0001         /* J State */
+#define   M66592_SE0             0x0000         /* SE0 */
 
 #define M66592_DVSTCTR          0x04
-#define M66592_WKUP             0x0100  /* b8: Remote wakeup */
-#define M66592_RWUPE            0x0080  /* b7: Remote wakeup sense */
-#define M66592_USBRST           0x0040  /* b6: USB reset enable */
-#define M66592_RESUME           0x0020  /* b5: Resume enable */
-#define M66592_UACT             0x0010  /* b4: USB bus enable */
-#define M66592_RHST             0x0003  /* b1-0: Reset handshake status */
-#define   M66592_HSMODE          0x0003           /* Hi-Speed mode */
-#define   M66592_FSMODE          0x0002           /* Full-Speed mode */
-#define   M66592_HSPROC          0x0001           /* HS handshake is processing */
+#define M66592_WKUP             0x0100  /* b8: Remote wakeup */
+#define M66592_RWUPE            0x0080  /* b7: Remote wakeup sense */
+#define M66592_USBRST           0x0040  /* b6: USB reset enable */
+#define M66592_RESUME           0x0020  /* b5: Resume enable */
+#define M66592_UACT             0x0010  /* b4: USB bus enable */
+#define M66592_RHST             0x0003  /* b1-0: Reset handshake status */
+#define   M66592_HSMODE          0x0003         /* Hi-Speed mode */
+#define   M66592_FSMODE          0x0002         /* Full-Speed mode */
+#define   M66592_HSPROC          0x0001         /* HS handshake is processing */
 
 #define M66592_TESTMODE         0x06
-#define M66592_UTST             0x000F  /* b4-0: Test select */
-#define   M66592_H_TST_PACKET    0x000C           /* HOST TEST Packet */
-#define   M66592_H_TST_SE0_NAK   0x000B           /* HOST TEST SE0 NAK */
-#define   M66592_H_TST_K         0x000A           /* HOST TEST K */
-#define   M66592_H_TST_J         0x0009           /* HOST TEST J */
-#define   M66592_H_TST_NORMAL    0x0000           /* HOST Normal Mode */
-#define   M66592_P_TST_PACKET    0x0004           /* PERI TEST Packet */
-#define   M66592_P_TST_SE0_NAK   0x0003           /* PERI TEST SE0 NAK */
-#define   M66592_P_TST_K         0x0002           /* PERI TEST K */
-#define   M66592_P_TST_J         0x0001           /* PERI TEST J */
-#define   M66592_P_TST_NORMAL    0x0000           /* PERI Normal Mode */
+#define M66592_UTST             0x000F  /* b4-0: Test select */
+#define   M66592_H_TST_PACKET    0x000C         /* HOST TEST Packet */
+#define   M66592_H_TST_SE0_NAK   0x000B         /* HOST TEST SE0 NAK */
+#define   M66592_H_TST_K         0x000A         /* HOST TEST K */
+#define   M66592_H_TST_J         0x0009         /* HOST TEST J */
+#define   M66592_H_TST_NORMAL    0x0000         /* HOST Normal Mode */
+#define   M66592_P_TST_PACKET    0x0004         /* PERI TEST Packet */
+#define   M66592_P_TST_SE0_NAK   0x0003         /* PERI TEST SE0 NAK */
+#define   M66592_P_TST_K         0x0002         /* PERI TEST K */
+#define   M66592_P_TST_J         0x0001         /* PERI TEST J */
+#define   M66592_P_TST_NORMAL    0x0000         /* PERI Normal Mode */
 
 #define M66592_PINCFG           0x0A
-#define M66592_LDRV             0x8000  /* b15: Drive Current Adjust */
-#define M66592_BIGEND           0x0100  /* b8: Big endian mode */
+#define M66592_LDRV             0x8000  /* b15: Drive Current Adjust */
+#define M66592_BIGEND           0x0100  /* b8: Big endian mode */
 
 #define M66592_DMA0CFG          0x0C
 #define M66592_DMA1CFG          0x0E
-#define M66592_DREQA            0x4000  /* b14: Dreq active select */
-#define M66592_BURST            0x2000  /* b13: Burst mode */
-#define M66592_DACKA            0x0400  /* b10: Dack active select */
-#define M66592_DFORM            0x0380  /* b9-7: DMA mode select */
-#define   M66592_CPU_ADR_RD_WR   0x0000           /* Address + RD/WR mode (CPU bus) */
-#define   M66592_CPU_DACK_RD_WR  0x0100           /* DACK + RD/WR mode (CPU bus) */
-#define   M66592_CPU_DACK_ONLY   0x0180           /* DACK only mode (CPU bus) */
-#define   M66592_SPLIT_DACK_ONLY         0x0200           /* DACK only mode (SPLIT bus) */
-#define   M66592_SPLIT_DACK_DSTB         0x0300           /* DACK + DSTB0 mode (SPLIT bus) */
-#define M66592_DENDA            0x0040  /* b6: Dend active select */
-#define M66592_PKTM             0x0020  /* b5: Packet mode */
-#define M66592_DENDE            0x0010  /* b4: Dend enable */
-#define M66592_OBUS             0x0004  /* b2: OUTbus mode */
+#define M66592_DREQA            0x4000  /* b14: Dreq active select */
+#define M66592_BURST            0x2000  /* b13: Burst mode */
+#define M66592_DACKA            0x0400  /* b10: Dack active select */
+#define M66592_DFORM            0x0380  /* b9-7: DMA mode select */
+#define   M66592_CPU_ADR_RD_WR   0x0000   /* Address + RD/WR mode (CPU bus) */
+#define   M66592_CPU_DACK_RD_WR  0x0100   /* DACK + RD/WR mode (CPU bus) */
+#define   M66592_CPU_DACK_ONLY   0x0180   /* DACK only mode (CPU bus) */
+#define   M66592_SPLIT_DACK_ONLY 0x0200   /* DACK only mode (SPLIT bus) */
+#define   M66592_SPLIT_DACK_DSTB 0x0300   /* DACK + DSTB0 mode (SPLIT bus) */
+#define M66592_DENDA            0x0040  /* b6: Dend active select */
+#define M66592_PKTM             0x0020  /* b5: Packet mode */
+#define M66592_DENDE            0x0010  /* b4: Dend enable */
+#define M66592_OBUS             0x0004  /* b2: OUTbus mode */
 
 #define M66592_CFIFO            0x10
 #define M66592_D0FIFO           0x14
@@ -99,300 +99,300 @@
 #define M66592_CFIFOSEL         0x1E
 #define M66592_D0FIFOSEL        0x24
 #define M66592_D1FIFOSEL        0x2A
-#define M66592_RCNT             0x8000  /* b15: Read count mode */
-#define M66592_REW              0x4000  /* b14: Buffer rewind */
-#define M66592_DCLRM            0x2000  /* b13: DMA buffer clear mode */
-#define M66592_DREQE            0x1000  /* b12: DREQ output enable */
-#define M66592_MBW              0x0400  /* b10: Maximum bit width for FIFO access */
-#define   M66592_MBW_8           0x0000   /*  8bit */
-#define   M66592_MBW_16          0x0400           /* 16bit */
-#define M66592_TRENB            0x0200  /* b9: Transaction counter enable */
-#define M66592_TRCLR            0x0100  /* b8: Transaction counter clear */
-#define M66592_DEZPM            0x0080  /* b7: Zero-length packet additional mode */
-#define M66592_ISEL             0x0020  /* b5: DCP FIFO port direction select */
-#define M66592_CURPIPE          0x0007  /* b2-0: PIPE select */
+#define M66592_RCNT             0x8000  /* b15: Read count mode */
+#define M66592_REW              0x4000  /* b14: Buffer rewind */
+#define M66592_DCLRM            0x2000  /* b13: DMA buffer clear mode */
+#define M66592_DREQE            0x1000  /* b12: DREQ output enable */
+#define M66592_MBW              0x0400  /* b10: Maximum bit width for FIFO */
+#define   M66592_MBW_8           0x0000   /*  8bit */
+#define   M66592_MBW_16          0x0400   /* 16bit */
+#define M66592_TRENB            0x0200  /* b9: Transaction counter enable */
+#define M66592_TRCLR            0x0100  /* b8: Transaction counter clear */
+#define M66592_DEZPM            0x0080  /* b7: Zero-length packet mode */
+#define M66592_ISEL             0x0020  /* b5: DCP FIFO port direction select */
+#define M66592_CURPIPE          0x0007  /* b2-0: PIPE select */
 
 #define M66592_CFIFOCTR         0x20
 #define M66592_D0FIFOCTR        0x26
 #define M66592_D1FIFOCTR        0x2c
-#define M66592_BVAL             0x8000  /* b15: Buffer valid flag */
-#define M66592_BCLR             0x4000  /* b14: Buffer clear */
-#define M66592_FRDY             0x2000  /* b13: FIFO ready */
-#define M66592_DTLN             0x0FFF  /* b11-0: FIFO received data length */
+#define M66592_BVAL             0x8000  /* b15: Buffer valid flag */
+#define M66592_BCLR             0x4000  /* b14: Buffer clear */
+#define M66592_FRDY             0x2000  /* b13: FIFO ready */
+#define M66592_DTLN             0x0FFF  /* b11-0: FIFO received data length */
 
 #define M66592_CFIFOSIE         0x22
-#define M66592_TGL              0x8000  /* b15: Buffer toggle */
-#define M66592_SCLR             0x4000  /* b14: Buffer clear */
-#define M66592_SBUSY            0x2000  /* b13: SIE_FIFO busy */
+#define M66592_TGL              0x8000  /* b15: Buffer toggle */
+#define M66592_SCLR             0x4000  /* b14: Buffer clear */
+#define M66592_SBUSY            0x2000  /* b13: SIE_FIFO busy */
 
 #define M66592_D0FIFOTRN        0x28
 #define M66592_D1FIFOTRN        0x2E
-#define M66592_TRNCNT           0xFFFF  /* b15-0: Transaction counter */
+#define M66592_TRNCNT           0xFFFF  /* b15-0: Transaction counter */
 
 #define M66592_INTENB0  0x30
-#define M66592_VBSE     0x8000  /* b15: VBUS interrupt */
-#define M66592_RSME     0x4000  /* b14: Resume interrupt */
-#define M66592_SOFE     0x2000  /* b13: Frame update interrupt */
-#define M66592_DVSE     0x1000  /* b12: Device state transition interrupt */
-#define M66592_CTRE     0x0800  /* b11: Control transfer stage transition interrupt */
-#define M66592_BEMPE    0x0400  /* b10: Buffer empty interrupt */
-#define M66592_NRDYE    0x0200  /* b9: Buffer not ready interrupt */
-#define M66592_BRDYE    0x0100  /* b8: Buffer ready interrupt */
-#define M66592_URST     0x0080  /* b7: USB reset detected interrupt */
-#define M66592_SADR     0x0040  /* b6: Set address executed interrupt */
-#define M66592_SCFG     0x0020  /* b5: Set configuration executed interrupt */
-#define M66592_SUSP     0x0010  /* b4: Suspend detected interrupt */
-#define M66592_WDST     0x0008  /* b3: Control write data stage completed interrupt */
-#define M66592_RDST     0x0004  /* b2: Control read data stage completed interrupt */
-#define M66592_CMPL     0x0002  /* b1: Control transfer complete interrupt */
-#define M66592_SERR     0x0001  /* b0: Sequence error interrupt */
+#define M66592_VBSE     0x8000  /* b15: VBUS interrupt */
+#define M66592_RSME     0x4000  /* b14: Resume interrupt */
+#define M66592_SOFE     0x2000  /* b13: Frame update interrupt */
+#define M66592_DVSE     0x1000  /* b12: Device state transition interrupt */
+#define M66592_CTRE     0x0800  /* b11: Control transfer stage transition irq */
+#define M66592_BEMPE    0x0400  /* b10: Buffer empty interrupt */
+#define M66592_NRDYE    0x0200  /* b9: Buffer not ready interrupt */
+#define M66592_BRDYE    0x0100  /* b8: Buffer ready interrupt */
+#define M66592_URST     0x0080  /* b7: USB reset detected interrupt */
+#define M66592_SADR     0x0040  /* b6: Set address executed interrupt */
+#define M66592_SCFG     0x0020  /* b5: Set configuration executed interrupt */
+#define M66592_SUSP     0x0010  /* b4: Suspend detected interrupt */
+#define M66592_WDST     0x0008  /* b3: Control write data stage completed irq */
+#define M66592_RDST     0x0004  /* b2: Control read data stage completed irq */
+#define M66592_CMPL     0x0002  /* b1: Control transfer complete interrupt */
+#define M66592_SERR     0x0001  /* b0: Sequence error interrupt */
 
 #define M66592_INTENB1  0x32
-#define M66592_BCHGE    0x4000  /* b14: USB us chenge interrupt */
-#define M66592_DTCHE    0x1000  /* b12: Detach sense interrupt */
-#define M66592_SIGNE    0x0020  /* b5: SETUP IGNORE interrupt */
-#define M66592_SACKE    0x0010  /* b4: SETUP ACK interrupt */
-#define M66592_BRDYM    0x0004  /* b2: BRDY clear timing */
-#define M66592_INTL     0x0002  /* b1: Interrupt sense select */
-#define M66592_PCSE     0x0001  /* b0: PCUT enable by CS assert */
+#define M66592_BCHGE    0x4000  /* b14: USB us chenge interrupt */
+#define M66592_DTCHE    0x1000  /* b12: Detach sense interrupt */
+#define M66592_SIGNE    0x0020  /* b5: SETUP IGNORE interrupt */
+#define M66592_SACKE    0x0010  /* b4: SETUP ACK interrupt */
+#define M66592_BRDYM    0x0004  /* b2: BRDY clear timing */
+#define M66592_INTL     0x0002  /* b1: Interrupt sense select */
+#define M66592_PCSE     0x0001  /* b0: PCUT enable by CS assert */
 
 #define M66592_BRDYENB          0x36
 #define M66592_BRDYSTS          0x46
-#define M66592_BRDY7            0x0080  /* b7: PIPE7 */
-#define M66592_BRDY6            0x0040  /* b6: PIPE6 */
-#define M66592_BRDY5            0x0020  /* b5: PIPE5 */
-#define M66592_BRDY4            0x0010  /* b4: PIPE4 */
-#define M66592_BRDY3            0x0008  /* b3: PIPE3 */
-#define M66592_BRDY2            0x0004  /* b2: PIPE2 */
-#define M66592_BRDY1            0x0002  /* b1: PIPE1 */
-#define M66592_BRDY0            0x0001  /* b1: PIPE0 */
+#define M66592_BRDY7            0x0080  /* b7: PIPE7 */
+#define M66592_BRDY6            0x0040  /* b6: PIPE6 */
+#define M66592_BRDY5            0x0020  /* b5: PIPE5 */
+#define M66592_BRDY4            0x0010  /* b4: PIPE4 */
+#define M66592_BRDY3            0x0008  /* b3: PIPE3 */
+#define M66592_BRDY2            0x0004  /* b2: PIPE2 */
+#define M66592_BRDY1            0x0002  /* b1: PIPE1 */
+#define M66592_BRDY0            0x0001  /* b1: PIPE0 */
 
 #define M66592_NRDYENB          0x38
 #define M66592_NRDYSTS          0x48
-#define M66592_NRDY7            0x0080  /* b7: PIPE7 */
-#define M66592_NRDY6            0x0040  /* b6: PIPE6 */
-#define M66592_NRDY5            0x0020  /* b5: PIPE5 */
-#define M66592_NRDY4            0x0010  /* b4: PIPE4 */
-#define M66592_NRDY3            0x0008  /* b3: PIPE3 */
-#define M66592_NRDY2            0x0004  /* b2: PIPE2 */
-#define M66592_NRDY1            0x0002  /* b1: PIPE1 */
-#define M66592_NRDY0            0x0001  /* b1: PIPE0 */
+#define M66592_NRDY7            0x0080  /* b7: PIPE7 */
+#define M66592_NRDY6            0x0040  /* b6: PIPE6 */
+#define M66592_NRDY5            0x0020  /* b5: PIPE5 */
+#define M66592_NRDY4            0x0010  /* b4: PIPE4 */
+#define M66592_NRDY3            0x0008  /* b3: PIPE3 */
+#define M66592_NRDY2            0x0004  /* b2: PIPE2 */
+#define M66592_NRDY1            0x0002  /* b1: PIPE1 */
+#define M66592_NRDY0            0x0001  /* b1: PIPE0 */
 
 #define M66592_BEMPENB          0x3A
 #define M66592_BEMPSTS          0x4A
-#define M66592_BEMP7            0x0080  /* b7: PIPE7 */
-#define M66592_BEMP6            0x0040  /* b6: PIPE6 */
-#define M66592_BEMP5            0x0020  /* b5: PIPE5 */
-#define M66592_BEMP4            0x0010  /* b4: PIPE4 */
-#define M66592_BEMP3            0x0008  /* b3: PIPE3 */
-#define M66592_BEMP2            0x0004  /* b2: PIPE2 */
-#define M66592_BEMP1            0x0002  /* b1: PIPE1 */
-#define M66592_BEMP0            0x0001  /* b0: PIPE0 */
+#define M66592_BEMP7            0x0080  /* b7: PIPE7 */
+#define M66592_BEMP6            0x0040  /* b6: PIPE6 */
+#define M66592_BEMP5            0x0020  /* b5: PIPE5 */
+#define M66592_BEMP4            0x0010  /* b4: PIPE4 */
+#define M66592_BEMP3            0x0008  /* b3: PIPE3 */
+#define M66592_BEMP2            0x0004  /* b2: PIPE2 */
+#define M66592_BEMP1            0x0002  /* b1: PIPE1 */
+#define M66592_BEMP0            0x0001  /* b0: PIPE0 */
 
 #define M66592_SOFCFG           0x3C
-#define M66592_SOFM             0x000C  /* b3-2: SOF palse mode */
-#define   M66592_SOF_125US       0x0008           /* SOF OUT 125us uFrame Signal */
-#define   M66592_SOF_1MS         0x0004           /* SOF OUT 1ms Frame Signal */
-#define   M66592_SOF_DISABLE     0x0000           /* SOF OUT Disable */
+#define M66592_SOFM             0x000C  /* b3-2: SOF palse mode */
+#define   M66592_SOF_125US       0x0008   /* SOF OUT 125us uFrame Signal */
+#define   M66592_SOF_1MS         0x0004   /* SOF OUT 1ms Frame Signal */
+#define   M66592_SOF_DISABLE     0x0000   /* SOF OUT Disable */
 
 #define M66592_INTSTS0          0x40
-#define M66592_VBINT            0x8000  /* b15: VBUS interrupt */
-#define M66592_RESM             0x4000  /* b14: Resume interrupt */
-#define M66592_SOFR             0x2000  /* b13: SOF frame update interrupt */
-#define M66592_DVST             0x1000  /* b12: Device state transition interrupt */
-#define M66592_CTRT             0x0800  /* b11: Control transfer stage transition interrupt */
-#define M66592_BEMP             0x0400  /* b10: Buffer empty interrupt */
-#define M66592_NRDY             0x0200  /* b9: Buffer not ready interrupt */
-#define M66592_BRDY             0x0100  /* b8: Buffer ready interrupt */
-#define M66592_VBSTS            0x0080  /* b7: VBUS input port */
-#define M66592_DVSQ             0x0070  /* b6-4: Device state */
-#define   M66592_DS_SPD_CNFG     0x0070           /* Suspend Configured */
-#define   M66592_DS_SPD_ADDR     0x0060           /* Suspend Address */
-#define   M66592_DS_SPD_DFLT     0x0050           /* Suspend Default */
-#define   M66592_DS_SPD_POWR     0x0040           /* Suspend Powered */
-#define   M66592_DS_SUSP         0x0040           /* Suspend */
-#define   M66592_DS_CNFG         0x0030           /* Configured */
-#define   M66592_DS_ADDS         0x0020           /* Address */
-#define   M66592_DS_DFLT         0x0010           /* Default */
-#define   M66592_DS_POWR         0x0000           /* Powered */
-#define M66592_DVSQS            0x0030  /* b5-4: Device state */
-#define M66592_VALID            0x0008  /* b3: Setup packet detected flag */
-#define M66592_CTSQ             0x0007  /* b2-0: Control transfer stage */
-#define   M66592_CS_SQER         0x0006           /* Sequence error */
-#define   M66592_CS_WRND         0x0005           /* Control write nodata status stage */
-#define   M66592_CS_WRSS         0x0004           /* Control write status stage */
-#define   M66592_CS_WRDS         0x0003           /* Control write data stage */
-#define   M66592_CS_RDSS         0x0002           /* Control read status stage */
-#define   M66592_CS_RDDS         0x0001           /* Control read data stage */
-#define   M66592_CS_IDST         0x0000           /* Idle or setup stage */
+#define M66592_VBINT            0x8000  /* b15: VBUS interrupt */
+#define M66592_RESM             0x4000  /* b14: Resume interrupt */
+#define M66592_SOFR             0x2000  /* b13: SOF frame update interrupt */
+#define M66592_DVST             0x1000  /* b12: Device state transition */
+#define M66592_CTRT             0x0800  /* b11: Control stage transition */
+#define M66592_BEMP             0x0400  /* b10: Buffer empty interrupt */
+#define M66592_NRDY             0x0200  /* b9: Buffer not ready interrupt */
+#define M66592_BRDY             0x0100  /* b8: Buffer ready interrupt */
+#define M66592_VBSTS            0x0080  /* b7: VBUS input port */
+#define M66592_DVSQ             0x0070  /* b6-4: Device state */
+#define   M66592_DS_SPD_CNFG     0x0070    /* Suspend Configured */
+#define   M66592_DS_SPD_ADDR     0x0060    /* Suspend Address */
+#define   M66592_DS_SPD_DFLT     0x0050    /* Suspend Default */
+#define   M66592_DS_SPD_POWR     0x0040    /* Suspend Powered */
+#define   M66592_DS_SUSP         0x0040    /* Suspend */
+#define   M66592_DS_CNFG         0x0030    /* Configured */
+#define   M66592_DS_ADDS         0x0020    /* Address */
+#define   M66592_DS_DFLT         0x0010    /* Default */
+#define   M66592_DS_POWR         0x0000    /* Powered */
+#define M66592_DVSQS            0x0030  /* b5-4: Device state */
+#define M66592_VALID            0x0008  /* b3: Setup packet detected flag */
+#define M66592_CTSQ             0x0007  /* b2-0: Control transfer stage */
+#define   M66592_CS_SQER         0x0006   /* Sequence error */
+#define   M66592_CS_WRND         0x0005   /* Control write nodata status */
+#define   M66592_CS_WRSS         0x0004   /* Control write status stage */
+#define   M66592_CS_WRDS         0x0003   /* Control write data stage */
+#define   M66592_CS_RDSS         0x0002   /* Control read status stage */
+#define   M66592_CS_RDDS         0x0001   /* Control read data stage */
+#define   M66592_CS_IDST         0x0000   /* Idle or setup stage */
 
 #define M66592_INTSTS1          0x42
-#define M66592_BCHG             0x4000  /* b14: USB bus chenge interrupt */
-#define M66592_DTCH             0x1000  /* b12: Detach sense interrupt */
-#define M66592_SIGN             0x0020  /* b5: SETUP IGNORE interrupt */
-#define M66592_SACK             0x0010  /* b4: SETUP ACK interrupt */
+#define M66592_BCHG             0x4000  /* b14: USB bus chenge interrupt */
+#define M66592_DTCH             0x1000  /* b12: Detach sense interrupt */
+#define M66592_SIGN             0x0020  /* b5: SETUP IGNORE interrupt */
+#define M66592_SACK             0x0010  /* b4: SETUP ACK interrupt */
 
 #define M66592_FRMNUM           0x4C
-#define M66592_OVRN             0x8000  /* b15: Overrun error */
-#define M66592_CRCE             0x4000  /* b14: Received data error */
-#define M66592_SOFRM            0x0800  /* b11: SOF output mode */
-#define M66592_FRNM             0x07FF  /* b10-0: Frame number */
+#define M66592_OVRN             0x8000  /* b15: Overrun error */
+#define M66592_CRCE             0x4000  /* b14: Received data error */
+#define M66592_SOFRM            0x0800  /* b11: SOF output mode */
+#define M66592_FRNM             0x07FF  /* b10-0: Frame number */
 
 #define M66592_UFRMNUM          0x4E
-#define M66592_UFRNM            0x0007  /* b2-0: Micro frame number */
+#define M66592_UFRNM            0x0007  /* b2-0: Micro frame number */
 
 #define M66592_RECOVER          0x50
-#define M66592_STSRECOV         0x0700  /* Status recovery */
-#define   M66592_STSR_HI         0x0400           /* FULL(0) or HI(1) Speed */
-#define   M66592_STSR_DEFAULT    0x0100           /* Default state */
-#define   M66592_STSR_ADDRESS    0x0200           /* Address state */
-#define   M66592_STSR_CONFIG     0x0300           /* Configured state */
-#define M66592_USBADDR          0x007F  /* b6-0: USB address */
+#define M66592_STSRECOV         0x0700  /* Status recovery */
+#define   M66592_STSR_HI         0x0400           /* FULL(0) or HI(1) Speed */
+#define   M66592_STSR_DEFAULT    0x0100           /* Default state */
+#define   M66592_STSR_ADDRESS    0x0200           /* Address state */
+#define   M66592_STSR_CONFIG     0x0300           /* Configured state */
+#define M66592_USBADDR          0x007F  /* b6-0: USB address */
 
 #define M66592_USBREQ                   0x54
-#define M66592_bRequest                 0xFF00  /* b15-8: bRequest */
-#define   M66592_GET_STATUS              0x0000
-#define   M66592_CLEAR_FEATURE           0x0100
-#define   M66592_ReqRESERVED             0x0200
-#define   M66592_SET_FEATURE             0x0300
-#define   M66592_ReqRESERVED1            0x0400
-#define   M66592_SET_ADDRESS             0x0500
-#define   M66592_GET_DESCRIPTOR          0x0600
-#define   M66592_SET_DESCRIPTOR          0x0700
-#define   M66592_GET_CONFIGURATION       0x0800
-#define   M66592_SET_CONFIGURATION       0x0900
-#define   M66592_GET_INTERFACE           0x0A00
-#define   M66592_SET_INTERFACE           0x0B00
-#define   M66592_SYNCH_FRAME             0x0C00
-#define M66592_bmRequestType            0x00FF  /* b7-0: bmRequestType */
-#define M66592_bmRequestTypeDir         0x0080  /* b7  : Data transfer direction */
-#define   M66592_HOST_TO_DEVICE          0x0000
-#define   M66592_DEVICE_TO_HOST          0x0080
-#define M66592_bmRequestTypeType        0x0060  /* b6-5: Type */
-#define   M66592_STANDARD                0x0000
-#define   M66592_CLASS                   0x0020
-#define   M66592_VENDOR                  0x0040
-#define M66592_bmRequestTypeRecip       0x001F  /* b4-0: Recipient */
-#define   M66592_DEVICE                  0x0000
-#define   M66592_INTERFACE               0x0001
-#define   M66592_ENDPOINT                0x0002
+#define M66592_bRequest                 0xFF00  /* b15-8: bRequest */
+#define   M66592_GET_STATUS              0x0000
+#define   M66592_CLEAR_FEATURE           0x0100
+#define   M66592_ReqRESERVED             0x0200
+#define   M66592_SET_FEATURE             0x0300
+#define   M66592_ReqRESERVED1            0x0400
+#define   M66592_SET_ADDRESS             0x0500
+#define   M66592_GET_DESCRIPTOR          0x0600
+#define   M66592_SET_DESCRIPTOR          0x0700
+#define   M66592_GET_CONFIGURATION       0x0800
+#define   M66592_SET_CONFIGURATION       0x0900
+#define   M66592_GET_INTERFACE           0x0A00
+#define   M66592_SET_INTERFACE           0x0B00
+#define   M66592_SYNCH_FRAME             0x0C00
+#define M66592_bmRequestType            0x00FF  /* b7-0: bmRequestType */
+#define M66592_bmRequestTypeDir         0x0080  /* b7  : Data direction */
+#define   M66592_HOST_TO_DEVICE          0x0000
+#define   M66592_DEVICE_TO_HOST          0x0080
+#define M66592_bmRequestTypeType        0x0060  /* b6-5: Type */
+#define   M66592_STANDARD                0x0000
+#define   M66592_CLASS                   0x0020
+#define   M66592_VENDOR                  0x0040
+#define M66592_bmRequestTypeRecip       0x001F  /* b4-0: Recipient */
+#define   M66592_DEVICE                  0x0000
+#define   M66592_INTERFACE               0x0001
+#define   M66592_ENDPOINT                0x0002
 
 #define M66592_USBVAL                           0x56
-#define M66592_wValue                           0xFFFF  /* b15-0: wValue */
+#define M66592_wValue                           0xFFFF  /* b15-0: wValue */
 /* Standard Feature Selector */
-#define   M66592_ENDPOINT_HALT                  0x0000
-#define   M66592_DEVICE_REMOTE_WAKEUP           0x0001
-#define   M66592_TEST_MODE                      0x0002
+#define   M66592_ENDPOINT_HALT                  0x0000
+#define   M66592_DEVICE_REMOTE_WAKEUP           0x0001
+#define   M66592_TEST_MODE                      0x0002
 /* Descriptor Types */
-#define M66592_DT_TYPE                          0xFF00
-#define M66592_GET_DT_TYPE(v)                   (((v) & DT_TYPE) >> 8)
-#define   M66592_DT_DEVICE                      0x01
-#define   M66592_DT_CONFIGURATION               0x02
-#define   M66592_DT_STRING                      0x03
-#define   M66592_DT_INTERFACE                   0x04
-#define   M66592_DT_ENDPOINT                    0x05
-#define   M66592_DT_DEVICE_QUALIFIER            0x06
-#define   M66592_DT_OTHER_SPEED_CONFIGURATION   0x07
-#define   M66592_DT_INTERFACE_POWER             0x08
-#define M66592_DT_INDEX                         0x00FF
-#define M66592_CONF_NUM                         0x00FF
-#define M66592_ALT_SET                          0x00FF
+#define M66592_DT_TYPE                          0xFF00
+#define M66592_GET_DT_TYPE(v)                   (((v) & DT_TYPE) >> 8)
+#define   M66592_DT_DEVICE                      0x01
+#define   M66592_DT_CONFIGURATION               0x02
+#define   M66592_DT_STRING                      0x03
+#define   M66592_DT_INTERFACE                   0x04
+#define   M66592_DT_ENDPOINT                    0x05
+#define   M66592_DT_DEVICE_QUALIFIER            0x06
+#define   M66592_DT_OTHER_SPEED_CONFIGURATION   0x07
+#define   M66592_DT_INTERFACE_POWER             0x08
+#define M66592_DT_INDEX                         0x00FF
+#define M66592_CONF_NUM                         0x00FF
+#define M66592_ALT_SET                          0x00FF
 
 #define M66592_USBINDEX                 0x58
-#define M66592_wIndex                   0xFFFF  /* b15-0: wIndex */
-#define M66592_TEST_SELECT              0xFF00  /* b15-b8: Test Mode Selectors */
-#define   M66592_TEST_J                  0x0100           /* Test_J */
-#define   M66592_TEST_K                  0x0200           /* Test_K */
-#define   M66592_TEST_SE0_NAK            0x0300           /* Test_SE0_NAK */
-#define   M66592_TEST_PACKET             0x0400           /* Test_Packet */
-#define   M66592_TEST_FORCE_ENABLE       0x0500           /* Test_Force_Enable */
-#define   M66592_TEST_STSelectors        0x0600           /* Standard test selectors */
-#define   M66592_TEST_Reserved           0x4000           /* Reserved */
-#define   M66592_TEST_VSTModes           0xC000           /* Vendor-specific test modes */
-#define M66592_EP_DIR                   0x0080  /* b7: Endpoint Direction */
-#define   M66592_EP_DIR_IN               0x0080
-#define   M66592_EP_DIR_OUT              0x0000
+#define M66592_wIndex                   0xFFFF  /* b15-0: wIndex */
+#define M66592_TEST_SELECT              0xFF00  /* b15-b8: Test Mode */
+#define   M66592_TEST_J                  0x0100   /* Test_J */
+#define   M66592_TEST_K                  0x0200   /* Test_K */
+#define   M66592_TEST_SE0_NAK            0x0300   /* Test_SE0_NAK */
+#define   M66592_TEST_PACKET             0x0400   /* Test_Packet */
+#define   M66592_TEST_FORCE_ENABLE       0x0500   /* Test_Force_Enable */
+#define   M66592_TEST_STSelectors        0x0600   /* Standard test selectors */
+#define   M66592_TEST_Reserved           0x4000   /* Reserved */
+#define   M66592_TEST_VSTModes           0xC000   /* Vendor-specific tests */
+#define M66592_EP_DIR                   0x0080  /* b7: Endpoint Direction */
+#define   M66592_EP_DIR_IN               0x0080
+#define   M66592_EP_DIR_OUT              0x0000
 
 #define M66592_USBLENG          0x5A
-#define M66592_wLength          0xFFFF  /* b15-0: wLength */
+#define M66592_wLength          0xFFFF  /* b15-0: wLength */
 
 #define M66592_DCPCFG           0x5C
-#define M66592_CNTMD            0x0100  /* b8: Continuous transfer mode select */
-#define M66592_DIR              0x0010  /* b4: Control transfer DIR select */
+#define M66592_CNTMD            0x0100  /* b8: Continuous transfer mode */
+#define M66592_DIR              0x0010  /* b4: Control transfer DIR select */
 
 #define M66592_DCPMAXP          0x5E
-#define M66592_DEVSEL           0xC000  /* b15-14: Device address select */
-#define   M66592_DEVICE_0        0x0000           /* Device address 0 */
-#define   M66592_DEVICE_1        0x4000           /* Device address 1 */
-#define   M66592_DEVICE_2        0x8000           /* Device address 2 */
-#define   M66592_DEVICE_3        0xC000           /* Device address 3 */
-#define M66592_MAXP             0x007F  /* b6-0: Maxpacket size of default control pipe */
+#define M66592_DEVSEL           0xC000  /* b15-14: Device address select */
+#define   M66592_DEVICE_0        0x0000           /* Device address 0 */
+#define   M66592_DEVICE_1        0x4000           /* Device address 1 */
+#define   M66592_DEVICE_2        0x8000           /* Device address 2 */
+#define   M66592_DEVICE_3        0xC000           /* Device address 3 */
+#define M66592_MAXP             0x007F  /* b6-0: Maxpacket size of ep0 */
 
 #define M66592_DCPCTR           0x60
-#define M66592_BSTS             0x8000  /* b15: Buffer status */
-#define M66592_SUREQ            0x4000  /* b14: Send USB request  */
-#define M66592_SQCLR            0x0100  /* b8: Sequence toggle bit clear */
-#define M66592_SQSET            0x0080  /* b7: Sequence toggle bit set */
-#define M66592_SQMON            0x0040  /* b6: Sequence toggle bit monitor */
-#define M66592_CCPL             0x0004  /* b2: Enable control transfer complete */
-#define M66592_PID              0x0003  /* b1-0: Response PID */
-#define   M66592_PID_STALL       0x0002           /* STALL */
-#define   M66592_PID_BUF         0x0001           /* BUF */
-#define   M66592_PID_NAK         0x0000           /* NAK */
+#define M66592_BSTS             0x8000  /* b15: Buffer status */
+#define M66592_SUREQ            0x4000  /* b14: Send USB request  */
+#define M66592_SQCLR            0x0100  /* b8: Sequence toggle bit clear */
+#define M66592_SQSET            0x0080  /* b7: Sequence toggle bit set */
+#define M66592_SQMON            0x0040  /* b6: Sequence toggle bit monitor */
+#define M66592_CCPL             0x0004  /* b2: control transfer complete */
+#define M66592_PID              0x0003  /* b1-0: Response PID */
+#define   M66592_PID_STALL       0x0002           /* STALL */
+#define   M66592_PID_BUF         0x0001           /* BUF */
+#define   M66592_PID_NAK         0x0000           /* NAK */
 
 #define M66592_PIPESEL          0x64
-#define M66592_PIPENM           0x0007  /* b2-0: Pipe select */
-#define   M66592_PIPE0           0x0000           /* PIPE 0 */
-#define   M66592_PIPE1           0x0001           /* PIPE 1 */
-#define   M66592_PIPE2           0x0002           /* PIPE 2 */
-#define   M66592_PIPE3           0x0003           /* PIPE 3 */
-#define   M66592_PIPE4           0x0004           /* PIPE 4 */
-#define   M66592_PIPE5           0x0005           /* PIPE 5 */
-#define   M66592_PIPE6           0x0006           /* PIPE 6 */
-#define   M66592_PIPE7           0x0007           /* PIPE 7 */
+#define M66592_PIPENM           0x0007  /* b2-0: Pipe select */
+#define   M66592_PIPE0           0x0000           /* PIPE 0 */
+#define   M66592_PIPE1           0x0001           /* PIPE 1 */
+#define   M66592_PIPE2           0x0002           /* PIPE 2 */
+#define   M66592_PIPE3           0x0003           /* PIPE 3 */
+#define   M66592_PIPE4           0x0004           /* PIPE 4 */
+#define   M66592_PIPE5           0x0005           /* PIPE 5 */
+#define   M66592_PIPE6           0x0006           /* PIPE 6 */
+#define   M66592_PIPE7           0x0007           /* PIPE 7 */
 
 #define M66592_PIPECFG          0x66
-#define M66592_TYP              0xC000  /* b15-14: Transfer type */
-#define   M66592_ISO             0xC000           /* Isochronous */
-#define   M66592_INT             0x8000           /* Interrupt */
-#define   M66592_BULK            0x4000           /* Bulk */
-#define M66592_BFRE             0x0400  /* b10: Buffer ready interrupt mode select */
-#define M66592_DBLB             0x0200  /* b9: Double buffer mode select */
-#define M66592_CNTMD            0x0100  /* b8: Continuous transfer mode select */
-#define M66592_SHTNAK           0x0080  /* b7: Transfer end NAK */
-#define M66592_DIR              0x0010  /* b4: Transfer direction select */
-#define   M66592_DIR_H_OUT       0x0010           /* HOST OUT */
-#define   M66592_DIR_P_IN        0x0010           /* PERI IN */
-#define   M66592_DIR_H_IN        0x0000           /* HOST IN */
-#define   M66592_DIR_P_OUT       0x0000           /* PERI OUT */
-#define M66592_EPNUM            0x000F  /* b3-0: Eendpoint number select */
-#define   M66592_EP1             0x0001
-#define   M66592_EP2             0x0002
-#define   M66592_EP3             0x0003
-#define   M66592_EP4             0x0004
-#define   M66592_EP5             0x0005
-#define   M66592_EP6             0x0006
-#define   M66592_EP7             0x0007
-#define   M66592_EP8             0x0008
-#define   M66592_EP9             0x0009
-#define   M66592_EP10            0x000A
-#define   M66592_EP11            0x000B
-#define   M66592_EP12            0x000C
-#define   M66592_EP13            0x000D
-#define   M66592_EP14            0x000E
-#define   M66592_EP15            0x000F
+#define M66592_TYP              0xC000  /* b15-14: Transfer type */
+#define   M66592_ISO             0xC000           /* Isochronous */
+#define   M66592_INT             0x8000           /* Interrupt */
+#define   M66592_BULK            0x4000           /* Bulk */
+#define M66592_BFRE             0x0400  /* b10: Buffer ready interrupt mode */
+#define M66592_DBLB             0x0200  /* b9: Double buffer mode select */
+#define M66592_CNTMD            0x0100  /* b8: Continuous transfer mode */
+#define M66592_SHTNAK           0x0080  /* b7: Transfer end NAK */
+#define M66592_DIR              0x0010  /* b4: Transfer direction select */
+#define   M66592_DIR_H_OUT       0x0010           /* HOST OUT */
+#define   M66592_DIR_P_IN        0x0010           /* PERI IN */
+#define   M66592_DIR_H_IN        0x0000           /* HOST IN */
+#define   M66592_DIR_P_OUT       0x0000           /* PERI OUT */
+#define M66592_EPNUM            0x000F  /* b3-0: Eendpoint number select */
+#define   M66592_EP1             0x0001
+#define   M66592_EP2             0x0002
+#define   M66592_EP3             0x0003
+#define   M66592_EP4             0x0004
+#define   M66592_EP5             0x0005
+#define   M66592_EP6             0x0006
+#define   M66592_EP7             0x0007
+#define   M66592_EP8             0x0008
+#define   M66592_EP9             0x0009
+#define   M66592_EP10            0x000A
+#define   M66592_EP11            0x000B
+#define   M66592_EP12            0x000C
+#define   M66592_EP13            0x000D
+#define   M66592_EP14            0x000E
+#define   M66592_EP15            0x000F
 
 #define M66592_PIPEBUF          0x68
-#define M66592_BUFSIZE          0x7C00  /* b14-10: Pipe buffer size */
-#define M66592_BUF_SIZE(x)      ((((x) / 64) - 1) << 10)
-#define M66592_BUFNMB           0x00FF  /* b7-0: Pipe buffer number */
+#define M66592_BUFSIZE          0x7C00  /* b14-10: Pipe buffer size */
+#define M66592_BUF_SIZE(x)      ((((x) / 64) - 1) << 10)
+#define M66592_BUFNMB           0x00FF  /* b7-0: Pipe buffer number */
 
 #define M66592_PIPEMAXP         0x6A
-#define M66592_MXPS             0x07FF  /* b10-0: Maxpacket size */
+#define M66592_MXPS             0x07FF  /* b10-0: Maxpacket size */
 
 #define M66592_PIPEPERI         0x6C
-#define M66592_IFIS             0x1000  /* b12: Isochronous in-buffer flush mode select */
-#define M66592_IITV             0x0007  /* b2-0: Isochronous interval */
+#define M66592_IFIS             0x1000  /* b12: ISO in-buffer flush mode */
+#define M66592_IITV             0x0007  /* b2-0: ISO interval */
 
 #define M66592_PIPE1CTR         0x70
 #define M66592_PIPE2CTR         0x72
@@ -401,19 +401,17 @@
 #define M66592_PIPE5CTR         0x78
 #define M66592_PIPE6CTR         0x7A
 #define M66592_PIPE7CTR         0x7C
-#define M66592_BSTS             0x8000  /* b15: Buffer status */
-#define M66592_INBUFM           0x4000  /* b14: IN buffer monitor (Only for PIPE1 to 5) */
-#define M66592_ACLRM            0x0200  /* b9: Out buffer auto clear mode */
-#define M66592_SQCLR            0x0100  /* b8: Sequence toggle bit clear */
-#define M66592_SQSET            0x0080  /* b7: Sequence toggle bit set */
-#define M66592_SQMON            0x0040  /* b6: Sequence toggle bit monitor */
-#define M66592_PID              0x0003  /* b1-0: Response PID */
+#define M66592_BSTS             0x8000  /* b15: Buffer status */
+#define M66592_INBUFM           0x4000  /* b14: IN buffer monitor (PIPE 1-5) */
+#define M66592_ACLRM            0x0200  /* b9: Out buffer auto clear mode */
+#define M66592_SQCLR            0x0100  /* b8: Sequence toggle bit clear */
+#define M66592_SQSET            0x0080  /* b7: Sequence toggle bit set */
+#define M66592_SQMON            0x0040  /* b6: Sequence toggle bit monitor */
+#define M66592_PID              0x0003  /* b1-0: Response PID */
 
 #define M66592_INVALID_REG      0x7E
 
 
-#define __iomem
-
 #define get_pipectr_addr(pipenum)       (M66592_PIPE1CTR + (pipenum - 1) * 2)
 
 #define M66592_MAX_SAMPLING     10
@@ -449,7 +447,7 @@ struct m66592_ep {
         struct m66592           *m66592;
 
         struct list_head        queue;
-        unsigned                busy:1;
+        unsigned                busy:1;
         unsigned                internal_ccpl:1;        /* use only control */
 
         /* this member can able to after m66592_enable */
@@ -477,7 +475,7 @@ struct m66592 {
         struct m66592_ep        *epaddr2ep[16];
 
         struct usb_request      *ep0_req;       /* for internal request */
-        u16                     *ep0_buf;       /* for internal request */
+        u16                     ep0_data;       /* for internal request */
 
         struct timer_list       timer;
 
@@ -527,8 +525,8 @@ static inline u16 m66592_read(struct m66592 *m66592, unsigned long offset)
 }
 
 static inline void m66592_read_fifo(struct m66592 *m66592,
-                                    unsigned long offset,
-                                    void *buf, unsigned long len)
+                unsigned long offset,
+                void *buf, unsigned long len)
 {
         unsigned long fifoaddr = (unsigned long)m66592->reg + offset;
 
@@ -543,8 +541,8 @@ static inline void m66592_write(struct m66592 *m66592, u16 val,
 }
 
 static inline void m66592_write_fifo(struct m66592 *m66592,
-                                     unsigned long offset,
-                                     void *buf, unsigned long len)
+                unsigned long offset,
+                void *buf, unsigned long len)
 {
         unsigned long fifoaddr = (unsigned long)m66592->reg + offset;
         unsigned long odd = len & 0x0001;
@@ -558,7 +556,7 @@ static inline void m66592_write_fifo(struct m66592 *m66592,
 }
 
 static inline void m66592_mdfy(struct m66592 *m66592, u16 val, u16 pat,
-                               unsigned long offset)
+                unsigned long offset)
 {
         u16 tmp;
         tmp = m66592_read(m66592, offset);
diff --git a/drivers/usb/gadget/serial.c b/drivers/usb/gadget/serial.c
index 38138bb9ddb0..9cd98e73dc1d 100644
--- a/drivers/usb/gadget/serial.c
+++ b/drivers/usb/gadget/serial.c
@@ -33,6 +33,7 @@
 #include <linux/device.h>
 #include <linux/tty.h>
 #include <linux/tty_flip.h>
+#include <linux/mutex.h>
 
 #include <asm/byteorder.h>
 #include <asm/io.h>
@@ -258,7 +259,7 @@ static const char *EP_IN_NAME;
 static const char *EP_OUT_NAME;
 static const char *EP_NOTIFY_NAME;
 
-static struct semaphore gs_open_close_sem[GS_NUM_PORTS];
+static struct mutex gs_open_close_lock[GS_NUM_PORTS];
 
 static unsigned int read_q_size = GS_DEFAULT_READ_Q_SIZE;
 static unsigned int write_q_size = GS_DEFAULT_WRITE_Q_SIZE;
@@ -595,7 +596,7 @@ static int __init gs_module_init(void)
         tty_set_operations(gs_tty_driver, &gs_tty_ops);
 
         for (i=0; i < GS_NUM_PORTS; i++)
-                sema_init(&gs_open_close_sem[i], 1);
+                mutex_init(&gs_open_close_lock[i]);
 
         retval = tty_register_driver(gs_tty_driver);
         if (retval) {
@@ -635,7 +636,7 @@ static int gs_open(struct tty_struct *tty, struct file *file)
         struct gs_port *port;
         struct gs_dev *dev;
         struct gs_buf *buf;
-        struct semaphore *sem;
+        struct mutex *mtx;
         int ret;
 
         port_num = tty->index;
@@ -656,10 +657,10 @@ static int gs_open(struct tty_struct *tty, struct file *file)
                 return -ENODEV;
         }
 
-        sem = &gs_open_close_sem[port_num];
-        if (down_interruptible(sem)) {
+        mtx = &gs_open_close_lock[port_num];
+        if (mutex_lock_interruptible(mtx)) {
                 printk(KERN_ERR
-                "gs_open: (%d,%p,%p) interrupted waiting for semaphore\n",
+                "gs_open: (%d,%p,%p) interrupted waiting for mutex\n",
                         port_num, tty, file);
                 return -ERESTARTSYS;
         }
@@ -754,12 +755,12 @@ static int gs_open(struct tty_struct *tty, struct file *file)
 
 exit_unlock_port:
         spin_unlock_irqrestore(&port->port_lock, flags);
-        up(sem);
+        mutex_unlock(mtx);
         return ret;
 
 exit_unlock_dev:
         spin_unlock_irqrestore(&dev->dev_lock, flags);
-        up(sem);
+        mutex_unlock(mtx);
         return ret;
 
 }
@@ -781,7 +782,7 @@ exit_unlock_dev:
 static void gs_close(struct tty_struct *tty, struct file *file)
 {
         struct gs_port *port = tty->driver_data;
-        struct semaphore *sem;
+        struct mutex *mtx;
 
         if (port == NULL) {
                 printk(KERN_ERR "gs_close: NULL port pointer\n");
@@ -790,8 +791,8 @@ static void gs_close(struct tty_struct *tty, struct file *file)
 
         gs_debug("gs_close: (%d,%p,%p)\n", port->port_num, tty, file);
 
-        sem = &gs_open_close_sem[port->port_num];
-        down(sem);
+        mtx = &gs_open_close_lock[port->port_num];
+        mutex_lock(mtx);
 
         spin_lock_irq(&port->port_lock);
 
@@ -846,7 +847,7 @@ static void gs_close(struct tty_struct *tty, struct file *file)
 
 exit:
         spin_unlock_irq(&port->port_lock);
-        up(sem);
+        mutex_unlock(mtx);
 }
 
 /*
diff --git a/drivers/usb/host/isp116x-hcd.c b/drivers/usb/host/isp116x-hcd.c
index 46873f2534b5..5c851a36de72 100644
--- a/drivers/usb/host/isp116x-hcd.c
+++ b/drivers/usb/host/isp116x-hcd.c
@@ -228,7 +228,6 @@ static void preproc_atl_queue(struct isp116x *isp116x)
                                    struct urb, urb_list);
                 ptd = &ep->ptd;
                 len = ep->length;
-                spin_lock(&urb->lock);
                 ep->data = (unsigned char *)urb->transfer_buffer
                     + urb->actual_length;
 
@@ -264,7 +263,6 @@ static void preproc_atl_queue(struct isp116x *isp116x)
                     | PTD_EP(ep->epnum);
                 ptd->len = PTD_LEN(len) | PTD_DIR(dir);
                 ptd->faddr = PTD_FA(usb_pipedevice(urb->pipe));
-                spin_unlock(&urb->lock);
                 if (!ep->active) {
                         ptd->mps |= PTD_LAST_MSK;
                         isp116x->atl_last_dir = dir;
@@ -275,6 +273,61 @@ static void preproc_atl_queue(struct isp116x *isp116x)
 }
 
 /*
+  Take done or failed requests out of schedule. Give back
+  processed urbs.
+*/
+static void finish_request(struct isp116x *isp116x, struct isp116x_ep *ep,
+                           struct urb *urb)
+__releases(isp116x->lock) __acquires(isp116x->lock)
+{
+        unsigned i;
+
+        urb->hcpriv = NULL;
+        ep->error_count = 0;
+
+        if (usb_pipecontrol(urb->pipe))
+                ep->nextpid = USB_PID_SETUP;
+
+        urb_dbg(urb, "Finish");
+
+        spin_unlock(&isp116x->lock);
+        usb_hcd_giveback_urb(isp116x_to_hcd(isp116x), urb);
+        spin_lock(&isp116x->lock);
+
+        /* take idle endpoints out of the schedule */
+        if (!list_empty(&ep->hep->urb_list))
+                return;
+
+        /* async deschedule */
+        if (!list_empty(&ep->schedule)) {
+                list_del_init(&ep->schedule);
+                return;
+        }
+
+        /* periodic deschedule */
+        DBG("deschedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
+        for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
+                struct isp116x_ep *temp;
+                struct isp116x_ep **prev = &isp116x->periodic[i];
+
+                while (*prev && ((temp = *prev) != ep))
+                        prev = &temp->next;
+                if (*prev)
+                        *prev = ep->next;
+                isp116x->load[i] -= ep->load;
+        }
+        ep->branch = PERIODIC_SIZE;
+        isp116x_to_hcd(isp116x)->self.bandwidth_allocated -=
+            ep->load / ep->period;
+
+        /* switch irq type? */
+        if (!--isp116x->periodic_count) {
+                isp116x->irqenb &= ~HCuPINT_SOF;
+                isp116x->irqenb |= HCuPINT_ATL;
+        }
+}
+
+/*
   Analyze transfer results, handle partial transfers and errors
 */
 static void postproc_atl_queue(struct isp116x *isp116x)
@@ -284,6 +337,7 @@ static void postproc_atl_queue(struct isp116x *isp116x)
         struct usb_device *udev;
         struct ptd *ptd;
         int short_not_ok;
+        int status;
         u8 cc;
 
         for (ep = isp116x->atl_active; ep; ep = ep->active) {
@@ -294,7 +348,7 @@ static void postproc_atl_queue(struct isp116x *isp116x)
                 ptd = &ep->ptd;
                 cc = PTD_GET_CC(ptd);
                 short_not_ok = 1;
-                spin_lock(&urb->lock);
+                status = -EINPROGRESS;
 
                 /* Data underrun is special. For allowed underrun
                    we clear the error and continue as normal. For
@@ -302,47 +356,36 @@ static void postproc_atl_queue(struct isp116x *isp116x)
                    immediately while for control transfer,
                    we do a STATUS stage. */
                 if (cc == TD_DATAUNDERRUN) {
-                        if (!(urb->transfer_flags & URB_SHORT_NOT_OK)) {
-                                DBG("Allowed data underrun\n");
+                        if (!(urb->transfer_flags & URB_SHORT_NOT_OK) ||
+                                        usb_pipecontrol(urb->pipe)) {
+                                DBG("Allowed or control data underrun\n");
                                 cc = TD_CC_NOERROR;
                                 short_not_ok = 0;
                         } else {
                                 ep->error_count = 1;
-                                if (usb_pipecontrol(urb->pipe))
-                                        ep->nextpid = USB_PID_ACK;
-                                else
-                                        usb_settoggle(udev, ep->epnum,
-                                                      ep->nextpid ==
-                                                      USB_PID_OUT,
-                                                      PTD_GET_TOGGLE(ptd));
+                                usb_settoggle(udev, ep->epnum,
+                                              ep->nextpid == USB_PID_OUT,
+                                              PTD_GET_TOGGLE(ptd));
                                 urb->actual_length += PTD_GET_COUNT(ptd);
-                                urb->status = cc_to_error[TD_DATAUNDERRUN];
-                                spin_unlock(&urb->lock);
-                                continue;
+                                status = cc_to_error[TD_DATAUNDERRUN];
+                                goto done;
                         }
                 }
-                /* Keep underrun error through the STATUS stage */
-                if (urb->status == cc_to_error[TD_DATAUNDERRUN])
-                        cc = TD_DATAUNDERRUN;
 
                 if (cc != TD_CC_NOERROR && cc != TD_NOTACCESSED
                     && (++ep->error_count >= 3 || cc == TD_CC_STALL
                         || cc == TD_DATAOVERRUN)) {
-                        if (urb->status == -EINPROGRESS)
-                                urb->status = cc_to_error[cc];
+                        status = cc_to_error[cc];
                         if (ep->nextpid == USB_PID_ACK)
                                 ep->nextpid = 0;
-                        spin_unlock(&urb->lock);
-                        continue;
+                        goto done;
                 }
                 /* According to usb spec, zero-length Int transfer signals
                    finishing of the urb. Hey, does this apply only
                    for IN endpoints? */
                 if (usb_pipeint(urb->pipe) && !PTD_GET_LEN(ptd)) {
-                        if (urb->status == -EINPROGRESS)
-                                urb->status = 0;
-                        spin_unlock(&urb->lock);
-                        continue;
+                        status = 0;
+                        goto done;
                 }
 
                 /* Relax after previously failed, but later succeeded
@@ -381,8 +424,8 @@ static void postproc_atl_queue(struct isp116x *isp116x)
                         /* All data for this URB is transferred, let's finish */
                         if (usb_pipecontrol(urb->pipe))
                                 ep->nextpid = USB_PID_ACK;
-                        else if (urb->status == -EINPROGRESS)
-                                urb->status = 0;
+                        else
+                                status = 0;
                         break;
                 case USB_PID_SETUP:
                         if (PTD_GET_ACTIVE(ptd)
@@ -402,69 +445,27 @@ static void postproc_atl_queue(struct isp116x *isp116x)
                         if (PTD_GET_ACTIVE(ptd)
                             || (cc != TD_CC_NOERROR && cc < 0x0E))
                                 break;
-                        if (urb->status == -EINPROGRESS)
-                                urb->status = 0;
+                        if ((urb->transfer_flags & URB_SHORT_NOT_OK) &&
+                                        urb->actual_length <
+                                                urb->transfer_buffer_length)
+                                status = -EREMOTEIO;
+                        else
+                                status = 0;
                         ep->nextpid = 0;
                         break;
                 default:
                         BUG();
                 }
-                spin_unlock(&urb->lock);
-        }
-}
-
-/*
-  Take done or failed requests out of schedule. Give back
-  processed urbs.
-*/
-static void finish_request(struct isp116x *isp116x, struct isp116x_ep *ep,
-                           struct urb *urb)
-__releases(isp116x->lock) __acquires(isp116x->lock)
-{
-        unsigned i;
-
-        urb->hcpriv = NULL;
-        ep->error_count = 0;
-
-        if (usb_pipecontrol(urb->pipe))
-                ep->nextpid = USB_PID_SETUP;
-
-        urb_dbg(urb, "Finish");
-
-        spin_unlock(&isp116x->lock);
-        usb_hcd_giveback_urb(isp116x_to_hcd(isp116x), urb);
-        spin_lock(&isp116x->lock);
-
-        /* take idle endpoints out of the schedule */
-        if (!list_empty(&ep->hep->urb_list))
-                return;
-
-        /* async deschedule */
-        if (!list_empty(&ep->schedule)) {
-                list_del_init(&ep->schedule);
-                return;
-        }
 
-        /* periodic deschedule */
-        DBG("deschedule qh%d/%p branch %d\n", ep->period, ep, ep->branch);
-        for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) {
-                struct isp116x_ep *temp;
-                struct isp116x_ep **prev = &isp116x->periodic[i];
-
-                while (*prev && ((temp = *prev) != ep))
-                        prev = &temp->next;
-                if (*prev)
-                        *prev = ep->next;
-                isp116x->load[i] -= ep->load;
-        }
-        ep->branch = PERIODIC_SIZE;
-        isp116x_to_hcd(isp116x)->self.bandwidth_allocated -=
-            ep->load / ep->period;
-
-        /* switch irq type? */
-        if (!--isp116x->periodic_count) {
-                isp116x->irqenb &= ~HCuPINT_SOF;
-                isp116x->irqenb |= HCuPINT_ATL;
+ done:
+                if (status != -EINPROGRESS) {
+                        spin_lock(&urb->lock);
+                        if (urb->status == -EINPROGRESS)
+                                urb->status = status;
+                        spin_unlock(&urb->lock);
+                }
+                if (urb->status != -EINPROGRESS)
+                        finish_request(isp116x, ep, urb);
         }
 }
 
@@ -570,9 +571,6 @@ static void start_atl_transfers(struct isp116x *isp116x)
 */
 static void finish_atl_transfers(struct isp116x *isp116x)
 {
-        struct isp116x_ep *ep;
-        struct urb *urb;
-
         if (!isp116x->atl_active)
                 return;
         /* Fifo not ready? */
@@ -582,16 +580,6 @@ static void finish_atl_transfers(struct isp116x *isp116x)
         atomic_inc(&isp116x->atl_finishing);
         unpack_fifo(isp116x);
         postproc_atl_queue(isp116x);
-        for (ep = isp116x->atl_active; ep; ep = ep->active) {
-                urb =
-                    container_of(ep->hep->urb_list.next, struct urb, urb_list);
-                /* USB_PID_ACK check here avoids finishing of
-                   control transfers, for which TD_DATAUNDERRUN
-                   occured, while URB_SHORT_NOT_OK was set */
-                if (urb && urb->status != -EINPROGRESS
-                    && ep->nextpid != USB_PID_ACK)
-                        finish_request(isp116x, ep, urb);
-        }
         atomic_dec(&isp116x->atl_finishing);
 }
 
@@ -821,15 +809,12 @@ static int isp116x_urb_enqueue(struct usb_hcd *hcd,
         }
 
         /* in case of unlink-during-submit */
-        spin_lock(&urb->lock);
         if (urb->status != -EINPROGRESS) {
-                spin_unlock(&urb->lock);
                 finish_request(isp116x, ep, urb);
                 ret = 0;
                 goto fail;
         }
         urb->hcpriv = hep;
-        spin_unlock(&urb->lock);
         start_atl_transfers(isp116x);
 
       fail:
diff --git a/drivers/usb/host/r8a66597-hcd.c b/drivers/usb/host/r8a66597-hcd.c
index a7a7070c6e2a..d60f1985320c 100644
--- a/drivers/usb/host/r8a66597-hcd.c
+++ b/drivers/usb/host/r8a66597-hcd.c
@@ -35,10 +35,8 @@
 #include <linux/interrupt.h>
 #include <linux/usb.h>
 #include <linux/platform_device.h>
-
-#include <asm/io.h>
-#include <asm/irq.h>
-#include <asm/system.h>
+#include <linux/io.h>
+#include <linux/irq.h>
 
 #include "../core/hcd.h"
 #include "r8a66597.h"
@@ -54,16 +52,21 @@ static const char hcd_name[] = "r8a66597_hcd";
 /* module parameters */
 static unsigned short clock = XTAL12;
 module_param(clock, ushort, 0644);
-MODULE_PARM_DESC(clock, "input clock: 48MHz=32768, 24MHz=16384, 12MHz=0(default=0)");
+MODULE_PARM_DESC(clock, "input clock: 48MHz=32768, 24MHz=16384, 12MHz=0 "
+                "(default=0)");
+
 static unsigned short vif = LDRV;
 module_param(vif, ushort, 0644);
 MODULE_PARM_DESC(vif, "input VIF: 3.3V=32768, 1.5V=0(default=32768)");
-static unsigned short endian = 0;
+
+static unsigned short endian;
 module_param(endian, ushort, 0644);
-MODULE_PARM_DESC(endian, "data endian: big=256, little=0(default=0)");
+MODULE_PARM_DESC(endian, "data endian: big=256, little=0 (default=0)");
+
 static unsigned short irq_sense = INTL;
 module_param(irq_sense, ushort, 0644);
-MODULE_PARM_DESC(irq_sense, "IRQ sense: low level=32, falling edge=0(default=32)");
+MODULE_PARM_DESC(irq_sense, "IRQ sense: low level=32, falling edge=0 "
+                "(default=32)");
 
 static void packet_write(struct r8a66597 *r8a66597, u16 pipenum);
 static int r8a66597_get_frame(struct usb_hcd *hcd);
@@ -308,7 +311,7 @@ static int make_r8a66597_device(struct r8a66597 *r8a66597,
         struct r8a66597_device *dev;
         int usb_address = urb->setup_packet[2]; /* urb->pipe is address 0 */
 
-        dev = kzalloc(sizeof(struct r8a66597_device), GFP_KERNEL);
+        dev = kzalloc(sizeof(struct r8a66597_device), GFP_ATOMIC);
         if (dev == NULL)
                 return -ENOMEM;
 
@@ -611,33 +614,33 @@ static u16 get_empty_pipenum(struct r8a66597 *r8a66597,
         u16 array[R8A66597_MAX_NUM_PIPE], i = 0, min;
 
         memset(array, 0, sizeof(array));
-        switch(ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
-        case USB_ENDPOINT_XFER_BULK:
+        switch (ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
+        case USB_ENDPOINT_XFER_BULK:
                 if (ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
                         array[i++] = 4;
                 else {
                         array[i++] = 3;
                         array[i++] = 5;
                 }
-                break;
-        case USB_ENDPOINT_XFER_INT:
+                break;
+        case USB_ENDPOINT_XFER_INT:
                 if (ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK) {
                         array[i++] = 6;
                         array[i++] = 7;
                         array[i++] = 8;
                 } else
                         array[i++] = 9;
-                break;
-        case USB_ENDPOINT_XFER_ISOC:
+                break;
+        case USB_ENDPOINT_XFER_ISOC:
                 if (ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
                         array[i++] = 2;
                 else
                         array[i++] = 1;
-                break;
-        default:
-                err("Illegal type");
-                return 0;
-        }
+                break;
+        default:
+                err("Illegal type");
+                return 0;
+        }
 
         i = 1;
         min = array[0];
@@ -654,7 +657,7 @@ static u16 get_r8a66597_type(__u8 type)
 {
         u16 r8a66597_type;
 
-        switch(type) {
+        switch (type) {
         case USB_ENDPOINT_XFER_BULK:
                 r8a66597_type = R8A66597_BULK;
                 break;
@@ -874,7 +877,7 @@ static void r8a66597_usb_preconnect(struct r8a66597 *r8a66597, int port)
 {
         r8a66597->root_hub[port].port |= (1 << USB_PORT_FEAT_CONNECTION)
                                          | (1 << USB_PORT_FEAT_C_CONNECTION);
-        r8a66597_write(r8a66597, (u16)~DTCH, get_intsts_reg(port));
+        r8a66597_write(r8a66597, ~DTCH, get_intsts_reg(port));
         r8a66597_bset(r8a66597, DTCHE, get_intenb_reg(port));
 }
 
@@ -917,7 +920,7 @@ static void prepare_setup_packet(struct r8a66597 *r8a66597,
 
         r8a66597_write(r8a66597, make_devsel(td->address) | td->maxpacket,
                        DCPMAXP);
-        r8a66597_write(r8a66597, (u16)~(SIGN | SACK), INTSTS1);
+        r8a66597_write(r8a66597, ~(SIGN | SACK), INTSTS1);
 
         for (i = 0; i < 4; i++) {
                 r8a66597_write(r8a66597, p[i], setup_addr);
@@ -948,19 +951,18 @@ static void prepare_packet_read(struct r8a66597 *r8a66597,
                         pipe_irq_disable(r8a66597, td->pipenum);
                         pipe_setting(r8a66597, td);
                         pipe_stop(r8a66597, td->pipe);
-                        r8a66597_write(r8a66597, (u16)~(1 << td->pipenum),
-                                       BRDYSTS);
+                        r8a66597_write(r8a66597, ~(1 << td->pipenum), BRDYSTS);
 
                         if (td->pipe->pipetre) {
                                 r8a66597_write(r8a66597, TRCLR,
-                                                td->pipe->pipetre);
+                                                td->pipe->pipetre);
                                 r8a66597_write(r8a66597,
-                                               (urb->transfer_buffer_length
-                                               + td->maxpacket - 1)
-                                               / td->maxpacket,
-                                               td->pipe->pipetrn);
+                                                (urb->transfer_buffer_length
+                                                + td->maxpacket - 1)
+                                                / td->maxpacket,
+                                                td->pipe->pipetrn);
                                 r8a66597_bset(r8a66597, TRENB,
-                                              td->pipe->pipetre);
+                                                td->pipe->pipetre);
                         }
 
                         pipe_start(r8a66597, td->pipe);
@@ -991,7 +993,7 @@ static void prepare_packet_write(struct r8a66597 *r8a66597,
                 if (td->pipe->pipetre)
                         r8a66597_bclr(r8a66597, TRENB, td->pipe->pipetre);
         }
-        r8a66597_write(r8a66597, (u16)~(1 << td->pipenum), BRDYSTS);
+        r8a66597_write(r8a66597, ~(1 << td->pipenum), BRDYSTS);
 
         fifo_change_from_pipe(r8a66597, td->pipe);
         tmp = r8a66597_read(r8a66597, td->pipe->fifoctr);
@@ -1009,21 +1011,21 @@ static void prepare_status_packet(struct r8a66597 *r8a66597,
         struct urb *urb = td->urb;
 
         r8a66597_pipe_toggle(r8a66597, td->pipe, 1);
+        pipe_stop(r8a66597, td->pipe);
 
         if (urb->setup_packet[0] & USB_ENDPOINT_DIR_MASK) {
                 r8a66597_bset(r8a66597, R8A66597_DIR, DCPCFG);
                 r8a66597_mdfy(r8a66597, ISEL, ISEL | CURPIPE, CFIFOSEL);
                 r8a66597_reg_wait(r8a66597, CFIFOSEL, CURPIPE, 0);
-                r8a66597_write(r8a66597, BVAL | BCLR, CFIFOCTR);
-                r8a66597_write(r8a66597, (u16)~BEMP0, BEMPSTS);
+                r8a66597_write(r8a66597, ~BEMP0, BEMPSTS);
+                r8a66597_write(r8a66597, BCLR, CFIFOCTR);
+                r8a66597_write(r8a66597, BVAL, CFIFOCTR);
                 enable_irq_empty(r8a66597, 0);
         } else {
                 r8a66597_bclr(r8a66597, R8A66597_DIR, DCPCFG);
                 r8a66597_mdfy(r8a66597, 0, ISEL | CURPIPE, CFIFOSEL);
                 r8a66597_reg_wait(r8a66597, CFIFOSEL, CURPIPE, 0);
                 r8a66597_write(r8a66597, BCLR, CFIFOCTR);
-                r8a66597_write(r8a66597, (u16)~BRDY0, BRDYSTS);
-                r8a66597_write(r8a66597, (u16)~BEMP0, BEMPSTS);
                 enable_irq_ready(r8a66597, 0);
         }
         enable_irq_nrdy(r8a66597, 0);
@@ -1269,7 +1271,7 @@ static void packet_write(struct r8a66597 *r8a66597, u16 pipenum)
 
         /* write fifo */
         if (pipenum > 0)
-                r8a66597_write(r8a66597, (u16)~(1 << pipenum), BEMPSTS);
+                r8a66597_write(r8a66597, ~(1 << pipenum), BEMPSTS);
         if (urb->transfer_buffer) {
                 r8a66597_write_fifo(r8a66597, td->pipe->fifoaddr, buf, size);
                 if (!usb_pipebulk(urb->pipe) || td->maxpacket != size)
@@ -1362,7 +1364,7 @@ static void irq_pipe_ready(struct r8a66597 *r8a66597)
 
         mask = r8a66597_read(r8a66597, BRDYSTS)
                & r8a66597_read(r8a66597, BRDYENB);
-        r8a66597_write(r8a66597, (u16)~mask, BRDYSTS);
+        r8a66597_write(r8a66597, ~mask, BRDYSTS);
         if (mask & BRDY0) {
                 td = r8a66597_get_td(r8a66597, 0);
                 if (td && td->type == USB_PID_IN)
@@ -1397,7 +1399,7 @@ static void irq_pipe_empty(struct r8a66597 *r8a66597)
 
         mask = r8a66597_read(r8a66597, BEMPSTS)
                & r8a66597_read(r8a66597, BEMPENB);
-        r8a66597_write(r8a66597, (u16)~mask, BEMPSTS);
+        r8a66597_write(r8a66597, ~mask, BEMPSTS);
         if (mask & BEMP0) {
                 cfifo_change(r8a66597, 0);
                 td = r8a66597_get_td(r8a66597, 0);
@@ -1434,7 +1436,7 @@ static void irq_pipe_nrdy(struct r8a66597 *r8a66597)
 
         mask = r8a66597_read(r8a66597, NRDYSTS)
                & r8a66597_read(r8a66597, NRDYENB);
-        r8a66597_write(r8a66597, (u16)~mask, NRDYSTS);
+        r8a66597_write(r8a66597, ~mask, NRDYSTS);
         if (mask & NRDY0) {
                 cfifo_change(r8a66597, 0);
                 set_urb_error(r8a66597, 0);
@@ -1488,14 +1490,14 @@ static irqreturn_t r8a66597_irq(struct usb_hcd *hcd)
         mask0 = intsts0 & intenb0 & (BEMP | NRDY | BRDY);
         if (mask2) {
                 if (mask2 & ATTCH) {
-                        r8a66597_write(r8a66597, (u16)~ATTCH, INTSTS2);
+                        r8a66597_write(r8a66597, ~ATTCH, INTSTS2);
                         r8a66597_bclr(r8a66597, ATTCHE, INTENB2);
 
                         /* start usb bus sampling */
                         start_root_hub_sampling(r8a66597, 1);
                 }
                 if (mask2 & DTCH) {
-                        r8a66597_write(r8a66597, (u16)~DTCH, INTSTS2);
+                        r8a66597_write(r8a66597, ~DTCH, INTSTS2);
                         r8a66597_bclr(r8a66597, DTCHE, INTENB2);
                         r8a66597_usb_disconnect(r8a66597, 1);
                 }
@@ -1503,24 +1505,24 @@ static irqreturn_t r8a66597_irq(struct usb_hcd *hcd)
 
         if (mask1) {
                 if (mask1 & ATTCH) {
-                        r8a66597_write(r8a66597, (u16)~ATTCH, INTSTS1);
+                        r8a66597_write(r8a66597, ~ATTCH, INTSTS1);
                         r8a66597_bclr(r8a66597, ATTCHE, INTENB1);
 
                         /* start usb bus sampling */
                         start_root_hub_sampling(r8a66597, 0);
                 }
                 if (mask1 & DTCH) {
-                        r8a66597_write(r8a66597, (u16)~DTCH, INTSTS1);
+                        r8a66597_write(r8a66597, ~DTCH, INTSTS1);
                         r8a66597_bclr(r8a66597, DTCHE, INTENB1);
                         r8a66597_usb_disconnect(r8a66597, 0);
                 }
                 if (mask1 & SIGN) {
-                        r8a66597_write(r8a66597, (u16)~SIGN, INTSTS1);
+                        r8a66597_write(r8a66597, ~SIGN, INTSTS1);
                         set_urb_error(r8a66597, 0);
                         check_next_phase(r8a66597);
                 }
                 if (mask1 & SACK) {
-                        r8a66597_write(r8a66597, (u16)~SACK, INTSTS1);
+                        r8a66597_write(r8a66597, ~SACK, INTSTS1);
                         check_next_phase(r8a66597);
                 }
         }
@@ -1663,13 +1665,9 @@ static int check_pipe_config(struct r8a66597 *r8a66597, struct urb *urb)
 static int r8a66597_start(struct usb_hcd *hcd)
 {
         struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
-        int ret;
 
         hcd->state = HC_STATE_RUNNING;
-        if ((ret = enable_controller(r8a66597)) < 0)
-                return ret;
-
-        return 0;
+        return enable_controller(r8a66597);
 }
 
 static void r8a66597_stop(struct usb_hcd *hcd)
@@ -1696,13 +1694,12 @@ static void set_address_zero(struct r8a66597 *r8a66597, struct urb *urb)
 
 static struct r8a66597_td *r8a66597_make_td(struct r8a66597 *r8a66597,
                                             struct urb *urb,
-                                            struct usb_host_endpoint *hep,
-                                            gfp_t mem_flags)
+                                            struct usb_host_endpoint *hep)
 {
         struct r8a66597_td *td;
         u16 pipenum;
 
-        td = kzalloc(sizeof(struct r8a66597_td), mem_flags);
+        td = kzalloc(sizeof(struct r8a66597_td), GFP_ATOMIC);
         if (td == NULL)
                 return NULL;
 
@@ -1741,7 +1738,8 @@ static int r8a66597_urb_enqueue(struct usb_hcd *hcd,
         }
 
         if (!hep->hcpriv) {
-                hep->hcpriv = kzalloc(sizeof(struct r8a66597_pipe), mem_flags);
+                hep->hcpriv = kzalloc(sizeof(struct r8a66597_pipe),
+                                GFP_ATOMIC);
                 if (!hep->hcpriv) {
                         ret = -ENOMEM;
                         goto error;
@@ -1755,7 +1753,7 @@ static int r8a66597_urb_enqueue(struct usb_hcd *hcd,
                 init_pipe_config(r8a66597, urb);
 
         set_address_zero(r8a66597, urb);
-        td = r8a66597_make_td(r8a66597, urb, hep, mem_flags);
+        td = r8a66597_make_td(r8a66597, urb, hep);
         if (td == NULL) {
                 ret = -ENOMEM;
                 goto error;
diff --git a/drivers/usb/host/r8a66597.h b/drivers/usb/host/r8a66597.h
index 97c2a71ac7a1..fe9ceb077d9b 100644
--- a/drivers/usb/host/r8a66597.h
+++ b/drivers/usb/host/r8a66597.h
@@ -203,14 +203,14 @@
 #define DTLN            0x0FFF  /* b11-0: FIFO received data length */
 
 /* Interrupt Enable Register 0 */
-#define VBSE            0x8000  /* b15: VBUS interrupt */
-#define RSME            0x4000  /* b14: Resume interrupt */
-#define SOFE            0x2000  /* b13: Frame update interrupt */
-#define DVSE            0x1000  /* b12: Device state transition interrupt */
-#define CTRE            0x0800  /* b11: Control transfer stage transition interrupt */
-#define BEMPE           0x0400  /* b10: Buffer empty interrupt */
-#define NRDYE           0x0200  /* b9: Buffer not ready interrupt */
-#define BRDYE           0x0100  /* b8: Buffer ready interrupt */
+#define VBSE    0x8000  /* b15: VBUS interrupt */
+#define RSME    0x4000  /* b14: Resume interrupt */
+#define SOFE    0x2000  /* b13: Frame update interrupt */
+#define DVSE    0x1000  /* b12: Device state transition interrupt */
+#define CTRE    0x0800  /* b11: Control transfer stage transition interrupt */
+#define BEMPE   0x0400  /* b10: Buffer empty interrupt */
+#define NRDYE   0x0200  /* b9: Buffer not ready interrupt */
+#define BRDYE   0x0100  /* b8: Buffer ready interrupt */
 
 /* Interrupt Enable Register 1 */
 #define OVRCRE          0x8000  /* b15: Over-current interrupt */
@@ -268,16 +268,16 @@
 #define   SOF_DISABLE    0x0000   /* SOF OUT Disable */
 
 /* Interrupt Status Register 0 */
-#define VBINT           0x8000  /* b15: VBUS interrupt */
-#define RESM            0x4000  /* b14: Resume interrupt */
-#define SOFR            0x2000  /* b13: SOF frame update interrupt */
-#define DVST            0x1000  /* b12: Device state transition interrupt */
-#define CTRT            0x0800  /* b11: Control transfer stage transition interrupt */
-#define BEMP            0x0400  /* b10: Buffer empty interrupt */
-#define NRDY            0x0200  /* b9: Buffer not ready interrupt */
-#define BRDY            0x0100  /* b8: Buffer ready interrupt */
-#define VBSTS           0x0080  /* b7: VBUS input port */
-#define DVSQ            0x0070  /* b6-4: Device state */
+#define VBINT   0x8000  /* b15: VBUS interrupt */
+#define RESM    0x4000  /* b14: Resume interrupt */
+#define SOFR    0x2000  /* b13: SOF frame update interrupt */
+#define DVST    0x1000  /* b12: Device state transition interrupt */
+#define CTRT    0x0800  /* b11: Control transfer stage transition interrupt */
+#define BEMP    0x0400  /* b10: Buffer empty interrupt */
+#define NRDY    0x0200  /* b9: Buffer not ready interrupt */
+#define BRDY    0x0100  /* b8: Buffer ready interrupt */
+#define VBSTS   0x0080  /* b7: VBUS input port */
+#define DVSQ    0x0070  /* b6-4: Device state */
 #define   DS_SPD_CNFG    0x0070   /* Suspend Configured */
 #define   DS_SPD_ADDR    0x0060   /* Suspend Address */
 #define   DS_SPD_DFLT    0x0050   /* Suspend Default */
@@ -315,13 +315,10 @@
 /* Micro Frame Number Register */
 #define UFRNM           0x0007  /* b2-0: Micro frame number */
 
-/* USB Address / Low Power Status Recovery Register */
-//#define       USBADDR         0x007F  /* b6-0: USB address */
-
 /* Default Control Pipe Maxpacket Size Register */
 /* Pipe Maxpacket Size Register */
-#define DEVSEL          0xF000  /* b15-14: Device address select */
-#define MAXP            0x007F  /* b6-0: Maxpacket size of default control pipe */
+#define DEVSEL  0xF000  /* b15-14: Device address select */
+#define MAXP    0x007F  /* b6-0: Maxpacket size of default control pipe */
 
 /* Default Control Pipe Control Register */
 #define BSTS            0x8000  /* b15: Buffer status */
@@ -366,21 +363,21 @@
 #define MXPS            0x07FF  /* b10-0: Maxpacket size */
 
 /* Pipe Cycle Configuration Register */
-#define IFIS            0x1000  /* b12: Isochronous in-buffer flush mode select */
-#define IITV            0x0007  /* b2-0: Isochronous interval */
+#define IFIS    0x1000  /* b12: Isochronous in-buffer flush mode select */
+#define IITV    0x0007  /* b2-0: Isochronous interval */
 
 /* Pipex Control Register */
-#define BSTS            0x8000  /* b15: Buffer status */
-#define INBUFM          0x4000  /* b14: IN buffer monitor (Only for PIPE1 to 5) */
-#define CSCLR           0x2000  /* b13: complete-split status clear */
-#define CSSTS           0x1000  /* b12: complete-split status */
-#define ATREPM          0x0400  /* b10: Auto repeat mode */
-#define ACLRM           0x0200  /* b9: Out buffer auto clear mode */
-#define SQCLR           0x0100  /* b8: Sequence toggle bit clear */
-#define SQSET           0x0080  /* b7: Sequence toggle bit set */
-#define SQMON           0x0040  /* b6: Sequence toggle bit monitor */
-#define PBUSY           0x0020  /* b5: pipe busy */
-#define PID             0x0003  /* b1-0: Response PID */
+#define BSTS    0x8000  /* b15: Buffer status */
+#define INBUFM  0x4000  /* b14: IN buffer monitor (Only for PIPE1 to 5) */
+#define CSCLR   0x2000  /* b13: complete-split status clear */
+#define CSSTS   0x1000  /* b12: complete-split status */
+#define ATREPM  0x0400  /* b10: Auto repeat mode */
+#define ACLRM   0x0200  /* b9: Out buffer auto clear mode */
+#define SQCLR   0x0100  /* b8: Sequence toggle bit clear */
+#define SQSET   0x0080  /* b7: Sequence toggle bit set */
+#define SQMON   0x0040  /* b6: Sequence toggle bit monitor */
+#define PBUSY   0x0020  /* b5: pipe busy */
+#define PID     0x0003  /* b1-0: Response PID */
 
 /* PIPExTRE */
 #define TRENB           0x0200  /* b9: Transaction counter enable */
@@ -407,15 +404,15 @@
 #define make_devsel(addr)               (addr << 12)
 
 struct r8a66597_pipe_info {
-        u16 pipenum;
-        u16 address;    /* R8A66597 HCD usb addres */
-        u16 epnum;
-        u16 maxpacket;
-        u16 type;
-        u16 bufnum;
-        u16 buf_bsize;
-        u16 interval;
-        u16 dir_in;
+        u16 pipenum;
+        u16 address;    /* R8A66597 HCD usb addres */
+        u16 epnum;
+        u16 maxpacket;
+        u16 type;
+        u16 bufnum;
+        u16 buf_bsize;
+        u16 interval;
+        u16 dir_in;
 };
 
 struct r8a66597_pipe {
diff --git a/drivers/usb/host/u132-hcd.c b/drivers/usb/host/u132-hcd.c
index e98df2ee9901..7f765ec038cd 100644
--- a/drivers/usb/host/u132-hcd.c
+++ b/drivers/usb/host/u132-hcd.c
@@ -52,6 +52,7 @@
 #include <linux/workqueue.h>
 #include <linux/platform_device.h>
 #include <linux/pci_ids.h>
+#include <linux/mutex.h>
 #include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/system.h>
@@ -83,7 +84,7 @@ static DECLARE_WAIT_QUEUE_HEAD(u132_hcd_wait);
 * u132_module_lock exists to protect access to global variables
 *
 */
-static struct semaphore u132_module_lock;
+static struct mutex u132_module_lock;
 static int u132_exiting = 0;
 static int u132_instances = 0;
 static struct list_head u132_static_list;
@@ -258,10 +259,10 @@ static void u132_hcd_delete(struct kref *kref)
         struct platform_device *pdev = u132->platform_dev;
         struct usb_hcd *hcd = u132_to_hcd(u132);
         u132->going += 1;
-        down(&u132_module_lock);
+        mutex_lock(&u132_module_lock);
         list_del_init(&u132->u132_list);
         u132_instances -= 1;
-        up(&u132_module_lock);
+        mutex_unlock(&u132_module_lock);
         dev_warn(&u132->platform_dev->dev, "FREEING the hcd=%p and thus the u13"
                 "2=%p going=%d pdev=%p\n", hcd, u132, u132->going, pdev);
         usb_put_hcd(hcd);
@@ -3111,10 +3112,10 @@ static int __devinit u132_probe(struct platform_device *pdev)
                 int retval = 0;
                 struct u132 *u132 = hcd_to_u132(hcd);
                 hcd->rsrc_start = 0;
-                down(&u132_module_lock);
+                mutex_lock(&u132_module_lock);
                 list_add_tail(&u132->u132_list, &u132_static_list);
                 u132->sequence_num = ++u132_instances;
-                up(&u132_module_lock);
+                mutex_unlock(&u132_module_lock);
                 u132_u132_init_kref(u132);
                 u132_initialise(u132, pdev);
                 hcd->product_desc = "ELAN U132 Host Controller";
@@ -3216,7 +3217,7 @@ static int __init u132_hcd_init(void)
         INIT_LIST_HEAD(&u132_static_list);
         u132_instances = 0;
         u132_exiting = 0;
-        init_MUTEX(&u132_module_lock);
+        mutex_init(&u132_module_lock);
         if (usb_disabled())
                 return -ENODEV;
         printk(KERN_INFO "driver %s built at %s on %s\n", hcd_name, __TIME__,
@@ -3232,9 +3233,9 @@ static void __exit u132_hcd_exit(void)
 {
         struct u132 *u132;
         struct u132 *temp;
-        down(&u132_module_lock);
+        mutex_lock(&u132_module_lock);
         u132_exiting += 1;
-        up(&u132_module_lock);
+        mutex_unlock(&u132_module_lock);
         list_for_each_entry_safe(u132, temp, &u132_static_list, u132_list) {
                 platform_device_unregister(u132->platform_dev);
         } platform_driver_unregister(&u132_platform_driver);
diff --git a/drivers/usb/host/uhci-hcd.c b/drivers/usb/host/uhci-hcd.c
index 76c555a67dac..805e5fc5f5db 100644
--- a/drivers/usb/host/uhci-hcd.c
+++ b/drivers/usb/host/uhci-hcd.c
@@ -933,7 +933,7 @@ static int __init uhci_hcd_init(void)
         }
 
         uhci_up_cachep = kmem_cache_create("uhci_urb_priv",
-                sizeof(struct urb_priv), 0, 0, NULL, NULL);
+                sizeof(struct urb_priv), 0, 0, NULL);
         if (!uhci_up_cachep)
                 goto up_failed;
 
diff --git a/drivers/usb/host/uhci-q.c b/drivers/usb/host/uhci-q.c
index 4aed305982ec..3bb908ca38e9 100644
--- a/drivers/usb/host/uhci-q.c
+++ b/drivers/usb/host/uhci-q.c
@@ -827,8 +827,10 @@ static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb,
          * If direction is "send", change the packet ID from SETUP (0x2D)
          * to OUT (0xE1).  Else change it from SETUP to IN (0x69) and
          * set Short Packet Detect (SPD) for all data packets.
+         *
+         * 0-length transfers always get treated as "send".
          */
-        if (usb_pipeout(urb->pipe))
+        if (usb_pipeout(urb->pipe) || len == 0)
                 destination ^= (USB_PID_SETUP ^ USB_PID_OUT);
         else {
                 destination ^= (USB_PID_SETUP ^ USB_PID_IN);
@@ -839,7 +841,12 @@ static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb,
          * Build the DATA TDs
          */
         while (len > 0) {
-                int pktsze = min(len, maxsze);
+                int pktsze = maxsze;
+
+                if (len <= pktsze) {            /* The last data packet */
+                        pktsze = len;
+                        status &= ~TD_CTRL_SPD;
+                }
 
                 td = uhci_alloc_td(uhci);
                 if (!td)
@@ -866,20 +873,10 @@ static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb,
                 goto nomem;
         *plink = LINK_TO_TD(td);
 
-        /*
-         * It's IN if the pipe is an output pipe or we're not expecting
-         * data back.
-         */
-        destination &= ~TD_TOKEN_PID_MASK;
-        if (usb_pipeout(urb->pipe) || !urb->transfer_buffer_length)
-                destination |= USB_PID_IN;
-        else
-                destination |= USB_PID_OUT;
-
+        /* Change direction for the status transaction */
+        destination ^= (USB_PID_IN ^ USB_PID_OUT);
         destination |= TD_TOKEN_TOGGLE;         /* End in Data1 */
 
-        status &= ~TD_CTRL_SPD;
-
         uhci_add_td_to_urbp(td, urbp);
         uhci_fill_td(td, status | TD_CTRL_IOC,
                         destination | uhci_explen(0), 0);
@@ -1185,10 +1182,18 @@ static int uhci_result_common(struct uhci_hcd *uhci, struct urb *urb)
                                 }
                         }
 
+                /* Did we receive a short packet? */
                 } else if (len < uhci_expected_length(td_token(td))) {
 
-                        /* We received a short packet */
-                        if (urb->transfer_flags & URB_SHORT_NOT_OK)
+                        /* For control transfers, go to the status TD if
+                         * this isn't already the last data TD */
+                        if (qh->type == USB_ENDPOINT_XFER_CONTROL) {
+                                if (td->list.next != urbp->td_list.prev)
+                                        ret = 1;
+                        }
+
+                        /* For bulk and interrupt, this may be an error */
+                        else if (urb->transfer_flags & URB_SHORT_NOT_OK)
                                 ret = -EREMOTEIO;
 
                         /* Fixup needed only if this isn't the URB's last TD */
@@ -1208,10 +1213,6 @@ static int uhci_result_common(struct uhci_hcd *uhci, struct urb *urb)
 
 err:
         if (ret < 0) {
-                /* In case a control transfer gets an error
-                 * during the setup stage */
-                urb->actual_length = max(urb->actual_length, 0);
-
                 /* Note that the queue has stopped and save
                  * the next toggle value */
                 qh->element = UHCI_PTR_TERM;
@@ -1489,9 +1490,25 @@ __acquires(uhci->lock)
 {
         struct urb_priv *urbp = (struct urb_priv *) urb->hcpriv;
 
+        if (qh->type == USB_ENDPOINT_XFER_CONTROL) {
+
+                /* urb->actual_length < 0 means the setup transaction didn't
+                 * complete successfully.  Either it failed or the URB was
+                 * unlinked first.  Regardless, don't confuse people with a
+                 * negative length. */
+                urb->actual_length = max(urb->actual_length, 0);
+
+                /* Report erroneous short transfers */
+                if (unlikely((urb->transfer_flags & URB_SHORT_NOT_OK) &&
+                                urb->actual_length <
+                                        urb->transfer_buffer_length &&
+                                urb->status == 0))
+                        urb->status = -EREMOTEIO;
+        }
+
         /* When giving back the first URB in an Isochronous queue,
          * reinitialize the QH's iso-related members for the next URB. */
-        if (qh->type == USB_ENDPOINT_XFER_ISOC &&
+        else if (qh->type == USB_ENDPOINT_XFER_ISOC &&
                         urbp->node.prev == &qh->queue &&
                         urbp->node.next != &qh->queue) {
                 struct urb *nurb = list_entry(urbp->node.next,
diff --git a/drivers/usb/image/mdc800.c b/drivers/usb/image/mdc800.c
index 36502a06f73a..d1131a87a5b1 100644
--- a/drivers/usb/image/mdc800.c
+++ b/drivers/usb/image/mdc800.c
@@ -284,9 +284,9 @@ static void mdc800_usb_irq (struct urb *urb)
         int data_received=0, wake_up;
         unsigned char* b=urb->transfer_buffer;
         struct mdc800_data* mdc800=urb->context;
+        int status = urb->status;
 
-        if (urb->status >= 0)
-        {
+        if (status >= 0) {
 
                 //dbg ("%i %i %i %i %i %i %i %i \n",b[0],b[1],b[2],b[3],b[4],b[5],b[6],b[7]);
 
@@ -324,7 +324,7 @@ static void mdc800_usb_irq (struct urb *urb)
                 ||
                         ((mdc800->camera_request_ready == 3) && (mdc800->camera_busy))
                 ||
-                        (urb->status < 0)
+                        (status < 0)
                 );
 
         if (wake_up)
@@ -376,15 +376,12 @@ static int mdc800_usb_waitForIRQ (int mode, int msec)
 static void mdc800_usb_write_notify (struct urb *urb)
 {
         struct mdc800_data* mdc800=urb->context;
+        int status = urb->status;
 
-        if (urb->status != 0)
-        {
-                err ("writing command fails (status=%i)", urb->status);
-        }
+        if (status != 0)
+                err ("writing command fails (status=%i)", status);
         else
-        {       
                 mdc800->state=READY;
-        }
         mdc800->written = 1;
         wake_up (&mdc800->write_wait);
 }
@@ -396,9 +393,9 @@ static void mdc800_usb_write_notify (struct urb *urb)
 static void mdc800_usb_download_notify (struct urb *urb)
 {
         struct mdc800_data* mdc800=urb->context;
+        int status = urb->status;
 
-        if (urb->status == 0)
-        {
+        if (status == 0) {
                 /* Fill output buffer with these data */
                 memcpy (mdc800->out,  urb->transfer_buffer, 64);
                 mdc800->out_count=64;
@@ -408,10 +405,8 @@ static void mdc800_usb_download_notify (struct urb *urb)
                 {
                         mdc800->state=READY;
                 }
-        }
-        else
-        {
-                err ("request bytes fails (status:%i)", urb->status);
+        } else {
+                err ("request bytes fails (status:%i)", status);
         }
         mdc800->downloaded = 1;
         wake_up (&mdc800->download_wait);
@@ -649,9 +644,9 @@ static int mdc800_device_open (struct inode* inode, struct file *file)
 
         retval=0;
         mdc800->irq_urb->dev = mdc800->dev;
-        if (usb_submit_urb (mdc800->irq_urb, GFP_KERNEL))
-        {
-                err ("request USB irq fails (submit_retval=%i urb_status=%i).",retval, mdc800->irq_urb->status);
+        retval = usb_submit_urb (mdc800->irq_urb, GFP_KERNEL);
+        if (retval) {
+                err ("request USB irq fails (submit_retval=%i).", retval);
                 errn = -EIO;
                 goto error_out;
         }
@@ -698,6 +693,7 @@ static ssize_t mdc800_device_read (struct file *file, char __user *buf, size_t l
 {
         size_t left=len, sts=len; /* single transfer size */
         char __user *ptr = buf;
+        int retval;
 
         mutex_lock(&mdc800->io_lock);
         if (mdc800->state == NOT_CONNECTED)
@@ -737,9 +733,9 @@ static ssize_t mdc800_device_read (struct file *file, char __user *buf, size_t l
 
                                 /* Download -> Request new bytes */
                                 mdc800->download_urb->dev = mdc800->dev;
-                                if (usb_submit_urb (mdc800->download_urb, GFP_KERNEL))
-                                {
-                                        err ("Can't submit download urb (status=%i)",mdc800->download_urb->status);
+                                retval = usb_submit_urb (mdc800->download_urb, GFP_KERNEL);
+                                if (retval) {
+                                        err ("Can't submit download urb (retval=%i)",retval);
                                         mutex_unlock(&mdc800->io_lock);
                                         return len-left;
                                 }
@@ -788,6 +784,7 @@ static ssize_t mdc800_device_read (struct file *file, char __user *buf, size_t l
 static ssize_t mdc800_device_write (struct file *file, const char __user *buf, size_t len, loff_t *pos)
 {
         size_t i=0;
+        int retval;
 
         mutex_lock(&mdc800->io_lock);
         if (mdc800->state != READY)
@@ -854,9 +851,9 @@ static ssize_t mdc800_device_write (struct file *file, const char __user *buf, s
                         mdc800->state=WORKING;
                         memcpy (mdc800->write_urb->transfer_buffer, mdc800->in,8);
                         mdc800->write_urb->dev = mdc800->dev;
-                        if (usb_submit_urb (mdc800->write_urb, GFP_KERNEL))
-                        {
-                                err ("submitting write urb fails (status=%i)", mdc800->write_urb->status);
+                        retval = usb_submit_urb (mdc800->write_urb, GFP_KERNEL);
+                        if (retval) {
+                                err ("submitting write urb fails (retval=%i)", retval);
                                 mutex_unlock(&mdc800->io_lock);
                                 return -EIO;
                         }
diff --git a/drivers/usb/image/microtek.c b/drivers/usb/image/microtek.c
index 51bd80d2b8cc..768b2c11a231 100644
--- a/drivers/usb/image/microtek.c
+++ b/drivers/usb/image/microtek.c
@@ -189,7 +189,7 @@ static struct usb_driver mts_usb_driver = {
 #define MTS_DEBUG_INT() \
         do { MTS_DEBUG_GOT_HERE(); \
              MTS_DEBUG("transfer = 0x%x context = 0x%x\n",(int)transfer,(int)context ); \
-             MTS_DEBUG("status = 0x%x data-length = 0x%x sent = 0x%x\n",(int)transfer->status,(int)context->data_length, (int)transfer->actual_length ); \
+             MTS_DEBUG("status = 0x%x data-length = 0x%x sent = 0x%x\n",transfer->status,(int)context->data_length, (int)transfer->actual_length ); \
              mts_debug_dump(context->instance);\
            } while(0)
 #else
@@ -393,8 +393,6 @@ void mts_int_submit_urb (struct urb* transfer,
                       context
                 );
 
-        transfer->status = 0;
-
         res = usb_submit_urb( transfer, GFP_ATOMIC );
         if ( unlikely(res) ) {
                 MTS_INT_ERROR( "could not submit URB! Error was %d\n",(int)res );
@@ -444,12 +442,13 @@ static void mts_get_status( struct urb *transfer )
 static void mts_data_done( struct urb* transfer )
 /* Interrupt context! */
 {
+        int status = transfer->status;
         MTS_INT_INIT();
 
         if ( context->data_length != transfer->actual_length ) {
                 context->srb->resid = context->data_length - transfer->actual_length;
-        } else if ( unlikely(transfer->status) ) {
-                context->srb->result = (transfer->status == -ENOENT ? DID_ABORT : DID_ERROR)<<16;
+        } else if ( unlikely(status) ) {
+                context->srb->result = (status == -ENOENT ? DID_ABORT : DID_ERROR)<<16;
         }
 
         mts_get_status(transfer);
@@ -461,10 +460,11 @@ static void mts_data_done( struct urb* transfer )
 static void mts_command_done( struct urb *transfer )
 /* Interrupt context! */
 {
+        int status = transfer->status;
         MTS_INT_INIT();
 
-        if ( unlikely(transfer->status) ) {
-                if (transfer->status == -ENOENT) {
+        if ( unlikely(status) ) {
+                if (status == -ENOENT) {
                         /* We are being killed */
                         MTS_DEBUG_GOT_HERE();
                         context->srb->result = DID_ABORT<<16;
@@ -502,12 +502,13 @@ static void mts_command_done( struct urb *transfer )
 static void mts_do_sg (struct urb* transfer)
 {
         struct scatterlist * sg;
+        int status = transfer->status;
         MTS_INT_INIT();
 
         MTS_DEBUG("Processing fragment %d of %d\n", context->fragment,context->srb->use_sg);
 
-        if (unlikely(transfer->status)) {
-                context->srb->result = (transfer->status == -ENOENT ? DID_ABORT : DID_ERROR)<<16;
+        if (unlikely(status)) {
+                context->srb->result = (status == -ENOENT ? DID_ABORT : DID_ERROR)<<16;
                 mts_transfer_cleanup(transfer);
         }
 
diff --git a/drivers/usb/misc/adutux.c b/drivers/usb/misc/adutux.c
index d72c42e5f22d..e9fdbc8997b3 100644
--- a/drivers/usb/misc/adutux.c
+++ b/drivers/usb/misc/adutux.c
@@ -24,6 +24,7 @@
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/usb.h>
+#include <linux/mutex.h>
 #include <asm/uaccess.h>
 
 #ifdef CONFIG_USB_DEBUG
@@ -80,7 +81,7 @@ MODULE_DEVICE_TABLE(usb, device_table);
 
 /* Structure to hold all of our device specific stuff */
 struct adu_device {
-        struct semaphore        sem; /* locks this structure */
+        struct mutex            mtx; /* locks this structure */
         struct usb_device*      udev; /* save off the usb device pointer */
         struct usb_interface*   interface;
         unsigned char           minor; /* the starting minor number for this device */
@@ -178,17 +179,18 @@ static void adu_delete(struct adu_device *dev)
 static void adu_interrupt_in_callback(struct urb *urb)
 {
         struct adu_device *dev = urb->context;
+        int status = urb->status;
 
-        dbg(4," %s : enter, status %d", __FUNCTION__, urb->status);
+        dbg(4," %s : enter, status %d", __FUNCTION__, status);
         adu_debug_data(5, __FUNCTION__, urb->actual_length,
                        urb->transfer_buffer);
 
         spin_lock(&dev->buflock);
 
-        if (urb->status != 0) {
-                if ((urb->status != -ENOENT) && (urb->status != -ECONNRESET)) {
+        if (status != 0) {
+                if ((status != -ENOENT) && (status != -ECONNRESET)) {
                         dbg(1," %s : nonzero status received: %d",
-                            __FUNCTION__, urb->status);
+                            __FUNCTION__, status);
                 }
                 goto exit;
         }
@@ -216,21 +218,22 @@ exit:
         wake_up_interruptible(&dev->read_wait);
         adu_debug_data(5, __FUNCTION__, urb->actual_length,
                        urb->transfer_buffer);
-        dbg(4," %s : leave, status %d", __FUNCTION__, urb->status);
+        dbg(4," %s : leave, status %d", __FUNCTION__, status);
 }
 
 static void adu_interrupt_out_callback(struct urb *urb)
 {
         struct adu_device *dev = urb->context;
+        int status = urb->status;
 
-        dbg(4," %s : enter, status %d", __FUNCTION__, urb->status);
+        dbg(4," %s : enter, status %d", __FUNCTION__, status);
         adu_debug_data(5,__FUNCTION__, urb->actual_length, urb->transfer_buffer);
 
-        if (urb->status != 0) {
-                if ((urb->status != -ENOENT) &&
-                    (urb->status != -ECONNRESET)) {
+        if (status != 0) {
+                if ((status != -ENOENT) &&
+                    (status != -ECONNRESET)) {
                         dbg(1, " %s :nonzero status received: %d",
-                            __FUNCTION__, urb->status);
+                            __FUNCTION__, status);
                 }
                 goto exit;
         }
@@ -240,7 +243,7 @@ exit:
 
         adu_debug_data(5, __FUNCTION__, urb->actual_length,
                        urb->transfer_buffer);
-        dbg(4," %s : leave, status %d", __FUNCTION__, urb->status);
+        dbg(4," %s : leave, status %d", __FUNCTION__, status);
 }
 
 static int adu_open(struct inode *inode, struct file *file)
@@ -269,8 +272,8 @@ static int adu_open(struct inode *inode, struct file *file)
         }
 
         /* lock this device */
-        if ((retval = down_interruptible(&dev->sem))) {
-                dbg(2, "%s : sem down failed", __FUNCTION__);
+        if ((retval = mutex_lock_interruptible(&dev->mtx))) {
+                dbg(2, "%s : mutex lock failed", __FUNCTION__);
                 goto exit_no_device;
         }
 
@@ -299,7 +302,7 @@ static int adu_open(struct inode *inode, struct file *file)
                 if (retval)
                         --dev->open_count;
         }
-        up(&dev->sem);
+        mutex_unlock(&dev->mtx);
 
 exit_no_device:
         dbg(2,"%s : leave, return value %d ", __FUNCTION__, retval);
@@ -347,7 +350,7 @@ static int adu_release(struct inode *inode, struct file *file)
         }
 
         /* lock our device */
-        down(&dev->sem); /* not interruptible */
+        mutex_lock(&dev->mtx); /* not interruptible */
 
         if (dev->open_count <= 0) {
                 dbg(1," %s : device not opened", __FUNCTION__);
@@ -357,7 +360,7 @@ static int adu_release(struct inode *inode, struct file *file)
 
         if (dev->udev == NULL) {
                 /* the device was unplugged before the file was released */
-                up(&dev->sem);
+                mutex_unlock(&dev->mtx);
                 adu_delete(dev);
                 dev = NULL;
         } else {
@@ -367,7 +370,7 @@ static int adu_release(struct inode *inode, struct file *file)
 
 exit:
         if (dev)
-                up(&dev->sem);
+                mutex_unlock(&dev->mtx);
         dbg(2," %s : leave, return value %d", __FUNCTION__, retval);
         return retval;
 }
@@ -390,7 +393,7 @@ static ssize_t adu_read(struct file *file, __user char *buffer, size_t count,
         dev = file->private_data;
         dbg(2," %s : dev=%p", __FUNCTION__, dev);
         /* lock this object */
-        if (down_interruptible(&dev->sem))
+        if (mutex_lock_interruptible(&dev->mtx))
                 return -ERESTARTSYS;
 
         /* verify that the device wasn't unplugged */
@@ -522,7 +525,7 @@ static ssize_t adu_read(struct file *file, __user char *buffer, size_t count,
 
 exit:
         /* unlock the device */
-        up(&dev->sem);
+        mutex_unlock(&dev->mtx);
 
         dbg(2," %s : leave, return value %d", __FUNCTION__, retval);
         return retval;
@@ -543,7 +546,7 @@ static ssize_t adu_write(struct file *file, const __user char *buffer,
         dev = file->private_data;
 
         /* lock this object */
-        retval = down_interruptible(&dev->sem);
+        retval = mutex_lock_interruptible(&dev->mtx);
         if (retval)
                 goto exit_nolock;
 
@@ -571,9 +574,9 @@ static ssize_t adu_write(struct file *file, const __user char *buffer,
                                 retval = -EINTR;
                                 goto exit;
                         }
-                        up(&dev->sem);
+                        mutex_unlock(&dev->mtx);
                         timeout = interruptible_sleep_on_timeout(&dev->write_wait, timeout);
-                        retval = down_interruptible(&dev->sem);
+                        retval = mutex_lock_interruptible(&dev->mtx);
                         if (retval) {
                                 retval = bytes_written ? bytes_written : retval;
                                 goto exit_nolock;
@@ -638,7 +641,7 @@ static ssize_t adu_write(struct file *file, const __user char *buffer,
 
 exit:
         /* unlock the device */
-        up(&dev->sem);
+        mutex_unlock(&dev->mtx);
 exit_nolock:
 
         dbg(2," %s : leave, return value %d", __FUNCTION__, retval);
@@ -698,7 +701,7 @@ static int adu_probe(struct usb_interface *interface,
                 goto exit;
         }
 
-        init_MUTEX(&dev->sem);
+        mutex_init(&dev->mtx);
         spin_lock_init(&dev->buflock);
         dev->udev = udev;
         init_waitqueue_head(&dev->read_wait);
@@ -835,16 +838,16 @@ static void adu_disconnect(struct usb_interface *interface)
         usb_deregister_dev(interface, &adu_class);
         dev->minor = 0;
 
-        down(&dev->sem); /* not interruptible */
+        mutex_lock(&dev->mtx); /* not interruptible */
 
         /* if the device is not opened, then we clean up right now */
         dbg(2," %s : open count %d", __FUNCTION__, dev->open_count);
         if (!dev->open_count) {
-                up(&dev->sem);
+                mutex_unlock(&dev->mtx);
                 adu_delete(dev);
         } else {
                 dev->udev = NULL;
-                up(&dev->sem);
+                mutex_unlock(&dev->mtx);
         }
 
         dev_info(&interface->dev, "ADU device adutux%d now disconnected",
diff --git a/drivers/usb/misc/appledisplay.c b/drivers/usb/misc/appledisplay.c
index cf70c16f0e3f..b09c83568c1a 100644
--- a/drivers/usb/misc/appledisplay.c
+++ b/drivers/usb/misc/appledisplay.c
@@ -88,9 +88,10 @@ static void appledisplay_complete(struct urb *urb)
 {
         struct appledisplay *pdata = urb->context;
         unsigned long flags;
+        int status = urb->status;
         int retval;
 
-        switch (urb->status) {
+        switch (status) {
         case 0:
                 /* success */
                 break;
@@ -102,12 +103,12 @@ static void appledisplay_complete(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* This urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d",
-                        __FUNCTION__, urb->status);
+                dbg("%s - urb shuttingdown with status: %d",
+                        __FUNCTION__, status);
                 return;
         default:
                 dbg("%s - nonzero urb status received: %d",
-                        __FUNCTION__, urb->status);
+                        __FUNCTION__, status);
                 goto exit;
         }
 
diff --git a/drivers/usb/misc/auerswald.c b/drivers/usb/misc/auerswald.c
index 42d4e6454a77..df7e1ecc810a 100644
--- a/drivers/usb/misc/auerswald.c
+++ b/drivers/usb/misc/auerswald.c
@@ -862,14 +862,16 @@ static void auerswald_ctrlread_wretcomplete (struct urb * urb)
         pauerbuf_t bp = (pauerbuf_t) urb->context;
         pauerswald_t cp;
         int ret;
+        int status = urb->status;
+
         dbg ("auerswald_ctrlread_wretcomplete called");
-        dbg ("complete with status: %d", urb->status);
+        dbg ("complete with status: %d", status);
         cp = ((pauerswald_t)((char *)(bp->list)-(unsigned long)(&((pauerswald_t)0)->bufctl)));
 
         /* check if it is possible to advance */
-        if (!auerswald_status_retry (urb->status) || !cp->usbdev) {
+        if (!auerswald_status_retry(status) || !cp->usbdev) {
                 /* reuse the buffer */
-                err ("control dummy: transmission error %d, can not retry", urb->status);
+                err ("control dummy: transmission error %d, can not retry", status);
                 auerbuf_releasebuf (bp);
                 /* Wake up all processes waiting for a buffer */
                 wake_up (&cp->bufferwait);
@@ -902,21 +904,23 @@ static void auerswald_ctrlread_complete (struct urb * urb)
         pauerswald_t  cp;
         pauerscon_t   scp;
         pauerbuf_t    bp  = (pauerbuf_t) urb->context;
+        int status = urb->status;
         int ret;
+
         dbg ("auerswald_ctrlread_complete called");
 
         cp = ((pauerswald_t)((char *)(bp->list)-(unsigned long)(&((pauerswald_t)0)->bufctl)));
 
         /* check if there is valid data in this urb */
-        if (urb->status) {
-                dbg ("complete with non-zero status: %d", urb->status);
+        if (status) {
+                dbg ("complete with non-zero status: %d", status);
                 /* should we do a retry? */
-                if (!auerswald_status_retry (urb->status)
+                if (!auerswald_status_retry(status)
                  || !cp->usbdev
                  || (cp->version < AUV_RETRY)
                  || (bp->retries >= AU_RETRIES)) {
                         /* reuse the buffer */
-                        err ("control read: transmission error %d, can not retry", urb->status);
+                        err ("control read: transmission error %d, can not retry", status);
                         auerbuf_releasebuf (bp);
                         /* Wake up all processes waiting for a buffer */
                         wake_up (&cp->bufferwait);
@@ -974,12 +978,13 @@ static void auerswald_int_complete (struct urb * urb)
         unsigned  int channelid;
         unsigned  int bytecount;
         int ret;
+        int status = urb->status;
         pauerbuf_t   bp = NULL;
         pauerswald_t cp = (pauerswald_t) urb->context;
 
         dbg ("%s called", __FUNCTION__);
 
-        switch (urb->status) {
+        switch (status) {
         case 0:
                 /* success */
                 break;
@@ -987,10 +992,10 @@ static void auerswald_int_complete (struct urb * urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
+                dbg("%s - urb shutting down with status: %d", __FUNCTION__, status);
                 return;
         default:
-                dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
+                dbg("%s - nonzero urb status received: %d", __FUNCTION__, status);
                 goto exit;
         }
 
diff --git a/drivers/usb/misc/ftdi-elan.c b/drivers/usb/misc/ftdi-elan.c
index e0f122e131d7..538b535e955b 100644
--- a/drivers/usb/misc/ftdi-elan.c
+++ b/drivers/usb/misc/ftdi-elan.c
@@ -44,6 +44,7 @@
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/kref.h>
+#include <linux/mutex.h>
 #include <asm/uaccess.h>
 #include <linux/usb.h>
 #include <linux/workqueue.h>
@@ -64,7 +65,7 @@ static struct workqueue_struct *respond_queue;
 * ftdi_module_lock exists to protect access to global variables
 *
 */
-static struct semaphore ftdi_module_lock;
+static struct mutex ftdi_module_lock;
 static int ftdi_instances = 0;
 static struct list_head ftdi_static_list;
 /*
@@ -199,10 +200,10 @@ static void ftdi_elan_delete(struct kref *kref)
         dev_warn(&ftdi->udev->dev, "FREEING ftdi=%p\n", ftdi);
         usb_put_dev(ftdi->udev);
         ftdi->disconnected += 1;
-        down(&ftdi_module_lock);
+        mutex_lock(&ftdi_module_lock);
         list_del_init(&ftdi->ftdi_list);
         ftdi_instances -= 1;
-        up(&ftdi_module_lock);
+        mutex_unlock(&ftdi_module_lock);
         kfree(ftdi->bulk_in_buffer);
         ftdi->bulk_in_buffer = NULL;
 }
@@ -746,10 +747,12 @@ static ssize_t ftdi_elan_read(struct file *file, char __user *buffer,
 static void ftdi_elan_write_bulk_callback(struct urb *urb)
 {
         struct usb_ftdi *ftdi = (struct usb_ftdi *)urb->context;
-        if (urb->status && !(urb->status == -ENOENT || urb->status ==
-                -ECONNRESET || urb->status == -ESHUTDOWN)) {
+        int status = urb->status;
+
+        if (status && !(status == -ENOENT || status == -ECONNRESET ||
+            status == -ESHUTDOWN)) {
                 dev_err(&ftdi->udev->dev, "urb=%p write bulk status received: %"
-                        "d\n", urb, urb->status);
+                        "d\n", urb, status);
         }
         usb_buffer_free(urb->dev, urb->transfer_buffer_length,
                 urb->transfer_buffer, urb->transfer_dma);
@@ -2780,10 +2783,10 @@ static int ftdi_elan_probe(struct usb_interface *interface,
                 return -ENOMEM;
         }
         memset(ftdi, 0x00, sizeof(struct usb_ftdi));
-        down(&ftdi_module_lock);
+        mutex_lock(&ftdi_module_lock);
         list_add_tail(&ftdi->ftdi_list, &ftdi_static_list);
         ftdi->sequence_num = ++ftdi_instances;
-        up(&ftdi_module_lock);
+        mutex_unlock(&ftdi_module_lock);
         ftdi_elan_init_kref(ftdi);
         init_MUTEX(&ftdi->sw_lock);
         ftdi->udev = usb_get_dev(interface_to_usbdev(interface));
@@ -2909,7 +2912,7 @@ static int __init ftdi_elan_init(void)
         int result;
         printk(KERN_INFO "driver %s built at %s on %s\n", ftdi_elan_driver.name,
                __TIME__, __DATE__);
-        init_MUTEX(&ftdi_module_lock);
+        mutex_init(&ftdi_module_lock);
         INIT_LIST_HEAD(&ftdi_static_list);
         status_queue = create_singlethread_workqueue("ftdi-status-control");
         if (!status_queue)
diff --git a/drivers/usb/misc/iowarrior.c b/drivers/usb/misc/iowarrior.c
index 28548d186712..46d9f27ec173 100644
--- a/drivers/usb/misc/iowarrior.c
+++ b/drivers/usb/misc/iowarrior.c
@@ -158,9 +158,10 @@ static void iowarrior_callback(struct urb *urb)
         int read_idx;
         int aux_idx;
         int offset;
-        int status;
+        int status = urb->status;
+        int retval;
 
-        switch (urb->status) {
+        switch (status) {
         case 0:
                 /* success */
                 break;
@@ -213,10 +214,10 @@ static void iowarrior_callback(struct urb *urb)
         wake_up_interruptible(&dev->read_wait);
 
 exit:
-        status = usb_submit_urb(urb, GFP_ATOMIC);
-        if (status)
+        retval = usb_submit_urb(urb, GFP_ATOMIC);
+        if (retval)
                 dev_err(&dev->interface->dev, "%s - usb_submit_urb failed with result %d",
-                        __FUNCTION__, status);
+                        __FUNCTION__, retval);
 
 }
 
@@ -226,13 +227,15 @@ exit:
 static void iowarrior_write_callback(struct urb *urb)
 {
         struct iowarrior *dev;
+        int status = urb->status;
+
         dev = (struct iowarrior *)urb->context;
         /* sync/async unlink faults aren't errors */
-        if (urb->status &&
-            !(urb->status == -ENOENT ||
-              urb->status == -ECONNRESET || urb->status == -ESHUTDOWN)) {
+        if (status &&
+            !(status == -ENOENT ||
+              status == -ECONNRESET || status == -ESHUTDOWN)) {
                 dbg("%s - nonzero write bulk status received: %d",
-                    __func__, urb->status);
+                    __func__, status);
         }
         /* free up our allocated buffer */
         usb_buffer_free(urb->dev, urb->transfer_buffer_length,
diff --git a/drivers/usb/misc/ldusb.c b/drivers/usb/misc/ldusb.c
index 5e950b90c541..8208496dfc63 100644
--- a/drivers/usb/misc/ldusb.c
+++ b/drivers/usb/misc/ldusb.c
@@ -219,16 +219,17 @@ static void ld_usb_interrupt_in_callback(struct urb *urb)
         struct ld_usb *dev = urb->context;
         size_t *actual_buffer;
         unsigned int next_ring_head;
+        int status = urb->status;
         int retval;
 
-        if (urb->status) {
-                if (urb->status == -ENOENT ||
-                    urb->status == -ECONNRESET ||
-                    urb->status == -ESHUTDOWN) {
+        if (status) {
+                if (status == -ENOENT ||
+                    status == -ECONNRESET ||
+                    status == -ESHUTDOWN) {
                         goto exit;
                 } else {
                         dbg_info(&dev->intf->dev, "%s: nonzero status received: %d\n",
-                                 __FUNCTION__, urb->status);
+                                 __FUNCTION__, status);
                         spin_lock(&dev->rbsl);
                         goto resubmit; /* maybe we can recover */
                 }
@@ -275,14 +276,15 @@ exit:
 static void ld_usb_interrupt_out_callback(struct urb *urb)
 {
         struct ld_usb *dev = urb->context;
+        int status = urb->status;
 
         /* sync/async unlink faults aren't errors */
-        if (urb->status && !(urb->status == -ENOENT ||
-                             urb->status == -ECONNRESET ||
-                             urb->status == -ESHUTDOWN))
+        if (status && !(status == -ENOENT ||
+                        status == -ECONNRESET ||
+                        status == -ESHUTDOWN))
                 dbg_info(&dev->intf->dev,
                          "%s - nonzero write interrupt status received: %d\n",
-                         __FUNCTION__, urb->status);
+                         __FUNCTION__, status);
 
         dev->interrupt_out_busy = 0;
         wake_up_interruptible(&dev->write_wait);
diff --git a/drivers/usb/misc/legousbtower.c b/drivers/usb/misc/legousbtower.c
index 2ed0daea894c..561970b889a5 100644
--- a/drivers/usb/misc/legousbtower.c
+++ b/drivers/usb/misc/legousbtower.c
@@ -742,19 +742,20 @@ exit:
 static void tower_interrupt_in_callback (struct urb *urb)
 {
         struct lego_usb_tower *dev = (struct lego_usb_tower *)urb->context;
+        int status = urb->status;
         int retval;
 
-        dbg(4, "%s: enter, status %d", __FUNCTION__, urb->status);
+        dbg(4, "%s: enter, status %d", __FUNCTION__, status);
 
         lego_usb_tower_debug_data(5, __FUNCTION__, urb->actual_length, urb->transfer_buffer);
 
-        if (urb->status) {
-                if (urb->status == -ENOENT ||
-                    urb->status == -ECONNRESET ||
-                    urb->status == -ESHUTDOWN) {
+        if (status) {
+                if (status == -ENOENT ||
+                    status == -ECONNRESET ||
+                    status == -ESHUTDOWN) {
                         goto exit;
                 } else {
-                        dbg(1, "%s: nonzero status received: %d", __FUNCTION__, urb->status);
+                        dbg(1, "%s: nonzero status received: %d", __FUNCTION__, status);
                         goto resubmit; /* maybe we can recover */
                 }
         }
@@ -788,7 +789,7 @@ exit:
         wake_up_interruptible (&dev->read_wait);
 
         lego_usb_tower_debug_data(5, __FUNCTION__, urb->actual_length, urb->transfer_buffer);
-        dbg(4, "%s: leave, status %d", __FUNCTION__, urb->status);
+        dbg(4, "%s: leave, status %d", __FUNCTION__, status);
 }
 
 
@@ -798,23 +799,24 @@ exit:
 static void tower_interrupt_out_callback (struct urb *urb)
 {
         struct lego_usb_tower *dev = (struct lego_usb_tower *)urb->context;
+        int status = urb->status;
 
-        dbg(4, "%s: enter, status %d", __FUNCTION__, urb->status);
+        dbg(4, "%s: enter, status %d", __FUNCTION__, status);
         lego_usb_tower_debug_data(5, __FUNCTION__, urb->actual_length, urb->transfer_buffer);
 
         /* sync/async unlink faults aren't errors */
-        if (urb->status && !(urb->status == -ENOENT ||
-                             urb->status == -ECONNRESET ||
-                             urb->status == -ESHUTDOWN)) {
+        if (status && !(status == -ENOENT ||
+                        status == -ECONNRESET ||
+                        status == -ESHUTDOWN)) {
                 dbg(1, "%s - nonzero write bulk status received: %d",
-                    __FUNCTION__, urb->status);
+                    __FUNCTION__, status);
         }
 
         dev->interrupt_out_busy = 0;
         wake_up_interruptible(&dev->write_wait);
 
         lego_usb_tower_debug_data(5, __FUNCTION__, urb->actual_length, urb->transfer_buffer);
-        dbg(4, "%s: leave, status %d", __FUNCTION__, urb->status);
+        dbg(4, "%s: leave, status %d", __FUNCTION__, status);
 }
 
 
diff --git a/drivers/usb/misc/phidgetkit.c b/drivers/usb/misc/phidgetkit.c
index 371bf2b1197d..aa9bcceabe74 100644
--- a/drivers/usb/misc/phidgetkit.c
+++ b/drivers/usb/misc/phidgetkit.c
@@ -305,9 +305,10 @@ static void interfacekit_irq(struct urb *urb)
         struct interfacekit *kit = urb->context;
         unsigned char *buffer = kit->data;
         int i, level, sensor;
-        int status;
+        int retval;
+        int status = urb->status;
 
-        switch (urb->status) {
+        switch (status) {
         case 0:                 /* success */
                 break;
         case -ECONNRESET:       /* unlink */
@@ -377,11 +378,11 @@ static void interfacekit_irq(struct urb *urb)
                 schedule_delayed_work(&kit->do_notify, 0);
 
 resubmit:
-        status = usb_submit_urb(urb, GFP_ATOMIC);
-        if (status)
-                err("can't resubmit intr, %s-%s/interfacekit0, status %d",
+        retval = usb_submit_urb(urb, GFP_ATOMIC);
+        if (retval)
+                err("can't resubmit intr, %s-%s/interfacekit0, retval %d",
                         kit->udev->bus->bus_name,
-                        kit->udev->devpath, status);
+                        kit->udev->devpath, retval);
 }
 
 static void do_notify(struct work_struct *work)
diff --git a/drivers/usb/misc/phidgetmotorcontrol.c b/drivers/usb/misc/phidgetmotorcontrol.c
index 5727e1ea2f91..df0ebcdb9d6a 100644
--- a/drivers/usb/misc/phidgetmotorcontrol.c
+++ b/drivers/usb/misc/phidgetmotorcontrol.c
@@ -95,9 +95,10 @@ static void motorcontrol_irq(struct urb *urb)
         struct motorcontrol *mc = urb->context;
         unsigned char *buffer = mc->data;
         int i, level;
-        int status;
+        int retval;
+        int status = urb->status;;
 
-        switch (urb->status) {
+        switch (status) {
         case 0:                 /* success */
                 break;
         case -ECONNRESET:       /* unlink */
@@ -151,12 +152,12 @@ static void motorcontrol_irq(struct urb *urb)
                 schedule_delayed_work(&mc->do_notify, 0);
 
 resubmit:
-        status = usb_submit_urb(urb, GFP_ATOMIC);
-        if (status)
+        retval = usb_submit_urb(urb, GFP_ATOMIC);
+        if (retval)
                 dev_err(&mc->intf->dev,
-                        "can't resubmit intr, %s-%s/motorcontrol0, status %d",
+                        "can't resubmit intr, %s-%s/motorcontrol0, retval %d",
                         mc->udev->bus->bus_name,
-                        mc->udev->devpath, status);
+                        mc->udev->devpath, retval);
 }
 
 static void do_notify(struct work_struct *work)
diff --git a/drivers/usb/misc/usblcd.c b/drivers/usb/misc/usblcd.c
index 504f7221b0d0..719842032712 100644
--- a/drivers/usb/misc/usblcd.c
+++ b/drivers/usb/misc/usblcd.c
@@ -176,16 +176,17 @@ static int lcd_ioctl(struct inode *inode, struct file *file, unsigned int cmd, u
 static void lcd_write_bulk_callback(struct urb *urb)
 {
         struct usb_lcd *dev;
+        int status = urb->status;
 
         dev = (struct usb_lcd *)urb->context;
 
         /* sync/async unlink faults aren't errors */
-        if (urb->status &&
-            !(urb->status == -ENOENT ||
-              urb->status == -ECONNRESET ||
-              urb->status == -ESHUTDOWN)) {
+        if (status &&
+            !(status == -ENOENT ||
+              status == -ECONNRESET ||
+              status == -ESHUTDOWN)) {
                 dbg("USBLCD: %s - nonzero write bulk status received: %d",
-                    __FUNCTION__, urb->status);
+                    __FUNCTION__, status);
         }
 
         /* free up our allocated buffer */
diff --git a/drivers/usb/misc/usbtest.c b/drivers/usb/misc/usbtest.c
index fb321864a92d..e901d31e051b 100644
--- a/drivers/usb/misc/usbtest.c
+++ b/drivers/usb/misc/usbtest.c
@@ -768,8 +768,8 @@ static void ctrl_complete (struct urb *urb)
 
                 /* some faults are allowed, not required */
                 if (subcase->expected > 0 && (
-                          ((urb->status == -subcase->expected   /* happened */
-                           || urb->status == 0))))              /* didn't */
+                          ((status == -subcase->expected        /* happened */
+                           || status == 0))))                   /* didn't */
                         status = 0;
                 /* sometimes more than one fault is allowed */
                 else if (subcase->number == 12 && status == -EPIPE)
diff --git a/drivers/usb/misc/uss720.c b/drivers/usb/misc/uss720.c
index 1a60f9c473ad..2734fe2b9c43 100644
--- a/drivers/usb/misc/uss720.c
+++ b/drivers/usb/misc/uss720.c
@@ -111,12 +111,13 @@ static void async_complete(struct urb *urb)
         struct uss720_async_request *rq;
         struct parport *pp;
         struct parport_uss720_private *priv;
+        int status = urb->status;
 
         rq = urb->context;
         priv = rq->priv;
         pp = priv->pp;
-        if (urb->status) {
-                err("async_complete: urb error %d", urb->status);
+        if (status) {
+                err("async_complete: urb error %d", status);
         } else if (rq->dr.bRequest == 3) {
                 memcpy(priv->reg, rq->reg, sizeof(priv->reg));
 #if 0
diff --git a/drivers/usb/mon/mon_text.c b/drivers/usb/mon/mon_text.c
index 982b773d71e6..8f27a9e1c36b 100644
--- a/drivers/usb/mon/mon_text.c
+++ b/drivers/usb/mon/mon_text.c
@@ -340,7 +340,7 @@ static int mon_text_open(struct inode *inode, struct file *file)
         snprintf(rp->slab_name, SLAB_NAME_SZ, "mon_text_%p", rp);
         rp->e_slab = kmem_cache_create(rp->slab_name,
             sizeof(struct mon_event_text), sizeof(long), 0,
-            mon_text_ctor, NULL);
+            mon_text_ctor);
         if (rp->e_slab == NULL) {
                 rc = -ENOMEM;
                 goto err_slab;
diff --git a/drivers/usb/serial/io_ti.c b/drivers/usb/serial/io_ti.c
index 0d3903691e8c..b8670905bc3a 100644
--- a/drivers/usb/serial/io_ti.c
+++ b/drivers/usb/serial/io_ti.c
@@ -2794,16 +2794,14 @@ static void edge_shutdown (struct usb_serial *serial)
 
         dbg ("%s", __FUNCTION__);
 
-        for (i=0; i < serial->num_ports; ++i) {
+        for (i = 0; i < serial->num_ports; ++i) {
                 edge_port = usb_get_serial_port_data(serial->port[i]);
                 edge_remove_sysfs_attrs(edge_port->port);
-                if (edge_port) {
-                        edge_buf_free(edge_port->ep_out_buf);
-                        kfree(edge_port);
-                }
+                edge_buf_free(edge_port->ep_out_buf);
+                kfree(edge_port);
                 usb_set_serial_port_data(serial->port[i], NULL);
         }
-        kfree (usb_get_serial_data(serial));
+        kfree(usb_get_serial_data(serial));
         usb_set_serial_data(serial, NULL);
 }
 
diff --git a/drivers/usb/serial/mos7720.c b/drivers/usb/serial/mos7720.c
index 231b584f6d0f..01e811becec4 100644
--- a/drivers/usb/serial/mos7720.c
+++ b/drivers/usb/serial/mos7720.c
@@ -110,11 +110,6 @@ static void mos7720_interrupt_callback(struct urb *urb)
 
         dbg("%s"," : Entering\n");
 
-        if (!urb) {
-                dbg("%s","Invalid Pointer !!!!:\n");
-                return;
-        }
-
         switch (status) {
         case 0:
                 /* success */
diff --git a/drivers/usb/serial/mos7840.c b/drivers/usb/serial/mos7840.c
index 37f41f576d3d..f76480f1455d 100644
--- a/drivers/usb/serial/mos7840.c
+++ b/drivers/usb/serial/mos7840.c
@@ -436,11 +436,6 @@ static void mos7840_control_callback(struct urb *urb)
         int result = 0;
         int status = urb->status;
 
-        if (!urb) {
-                dbg("%s", "Invalid Pointer !!!!:\n");
-                return;
-        }
-
         mos7840_port = (struct moschip_port *)urb->context;
 
         switch (status) {
@@ -525,10 +520,6 @@ static void mos7840_interrupt_callback(struct urb *urb)
         int status = urb->status;
 
         dbg("%s", " : Entering\n");
-        if (!urb) {
-                dbg("%s", "Invalid Pointer !!!!:\n");
-                return;
-        }
 
         switch (status) {
         case 0:
@@ -676,11 +667,6 @@ static void mos7840_bulk_in_callback(struct urb *urb)
         struct tty_struct *tty;
         int status = urb->status;
 
-        if (!urb) {
-                dbg("%s", "Invalid Pointer !!!!:\n");
-                return;
-        }
-
         if (status) {
                 dbg("nonzero read bulk status received: %d", status);
                 return;
@@ -753,11 +739,6 @@ static void mos7840_bulk_out_data_callback(struct urb *urb)
         int status = urb->status;
         int i;
 
-        if (!urb) {
-                dbg("%s", "Invalid Pointer !!!!:\n");
-                return;
-        }
-
         mos7840_port = (struct moschip_port *)urb->context;
         spin_lock(&mos7840_port->pool_lock);
         for (i = 0; i < NUM_URBS; i++) {
diff --git a/drivers/usb/serial/sierra.c b/drivers/usb/serial/sierra.c
index e7db20343d1a..0794ccdebfd4 100644
--- a/drivers/usb/serial/sierra.c
+++ b/drivers/usb/serial/sierra.c
@@ -1,7 +1,7 @@
 /*
   USB Driver for Sierra Wireless
 
-  Copyright (C) 2006  Kevin Lloyd <linux@sierrawireless.com>
+  Copyright (C) 2006, 2007  Kevin Lloyd <linux@sierrawireless.com>
 
   IMPORTANT DISCLAIMER: This driver is not commercially supported by
   Sierra Wireless. Use at your own risk.
@@ -12,10 +12,9 @@
 
   Portions based on the option driver by Matthias Urlichs <smurf@smurf.noris.de>
   Whom based his on the Keyspan driver by Hugh Blemings <hugh@blemings.org>
-
 */
 
-#define DRIVER_VERSION "v.1.0.6"
+#define DRIVER_VERSION "v.1.2.5b"
 #define DRIVER_AUTHOR "Kevin Lloyd <linux@sierrawireless.com>"
 #define DRIVER_DESC "USB Driver for Sierra Wireless USB modems"
 
@@ -28,23 +27,98 @@
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 
+#define SWIMS_USB_REQUEST_SetMode       0x0B
+#define SWIMS_USB_REQUEST_TYPE_SetMode  0x40
+#define SWIMS_USB_INDEX_SetMode         0x0000
+#define SWIMS_SET_MODE_Modem            0x0001
+
+/* per port private data */
+#define N_IN_URB        4
+#define N_OUT_URB       4
+#define IN_BUFLEN       4096
+
+static int debug;
+
+enum devicetype {
+        DEVICE_3_PORT =         0,
+        DEVICE_1_PORT =         1,
+        DEVICE_INSTALLER =      2,
+};
+
+int sierra_set_power_state(struct usb_device *udev, __u16 swiState)
+{
+        int result;
+        dev_dbg(&udev->dev, "%s", "SET POWER STATE");
+        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                        0x00,                   /* __u8 request      */
+                        0x40,                   /* __u8 request type */
+                        swiState,               /* __u16 value       */
+                        0,                      /* __u16 index       */
+                        NULL,                   /* void *data        */
+                        0,                      /* __u16 size        */
+                        USB_CTRL_SET_TIMEOUT);  /* int timeout       */
+        return result;
+}
+
+int sierra_set_ms_mode(struct usb_device *udev, __u16 eSocMode)
+{
+        int result;
+        dev_dbg(&udev->dev, "%s", "DEVICE MODE SWITCH");
+        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                        SWIMS_USB_REQUEST_SetMode,      /* __u8 request      */
+                        SWIMS_USB_REQUEST_TYPE_SetMode, /* __u8 request type */
+                        eSocMode,                       /* __u16 value       */
+                        SWIMS_USB_INDEX_SetMode,        /* __u16 index       */
+                        NULL,                           /* void *data        */
+                        0,                              /* __u16 size        */
+                        USB_CTRL_SET_TIMEOUT);          /* int timeout       */
+        return result;
+}
+
+int sierra_probe(struct usb_interface *iface, const struct usb_device_id *id)
+{
+        int result;
+        struct usb_device *udev;
+
+        udev = usb_get_dev(interface_to_usbdev(iface));
+
+        /* Check if in installer mode */
+        if (id->driver_info == DEVICE_INSTALLER) {
+                dev_dbg(&udev->dev, "%s", "FOUND DEVICE(SW)\n");
+                result = sierra_set_ms_mode(udev, SWIMS_SET_MODE_Modem);
+                /*We do not want to bind to the device when in installer mode*/
+                return -EIO;
+        }
+
+        return usb_serial_probe(iface, id);
+}
 
 static struct usb_device_id id_table [] = {
         { USB_DEVICE(0x1199, 0x0017) }, /* Sierra Wireless EM5625 */
         { USB_DEVICE(0x1199, 0x0018) }, /* Sierra Wireless MC5720 */
         { USB_DEVICE(0x1199, 0x0218) }, /* Sierra Wireless MC5720 */
+        { USB_DEVICE(0x0f30, 0x1b1d) }, /* Sierra Wireless MC5720 */
         { USB_DEVICE(0x1199, 0x0020) }, /* Sierra Wireless MC5725 */
         { USB_DEVICE(0x1199, 0x0019) }, /* Sierra Wireless AirCard 595 */
-        { USB_DEVICE(0x1199, 0x0120) }, /* Sierra Wireless AirCard 595U */
         { USB_DEVICE(0x1199, 0x0021) }, /* Sierra Wireless AirCard 597E */
+        { USB_DEVICE(0x1199, 0x0120) }, /* Sierra Wireless USB Dongle 595U */
+
         { USB_DEVICE(0x1199, 0x6802) }, /* Sierra Wireless MC8755 */
         { USB_DEVICE(0x1199, 0x6804) }, /* Sierra Wireless MC8755 */
         { USB_DEVICE(0x1199, 0x6803) }, /* Sierra Wireless MC8765 */
-        { USB_DEVICE(0x1199, 0x6812) }, /* Sierra Wireless MC8775 */
+        { USB_DEVICE(0x1199, 0x6812) }, /* Sierra Wireless MC8775 & AC 875U */
         { USB_DEVICE(0x1199, 0x6820) }, /* Sierra Wireless AirCard 875 */
+        { USB_DEVICE(0x1199, 0x6832) }, /* Sierra Wireless MC8780*/
+        { USB_DEVICE(0x1199, 0x6833) }, /* Sierra Wireless MC8781*/
+        { USB_DEVICE(0x1199, 0x6850) }, /* Sierra Wireless AirCard 880 */
+        { USB_DEVICE(0x1199, 0x6851) }, /* Sierra Wireless AirCard 881 */
+        { USB_DEVICE(0x1199, 0x6852) }, /* Sierra Wireless AirCard 880 E */
+        { USB_DEVICE(0x1199, 0x6853) }, /* Sierra Wireless AirCard 881 E */
 
-        { USB_DEVICE(0x1199, 0x0112) }, /* Sierra Wireless AirCard 580 */
-        { USB_DEVICE(0x0F3D, 0x0112) }, /* AirPrime/Sierra PC 5220 */
+        { USB_DEVICE(0x1199, 0x0112), .driver_info = DEVICE_1_PORT }, /* Sierra Wireless AirCard 580 */
+        { USB_DEVICE(0x0F3D, 0x0112), .driver_info = DEVICE_1_PORT }, /* Airprime/Sierra PC 5220 */
+
+        { USB_DEVICE(0x1199, 0x0FFF), .driver_info = DEVICE_INSTALLER},
         { }
 };
 MODULE_DEVICE_TABLE(usb, id_table);
@@ -58,35 +132,36 @@ static struct usb_device_id id_table_1port [] = {
 static struct usb_device_id id_table_3port [] = {
         { USB_DEVICE(0x1199, 0x0017) }, /* Sierra Wireless EM5625 */
         { USB_DEVICE(0x1199, 0x0018) }, /* Sierra Wireless MC5720 */
+        { USB_DEVICE(0x0f30, 0x1b1d) }, /* Sierra Wireless MC5720 */
         { USB_DEVICE(0x1199, 0x0218) }, /* Sierra Wireless MC5720 */
         { USB_DEVICE(0x1199, 0x0020) }, /* Sierra Wireless MC5725 */
         { USB_DEVICE(0x1199, 0x0019) }, /* Sierra Wireless AirCard 595 */
-        { USB_DEVICE(0x1199, 0x0120) }, /* Sierra Wireless AirCard 595U */
         { USB_DEVICE(0x1199, 0x0021) }, /* Sierra Wireless AirCard 597E */
+        { USB_DEVICE(0x1199, 0x0120) }, /* Sierra Wireless USB Dongle 595U*/
+
         { USB_DEVICE(0x1199, 0x6802) }, /* Sierra Wireless MC8755 */
         { USB_DEVICE(0x1199, 0x6804) }, /* Sierra Wireless MC8755 */
         { USB_DEVICE(0x1199, 0x6803) }, /* Sierra Wireless MC8765 */
-        { USB_DEVICE(0x1199, 0x6812) }, /* Sierra Wireless MC8775 */
+        { USB_DEVICE(0x1199, 0x6812) }, /* Sierra Wireless MC8775 & AC 875U */
         { USB_DEVICE(0x1199, 0x6820) }, /* Sierra Wireless AirCard 875 */
+        { USB_DEVICE(0x1199, 0x6832) }, /* Sierra Wireless MC8780*/
+        { USB_DEVICE(0x1199, 0x6833) }, /* Sierra Wireless MC8781*/
+        { USB_DEVICE(0x1199, 0x6850) }, /* Sierra Wireless AirCard 880 */
+        { USB_DEVICE(0x1199, 0x6851) }, /* Sierra Wireless AirCard 881 */
+        { USB_DEVICE(0x1199, 0x6852) }, /* Sierra Wireless AirCard 880E */
+        { USB_DEVICE(0x1199, 0x6853) }, /* Sierra Wireless AirCard 881E */
         { }
 };
 
 static struct usb_driver sierra_driver = {
         .name       = "sierra",
-        .probe      = usb_serial_probe,
+        .probe      = sierra_probe,
         .disconnect = usb_serial_disconnect,
         .id_table   = id_table,
         .no_dynamic_id =        1,
 };
 
 
-static int debug;
-
-/* per port private data */
-#define N_IN_URB        4
-#define N_OUT_URB       4
-#define IN_BUFLEN       4096
-
 struct sierra_port_private {
         spinlock_t lock;        /* lock the structure */
         int outstanding_urbs;   /* number of out urbs in flight */
@@ -421,7 +496,6 @@ static int sierra_open(struct usb_serial_port *port, struct file *filp)
         int i;
         struct urb *urb;
         int result;
-        __u16 set_mode_dzero = 0x0000;
 
         portdata = usb_get_serial_port_data(port);
 
@@ -457,12 +531,6 @@ static int sierra_open(struct usb_serial_port *port, struct file *filp)
 
         port->tty->low_latency = 1;
 
-        /* set mode to D0 */
-        result = usb_control_msg(serial->dev,
-                                 usb_rcvctrlpipe(serial->dev, 0),
-                                 0x00, 0x40, set_mode_dzero, 0, NULL,
-                                 0, USB_CTRL_SET_TIMEOUT);
-
         sierra_send_setup(port);
 
         /* start up the interrupt endpoint if we have one */
@@ -510,6 +578,9 @@ static int sierra_startup(struct usb_serial *serial)
 
         dbg("%s", __FUNCTION__);
 
+        /*Set Device mode to D0 */
+        sierra_set_power_state(serial->dev, 0x0000);
+
         /* Now setup per port private data */
         for (i = 0; i < serial->num_ports; i++) {
                 port = serial->port[i];
diff --git a/drivers/usb/storage/dpcm.c b/drivers/usb/storage/dpcm.c
index 1628cb258562..9a410b5a6e5b 100644
--- a/drivers/usb/storage/dpcm.c
+++ b/drivers/usb/storage/dpcm.c
@@ -46,43 +46,43 @@
  */
 int dpcm_transport(struct scsi_cmnd *srb, struct us_data *us)
 {
-  int ret;
+        int ret;
 
-  if(srb == NULL)
-    return USB_STOR_TRANSPORT_ERROR;
+        if (srb == NULL)
+                return USB_STOR_TRANSPORT_ERROR;
 
-  US_DEBUGP("dpcm_transport: LUN=%d\n", srb->device->lun);
+        US_DEBUGP("dpcm_transport: LUN=%d\n", srb->device->lun);
 
-  switch(srb->device->lun) {
-  case 0:
+        switch (srb->device->lun) {
+                case 0:
 
-    /*
-     * LUN 0 corresponds to the CompactFlash card reader.
-     */
-    ret = usb_stor_CB_transport(srb, us);
-    break;
+                        /*
+                         * LUN 0 corresponds to the CompactFlash card reader.
+                         */
+                        ret = usb_stor_CB_transport(srb, us);
+                        break;
 
 #ifdef CONFIG_USB_STORAGE_SDDR09
-  case 1:
+                case 1:
 
-    /*
-     * LUN 1 corresponds to the SmartMedia card reader.
-     */
+                        /*
+                         * LUN 1 corresponds to the SmartMedia card reader.
+                         */
 
-    /*
-     * Set the LUN to 0 (just in case).
-     */
-    srb->device->lun = 0; us->srb->device->lun = 0;
-    ret = sddr09_transport(srb, us);
-    srb->device->lun = 1; us->srb->device->lun = 1;
-    break;
+                        /*
+                         * Set the LUN to 0 (just in case).
+                         */
+                        srb->device->lun = 0; us->srb->device->lun = 0;
+                        ret = sddr09_transport(srb, us);
+                        srb->device->lun = 1; us->srb->device->lun = 1;
+                        break;
 
 #endif
 
-  default:
-    US_DEBUGP("dpcm_transport: Invalid LUN %d\n", srb->device->lun);
-    ret = USB_STOR_TRANSPORT_ERROR;
-    break;
-  }
-  return ret;
+                default:
+                        US_DEBUGP("dpcm_transport: Invalid LUN %d\n", srb->device->lun);
+                        ret = USB_STOR_TRANSPORT_ERROR;
+                        break;
+        }
+        return ret;
 }
diff --git a/drivers/usb/storage/onetouch.c b/drivers/usb/storage/onetouch.c
index d35369392fed..dfd42fe9e5f0 100644
--- a/drivers/usb/storage/onetouch.c
+++ b/drivers/usb/storage/onetouch.c
@@ -57,9 +57,10 @@ static void usb_onetouch_irq(struct urb *urb)
         struct usb_onetouch *onetouch = urb->context;
         signed char *data = onetouch->data;
         struct input_dev *dev = onetouch->dev;
-        int status;
+        int status = urb->status;
+        int retval;
 
-        switch (urb->status) {
+        switch (status) {
         case 0:                 /* success */
                 break;
         case -ECONNRESET:       /* unlink */
@@ -75,11 +76,11 @@ static void usb_onetouch_irq(struct urb *urb)
         input_sync(dev);
 
 resubmit:
-        status = usb_submit_urb (urb, GFP_ATOMIC);
-        if (status)
-                err ("can't resubmit intr, %s-%s/input0, status %d",
+        retval = usb_submit_urb (urb, GFP_ATOMIC);
+        if (retval)
+                err ("can't resubmit intr, %s-%s/input0, retval %d",
                         onetouch->udev->bus->bus_name,
-                        onetouch->udev->devpath, status);
+                        onetouch->udev->devpath, retval);
 }
 
 static int usb_onetouch_open(struct input_dev *dev)
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index b6bf31a97b60..a624e72f81dc 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -313,6 +313,13 @@ UNUSUAL_DEV(  0x04b0, 0x0301, 0x0010, 0x0010,
                 US_SC_DEVICE, US_PR_DEVICE,NULL,
                 US_FL_NOT_LOCKABLE ),
 
+/* Reported by Stefan de Konink <skinkie@xs4all.nl> */
+UNUSUAL_DEV(  0x04b0, 0x0401, 0x0200, 0x0200,
+                "NIKON",
+                "NIKON DSC D100",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_FIX_CAPACITY),
+
 /* Reported by Andreas Bockhold <andreas@bockionline.de> */
 UNUSUAL_DEV(  0x04b0, 0x0405, 0x0100, 0x0100,
                 "NIKON",
@@ -1384,6 +1391,17 @@ UNUSUAL_DEV(  0x1019, 0x0c55, 0x0000, 0x0110,
                 US_SC_DEVICE, US_PR_DEVICE, usb_stor_ucr61s2b_init,
                 0 ),
 
+/* Reported by Kevin Lloyd <linux@sierrawireless.com>
+ * Entry is needed for the initializer function override,
+ * which instructs the device to load as a modem
+ * device.
+ */
+UNUSUAL_DEV(  0x1199, 0x0fff, 0x0000, 0x9999,
+                "Sierra Wireless",
+                "USB MMC Storage",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_IGNORE_DEVICE),
+
 /* Reported by Jaco Kroon <jaco@kroon.co.za>
  * The usb-storage module found on the Digitech GNX4 (and supposedly other
  * devices) misbehaves and causes a bunch of invalid I/O errors.
diff --git a/drivers/video/backlight/cr_bllcd.c b/drivers/video/backlight/cr_bllcd.c
index e9bbc3455c94..1b3f6586bc9f 100644
--- a/drivers/video/backlight/cr_bllcd.c
+++ b/drivers/video/backlight/cr_bllcd.c
@@ -174,7 +174,7 @@ static int cr_backlight_probe(struct platform_device *pdev)
         struct cr_panel *crp;
         u8 dev_en;
 
-        crp = kzalloc(sizeof(crp), GFP_KERNEL);
+        crp = kzalloc(sizeof(*crp), GFP_KERNEL);
         if (crp == NULL)
                 return -ENOMEM;
 
diff --git a/drivers/video/logo/logo.c b/drivers/video/logo/logo.c
index 80c03618eb53..2b0f799aa8da 100644
--- a/drivers/video/logo/logo.c
+++ b/drivers/video/logo/logo.c
@@ -34,8 +34,11 @@ extern const struct linux_logo logo_superh_vga16;
 extern const struct linux_logo logo_superh_clut224;
 extern const struct linux_logo logo_m32r_clut224;
 
-
-const struct linux_logo *fb_find_logo(int depth)
+/* logo's are marked __initdata. Use __init_refok to tell
+ * modpost that it is intended that this function uses data
+ * marked __initdata.
+ */
+const struct linux_logo * __init_refok fb_find_logo(int depth)
 {
         const struct linux_logo *logo = NULL;