187 files changed, 7851 insertions, 2193 deletions
diff --git a/drivers/Kconfig b/drivers/Kconfig
index a442c8f29fc1..48bbdbe43e69 100644
--- a/drivers/Kconfig
+++ b/drivers/Kconfig
@@ -52,6 +52,8 @@ source "drivers/i2c/Kconfig"
 source "drivers/spi/Kconfig"
+source "drivers/pps/Kconfig"
 source "drivers/gpio/Kconfig"
 source "drivers/w1/Kconfig"
diff --git a/drivers/Makefile b/drivers/Makefile
index 00b44f4ccf03..bc4205d2fc3c 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -72,6 +72,7 @@ obj-$(CONFIG_INPUT)		+= input/
 obj-$(CONFIG_I2O)               += message/
 obj-$(CONFIG_RTC_LIB)           += rtc/
 obj-y                           += i2c/ media/
+obj-$(CONFIG_PPS)               += pps/
 obj-$(CONFIG_W1)                += w1/
 obj-$(CONFIG_POWER_SUPPLY)      += power/
 obj-$(CONFIG_HWMON)             += hwmon/
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 30bae6de6a0d..0bd01f49cfd8 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -807,7 +807,7 @@ if RTC_LIB=n
 config RTC
        tristate "Enhanced Real Time Clock Support (legacy PC RTC driver)"
        depends on !PPC && !PARISC && !IA64 && !M68K && !SPARC && !FRV \
-                        && !ARM && !SUPERH && !S390 && !AVR32
+                        && !ARM && !SUPERH && !S390 && !AVR32 && !BLACKFIN
        ---help---
          If you say Y here and create a character special file /dev/rtc with
          major number 10 and minor number 135 using mknod ("man mknod"), you
diff --git a/drivers/char/agp/hp-agp.c b/drivers/char/agp/hp-agp.c
index 183ac3fe44fb..9c7e2343c399 100644
--- a/drivers/char/agp/hp-agp.c
+++ b/drivers/char/agp/hp-agp.c
@@ -518,8 +518,9 @@ zx1_gart_probe (acpi_handle obj, u32 depth, void *context, void **ret)
        if (hp_zx1_setup(sba_hpa + HP_ZX1_IOC_OFFSET, lba_hpa))
                return AE_OK;
-        printk(KERN_INFO PFX "Detected HP ZX1 %s AGP chipset (ioc=%lx, lba=%lx)\n",
+        printk(KERN_INFO PFX "Detected HP ZX1 %s AGP chipset "
-                (char *) context, sba_hpa + HP_ZX1_IOC_OFFSET, lba_hpa);
+                "(ioc=%llx, lba=%llx)\n", (char *)context,
+                sba_hpa + HP_ZX1_IOC_OFFSET, lba_hpa);
        hp_zx1_gart_found = 1;
        return AE_CTRL_TERMINATE; /* we only support one bridge; quit looking */
diff --git a/drivers/char/dtlk.c b/drivers/char/dtlk.c
index 6b900b297cc6..52e06589821d 100644
--- a/drivers/char/dtlk.c
+++ b/drivers/char/dtlk.c
@@ -571,7 +571,7 @@ static char dtlk_read_tts(void)
                portval = inb_p(dtlk_port_tts);
        } while ((portval & TTS_READABLE) == 0 &&
                 retries++ < DTLK_MAX_RETRIES);
-        if (retries == DTLK_MAX_RETRIES)
+        if (retries > DTLK_MAX_RETRIES)
                printk(KERN_ERR "dtlk_read_tts() timeout\n");
        ch = inb_p(dtlk_port_tts);      /* input from TTS port */
@@ -583,7 +583,7 @@ static char dtlk_read_tts(void)
                portval = inb_p(dtlk_port_tts);
        } while ((portval & TTS_READABLE) != 0 &&
                 retries++ < DTLK_MAX_RETRIES);
-        if (retries == DTLK_MAX_RETRIES)
+        if (retries > DTLK_MAX_RETRIES)
                printk(KERN_ERR "dtlk_read_tts() timeout\n");
        TRACE_RET;
@@ -640,7 +640,7 @@ static char dtlk_write_tts(char ch)
                while ((inb_p(dtlk_port_tts) & TTS_WRITABLE) == 0 &&
                       retries++ < DTLK_MAX_RETRIES)    /* DT ready? */
                        ;
-        if (retries == DTLK_MAX_RETRIES)
+        if (retries > DTLK_MAX_RETRIES)
                printk(KERN_ERR "dtlk_write_tts() timeout\n");
        outb_p(ch, dtlk_port_tts);      /* output to TTS port */
diff --git a/drivers/char/isicom.c b/drivers/char/isicom.c
index 4d745a89504f..4159292e35cf 100644
--- a/drivers/char/isicom.c
+++ b/drivers/char/isicom.c
@@ -1593,7 +1593,7 @@ static unsigned int card_count;
 static int __devinit isicom_probe(struct pci_dev *pdev,
        const struct pci_device_id *ent)
 {
-        unsigned int signature, index;
+        unsigned int uninitialized_var(signature), index;
        int retval = -EPERM;
        struct isi_board *board = NULL;
diff --git a/drivers/char/istallion.c b/drivers/char/istallion.c
index e18800c400b1..0c999f5bb3db 100644
--- a/drivers/char/istallion.c
+++ b/drivers/char/istallion.c
@@ -3785,7 +3785,7 @@ err:
        return retval;
 }
-static void stli_pciremove(struct pci_dev *pdev)
+static void __devexit stli_pciremove(struct pci_dev *pdev)
 {
        struct stlibrd *brdp = pci_get_drvdata(pdev);
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index f96d0bef855e..afa8813e737a 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -863,59 +863,58 @@ static const struct file_operations kmsg_fops = {
        .write =        kmsg_write,
 };
-static int memory_open(struct inode * inode, struct file * filp)
+static const struct {
-{
+        unsigned int            minor;
-        int ret = 0;
+        char                    *name;
+        umode_t                 mode;
-        lock_kernel();
+        const struct file_operations    *fops;
-        switch (iminor(inode)) {
+        struct backing_dev_info *dev_info;
-                case 1:
+} devlist[] = { /* list of minor devices */
-                        filp->f_op = &mem_fops;
+        {1, "mem",     S_IRUSR | S_IWUSR | S_IRGRP, &mem_fops,
-                        filp->f_mapping->backing_dev_info =
+                &directly_mappable_cdev_bdi},
-                                &directly_mappable_cdev_bdi;
-                        break;
 #ifdef CONFIG_DEVKMEM
-                case 2:
+        {2, "kmem",    S_IRUSR | S_IWUSR | S_IRGRP, &kmem_fops,
-                        filp->f_op = &kmem_fops;
+                &directly_mappable_cdev_bdi},
-                        filp->f_mapping->backing_dev_info =
-                                &directly_mappable_cdev_bdi;
-                        break;
 #endif
-                case 3:
+        {3, "null",    S_IRUGO | S_IWUGO,           &null_fops, NULL},
-                        filp->f_op = &null_fops;
-                        break;
 #ifdef CONFIG_DEVPORT
-                case 4:
+        {4, "port",    S_IRUSR | S_IWUSR | S_IRGRP, &port_fops, NULL},
-                        filp->f_op = &port_fops;
-                        break;
 #endif
-                case 5:
+        {5, "zero",    S_IRUGO | S_IWUGO,           &zero_fops, &zero_bdi},
-                        filp->f_mapping->backing_dev_info = &zero_bdi;
+        {7, "full",    S_IRUGO | S_IWUGO,           &full_fops, NULL},
-                        filp->f_op = &zero_fops;
+        {8, "random",  S_IRUGO | S_IWUSR,           &random_fops, NULL},
-                        break;
+        {9, "urandom", S_IRUGO | S_IWUSR,           &urandom_fops, NULL},
-                case 7:
+        {11,"kmsg",    S_IRUGO | S_IWUSR,           &kmsg_fops, NULL},
-                        filp->f_op = &full_fops;
-                        break;
-                case 8:
-                        filp->f_op = &random_fops;
-                        break;
-                case 9:
-                        filp->f_op = &urandom_fops;
-                        break;
-                case 11:
-                        filp->f_op = &kmsg_fops;
-                        break;
 #ifdef CONFIG_CRASH_DUMP
-                case 12:
+        {12,"oldmem",    S_IRUSR | S_IWUSR | S_IRGRP, &oldmem_fops, NULL},
-                        filp->f_op = &oldmem_fops;
-                        break;
 #endif
-                default:
+};
-                        unlock_kernel();
-                        return -ENXIO;
+static int memory_open(struct inode *inode, struct file *filp)
+{
+        int ret = 0;
+        int i;
+        lock_kernel();
+        for (i = 0; i < ARRAY_SIZE(devlist); i++) {
+                if (devlist[i].minor == iminor(inode)) {
+                        filp->f_op = devlist[i].fops;
+                        if (devlist[i].dev_info) {
+                                filp->f_mapping->backing_dev_info =
+                                        devlist[i].dev_info;
+                        }
+                        break;
+                }
        }
-        if (filp->f_op && filp->f_op->open)
-                ret = filp->f_op->open(inode,filp);
+        if (i == ARRAY_SIZE(devlist))
+                ret = -ENXIO;
+        else
+                if (filp->f_op && filp->f_op->open)
+                        ret = filp->f_op->open(inode, filp);
        unlock_kernel();
        return ret;
 }
@@ -924,30 +923,6 @@ static const struct file_operations memory_fops = {
        .open           = memory_open,  /* just a selector for the real open */
 };
-static const struct {
-        unsigned int            minor;
-        char                    *name;
-        umode_t                 mode;
-        const struct file_operations    *fops;
-} devlist[] = { /* list of minor devices */
-        {1, "mem",     S_IRUSR | S_IWUSR | S_IRGRP, &mem_fops},
-#ifdef CONFIG_DEVKMEM
-        {2, "kmem",    S_IRUSR | S_IWUSR | S_IRGRP, &kmem_fops},
-#endif
-        {3, "null",    S_IRUGO | S_IWUGO,           &null_fops},
-#ifdef CONFIG_DEVPORT
-        {4, "port",    S_IRUSR | S_IWUSR | S_IRGRP, &port_fops},
-#endif
-        {5, "zero",    S_IRUGO | S_IWUGO,           &zero_fops},
-        {7, "full",    S_IRUGO | S_IWUGO,           &full_fops},
-        {8, "random",  S_IRUGO | S_IWUSR,           &random_fops},
-        {9, "urandom", S_IRUGO | S_IWUSR,           &urandom_fops},
-        {11,"kmsg",    S_IRUGO | S_IWUSR,           &kmsg_fops},
-#ifdef CONFIG_CRASH_DUMP
-        {12,"oldmem",    S_IRUSR | S_IWUSR | S_IRGRP, &oldmem_fops},
-#endif
-};
 static struct class *mem_class;
 static int __init chr_dev_init(void)
diff --git a/drivers/char/moxa.c b/drivers/char/moxa.c
index 65b6ff2442c6..6799588b0099 100644
--- a/drivers/char/moxa.c
+++ b/drivers/char/moxa.c
@@ -1189,6 +1189,11 @@ static int moxa_open(struct tty_struct *tty, struct file *filp)
                return -ENODEV;
        }
+        if (port % MAX_PORTS_PER_BOARD >= brd->numPorts) {
+                retval = -ENODEV;
+                goto out_unlock;
+        }
        ch = &brd->ports[port % MAX_PORTS_PER_BOARD];
        ch->port.count++;
        tty->driver_data = ch;
@@ -1213,8 +1218,8 @@ static int moxa_open(struct tty_struct *tty, struct file *filp)
                                moxa_close_port(tty);
        } else
                ch->port.flags |= ASYNC_NORMAL_ACTIVE;
+out_unlock:
        mutex_unlock(&moxa_openlock);
        return retval;
 }
diff --git a/drivers/char/ppdev.c b/drivers/char/ppdev.c
index c84c34fb1231..432655bcb04c 100644
--- a/drivers/char/ppdev.c
+++ b/drivers/char/ppdev.c
@@ -114,8 +114,7 @@ static ssize_t pp_read (struct file * file, char __user * buf, size_t count,
        if (!(pp->flags & PP_CLAIMED)) {
                /* Don't have the port claimed */
-                printk (KERN_DEBUG CHRDEV "%x: claim the port first\n",
+                pr_debug(CHRDEV "%x: claim the port first\n", minor);
-                        minor);
                return -EINVAL;
        }
@@ -198,8 +197,7 @@ static ssize_t pp_write (struct file * file, const char __user * buf,
        if (!(pp->flags & PP_CLAIMED)) {
                /* Don't have the port claimed */
-                printk (KERN_DEBUG CHRDEV "%x: claim the port first\n",
+                pr_debug(CHRDEV "%x: claim the port first\n", minor);
-                        minor);
                return -EINVAL;
        }
@@ -313,7 +311,7 @@ static int register_device (int minor, struct pp_struct *pp)
        }
        pp->pdev = pdev;
-        printk (KERN_DEBUG "%s: registered pardevice\n", name);
+        pr_debug("%s: registered pardevice\n", name);
        return 0;
 }
@@ -343,8 +341,7 @@ static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                int ret;
                if (pp->flags & PP_CLAIMED) {
-                        printk (KERN_DEBUG CHRDEV
+                        pr_debug(CHRDEV "%x: you've already got it!\n", minor);
-                                "%x: you've already got it!\n", minor);
                        return -EINVAL;
                }
@@ -379,7 +376,7 @@ static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
            }
        case PPEXCL:
                if (pp->pdev) {
-                        printk (KERN_DEBUG CHRDEV "%x: too late for PPEXCL; "
+                        pr_debug(CHRDEV "%x: too late for PPEXCL; "
                                "already registered\n", minor);
                        if (pp->flags & PP_EXCL)
                                /* But it's not really an error. */
@@ -491,8 +488,7 @@ static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
        /* Everything else requires the port to be claimed, so check
         * that now. */
        if ((pp->flags & PP_CLAIMED) == 0) {
-                printk (KERN_DEBUG CHRDEV "%x: claim the port first\n",
+                pr_debug(CHRDEV "%x: claim the port first\n", minor);
-                        minor);
                return -EINVAL;
        }
@@ -624,8 +620,7 @@ static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                return 0;
        default:
-                printk (KERN_DEBUG CHRDEV "%x: What? (cmd=0x%x)\n", minor,
+                pr_debug(CHRDEV "%x: What? (cmd=0x%x)\n", minor, cmd);
-                        cmd);
                return -EINVAL;
        }
@@ -698,9 +693,8 @@ static int pp_release (struct inode * inode, struct file * file)
        }
        if (compat_negot) {
                parport_negotiate (pp->pdev->port, IEEE1284_MODE_COMPAT);
-                printk (KERN_DEBUG CHRDEV
+                pr_debug(CHRDEV "%x: negotiated back to compatibility "
-                        "%x: negotiated back to compatibility mode because "
+                        "mode because user-space forgot\n", minor);
-                        "user-space forgot\n", minor);
        }
        if (pp->flags & PP_CLAIMED) {
@@ -713,7 +707,7 @@ static int pp_release (struct inode * inode, struct file * file)
                info->phase = pp->saved_state.phase;
                parport_release (pp->pdev);
                if (compat_negot != 1) {
-                        printk (KERN_DEBUG CHRDEV "%x: released pardevice "
+                        pr_debug(CHRDEV "%x: released pardevice "
                                "because user-space forgot\n", minor);
                }
        }
@@ -723,8 +717,7 @@ static int pp_release (struct inode * inode, struct file * file)
                parport_unregister_device (pp->pdev);
                kfree (name);
                pp->pdev = NULL;
-                printk (KERN_DEBUG CHRDEV "%x: unregistered pardevice\n",
+                pr_debug(CHRDEV "%x: unregistered pardevice\n", minor);
-                        minor);
        }
        kfree (pp);
diff --git a/drivers/char/sysrq.c b/drivers/char/sysrq.c
index 39a05b5fa9cb..0db35857e4d8 100644
--- a/drivers/char/sysrq.c
+++ b/drivers/char/sysrq.c
@@ -121,20 +121,17 @@ static struct sysrq_key_op sysrq_unraw_op = {
 #define sysrq_unraw_op (*(struct sysrq_key_op *)0)
 #endif /* CONFIG_VT */
-#ifdef CONFIG_KEXEC
+static void sysrq_handle_crash(int key, struct tty_struct *tty)
-static void sysrq_handle_crashdump(int key, struct tty_struct *tty)
 {
-        crash_kexec(get_irq_regs());
+        char *killer = NULL;
+        *killer = 1;
 }
 static struct sysrq_key_op sysrq_crashdump_op = {
-        .handler        = sysrq_handle_crashdump,
+        .handler        = sysrq_handle_crash,
-        .help_msg       = "Crashdump",
+        .help_msg       = "Crash",
-        .action_msg     = "Trigger a crashdump",
+        .action_msg     = "Trigger a crash",
        .enable_mask    = SYSRQ_ENABLE_DUMP,
 };
-#else
-#define sysrq_crashdump_op (*(struct sysrq_key_op *)0)
-#endif
 static void sysrq_handle_reboot(int key, struct tty_struct *tty)
 {
diff --git a/drivers/clocksource/sh_cmt.c b/drivers/clocksource/sh_cmt.c
index cf56a2af5fe1..2964f5f4a7ef 100644
--- a/drivers/clocksource/sh_cmt.c
+++ b/drivers/clocksource/sh_cmt.c
@@ -184,6 +184,9 @@ static void sh_cmt_disable(struct sh_cmt_priv *p)
        /* disable channel */
        sh_cmt_start_stop_ch(p, 0);
+        /* disable interrupts in CMT block */
+        sh_cmt_write(p, CMCSR, 0);
        /* stop clock */
        clk_disable(p->clk);
 }
@@ -599,7 +602,6 @@ static int sh_cmt_setup(struct sh_cmt_priv *p, struct platform_device *pdev)
        p->irqaction.handler = sh_cmt_interrupt;
        p->irqaction.dev_id = p;
        p->irqaction.flags = IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL;
-        p->irqaction.mask = CPU_MASK_NONE;
        ret = setup_irq(irq, &p->irqaction);
        if (ret) {
                pr_err("sh_cmt: failed to request irq %d\n", irq);
diff --git a/drivers/clocksource/sh_mtu2.c b/drivers/clocksource/sh_mtu2.c
index d1ae75454d10..973e714d6051 100644
--- a/drivers/clocksource/sh_mtu2.c
+++ b/drivers/clocksource/sh_mtu2.c
@@ -283,7 +283,6 @@ static int sh_mtu2_setup(struct sh_mtu2_priv *p, struct platform_device *pdev)
        p->irqaction.dev_id = p;
        p->irqaction.irq = irq;
        p->irqaction.flags = IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL;
-        p->irqaction.mask = CPU_MASK_NONE;
        /* get hold of clock */
        p->clk = clk_get(&p->pdev->dev, cfg->clk);
diff --git a/drivers/clocksource/sh_tmu.c b/drivers/clocksource/sh_tmu.c
index d6ea4398bf62..9ffb05f4095d 100644
--- a/drivers/clocksource/sh_tmu.c
+++ b/drivers/clocksource/sh_tmu.c
@@ -138,6 +138,9 @@ static void sh_tmu_disable(struct sh_tmu_priv *p)
        /* disable channel */
        sh_tmu_start_stop_ch(p, 0);
+        /* disable interrupts in TMU block */
+        sh_tmu_write(p, TCR, 0x0000);
        /* stop clock */
        clk_disable(p->clk);
 }
@@ -385,7 +388,6 @@ static int sh_tmu_setup(struct sh_tmu_priv *p, struct platform_device *pdev)
        p->irqaction.dev_id = p;
        p->irqaction.irq = irq;
        p->irqaction.flags = IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL;
-        p->irqaction.mask = CPU_MASK_NONE;
        /* get hold of clock */
        p->clk = clk_get(&p->pdev->dev, cfg->clk);
diff --git a/drivers/edac/Kconfig b/drivers/edac/Kconfig
index ab4f3592a11c..4339b1a879cd 100644
--- a/drivers/edac/Kconfig
+++ b/drivers/edac/Kconfig
@@ -5,7 +5,7 @@
 #
 menuconfig EDAC
-        bool "EDAC - error detection and reporting"
+        bool "EDAC (Error Detection And Correction) reporting"
        depends on HAS_IOMEM
        depends on X86 || PPC
        help
@@ -232,4 +232,13 @@ config EDAC_AMD8111
          Note, add more Kconfig dependency if it's adopted
          on some machine other than Maple.
+config EDAC_CPC925
+        tristate "IBM CPC925 Memory Controller (PPC970FX)"
+        depends on EDAC_MM_EDAC && PPC64
+        help
+          Support for error detection and correction on the
+          IBM CPC925 Bridge and Memory Controller, which is
+          a companion chip to the PowerPC 970 family of
+          processors.
 endif # EDAC
diff --git a/drivers/edac/Makefile b/drivers/edac/Makefile
index 633dc5604ee3..98aa4a7db412 100644
--- a/drivers/edac/Makefile
+++ b/drivers/edac/Makefile
@@ -18,6 +18,7 @@ edac_core-objs	+= edac_pci.o edac_pci_sysfs.o
 endif
 obj-$(CONFIG_EDAC_AMD76X)               += amd76x_edac.o
+obj-$(CONFIG_EDAC_CPC925)               += cpc925_edac.o
 obj-$(CONFIG_EDAC_I5000)                += i5000_edac.o
 obj-$(CONFIG_EDAC_I5100)                += i5100_edac.o
 obj-$(CONFIG_EDAC_I5400)                += i5400_edac.o
diff --git a/drivers/edac/amd8111_edac.c b/drivers/edac/amd8111_edac.c
index 2cb58ef743e0..35b78d04bbfa 100644
--- a/drivers/edac/amd8111_edac.c
+++ b/drivers/edac/amd8111_edac.c
@@ -37,7 +37,6 @@
 #define AMD8111_EDAC_MOD_STR    "amd8111_edac"
 #define PCI_DEVICE_ID_AMD_8111_PCI      0x7460
-static int edac_dev_idx;
 enum amd8111_edac_devs {
        LPC_BRIDGE = 0,
@@ -377,7 +376,7 @@ static int amd8111_dev_probe(struct pci_dev *dev,
         * edac_device_ctl_info, but make use of existing
         * one instead.
        */
-        dev_info->edac_idx = edac_dev_idx++;
+        dev_info->edac_idx = edac_device_alloc_index();
        dev_info->edac_dev =
                edac_device_alloc_ctl_info(0, dev_info->ctl_name, 1,
                                           NULL, 0, 0,
diff --git a/drivers/edac/cell_edac.c b/drivers/edac/cell_edac.c
index cb0f639f049d..c973004c002c 100644
--- a/drivers/edac/cell_edac.c
+++ b/drivers/edac/cell_edac.c
@@ -227,7 +227,7 @@ static struct platform_driver cell_edac_driver = {
                .owner  = THIS_MODULE,
        },
        .probe          = cell_edac_probe,
-        .remove         = cell_edac_remove,
+        .remove         = __devexit_p(cell_edac_remove),
 };
 static int __init cell_edac_init(void)
diff --git a/drivers/edac/cpc925_edac.c b/drivers/edac/cpc925_edac.c
new file mode 100644
index 000000000000..8c54196b5aba
--- /dev/null
+++ b/drivers/edac/cpc925_edac.c
@@ -0,0 +1,1017 @@
+/*
+ * cpc925_edac.c, EDAC driver for IBM CPC925 Bridge and Memory Controller.
+ *
+ * Copyright (c) 2008 Wind River Systems, Inc.
+ *
+ * Authors:     Cao Qingtao <qingtao.cao@windriver.com>
+ *
+ * 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.
+ *
+ * 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
+ */
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/edac.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include "edac_core.h"
+#include "edac_module.h"
+#define CPC925_EDAC_REVISION    " Ver: 1.0.0 " __DATE__
+#define CPC925_EDAC_MOD_STR     "cpc925_edac"
+#define cpc925_printk(level, fmt, arg...) \
+        edac_printk(level, "CPC925", fmt, ##arg)
+#define cpc925_mc_printk(mci, level, fmt, arg...) \
+        edac_mc_chipset_printk(mci, level, "CPC925", fmt, ##arg)
+/*
+ * CPC925 registers are of 32 bits with bit0 defined at the
+ * most significant bit and bit31 at that of least significant.
+ */
+#define CPC925_BITS_PER_REG     32
+#define CPC925_BIT(nr)          (1UL << (CPC925_BITS_PER_REG - 1 - nr))
+/*
+ * EDAC device names for the error detections of
+ * CPU Interface and Hypertransport Link.
+ */
+#define CPC925_CPU_ERR_DEV      "cpu"
+#define CPC925_HT_LINK_DEV      "htlink"
+/* Suppose DDR Refresh cycle is 15.6 microsecond */
+#define CPC925_REF_FREQ         0xFA69
+#define CPC925_SCRUB_BLOCK_SIZE 64      /* bytes */
+#define CPC925_NR_CSROWS        8
+/*
+ * All registers and bits definitions are taken from
+ * "CPC925 Bridge and Memory Controller User Manual, SA14-2761-02".
+ */
+/*
+ * CPU and Memory Controller Registers
+ */
+/************************************************************
+ *      Processor Interface Exception Mask Register (APIMASK)
+ ************************************************************/
+#define REG_APIMASK_OFFSET      0x30070
+enum apimask_bits {
+        APIMASK_DART    = CPC925_BIT(0), /* DART Exception */
+        APIMASK_ADI0    = CPC925_BIT(1), /* Handshake Error on PI0_ADI */
+        APIMASK_ADI1    = CPC925_BIT(2), /* Handshake Error on PI1_ADI */
+        APIMASK_STAT    = CPC925_BIT(3), /* Status Exception */
+        APIMASK_DERR    = CPC925_BIT(4), /* Data Error Exception */
+        APIMASK_ADRS0   = CPC925_BIT(5), /* Addressing Exception on PI0 */
+        APIMASK_ADRS1   = CPC925_BIT(6), /* Addressing Exception on PI1 */
+                                         /* BIT(7) Reserved */
+        APIMASK_ECC_UE_H = CPC925_BIT(8), /* UECC upper */
+        APIMASK_ECC_CE_H = CPC925_BIT(9), /* CECC upper */
+        APIMASK_ECC_UE_L = CPC925_BIT(10), /* UECC lower */
+        APIMASK_ECC_CE_L = CPC925_BIT(11), /* CECC lower */
+        CPU_MASK_ENABLE = (APIMASK_DART | APIMASK_ADI0 | APIMASK_ADI1 |
+                           APIMASK_STAT | APIMASK_DERR | APIMASK_ADRS0 |
+                           APIMASK_ADRS1),
+        ECC_MASK_ENABLE = (APIMASK_ECC_UE_H | APIMASK_ECC_CE_H |
+                           APIMASK_ECC_UE_L | APIMASK_ECC_CE_L),
+};
+/************************************************************
+ *      Processor Interface Exception Register (APIEXCP)
+ ************************************************************/
+#define REG_APIEXCP_OFFSET      0x30060
+enum apiexcp_bits {
+        APIEXCP_DART    = CPC925_BIT(0), /* DART Exception */
+        APIEXCP_ADI0    = CPC925_BIT(1), /* Handshake Error on PI0_ADI */
+        APIEXCP_ADI1    = CPC925_BIT(2), /* Handshake Error on PI1_ADI */
+        APIEXCP_STAT    = CPC925_BIT(3), /* Status Exception */
+        APIEXCP_DERR    = CPC925_BIT(4), /* Data Error Exception */
+        APIEXCP_ADRS0   = CPC925_BIT(5), /* Addressing Exception on PI0 */
+        APIEXCP_ADRS1   = CPC925_BIT(6), /* Addressing Exception on PI1 */
+                                         /* BIT(7) Reserved */
+        APIEXCP_ECC_UE_H = CPC925_BIT(8), /* UECC upper */
+        APIEXCP_ECC_CE_H = CPC925_BIT(9), /* CECC upper */
+        APIEXCP_ECC_UE_L = CPC925_BIT(10), /* UECC lower */
+        APIEXCP_ECC_CE_L = CPC925_BIT(11), /* CECC lower */
+        CPU_EXCP_DETECTED = (APIEXCP_DART | APIEXCP_ADI0 | APIEXCP_ADI1 |
+                             APIEXCP_STAT | APIEXCP_DERR | APIEXCP_ADRS0 |
+                             APIEXCP_ADRS1),
+        UECC_EXCP_DETECTED = (APIEXCP_ECC_UE_H | APIEXCP_ECC_UE_L),
+        CECC_EXCP_DETECTED = (APIEXCP_ECC_CE_H | APIEXCP_ECC_CE_L),
+        ECC_EXCP_DETECTED = (UECC_EXCP_DETECTED | CECC_EXCP_DETECTED),
+};
+/************************************************************
+ *      Memory Bus Configuration Register (MBCR)
+************************************************************/
+#define REG_MBCR_OFFSET         0x2190
+#define MBCR_64BITCFG_SHIFT     23
+#define MBCR_64BITCFG_MASK      (1UL << MBCR_64BITCFG_SHIFT)
+#define MBCR_64BITBUS_SHIFT     22
+#define MBCR_64BITBUS_MASK      (1UL << MBCR_64BITBUS_SHIFT)
+/************************************************************
+ *      Memory Bank Mode Register (MBMR)
+************************************************************/
+#define REG_MBMR_OFFSET         0x21C0
+#define MBMR_MODE_MAX_VALUE     0xF
+#define MBMR_MODE_SHIFT         25
+#define MBMR_MODE_MASK          (MBMR_MODE_MAX_VALUE << MBMR_MODE_SHIFT)
+#define MBMR_BBA_SHIFT          24
+#define MBMR_BBA_MASK           (1UL << MBMR_BBA_SHIFT)
+/************************************************************
+ *      Memory Bank Boundary Address Register (MBBAR)
+ ************************************************************/
+#define REG_MBBAR_OFFSET        0x21D0
+#define MBBAR_BBA_MAX_VALUE     0xFF
+#define MBBAR_BBA_SHIFT         24
+#define MBBAR_BBA_MASK          (MBBAR_BBA_MAX_VALUE << MBBAR_BBA_SHIFT)
+/************************************************************
+ *      Memory Scrub Control Register (MSCR)
+ ************************************************************/
+#define REG_MSCR_OFFSET         0x2400
+#define MSCR_SCRUB_MOD_MASK     0xC0000000 /* scrub_mod - bit0:1*/
+#define MSCR_BACKGR_SCRUB       0x40000000 /* 01 */
+#define MSCR_SI_SHIFT           16      /* si - bit8:15*/
+#define MSCR_SI_MAX_VALUE       0xFF
+#define MSCR_SI_MASK            (MSCR_SI_MAX_VALUE << MSCR_SI_SHIFT)
+/************************************************************
+ *      Memory Scrub Range Start Register (MSRSR)
+ ************************************************************/
+#define REG_MSRSR_OFFSET        0x2410
+/************************************************************
+ *      Memory Scrub Range End Register (MSRER)
+ ************************************************************/
+#define REG_MSRER_OFFSET        0x2420
+/************************************************************
+ *      Memory Scrub Pattern Register (MSPR)
+ ************************************************************/
+#define REG_MSPR_OFFSET         0x2430
+/************************************************************
+ *      Memory Check Control Register (MCCR)
+ ************************************************************/
+#define REG_MCCR_OFFSET         0x2440
+enum mccr_bits {
+        MCCR_ECC_EN     = CPC925_BIT(0), /* ECC high and low check */
+};
+/************************************************************
+ *      Memory Check Range End Register (MCRER)
+ ************************************************************/
+#define REG_MCRER_OFFSET        0x2450
+/************************************************************
+ *      Memory Error Address Register (MEAR)
+ ************************************************************/
+#define REG_MEAR_OFFSET         0x2460
+#define MEAR_BCNT_MAX_VALUE     0x3
+#define MEAR_BCNT_SHIFT         30
+#define MEAR_BCNT_MASK          (MEAR_BCNT_MAX_VALUE << MEAR_BCNT_SHIFT)
+#define MEAR_RANK_MAX_VALUE     0x7
+#define MEAR_RANK_SHIFT         27
+#define MEAR_RANK_MASK          (MEAR_RANK_MAX_VALUE << MEAR_RANK_SHIFT)
+#define MEAR_COL_MAX_VALUE      0x7FF
+#define MEAR_COL_SHIFT          16
+#define MEAR_COL_MASK           (MEAR_COL_MAX_VALUE << MEAR_COL_SHIFT)
+#define MEAR_BANK_MAX_VALUE     0x3
+#define MEAR_BANK_SHIFT         14
+#define MEAR_BANK_MASK          (MEAR_BANK_MAX_VALUE << MEAR_BANK_SHIFT)
+#define MEAR_ROW_MASK           0x00003FFF
+/************************************************************
+ *      Memory Error Syndrome Register (MESR)
+ ************************************************************/
+#define REG_MESR_OFFSET         0x2470
+#define MESR_ECC_SYN_H_MASK     0xFF00
+#define MESR_ECC_SYN_L_MASK     0x00FF
+/************************************************************
+ *      Memory Mode Control Register (MMCR)
+ ************************************************************/
+#define REG_MMCR_OFFSET         0x2500
+enum mmcr_bits {
+        MMCR_REG_DIMM_MODE = CPC925_BIT(3),
+};
+/*
+ * HyperTransport Link Registers
+ */
+/************************************************************
+ *  Error Handling/Enumeration Scratch Pad Register (ERRCTRL)
+ ************************************************************/
+#define REG_ERRCTRL_OFFSET      0x70140
+enum errctrl_bits {                      /* nonfatal interrupts for */
+        ERRCTRL_SERR_NF = CPC925_BIT(0), /* system error */
+        ERRCTRL_CRC_NF  = CPC925_BIT(1), /* CRC error */
+        ERRCTRL_RSP_NF  = CPC925_BIT(2), /* Response error */
+        ERRCTRL_EOC_NF  = CPC925_BIT(3), /* End-Of-Chain error */
+        ERRCTRL_OVF_NF  = CPC925_BIT(4), /* Overflow error */
+        ERRCTRL_PROT_NF = CPC925_BIT(5), /* Protocol error */
+        ERRCTRL_RSP_ERR = CPC925_BIT(6), /* Response error received */
+        ERRCTRL_CHN_FAL = CPC925_BIT(7), /* Sync flooding detected */
+        HT_ERRCTRL_ENABLE = (ERRCTRL_SERR_NF | ERRCTRL_CRC_NF |
+                             ERRCTRL_RSP_NF | ERRCTRL_EOC_NF |
+                             ERRCTRL_OVF_NF | ERRCTRL_PROT_NF),
+        HT_ERRCTRL_DETECTED = (ERRCTRL_RSP_ERR | ERRCTRL_CHN_FAL),
+};
+/************************************************************
+ *  Link Configuration and Link Control Register (LINKCTRL)
+ ************************************************************/
+#define REG_LINKCTRL_OFFSET     0x70110
+enum linkctrl_bits {
+        LINKCTRL_CRC_ERR        = (CPC925_BIT(22) | CPC925_BIT(23)),
+        LINKCTRL_LINK_FAIL      = CPC925_BIT(27),
+        HT_LINKCTRL_DETECTED    = (LINKCTRL_CRC_ERR | LINKCTRL_LINK_FAIL),
+};
+/************************************************************
+ *  Link FreqCap/Error/Freq/Revision ID Register (LINKERR)
+ ************************************************************/
+#define REG_LINKERR_OFFSET      0x70120
+enum linkerr_bits {
+        LINKERR_EOC_ERR         = CPC925_BIT(17), /* End-Of-Chain error */
+        LINKERR_OVF_ERR         = CPC925_BIT(18), /* Receive Buffer Overflow */
+        LINKERR_PROT_ERR        = CPC925_BIT(19), /* Protocol error */
+        HT_LINKERR_DETECTED     = (LINKERR_EOC_ERR | LINKERR_OVF_ERR |
+                                   LINKERR_PROT_ERR),
+};
+/************************************************************
+ *      Bridge Control Register (BRGCTRL)
+ ************************************************************/
+#define REG_BRGCTRL_OFFSET      0x70300
+enum brgctrl_bits {
+        BRGCTRL_DETSERR = CPC925_BIT(0), /* SERR on Secondary Bus */
+        BRGCTRL_SECBUSRESET = CPC925_BIT(9), /* Secondary Bus Reset */
+};
+/* Private structure for edac memory controller */
+struct cpc925_mc_pdata {
+        void __iomem *vbase;
+        unsigned long total_mem;
+        const char *name;
+        int edac_idx;
+};
+/* Private structure for common edac device */
+struct cpc925_dev_info {
+        void __iomem *vbase;
+        struct platform_device *pdev;
+        char *ctl_name;
+        int edac_idx;
+        struct edac_device_ctl_info *edac_dev;
+        void (*init)(struct cpc925_dev_info *dev_info);
+        void (*exit)(struct cpc925_dev_info *dev_info);
+        void (*check)(struct edac_device_ctl_info *edac_dev);
+};
+/* Get total memory size from Open Firmware DTB */
+static void get_total_mem(struct cpc925_mc_pdata *pdata)
+{
+        struct device_node *np = NULL;
+        const unsigned int *reg, *reg_end;
+        int len, sw, aw;
+        unsigned long start, size;
+        np = of_find_node_by_type(NULL, "memory");
+        if (!np)
+                return;
+        aw = of_n_addr_cells(np);
+        sw = of_n_size_cells(np);
+        reg = (const unsigned int *)of_get_property(np, "reg", &len);
+        reg_end = reg + len/4;
+        pdata->total_mem = 0;
+        do {
+                start = of_read_number(reg, aw);
+                reg += aw;
+                size = of_read_number(reg, sw);
+                reg += sw;
+                debugf1("%s: start 0x%lx, size 0x%lx\n", __func__,
+                        start, size);
+                pdata->total_mem += size;
+        } while (reg < reg_end);
+        of_node_put(np);
+        debugf0("%s: total_mem 0x%lx\n", __func__, pdata->total_mem);
+}
+static void cpc925_init_csrows(struct mem_ctl_info *mci)
+{
+        struct cpc925_mc_pdata *pdata = mci->pvt_info;
+        struct csrow_info *csrow;
+        int index;
+        u32 mbmr, mbbar, bba;
+        unsigned long row_size, last_nr_pages = 0;
+        get_total_mem(pdata);
+        for (index = 0; index < mci->nr_csrows; index++) {
+                mbmr = __raw_readl(pdata->vbase + REG_MBMR_OFFSET +
+                                   0x20 * index);
+                mbbar = __raw_readl(pdata->vbase + REG_MBBAR_OFFSET +
+                                   0x20 + index);
+                bba = (((mbmr & MBMR_BBA_MASK) >> MBMR_BBA_SHIFT) << 8) |
+                       ((mbbar & MBBAR_BBA_MASK) >> MBBAR_BBA_SHIFT);
+                if (bba == 0)
+                        continue; /* not populated */
+                csrow = &mci->csrows[index];
+                row_size = bba * (1UL << 28);   /* 256M */
+                csrow->first_page = last_nr_pages;
+                csrow->nr_pages = row_size >> PAGE_SHIFT;
+                csrow->last_page = csrow->first_page + csrow->nr_pages - 1;
+                last_nr_pages = csrow->last_page + 1;
+                csrow->mtype = MEM_RDDR;
+                csrow->edac_mode = EDAC_SECDED;
+                switch (csrow->nr_channels) {
+                case 1: /* Single channel */
+                        csrow->grain = 32; /* four-beat burst of 32 bytes */
+                        break;
+                case 2: /* Dual channel */
+                default:
+                        csrow->grain = 64; /* four-beat burst of 64 bytes */
+                        break;
+                }
+                switch ((mbmr & MBMR_MODE_MASK) >> MBMR_MODE_SHIFT) {
+                case 6: /* 0110, no way to differentiate X8 VS X16 */
+                case 5: /* 0101 */
+                case 8: /* 1000 */
+                        csrow->dtype = DEV_X16;
+                        break;
+                case 7: /* 0111 */
+                case 9: /* 1001 */
+                        csrow->dtype = DEV_X8;
+                        break;
+                default:
+                        csrow->dtype = DEV_UNKNOWN;
+                        break;
+                }
+        }
+}
+/* Enable memory controller ECC detection */
+static void cpc925_mc_init(struct mem_ctl_info *mci)
+{
+        struct cpc925_mc_pdata *pdata = mci->pvt_info;
+        u32 apimask;
+        u32 mccr;
+        /* Enable various ECC error exceptions */
+        apimask = __raw_readl(pdata->vbase + REG_APIMASK_OFFSET);
+        if ((apimask & ECC_MASK_ENABLE) == 0) {
+                apimask |= ECC_MASK_ENABLE;
+                __raw_writel(apimask, pdata->vbase + REG_APIMASK_OFFSET);
+        }
+        /* Enable ECC detection */
+        mccr = __raw_readl(pdata->vbase + REG_MCCR_OFFSET);
+        if ((mccr & MCCR_ECC_EN) == 0) {
+                mccr |= MCCR_ECC_EN;
+                __raw_writel(mccr, pdata->vbase + REG_MCCR_OFFSET);
+        }
+}
+/* Disable memory controller ECC detection */
+static void cpc925_mc_exit(struct mem_ctl_info *mci)
+{
+        /*
+         * WARNING:
+         * We are supposed to clear the ECC error detection bits,
+         * and it will be no problem to do so. However, once they
+         * are cleared here if we want to re-install CPC925 EDAC
+         * module later, setting them up in cpc925_mc_init() will
+         * trigger machine check exception.
+         * Also, it's ok to leave ECC error detection bits enabled,
+         * since they are reset to 1 by default or by boot loader.
+         */
+        return;
+}
+/*
+ * Revert DDR column/row/bank addresses into page frame number and
+ * offset in page.
+ *
+ * Suppose memory mode is 0x0111(128-bit mode, identical DIMM pairs),
+ * physical address(PA) bits to column address(CA) bits mappings are:
+ * CA   0   1   2   3   4   5   6   7   8   9   10
+ * PA   59  58  57  56  55  54  53  52  51  50  49
+ *
+ * physical address(PA) bits to bank address(BA) bits mappings are:
+ * BA   0   1
+ * PA   43  44
+ *
+ * physical address(PA) bits to row address(RA) bits mappings are:
+ * RA   0   1   2   3   4   5   6   7   8   9   10   11   12
+ * PA   36  35  34  48  47  46  45  40  41  42  39   38   37
+ */
+static void cpc925_mc_get_pfn(struct mem_ctl_info *mci, u32 mear,
+                unsigned long *pfn, unsigned long *offset, int *csrow)
+{
+        u32 bcnt, rank, col, bank, row;
+        u32 c;
+        unsigned long pa;
+        int i;
+        bcnt = (mear & MEAR_BCNT_MASK) >> MEAR_BCNT_SHIFT;
+        rank = (mear & MEAR_RANK_MASK) >> MEAR_RANK_SHIFT;
+        col = (mear & MEAR_COL_MASK) >> MEAR_COL_SHIFT;
+        bank = (mear & MEAR_BANK_MASK) >> MEAR_BANK_SHIFT;
+        row = mear & MEAR_ROW_MASK;
+        *csrow = rank;
+#ifdef CONFIG_EDAC_DEBUG
+        if (mci->csrows[rank].first_page == 0) {
+                cpc925_mc_printk(mci, KERN_ERR, "ECC occurs in a "
+                        "non-populated csrow, broken hardware?\n");
+                return;
+        }
+#endif
+        /* Revert csrow number */
+        pa = mci->csrows[rank].first_page << PAGE_SHIFT;
+        /* Revert column address */
+        col += bcnt;
+        for (i = 0; i < 11; i++) {
+                c = col & 0x1;
+                col >>= 1;
+                pa |= c << (14 - i);
+        }
+        /* Revert bank address */
+        pa |= bank << 19;
+        /* Revert row address, in 4 steps */
+        for (i = 0; i < 3; i++) {
+                c = row & 0x1;
+                row >>= 1;
+                pa |= c << (26 - i);
+        }
+        for (i = 0; i < 3; i++) {
+                c = row & 0x1;
+                row >>= 1;
+                pa |= c << (21 + i);
+        }
+        for (i = 0; i < 4; i++) {
+                c = row & 0x1;
+                row >>= 1;
+                pa |= c << (18 - i);
+        }
+        for (i = 0; i < 3; i++) {
+                c = row & 0x1;
+                row >>= 1;
+                pa |= c << (29 - i);
+        }
+        *offset = pa & (PAGE_SIZE - 1);
+        *pfn = pa >> PAGE_SHIFT;
+        debugf0("%s: ECC physical address 0x%lx\n", __func__, pa);
+}
+static int cpc925_mc_find_channel(struct mem_ctl_info *mci, u16 syndrome)
+{
+        if ((syndrome & MESR_ECC_SYN_H_MASK) == 0)
+                return 0;
+        if ((syndrome & MESR_ECC_SYN_L_MASK) == 0)
+                return 1;
+        cpc925_mc_printk(mci, KERN_INFO, "Unexpected syndrome value: 0x%x\n",
+                         syndrome);
+        return 1;
+}
+/* Check memory controller registers for ECC errors */
+static void cpc925_mc_check(struct mem_ctl_info *mci)
+{
+        struct cpc925_mc_pdata *pdata = mci->pvt_info;
+        u32 apiexcp;
+        u32 mear;
+        u32 mesr;
+        u16 syndrome;
+        unsigned long pfn = 0, offset = 0;
+        int csrow = 0, channel = 0;
+        /* APIEXCP is cleared when read */
+        apiexcp = __raw_readl(pdata->vbase + REG_APIEXCP_OFFSET);
+        if ((apiexcp & ECC_EXCP_DETECTED) == 0)
+                return;
+        mesr = __raw_readl(pdata->vbase + REG_MESR_OFFSET);
+        syndrome = mesr | (MESR_ECC_SYN_H_MASK | MESR_ECC_SYN_L_MASK);
+        mear = __raw_readl(pdata->vbase + REG_MEAR_OFFSET);
+        /* Revert column/row addresses into page frame number, etc */
+        cpc925_mc_get_pfn(mci, mear, &pfn, &offset, &csrow);
+        if (apiexcp & CECC_EXCP_DETECTED) {
+                cpc925_mc_printk(mci, KERN_INFO, "DRAM CECC Fault\n");
+                channel = cpc925_mc_find_channel(mci, syndrome);
+                edac_mc_handle_ce(mci, pfn, offset, syndrome,
+                                  csrow, channel, mci->ctl_name);
+        }
+        if (apiexcp & UECC_EXCP_DETECTED) {
+                cpc925_mc_printk(mci, KERN_INFO, "DRAM UECC Fault\n");
+                edac_mc_handle_ue(mci, pfn, offset, csrow, mci->ctl_name);
+        }
+        cpc925_mc_printk(mci, KERN_INFO, "Dump registers:\n");
+        cpc925_mc_printk(mci, KERN_INFO, "APIMASK               0x%08x\n",
+                __raw_readl(pdata->vbase + REG_APIMASK_OFFSET));
+        cpc925_mc_printk(mci, KERN_INFO, "APIEXCP               0x%08x\n",
+                apiexcp);
+        cpc925_mc_printk(mci, KERN_INFO, "Mem Scrub Ctrl        0x%08x\n",
+                __raw_readl(pdata->vbase + REG_MSCR_OFFSET));
+        cpc925_mc_printk(mci, KERN_INFO, "Mem Scrub Rge Start   0x%08x\n",
+                __raw_readl(pdata->vbase + REG_MSRSR_OFFSET));
+        cpc925_mc_printk(mci, KERN_INFO, "Mem Scrub Rge End     0x%08x\n",
+                __raw_readl(pdata->vbase + REG_MSRER_OFFSET));
+        cpc925_mc_printk(mci, KERN_INFO, "Mem Scrub Pattern     0x%08x\n",
+                __raw_readl(pdata->vbase + REG_MSPR_OFFSET));
+        cpc925_mc_printk(mci, KERN_INFO, "Mem Chk Ctrl          0x%08x\n",
+                __raw_readl(pdata->vbase + REG_MCCR_OFFSET));
+        cpc925_mc_printk(mci, KERN_INFO, "Mem Chk Rge End       0x%08x\n",
+                __raw_readl(pdata->vbase + REG_MCRER_OFFSET));
+        cpc925_mc_printk(mci, KERN_INFO, "Mem Err Address       0x%08x\n",
+                mesr);
+        cpc925_mc_printk(mci, KERN_INFO, "Mem Err Syndrome      0x%08x\n",
+                syndrome);
+}
+/******************** CPU err device********************************/
+/* Enable CPU Errors detection */
+static void cpc925_cpu_init(struct cpc925_dev_info *dev_info)
+{
+        u32 apimask;
+        apimask = __raw_readl(dev_info->vbase + REG_APIMASK_OFFSET);
+        if ((apimask & CPU_MASK_ENABLE) == 0) {
+                apimask |= CPU_MASK_ENABLE;
+                __raw_writel(apimask, dev_info->vbase + REG_APIMASK_OFFSET);
+        }
+}
+/* Disable CPU Errors detection */
+static void cpc925_cpu_exit(struct cpc925_dev_info *dev_info)
+{
+        /*
+         * WARNING:
+         * We are supposed to clear the CPU error detection bits,
+         * and it will be no problem to do so. However, once they
+         * are cleared here if we want to re-install CPC925 EDAC
+         * module later, setting them up in cpc925_cpu_init() will
+         * trigger machine check exception.
+         * Also, it's ok to leave CPU error detection bits enabled,
+         * since they are reset to 1 by default.
+         */
+        return;
+}
+/* Check for CPU Errors */
+static void cpc925_cpu_check(struct edac_device_ctl_info *edac_dev)
+{
+        struct cpc925_dev_info *dev_info = edac_dev->pvt_info;
+        u32 apiexcp;
+        u32 apimask;
+        /* APIEXCP is cleared when read */
+        apiexcp = __raw_readl(dev_info->vbase + REG_APIEXCP_OFFSET);
+        if ((apiexcp & CPU_EXCP_DETECTED) == 0)
+                return;
+        apimask = __raw_readl(dev_info->vbase + REG_APIMASK_OFFSET);
+        cpc925_printk(KERN_INFO, "Processor Interface Fault\n"
+                                 "Processor Interface register dump:\n");
+        cpc925_printk(KERN_INFO, "APIMASK               0x%08x\n", apimask);
+        cpc925_printk(KERN_INFO, "APIEXCP               0x%08x\n", apiexcp);
+        edac_device_handle_ue(edac_dev, 0, 0, edac_dev->ctl_name);
+}
+/******************** HT Link err device****************************/
+/* Enable HyperTransport Link Error detection */
+static void cpc925_htlink_init(struct cpc925_dev_info *dev_info)
+{
+        u32 ht_errctrl;
+        ht_errctrl = __raw_readl(dev_info->vbase + REG_ERRCTRL_OFFSET);
+        if ((ht_errctrl & HT_ERRCTRL_ENABLE) == 0) {
+                ht_errctrl |= HT_ERRCTRL_ENABLE;
+                __raw_writel(ht_errctrl, dev_info->vbase + REG_ERRCTRL_OFFSET);
+        }
+}
+/* Disable HyperTransport Link Error detection */
+static void cpc925_htlink_exit(struct cpc925_dev_info *dev_info)
+{
+        u32 ht_errctrl;
+        ht_errctrl = __raw_readl(dev_info->vbase + REG_ERRCTRL_OFFSET);
+        ht_errctrl &= ~HT_ERRCTRL_ENABLE;
+        __raw_writel(ht_errctrl, dev_info->vbase + REG_ERRCTRL_OFFSET);
+}
+/* Check for HyperTransport Link errors */
+static void cpc925_htlink_check(struct edac_device_ctl_info *edac_dev)
+{
+        struct cpc925_dev_info *dev_info = edac_dev->pvt_info;
+        u32 brgctrl = __raw_readl(dev_info->vbase + REG_BRGCTRL_OFFSET);
+        u32 linkctrl = __raw_readl(dev_info->vbase + REG_LINKCTRL_OFFSET);
+        u32 errctrl = __raw_readl(dev_info->vbase + REG_ERRCTRL_OFFSET);
+        u32 linkerr = __raw_readl(dev_info->vbase + REG_LINKERR_OFFSET);
+        if (!((brgctrl & BRGCTRL_DETSERR) ||
+              (linkctrl & HT_LINKCTRL_DETECTED) ||
+              (errctrl & HT_ERRCTRL_DETECTED) ||
+              (linkerr & HT_LINKERR_DETECTED)))
+                return;
+        cpc925_printk(KERN_INFO, "HT Link Fault\n"
+                                 "HT register dump:\n");
+        cpc925_printk(KERN_INFO, "Bridge Ctrl                   0x%08x\n",
+                      brgctrl);
+        cpc925_printk(KERN_INFO, "Link Config Ctrl              0x%08x\n",
+                      linkctrl);
+        cpc925_printk(KERN_INFO, "Error Enum and Ctrl           0x%08x\n",
+                      errctrl);
+        cpc925_printk(KERN_INFO, "Link Error                    0x%08x\n",
+                      linkerr);
+        /* Clear by write 1 */
+        if (brgctrl & BRGCTRL_DETSERR)
+                __raw_writel(BRGCTRL_DETSERR,
+                                dev_info->vbase + REG_BRGCTRL_OFFSET);
+        if (linkctrl & HT_LINKCTRL_DETECTED)
+                __raw_writel(HT_LINKCTRL_DETECTED,
+                                dev_info->vbase + REG_LINKCTRL_OFFSET);
+        /* Initiate Secondary Bus Reset to clear the chain failure */
+        if (errctrl & ERRCTRL_CHN_FAL)
+                __raw_writel(BRGCTRL_SECBUSRESET,
+                                dev_info->vbase + REG_BRGCTRL_OFFSET);
+        if (errctrl & ERRCTRL_RSP_ERR)
+                __raw_writel(ERRCTRL_RSP_ERR,
+                                dev_info->vbase + REG_ERRCTRL_OFFSET);
+        if (linkerr & HT_LINKERR_DETECTED)
+                __raw_writel(HT_LINKERR_DETECTED,
+                                dev_info->vbase + REG_LINKERR_OFFSET);
+        edac_device_handle_ce(edac_dev, 0, 0, edac_dev->ctl_name);
+}
+static struct cpc925_dev_info cpc925_devs[] = {
+        {
+        .ctl_name = CPC925_CPU_ERR_DEV,
+        .init = cpc925_cpu_init,
+        .exit = cpc925_cpu_exit,
+        .check = cpc925_cpu_check,
+        },
+        {
+        .ctl_name = CPC925_HT_LINK_DEV,
+        .init = cpc925_htlink_init,
+        .exit = cpc925_htlink_exit,
+        .check = cpc925_htlink_check,
+        },
+        {0}, /* Terminated by NULL */
+};
+/*
+ * Add CPU Err detection and HyperTransport Link Err detection
+ * as common "edac_device", they have no corresponding device
+ * nodes in the Open Firmware DTB and we have to add platform
+ * devices for them. Also, they will share the MMIO with that
+ * of memory controller.
+ */
+static void cpc925_add_edac_devices(void __iomem *vbase)
+{
+        struct cpc925_dev_info *dev_info;
+        if (!vbase) {
+                cpc925_printk(KERN_ERR, "MMIO not established yet\n");
+                return;
+        }
+        for (dev_info = &cpc925_devs[0]; dev_info->init; dev_info++) {
+                dev_info->vbase = vbase;
+                dev_info->pdev = platform_device_register_simple(
+                                        dev_info->ctl_name, 0, NULL, 0);
+                if (IS_ERR(dev_info->pdev)) {
+                        cpc925_printk(KERN_ERR,
+                                "Can't register platform device for %s\n",
+                                dev_info->ctl_name);
+                        continue;
+                }
+                /*
+                 * Don't have to allocate private structure but
+                 * make use of cpc925_devs[] instead.
+                 */
+                dev_info->edac_idx = edac_device_alloc_index();
+                dev_info->edac_dev =
+                        edac_device_alloc_ctl_info(0, dev_info->ctl_name,
+                                1, NULL, 0, 0, NULL, 0, dev_info->edac_idx);
+                if (!dev_info->edac_dev) {
+                        cpc925_printk(KERN_ERR, "No memory for edac device\n");
+                        goto err1;
+                }
+                dev_info->edac_dev->pvt_info = dev_info;
+                dev_info->edac_dev->dev = &dev_info->pdev->dev;
+                dev_info->edac_dev->ctl_name = dev_info->ctl_name;
+                dev_info->edac_dev->mod_name = CPC925_EDAC_MOD_STR;
+                dev_info->edac_dev->dev_name = dev_name(&dev_info->pdev->dev);
+                if (edac_op_state == EDAC_OPSTATE_POLL)
+                        dev_info->edac_dev->edac_check = dev_info->check;
+                if (dev_info->init)
+                        dev_info->init(dev_info);
+                if (edac_device_add_device(dev_info->edac_dev) > 0) {
+                        cpc925_printk(KERN_ERR,
+                                "Unable to add edac device for %s\n",
+                                dev_info->ctl_name);
+                        goto err2;
+                }
+                debugf0("%s: Successfully added edac device for %s\n",
+                        __func__, dev_info->ctl_name);
+                continue;
+err2:
+                if (dev_info->exit)
+                        dev_info->exit(dev_info);
+                edac_device_free_ctl_info(dev_info->edac_dev);
+err1:
+                platform_device_unregister(dev_info->pdev);
+        }
+}
+/*
+ * Delete the common "edac_device" for CPU Err Detection
+ * and HyperTransport Link Err Detection
+ */
+static void cpc925_del_edac_devices(void)
+{
+        struct cpc925_dev_info *dev_info;
+        for (dev_info = &cpc925_devs[0]; dev_info->init; dev_info++) {
+                if (dev_info->edac_dev) {
+                        edac_device_del_device(dev_info->edac_dev->dev);
+                        edac_device_free_ctl_info(dev_info->edac_dev);
+                        platform_device_unregister(dev_info->pdev);
+                }
+                if (dev_info->exit)
+                        dev_info->exit(dev_info);
+                debugf0("%s: Successfully deleted edac device for %s\n",
+                        __func__, dev_info->ctl_name);
+        }
+}
+/* Convert current back-ground scrub rate into byte/sec bandwith */
+static int cpc925_get_sdram_scrub_rate(struct mem_ctl_info *mci, u32 *bw)
+{
+        struct cpc925_mc_pdata *pdata = mci->pvt_info;
+        u32 mscr;
+        u8 si;
+        mscr = __raw_readl(pdata->vbase + REG_MSCR_OFFSET);
+        si = (mscr & MSCR_SI_MASK) >> MSCR_SI_SHIFT;
+        debugf0("%s, Mem Scrub Ctrl Register 0x%x\n", __func__, mscr);
+        if (((mscr & MSCR_SCRUB_MOD_MASK) != MSCR_BACKGR_SCRUB) ||
+            (si == 0)) {
+                cpc925_mc_printk(mci, KERN_INFO, "Scrub mode not enabled\n");
+                *bw = 0;
+        } else
+                *bw = CPC925_SCRUB_BLOCK_SIZE * 0xFA67 / si;
+        return 0;
+}
+/* Return 0 for single channel; 1 for dual channel */
+static int cpc925_mc_get_channels(void __iomem *vbase)
+{
+        int dual = 0;
+        u32 mbcr;
+        mbcr = __raw_readl(vbase + REG_MBCR_OFFSET);
+        /*
+         * Dual channel only when 128-bit wide physical bus
+         * and 128-bit configuration.
+         */
+        if (((mbcr & MBCR_64BITCFG_MASK) == 0) &&
+            ((mbcr & MBCR_64BITBUS_MASK) == 0))
+                dual = 1;
+        debugf0("%s: %s channel\n", __func__,
+                (dual > 0) ? "Dual" : "Single");
+        return dual;
+}
+static int __devinit cpc925_probe(struct platform_device *pdev)
+{
+        static int edac_mc_idx;
+        struct mem_ctl_info *mci;
+        void __iomem *vbase;
+        struct cpc925_mc_pdata *pdata;
+        struct resource *r;
+        int res = 0, nr_channels;
+        debugf0("%s: %s platform device found!\n", __func__, pdev->name);
+        if (!devres_open_group(&pdev->dev, cpc925_probe, GFP_KERNEL)) {
+                res = -ENOMEM;
+                goto out;
+        }
+        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!r) {
+                cpc925_printk(KERN_ERR, "Unable to get resource\n");
+                res = -ENOENT;
+                goto err1;
+        }
+        if (!devm_request_mem_region(&pdev->dev,
+                                     r->start,
+                                     r->end - r->start + 1,
+                                     pdev->name)) {
+                cpc925_printk(KERN_ERR, "Unable to request mem region\n");
+                res = -EBUSY;
+                goto err1;
+        }
+        vbase = devm_ioremap(&pdev->dev, r->start, r->end - r->start + 1);
+        if (!vbase) {
+                cpc925_printk(KERN_ERR, "Unable to ioremap device\n");
+                res = -ENOMEM;
+                goto err2;
+        }
+        nr_channels = cpc925_mc_get_channels(vbase);
+        mci = edac_mc_alloc(sizeof(struct cpc925_mc_pdata),
+                        CPC925_NR_CSROWS, nr_channels + 1, edac_mc_idx);
+        if (!mci) {
+                cpc925_printk(KERN_ERR, "No memory for mem_ctl_info\n");
+                res = -ENOMEM;
+                goto err2;
+        }
+        pdata = mci->pvt_info;
+        pdata->vbase = vbase;
+        pdata->edac_idx = edac_mc_idx++;
+        pdata->name = pdev->name;
+        mci->dev = &pdev->dev;
+        platform_set_drvdata(pdev, mci);
+        mci->dev_name = dev_name(&pdev->dev);
+        mci->mtype_cap = MEM_FLAG_RDDR | MEM_FLAG_DDR;
+        mci->edac_ctl_cap = EDAC_FLAG_NONE | EDAC_FLAG_SECDED;
+        mci->edac_cap = EDAC_FLAG_SECDED;
+        mci->mod_name = CPC925_EDAC_MOD_STR;
+        mci->mod_ver = CPC925_EDAC_REVISION;
+        mci->ctl_name = pdev->name;
+        if (edac_op_state == EDAC_OPSTATE_POLL)
+                mci->edac_check = cpc925_mc_check;
+        mci->ctl_page_to_phys = NULL;
+        mci->scrub_mode = SCRUB_SW_SRC;
+        mci->set_sdram_scrub_rate = NULL;
+        mci->get_sdram_scrub_rate = cpc925_get_sdram_scrub_rate;
+        cpc925_init_csrows(mci);
+        /* Setup memory controller registers */
+        cpc925_mc_init(mci);
+        if (edac_mc_add_mc(mci) > 0) {
+                cpc925_mc_printk(mci, KERN_ERR, "Failed edac_mc_add_mc()\n");
+                goto err3;
+        }
+        cpc925_add_edac_devices(vbase);
+        /* get this far and it's successful */
+        debugf0("%s: success\n", __func__);
+        res = 0;
+        goto out;
+err3:
+        cpc925_mc_exit(mci);
+        edac_mc_free(mci);
+err2:
+        devm_release_mem_region(&pdev->dev, r->start, r->end-r->start+1);
+err1:
+        devres_release_group(&pdev->dev, cpc925_probe);
+out:
+        return res;
+}
+static int cpc925_remove(struct platform_device *pdev)
+{
+        struct mem_ctl_info *mci = platform_get_drvdata(pdev);
+        /*
+         * Delete common edac devices before edac mc, because
+         * the former share the MMIO of the latter.
+         */
+        cpc925_del_edac_devices();
+        cpc925_mc_exit(mci);
+        edac_mc_del_mc(&pdev->dev);
+        edac_mc_free(mci);
+        return 0;
+}
+static struct platform_driver cpc925_edac_driver = {
+        .probe = cpc925_probe,
+        .remove = cpc925_remove,
+        .driver = {
+                   .name = "cpc925_edac",
+        }
+};
+static int __init cpc925_edac_init(void)
+{
+        int ret = 0;
+        printk(KERN_INFO "IBM CPC925 EDAC driver " CPC925_EDAC_REVISION "\n");
+        printk(KERN_INFO "\t(c) 2008 Wind River Systems, Inc\n");
+        /* Only support POLL mode so far */
+        edac_op_state = EDAC_OPSTATE_POLL;
+        ret = platform_driver_register(&cpc925_edac_driver);
+        if (ret) {
+                printk(KERN_WARNING "Failed to register %s\n",
+                        CPC925_EDAC_MOD_STR);
+        }
+        return ret;
+}
+static void __exit cpc925_edac_exit(void)
+{
+        platform_driver_unregister(&cpc925_edac_driver);
+}
+module_init(cpc925_edac_init);
+module_exit(cpc925_edac_exit);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Cao Qingtao <qingtao.cao@windriver.com>");
+MODULE_DESCRIPTION("IBM CPC925 Bridge and MC EDAC kernel module");
diff --git a/drivers/edac/edac_core.h b/drivers/edac/edac_core.h
index 48d3b1409834..3493c6bdb820 100644
--- a/drivers/edac/edac_core.h
+++ b/drivers/edac/edac_core.h
@@ -841,6 +841,7 @@ extern void edac_device_handle_ue(struct edac_device_ctl_info *edac_dev,
                                int inst_nr, int block_nr, const char *msg);
 extern void edac_device_handle_ce(struct edac_device_ctl_info *edac_dev,
                                int inst_nr, int block_nr, const char *msg);
+extern int edac_device_alloc_index(void);
 /*
 * edac_pci APIs
diff --git a/drivers/edac/edac_device.c b/drivers/edac/edac_device.c
index a7d2c717d033..b02a6a69a8f0 100644
--- a/drivers/edac/edac_device.c
+++ b/drivers/edac/edac_device.c
@@ -490,6 +490,20 @@ void edac_device_reset_delay_period(struct edac_device_ctl_info *edac_dev,
        mutex_unlock(&device_ctls_mutex);
 }
+/*
+ * edac_device_alloc_index: Allocate a unique device index number
+ *
+ * Return:
+ *      allocated index number
+ */
+int edac_device_alloc_index(void)
+{
+        static atomic_t device_indexes = ATOMIC_INIT(0);
+        return atomic_inc_return(&device_indexes) - 1;
+}
+EXPORT_SYMBOL_GPL(edac_device_alloc_index);
 /**
 * edac_device_add_device: Insert the 'edac_dev' structure into the
 * edac_device global list and create sysfs entries associated with
diff --git a/drivers/firmware/pcdp.c b/drivers/firmware/pcdp.c
index 58e9f8e457f8..51e0e2d8fac6 100644
--- a/drivers/firmware/pcdp.c
+++ b/drivers/firmware/pcdp.c
@@ -28,10 +28,10 @@ setup_serial_console(struct pcdp_uart *uart)
        char parity;
        mmio = (uart->addr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY);
-        p += sprintf(p, "uart8250,%s,0x%lx",
+        p += sprintf(p, "uart8250,%s,0x%llx",
                mmio ? "mmio" : "io", uart->addr.address);
        if (uart->baud) {
-                p += sprintf(p, ",%lu", uart->baud);
+                p += sprintf(p, ",%llu", uart->baud);
                if (uart->bits) {
                        switch (uart->parity) {
                            case 0x2: parity = 'e'; break;
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index 11f373971fa5..3582c39f9725 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -67,6 +67,12 @@ config GPIO_SYSFS
 comment "Memory mapped GPIO expanders:"
+config GPIO_PL061
+        bool "PrimeCell PL061 GPIO support"
+        depends on ARM_AMBA
+        help
+          Say yes here to support the PrimeCell PL061 GPIO device
 config GPIO_XILINX
        bool "Xilinx GPIO support"
        depends on PPC_OF || MICROBLAZE
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index 49ac64e515e6..ef90203e8f3c 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -9,6 +9,7 @@ obj-$(CONFIG_GPIO_MAX732X)	+= max732x.o
 obj-$(CONFIG_GPIO_MCP23S08)     += mcp23s08.o
 obj-$(CONFIG_GPIO_PCA953X)      += pca953x.o
 obj-$(CONFIG_GPIO_PCF857X)      += pcf857x.o
+obj-$(CONFIG_GPIO_PL061)        += pl061.o
 obj-$(CONFIG_GPIO_TWL4030)      += twl4030-gpio.o
 obj-$(CONFIG_GPIO_XILINX)       += xilinx_gpio.o
 obj-$(CONFIG_GPIO_BT8XX)        += bt8xxgpio.o
diff --git a/drivers/gpio/max7301.c b/drivers/gpio/max7301.c
index 3e7f4e06386e..7b82eaae2621 100644
--- a/drivers/gpio/max7301.c
+++ b/drivers/gpio/max7301.c
@@ -287,7 +287,7 @@ exit_destroy:
        return ret;
 }
-static int max7301_remove(struct spi_device *spi)
+static int __devexit max7301_remove(struct spi_device *spi)
 {
        struct max7301 *ts;
        int ret;
diff --git a/drivers/gpio/pca953x.c b/drivers/gpio/pca953x.c
index 8dc0164bd51e..cdb6574d25a6 100644
--- a/drivers/gpio/pca953x.c
+++ b/drivers/gpio/pca953x.c
@@ -15,6 +15,10 @@
 #include <linux/init.h>
 #include <linux/i2c.h>
 #include <linux/i2c/pca953x.h>
+#ifdef CONFIG_OF_GPIO
+#include <linux/of_platform.h>
+#include <linux/of_gpio.h>
+#endif
 #include <asm/gpio.h>
@@ -32,6 +36,7 @@ static const struct i2c_device_id pca953x_id[] = {
        { "pca9539", 16, },
        { "pca9554", 8, },
        { "pca9555", 16, },
+        { "pca9556", 8, },
        { "pca9557", 8, },
        { "max7310", 8, },
@@ -49,7 +54,9 @@ struct pca953x_chip {
        uint16_t reg_direction;
        struct i2c_client *client;
+        struct pca953x_platform_data *dyn_pdata;
        struct gpio_chip gpio_chip;
+        char **names;
 };
 static int pca953x_write_reg(struct pca953x_chip *chip, int reg, uint16_t val)
@@ -192,8 +199,57 @@ static void pca953x_setup_gpio(struct pca953x_chip *chip, int gpios)
        gc->label = chip->client->name;
        gc->dev = &chip->client->dev;
        gc->owner = THIS_MODULE;
+        gc->names = chip->names;
 }
+/*
+ * Handlers for alternative sources of platform_data
+ */
+#ifdef CONFIG_OF_GPIO
+/*
+ * Translate OpenFirmware node properties into platform_data
+ */
+static struct pca953x_platform_data *
+pca953x_get_alt_pdata(struct i2c_client *client)
+{
+        struct pca953x_platform_data *pdata;
+        struct device_node *node;
+        const uint16_t *val;
+        node = dev_archdata_get_node(&client->dev.archdata);
+        if (node == NULL)
+                return NULL;
+        pdata = kzalloc(sizeof(struct pca953x_platform_data), GFP_KERNEL);
+        if (pdata == NULL) {
+                dev_err(&client->dev, "Unable to allocate platform_data\n");
+                return NULL;
+        }
+        pdata->gpio_base = -1;
+        val = of_get_property(node, "linux,gpio-base", NULL);
+        if (val) {
+                if (*val < 0)
+                        dev_warn(&client->dev,
+                                 "invalid gpio-base in device tree\n");
+                else
+                        pdata->gpio_base = *val;
+        }
+        val = of_get_property(node, "polarity", NULL);
+        if (val)
+                pdata->invert = *val;
+        return pdata;
+}
+#else
+static struct pca953x_platform_data *
+pca953x_get_alt_pdata(struct i2c_client *client)
+{
+        return NULL;
+}
+#endif
 static int __devinit pca953x_probe(struct i2c_client *client,
                                   const struct i2c_device_id *id)
 {
@@ -201,20 +257,32 @@ static int __devinit pca953x_probe(struct i2c_client *client,
        struct pca953x_chip *chip;
        int ret;
+        chip = kzalloc(sizeof(struct pca953x_chip), GFP_KERNEL);
+        if (chip == NULL)
+                return -ENOMEM;
        pdata = client->dev.platform_data;
        if (pdata == NULL) {
-                dev_dbg(&client->dev, "no platform data\n");
+                pdata = pca953x_get_alt_pdata(client);
-                return -EINVAL;
+                /*
+                 * Unlike normal platform_data, this is allocated
+                 * dynamically and must be freed in the driver
+                 */
+                chip->dyn_pdata = pdata;
        }
-        chip = kzalloc(sizeof(struct pca953x_chip), GFP_KERNEL);
+        if (pdata == NULL) {
-        if (chip == NULL)
+                dev_dbg(&client->dev, "no platform data\n");
-                return -ENOMEM;
+                ret = -EINVAL;
+                goto out_failed;
+        }
        chip->client = client;
        chip->gpio_start = pdata->gpio_base;
+        chip->names = pdata->names;
        /* initialize cached registers from their original values.
         * we can't share this chip with another i2c master.
         */
@@ -249,6 +317,7 @@ static int __devinit pca953x_probe(struct i2c_client *client,
        return 0;
 out_failed:
+        kfree(chip->dyn_pdata);
        kfree(chip);
        return ret;
 }
@@ -276,6 +345,7 @@ static int pca953x_remove(struct i2c_client *client)
                return ret;
        }
+        kfree(chip->dyn_pdata);
        kfree(chip);
        return 0;
 }
diff --git a/drivers/gpio/pl061.c b/drivers/gpio/pl061.c
new file mode 100644
index 000000000000..aa8e7cb020d9
--- /dev/null
+++ b/drivers/gpio/pl061.c
@@ -0,0 +1,341 @@
+/*
+ *  linux/drivers/gpio/pl061.c
+ *
+ *  Copyright (C) 2008, 2009 Provigent Ltd.
+ *
+ * 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.
+ *
+ * Driver for the ARM PrimeCell(tm) General Purpose Input/Output (PL061)
+ *
+ * Data sheet: ARM DDI 0190B, September 2000
+ */
+#include <linux/spinlock.h>
+#include <linux/errno.h>
+#include <linux/module.h>
+#include <linux/list.h>
+#include <linux/io.h>
+#include <linux/ioport.h>
+#include <linux/irq.h>
+#include <linux/bitops.h>
+#include <linux/workqueue.h>
+#include <linux/gpio.h>
+#include <linux/device.h>
+#include <linux/amba/bus.h>
+#include <linux/amba/pl061.h>
+#define GPIODIR 0x400
+#define GPIOIS  0x404
+#define GPIOIBE 0x408
+#define GPIOIEV 0x40C
+#define GPIOIE  0x410
+#define GPIORIS 0x414
+#define GPIOMIS 0x418
+#define GPIOIC  0x41C
+#define PL061_GPIO_NR   8
+struct pl061_gpio {
+        /* We use a list of pl061_gpio structs for each trigger IRQ in the main
+         * interrupts controller of the system. We need this to support systems
+         * in which more that one PL061s are connected to the same IRQ. The ISR
+         * interates through this list to find the source of the interrupt.
+         */
+        struct list_head        list;
+        /* Each of the two spinlocks protects a different set of hardware
+         * regiters and data structurs. This decouples the code of the IRQ from
+         * the GPIO code. This also makes the case of a GPIO routine call from
+         * the IRQ code simpler.
+         */
+        spinlock_t              lock;           /* GPIO registers */
+        spinlock_t              irq_lock;       /* IRQ registers */
+        void __iomem            *base;
+        unsigned                irq_base;
+        struct gpio_chip        gc;
+};
+static int pl061_direction_input(struct gpio_chip *gc, unsigned offset)
+{
+        struct pl061_gpio *chip = container_of(gc, struct pl061_gpio, gc);
+        unsigned long flags;
+        unsigned char gpiodir;
+        if (offset >= gc->ngpio)
+                return -EINVAL;
+        spin_lock_irqsave(&chip->lock, flags);
+        gpiodir = readb(chip->base + GPIODIR);
+        gpiodir &= ~(1 << offset);
+        writeb(gpiodir, chip->base + GPIODIR);
+        spin_unlock_irqrestore(&chip->lock, flags);
+        return 0;
+}
+static int pl061_direction_output(struct gpio_chip *gc, unsigned offset,
+                int value)
+{
+        struct pl061_gpio *chip = container_of(gc, struct pl061_gpio, gc);
+        unsigned long flags;
+        unsigned char gpiodir;
+        if (offset >= gc->ngpio)
+                return -EINVAL;
+        spin_lock_irqsave(&chip->lock, flags);
+        writeb(!!value << offset, chip->base + (1 << (offset + 2)));
+        gpiodir = readb(chip->base + GPIODIR);
+        gpiodir |= 1 << offset;
+        writeb(gpiodir, chip->base + GPIODIR);
+        spin_unlock_irqrestore(&chip->lock, flags);
+        return 0;
+}
+static int pl061_get_value(struct gpio_chip *gc, unsigned offset)
+{
+        struct pl061_gpio *chip = container_of(gc, struct pl061_gpio, gc);
+        return !!readb(chip->base + (1 << (offset + 2)));
+}
+static void pl061_set_value(struct gpio_chip *gc, unsigned offset, int value)
+{
+        struct pl061_gpio *chip = container_of(gc, struct pl061_gpio, gc);
+        writeb(!!value << offset, chip->base + (1 << (offset + 2)));
+}
+/*
+ * PL061 GPIO IRQ
+ */
+static void pl061_irq_disable(unsigned irq)
+{
+        struct pl061_gpio *chip = get_irq_chip_data(irq);
+        int offset = irq - chip->irq_base;
+        unsigned long flags;
+        u8 gpioie;
+        spin_lock_irqsave(&chip->irq_lock, flags);
+        gpioie = readb(chip->base + GPIOIE);
+        gpioie &= ~(1 << offset);
+        writeb(gpioie, chip->base + GPIOIE);
+        spin_unlock_irqrestore(&chip->irq_lock, flags);
+}
+static void pl061_irq_enable(unsigned irq)
+{
+        struct pl061_gpio *chip = get_irq_chip_data(irq);
+        int offset = irq - chip->irq_base;
+        unsigned long flags;
+        u8 gpioie;
+        spin_lock_irqsave(&chip->irq_lock, flags);
+        gpioie = readb(chip->base + GPIOIE);
+        gpioie |= 1 << offset;
+        writeb(gpioie, chip->base + GPIOIE);
+        spin_unlock_irqrestore(&chip->irq_lock, flags);
+}
+static int pl061_irq_type(unsigned irq, unsigned trigger)
+{
+        struct pl061_gpio *chip = get_irq_chip_data(irq);
+        int offset = irq - chip->irq_base;
+        unsigned long flags;
+        u8 gpiois, gpioibe, gpioiev;
+        if (offset < 0 || offset > PL061_GPIO_NR)
+                return -EINVAL;
+        spin_lock_irqsave(&chip->irq_lock, flags);
+        gpioiev = readb(chip->base + GPIOIEV);
+        gpiois = readb(chip->base + GPIOIS);
+        if (trigger & (IRQ_TYPE_LEVEL_HIGH | IRQ_TYPE_LEVEL_LOW)) {
+                gpiois |= 1 << offset;
+                if (trigger & IRQ_TYPE_LEVEL_HIGH)
+                        gpioiev |= 1 << offset;
+                else
+                        gpioiev &= ~(1 << offset);
+        } else
+                gpiois &= ~(1 << offset);
+        writeb(gpiois, chip->base + GPIOIS);
+        gpioibe = readb(chip->base + GPIOIBE);
+        if ((trigger & IRQ_TYPE_EDGE_BOTH) == IRQ_TYPE_EDGE_BOTH)
+                gpioibe |= 1 << offset;
+        else {
+                gpioibe &= ~(1 << offset);
+                if (trigger & IRQ_TYPE_EDGE_RISING)
+                        gpioiev |= 1 << offset;
+                else
+                        gpioiev &= ~(1 << offset);
+        }
+        writeb(gpioibe, chip->base + GPIOIBE);
+        writeb(gpioiev, chip->base + GPIOIEV);
+        spin_unlock_irqrestore(&chip->irq_lock, flags);
+        return 0;
+}
+static struct irq_chip pl061_irqchip = {
+        .name           = "GPIO",
+        .enable         = pl061_irq_enable,
+        .disable        = pl061_irq_disable,
+        .set_type       = pl061_irq_type,
+};
+static void pl061_irq_handler(unsigned irq, struct irq_desc *desc)
+{
+        struct list_head *chip_list = get_irq_chip_data(irq);
+        struct list_head *ptr;
+        struct pl061_gpio *chip;
+        desc->chip->ack(irq);
+        list_for_each(ptr, chip_list) {
+                unsigned long pending;
+                int gpio;
+                chip = list_entry(ptr, struct pl061_gpio, list);
+                pending = readb(chip->base + GPIOMIS);
+                writeb(pending, chip->base + GPIOIC);
+                if (pending == 0)
+                        continue;
+                for_each_bit(gpio, &pending, PL061_GPIO_NR)
+                        generic_handle_irq(gpio_to_irq(gpio));
+        }
+        desc->chip->unmask(irq);
+}
+static int __init pl061_probe(struct amba_device *dev, struct amba_id *id)
+{
+        struct pl061_platform_data *pdata;
+        struct pl061_gpio *chip;
+        struct list_head *chip_list;
+        int ret, irq, i;
+        static unsigned long init_irq[BITS_TO_LONGS(NR_IRQS)];
+        pdata = dev->dev.platform_data;
+        if (pdata == NULL)
+                return -ENODEV;
+        chip = kzalloc(sizeof(*chip), GFP_KERNEL);
+        if (chip == NULL)
+                return -ENOMEM;
+        if (!request_mem_region(dev->res.start,
+                                resource_size(&dev->res), "pl061")) {
+                ret = -EBUSY;
+                goto free_mem;
+        }
+        chip->base = ioremap(dev->res.start, resource_size(&dev->res));
+        if (chip->base == NULL) {
+                ret = -ENOMEM;
+                goto release_region;
+        }
+        spin_lock_init(&chip->lock);
+        spin_lock_init(&chip->irq_lock);
+        INIT_LIST_HEAD(&chip->list);
+        chip->gc.direction_input = pl061_direction_input;
+        chip->gc.direction_output = pl061_direction_output;
+        chip->gc.get = pl061_get_value;
+        chip->gc.set = pl061_set_value;
+        chip->gc.base = pdata->gpio_base;
+        chip->gc.ngpio = PL061_GPIO_NR;
+        chip->gc.label = dev_name(&dev->dev);
+        chip->gc.dev = &dev->dev;
+        chip->gc.owner = THIS_MODULE;
+        chip->irq_base = pdata->irq_base;
+        ret = gpiochip_add(&chip->gc);
+        if (ret)
+                goto iounmap;
+        /*
+         * irq_chip support
+         */
+        if (chip->irq_base == (unsigned) -1)
+                return 0;
+        writeb(0, chip->base + GPIOIE); /* disable irqs */
+        irq = dev->irq[0];
+        if (irq < 0) {
+                ret = -ENODEV;
+                goto iounmap;
+        }
+        set_irq_chained_handler(irq, pl061_irq_handler);
+        if (!test_and_set_bit(irq, init_irq)) { /* list initialized? */
+                chip_list = kmalloc(sizeof(*chip_list), GFP_KERNEL);
+                if (chip_list == NULL) {
+                        ret = -ENOMEM;
+                        goto iounmap;
+                }
+                INIT_LIST_HEAD(chip_list);
+                set_irq_chip_data(irq, chip_list);
+        } else
+                chip_list = get_irq_chip_data(irq);
+        list_add(&chip->list, chip_list);
+        for (i = 0; i < PL061_GPIO_NR; i++) {
+                if (pdata->directions & (1 << i))
+                        pl061_direction_output(&chip->gc, i,
+                                        pdata->values & (1 << i));
+                else
+                        pl061_direction_input(&chip->gc, i);
+                set_irq_chip(i+chip->irq_base, &pl061_irqchip);
+                set_irq_handler(i+chip->irq_base, handle_simple_irq);
+                set_irq_flags(i+chip->irq_base, IRQF_VALID);
+                set_irq_chip_data(i+chip->irq_base, chip);
+        }
+        return 0;
+iounmap:
+        iounmap(chip->base);
+release_region:
+        release_mem_region(dev->res.start, resource_size(&dev->res));
+free_mem:
+        kfree(chip);
+        return ret;
+}
+static struct amba_id pl061_ids[] __initdata = {
+        {
+                .id     = 0x00041061,
+                .mask   = 0x000fffff,
+        },
+        { 0, 0 },
+};
+static struct amba_driver pl061_gpio_driver = {
+        .drv = {
+                .name   = "pl061_gpio",
+        },
+        .id_table       = pl061_ids,
+        .probe          = pl061_probe,
+};
+static int __init pl061_gpio_init(void)
+{
+        return amba_driver_register(&pl061_gpio_driver);
+}
+subsys_initcall(pl061_gpio_init);
+MODULE_AUTHOR("Baruch Siach <baruch@tkos.co.il>");
+MODULE_DESCRIPTION("PL061 GPIO driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/isdn/i4l/isdn_net.c b/drivers/isdn/i4l/isdn_net.c
index 34d54e7281fd..de4aad076ebc 100644
--- a/drivers/isdn/i4l/isdn_net.c
+++ b/drivers/isdn/i4l/isdn_net.c
@@ -1300,7 +1300,7 @@ isdn_net_start_xmit(struct sk_buff *skb, struct net_device *ndev)
                                netif_stop_queue(ndev);
                }
        }
-        return 1;
+        return NETDEV_TX_BUSY;
 }
 /*
diff --git a/drivers/md/faulty.c b/drivers/md/faulty.c
index 8695809b24b0..87d88dbb667f 100644
--- a/drivers/md/faulty.c
+++ b/drivers/md/faulty.c
@@ -255,14 +255,14 @@ static void status(struct seq_file *seq, mddev_t *mddev)
 }
-static int reconfig(mddev_t *mddev, int layout, int chunk_size)
+static int reshape(mddev_t *mddev)
 {
-        int mode = layout & ModeMask;
+        int mode = mddev->new_layout & ModeMask;
-        int count = layout >> ModeShift;
+        int count = mddev->new_layout >> ModeShift;
        conf_t *conf = mddev->private;
-        if (chunk_size != -1)
+        if (mddev->new_layout < 0)
-                return -EINVAL;
+                return 0;
        /* new layout */
        if (mode == ClearFaults)
@@ -279,6 +279,7 @@ static int reconfig(mddev_t *mddev, int layout, int chunk_size)
                atomic_set(&conf->counters[mode], count);
        } else
                return -EINVAL;
+        mddev->new_layout = -1;
        mddev->layout = -1; /* makes sure further changes come through */
        return 0;
 }
@@ -298,8 +299,12 @@ static int run(mddev_t *mddev)
 {
        mdk_rdev_t *rdev;
        int i;
+        conf_t *conf;
+        if (md_check_no_bitmap(mddev))
+                return -EINVAL;
-        conf_t *conf = kmalloc(sizeof(*conf), GFP_KERNEL);
+        conf = kmalloc(sizeof(*conf), GFP_KERNEL);
        if (!conf)
                return -ENOMEM;
@@ -315,7 +320,7 @@ static int run(mddev_t *mddev)
        md_set_array_sectors(mddev, faulty_size(mddev, 0, 0));
        mddev->private = conf;
-        reconfig(mddev, mddev->layout, -1);
+        reshape(mddev);
        return 0;
 }
@@ -338,7 +343,7 @@ static struct mdk_personality faulty_personality =
        .run            = run,
        .stop           = stop,
        .status         = status,
-        .reconfig       = reconfig,
+        .check_reshape  = reshape,
        .size           = faulty_size,
 };
diff --git a/drivers/md/linear.c b/drivers/md/linear.c
index 64f1f3e046e0..15c8b7b25a9b 100644
--- a/drivers/md/linear.c
+++ b/drivers/md/linear.c
@@ -27,19 +27,27 @@
 */
 static inline dev_info_t *which_dev(mddev_t *mddev, sector_t sector)
 {
-        dev_info_t *hash;
+        int lo, mid, hi;
-        linear_conf_t *conf = mddev_to_conf(mddev);
+        linear_conf_t *conf;
-        sector_t idx = sector >> conf->sector_shift;
+        lo = 0;
+        hi = mddev->raid_disks - 1;
+        conf = rcu_dereference(mddev->private);
        /*
-         * sector_div(a,b) returns the remainer and sets a to a/b
+         * Binary Search
         */
-        (void)sector_div(idx, conf->spacing);
-        hash = conf->hash_table[idx];
-        while (sector >= hash->num_sectors + hash->start_sector)
+        while (hi > lo) {
-                hash++;
-        return hash;
+                mid = (hi + lo) / 2;
+                if (sector < conf->disks[mid].end_sector)
+                        hi = mid;
+                else
+                        lo = mid + 1;
+        }
+        return conf->disks + lo;
 }
 /**
@@ -59,8 +67,10 @@ static int linear_mergeable_bvec(struct request_queue *q,
        unsigned long maxsectors, bio_sectors = bvm->bi_size >> 9;
        sector_t sector = bvm->bi_sector + get_start_sect(bvm->bi_bdev);
+        rcu_read_lock();
        dev0 = which_dev(mddev, sector);
-        maxsectors = dev0->num_sectors - (sector - dev0->start_sector);
+        maxsectors = dev0->end_sector - sector;
+        rcu_read_unlock();
        if (maxsectors < bio_sectors)
                maxsectors = 0;
@@ -79,46 +89,57 @@ static int linear_mergeable_bvec(struct request_queue *q,
 static void linear_unplug(struct request_queue *q)
 {
        mddev_t *mddev = q->queuedata;
-        linear_conf_t *conf = mddev_to_conf(mddev);
+        linear_conf_t *conf;
        int i;
+        rcu_read_lock();
+        conf = rcu_dereference(mddev->private);
        for (i=0; i < mddev->raid_disks; i++) {
                struct request_queue *r_queue = bdev_get_queue(conf->disks[i].rdev->bdev);
                blk_unplug(r_queue);
        }
+        rcu_read_unlock();
 }
 static int linear_congested(void *data, int bits)
 {
        mddev_t *mddev = data;
-        linear_conf_t *conf = mddev_to_conf(mddev);
+        linear_conf_t *conf;
        int i, ret = 0;
+        rcu_read_lock();
+        conf = rcu_dereference(mddev->private);
        for (i = 0; i < mddev->raid_disks && !ret ; i++) {
                struct request_queue *q = bdev_get_queue(conf->disks[i].rdev->bdev);
                ret |= bdi_congested(&q->backing_dev_info, bits);
        }
+        rcu_read_unlock();
        return ret;
 }
 static sector_t linear_size(mddev_t *mddev, sector_t sectors, int raid_disks)
 {
-        linear_conf_t *conf = mddev_to_conf(mddev);
+        linear_conf_t *conf;
+        sector_t array_sectors;
+        rcu_read_lock();
+        conf = rcu_dereference(mddev->private);
        WARN_ONCE(sectors || raid_disks,
                  "%s does not support generic reshape\n", __func__);
+        array_sectors = conf->array_sectors;
+        rcu_read_unlock();
-        return conf->array_sectors;
+        return array_sectors;
 }
 static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks)
 {
        linear_conf_t *conf;
-        dev_info_t **table;
        mdk_rdev_t *rdev;
-        int i, nb_zone, cnt;
+        int i, cnt;
-        sector_t min_sectors;
-        sector_t curr_sector;
        conf = kzalloc (sizeof (*conf) + raid_disks*sizeof(dev_info_t),
                        GFP_KERNEL);
@@ -131,6 +152,7 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks)
        list_for_each_entry(rdev, &mddev->disks, same_set) {
                int j = rdev->raid_disk;
                dev_info_t *disk = conf->disks + j;
+                sector_t sectors;
                if (j < 0 || j >= raid_disks || disk->rdev) {
                        printk("linear: disk numbering problem. Aborting!\n");
@@ -138,6 +160,11 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks)
                }
                disk->rdev = rdev;
+                if (mddev->chunk_sectors) {
+                        sectors = rdev->sectors;
+                        sector_div(sectors, mddev->chunk_sectors);
+                        rdev->sectors = sectors * mddev->chunk_sectors;
+                }
                blk_queue_stack_limits(mddev->queue,
                                       rdev->bdev->bd_disk->queue);
@@ -149,102 +176,24 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks)
                    queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
                        blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
-                disk->num_sectors = rdev->sectors;
                conf->array_sectors += rdev->sectors;
                cnt++;
        }
        if (cnt != raid_disks) {
                printk("linear: not enough drives present. Aborting!\n");
                goto out;
        }
-        min_sectors = conf->array_sectors;
-        sector_div(min_sectors, PAGE_SIZE/sizeof(struct dev_info *));
-        if (min_sectors == 0)
-                min_sectors = 1;
-        /* min_sectors is the minimum spacing that will fit the hash
-         * table in one PAGE.  This may be much smaller than needed.
-         * We find the smallest non-terminal set of consecutive devices
-         * that is larger than min_sectors and use the size of that as
-         * the actual spacing
-         */
-        conf->spacing = conf->array_sectors;
-        for (i=0; i < cnt-1 ; i++) {
-                sector_t tmp = 0;
-                int j;
-                for (j = i; j < cnt - 1 && tmp < min_sectors; j++)
-                        tmp += conf->disks[j].num_sectors;
-                if (tmp >= min_sectors && tmp < conf->spacing)
-                        conf->spacing = tmp;
-        }
-        /* spacing may be too large for sector_div to work with,
-         * so we might need to pre-shift
-         */
-        conf->sector_shift = 0;
-        if (sizeof(sector_t) > sizeof(u32)) {
-                sector_t space = conf->spacing;
-                while (space > (sector_t)(~(u32)0)) {
-                        space >>= 1;
-                        conf->sector_shift++;
-                }
-        }
        /*
-         * This code was restructured to work around a gcc-2.95.3 internal
+         * Here we calculate the device offsets.
-         * compiler error.  Alter it with care.
         */
-        {
+        conf->disks[0].end_sector = conf->disks[0].rdev->sectors;
-                sector_t sz;
-                unsigned round;
-                unsigned long base;
-                sz = conf->array_sectors >> conf->sector_shift;
-                sz += 1; /* force round-up */
-                base = conf->spacing >> conf->sector_shift;
-                round = sector_div(sz, base);
-                nb_zone = sz + (round ? 1 : 0);
-        }
-        BUG_ON(nb_zone > PAGE_SIZE / sizeof(struct dev_info *));
-        conf->hash_table = kmalloc (sizeof (struct dev_info *) * nb_zone,
-                                        GFP_KERNEL);
-        if (!conf->hash_table)
-                goto out;
-        /*
-         * Here we generate the linear hash table
-         * First calculate the device offsets.
-         */
-        conf->disks[0].start_sector = 0;
        for (i = 1; i < raid_disks; i++)
-                conf->disks[i].start_sector =
+                conf->disks[i].end_sector =
-                        conf->disks[i-1].start_sector +
+                        conf->disks[i-1].end_sector +
-                        conf->disks[i-1].num_sectors;
+                        conf->disks[i].rdev->sectors;
-        table = conf->hash_table;
-        i = 0;
-        for (curr_sector = 0;
-             curr_sector < conf->array_sectors;
-             curr_sector += conf->spacing) {
-                while (i < raid_disks-1 &&
-                       curr_sector >= conf->disks[i+1].start_sector)
-                        i++;
-                *table ++ = conf->disks + i;
-        }
-        if (conf->sector_shift) {
-                conf->spacing >>= conf->sector_shift;
-                /* round spacing up so that when we divide by it,
-                 * we err on the side of "too-low", which is safest.
-                 */
-                conf->spacing++;
-        }
-        BUG_ON(table - conf->hash_table > nb_zone);
        return conf;
@@ -257,6 +206,8 @@ static int linear_run (mddev_t *mddev)
 {
        linear_conf_t *conf;
+        if (md_check_no_bitmap(mddev))
+                return -EINVAL;
        mddev->queue->queue_lock = &mddev->queue->__queue_lock;
        conf = linear_conf(mddev, mddev->raid_disks);
@@ -272,6 +223,12 @@ static int linear_run (mddev_t *mddev)
        return 0;
 }
+static void free_conf(struct rcu_head *head)
+{
+        linear_conf_t *conf = container_of(head, linear_conf_t, rcu);
+        kfree(conf);
+}
 static int linear_add(mddev_t *mddev, mdk_rdev_t *rdev)
 {
        /* Adding a drive to a linear array allows the array to grow.
@@ -282,7 +239,7 @@ static int linear_add(mddev_t *mddev, mdk_rdev_t *rdev)
         * The current one is never freed until the array is stopped.
         * This avoids races.
         */
-        linear_conf_t *newconf;
+        linear_conf_t *newconf, *oldconf;
        if (rdev->saved_raid_disk != mddev->raid_disks)
                return -EINVAL;
@@ -294,25 +251,29 @@ static int linear_add(mddev_t *mddev, mdk_rdev_t *rdev)
        if (!newconf)
                return -ENOMEM;
-        newconf->prev = mddev_to_conf(mddev);
+        oldconf = rcu_dereference(mddev->private);
-        mddev->private = newconf;
        mddev->raid_disks++;
+        rcu_assign_pointer(mddev->private, newconf);
        md_set_array_sectors(mddev, linear_size(mddev, 0, 0));
        set_capacity(mddev->gendisk, mddev->array_sectors);
+        call_rcu(&oldconf->rcu, free_conf);
        return 0;
 }
 static int linear_stop (mddev_t *mddev)
 {
-        linear_conf_t *conf = mddev_to_conf(mddev);
+        linear_conf_t *conf = mddev->private;
-  
+        /*
+         * We do not require rcu protection here since
+         * we hold reconfig_mutex for both linear_add and
+         * linear_stop, so they cannot race.
+         * We should make sure any old 'conf's are properly
+         * freed though.
+         */
+        rcu_barrier();
        blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
-        do {
+        kfree(conf);
-                linear_conf_t *t = conf->prev;
-                kfree(conf->hash_table);
-                kfree(conf);
-                conf = t;
-        } while (conf);
        return 0;
 }
@@ -322,6 +283,7 @@ static int linear_make_request (struct request_queue *q, struct bio *bio)
        const int rw = bio_data_dir(bio);
        mddev_t *mddev = q->queuedata;
        dev_info_t *tmp_dev;
+        sector_t start_sector;
        int cpu;
        if (unlikely(bio_barrier(bio))) {
@@ -335,33 +297,36 @@ static int linear_make_request (struct request_queue *q, struct bio *bio)
                      bio_sectors(bio));
        part_stat_unlock();
+        rcu_read_lock();
        tmp_dev = which_dev(mddev, bio->bi_sector);
-    
+        start_sector = tmp_dev->end_sector - tmp_dev->rdev->sectors;
-        if (unlikely(bio->bi_sector >= (tmp_dev->num_sectors +
-                                        tmp_dev->start_sector)
-                     || (bio->bi_sector <
+        if (unlikely(bio->bi_sector >= (tmp_dev->end_sector)
-                         tmp_dev->start_sector))) {
+                     || (bio->bi_sector < start_sector))) {
                char b[BDEVNAME_SIZE];
                printk("linear_make_request: Sector %llu out of bounds on "
                        "dev %s: %llu sectors, offset %llu\n",
                        (unsigned long long)bio->bi_sector,
                        bdevname(tmp_dev->rdev->bdev, b),
-                        (unsigned long long)tmp_dev->num_sectors,
+                        (unsigned long long)tmp_dev->rdev->sectors,
-                        (unsigned long long)tmp_dev->start_sector);
+                        (unsigned long long)start_sector);
+                rcu_read_unlock();
                bio_io_error(bio);
                return 0;
        }
        if (unlikely(bio->bi_sector + (bio->bi_size >> 9) >
-                     tmp_dev->start_sector + tmp_dev->num_sectors)) {
+                     tmp_dev->end_sector)) {
                /* This bio crosses a device boundary, so we have to
                 * split it.
                 */
                struct bio_pair *bp;
+                sector_t end_sector = tmp_dev->end_sector;
+                rcu_read_unlock();
-                bp = bio_split(bio,
+                bp = bio_split(bio, end_sector - bio->bi_sector);
-                               tmp_dev->start_sector + tmp_dev->num_sectors
-                               - bio->bi_sector);
                if (linear_make_request(q, &bp->bio1))
                        generic_make_request(&bp->bio1);
@@ -372,8 +337,9 @@ static int linear_make_request (struct request_queue *q, struct bio *bio)
        }
                    
        bio->bi_bdev = tmp_dev->rdev->bdev;
-        bio->bi_sector = bio->bi_sector - tmp_dev->start_sector
+        bio->bi_sector = bio->bi_sector - start_sector
                + tmp_dev->rdev->data_offset;
+        rcu_read_unlock();
        return 1;
 }
@@ -381,7 +347,7 @@ static int linear_make_request (struct request_queue *q, struct bio *bio)
 static void linear_status (struct seq_file *seq, mddev_t *mddev)
 {
-        seq_printf(seq, " %dk rounding", mddev->chunk_size/1024);
+        seq_printf(seq, " %dk rounding", mddev->chunk_sectors / 2);
 }
diff --git a/drivers/md/linear.h b/drivers/md/linear.h
index bf8179587f95..0ce29b61605a 100644
--- a/drivers/md/linear.h
+++ b/drivers/md/linear.h
@@ -3,27 +3,19 @@
 struct dev_info {
        mdk_rdev_t      *rdev;
-        sector_t        num_sectors;
+        sector_t        end_sector;
-        sector_t        start_sector;
 };
 typedef struct dev_info dev_info_t;
 struct linear_private_data
 {
-        struct linear_private_data *prev;       /* earlier version */
-        dev_info_t              **hash_table;
-        sector_t                spacing;
        sector_t                array_sectors;
-        int                     sector_shift;   /* shift before dividing
-                                                 * by spacing
-                                                 */
        dev_info_t              disks[0];
+        struct rcu_head         rcu;
 };
 typedef struct linear_private_data linear_conf_t;
-#define mddev_to_conf(mddev) ((linear_conf_t *) mddev->private)
 #endif
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 20f6ac338349..09be637d52cb 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -440,15 +440,6 @@ static inline sector_t calc_dev_sboffset(struct block_device *bdev)
        return MD_NEW_SIZE_SECTORS(num_sectors);
 }
-static sector_t calc_num_sectors(mdk_rdev_t *rdev, unsigned chunk_size)
-{
-        sector_t num_sectors = rdev->sb_start;
-        if (chunk_size)
-                num_sectors &= ~((sector_t)chunk_size/512 - 1);
-        return num_sectors;
-}
 static int alloc_disk_sb(mdk_rdev_t * rdev)
 {
        if (rdev->sb_page)
@@ -745,6 +736,24 @@ struct super_type  {
 };
 /*
+ * Check that the given mddev has no bitmap.
+ *
+ * This function is called from the run method of all personalities that do not
+ * support bitmaps. It prints an error message and returns non-zero if mddev
+ * has a bitmap. Otherwise, it returns 0.
+ *
+ */
+int md_check_no_bitmap(mddev_t *mddev)
+{
+        if (!mddev->bitmap_file && !mddev->bitmap_offset)
+                return 0;
+        printk(KERN_ERR "%s: bitmaps are not supported for %s\n",
+                mdname(mddev), mddev->pers->name);
+        return 1;
+}
+EXPORT_SYMBOL(md_check_no_bitmap);
+/*
 * load_super for 0.90.0 
 */
 static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
@@ -797,17 +806,6 @@ static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version
        rdev->data_offset = 0;
        rdev->sb_size = MD_SB_BYTES;
-        if (sb->state & (1<<MD_SB_BITMAP_PRESENT)) {
-                if (sb->level != 1 && sb->level != 4
-                    && sb->level != 5 && sb->level != 6
-                    && sb->level != 10) {
-                        /* FIXME use a better test */
-                        printk(KERN_WARNING
-                               "md: bitmaps not supported for this level.\n");
-                        goto abort;
-                }
-        }
        if (sb->level == LEVEL_MULTIPATH)
                rdev->desc_nr = -1;
        else
@@ -836,7 +834,7 @@ static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version
                else 
                        ret = 0;
        }
-        rdev->sectors = calc_num_sectors(rdev, sb->chunk_size);
+        rdev->sectors = rdev->sb_start;
        if (rdev->sectors < sb->size * 2 && sb->level > 1)
                /* "this cannot possibly happen" ... */
@@ -866,7 +864,7 @@ static int super_90_validate(mddev_t *mddev, mdk_rdev_t *rdev)
                mddev->minor_version = sb->minor_version;
                mddev->patch_version = sb->patch_version;
                mddev->external = 0;
-                mddev->chunk_size = sb->chunk_size;
+                mddev->chunk_sectors = sb->chunk_size >> 9;
                mddev->ctime = sb->ctime;
                mddev->utime = sb->utime;
                mddev->level = sb->level;
@@ -883,13 +881,13 @@ static int super_90_validate(mddev_t *mddev, mdk_rdev_t *rdev)
                        mddev->delta_disks = sb->delta_disks;
                        mddev->new_level = sb->new_level;
                        mddev->new_layout = sb->new_layout;
-                        mddev->new_chunk = sb->new_chunk;
+                        mddev->new_chunk_sectors = sb->new_chunk >> 9;
                } else {
                        mddev->reshape_position = MaxSector;
                        mddev->delta_disks = 0;
                        mddev->new_level = mddev->level;
                        mddev->new_layout = mddev->layout;
-                        mddev->new_chunk = mddev->chunk_size;
+                        mddev->new_chunk_sectors = mddev->chunk_sectors;
                }
                if (sb->state & (1<<MD_SB_CLEAN))
@@ -1004,7 +1002,7 @@ static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev)
                sb->new_level = mddev->new_level;
                sb->delta_disks = mddev->delta_disks;
                sb->new_layout = mddev->new_layout;
-                sb->new_chunk = mddev->new_chunk;
+                sb->new_chunk = mddev->new_chunk_sectors << 9;
        }
        mddev->minor_version = sb->minor_version;
        if (mddev->in_sync)
@@ -1018,7 +1016,7 @@ static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev)
                sb->recovery_cp = 0;
        sb->layout = mddev->layout;
-        sb->chunk_size = mddev->chunk_size;
+        sb->chunk_size = mddev->chunk_sectors << 9;
        if (mddev->bitmap && mddev->bitmap_file == NULL)
                sb->state |= (1<<MD_SB_BITMAP_PRESENT);
@@ -1185,17 +1183,6 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
                       bdevname(rdev->bdev,b));
                return -EINVAL;
        }
-        if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET)) {
-                if (sb->level != cpu_to_le32(1) &&
-                    sb->level != cpu_to_le32(4) &&
-                    sb->level != cpu_to_le32(5) &&
-                    sb->level != cpu_to_le32(6) &&
-                    sb->level != cpu_to_le32(10)) {
-                        printk(KERN_WARNING
-                               "md: bitmaps not supported for this level.\n");
-                        return -EINVAL;
-                }
-        }
        rdev->preferred_minor = 0xffff;
        rdev->data_offset = le64_to_cpu(sb->data_offset);
@@ -1248,9 +1235,6 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
        if (rdev->sectors < le64_to_cpu(sb->data_size))
                return -EINVAL;
        rdev->sectors = le64_to_cpu(sb->data_size);
-        if (le32_to_cpu(sb->chunksize))
-                rdev->sectors &= ~((sector_t)le32_to_cpu(sb->chunksize) - 1);
        if (le64_to_cpu(sb->size) > rdev->sectors)
                return -EINVAL;
        return ret;
@@ -1271,7 +1255,7 @@ static int super_1_validate(mddev_t *mddev, mdk_rdev_t *rdev)
                mddev->major_version = 1;
                mddev->patch_version = 0;
                mddev->external = 0;
-                mddev->chunk_size = le32_to_cpu(sb->chunksize) << 9;
+                mddev->chunk_sectors = le32_to_cpu(sb->chunksize);
                mddev->ctime = le64_to_cpu(sb->ctime) & ((1ULL << 32)-1);
                mddev->utime = le64_to_cpu(sb->utime) & ((1ULL << 32)-1);
                mddev->level = le32_to_cpu(sb->level);
@@ -1297,13 +1281,13 @@ static int super_1_validate(mddev_t *mddev, mdk_rdev_t *rdev)
                        mddev->delta_disks = le32_to_cpu(sb->delta_disks);
                        mddev->new_level = le32_to_cpu(sb->new_level);
                        mddev->new_layout = le32_to_cpu(sb->new_layout);
-                        mddev->new_chunk = le32_to_cpu(sb->new_chunk)<<9;
+                        mddev->new_chunk_sectors = le32_to_cpu(sb->new_chunk);
                } else {
                        mddev->reshape_position = MaxSector;
                        mddev->delta_disks = 0;
                        mddev->new_level = mddev->level;
                        mddev->new_layout = mddev->layout;
-                        mddev->new_chunk = mddev->chunk_size;
+                        mddev->new_chunk_sectors = mddev->chunk_sectors;
                }
        } else if (mddev->pers == NULL) {
@@ -1375,7 +1359,7 @@ static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
        sb->raid_disks = cpu_to_le32(mddev->raid_disks);
        sb->size = cpu_to_le64(mddev->dev_sectors);
-        sb->chunksize = cpu_to_le32(mddev->chunk_size >> 9);
+        sb->chunksize = cpu_to_le32(mddev->chunk_sectors);
        sb->level = cpu_to_le32(mddev->level);
        sb->layout = cpu_to_le32(mddev->layout);
@@ -1402,7 +1386,7 @@ static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
                sb->new_layout = cpu_to_le32(mddev->new_layout);
                sb->delta_disks = cpu_to_le32(mddev->delta_disks);
                sb->new_level = cpu_to_le32(mddev->new_level);
-                sb->new_chunk = cpu_to_le32(mddev->new_chunk>>9);
+                sb->new_chunk = cpu_to_le32(mddev->new_chunk_sectors);
        }
        max_dev = 0;
@@ -1897,6 +1881,7 @@ static void md_update_sb(mddev_t * mddev, int force_change)
        int sync_req;
        int nospares = 0;
+        mddev->utime = get_seconds();
        if (mddev->external)
                return;
 repeat:
@@ -1926,7 +1911,6 @@ repeat:
                nospares = 0;
        sync_req = mddev->in_sync;
-        mddev->utime = get_seconds();
        /* If this is just a dirty<->clean transition, and the array is clean
         * and 'events' is odd, we can roll back to the previous clean state */
@@ -2597,15 +2581,6 @@ static void analyze_sbs(mddev_t * mddev)
                        clear_bit(In_sync, &rdev->flags);
                }
        }
-        if (mddev->recovery_cp != MaxSector &&
-            mddev->level >= 1)
-                printk(KERN_ERR "md: %s: raid array is not clean"
-                       " -- starting background reconstruction\n",
-                       mdname(mddev));
 }
 static void md_safemode_timeout(unsigned long data);
@@ -2746,7 +2721,7 @@ level_store(mddev_t *mddev, const char *buf, size_t len)
        if (IS_ERR(priv)) {
                mddev->new_level = mddev->level;
                mddev->new_layout = mddev->layout;
-                mddev->new_chunk = mddev->chunk_size;
+                mddev->new_chunk_sectors = mddev->chunk_sectors;
                mddev->raid_disks -= mddev->delta_disks;
                mddev->delta_disks = 0;
                module_put(pers->owner);
@@ -2764,7 +2739,7 @@ level_store(mddev_t *mddev, const char *buf, size_t len)
        strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
        mddev->level = mddev->new_level;
        mddev->layout = mddev->new_layout;
-        mddev->chunk_size = mddev->new_chunk;
+        mddev->chunk_sectors = mddev->new_chunk_sectors;
        mddev->delta_disks = 0;
        pers->run(mddev);
        mddev_resume(mddev);
@@ -2800,11 +2775,14 @@ layout_store(mddev_t *mddev, const char *buf, size_t len)
        if (mddev->pers) {
                int err;
-                if (mddev->pers->reconfig == NULL)
+                if (mddev->pers->check_reshape == NULL)
                        return -EBUSY;
-                err = mddev->pers->reconfig(mddev, n, -1);
+                mddev->new_layout = n;
-                if (err)
+                err = mddev->pers->check_reshape(mddev);
+                if (err) {
+                        mddev->new_layout = mddev->layout;
                        return err;
+                }
        } else {
                mddev->new_layout = n;
                if (mddev->reshape_position == MaxSector)
@@ -2857,10 +2835,11 @@ static ssize_t
 chunk_size_show(mddev_t *mddev, char *page)
 {
        if (mddev->reshape_position != MaxSector &&
-            mddev->chunk_size != mddev->new_chunk)
+            mddev->chunk_sectors != mddev->new_chunk_sectors)
-                return sprintf(page, "%d (%d)\n", mddev->new_chunk,
+                return sprintf(page, "%d (%d)\n",
-                               mddev->chunk_size);
+                               mddev->new_chunk_sectors << 9,
-        return sprintf(page, "%d\n", mddev->chunk_size);
+                               mddev->chunk_sectors << 9);
+        return sprintf(page, "%d\n", mddev->chunk_sectors << 9);
 }
 static ssize_t
@@ -2874,15 +2853,18 @@ chunk_size_store(mddev_t *mddev, const char *buf, size_t len)
        if (mddev->pers) {
                int err;
-                if (mddev->pers->reconfig == NULL)
+                if (mddev->pers->check_reshape == NULL)
                        return -EBUSY;
-                err = mddev->pers->reconfig(mddev, -1, n);
+                mddev->new_chunk_sectors = n >> 9;
-                if (err)
+                err = mddev->pers->check_reshape(mddev);
+                if (err) {
+                        mddev->new_chunk_sectors = mddev->chunk_sectors;
                        return err;
+                }
        } else {
-                mddev->new_chunk = n;
+                mddev->new_chunk_sectors = n >> 9;
                if (mddev->reshape_position == MaxSector)
-                        mddev->chunk_size = n;
+                        mddev->chunk_sectors = n >> 9;
        }
        return len;
 }
@@ -3527,8 +3509,9 @@ min_sync_store(mddev_t *mddev, const char *buf, size_t len)
                return -EBUSY;
        /* Must be a multiple of chunk_size */
-        if (mddev->chunk_size) {
+        if (mddev->chunk_sectors) {
-                if (min & (sector_t)((mddev->chunk_size>>9)-1))
+                sector_t temp = min;
+                if (sector_div(temp, mddev->chunk_sectors))
                        return -EINVAL;
        }
        mddev->resync_min = min;
@@ -3564,8 +3547,9 @@ max_sync_store(mddev_t *mddev, const char *buf, size_t len)
                        return -EBUSY;
                /* Must be a multiple of chunk_size */
-                if (mddev->chunk_size) {
+                if (mddev->chunk_sectors) {
-                        if (max & (sector_t)((mddev->chunk_size>>9)-1))
+                        sector_t temp = max;
+                        if (sector_div(temp, mddev->chunk_sectors))
                                return -EINVAL;
                }
                mddev->resync_max = max;
@@ -3656,7 +3640,7 @@ reshape_position_store(mddev_t *mddev, const char *buf, size_t len)
        mddev->delta_disks = 0;
        mddev->new_level = mddev->level;
        mddev->new_layout = mddev->layout;
-        mddev->new_chunk = mddev->chunk_size;
+        mddev->new_chunk_sectors = mddev->chunk_sectors;
        return len;
 }
@@ -3976,11 +3960,9 @@ static int start_dirty_degraded;
 static int do_md_run(mddev_t * mddev)
 {
        int err;
-        int chunk_size;
        mdk_rdev_t *rdev;
        struct gendisk *disk;
        struct mdk_personality *pers;
-        char b[BDEVNAME_SIZE];
        if (list_empty(&mddev->disks))
                /* cannot run an array with no devices.. */
@@ -3998,38 +3980,6 @@ static int do_md_run(mddev_t * mddev)
                analyze_sbs(mddev);
        }
-        chunk_size = mddev->chunk_size;
-        if (chunk_size) {
-                if (chunk_size > MAX_CHUNK_SIZE) {
-                        printk(KERN_ERR "too big chunk_size: %d > %d\n",
-                                chunk_size, MAX_CHUNK_SIZE);
-                        return -EINVAL;
-                }
-                /*
-                 * chunk-size has to be a power of 2
-                 */
-                if ( (1 << ffz(~chunk_size)) != chunk_size) {
-                        printk(KERN_ERR "chunk_size of %d not valid\n", chunk_size);
-                        return -EINVAL;
-                }
-                /* devices must have minimum size of one chunk */
-                list_for_each_entry(rdev, &mddev->disks, same_set) {
-                        if (test_bit(Faulty, &rdev->flags))
-                                continue;
-                        if (rdev->sectors < chunk_size / 512) {
-                                printk(KERN_WARNING
-                                        "md: Dev %s smaller than chunk_size:"
-                                        " %llu < %d\n",
-                                        bdevname(rdev->bdev,b),
-                                        (unsigned long long)rdev->sectors,
-                                        chunk_size / 512);
-                                return -EINVAL;
-                        }
-                }
-        }
        if (mddev->level != LEVEL_NONE)
                request_module("md-level-%d", mddev->level);
        else if (mddev->clevel[0])
@@ -4405,7 +4355,7 @@ static int do_md_stop(mddev_t * mddev, int mode, int is_open)
                mddev->flags = 0;
                mddev->ro = 0;
                mddev->metadata_type[0] = 0;
-                mddev->chunk_size = 0;
+                mddev->chunk_sectors = 0;
                mddev->ctime = mddev->utime = 0;
                mddev->layout = 0;
                mddev->max_disks = 0;
@@ -4413,7 +4363,7 @@ static int do_md_stop(mddev_t * mddev, int mode, int is_open)
                mddev->delta_disks = 0;
                mddev->new_level = LEVEL_NONE;
                mddev->new_layout = 0;
-                mddev->new_chunk = 0;
+                mddev->new_chunk_sectors = 0;
                mddev->curr_resync = 0;
                mddev->resync_mismatches = 0;
                mddev->suspend_lo = mddev->suspend_hi = 0;
@@ -4618,7 +4568,7 @@ static int get_array_info(mddev_t * mddev, void __user * arg)
        info.spare_disks   = spare;
        info.layout        = mddev->layout;
-        info.chunk_size    = mddev->chunk_size;
+        info.chunk_size    = mddev->chunk_sectors << 9;
        if (copy_to_user(arg, &info, sizeof(info)))
                return -EFAULT;
@@ -4843,7 +4793,7 @@ static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info)
                        rdev->sb_start = rdev->bdev->bd_inode->i_size / 512;
                } else 
                        rdev->sb_start = calc_dev_sboffset(rdev->bdev);
-                rdev->sectors = calc_num_sectors(rdev, mddev->chunk_size);
+                rdev->sectors = rdev->sb_start;
                err = bind_rdev_to_array(rdev, mddev);
                if (err) {
@@ -4913,7 +4863,7 @@ static int hot_add_disk(mddev_t * mddev, dev_t dev)
        else
                rdev->sb_start = rdev->bdev->bd_inode->i_size / 512;
-        rdev->sectors = calc_num_sectors(rdev, mddev->chunk_size);
+        rdev->sectors = rdev->sb_start;
        if (test_bit(Faulty, &rdev->flags)) {
                printk(KERN_WARNING 
@@ -5062,7 +5012,7 @@ static int set_array_info(mddev_t * mddev, mdu_array_info_t *info)
        mddev->external      = 0;
        mddev->layout        = info->layout;
-        mddev->chunk_size    = info->chunk_size;
+        mddev->chunk_sectors = info->chunk_size >> 9;
        mddev->max_disks     = MD_SB_DISKS;
@@ -5081,7 +5031,7 @@ static int set_array_info(mddev_t * mddev, mdu_array_info_t *info)
        get_random_bytes(mddev->uuid, 16);
        mddev->new_level = mddev->level;
-        mddev->new_chunk = mddev->chunk_size;
+        mddev->new_chunk_sectors = mddev->chunk_sectors;
        mddev->new_layout = mddev->layout;
        mddev->delta_disks = 0;
@@ -5191,7 +5141,7 @@ static int update_array_info(mddev_t *mddev, mdu_array_info_t *info)
            mddev->level         != info->level         ||
 /*          mddev->layout        != info->layout        || */
            !mddev->persistent   != info->not_persistent||
-            mddev->chunk_size    != info->chunk_size    ||
+            mddev->chunk_sectors != info->chunk_size >> 9 ||
            /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
            ((state^info->state) & 0xfffffe00)
                )
@@ -5215,10 +5165,15 @@ static int update_array_info(mddev_t *mddev, mdu_array_info_t *info)
                 * we don't need to do anything at the md level, the
                 * personality will take care of it all.
                 */
-                if (mddev->pers->reconfig == NULL)
+                if (mddev->pers->check_reshape == NULL)
                        return -EINVAL;
-                else
+                else {
-                        return mddev->pers->reconfig(mddev, info->layout, -1);
+                        mddev->new_layout = info->layout;
+                        rv = mddev->pers->check_reshape(mddev);
+                        if (rv)
+                                mddev->new_layout = mddev->layout;
+                        return rv;
+                }
        }
        if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
                rv = update_size(mddev, (sector_t)info->size * 2);
@@ -6717,7 +6672,8 @@ void md_check_recovery(mddev_t *mddev)
                 */
                if (mddev->reshape_position != MaxSector) {
-                        if (mddev->pers->check_reshape(mddev) != 0)
+                        if (mddev->pers->check_reshape == NULL ||
+                            mddev->pers->check_reshape(mddev) != 0)
                                /* Cannot proceed */
                                goto unlock;
                        set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
diff --git a/drivers/md/md.h b/drivers/md/md.h
index 8227ab909d44..9430a110db93 100644
--- a/drivers/md/md.h
+++ b/drivers/md/md.h
@@ -30,13 +30,6 @@ typedef struct mddev_s mddev_t;
 typedef struct mdk_rdev_s mdk_rdev_t;
 /*
- * options passed in raidrun:
- */
-/* Currently this must fit in an 'int' */
-#define MAX_CHUNK_SIZE (1<<30)
-/*
 * MD's 'extended' device
 */
 struct mdk_rdev_s
@@ -145,7 +138,7 @@ struct mddev_s
        int                             external;       /* metadata is
                                                         * managed externally */
        char                            metadata_type[17]; /* externally set*/
-        int                             chunk_size;
+        int                             chunk_sectors;
        time_t                          ctime, utime;
        int                             level, layout;
        char                            clevel[16];
@@ -166,7 +159,8 @@ struct mddev_s
         * If reshape_position is MaxSector, then no reshape is happening (yet).
         */
        sector_t                        reshape_position;
-        int                             delta_disks, new_level, new_layout, new_chunk;
+        int                             delta_disks, new_level, new_layout;
+        int                             new_chunk_sectors;
        struct mdk_thread_s             *thread;        /* management thread */
        struct mdk_thread_s             *sync_thread;   /* doing resync or reconstruct */
@@ -325,7 +319,6 @@ struct mdk_personality
        int (*check_reshape) (mddev_t *mddev);
        int (*start_reshape) (mddev_t *mddev);
        void (*finish_reshape) (mddev_t *mddev);
-        int (*reconfig) (mddev_t *mddev, int layout, int chunk_size);
        /* quiesce moves between quiescence states
         * 0 - fully active
         * 1 - no new requests allowed
@@ -437,5 +430,6 @@ extern void md_new_event(mddev_t *mddev);
 extern int md_allow_write(mddev_t *mddev);
 extern void md_wait_for_blocked_rdev(mdk_rdev_t *rdev, mddev_t *mddev);
 extern void md_set_array_sectors(mddev_t *mddev, sector_t array_sectors);
+extern int md_check_no_bitmap(mddev_t *mddev);
 #endif /* _MD_MD_H */
diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c
index 4ee31aa13c40..cbe368fa6598 100644
--- a/drivers/md/multipath.c
+++ b/drivers/md/multipath.c
@@ -58,7 +58,7 @@ static void multipath_reschedule_retry (struct multipath_bh *mp_bh)
 {
        unsigned long flags;
        mddev_t *mddev = mp_bh->mddev;
-        multipath_conf_t *conf = mddev_to_conf(mddev);
+        multipath_conf_t *conf = mddev->private;
        spin_lock_irqsave(&conf->device_lock, flags);
        list_add(&mp_bh->retry_list, &conf->retry_list);
@@ -75,7 +75,7 @@ static void multipath_reschedule_retry (struct multipath_bh *mp_bh)
 static void multipath_end_bh_io (struct multipath_bh *mp_bh, int err)
 {
        struct bio *bio = mp_bh->master_bio;
-        multipath_conf_t *conf = mddev_to_conf(mp_bh->mddev);
+        multipath_conf_t *conf = mp_bh->mddev->private;
        bio_endio(bio, err);
        mempool_free(mp_bh, conf->pool);
@@ -85,7 +85,7 @@ static void multipath_end_request(struct bio *bio, int error)
 {
        int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
        struct multipath_bh * mp_bh = (struct multipath_bh *)(bio->bi_private);
-        multipath_conf_t *conf = mddev_to_conf(mp_bh->mddev);
+        multipath_conf_t *conf = mp_bh->mddev->private;
        mdk_rdev_t *rdev = conf->multipaths[mp_bh->path].rdev;
        if (uptodate)
@@ -107,7 +107,7 @@ static void multipath_end_request(struct bio *bio, int error)
 static void unplug_slaves(mddev_t *mddev)
 {
-        multipath_conf_t *conf = mddev_to_conf(mddev);
+        multipath_conf_t *conf = mddev->private;
        int i;
        rcu_read_lock();
@@ -138,7 +138,7 @@ static void multipath_unplug(struct request_queue *q)
 static int multipath_make_request (struct request_queue *q, struct bio * bio)
 {
        mddev_t *mddev = q->queuedata;
-        multipath_conf_t *conf = mddev_to_conf(mddev);
+        multipath_conf_t *conf = mddev->private;
        struct multipath_bh * mp_bh;
        struct multipath_info *multipath;
        const int rw = bio_data_dir(bio);
@@ -180,7 +180,7 @@ static int multipath_make_request (struct request_queue *q, struct bio * bio)
 static void multipath_status (struct seq_file *seq, mddev_t *mddev)
 {
-        multipath_conf_t *conf = mddev_to_conf(mddev);
+        multipath_conf_t *conf = mddev->private;
        int i;
        
        seq_printf (seq, " [%d/%d] [", conf->raid_disks,
@@ -195,7 +195,7 @@ static void multipath_status (struct seq_file *seq, mddev_t *mddev)
 static int multipath_congested(void *data, int bits)
 {
        mddev_t *mddev = data;
-        multipath_conf_t *conf = mddev_to_conf(mddev);
+        multipath_conf_t *conf = mddev->private;
        int i, ret = 0;
        rcu_read_lock();
@@ -220,7 +220,7 @@ static int multipath_congested(void *data, int bits)
 */
 static void multipath_error (mddev_t *mddev, mdk_rdev_t *rdev)
 {
-        multipath_conf_t *conf = mddev_to_conf(mddev);
+        multipath_conf_t *conf = mddev->private;
        if (conf->working_disks <= 1) {
                /*
@@ -367,7 +367,7 @@ static void multipathd (mddev_t *mddev)
        struct multipath_bh *mp_bh;
        struct bio *bio;
        unsigned long flags;
-        multipath_conf_t *conf = mddev_to_conf(mddev);
+        multipath_conf_t *conf = mddev->private;
        struct list_head *head = &conf->retry_list;
        md_check_recovery(mddev);
@@ -421,6 +421,9 @@ static int multipath_run (mddev_t *mddev)
        struct multipath_info *disk;
        mdk_rdev_t *rdev;
+        if (md_check_no_bitmap(mddev))
+                return -EINVAL;
        if (mddev->level != LEVEL_MULTIPATH) {
                printk("multipath: %s: raid level not set to multipath IO (%d)\n",
                       mdname(mddev), mddev->level);
@@ -531,7 +534,7 @@ out:
 static int multipath_stop (mddev_t *mddev)
 {
-        multipath_conf_t *conf = mddev_to_conf(mddev);
+        multipath_conf_t *conf = mddev->private;
        md_unregister_thread(mddev->thread);
        mddev->thread = NULL;
diff --git a/drivers/md/multipath.h b/drivers/md/multipath.h
index 6fa70b400cda..d1c2a8d78395 100644
--- a/drivers/md/multipath.h
+++ b/drivers/md/multipath.h
@@ -19,12 +19,6 @@ struct multipath_private_data {
 typedef struct multipath_private_data multipath_conf_t;
 /*
- * this is the only point in the RAID code where we violate
- * C type safety. mddev->private is an 'opaque' pointer.
- */
-#define mddev_to_conf(mddev) ((multipath_conf_t *) mddev->private)
-/*
 * this is our 'private' 'collective' MULTIPATH buffer head.
 * it contains information about what kind of IO operations were started
 * for this MULTIPATH operation, and about their status:
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index 925507e7d673..ab4a489d8695 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -26,8 +26,8 @@
 static void raid0_unplug(struct request_queue *q)
 {
        mddev_t *mddev = q->queuedata;
-        raid0_conf_t *conf = mddev_to_conf(mddev);
+        raid0_conf_t *conf = mddev->private;
-        mdk_rdev_t **devlist = conf->strip_zone[0].dev;
+        mdk_rdev_t **devlist = conf->devlist;
        int i;
        for (i=0; i<mddev->raid_disks; i++) {
@@ -40,8 +40,8 @@ static void raid0_unplug(struct request_queue *q)
 static int raid0_congested(void *data, int bits)
 {
        mddev_t *mddev = data;
-        raid0_conf_t *conf = mddev_to_conf(mddev);
+        raid0_conf_t *conf = mddev->private;
-        mdk_rdev_t **devlist = conf->strip_zone[0].dev;
+        mdk_rdev_t **devlist = conf->devlist;
        int i, ret = 0;
        for (i = 0; i < mddev->raid_disks && !ret ; i++) {
@@ -52,27 +52,60 @@ static int raid0_congested(void *data, int bits)
        return ret;
 }
+/*
+ * inform the user of the raid configuration
+*/
+static void dump_zones(mddev_t *mddev)
+{
+        int j, k, h;
+        sector_t zone_size = 0;
+        sector_t zone_start = 0;
+        char b[BDEVNAME_SIZE];
+        raid0_conf_t *conf = mddev->private;
+        printk(KERN_INFO "******* %s configuration *********\n",
+                mdname(mddev));
+        h = 0;
+        for (j = 0; j < conf->nr_strip_zones; j++) {
+                printk(KERN_INFO "zone%d=[", j);
+                for (k = 0; k < conf->strip_zone[j].nb_dev; k++)
+                        printk("%s/",
+                        bdevname(conf->devlist[j*mddev->raid_disks
+                                                + k]->bdev, b));
+                printk("]\n");
+                zone_size  = conf->strip_zone[j].zone_end - zone_start;
+                printk(KERN_INFO "        zone offset=%llukb "
+                                "device offset=%llukb size=%llukb\n",
+                        (unsigned long long)zone_start>>1,
+                        (unsigned long long)conf->strip_zone[j].dev_start>>1,
+                        (unsigned long long)zone_size>>1);
+                zone_start = conf->strip_zone[j].zone_end;
+        }
+        printk(KERN_INFO "**********************************\n\n");
+}
-static int create_strip_zones (mddev_t *mddev)
+static int create_strip_zones(mddev_t *mddev)
 {
-        int i, c, j;
+        int i, c, j, err;
-        sector_t current_start, curr_zone_start;
+        sector_t curr_zone_end, sectors;
-        sector_t min_spacing;
+        mdk_rdev_t *smallest, *rdev1, *rdev2, *rdev, **dev;
-        raid0_conf_t *conf = mddev_to_conf(mddev);
-        mdk_rdev_t *smallest, *rdev1, *rdev2, *rdev;
        struct strip_zone *zone;
        int cnt;
        char b[BDEVNAME_SIZE];
- 
+        raid0_conf_t *conf = kzalloc(sizeof(*conf), GFP_KERNEL);
-        /*
-         * The number of 'same size groups'
+        if (!conf)
-         */
+                return -ENOMEM;
-        conf->nr_strip_zones = 0;
- 
        list_for_each_entry(rdev1, &mddev->disks, same_set) {
                printk(KERN_INFO "raid0: looking at %s\n",
                        bdevname(rdev1->bdev,b));
                c = 0;
+                /* round size to chunk_size */
+                sectors = rdev1->sectors;
+                sector_div(sectors, mddev->chunk_sectors);
+                rdev1->sectors = sectors * mddev->chunk_sectors;
                list_for_each_entry(rdev2, &mddev->disks, same_set) {
                        printk(KERN_INFO "raid0:   comparing %s(%llu)",
                               bdevname(rdev1->bdev,b),
@@ -103,16 +136,16 @@ static int create_strip_zones (mddev_t *mddev)
                }
        }
        printk(KERN_INFO "raid0: FINAL %d zones\n", conf->nr_strip_zones);
+        err = -ENOMEM;
        conf->strip_zone = kzalloc(sizeof(struct strip_zone)*
                                conf->nr_strip_zones, GFP_KERNEL);
        if (!conf->strip_zone)
-                return 1;
+                goto abort;
        conf->devlist = kzalloc(sizeof(mdk_rdev_t*)*
                                conf->nr_strip_zones*mddev->raid_disks,
                                GFP_KERNEL);
        if (!conf->devlist)
-                return 1;
+                goto abort;
        /* The first zone must contain all devices, so here we check that
         * there is a proper alignment of slots to devices and find them all
@@ -120,7 +153,8 @@ static int create_strip_zones (mddev_t *mddev)
        zone = &conf->strip_zone[0];
        cnt = 0;
        smallest = NULL;
-        zone->dev = conf->devlist;
+        dev = conf->devlist;
+        err = -EINVAL;
        list_for_each_entry(rdev1, &mddev->disks, same_set) {
                int j = rdev1->raid_disk;
@@ -129,12 +163,12 @@ static int create_strip_zones (mddev_t *mddev)
                                "aborting!\n", j);
                        goto abort;
                }
-                if (zone->dev[j]) {
+                if (dev[j]) {
                        printk(KERN_ERR "raid0: multiple devices for %d - "
                                "aborting!\n", j);
                        goto abort;
                }
-                zone->dev[j] = rdev1;
+                dev[j] = rdev1;
                blk_queue_stack_limits(mddev->queue,
                                       rdev1->bdev->bd_disk->queue);
@@ -157,34 +191,32 @@ static int create_strip_zones (mddev_t *mddev)
                goto abort;
        }
        zone->nb_dev = cnt;
-        zone->sectors = smallest->sectors * cnt;
+        zone->zone_end = smallest->sectors * cnt;
-        zone->zone_start = 0;
-        current_start = smallest->sectors;
+        curr_zone_end = zone->zone_end;
-        curr_zone_start = zone->sectors;
        /* now do the other zones */
        for (i = 1; i < conf->nr_strip_zones; i++)
        {
                zone = conf->strip_zone + i;
-                zone->dev = conf->strip_zone[i-1].dev + mddev->raid_disks;
+                dev = conf->devlist + i * mddev->raid_disks;
                printk(KERN_INFO "raid0: zone %d\n", i);
-                zone->dev_start = current_start;
+                zone->dev_start = smallest->sectors;
                smallest = NULL;
                c = 0;
                for (j=0; j<cnt; j++) {
                        char b[BDEVNAME_SIZE];
-                        rdev = conf->strip_zone[0].dev[j];
+                        rdev = conf->devlist[j];
                        printk(KERN_INFO "raid0: checking %s ...",
                                bdevname(rdev->bdev, b));
-                        if (rdev->sectors <= current_start) {
+                        if (rdev->sectors <= zone->dev_start) {
                                printk(KERN_INFO " nope.\n");
                                continue;
                        }
                        printk(KERN_INFO " contained as device %d\n", c);
-                        zone->dev[c] = rdev;
+                        dev[c] = rdev;
                        c++;
                        if (!smallest || rdev->sectors < smallest->sectors) {
                                smallest = rdev;
@@ -194,47 +226,39 @@ static int create_strip_zones (mddev_t *mddev)
                }
                zone->nb_dev = c;
-                zone->sectors = (smallest->sectors - current_start) * c;
+                sectors = (smallest->sectors - zone->dev_start) * c;
                printk(KERN_INFO "raid0: zone->nb_dev: %d, sectors: %llu\n",
-                        zone->nb_dev, (unsigned long long)zone->sectors);
+                        zone->nb_dev, (unsigned long long)sectors);
-                zone->zone_start = curr_zone_start;
+                curr_zone_end += sectors;
-                curr_zone_start += zone->sectors;
+                zone->zone_end = curr_zone_end;
-                current_start = smallest->sectors;
                printk(KERN_INFO "raid0: current zone start: %llu\n",
-                        (unsigned long long)current_start);
+                        (unsigned long long)smallest->sectors);
-        }
-        /* Now find appropriate hash spacing.
-         * We want a number which causes most hash entries to cover
-         * at most two strips, but the hash table must be at most
-         * 1 PAGE.  We choose the smallest strip, or contiguous collection
-         * of strips, that has big enough size.  We never consider the last
-         * strip though as it's size has no bearing on the efficacy of the hash
-         * table.
-         */
-        conf->spacing = curr_zone_start;
-        min_spacing = curr_zone_start;
-        sector_div(min_spacing, PAGE_SIZE/sizeof(struct strip_zone*));
-        for (i=0; i < conf->nr_strip_zones-1; i++) {
-                sector_t s = 0;
-                for (j = i; j < conf->nr_strip_zones - 1 &&
-                                s < min_spacing; j++)
-                        s += conf->strip_zone[j].sectors;
-                if (s >= min_spacing && s < conf->spacing)
-                        conf->spacing = s;
        }
        mddev->queue->unplug_fn = raid0_unplug;
        mddev->queue->backing_dev_info.congested_fn = raid0_congested;
        mddev->queue->backing_dev_info.congested_data = mddev;
+        /*
+         * now since we have the hard sector sizes, we can make sure
+         * chunk size is a multiple of that sector size
+         */
+        if ((mddev->chunk_sectors << 9) % queue_logical_block_size(mddev->queue)) {
+                printk(KERN_ERR "%s chunk_size of %d not valid\n",
+                       mdname(mddev),
+                       mddev->chunk_sectors << 9);
+                goto abort;
+        }
        printk(KERN_INFO "raid0: done.\n");
+        mddev->private = conf;
        return 0;
- abort:
+abort:
-        return 1;
+        kfree(conf->strip_zone);
+        kfree(conf->devlist);
+        kfree(conf);
+        mddev->private = NULL;
+        return err;
 }
 /**
@@ -252,10 +276,15 @@ static int raid0_mergeable_bvec(struct request_queue *q,
        mddev_t *mddev = q->queuedata;
        sector_t sector = bvm->bi_sector + get_start_sect(bvm->bi_bdev);
        int max;
-        unsigned int chunk_sectors = mddev->chunk_size >> 9;
+        unsigned int chunk_sectors = mddev->chunk_sectors;
        unsigned int bio_sectors = bvm->bi_size >> 9;
-        max =  (chunk_sectors - ((sector & (chunk_sectors - 1)) + bio_sectors)) << 9;
+        if (is_power_of_2(chunk_sectors))
+                max =  (chunk_sectors - ((sector & (chunk_sectors-1))
+                                                + bio_sectors)) << 9;
+        else
+                max =  (chunk_sectors - (sector_div(sector, chunk_sectors)
+                                                + bio_sectors)) << 9;
        if (max < 0) max = 0; /* bio_add cannot handle a negative return */
        if (max <= biovec->bv_len && bio_sectors == 0)
                return biovec->bv_len;
@@ -277,84 +306,28 @@ static sector_t raid0_size(mddev_t *mddev, sector_t sectors, int raid_disks)
        return array_sectors;
 }
-static int raid0_run (mddev_t *mddev)
+static int raid0_run(mddev_t *mddev)
 {
-        unsigned  cur=0, i=0, nb_zone;
+        int ret;
-        s64 sectors;
-        raid0_conf_t *conf;
-        if (mddev->chunk_size == 0) {
+        if (mddev->chunk_sectors == 0) {
-                printk(KERN_ERR "md/raid0: non-zero chunk size required.\n");
+                printk(KERN_ERR "md/raid0: chunk size must be set.\n");
                return -EINVAL;
        }
-        printk(KERN_INFO "%s: setting max_sectors to %d, segment boundary to %d\n",
+        if (md_check_no_bitmap(mddev))
-               mdname(mddev),
+                return -EINVAL;
-               mddev->chunk_size >> 9,
+        blk_queue_max_sectors(mddev->queue, mddev->chunk_sectors);
-               (mddev->chunk_size>>1)-1);
-        blk_queue_max_sectors(mddev->queue, mddev->chunk_size >> 9);
-        blk_queue_segment_boundary(mddev->queue, (mddev->chunk_size>>1) - 1);
        mddev->queue->queue_lock = &mddev->queue->__queue_lock;
-        conf = kmalloc(sizeof (raid0_conf_t), GFP_KERNEL);
+        ret = create_strip_zones(mddev);
-        if (!conf)
+        if (ret < 0)
-                goto out;
+                return ret;
-        mddev->private = (void *)conf;
- 
-        conf->strip_zone = NULL;
-        conf->devlist = NULL;
-        if (create_strip_zones (mddev)) 
-                goto out_free_conf;
        /* calculate array device size */
        md_set_array_sectors(mddev, raid0_size(mddev, 0, 0));
        printk(KERN_INFO "raid0 : md_size is %llu sectors.\n",
                (unsigned long long)mddev->array_sectors);
-        printk(KERN_INFO "raid0 : conf->spacing is %llu sectors.\n",
-                (unsigned long long)conf->spacing);
-        {
-                sector_t s = raid0_size(mddev, 0, 0);
-                sector_t space = conf->spacing;
-                int round;
-                conf->sector_shift = 0;
-                if (sizeof(sector_t) > sizeof(u32)) {
-                        /*shift down space and s so that sector_div will work */
-                        while (space > (sector_t) (~(u32)0)) {
-                                s >>= 1;
-                                space >>= 1;
-                                s += 1; /* force round-up */
-                                conf->sector_shift++;
-                        }
-                }
-                round = sector_div(s, (u32)space) ? 1 : 0;
-                nb_zone = s + round;
-        }
-        printk(KERN_INFO "raid0 : nb_zone is %d.\n", nb_zone);
-        printk(KERN_INFO "raid0 : Allocating %zu bytes for hash.\n",
-                                nb_zone*sizeof(struct strip_zone*));
-        conf->hash_table = kmalloc (sizeof (struct strip_zone *)*nb_zone, GFP_KERNEL);
-        if (!conf->hash_table)
-                goto out_free_conf;
-        sectors = conf->strip_zone[cur].sectors;
-        conf->hash_table[0] = conf->strip_zone + cur;
-        for (i=1; i< nb_zone; i++) {
-                while (sectors <= conf->spacing) {
-                        cur++;
-                        sectors += conf->strip_zone[cur].sectors;
-                }
-                sectors -= conf->spacing;
-                conf->hash_table[i] = conf->strip_zone + cur;
-        }
-        if (conf->sector_shift) {
-                conf->spacing >>= conf->sector_shift;
-                /* round spacing up so when we divide by it, we
-                 * err on the side of too-low, which is safest
-                 */
-                conf->spacing++;
-        }
        /* calculate the max read-ahead size.
         * For read-ahead of large files to be effective, we need to
         * readahead at least twice a whole stripe. i.e. number of devices
@@ -365,48 +338,107 @@ static int raid0_run (mddev_t *mddev)
         * chunksize should be used in that case.
         */
        {
-                int stripe = mddev->raid_disks * mddev->chunk_size / PAGE_SIZE;
+                int stripe = mddev->raid_disks *
+                        (mddev->chunk_sectors << 9) / PAGE_SIZE;
                if (mddev->queue->backing_dev_info.ra_pages < 2* stripe)
                        mddev->queue->backing_dev_info.ra_pages = 2* stripe;
        }
        blk_queue_merge_bvec(mddev->queue, raid0_mergeable_bvec);
+        dump_zones(mddev);
        return 0;
+}
-out_free_conf:
+static int raid0_stop(mddev_t *mddev)
+{
+        raid0_conf_t *conf = mddev->private;
+        blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
        kfree(conf->strip_zone);
        kfree(conf->devlist);
        kfree(conf);
        mddev->private = NULL;
-out:
+        return 0;
-        return -ENOMEM;
 }
-static int raid0_stop (mddev_t *mddev)
+/* Find the zone which holds a particular offset
+ * Update *sectorp to be an offset in that zone
+ */
+static struct strip_zone *find_zone(struct raid0_private_data *conf,
+                                    sector_t *sectorp)
 {
-        raid0_conf_t *conf = mddev_to_conf(mddev);
+        int i;
+        struct strip_zone *z = conf->strip_zone;
+        sector_t sector = *sectorp;
+        for (i = 0; i < conf->nr_strip_zones; i++)
+                if (sector < z[i].zone_end) {
+                        if (i)
+                                *sectorp = sector - z[i-1].zone_end;
+                        return z + i;
+                }
+        BUG();
+}
-        blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
+/*
-        kfree(conf->hash_table);
+ * remaps the bio to the target device. we separate two flows.
-        conf->hash_table = NULL;
+ * power 2 flow and a general flow for the sake of perfromance
-        kfree(conf->strip_zone);
+*/
-        conf->strip_zone = NULL;
+static mdk_rdev_t *map_sector(mddev_t *mddev, struct strip_zone *zone,
-        kfree(conf);
+                                sector_t sector, sector_t *sector_offset)
-        mddev->private = NULL;
+{
+        unsigned int sect_in_chunk;
+        sector_t chunk;
+        raid0_conf_t *conf = mddev->private;
+        unsigned int chunk_sects = mddev->chunk_sectors;
+        if (is_power_of_2(chunk_sects)) {
+                int chunksect_bits = ffz(~chunk_sects);
+                /* find the sector offset inside the chunk */
+                sect_in_chunk  = sector & (chunk_sects - 1);
+                sector >>= chunksect_bits;
+                /* chunk in zone */
+                chunk = *sector_offset;
+                /* quotient is the chunk in real device*/
+                sector_div(chunk, zone->nb_dev << chunksect_bits);
+        } else{
+                sect_in_chunk = sector_div(sector, chunk_sects);
+                chunk = *sector_offset;
+                sector_div(chunk, chunk_sects * zone->nb_dev);
+        }
+        /*
+        *  position the bio over the real device
+        *  real sector = chunk in device + starting of zone
+        *       + the position in the chunk
+        */
+        *sector_offset = (chunk * chunk_sects) + sect_in_chunk;
+        return conf->devlist[(zone - conf->strip_zone)*mddev->raid_disks
+                             + sector_div(sector, zone->nb_dev)];
+}
-        return 0;
+/*
+ * Is io distribute over 1 or more chunks ?
+*/
+static inline int is_io_in_chunk_boundary(mddev_t *mddev,
+                        unsigned int chunk_sects, struct bio *bio)
+{
+        if (likely(is_power_of_2(chunk_sects))) {
+                return chunk_sects >= ((bio->bi_sector & (chunk_sects-1))
+                                        + (bio->bi_size >> 9));
+        } else{
+                sector_t sector = bio->bi_sector;
+                return chunk_sects >= (sector_div(sector, chunk_sects)
+                                                + (bio->bi_size >> 9));
+        }
 }
-static int raid0_make_request (struct request_queue *q, struct bio *bio)
+static int raid0_make_request(struct request_queue *q, struct bio *bio)
 {
        mddev_t *mddev = q->queuedata;
-        unsigned int sect_in_chunk, chunksect_bits, chunk_sects;
+        unsigned int chunk_sects;
-        raid0_conf_t *conf = mddev_to_conf(mddev);
+        sector_t sector_offset;
        struct strip_zone *zone;
        mdk_rdev_t *tmp_dev;
-        sector_t chunk;
-        sector_t sector, rsect;
        const int rw = bio_data_dir(bio);
        int cpu;
@@ -421,11 +453,9 @@ static int raid0_make_request (struct request_queue *q, struct bio *bio)
                      bio_sectors(bio));
        part_stat_unlock();
-        chunk_sects = mddev->chunk_size >> 9;
+        chunk_sects = mddev->chunk_sectors;
-        chunksect_bits = ffz(~chunk_sects);
+        if (unlikely(!is_io_in_chunk_boundary(mddev, chunk_sects, bio))) {
-        sector = bio->bi_sector;
+                sector_t sector = bio->bi_sector;
-        if (unlikely(chunk_sects < (bio->bi_sector & (chunk_sects - 1)) + (bio->bi_size >> 9))) {
                struct bio_pair *bp;
                /* Sanity check -- queue functions should prevent this happening */
                if (bio->bi_vcnt != 1 ||
@@ -434,7 +464,12 @@ static int raid0_make_request (struct request_queue *q, struct bio *bio)
                /* This is a one page bio that upper layers
                 * refuse to split for us, so we need to split it.
                 */
-                bp = bio_split(bio, chunk_sects - (bio->bi_sector & (chunk_sects - 1)));
+                if (likely(is_power_of_2(chunk_sects)))
+                        bp = bio_split(bio, chunk_sects - (sector &
+                                                           (chunk_sects-1)));
+                else
+                        bp = bio_split(bio, chunk_sects -
+                                       sector_div(sector, chunk_sects));
                if (raid0_make_request(q, &bp->bio1))
                        generic_make_request(&bp->bio1);
                if (raid0_make_request(q, &bp->bio2))
@@ -443,34 +478,14 @@ static int raid0_make_request (struct request_queue *q, struct bio *bio)
                bio_pair_release(bp);
                return 0;
        }
- 
-        {
-                sector_t x = sector >> conf->sector_shift;
-                sector_div(x, (u32)conf->spacing);
-                zone = conf->hash_table[x];
-        }
-        while (sector >= zone->zone_start + zone->sectors)
+        sector_offset = bio->bi_sector;
-                zone++;
+        zone =  find_zone(mddev->private, &sector_offset);
+        tmp_dev = map_sector(mddev, zone, bio->bi_sector,
-        sect_in_chunk = bio->bi_sector & (chunk_sects - 1);
+                             &sector_offset);
-        {
-                sector_t x = (sector - zone->zone_start) >> chunksect_bits;
-                sector_div(x, zone->nb_dev);
-                chunk = x;
-                x = sector >> chunksect_bits;
-                tmp_dev = zone->dev[sector_div(x, zone->nb_dev)];
-        }
-        rsect = (chunk << chunksect_bits) + zone->dev_start + sect_in_chunk;
- 
        bio->bi_bdev = tmp_dev->bdev;
-        bio->bi_sector = rsect + tmp_dev->data_offset;
+        bio->bi_sector = sector_offset + zone->dev_start +
+                tmp_dev->data_offset;
        /*
         * Let the main block layer submit the IO and resolve recursion:
         */
@@ -485,31 +500,35 @@ bad_map:
        return 0;
 }
-static void raid0_status (struct seq_file *seq, mddev_t *mddev)
+static void raid0_status(struct seq_file *seq, mddev_t *mddev)
 {
 #undef MD_DEBUG
 #ifdef MD_DEBUG
        int j, k, h;
        char b[BDEVNAME_SIZE];
-        raid0_conf_t *conf = mddev_to_conf(mddev);
+        raid0_conf_t *conf = mddev->private;
+        sector_t zone_size;
+        sector_t zone_start = 0;
        h = 0;
        for (j = 0; j < conf->nr_strip_zones; j++) {
                seq_printf(seq, "      z%d", j);
-                if (conf->hash_table[h] == conf->strip_zone+j)
-                        seq_printf(seq, "(h%d)", h++);
                seq_printf(seq, "=[");
                for (k = 0; k < conf->strip_zone[j].nb_dev; k++)
                        seq_printf(seq, "%s/", bdevname(
-                                conf->strip_zone[j].dev[k]->bdev,b));
+                                conf->devlist[j*mddev->raid_disks + k]
+                                                ->bdev, b));
-                seq_printf(seq, "] zs=%d ds=%d s=%d\n",
-                                conf->strip_zone[j].zone_start,
+                zone_size  = conf->strip_zone[j].zone_end - zone_start;
-                                conf->strip_zone[j].dev_start,
+                seq_printf(seq, "] ze=%lld ds=%lld s=%lld\n",
-                                conf->strip_zone[j].sectors);
+                        (unsigned long long)zone_start>>1,
+                        (unsigned long long)conf->strip_zone[j].dev_start>>1,
+                        (unsigned long long)zone_size>>1);
+                zone_start = conf->strip_zone[j].zone_end;
        }
 #endif
-        seq_printf(seq, " %dk chunks", mddev->chunk_size/1024);
+        seq_printf(seq, " %dk chunks", mddev->chunk_sectors / 2);
        return;
 }
diff --git a/drivers/md/raid0.h b/drivers/md/raid0.h
index 824b12eb1d4f..91f8e876ee64 100644
--- a/drivers/md/raid0.h
+++ b/drivers/md/raid0.h
@@ -3,26 +3,18 @@
 struct strip_zone
 {
-        sector_t zone_start;    /* Zone offset in md_dev (in sectors) */
+        sector_t zone_end;      /* Start of the next zone (in sectors) */
        sector_t dev_start;     /* Zone offset in real dev (in sectors) */
-        sector_t sectors;       /* Zone size in sectors */
        int nb_dev;             /* # of devices attached to the zone */
-        mdk_rdev_t **dev;       /* Devices attached to the zone */
 };
 struct raid0_private_data
 {
-        struct strip_zone **hash_table; /* Table of indexes into strip_zone */
        struct strip_zone *strip_zone;
        mdk_rdev_t **devlist; /* lists of rdevs, pointed to by strip_zone->dev */
        int nr_strip_zones;
-        sector_t spacing;
-        int sector_shift; /* shift this before divide by spacing */
 };
 typedef struct raid0_private_data raid0_conf_t;
-#define mddev_to_conf(mddev) ((raid0_conf_t *) mddev->private)
 #endif
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index e23758b4a34e..89939a7aef57 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -182,7 +182,7 @@ static void put_all_bios(conf_t *conf, r1bio_t *r1_bio)
 static void free_r1bio(r1bio_t *r1_bio)
 {
-        conf_t *conf = mddev_to_conf(r1_bio->mddev);
+        conf_t *conf = r1_bio->mddev->private;
        /*
         * Wake up any possible resync thread that waits for the device
@@ -196,7 +196,7 @@ static void free_r1bio(r1bio_t *r1_bio)
 static void put_buf(r1bio_t *r1_bio)
 {
-        conf_t *conf = mddev_to_conf(r1_bio->mddev);
+        conf_t *conf = r1_bio->mddev->private;
        int i;
        for (i=0; i<conf->raid_disks; i++) {
@@ -214,7 +214,7 @@ static void reschedule_retry(r1bio_t *r1_bio)
 {
        unsigned long flags;
        mddev_t *mddev = r1_bio->mddev;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        spin_lock_irqsave(&conf->device_lock, flags);
        list_add(&r1_bio->retry_list, &conf->retry_list);
@@ -253,7 +253,7 @@ static void raid_end_bio_io(r1bio_t *r1_bio)
 */
 static inline void update_head_pos(int disk, r1bio_t *r1_bio)
 {
-        conf_t *conf = mddev_to_conf(r1_bio->mddev);
+        conf_t *conf = r1_bio->mddev->private;
        conf->mirrors[disk].head_position =
                r1_bio->sector + (r1_bio->sectors);
@@ -264,7 +264,7 @@ static void raid1_end_read_request(struct bio *bio, int error)
        int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
        r1bio_t * r1_bio = (r1bio_t *)(bio->bi_private);
        int mirror;
-        conf_t *conf = mddev_to_conf(r1_bio->mddev);
+        conf_t *conf = r1_bio->mddev->private;
        mirror = r1_bio->read_disk;
        /*
@@ -309,7 +309,7 @@ static void raid1_end_write_request(struct bio *bio, int error)
        int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
        r1bio_t * r1_bio = (r1bio_t *)(bio->bi_private);
        int mirror, behind = test_bit(R1BIO_BehindIO, &r1_bio->state);
-        conf_t *conf = mddev_to_conf(r1_bio->mddev);
+        conf_t *conf = r1_bio->mddev->private;
        struct bio *to_put = NULL;
@@ -541,7 +541,7 @@ static int read_balance(conf_t *conf, r1bio_t *r1_bio)
 static void unplug_slaves(mddev_t *mddev)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        int i;
        rcu_read_lock();
@@ -573,7 +573,7 @@ static void raid1_unplug(struct request_queue *q)
 static int raid1_congested(void *data, int bits)
 {
        mddev_t *mddev = data;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        int i, ret = 0;
        rcu_read_lock();
@@ -772,7 +772,7 @@ do_sync_io:
 static int make_request(struct request_queue *q, struct bio * bio)
 {
        mddev_t *mddev = q->queuedata;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        mirror_info_t *mirror;
        r1bio_t *r1_bio;
        struct bio *read_bio;
@@ -991,7 +991,7 @@ static int make_request(struct request_queue *q, struct bio * bio)
 static void status(struct seq_file *seq, mddev_t *mddev)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        int i;
        seq_printf(seq, " [%d/%d] [", conf->raid_disks,
@@ -1010,7 +1010,7 @@ static void status(struct seq_file *seq, mddev_t *mddev)
 static void error(mddev_t *mddev, mdk_rdev_t *rdev)
 {
        char b[BDEVNAME_SIZE];
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        /*
         * If it is not operational, then we have already marked it as dead
@@ -1214,7 +1214,7 @@ static void end_sync_write(struct bio *bio, int error)
        int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
        r1bio_t * r1_bio = (r1bio_t *)(bio->bi_private);
        mddev_t *mddev = r1_bio->mddev;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        int i;
        int mirror=0;
@@ -1248,7 +1248,7 @@ static void end_sync_write(struct bio *bio, int error)
 static void sync_request_write(mddev_t *mddev, r1bio_t *r1_bio)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        int i;
        int disks = conf->raid_disks;
        struct bio *bio, *wbio;
@@ -1562,7 +1562,7 @@ static void raid1d(mddev_t *mddev)
        r1bio_t *r1_bio;
        struct bio *bio;
        unsigned long flags;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        struct list_head *head = &conf->retry_list;
        int unplug=0;
        mdk_rdev_t *rdev;
@@ -1585,7 +1585,7 @@ static void raid1d(mddev_t *mddev)
                spin_unlock_irqrestore(&conf->device_lock, flags);
                mddev = r1_bio->mddev;
-                conf = mddev_to_conf(mddev);
+                conf = mddev->private;
                if (test_bit(R1BIO_IsSync, &r1_bio->state)) {
                        sync_request_write(mddev, r1_bio);
                        unplug = 1;
@@ -1706,7 +1706,7 @@ static int init_resync(conf_t *conf)
 static sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *skipped, int go_faster)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        r1bio_t *r1_bio;
        struct bio *bio;
        sector_t max_sector, nr_sectors;
@@ -2052,6 +2052,10 @@ static int run(mddev_t *mddev)
                goto out_free_conf;
        }
+        if (mddev->recovery_cp != MaxSector)
+                printk(KERN_NOTICE "raid1: %s is not clean"
+                       " -- starting background reconstruction\n",
+                       mdname(mddev));
        printk(KERN_INFO 
                "raid1: raid set %s active with %d out of %d mirrors\n",
                mdname(mddev), mddev->raid_disks - mddev->degraded, 
@@ -2087,7 +2091,7 @@ out:
 static int stop(mddev_t *mddev)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        struct bitmap *bitmap = mddev->bitmap;
        int behind_wait = 0;
@@ -2155,16 +2159,16 @@ static int raid1_reshape(mddev_t *mddev)
        mempool_t *newpool, *oldpool;
        struct pool_info *newpoolinfo;
        mirror_info_t *newmirrors;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        int cnt, raid_disks;
        unsigned long flags;
        int d, d2, err;
        /* Cannot change chunk_size, layout, or level */
-        if (mddev->chunk_size != mddev->new_chunk ||
+        if (mddev->chunk_sectors != mddev->new_chunk_sectors ||
            mddev->layout != mddev->new_layout ||
            mddev->level != mddev->new_level) {
-                mddev->new_chunk = mddev->chunk_size;
+                mddev->new_chunk_sectors = mddev->chunk_sectors;
                mddev->new_layout = mddev->layout;
                mddev->new_level = mddev->level;
                return -EINVAL;
@@ -2252,7 +2256,7 @@ static int raid1_reshape(mddev_t *mddev)
 static void raid1_quiesce(mddev_t *mddev, int state)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        switch(state) {
        case 1:
diff --git a/drivers/md/raid1.h b/drivers/md/raid1.h
index 1620eea3d57c..e87b84deff68 100644
--- a/drivers/md/raid1.h
+++ b/drivers/md/raid1.h
@@ -64,12 +64,6 @@ struct r1_private_data_s {
 typedef struct r1_private_data_s conf_t;
 /*
- * this is the only point in the RAID code where we violate
- * C type safety. mddev->private is an 'opaque' pointer.
- */
-#define mddev_to_conf(mddev) ((conf_t *) mddev->private)
-/*
 * this is our 'private' RAID1 bio.
 *
 * it contains information about what kind of IO operations were started
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 750550c1166f..ae12ceafe10c 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -188,7 +188,7 @@ static void put_all_bios(conf_t *conf, r10bio_t *r10_bio)
 static void free_r10bio(r10bio_t *r10_bio)
 {
-        conf_t *conf = mddev_to_conf(r10_bio->mddev);
+        conf_t *conf = r10_bio->mddev->private;
        /*
         * Wake up any possible resync thread that waits for the device
@@ -202,7 +202,7 @@ static void free_r10bio(r10bio_t *r10_bio)
 static void put_buf(r10bio_t *r10_bio)
 {
-        conf_t *conf = mddev_to_conf(r10_bio->mddev);
+        conf_t *conf = r10_bio->mddev->private;
        mempool_free(r10_bio, conf->r10buf_pool);
@@ -213,7 +213,7 @@ static void reschedule_retry(r10bio_t *r10_bio)
 {
        unsigned long flags;
        mddev_t *mddev = r10_bio->mddev;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        spin_lock_irqsave(&conf->device_lock, flags);
        list_add(&r10_bio->retry_list, &conf->retry_list);
@@ -245,7 +245,7 @@ static void raid_end_bio_io(r10bio_t *r10_bio)
 */
 static inline void update_head_pos(int slot, r10bio_t *r10_bio)
 {
-        conf_t *conf = mddev_to_conf(r10_bio->mddev);
+        conf_t *conf = r10_bio->mddev->private;
        conf->mirrors[r10_bio->devs[slot].devnum].head_position =
                r10_bio->devs[slot].addr + (r10_bio->sectors);
@@ -256,7 +256,7 @@ static void raid10_end_read_request(struct bio *bio, int error)
        int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
        r10bio_t * r10_bio = (r10bio_t *)(bio->bi_private);
        int slot, dev;
-        conf_t *conf = mddev_to_conf(r10_bio->mddev);
+        conf_t *conf = r10_bio->mddev->private;
        slot = r10_bio->read_slot;
@@ -297,7 +297,7 @@ static void raid10_end_write_request(struct bio *bio, int error)
        int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
        r10bio_t * r10_bio = (r10bio_t *)(bio->bi_private);
        int slot, dev;
-        conf_t *conf = mddev_to_conf(r10_bio->mddev);
+        conf_t *conf = r10_bio->mddev->private;
        for (slot = 0; slot < conf->copies; slot++)
                if (r10_bio->devs[slot].bio == bio)
@@ -461,7 +461,7 @@ static int raid10_mergeable_bvec(struct request_queue *q,
        mddev_t *mddev = q->queuedata;
        sector_t sector = bvm->bi_sector + get_start_sect(bvm->bi_bdev);
        int max;
-        unsigned int chunk_sectors = mddev->chunk_size >> 9;
+        unsigned int chunk_sectors = mddev->chunk_sectors;
        unsigned int bio_sectors = bvm->bi_size >> 9;
        max =  (chunk_sectors - ((sector & (chunk_sectors - 1)) + bio_sectors)) << 9;
@@ -596,7 +596,7 @@ rb_out:
 static void unplug_slaves(mddev_t *mddev)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        int i;
        rcu_read_lock();
@@ -628,7 +628,7 @@ static void raid10_unplug(struct request_queue *q)
 static int raid10_congested(void *data, int bits)
 {
        mddev_t *mddev = data;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        int i, ret = 0;
        rcu_read_lock();
@@ -788,7 +788,7 @@ static void unfreeze_array(conf_t *conf)
 static int make_request(struct request_queue *q, struct bio * bio)
 {
        mddev_t *mddev = q->queuedata;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        mirror_info_t *mirror;
        r10bio_t *r10_bio;
        struct bio *read_bio;
@@ -981,11 +981,11 @@ static int make_request(struct request_queue *q, struct bio * bio)
 static void status(struct seq_file *seq, mddev_t *mddev)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        int i;
        if (conf->near_copies < conf->raid_disks)
-                seq_printf(seq, " %dK chunks", mddev->chunk_size/1024);
+                seq_printf(seq, " %dK chunks", mddev->chunk_sectors / 2);
        if (conf->near_copies > 1)
                seq_printf(seq, " %d near-copies", conf->near_copies);
        if (conf->far_copies > 1) {
@@ -1006,7 +1006,7 @@ static void status(struct seq_file *seq, mddev_t *mddev)
 static void error(mddev_t *mddev, mdk_rdev_t *rdev)
 {
        char b[BDEVNAME_SIZE];
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        /*
         * If it is not operational, then we have already marked it as dead
@@ -1215,7 +1215,7 @@ abort:
 static void end_sync_read(struct bio *bio, int error)
 {
        r10bio_t * r10_bio = (r10bio_t *)(bio->bi_private);
-        conf_t *conf = mddev_to_conf(r10_bio->mddev);
+        conf_t *conf = r10_bio->mddev->private;
        int i,d;
        for (i=0; i<conf->copies; i++)
@@ -1253,7 +1253,7 @@ static void end_sync_write(struct bio *bio, int error)
        int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
        r10bio_t * r10_bio = (r10bio_t *)(bio->bi_private);
        mddev_t *mddev = r10_bio->mddev;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        int i,d;
        for (i = 0; i < conf->copies; i++)
@@ -1300,7 +1300,7 @@ static void end_sync_write(struct bio *bio, int error)
 */
 static void sync_request_write(mddev_t *mddev, r10bio_t *r10_bio)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        int i, first;
        struct bio *tbio, *fbio;
@@ -1400,7 +1400,7 @@ done:
 static void recovery_request_write(mddev_t *mddev, r10bio_t *r10_bio)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        int i, d;
        struct bio *bio, *wbio;
@@ -1549,7 +1549,7 @@ static void raid10d(mddev_t *mddev)
        r10bio_t *r10_bio;
        struct bio *bio;
        unsigned long flags;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        struct list_head *head = &conf->retry_list;
        int unplug=0;
        mdk_rdev_t *rdev;
@@ -1572,7 +1572,7 @@ static void raid10d(mddev_t *mddev)
                spin_unlock_irqrestore(&conf->device_lock, flags);
                mddev = r10_bio->mddev;
-                conf = mddev_to_conf(mddev);
+                conf = mddev->private;
                if (test_bit(R10BIO_IsSync, &r10_bio->state)) {
                        sync_request_write(mddev, r10_bio);
                        unplug = 1;
@@ -1680,7 +1680,7 @@ static int init_resync(conf_t *conf)
 static sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *skipped, int go_faster)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        r10bio_t *r10_bio;
        struct bio *biolist = NULL, *bio;
        sector_t max_sector, nr_sectors;
@@ -2026,7 +2026,7 @@ static sector_t
 raid10_size(mddev_t *mddev, sector_t sectors, int raid_disks)
 {
        sector_t size;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        if (!raid_disks)
                raid_disks = mddev->raid_disks;
@@ -2050,9 +2050,10 @@ static int run(mddev_t *mddev)
        int nc, fc, fo;
        sector_t stride, size;
-        if (mddev->chunk_size < PAGE_SIZE) {
+        if (mddev->chunk_sectors < (PAGE_SIZE >> 9) ||
+            !is_power_of_2(mddev->chunk_sectors)) {
                printk(KERN_ERR "md/raid10: chunk size must be "
-                       "at least PAGE_SIZE(%ld).\n", PAGE_SIZE);
+                       "at least PAGE_SIZE(%ld) and be a power of 2.\n", PAGE_SIZE);
                return -EINVAL;
        }
@@ -2095,8 +2096,8 @@ static int run(mddev_t *mddev)
        conf->far_copies = fc;
        conf->copies = nc*fc;
        conf->far_offset = fo;
-        conf->chunk_mask = (sector_t)(mddev->chunk_size>>9)-1;
+        conf->chunk_mask = mddev->chunk_sectors - 1;
-        conf->chunk_shift = ffz(~mddev->chunk_size) - 9;
+        conf->chunk_shift = ffz(~mddev->chunk_sectors);
        size = mddev->dev_sectors >> conf->chunk_shift;
        sector_div(size, fc);
        size = size * conf->raid_disks;
@@ -2185,6 +2186,10 @@ static int run(mddev_t *mddev)
                goto out_free_conf;
        }
+        if (mddev->recovery_cp != MaxSector)
+                printk(KERN_NOTICE "raid10: %s is not clean"
+                       " -- starting background reconstruction\n",
+                       mdname(mddev));
        printk(KERN_INFO
                "raid10: raid set %s active with %d out of %d devices\n",
                mdname(mddev), mddev->raid_disks - mddev->degraded,
@@ -2204,7 +2209,8 @@ static int run(mddev_t *mddev)
         * maybe...
         */
        {
-                int stripe = conf->raid_disks * (mddev->chunk_size / PAGE_SIZE);
+                int stripe = conf->raid_disks *
+                        ((mddev->chunk_sectors << 9) / PAGE_SIZE);
                stripe /= conf->near_copies;
                if (mddev->queue->backing_dev_info.ra_pages < 2* stripe)
                        mddev->queue->backing_dev_info.ra_pages = 2* stripe;
@@ -2227,7 +2233,7 @@ out:
 static int stop(mddev_t *mddev)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        raise_barrier(conf, 0);
        lower_barrier(conf);
@@ -2245,7 +2251,7 @@ static int stop(mddev_t *mddev)
 static void raid10_quiesce(mddev_t *mddev, int state)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
        switch(state) {
        case 1:
diff --git a/drivers/md/raid10.h b/drivers/md/raid10.h
index 244dbe507a54..59cd1efb8d30 100644
--- a/drivers/md/raid10.h
+++ b/drivers/md/raid10.h
@@ -62,12 +62,6 @@ struct r10_private_data_s {
 typedef struct r10_private_data_s conf_t;
 /*
- * this is the only point in the RAID code where we violate
- * C type safety. mddev->private is an 'opaque' pointer.
- */
-#define mddev_to_conf(mddev) ((conf_t *) mddev->private)
-/*
 * this is our 'private' RAID10 bio.
 *
 * it contains information about what kind of IO operations were started
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index bef876698232..f9f991e6e138 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -1274,8 +1274,8 @@ static sector_t raid5_compute_sector(raid5_conf_t *conf, sector_t r_sector,
        sector_t new_sector;
        int algorithm = previous ? conf->prev_algo
                                 : conf->algorithm;
-        int sectors_per_chunk = previous ? (conf->prev_chunk >> 9)
+        int sectors_per_chunk = previous ? conf->prev_chunk_sectors
-                                         : (conf->chunk_size >> 9);
+                                         : conf->chunk_sectors;
        int raid_disks = previous ? conf->previous_raid_disks
                                  : conf->raid_disks;
        int data_disks = raid_disks - conf->max_degraded;
@@ -1480,8 +1480,8 @@ static sector_t compute_blocknr(struct stripe_head *sh, int i, int previous)
        int raid_disks = sh->disks;
        int data_disks = raid_disks - conf->max_degraded;
        sector_t new_sector = sh->sector, check;
-        int sectors_per_chunk = previous ? (conf->prev_chunk >> 9)
+        int sectors_per_chunk = previous ? conf->prev_chunk_sectors
-                                         : (conf->chunk_size >> 9);
+                                         : conf->chunk_sectors;
        int algorithm = previous ? conf->prev_algo
                                 : conf->algorithm;
        sector_t stripe;
@@ -1997,8 +1997,7 @@ static void stripe_set_idx(sector_t stripe, raid5_conf_t *conf, int previous,
                            struct stripe_head *sh)
 {
        int sectors_per_chunk =
-                previous ? (conf->prev_chunk >> 9)
+                previous ? conf->prev_chunk_sectors : conf->chunk_sectors;
-                         : (conf->chunk_size >> 9);
        int dd_idx;
        int chunk_offset = sector_div(stripe, sectors_per_chunk);
        int disks = previous ? conf->previous_raid_disks : conf->raid_disks;
@@ -3284,7 +3283,7 @@ static void activate_bit_delay(raid5_conf_t *conf)
 static void unplug_slaves(mddev_t *mddev)
 {
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
        int i;
        rcu_read_lock();
@@ -3308,7 +3307,7 @@ static void unplug_slaves(mddev_t *mddev)
 static void raid5_unplug_device(struct request_queue *q)
 {
        mddev_t *mddev = q->queuedata;
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
        unsigned long flags;
        spin_lock_irqsave(&conf->device_lock, flags);
@@ -3327,7 +3326,7 @@ static void raid5_unplug_device(struct request_queue *q)
 static int raid5_congested(void *data, int bits)
 {
        mddev_t *mddev = data;
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
        /* No difference between reads and writes.  Just check
         * how busy the stripe_cache is
@@ -3352,14 +3351,14 @@ static int raid5_mergeable_bvec(struct request_queue *q,
        mddev_t *mddev = q->queuedata;
        sector_t sector = bvm->bi_sector + get_start_sect(bvm->bi_bdev);
        int max;
-        unsigned int chunk_sectors = mddev->chunk_size >> 9;
+        unsigned int chunk_sectors = mddev->chunk_sectors;
        unsigned int bio_sectors = bvm->bi_size >> 9;
        if ((bvm->bi_rw & 1) == WRITE)
                return biovec->bv_len; /* always allow writes to be mergeable */
-        if (mddev->new_chunk < mddev->chunk_size)
+        if (mddev->new_chunk_sectors < mddev->chunk_sectors)
-                chunk_sectors = mddev->new_chunk >> 9;
+                chunk_sectors = mddev->new_chunk_sectors;
        max =  (chunk_sectors - ((sector & (chunk_sectors - 1)) + bio_sectors)) << 9;
        if (max < 0) max = 0;
        if (max <= biovec->bv_len && bio_sectors == 0)
@@ -3372,11 +3371,11 @@ static int raid5_mergeable_bvec(struct request_queue *q,
 static int in_chunk_boundary(mddev_t *mddev, struct bio *bio)
 {
        sector_t sector = bio->bi_sector + get_start_sect(bio->bi_bdev);
-        unsigned int chunk_sectors = mddev->chunk_size >> 9;
+        unsigned int chunk_sectors = mddev->chunk_sectors;
        unsigned int bio_sectors = bio->bi_size >> 9;
-        if (mddev->new_chunk < mddev->chunk_size)
+        if (mddev->new_chunk_sectors < mddev->chunk_sectors)
-                chunk_sectors = mddev->new_chunk >> 9;
+                chunk_sectors = mddev->new_chunk_sectors;
        return  chunk_sectors >=
                ((sector & (chunk_sectors - 1)) + bio_sectors);
 }
@@ -3440,7 +3439,7 @@ static void raid5_align_endio(struct bio *bi, int error)
        bio_put(bi);
        mddev = raid_bi->bi_bdev->bd_disk->queue->queuedata;
-        conf = mddev_to_conf(mddev);
+        conf = mddev->private;
        rdev = (void*)raid_bi->bi_next;
        raid_bi->bi_next = NULL;
@@ -3482,7 +3481,7 @@ static int bio_fits_rdev(struct bio *bi)
 static int chunk_aligned_read(struct request_queue *q, struct bio * raid_bio)
 {
        mddev_t *mddev = q->queuedata;
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
        unsigned int dd_idx;
        struct bio* align_bi;
        mdk_rdev_t *rdev;
@@ -3599,7 +3598,7 @@ static struct stripe_head *__get_priority_stripe(raid5_conf_t *conf)
 static int make_request(struct request_queue *q, struct bio * bi)
 {
        mddev_t *mddev = q->queuedata;
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
        int dd_idx;
        sector_t new_sector;
        sector_t logical_sector, last_sector;
@@ -3696,6 +3695,7 @@ static int make_request(struct request_queue *q, struct bio * bi)
                                spin_unlock_irq(&conf->device_lock);
                                if (must_retry) {
                                        release_stripe(sh);
+                                        schedule();
                                        goto retry;
                                }
                        }
@@ -3791,10 +3791,10 @@ static sector_t reshape_request(mddev_t *mddev, sector_t sector_nr, int *skipped
         * If old and new chunk sizes differ, we need to process the
         * largest of these
         */
-        if (mddev->new_chunk > mddev->chunk_size)
+        if (mddev->new_chunk_sectors > mddev->chunk_sectors)
-                reshape_sectors = mddev->new_chunk / 512;
+                reshape_sectors = mddev->new_chunk_sectors;
        else
-                reshape_sectors = mddev->chunk_size / 512;
+                reshape_sectors = mddev->chunk_sectors;
        /* we update the metadata when there is more than 3Meg
         * in the block range (that is rather arbitrary, should
@@ -3917,7 +3917,7 @@ static sector_t reshape_request(mddev_t *mddev, sector_t sector_nr, int *skipped
                                     1, &dd_idx, NULL);
        last_sector =
                raid5_compute_sector(conf, ((stripe_addr+reshape_sectors)
-                                            *(new_data_disks) - 1),
+                                            * new_data_disks - 1),
                                     1, &dd_idx, NULL);
        if (last_sector >= mddev->dev_sectors)
                last_sector = mddev->dev_sectors - 1;
@@ -3946,7 +3946,7 @@ static sector_t reshape_request(mddev_t *mddev, sector_t sector_nr, int *skipped
                wait_event(conf->wait_for_overlap,
                           atomic_read(&conf->reshape_stripes) == 0);
                mddev->reshape_position = conf->reshape_progress;
-                mddev->curr_resync_completed = mddev->curr_resync;
+                mddev->curr_resync_completed = mddev->curr_resync + reshape_sectors;
                conf->reshape_checkpoint = jiffies;
                set_bit(MD_CHANGE_DEVS, &mddev->flags);
                md_wakeup_thread(mddev->thread);
@@ -4129,7 +4129,7 @@ static int  retry_aligned_read(raid5_conf_t *conf, struct bio *raid_bio)
 static void raid5d(mddev_t *mddev)
 {
        struct stripe_head *sh;
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
        int handled;
        pr_debug("+++ raid5d active\n");
@@ -4185,7 +4185,7 @@ static void raid5d(mddev_t *mddev)
 static ssize_t
 raid5_show_stripe_cache_size(mddev_t *mddev, char *page)
 {
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
        if (conf)
                return sprintf(page, "%d\n", conf->max_nr_stripes);
        else
@@ -4195,7 +4195,7 @@ raid5_show_stripe_cache_size(mddev_t *mddev, char *page)
 static ssize_t
 raid5_store_stripe_cache_size(mddev_t *mddev, const char *page, size_t len)
 {
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
        unsigned long new;
        int err;
@@ -4233,7 +4233,7 @@ raid5_stripecache_size = __ATTR(stripe_cache_size, S_IRUGO | S_IWUSR,
 static ssize_t
 raid5_show_preread_threshold(mddev_t *mddev, char *page)
 {
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
        if (conf)
                return sprintf(page, "%d\n", conf->bypass_threshold);
        else
@@ -4243,7 +4243,7 @@ raid5_show_preread_threshold(mddev_t *mddev, char *page)
 static ssize_t
 raid5_store_preread_threshold(mddev_t *mddev, const char *page, size_t len)
 {
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
        unsigned long new;
        if (len >= PAGE_SIZE)
                return -EINVAL;
@@ -4267,7 +4267,7 @@ raid5_preread_bypass_threshold = __ATTR(preread_bypass_threshold,
 static ssize_t
 stripe_cache_active_show(mddev_t *mddev, char *page)
 {
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
        if (conf)
                return sprintf(page, "%d\n", atomic_read(&conf->active_stripes));
        else
@@ -4291,7 +4291,7 @@ static struct attribute_group raid5_attrs_group = {
 static sector_t
 raid5_size(mddev_t *mddev, sector_t sectors, int raid_disks)
 {
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
        if (!sectors)
                sectors = mddev->dev_sectors;
@@ -4303,8 +4303,8 @@ raid5_size(mddev_t *mddev, sector_t sectors, int raid_disks)
                        raid_disks = conf->previous_raid_disks;
        }
-        sectors &= ~((sector_t)mddev->chunk_size/512 - 1);
+        sectors &= ~((sector_t)mddev->chunk_sectors - 1);
-        sectors &= ~((sector_t)mddev->new_chunk/512 - 1);
+        sectors &= ~((sector_t)mddev->new_chunk_sectors - 1);
        return sectors * (raid_disks - conf->max_degraded);
 }
@@ -4336,9 +4336,11 @@ static raid5_conf_t *setup_conf(mddev_t *mddev)
                return ERR_PTR(-EINVAL);
        }
-        if (!mddev->new_chunk || mddev->new_chunk % PAGE_SIZE) {
+        if (!mddev->new_chunk_sectors ||
+            (mddev->new_chunk_sectors << 9) % PAGE_SIZE ||
+            !is_power_of_2(mddev->new_chunk_sectors)) {
                printk(KERN_ERR "raid5: invalid chunk size %d for %s\n",
-                        mddev->new_chunk, mdname(mddev));
+                       mddev->new_chunk_sectors << 9, mdname(mddev));
                return ERR_PTR(-EINVAL);
        }
@@ -4401,7 +4403,7 @@ static raid5_conf_t *setup_conf(mddev_t *mddev)
                        conf->fullsync = 1;
        }
-        conf->chunk_size = mddev->new_chunk;
+        conf->chunk_sectors = mddev->new_chunk_sectors;
        conf->level = mddev->new_level;
        if (conf->level == 6)
                conf->max_degraded = 2;
@@ -4411,7 +4413,7 @@ static raid5_conf_t *setup_conf(mddev_t *mddev)
        conf->max_nr_stripes = NR_STRIPES;
        conf->reshape_progress = mddev->reshape_position;
        if (conf->reshape_progress != MaxSector) {
-                conf->prev_chunk = mddev->chunk_size;
+                conf->prev_chunk_sectors = mddev->chunk_sectors;
                conf->prev_algo = mddev->layout;
        }
@@ -4453,6 +4455,10 @@ static int run(mddev_t *mddev)
        int working_disks = 0;
        mdk_rdev_t *rdev;
+        if (mddev->recovery_cp != MaxSector)
+                printk(KERN_NOTICE "raid5: %s is not clean"
+                       " -- starting background reconstruction\n",
+                       mdname(mddev));
        if (mddev->reshape_position != MaxSector) {
                /* Check that we can continue the reshape.
                 * Currently only disks can change, it must
@@ -4475,7 +4481,7 @@ static int run(mddev_t *mddev)
                 * geometry.
                 */
                here_new = mddev->reshape_position;
-                if (sector_div(here_new, (mddev->new_chunk>>9)*
+                if (sector_div(here_new, mddev->new_chunk_sectors *
                               (mddev->raid_disks - max_degraded))) {
                        printk(KERN_ERR "raid5: reshape_position not "
                               "on a stripe boundary\n");
@@ -4483,7 +4489,7 @@ static int run(mddev_t *mddev)
                }
                /* here_new is the stripe we will write to */
                here_old = mddev->reshape_position;
-                sector_div(here_old, (mddev->chunk_size>>9)*
+                sector_div(here_old, mddev->chunk_sectors *
                           (old_disks-max_degraded));
                /* here_old is the first stripe that we might need to read
                 * from */
@@ -4498,7 +4504,7 @@ static int run(mddev_t *mddev)
        } else {
                BUG_ON(mddev->level != mddev->new_level);
                BUG_ON(mddev->layout != mddev->new_layout);
-                BUG_ON(mddev->chunk_size != mddev->new_chunk);
+                BUG_ON(mddev->chunk_sectors != mddev->new_chunk_sectors);
                BUG_ON(mddev->delta_disks != 0);
        }
@@ -4532,7 +4538,7 @@ static int run(mddev_t *mddev)
        }
        /* device size must be a multiple of chunk size */
-        mddev->dev_sectors &= ~(mddev->chunk_size / 512 - 1);
+        mddev->dev_sectors &= ~(mddev->chunk_sectors - 1);
        mddev->resync_max_sectors = mddev->dev_sectors;
        if (mddev->degraded > 0 &&
@@ -4581,7 +4587,7 @@ static int run(mddev_t *mddev)
        {
                int data_disks = conf->previous_raid_disks - conf->max_degraded;
                int stripe = data_disks *
-                        (mddev->chunk_size / PAGE_SIZE);
+                        ((mddev->chunk_sectors << 9) / PAGE_SIZE);
                if (mddev->queue->backing_dev_info.ra_pages < 2 * stripe)
                        mddev->queue->backing_dev_info.ra_pages = 2 * stripe;
        }
@@ -4678,7 +4684,8 @@ static void status(struct seq_file *seq, mddev_t *mddev)
        raid5_conf_t *conf = (raid5_conf_t *) mddev->private;
        int i;
-        seq_printf (seq, " level %d, %dk chunk, algorithm %d", mddev->level, mddev->chunk_size >> 10, mddev->layout);
+        seq_printf(seq, " level %d, %dk chunk, algorithm %d", mddev->level,
+                mddev->chunk_sectors / 2, mddev->layout);
        seq_printf (seq, " [%d/%d] [", conf->raid_disks, conf->raid_disks - mddev->degraded);
        for (i = 0; i < conf->raid_disks; i++)
                seq_printf (seq, "%s",
@@ -4826,7 +4833,7 @@ static int raid5_resize(mddev_t *mddev, sector_t sectors)
         * any io in the removed space completes, but it hardly seems
         * worth it.
         */
-        sectors &= ~((sector_t)mddev->chunk_size/512 - 1);
+        sectors &= ~((sector_t)mddev->chunk_sectors - 1);
        md_set_array_sectors(mddev, raid5_size(mddev, sectors,
                                               mddev->raid_disks));
        if (mddev->array_sectors >
@@ -4843,14 +4850,37 @@ static int raid5_resize(mddev_t *mddev, sector_t sectors)
        return 0;
 }
-static int raid5_check_reshape(mddev_t *mddev)
+static int check_stripe_cache(mddev_t *mddev)
 {
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        /* Can only proceed if there are plenty of stripe_heads.
+         * We need a minimum of one full stripe,, and for sensible progress
+         * it is best to have about 4 times that.
+         * If we require 4 times, then the default 256 4K stripe_heads will
+         * allow for chunk sizes up to 256K, which is probably OK.
+         * If the chunk size is greater, user-space should request more
+         * stripe_heads first.
+         */
+        raid5_conf_t *conf = mddev->private;
+        if (((mddev->chunk_sectors << 9) / STRIPE_SIZE) * 4
+            > conf->max_nr_stripes ||
+            ((mddev->new_chunk_sectors << 9) / STRIPE_SIZE) * 4
+            > conf->max_nr_stripes) {
+                printk(KERN_WARNING "raid5: reshape: not enough stripes.  Needed %lu\n",
+                       ((max(mddev->chunk_sectors, mddev->new_chunk_sectors) << 9)
+                        / STRIPE_SIZE)*4);
+                return 0;
+        }
+        return 1;
+}
+static int check_reshape(mddev_t *mddev)
+{
+        raid5_conf_t *conf = mddev->private;
        if (mddev->delta_disks == 0 &&
            mddev->new_layout == mddev->layout &&
-            mddev->new_chunk == mddev->chunk_size)
+            mddev->new_chunk_sectors == mddev->chunk_sectors)
-                return -EINVAL; /* nothing to do */
+                return 0; /* nothing to do */
        if (mddev->bitmap)
                /* Cannot grow a bitmap yet */
                return -EBUSY;
@@ -4869,28 +4899,15 @@ static int raid5_check_reshape(mddev_t *mddev)
                        return -EINVAL;
        }
-        /* Can only proceed if there are plenty of stripe_heads.
+        if (!check_stripe_cache(mddev))
-         * We need a minimum of one full stripe,, and for sensible progress
-         * it is best to have about 4 times that.
-         * If we require 4 times, then the default 256 4K stripe_heads will
-         * allow for chunk sizes up to 256K, which is probably OK.
-         * If the chunk size is greater, user-space should request more
-         * stripe_heads first.
-         */
-        if ((mddev->chunk_size / STRIPE_SIZE) * 4 > conf->max_nr_stripes ||
-            (mddev->new_chunk / STRIPE_SIZE) * 4 > conf->max_nr_stripes) {
-                printk(KERN_WARNING "raid5: reshape: not enough stripes.  Needed %lu\n",
-                       (max(mddev->chunk_size, mddev->new_chunk)
-                        / STRIPE_SIZE)*4);
                return -ENOSPC;
-        }
        return resize_stripes(conf, conf->raid_disks + mddev->delta_disks);
 }
 static int raid5_start_reshape(mddev_t *mddev)
 {
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
        mdk_rdev_t *rdev;
        int spares = 0;
        int added_devices = 0;
@@ -4899,6 +4916,9 @@ static int raid5_start_reshape(mddev_t *mddev)
        if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
                return -EBUSY;
+        if (!check_stripe_cache(mddev))
+                return -ENOSPC;
        list_for_each_entry(rdev, &mddev->disks, same_set)
                if (rdev->raid_disk < 0 &&
                    !test_bit(Faulty, &rdev->flags))
@@ -4925,8 +4945,8 @@ static int raid5_start_reshape(mddev_t *mddev)
        spin_lock_irq(&conf->device_lock);
        conf->previous_raid_disks = conf->raid_disks;
        conf->raid_disks += mddev->delta_disks;
-        conf->prev_chunk = conf->chunk_size;
+        conf->prev_chunk_sectors = conf->chunk_sectors;
-        conf->chunk_size = mddev->new_chunk;
+        conf->chunk_sectors = mddev->new_chunk_sectors;
        conf->prev_algo = conf->algorithm;
        conf->algorithm = mddev->new_layout;
        if (mddev->delta_disks < 0)
@@ -5008,7 +5028,7 @@ static void end_reshape(raid5_conf_t *conf)
                 */
                {
                        int data_disks = conf->raid_disks - conf->max_degraded;
-                        int stripe = data_disks * (conf->chunk_size
+                        int stripe = data_disks * ((conf->chunk_sectors << 9)
                                                   / PAGE_SIZE);
                        if (conf->mddev->queue->backing_dev_info.ra_pages < 2 * stripe)
                                conf->mddev->queue->backing_dev_info.ra_pages = 2 * stripe;
@@ -5022,7 +5042,7 @@ static void end_reshape(raid5_conf_t *conf)
 static void raid5_finish_reshape(mddev_t *mddev)
 {
        struct block_device *bdev;
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
        if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
@@ -5053,7 +5073,7 @@ static void raid5_finish_reshape(mddev_t *mddev)
                                raid5_remove_disk(mddev, d);
                }
                mddev->layout = conf->algorithm;
-                mddev->chunk_size = conf->chunk_size;
+                mddev->chunk_sectors = conf->chunk_sectors;
                mddev->reshape_position = MaxSector;
                mddev->delta_disks = 0;
        }
@@ -5061,7 +5081,7 @@ static void raid5_finish_reshape(mddev_t *mddev)
 static void raid5_quiesce(mddev_t *mddev, int state)
 {
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
        switch(state) {
        case 2: /* resume for a suspend */
@@ -5111,7 +5131,7 @@ static void *raid5_takeover_raid1(mddev_t *mddev)
        mddev->new_level = 5;
        mddev->new_layout = ALGORITHM_LEFT_SYMMETRIC;
-        mddev->new_chunk = chunksect << 9;
+        mddev->new_chunk_sectors = chunksect;
        return setup_conf(mddev);
 }
@@ -5150,24 +5170,24 @@ static void *raid5_takeover_raid6(mddev_t *mddev)
 }
-static int raid5_reconfig(mddev_t *mddev, int new_layout, int new_chunk)
+static int raid5_check_reshape(mddev_t *mddev)
 {
        /* For a 2-drive array, the layout and chunk size can be changed
         * immediately as not restriping is needed.
         * For larger arrays we record the new value - after validation
         * to be used by a reshape pass.
         */
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
+        int new_chunk = mddev->new_chunk_sectors;
-        if (new_layout >= 0 && !algorithm_valid_raid5(new_layout))
+        if (mddev->new_layout >= 0 && !algorithm_valid_raid5(mddev->new_layout))
                return -EINVAL;
        if (new_chunk > 0) {
-                if (new_chunk & (new_chunk-1))
+                if (!is_power_of_2(new_chunk))
-                        /* not a power of 2 */
                        return -EINVAL;
-                if (new_chunk < PAGE_SIZE)
+                if (new_chunk < (PAGE_SIZE>>9))
                        return -EINVAL;
-                if (mddev->array_sectors & ((new_chunk>>9)-1))
+                if (mddev->array_sectors & (new_chunk-1))
                        /* not factor of array size */
                        return -EINVAL;
        }
@@ -5175,49 +5195,39 @@ static int raid5_reconfig(mddev_t *mddev, int new_layout, int new_chunk)
        /* They look valid */
        if (mddev->raid_disks == 2) {
+                /* can make the change immediately */
-                if (new_layout >= 0) {
+                if (mddev->new_layout >= 0) {
-                        conf->algorithm = new_layout;
+                        conf->algorithm = mddev->new_layout;
-                        mddev->layout = mddev->new_layout = new_layout;
+                        mddev->layout = mddev->new_layout;
                }
                if (new_chunk > 0) {
-                        conf->chunk_size = new_chunk;
+                        conf->chunk_sectors = new_chunk ;
-                        mddev->chunk_size = mddev->new_chunk = new_chunk;
+                        mddev->chunk_sectors = new_chunk;
                }
                set_bit(MD_CHANGE_DEVS, &mddev->flags);
                md_wakeup_thread(mddev->thread);
-        } else {
-                if (new_layout >= 0)
-                        mddev->new_layout = new_layout;
-                if (new_chunk > 0)
-                        mddev->new_chunk = new_chunk;
        }
-        return 0;
+        return check_reshape(mddev);
 }
-static int raid6_reconfig(mddev_t *mddev, int new_layout, int new_chunk)
+static int raid6_check_reshape(mddev_t *mddev)
 {
-        if (new_layout >= 0 && !algorithm_valid_raid6(new_layout))
+        int new_chunk = mddev->new_chunk_sectors;
+        if (mddev->new_layout >= 0 && !algorithm_valid_raid6(mddev->new_layout))
                return -EINVAL;
        if (new_chunk > 0) {
-                if (new_chunk & (new_chunk-1))
+                if (!is_power_of_2(new_chunk))
-                        /* not a power of 2 */
                        return -EINVAL;
-                if (new_chunk < PAGE_SIZE)
+                if (new_chunk < (PAGE_SIZE >> 9))
                        return -EINVAL;
-                if (mddev->array_sectors & ((new_chunk>>9)-1))
+                if (mddev->array_sectors & (new_chunk-1))
                        /* not factor of array size */
                        return -EINVAL;
        }
        /* They look valid */
+        return check_reshape(mddev);
-        if (new_layout >= 0)
-                mddev->new_layout = new_layout;
-        if (new_chunk > 0)
-                mddev->new_chunk = new_chunk;
-        return 0;
 }
 static void *raid5_takeover(mddev_t *mddev)
@@ -5227,8 +5237,6 @@ static void *raid5_takeover(mddev_t *mddev)
         *  raid1 - if there are two drives.  We need to know the chunk size
         *  raid4 - trivial - just use a raid4 layout.
         *  raid6 - Providing it is a *_6 layout
-         *
-         * For now, just do raid1
         */
        if (mddev->level == 1)
@@ -5310,12 +5318,11 @@ static struct mdk_personality raid6_personality =
        .sync_request   = sync_request,
        .resize         = raid5_resize,
        .size           = raid5_size,
-        .check_reshape  = raid5_check_reshape,
+        .check_reshape  = raid6_check_reshape,
        .start_reshape  = raid5_start_reshape,
        .finish_reshape = raid5_finish_reshape,
        .quiesce        = raid5_quiesce,
        .takeover       = raid6_takeover,
-        .reconfig       = raid6_reconfig,
 };
 static struct mdk_personality raid5_personality =
 {
@@ -5338,7 +5345,6 @@ static struct mdk_personality raid5_personality =
        .finish_reshape = raid5_finish_reshape,
        .quiesce        = raid5_quiesce,
        .takeover       = raid5_takeover,
-        .reconfig       = raid5_reconfig,
 };
 static struct mdk_personality raid4_personality =
diff --git a/drivers/md/raid5.h b/drivers/md/raid5.h
index 52ba99954dec..9459689c4ea0 100644
--- a/drivers/md/raid5.h
+++ b/drivers/md/raid5.h
@@ -334,7 +334,8 @@ struct raid5_private_data {
        struct hlist_head       *stripe_hashtbl;
        mddev_t                 *mddev;
        struct disk_info        *spare;
-        int                     chunk_size, level, algorithm;
+        int                     chunk_sectors;
+        int                     level, algorithm;
        int                     max_degraded;
        int                     raid_disks;
        int                     max_nr_stripes;
@@ -350,7 +351,8 @@ struct raid5_private_data {
         */
        sector_t                reshape_safe;
        int                     previous_raid_disks;
-        int                     prev_chunk, prev_algo;
+        int                     prev_chunk_sectors;
+        int                     prev_algo;
        short                   generation; /* increments with every reshape */
        unsigned long           reshape_checkpoint; /* Time we last updated
                                                     * metadata */
@@ -408,8 +410,6 @@ struct raid5_private_data {
 typedef struct raid5_private_data raid5_conf_t;
-#define mddev_to_conf(mddev) ((raid5_conf_t *) mddev->private)
 /*
 * Our supported algorithms
 */
diff --git a/drivers/media/video/ov772x.c b/drivers/media/video/ov772x.c
index c0d911252862..0bce255168bd 100644
--- a/drivers/media/video/ov772x.c
+++ b/drivers/media/video/ov772x.c
@@ -1067,10 +1067,12 @@ static int ov772x_probe(struct i2c_client *client,
        struct i2c_adapter        *adapter = to_i2c_adapter(client->dev.parent);
        int                        ret;
-        info = client->dev.platform_data;
+        if (!client->dev.platform_data)
-        if (!info)
                return -EINVAL;
+        info = container_of(client->dev.platform_data,
+                            struct ov772x_camera_info, link);
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
                dev_err(&adapter->dev,
                        "I2C-Adapter doesn't support "
diff --git a/drivers/media/video/tw9910.c b/drivers/media/video/tw9910.c
index a39947643992..aa5065ea09ed 100644
--- a/drivers/media/video/tw9910.c
+++ b/drivers/media/video/tw9910.c
@@ -875,10 +875,12 @@ static int tw9910_probe(struct i2c_client *client,
        const struct tw9910_scale_ctrl *scale;
        int                             i, ret;
-        info = client->dev.platform_data;
+        if (!client->dev.platform_data)
-        if (!info)
                return -EINVAL;
+        info = container_of(client->dev.platform_data,
+                            struct tw9910_video_info, link);
        if (!i2c_check_functionality(to_i2c_adapter(client->dev.parent),
                                     I2C_FUNC_SMBUS_BYTE_DATA)) {
                dev_err(&client->dev,
diff --git a/drivers/message/fusion/mptbase.c b/drivers/message/fusion/mptbase.c
index 0df065275cd3..5d0ba4f5924c 100644
--- a/drivers/message/fusion/mptbase.c
+++ b/drivers/message/fusion/mptbase.c
@@ -4414,11 +4414,11 @@ PrimeIocFifos(MPT_ADAPTER *ioc)
                 * 1078 errata workaround for the 36GB limitation
                 */
                if (ioc->pcidev->device == MPI_MANUFACTPAGE_DEVID_SAS1078 &&
-                    ioc->dma_mask > DMA_35BIT_MASK) {
+                    ioc->dma_mask > DMA_BIT_MASK(35)) {
                        if (!pci_set_dma_mask(ioc->pcidev, DMA_BIT_MASK(32))
                            && !pci_set_consistent_dma_mask(ioc->pcidev,
                            DMA_BIT_MASK(32))) {
-                                dma_mask = DMA_35BIT_MASK;
+                                dma_mask = DMA_BIT_MASK(35);
                                d36memprintk(ioc, printk(MYIOC_s_DEBUG_FMT
                                    "setting 35 bit addressing for "
                                    "Request/Reply/Chain and Sense Buffers\n",
@@ -4575,7 +4575,7 @@ PrimeIocFifos(MPT_ADAPTER *ioc)
                alloc_dma += ioc->reply_sz;
        }
-        if (dma_mask == DMA_35BIT_MASK && !pci_set_dma_mask(ioc->pcidev,
+        if (dma_mask == DMA_BIT_MASK(35) && !pci_set_dma_mask(ioc->pcidev,
            ioc->dma_mask) && !pci_set_consistent_dma_mask(ioc->pcidev,
            ioc->dma_mask))
                d36memprintk(ioc, printk(MYIOC_s_DEBUG_FMT
@@ -4602,7 +4602,7 @@ out_fail:
                ioc->sense_buf_pool = NULL;
        }
-        if (dma_mask == DMA_35BIT_MASK && !pci_set_dma_mask(ioc->pcidev,
+        if (dma_mask == DMA_BIT_MASK(35) && !pci_set_dma_mask(ioc->pcidev,
            DMA_BIT_MASK(64)) && !pci_set_consistent_dma_mask(ioc->pcidev,
            DMA_BIT_MASK(64)))
                d36memprintk(ioc, printk(MYIOC_s_DEBUG_FMT
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index ee3927ab11e0..491ac0f800d2 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -30,6 +30,7 @@ config MFD_SM501_GPIO
 config MFD_ASIC3
        bool "Support for Compaq ASIC3"
        depends on GENERIC_HARDIRQS && GPIOLIB && ARM
+        select MFD_CORE
         ---help---
          This driver supports the ASIC3 multifunction chip found on many
          PDAs (mainly iPAQ and HTC based ones)
@@ -152,7 +153,7 @@ config MFD_WM8400
        depends on I2C
        help
          Support for the Wolfson Microelecronics WM8400 PMIC and audio
-          CODEC.  This driver adds provides common support for accessing
+          CODEC.  This driver provides common support for accessing
          the device, additional drivers must be enabled in order to use
          the functionality of the device.
@@ -241,6 +242,27 @@ config PCF50633_GPIO
         Say yes here if you want to include support GPIO for pins on
         the PCF50633 chip.
+config AB3100_CORE
+        tristate "ST-Ericsson AB3100 Mixed Signal Circuit core functions"
+        depends on I2C
+        default y if ARCH_U300
+        help
+          Select this to enable the AB3100 Mixed Signal IC core
+          functionality. This connects to a AB3100 on the I2C bus
+          and expose a number of symbols needed for dependent devices
+          to read and write registers and subscribe to events from
+          this multi-functional IC. This is needed to use other features
+          of the AB3100 such as battery-backed RTC, charging control,
+          LEDs, vibrator, system power and temperature, power management
+          and ALSA sound.
+config EZX_PCAP
+        bool "PCAP Support"
+        depends on GENERIC_HARDIRQS && SPI_MASTER
+        help
+          This enables the PCAP ASIC present on EZX Phones. This is
+          needed for MMC, TouchScreen, Sound, USB, etc..
 endmenu
 menu "Multimedia Capabilities Port drivers"
diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
index 3afb5192e4da..6f8a9a1af20b 100644
--- a/drivers/mfd/Makefile
+++ b/drivers/mfd/Makefile
@@ -26,6 +26,8 @@ obj-$(CONFIG_TWL4030_CORE)	+= twl4030-core.o twl4030-irq.o
 obj-$(CONFIG_MFD_CORE)          += mfd-core.o
+obj-$(CONFIG_EZX_PCAP)          += ezx-pcap.o
 obj-$(CONFIG_MCP)               += mcp-core.o
 obj-$(CONFIG_MCP_SA11X0)        += mcp-sa11x0.o
 obj-$(CONFIG_MCP_UCB1200)       += ucb1x00-core.o
@@ -40,4 +42,5 @@ obj-$(CONFIG_PMIC_DA903X)	+= da903x.o
 obj-$(CONFIG_MFD_PCF50633)      += pcf50633-core.o
 obj-$(CONFIG_PCF50633_ADC)      += pcf50633-adc.o
-obj-$(CONFIG_PCF50633_GPIO)     += pcf50633-gpio.o
-\ No newline at end of file
+obj-$(CONFIG_PCF50633_GPIO)     += pcf50633-gpio.o
+obj-$(CONFIG_AB3100_CORE)       += ab3100-core.o
diff --git a/drivers/mfd/ab3100-core.c b/drivers/mfd/ab3100-core.c
new file mode 100644
index 000000000000..13e7d7bfe85f
--- /dev/null
+++ b/drivers/mfd/ab3100-core.c
@@ -0,0 +1,991 @@
+/*
+ * Copyright (C) 2007-2009 ST-Ericsson
+ * License terms: GNU General Public License (GPL) version 2
+ * Low-level core for exclusive access to the AB3100 IC on the I2C bus
+ * and some basic chip-configuration.
+ * Author: Linus Walleij <linus.walleij@stericsson.com>
+ */
+#include <linux/i2c.h>
+#include <linux/mutex.h>
+#include <linux/list.h>
+#include <linux/notifier.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/device.h>
+#include <linux/interrupt.h>
+#include <linux/workqueue.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+#include <linux/uaccess.h>
+#include <linux/mfd/ab3100.h>
+/* These are the only registers inside AB3100 used in this main file */
+/* Interrupt event registers */
+#define AB3100_EVENTA1          0x21
+#define AB3100_EVENTA2          0x22
+#define AB3100_EVENTA3          0x23
+/* AB3100 DAC converter registers */
+#define AB3100_DIS              0x00
+#define AB3100_D0C              0x01
+#define AB3100_D1C              0x02
+#define AB3100_D2C              0x03
+#define AB3100_D3C              0x04
+/* Chip ID register */
+#define AB3100_CID              0x20
+/* AB3100 interrupt registers */
+#define AB3100_IMRA1            0x24
+#define AB3100_IMRA2            0x25
+#define AB3100_IMRA3            0x26
+#define AB3100_IMRB1            0x2B
+#define AB3100_IMRB2            0x2C
+#define AB3100_IMRB3            0x2D
+/* System Power Monitoring and control registers */
+#define AB3100_MCA              0x2E
+#define AB3100_MCB              0x2F
+/* SIM power up */
+#define AB3100_SUP              0x50
+/*
+ * I2C communication
+ *
+ * The AB3100 is usually assigned address 0x48 (7-bit)
+ * The chip is defined in the platform i2c_board_data section.
+ */
+static unsigned short normal_i2c[] = { 0x48, I2C_CLIENT_END };
+I2C_CLIENT_INSMOD_1(ab3100);
+u8 ab3100_get_chip_type(struct ab3100 *ab3100)
+{
+        u8 chip = ABUNKNOWN;
+        switch (ab3100->chip_id & 0xf0) {
+        case  0xa0:
+                chip = AB3000;
+                break;
+        case  0xc0:
+                chip = AB3100;
+                break;
+        }
+        return chip;
+}
+EXPORT_SYMBOL(ab3100_get_chip_type);
+int ab3100_set_register(struct ab3100 *ab3100, u8 reg, u8 regval)
+{
+        u8 regandval[2] = {reg, regval};
+        int err;
+        err = mutex_lock_interruptible(&ab3100->access_mutex);
+        if (err)
+                return err;
+        /*
+         * A two-byte write message with the first byte containing the register
+         * number and the second byte containing the value to be written
+         * effectively sets a register in the AB3100.
+         */
+        err = i2c_master_send(ab3100->i2c_client, regandval, 2);
+        if (err < 0) {
+                dev_err(ab3100->dev,
+                        "write error (write register): %d\n",
+                        err);
+        } else if (err != 2) {
+                dev_err(ab3100->dev,
+                        "write error (write register) "
+                        "%d bytes transferred (expected 2)\n",
+                        err);
+                err = -EIO;
+        } else {
+                /* All is well */
+                err = 0;
+        }
+        mutex_unlock(&ab3100->access_mutex);
+        return 0;
+}
+EXPORT_SYMBOL(ab3100_set_register);
+/*
+ * The test registers exist at an I2C bus address up one
+ * from the ordinary base. They are not supposed to be used
+ * in production code, but sometimes you have to do that
+ * anyway. It's currently only used from this file so declare
+ * it static and do not export.
+ */
+static int ab3100_set_test_register(struct ab3100 *ab3100,
+                                    u8 reg, u8 regval)
+{
+        u8 regandval[2] = {reg, regval};
+        int err;
+        err = mutex_lock_interruptible(&ab3100->access_mutex);
+        if (err)
+                return err;
+        err = i2c_master_send(ab3100->testreg_client, regandval, 2);
+        if (err < 0) {
+                dev_err(ab3100->dev,
+                        "write error (write test register): %d\n",
+                        err);
+        } else if (err != 2) {
+                dev_err(ab3100->dev,
+                        "write error (write test register) "
+                        "%d bytes transferred (expected 2)\n",
+                        err);
+                err = -EIO;
+        } else {
+                /* All is well */
+                err = 0;
+        }
+        mutex_unlock(&ab3100->access_mutex);
+        return err;
+}
+int ab3100_get_register(struct ab3100 *ab3100, u8 reg, u8 *regval)
+{
+        int err;
+        err = mutex_lock_interruptible(&ab3100->access_mutex);
+        if (err)
+                return err;
+        /*
+         * AB3100 require an I2C "stop" command between each message, else
+         * it will not work. The only way of achieveing this with the
+         * message transport layer is to send the read and write messages
+         * separately.
+         */
+        err = i2c_master_send(ab3100->i2c_client, &reg, 1);
+        if (err < 0) {
+                dev_err(ab3100->dev,
+                        "write error (send register address): %d\n",
+                        err);
+                goto get_reg_out_unlock;
+        } else if (err != 1) {
+                dev_err(ab3100->dev,
+                        "write error (send register address) "
+                        "%d bytes transferred (expected 1)\n",
+                        err);
+                err = -EIO;
+                goto get_reg_out_unlock;
+        } else {
+                /* All is well */
+                err = 0;
+        }
+        err = i2c_master_recv(ab3100->i2c_client, regval, 1);
+        if (err < 0) {
+                dev_err(ab3100->dev,
+                        "write error (read register): %d\n",
+                        err);
+                goto get_reg_out_unlock;
+        } else if (err != 1) {
+                dev_err(ab3100->dev,
+                        "write error (read register) "
+                        "%d bytes transferred (expected 1)\n",
+                        err);
+                err = -EIO;
+                goto get_reg_out_unlock;
+        } else {
+                /* All is well */
+                err = 0;
+        }
+ get_reg_out_unlock:
+        mutex_unlock(&ab3100->access_mutex);
+        return err;
+}
+EXPORT_SYMBOL(ab3100_get_register);
+int ab3100_get_register_page(struct ab3100 *ab3100,
+                             u8 first_reg, u8 *regvals, u8 numregs)
+{
+        int err;
+        if (ab3100->chip_id == 0xa0 ||
+            ab3100->chip_id == 0xa1)
+                /* These don't support paged reads */
+                return -EIO;
+        err = mutex_lock_interruptible(&ab3100->access_mutex);
+        if (err)
+                return err;
+        /*
+         * Paged read also require an I2C "stop" command.
+         */
+        err = i2c_master_send(ab3100->i2c_client, &first_reg, 1);
+        if (err < 0) {
+                dev_err(ab3100->dev,
+                        "write error (send first register address): %d\n",
+                        err);
+                goto get_reg_page_out_unlock;
+        } else if (err != 1) {
+                dev_err(ab3100->dev,
+                        "write error (send first register address) "
+                        "%d bytes transferred (expected 1)\n",
+                        err);
+                err = -EIO;
+                goto get_reg_page_out_unlock;
+        }
+        err = i2c_master_recv(ab3100->i2c_client, regvals, numregs);
+        if (err < 0) {
+                dev_err(ab3100->dev,
+                        "write error (read register page): %d\n",
+                        err);
+                goto get_reg_page_out_unlock;
+        } else if (err != numregs) {
+                dev_err(ab3100->dev,
+                        "write error (read register page) "
+                        "%d bytes transferred (expected %d)\n",
+                        err, numregs);
+                err = -EIO;
+                goto get_reg_page_out_unlock;
+        }
+        /* All is well */
+        err = 0;
+ get_reg_page_out_unlock:
+        mutex_unlock(&ab3100->access_mutex);
+        return err;
+}
+EXPORT_SYMBOL(ab3100_get_register_page);
+int ab3100_mask_and_set_register(struct ab3100 *ab3100,
+                                 u8 reg, u8 andmask, u8 ormask)
+{
+        u8 regandval[2] = {reg, 0};
+        int err;
+        err = mutex_lock_interruptible(&ab3100->access_mutex);
+        if (err)
+                return err;
+        /* First read out the target register */
+        err = i2c_master_send(ab3100->i2c_client, &reg, 1);
+        if (err < 0) {
+                dev_err(ab3100->dev,
+                        "write error (maskset send address): %d\n",
+                        err);
+                goto get_maskset_unlock;
+        } else if (err != 1) {
+                dev_err(ab3100->dev,
+                        "write error (maskset send address) "
+                        "%d bytes transferred (expected 1)\n",
+                        err);
+                err = -EIO;
+                goto get_maskset_unlock;
+        }
+        err = i2c_master_recv(ab3100->i2c_client, &regandval[1], 1);
+        if (err < 0) {
+                dev_err(ab3100->dev,
+                        "write error (maskset read register): %d\n",
+                        err);
+                goto get_maskset_unlock;
+        } else if (err != 1) {
+                dev_err(ab3100->dev,
+                        "write error (maskset read register) "
+                        "%d bytes transferred (expected 1)\n",
+                        err);
+                err = -EIO;
+                goto get_maskset_unlock;
+        }
+        /* Modify the register */
+        regandval[1] &= andmask;
+        regandval[1] |= ormask;
+        /* Write the register */
+        err = i2c_master_send(ab3100->i2c_client, regandval, 2);
+        if (err < 0) {
+                dev_err(ab3100->dev,
+                        "write error (write register): %d\n",
+                        err);
+                goto get_maskset_unlock;
+        } else if (err != 2) {
+                dev_err(ab3100->dev,
+                        "write error (write register) "
+                        "%d bytes transferred (expected 2)\n",
+                        err);
+                err = -EIO;
+                goto get_maskset_unlock;
+        }
+        /* All is well */
+        err = 0;
+ get_maskset_unlock:
+        mutex_unlock(&ab3100->access_mutex);
+        return err;
+}
+EXPORT_SYMBOL(ab3100_mask_and_set_register);
+/*
+ * Register a simple callback for handling any AB3100 events.
+ */
+int ab3100_event_register(struct ab3100 *ab3100,
+                          struct notifier_block *nb)
+{
+        return blocking_notifier_chain_register(&ab3100->event_subscribers,
+                                               nb);
+}
+EXPORT_SYMBOL(ab3100_event_register);
+/*
+ * Remove a previously registered callback.
+ */
+int ab3100_event_unregister(struct ab3100 *ab3100,
+                            struct notifier_block *nb)
+{
+  return blocking_notifier_chain_unregister(&ab3100->event_subscribers,
+                                            nb);
+}
+EXPORT_SYMBOL(ab3100_event_unregister);
+int ab3100_event_registers_startup_state_get(struct ab3100 *ab3100,
+                                             u32 *fatevent)
+{
+        if (!ab3100->startup_events_read)
+                return -EAGAIN; /* Try again later */
+        *fatevent = ab3100->startup_events;
+        return 0;
+}
+EXPORT_SYMBOL(ab3100_event_registers_startup_state_get);
+/* Interrupt handling worker */
+static void ab3100_work(struct work_struct *work)
+{
+        struct ab3100 *ab3100 = container_of(work, struct ab3100, work);
+        u8 event_regs[3];
+        u32 fatevent;
+        int err;
+        err = ab3100_get_register_page(ab3100, AB3100_EVENTA1,
+                                       event_regs, 3);
+        if (err)
+                goto err_event_wq;
+        fatevent = (event_regs[0] << 16) |
+                (event_regs[1] << 8) |
+                event_regs[2];
+        if (!ab3100->startup_events_read) {
+                ab3100->startup_events = fatevent;
+                ab3100->startup_events_read = true;
+        }
+        /*
+         * The notified parties will have to mask out the events
+         * they're interested in and react to them. They will be
+         * notified on all events, then they use the fatevent value
+         * to determine if they're interested.
+         */
+        blocking_notifier_call_chain(&ab3100->event_subscribers,
+                                     fatevent, NULL);
+        dev_dbg(ab3100->dev,
+                "IRQ Event: 0x%08x\n", fatevent);
+        /* By now the IRQ should be acked and deasserted so enable it again */
+        enable_irq(ab3100->i2c_client->irq);
+        return;
+ err_event_wq:
+        dev_dbg(ab3100->dev,
+                "error in event workqueue\n");
+        /* Enable the IRQ anyway, what choice do we have? */
+        enable_irq(ab3100->i2c_client->irq);
+        return;
+}
+static irqreturn_t ab3100_irq_handler(int irq, void *data)
+{
+        struct ab3100 *ab3100 = data;
+        /*
+         * Disable the IRQ and dispatch a worker to handle the
+         * event. Since the chip resides on I2C this is slow
+         * stuff and we will re-enable the interrupts once th
+         * worker has finished.
+         */
+        disable_irq(ab3100->i2c_client->irq);
+        schedule_work(&ab3100->work);
+        return IRQ_HANDLED;
+}
+#ifdef CONFIG_DEBUG_FS
+/*
+ * Some debugfs entries only exposed if we're using debug
+ */
+static int ab3100_registers_print(struct seq_file *s, void *p)
+{
+        struct ab3100 *ab3100 = s->private;
+        u8 value;
+        u8 reg;
+        seq_printf(s, "AB3100 registers:\n");
+        for (reg = 0; reg < 0xff; reg++) {
+                ab3100_get_register(ab3100, reg, &value);
+                seq_printf(s, "[0x%x]:  0x%x\n", reg, value);
+        }
+        return 0;
+}
+static int ab3100_registers_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, ab3100_registers_print, inode->i_private);
+}
+static const struct file_operations ab3100_registers_fops = {
+        .open = ab3100_registers_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+struct ab3100_get_set_reg_priv {
+        struct ab3100 *ab3100;
+        bool mode;
+};
+static int ab3100_get_set_reg_open_file(struct inode *inode, struct file *file)
+{
+        file->private_data = inode->i_private;
+        return 0;
+}
+static int ab3100_get_set_reg(struct file *file,
+                              const char __user *user_buf,
+                              size_t count, loff_t *ppos)
+{
+        struct ab3100_get_set_reg_priv *priv = file->private_data;
+        struct ab3100 *ab3100 = priv->ab3100;
+        char buf[32];
+        int buf_size;
+        int regp;
+        unsigned long user_reg;
+        int err;
+        int i = 0;
+        /* Get userspace string and assure termination */
+        buf_size = min(count, (sizeof(buf)-1));
+        if (copy_from_user(buf, user_buf, buf_size))
+                return -EFAULT;
+        buf[buf_size] = 0;
+        /*
+         * The idea is here to parse a string which is either
+         * "0xnn" for reading a register, or "0xaa 0xbb" for
+         * writing 0xbb to the register 0xaa. First move past
+         * whitespace and then begin to parse the register.
+         */
+        while ((i < buf_size) && (buf[i] == ' '))
+                i++;
+        regp = i;
+        /*
+         * Advance pointer to end of string then terminate
+         * the register string. This is needed to satisfy
+         * the strict_strtoul() function.
+         */
+        while ((i < buf_size) && (buf[i] != ' '))
+                i++;
+        buf[i] = '\0';
+        err = strict_strtoul(&buf[regp], 16, &user_reg);
+        if (err)
+                return err;
+        if (user_reg > 0xff)
+                return -EINVAL;
+        /* Either we read or we write a register here */
+        if (!priv->mode) {
+                /* Reading */
+                u8 reg = (u8) user_reg;
+                u8 regvalue;
+                ab3100_get_register(ab3100, reg, &regvalue);
+                dev_info(ab3100->dev,
+                         "debug read AB3100 reg[0x%02x]: 0x%02x\n",
+                         reg, regvalue);
+        } else {
+                int valp;
+                unsigned long user_value;
+                u8 reg = (u8) user_reg;
+                u8 value;
+                u8 regvalue;
+                /*
+                 * Writing, we need some value to write to
+                 * the register so keep parsing the string
+                 * from userspace.
+                 */
+                i++;
+                while ((i < buf_size) && (buf[i] == ' '))
+                        i++;
+                valp = i;
+                while ((i < buf_size) && (buf[i] != ' '))
+                        i++;
+                buf[i] = '\0';
+                err = strict_strtoul(&buf[valp], 16, &user_value);
+                if (err)
+                        return err;
+                if (user_reg > 0xff)
+                        return -EINVAL;
+                value = (u8) user_value;
+                ab3100_set_register(ab3100, reg, value);
+                ab3100_get_register(ab3100, reg, &regvalue);
+                dev_info(ab3100->dev,
+                         "debug write reg[0x%02x] with 0x%02x, "
+                         "after readback: 0x%02x\n",
+                         reg, value, regvalue);
+        }
+        return buf_size;
+}
+static const struct file_operations ab3100_get_set_reg_fops = {
+        .open = ab3100_get_set_reg_open_file,
+        .write = ab3100_get_set_reg,
+};
+static struct dentry *ab3100_dir;
+static struct dentry *ab3100_reg_file;
+static struct ab3100_get_set_reg_priv ab3100_get_priv;
+static struct dentry *ab3100_get_reg_file;
+static struct ab3100_get_set_reg_priv ab3100_set_priv;
+static struct dentry *ab3100_set_reg_file;
+static void ab3100_setup_debugfs(struct ab3100 *ab3100)
+{
+        int err;
+        ab3100_dir = debugfs_create_dir("ab3100", NULL);
+        if (!ab3100_dir)
+                goto exit_no_debugfs;
+        ab3100_reg_file = debugfs_create_file("registers",
+                                S_IRUGO, ab3100_dir, ab3100,
+                                &ab3100_registers_fops);
+        if (!ab3100_reg_file) {
+                err = -ENOMEM;
+                goto exit_destroy_dir;
+        }
+        ab3100_get_priv.ab3100 = ab3100;
+        ab3100_get_priv.mode = false;
+        ab3100_get_reg_file = debugfs_create_file("get_reg",
+                                S_IWUGO, ab3100_dir, &ab3100_get_priv,
+                                &ab3100_get_set_reg_fops);
+        if (!ab3100_get_reg_file) {
+                err = -ENOMEM;
+                goto exit_destroy_reg;
+        }
+        ab3100_set_priv.ab3100 = ab3100;
+        ab3100_set_priv.mode = true;
+        ab3100_set_reg_file = debugfs_create_file("set_reg",
+                                S_IWUGO, ab3100_dir, &ab3100_set_priv,
+                                &ab3100_get_set_reg_fops);
+        if (!ab3100_set_reg_file) {
+                err = -ENOMEM;
+                goto exit_destroy_get_reg;
+        }
+        return;
+ exit_destroy_get_reg:
+        debugfs_remove(ab3100_get_reg_file);
+ exit_destroy_reg:
+        debugfs_remove(ab3100_reg_file);
+ exit_destroy_dir:
+        debugfs_remove(ab3100_dir);
+ exit_no_debugfs:
+        return;
+}
+static inline void ab3100_remove_debugfs(void)
+{
+        debugfs_remove(ab3100_set_reg_file);
+        debugfs_remove(ab3100_get_reg_file);
+        debugfs_remove(ab3100_reg_file);
+        debugfs_remove(ab3100_dir);
+}
+#else
+static inline void ab3100_setup_debugfs(struct ab3100 *ab3100)
+{
+}
+static inline void ab3100_remove_debugfs(void)
+{
+}
+#endif
+/*
+ * Basic set-up, datastructure creation/destruction and I2C interface.
+ * This sets up a default config in the AB3100 chip so that it
+ * will work as expected.
+ */
+struct ab3100_init_setting {
+        u8 abreg;
+        u8 setting;
+};
+static const struct ab3100_init_setting __initdata
+ab3100_init_settings[] = {
+        {
+                .abreg = AB3100_MCA,
+                .setting = 0x01
+        }, {
+                .abreg = AB3100_MCB,
+                .setting = 0x30
+        }, {
+                .abreg = AB3100_IMRA1,
+                .setting = 0x00
+        }, {
+                .abreg = AB3100_IMRA2,
+                .setting = 0xFF
+        }, {
+                .abreg = AB3100_IMRA3,
+                .setting = 0x01
+        }, {
+                .abreg = AB3100_IMRB1,
+                .setting = 0xFF
+        }, {
+                .abreg = AB3100_IMRB2,
+                .setting = 0xFF
+        }, {
+                .abreg = AB3100_IMRB3,
+                .setting = 0xFF
+        }, {
+                .abreg = AB3100_SUP,
+                .setting = 0x00
+        }, {
+                .abreg = AB3100_DIS,
+                .setting = 0xF0
+        }, {
+                .abreg = AB3100_D0C,
+                .setting = 0x00
+        }, {
+                .abreg = AB3100_D1C,
+                .setting = 0x00
+        }, {
+                .abreg = AB3100_D2C,
+                .setting = 0x00
+        }, {
+                .abreg = AB3100_D3C,
+                .setting = 0x00
+        },
+};
+static int __init ab3100_setup(struct ab3100 *ab3100)
+{
+        int err = 0;
+        int i;
+        for (i = 0; i < ARRAY_SIZE(ab3100_init_settings); i++) {
+                err = ab3100_set_register(ab3100,
+                                          ab3100_init_settings[i].abreg,
+                                          ab3100_init_settings[i].setting);
+                if (err)
+                        goto exit_no_setup;
+        }
+        /*
+         * Special trick to make the AB3100 use the 32kHz clock (RTC)
+         * bit 3 in test registe 0x02 is a special, undocumented test
+         * register bit that only exist in AB3100 P1E
+         */
+        if (ab3100->chip_id == 0xc4) {
+                dev_warn(ab3100->dev,
+                         "AB3100 P1E variant detected, "
+                         "forcing chip to 32KHz\n");
+                err = ab3100_set_test_register(ab3100, 0x02, 0x08);
+        }
+ exit_no_setup:
+        return err;
+}
+/*
+ * Here we define all the platform devices that appear
+ * as children of the AB3100. These are regular platform
+ * devices with the IORESOURCE_IO .start and .end set
+ * to correspond to the internal AB3100 register range
+ * mapping to the corresponding subdevice.
+ */
+#define AB3100_DEVICE(devname, devid)                           \
+static struct platform_device ab3100_##devname##_device = {     \
+        .name           = devid,                                \
+        .id             = -1,                                   \
+}
+/*
+ * This lists all the subdevices and corresponding register
+ * ranges.
+ */
+AB3100_DEVICE(dac, "ab3100-dac");
+AB3100_DEVICE(leds, "ab3100-leds");
+AB3100_DEVICE(power, "ab3100-power");
+AB3100_DEVICE(regulators, "ab3100-regulators");
+AB3100_DEVICE(sim, "ab3100-sim");
+AB3100_DEVICE(uart, "ab3100-uart");
+AB3100_DEVICE(rtc, "ab3100-rtc");
+AB3100_DEVICE(charger, "ab3100-charger");
+AB3100_DEVICE(boost, "ab3100-boost");
+AB3100_DEVICE(adc, "ab3100-adc");
+AB3100_DEVICE(fuelgauge, "ab3100-fuelgauge");
+AB3100_DEVICE(vibrator, "ab3100-vibrator");
+AB3100_DEVICE(otp, "ab3100-otp");
+AB3100_DEVICE(codec, "ab3100-codec");
+static struct platform_device *
+ab3100_platform_devs[] = {
+        &ab3100_dac_device,
+        &ab3100_leds_device,
+        &ab3100_power_device,
+        &ab3100_regulators_device,
+        &ab3100_sim_device,
+        &ab3100_uart_device,
+        &ab3100_rtc_device,
+        &ab3100_charger_device,
+        &ab3100_boost_device,
+        &ab3100_adc_device,
+        &ab3100_fuelgauge_device,
+        &ab3100_vibrator_device,
+        &ab3100_otp_device,
+        &ab3100_codec_device,
+};
+struct ab_family_id {
+        u8      id;
+        char    *name;
+};
+static const struct ab_family_id ids[] __initdata = {
+        /* AB3100 */
+        {
+                .id = 0xc0,
+                .name = "P1A"
+        }, {
+                .id = 0xc1,
+                .name = "P1B"
+        }, {
+                .id = 0xc2,
+                .name = "P1C"
+        }, {
+                .id = 0xc3,
+                .name = "P1D"
+        }, {
+                .id = 0xc4,
+                .name = "P1E"
+        }, {
+                .id = 0xc5,
+                .name = "P1F/R1A"
+        }, {
+                .id = 0xc6,
+                .name = "P1G/R1A"
+        }, {
+                .id = 0xc7,
+                .name = "P2A/R2A"
+        }, {
+                .id = 0xc8,
+                .name = "P2B/R2B"
+        },
+        /* AB3000 variants, not supported */
+        {
+                .id = 0xa0
+        }, {
+                .id = 0xa1
+        }, {
+                .id = 0xa2
+        }, {
+                .id = 0xa3
+        }, {
+                .id = 0xa4
+        }, {
+                .id = 0xa5
+        }, {
+                .id = 0xa6
+        }, {
+                .id = 0xa7
+        },
+        /* Terminator */
+        {
+                .id = 0x00,
+        },
+};
+static int __init ab3100_probe(struct i2c_client *client,
+                        const struct i2c_device_id *id)
+{
+        struct ab3100 *ab3100;
+        int err;
+        int i;
+        ab3100 = kzalloc(sizeof(struct ab3100), GFP_KERNEL);
+        if (!ab3100) {
+                dev_err(&client->dev, "could not allocate AB3100 device\n");
+                return -ENOMEM;
+        }
+        /* Initialize data structure */
+        mutex_init(&ab3100->access_mutex);
+        BLOCKING_INIT_NOTIFIER_HEAD(&ab3100->event_subscribers);
+        ab3100->i2c_client = client;
+        ab3100->dev = &ab3100->i2c_client->dev;
+        i2c_set_clientdata(client, ab3100);
+        /* Read chip ID register */
+        err = ab3100_get_register(ab3100, AB3100_CID,
+                                  &ab3100->chip_id);
+        if (err) {
+                dev_err(&client->dev,
+                        "could not communicate with the AB3100 analog "
+                        "baseband chip\n");
+                goto exit_no_detect;
+        }
+        for (i = 0; ids[i].id != 0x0; i++) {
+                if (ids[i].id == ab3100->chip_id) {
+                        if (ids[i].name != NULL) {
+                                snprintf(&ab3100->chip_name[0],
+                                         sizeof(ab3100->chip_name) - 1,
+                                         "AB3100 %s",
+                                         ids[i].name);
+                                break;
+                        } else {
+                                dev_err(&client->dev,
+                                        "AB3000 is not supported\n");
+                                goto exit_no_detect;
+                        }
+                }
+        }
+        if (ids[i].id == 0x0) {
+                dev_err(&client->dev, "unknown analog baseband chip id: 0x%x\n",
+                        ab3100->chip_id);
+                dev_err(&client->dev, "accepting it anyway. Please update "
+                        "the driver.\n");
+                goto exit_no_detect;
+        }
+        dev_info(&client->dev, "Detected chip: %s\n",
+                 &ab3100->chip_name[0]);
+        /* Attach a second dummy i2c_client to the test register address */
+        ab3100->testreg_client = i2c_new_dummy(client->adapter,
+                                                     client->addr + 1);
+        if (!ab3100->testreg_client) {
+                err = -ENOMEM;
+                goto exit_no_testreg_client;
+        }
+        strlcpy(ab3100->testreg_client->name, id->name,
+                sizeof(ab3100->testreg_client->name));
+        err = ab3100_setup(ab3100);
+        if (err)
+                goto exit_no_setup;
+        INIT_WORK(&ab3100->work, ab3100_work);
+        /* This real unpredictable IRQ is of course sampled for entropy */
+        err = request_irq(client->irq, ab3100_irq_handler,
+                          IRQF_DISABLED | IRQF_SAMPLE_RANDOM,
+                          "AB3100 IRQ", ab3100);
+        if (err)
+                goto exit_no_irq;
+        /* Set parent and a pointer back to the container in device data */
+        for (i = 0; i < ARRAY_SIZE(ab3100_platform_devs); i++) {
+                ab3100_platform_devs[i]->dev.parent =
+                        &client->dev;
+                platform_set_drvdata(ab3100_platform_devs[i], ab3100);
+        }
+        /* Register the platform devices */
+        platform_add_devices(ab3100_platform_devs,
+                             ARRAY_SIZE(ab3100_platform_devs));
+        ab3100_setup_debugfs(ab3100);
+        return 0;
+ exit_no_irq:
+ exit_no_setup:
+        i2c_unregister_device(ab3100->testreg_client);
+ exit_no_testreg_client:
+ exit_no_detect:
+        kfree(ab3100);
+        return err;
+}
+static int __exit ab3100_remove(struct i2c_client *client)
+{
+        struct ab3100 *ab3100 = i2c_get_clientdata(client);
+        int i;
+        /* Unregister subdevices */
+        for (i = 0; i < ARRAY_SIZE(ab3100_platform_devs); i++)
+                platform_device_unregister(ab3100_platform_devs[i]);
+        ab3100_remove_debugfs();
+        i2c_unregister_device(ab3100->testreg_client);
+        /*
+         * At this point, all subscribers should have unregistered
+         * their notifiers so deactivate IRQ
+         */
+        free_irq(client->irq, ab3100);
+        kfree(ab3100);
+        return 0;
+}
+static const struct i2c_device_id ab3100_id[] = {
+        { "ab3100", ab3100 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, ab3100_id);
+static struct i2c_driver ab3100_driver = {
+        .driver = {
+                .name   = "ab3100",
+                .owner  = THIS_MODULE,
+        },
+        .id_table       = ab3100_id,
+        .probe          = ab3100_probe,
+        .remove         = __exit_p(ab3100_remove),
+};
+static int __init ab3100_i2c_init(void)
+{
+        return i2c_add_driver(&ab3100_driver);
+}
+static void __exit ab3100_i2c_exit(void)
+{
+        i2c_del_driver(&ab3100_driver);
+}
+subsys_initcall(ab3100_i2c_init);
+module_exit(ab3100_i2c_exit);
+MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>");
+MODULE_DESCRIPTION("AB3100 core driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/asic3.c b/drivers/mfd/asic3.c
index 9e485459f63b..63a2a6632106 100644
--- a/drivers/mfd/asic3.c
+++ b/drivers/mfd/asic3.c
@@ -17,6 +17,7 @@
 */
 #include <linux/kernel.h>
+#include <linux/delay.h>
 #include <linux/irq.h>
 #include <linux/gpio.h>
 #include <linux/io.h>
@@ -24,6 +25,51 @@
 #include <linux/platform_device.h>
 #include <linux/mfd/asic3.h>
+#include <linux/mfd/core.h>
+#include <linux/mfd/ds1wm.h>
+#include <linux/mfd/tmio.h>
+enum {
+        ASIC3_CLOCK_SPI,
+        ASIC3_CLOCK_OWM,
+        ASIC3_CLOCK_PWM0,
+        ASIC3_CLOCK_PWM1,
+        ASIC3_CLOCK_LED0,
+        ASIC3_CLOCK_LED1,
+        ASIC3_CLOCK_LED2,
+        ASIC3_CLOCK_SD_HOST,
+        ASIC3_CLOCK_SD_BUS,
+        ASIC3_CLOCK_SMBUS,
+        ASIC3_CLOCK_EX0,
+        ASIC3_CLOCK_EX1,
+};
+struct asic3_clk {
+        int enabled;
+        unsigned int cdex;
+        unsigned long rate;
+};
+#define INIT_CDEX(_name, _rate) \
+        [ASIC3_CLOCK_##_name] = {               \
+                .cdex = CLOCK_CDEX_##_name,     \
+                .rate = _rate,                  \
+        }
+struct asic3_clk asic3_clk_init[] __initdata = {
+        INIT_CDEX(SPI, 0),
+        INIT_CDEX(OWM, 5000000),
+        INIT_CDEX(PWM0, 0),
+        INIT_CDEX(PWM1, 0),
+        INIT_CDEX(LED0, 0),
+        INIT_CDEX(LED1, 0),
+        INIT_CDEX(LED2, 0),
+        INIT_CDEX(SD_HOST, 24576000),
+        INIT_CDEX(SD_BUS, 12288000),
+        INIT_CDEX(SMBUS, 0),
+        INIT_CDEX(EX0, 32768),
+        INIT_CDEX(EX1, 24576000),
+};
 struct asic3 {
        void __iomem *mapping;
@@ -34,6 +80,8 @@ struct asic3 {
        u16 irq_bothedge[4];
        struct gpio_chip gpio;
        struct device *dev;
+        struct asic3_clk clocks[ARRAY_SIZE(asic3_clk_init)];
 };
 static int asic3_gpio_get(struct gpio_chip *chip, unsigned offset);
@@ -52,6 +100,21 @@ static inline u32 asic3_read_register(struct asic3 *asic,
                        (reg >> asic->bus_shift));
 }
+void asic3_set_register(struct asic3 *asic, u32 reg, u32 bits, bool set)
+{
+        unsigned long flags;
+        u32 val;
+        spin_lock_irqsave(&asic->lock, flags);
+        val = asic3_read_register(asic, reg);
+        if (set)
+                val |= bits;
+        else
+                val &= ~bits;
+        asic3_write_register(asic, reg, val);
+        spin_unlock_irqrestore(&asic->lock, flags);
+}
 /* IRQs */
 #define MAX_ASIC_ISR_LOOPS    20
 #define ASIC3_GPIO_BASE_INCR \
@@ -525,6 +588,240 @@ static int asic3_gpio_remove(struct platform_device *pdev)
        return gpiochip_remove(&asic->gpio);
 }
+static int asic3_clk_enable(struct asic3 *asic, struct asic3_clk *clk)
+{
+        unsigned long flags;
+        u32 cdex;
+        spin_lock_irqsave(&asic->lock, flags);
+        if (clk->enabled++ == 0) {
+                cdex = asic3_read_register(asic, ASIC3_OFFSET(CLOCK, CDEX));
+                cdex |= clk->cdex;
+                asic3_write_register(asic, ASIC3_OFFSET(CLOCK, CDEX), cdex);
+        }
+        spin_unlock_irqrestore(&asic->lock, flags);
+        return 0;
+}
+static void asic3_clk_disable(struct asic3 *asic, struct asic3_clk *clk)
+{
+        unsigned long flags;
+        u32 cdex;
+        WARN_ON(clk->enabled == 0);
+        spin_lock_irqsave(&asic->lock, flags);
+        if (--clk->enabled == 0) {
+                cdex = asic3_read_register(asic, ASIC3_OFFSET(CLOCK, CDEX));
+                cdex &= ~clk->cdex;
+                asic3_write_register(asic, ASIC3_OFFSET(CLOCK, CDEX), cdex);
+        }
+        spin_unlock_irqrestore(&asic->lock, flags);
+}
+/* MFD cells (SPI, PWM, LED, DS1WM, MMC) */
+static struct ds1wm_driver_data ds1wm_pdata = {
+        .active_high = 1,
+};
+static struct resource ds1wm_resources[] = {
+        {
+                .start = ASIC3_OWM_BASE,
+                .end   = ASIC3_OWM_BASE + 0x13,
+                .flags = IORESOURCE_MEM,
+        },
+        {
+                .start = ASIC3_IRQ_OWM,
+                .start = ASIC3_IRQ_OWM,
+                .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE,
+        },
+};
+static int ds1wm_enable(struct platform_device *pdev)
+{
+        struct asic3 *asic = dev_get_drvdata(pdev->dev.parent);
+        /* Turn on external clocks and the OWM clock */
+        asic3_clk_enable(asic, &asic->clocks[ASIC3_CLOCK_EX0]);
+        asic3_clk_enable(asic, &asic->clocks[ASIC3_CLOCK_EX1]);
+        asic3_clk_enable(asic, &asic->clocks[ASIC3_CLOCK_OWM]);
+        msleep(1);
+        /* Reset and enable DS1WM */
+        asic3_set_register(asic, ASIC3_OFFSET(EXTCF, RESET),
+                           ASIC3_EXTCF_OWM_RESET, 1);
+        msleep(1);
+        asic3_set_register(asic, ASIC3_OFFSET(EXTCF, RESET),
+                           ASIC3_EXTCF_OWM_RESET, 0);
+        msleep(1);
+        asic3_set_register(asic, ASIC3_OFFSET(EXTCF, SELECT),
+                           ASIC3_EXTCF_OWM_EN, 1);
+        msleep(1);
+        return 0;
+}
+static int ds1wm_disable(struct platform_device *pdev)
+{
+        struct asic3 *asic = dev_get_drvdata(pdev->dev.parent);
+        asic3_set_register(asic, ASIC3_OFFSET(EXTCF, SELECT),
+                           ASIC3_EXTCF_OWM_EN, 0);
+        asic3_clk_disable(asic, &asic->clocks[ASIC3_CLOCK_OWM]);
+        asic3_clk_disable(asic, &asic->clocks[ASIC3_CLOCK_EX0]);
+        asic3_clk_disable(asic, &asic->clocks[ASIC3_CLOCK_EX1]);
+        return 0;
+}
+static struct mfd_cell asic3_cell_ds1wm = {
+        .name          = "ds1wm",
+        .enable        = ds1wm_enable,
+        .disable       = ds1wm_disable,
+        .driver_data   = &ds1wm_pdata,
+        .num_resources = ARRAY_SIZE(ds1wm_resources),
+        .resources     = ds1wm_resources,
+};
+static struct tmio_mmc_data asic3_mmc_data = {
+        .hclk = 24576000,
+};
+static struct resource asic3_mmc_resources[] = {
+        {
+                .start = ASIC3_SD_CTRL_BASE,
+                .end   = ASIC3_SD_CTRL_BASE + 0x3ff,
+                .flags = IORESOURCE_MEM,
+        },
+        {
+                .start = ASIC3_SD_CONFIG_BASE,
+                .end   = ASIC3_SD_CONFIG_BASE + 0x1ff,
+                .flags = IORESOURCE_MEM,
+        },
+        {
+                .start = 0,
+                .end   = 0,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+static int asic3_mmc_enable(struct platform_device *pdev)
+{
+        struct asic3 *asic = dev_get_drvdata(pdev->dev.parent);
+        /* Not sure if it must be done bit by bit, but leaving as-is */
+        asic3_set_register(asic, ASIC3_OFFSET(SDHWCTRL, SDCONF),
+                           ASIC3_SDHWCTRL_LEVCD, 1);
+        asic3_set_register(asic, ASIC3_OFFSET(SDHWCTRL, SDCONF),
+                           ASIC3_SDHWCTRL_LEVWP, 1);
+        asic3_set_register(asic, ASIC3_OFFSET(SDHWCTRL, SDCONF),
+                           ASIC3_SDHWCTRL_SUSPEND, 0);
+        asic3_set_register(asic, ASIC3_OFFSET(SDHWCTRL, SDCONF),
+                           ASIC3_SDHWCTRL_PCLR, 0);
+        asic3_clk_enable(asic, &asic->clocks[ASIC3_CLOCK_EX0]);
+        /* CLK32 used for card detection and for interruption detection
+         * when HCLK is stopped.
+         */
+        asic3_clk_enable(asic, &asic->clocks[ASIC3_CLOCK_EX1]);
+        msleep(1);
+        /* HCLK 24.576 MHz, BCLK 12.288 MHz: */
+        asic3_write_register(asic, ASIC3_OFFSET(CLOCK, SEL),
+                CLOCK_SEL_CX | CLOCK_SEL_SD_HCLK_SEL);
+        asic3_clk_enable(asic, &asic->clocks[ASIC3_CLOCK_SD_HOST]);
+        asic3_clk_enable(asic, &asic->clocks[ASIC3_CLOCK_SD_BUS]);
+        msleep(1);
+        asic3_set_register(asic, ASIC3_OFFSET(EXTCF, SELECT),
+                           ASIC3_EXTCF_SD_MEM_ENABLE, 1);
+        /* Enable SD card slot 3.3V power supply */
+        asic3_set_register(asic, ASIC3_OFFSET(SDHWCTRL, SDCONF),
+                           ASIC3_SDHWCTRL_SDPWR, 1);
+        return 0;
+}
+static int asic3_mmc_disable(struct platform_device *pdev)
+{
+        struct asic3 *asic = dev_get_drvdata(pdev->dev.parent);
+        /* Put in suspend mode */
+        asic3_set_register(asic, ASIC3_OFFSET(SDHWCTRL, SDCONF),
+                           ASIC3_SDHWCTRL_SUSPEND, 1);
+        /* Disable clocks */
+        asic3_clk_disable(asic, &asic->clocks[ASIC3_CLOCK_SD_HOST]);
+        asic3_clk_disable(asic, &asic->clocks[ASIC3_CLOCK_SD_BUS]);
+        asic3_clk_disable(asic, &asic->clocks[ASIC3_CLOCK_EX0]);
+        asic3_clk_disable(asic, &asic->clocks[ASIC3_CLOCK_EX1]);
+        return 0;
+}
+static struct mfd_cell asic3_cell_mmc = {
+        .name          = "tmio-mmc",
+        .enable        = asic3_mmc_enable,
+        .disable       = asic3_mmc_disable,
+        .driver_data   = &asic3_mmc_data,
+        .num_resources = ARRAY_SIZE(asic3_mmc_resources),
+        .resources     = asic3_mmc_resources,
+};
+static int __init asic3_mfd_probe(struct platform_device *pdev,
+                                  struct resource *mem)
+{
+        struct asic3 *asic = platform_get_drvdata(pdev);
+        struct resource *mem_sdio;
+        int irq, ret;
+        mem_sdio = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        if (!mem_sdio)
+                dev_dbg(asic->dev, "no SDIO MEM resource\n");
+        irq = platform_get_irq(pdev, 1);
+        if (irq < 0)
+                dev_dbg(asic->dev, "no SDIO IRQ resource\n");
+        /* DS1WM */
+        asic3_set_register(asic, ASIC3_OFFSET(EXTCF, SELECT),
+                           ASIC3_EXTCF_OWM_SMB, 0);
+        ds1wm_resources[0].start >>= asic->bus_shift;
+        ds1wm_resources[0].end   >>= asic->bus_shift;
+        asic3_cell_ds1wm.platform_data = &asic3_cell_ds1wm;
+        asic3_cell_ds1wm.data_size = sizeof(asic3_cell_ds1wm);
+        /* MMC */
+        asic3_mmc_resources[0].start >>= asic->bus_shift;
+        asic3_mmc_resources[0].end   >>= asic->bus_shift;
+        asic3_mmc_resources[1].start >>= asic->bus_shift;
+        asic3_mmc_resources[1].end   >>= asic->bus_shift;
+        asic3_cell_mmc.platform_data = &asic3_cell_mmc;
+        asic3_cell_mmc.data_size = sizeof(asic3_cell_mmc);
+        ret = mfd_add_devices(&pdev->dev, pdev->id,
+                        &asic3_cell_ds1wm, 1, mem, asic->irq_base);
+        if (ret < 0)
+                goto out;
+        if (mem_sdio && (irq >= 0))
+                ret = mfd_add_devices(&pdev->dev, pdev->id,
+                        &asic3_cell_mmc, 1, mem_sdio, irq);
+ out:
+        return ret;
+}
+static void asic3_mfd_remove(struct platform_device *pdev)
+{
+        mfd_remove_devices(&pdev->dev);
+}
 /* Core */
 static int __init asic3_probe(struct platform_device *pdev)
@@ -533,7 +830,6 @@ static int __init asic3_probe(struct platform_device *pdev)
        struct asic3 *asic;
        struct resource *mem;
        unsigned long clksel;
-        int map_size;
        int ret = 0;
        asic = kzalloc(sizeof(struct asic3), GFP_KERNEL);
@@ -553,8 +849,7 @@ static int __init asic3_probe(struct platform_device *pdev)
                goto out_free;
        }
-        map_size = mem->end - mem->start + 1;
+        asic->mapping = ioremap(mem->start, resource_size(mem));
-        asic->mapping = ioremap(mem->start, map_size);
        if (!asic->mapping) {
                ret = -ENOMEM;
                dev_err(asic->dev, "Couldn't ioremap\n");
@@ -564,7 +859,7 @@ static int __init asic3_probe(struct platform_device *pdev)
        asic->irq_base = pdata->irq_base;
        /* calculate bus shift from mem resource */
-        asic->bus_shift = 2 - (map_size >> 12);
+        asic->bus_shift = 2 - (resource_size(mem) >> 12);
        clksel = 0;
        asic3_write_register(asic, ASIC3_OFFSET(CLOCK, SEL), clksel);
@@ -590,6 +885,13 @@ static int __init asic3_probe(struct platform_device *pdev)
                goto out_irq;
        }
+        /* Making a per-device copy is only needed for the
+         * theoretical case of multiple ASIC3s on one board:
+         */
+        memcpy(asic->clocks, asic3_clk_init, sizeof(asic3_clk_init));
+        asic3_mfd_probe(pdev, mem);
        dev_info(asic->dev, "ASIC3 Core driver\n");
        return 0;
@@ -611,6 +913,8 @@ static int asic3_remove(struct platform_device *pdev)
        int ret;
        struct asic3 *asic = platform_get_drvdata(pdev);
+        asic3_mfd_remove(pdev);
        ret = asic3_gpio_remove(pdev);
        if (ret < 0)
                return ret;
diff --git a/drivers/mfd/da903x.c b/drivers/mfd/da903x.c
index 7283d88656af..e5ffe5617393 100644
--- a/drivers/mfd/da903x.c
+++ b/drivers/mfd/da903x.c
@@ -561,7 +561,7 @@ static int __init da903x_init(void)
 {
        return i2c_add_driver(&da903x_driver);
 }
-module_init(da903x_init);
+subsys_initcall(da903x_init);
 static void __exit da903x_exit(void)
 {
diff --git a/drivers/mfd/ezx-pcap.c b/drivers/mfd/ezx-pcap.c
new file mode 100644
index 000000000000..671a7efe86a8
--- /dev/null
+++ b/drivers/mfd/ezx-pcap.c
@@ -0,0 +1,505 @@
+/*
+ * Driver for Motorola PCAP2 as present in EZX phones
+ *
+ * Copyright (C) 2006 Harald Welte <laforge@openezx.org>
+ * Copyright (C) 2009 Daniel Ribeiro <drwyrm@gmail.com>
+ *
+ * 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/module.h>
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/mfd/ezx-pcap.h>
+#include <linux/spi/spi.h>
+#define PCAP_ADC_MAXQ           8
+struct pcap_adc_request {
+        u8 bank;
+        u8 ch[2];
+        u32 flags;
+        void (*callback)(void *, u16[]);
+        void *data;
+};
+struct pcap_adc_sync_request {
+        u16 res[2];
+        struct completion completion;
+};
+struct pcap_chip {
+        struct spi_device *spi;
+        /* IO */
+        u32 buf;
+        struct mutex io_mutex;
+        /* IRQ */
+        unsigned int irq_base;
+        u32 msr;
+        struct work_struct isr_work;
+        struct work_struct msr_work;
+        struct workqueue_struct *workqueue;
+        /* ADC */
+        struct pcap_adc_request *adc_queue[PCAP_ADC_MAXQ];
+        u8 adc_head;
+        u8 adc_tail;
+        struct mutex adc_mutex;
+};
+/* IO */
+static int ezx_pcap_putget(struct pcap_chip *pcap, u32 *data)
+{
+        struct spi_transfer t;
+        struct spi_message m;
+        int status;
+        memset(&t, 0, sizeof t);
+        spi_message_init(&m);
+        t.len = sizeof(u32);
+        spi_message_add_tail(&t, &m);
+        pcap->buf = *data;
+        t.tx_buf = (u8 *) &pcap->buf;
+        t.rx_buf = (u8 *) &pcap->buf;
+        status = spi_sync(pcap->spi, &m);
+        if (status == 0)
+                *data = pcap->buf;
+        return status;
+}
+int ezx_pcap_write(struct pcap_chip *pcap, u8 reg_num, u32 value)
+{
+        int ret;
+        mutex_lock(&pcap->io_mutex);
+        value &= PCAP_REGISTER_VALUE_MASK;
+        value |= PCAP_REGISTER_WRITE_OP_BIT
+                | (reg_num << PCAP_REGISTER_ADDRESS_SHIFT);
+        ret = ezx_pcap_putget(pcap, &value);
+        mutex_unlock(&pcap->io_mutex);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(ezx_pcap_write);
+int ezx_pcap_read(struct pcap_chip *pcap, u8 reg_num, u32 *value)
+{
+        int ret;
+        mutex_lock(&pcap->io_mutex);
+        *value = PCAP_REGISTER_READ_OP_BIT
+                | (reg_num << PCAP_REGISTER_ADDRESS_SHIFT);
+        ret = ezx_pcap_putget(pcap, value);
+        mutex_unlock(&pcap->io_mutex);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(ezx_pcap_read);
+/* IRQ */
+static inline unsigned int irq2pcap(struct pcap_chip *pcap, int irq)
+{
+        return 1 << (irq - pcap->irq_base);
+}
+int pcap_to_irq(struct pcap_chip *pcap, int irq)
+{
+        return pcap->irq_base + irq;
+}
+EXPORT_SYMBOL_GPL(pcap_to_irq);
+static void pcap_mask_irq(unsigned int irq)
+{
+        struct pcap_chip *pcap = get_irq_chip_data(irq);
+        pcap->msr |= irq2pcap(pcap, irq);
+        queue_work(pcap->workqueue, &pcap->msr_work);
+}
+static void pcap_unmask_irq(unsigned int irq)
+{
+        struct pcap_chip *pcap = get_irq_chip_data(irq);
+        pcap->msr &= ~irq2pcap(pcap, irq);
+        queue_work(pcap->workqueue, &pcap->msr_work);
+}
+static struct irq_chip pcap_irq_chip = {
+        .name   = "pcap",
+        .mask   = pcap_mask_irq,
+        .unmask = pcap_unmask_irq,
+};
+static void pcap_msr_work(struct work_struct *work)
+{
+        struct pcap_chip *pcap = container_of(work, struct pcap_chip, msr_work);
+        ezx_pcap_write(pcap, PCAP_REG_MSR, pcap->msr);
+}
+static void pcap_isr_work(struct work_struct *work)
+{
+        struct pcap_chip *pcap = container_of(work, struct pcap_chip, isr_work);
+        struct pcap_platform_data *pdata = pcap->spi->dev.platform_data;
+        u32 msr, isr, int_sel, service;
+        int irq;
+        ezx_pcap_read(pcap, PCAP_REG_MSR, &msr);
+        ezx_pcap_read(pcap, PCAP_REG_ISR, &isr);
+        /* We cant service/ack irqs that are assigned to port 2 */
+        if (!(pdata->config & PCAP_SECOND_PORT)) {
+                ezx_pcap_read(pcap, PCAP_REG_INT_SEL, &int_sel);
+                isr &= ~int_sel;
+        }
+        ezx_pcap_write(pcap, PCAP_REG_ISR, isr);
+        local_irq_disable();
+        service = isr & ~msr;
+        for (irq = pcap->irq_base; service; service >>= 1, irq++) {
+                if (service & 1) {
+                        struct irq_desc *desc = irq_to_desc(irq);
+                        if (WARN(!desc, KERN_WARNING
+                                        "Invalid PCAP IRQ %d\n", irq))
+                                break;
+                        if (desc->status & IRQ_DISABLED)
+                                note_interrupt(irq, desc, IRQ_NONE);
+                        else
+                                desc->handle_irq(irq, desc);
+                }
+        }
+        local_irq_enable();
+}
+static void pcap_irq_handler(unsigned int irq, struct irq_desc *desc)
+{
+        struct pcap_chip *pcap = get_irq_data(irq);
+        desc->chip->ack(irq);
+        queue_work(pcap->workqueue, &pcap->isr_work);
+        return;
+}
+/* ADC */
+static void pcap_disable_adc(struct pcap_chip *pcap)
+{
+        u32 tmp;
+        ezx_pcap_read(pcap, PCAP_REG_ADC, &tmp);
+        tmp &= ~(PCAP_ADC_ADEN|PCAP_ADC_BATT_I_ADC|PCAP_ADC_BATT_I_POLARITY);
+        ezx_pcap_write(pcap, PCAP_REG_ADC, tmp);
+}
+static void pcap_adc_trigger(struct pcap_chip *pcap)
+{
+        u32 tmp;
+        u8 head;
+        mutex_lock(&pcap->adc_mutex);
+        head = pcap->adc_head;
+        if (!pcap->adc_queue[head]) {
+                /* queue is empty, save power */
+                pcap_disable_adc(pcap);
+                mutex_unlock(&pcap->adc_mutex);
+                return;
+        }
+        mutex_unlock(&pcap->adc_mutex);
+        /* start conversion on requested bank */
+        tmp = pcap->adc_queue[head]->flags | PCAP_ADC_ADEN;
+        if (pcap->adc_queue[head]->bank == PCAP_ADC_BANK_1)
+                tmp |= PCAP_ADC_AD_SEL1;
+        ezx_pcap_write(pcap, PCAP_REG_ADC, tmp);
+        ezx_pcap_write(pcap, PCAP_REG_ADR, PCAP_ADR_ASC);
+}
+static irqreturn_t pcap_adc_irq(int irq, void *_pcap)
+{
+        struct pcap_chip *pcap = _pcap;
+        struct pcap_adc_request *req;
+        u16 res[2];
+        u32 tmp;
+        mutex_lock(&pcap->adc_mutex);
+        req = pcap->adc_queue[pcap->adc_head];
+        if (WARN(!req, KERN_WARNING "adc irq without pending request\n"))
+                return IRQ_HANDLED;
+        /* read requested channels results */
+        ezx_pcap_read(pcap, PCAP_REG_ADC, &tmp);
+        tmp &= ~(PCAP_ADC_ADA1_MASK | PCAP_ADC_ADA2_MASK);
+        tmp |= (req->ch[0] << PCAP_ADC_ADA1_SHIFT);
+        tmp |= (req->ch[1] << PCAP_ADC_ADA2_SHIFT);
+        ezx_pcap_write(pcap, PCAP_REG_ADC, tmp);
+        ezx_pcap_read(pcap, PCAP_REG_ADR, &tmp);
+        res[0] = (tmp & PCAP_ADR_ADD1_MASK) >> PCAP_ADR_ADD1_SHIFT;
+        res[1] = (tmp & PCAP_ADR_ADD2_MASK) >> PCAP_ADR_ADD2_SHIFT;
+        pcap->adc_queue[pcap->adc_head] = NULL;
+        pcap->adc_head = (pcap->adc_head + 1) & (PCAP_ADC_MAXQ - 1);
+        mutex_unlock(&pcap->adc_mutex);
+        /* pass the results and release memory */
+        req->callback(req->data, res);
+        kfree(req);
+        /* trigger next conversion (if any) on queue */
+        pcap_adc_trigger(pcap);
+        return IRQ_HANDLED;
+}
+int pcap_adc_async(struct pcap_chip *pcap, u8 bank, u32 flags, u8 ch[],
+                                                void *callback, void *data)
+{
+        struct pcap_adc_request *req;
+        /* This will be freed after we have a result */
+        req = kmalloc(sizeof(struct pcap_adc_request), GFP_KERNEL);
+        if (!req)
+                return -ENOMEM;
+        req->bank = bank;
+        req->flags = flags;
+        req->ch[0] = ch[0];
+        req->ch[1] = ch[1];
+        req->callback = callback;
+        req->data = data;
+        mutex_lock(&pcap->adc_mutex);
+        if (pcap->adc_queue[pcap->adc_tail]) {
+                mutex_unlock(&pcap->adc_mutex);
+                kfree(req);
+                return -EBUSY;
+        }
+        pcap->adc_queue[pcap->adc_tail] = req;
+        pcap->adc_tail = (pcap->adc_tail + 1) & (PCAP_ADC_MAXQ - 1);
+        mutex_unlock(&pcap->adc_mutex);
+        /* start conversion */
+        pcap_adc_trigger(pcap);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(pcap_adc_async);
+static void pcap_adc_sync_cb(void *param, u16 res[])
+{
+        struct pcap_adc_sync_request *req = param;
+        req->res[0] = res[0];
+        req->res[1] = res[1];
+        complete(&req->completion);
+}
+int pcap_adc_sync(struct pcap_chip *pcap, u8 bank, u32 flags, u8 ch[],
+                                                                u16 res[])
+{
+        struct pcap_adc_sync_request sync_data;
+        int ret;
+        init_completion(&sync_data.completion);
+        ret = pcap_adc_async(pcap, bank, flags, ch, pcap_adc_sync_cb,
+                                                                &sync_data);
+        if (ret)
+                return ret;
+        wait_for_completion(&sync_data.completion);
+        res[0] = sync_data.res[0];
+        res[1] = sync_data.res[1];
+        return 0;
+}
+EXPORT_SYMBOL_GPL(pcap_adc_sync);
+/* subdevs */
+static int pcap_remove_subdev(struct device *dev, void *unused)
+{
+        platform_device_unregister(to_platform_device(dev));
+        return 0;
+}
+static int __devinit pcap_add_subdev(struct pcap_chip *pcap,
+                                                struct pcap_subdev *subdev)
+{
+        struct platform_device *pdev;
+        pdev = platform_device_alloc(subdev->name, subdev->id);
+        pdev->dev.parent = &pcap->spi->dev;
+        pdev->dev.platform_data = subdev->platform_data;
+        platform_set_drvdata(pdev, pcap);
+        return platform_device_add(pdev);
+}
+static int __devexit ezx_pcap_remove(struct spi_device *spi)
+{
+        struct pcap_chip *pcap = dev_get_drvdata(&spi->dev);
+        struct pcap_platform_data *pdata = spi->dev.platform_data;
+        int i, adc_irq;
+        /* remove all registered subdevs */
+        device_for_each_child(&spi->dev, NULL, pcap_remove_subdev);
+        /* cleanup ADC */
+        adc_irq = pcap_to_irq(pcap, (pdata->config & PCAP_SECOND_PORT) ?
+                                PCAP_IRQ_ADCDONE2 : PCAP_IRQ_ADCDONE);
+        free_irq(adc_irq, pcap);
+        mutex_lock(&pcap->adc_mutex);
+        for (i = 0; i < PCAP_ADC_MAXQ; i++)
+                kfree(pcap->adc_queue[i]);
+        mutex_unlock(&pcap->adc_mutex);
+        /* cleanup irqchip */
+        for (i = pcap->irq_base; i < (pcap->irq_base + PCAP_NIRQS); i++)
+                set_irq_chip_and_handler(i, NULL, NULL);
+        destroy_workqueue(pcap->workqueue);
+        kfree(pcap);
+        return 0;
+}
+static int __devinit ezx_pcap_probe(struct spi_device *spi)
+{
+        struct pcap_platform_data *pdata = spi->dev.platform_data;
+        struct pcap_chip *pcap;
+        int i, adc_irq;
+        int ret = -ENODEV;
+        /* platform data is required */
+        if (!pdata)
+                goto ret;
+        pcap = kzalloc(sizeof(*pcap), GFP_KERNEL);
+        if (!pcap) {
+                ret = -ENOMEM;
+                goto ret;
+        }
+        mutex_init(&pcap->io_mutex);
+        mutex_init(&pcap->adc_mutex);
+        INIT_WORK(&pcap->isr_work, pcap_isr_work);
+        INIT_WORK(&pcap->msr_work, pcap_msr_work);
+        dev_set_drvdata(&spi->dev, pcap);
+        /* setup spi */
+        spi->bits_per_word = 32;
+        spi->mode = SPI_MODE_0 | (pdata->config & PCAP_CS_AH ? SPI_CS_HIGH : 0);
+        ret = spi_setup(spi);
+        if (ret)
+                goto free_pcap;
+        pcap->spi = spi;
+        /* setup irq */
+        pcap->irq_base = pdata->irq_base;
+        pcap->workqueue = create_singlethread_workqueue("pcapd");
+        if (!pcap->workqueue) {
+                dev_err(&spi->dev, "cant create pcap thread\n");
+                goto free_pcap;
+        }
+        /* redirect interrupts to AP, except adcdone2 */
+        if (!(pdata->config & PCAP_SECOND_PORT))
+                ezx_pcap_write(pcap, PCAP_REG_INT_SEL,
+                                        (1 << PCAP_IRQ_ADCDONE2));
+        /* setup irq chip */
+        for (i = pcap->irq_base; i < (pcap->irq_base + PCAP_NIRQS); i++) {
+                set_irq_chip_and_handler(i, &pcap_irq_chip, handle_simple_irq);
+                set_irq_chip_data(i, pcap);
+#ifdef CONFIG_ARM
+                set_irq_flags(i, IRQF_VALID);
+#else
+                set_irq_noprobe(i);
+#endif
+        }
+        /* mask/ack all PCAP interrupts */
+        ezx_pcap_write(pcap, PCAP_REG_MSR, PCAP_MASK_ALL_INTERRUPT);
+        ezx_pcap_write(pcap, PCAP_REG_ISR, PCAP_CLEAR_INTERRUPT_REGISTER);
+        pcap->msr = PCAP_MASK_ALL_INTERRUPT;
+        set_irq_type(spi->irq, IRQ_TYPE_EDGE_RISING);
+        set_irq_data(spi->irq, pcap);
+        set_irq_chained_handler(spi->irq, pcap_irq_handler);
+        set_irq_wake(spi->irq, 1);
+        /* ADC */
+        adc_irq = pcap_to_irq(pcap, (pdata->config & PCAP_SECOND_PORT) ?
+                                        PCAP_IRQ_ADCDONE2 : PCAP_IRQ_ADCDONE);
+        ret = request_irq(adc_irq, pcap_adc_irq, 0, "ADC", pcap);
+        if (ret)
+                goto free_irqchip;
+        /* setup subdevs */
+        for (i = 0; i < pdata->num_subdevs; i++) {
+                ret = pcap_add_subdev(pcap, &pdata->subdevs[i]);
+                if (ret)
+                        goto remove_subdevs;
+        }
+        /* board specific quirks */
+        if (pdata->init)
+                pdata->init(pcap);
+        return 0;
+remove_subdevs:
+        device_for_each_child(&spi->dev, NULL, pcap_remove_subdev);
+/* free_adc: */
+        free_irq(adc_irq, pcap);
+free_irqchip:
+        for (i = pcap->irq_base; i < (pcap->irq_base + PCAP_NIRQS); i++)
+                set_irq_chip_and_handler(i, NULL, NULL);
+/* destroy_workqueue: */
+        destroy_workqueue(pcap->workqueue);
+free_pcap:
+        kfree(pcap);
+ret:
+        return ret;
+}
+static struct spi_driver ezxpcap_driver = {
+        .probe  = ezx_pcap_probe,
+        .remove = __devexit_p(ezx_pcap_remove),
+        .driver = {
+                .name   = "ezx-pcap",
+                .owner  = THIS_MODULE,
+        },
+};
+static int __init ezx_pcap_init(void)
+{
+        return spi_register_driver(&ezxpcap_driver);
+}
+static void __exit ezx_pcap_exit(void)
+{
+        spi_unregister_driver(&ezxpcap_driver);
+}
+module_init(ezx_pcap_init);
+module_exit(ezx_pcap_exit);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Daniel Ribeiro / Harald Welte");
+MODULE_DESCRIPTION("Motorola PCAP2 ASIC Driver");
diff --git a/drivers/mfd/pcf50633-core.c b/drivers/mfd/pcf50633-core.c
index 082c197ab9b8..8d3c38bf9714 100644
--- a/drivers/mfd/pcf50633-core.c
+++ b/drivers/mfd/pcf50633-core.c
@@ -705,5 +705,5 @@ MODULE_DESCRIPTION("I2C chip driver for NXP PCF50633 PMU");
 MODULE_AUTHOR("Harald Welte <laforge@openmoko.org>");
 MODULE_LICENSE("GPL");
-module_init(pcf50633_init);
+subsys_initcall(pcf50633_init);
 module_exit(pcf50633_exit);
diff --git a/drivers/mfd/pcf50633-gpio.c b/drivers/mfd/pcf50633-gpio.c
index 2fa2eca5c9cc..9ab19a8f669d 100644
--- a/drivers/mfd/pcf50633-gpio.c
+++ b/drivers/mfd/pcf50633-gpio.c
@@ -15,6 +15,7 @@
 */
 #include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/mfd/pcf50633/core.h>
 #include <linux/mfd/pcf50633/gpio.h>
@@ -116,3 +117,5 @@ int pcf50633_gpio_power_supply_set(struct pcf50633 *pcf,
        return pcf50633_reg_set_bit_mask(pcf, reg, mask, val);
 }
 EXPORT_SYMBOL_GPL(pcf50633_gpio_power_supply_set);
+MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/t7l66xb.c b/drivers/mfd/t7l66xb.c
index 875f7a875734..0a255c1f1ce7 100644
--- a/drivers/mfd/t7l66xb.c
+++ b/drivers/mfd/t7l66xb.c
@@ -108,7 +108,7 @@ static int t7l66xb_mmc_disable(struct platform_device *mmc)
 /*--------------------------------------------------------------------------*/
-static const struct tmio_mmc_data t7166xb_mmc_data = {
+static struct tmio_mmc_data t7166xb_mmc_data = {
        .hclk = 24000000,
 };
diff --git a/drivers/mfd/tc6387xb.c b/drivers/mfd/tc6387xb.c
index c3993ac20542..3280ab33f88a 100644
--- a/drivers/mfd/tc6387xb.c
+++ b/drivers/mfd/tc6387xb.c
@@ -75,7 +75,7 @@ static int tc6387xb_mmc_disable(struct platform_device *mmc)
 /*--------------------------------------------------------------------------*/
-const static struct tmio_mmc_data tc6387xb_mmc_data = {
+static struct tmio_mmc_data tc6387xb_mmc_data = {
        .hclk = 24000000,
 };
diff --git a/drivers/mfd/tc6393xb.c b/drivers/mfd/tc6393xb.c
index 9d2abb5d6e2c..1429a7341a9a 100644
--- a/drivers/mfd/tc6393xb.c
+++ b/drivers/mfd/tc6393xb.c
@@ -136,7 +136,7 @@ static int tc6393xb_nand_enable(struct platform_device *nand)
        return 0;
 }
-const static struct tmio_mmc_data tc6393xb_mmc_data = {
+static struct tmio_mmc_data tc6393xb_mmc_data = {
        .hclk = 24000000,
 };
diff --git a/drivers/mfd/twl4030-core.c b/drivers/mfd/twl4030-core.c
index ec90e953adce..cd1008c19cd7 100644
--- a/drivers/mfd/twl4030-core.c
+++ b/drivers/mfd/twl4030-core.c
@@ -647,7 +647,7 @@ static inline int __init unprotect_pm_master(void)
        return e;
 }
-static void __init clocks_init(struct device *dev)
+static void clocks_init(struct device *dev)
 {
        int e = 0;
        struct clk *osc;
diff --git a/drivers/mfd/twl4030-irq.c b/drivers/mfd/twl4030-irq.c
index aca2670afd78..bae61b22501c 100644
--- a/drivers/mfd/twl4030-irq.c
+++ b/drivers/mfd/twl4030-irq.c
@@ -255,7 +255,7 @@ static int twl4030_irq_thread(void *data)
 * thread.  All we do here is acknowledge and mask the interrupt and wakeup
 * the kernel thread.
 */
-static void handle_twl4030_pih(unsigned int irq, irq_desc_t *desc)
+static void handle_twl4030_pih(unsigned int irq, struct irq_desc *desc)
 {
        /* Acknowledge, clear *AND* mask the interrupt... */
        desc->chip->ack(irq);
diff --git a/drivers/mfd/wm8350-regmap.c b/drivers/mfd/wm8350-regmap.c
index 9a4cc954cb7c..7ccc1eab98ab 100644
--- a/drivers/mfd/wm8350-regmap.c
+++ b/drivers/mfd/wm8350-regmap.c
@@ -3186,7 +3186,7 @@ const struct wm8350_reg_access wm8350_reg_io_map[] = {
        /*  read    write volatile */
        { 0xFFFF, 0xFFFF, 0xFFFF }, /* R0   - Reset/ID */
        { 0x7CFF, 0x0C00, 0x7FFF }, /* R1   - ID */
-        { 0x0000, 0x0000, 0x0000 }, /* R2 */
+        { 0x007F, 0x0000, 0x0000 }, /* R2   - ROM Mask ID */
        { 0xBE3B, 0xBE3B, 0x8000 }, /* R3   - System Control 1 */
        { 0xFEF7, 0xFEF7, 0xF800 }, /* R4   - System Control 2 */
        { 0x80FF, 0x80FF, 0x8000 }, /* R5   - System Hibernate */
@@ -3411,7 +3411,7 @@ const struct wm8350_reg_access wm8350_reg_io_map[] = {
        { 0x0000, 0x0000, 0x0000 }, /* R224 */
        { 0x8F3F, 0x0000, 0xFFFF }, /* R225 - DCDC/LDO status */
        { 0x0000, 0x0000, 0xFFFF }, /* R226 - Charger status */
-        { 0x0000, 0x0000, 0xFFFF }, /* R227 */
+        { 0x34FE, 0x0000, 0xFFFF }, /* R227 */
        { 0x0000, 0x0000, 0x0000 }, /* R228 */
        { 0x0000, 0x0000, 0x0000 }, /* R229 */
        { 0xFFFF, 0x1FFF, 0xFFFF }, /* R230 - GPIO Pin Status */
diff --git a/drivers/mfd/wm8400-core.c b/drivers/mfd/wm8400-core.c
index 7c21bf791569..ecfc8bbe89b9 100644
--- a/drivers/mfd/wm8400-core.c
+++ b/drivers/mfd/wm8400-core.c
@@ -460,7 +460,7 @@ static int __init wm8400_module_init(void)
        return ret;
 }
-module_init(wm8400_module_init);
+subsys_initcall(wm8400_module_init);
 static void __exit wm8400_module_exit(void)
 {
diff --git a/drivers/misc/sgi-gru/Makefile b/drivers/misc/sgi-gru/Makefile
index bcd8136d2f98..7c4c306dfa8a 100644
--- a/drivers/misc/sgi-gru/Makefile
+++ b/drivers/misc/sgi-gru/Makefile
@@ -3,5 +3,5 @@ ifdef CONFIG_SGI_GRU_DEBUG
 endif
 obj-$(CONFIG_SGI_GRU) := gru.o
-gru-y := grufile.o grumain.o grufault.o grutlbpurge.o gruprocfs.o grukservices.o gruhandles.o
+gru-y := grufile.o grumain.o grufault.o grutlbpurge.o gruprocfs.o grukservices.o gruhandles.o grukdump.o
diff --git a/drivers/misc/sgi-gru/gru_instructions.h b/drivers/misc/sgi-gru/gru_instructions.h
index 3fde33c1e8f3..3c9c06618e6a 100644
--- a/drivers/misc/sgi-gru/gru_instructions.h
+++ b/drivers/misc/sgi-gru/gru_instructions.h
@@ -81,6 +81,8 @@ struct control_block_extended_exc_detail {
        int             exopc;
        long            exceptdet0;
        int             exceptdet1;
+        int             cbrstate;
+        int             cbrexecstatus;
 };
 /*
@@ -107,7 +109,8 @@ struct gru_instruction_bits {
    unsigned char               reserved2: 2;
    unsigned char               istatus:   2;
    unsigned char               isubstatus:4;
-    unsigned char               reserved3: 2;
+    unsigned char               reserved3: 1;
+    unsigned char               tlb_fault_color: 1;
    /* DW 1 */
    unsigned long               idef4;          /* 42 bits: TRi1, BufSize */
    /* DW 2-6 */
@@ -250,17 +253,37 @@ struct gru_instruction {
 #define CBE_CAUSE_HA_RESPONSE_FATAL             (1 << 13)
 #define CBE_CAUSE_HA_RESPONSE_NON_FATAL         (1 << 14)
 #define CBE_CAUSE_ADDRESS_SPACE_DECODE_ERROR    (1 << 15)
-#define CBE_CAUSE_RESPONSE_DATA_ERROR           (1 << 16)
+#define CBE_CAUSE_PROTOCOL_STATE_DATA_ERROR     (1 << 16)
-#define CBE_CAUSE_PROTOCOL_STATE_DATA_ERROR     (1 << 17)
+#define CBE_CAUSE_RA_RESPONSE_DATA_ERROR        (1 << 17)
+#define CBE_CAUSE_HA_RESPONSE_DATA_ERROR        (1 << 18)
+/* CBE cbrexecstatus bits */
+#define CBR_EXS_ABORT_OCC_BIT                   0
+#define CBR_EXS_INT_OCC_BIT                     1
+#define CBR_EXS_PENDING_BIT                     2
+#define CBR_EXS_QUEUED_BIT                      3
+#define CBR_EXS_TLB_INVAL_BIT                   4
+#define CBR_EXS_EXCEPTION_BIT                   5
+#define CBR_EXS_ABORT_OCC                       (1 << CBR_EXS_ABORT_OCC_BIT)
+#define CBR_EXS_INT_OCC                         (1 << CBR_EXS_INT_OCC_BIT)
+#define CBR_EXS_PENDING                         (1 << CBR_EXS_PENDING_BIT)
+#define CBR_EXS_QUEUED                          (1 << CBR_EXS_QUEUED_BIT)
+#define CBR_TLB_INVAL                           (1 << CBR_EXS_TLB_INVAL_BIT)
+#define CBR_EXS_EXCEPTION                       (1 << CBR_EXS_EXCEPTION_BIT)
 /*
 * Exceptions are retried for the following cases. If any OTHER bits are set
 * in ecause, the exception is not retryable.
 */
-#define EXCEPTION_RETRY_BITS (CBE_CAUSE_RESPONSE_DATA_ERROR |           \
+#define EXCEPTION_RETRY_BITS (CBE_CAUSE_EXECUTION_HW_ERROR |            \
-                              CBE_CAUSE_RA_REQUEST_TIMEOUT |            \
                              CBE_CAUSE_TLBHW_ERROR |                   \
-                              CBE_CAUSE_HA_REQUEST_TIMEOUT)
+                              CBE_CAUSE_RA_REQUEST_TIMEOUT |            \
+                              CBE_CAUSE_RA_RESPONSE_NON_FATAL |         \
+                              CBE_CAUSE_HA_RESPONSE_NON_FATAL |         \
+                              CBE_CAUSE_RA_RESPONSE_DATA_ERROR |        \
+                              CBE_CAUSE_HA_RESPONSE_DATA_ERROR          \
+                              )
 /* Message queue head structure */
 union gru_mesqhead {
@@ -600,9 +623,11 @@ static inline int gru_get_cb_substatus(void *cb)
        return cbs->isubstatus;
 }
-/* Check the status of a CB. If the CB is in UPM mode, call the
+/*
- * OS to handle the UPM status.
+ * User interface to check an instruction status. UPM and exceptions
- * Returns the CB status field value (0 for normal completion)
+ * are handled automatically. However, this function does NOT wait
+ * for an active instruction to complete.
+ *
 */
 static inline int gru_check_status(void *cb)
 {
@@ -610,34 +635,31 @@ static inline int gru_check_status(void *cb)
        int ret;
        ret = cbs->istatus;
-        if (ret == CBS_CALL_OS)
+        if (ret != CBS_ACTIVE)
                ret = gru_check_status_proc(cb);
        return ret;
 }
-/* Wait for CB to complete.
+/*
- * Returns the CB status field value (0 for normal completion)
+ * User interface (via inline function) to wait for an instruction
+ * to complete. Completion status (IDLE or EXCEPTION is returned
+ * to the user. Exception due to hardware errors are automatically
+ * retried before returning an exception.
+ *
 */
 static inline int gru_wait(void *cb)
 {
-        struct gru_control_block_status *cbs = (void *)cb;
+        return gru_wait_proc(cb);
-        int ret = cbs->istatus;
-        if (ret != CBS_IDLE)
-                ret = gru_wait_proc(cb);
-        return ret;
 }
-/* Wait for CB to complete. Aborts program if error. (Note: error does NOT
+/*
+ * Wait for CB to complete. Aborts program if error. (Note: error does NOT
 * mean TLB mis - only fatal errors such as memory parity error or user
 * bugs will cause termination.
 */
 static inline void gru_wait_abort(void *cb)
 {
-        struct gru_control_block_status *cbs = (void *)cb;
+        gru_wait_abort_proc(cb);
-        if (cbs->istatus != CBS_IDLE)
-                gru_wait_abort_proc(cb);
 }
diff --git a/drivers/misc/sgi-gru/grufault.c b/drivers/misc/sgi-gru/grufault.c
index ab118558552e..679e01778286 100644
--- a/drivers/misc/sgi-gru/grufault.c
+++ b/drivers/misc/sgi-gru/grufault.c
@@ -166,7 +166,8 @@ static inline struct gru_state *irq_to_gru(int irq)
 * the GRU, atomic operations must be used to clear bits.
 */
 static void get_clear_fault_map(struct gru_state *gru,
-                                struct gru_tlb_fault_map *map)
+                                struct gru_tlb_fault_map *imap,
+                                struct gru_tlb_fault_map *dmap)
 {
        unsigned long i, k;
        struct gru_tlb_fault_map *tfm;
@@ -177,7 +178,11 @@ static void get_clear_fault_map(struct gru_state *gru,
                k = tfm->fault_bits[i];
                if (k)
                        k = xchg(&tfm->fault_bits[i], 0UL);
-                map->fault_bits[i] = k;
+                imap->fault_bits[i] = k;
+                k = tfm->done_bits[i];
+                if (k)
+                        k = xchg(&tfm->done_bits[i], 0UL);
+                dmap->fault_bits[i] = k;
        }
        /*
@@ -334,6 +339,12 @@ static int gru_try_dropin(struct gru_thread_state *gts,
         * Might be a hardware race OR a stupid user. Ignore FMM because FMM
         * is a transient state.
         */
+        if (tfh->status != TFHSTATUS_EXCEPTION) {
+                gru_flush_cache(tfh);
+                if (tfh->status != TFHSTATUS_EXCEPTION)
+                        goto failnoexception;
+                STAT(tfh_stale_on_fault);
+        }
        if (tfh->state == TFHSTATE_IDLE)
                goto failidle;
        if (tfh->state == TFHSTATE_MISS_FMM && cb)
@@ -401,8 +412,17 @@ failfmm:
        gru_dbg(grudev, "FAILED fmm tfh: 0x%p, state %d\n", tfh, tfh->state);
        return 0;
+failnoexception:
+        /* TFH status did not show exception pending */
+        gru_flush_cache(tfh);
+        if (cb)
+                gru_flush_cache(cb);
+        STAT(tlb_dropin_fail_no_exception);
+        gru_dbg(grudev, "FAILED non-exception tfh: 0x%p, status %d, state %d\n", tfh, tfh->status, tfh->state);
+        return 0;
 failidle:
-        /* TFH was idle  - no miss pending */
+        /* TFH state was idle  - no miss pending */
        gru_flush_cache(tfh);
        if (cb)
                gru_flush_cache(cb);
@@ -438,7 +458,7 @@ failactive:
 irqreturn_t gru_intr(int irq, void *dev_id)
 {
        struct gru_state *gru;
-        struct gru_tlb_fault_map map;
+        struct gru_tlb_fault_map imap, dmap;
        struct gru_thread_state *gts;
        struct gru_tlb_fault_handle *tfh = NULL;
        int cbrnum, ctxnum;
@@ -451,11 +471,15 @@ irqreturn_t gru_intr(int irq, void *dev_id)
                        raw_smp_processor_id(), irq);
                return IRQ_NONE;
        }
-        get_clear_fault_map(gru, &map);
+        get_clear_fault_map(gru, &imap, &dmap);
-        gru_dbg(grudev, "irq %d, gru %x, map 0x%lx\n", irq, gru->gs_gid,
-                map.fault_bits[0]);
+        for_each_cbr_in_tfm(cbrnum, dmap.fault_bits) {
+                complete(gru->gs_blade->bs_async_wq);
+                gru_dbg(grudev, "gid %d, cbr_done %d, done %d\n",
+                        gru->gs_gid, cbrnum, gru->gs_blade->bs_async_wq->done);
+        }
-        for_each_cbr_in_tfm(cbrnum, map.fault_bits) {
+        for_each_cbr_in_tfm(cbrnum, imap.fault_bits) {
                tfh = get_tfh_by_index(gru, cbrnum);
                prefetchw(tfh); /* Helps on hdw, required for emulator */
@@ -472,7 +496,9 @@ irqreturn_t gru_intr(int irq, void *dev_id)
                 * This is running in interrupt context. Trylock the mmap_sem.
                 * If it fails, retry the fault in user context.
                 */
-                if (down_read_trylock(&gts->ts_mm->mmap_sem)) {
+                if (!gts->ts_force_cch_reload &&
+                                        down_read_trylock(&gts->ts_mm->mmap_sem)) {
+                        gts->ustats.fmm_tlbdropin++;
                        gru_try_dropin(gts, tfh, NULL);
                        up_read(&gts->ts_mm->mmap_sem);
                } else {
@@ -491,6 +517,7 @@ static int gru_user_dropin(struct gru_thread_state *gts,
        struct gru_mm_struct *gms = gts->ts_gms;
        int ret;
+        gts->ustats.upm_tlbdropin++;
        while (1) {
                wait_event(gms->ms_wait_queue,
                           atomic_read(&gms->ms_range_active) == 0);
@@ -546,8 +573,8 @@ int gru_handle_user_call_os(unsigned long cb)
         * CCH may contain stale data if ts_force_cch_reload is set.
         */
        if (gts->ts_gru && gts->ts_force_cch_reload) {
-                gru_update_cch(gts, 0);
                gts->ts_force_cch_reload = 0;
+                gru_update_cch(gts, 0);
        }
        ret = -EAGAIN;
@@ -589,20 +616,26 @@ int gru_get_exception_detail(unsigned long arg)
        } else if (gts->ts_gru) {
                cbrnum = thread_cbr_number(gts, ucbnum);
                cbe = get_cbe_by_index(gts->ts_gru, cbrnum);
-                prefetchw(cbe);/* Harmless on hardware, required for emulator */
+                gru_flush_cache(cbe);   /* CBE not coherent */
                excdet.opc = cbe->opccpy;
                excdet.exopc = cbe->exopccpy;
                excdet.ecause = cbe->ecause;
                excdet.exceptdet0 = cbe->idef1upd;
                excdet.exceptdet1 = cbe->idef3upd;
+                excdet.cbrstate = cbe->cbrstate;
+                excdet.cbrexecstatus = cbe->cbrexecstatus;
+                gru_flush_cache(cbe);
                ret = 0;
        } else {
                ret = -EAGAIN;
        }
        gru_unlock_gts(gts);
-        gru_dbg(grudev, "address 0x%lx, ecause 0x%x\n", excdet.cb,
+        gru_dbg(grudev,
-                excdet.ecause);
+                "cb 0x%lx, op %d, exopc %d, cbrstate %d, cbrexecstatus 0x%x, ecause 0x%x, "
+                "exdet0 0x%lx, exdet1 0x%x\n",
+                excdet.cb, excdet.opc, excdet.exopc, excdet.cbrstate, excdet.cbrexecstatus,
+                excdet.ecause, excdet.exceptdet0, excdet.exceptdet1);
        if (!ret && copy_to_user((void __user *)arg, &excdet, sizeof(excdet)))
                ret = -EFAULT;
        return ret;
@@ -627,7 +660,7 @@ static int gru_unload_all_contexts(void)
                        if (gts && mutex_trylock(&gts->ts_ctxlock)) {
                                spin_unlock(&gru->gs_lock);
                                gru_unload_context(gts, 1);
-                                gru_unlock_gts(gts);
+                                mutex_unlock(&gts->ts_ctxlock);
                                spin_lock(&gru->gs_lock);
                        }
                }
@@ -669,6 +702,7 @@ int gru_user_flush_tlb(unsigned long arg)
 {
        struct gru_thread_state *gts;
        struct gru_flush_tlb_req req;
+        struct gru_mm_struct *gms;
        STAT(user_flush_tlb);
        if (copy_from_user(&req, (void __user *)arg, sizeof(req)))
@@ -681,8 +715,34 @@ int gru_user_flush_tlb(unsigned long arg)
        if (!gts)
                return -EINVAL;
-        gru_flush_tlb_range(gts->ts_gms, req.vaddr, req.len);
+        gms = gts->ts_gms;
        gru_unlock_gts(gts);
+        gru_flush_tlb_range(gms, req.vaddr, req.len);
+        return 0;
+}
+/*
+ * Fetch GSEG statisticss
+ */
+long gru_get_gseg_statistics(unsigned long arg)
+{
+        struct gru_thread_state *gts;
+        struct gru_get_gseg_statistics_req req;
+        if (copy_from_user(&req, (void __user *)arg, sizeof(req)))
+                return -EFAULT;
+        gts = gru_find_lock_gts(req.gseg);
+        if (gts) {
+                memcpy(&req.stats, &gts->ustats, sizeof(gts->ustats));
+                gru_unlock_gts(gts);
+        } else {
+                memset(&req.stats, 0, sizeof(gts->ustats));
+        }
+        if (copy_to_user((void __user *)arg, &req, sizeof(req)))
+                return -EFAULT;
        return 0;
 }
@@ -691,18 +751,34 @@ int gru_user_flush_tlb(unsigned long arg)
 * Register the current task as the user of the GSEG slice.
 * Needed for TLB fault interrupt targeting.
 */
-int gru_set_task_slice(long address)
+int gru_set_context_option(unsigned long arg)
 {
        struct gru_thread_state *gts;
+        struct gru_set_context_option_req req;
+        int ret = 0;
+        STAT(set_context_option);
+        if (copy_from_user(&req, (void __user *)arg, sizeof(req)))
+                return -EFAULT;
+        gru_dbg(grudev, "op %d, gseg 0x%lx, value1 0x%lx\n", req.op, req.gseg, req.val1);
-        STAT(set_task_slice);
+        gts = gru_alloc_locked_gts(req.gseg);
-        gru_dbg(grudev, "address 0x%lx\n", address);
-        gts = gru_alloc_locked_gts(address);
        if (!gts)
                return -EINVAL;
-        gts->ts_tgid_owner = current->tgid;
+        switch (req.op) {
+        case sco_gseg_owner:
+                /* Register the current task as the GSEG owner */
+                gts->ts_tgid_owner = current->tgid;
+                break;
+        case sco_cch_req_slice:
+                /* Set the CCH slice option */
+                gts->ts_cch_req_slice = req.val1 & 3;
+                break;
+        default:
+                ret = -EINVAL;
+        }
        gru_unlock_gts(gts);
-        return 0;
+        return ret;
 }
diff --git a/drivers/misc/sgi-gru/grufile.c b/drivers/misc/sgi-gru/grufile.c
index 3ce2920e2bf3..fa2d93a9fb8d 100644
--- a/drivers/misc/sgi-gru/grufile.c
+++ b/drivers/misc/sgi-gru/grufile.c
@@ -46,6 +46,7 @@
 struct gru_blade_state *gru_base[GRU_MAX_BLADES] __read_mostly;
 unsigned long gru_start_paddr __read_mostly;
+void *gru_start_vaddr __read_mostly;
 unsigned long gru_end_paddr __read_mostly;
 unsigned int gru_max_gids __read_mostly;
 struct gru_stats_s gru_stats;
@@ -135,11 +136,9 @@ static int gru_create_new_context(unsigned long arg)
        if (copy_from_user(&req, (void __user *)arg, sizeof(req)))
                return -EFAULT;
-        if (req.data_segment_bytes == 0 ||
+        if (req.data_segment_bytes > max_user_dsr_bytes)
-                                req.data_segment_bytes > max_user_dsr_bytes)
                return -EINVAL;
-        if (!req.control_blocks || !req.maximum_thread_count ||
+        if (req.control_blocks > max_user_cbrs || !req.maximum_thread_count)
-                                req.control_blocks > max_user_cbrs)
                return -EINVAL;
        if (!(req.options & GRU_OPT_MISS_MASK))
@@ -184,41 +183,6 @@ static long gru_get_config_info(unsigned long arg)
 }
 /*
- * Get GRU chiplet status
- */
-static long gru_get_chiplet_status(unsigned long arg)
-{
-        struct gru_state *gru;
-        struct gru_chiplet_info info;
-        if (copy_from_user(&info, (void __user *)arg, sizeof(info)))
-                return -EFAULT;
-        if (info.node == -1)
-                info.node = numa_node_id();
-        if (info.node >= num_possible_nodes() ||
-                        info.chiplet >= GRU_CHIPLETS_PER_HUB ||
-                        info.node < 0 || info.chiplet < 0)
-                return -EINVAL;
-        info.blade = uv_node_to_blade_id(info.node);
-        gru = get_gru(info.blade, info.chiplet);
-        info.total_dsr_bytes = GRU_NUM_DSR_BYTES;
-        info.total_cbr = GRU_NUM_CB;
-        info.total_user_dsr_bytes = GRU_NUM_DSR_BYTES -
-                gru->gs_reserved_dsr_bytes;
-        info.total_user_cbr = GRU_NUM_CB - gru->gs_reserved_cbrs;
-        info.free_user_dsr_bytes = hweight64(gru->gs_dsr_map) *
-                        GRU_DSR_AU_BYTES;
-        info.free_user_cbr = hweight64(gru->gs_cbr_map) * GRU_CBR_AU_SIZE;
-        if (copy_to_user((void __user *)arg, &info, sizeof(info)))
-                return -EFAULT;
-        return 0;
-}
-/*
 * gru_file_unlocked_ioctl
 *
 * Called to update file attributes via IOCTL calls.
@@ -234,8 +198,8 @@ static long gru_file_unlocked_ioctl(struct file *file, unsigned int req,
        case GRU_CREATE_CONTEXT:
                err = gru_create_new_context(arg);
                break;
-        case GRU_SET_TASK_SLICE:
+        case GRU_SET_CONTEXT_OPTION:
-                err = gru_set_task_slice(arg);
+                err = gru_set_context_option(arg);
                break;
        case GRU_USER_GET_EXCEPTION_DETAIL:
                err = gru_get_exception_detail(arg);
@@ -243,18 +207,24 @@ static long gru_file_unlocked_ioctl(struct file *file, unsigned int req,
        case GRU_USER_UNLOAD_CONTEXT:
                err = gru_user_unload_context(arg);
                break;
-        case GRU_GET_CHIPLET_STATUS:
-                err = gru_get_chiplet_status(arg);
-                break;
        case GRU_USER_FLUSH_TLB:
                err = gru_user_flush_tlb(arg);
                break;
        case GRU_USER_CALL_OS:
                err = gru_handle_user_call_os(arg);
                break;
+        case GRU_GET_GSEG_STATISTICS:
+                err = gru_get_gseg_statistics(arg);
+                break;
+        case GRU_KTEST:
+                err = gru_ktest(arg);
+                break;
        case GRU_GET_CONFIG_INFO:
                err = gru_get_config_info(arg);
                break;
+        case GRU_DUMP_CHIPLET_STATE:
+                err = gru_dump_chiplet_request(arg);
+                break;
        }
        return err;
 }
@@ -282,7 +252,6 @@ static void gru_init_chiplet(struct gru_state *gru, unsigned long paddr,
        gru_dbg(grudev, "bid %d, nid %d, gid %d, vaddr %p (0x%lx)\n",
                bid, nid, gru->gs_gid, gru->gs_gru_base_vaddr,
                gru->gs_gru_base_paddr);
-        gru_kservices_init(gru);
 }
 static int gru_init_tables(unsigned long gru_base_paddr, void *gru_base_vaddr)
@@ -309,6 +278,7 @@ static int gru_init_tables(unsigned long gru_base_paddr, void *gru_base_vaddr)
                memset(gru_base[bid], 0, sizeof(struct gru_blade_state));
                gru_base[bid]->bs_lru_gru = &gru_base[bid]->bs_grus[0];
                spin_lock_init(&gru_base[bid]->bs_lock);
+                init_rwsem(&gru_base[bid]->bs_kgts_sema);
                dsrbytes = 0;
                cbrs = 0;
@@ -372,7 +342,6 @@ static int __init gru_init(void)
 {
        int ret, irq, chip;
        char id[10];
-        void *gru_start_vaddr;
        if (!is_uv_system())
                return 0;
@@ -422,6 +391,7 @@ static int __init gru_init(void)
                printk(KERN_ERR "%s: init tables failed\n", GRU_DRIVER_ID_STR);
                goto exit3;
        }
+        gru_kservices_init();
        printk(KERN_INFO "%s: v%s\n", GRU_DRIVER_ID_STR,
               GRU_DRIVER_VERSION_STR);
@@ -440,7 +410,7 @@ exit1:
 static void __exit gru_exit(void)
 {
-        int i, bid, gid;
+        int i, bid;
        int order = get_order(sizeof(struct gru_state) *
                              GRU_CHIPLETS_PER_BLADE);
@@ -449,10 +419,7 @@ static void __exit gru_exit(void)
        for (i = 0; i < GRU_CHIPLETS_PER_BLADE; i++)
                free_irq(IRQ_GRU + i, NULL);
+        gru_kservices_exit();
-        foreach_gid(gid)
-                gru_kservices_exit(GID_TO_GRU(gid));
        for (bid = 0; bid < GRU_MAX_BLADES; bid++)
                free_pages((unsigned long)gru_base[bid], order);
diff --git a/drivers/misc/sgi-gru/gruhandles.c b/drivers/misc/sgi-gru/gruhandles.c
index 9b7ccb328697..37e7cfc53b9c 100644
--- a/drivers/misc/sgi-gru/gruhandles.c
+++ b/drivers/misc/sgi-gru/gruhandles.c
@@ -57,7 +57,7 @@ static void start_instruction(void *h)
 static int wait_instruction_complete(void *h, enum mcs_op opc)
 {
        int status;
-        cycles_t start_time = get_cycles();
+        unsigned long start_time = get_cycles();
        while (1) {
                cpu_relax();
@@ -65,25 +65,16 @@ static int wait_instruction_complete(void *h, enum mcs_op opc)
                if (status != CCHSTATUS_ACTIVE)
                        break;
                if (GRU_OPERATION_TIMEOUT < (get_cycles() - start_time))
-                        panic("GRU %p is malfunctioning\n", h);
+                        panic("GRU %p is malfunctioning: start %ld, end %ld\n",
+                              h, start_time, (unsigned long)get_cycles());
        }
        if (gru_options & OPT_STATS)
                update_mcs_stats(opc, get_cycles() - start_time);
        return status;
 }
-int cch_allocate(struct gru_context_configuration_handle *cch,
+int cch_allocate(struct gru_context_configuration_handle *cch)
-                int asidval, int sizeavail, unsigned long cbrmap,
-                unsigned long dsrmap)
 {
-        int i;
-        for (i = 0; i < 8; i++) {
-                cch->asid[i] = (asidval++);
-                cch->sizeavail[i] = sizeavail;
-        }
-        cch->dsr_allocation_map = dsrmap;
-        cch->cbr_allocation_map = cbrmap;
        cch->opc = CCHOP_ALLOCATE;
        start_instruction(cch);
        return wait_instruction_complete(cch, cchop_allocate);
diff --git a/drivers/misc/sgi-gru/gruhandles.h b/drivers/misc/sgi-gru/gruhandles.h
index 1ed74d7508c8..f44112242d00 100644
--- a/drivers/misc/sgi-gru/gruhandles.h
+++ b/drivers/misc/sgi-gru/gruhandles.h
@@ -39,7 +39,6 @@
 #define GRU_NUM_CBE             128
 #define GRU_NUM_TFH             128
 #define GRU_NUM_CCH             16
-#define GRU_NUM_GSH             1
 /* Maximum resource counts that can be reserved by user programs */
 #define GRU_NUM_USER_CBR        GRU_NUM_CBE
@@ -56,7 +55,6 @@
 #define GRU_CBE_BASE            (GRU_MCS_BASE + 0x10000)
 #define GRU_TFH_BASE            (GRU_MCS_BASE + 0x18000)
 #define GRU_CCH_BASE            (GRU_MCS_BASE + 0x20000)
-#define GRU_GSH_BASE            (GRU_MCS_BASE + 0x30000)
 /* User gseg constants */
 #define GRU_GSEG_STRIDE         (4 * 1024 * 1024)
@@ -251,15 +249,15 @@ struct gru_tlb_fault_handle {
        unsigned int fill1:9;
        unsigned int status:2;
-        unsigned int fill2:1;
+        unsigned int fill2:2;
-        unsigned int color:1;
        unsigned int state:3;
        unsigned int fill3:1;
-        unsigned int cause:7;           /* DW 0 - high 32 */
+        unsigned int cause:6;
+        unsigned int cb_int:1;
        unsigned int fill4:1;
-        unsigned int indexway:12;
+        unsigned int indexway:12;       /* DW 0 - high 32 */
        unsigned int fill5:4;
        unsigned int ctxnum:4;
@@ -457,21 +455,7 @@ enum gru_cbr_state {
        CBRSTATE_BUSY_INTERRUPT,
 };
-/* CBE cbrexecstatus bits */
+/* CBE cbrexecstatus bits  - defined in gru_instructions.h*/
-#define CBR_EXS_ABORT_OCC_BIT                   0
-#define CBR_EXS_INT_OCC_BIT                     1
-#define CBR_EXS_PENDING_BIT                     2
-#define CBR_EXS_QUEUED_BIT                      3
-#define CBR_EXS_TLBHW_BIT                       4
-#define CBR_EXS_EXCEPTION_BIT                   5
-#define CBR_EXS_ABORT_OCC                       (1 << CBR_EXS_ABORT_OCC_BIT)
-#define CBR_EXS_INT_OCC                         (1 << CBR_EXS_INT_OCC_BIT)
-#define CBR_EXS_PENDING                         (1 << CBR_EXS_PENDING_BIT)
-#define CBR_EXS_QUEUED                          (1 << CBR_EXS_QUEUED_BIT)
-#define CBR_EXS_TLBHW                           (1 << CBR_EXS_TLBHW_BIT)
-#define CBR_EXS_EXCEPTION                       (1 << CBR_EXS_EXCEPTION_BIT)
 /* CBE ecause bits  - defined in gru_instructions.h */
 /*
@@ -495,9 +479,7 @@ enum gru_cbr_state {
 /* minimum TLB purge count to ensure a full purge */
 #define GRUMAXINVAL             1024UL
-int cch_allocate(struct gru_context_configuration_handle *cch,
+int cch_allocate(struct gru_context_configuration_handle *cch);
-       int asidval, int sizeavail, unsigned long cbrmap, unsigned long dsrmap);
 int cch_start(struct gru_context_configuration_handle *cch);
 int cch_interrupt(struct gru_context_configuration_handle *cch);
 int cch_deallocate(struct gru_context_configuration_handle *cch);
diff --git a/drivers/misc/sgi-gru/grukdump.c b/drivers/misc/sgi-gru/grukdump.c
new file mode 100644
index 000000000000..55eabfa85585
--- /dev/null
+++ b/drivers/misc/sgi-gru/grukdump.c
@@ -0,0 +1,232 @@
+/*
+ * SN Platform GRU Driver
+ *
+ *            Dump GRU State
+ *
+ *  Copyright (c) 2008 Silicon Graphics, Inc.  All Rights Reserved.
+ *
+ *  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
+ */
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/spinlock.h>
+#include <linux/uaccess.h>
+#include <linux/delay.h>
+#include <linux/bitops.h>
+#include <asm/uv/uv_hub.h>
+#include "gru.h"
+#include "grutables.h"
+#include "gruhandles.h"
+#include "grulib.h"
+#define CCH_LOCK_ATTEMPTS       10
+static int gru_user_copy_handle(void __user **dp, void *s)
+{
+        if (copy_to_user(*dp, s, GRU_HANDLE_BYTES))
+                return -1;
+        *dp += GRU_HANDLE_BYTES;
+        return 0;
+}
+static int gru_dump_context_data(void *grubase,
+                        struct gru_context_configuration_handle *cch,
+                        void __user *ubuf, int ctxnum, int dsrcnt)
+{
+        void *cb, *cbe, *tfh, *gseg;
+        int i, scr;
+        gseg = grubase + ctxnum * GRU_GSEG_STRIDE;
+        cb = gseg + GRU_CB_BASE;
+        cbe = grubase + GRU_CBE_BASE;
+        tfh = grubase + GRU_TFH_BASE;
+        for_each_cbr_in_allocation_map(i, &cch->cbr_allocation_map, scr) {
+                if (gru_user_copy_handle(&ubuf, cb))
+                        goto fail;
+                if (gru_user_copy_handle(&ubuf, tfh + i * GRU_HANDLE_STRIDE))
+                        goto fail;
+                if (gru_user_copy_handle(&ubuf, cbe + i * GRU_HANDLE_STRIDE))
+                        goto fail;
+                cb += GRU_HANDLE_STRIDE;
+        }
+        if (dsrcnt)
+                memcpy(ubuf, gseg + GRU_DS_BASE, dsrcnt * GRU_HANDLE_STRIDE);
+        return 0;
+fail:
+        return -EFAULT;
+}
+static int gru_dump_tfm(struct gru_state *gru,
+                void __user *ubuf, void __user *ubufend)
+{
+        struct gru_tlb_fault_map *tfm;
+        int i, ret, bytes;
+        bytes = GRU_NUM_TFM * GRU_CACHE_LINE_BYTES;
+        if (bytes > ubufend - ubuf)
+                ret = -EFBIG;
+        for (i = 0; i < GRU_NUM_TFM; i++) {
+                tfm = get_tfm(gru->gs_gru_base_vaddr, i);
+                if (gru_user_copy_handle(&ubuf, tfm))
+                        goto fail;
+        }
+        return GRU_NUM_TFM * GRU_CACHE_LINE_BYTES;
+fail:
+        return -EFAULT;
+}
+static int gru_dump_tgh(struct gru_state *gru,
+                void __user *ubuf, void __user *ubufend)
+{
+        struct gru_tlb_global_handle *tgh;
+        int i, ret, bytes;
+        bytes = GRU_NUM_TGH * GRU_CACHE_LINE_BYTES;
+        if (bytes > ubufend - ubuf)
+                ret = -EFBIG;
+        for (i = 0; i < GRU_NUM_TGH; i++) {
+                tgh = get_tgh(gru->gs_gru_base_vaddr, i);
+                if (gru_user_copy_handle(&ubuf, tgh))
+                        goto fail;
+        }
+        return GRU_NUM_TGH * GRU_CACHE_LINE_BYTES;
+fail:
+        return -EFAULT;
+}
+static int gru_dump_context(struct gru_state *gru, int ctxnum,
+                void __user *ubuf, void __user *ubufend, char data_opt,
+                char lock_cch)
+{
+        struct gru_dump_context_header hdr;
+        struct gru_dump_context_header __user *uhdr = ubuf;
+        struct gru_context_configuration_handle *cch, *ubufcch;
+        struct gru_thread_state *gts;
+        int try, cch_locked, cbrcnt = 0, dsrcnt = 0, bytes = 0, ret = 0;
+        void *grubase;
+        memset(&hdr, 0, sizeof(hdr));
+        grubase = gru->gs_gru_base_vaddr;
+        cch = get_cch(grubase, ctxnum);
+        for (try = 0; try < CCH_LOCK_ATTEMPTS; try++) {
+                cch_locked =  trylock_cch_handle(cch);
+                if (cch_locked)
+                        break;
+                msleep(1);
+        }
+        ubuf += sizeof(hdr);
+        ubufcch = ubuf;
+        if (gru_user_copy_handle(&ubuf, cch))
+                goto fail;
+        if (cch_locked)
+                ubufcch->delresp = 0;
+        bytes = sizeof(hdr) + GRU_CACHE_LINE_BYTES;
+        if (cch_locked || !lock_cch) {
+                gts = gru->gs_gts[ctxnum];
+                if (gts && gts->ts_vma) {
+                        hdr.pid = gts->ts_tgid_owner;
+                        hdr.vaddr = gts->ts_vma->vm_start;
+                }
+                if (cch->state != CCHSTATE_INACTIVE) {
+                        cbrcnt = hweight64(cch->cbr_allocation_map) *
+                                                GRU_CBR_AU_SIZE;
+                        dsrcnt = data_opt ? hweight32(cch->dsr_allocation_map) *
+                                                GRU_DSR_AU_CL : 0;
+                }
+                bytes += (3 * cbrcnt + dsrcnt) * GRU_CACHE_LINE_BYTES;
+                if (bytes > ubufend - ubuf)
+                        ret = -EFBIG;
+                else
+                        ret = gru_dump_context_data(grubase, cch, ubuf, ctxnum,
+                                                        dsrcnt);
+        }
+        if (cch_locked)
+                unlock_cch_handle(cch);
+        if (ret)
+                return ret;
+        hdr.magic = GRU_DUMP_MAGIC;
+        hdr.gid = gru->gs_gid;
+        hdr.ctxnum = ctxnum;
+        hdr.cbrcnt = cbrcnt;
+        hdr.dsrcnt = dsrcnt;
+        hdr.cch_locked = cch_locked;
+        if (!ret && copy_to_user((void __user *)uhdr, &hdr, sizeof(hdr)))
+                ret = -EFAULT;
+        return ret ? ret : bytes;
+fail:
+        unlock_cch_handle(cch);
+        return -EFAULT;
+}
+int gru_dump_chiplet_request(unsigned long arg)
+{
+        struct gru_state *gru;
+        struct gru_dump_chiplet_state_req req;
+        void __user *ubuf;
+        void __user *ubufend;
+        int ctxnum, ret, cnt = 0;
+        if (copy_from_user(&req, (void __user *)arg, sizeof(req)))
+                return -EFAULT;
+        /* Currently, only dump by gid is implemented */
+        if (req.gid >= gru_max_gids || req.gid < 0)
+                return -EINVAL;
+        gru = GID_TO_GRU(req.gid);
+        ubuf = req.buf;
+        ubufend = req.buf + req.buflen;
+        ret = gru_dump_tfm(gru, ubuf, ubufend);
+        if (ret < 0)
+                goto fail;
+        ubuf += ret;
+        ret = gru_dump_tgh(gru, ubuf, ubufend);
+        if (ret < 0)
+                goto fail;
+        ubuf += ret;
+        for (ctxnum = 0; ctxnum < GRU_NUM_CCH; ctxnum++) {
+                if (req.ctxnum == ctxnum || req.ctxnum < 0) {
+                        ret = gru_dump_context(gru, ctxnum, ubuf, ubufend,
+                                                req.data_opt, req.lock_cch);
+                        if (ret < 0)
+                                goto fail;
+                        ubuf += ret;
+                        cnt++;
+                }
+        }
+        if (copy_to_user((void __user *)arg, &req, sizeof(req)))
+                return -EFAULT;
+        return cnt;
+fail:
+        return ret;
+}
diff --git a/drivers/misc/sgi-gru/grukservices.c b/drivers/misc/sgi-gru/grukservices.c
index d8bd7d84a7cf..eedbf9c32760 100644
--- a/drivers/misc/sgi-gru/grukservices.c
+++ b/drivers/misc/sgi-gru/grukservices.c
@@ -31,6 +31,7 @@
 #include <linux/proc_fs.h>
 #include <linux/interrupt.h>
 #include <linux/uaccess.h>
+#include <linux/delay.h>
 #include "gru.h"
 #include "grulib.h"
 #include "grutables.h"
@@ -45,18 +46,66 @@
 * resources. This will likely be replaced when we better understand the
 * kernel/user requirements.
 *
- * At boot time, the kernel permanently reserves a fixed number of
+ * Blade percpu resources reserved for kernel use. These resources are
- * CBRs/DSRs for each cpu to use. The resources are all taken from
+ * reserved whenever the the kernel context for the blade is loaded. Note
- * the GRU chiplet 1 on the blade. This leaves the full set of resources
+ * that the kernel context is not guaranteed to be always available. It is
- * of chiplet 0 available to be allocated to a single user.
+ * loaded on demand & can be stolen by a user if the user demand exceeds the
+ * kernel demand. The kernel can always reload the kernel context but
+ * a SLEEP may be required!!!.
+ *
+ * Async Overview:
+ *
+ *      Each blade has one "kernel context" that owns GRU kernel resources
+ *      located on the blade. Kernel drivers use GRU resources in this context
+ *      for sending messages, zeroing memory, etc.
+ *
+ *      The kernel context is dynamically loaded on demand. If it is not in
+ *      use by the kernel, the kernel context can be unloaded & given to a user.
+ *      The kernel context will be reloaded when needed. This may require that
+ *      a context be stolen from a user.
+ *              NOTE: frequent unloading/reloading of the kernel context is
+ *              expensive. We are depending on batch schedulers, cpusets, sane
+ *              drivers or some other mechanism to prevent the need for frequent
+ *              stealing/reloading.
+ *
+ *      The kernel context consists of two parts:
+ *              - 1 CB & a few DSRs that are reserved for each cpu on the blade.
+ *                Each cpu has it's own private resources & does not share them
+ *                with other cpus. These resources are used serially, ie,
+ *                locked, used & unlocked  on each call to a function in
+ *                grukservices.
+ *                      (Now that we have dynamic loading of kernel contexts, I
+ *                       may rethink this & allow sharing between cpus....)
+ *
+ *              - Additional resources can be reserved long term & used directly
+ *                by UV drivers located in the kernel. Drivers using these GRU
+ *                resources can use asynchronous GRU instructions that send
+ *                interrupts on completion.
+ *                      - these resources must be explicitly locked/unlocked
+ *                      - locked resources prevent (obviously) the kernel
+ *                        context from being unloaded.
+ *                      - drivers using these resource directly issue their own
+ *                        GRU instruction and must wait/check completion.
+ *
+ *                When these resources are reserved, the caller can optionally
+ *                associate a wait_queue with the resources and use asynchronous
+ *                GRU instructions. When an async GRU instruction completes, the
+ *                driver will do a wakeup on the event.
+ *
 */
-/* Blade percpu resources PERMANENTLY reserved for kernel use */
+#define ASYNC_HAN_TO_BID(h)     ((h) - 1)
+#define ASYNC_BID_TO_HAN(b)     ((b) + 1)
+#define ASYNC_HAN_TO_BS(h)      gru_base[ASYNC_HAN_TO_BID(h)]
+#define KCB_TO_GID(cb)          ((cb - gru_start_vaddr) /               \
+                                        (GRU_SIZE * GRU_CHIPLETS_PER_BLADE))
+#define KCB_TO_BS(cb)           gru_base[KCB_TO_GID(cb)]
 #define GRU_NUM_KERNEL_CBR      1
 #define GRU_NUM_KERNEL_DSR_BYTES 256
 #define GRU_NUM_KERNEL_DSR_CL   (GRU_NUM_KERNEL_DSR_BYTES /             \
                                        GRU_CACHE_LINE_BYTES)
-#define KERNEL_CTXNUM           15
 /* GRU instruction attributes for all instructions */
 #define IMA                     IMA_CB_DELAY
@@ -98,6 +147,108 @@ struct message_header {
 #define HSTATUS(mq, h)  ((mq) + offsetof(struct message_queue, hstatus[h]))
+/*
+ * Reload the blade's kernel context into a GRU chiplet. Called holding
+ * the bs_kgts_sema for READ. Will steal user contexts if necessary.
+ */
+static void gru_load_kernel_context(struct gru_blade_state *bs, int blade_id)
+{
+        struct gru_state *gru;
+        struct gru_thread_state *kgts;
+        void *vaddr;
+        int ctxnum, ncpus;
+        up_read(&bs->bs_kgts_sema);
+        down_write(&bs->bs_kgts_sema);
+        if (!bs->bs_kgts)
+                bs->bs_kgts = gru_alloc_gts(NULL, 0, 0, 0, 0);
+        kgts = bs->bs_kgts;
+        if (!kgts->ts_gru) {
+                STAT(load_kernel_context);
+                ncpus = uv_blade_nr_possible_cpus(blade_id);
+                kgts->ts_cbr_au_count = GRU_CB_COUNT_TO_AU(
+                        GRU_NUM_KERNEL_CBR * ncpus + bs->bs_async_cbrs);
+                kgts->ts_dsr_au_count = GRU_DS_BYTES_TO_AU(
+                        GRU_NUM_KERNEL_DSR_BYTES * ncpus +
+                                bs->bs_async_dsr_bytes);
+                while (!gru_assign_gru_context(kgts, blade_id)) {
+                        msleep(1);
+                        gru_steal_context(kgts, blade_id);
+                }
+                gru_load_context(kgts);
+                gru = bs->bs_kgts->ts_gru;
+                vaddr = gru->gs_gru_base_vaddr;
+                ctxnum = kgts->ts_ctxnum;
+                bs->kernel_cb = get_gseg_base_address_cb(vaddr, ctxnum, 0);
+                bs->kernel_dsr = get_gseg_base_address_ds(vaddr, ctxnum, 0);
+        }
+        downgrade_write(&bs->bs_kgts_sema);
+}
+/*
+ * Free all kernel contexts that are not currently in use.
+ *   Returns 0 if all freed, else number of inuse context.
+ */
+static int gru_free_kernel_contexts(void)
+{
+        struct gru_blade_state *bs;
+        struct gru_thread_state *kgts;
+        int bid, ret = 0;
+        for (bid = 0; bid < GRU_MAX_BLADES; bid++) {
+                bs = gru_base[bid];
+                if (!bs)
+                        continue;
+                if (down_write_trylock(&bs->bs_kgts_sema)) {
+                        kgts = bs->bs_kgts;
+                        if (kgts && kgts->ts_gru)
+                                gru_unload_context(kgts, 0);
+                        kfree(kgts);
+                        bs->bs_kgts = NULL;
+                        up_write(&bs->bs_kgts_sema);
+                } else {
+                        ret++;
+                }
+        }
+        return ret;
+}
+/*
+ * Lock & load the kernel context for the specified blade.
+ */
+static struct gru_blade_state *gru_lock_kernel_context(int blade_id)
+{
+        struct gru_blade_state *bs;
+        STAT(lock_kernel_context);
+        bs = gru_base[blade_id];
+        down_read(&bs->bs_kgts_sema);
+        if (!bs->bs_kgts || !bs->bs_kgts->ts_gru)
+                gru_load_kernel_context(bs, blade_id);
+        return bs;
+}
+/*
+ * Unlock the kernel context for the specified blade. Context is not
+ * unloaded but may be stolen before next use.
+ */
+static void gru_unlock_kernel_context(int blade_id)
+{
+        struct gru_blade_state *bs;
+        bs = gru_base[blade_id];
+        up_read(&bs->bs_kgts_sema);
+        STAT(unlock_kernel_context);
+}
+/*
+ * Reserve & get pointers to the DSR/CBRs reserved for the current cpu.
+ *      - returns with preemption disabled
+ */
 static int gru_get_cpu_resources(int dsr_bytes, void **cb, void **dsr)
 {
        struct gru_blade_state *bs;
@@ -105,30 +256,148 @@ static int gru_get_cpu_resources(int dsr_bytes, void **cb, void **dsr)
        BUG_ON(dsr_bytes > GRU_NUM_KERNEL_DSR_BYTES);
        preempt_disable();
-        bs = gru_base[uv_numa_blade_id()];
+        bs = gru_lock_kernel_context(uv_numa_blade_id());
        lcpu = uv_blade_processor_id();
        *cb = bs->kernel_cb + lcpu * GRU_HANDLE_STRIDE;
        *dsr = bs->kernel_dsr + lcpu * GRU_NUM_KERNEL_DSR_BYTES;
        return 0;
 }
+/*
+ * Free the current cpus reserved DSR/CBR resources.
+ */
 static void gru_free_cpu_resources(void *cb, void *dsr)
 {
+        gru_unlock_kernel_context(uv_numa_blade_id());
        preempt_enable();
 }
+/*
+ * Reserve GRU resources to be used asynchronously.
+ *   Note: currently supports only 1 reservation per blade.
+ *
+ *      input:
+ *              blade_id  - blade on which resources should be reserved
+ *              cbrs      - number of CBRs
+ *              dsr_bytes - number of DSR bytes needed
+ *      output:
+ *              handle to identify resource
+ *              (0 = async resources already reserved)
+ */
+unsigned long gru_reserve_async_resources(int blade_id, int cbrs, int dsr_bytes,
+                        struct completion *cmp)
+{
+        struct gru_blade_state *bs;
+        struct gru_thread_state *kgts;
+        int ret = 0;
+        bs = gru_base[blade_id];
+        down_write(&bs->bs_kgts_sema);
+        /* Verify no resources already reserved */
+        if (bs->bs_async_dsr_bytes + bs->bs_async_cbrs)
+                goto done;
+        bs->bs_async_dsr_bytes = dsr_bytes;
+        bs->bs_async_cbrs = cbrs;
+        bs->bs_async_wq = cmp;
+        kgts = bs->bs_kgts;
+        /* Resources changed. Unload context if already loaded */
+        if (kgts && kgts->ts_gru)
+                gru_unload_context(kgts, 0);
+        ret = ASYNC_BID_TO_HAN(blade_id);
+done:
+        up_write(&bs->bs_kgts_sema);
+        return ret;
+}
+/*
+ * Release async resources previously reserved.
+ *
+ *      input:
+ *              han - handle to identify resources
+ */
+void gru_release_async_resources(unsigned long han)
+{
+        struct gru_blade_state *bs = ASYNC_HAN_TO_BS(han);
+        down_write(&bs->bs_kgts_sema);
+        bs->bs_async_dsr_bytes = 0;
+        bs->bs_async_cbrs = 0;
+        bs->bs_async_wq = NULL;
+        up_write(&bs->bs_kgts_sema);
+}
+/*
+ * Wait for async GRU instructions to complete.
+ *
+ *      input:
+ *              han - handle to identify resources
+ */
+void gru_wait_async_cbr(unsigned long han)
+{
+        struct gru_blade_state *bs = ASYNC_HAN_TO_BS(han);
+        wait_for_completion(bs->bs_async_wq);
+        mb();
+}
+/*
+ * Lock previous reserved async GRU resources
+ *
+ *      input:
+ *              han - handle to identify resources
+ *      output:
+ *              cb  - pointer to first CBR
+ *              dsr - pointer to first DSR
+ */
+void gru_lock_async_resource(unsigned long han,  void **cb, void **dsr)
+{
+        struct gru_blade_state *bs = ASYNC_HAN_TO_BS(han);
+        int blade_id = ASYNC_HAN_TO_BID(han);
+        int ncpus;
+        gru_lock_kernel_context(blade_id);
+        ncpus = uv_blade_nr_possible_cpus(blade_id);
+        if (cb)
+                *cb = bs->kernel_cb + ncpus * GRU_HANDLE_STRIDE;
+        if (dsr)
+                *dsr = bs->kernel_dsr + ncpus * GRU_NUM_KERNEL_DSR_BYTES;
+}
+/*
+ * Unlock previous reserved async GRU resources
+ *
+ *      input:
+ *              han - handle to identify resources
+ */
+void gru_unlock_async_resource(unsigned long han)
+{
+        int blade_id = ASYNC_HAN_TO_BID(han);
+        gru_unlock_kernel_context(blade_id);
+}
+/*----------------------------------------------------------------------*/
 int gru_get_cb_exception_detail(void *cb,
                struct control_block_extended_exc_detail *excdet)
 {
        struct gru_control_block_extended *cbe;
+        struct gru_blade_state *bs;
+        int cbrnum;
-        cbe = get_cbe(GRUBASE(cb), get_cb_number(cb));
+        bs = KCB_TO_BS(cb);
-        prefetchw(cbe); /* Harmless on hardware, required for emulator */
+        cbrnum = thread_cbr_number(bs->bs_kgts, get_cb_number(cb));
+        cbe = get_cbe(GRUBASE(cb), cbrnum);
+        gru_flush_cache(cbe);   /* CBE not coherent */
        excdet->opc = cbe->opccpy;
        excdet->exopc = cbe->exopccpy;
        excdet->ecause = cbe->ecause;
        excdet->exceptdet0 = cbe->idef1upd;
        excdet->exceptdet1 = cbe->idef3upd;
+        gru_flush_cache(cbe);
        return 0;
 }
@@ -167,13 +436,13 @@ static int gru_retry_exception(void *cb)
        int retry = EXCEPTION_RETRY_LIMIT;
        while (1)  {
-                if (gru_get_cb_message_queue_substatus(cb))
-                        break;
                if (gru_wait_idle_or_exception(gen) == CBS_IDLE)
                        return CBS_IDLE;
+                if (gru_get_cb_message_queue_substatus(cb))
+                        return CBS_EXCEPTION;
                gru_get_cb_exception_detail(cb, &excdet);
-                if (excdet.ecause & ~EXCEPTION_RETRY_BITS)
+                if ((excdet.ecause & ~EXCEPTION_RETRY_BITS) ||
+                                (excdet.cbrexecstatus & CBR_EXS_ABORT_OCC))
                        break;
                if (retry-- == 0)
                        break;
@@ -416,6 +685,29 @@ static void send_message_queue_interrupt(struct gru_message_queue_desc *mqd)
                                mqd->interrupt_vector);
 }
+/*
+ * Handle a PUT failure. Note: if message was a 2-line message, one of the
+ * lines might have successfully have been written. Before sending the
+ * message, "present" must be cleared in BOTH lines to prevent the receiver
+ * from prematurely seeing the full message.
+ */
+static int send_message_put_nacked(void *cb, struct gru_message_queue_desc *mqd,
+                        void *mesg, int lines)
+{
+        unsigned long m;
+        m = mqd->mq_gpa + (gru_get_amo_value_head(cb) << 6);
+        if (lines == 2) {
+                gru_vset(cb, m, 0, XTYPE_CL, lines, 1, IMA);
+                if (gru_wait(cb) != CBS_IDLE)
+                        return MQE_UNEXPECTED_CB_ERR;
+        }
+        gru_vstore(cb, m, gru_get_tri(mesg), XTYPE_CL, lines, 1, IMA);
+        if (gru_wait(cb) != CBS_IDLE)
+                return MQE_UNEXPECTED_CB_ERR;
+        send_message_queue_interrupt(mqd);
+        return MQE_OK;
+}
 /*
 * Handle a gru_mesq failure. Some of these failures are software recoverable
@@ -425,7 +717,6 @@ static int send_message_failure(void *cb, struct gru_message_queue_desc *mqd,
                                void *mesg, int lines)
 {
        int substatus, ret = 0;
-        unsigned long m;
        substatus = gru_get_cb_message_queue_substatus(cb);
        switch (substatus) {
@@ -447,14 +738,7 @@ static int send_message_failure(void *cb, struct gru_message_queue_desc *mqd,
                break;
        case CBSS_PUT_NACKED:
                STAT(mesq_send_put_nacked);
-                m = mqd->mq_gpa + (gru_get_amo_value_head(cb) << 6);
+                ret = send_message_put_nacked(cb, mqd, mesg, lines);
-                gru_vstore(cb, m, gru_get_tri(mesg), XTYPE_CL, lines, 1, IMA);
-                if (gru_wait(cb) == CBS_IDLE) {
-                        ret = MQE_OK;
-                        send_message_queue_interrupt(mqd);
-                } else {
-                        ret = MQE_UNEXPECTED_CB_ERR;
-                }
                break;
        default:
                BUG();
@@ -597,115 +881,177 @@ EXPORT_SYMBOL_GPL(gru_copy_gpa);
 /* ------------------- KERNEL QUICKTESTS RUN AT STARTUP ----------------*/
 /*      Temp - will delete after we gain confidence in the GRU          */
-static __cacheline_aligned unsigned long word0;
-static __cacheline_aligned unsigned long word1;
-static int quicktest(struct gru_state *gru)
+static int quicktest0(unsigned long arg)
 {
+        unsigned long word0;
+        unsigned long word1;
        void *cb;
-        void *ds;
+        void *dsr;
        unsigned long *p;
+        int ret = -EIO;
-        cb = get_gseg_base_address_cb(gru->gs_gru_base_vaddr, KERNEL_CTXNUM, 0);
+        if (gru_get_cpu_resources(GRU_CACHE_LINE_BYTES, &cb, &dsr))
-        ds = get_gseg_base_address_ds(gru->gs_gru_base_vaddr, KERNEL_CTXNUM, 0);
+                return MQE_BUG_NO_RESOURCES;
-        p = ds;
+        p = dsr;
        word0 = MAGIC;
+        word1 = 0;
-        gru_vload(cb, uv_gpa(&word0), 0, XTYPE_DW, 1, 1, IMA);
+        gru_vload(cb, uv_gpa(&word0), gru_get_tri(dsr), XTYPE_DW, 1, 1, IMA);
-        if (gru_wait(cb) != CBS_IDLE)
+        if (gru_wait(cb) != CBS_IDLE) {
-                BUG();
+                printk(KERN_DEBUG "GRU quicktest0: CBR failure 1\n");
+                goto done;
+        }
-        if (*(unsigned long *)ds != MAGIC)
+        if (*p != MAGIC) {
-                BUG();
+                printk(KERN_DEBUG "GRU: quicktest0 bad magic 0x%lx\n", *p);
-        gru_vstore(cb, uv_gpa(&word1), 0, XTYPE_DW, 1, 1, IMA);
+                goto done;
-        if (gru_wait(cb) != CBS_IDLE)
+        }
-                BUG();
+        gru_vstore(cb, uv_gpa(&word1), gru_get_tri(dsr), XTYPE_DW, 1, 1, IMA);
+        if (gru_wait(cb) != CBS_IDLE) {
+                printk(KERN_DEBUG "GRU quicktest0: CBR failure 2\n");
+                goto done;
+        }
-        if (word0 != word1 || word0 != MAGIC) {
+        if (word0 != word1 || word1 != MAGIC) {
-                printk
+                printk(KERN_DEBUG
-                    ("GRU quicktest err: gid %d, found 0x%lx, expected 0x%lx\n",
+                       "GRU quicktest0 err: found 0x%lx, expected 0x%lx\n",
-                     gru->gs_gid, word1, MAGIC);
+                     word1, MAGIC);
-                BUG();          /* ZZZ should not be fatal */
+                goto done;
        }
+        ret = 0;
-        return 0;
+done:
+        gru_free_cpu_resources(cb, dsr);
+        return ret;
 }
+#define ALIGNUP(p, q)   ((void *)(((unsigned long)(p) + (q) - 1) & ~(q - 1)))
-int gru_kservices_init(struct gru_state *gru)
+static int quicktest1(unsigned long arg)
 {
-        struct gru_blade_state *bs;
+        struct gru_message_queue_desc mqd;
-        struct gru_context_configuration_handle *cch;
+        void *p, *mq;
-        unsigned long cbr_map, dsr_map;
+        unsigned long *dw;
-        int err, num, cpus_possible;
+        int i, ret = -EIO;
+        char mes[GRU_CACHE_LINE_BYTES], *m;
-        /*
-         * Currently, resources are reserved ONLY on the second chiplet
+        /* Need  1K cacheline aligned that does not cross page boundary */
-         * on each blade. This leaves ALL resources on chiplet 0 available
+        p = kmalloc(4096, 0);
-         * for user code.
+        mq = ALIGNUP(p, 1024);
-         */
+        memset(mes, 0xee, sizeof(mes));
-        bs = gru->gs_blade;
+        dw = mq;
-        if (gru != &bs->bs_grus[1])
-                return 0;
+        gru_create_message_queue(&mqd, mq, 8 * GRU_CACHE_LINE_BYTES, 0, 0, 0);
+        for (i = 0; i < 6; i++) {
-        cpus_possible = uv_blade_nr_possible_cpus(gru->gs_blade_id);
+                mes[8] = i;
+                do {
-        num = GRU_NUM_KERNEL_CBR * cpus_possible;
+                        ret = gru_send_message_gpa(&mqd, mes, sizeof(mes));
-        cbr_map = gru_reserve_cb_resources(gru, GRU_CB_COUNT_TO_AU(num), NULL);
+                } while (ret == MQE_CONGESTION);
-        gru->gs_reserved_cbrs += num;
+                if (ret)
+                        break;
-        num = GRU_NUM_KERNEL_DSR_BYTES * cpus_possible;
-        dsr_map = gru_reserve_ds_resources(gru, GRU_DS_BYTES_TO_AU(num), NULL);
-        gru->gs_reserved_dsr_bytes += num;
-        gru->gs_active_contexts++;
-        __set_bit(KERNEL_CTXNUM, &gru->gs_context_map);
-        cch = get_cch(gru->gs_gru_base_vaddr, KERNEL_CTXNUM);
-        bs->kernel_cb = get_gseg_base_address_cb(gru->gs_gru_base_vaddr,
-                                        KERNEL_CTXNUM, 0);
-        bs->kernel_dsr = get_gseg_base_address_ds(gru->gs_gru_base_vaddr,
-                                        KERNEL_CTXNUM, 0);
-        lock_cch_handle(cch);
-        cch->tfm_fault_bit_enable = 0;
-        cch->tlb_int_enable = 0;
-        cch->tfm_done_bit_enable = 0;
-        cch->unmap_enable = 1;
-        err = cch_allocate(cch, 0, 0, cbr_map, dsr_map);
-        if (err) {
-                gru_dbg(grudev,
-                        "Unable to allocate kernel CCH: gid %d, err %d\n",
-                        gru->gs_gid, err);
-                BUG();
        }
-        if (cch_start(cch)) {
+        if (ret != MQE_QUEUE_FULL || i != 4)
-                gru_dbg(grudev, "Unable to start kernel CCH: gid %d, err %d\n",
+                goto done;
-                        gru->gs_gid, err);
-                BUG();
+        for (i = 0; i < 6; i++) {
+                m = gru_get_next_message(&mqd);
+                if (!m || m[8] != i)
+                        break;
+                gru_free_message(&mqd, m);
        }
-        unlock_cch_handle(cch);
+        ret = (i == 4) ? 0 : -EIO;
-        if (gru_options & GRU_QUICKLOOK)
+done:
-                quicktest(gru);
+        kfree(p);
-        return 0;
+        return ret;
 }
-void gru_kservices_exit(struct gru_state *gru)
+static int quicktest2(unsigned long arg)
 {
-        struct gru_context_configuration_handle *cch;
+        static DECLARE_COMPLETION(cmp);
-        struct gru_blade_state *bs;
+        unsigned long han;
+        int blade_id = 0;
+        int numcb = 4;
+        int ret = 0;
+        unsigned long *buf;
+        void *cb0, *cb;
+        int i, k, istatus, bytes;
+        bytes = numcb * 4 * 8;
+        buf = kmalloc(bytes, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+        ret = -EBUSY;
+        han = gru_reserve_async_resources(blade_id, numcb, 0, &cmp);
+        if (!han)
+                goto done;
+        gru_lock_async_resource(han, &cb0, NULL);
+        memset(buf, 0xee, bytes);
+        for (i = 0; i < numcb; i++)
+                gru_vset(cb0 + i * GRU_HANDLE_STRIDE, uv_gpa(&buf[i * 4]), 0,
+                                XTYPE_DW, 4, 1, IMA_INTERRUPT);
+        ret = 0;
+        for (k = 0; k < numcb; k++) {
+                gru_wait_async_cbr(han);
+                for (i = 0; i < numcb; i++) {
+                        cb = cb0 + i * GRU_HANDLE_STRIDE;
+                        istatus = gru_check_status(cb);
+                        if (istatus == CBS_ACTIVE)
+                                continue;
+                        if (istatus == CBS_EXCEPTION)
+                                ret = -EFAULT;
+                        else if (buf[i] || buf[i + 1] || buf[i + 2] ||
+                                        buf[i + 3])
+                                ret = -EIO;
+                }
+        }
+        BUG_ON(cmp.done);
-        bs = gru->gs_blade;
+        gru_unlock_async_resource(han);
-        if (gru != &bs->bs_grus[1])
+        gru_release_async_resources(han);
-                return;
+done:
+        kfree(buf);
+        return ret;
+}
-        cch = get_cch(gru->gs_gru_base_vaddr, KERNEL_CTXNUM);
+/*
-        lock_cch_handle(cch);
+ * Debugging only. User hook for various kernel tests
-        if (cch_interrupt_sync(cch))
+ * of driver & gru.
-                BUG();
+ */
-        if (cch_deallocate(cch))
+int gru_ktest(unsigned long arg)
+{
+        int ret = -EINVAL;
+        switch (arg & 0xff) {
+        case 0:
+                ret = quicktest0(arg);
+                break;
+        case 1:
+                ret = quicktest1(arg);
+                break;
+        case 2:
+                ret = quicktest2(arg);
+                break;
+        case 99:
+                ret = gru_free_kernel_contexts();
+                break;
+        }
+        return ret;
+}
+int gru_kservices_init(void)
+{
+        return 0;
+}
+void gru_kservices_exit(void)
+{
+        if (gru_free_kernel_contexts())
                BUG();
-        unlock_cch_handle(cch);
 }
diff --git a/drivers/misc/sgi-gru/grukservices.h b/drivers/misc/sgi-gru/grukservices.h
index 747ed315d56f..d60d34bca44d 100644
--- a/drivers/misc/sgi-gru/grukservices.h
+++ b/drivers/misc/sgi-gru/grukservices.h
@@ -146,4 +146,55 @@ extern void *gru_get_next_message(struct gru_message_queue_desc *mqd);
 extern int gru_copy_gpa(unsigned long dest_gpa, unsigned long src_gpa,
                                                        unsigned int bytes);
+/*
+ * Reserve GRU resources to be used asynchronously.
+ *
+ *      input:
+ *              blade_id  - blade on which resources should be reserved
+ *              cbrs      - number of CBRs
+ *              dsr_bytes - number of DSR bytes needed
+ *              cmp       - completion structure for waiting for
+ *                          async completions
+ *      output:
+ *              handle to identify resource
+ *              (0 = no resources)
+ */
+extern unsigned long gru_reserve_async_resources(int blade_id, int cbrs, int dsr_bytes,
+                                struct completion *cmp);
+/*
+ * Release async resources previously reserved.
+ *
+ *      input:
+ *              han - handle to identify resources
+ */
+extern void gru_release_async_resources(unsigned long han);
+/*
+ * Wait for async GRU instructions to complete.
+ *
+ *      input:
+ *              han - handle to identify resources
+ */
+extern void gru_wait_async_cbr(unsigned long han);
+/*
+ * Lock previous reserved async GRU resources
+ *
+ *      input:
+ *              han - handle to identify resources
+ *      output:
+ *              cb  - pointer to first CBR
+ *              dsr - pointer to first DSR
+ */
+extern void gru_lock_async_resource(unsigned long han,  void **cb, void **dsr);
+/*
+ * Unlock previous reserved async GRU resources
+ *
+ *      input:
+ *              han - handle to identify resources
+ */
+extern void gru_unlock_async_resource(unsigned long han);
 #endif          /* __GRU_KSERVICES_H_ */
diff --git a/drivers/misc/sgi-gru/grulib.h b/drivers/misc/sgi-gru/grulib.h
index e56e196a6998..889bc442a3e8 100644
--- a/drivers/misc/sgi-gru/grulib.h
+++ b/drivers/misc/sgi-gru/grulib.h
@@ -32,8 +32,8 @@
 /* Set Number of Request Blocks */
 #define GRU_CREATE_CONTEXT              _IOWR(GRU_IOCTL_NUM, 1, void *)
-/* Register task as using the slice */
+/*  Set Context Options */
-#define GRU_SET_TASK_SLICE              _IOWR(GRU_IOCTL_NUM, 5, void *)
+#define GRU_SET_CONTEXT_OPTION          _IOWR(GRU_IOCTL_NUM, 4, void *)
 /* Fetch exception detail */
 #define GRU_USER_GET_EXCEPTION_DETAIL   _IOWR(GRU_IOCTL_NUM, 6, void *)
@@ -44,8 +44,11 @@
 /* For user unload context */
 #define GRU_USER_UNLOAD_CONTEXT         _IOWR(GRU_IOCTL_NUM, 9, void *)
-/* For fetching GRU chiplet status */
+/* For dumpping GRU chiplet state */
-#define GRU_GET_CHIPLET_STATUS          _IOWR(GRU_IOCTL_NUM, 10, void *)
+#define GRU_DUMP_CHIPLET_STATE          _IOWR(GRU_IOCTL_NUM, 11, void *)
+/* For getting gseg statistics */
+#define GRU_GET_GSEG_STATISTICS         _IOWR(GRU_IOCTL_NUM, 12, void *)
 /* For user TLB flushing (primarily for tests) */
 #define GRU_USER_FLUSH_TLB              _IOWR(GRU_IOCTL_NUM, 50, void *)
@@ -53,8 +56,26 @@
 /* Get some config options (primarily for tests & emulator) */
 #define GRU_GET_CONFIG_INFO             _IOWR(GRU_IOCTL_NUM, 51, void *)
+/* Various kernel self-tests */
+#define GRU_KTEST                       _IOWR(GRU_IOCTL_NUM, 52, void *)
 #define CONTEXT_WINDOW_BYTES(th)        (GRU_GSEG_PAGESIZE * (th))
 #define THREAD_POINTER(p, th)           (p + GRU_GSEG_PAGESIZE * (th))
+#define GSEG_START(cb)                  ((void *)((unsigned long)(cb) & ~(GRU_GSEG_PAGESIZE - 1)))
+/*
+ * Statictics kept on a per-GTS basis.
+ */
+struct gts_statistics {
+        unsigned long   fmm_tlbdropin;
+        unsigned long   upm_tlbdropin;
+        unsigned long   context_stolen;
+};
+struct gru_get_gseg_statistics_req {
+        unsigned long           gseg;
+        struct gts_statistics   stats;
+};
 /*
 * Structure used to pass TLB flush parameters to the driver
@@ -75,6 +96,16 @@ struct gru_unload_context_req {
 };
 /*
+ * Structure used to set context options
+ */
+enum {sco_gseg_owner, sco_cch_req_slice};
+struct gru_set_context_option_req {
+        unsigned long   gseg;
+        int             op;
+        unsigned long   val1;
+};
+/*
 * Structure used to pass TLB flush parameters to the driver
 */
 struct gru_flush_tlb_req {
@@ -84,6 +115,36 @@ struct gru_flush_tlb_req {
 };
 /*
+ * Structure used to pass TLB flush parameters to the driver
+ */
+enum {dcs_pid, dcs_gid};
+struct gru_dump_chiplet_state_req {
+        unsigned int    op;
+        unsigned int    gid;
+        int             ctxnum;
+        char            data_opt;
+        char            lock_cch;
+        pid_t           pid;
+        void            *buf;
+        size_t          buflen;
+        /* ---- output --- */
+        unsigned int    num_contexts;
+};
+#define GRU_DUMP_MAGIC  0x3474ab6c
+struct gru_dump_context_header {
+        unsigned int    magic;
+        unsigned int    gid;
+        unsigned char   ctxnum;
+        unsigned char   cbrcnt;
+        unsigned char   dsrcnt;
+        pid_t           pid;
+        unsigned long   vaddr;
+        int             cch_locked;
+        unsigned long   data[0];
+};
+/*
 * GRU configuration info (temp - for testing)
 */
 struct gru_config_info {
diff --git a/drivers/misc/sgi-gru/grumain.c b/drivers/misc/sgi-gru/grumain.c
index ec3f7a17d221..3bc643dad606 100644
--- a/drivers/misc/sgi-gru/grumain.c
+++ b/drivers/misc/sgi-gru/grumain.c
@@ -3,11 +3,21 @@
 *
 *            DRIVER TABLE MANAGER + GRU CONTEXT LOAD/UNLOAD
 *
- * This file is subject to the terms and conditions of the GNU General Public
+ *  Copyright (c) 2008 Silicon Graphics, Inc.  All Rights Reserved.
- * License.  See the file "COPYING" in the main directory of this archive
- * for more details.
 *
- * Copyright (c) 2008 Silicon Graphics, Inc.  All Rights Reserved.
+ *  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
 */
 #include <linux/kernel.h>
@@ -96,7 +106,7 @@ static int gru_reset_asid_limit(struct gru_state *gru, int asid)
        gid = gru->gs_gid;
 again:
        for (i = 0; i < GRU_NUM_CCH; i++) {
-                if (!gru->gs_gts[i])
+                if (!gru->gs_gts[i] || is_kernel_context(gru->gs_gts[i]))
                        continue;
                inuse_asid = gru->gs_gts[i]->ts_gms->ms_asids[gid].mt_asid;
                gru_dbg(grudev, "gid %d, gts %p, gms %p, inuse 0x%x, cxt %d\n",
@@ -150,7 +160,7 @@ static unsigned long reserve_resources(unsigned long *p, int n, int mmax,
        unsigned long bits = 0;
        int i;
-        do {
+        while (n--) {
                i = find_first_bit(p, mmax);
                if (i == mmax)
                        BUG();
@@ -158,7 +168,7 @@ static unsigned long reserve_resources(unsigned long *p, int n, int mmax,
                __set_bit(i, &bits);
                if (idx)
                        *idx++ = i;
-        } while (--n);
+        }
        return bits;
 }
@@ -299,38 +309,39 @@ static struct gru_thread_state *gru_find_current_gts_nolock(struct gru_vma_data
 /*
 * Allocate a thread state structure.
 */
-static struct gru_thread_state *gru_alloc_gts(struct vm_area_struct *vma,
+struct gru_thread_state *gru_alloc_gts(struct vm_area_struct *vma,
-                                              struct gru_vma_data *vdata,
+                int cbr_au_count, int dsr_au_count, int options, int tsid)
-                                              int tsid)
 {
        struct gru_thread_state *gts;
        int bytes;
-        bytes = DSR_BYTES(vdata->vd_dsr_au_count) +
+        bytes = DSR_BYTES(dsr_au_count) + CBR_BYTES(cbr_au_count);
-                                CBR_BYTES(vdata->vd_cbr_au_count);
        bytes += sizeof(struct gru_thread_state);
-        gts = kzalloc(bytes, GFP_KERNEL);
+        gts = kmalloc(bytes, GFP_KERNEL);
        if (!gts)
                return NULL;
        STAT(gts_alloc);
+        memset(gts, 0, sizeof(struct gru_thread_state)); /* zero out header */
        atomic_set(&gts->ts_refcnt, 1);
        mutex_init(&gts->ts_ctxlock);
-        gts->ts_cbr_au_count = vdata->vd_cbr_au_count;
+        gts->ts_cbr_au_count = cbr_au_count;
-        gts->ts_dsr_au_count = vdata->vd_dsr_au_count;
+        gts->ts_dsr_au_count = dsr_au_count;
-        gts->ts_user_options = vdata->vd_user_options;
+        gts->ts_user_options = options;
        gts->ts_tsid = tsid;
-        gts->ts_user_options = vdata->vd_user_options;
        gts->ts_ctxnum = NULLCTX;
-        gts->ts_mm = current->mm;
-        gts->ts_vma = vma;
        gts->ts_tlb_int_select = -1;
-        gts->ts_gms = gru_register_mmu_notifier();
+        gts->ts_cch_req_slice = -1;
        gts->ts_sizeavail = GRU_SIZEAVAIL(PAGE_SHIFT);
-        if (!gts->ts_gms)
+        if (vma) {
-                goto err;
+                gts->ts_mm = current->mm;
+                gts->ts_vma = vma;
+                gts->ts_gms = gru_register_mmu_notifier();
+                if (!gts->ts_gms)
+                        goto err;
+        }
-        gru_dbg(grudev, "alloc vdata %p, new gts %p\n", vdata, gts);
+        gru_dbg(grudev, "alloc gts %p\n", gts);
        return gts;
 err:
@@ -381,7 +392,8 @@ struct gru_thread_state *gru_alloc_thread_state(struct vm_area_struct *vma,
        struct gru_vma_data *vdata = vma->vm_private_data;
        struct gru_thread_state *gts, *ngts;
-        gts = gru_alloc_gts(vma, vdata, tsid);
+        gts = gru_alloc_gts(vma, vdata->vd_cbr_au_count, vdata->vd_dsr_au_count,
+                            vdata->vd_user_options, tsid);
        if (!gts)
                return NULL;
@@ -458,7 +470,8 @@ static void gru_prefetch_context(void *gseg, void *cb, void *cbe,
 }
 static void gru_load_context_data(void *save, void *grubase, int ctxnum,
-                                  unsigned long cbrmap, unsigned long dsrmap)
+                                  unsigned long cbrmap, unsigned long dsrmap,
+                                  int data_valid)
 {
        void *gseg, *cb, *cbe;
        unsigned long length;
@@ -471,12 +484,22 @@ static void gru_load_context_data(void *save, void *grubase, int ctxnum,
        gru_prefetch_context(gseg, cb, cbe, cbrmap, length);
        for_each_cbr_in_allocation_map(i, &cbrmap, scr) {
-                save += gru_copy_handle(cb, save);
+                if (data_valid) {
-                save += gru_copy_handle(cbe + i * GRU_HANDLE_STRIDE, save);
+                        save += gru_copy_handle(cb, save);
+                        save += gru_copy_handle(cbe + i * GRU_HANDLE_STRIDE,
+                                                save);
+                } else {
+                        memset(cb, 0, GRU_CACHE_LINE_BYTES);
+                        memset(cbe + i * GRU_HANDLE_STRIDE, 0,
+                                                GRU_CACHE_LINE_BYTES);
+                }
                cb += GRU_HANDLE_STRIDE;
        }
-        memcpy(gseg + GRU_DS_BASE, save, length);
+        if (data_valid)
+                memcpy(gseg + GRU_DS_BASE, save, length);
+        else
+                memset(gseg + GRU_DS_BASE, 0, length);
 }
 static void gru_unload_context_data(void *save, void *grubase, int ctxnum,
@@ -506,7 +529,8 @@ void gru_unload_context(struct gru_thread_state *gts, int savestate)
        struct gru_context_configuration_handle *cch;
        int ctxnum = gts->ts_ctxnum;
-        zap_vma_ptes(gts->ts_vma, UGRUADDR(gts), GRU_GSEG_PAGESIZE);
+        if (!is_kernel_context(gts))
+                zap_vma_ptes(gts->ts_vma, UGRUADDR(gts), GRU_GSEG_PAGESIZE);
        cch = get_cch(gru->gs_gru_base_vaddr, ctxnum);
        gru_dbg(grudev, "gts %p\n", gts);
@@ -514,11 +538,14 @@ void gru_unload_context(struct gru_thread_state *gts, int savestate)
        if (cch_interrupt_sync(cch))
                BUG();
-        gru_unload_mm_tracker(gru, gts);
+        if (!is_kernel_context(gts))
-        if (savestate)
+                gru_unload_mm_tracker(gru, gts);
+        if (savestate) {
                gru_unload_context_data(gts->ts_gdata, gru->gs_gru_base_vaddr,
                                        ctxnum, gts->ts_cbr_map,
                                        gts->ts_dsr_map);
+                gts->ts_data_valid = 1;
+        }
        if (cch_deallocate(cch))
                BUG();
@@ -526,24 +553,22 @@ void gru_unload_context(struct gru_thread_state *gts, int savestate)
        unlock_cch_handle(cch);
        gru_free_gru_context(gts);
-        STAT(unload_context);
 }
 /*
 * Load a GRU context by copying it from the thread data structure in memory
 * to the GRU.
 */
-static void gru_load_context(struct gru_thread_state *gts)
+void gru_load_context(struct gru_thread_state *gts)
 {
        struct gru_state *gru = gts->ts_gru;
        struct gru_context_configuration_handle *cch;
-        int err, asid, ctxnum = gts->ts_ctxnum;
+        int i, err, asid, ctxnum = gts->ts_ctxnum;
        gru_dbg(grudev, "gts %p\n", gts);
        cch = get_cch(gru->gs_gru_base_vaddr, ctxnum);
        lock_cch_handle(cch);
-        asid = gru_load_mm_tracker(gru, gts);
        cch->tfm_fault_bit_enable =
            (gts->ts_user_options == GRU_OPT_MISS_FMM_POLL
             || gts->ts_user_options == GRU_OPT_MISS_FMM_INTR);
@@ -552,9 +577,32 @@ static void gru_load_context(struct gru_thread_state *gts)
                gts->ts_tlb_int_select = gru_cpu_fault_map_id();
                cch->tlb_int_select = gts->ts_tlb_int_select;
        }
+        if (gts->ts_cch_req_slice >= 0) {
+                cch->req_slice_set_enable = 1;
+                cch->req_slice = gts->ts_cch_req_slice;
+        } else {
+                cch->req_slice_set_enable =0;
+        }
        cch->tfm_done_bit_enable = 0;
-        err = cch_allocate(cch, asid, gts->ts_sizeavail, gts->ts_cbr_map,
+        cch->dsr_allocation_map = gts->ts_dsr_map;
-                                gts->ts_dsr_map);
+        cch->cbr_allocation_map = gts->ts_cbr_map;
+        if (is_kernel_context(gts)) {
+                cch->unmap_enable = 1;
+                cch->tfm_done_bit_enable = 1;
+                cch->cb_int_enable = 1;
+        } else {
+                cch->unmap_enable = 0;
+                cch->tfm_done_bit_enable = 0;
+                cch->cb_int_enable = 0;
+                asid = gru_load_mm_tracker(gru, gts);
+                for (i = 0; i < 8; i++) {
+                        cch->asid[i] = asid + i;
+                        cch->sizeavail[i] = gts->ts_sizeavail;
+                }
+        }
+        err = cch_allocate(cch);
        if (err) {
                gru_dbg(grudev,
                        "err %d: cch %p, gts %p, cbr 0x%lx, dsr 0x%lx\n",
@@ -563,13 +611,11 @@ static void gru_load_context(struct gru_thread_state *gts)
        }
        gru_load_context_data(gts->ts_gdata, gru->gs_gru_base_vaddr, ctxnum,
-                              gts->ts_cbr_map, gts->ts_dsr_map);
+                        gts->ts_cbr_map, gts->ts_dsr_map, gts->ts_data_valid);
        if (cch_start(cch))
                BUG();
        unlock_cch_handle(cch);
-        STAT(load_context);
 }
 /*
@@ -599,6 +645,9 @@ int gru_update_cch(struct gru_thread_state *gts, int force_unload)
                                cch->sizeavail[i] = gts->ts_sizeavail;
                        gts->ts_tlb_int_select = gru_cpu_fault_map_id();
                        cch->tlb_int_select = gru_cpu_fault_map_id();
+                        cch->tfm_fault_bit_enable =
+                          (gts->ts_user_options == GRU_OPT_MISS_FMM_POLL
+                            || gts->ts_user_options == GRU_OPT_MISS_FMM_INTR);
                } else {
                        for (i = 0; i < 8; i++)
                                cch->asid[i] = 0;
@@ -642,7 +691,28 @@ static int gru_retarget_intr(struct gru_thread_state *gts)
 #define next_gru(b, g)  (((g) < &(b)->bs_grus[GRU_CHIPLETS_PER_BLADE - 1]) ?  \
                                 ((g)+1) : &(b)->bs_grus[0])
-static void gru_steal_context(struct gru_thread_state *gts)
+static int is_gts_stealable(struct gru_thread_state *gts,
+                struct gru_blade_state *bs)
+{
+        if (is_kernel_context(gts))
+                return down_write_trylock(&bs->bs_kgts_sema);
+        else
+                return mutex_trylock(&gts->ts_ctxlock);
+}
+static void gts_stolen(struct gru_thread_state *gts,
+                struct gru_blade_state *bs)
+{
+        if (is_kernel_context(gts)) {
+                up_write(&bs->bs_kgts_sema);
+                STAT(steal_kernel_context);
+        } else {
+                mutex_unlock(&gts->ts_ctxlock);
+                STAT(steal_user_context);
+        }
+}
+void gru_steal_context(struct gru_thread_state *gts, int blade_id)
 {
        struct gru_blade_state *blade;
        struct gru_state *gru, *gru0;
@@ -652,8 +722,7 @@ static void gru_steal_context(struct gru_thread_state *gts)
        cbr = gts->ts_cbr_au_count;
        dsr = gts->ts_dsr_au_count;
-        preempt_disable();
+        blade = gru_base[blade_id];
-        blade = gru_base[uv_numa_blade_id()];
        spin_lock(&blade->bs_lock);
        ctxnum = next_ctxnum(blade->bs_lru_ctxnum);
@@ -676,7 +745,7 @@ static void gru_steal_context(struct gru_thread_state *gts)
                         * success are high. If trylock fails, try to steal a
                         * different GSEG.
                         */
-                        if (ngts && mutex_trylock(&ngts->ts_ctxlock))
+                        if (ngts && is_gts_stealable(ngts, blade))
                                break;
                        ngts = NULL;
                        flag = 1;
@@ -690,13 +759,12 @@ static void gru_steal_context(struct gru_thread_state *gts)
        blade->bs_lru_gru = gru;
        blade->bs_lru_ctxnum = ctxnum;
        spin_unlock(&blade->bs_lock);
-        preempt_enable();
        if (ngts) {
-                STAT(steal_context);
+                gts->ustats.context_stolen++;
                ngts->ts_steal_jiffies = jiffies;
-                gru_unload_context(ngts, 1);
+                gru_unload_context(ngts, is_kernel_context(ngts) ? 0 : 1);
-                mutex_unlock(&ngts->ts_ctxlock);
+                gts_stolen(ngts, blade);
        } else {
                STAT(steal_context_failed);
        }
@@ -710,17 +778,17 @@ static void gru_steal_context(struct gru_thread_state *gts)
 /*
 * Scan the GRUs on the local blade & assign a GRU context.
 */
-static struct gru_state *gru_assign_gru_context(struct gru_thread_state *gts)
+struct gru_state *gru_assign_gru_context(struct gru_thread_state *gts,
+                                                int blade)
 {
        struct gru_state *gru, *grux;
        int i, max_active_contexts;
-        preempt_disable();
 again:
        gru = NULL;
        max_active_contexts = GRU_NUM_CCH;
-        for_each_gru_on_blade(grux, uv_numa_blade_id(), i) {
+        for_each_gru_on_blade(grux, blade, i) {
                if (check_gru_resources(grux, gts->ts_cbr_au_count,
                                        gts->ts_dsr_au_count,
                                        max_active_contexts)) {
@@ -760,7 +828,6 @@ again:
                STAT(assign_context_failed);
        }
-        preempt_enable();
        return gru;
 }
@@ -775,6 +842,7 @@ int gru_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
        struct gru_thread_state *gts;
        unsigned long paddr, vaddr;
+        int blade_id;
        vaddr = (unsigned long)vmf->virtual_address;
        gru_dbg(grudev, "vma %p, vaddr 0x%lx (0x%lx)\n",
@@ -789,8 +857,10 @@ int gru_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 again:
        mutex_lock(&gts->ts_ctxlock);
        preempt_disable();
+        blade_id = uv_numa_blade_id();
        if (gts->ts_gru) {
-                if (gts->ts_gru->gs_blade_id != uv_numa_blade_id()) {
+                if (gts->ts_gru->gs_blade_id != blade_id) {
                        STAT(migrated_nopfn_unload);
                        gru_unload_context(gts, 1);
                } else {
@@ -800,12 +870,15 @@ again:
        }
        if (!gts->ts_gru) {
-                if (!gru_assign_gru_context(gts)) {
+                STAT(load_user_context);
-                        mutex_unlock(&gts->ts_ctxlock);
+                if (!gru_assign_gru_context(gts, blade_id)) {
                        preempt_enable();
+                        mutex_unlock(&gts->ts_ctxlock);
+                        set_current_state(TASK_INTERRUPTIBLE);
                        schedule_timeout(GRU_ASSIGN_DELAY);  /* true hack ZZZ */
+                        blade_id = uv_numa_blade_id();
                        if (gts->ts_steal_jiffies + GRU_STEAL_DELAY < jiffies)
-                                gru_steal_context(gts);
+                                gru_steal_context(gts, blade_id);
                        goto again;
                }
                gru_load_context(gts);
@@ -815,8 +888,8 @@ again:
                                vma->vm_page_prot);
        }
-        mutex_unlock(&gts->ts_ctxlock);
        preempt_enable();
+        mutex_unlock(&gts->ts_ctxlock);
        return VM_FAULT_NOPAGE;
 }
diff --git a/drivers/misc/sgi-gru/gruprocfs.c b/drivers/misc/sgi-gru/gruprocfs.c
index ee74821b171c..9cbf95bedce6 100644
--- a/drivers/misc/sgi-gru/gruprocfs.c
+++ b/drivers/misc/sgi-gru/gruprocfs.c
@@ -51,9 +51,12 @@ static int statistics_show(struct seq_file *s, void *p)
        printstat(s, assign_context);
        printstat(s, assign_context_failed);
        printstat(s, free_context);
-        printstat(s, load_context);
+        printstat(s, load_user_context);
-        printstat(s, unload_context);
+        printstat(s, load_kernel_context);
-        printstat(s, steal_context);
+        printstat(s, lock_kernel_context);
+        printstat(s, unlock_kernel_context);
+        printstat(s, steal_user_context);
+        printstat(s, steal_kernel_context);
        printstat(s, steal_context_failed);
        printstat(s, nopfn);
        printstat(s, break_cow);
@@ -70,7 +73,7 @@ static int statistics_show(struct seq_file *s, void *p)
        printstat(s, user_flush_tlb);
        printstat(s, user_unload_context);
        printstat(s, user_exception);
-        printstat(s, set_task_slice);
+        printstat(s, set_context_option);
        printstat(s, migrate_check);
        printstat(s, migrated_retarget);
        printstat(s, migrated_unload);
@@ -84,6 +87,9 @@ static int statistics_show(struct seq_file *s, void *p)
        printstat(s, tlb_dropin_fail_range_active);
        printstat(s, tlb_dropin_fail_idle);
        printstat(s, tlb_dropin_fail_fmm);
+        printstat(s, tlb_dropin_fail_no_exception);
+        printstat(s, tlb_dropin_fail_no_exception_war);
+        printstat(s, tfh_stale_on_fault);
        printstat(s, mmu_invalidate_range);
        printstat(s, mmu_invalidate_page);
        printstat(s, mmu_clear_flush_young);
@@ -158,8 +164,7 @@ static ssize_t options_write(struct file *file, const char __user *userbuf,
        unsigned long val;
        char buf[80];
-        if (copy_from_user
+        if (strncpy_from_user(buf, userbuf, sizeof(buf) - 1) < 0)
-            (buf, userbuf, count < sizeof(buf) ? count : sizeof(buf)))
                return -EFAULT;
        buf[count - 1] = '\0';
        if (!strict_strtoul(buf, 10, &val))
diff --git a/drivers/misc/sgi-gru/grutables.h b/drivers/misc/sgi-gru/grutables.h
index bf1eeb7553ed..34ab3d453919 100644
--- a/drivers/misc/sgi-gru/grutables.h
+++ b/drivers/misc/sgi-gru/grutables.h
@@ -148,11 +148,13 @@
 #include <linux/wait.h>
 #include <linux/mmu_notifier.h>
 #include "gru.h"
+#include "grulib.h"
 #include "gruhandles.h"
 extern struct gru_stats_s gru_stats;
 extern struct gru_blade_state *gru_base[];
 extern unsigned long gru_start_paddr, gru_end_paddr;
+extern void *gru_start_vaddr;
 extern unsigned int gru_max_gids;
 #define GRU_MAX_BLADES          MAX_NUMNODES
@@ -174,9 +176,12 @@ struct gru_stats_s {
        atomic_long_t assign_context;
        atomic_long_t assign_context_failed;
        atomic_long_t free_context;
-        atomic_long_t load_context;
+        atomic_long_t load_user_context;
-        atomic_long_t unload_context;
+        atomic_long_t load_kernel_context;
-        atomic_long_t steal_context;
+        atomic_long_t lock_kernel_context;
+        atomic_long_t unlock_kernel_context;
+        atomic_long_t steal_user_context;
+        atomic_long_t steal_kernel_context;
        atomic_long_t steal_context_failed;
        atomic_long_t nopfn;
        atomic_long_t break_cow;
@@ -193,7 +198,7 @@ struct gru_stats_s {
        atomic_long_t user_flush_tlb;
        atomic_long_t user_unload_context;
        atomic_long_t user_exception;
-        atomic_long_t set_task_slice;
+        atomic_long_t set_context_option;
        atomic_long_t migrate_check;
        atomic_long_t migrated_retarget;
        atomic_long_t migrated_unload;
@@ -207,6 +212,9 @@ struct gru_stats_s {
        atomic_long_t tlb_dropin_fail_range_active;
        atomic_long_t tlb_dropin_fail_idle;
        atomic_long_t tlb_dropin_fail_fmm;
+        atomic_long_t tlb_dropin_fail_no_exception;
+        atomic_long_t tlb_dropin_fail_no_exception_war;
+        atomic_long_t tfh_stale_on_fault;
        atomic_long_t mmu_invalidate_range;
        atomic_long_t mmu_invalidate_page;
        atomic_long_t mmu_clear_flush_young;
@@ -253,7 +261,6 @@ extern struct mcs_op_statistic mcs_op_statistics[mcsop_last];
 #define OPT_DPRINT      1
 #define OPT_STATS       2
-#define GRU_QUICKLOOK   4
 #define IRQ_GRU                 110     /* Starting IRQ number for interrupts */
@@ -373,6 +380,7 @@ struct gru_thread_state {
                                                   required for contest */
        unsigned char           ts_cbr_au_count;/* Number of CBR resources
                                                   required for contest */
+        char                    ts_cch_req_slice;/* CCH packet slice */
        char                    ts_blade;       /* If >= 0, migrate context if
                                                   ref from diferent blade */
        char                    ts_force_cch_reload;
@@ -380,6 +388,9 @@ struct gru_thread_state {
                                                   after migration */
        char                    ts_cbr_idx[GRU_CBR_AU];/* CBR numbers of each
                                                          allocated CB */
+        int                     ts_data_valid;  /* Indicates if ts_gdata has
+                                                   valid data */
+        struct gts_statistics   ustats;         /* User statistics */
        unsigned long           ts_gdata[0];    /* save area for GRU data (CB,
                                                   DS, CBE) */
 };
@@ -452,6 +463,14 @@ struct gru_blade_state {
                                                           reserved cb */
        void                    *kernel_dsr;            /* First kernel
                                                           reserved DSR */
+        struct rw_semaphore     bs_kgts_sema;           /* lock for kgts */
+        struct gru_thread_state *bs_kgts;               /* GTS for kernel use */
+        /* ---- the following are used for managing kernel async GRU CBRs --- */
+        int                     bs_async_dsr_bytes;     /* DSRs for async */
+        int                     bs_async_cbrs;          /* CBRs AU for async */
+        struct completion       *bs_async_wq;
        /* ---- the following are protected by the bs_lock spinlock ---- */
        spinlock_t              bs_lock;                /* lock used for
                                                           stealing contexts */
@@ -552,6 +571,12 @@ struct gru_blade_state {
 /* Lock hierarchy checking enabled only in emulator */
+/* 0 = lock failed, 1 = locked */
+static inline int __trylock_handle(void *h)
+{
+        return !test_and_set_bit(1, h);
+}
 static inline void __lock_handle(void *h)
 {
        while (test_and_set_bit(1, h))
@@ -563,6 +588,11 @@ static inline void __unlock_handle(void *h)
        clear_bit(1, h);
 }
+static inline int trylock_cch_handle(struct gru_context_configuration_handle *cch)
+{
+        return __trylock_handle(cch);
+}
 static inline void lock_cch_handle(struct gru_context_configuration_handle *cch)
 {
        __lock_handle(cch);
@@ -584,6 +614,11 @@ static inline void unlock_tgh_handle(struct gru_tlb_global_handle *tgh)
        __unlock_handle(tgh);
 }
+static inline int is_kernel_context(struct gru_thread_state *gts)
+{
+        return !gts->ts_mm;
+}
 /*-----------------------------------------------------------------------------
 * Function prototypes & externs
 */
@@ -598,24 +633,32 @@ extern struct gru_thread_state *gru_find_thread_state(struct vm_area_struct
                                *vma, int tsid);
 extern struct gru_thread_state *gru_alloc_thread_state(struct vm_area_struct
                                *vma, int tsid);
+extern struct gru_state *gru_assign_gru_context(struct gru_thread_state *gts,
+                int blade);
+extern void gru_load_context(struct gru_thread_state *gts);
+extern void gru_steal_context(struct gru_thread_state *gts, int blade_id);
 extern void gru_unload_context(struct gru_thread_state *gts, int savestate);
 extern int gru_update_cch(struct gru_thread_state *gts, int force_unload);
 extern void gts_drop(struct gru_thread_state *gts);
 extern void gru_tgh_flush_init(struct gru_state *gru);
-extern int gru_kservices_init(struct gru_state *gru);
+extern int gru_kservices_init(void);
-extern void gru_kservices_exit(struct gru_state *gru);
+extern void gru_kservices_exit(void);
+extern int gru_dump_chiplet_request(unsigned long arg);
+extern long gru_get_gseg_statistics(unsigned long arg);
 extern irqreturn_t gru_intr(int irq, void *dev_id);
 extern int gru_handle_user_call_os(unsigned long address);
 extern int gru_user_flush_tlb(unsigned long arg);
 extern int gru_user_unload_context(unsigned long arg);
 extern int gru_get_exception_detail(unsigned long arg);
-extern int gru_set_task_slice(long address);
+extern int gru_set_context_option(unsigned long address);
 extern int gru_cpu_fault_map_id(void);
 extern struct vm_area_struct *gru_find_vma(unsigned long vaddr);
 extern void gru_flush_all_tlb(struct gru_state *gru);
 extern int gru_proc_init(void);
 extern void gru_proc_exit(void);
+extern struct gru_thread_state *gru_alloc_gts(struct vm_area_struct *vma,
+                int cbr_au_count, int dsr_au_count, int options, int tsid);
 extern unsigned long gru_reserve_cb_resources(struct gru_state *gru,
                int cbr_au_count, char *cbmap);
 extern unsigned long gru_reserve_ds_resources(struct gru_state *gru,
@@ -624,6 +667,7 @@ extern int gru_fault(struct vm_area_struct *, struct vm_fault *vmf);
 extern struct gru_mm_struct *gru_register_mmu_notifier(void);
 extern void gru_drop_mmu_notifier(struct gru_mm_struct *gms);
+extern int gru_ktest(unsigned long arg);
 extern void gru_flush_tlb_range(struct gru_mm_struct *gms, unsigned long start,
                                        unsigned long len);
diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c
index 7e3738112c4e..38f1c3375d7f 100644
--- a/drivers/net/bnx2.c
+++ b/drivers/net/bnx2.c
@@ -3552,14 +3552,14 @@ bnx2_set_rx_mode(struct net_device *dev)
                sort_mode |= BNX2_RPM_SORT_USER0_MC_HSH_EN;
        }
-        if (dev->uc_count > BNX2_MAX_UNICAST_ADDRESSES) {
+        if (dev->uc.count > BNX2_MAX_UNICAST_ADDRESSES) {
                rx_mode |= BNX2_EMAC_RX_MODE_PROMISCUOUS;
                sort_mode |= BNX2_RPM_SORT_USER0_PROM_EN |
                             BNX2_RPM_SORT_USER0_PROM_VLAN;
        } else if (!(dev->flags & IFF_PROMISC)) {
                /* Add all entries into to the match filter list */
                i = 0;
-                list_for_each_entry(ha, &dev->uc_list, list) {
+                list_for_each_entry(ha, &dev->uc.list, list) {
                        bnx2_set_mac_addr(bp, ha->addr,
                                          i + BNX2_START_UNICAST_ADDRESS_INDEX);
                        sort_mode |= (1 <<
diff --git a/drivers/net/davinci_emac.c b/drivers/net/davinci_emac.c
index 0e9b9f9632c1..2df8fb0af701 100644
--- a/drivers/net/davinci_emac.c
+++ b/drivers/net/davinci_emac.c
@@ -2767,7 +2767,6 @@ static int __devexit davinci_emac_remove(struct platform_device *pdev)
        dev_notice(&ndev->dev, "DaVinci EMAC: davinci_emac_remove()\n");
-        clk_disable(emac_clk);
        platform_set_drvdata(pdev, NULL);
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        mdiobus_unregister(priv->mii_bus);
diff --git a/drivers/net/e100.c b/drivers/net/e100.c
index f7929e89eb03..efa680f4b8dd 100644
--- a/drivers/net/e100.c
+++ b/drivers/net/e100.c
@@ -2895,12 +2895,13 @@ static void __e100_shutdown(struct pci_dev *pdev, bool *enable_wake)
 static int __e100_power_off(struct pci_dev *pdev, bool wake)
 {
-        if (wake) {
+        if (wake)
                return pci_prepare_to_sleep(pdev);
-        } else {
-                pci_wake_from_d3(pdev, false);
+        pci_wake_from_d3(pdev, false);
-                return pci_set_power_state(pdev, PCI_D3hot);
+        pci_set_power_state(pdev, PCI_D3hot);
-        }
+        return 0;
 }
 #ifdef CONFIG_PM
diff --git a/drivers/net/e1000/e1000_main.c b/drivers/net/e1000/e1000_main.c
index 8d36743c8140..5e3356f8eb5a 100644
--- a/drivers/net/e1000/e1000_main.c
+++ b/drivers/net/e1000/e1000_main.c
@@ -2370,7 +2370,7 @@ static void e1000_set_rx_mode(struct net_device *netdev)
                        rctl |= E1000_RCTL_VFE;
        }
-        if (netdev->uc_count > rar_entries - 1) {
+        if (netdev->uc.count > rar_entries - 1) {
                rctl |= E1000_RCTL_UPE;
        } else if (!(netdev->flags & IFF_PROMISC)) {
                rctl &= ~E1000_RCTL_UPE;
@@ -2394,7 +2394,7 @@ static void e1000_set_rx_mode(struct net_device *netdev)
         */
        i = 1;
        if (use_uc)
-                list_for_each_entry(ha, &netdev->uc_list, list) {
+                list_for_each_entry(ha, &netdev->uc.list, list) {
                        if (i == rar_entries)
                                break;
                        e1000_rar_set(hw, ha->addr, i++);
diff --git a/drivers/net/forcedeth.c b/drivers/net/forcedeth.c
index b60a3041b64c..1094d292630f 100644
--- a/drivers/net/forcedeth.c
+++ b/drivers/net/forcedeth.c
@@ -719,7 +719,8 @@ static const struct register_test nv_registers_test[] = {
 struct nv_skb_map {
        struct sk_buff *skb;
        dma_addr_t dma;
-        unsigned int dma_len;
+        unsigned int dma_len:31;
+        unsigned int dma_single:1;
        struct ring_desc_ex *first_tx_desc;
        struct nv_skb_map *next_tx_ctx;
 };
@@ -1912,6 +1913,7 @@ static void nv_init_tx(struct net_device *dev)
                np->tx_skb[i].skb = NULL;
                np->tx_skb[i].dma = 0;
                np->tx_skb[i].dma_len = 0;
+                np->tx_skb[i].dma_single = 0;
                np->tx_skb[i].first_tx_desc = NULL;
                np->tx_skb[i].next_tx_ctx = NULL;
        }
@@ -1930,23 +1932,30 @@ static int nv_init_ring(struct net_device *dev)
                return nv_alloc_rx_optimized(dev);
 }
-static int nv_release_txskb(struct net_device *dev, struct nv_skb_map* tx_skb)
+static void nv_unmap_txskb(struct fe_priv *np, struct nv_skb_map *tx_skb)
 {
-        struct fe_priv *np = netdev_priv(dev);
        if (tx_skb->dma) {
-                pci_unmap_page(np->pci_dev, tx_skb->dma,
+                if (tx_skb->dma_single)
-                               tx_skb->dma_len,
+                        pci_unmap_single(np->pci_dev, tx_skb->dma,
-                               PCI_DMA_TODEVICE);
+                                         tx_skb->dma_len,
+                                         PCI_DMA_TODEVICE);
+                else
+                        pci_unmap_page(np->pci_dev, tx_skb->dma,
+                                       tx_skb->dma_len,
+                                       PCI_DMA_TODEVICE);
                tx_skb->dma = 0;
        }
+}
+static int nv_release_txskb(struct fe_priv *np, struct nv_skb_map *tx_skb)
+{
+        nv_unmap_txskb(np, tx_skb);
        if (tx_skb->skb) {
                dev_kfree_skb_any(tx_skb->skb);
                tx_skb->skb = NULL;
                return 1;
-        } else {
-                return 0;
        }
+        return 0;
 }
 static void nv_drain_tx(struct net_device *dev)
@@ -1964,10 +1973,11 @@ static void nv_drain_tx(struct net_device *dev)
                        np->tx_ring.ex[i].bufhigh = 0;
                        np->tx_ring.ex[i].buflow = 0;
                }
-                if (nv_release_txskb(dev, &np->tx_skb[i]))
+                if (nv_release_txskb(np, &np->tx_skb[i]))
                        dev->stats.tx_dropped++;
                np->tx_skb[i].dma = 0;
                np->tx_skb[i].dma_len = 0;
+                np->tx_skb[i].dma_single = 0;
                np->tx_skb[i].first_tx_desc = NULL;
                np->tx_skb[i].next_tx_ctx = NULL;
        }
@@ -2171,6 +2181,7 @@ static int nv_start_xmit(struct sk_buff *skb, struct net_device *dev)
                np->put_tx_ctx->dma = pci_map_single(np->pci_dev, skb->data + offset, bcnt,
                                                PCI_DMA_TODEVICE);
                np->put_tx_ctx->dma_len = bcnt;
+                np->put_tx_ctx->dma_single = 1;
                put_tx->buf = cpu_to_le32(np->put_tx_ctx->dma);
                put_tx->flaglen = cpu_to_le32((bcnt-1) | tx_flags);
@@ -2196,6 +2207,7 @@ static int nv_start_xmit(struct sk_buff *skb, struct net_device *dev)
                        np->put_tx_ctx->dma = pci_map_page(np->pci_dev, frag->page, frag->page_offset+offset, bcnt,
                                                           PCI_DMA_TODEVICE);
                        np->put_tx_ctx->dma_len = bcnt;
+                        np->put_tx_ctx->dma_single = 0;
                        put_tx->buf = cpu_to_le32(np->put_tx_ctx->dma);
                        put_tx->flaglen = cpu_to_le32((bcnt-1) | tx_flags);
@@ -2291,6 +2303,7 @@ static int nv_start_xmit_optimized(struct sk_buff *skb, struct net_device *dev)
                np->put_tx_ctx->dma = pci_map_single(np->pci_dev, skb->data + offset, bcnt,
                                                PCI_DMA_TODEVICE);
                np->put_tx_ctx->dma_len = bcnt;
+                np->put_tx_ctx->dma_single = 1;
                put_tx->bufhigh = cpu_to_le32(dma_high(np->put_tx_ctx->dma));
                put_tx->buflow = cpu_to_le32(dma_low(np->put_tx_ctx->dma));
                put_tx->flaglen = cpu_to_le32((bcnt-1) | tx_flags);
@@ -2317,6 +2330,7 @@ static int nv_start_xmit_optimized(struct sk_buff *skb, struct net_device *dev)
                        np->put_tx_ctx->dma = pci_map_page(np->pci_dev, frag->page, frag->page_offset+offset, bcnt,
                                                           PCI_DMA_TODEVICE);
                        np->put_tx_ctx->dma_len = bcnt;
+                        np->put_tx_ctx->dma_single = 0;
                        put_tx->bufhigh = cpu_to_le32(dma_high(np->put_tx_ctx->dma));
                        put_tx->buflow = cpu_to_le32(dma_low(np->put_tx_ctx->dma));
                        put_tx->flaglen = cpu_to_le32((bcnt-1) | tx_flags);
@@ -2434,10 +2448,7 @@ static int nv_tx_done(struct net_device *dev, int limit)
                dprintk(KERN_DEBUG "%s: nv_tx_done: flags 0x%x.\n",
                                        dev->name, flags);
-                pci_unmap_page(np->pci_dev, np->get_tx_ctx->dma,
+                nv_unmap_txskb(np, np->get_tx_ctx);
-                               np->get_tx_ctx->dma_len,
-                               PCI_DMA_TODEVICE);
-                np->get_tx_ctx->dma = 0;
                if (np->desc_ver == DESC_VER_1) {
                        if (flags & NV_TX_LASTPACKET) {
@@ -2502,10 +2513,7 @@ static int nv_tx_done_optimized(struct net_device *dev, int limit)
                dprintk(KERN_DEBUG "%s: nv_tx_done_optimized: flags 0x%x.\n",
                                        dev->name, flags);
-                pci_unmap_page(np->pci_dev, np->get_tx_ctx->dma,
+                nv_unmap_txskb(np, np->get_tx_ctx);
-                               np->get_tx_ctx->dma_len,
-                               PCI_DMA_TODEVICE);
-                np->get_tx_ctx->dma = 0;
                if (flags & NV_TX2_LASTPACKET) {
                        if (!(flags & NV_TX2_ERROR))
@@ -5091,7 +5099,7 @@ static int nv_loopback_test(struct net_device *dev)
                dprintk(KERN_DEBUG "%s: loopback - did not receive test packet\n", dev->name);
        }
-        pci_unmap_page(np->pci_dev, test_dma_addr,
+        pci_unmap_single(np->pci_dev, test_dma_addr,
                       (skb_end_pointer(tx_skb) - tx_skb->data),
                       PCI_DMA_TODEVICE);
        dev_kfree_skb_any(tx_skb);
diff --git a/drivers/net/hamradio/bpqether.c b/drivers/net/hamradio/bpqether.c
index 5105548ad50c..abcd19a8bff9 100644
--- a/drivers/net/hamradio/bpqether.c
+++ b/drivers/net/hamradio/bpqether.c
@@ -260,7 +260,7 @@ static int bpq_xmit(struct sk_buff *skb, struct net_device *dev)
         */
        if (!netif_running(dev)) {
                kfree_skb(skb);
-                return -ENODEV;
+                return NETDEV_TX_OK;
        }
        skb_pull(skb, 1);
diff --git a/drivers/net/hp100.c b/drivers/net/hp100.c
index 8feda9fe8297..1d3429a415e6 100644
--- a/drivers/net/hp100.c
+++ b/drivers/net/hp100.c
@@ -1495,13 +1495,8 @@ static int hp100_start_xmit_bm(struct sk_buff *skb, struct net_device *dev)
        hp100_outw(0x4210, TRACE);
        printk("hp100: %s: start_xmit_bm\n", dev->name);
 #endif
-        if (skb == NULL) {
-                return 0;
-        }
        if (skb->len <= 0)
-                return 0;
+                goto drop;
        if (lp->chip == HP100_CHIPID_SHASTA && skb_padto(skb, ETH_ZLEN))
                return 0;
@@ -1514,10 +1509,10 @@ static int hp100_start_xmit_bm(struct sk_buff *skb, struct net_device *dev)
 #endif
                /* not waited long enough since last tx? */
                if (time_before(jiffies, dev->trans_start + HZ))
-                        return -EAGAIN;
+                        goto drop;
                if (hp100_check_lan(dev))
-                        return -EIO;
+                        goto drop;
                if (lp->lan_type == HP100_LAN_100 && lp->hub_status < 0) {
                        /* we have a 100Mb/s adapter but it isn't connected to hub */
@@ -1551,7 +1546,7 @@ static int hp100_start_xmit_bm(struct sk_buff *skb, struct net_device *dev)
                }
                dev->trans_start = jiffies;
-                return -EAGAIN;
+                goto drop;
        }
        /*
@@ -1591,6 +1586,10 @@ static int hp100_start_xmit_bm(struct sk_buff *skb, struct net_device *dev)
        dev->trans_start = jiffies;
        return 0;
+drop:
+        dev_kfree_skb(skb);
+        return NETDEV_TX_OK;
 }
@@ -1648,16 +1647,11 @@ static int hp100_start_xmit(struct sk_buff *skb, struct net_device *dev)
        hp100_outw(0x4212, TRACE);
        printk("hp100: %s: start_xmit\n", dev->name);
 #endif
-        if (skb == NULL) {
-                return 0;
-        }
        if (skb->len <= 0)
-                return 0;
+                goto drop;
        if (hp100_check_lan(dev))
-                return -EIO;
+                goto drop;
        /* If there is not enough free memory on the card... */
        i = hp100_inl(TX_MEM_FREE) & 0x7fffffff;
@@ -1671,7 +1665,7 @@ static int hp100_start_xmit(struct sk_buff *skb, struct net_device *dev)
                        printk("hp100: %s: trans_start timing problem\n",
                               dev->name);
 #endif
-                        return -EAGAIN;
+                        goto drop;
                }
                if (lp->lan_type == HP100_LAN_100 && lp->hub_status < 0) {
                        /* we have a 100Mb/s adapter but it isn't connected to hub */
@@ -1705,7 +1699,7 @@ static int hp100_start_xmit(struct sk_buff *skb, struct net_device *dev)
                        }
                }
                dev->trans_start = jiffies;
-                return -EAGAIN;
+                goto drop;
        }
        for (i = 0; i < 6000 && (hp100_inb(OPTION_MSW) & HP100_TX_CMD); i++) {
@@ -1759,6 +1753,11 @@ static int hp100_start_xmit(struct sk_buff *skb, struct net_device *dev)
 #endif
        return 0;
+drop:
+        dev_kfree_skb(skb);
+        return NETDEV_TX_OK;
 }
diff --git a/drivers/net/igbvf/netdev.c b/drivers/net/igbvf/netdev.c
index 22aadb7884fa..2bc9d63027db 100644
--- a/drivers/net/igbvf/netdev.c
+++ b/drivers/net/igbvf/netdev.c
@@ -1281,7 +1281,7 @@ static void igbvf_configure_tx(struct igbvf_adapter *adapter)
        /* Setup the HW Tx Head and Tail descriptor pointers */
        ew32(TDLEN(0), tx_ring->count * sizeof(union e1000_adv_tx_desc));
        tdba = tx_ring->dma;
-        ew32(TDBAL(0), (tdba & DMA_32BIT_MASK));
+        ew32(TDBAL(0), (tdba & DMA_BIT_MASK(32)));
        ew32(TDBAH(0), (tdba >> 32));
        ew32(TDH(0), 0);
        ew32(TDT(0), 0);
@@ -1367,7 +1367,7 @@ static void igbvf_configure_rx(struct igbvf_adapter *adapter)
         * the Base and Length of the Rx Descriptor Ring
         */
        rdba = rx_ring->dma;
-        ew32(RDBAL(0), (rdba & DMA_32BIT_MASK));
+        ew32(RDBAL(0), (rdba & DMA_BIT_MASK(32)));
        ew32(RDBAH(0), (rdba >> 32));
        ew32(RDLEN(0), rx_ring->count * sizeof(union e1000_adv_rx_desc));
        rx_ring->head = E1000_RDH(0);
@@ -2628,15 +2628,16 @@ static int __devinit igbvf_probe(struct pci_dev *pdev,
                return err;
        pci_using_dac = 0;
-        err = pci_set_dma_mask(pdev, DMA_64BIT_MASK);
+        err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
        if (!err) {
-                err = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
+                err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
                if (!err)
                        pci_using_dac = 1;
        } else {
-                err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+                err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
                if (err) {
-                        err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
+                        err = pci_set_consistent_dma_mask(pdev,
+                                                          DMA_BIT_MASK(32));
                        if (err) {
                                dev_err(&pdev->dev, "No usable DMA "
                                        "configuration, aborting\n");
diff --git a/drivers/net/ixgbe/ixgbe_fcoe.c b/drivers/net/ixgbe/ixgbe_fcoe.c
index 3c3bf1f07b81..fa9f24e23683 100644
--- a/drivers/net/ixgbe/ixgbe_fcoe.c
+++ b/drivers/net/ixgbe/ixgbe_fcoe.c
@@ -251,7 +251,7 @@ int ixgbe_fcoe_ddp_get(struct net_device *netdev, u16 xid,
        /* program DMA context */
        hw = &adapter->hw;
        spin_lock_bh(&fcoe->lock);
-        IXGBE_WRITE_REG(hw, IXGBE_FCPTRL, ddp->udp & DMA_32BIT_MASK);
+        IXGBE_WRITE_REG(hw, IXGBE_FCPTRL, ddp->udp & DMA_BIT_MASK(32));
        IXGBE_WRITE_REG(hw, IXGBE_FCPTRH, (u64)ddp->udp >> 32);
        IXGBE_WRITE_REG(hw, IXGBE_FCBUFF, fcbuff);
        IXGBE_WRITE_REG(hw, IXGBE_FCDMARW, fcdmarw);
diff --git a/drivers/net/ixgbe/ixgbe_main.c b/drivers/net/ixgbe/ixgbe_main.c
index a551a96ce676..e756e220db32 100644
--- a/drivers/net/ixgbe/ixgbe_main.c
+++ b/drivers/net/ixgbe/ixgbe_main.c
@@ -2321,7 +2321,7 @@ static void ixgbe_set_rx_mode(struct net_device *netdev)
        IXGBE_WRITE_REG(hw, IXGBE_VLNCTRL, vlnctrl);
        /* reprogram secondary unicast list */
-        hw->mac.ops.update_uc_addr_list(hw, &netdev->uc_list);
+        hw->mac.ops.update_uc_addr_list(hw, &netdev->uc.list);
        /* reprogram multicast list */
        addr_count = netdev->mc_count;
@@ -5261,7 +5261,7 @@ static int ixgbe_ioctl(struct net_device *netdev, struct ifreq *req, int cmd)
 /**
 * ixgbe_add_sanmac_netdev - Add the SAN MAC address to the corresponding
- * netdev->dev_addr_list
+ * netdev->dev_addrs
 * @netdev: network interface device structure
 *
 * Returns non-zero on failure
@@ -5282,7 +5282,7 @@ static int ixgbe_add_sanmac_netdev(struct net_device *dev)
 /**
 * ixgbe_del_sanmac_netdev - Removes the SAN MAC address to the corresponding
- * netdev->dev_addr_list
+ * netdev->dev_addrs
 * @netdev: network interface device structure
 *
 * Returns non-zero on failure
diff --git a/drivers/net/mv643xx_eth.c b/drivers/net/mv643xx_eth.c
index b4e18a58cb1b..745ae8b4a2e8 100644
--- a/drivers/net/mv643xx_eth.c
+++ b/drivers/net/mv643xx_eth.c
@@ -1729,7 +1729,7 @@ static u32 uc_addr_filter_mask(struct net_device *dev)
                return 0;
        nibbles = 1 << (dev->dev_addr[5] & 0x0f);
-        list_for_each_entry(ha, &dev->uc_list, list) {
+        list_for_each_entry(ha, &dev->uc.list, list) {
                if (memcmp(dev->dev_addr, ha->addr, 5))
                        return 0;
                if ((dev->dev_addr[5] ^ ha->addr[5]) & 0xf0)
diff --git a/drivers/net/netxen/netxen_nic.h b/drivers/net/netxen/netxen_nic.h
index ab11c2b3f0fe..970cedeb5f37 100644
--- a/drivers/net/netxen/netxen_nic.h
+++ b/drivers/net/netxen/netxen_nic.h
@@ -169,6 +169,7 @@
 #define MAX_NUM_CARDS           4
 #define MAX_BUFFERS_PER_CMD     32
+#define TX_STOP_THRESH          ((MAX_SKB_FRAGS >> 2) + 4)
 /*
 * Following are the states of the Phantom. Phantom will set them and
@@ -1436,7 +1437,7 @@ int netxen_nic_set_mac(struct net_device *netdev, void *p);
 struct net_device_stats *netxen_nic_get_stats(struct net_device *netdev);
 void netxen_nic_update_cmd_producer(struct netxen_adapter *adapter,
-                struct nx_host_tx_ring *tx_ring, uint32_t crb_producer);
+                struct nx_host_tx_ring *tx_ring);
 /*
 * NetXen Board information
@@ -1538,6 +1539,14 @@ dma_watchdog_wakeup(struct netxen_adapter *adapter)
 }
+static inline u32 netxen_tx_avail(struct nx_host_tx_ring *tx_ring)
+{
+        smp_mb();
+        return find_diff_among(tx_ring->producer,
+                        tx_ring->sw_consumer, tx_ring->num_desc);
+}
 int netxen_get_flash_mac_addr(struct netxen_adapter *adapter, __le64 *mac);
 int netxen_p3_get_mac_addr(struct netxen_adapter *adapter, __le64 *mac);
 extern void netxen_change_ringparam(struct netxen_adapter *adapter);
diff --git a/drivers/net/netxen/netxen_nic_hdr.h b/drivers/net/netxen/netxen_nic_hdr.h
index 7f0ddbfa7b28..3cc047844af3 100644
--- a/drivers/net/netxen/netxen_nic_hdr.h
+++ b/drivers/net/netxen/netxen_nic_hdr.h
@@ -355,6 +355,7 @@ enum {
 #define NETXEN_HW_CRB_HUB_AGT_ADR_LPC   \
        ((NETXEN_HW_H6_CH_HUB_ADR << 7) | NETXEN_HW_LPC_CRB_AGT_ADR)
+#define NETXEN_SRE_MISC                 (NETXEN_CRB_SRE + 0x0002c)
 #define NETXEN_SRE_INT_STATUS           (NETXEN_CRB_SRE + 0x00034)
 #define NETXEN_SRE_PBI_ACTIVE_STATUS    (NETXEN_CRB_SRE + 0x01014)
 #define NETXEN_SRE_L1RE_CTL             (NETXEN_CRB_SRE + 0x03000)
diff --git a/drivers/net/netxen/netxen_nic_hw.c b/drivers/net/netxen/netxen_nic_hw.c
index 42ffb825ebf1..ce3b89d2cbb6 100644
--- a/drivers/net/netxen/netxen_nic_hw.c
+++ b/drivers/net/netxen/netxen_nic_hw.c
@@ -488,7 +488,7 @@ netxen_send_cmd_descs(struct netxen_adapter *adapter,
        tx_ring->producer = producer;
-        netxen_nic_update_cmd_producer(adapter, tx_ring, producer);
+        netxen_nic_update_cmd_producer(adapter, tx_ring);
        netif_tx_unlock_bh(adapter->netdev);
@@ -2041,8 +2041,8 @@ void netxen_nic_get_firmware_info(struct netxen_adapter *adapter)
                        fw_major, fw_minor, fw_build);
        if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
-                i = NXRD32(adapter, NETXEN_MIU_MN_CONTROL);
+                i = NXRD32(adapter, NETXEN_SRE_MISC);
-                adapter->ahw.cut_through = (i & 0x4) ? 1 : 0;
+                adapter->ahw.cut_through = (i & 0x8000) ? 1 : 0;
                dev_info(&pdev->dev, "firmware running in %s mode\n",
                adapter->ahw.cut_through ? "cut-through" : "legacy");
        }
diff --git a/drivers/net/netxen/netxen_nic_init.c b/drivers/net/netxen/netxen_nic_init.c
index 6f77ad58e3b3..bdb143d2b5c7 100644
--- a/drivers/net/netxen/netxen_nic_init.c
+++ b/drivers/net/netxen/netxen_nic_init.c
@@ -1292,7 +1292,6 @@ int netxen_process_cmd_ring(struct netxen_adapter *adapter)
                return 1;
        sw_consumer = tx_ring->sw_consumer;
-        barrier(); /* hw_consumer can change underneath */
        hw_consumer = le32_to_cpu(*(tx_ring->hw_consumer));
        while (sw_consumer != hw_consumer) {
@@ -1319,14 +1318,15 @@ int netxen_process_cmd_ring(struct netxen_adapter *adapter)
                        break;
        }
-        tx_ring->sw_consumer = sw_consumer;
        if (count && netif_running(netdev)) {
+                tx_ring->sw_consumer = sw_consumer;
                smp_mb();
                if (netif_queue_stopped(netdev) && netif_carrier_ok(netdev)) {
                        netif_tx_lock(netdev);
-                        netif_wake_queue(netdev);
+                        if (netxen_tx_avail(tx_ring) > TX_STOP_THRESH)
-                        smp_mb();
+                                netif_wake_queue(netdev);
                        netif_tx_unlock(netdev);
                }
        }
@@ -1343,7 +1343,6 @@ int netxen_process_cmd_ring(struct netxen_adapter *adapter)
         * There is still a possible race condition and the host could miss an
         * interrupt. The card has to take care of this.
         */
-        barrier(); /* hw_consumer can change underneath */
        hw_consumer = le32_to_cpu(*(tx_ring->hw_consumer));
        done = (sw_consumer == hw_consumer);
        spin_unlock(&adapter->tx_clean_lock);
diff --git a/drivers/net/netxen/netxen_nic_main.c b/drivers/net/netxen/netxen_nic_main.c
index 98737ef72936..71daa3d5f114 100644
--- a/drivers/net/netxen/netxen_nic_main.c
+++ b/drivers/net/netxen/netxen_nic_main.c
@@ -107,9 +107,14 @@ static uint32_t crb_cmd_producer[4] = {
 void
 netxen_nic_update_cmd_producer(struct netxen_adapter *adapter,
-                struct nx_host_tx_ring *tx_ring, u32 producer)
+                struct nx_host_tx_ring *tx_ring)
 {
-        NXWR32(adapter, tx_ring->crb_cmd_producer, producer);
+        NXWR32(adapter, tx_ring->crb_cmd_producer, tx_ring->producer);
+        if (netxen_tx_avail(tx_ring) <= TX_STOP_THRESH) {
+                netif_stop_queue(adapter->netdev);
+                smp_mb();
+        }
 }
 static uint32_t crb_cmd_consumer[4] = {
@@ -119,9 +124,9 @@ static uint32_t crb_cmd_consumer[4] = {
 static inline void
 netxen_nic_update_cmd_consumer(struct netxen_adapter *adapter,
-                struct nx_host_tx_ring *tx_ring, u32 consumer)
+                struct nx_host_tx_ring *tx_ring)
 {
-        NXWR32(adapter, tx_ring->crb_cmd_consumer, consumer);
+        NXWR32(adapter, tx_ring->crb_cmd_consumer, tx_ring->sw_consumer);
 }
 static uint32_t msi_tgt_status[8] = {
@@ -900,8 +905,11 @@ netxen_nic_attach(struct netxen_adapter *adapter)
                tx_ring->crb_cmd_producer = crb_cmd_producer[adapter->portnum];
                tx_ring->crb_cmd_consumer = crb_cmd_consumer[adapter->portnum];
-                netxen_nic_update_cmd_producer(adapter, tx_ring, 0);
+                tx_ring->producer = 0;
-                netxen_nic_update_cmd_consumer(adapter, tx_ring, 0);
+                tx_ring->sw_consumer = 0;
+                netxen_nic_update_cmd_producer(adapter, tx_ring);
+                netxen_nic_update_cmd_consumer(adapter, tx_ring);
        }
        for (ring = 0; ring < adapter->max_rds_rings; ring++) {
@@ -1362,7 +1370,7 @@ netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
        dma_addr_t temp_dma;
        int i, k;
-        u32 producer, consumer;
+        u32 producer;
        int frag_count, no_of_desc;
        u32 num_txd = tx_ring->num_desc;
        bool is_tso = false;
@@ -1372,15 +1380,13 @@ netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
        /* 4 fragments per cmd des */
        no_of_desc = (frag_count + 3) >> 2;
-        producer = tx_ring->producer;
+        if (unlikely(no_of_desc + 2) > netxen_tx_avail(tx_ring)) {
-        smp_mb();
-        consumer = tx_ring->sw_consumer;
-        if ((no_of_desc+2) >= find_diff_among(producer, consumer, num_txd)) {
                netif_stop_queue(netdev);
-                smp_mb();
                return NETDEV_TX_BUSY;
        }
+        producer = tx_ring->producer;
        hwdesc = &tx_ring->desc_head[producer];
        netxen_clear_cmddesc((u64 *)hwdesc);
        pbuf = &tx_ring->cmd_buf_arr[producer];
@@ -1493,7 +1499,7 @@ netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
        tx_ring->producer = producer;
        adapter->stats.txbytes += skb->len;
-        netxen_nic_update_cmd_producer(adapter, tx_ring, producer);
+        netxen_nic_update_cmd_producer(adapter, tx_ring);
        adapter->stats.xmitcalled++;
diff --git a/drivers/net/niu.c b/drivers/net/niu.c
index fa61a12c5e15..d2146d4a10f3 100644
--- a/drivers/net/niu.c
+++ b/drivers/net/niu.c
@@ -6376,7 +6376,7 @@ static void niu_set_rx_mode(struct net_device *dev)
        if ((dev->flags & IFF_ALLMULTI) || (dev->mc_count > 0))
                np->flags |= NIU_FLAGS_MCAST;
-        alt_cnt = dev->uc_count;
+        alt_cnt = dev->uc.count;
        if (alt_cnt > niu_num_alt_addr(np)) {
                alt_cnt = 0;
                np->flags |= NIU_FLAGS_PROMISC;
@@ -6385,7 +6385,7 @@ static void niu_set_rx_mode(struct net_device *dev)
        if (alt_cnt) {
                int index = 0;
-                list_for_each_entry(ha, &dev->uc_list, list) {
+                list_for_each_entry(ha, &dev->uc.list, list) {
                        err = niu_set_alt_mac(np, index, ha->addr);
                        if (err)
                                printk(KERN_WARNING PFX "%s: Error %d "
diff --git a/drivers/net/phy/phy_device.c b/drivers/net/phy/phy_device.c
index a2ece89622d6..eba937c46376 100644
--- a/drivers/net/phy/phy_device.c
+++ b/drivers/net/phy/phy_device.c
@@ -244,7 +244,7 @@ EXPORT_SYMBOL(get_phy_device);
 /**
 * phy_device_register - Register the phy device on the MDIO bus
- * @phy_device: phy_device structure to be added to the MDIO bus
+ * @phydev: phy_device structure to be added to the MDIO bus
 */
 int phy_device_register(struct phy_device *phydev)
 {
diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
index 35196faa084e..4e22462684c9 100644
--- a/drivers/net/r8169.c
+++ b/drivers/net/r8169.c
@@ -3811,22 +3811,11 @@ static struct net_device_stats *rtl8169_get_stats(struct net_device *dev)
 static void rtl8169_net_suspend(struct net_device *dev)
 {
-        struct rtl8169_private *tp = netdev_priv(dev);
-        void __iomem *ioaddr = tp->mmio_addr;
        if (!netif_running(dev))
                return;
        netif_device_detach(dev);
        netif_stop_queue(dev);
-        spin_lock_irq(&tp->lock);
-        rtl8169_asic_down(ioaddr);
-        rtl8169_rx_missed(dev, ioaddr);
-        spin_unlock_irq(&tp->lock);
 }
 #ifdef CONFIG_PM
@@ -3876,9 +3865,17 @@ static struct dev_pm_ops rtl8169_pm_ops = {
 static void rtl_shutdown(struct pci_dev *pdev)
 {
        struct net_device *dev = pci_get_drvdata(pdev);
+        struct rtl8169_private *tp = netdev_priv(dev);
+        void __iomem *ioaddr = tp->mmio_addr;
        rtl8169_net_suspend(dev);
+        spin_lock_irq(&tp->lock);
+        rtl8169_asic_down(ioaddr);
+        spin_unlock_irq(&tp->lock);
        if (system_state == SYSTEM_POWER_OFF) {
                pci_wake_from_d3(pdev, true);
                pci_set_power_state(pdev, PCI_D3hot);
diff --git a/drivers/net/sis190.c b/drivers/net/sis190.c
index e2247669a495..1f040e8a000b 100644
--- a/drivers/net/sis190.c
+++ b/drivers/net/sis190.c
@@ -1281,7 +1281,7 @@ static u16 sis190_default_phy(struct net_device *dev)
                else if (phy_lan)
                        phy_default = phy_lan;
                else
-                        phy_default = list_entry(&tp->first_phy,
+                        phy_default = list_first_entry(&tp->first_phy,
                                                 struct sis190_phy, list);
        }
diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c
index 6b5946fe8ae2..7681d28c53d7 100644
--- a/drivers/net/sky2.c
+++ b/drivers/net/sky2.c
@@ -50,7 +50,7 @@
 #include "sky2.h"
 #define DRV_NAME                "sky2"
-#define DRV_VERSION             "1.22"
+#define DRV_VERSION             "1.23"
 #define PFX                     DRV_NAME " "
 /*
@@ -65,9 +65,9 @@
 #define RX_DEF_PENDING          RX_MAX_PENDING
 #define TX_RING_SIZE            512
-#define TX_DEF_PENDING          (TX_RING_SIZE - 1)
+#define TX_DEF_PENDING          128
-#define TX_MIN_PENDING          64
 #define MAX_SKB_TX_LE           (4 + (sizeof(dma_addr_t)/sizeof(u32))*MAX_SKB_FRAGS)
+#define TX_MIN_PENDING          (MAX_SKB_TX_LE+1)
 #define STATUS_RING_SIZE        2048    /* 2 ports * (TX + 2*RX) */
 #define STATUS_LE_BYTES         (STATUS_RING_SIZE*sizeof(struct sky2_status_le))
@@ -1151,7 +1151,14 @@ stopped:
        /* reset the Rx prefetch unit */
        sky2_write32(hw, Y2_QADDR(rxq, PREF_UNIT_CTRL), PREF_UNIT_RST_SET);
-        mmiowb();
+        /* Reset the RAM Buffer receive queue */
+        sky2_write8(hw, RB_ADDR(rxq, RB_CTRL), RB_RST_SET);
+        /* Reset Rx MAC FIFO */
+        sky2_write8(hw, SK_REG(sky2->port, RX_GMF_CTRL_T), GMF_RST_SET);
+        sky2_read8(hw, B0_CTST);
 }
 /* Clean out receive buffer area, assumes receiver hardware stopped */
@@ -1169,6 +1176,7 @@ static void sky2_rx_clean(struct sky2_port *sky2)
                        re->skb = NULL;
                }
        }
+        skb_queue_purge(&sky2->rx_recycle);
 }
 /* Basic MII support */
@@ -1245,6 +1253,12 @@ static void sky2_vlan_rx_register(struct net_device *dev, struct vlan_group *grp
 }
 #endif
+/* Amount of required worst case padding in rx buffer */
+static inline unsigned sky2_rx_pad(const struct sky2_hw *hw)
+{
+        return (hw->flags & SKY2_HW_RAM_BUFFER) ? 8 : 2;
+}
 /*
 * Allocate an skb for receiving. If the MTU is large enough
 * make the skb non-linear with a fragment list of pages.
@@ -1254,6 +1268,13 @@ static struct sk_buff *sky2_rx_alloc(struct sky2_port *sky2)
        struct sk_buff *skb;
        int i;
+        skb = __skb_dequeue(&sky2->rx_recycle);
+        if (!skb)
+                skb = netdev_alloc_skb(sky2->netdev, sky2->rx_data_size
+                                       + sky2_rx_pad(sky2->hw));
+        if (!skb)
+                goto nomem;
        if (sky2->hw->flags & SKY2_HW_RAM_BUFFER) {
                unsigned char *start;
                /*
@@ -1262,18 +1283,10 @@ static struct sk_buff *sky2_rx_alloc(struct sky2_port *sky2)
                 * The buffer returned from netdev_alloc_skb is
                 * aligned except if slab debugging is enabled.
                 */
-                skb = netdev_alloc_skb(sky2->netdev, sky2->rx_data_size + 8);
-                if (!skb)
-                        goto nomem;
                start = PTR_ALIGN(skb->data, 8);
                skb_reserve(skb, start - skb->data);
-        } else {
+        } else
-                skb = netdev_alloc_skb(sky2->netdev,
-                                       sky2->rx_data_size + NET_IP_ALIGN);
-                if (!skb)
-                        goto nomem;
                skb_reserve(skb, NET_IP_ALIGN);
-        }
        for (i = 0; i < sky2->rx_nfrags; i++) {
                struct page *page = alloc_page(GFP_ATOMIC);
@@ -1350,6 +1363,8 @@ static int sky2_rx_start(struct sky2_port *sky2)
        sky2->rx_data_size = size;
+        skb_queue_head_init(&sky2->rx_recycle);
        /* Fill Rx ring */
        for (i = 0; i < sky2->rx_pending; i++) {
                re = sky2->rx_ring + i;
@@ -1488,6 +1503,7 @@ static int sky2_up(struct net_device *dev)
        imask = sky2_read32(hw, B0_IMSK);
        imask |= portirq_msk[port];
        sky2_write32(hw, B0_IMSK, imask);
+        sky2_read32(hw, B0_IMSK);
        sky2_set_multicast(dev);
@@ -1756,14 +1772,22 @@ static void sky2_tx_complete(struct sky2_port *sky2, u16 done)
                }
                if (le->ctrl & EOP) {
+                        struct sk_buff *skb = re->skb;
                        if (unlikely(netif_msg_tx_done(sky2)))
                                printk(KERN_DEBUG "%s: tx done %u\n",
                                       dev->name, idx);
                        dev->stats.tx_packets++;
-                        dev->stats.tx_bytes += re->skb->len;
+                        dev->stats.tx_bytes += skb->len;
+                        if (skb_queue_len(&sky2->rx_recycle) < sky2->rx_pending
+                            && skb_recycle_check(skb, sky2->rx_data_size
+                                                 + sky2_rx_pad(sky2->hw)))
+                                __skb_queue_head(&sky2->rx_recycle, skb);
+                        else
+                                dev_kfree_skb_any(skb);
-                        dev_kfree_skb_any(re->skb);
                        sky2->tx_next = RING_NEXT(idx, TX_RING_SIZE);
                }
        }
@@ -1805,10 +1829,10 @@ static int sky2_down(struct net_device *dev)
        imask = sky2_read32(hw, B0_IMSK);
        imask &= ~portirq_msk[port];
        sky2_write32(hw, B0_IMSK, imask);
+        sky2_read32(hw, B0_IMSK);
-        synchronize_irq(hw->pdev->irq);
+        /* Force flow control off */
+        sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_PAUSE_OFF);
-        sky2_gmac_reset(hw, port);
        /* Stop transmitter */
        sky2_write32(hw, Q_ADDR(txqaddr[port], Q_CSR), BMU_STOP);
@@ -1821,9 +1845,6 @@ static int sky2_down(struct net_device *dev)
        ctrl &= ~(GM_GPCR_TX_ENA | GM_GPCR_RX_ENA);
        gma_write16(hw, port, GM_GP_CTRL, ctrl);
-        /* Make sure no packets are pending */
-        napi_synchronize(&hw->napi);
        sky2_write8(hw, SK_REG(port, GPHY_CTRL), GPC_RST_SET);
        /* Workaround shared GMAC reset */
@@ -1854,6 +1875,15 @@ static int sky2_down(struct net_device *dev)
        sky2_write8(hw, SK_REG(port, RX_GMF_CTRL_T), GMF_RST_SET);
        sky2_write8(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_RST_SET);
+        /* Force any delayed status interrrupt and NAPI */
+        sky2_write32(hw, STAT_LEV_TIMER_CNT, 0);
+        sky2_write32(hw, STAT_TX_TIMER_CNT, 0);
+        sky2_write32(hw, STAT_ISR_TIMER_CNT, 0);
+        sky2_read8(hw, STAT_ISR_TIMER_CTRL);
+        synchronize_irq(hw->pdev->irq);
+        napi_synchronize(&hw->napi);
        sky2_phy_power_down(hw, port);
        /* turn off LED's */
@@ -2343,11 +2373,45 @@ static inline void sky2_tx_done(struct net_device *dev, u16 last)
        }
 }
+static inline void sky2_skb_rx(const struct sky2_port *sky2,
+                               u32 status, struct sk_buff *skb)
+{
+#ifdef SKY2_VLAN_TAG_USED
+        u16 vlan_tag = be16_to_cpu(sky2->rx_tag);
+        if (sky2->vlgrp && (status & GMR_FS_VLAN)) {
+                if (skb->ip_summed == CHECKSUM_NONE)
+                        vlan_hwaccel_receive_skb(skb, sky2->vlgrp, vlan_tag);
+                else
+                        vlan_gro_receive(&sky2->hw->napi, sky2->vlgrp,
+                                         vlan_tag, skb);
+                return;
+        }
+#endif
+        if (skb->ip_summed == CHECKSUM_NONE)
+                netif_receive_skb(skb);
+        else
+                napi_gro_receive(&sky2->hw->napi, skb);
+}
+static inline void sky2_rx_done(struct sky2_hw *hw, unsigned port,
+                                unsigned packets, unsigned bytes)
+{
+        if (packets) {
+                struct net_device *dev = hw->dev[port];
+                dev->stats.rx_packets += packets;
+                dev->stats.rx_bytes += bytes;
+                dev->last_rx = jiffies;
+                sky2_rx_update(netdev_priv(dev), rxqaddr[port]);
+        }
+}
 /* Process status response ring */
 static int sky2_status_intr(struct sky2_hw *hw, int to_do, u16 idx)
 {
        int work_done = 0;
-        unsigned rx[2] = { 0, 0 };
+        unsigned int total_bytes[2] = { 0 };
+        unsigned int total_packets[2] = { 0 };
        rmb();
        do {
@@ -2374,7 +2438,8 @@ static int sky2_status_intr(struct sky2_hw *hw, int to_do, u16 idx)
                le->opcode = 0;
                switch (opcode & ~HW_OWNER) {
                case OP_RXSTAT:
-                        ++rx[port];
+                        total_packets[port]++;
+                        total_bytes[port] += length;
                        skb = sky2_receive(dev, length, status);
                        if (unlikely(!skb)) {
                                dev->stats.rx_dropped++;
@@ -2392,18 +2457,8 @@ static int sky2_status_intr(struct sky2_hw *hw, int to_do, u16 idx)
                        }
                        skb->protocol = eth_type_trans(skb, dev);
-                        dev->stats.rx_packets++;
-                        dev->stats.rx_bytes += skb->len;
-                        dev->last_rx = jiffies;
-#ifdef SKY2_VLAN_TAG_USED
+                        sky2_skb_rx(sky2, status, skb);
-                        if (sky2->vlgrp && (status & GMR_FS_VLAN)) {
-                                vlan_hwaccel_receive_skb(skb,
-                                                         sky2->vlgrp,
-                                                         be16_to_cpu(sky2->rx_tag));
-                        } else
-#endif
-                                netif_receive_skb(skb);
                        /* Stop after net poll weight */
                        if (++work_done >= to_do)
@@ -2473,11 +2528,8 @@ static int sky2_status_intr(struct sky2_hw *hw, int to_do, u16 idx)
        sky2_write32(hw, STAT_CTRL, SC_STAT_CLR_IRQ);
 exit_loop:
-        if (rx[0])
+        sky2_rx_done(hw, 0, total_packets[0], total_bytes[0]);
-                sky2_rx_update(netdev_priv(hw->dev[0]), Q_R1);
+        sky2_rx_done(hw, 1, total_packets[1], total_bytes[1]);
-        if (rx[1])
-                sky2_rx_update(netdev_priv(hw->dev[1]), Q_R2);
        return work_done;
 }
@@ -4364,6 +4416,22 @@ static int __devinit sky2_probe(struct pci_dev *pdev,
                goto err_out;
        }
+        /* Get configuration information
+         * Note: only regular PCI config access once to test for HW issues
+         *       other PCI access through shared memory for speed and to
+         *       avoid MMCONFIG problems.
+         */
+        err = pci_read_config_dword(pdev, PCI_DEV_REG2, &reg);
+        if (err) {
+                dev_err(&pdev->dev, "PCI read config failed\n");
+                goto err_out;
+        }
+        if (~reg == 0) {
+                dev_err(&pdev->dev, "PCI configuration read error\n");
+                goto err_out;
+        }
        err = pci_request_regions(pdev, DRV_NAME);
        if (err) {
                dev_err(&pdev->dev, "cannot obtain PCI resources\n");
@@ -4389,21 +4457,6 @@ static int __devinit sky2_probe(struct pci_dev *pdev,
                }
        }
-        /* Get configuration information
-         * Note: only regular PCI config access once to test for HW issues
-         *       other PCI access through shared memory for speed and to
-         *       avoid MMCONFIG problems.
-         */
-        err = pci_read_config_dword(pdev, PCI_DEV_REG2, &reg);
-        if (err) {
-                dev_err(&pdev->dev, "PCI read config failed\n");
-                goto err_out_free_regions;
-        }
-        /* size of available VPD, only impact sysfs */
-        err = pci_vpd_truncate(pdev, 1ul << (((reg & PCI_VPD_ROM_SZ) >> 14) + 8));
-        if (err)
-                dev_warn(&pdev->dev, "Can't set VPD size\n");
 #ifdef __BIG_ENDIAN
        /* The sk98lin vendor driver uses hardware byte swapping but
diff --git a/drivers/net/sky2.h b/drivers/net/sky2.h
index 92fb24b27d45..b5549c9e5107 100644
--- a/drivers/net/sky2.h
+++ b/drivers/net/sky2.h
@@ -2028,6 +2028,7 @@ struct sky2_port {
        u16                  rx_pending;
        u16                  rx_data_size;
        u16                  rx_nfrags;
+        struct sk_buff_head  rx_recycle;
 #ifdef SKY2_VLAN_TAG_USED
        u16                  rx_tag;
diff --git a/drivers/net/sonic.c b/drivers/net/sonic.c
index e4255d829380..753a1fba4609 100644
--- a/drivers/net/sonic.c
+++ b/drivers/net/sonic.c
@@ -223,7 +223,7 @@ static int sonic_send_packet(struct sk_buff *skb, struct net_device *dev)
        if (!laddr) {
                printk(KERN_ERR "%s: failed to map tx DMA buffer.\n", dev->name);
                dev_kfree_skb(skb);
-                return NETDEV_TX_BUSY
+                return NETDEV_TX_BUSY;
        }
        sonic_tda_put(dev, entry, SONIC_TD_STATUS, 0);       /* clear status */
diff --git a/drivers/net/ucc_geth.c b/drivers/net/ucc_geth.c
index e2f2e91cfdd2..40c6eba775ce 100644
--- a/drivers/net/ucc_geth.c
+++ b/drivers/net/ucc_geth.c
@@ -65,8 +65,6 @@
 static DEFINE_SPINLOCK(ugeth_lock);
-static void uec_configure_serdes(struct net_device *dev);
 static struct {
        u32 msg_enable;
 } debug = { -1 };
@@ -1536,6 +1534,49 @@ static void adjust_link(struct net_device *dev)
        spin_unlock_irqrestore(&ugeth->lock, flags);
 }
+/* Initialize TBI PHY interface for communicating with the
+ * SERDES lynx PHY on the chip.  We communicate with this PHY
+ * through the MDIO bus on each controller, treating it as a
+ * "normal" PHY at the address found in the UTBIPA register.  We assume
+ * that the UTBIPA register is valid.  Either the MDIO bus code will set
+ * it to a value that doesn't conflict with other PHYs on the bus, or the
+ * value doesn't matter, as there are no other PHYs on the bus.
+ */
+static void uec_configure_serdes(struct net_device *dev)
+{
+        struct ucc_geth_private *ugeth = netdev_priv(dev);
+        struct ucc_geth_info *ug_info = ugeth->ug_info;
+        struct phy_device *tbiphy;
+        if (!ug_info->tbi_node) {
+                dev_warn(&dev->dev, "SGMII mode requires that the device "
+                        "tree specify a tbi-handle\n");
+                return;
+        }
+        tbiphy = of_phy_find_device(ug_info->tbi_node);
+        if (!tbiphy) {
+                dev_err(&dev->dev, "error: Could not get TBI device\n");
+                return;
+        }
+        /*
+         * If the link is already up, we must already be ok, and don't need to
+         * configure and reset the TBI<->SerDes link.  Maybe U-Boot configured
+         * everything for us?  Resetting it takes the link down and requires
+         * several seconds for it to come back.
+         */
+        if (phy_read(tbiphy, ENET_TBI_MII_SR) & TBISR_LSTATUS)
+                return;
+        /* Single clk mode, mii mode off(for serdes communication) */
+        phy_write(tbiphy, ENET_TBI_MII_ANA, TBIANA_SETTINGS);
+        phy_write(tbiphy, ENET_TBI_MII_TBICON, TBICON_CLK_SELECT);
+        phy_write(tbiphy, ENET_TBI_MII_CR, TBICR_SETTINGS);
+}
 /* Configure the PHY for dev.
 * returns 0 if success.  -1 if failure
 */
@@ -1577,41 +1618,7 @@ static int init_phy(struct net_device *dev)
        return 0;
 }
-/* Initialize TBI PHY interface for communicating with the
- * SERDES lynx PHY on the chip.  We communicate with this PHY
- * through the MDIO bus on each controller, treating it as a
- * "normal" PHY at the address found in the UTBIPA register.  We assume
- * that the UTBIPA register is valid.  Either the MDIO bus code will set
- * it to a value that doesn't conflict with other PHYs on the bus, or the
- * value doesn't matter, as there are no other PHYs on the bus.
- */
-static void uec_configure_serdes(struct net_device *dev)
-{
-        struct ucc_geth_private *ugeth = netdev_priv(dev);
-        if (!ugeth->tbiphy) {
-                printk(KERN_WARNING "SGMII mode requires that the device "
-                        "tree specify a tbi-handle\n");
-        return;
-        }
-        /*
-         * If the link is already up, we must already be ok, and don't need to
-         * configure and reset the TBI<->SerDes link.  Maybe U-Boot configured
-         * everything for us?  Resetting it takes the link down and requires
-         * several seconds for it to come back.
-         */
-        if (phy_read(ugeth->tbiphy, ENET_TBI_MII_SR) & TBISR_LSTATUS)
-                return;
-        /* Single clk mode, mii mode off(for serdes communication) */
-        phy_write(ugeth->tbiphy, ENET_TBI_MII_ANA, TBIANA_SETTINGS);
-        phy_write(ugeth->tbiphy, ENET_TBI_MII_TBICON, TBICON_CLK_SELECT);
-        phy_write(ugeth->tbiphy, ENET_TBI_MII_CR, TBICR_SETTINGS);
-}
 static int ugeth_graceful_stop_tx(struct ucc_geth_private *ugeth)
 {
@@ -3711,6 +3718,9 @@ static int ucc_geth_probe(struct of_device* ofdev, const struct of_device_id *ma
        }
        ug_info->phy_node = phy;
+        /* Find the TBI PHY node.  If it's not there, we don't support SGMII */
+        ug_info->tbi_node = of_parse_phandle(np, "tbi-handle", 0);
        /* get the phy interface type, or default to MII */
        prop = of_get_property(np, "phy-connection-type", NULL);
        if (!prop) {
@@ -3818,37 +3828,6 @@ static int ucc_geth_probe(struct of_device* ofdev, const struct of_device_id *ma
        ugeth->ndev = dev;
        ugeth->node = np;
-        /* Find the TBI PHY.  If it's not there, we don't support SGMII */
-        ph = of_get_property(np, "tbi-handle", NULL);
-        if (ph) {
-                struct device_node *tbi = of_find_node_by_phandle(*ph);
-                struct of_device *ofdev;
-                struct mii_bus *bus;
-                const unsigned int *id;
-                if (!tbi)
-                        return 0;
-                mdio = of_get_parent(tbi);
-                if (!mdio)
-                        return 0;
-                ofdev = of_find_device_by_node(mdio);
-                of_node_put(mdio);
-                id = of_get_property(tbi, "reg", NULL);
-                if (!id)
-                        return 0;
-                of_node_put(tbi);
-                bus = dev_get_drvdata(&ofdev->dev);
-                if (!bus)
-                        return 0;
-                ugeth->tbiphy = bus->phy_map[*id];
-        }
        return 0;
 }
diff --git a/drivers/net/ucc_geth.h b/drivers/net/ucc_geth.h
index 5beba4c14532..195ab267ead7 100644
--- a/drivers/net/ucc_geth.h
+++ b/drivers/net/ucc_geth.h
@@ -1125,6 +1125,7 @@ struct ucc_geth_info {
        u16 pausePeriod;
        u16 extensionField;
        struct device_node *phy_node;
+        struct device_node *tbi_node;
        u8 weightfactor[NUM_TX_QUEUES];
        u8 interruptcoalescingmaxvalue[NUM_RX_QUEUES];
        u8 l2qt[UCC_GETH_VLAN_PRIORITY_MAX];
@@ -1213,7 +1214,6 @@ struct ucc_geth_private {
        struct ugeth_mii_info *mii_info;
        struct phy_device *phydev;
-        struct phy_device *tbiphy;
        phy_interface_t phy_interface;
        int max_speed;
        uint32_t msg_enable;
diff --git a/drivers/net/via-velocity.c b/drivers/net/via-velocity.c
index e2a7725e567e..b02f7adff5dc 100644
--- a/drivers/net/via-velocity.c
+++ b/drivers/net/via-velocity.c
@@ -989,8 +989,10 @@ static int __devinit velocity_found1(struct pci_dev *pdev, const struct pci_devi
        if (ret < 0)
                goto err_iounmap;
-        if (velocity_get_link(dev))
+        if (!velocity_get_link(dev)) {
                netif_carrier_off(dev);
+                vptr->mii_status |= VELOCITY_LINK_FAIL;
+        }
        velocity_print_info(vptr);
        pci_set_drvdata(pdev, dev);
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index 52198f6797a4..2a6e81d5b579 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -709,7 +709,7 @@ static void virtnet_set_rx_mode(struct net_device *dev)
                         allmulti ? "en" : "dis");
        /* MAC filter - use one buffer for both lists */
-        mac_data = buf = kzalloc(((dev->uc_count + dev->mc_count) * ETH_ALEN) +
+        mac_data = buf = kzalloc(((dev->uc.count + dev->mc_count) * ETH_ALEN) +
                                 (2 * sizeof(mac_data->entries)), GFP_ATOMIC);
        if (!buf) {
                dev_warn(&dev->dev, "No memory for MAC address buffer\n");
@@ -719,16 +719,16 @@ static void virtnet_set_rx_mode(struct net_device *dev)
        sg_init_table(sg, 2);
        /* Store the unicast list and count in the front of the buffer */
-        mac_data->entries = dev->uc_count;
+        mac_data->entries = dev->uc.count;
        i = 0;
-        list_for_each_entry(ha, &dev->uc_list, list)
+        list_for_each_entry(ha, &dev->uc.list, list)
                memcpy(&mac_data->macs[i++][0], ha->addr, ETH_ALEN);
        sg_set_buf(&sg[0], mac_data,
-                   sizeof(mac_data->entries) + (dev->uc_count * ETH_ALEN));
+                   sizeof(mac_data->entries) + (dev->uc.count * ETH_ALEN));
        /* multicast list and count fill the end */
-        mac_data = (void *)&mac_data->macs[dev->uc_count][0];
+        mac_data = (void *)&mac_data->macs[dev->uc.count][0];
        mac_data->entries = dev->mc_count;
        addr = dev->mc_list;
diff --git a/drivers/net/vxge/vxge-config.c b/drivers/net/vxge/vxge-config.c
index 26cde573af43..58d2551c78ed 100644
--- a/drivers/net/vxge/vxge-config.c
+++ b/drivers/net/vxge/vxge-config.c
@@ -454,7 +454,7 @@ __vxge_hw_verify_pci_e_info(struct __vxge_hw_device *hldev)
        return VXGE_HW_OK;
 }
-static enum vxge_hw_status
+enum vxge_hw_status
 __vxge_hw_device_is_privilaged(struct __vxge_hw_device *hldev)
 {
        if ((hldev->host_type == VXGE_HW_NO_MR_NO_SR_NORMAL_FUNCTION ||
@@ -676,10 +676,12 @@ enum vxge_hw_status __vxge_hw_device_initialize(struct __vxge_hw_device *hldev)
 {
        enum vxge_hw_status status = VXGE_HW_OK;
-        /* Validate the pci-e link width and speed */
+        if (VXGE_HW_OK == __vxge_hw_device_is_privilaged(hldev)) {
-        status = __vxge_hw_verify_pci_e_info(hldev);
+                /* Validate the pci-e link width and speed */
-        if (status != VXGE_HW_OK)
+                status = __vxge_hw_verify_pci_e_info(hldev);
-                goto exit;
+                if (status != VXGE_HW_OK)
+                        goto exit;
+        }
        vxge_hw_wrr_rebalance(hldev);
 exit:
diff --git a/drivers/net/vxge/vxge-main.c b/drivers/net/vxge/vxge-main.c
index 6c838b3e063a..6034497536a4 100644
--- a/drivers/net/vxge/vxge-main.c
+++ b/drivers/net/vxge/vxge-main.c
@@ -4203,6 +4203,16 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre)
                max_vpath_supported++;
        }
+        /* Enable SRIOV mode, if firmware has SRIOV support and if it is a PF */
+        if ((VXGE_HW_FUNCTION_MODE_SRIOV ==
+                ll_config.device_hw_info.function_mode) &&
+                (max_config_dev > 1) && (pdev->is_physfn)) {
+                        ret = pci_enable_sriov(pdev, max_config_dev - 1);
+                        if (ret)
+                                vxge_debug_ll_config(VXGE_ERR,
+                                        "Failed to enable SRIOV: %d \n", ret);
+        }
        /*
         * Configure vpaths and get driver configured number of vpaths
         * which is less than or equal to the maximum vpaths per function.
@@ -4366,6 +4376,7 @@ _exit6:
        vxge_device_unregister(hldev);
 _exit5:
+        pci_disable_sriov(pdev);
        vxge_hw_device_terminate(hldev);
 _exit4:
        iounmap(attr.bar1);
@@ -4429,6 +4440,8 @@ vxge_remove(struct pci_dev *pdev)
        iounmap(vdev->bar0);
        iounmap(vdev->bar1);
+        pci_disable_sriov(pdev);
        /* we are safe to free it now */
        free_netdev(dev);
diff --git a/drivers/net/vxge/vxge-version.h b/drivers/net/vxge/vxge-version.h
index 7da02c545ed5..82786ffb7dd9 100644
--- a/drivers/net/vxge/vxge-version.h
+++ b/drivers/net/vxge/vxge-version.h
@@ -17,7 +17,7 @@
 #define VXGE_VERSION_MAJOR      "2"
 #define VXGE_VERSION_MINOR      "0"
-#define VXGE_VERSION_FIX        "1"
+#define VXGE_VERSION_FIX        "4"
-#define VXGE_VERSION_BUILD      "17129"
+#define VXGE_VERSION_BUILD      "17795"
 #define VXGE_VERSION_FOR        "k"
 #endif
diff --git a/drivers/net/wan/lapbether.c b/drivers/net/wan/lapbether.c
index 2dd78d20eb05..aff4f6bdf3d5 100644
--- a/drivers/net/wan/lapbether.c
+++ b/drivers/net/wan/lapbether.c
@@ -149,46 +149,40 @@ static int lapbeth_data_indication(struct net_device *dev, struct sk_buff *skb)
 */
 static int lapbeth_xmit(struct sk_buff *skb, struct net_device *dev)
 {
-        int err = -ENODEV;
+        int err;
        /*
         * Just to be *really* sure not to send anything if the interface
         * is down, the ethernet device may have gone.
         */
-        if (!netif_running(dev)) {
+        if (!netif_running(dev))
                goto drop;
-        }
        switch (skb->data[0]) {
        case 0x00:
-                err = 0;
                break;
        case 0x01:
                if ((err = lapb_connect_request(dev)) != LAPB_OK)
                        printk(KERN_ERR "lapbeth: lapb_connect_request "
                               "error: %d\n", err);
-                goto drop_ok;
+                goto drop;
        case 0x02:
                if ((err = lapb_disconnect_request(dev)) != LAPB_OK)
                        printk(KERN_ERR "lapbeth: lapb_disconnect_request "
                               "err: %d\n", err);
                /* Fall thru */
        default:
-                goto drop_ok;
+                goto drop;
        }
        skb_pull(skb, 1);
        if ((err = lapb_data_request(dev, skb)) != LAPB_OK) {
                printk(KERN_ERR "lapbeth: lapb_data_request error - %d\n", err);
-                err = -ENOMEM;
                goto drop;
        }
-        err = 0;
 out:
-        return err;
+        return NETDEV_TX_OK;
-drop_ok:
-        err = 0;
 drop:
        kfree_skb(skb);
        goto out;
diff --git a/drivers/net/wireless/ath/ath5k/pcu.c b/drivers/net/wireless/ath/ath5k/pcu.c
index ec35503f6a40..2942f13c9c4a 100644
--- a/drivers/net/wireless/ath/ath5k/pcu.c
+++ b/drivers/net/wireless/ath/ath5k/pcu.c
@@ -733,8 +733,9 @@ void ath5k_hw_init_beacon(struct ath5k_hw *ah, u32 next_beacon, u32 interval)
        /*
         * Set the beacon register and enable all timers.
         */
-        /* When in AP mode zero timer0 to start TSF */
+        /* When in AP or Mesh Point mode zero timer0 to start TSF */
-        if (ah->ah_op_mode == NL80211_IFTYPE_AP)
+        if (ah->ah_op_mode == NL80211_IFTYPE_AP ||
+            ah->ah_op_mode == NL80211_IFTYPE_MESH_POINT)
                ath5k_hw_reg_write(ah, 0, AR5K_TIMER0);
        ath5k_hw_reg_write(ah, next_beacon, AR5K_TIMER0);
diff --git a/drivers/net/wireless/ath/ath9k/Kconfig b/drivers/net/wireless/ath/ath9k/Kconfig
index 0ed1ac312aa6..2d79610bce12 100644
--- a/drivers/net/wireless/ath/ath9k/Kconfig
+++ b/drivers/net/wireless/ath/ath9k/Kconfig
@@ -1,7 +1,6 @@
 config ATH9K
        tristate "Atheros 802.11n wireless cards support"
        depends on PCI && MAC80211 && WLAN_80211
-        depends on RFKILL || RFKILL=n
        select ATH_COMMON
        select MAC80211_LEDS
        select LEDS_CLASS
diff --git a/drivers/net/wireless/ath/ath9k/ath9k.h b/drivers/net/wireless/ath/ath9k/ath9k.h
index 515880aa2116..5efc9345ca0d 100644
--- a/drivers/net/wireless/ath/ath9k/ath9k.h
+++ b/drivers/net/wireless/ath/ath9k/ath9k.h
@@ -21,7 +21,6 @@
 #include <linux/device.h>
 #include <net/mac80211.h>
 #include <linux/leds.h>
-#include <linux/rfkill.h>
 #include "hw.h"
 #include "rc.h"
@@ -460,12 +459,6 @@ struct ath_led {
        bool registered;
 };
-struct ath_rfkill {
-        struct rfkill *rfkill;
-        struct rfkill_ops ops;
-        char rfkill_name[32];
-};
 /********************/
 /* Main driver core */
 /********************/
@@ -505,7 +498,6 @@ struct ath_rfkill {
 #define SC_OP_PROTECT_ENABLE    BIT(6)
 #define SC_OP_RXFLUSH           BIT(7)
 #define SC_OP_LED_ASSOCIATED    BIT(8)
-#define SC_OP_RFKILL_REGISTERED BIT(9)
 #define SC_OP_WAIT_FOR_BEACON   BIT(12)
 #define SC_OP_LED_ON            BIT(13)
 #define SC_OP_SCANNING          BIT(14)
@@ -591,7 +583,6 @@ struct ath_softc {
        int beacon_interval;
-        struct ath_rfkill rf_kill;
        struct ath_ani ani;
        struct ath9k_node_stats nodestats;
 #ifdef CONFIG_ATH9K_DEBUG
@@ -677,6 +668,7 @@ static inline void ath9k_ps_restore(struct ath_softc *sc)
        if (atomic_dec_and_test(&sc->ps_usecount))
                if ((sc->hw->conf.flags & IEEE80211_CONF_PS) &&
                    !(sc->sc_flags & (SC_OP_WAIT_FOR_BEACON |
+                                      SC_OP_WAIT_FOR_CAB |
                                      SC_OP_WAIT_FOR_PSPOLL_DATA |
                                      SC_OP_WAIT_FOR_TX_ACK)))
                        ath9k_hw_setpower(sc->sc_ah,
diff --git a/drivers/net/wireless/ath/ath9k/hw.c b/drivers/net/wireless/ath/ath9k/hw.c
index 1579c9407ed5..34935a8ee59d 100644
--- a/drivers/net/wireless/ath/ath9k/hw.c
+++ b/drivers/net/wireless/ath/ath9k/hw.c
@@ -2186,6 +2186,18 @@ static void ath9k_hw_spur_mitigate(struct ath_hw *ah, struct ath9k_channel *chan
        REG_WRITE(ah, AR_PHY_MASK2_P_61_45, tmp_mask);
 }
+static void ath9k_enable_rfkill(struct ath_hw *ah)
+{
+        REG_SET_BIT(ah, AR_GPIO_INPUT_EN_VAL,
+                    AR_GPIO_INPUT_EN_VAL_RFSILENT_BB);
+        REG_CLR_BIT(ah, AR_GPIO_INPUT_MUX2,
+                    AR_GPIO_INPUT_MUX2_RFSILENT);
+        ath9k_hw_cfg_gpio_input(ah, ah->rfkill_gpio);
+        REG_SET_BIT(ah, AR_PHY_TEST, RFSILENT_BB);
+}
 int ath9k_hw_reset(struct ath_hw *ah, struct ath9k_channel *chan,
                    bool bChannelChange)
 {
@@ -2313,10 +2325,9 @@ int ath9k_hw_reset(struct ath_hw *ah, struct ath9k_channel *chan,
        ath9k_hw_init_interrupt_masks(ah, ah->opmode);
        ath9k_hw_init_qos(ah);
-#if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
        if (ah->caps.hw_caps & ATH9K_HW_CAP_RFSILENT)
                ath9k_enable_rfkill(ah);
-#endif
        ath9k_hw_init_user_settings(ah);
        REG_WRITE(ah, AR_STA_ID1,
@@ -3613,20 +3624,6 @@ void ath9k_hw_set_gpio(struct ath_hw *ah, u32 gpio, u32 val)
                AR_GPIO_BIT(gpio));
 }
-#if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
-void ath9k_enable_rfkill(struct ath_hw *ah)
-{
-        REG_SET_BIT(ah, AR_GPIO_INPUT_EN_VAL,
-                    AR_GPIO_INPUT_EN_VAL_RFSILENT_BB);
-        REG_CLR_BIT(ah, AR_GPIO_INPUT_MUX2,
-                    AR_GPIO_INPUT_MUX2_RFSILENT);
-        ath9k_hw_cfg_gpio_input(ah, ah->rfkill_gpio);
-        REG_SET_BIT(ah, AR_PHY_TEST, RFSILENT_BB);
-}
-#endif
 u32 ath9k_hw_getdefantenna(struct ath_hw *ah)
 {
        return REG_READ(ah, AR_DEF_ANTENNA) & 0x7;
diff --git a/drivers/net/wireless/ath/ath9k/hw.h b/drivers/net/wireless/ath/ath9k/hw.h
index dd8508ef6e05..9d0b31ad4603 100644
--- a/drivers/net/wireless/ath/ath9k/hw.h
+++ b/drivers/net/wireless/ath/ath9k/hw.h
@@ -565,9 +565,6 @@ u32 ath9k_hw_gpio_get(struct ath_hw *ah, u32 gpio);
 void ath9k_hw_cfg_output(struct ath_hw *ah, u32 gpio,
                         u32 ah_signal_type);
 void ath9k_hw_set_gpio(struct ath_hw *ah, u32 gpio, u32 val);
-#if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
-void ath9k_enable_rfkill(struct ath_hw *ah);
-#endif
 u32 ath9k_hw_getdefantenna(struct ath_hw *ah);
 void ath9k_hw_setantenna(struct ath_hw *ah, u32 antenna);
 bool ath9k_hw_setantennaswitch(struct ath_hw *ah,
diff --git a/drivers/net/wireless/ath/ath9k/main.c b/drivers/net/wireless/ath/ath9k/main.c
index f7baa406918b..9f49a3251d4d 100644
--- a/drivers/net/wireless/ath/ath9k/main.c
+++ b/drivers/net/wireless/ath/ath9k/main.c
@@ -231,6 +231,19 @@ static void ath_setup_rates(struct ath_softc *sc, enum ieee80211_band band)
        }
 }
+static struct ath9k_channel *ath_get_curchannel(struct ath_softc *sc,
+                                                struct ieee80211_hw *hw)
+{
+        struct ieee80211_channel *curchan = hw->conf.channel;
+        struct ath9k_channel *channel;
+        u8 chan_idx;
+        chan_idx = curchan->hw_value;
+        channel = &sc->sc_ah->channels[chan_idx];
+        ath9k_update_ichannel(sc, hw, channel);
+        return channel;
+}
 /*
 * Set/change channels.  If the channel is really being changed, it's done
 * by reseting the chip.  To accomplish this we must first cleanup any pending
@@ -283,7 +296,7 @@ int ath_set_channel(struct ath_softc *sc, struct ieee80211_hw *hw,
                        "reset status %d\n",
                        channel->center_freq, r);
                spin_unlock_bh(&sc->sc_resetlock);
-                return r;
+                goto ps_restore;
        }
        spin_unlock_bh(&sc->sc_resetlock);
@@ -292,14 +305,17 @@ int ath_set_channel(struct ath_softc *sc, struct ieee80211_hw *hw,
        if (ath_startrecv(sc) != 0) {
                DPRINTF(sc, ATH_DBG_FATAL,
                        "Unable to restart recv logic\n");
-                return -EIO;
+                r = -EIO;
+                goto ps_restore;
        }
        ath_cache_conf_rate(sc, &hw->conf);
        ath_update_txpow(sc);
        ath9k_hw_set_interrupts(ah, sc->imask);
+ ps_restore:
        ath9k_ps_restore(sc);
-        return 0;
+        return r;
 }
 /*
@@ -1110,6 +1126,9 @@ void ath_radio_enable(struct ath_softc *sc)
        ath9k_ps_wakeup(sc);
        ath9k_hw_configpcipowersave(ah, 0);
+        if (!ah->curchan)
+                ah->curchan = ath_get_curchannel(sc, sc->hw);
        spin_lock_bh(&sc->sc_resetlock);
        r = ath9k_hw_reset(ah, ah->curchan, false);
        if (r) {
@@ -1162,6 +1181,9 @@ void ath_radio_disable(struct ath_softc *sc)
        ath_stoprecv(sc);               /* turn off frame recv */
        ath_flushrecv(sc);              /* flush recv queue */
+        if (!ah->curchan)
+                ah->curchan = ath_get_curchannel(sc, sc->hw);
        spin_lock_bh(&sc->sc_resetlock);
        r = ath9k_hw_reset(ah, ah->curchan, false);
        if (r) {
@@ -1178,8 +1200,6 @@ void ath_radio_disable(struct ath_softc *sc)
        ath9k_ps_restore(sc);
 }
-#if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
 /*******************/
 /*      Rfkill     */
 /*******************/
@@ -1192,81 +1212,27 @@ static bool ath_is_rfkill_set(struct ath_softc *sc)
                                  ah->rfkill_polarity;
 }
-/* s/w rfkill handlers */
+static void ath9k_rfkill_poll_state(struct ieee80211_hw *hw)
-static int ath_rfkill_set_block(void *data, bool blocked)
 {
-        struct ath_softc *sc = data;
+        struct ath_wiphy *aphy = hw->priv;
+        struct ath_softc *sc = aphy->sc;
-        if (blocked)
-                ath_radio_disable(sc);
-        else
-                ath_radio_enable(sc);
-        return 0;
-}
-static void ath_rfkill_poll_state(struct rfkill *rfkill, void *data)
-{
-        struct ath_softc *sc = data;
        bool blocked = !!ath_is_rfkill_set(sc);
-        if (rfkill_set_hw_state(rfkill, blocked))
+        wiphy_rfkill_set_hw_state(hw->wiphy, blocked);
+        if (blocked)
                ath_radio_disable(sc);
        else
                ath_radio_enable(sc);
 }
-/* Init s/w rfkill */
+static void ath_start_rfkill_poll(struct ath_softc *sc)
-static int ath_init_sw_rfkill(struct ath_softc *sc)
-{
-        sc->rf_kill.ops.set_block = ath_rfkill_set_block;
-        if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_RFSILENT)
-                sc->rf_kill.ops.poll = ath_rfkill_poll_state;
-        snprintf(sc->rf_kill.rfkill_name, sizeof(sc->rf_kill.rfkill_name),
-                "ath9k-%s::rfkill", wiphy_name(sc->hw->wiphy));
-        sc->rf_kill.rfkill = rfkill_alloc(sc->rf_kill.rfkill_name,
-                                          wiphy_dev(sc->hw->wiphy),
-                                          RFKILL_TYPE_WLAN,
-                                          &sc->rf_kill.ops, sc);
-        if (!sc->rf_kill.rfkill) {
-                DPRINTF(sc, ATH_DBG_FATAL, "Failed to allocate rfkill\n");
-                return -ENOMEM;
-        }
-        return 0;
-}
-/* Deinitialize rfkill */
-static void ath_deinit_rfkill(struct ath_softc *sc)
-{
-        if (sc->sc_flags & SC_OP_RFKILL_REGISTERED) {
-                rfkill_unregister(sc->rf_kill.rfkill);
-                rfkill_destroy(sc->rf_kill.rfkill);
-                sc->sc_flags &= ~SC_OP_RFKILL_REGISTERED;
-        }
-}
-static int ath_start_rfkill_poll(struct ath_softc *sc)
 {
-        if (!(sc->sc_flags & SC_OP_RFKILL_REGISTERED)) {
+        struct ath_hw *ah = sc->sc_ah;
-                if (rfkill_register(sc->rf_kill.rfkill)) {
-                        DPRINTF(sc, ATH_DBG_FATAL,
-                                "Unable to register rfkill\n");
-                        rfkill_destroy(sc->rf_kill.rfkill);
-                        /* Deinitialize the device */
-                        ath_cleanup(sc);
-                        return -EIO;
-                } else {
-                        sc->sc_flags |= SC_OP_RFKILL_REGISTERED;
-                }
-        }
-        return 0;
+        if (ah->caps.hw_caps & ATH9K_HW_CAP_RFSILENT)
+                wiphy_rfkill_start_polling(sc->hw->wiphy);
 }
-#endif /* CONFIG_RFKILL */
 void ath_cleanup(struct ath_softc *sc)
 {
@@ -1286,9 +1252,6 @@ void ath_detach(struct ath_softc *sc)
        DPRINTF(sc, ATH_DBG_CONFIG, "Detach ATH hw\n");
-#if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
-        ath_deinit_rfkill(sc);
-#endif
        ath_deinit_leds(sc);
        cancel_work_sync(&sc->chan_work);
        cancel_delayed_work_sync(&sc->wiphy_work);
@@ -1626,13 +1589,6 @@ int ath_attach(u16 devid, struct ath_softc *sc)
        if (error != 0)
                goto error_attach;
-#if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
-        /* Initialize s/w rfkill */
-        error = ath_init_sw_rfkill(sc);
-        if (error)
-                goto error_attach;
-#endif
        INIT_WORK(&sc->chan_work, ath9k_wiphy_chan_work);
        INIT_DELAYED_WORK(&sc->wiphy_work, ath9k_wiphy_work);
        sc->wiphy_scheduler_int = msecs_to_jiffies(500);
@@ -1648,6 +1604,7 @@ int ath_attach(u16 devid, struct ath_softc *sc)
        /* Initialize LED control */
        ath_init_leds(sc);
+        ath_start_rfkill_poll(sc);
        return 0;
@@ -1920,7 +1877,7 @@ static int ath9k_start(struct ieee80211_hw *hw)
        struct ath_softc *sc = aphy->sc;
        struct ieee80211_channel *curchan = hw->conf.channel;
        struct ath9k_channel *init_channel;
-        int r, pos;
+        int r;
        DPRINTF(sc, ATH_DBG_CONFIG, "Starting driver with "
                "initial channel: %d MHz\n", curchan->center_freq);
@@ -1950,11 +1907,9 @@ static int ath9k_start(struct ieee80211_hw *hw)
        /* setup initial channel */
-        pos = curchan->hw_value;
+        sc->chan_idx = curchan->hw_value;
-        sc->chan_idx = pos;
+        init_channel = ath_get_curchannel(sc, hw);
-        init_channel = &sc->sc_ah->channels[pos];
-        ath9k_update_ichannel(sc, hw, init_channel);
        /* Reset SERDES registers */
        ath9k_hw_configpcipowersave(sc->sc_ah, 0);
@@ -2018,10 +1973,6 @@ static int ath9k_start(struct ieee80211_hw *hw)
        ieee80211_wake_queues(hw);
-#if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
-        r = ath_start_rfkill_poll(sc);
-#endif
 mutex_unlock:
        mutex_unlock(&sc->mutex);
@@ -2159,7 +2110,7 @@ static void ath9k_stop(struct ieee80211_hw *hw)
        } else
                sc->rx.rxlink = NULL;
-        rfkill_pause_polling(sc->rf_kill.rfkill);
+        wiphy_rfkill_stop_polling(sc->hw->wiphy);
        /* disable HAL and put h/w to sleep */
        ath9k_hw_disable(sc->sc_ah);
@@ -2765,6 +2716,7 @@ struct ieee80211_ops ath9k_ops = {
        .ampdu_action       = ath9k_ampdu_action,
        .sw_scan_start      = ath9k_sw_scan_start,
        .sw_scan_complete   = ath9k_sw_scan_complete,
+        .rfkill_poll        = ath9k_rfkill_poll_state,
 };
 static struct {
diff --git a/drivers/net/wireless/ath/ath9k/recv.c b/drivers/net/wireless/ath/ath9k/recv.c
index 5014a19b0f75..f99f3a76df3f 100644
--- a/drivers/net/wireless/ath/ath9k/recv.c
+++ b/drivers/net/wireless/ath/ath9k/recv.c
@@ -817,6 +817,7 @@ int ath_rx_tasklet(struct ath_softc *sc, int flush)
                }
                if (unlikely(sc->sc_flags & (SC_OP_WAIT_FOR_BEACON |
+                                             SC_OP_WAIT_FOR_CAB |
                                             SC_OP_WAIT_FOR_PSPOLL_DATA)))
                        ath_rx_ps(sc, skb);
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn.c b/drivers/net/wireless/iwlwifi/iwl-agn.c
index a5637c4aa85d..6d1519e1f011 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn.c
@@ -2152,7 +2152,6 @@ static int iwl_mac_start(struct ieee80211_hw *hw)
        /* we should be verifying the device is ready to be opened */
        mutex_lock(&priv->mutex);
-        memset(&priv->staging_rxon, 0, sizeof(struct iwl_rxon_cmd));
        /* fetch ucode file from disk, alloc and copy to bus-master buffers ...
         * ucode filename and max sizes are card-specific. */
diff --git a/drivers/net/wireless/iwlwifi/iwl-core.c b/drivers/net/wireless/iwlwifi/iwl-core.c
index f9d16ca5b3d9..6ab07165ea28 100644
--- a/drivers/net/wireless/iwlwifi/iwl-core.c
+++ b/drivers/net/wireless/iwlwifi/iwl-core.c
@@ -629,13 +629,9 @@ u8 iwl_is_fat_tx_allowed(struct iwl_priv *priv,
                if (!sta_ht_inf->ht_supported)
                        return 0;
        }
+        return iwl_is_channel_extension(priv, priv->band,
-        if (iwl_ht_conf->ht_protection & IEEE80211_HT_OP_MODE_PROTECTION_20MHZ)
+                        le16_to_cpu(priv->staging_rxon.channel),
-                return 1;
+                        iwl_ht_conf->extension_chan_offset);
-        else
-                return iwl_is_channel_extension(priv, priv->band,
-                                le16_to_cpu(priv->staging_rxon.channel),
-                                iwl_ht_conf->extension_chan_offset);
 }
 EXPORT_SYMBOL(iwl_is_fat_tx_allowed);
@@ -826,9 +822,18 @@ void iwl_set_rxon_ht(struct iwl_priv *priv, struct iwl_ht_info *ht_info)
                         RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK);
        if (iwl_is_fat_tx_allowed(priv, NULL)) {
                /* pure 40 fat */
-                if (rxon->flags & RXON_FLG_FAT_PROT_MSK)
+                if (ht_info->ht_protection == IEEE80211_HT_OP_MODE_PROTECTION_20MHZ) {
                        rxon->flags |= RXON_FLG_CHANNEL_MODE_PURE_40;
-                else {
+                        /* Note: control channel is opposite of extension channel */
+                        switch (ht_info->extension_chan_offset) {
+                        case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
+                                rxon->flags &= ~RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK;
+                                break;
+                        case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
+                                rxon->flags |= RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK;
+                                break;
+                        }
+                } else {
                        /* Note: control channel is opposite of extension channel */
                        switch (ht_info->extension_chan_offset) {
                        case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
@@ -2390,39 +2395,46 @@ void iwl_bss_info_changed(struct ieee80211_hw *hw,
                priv->ibss_beacon = ieee80211_beacon_get(hw, vif);
        }
-        if ((changes & BSS_CHANGED_BSSID) && !iwl_is_rfkill(priv)) {
+        if (changes & BSS_CHANGED_BEACON_INT) {
-                /* If there is currently a HW scan going on in the background
+                priv->beacon_int = bss_conf->beacon_int;
-                 * then we need to cancel it else the RXON below will fail. */
+                /* TODO: in AP mode, do something to make this take effect */
+        }
+        if (changes & BSS_CHANGED_BSSID) {
+                IWL_DEBUG_MAC80211(priv, "BSSID %pM\n", bss_conf->bssid);
+                /*
+                 * If there is currently a HW scan going on in the
+                 * background then we need to cancel it else the RXON
+                 * below/in post_associate will fail.
+                 */
                if (iwl_scan_cancel_timeout(priv, 100)) {
-                        IWL_WARN(priv, "Aborted scan still in progress "
+                        IWL_WARN(priv, "Aborted scan still in progress after 100ms\n");
-                                    "after 100ms\n");
                        IWL_DEBUG_MAC80211(priv, "leaving - scan abort failed.\n");
                        mutex_unlock(&priv->mutex);
                        return;
                }
-                memcpy(priv->staging_rxon.bssid_addr,
-                       bss_conf->bssid, ETH_ALEN);
+                /* mac80211 only sets assoc when in STATION mode */
+                if (priv->iw_mode == NL80211_IFTYPE_ADHOC ||
-                /* TODO: Audit driver for usage of these members and see
+                    bss_conf->assoc) {
-                 * if mac80211 deprecates them (priv->bssid looks like it
+                        memcpy(priv->staging_rxon.bssid_addr,
-                 * shouldn't be there, but I haven't scanned the IBSS code
+                               bss_conf->bssid, ETH_ALEN);
-                 * to verify) - jpk */
-                memcpy(priv->bssid, bss_conf->bssid, ETH_ALEN);
+                        /* currently needed in a few places */
+                        memcpy(priv->bssid, bss_conf->bssid, ETH_ALEN);
-                if (priv->iw_mode == NL80211_IFTYPE_AP)
+                } else {
-                        iwlcore_config_ap(priv);
+                        priv->staging_rxon.filter_flags &=
-                else {
+                                ~RXON_FILTER_ASSOC_MSK;
-                        int rc = iwlcore_commit_rxon(priv);
-                        if ((priv->iw_mode == NL80211_IFTYPE_STATION) && rc)
-                                iwl_rxon_add_station(
-                                        priv, priv->active_rxon.bssid_addr, 1);
                }
-        } else if (!iwl_is_rfkill(priv)) {
-                iwl_scan_cancel_timeout(priv, 100);
-                priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
-                iwlcore_commit_rxon(priv);
        }
+        /*
+         * This needs to be after setting the BSSID in case
+         * mac80211 decides to do both changes at once because
+         * it will invoke post_associate.
+         */
        if (priv->iw_mode == NL80211_IFTYPE_ADHOC &&
            changes & BSS_CHANGED_BEACON) {
                struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
@@ -2431,8 +2443,6 @@ void iwl_bss_info_changed(struct ieee80211_hw *hw,
                        iwl_mac_beacon_update(hw, beacon);
        }
-        mutex_unlock(&priv->mutex);
        if (changes & BSS_CHANGED_ERP_PREAMBLE) {
                IWL_DEBUG_MAC80211(priv, "ERP_PREAMBLE %d\n",
                                   bss_conf->use_short_preamble);
@@ -2450,6 +2460,23 @@ void iwl_bss_info_changed(struct ieee80211_hw *hw,
                        priv->staging_rxon.flags &= ~RXON_FLG_TGG_PROTECT_MSK;
        }
+        if (changes & BSS_CHANGED_BASIC_RATES) {
+                /* XXX use this information
+                 *
+                 * To do that, remove code from iwl_set_rate() and put something
+                 * like this here:
+                 *
+                if (A-band)
+                        priv->staging_rxon.ofdm_basic_rates =
+                                bss_conf->basic_rates;
+                else
+                        priv->staging_rxon.ofdm_basic_rates =
+                                bss_conf->basic_rates >> 4;
+                        priv->staging_rxon.cck_basic_rates =
+                                bss_conf->basic_rates & 0xF;
+                 */
+        }
        if (changes & BSS_CHANGED_HT) {
                iwl_ht_conf(priv, bss_conf);
@@ -2459,10 +2486,6 @@ void iwl_bss_info_changed(struct ieee80211_hw *hw,
        if (changes & BSS_CHANGED_ASSOC) {
                IWL_DEBUG_MAC80211(priv, "ASSOC %d\n", bss_conf->assoc);
-                /* This should never happen as this function should
-                 * never be called from interrupt context. */
-                if (WARN_ON_ONCE(in_interrupt()))
-                        return;
                if (bss_conf->assoc) {
                        priv->assoc_id = bss_conf->aid;
                        priv->beacon_int = bss_conf->beacon_int;
@@ -2470,27 +2493,35 @@ void iwl_bss_info_changed(struct ieee80211_hw *hw,
                        priv->timestamp = bss_conf->timestamp;
                        priv->assoc_capability = bss_conf->assoc_capability;
-                        /* we have just associated, don't start scan too early
+                        /*
-                         * leave time for EAPOL exchange to complete
+                         * We have just associated, don't start scan too early
+                         * leave time for EAPOL exchange to complete.
+                         *
+                         * XXX: do this in mac80211
                         */
                        priv->next_scan_jiffies = jiffies +
                                        IWL_DELAY_NEXT_SCAN_AFTER_ASSOC;
-                        mutex_lock(&priv->mutex);
+                        if (!iwl_is_rfkill(priv))
-                        priv->cfg->ops->lib->post_associate(priv);
+                                priv->cfg->ops->lib->post_associate(priv);
-                        mutex_unlock(&priv->mutex);
+                } else
-                } else {
                        priv->assoc_id = 0;
-                        IWL_DEBUG_MAC80211(priv, "DISASSOC %d\n", bss_conf->assoc);
+        }
+        if (changes && iwl_is_associated(priv) && priv->assoc_id) {
+                IWL_DEBUG_MAC80211(priv, "Changes (%#x) while associated\n",
+                                   changes);
+                ret = iwl_send_rxon_assoc(priv);
+                if (!ret) {
+                        /* Sync active_rxon with latest change. */
+                        memcpy((void *)&priv->active_rxon,
+                                &priv->staging_rxon,
+                                sizeof(struct iwl_rxon_cmd));
                }
-        } else if (changes && iwl_is_associated(priv) && priv->assoc_id) {
-                        IWL_DEBUG_MAC80211(priv, "Associated Changes %d\n", changes);
-                        ret = iwl_send_rxon_assoc(priv);
-                        if (!ret)
-                                /* Sync active_rxon with latest change. */
-                                memcpy((void *)&priv->active_rxon,
-                                        &priv->staging_rxon,
-                                        sizeof(struct iwl_rxon_cmd));
        }
+        mutex_unlock(&priv->mutex);
        IWL_DEBUG_MAC80211(priv, "leave\n");
 }
 EXPORT_SYMBOL(iwl_bss_info_changed);
diff --git a/drivers/net/wireless/iwlwifi/iwl3945-base.c b/drivers/net/wireless/iwlwifi/iwl3945-base.c
index 83d31606dd00..cb9bd4c8f25e 100644
--- a/drivers/net/wireless/iwlwifi/iwl3945-base.c
+++ b/drivers/net/wireless/iwlwifi/iwl3945-base.c
@@ -2498,8 +2498,7 @@ static void iwl3945_alive_start(struct iwl_priv *priv)
                struct iwl3945_rxon_cmd *active_rxon =
                                (struct iwl3945_rxon_cmd *)(&priv->active_rxon);
-                memcpy(&priv->staging_rxon, &priv->active_rxon,
+                priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
-                       sizeof(priv->staging_rxon));
                active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
        } else {
                /* Initialize our rx_config data */
@@ -3147,7 +3146,6 @@ static int iwl3945_mac_start(struct ieee80211_hw *hw)
        /* we should be verifying the device is ready to be opened */
        mutex_lock(&priv->mutex);
-        memset(&priv->staging_rxon, 0, sizeof(priv->staging_rxon));
        /* fetch ucode file from disk, alloc and copy to bus-master buffers ...
         * ucode filename and max sizes are card-specific. */
diff --git a/drivers/net/wireless/libertas/if_spi.c b/drivers/net/wireless/libertas/if_spi.c
index 06a46d7b3d6c..6564282ce476 100644
--- a/drivers/net/wireless/libertas/if_spi.c
+++ b/drivers/net/wireless/libertas/if_spi.c
@@ -812,7 +812,6 @@ out:
 static void if_spi_e2h(struct if_spi_card *card)
 {
        int err = 0;
-        unsigned long flags;
        u32 cause;
        struct lbs_private *priv = card->priv;
@@ -827,10 +826,7 @@ static void if_spi_e2h(struct if_spi_card *card)
        /* generate a card interrupt */
        spu_write_u16(card, IF_SPI_CARD_INT_CAUSE_REG, IF_SPI_CIC_HOST_EVENT);
-        spin_lock_irqsave(&priv->driver_lock, flags);
        lbs_queue_event(priv, cause & 0xff);
-        spin_unlock_irqrestore(&priv->driver_lock, flags);
 out:
        if (err)
                lbs_pr_err("%s: error %d\n", __func__, err);
@@ -875,7 +871,12 @@ static int lbs_spi_thread(void *data)
                        err = if_spi_c2h_data(card);
                        if (err)
                                goto err;
-                if (hiStatus & IF_SPI_HIST_CMD_DOWNLOAD_RDY) {
+                /* workaround: in PS mode, the card does not set the Command
+                 * Download Ready bit, but it sets TX Download Ready. */
+                if (hiStatus & IF_SPI_HIST_CMD_DOWNLOAD_RDY ||
+                   (card->priv->psstate != PS_STATE_FULL_POWER &&
+                    (hiStatus & IF_SPI_HIST_TX_DOWNLOAD_RDY))) {
                        /* This means two things. First of all,
                         * if there was a previous command sent, the card has
                         * successfully received it.
diff --git a/drivers/pci/setup-res.c b/drivers/pci/setup-res.c
index 3039fcb86afc..12403516776a 100644
--- a/drivers/pci/setup-res.c
+++ b/drivers/pci/setup-res.c
@@ -99,11 +99,11 @@ void pci_update_resource(struct pci_dev *dev, int resno)
 int pci_claim_resource(struct pci_dev *dev, int resource)
 {
        struct resource *res = &dev->resource[resource];
-        struct resource *root = NULL;
+        struct resource *root;
        char *dtype = resource < PCI_BRIDGE_RESOURCES ? "device" : "bridge";
        int err;
-        root = pcibios_select_root(dev, res);
+        root = pci_find_parent_resource(dev, res);
        err = -EINVAL;
        if (root != NULL)
diff --git a/drivers/platform/x86/dell-laptop.c b/drivers/platform/x86/dell-laptop.c
index 2faf0e14f05a..74909c4aaeea 100644
--- a/drivers/platform/x86/dell-laptop.c
+++ b/drivers/platform/x86/dell-laptop.c
@@ -177,7 +177,7 @@ dell_send_request(struct calling_interface_buffer *buffer, int class,
 static int dell_rfkill_set(void *data, bool blocked)
 {
        struct calling_interface_buffer buffer;
-        int disable = blocked ? 0 : 1;
+        int disable = blocked ? 1 : 0;
        unsigned long radio = (unsigned long)data;
        memset(&buffer, 0, sizeof(struct calling_interface_buffer));
diff --git a/drivers/platform/x86/sony-laptop.c b/drivers/platform/x86/sony-laptop.c
index e48d9a4506ff..dafaa4a92df5 100644
--- a/drivers/platform/x86/sony-laptop.c
+++ b/drivers/platform/x86/sony-laptop.c
@@ -1133,8 +1133,9 @@ static void sony_nc_rfkill_update()
                        continue;
                if (hwblock) {
-                        if (rfkill_set_hw_state(sony_rfkill_devices[i], true))
+                        if (rfkill_set_hw_state(sony_rfkill_devices[i], true)) {
-                                sony_nc_rfkill_set((void *)i, true);
+                                /* we already know we're blocked */
+                        }
                        continue;
                }
diff --git a/drivers/pps/Kconfig b/drivers/pps/Kconfig
new file mode 100644
index 000000000000..cc2eb8edb514
--- /dev/null
+++ b/drivers/pps/Kconfig
@@ -0,0 +1,33 @@
+#
+# PPS support configuration
+#
+menu "PPS support"
+config PPS
+        tristate "PPS support"
+        depends on EXPERIMENTAL
+        ---help---
+          PPS (Pulse Per Second) is a special pulse provided by some GPS
+          antennae. Userland can use it to get a high-precision time
+          reference.
+          Some antennae's PPS signals are connected with the CD (Carrier
+          Detect) pin of the serial line they use to communicate with the
+          host. In this case use the SERIAL_LINE client support.
+          Some antennae's PPS signals are connected with some special host
+          inputs so you have to enable the corresponding client support.
+          To compile this driver as a module, choose M here: the module
+          will be called pps_core.ko.
+config PPS_DEBUG
+        bool "PPS debugging messages"
+        depends on PPS
+        help
+          Say Y here if you want the PPS support to produce a bunch of debug
+          messages to the system log.  Select this if you are having a
+          problem with PPS support and want to see more of what is going on.
+endmenu
diff --git a/drivers/pps/Makefile b/drivers/pps/Makefile
new file mode 100644
index 000000000000..19ea582f431d
--- /dev/null
+++ b/drivers/pps/Makefile
@@ -0,0 +1,8 @@
+#
+# Makefile for the PPS core.
+#
+pps_core-y                      := pps.o kapi.o sysfs.o
+obj-$(CONFIG_PPS)               := pps_core.o
+ccflags-$(CONFIG_PPS_DEBUG) := -DDEBUG
diff --git a/drivers/pps/kapi.c b/drivers/pps/kapi.c
new file mode 100644
index 000000000000..35a0b192d768
--- /dev/null
+++ b/drivers/pps/kapi.c
@@ -0,0 +1,329 @@
+/*
+ * kernel API
+ *
+ *
+ * Copyright (C) 2005-2009   Rodolfo Giometti <giometti@linux.it>
+ *
+ *   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/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/sched.h>
+#include <linux/time.h>
+#include <linux/spinlock.h>
+#include <linux/idr.h>
+#include <linux/fs.h>
+#include <linux/pps_kernel.h>
+/*
+ * Global variables
+ */
+DEFINE_SPINLOCK(pps_idr_lock);
+DEFINE_IDR(pps_idr);
+/*
+ * Local functions
+ */
+static void pps_add_offset(struct pps_ktime *ts, struct pps_ktime *offset)
+{
+        ts->nsec += offset->nsec;
+        while (ts->nsec >= NSEC_PER_SEC) {
+                ts->nsec -= NSEC_PER_SEC;
+                ts->sec++;
+        }
+        while (ts->nsec < 0) {
+                ts->nsec += NSEC_PER_SEC;
+                ts->sec--;
+        }
+        ts->sec += offset->sec;
+}
+/*
+ * Exported functions
+ */
+/* pps_get_source - find a PPS source
+ * @source: the PPS source ID.
+ *
+ * This function is used to find an already registered PPS source into the
+ * system.
+ *
+ * The function returns NULL if found nothing, otherwise it returns a pointer
+ * to the PPS source data struct (the refcounter is incremented by 1).
+ */
+struct pps_device *pps_get_source(int source)
+{
+        struct pps_device *pps;
+        unsigned long flags;
+        spin_lock_irqsave(&pps_idr_lock, flags);
+        pps = idr_find(&pps_idr, source);
+        if (pps != NULL)
+                atomic_inc(&pps->usage);
+        spin_unlock_irqrestore(&pps_idr_lock, flags);
+        return pps;
+}
+/* pps_put_source - free the PPS source data
+ * @pps: a pointer to the PPS source.
+ *
+ * This function is used to free a PPS data struct if its refcount is 0.
+ */
+void pps_put_source(struct pps_device *pps)
+{
+        unsigned long flags;
+        spin_lock_irqsave(&pps_idr_lock, flags);
+        BUG_ON(atomic_read(&pps->usage) == 0);
+        if (!atomic_dec_and_test(&pps->usage)) {
+                pps = NULL;
+                goto exit;
+        }
+        /* No more reference to the PPS source. We can safely remove the
+         * PPS data struct.
+         */
+        idr_remove(&pps_idr, pps->id);
+exit:
+        spin_unlock_irqrestore(&pps_idr_lock, flags);
+        kfree(pps);
+}
+/* pps_register_source - add a PPS source in the system
+ * @info: the PPS info struct
+ * @default_params: the default PPS parameters of the new source
+ *
+ * This function is used to add a new PPS source in the system. The new
+ * source is described by info's fields and it will have, as default PPS
+ * parameters, the ones specified into default_params.
+ *
+ * The function returns, in case of success, the PPS source ID.
+ */
+int pps_register_source(struct pps_source_info *info, int default_params)
+{
+        struct pps_device *pps;
+        int id;
+        int err;
+        /* Sanity checks */
+        if ((info->mode & default_params) != default_params) {
+                printk(KERN_ERR "pps: %s: unsupported default parameters\n",
+                                        info->name);
+                err = -EINVAL;
+                goto pps_register_source_exit;
+        }
+        if ((info->mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR)) != 0 &&
+                        info->echo == NULL) {
+                printk(KERN_ERR "pps: %s: echo function is not defined\n",
+                                        info->name);
+                err = -EINVAL;
+                goto pps_register_source_exit;
+        }
+        if ((info->mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) {
+                printk(KERN_ERR "pps: %s: unspecified time format\n",
+                                        info->name);
+                err = -EINVAL;
+                goto pps_register_source_exit;
+        }
+        /* Allocate memory for the new PPS source struct */
+        pps = kzalloc(sizeof(struct pps_device), GFP_KERNEL);
+        if (pps == NULL) {
+                err = -ENOMEM;
+                goto pps_register_source_exit;
+        }
+        /* These initializations must be done before calling idr_get_new()
+         * in order to avoid reces into pps_event().
+         */
+        pps->params.api_version = PPS_API_VERS;
+        pps->params.mode = default_params;
+        pps->info = *info;
+        init_waitqueue_head(&pps->queue);
+        spin_lock_init(&pps->lock);
+        atomic_set(&pps->usage, 1);
+        /* Get new ID for the new PPS source */
+        if (idr_pre_get(&pps_idr, GFP_KERNEL) == 0) {
+                err = -ENOMEM;
+                goto kfree_pps;
+        }
+        spin_lock_irq(&pps_idr_lock);
+        /* Now really allocate the PPS source.
+         * After idr_get_new() calling the new source will be freely available
+         * into the kernel.
+         */
+        err = idr_get_new(&pps_idr, pps, &id);
+        if (err < 0) {
+                spin_unlock_irq(&pps_idr_lock);
+                goto kfree_pps;
+        }
+        id = id & MAX_ID_MASK;
+        if (id >= PPS_MAX_SOURCES) {
+                spin_unlock_irq(&pps_idr_lock);
+                printk(KERN_ERR "pps: %s: too many PPS sources in the system\n",
+                                        info->name);
+                err = -EBUSY;
+                goto free_idr;
+        }
+        pps->id = id;
+        spin_unlock_irq(&pps_idr_lock);
+        /* Create the char device */
+        err = pps_register_cdev(pps);
+        if (err < 0) {
+                printk(KERN_ERR "pps: %s: unable to create char device\n",
+                                        info->name);
+                goto free_idr;
+        }
+        pr_info("new PPS source %s at ID %d\n", info->name, id);
+        return id;
+free_idr:
+        spin_lock_irq(&pps_idr_lock);
+        idr_remove(&pps_idr, id);
+        spin_unlock_irq(&pps_idr_lock);
+kfree_pps:
+        kfree(pps);
+pps_register_source_exit:
+        printk(KERN_ERR "pps: %s: unable to register source\n", info->name);
+        return err;
+}
+EXPORT_SYMBOL(pps_register_source);
+/* pps_unregister_source - remove a PPS source from the system
+ * @source: the PPS source ID
+ *
+ * This function is used to remove a previously registered PPS source from
+ * the system.
+ */
+void pps_unregister_source(int source)
+{
+        struct pps_device *pps;
+        spin_lock_irq(&pps_idr_lock);
+        pps = idr_find(&pps_idr, source);
+        if (!pps) {
+                BUG();
+                spin_unlock_irq(&pps_idr_lock);
+                return;
+        }
+        spin_unlock_irq(&pps_idr_lock);
+        pps_unregister_cdev(pps);
+        pps_put_source(pps);
+}
+EXPORT_SYMBOL(pps_unregister_source);
+/* pps_event - register a PPS event into the system
+ * @source: the PPS source ID
+ * @ts: the event timestamp
+ * @event: the event type
+ * @data: userdef pointer
+ *
+ * This function is used by each PPS client in order to register a new
+ * PPS event into the system (it's usually called inside an IRQ handler).
+ *
+ * If an echo function is associated with the PPS source it will be called
+ * as:
+ *      pps->info.echo(source, event, data);
+ */
+void pps_event(int source, struct pps_ktime *ts, int event, void *data)
+{
+        struct pps_device *pps;
+        unsigned long flags;
+        if ((event & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0) {
+                printk(KERN_ERR "pps: unknown event (%x) for source %d\n",
+                        event, source);
+                return;
+        }
+        pps = pps_get_source(source);
+        if (!pps)
+                return;
+        pr_debug("PPS event on source %d at %llu.%06u\n",
+                        pps->id, (unsigned long long) ts->sec, ts->nsec);
+        spin_lock_irqsave(&pps->lock, flags);
+        /* Must call the echo function? */
+        if ((pps->params.mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR)))
+                pps->info.echo(source, event, data);
+        /* Check the event */
+        pps->current_mode = pps->params.mode;
+        if (event & PPS_CAPTUREASSERT) {
+                /* We have to add an offset? */
+                if (pps->params.mode & PPS_OFFSETASSERT)
+                        pps_add_offset(ts, &pps->params.assert_off_tu);
+                /* Save the time stamp */
+                pps->assert_tu = *ts;
+                pps->assert_sequence++;
+                pr_debug("capture assert seq #%u for source %d\n",
+                        pps->assert_sequence, source);
+        }
+        if (event & PPS_CAPTURECLEAR) {
+                /* We have to add an offset? */
+                if (pps->params.mode & PPS_OFFSETCLEAR)
+                        pps_add_offset(ts, &pps->params.clear_off_tu);
+                /* Save the time stamp */
+                pps->clear_tu = *ts;
+                pps->clear_sequence++;
+                pr_debug("capture clear seq #%u for source %d\n",
+                        pps->clear_sequence, source);
+        }
+        pps->go = ~0;
+        wake_up_interruptible(&pps->queue);
+        kill_fasync(&pps->async_queue, SIGIO, POLL_IN);
+        spin_unlock_irqrestore(&pps->lock, flags);
+        /* Now we can release the PPS source for (possible) deregistration */
+        pps_put_source(pps);
+}
+EXPORT_SYMBOL(pps_event);
diff --git a/drivers/pps/pps.c b/drivers/pps/pps.c
new file mode 100644
index 000000000000..ac8cc8cea1e3
--- /dev/null
+++ b/drivers/pps/pps.c
@@ -0,0 +1,312 @@
+/*
+ * PPS core file
+ *
+ *
+ * Copyright (C) 2005-2009   Rodolfo Giometti <giometti@linux.it>
+ *
+ *   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/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/sched.h>
+#include <linux/uaccess.h>
+#include <linux/idr.h>
+#include <linux/cdev.h>
+#include <linux/poll.h>
+#include <linux/pps_kernel.h>
+/*
+ * Local variables
+ */
+static dev_t pps_devt;
+static struct class *pps_class;
+/*
+ * Char device methods
+ */
+static unsigned int pps_cdev_poll(struct file *file, poll_table *wait)
+{
+        struct pps_device *pps = file->private_data;
+        poll_wait(file, &pps->queue, wait);
+        return POLLIN | POLLRDNORM;
+}
+static int pps_cdev_fasync(int fd, struct file *file, int on)
+{
+        struct pps_device *pps = file->private_data;
+        return fasync_helper(fd, file, on, &pps->async_queue);
+}
+static long pps_cdev_ioctl(struct file *file,
+                unsigned int cmd, unsigned long arg)
+{
+        struct pps_device *pps = file->private_data;
+        struct pps_kparams params;
+        struct pps_fdata fdata;
+        unsigned long ticks;
+        void __user *uarg = (void __user *) arg;
+        int __user *iuarg = (int __user *) arg;
+        int err;
+        switch (cmd) {
+        case PPS_GETPARAMS:
+                pr_debug("PPS_GETPARAMS: source %d\n", pps->id);
+                /* Return current parameters */
+                err = copy_to_user(uarg, &pps->params,
+                                                sizeof(struct pps_kparams));
+                if (err)
+                        return -EFAULT;
+                break;
+        case PPS_SETPARAMS:
+                pr_debug("PPS_SETPARAMS: source %d\n", pps->id);
+                /* Check the capabilities */
+                if (!capable(CAP_SYS_TIME))
+                        return -EPERM;
+                err = copy_from_user(&params, uarg, sizeof(struct pps_kparams));
+                if (err)
+                        return -EFAULT;
+                if (!(params.mode & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR))) {
+                        pr_debug("capture mode unspecified (%x)\n",
+                                                                params.mode);
+                        return -EINVAL;
+                }
+                /* Check for supported capabilities */
+                if ((params.mode & ~pps->info.mode) != 0) {
+                        pr_debug("unsupported capabilities (%x)\n",
+                                                                params.mode);
+                        return -EINVAL;
+                }
+                spin_lock_irq(&pps->lock);
+                /* Save the new parameters */
+                pps->params = params;
+                /* Restore the read only parameters */
+                if ((params.mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) {
+                        /* section 3.3 of RFC 2783 interpreted */
+                        pr_debug("time format unspecified (%x)\n",
+                                                                params.mode);
+                        pps->params.mode |= PPS_TSFMT_TSPEC;
+                }
+                if (pps->info.mode & PPS_CANWAIT)
+                        pps->params.mode |= PPS_CANWAIT;
+                pps->params.api_version = PPS_API_VERS;
+                spin_unlock_irq(&pps->lock);
+                break;
+        case PPS_GETCAP:
+                pr_debug("PPS_GETCAP: source %d\n", pps->id);
+                err = put_user(pps->info.mode, iuarg);
+                if (err)
+                        return -EFAULT;
+                break;
+        case PPS_FETCH:
+                pr_debug("PPS_FETCH: source %d\n", pps->id);
+                err = copy_from_user(&fdata, uarg, sizeof(struct pps_fdata));
+                if (err)
+                        return -EFAULT;
+                pps->go = 0;
+                /* Manage the timeout */
+                if (fdata.timeout.flags & PPS_TIME_INVALID)
+                        err = wait_event_interruptible(pps->queue, pps->go);
+                else {
+                        pr_debug("timeout %lld.%09d\n",
+                                        (long long) fdata.timeout.sec,
+                                        fdata.timeout.nsec);
+                        ticks = fdata.timeout.sec * HZ;
+                        ticks += fdata.timeout.nsec / (NSEC_PER_SEC / HZ);
+                        if (ticks != 0) {
+                                err = wait_event_interruptible_timeout(
+                                                pps->queue, pps->go, ticks);
+                                if (err == 0)
+                                        return -ETIMEDOUT;
+                        }
+                }
+                /* Check for pending signals */
+                if (err == -ERESTARTSYS) {
+                        pr_debug("pending signal caught\n");
+                        return -EINTR;
+                }
+                /* Return the fetched timestamp */
+                spin_lock_irq(&pps->lock);
+                fdata.info.assert_sequence = pps->assert_sequence;
+                fdata.info.clear_sequence = pps->clear_sequence;
+                fdata.info.assert_tu = pps->assert_tu;
+                fdata.info.clear_tu = pps->clear_tu;
+                fdata.info.current_mode = pps->current_mode;
+                spin_unlock_irq(&pps->lock);
+                err = copy_to_user(uarg, &fdata, sizeof(struct pps_fdata));
+                if (err)
+                        return -EFAULT;
+                break;
+        default:
+                return -ENOTTY;
+                break;
+        }
+        return 0;
+}
+static int pps_cdev_open(struct inode *inode, struct file *file)
+{
+        struct pps_device *pps = container_of(inode->i_cdev,
+                                                struct pps_device, cdev);
+        int found;
+        found = pps_get_source(pps->id) != 0;
+        if (!found)
+                return -ENODEV;
+        file->private_data = pps;
+        return 0;
+}
+static int pps_cdev_release(struct inode *inode, struct file *file)
+{
+        struct pps_device *pps = file->private_data;
+        /* Free the PPS source and wake up (possible) deregistration */
+        pps_put_source(pps);
+        return 0;
+}
+/*
+ * Char device stuff
+ */
+static const struct file_operations pps_cdev_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .poll           = pps_cdev_poll,
+        .fasync         = pps_cdev_fasync,
+        .unlocked_ioctl = pps_cdev_ioctl,
+        .open           = pps_cdev_open,
+        .release        = pps_cdev_release,
+};
+int pps_register_cdev(struct pps_device *pps)
+{
+        int err;
+        pps->devno = MKDEV(MAJOR(pps_devt), pps->id);
+        cdev_init(&pps->cdev, &pps_cdev_fops);
+        pps->cdev.owner = pps->info.owner;
+        err = cdev_add(&pps->cdev, pps->devno, 1);
+        if (err) {
+                printk(KERN_ERR "pps: %s: failed to add char device %d:%d\n",
+                                pps->info.name, MAJOR(pps_devt), pps->id);
+                return err;
+        }
+        pps->dev = device_create(pps_class, pps->info.dev, pps->devno, NULL,
+                                                        "pps%d", pps->id);
+        if (err)
+                goto del_cdev;
+        dev_set_drvdata(pps->dev, pps);
+        pr_debug("source %s got cdev (%d:%d)\n", pps->info.name,
+                        MAJOR(pps_devt), pps->id);
+        return 0;
+del_cdev:
+        cdev_del(&pps->cdev);
+        return err;
+}
+void pps_unregister_cdev(struct pps_device *pps)
+{
+        device_destroy(pps_class, pps->devno);
+        cdev_del(&pps->cdev);
+}
+/*
+ * Module stuff
+ */
+static void __exit pps_exit(void)
+{
+        class_destroy(pps_class);
+        unregister_chrdev_region(pps_devt, PPS_MAX_SOURCES);
+}
+static int __init pps_init(void)
+{
+        int err;
+        pps_class = class_create(THIS_MODULE, "pps");
+        if (!pps_class) {
+                printk(KERN_ERR "pps: failed to allocate class\n");
+                return -ENOMEM;
+        }
+        pps_class->dev_attrs = pps_attrs;
+        err = alloc_chrdev_region(&pps_devt, 0, PPS_MAX_SOURCES, "pps");
+        if (err < 0) {
+                printk(KERN_ERR "pps: failed to allocate char device region\n");
+                goto remove_class;
+        }
+        pr_info("LinuxPPS API ver. %d registered\n", PPS_API_VERS);
+        pr_info("Software ver. %s - Copyright 2005-2007 Rodolfo Giometti "
+                "<giometti@linux.it>\n", PPS_VERSION);
+        return 0;
+remove_class:
+        class_destroy(pps_class);
+        return err;
+}
+subsys_initcall(pps_init);
+module_exit(pps_exit);
+MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
+MODULE_DESCRIPTION("LinuxPPS support (RFC 2783) - ver. " PPS_VERSION);
+MODULE_LICENSE("GPL");
diff --git a/drivers/pps/sysfs.c b/drivers/pps/sysfs.c
new file mode 100644
index 000000000000..ef0978c71eee
--- /dev/null
+++ b/drivers/pps/sysfs.c
@@ -0,0 +1,98 @@
+/*
+ * PPS sysfs support
+ *
+ *
+ * Copyright (C) 2007-2009   Rodolfo Giometti <giometti@linux.it>
+ *
+ *   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/device.h>
+#include <linux/module.h>
+#include <linux/string.h>
+#include <linux/pps_kernel.h>
+/*
+ * Attribute functions
+ */
+static ssize_t pps_show_assert(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct pps_device *pps = dev_get_drvdata(dev);
+        if (!(pps->info.mode & PPS_CAPTUREASSERT))
+                return 0;
+        return sprintf(buf, "%lld.%09d#%d\n",
+                        (long long) pps->assert_tu.sec, pps->assert_tu.nsec,
+                        pps->assert_sequence);
+}
+static ssize_t pps_show_clear(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct pps_device *pps = dev_get_drvdata(dev);
+        if (!(pps->info.mode & PPS_CAPTURECLEAR))
+                return 0;
+        return sprintf(buf, "%lld.%09d#%d\n",
+                        (long long) pps->clear_tu.sec, pps->clear_tu.nsec,
+                        pps->clear_sequence);
+}
+static ssize_t pps_show_mode(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct pps_device *pps = dev_get_drvdata(dev);
+        return sprintf(buf, "%4x\n", pps->info.mode);
+}
+static ssize_t pps_show_echo(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct pps_device *pps = dev_get_drvdata(dev);
+        return sprintf(buf, "%d\n", !!pps->info.echo);
+}
+static ssize_t pps_show_name(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct pps_device *pps = dev_get_drvdata(dev);
+        return sprintf(buf, "%s\n", pps->info.name);
+}
+static ssize_t pps_show_path(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct pps_device *pps = dev_get_drvdata(dev);
+        return sprintf(buf, "%s\n", pps->info.path);
+}
+struct device_attribute pps_attrs[] = {
+        __ATTR(assert, S_IRUGO, pps_show_assert, NULL),
+        __ATTR(clear, S_IRUGO, pps_show_clear, NULL),
+        __ATTR(mode, S_IRUGO, pps_show_mode, NULL),
+        __ATTR(echo, S_IRUGO, pps_show_echo, NULL),
+        __ATTR(name, S_IRUGO, pps_show_name, NULL),
+        __ATTR(path, S_IRUGO, pps_show_path, NULL),
+        __ATTR_NULL,
+};
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 277d35d232fa..81adbdbd5042 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -296,6 +296,15 @@ config RTC_DRV_RX8581
          This driver can also be built as a module. If so the module
          will be called rtc-rx8581.
+config RTC_DRV_RX8025
+        tristate "Epson RX-8025SA/NB"
+        help
+          If you say yes here you get support for the Epson
+          RX-8025SA/NB RTC chips.
+          This driver can also be built as a module. If so, the module
+          will be called rtc-rx8025.
 endif # I2C
 comment "SPI RTC drivers"
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index 6c0639a14f09..3c0f2b2ac927 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -62,6 +62,7 @@ obj-$(CONFIG_RTC_DRV_R9701)	+= rtc-r9701.o
 obj-$(CONFIG_RTC_DRV_RS5C313)   += rtc-rs5c313.o
 obj-$(CONFIG_RTC_DRV_RS5C348)   += rtc-rs5c348.o
 obj-$(CONFIG_RTC_DRV_RS5C372)   += rtc-rs5c372.o
+obj-$(CONFIG_RTC_DRV_RX8025)    += rtc-rx8025.o
 obj-$(CONFIG_RTC_DRV_RX8581)    += rtc-rx8581.o
 obj-$(CONFIG_RTC_DRV_S35390A)   += rtc-s35390a.o
 obj-$(CONFIG_RTC_DRV_S3C)       += rtc-s3c.o
diff --git a/drivers/rtc/interface.c b/drivers/rtc/interface.c
index 4348c4b0d453..4cdb31a362ca 100644
--- a/drivers/rtc/interface.c
+++ b/drivers/rtc/interface.c
@@ -371,19 +371,21 @@ EXPORT_SYMBOL_GPL(rtc_update_irq_enable);
 * @rtc: the rtc device
 * @num: how many irqs are being reported (usually one)
 * @events: mask of RTC_IRQF with one or more of RTC_PF, RTC_AF, RTC_UF
- * Context: in_interrupt(), irqs blocked
+ * Context: any
 */
 void rtc_update_irq(struct rtc_device *rtc,
                unsigned long num, unsigned long events)
 {
-        spin_lock(&rtc->irq_lock);
+        unsigned long flags;
+        spin_lock_irqsave(&rtc->irq_lock, flags);
        rtc->irq_data = (rtc->irq_data + (num << 8)) | events;
-        spin_unlock(&rtc->irq_lock);
+        spin_unlock_irqrestore(&rtc->irq_lock, flags);
-        spin_lock(&rtc->irq_task_lock);
+        spin_lock_irqsave(&rtc->irq_task_lock, flags);
        if (rtc->irq_task)
                rtc->irq_task->func(rtc->irq_task->private_data);
-        spin_unlock(&rtc->irq_task_lock);
+        spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
        wake_up_interruptible(&rtc->irq_queue);
        kill_fasync(&rtc->async_queue, SIGIO, POLL_IN);
diff --git a/drivers/rtc/rtc-dev.c b/drivers/rtc/rtc-dev.c
index 45152f4952d6..8a11de9552cd 100644
--- a/drivers/rtc/rtc-dev.c
+++ b/drivers/rtc/rtc-dev.c
@@ -60,8 +60,7 @@ static void rtc_uie_task(struct work_struct *work)
        err = rtc_read_time(rtc, &tm);
-        local_irq_disable();
+        spin_lock_irq(&rtc->irq_lock);
-        spin_lock(&rtc->irq_lock);
        if (rtc->stop_uie_polling || err) {
                rtc->uie_task_active = 0;
        } else if (rtc->oldsecs != tm.tm_sec) {
@@ -74,10 +73,9 @@ static void rtc_uie_task(struct work_struct *work)
        } else if (schedule_work(&rtc->uie_task) == 0) {
                rtc->uie_task_active = 0;
        }
-        spin_unlock(&rtc->irq_lock);
+        spin_unlock_irq(&rtc->irq_lock);
        if (num)
                rtc_update_irq(rtc, num, RTC_UF | RTC_IRQF);
-        local_irq_enable();
 }
 static void rtc_uie_timer(unsigned long data)
 {
diff --git a/drivers/rtc/rtc-ds1305.c b/drivers/rtc/rtc-ds1305.c
index fc372df6534b..8f410e59d9f5 100644
--- a/drivers/rtc/rtc-ds1305.c
+++ b/drivers/rtc/rtc-ds1305.c
@@ -499,10 +499,7 @@ static void ds1305_work(struct work_struct *work)
        if (!test_bit(FLAG_EXITING, &ds1305->flags))
                enable_irq(spi->irq);
-        /* rtc_update_irq() requires an IRQ-disabled context */
-        local_irq_disable();
        rtc_update_irq(ds1305->rtc, 1, RTC_AF | RTC_IRQF);
-        local_irq_enable();
 }
 /*
diff --git a/drivers/rtc/rtc-ds1307.c b/drivers/rtc/rtc-ds1307.c
index 2c4a65302a9d..47a93c022d91 100644
--- a/drivers/rtc/rtc-ds1307.c
+++ b/drivers/rtc/rtc-ds1307.c
@@ -31,6 +31,8 @@ enum ds_type {
        ds_1338,
        ds_1339,
        ds_1340,
+        ds_1388,
+        ds_3231,
        m41t00,
        rx_8025,
        // rs5c372 too?  different address...
@@ -66,6 +68,7 @@ enum ds_type {
 #define DS1337_REG_CONTROL      0x0e
 #       define DS1337_BIT_nEOSC         0x80
 #       define DS1339_BIT_BBSQI         0x20
+#       define DS3231_BIT_BBSQW         0x40 /* same as BBSQI */
 #       define DS1337_BIT_RS2           0x10
 #       define DS1337_BIT_RS1           0x08
 #       define DS1337_BIT_INTCN         0x04
@@ -94,6 +97,7 @@ enum ds_type {
 struct ds1307 {
+        u8                      offset; /* register's offset */
        u8                      regs[11];
        enum ds_type            type;
        unsigned long           flags;
@@ -128,6 +132,9 @@ static const struct chip_desc chips[] = {
 },
 [ds_1340] = {
 },
+[ds_3231] = {
+        .alarm          = 1,
+},
 [m41t00] = {
 },
 [rx_8025] = {
@@ -138,7 +145,9 @@ static const struct i2c_device_id ds1307_id[] = {
        { "ds1337", ds_1337 },
        { "ds1338", ds_1338 },
        { "ds1339", ds_1339 },
+        { "ds1388", ds_1388 },
        { "ds1340", ds_1340 },
+        { "ds3231", ds_3231 },
        { "m41t00", m41t00 },
        { "rx8025", rx_8025 },
        { }
@@ -258,12 +267,7 @@ static void ds1307_work(struct work_struct *work)
                control &= ~DS1337_BIT_A1IE;
                i2c_smbus_write_byte_data(client, DS1337_REG_CONTROL, control);
-                /* rtc_update_irq() assumes that it is called
-                 * from IRQ-disabled context.
-                 */
-                local_irq_disable();
                rtc_update_irq(ds1307->rtc, 1, RTC_AF | RTC_IRQF);
-                local_irq_enable();
        }
 out:
@@ -291,7 +295,7 @@ static int ds1307_get_time(struct device *dev, struct rtc_time *t)
        /* read the RTC date and time registers all at once */
        tmp = ds1307->read_block_data(ds1307->client,
-                DS1307_REG_SECS, 7, ds1307->regs);
+                ds1307->offset, 7, ds1307->regs);
        if (tmp != 7) {
                dev_err(dev, "%s error %d\n", "read", tmp);
                return -EIO;
@@ -353,6 +357,7 @@ static int ds1307_set_time(struct device *dev, struct rtc_time *t)
        switch (ds1307->type) {
        case ds_1337:
        case ds_1339:
+        case ds_3231:
                buf[DS1307_REG_MONTH] |= DS1337_BIT_CENTURY;
                break;
        case ds_1340:
@@ -367,7 +372,8 @@ static int ds1307_set_time(struct device *dev, struct rtc_time *t)
                "write", buf[0], buf[1], buf[2], buf[3],
                buf[4], buf[5], buf[6]);
-        result = ds1307->write_block_data(ds1307->client, 0, 7, buf);
+        result = ds1307->write_block_data(ds1307->client,
+                ds1307->offset, 7, buf);
        if (result < 0) {
                dev_err(dev, "%s error %d\n", "write", result);
                return result;
@@ -624,6 +630,11 @@ static int __devinit ds1307_probe(struct i2c_client *client,
        struct i2c_adapter      *adapter = to_i2c_adapter(client->dev.parent);
        int                     want_irq = false;
        unsigned char           *buf;
+        static const int        bbsqi_bitpos[] = {
+                [ds_1337] = 0,
+                [ds_1339] = DS1339_BIT_BBSQI,
+                [ds_3231] = DS3231_BIT_BBSQW,
+        };
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)
            && !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_I2C_BLOCK))
@@ -632,9 +643,12 @@ static int __devinit ds1307_probe(struct i2c_client *client,
        if (!(ds1307 = kzalloc(sizeof(struct ds1307), GFP_KERNEL)))
                return -ENOMEM;
-        ds1307->client = client;
        i2c_set_clientdata(client, ds1307);
-        ds1307->type = id->driver_data;
+        ds1307->client  = client;
+        ds1307->type    = id->driver_data;
+        ds1307->offset  = 0;
        buf = ds1307->regs;
        if (i2c_check_functionality(adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) {
                ds1307->read_block_data = i2c_smbus_read_i2c_block_data;
@@ -647,6 +661,7 @@ static int __devinit ds1307_probe(struct i2c_client *client,
        switch (ds1307->type) {
        case ds_1337:
        case ds_1339:
+        case ds_3231:
                /* has IRQ? */
                if (ds1307->client->irq > 0 && chip->alarm) {
                        INIT_WORK(&ds1307->work, ds1307_work);
@@ -666,12 +681,12 @@ static int __devinit ds1307_probe(struct i2c_client *client,
                        ds1307->regs[0] &= ~DS1337_BIT_nEOSC;
                /* Using IRQ?  Disable the square wave and both alarms.
-                 * For ds1339, be sure alarms can trigger when we're
+                 * For some variants, be sure alarms can trigger when we're
-                 * running on Vbackup (BBSQI); we assume ds1337 will
+                 * running on Vbackup (BBSQI/BBSQW)
-                 * ignore that bit
                 */
                if (want_irq) {
-                        ds1307->regs[0] |= DS1337_BIT_INTCN | DS1339_BIT_BBSQI;
+                        ds1307->regs[0] |= DS1337_BIT_INTCN
+                                        | bbsqi_bitpos[ds1307->type];
                        ds1307->regs[0] &= ~(DS1337_BIT_A2IE | DS1337_BIT_A1IE);
                }
@@ -751,6 +766,9 @@ static int __devinit ds1307_probe(struct i2c_client *client,
                                                  hour);
                }
                break;
+        case ds_1388:
+                ds1307->offset = 1; /* Seconds starts at 1 */
+                break;
        default:
                break;
        }
@@ -814,6 +832,8 @@ read_rtc:
        case rx_8025:
        case ds_1337:
        case ds_1339:
+        case ds_1388:
+        case ds_3231:
                break;
        }
diff --git a/drivers/rtc/rtc-ds1374.c b/drivers/rtc/rtc-ds1374.c
index 4d32e328f6cd..32b27739ec2a 100644
--- a/drivers/rtc/rtc-ds1374.c
+++ b/drivers/rtc/rtc-ds1374.c
@@ -296,12 +296,7 @@ static void ds1374_work(struct work_struct *work)
                control &= ~(DS1374_REG_CR_WACE | DS1374_REG_CR_AIE);
                i2c_smbus_write_byte_data(client, DS1374_REG_CR, control);
-                /* rtc_update_irq() assumes that it is called
-                 * from IRQ-disabled context.
-                 */
-                local_irq_disable();
                rtc_update_irq(ds1374->rtc, 1, RTC_AF | RTC_IRQF);
-                local_irq_enable();
        }
 out:
diff --git a/drivers/rtc/rtc-ds1553.c b/drivers/rtc/rtc-ds1553.c
index 38d472b63406..717288527c6b 100644
--- a/drivers/rtc/rtc-ds1553.c
+++ b/drivers/rtc/rtc-ds1553.c
@@ -329,8 +329,7 @@ static int __devinit ds1553_rtc_probe(struct platform_device *pdev)
        if (pdata->irq > 0) {
                writeb(0, ioaddr + RTC_INTERRUPTS);
                if (request_irq(pdata->irq, ds1553_rtc_interrupt,
-                                IRQF_DISABLED | IRQF_SHARED,
+                                IRQF_DISABLED, pdev->name, pdev) < 0) {
-                                pdev->name, pdev) < 0) {
                        dev_warn(&pdev->dev, "interrupt not available.\n");
                        pdata->irq = 0;
                }
diff --git a/drivers/rtc/rtc-ds1742.c b/drivers/rtc/rtc-ds1742.c
index 8bc8501bffc8..09249459e9a4 100644
--- a/drivers/rtc/rtc-ds1742.c
+++ b/drivers/rtc/rtc-ds1742.c
@@ -57,6 +57,7 @@ struct rtc_plat_data {
        size_t size;
        resource_size_t baseaddr;
        unsigned long last_jiffies;
+        struct bin_attribute nvram_attr;
 };
 static int ds1742_rtc_set_time(struct device *dev, struct rtc_time *tm)
@@ -157,18 +158,6 @@ static ssize_t ds1742_nvram_write(struct kobject *kobj,
        return count;
 }
-static struct bin_attribute ds1742_nvram_attr = {
-        .attr = {
-                .name = "nvram",
-                .mode = S_IRUGO | S_IWUSR,
-        },
-        .read = ds1742_nvram_read,
-        .write = ds1742_nvram_write,
-        /* REVISIT: size in sysfs won't match actual size... if it's
-         * not a constant, each RTC should have its own attribute.
-         */
-};
 static int __devinit ds1742_rtc_probe(struct platform_device *pdev)
 {
        struct rtc_device *rtc;
@@ -199,6 +188,12 @@ static int __devinit ds1742_rtc_probe(struct platform_device *pdev)
        pdata->size_nvram = pdata->size - RTC_SIZE;
        pdata->ioaddr_rtc = ioaddr + pdata->size_nvram;
+        pdata->nvram_attr.attr.name = "nvram";
+        pdata->nvram_attr.attr.mode = S_IRUGO | S_IWUSR;
+        pdata->nvram_attr.read = ds1742_nvram_read;
+        pdata->nvram_attr.write = ds1742_nvram_write;
+        pdata->nvram_attr.size = pdata->size_nvram;
        /* turn RTC on if it was not on */
        ioaddr = pdata->ioaddr_rtc;
        sec = readb(ioaddr + RTC_SECONDS);
@@ -221,11 +216,13 @@ static int __devinit ds1742_rtc_probe(struct platform_device *pdev)
        pdata->rtc = rtc;
        pdata->last_jiffies = jiffies;
        platform_set_drvdata(pdev, pdata);
-        ds1742_nvram_attr.size = max(ds1742_nvram_attr.size,
-                                     pdata->size_nvram);
+        ret = sysfs_create_bin_file(&pdev->dev.kobj, &pdata->nvram_attr);
-        ret = sysfs_create_bin_file(&pdev->dev.kobj, &ds1742_nvram_attr);
+        if (ret) {
-        if (ret)
+                dev_err(&pdev->dev, "creating nvram file in sysfs failed\n");
                goto out;
+        }
        return 0;
 out:
        if (pdata->rtc)
@@ -242,7 +239,7 @@ static int __devexit ds1742_rtc_remove(struct platform_device *pdev)
 {
        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
-        sysfs_remove_bin_file(&pdev->dev.kobj, &ds1742_nvram_attr);
+        sysfs_remove_bin_file(&pdev->dev.kobj, &pdata->nvram_attr);
        rtc_device_unregister(pdata->rtc);
        iounmap(pdata->ioaddr_nvram);
        release_mem_region(pdata->baseaddr, pdata->size);
diff --git a/drivers/rtc/rtc-rx8025.c b/drivers/rtc/rtc-rx8025.c
new file mode 100644
index 000000000000..b1a29bcfdf13
--- /dev/null
+++ b/drivers/rtc/rtc-rx8025.c
@@ -0,0 +1,688 @@
+/*
+ * Driver for Epson's RTC module RX-8025 SA/NB
+ *
+ * Copyright (C) 2009 Wolfgang Grandegger <wg@grandegger.com>
+ *
+ * Copyright (C) 2005 by Digi International Inc.
+ * All rights reserved.
+ *
+ * Modified by fengjh at rising.com.cn
+ * <http://lists.lm-sensors.org/mailman/listinfo/lm-sensors>
+ * 2006.11
+ *
+ * Code cleanup by Sergei Poselenov, <sposelenov@emcraft.com>
+ * Converted to new style by Wolfgang Grandegger <wg@grandegger.com>
+ * Alarm and periodic interrupt added by Dmitry Rakhchev <rda@emcraft.com>
+ *
+ * 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/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/bcd.h>
+#include <linux/i2c.h>
+#include <linux/list.h>
+#include <linux/rtc.h>
+/* Register definitions */
+#define RX8025_REG_SEC          0x00
+#define RX8025_REG_MIN          0x01
+#define RX8025_REG_HOUR         0x02
+#define RX8025_REG_WDAY         0x03
+#define RX8025_REG_MDAY         0x04
+#define RX8025_REG_MONTH        0x05
+#define RX8025_REG_YEAR         0x06
+#define RX8025_REG_DIGOFF       0x07
+#define RX8025_REG_ALWMIN       0x08
+#define RX8025_REG_ALWHOUR      0x09
+#define RX8025_REG_ALWWDAY      0x0a
+#define RX8025_REG_ALDMIN       0x0b
+#define RX8025_REG_ALDHOUR      0x0c
+/* 0x0d is reserved */
+#define RX8025_REG_CTRL1        0x0e
+#define RX8025_REG_CTRL2        0x0f
+#define RX8025_BIT_CTRL1_CT     (7 << 0)
+/* 1 Hz periodic level irq */
+#define RX8025_BIT_CTRL1_CT_1HZ 4
+#define RX8025_BIT_CTRL1_TEST   (1 << 3)
+#define RX8025_BIT_CTRL1_1224   (1 << 5)
+#define RX8025_BIT_CTRL1_DALE   (1 << 6)
+#define RX8025_BIT_CTRL1_WALE   (1 << 7)
+#define RX8025_BIT_CTRL2_DAFG   (1 << 0)
+#define RX8025_BIT_CTRL2_WAFG   (1 << 1)
+#define RX8025_BIT_CTRL2_CTFG   (1 << 2)
+#define RX8025_BIT_CTRL2_PON    (1 << 4)
+#define RX8025_BIT_CTRL2_XST    (1 << 5)
+#define RX8025_BIT_CTRL2_VDET   (1 << 6)
+/* Clock precision adjustment */
+#define RX8025_ADJ_RESOLUTION   3050 /* in ppb */
+#define RX8025_ADJ_DATA_MAX     62
+#define RX8025_ADJ_DATA_MIN     -62
+static const struct i2c_device_id rx8025_id[] = {
+        { "rx8025", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, rx8025_id);
+struct rx8025_data {
+        struct i2c_client *client;
+        struct rtc_device *rtc;
+        struct work_struct work;
+        u8 ctrl1;
+        unsigned exiting:1;
+};
+static int rx8025_read_reg(struct i2c_client *client, int number, u8 *value)
+{
+        int ret = i2c_smbus_read_byte_data(client, (number << 4) | 0x08);
+        if (ret < 0) {
+                dev_err(&client->dev, "Unable to read register #%d\n", number);
+                return ret;
+        }
+        *value = ret;
+        return 0;
+}
+static int rx8025_read_regs(struct i2c_client *client,
+                            int number, u8 length, u8 *values)
+{
+        int ret = i2c_smbus_read_i2c_block_data(client, (number << 4) | 0x08,
+                                                length, values);
+        if (ret != length) {
+                dev_err(&client->dev, "Unable to read registers #%d..#%d\n",
+                        number, number + length - 1);
+                return ret < 0 ? ret : -EIO;
+        }
+        return 0;
+}
+static int rx8025_write_reg(struct i2c_client *client, int number, u8 value)
+{
+        int ret = i2c_smbus_write_byte_data(client, number << 4, value);
+        if (ret)
+                dev_err(&client->dev, "Unable to write register #%d\n",
+                        number);
+        return ret;
+}
+static int rx8025_write_regs(struct i2c_client *client,
+                             int number, u8 length, u8 *values)
+{
+        int ret = i2c_smbus_write_i2c_block_data(client, (number << 4) | 0x08,
+                                                 length, values);
+        if (ret)
+                dev_err(&client->dev, "Unable to write registers #%d..#%d\n",
+                        number, number + length - 1);
+        return ret;
+}
+static irqreturn_t rx8025_irq(int irq, void *dev_id)
+{
+        struct i2c_client *client = dev_id;
+        struct rx8025_data *rx8025 = i2c_get_clientdata(client);
+        disable_irq_nosync(irq);
+        schedule_work(&rx8025->work);
+        return IRQ_HANDLED;
+}
+static void rx8025_work(struct work_struct *work)
+{
+        struct rx8025_data *rx8025 = container_of(work, struct rx8025_data,
+                                                  work);
+        struct i2c_client *client = rx8025->client;
+        struct mutex *lock = &rx8025->rtc->ops_lock;
+        u8 status;
+        mutex_lock(lock);
+        if (rx8025_read_reg(client, RX8025_REG_CTRL2, &status))
+                goto out;
+        if (!(status & RX8025_BIT_CTRL2_XST))
+                dev_warn(&client->dev, "Oscillation stop was detected,"
+                         "you may have to readjust the clock\n");
+        if (status & RX8025_BIT_CTRL2_CTFG) {
+                /* periodic */
+                status &= ~RX8025_BIT_CTRL2_CTFG;
+                local_irq_disable();
+                rtc_update_irq(rx8025->rtc, 1, RTC_PF | RTC_IRQF);
+                local_irq_enable();
+        }
+        if (status & RX8025_BIT_CTRL2_DAFG) {
+                /* alarm */
+                status &= RX8025_BIT_CTRL2_DAFG;
+                if (rx8025_write_reg(client, RX8025_REG_CTRL1,
+                                     rx8025->ctrl1 & ~RX8025_BIT_CTRL1_DALE))
+                        goto out;
+                local_irq_disable();
+                rtc_update_irq(rx8025->rtc, 1, RTC_AF | RTC_IRQF);
+                local_irq_enable();
+        }
+        /* acknowledge IRQ */
+        rx8025_write_reg(client, RX8025_REG_CTRL2,
+                         status | RX8025_BIT_CTRL2_XST);
+out:
+        if (!rx8025->exiting)
+                enable_irq(client->irq);
+        mutex_unlock(lock);
+}
+static int rx8025_get_time(struct device *dev, struct rtc_time *dt)
+{
+        struct rx8025_data *rx8025 = dev_get_drvdata(dev);
+        u8 date[7];
+        int err;
+        err = rx8025_read_regs(rx8025->client, RX8025_REG_SEC, 7, date);
+        if (err)
+                return err;
+        dev_dbg(dev, "%s: read 0x%02x 0x%02x "
+                "0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n", __func__,
+                date[0], date[1], date[2], date[3], date[4],
+                date[5], date[6]);
+        dt->tm_sec = bcd2bin(date[RX8025_REG_SEC] & 0x7f);
+        dt->tm_min = bcd2bin(date[RX8025_REG_MIN] & 0x7f);
+        if (rx8025->ctrl1 & RX8025_BIT_CTRL1_1224)
+                dt->tm_hour = bcd2bin(date[RX8025_REG_HOUR] & 0x3f);
+        else
+                dt->tm_hour = bcd2bin(date[RX8025_REG_HOUR] & 0x1f) % 12
+                        + (date[RX8025_REG_HOUR] & 0x20 ? 12 : 0);
+        dt->tm_mday = bcd2bin(date[RX8025_REG_MDAY] & 0x3f);
+        dt->tm_mon = bcd2bin(date[RX8025_REG_MONTH] & 0x1f) - 1;
+        dt->tm_year = bcd2bin(date[RX8025_REG_YEAR]);
+        if (dt->tm_year < 70)
+                dt->tm_year += 100;
+        dev_dbg(dev, "%s: date %ds %dm %dh %dmd %dm %dy\n", __func__,
+                dt->tm_sec, dt->tm_min, dt->tm_hour,
+                dt->tm_mday, dt->tm_mon, dt->tm_year);
+        return rtc_valid_tm(dt);
+}
+static int rx8025_set_time(struct device *dev, struct rtc_time *dt)
+{
+        struct rx8025_data *rx8025 = dev_get_drvdata(dev);
+        u8 date[7];
+        /*
+         * BUG: The HW assumes every year that is a multiple of 4 to be a leap
+         * year.  Next time this is wrong is 2100, which will not be a leap
+         * year.
+         */
+        /*
+         * Here the read-only bits are written as "0".  I'm not sure if that
+         * is sound.
+         */
+        date[RX8025_REG_SEC] = bin2bcd(dt->tm_sec);
+        date[RX8025_REG_MIN] = bin2bcd(dt->tm_min);
+        if (rx8025->ctrl1 & RX8025_BIT_CTRL1_1224)
+                date[RX8025_REG_HOUR] = bin2bcd(dt->tm_hour);
+        else
+                date[RX8025_REG_HOUR] = (dt->tm_hour >= 12 ? 0x20 : 0)
+                        | bin2bcd((dt->tm_hour + 11) % 12 + 1);
+        date[RX8025_REG_WDAY] = bin2bcd(dt->tm_wday);
+        date[RX8025_REG_MDAY] = bin2bcd(dt->tm_mday);
+        date[RX8025_REG_MONTH] = bin2bcd(dt->tm_mon + 1);
+        date[RX8025_REG_YEAR] = bin2bcd(dt->tm_year % 100);
+        dev_dbg(dev,
+                "%s: write 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
+                __func__,
+                date[0], date[1], date[2], date[3], date[4], date[5], date[6]);
+        return rx8025_write_regs(rx8025->client, RX8025_REG_SEC, 7, date);
+}
+static int rx8025_init_client(struct i2c_client *client, int *need_reset)
+{
+        struct rx8025_data *rx8025 = i2c_get_clientdata(client);
+        u8 ctrl[2], ctrl2;
+        int need_clear = 0;
+        int err;
+        err = rx8025_read_regs(rx8025->client, RX8025_REG_CTRL1, 2, ctrl);
+        if (err)
+                goto out;
+        /* Keep test bit zero ! */
+        rx8025->ctrl1 = ctrl[0] & ~RX8025_BIT_CTRL1_TEST;
+        if (ctrl[1] & RX8025_BIT_CTRL2_PON) {
+                dev_warn(&client->dev, "power-on reset was detected, "
+                         "you may have to readjust the clock\n");
+                *need_reset = 1;
+        }
+        if (ctrl[1] & RX8025_BIT_CTRL2_VDET) {
+                dev_warn(&client->dev, "a power voltage drop was detected, "
+                         "you may have to readjust the clock\n");
+                *need_reset = 1;
+        }
+        if (!(ctrl[1] & RX8025_BIT_CTRL2_XST)) {
+                dev_warn(&client->dev, "Oscillation stop was detected,"
+                         "you may have to readjust the clock\n");
+                *need_reset = 1;
+        }
+        if (ctrl[1] & (RX8025_BIT_CTRL2_DAFG | RX8025_BIT_CTRL2_WAFG)) {
+                dev_warn(&client->dev, "Alarm was detected\n");
+                need_clear = 1;
+        }
+        if (!(ctrl[1] & RX8025_BIT_CTRL2_CTFG))
+                need_clear = 1;
+        if (*need_reset || need_clear) {
+                ctrl2 = ctrl[0];
+                ctrl2 &= ~(RX8025_BIT_CTRL2_PON | RX8025_BIT_CTRL2_VDET |
+                           RX8025_BIT_CTRL2_CTFG | RX8025_BIT_CTRL2_WAFG |
+                           RX8025_BIT_CTRL2_DAFG);
+                ctrl2 |= RX8025_BIT_CTRL2_XST;
+                err = rx8025_write_reg(client, RX8025_REG_CTRL2, ctrl2);
+        }
+out:
+        return err;
+}
+/* Alarm support */
+static int rx8025_read_alarm(struct device *dev, struct rtc_wkalrm *t)
+{
+        struct rx8025_data *rx8025 = dev_get_drvdata(dev);
+        struct i2c_client *client = rx8025->client;
+        u8 ctrl2, ald[2];
+        int err;
+        if (client->irq <= 0)
+                return -EINVAL;
+        err = rx8025_read_regs(client, RX8025_REG_ALDMIN, 2, ald);
+        if (err)
+                return err;
+        err = rx8025_read_reg(client, RX8025_REG_CTRL2, &ctrl2);
+        if (err)
+                return err;
+        dev_dbg(dev, "%s: read alarm 0x%02x 0x%02x ctrl2 %02x\n",
+                __func__, ald[0], ald[1], ctrl2);
+        /* Hardware alarms precision is 1 minute! */
+        t->time.tm_sec = 0;
+        t->time.tm_min = bcd2bin(ald[0] & 0x7f);
+        if (rx8025->ctrl1 & RX8025_BIT_CTRL1_1224)
+                t->time.tm_hour = bcd2bin(ald[1] & 0x3f);
+        else
+                t->time.tm_hour = bcd2bin(ald[1] & 0x1f) % 12
+                        + (ald[1] & 0x20 ? 12 : 0);
+        t->time.tm_wday = -1;
+        t->time.tm_mday = -1;
+        t->time.tm_mon = -1;
+        t->time.tm_year = -1;
+        dev_dbg(dev, "%s: date: %ds %dm %dh %dmd %dm %dy\n",
+                __func__,
+                t->time.tm_sec, t->time.tm_min, t->time.tm_hour,
+                t->time.tm_mday, t->time.tm_mon, t->time.tm_year);
+        t->enabled = !!(rx8025->ctrl1 & RX8025_BIT_CTRL1_DALE);
+        t->pending = (ctrl2 & RX8025_BIT_CTRL2_DAFG) && t->enabled;
+        return err;
+}
+static int rx8025_set_alarm(struct device *dev, struct rtc_wkalrm *t)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct rx8025_data *rx8025 = dev_get_drvdata(dev);
+        u8 ald[2];
+        int err;
+        if (client->irq <= 0)
+                return -EINVAL;
+        /* Hardware alarm precision is 1 minute! */
+        ald[0] = bin2bcd(t->time.tm_min);
+        if (rx8025->ctrl1 & RX8025_BIT_CTRL1_1224)
+                ald[1] = bin2bcd(t->time.tm_hour);
+        else
+                ald[1] = (t->time.tm_hour >= 12 ? 0x20 : 0)
+                        | bin2bcd((t->time.tm_hour + 11) % 12 + 1);
+        dev_dbg(dev, "%s: write 0x%02x 0x%02x\n", __func__, ald[0], ald[1]);
+        if (rx8025->ctrl1 & RX8025_BIT_CTRL1_DALE) {
+                rx8025->ctrl1 &= ~RX8025_BIT_CTRL1_DALE;
+                err = rx8025_write_reg(rx8025->client, RX8025_REG_CTRL1,
+                                       rx8025->ctrl1);
+                if (err)
+                        return err;
+        }
+        err = rx8025_write_regs(rx8025->client, RX8025_REG_ALDMIN, 2, ald);
+        if (err)
+                return err;
+        if (t->enabled) {
+                rx8025->ctrl1 |= RX8025_BIT_CTRL1_DALE;
+                err = rx8025_write_reg(rx8025->client, RX8025_REG_CTRL1,
+                                       rx8025->ctrl1);
+                if (err)
+                        return err;
+        }
+        return 0;
+}
+static int rx8025_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct rx8025_data *rx8025 = dev_get_drvdata(dev);
+        u8 ctrl1;
+        int err;
+        ctrl1 = rx8025->ctrl1;
+        if (enabled)
+                ctrl1 |= RX8025_BIT_CTRL1_DALE;
+        else
+                ctrl1 &= ~RX8025_BIT_CTRL1_DALE;
+        if (ctrl1 != rx8025->ctrl1) {
+                rx8025->ctrl1 = ctrl1;
+                err = rx8025_write_reg(rx8025->client, RX8025_REG_CTRL1,
+                                       rx8025->ctrl1);
+                if (err)
+                        return err;
+        }
+        return 0;
+}
+static int rx8025_irq_set_state(struct device *dev, int enabled)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct rx8025_data *rx8025 = i2c_get_clientdata(client);
+        int ctrl1;
+        int err;
+        if (client->irq <= 0)
+                return -ENXIO;
+        ctrl1 = rx8025->ctrl1 & ~RX8025_BIT_CTRL1_CT;
+        if (enabled)
+                ctrl1 |= RX8025_BIT_CTRL1_CT_1HZ;
+        if (ctrl1 != rx8025->ctrl1) {
+                rx8025->ctrl1 = ctrl1;
+                err = rx8025_write_reg(rx8025->client, RX8025_REG_CTRL1,
+                                       rx8025->ctrl1);
+                if (err)
+                        return err;
+        }
+        return 0;
+}
+static struct rtc_class_ops rx8025_rtc_ops = {
+        .read_time = rx8025_get_time,
+        .set_time = rx8025_set_time,
+        .read_alarm = rx8025_read_alarm,
+        .set_alarm = rx8025_set_alarm,
+        .alarm_irq_enable = rx8025_alarm_irq_enable,
+        .irq_set_state  = rx8025_irq_set_state,
+};
+/*
+ * Clock precision adjustment support
+ *
+ * According to the RX8025 SA/NB application manual the frequency and
+ * temperature charateristics can be approximated using the following
+ * equation:
+ *
+ *   df = a * (ut - t)**2
+ *
+ *   df: Frequency deviation in any temperature
+ *   a : Coefficient = (-35 +-5) * 10**-9
+ *   ut: Ultimate temperature in degree = +25 +-5 degree
+ *   t : Any temperature in degree
+ *
+ * Note that the clock adjustment in ppb must be entered (which is
+ * the negative value of the deviation).
+ */
+static int rx8025_get_clock_adjust(struct device *dev, int *adj)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        u8 digoff;
+        int err;
+        err = rx8025_read_reg(client, RX8025_REG_DIGOFF, &digoff);
+        if (err)
+                return err;
+        *adj = digoff >= 64 ? digoff - 128 : digoff;
+        if (*adj > 0)
+                (*adj)--;
+        *adj *= -RX8025_ADJ_RESOLUTION;
+        return 0;
+}
+static int rx8025_set_clock_adjust(struct device *dev, int adj)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        u8 digoff;
+        int err;
+        adj /= -RX8025_ADJ_RESOLUTION;
+        if (adj > RX8025_ADJ_DATA_MAX)
+                adj = RX8025_ADJ_DATA_MAX;
+        else if (adj < RX8025_ADJ_DATA_MIN)
+                adj = RX8025_ADJ_DATA_MIN;
+        else if (adj > 0)
+                adj++;
+        else if (adj < 0)
+                adj += 128;
+        digoff = adj;
+        err = rx8025_write_reg(client, RX8025_REG_DIGOFF, digoff);
+        if (err)
+                return err;
+        dev_dbg(dev, "%s: write 0x%02x\n", __func__, digoff);
+        return 0;
+}
+static ssize_t rx8025_sysfs_show_clock_adjust(struct device *dev,
+                                              struct device_attribute *attr,
+                                              char *buf)
+{
+        int err, adj;
+        err = rx8025_get_clock_adjust(dev, &adj);
+        if (err)
+                return err;
+        return sprintf(buf, "%d\n", adj);
+}
+static ssize_t rx8025_sysfs_store_clock_adjust(struct device *dev,
+                                               struct device_attribute *attr,
+                                               const char *buf, size_t count)
+{
+        int adj, err;
+        if (sscanf(buf, "%i", &adj) != 1)
+                return -EINVAL;
+        err = rx8025_set_clock_adjust(dev, adj);
+        return err ? err : count;
+}
+static DEVICE_ATTR(clock_adjust_ppb, S_IRUGO | S_IWUSR,
+                   rx8025_sysfs_show_clock_adjust,
+                   rx8025_sysfs_store_clock_adjust);
+static int rx8025_sysfs_register(struct device *dev)
+{
+        return device_create_file(dev, &dev_attr_clock_adjust_ppb);
+}
+static void rx8025_sysfs_unregister(struct device *dev)
+{
+        device_remove_file(dev, &dev_attr_clock_adjust_ppb);
+}
+static int __devinit rx8025_probe(struct i2c_client *client,
+                                  const struct i2c_device_id *id)
+{
+        struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
+        struct rx8025_data *rx8025;
+        int err, need_reset = 0;
+        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA
+                                     | I2C_FUNC_SMBUS_I2C_BLOCK)) {
+                dev_err(&adapter->dev,
+                        "doesn't support required functionality\n");
+                err = -EIO;
+                goto errout;
+        }
+        rx8025 = kzalloc(sizeof(*rx8025), GFP_KERNEL);
+        if (!rx8025) {
+                dev_err(&adapter->dev, "failed to alloc memory\n");
+                err = -ENOMEM;
+                goto errout;
+        }
+        rx8025->client = client;
+        i2c_set_clientdata(client, rx8025);
+        INIT_WORK(&rx8025->work, rx8025_work);
+        err = rx8025_init_client(client, &need_reset);
+        if (err)
+                goto errout_free;
+        if (need_reset) {
+                struct rtc_time tm;
+                dev_info(&client->dev,
+                         "bad conditions detected, resetting date\n");
+                rtc_time_to_tm(0, &tm); /* 1970/1/1 */
+                rx8025_set_time(&client->dev, &tm);
+        }
+        rx8025->rtc = rtc_device_register(client->name, &client->dev,
+                                          &rx8025_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rx8025->rtc)) {
+                err = PTR_ERR(rx8025->rtc);
+                dev_err(&client->dev, "unable to register the class device\n");
+                goto errout_free;
+        }
+        if (client->irq > 0) {
+                dev_info(&client->dev, "IRQ %d supplied\n", client->irq);
+                err = request_irq(client->irq, rx8025_irq,
+                                  0, "rx8025", client);
+                if (err) {
+                        dev_err(&client->dev, "unable to request IRQ\n");
+                        goto errout_reg;
+                }
+        }
+        rx8025->rtc->irq_freq = 1;
+        rx8025->rtc->max_user_freq = 1;
+        err = rx8025_sysfs_register(&client->dev);
+        if (err)
+                goto errout_irq;
+        return 0;
+errout_irq:
+        if (client->irq > 0)
+                free_irq(client->irq, client);
+errout_reg:
+        rtc_device_unregister(rx8025->rtc);
+errout_free:
+        i2c_set_clientdata(client, NULL);
+        kfree(rx8025);
+errout:
+        dev_err(&adapter->dev, "probing for rx8025 failed\n");
+        return err;
+}
+static int __devexit rx8025_remove(struct i2c_client *client)
+{
+        struct rx8025_data *rx8025 = i2c_get_clientdata(client);
+        struct mutex *lock = &rx8025->rtc->ops_lock;
+        if (client->irq > 0) {
+                mutex_lock(lock);
+                rx8025->exiting = 1;
+                mutex_unlock(lock);
+                free_irq(client->irq, client);
+                flush_scheduled_work();
+        }
+        rx8025_sysfs_unregister(&client->dev);
+        rtc_device_unregister(rx8025->rtc);
+        i2c_set_clientdata(client, NULL);
+        kfree(rx8025);
+        return 0;
+}
+static struct i2c_driver rx8025_driver = {
+        .driver = {
+                .name = "rtc-rx8025",
+                .owner = THIS_MODULE,
+        },
+        .probe          = rx8025_probe,
+        .remove         = __devexit_p(rx8025_remove),
+        .id_table       = rx8025_id,
+};
+static int __init rx8025_init(void)
+{
+        return i2c_add_driver(&rx8025_driver);
+}
+static void __exit rx8025_exit(void)
+{
+        i2c_del_driver(&rx8025_driver);
+}
+MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>");
+MODULE_DESCRIPTION("RX-8025 SA/NB RTC driver");
+MODULE_LICENSE("GPL");
+module_init(rx8025_init);
+module_exit(rx8025_exit);
diff --git a/drivers/rtc/rtc-test.c b/drivers/rtc/rtc-test.c
index e478280ff628..51725f7755b0 100644
--- a/drivers/rtc/rtc-test.c
+++ b/drivers/rtc/rtc-test.c
@@ -93,7 +93,6 @@ static ssize_t test_irq_store(struct device *dev,
        struct rtc_device *rtc = platform_get_drvdata(plat_dev);
        retval = count;
-        local_irq_disable();
        if (strncmp(buf, "tick", 4) == 0)
                rtc_update_irq(rtc, 1, RTC_PF | RTC_IRQF);
        else if (strncmp(buf, "alarm", 5) == 0)
@@ -102,7 +101,6 @@ static ssize_t test_irq_store(struct device *dev,
                rtc_update_irq(rtc, 1, RTC_UF | RTC_IRQF);
        else
                retval = -EINVAL;
-        local_irq_enable();
        return retval;
 }
diff --git a/drivers/rtc/rtc-tx4939.c b/drivers/rtc/rtc-tx4939.c
index 4ee4857ff207..4a6ed1104fbb 100644
--- a/drivers/rtc/rtc-tx4939.c
+++ b/drivers/rtc/rtc-tx4939.c
@@ -261,10 +261,8 @@ static int __init tx4939_rtc_probe(struct platform_device *pdev)
        tx4939_rtc_cmd(pdata->rtcreg, TX4939_RTCCTL_COMMAND_NOP);
        if (devm_request_irq(&pdev->dev, irq, tx4939_rtc_interrupt,
-                             IRQF_DISABLED | IRQF_SHARED,
+                             IRQF_DISABLED, pdev->name, &pdev->dev) < 0)
-                             pdev->name, &pdev->dev) < 0) {
                return -EBUSY;
-        }
        rtc = rtc_device_register(pdev->name, &pdev->dev,
                                  &tx4939_rtc_ops, THIS_MODULE);
        if (IS_ERR(rtc))
diff --git a/drivers/s390/net/qeth_l2_main.c b/drivers/s390/net/qeth_l2_main.c
index 81d7f268418a..691cecd03b83 100644
--- a/drivers/s390/net/qeth_l2_main.c
+++ b/drivers/s390/net/qeth_l2_main.c
@@ -655,7 +655,7 @@ static void qeth_l2_set_multicast_list(struct net_device *dev)
        for (dm = dev->mc_list; dm; dm = dm->next)
                qeth_l2_add_mc(card, dm->da_addr, 0);
-        list_for_each_entry(ha, &dev->uc_list, list)
+        list_for_each_entry(ha, &dev->uc.list, list)
                qeth_l2_add_mc(card, ha->addr, 1);
        spin_unlock_bh(&card->mclock);
diff --git a/drivers/serial/sh-sci.c b/drivers/serial/sh-sci.c
index a4cf1079b312..66f52674ca0c 100644
--- a/drivers/serial/sh-sci.c
+++ b/drivers/serial/sh-sci.c
@@ -1332,44 +1332,46 @@ err_unreg:
        return ret;
 }
-static int sci_suspend(struct platform_device *dev, pm_message_t state)
+static int sci_suspend(struct device *dev)
 {
-        struct sh_sci_priv *priv = platform_get_drvdata(dev);
+        struct sh_sci_priv *priv = dev_get_drvdata(dev);
        struct sci_port *p;
        unsigned long flags;
        spin_lock_irqsave(&priv->lock, flags);
        list_for_each_entry(p, &priv->ports, node)
                uart_suspend_port(&sci_uart_driver, &p->port);
        spin_unlock_irqrestore(&priv->lock, flags);
        return 0;
 }
-static int sci_resume(struct platform_device *dev)
+static int sci_resume(struct device *dev)
 {
-        struct sh_sci_priv *priv = platform_get_drvdata(dev);
+        struct sh_sci_priv *priv = dev_get_drvdata(dev);
        struct sci_port *p;
        unsigned long flags;
        spin_lock_irqsave(&priv->lock, flags);
        list_for_each_entry(p, &priv->ports, node)
                uart_resume_port(&sci_uart_driver, &p->port);
        spin_unlock_irqrestore(&priv->lock, flags);
        return 0;
 }
+static struct dev_pm_ops sci_dev_pm_ops = {
+        .suspend        = sci_suspend,
+        .resume         = sci_resume,
+};
 static struct platform_driver sci_driver = {
        .probe          = sci_probe,
        .remove         = __devexit_p(sci_remove),
-        .suspend        = sci_suspend,
-        .resume         = sci_resume,
        .driver         = {
                .name   = "sh-sci",
                .owner  = THIS_MODULE,
+                .pm     = &sci_dev_pm_ops,
        },
 };
diff --git a/drivers/sh/intc.c b/drivers/sh/intc.c
index d687a9b93d03..3dd231a643b5 100644
--- a/drivers/sh/intc.c
+++ b/drivers/sh/intc.c
@@ -20,7 +20,6 @@
 #include <linux/module.h>
 #include <linux/io.h>
 #include <linux/interrupt.h>
-#include <linux/bootmem.h>
 #include <linux/sh_intc.h>
 #include <linux/sysdev.h>
 #include <linux/list.h>
@@ -675,7 +674,7 @@ void __init register_intc_controller(struct intc_desc *desc)
        unsigned int i, k, smp;
        struct intc_desc_int *d;
-        d = alloc_bootmem(sizeof(*d));
+        d = kzalloc(sizeof(*d), GFP_NOWAIT);
        INIT_LIST_HEAD(&d->list);
        list_add(&d->list, &intc_list);
@@ -687,9 +686,9 @@ void __init register_intc_controller(struct intc_desc *desc)
 #if defined(CONFIG_CPU_SH3) || defined(CONFIG_CPU_SH4A)
        d->nr_reg += desc->ack_regs ? desc->nr_ack_regs : 0;
 #endif
-        d->reg = alloc_bootmem(d->nr_reg * sizeof(*d->reg));
+        d->reg = kzalloc(d->nr_reg * sizeof(*d->reg), GFP_NOWAIT);
 #ifdef CONFIG_SMP
-        d->smp = alloc_bootmem(d->nr_reg * sizeof(*d->smp));
+        d->smp = kzalloc(d->nr_reg * sizeof(*d->smp), GFP_NOWAIT);
 #endif
        k = 0;
@@ -702,7 +701,7 @@ void __init register_intc_controller(struct intc_desc *desc)
        }
        if (desc->prio_regs) {
-                d->prio = alloc_bootmem(desc->nr_vectors * sizeof(*d->prio));
+                d->prio = kzalloc(desc->nr_vectors * sizeof(*d->prio), GFP_NOWAIT);
                for (i = 0; i < desc->nr_prio_regs; i++) {
                        smp = IS_SMP(desc->prio_regs[i]);
@@ -712,7 +711,7 @@ void __init register_intc_controller(struct intc_desc *desc)
        }
        if (desc->sense_regs) {
-                d->sense = alloc_bootmem(desc->nr_vectors * sizeof(*d->sense));
+                d->sense = kzalloc(desc->nr_vectors * sizeof(*d->sense), GFP_NOWAIT);
                for (i = 0; i < desc->nr_sense_regs; i++) {
                        k += save_reg(d, k, desc->sense_regs[i].reg, 0);
@@ -757,7 +756,7 @@ void __init register_intc_controller(struct intc_desc *desc)
                        vect2->enum_id = 0;
                        if (!intc_evt2irq_table)
-                                intc_evt2irq_table = alloc_bootmem(NR_IRQS);
+                                intc_evt2irq_table = kzalloc(NR_IRQS, GFP_NOWAIT);
                        if (!intc_evt2irq_table) {
                                pr_warning("intc: cannot allocate evt2irq!\n");
diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
index e8aae227b5e0..2c733c27db2f 100644
--- a/drivers/spi/Kconfig
+++ b/drivers/spi/Kconfig
@@ -139,17 +139,15 @@ config SPI_MPC52xx_PSC
          This enables using the Freescale MPC52xx Programmable Serial
          Controller in master SPI mode.
-config SPI_MPC83xx
+config SPI_MPC8xxx
-        tristate "Freescale MPC83xx/QUICC Engine SPI controller"
+        tristate "Freescale MPC8xxx SPI controller"
-        depends on (PPC_83xx || QUICC_ENGINE) && EXPERIMENTAL
+        depends on FSL_SOC
        help
-          This enables using the Freescale MPC83xx and QUICC Engine SPI
+          This enables using the Freescale MPC8xxx SPI controllers in master
-          controllers in master mode.
+          mode.
-          Note, this driver uniquely supports the SPI controller on the MPC83xx
+          This driver uses a simple set of shift registers for data (opposed
-          family of PowerPC processors, plus processors with QUICC Engine
+          to the CPM based descriptor model).
-          technology. This driver uses a simple set of shift registers for data
-          (opposed to the CPM based descriptor model).
 config SPI_OMAP_UWIRE
        tristate "OMAP1 MicroWire"
diff --git a/drivers/spi/Makefile b/drivers/spi/Makefile
index ecfadb180482..3de408d294ba 100644
--- a/drivers/spi/Makefile
+++ b/drivers/spi/Makefile
@@ -25,7 +25,7 @@ obj-$(CONFIG_SPI_OMAP24XX)		+= omap2_mcspi.o
 obj-$(CONFIG_SPI_ORION)                 += orion_spi.o
 obj-$(CONFIG_SPI_PL022)                 += amba-pl022.o
 obj-$(CONFIG_SPI_MPC52xx_PSC)           += mpc52xx_psc_spi.o
-obj-$(CONFIG_SPI_MPC83xx)               += spi_mpc83xx.o
+obj-$(CONFIG_SPI_MPC8xxx)               += spi_mpc8xxx.o
 obj-$(CONFIG_SPI_S3C24XX_GPIO)          += spi_s3c24xx_gpio.o
 obj-$(CONFIG_SPI_S3C24XX)               += spi_s3c24xx.o
 obj-$(CONFIG_SPI_TXX9)                  += spi_txx9.o
diff --git a/drivers/spi/atmel_spi.c b/drivers/spi/atmel_spi.c
index 12e443cc4ac9..f5b3fdbb1e27 100644
--- a/drivers/spi/atmel_spi.c
+++ b/drivers/spi/atmel_spi.c
@@ -530,9 +530,6 @@ atmel_spi_interrupt(int irq, void *dev_id)
        return ret;
 }
-/* the spi->mode bits understood by this driver: */
-#define MODEBITS (SPI_CPOL | SPI_CPHA | SPI_CS_HIGH)
 static int atmel_spi_setup(struct spi_device *spi)
 {
        struct atmel_spi        *as;
@@ -555,8 +552,6 @@ static int atmel_spi_setup(struct spi_device *spi)
                return -EINVAL;
        }
-        if (bits == 0)
-                bits = 8;
        if (bits < 8 || bits > 16) {
                dev_dbg(&spi->dev,
                                "setup: invalid bits_per_word %u (8 to 16)\n",
@@ -564,12 +559,6 @@ static int atmel_spi_setup(struct spi_device *spi)
                return -EINVAL;
        }
-        if (spi->mode & ~MODEBITS) {
-                dev_dbg(&spi->dev, "setup: unsupported mode bits %x\n",
-                        spi->mode & ~MODEBITS);
-                return -EINVAL;
-        }
        /* see notes above re chipselect */
        if (!atmel_spi_is_v2()
                        && spi->chip_select == 0
@@ -775,6 +764,9 @@ static int __init atmel_spi_probe(struct platform_device *pdev)
        if (!master)
                goto out_free;
+        /* the spi->mode bits understood by this driver: */
+        master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
        master->bus_num = pdev->id;
        master->num_chipselect = 4;
        master->setup = atmel_spi_setup;
diff --git a/drivers/spi/au1550_spi.c b/drivers/spi/au1550_spi.c
index b02f25c702fd..76cbc1a66598 100644
--- a/drivers/spi/au1550_spi.c
+++ b/drivers/spi/au1550_spi.c
@@ -284,27 +284,16 @@ static int au1550_spi_setupxfer(struct spi_device *spi, struct spi_transfer *t)
        return 0;
 }
-/* the spi->mode bits understood by this driver: */
-#define MODEBITS (SPI_CPOL | SPI_CPHA | SPI_CS_HIGH | SPI_LSB_FIRST)
 static int au1550_spi_setup(struct spi_device *spi)
 {
        struct au1550_spi *hw = spi_master_get_devdata(spi->master);
-        if (spi->bits_per_word == 0)
-                spi->bits_per_word = 8;
        if (spi->bits_per_word < 4 || spi->bits_per_word > 24) {
                dev_err(&spi->dev, "setup: invalid bits_per_word=%d\n",
                        spi->bits_per_word);
                return -EINVAL;
        }
-        if (spi->mode & ~MODEBITS) {
-                dev_dbg(&spi->dev, "setup: unsupported mode bits %x\n",
-                        spi->mode & ~MODEBITS);
-                return -EINVAL;
-        }
        if (spi->max_speed_hz == 0)
                spi->max_speed_hz = hw->freq_max;
        if (spi->max_speed_hz > hw->freq_max
@@ -781,6 +770,9 @@ static int __init au1550_spi_probe(struct platform_device *pdev)
                goto err_nomem;
        }
+        /* the spi->mode bits understood by this driver: */
+        master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH | SPI_LSB_FIRST;
        hw = spi_master_get_devdata(master);
        hw->master = spi_master_get(master);
diff --git a/drivers/spi/mpc52xx_psc_spi.c b/drivers/spi/mpc52xx_psc_spi.c
index e1901fdce774..1b74d5ca03f3 100644
--- a/drivers/spi/mpc52xx_psc_spi.c
+++ b/drivers/spi/mpc52xx_psc_spi.c
@@ -259,9 +259,6 @@ static void mpc52xx_psc_spi_work(struct work_struct *work)
        spin_unlock_irq(&mps->lock);
 }
-/* the spi->mode bits understood by this driver: */
-#define MODEBITS (SPI_CPOL | SPI_CPHA | SPI_CS_HIGH | SPI_LSB_FIRST)
 static int mpc52xx_psc_spi_setup(struct spi_device *spi)
 {
        struct mpc52xx_psc_spi *mps = spi_master_get_devdata(spi->master);
@@ -271,12 +268,6 @@ static int mpc52xx_psc_spi_setup(struct spi_device *spi)
        if (spi->bits_per_word%8)
                return -EINVAL;
-        if (spi->mode & ~MODEBITS) {
-                dev_dbg(&spi->dev, "setup: unsupported mode bits %x\n",
-                        spi->mode & ~MODEBITS);
-                return -EINVAL;
-        }
        if (!cs) {
                cs = kzalloc(sizeof *cs, GFP_KERNEL);
                if (!cs)
@@ -383,6 +374,9 @@ static int __init mpc52xx_psc_spi_do_probe(struct device *dev, u32 regaddr,
        dev_set_drvdata(dev, master);
        mps = spi_master_get_devdata(master);
+        /* the spi->mode bits understood by this driver: */
+        master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH | SPI_LSB_FIRST;
        mps->irq = irq;
        if (pdata == NULL) {
                dev_warn(dev, "probe called without platform data, no "
diff --git a/drivers/spi/omap2_mcspi.c b/drivers/spi/omap2_mcspi.c
index d6d0c5d241ce..eee4b6e0af2c 100644
--- a/drivers/spi/omap2_mcspi.c
+++ b/drivers/spi/omap2_mcspi.c
@@ -603,9 +603,6 @@ static int omap2_mcspi_request_dma(struct spi_device *spi)
        return 0;
 }
-/* the spi->mode bits understood by this driver: */
-#define MODEBITS (SPI_CPOL | SPI_CPHA | SPI_CS_HIGH)
 static int omap2_mcspi_setup(struct spi_device *spi)
 {
        int                     ret;
@@ -613,15 +610,7 @@ static int omap2_mcspi_setup(struct spi_device *spi)
        struct omap2_mcspi_dma  *mcspi_dma;
        struct omap2_mcspi_cs   *cs = spi->controller_state;
-        if (spi->mode & ~MODEBITS) {
+        if (spi->bits_per_word < 4 || spi->bits_per_word > 32) {
-                dev_dbg(&spi->dev, "setup: unsupported mode bits %x\n",
-                        spi->mode & ~MODEBITS);
-                return -EINVAL;
-        }
-        if (spi->bits_per_word == 0)
-                spi->bits_per_word = 8;
-        else if (spi->bits_per_word < 4 || spi->bits_per_word > 32) {
                dev_dbg(&spi->dev, "setup: unsupported %d bit words\n",
                        spi->bits_per_word);
                return -EINVAL;
@@ -984,6 +973,9 @@ static int __init omap2_mcspi_probe(struct platform_device *pdev)
                return -ENOMEM;
        }
+        /* the spi->mode bits understood by this driver: */
+        master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
        if (pdev->id != -1)
                master->bus_num = pdev->id;
diff --git a/drivers/spi/omap_uwire.c b/drivers/spi/omap_uwire.c
index fe8b9ac0ccef..aa90ddb37066 100644
--- a/drivers/spi/omap_uwire.c
+++ b/drivers/spi/omap_uwire.c
@@ -339,8 +339,6 @@ static int uwire_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
        bits = spi->bits_per_word;
        if (t != NULL && t->bits_per_word)
                bits = t->bits_per_word;
-        if (!bits)
-                bits = 8;
        if (bits > 16) {
                pr_debug("%s: wordsize %d?\n", dev_name(&spi->dev), bits);
@@ -449,19 +447,10 @@ done:
        return status;
 }
-/* the spi->mode bits understood by this driver: */
-#define MODEBITS (SPI_CPOL | SPI_CPHA | SPI_CS_HIGH)
 static int uwire_setup(struct spi_device *spi)
 {
        struct uwire_state *ust = spi->controller_state;
-        if (spi->mode & ~MODEBITS) {
-                dev_dbg(&spi->dev, "setup: unsupported mode bits %x\n",
-                        spi->mode & ~MODEBITS);
-                return -EINVAL;
-        }
        if (ust == NULL) {
                ust = kzalloc(sizeof(*ust), GFP_KERNEL);
                if (ust == NULL)
@@ -522,6 +511,9 @@ static int __init uwire_probe(struct platform_device *pdev)
        uwire_write_reg(UWIRE_SR3, 1);
+        /* the spi->mode bits understood by this driver: */
+        master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
        master->bus_num = 2;    /* "official" */
        master->num_chipselect = 4;
        master->setup = uwire_setup;
diff --git a/drivers/spi/orion_spi.c b/drivers/spi/orion_spi.c
index c8b0babdc2a6..3aea50da7b29 100644
--- a/drivers/spi/orion_spi.c
+++ b/drivers/spi/orion_spi.c
@@ -358,20 +358,11 @@ static int orion_spi_setup(struct spi_device *spi)
        orion_spi = spi_master_get_devdata(spi->master);
-        if (spi->mode) {
-                dev_err(&spi->dev, "setup: unsupported mode bits %x\n",
-                        spi->mode);
-                return -EINVAL;
-        }
        /* Fix ac timing if required.   */
        if (orion_spi->spi_info->enable_clock_fix)
                orion_spi_setbits(orion_spi, ORION_SPI_IF_CONFIG_REG,
                                  (1 << 14));
-        if (spi->bits_per_word == 0)
-                spi->bits_per_word = 8;
        if ((spi->max_speed_hz == 0)
                        || (spi->max_speed_hz > orion_spi->max_speed))
                spi->max_speed_hz = orion_spi->max_speed;
@@ -476,6 +467,9 @@ static int __init orion_spi_probe(struct platform_device *pdev)
        if (pdev->id != -1)
                master->bus_num = pdev->id;
+        /* we support only mode 0, and no options */
+        master->mode_bits = 0;
        master->setup = orion_spi_setup;
        master->transfer = orion_spi_transfer;
        master->num_chipselect = ORION_NUM_CHIPSELECTS;
diff --git a/drivers/spi/pxa2xx_spi.c b/drivers/spi/pxa2xx_spi.c
index 3f3c08c6ba4e..d949dbf1141f 100644
--- a/drivers/spi/pxa2xx_spi.c
+++ b/drivers/spi/pxa2xx_spi.c
@@ -1185,9 +1185,6 @@ static int transfer(struct spi_device *spi, struct spi_message *msg)
        return 0;
 }
-/* the spi->mode bits understood by this driver: */
-#define MODEBITS (SPI_CPOL | SPI_CPHA)
 static int setup_cs(struct spi_device *spi, struct chip_data *chip,
                    struct pxa2xx_spi_chip *chip_info)
 {
@@ -1236,9 +1233,6 @@ static int setup(struct spi_device *spi)
        uint tx_thres = TX_THRESH_DFLT;
        uint rx_thres = RX_THRESH_DFLT;
-        if (!spi->bits_per_word)
-                spi->bits_per_word = 8;
        if (drv_data->ssp_type != PXA25x_SSP
                && (spi->bits_per_word < 4 || spi->bits_per_word > 32)) {
                dev_err(&spi->dev, "failed setup: ssp_type=%d, bits/wrd=%d "
@@ -1255,12 +1249,6 @@ static int setup(struct spi_device *spi)
                return -EINVAL;
        }
-        if (spi->mode & ~MODEBITS) {
-                dev_dbg(&spi->dev, "setup: unsupported mode bits %x\n",
-                        spi->mode & ~MODEBITS);
-                return -EINVAL;
-        }
        /* Only alloc on first setup */
        chip = spi_get_ctldata(spi);
        if (!chip) {
@@ -1328,18 +1316,14 @@ static int setup(struct spi_device *spi)
        /* NOTE:  PXA25x_SSP _could_ use external clocking ... */
        if (drv_data->ssp_type != PXA25x_SSP)
-                dev_dbg(&spi->dev, "%d bits/word, %ld Hz, mode %d, %s\n",
+                dev_dbg(&spi->dev, "%ld Hz actual, %s\n",
-                                spi->bits_per_word,
                                clk_get_rate(ssp->clk)
                                        / (1 + ((chip->cr0 & SSCR0_SCR) >> 8)),
-                                spi->mode & 0x3,
                                chip->enable_dma ? "DMA" : "PIO");
        else
-                dev_dbg(&spi->dev, "%d bits/word, %ld Hz, mode %d, %s\n",
+                dev_dbg(&spi->dev, "%ld Hz actual, %s\n",
-                                spi->bits_per_word,
                                clk_get_rate(ssp->clk) / 2
                                        / (1 + ((chip->cr0 & SSCR0_SCR) >> 8)),
-                                spi->mode & 0x3,
                                chip->enable_dma ? "DMA" : "PIO");
        if (spi->bits_per_word <= 8) {
@@ -1500,6 +1484,9 @@ static int __init pxa2xx_spi_probe(struct platform_device *pdev)
        drv_data->pdev = pdev;
        drv_data->ssp = ssp;
+        /* the spi->mode bits understood by this driver: */
+        master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
        master->bus_num = pdev->id;
        master->num_chipselect = platform_info->num_chipselect;
        master->dma_alignment = DMA_ALIGNMENT;
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index 8eba98c8ed1e..70845ccd85c3 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -265,7 +265,7 @@ int spi_add_device(struct spi_device *spi)
         * normally rely on the device being setup.  Devices
         * using SPI_CS_HIGH can't coexist well otherwise...
         */
-        status = spi->master->setup(spi);
+        status = spi_setup(spi);
        if (status < 0) {
                dev_err(dev, "can't %s %s, status %d\n",
                                "setup", dev_name(&spi->dev), status);
@@ -583,6 +583,70 @@ EXPORT_SYMBOL_GPL(spi_busnum_to_master);
 /*-------------------------------------------------------------------------*/
+/* Core methods for SPI master protocol drivers.  Some of the
+ * other core methods are currently defined as inline functions.
+ */
+/**
+ * spi_setup - setup SPI mode and clock rate
+ * @spi: the device whose settings are being modified
+ * Context: can sleep, and no requests are queued to the device
+ *
+ * SPI protocol drivers may need to update the transfer mode if the
+ * device doesn't work with its default.  They may likewise need
+ * to update clock rates or word sizes from initial values.  This function
+ * changes those settings, and must be called from a context that can sleep.
+ * Except for SPI_CS_HIGH, which takes effect immediately, the changes take
+ * effect the next time the device is selected and data is transferred to
+ * or from it.  When this function returns, the spi device is deselected.
+ *
+ * Note that this call will fail if the protocol driver specifies an option
+ * that the underlying controller or its driver does not support.  For
+ * example, not all hardware supports wire transfers using nine bit words,
+ * LSB-first wire encoding, or active-high chipselects.
+ */
+int spi_setup(struct spi_device *spi)
+{
+        unsigned        bad_bits;
+        int             status;
+        /* help drivers fail *cleanly* when they need options
+         * that aren't supported with their current master
+         */
+        bad_bits = spi->mode & ~spi->master->mode_bits;
+        if (bad_bits) {
+                dev_dbg(&spi->dev, "setup: unsupported mode bits %x\n",
+                        bad_bits);
+                return -EINVAL;
+        }
+        if (!spi->bits_per_word)
+                spi->bits_per_word = 8;
+        status = spi->master->setup(spi);
+        dev_dbg(&spi->dev, "setup mode %d, %s%s%s%s"
+                                "%u bits/w, %u Hz max --> %d\n",
+                        (int) (spi->mode & (SPI_CPOL | SPI_CPHA)),
+                        (spi->mode & SPI_CS_HIGH) ? "cs_high, " : "",
+                        (spi->mode & SPI_LSB_FIRST) ? "lsb, " : "",
+                        (spi->mode & SPI_3WIRE) ? "3wire, " : "",
+                        (spi->mode & SPI_LOOP) ? "loopback, " : "",
+                        spi->bits_per_word, spi->max_speed_hz,
+                        status);
+        return status;
+}
+EXPORT_SYMBOL_GPL(spi_setup);
+/*-------------------------------------------------------------------------*/
+/* Utility methods for SPI master protocol drivers, layered on
+ * top of the core.  Some other utility methods are defined as
+ * inline functions.
+ */
 static void spi_complete(void *arg)
 {
        complete(arg);
@@ -636,8 +700,8 @@ static u8	*buf;
 * @spi: device with which data will be exchanged
 * @txbuf: data to be written (need not be dma-safe)
 * @n_tx: size of txbuf, in bytes
- * @rxbuf: buffer into which data will be read
+ * @rxbuf: buffer into which data will be read (need not be dma-safe)
- * @n_rx: size of rxbuf, in bytes (need not be dma-safe)
+ * @n_rx: size of rxbuf, in bytes
 * Context: can sleep
 *
 * This performs a half duplex MicroWire style transaction with the
diff --git a/drivers/spi/spi_bfin5xx.c b/drivers/spi/spi_bfin5xx.c
index 011c5bddba6a..73e24ef5a2f9 100644
--- a/drivers/spi/spi_bfin5xx.c
+++ b/drivers/spi/spi_bfin5xx.c
@@ -169,7 +169,7 @@ static int bfin_spi_flush(struct driver_data *drv_data)
        unsigned long limit = loops_per_jiffy << 1;
        /* wait for stop and clear stat */
-        while (!(read_STAT(drv_data) & BIT_STAT_SPIF) && limit--)
+        while (!(read_STAT(drv_data) & BIT_STAT_SPIF) && --limit)
                cpu_relax();
        write_STAT(drv_data, BIT_STAT_CLR);
@@ -1010,16 +1010,6 @@ static int bfin_spi_setup(struct spi_device *spi)
        struct driver_data *drv_data = spi_master_get_devdata(spi->master);
        int ret;
-        /* Abort device setup if requested features are not supported */
-        if (spi->mode & ~(SPI_CPOL | SPI_CPHA | SPI_LSB_FIRST)) {
-                dev_err(&spi->dev, "requested mode not fully supported\n");
-                return -EINVAL;
-        }
-        /* Zero (the default) here means 8 bits */
-        if (!spi->bits_per_word)
-                spi->bits_per_word = 8;
        if (spi->bits_per_word != 8 && spi->bits_per_word != 16)
                return -EINVAL;
@@ -1287,6 +1277,9 @@ static int __init bfin_spi_probe(struct platform_device *pdev)
        drv_data->pdev = pdev;
        drv_data->pin_req = platform_info->pin_req;
+        /* the spi->mode bits supported by this driver: */
+        master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_LSB_FIRST;
        master->bus_num = pdev->id;
        master->num_chipselect = platform_info->num_chipselect;
        master->cleanup = bfin_spi_cleanup;
diff --git a/drivers/spi/spi_bitbang.c b/drivers/spi/spi_bitbang.c
index 85e61f451218..2a5abc08e857 100644
--- a/drivers/spi/spi_bitbang.c
+++ b/drivers/spi/spi_bitbang.c
@@ -188,12 +188,6 @@ int spi_bitbang_setup(struct spi_device *spi)
        bitbang = spi_master_get_devdata(spi->master);
-        /* Bitbangers can support SPI_CS_HIGH, SPI_3WIRE, and so on;
-         * add those to master->flags, and provide the other support.
-         */
-        if ((spi->mode & ~(SPI_CPOL|SPI_CPHA|bitbang->flags)) != 0)
-                return -EINVAL;
        if (!cs) {
                cs = kzalloc(sizeof *cs, GFP_KERNEL);
                if (!cs)
@@ -201,9 +195,6 @@ int spi_bitbang_setup(struct spi_device *spi)
                spi->controller_state = cs;
        }
-        if (!spi->bits_per_word)
-                spi->bits_per_word = 8;
        /* per-word shift register access, in hardware or bitbanging */
        cs->txrx_word = bitbang->txrx_word[spi->mode & (SPI_CPOL|SPI_CPHA)];
        if (!cs->txrx_word)
@@ -213,9 +204,7 @@ int spi_bitbang_setup(struct spi_device *spi)
        if (retval < 0)
                return retval;
-        dev_dbg(&spi->dev, "%s, mode %d, %u bits/w, %u nsec/bit\n",
+        dev_dbg(&spi->dev, "%s, %u nsec/bit\n", __func__, 2 * cs->nsecs);
-                        __func__, spi->mode & (SPI_CPOL | SPI_CPHA),
-                        spi->bits_per_word, 2 * cs->nsecs);
        /* NOTE we _need_ to call chipselect() early, ideally with adapter
         * setup, unless the hardware defaults cooperate to avoid confusion
@@ -457,6 +446,9 @@ int spi_bitbang_start(struct spi_bitbang *bitbang)
        spin_lock_init(&bitbang->lock);
        INIT_LIST_HEAD(&bitbang->queue);
+        if (!bitbang->master->mode_bits)
+                bitbang->master->mode_bits = SPI_CPOL | SPI_CPHA | bitbang->flags;
        if (!bitbang->master->transfer)
                bitbang->master->transfer = spi_bitbang_transfer;
        if (!bitbang->txrx_bufs) {
diff --git a/drivers/spi/spi_imx.c b/drivers/spi/spi_imx.c
index 0671aeef5792..c195e45f7f35 100644
--- a/drivers/spi/spi_imx.c
+++ b/drivers/spi/spi_imx.c
@@ -1171,9 +1171,6 @@ msg_rejected:
        return -EINVAL;
 }
-/* the spi->mode bits understood by this driver: */
-#define MODEBITS (SPI_CPOL | SPI_CPHA | SPI_CS_HIGH)
 /* On first setup bad values must free chip_data memory since will cause
   spi_new_device to fail. Bad value setup from protocol driver are simply not
   applied and notified to the calling driver. */
@@ -1186,12 +1183,6 @@ static int setup(struct spi_device *spi)
        u32 tmp;
        int status = 0;
-        if (spi->mode & ~MODEBITS) {
-                dev_dbg(&spi->dev, "setup: unsupported mode bits %x\n",
-                        spi->mode & ~MODEBITS);
-                return -EINVAL;
-        }
        /* Get controller data */
        chip_info = spi->controller_data;
@@ -1286,10 +1277,7 @@ static int setup(struct spi_device *spi)
        /* SPI word width */
        tmp = spi->bits_per_word;
-        if (tmp == 0) {
+        if (tmp > 16) {
-                tmp = 8;
-                spi->bits_per_word = 8;
-        } else if (tmp > 16) {
                status = -EINVAL;
                dev_err(&spi->dev,
                        "setup - "
@@ -1481,6 +1469,9 @@ static int __init spi_imx_probe(struct platform_device *pdev)
        drv_data->master_info = platform_info;
        drv_data->pdev = pdev;
+        /* the spi->mode bits understood by this driver: */
+        master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
        master->bus_num = pdev->id;
        master->num_chipselect = platform_info->num_chipselect;
        master->dma_alignment = DMA_ALIGNMENT;
diff --git a/drivers/spi/spi_mpc83xx.c b/drivers/spi/spi_mpc8xxx.c
index a32ccb44065e..0fd0ec4d3a7d 100644
--- a/drivers/spi/spi_mpc83xx.c
+++ b/drivers/spi/spi_mpc8xxx.c
@@ -1,5 +1,5 @@
 /*
- * MPC83xx SPI controller driver.
+ * MPC8xxx SPI controller driver.
 *
 * Maintainer: Kumar Gala
 *
@@ -14,8 +14,10 @@
 #include <linux/init.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
+#include <linux/bug.h>
 #include <linux/errno.h>
 #include <linux/err.h>
+#include <linux/io.h>
 #include <linux/completion.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
@@ -33,10 +35,9 @@
 #include <sysdev/fsl_soc.h>
 #include <asm/irq.h>
-#include <asm/io.h>
 /* SPI Controller registers */
-struct mpc83xx_spi_reg {
+struct mpc8xxx_spi_reg {
        u8 res1[0x20];
        __be32 mode;
        __be32 event;
@@ -75,16 +76,16 @@ struct mpc83xx_spi_reg {
 #define SPIM_NF         0x00000100      /* Not full */
 /* SPI Controller driver's private data. */
-struct mpc83xx_spi {
+struct mpc8xxx_spi {
-        struct mpc83xx_spi_reg __iomem *base;
+        struct mpc8xxx_spi_reg __iomem *base;
        /* rx & tx bufs from the spi_transfer */
        const void *tx;
        void *rx;
        /* functions to deal with different sized buffers */
-        void (*get_rx) (u32 rx_data, struct mpc83xx_spi *);
+        void (*get_rx) (u32 rx_data, struct mpc8xxx_spi *);
-        u32(*get_tx) (struct mpc83xx_spi *);
+        u32(*get_tx) (struct mpc8xxx_spi *);
        unsigned int count;
        unsigned int irq;
@@ -97,8 +98,6 @@ struct mpc83xx_spi {
        bool qe_mode;
-        u8 busy;
        struct workqueue_struct *workqueue;
        struct work_struct work;
@@ -108,44 +107,44 @@ struct mpc83xx_spi {
        struct completion done;
 };
-struct spi_mpc83xx_cs {
+struct spi_mpc8xxx_cs {
        /* functions to deal with different sized buffers */
-        void (*get_rx) (u32 rx_data, struct mpc83xx_spi *);
+        void (*get_rx) (u32 rx_data, struct mpc8xxx_spi *);
-        u32 (*get_tx) (struct mpc83xx_spi *);
+        u32 (*get_tx) (struct mpc8xxx_spi *);
        u32 rx_shift;           /* RX data reg shift when in qe mode */
        u32 tx_shift;           /* TX data reg shift when in qe mode */
        u32 hw_mode;            /* Holds HW mode register settings */
 };
-static inline void mpc83xx_spi_write_reg(__be32 __iomem * reg, u32 val)
+static inline void mpc8xxx_spi_write_reg(__be32 __iomem *reg, u32 val)
 {
        out_be32(reg, val);
 }
-static inline u32 mpc83xx_spi_read_reg(__be32 __iomem * reg)
+static inline u32 mpc8xxx_spi_read_reg(__be32 __iomem *reg)
 {
        return in_be32(reg);
 }
 #define MPC83XX_SPI_RX_BUF(type)                                          \
 static                                                                    \
-void mpc83xx_spi_rx_buf_##type(u32 data, struct mpc83xx_spi *mpc83xx_spi) \
+void mpc8xxx_spi_rx_buf_##type(u32 data, struct mpc8xxx_spi *mpc8xxx_spi) \
 {                                                                         \
-        type * rx = mpc83xx_spi->rx;                                      \
+        type *rx = mpc8xxx_spi->rx;                                       \
-        *rx++ = (type)(data >> mpc83xx_spi->rx_shift);                    \
+        *rx++ = (type)(data >> mpc8xxx_spi->rx_shift);                    \
-        mpc83xx_spi->rx = rx;                                             \
+        mpc8xxx_spi->rx = rx;                                             \
 }
 #define MPC83XX_SPI_TX_BUF(type)                                \
 static                                                          \
-u32 mpc83xx_spi_tx_buf_##type(struct mpc83xx_spi *mpc83xx_spi)  \
+u32 mpc8xxx_spi_tx_buf_##type(struct mpc8xxx_spi *mpc8xxx_spi)  \
 {                                                               \
        u32 data;                                               \
-        const type * tx = mpc83xx_spi->tx;                      \
+        const type *tx = mpc8xxx_spi->tx;                       \
        if (!tx)                                                \
                return 0;                                       \
-        data = *tx++ << mpc83xx_spi->tx_shift;                  \
+        data = *tx++ << mpc8xxx_spi->tx_shift;                  \
-        mpc83xx_spi->tx = tx;                                   \
+        mpc8xxx_spi->tx = tx;                                   \
        return data;                                            \
 }
@@ -156,12 +155,12 @@ MPC83XX_SPI_TX_BUF(u8)
 MPC83XX_SPI_TX_BUF(u16)
 MPC83XX_SPI_TX_BUF(u32)
-static void mpc83xx_spi_chipselect(struct spi_device *spi, int value)
+static void mpc8xxx_spi_chipselect(struct spi_device *spi, int value)
 {
-        struct mpc83xx_spi *mpc83xx_spi = spi_master_get_devdata(spi->master);
+        struct mpc8xxx_spi *mpc8xxx_spi = spi_master_get_devdata(spi->master);
        struct fsl_spi_platform_data *pdata = spi->dev.parent->platform_data;
        bool pol = spi->mode & SPI_CS_HIGH;
-        struct spi_mpc83xx_cs   *cs = spi->controller_state;
+        struct spi_mpc8xxx_cs   *cs = spi->controller_state;
        if (value == BITBANG_CS_INACTIVE) {
                if (pdata->cs_control)
@@ -169,16 +168,16 @@ static void mpc83xx_spi_chipselect(struct spi_device *spi, int value)
        }
        if (value == BITBANG_CS_ACTIVE) {
-                u32 regval = mpc83xx_spi_read_reg(&mpc83xx_spi->base->mode);
+                u32 regval = mpc8xxx_spi_read_reg(&mpc8xxx_spi->base->mode);
-                mpc83xx_spi->rx_shift = cs->rx_shift;
+                mpc8xxx_spi->rx_shift = cs->rx_shift;
-                mpc83xx_spi->tx_shift = cs->tx_shift;
+                mpc8xxx_spi->tx_shift = cs->tx_shift;
-                mpc83xx_spi->get_rx = cs->get_rx;
+                mpc8xxx_spi->get_rx = cs->get_rx;
-                mpc83xx_spi->get_tx = cs->get_tx;
+                mpc8xxx_spi->get_tx = cs->get_tx;
                if (cs->hw_mode != regval) {
                        unsigned long flags;
-                        __be32 __iomem *mode = &mpc83xx_spi->base->mode;
+                        __be32 __iomem *mode = &mpc8xxx_spi->base->mode;
                        regval = cs->hw_mode;
                        /* Turn off IRQs locally to minimize time that
@@ -186,8 +185,8 @@ static void mpc83xx_spi_chipselect(struct spi_device *spi, int value)
                         */
                        local_irq_save(flags);
                        /* Turn off SPI unit prior changing mode */
-                        mpc83xx_spi_write_reg(mode, regval & ~SPMODE_ENABLE);
+                        mpc8xxx_spi_write_reg(mode, regval & ~SPMODE_ENABLE);
-                        mpc83xx_spi_write_reg(mode, regval);
+                        mpc8xxx_spi_write_reg(mode, regval);
                        local_irq_restore(flags);
                }
                if (pdata->cs_control)
@@ -196,15 +195,15 @@ static void mpc83xx_spi_chipselect(struct spi_device *spi, int value)
 }
 static
-int mpc83xx_spi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
+int mpc8xxx_spi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
 {
-        struct mpc83xx_spi *mpc83xx_spi;
+        struct mpc8xxx_spi *mpc8xxx_spi;
        u32 regval;
        u8 bits_per_word, pm;
        u32 hz;
-        struct spi_mpc83xx_cs   *cs = spi->controller_state;
+        struct spi_mpc8xxx_cs   *cs = spi->controller_state;
-        mpc83xx_spi = spi_master_get_devdata(spi->master);
+        mpc8xxx_spi = spi_master_get_devdata(spi->master);
        if (t) {
                bits_per_word = t->bits_per_word;
@@ -229,26 +228,26 @@ int mpc83xx_spi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
        cs->rx_shift = 0;
        cs->tx_shift = 0;
        if (bits_per_word <= 8) {
-                cs->get_rx = mpc83xx_spi_rx_buf_u8;
+                cs->get_rx = mpc8xxx_spi_rx_buf_u8;
-                cs->get_tx = mpc83xx_spi_tx_buf_u8;
+                cs->get_tx = mpc8xxx_spi_tx_buf_u8;
-                if (mpc83xx_spi->qe_mode) {
+                if (mpc8xxx_spi->qe_mode) {
                        cs->rx_shift = 16;
                        cs->tx_shift = 24;
                }
        } else if (bits_per_word <= 16) {
-                cs->get_rx = mpc83xx_spi_rx_buf_u16;
+                cs->get_rx = mpc8xxx_spi_rx_buf_u16;
-                cs->get_tx = mpc83xx_spi_tx_buf_u16;
+                cs->get_tx = mpc8xxx_spi_tx_buf_u16;
-                if (mpc83xx_spi->qe_mode) {
+                if (mpc8xxx_spi->qe_mode) {
                        cs->rx_shift = 16;
                        cs->tx_shift = 16;
                }
        } else if (bits_per_word <= 32) {
-                cs->get_rx = mpc83xx_spi_rx_buf_u32;
+                cs->get_rx = mpc8xxx_spi_rx_buf_u32;
-                cs->get_tx = mpc83xx_spi_tx_buf_u32;
+                cs->get_tx = mpc8xxx_spi_tx_buf_u32;
        } else
                return -EINVAL;
-        if (mpc83xx_spi->qe_mode && spi->mode & SPI_LSB_FIRST) {
+        if (mpc8xxx_spi->qe_mode && spi->mode & SPI_LSB_FIRST) {
                cs->tx_shift = 0;
                if (bits_per_word <= 8)
                        cs->rx_shift = 8;
@@ -256,10 +255,10 @@ int mpc83xx_spi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
                        cs->rx_shift = 0;
        }
-        mpc83xx_spi->rx_shift = cs->rx_shift;
+        mpc8xxx_spi->rx_shift = cs->rx_shift;
-        mpc83xx_spi->tx_shift = cs->tx_shift;
+        mpc8xxx_spi->tx_shift = cs->tx_shift;
-        mpc83xx_spi->get_rx = cs->get_rx;
+        mpc8xxx_spi->get_rx = cs->get_rx;
-        mpc83xx_spi->get_tx = cs->get_tx;
+        mpc8xxx_spi->get_tx = cs->get_tx;
        if (bits_per_word == 32)
                bits_per_word = 0;
@@ -272,25 +271,25 @@ int mpc83xx_spi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
        cs->hw_mode |= SPMODE_LEN(bits_per_word);
-        if ((mpc83xx_spi->spibrg / hz) > 64) {
+        if ((mpc8xxx_spi->spibrg / hz) > 64) {
                cs->hw_mode |= SPMODE_DIV16;
-                pm = mpc83xx_spi->spibrg / (hz * 64);
+                pm = mpc8xxx_spi->spibrg / (hz * 64);
-                if (pm > 16) {
-                        dev_err(&spi->dev, "Requested speed is too "
+                WARN_ONCE(pm > 16, "%s: Requested speed is too low: %d Hz. "
-                                "low: %d Hz. Will use %d Hz instead.\n",
+                          "Will use %d Hz instead.\n", dev_name(&spi->dev),
-                                hz, mpc83xx_spi->spibrg / 1024);
+                          hz, mpc8xxx_spi->spibrg / 1024);
+                if (pm > 16)
                        pm = 16;
-                }
        } else
-                pm = mpc83xx_spi->spibrg / (hz * 4);
+                pm = mpc8xxx_spi->spibrg / (hz * 4);
        if (pm)
                pm--;
        cs->hw_mode |= SPMODE_PM(pm);
-        regval =  mpc83xx_spi_read_reg(&mpc83xx_spi->base->mode);
+        regval =  mpc8xxx_spi_read_reg(&mpc8xxx_spi->base->mode);
        if (cs->hw_mode != regval) {
                unsigned long flags;
-                __be32 __iomem *mode = &mpc83xx_spi->base->mode;
+                __be32 __iomem *mode = &mpc8xxx_spi->base->mode;
                regval = cs->hw_mode;
                /* Turn off IRQs locally to minimize time
@@ -298,22 +297,22 @@ int mpc83xx_spi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
                 */
                local_irq_save(flags);
                /* Turn off SPI unit prior changing mode */
-                mpc83xx_spi_write_reg(mode, regval & ~SPMODE_ENABLE);
+                mpc8xxx_spi_write_reg(mode, regval & ~SPMODE_ENABLE);
-                mpc83xx_spi_write_reg(mode, regval);
+                mpc8xxx_spi_write_reg(mode, regval);
                local_irq_restore(flags);
        }
        return 0;
 }
-static int mpc83xx_spi_bufs(struct spi_device *spi, struct spi_transfer *t)
+static int mpc8xxx_spi_bufs(struct spi_device *spi, struct spi_transfer *t)
 {
-        struct mpc83xx_spi *mpc83xx_spi;
+        struct mpc8xxx_spi *mpc8xxx_spi;
        u32 word, len, bits_per_word;
-        mpc83xx_spi = spi_master_get_devdata(spi->master);
+        mpc8xxx_spi = spi_master_get_devdata(spi->master);
-        mpc83xx_spi->tx = t->tx_buf;
+        mpc8xxx_spi->tx = t->tx_buf;
-        mpc83xx_spi->rx = t->rx_buf;
+        mpc8xxx_spi->rx = t->rx_buf;
        bits_per_word = spi->bits_per_word;
        if (t->bits_per_word)
                bits_per_word = t->bits_per_word;
@@ -330,111 +329,106 @@ static int mpc83xx_spi_bufs(struct spi_device *spi, struct spi_transfer *t)
                        return -EINVAL;
                len /= 2;
        }
-        mpc83xx_spi->count = len;
+        mpc8xxx_spi->count = len;
-        INIT_COMPLETION(mpc83xx_spi->done);
+        INIT_COMPLETION(mpc8xxx_spi->done);
        /* enable rx ints */
-        mpc83xx_spi_write_reg(&mpc83xx_spi->base->mask, SPIM_NE);
+        mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->mask, SPIM_NE);
        /* transmit word */
-        word = mpc83xx_spi->get_tx(mpc83xx_spi);
+        word = mpc8xxx_spi->get_tx(mpc8xxx_spi);
-        mpc83xx_spi_write_reg(&mpc83xx_spi->base->transmit, word);
+        mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->transmit, word);
-        wait_for_completion(&mpc83xx_spi->done);
+        wait_for_completion(&mpc8xxx_spi->done);
        /* disable rx ints */
-        mpc83xx_spi_write_reg(&mpc83xx_spi->base->mask, 0);
+        mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->mask, 0);
-        return mpc83xx_spi->count;
+        return mpc8xxx_spi->count;
 }
-static void mpc83xx_spi_work(struct work_struct *work)
+static void mpc8xxx_spi_do_one_msg(struct spi_message *m)
 {
-        struct mpc83xx_spi *mpc83xx_spi =
+        struct spi_device *spi = m->spi;
-                container_of(work, struct mpc83xx_spi, work);
+        struct spi_transfer *t;
+        unsigned int cs_change;
-        spin_lock_irq(&mpc83xx_spi->lock);
+        const int nsecs = 50;
-        mpc83xx_spi->busy = 1;
+        int status;
-        while (!list_empty(&mpc83xx_spi->queue)) {
-                struct spi_message *m;
+        cs_change = 1;
-                struct spi_device *spi;
+        status = 0;
-                struct spi_transfer *t = NULL;
+        list_for_each_entry(t, &m->transfers, transfer_list) {
-                unsigned cs_change;
+                if (t->bits_per_word || t->speed_hz) {
-                int status, nsecs = 50;
+                        /* Don't allow changes if CS is active */
+                        status = -EINVAL;
-                m = container_of(mpc83xx_spi->queue.next,
-                                struct spi_message, queue);
-                list_del_init(&m->queue);
-                spin_unlock_irq(&mpc83xx_spi->lock);
-                spi = m->spi;
-                cs_change = 1;
-                status = 0;
-                list_for_each_entry(t, &m->transfers, transfer_list) {
-                        if (t->bits_per_word || t->speed_hz) {
-                                /* Don't allow changes if CS is active */
-                                status = -EINVAL;
-                                if (cs_change)
-                                        status = mpc83xx_spi_setup_transfer(spi, t);
-                                if (status < 0)
-                                        break;
-                        }
                        if (cs_change)
-                                mpc83xx_spi_chipselect(spi, BITBANG_CS_ACTIVE);
+                                status = mpc8xxx_spi_setup_transfer(spi, t);
-                        cs_change = t->cs_change;
+                        if (status < 0)
-                        if (t->len)
-                                status = mpc83xx_spi_bufs(spi, t);
-                        if (status) {
-                                status = -EMSGSIZE;
                                break;
-                        }
+                }
-                        m->actual_length += t->len;
-                        if (t->delay_usecs)
-                                udelay(t->delay_usecs);
-                        if (cs_change) {
+                if (cs_change) {
-                                ndelay(nsecs);
+                        mpc8xxx_spi_chipselect(spi, BITBANG_CS_ACTIVE);
-                                mpc83xx_spi_chipselect(spi, BITBANG_CS_INACTIVE);
+                        ndelay(nsecs);
-                                ndelay(nsecs);
+                }
-                        }
+                cs_change = t->cs_change;
+                if (t->len)
+                        status = mpc8xxx_spi_bufs(spi, t);
+                if (status) {
+                        status = -EMSGSIZE;
+                        break;
                }
+                m->actual_length += t->len;
-                m->status = status;
+                if (t->delay_usecs)
-                m->complete(m->context);
+                        udelay(t->delay_usecs);
-                if (status || !cs_change) {
+                if (cs_change) {
+                        ndelay(nsecs);
+                        mpc8xxx_spi_chipselect(spi, BITBANG_CS_INACTIVE);
                        ndelay(nsecs);
-                        mpc83xx_spi_chipselect(spi, BITBANG_CS_INACTIVE);
                }
+        }
-                mpc83xx_spi_setup_transfer(spi, NULL);
+        m->status = status;
+        m->complete(m->context);
-                spin_lock_irq(&mpc83xx_spi->lock);
+        if (status || !cs_change) {
+                ndelay(nsecs);
+                mpc8xxx_spi_chipselect(spi, BITBANG_CS_INACTIVE);
        }
-        mpc83xx_spi->busy = 0;
-        spin_unlock_irq(&mpc83xx_spi->lock);
+        mpc8xxx_spi_setup_transfer(spi, NULL);
 }
-/* the spi->mode bits understood by this driver: */
+static void mpc8xxx_spi_work(struct work_struct *work)
-#define MODEBITS        (SPI_CPOL | SPI_CPHA | SPI_CS_HIGH \
+{
-                        | SPI_LSB_FIRST | SPI_LOOP)
+        struct mpc8xxx_spi *mpc8xxx_spi = container_of(work, struct mpc8xxx_spi,
+                                                       work);
+        spin_lock_irq(&mpc8xxx_spi->lock);
+        while (!list_empty(&mpc8xxx_spi->queue)) {
+                struct spi_message *m = container_of(mpc8xxx_spi->queue.next,
+                                                   struct spi_message, queue);
+                list_del_init(&m->queue);
+                spin_unlock_irq(&mpc8xxx_spi->lock);
+                mpc8xxx_spi_do_one_msg(m);
+                spin_lock_irq(&mpc8xxx_spi->lock);
+        }
+        spin_unlock_irq(&mpc8xxx_spi->lock);
+}
-static int mpc83xx_spi_setup(struct spi_device *spi)
+static int mpc8xxx_spi_setup(struct spi_device *spi)
 {
-        struct mpc83xx_spi *mpc83xx_spi;
+        struct mpc8xxx_spi *mpc8xxx_spi;
        int retval;
        u32 hw_mode;
-        struct spi_mpc83xx_cs   *cs = spi->controller_state;
+        struct spi_mpc8xxx_cs   *cs = spi->controller_state;
-        if (spi->mode & ~MODEBITS) {
-                dev_dbg(&spi->dev, "setup: unsupported mode bits %x\n",
-                        spi->mode & ~MODEBITS);
-                return -EINVAL;
-        }
        if (!spi->max_speed_hz)
                return -EINVAL;
@@ -445,13 +439,10 @@ static int mpc83xx_spi_setup(struct spi_device *spi)
                        return -ENOMEM;
                spi->controller_state = cs;
        }
-        mpc83xx_spi = spi_master_get_devdata(spi->master);
+        mpc8xxx_spi = spi_master_get_devdata(spi->master);
-        if (!spi->bits_per_word)
-                spi->bits_per_word = 8;
        hw_mode = cs->hw_mode; /* Save orginal settings */
-        cs->hw_mode = mpc83xx_spi_read_reg(&mpc83xx_spi->base->mode);
+        cs->hw_mode = mpc8xxx_spi_read_reg(&mpc8xxx_spi->base->mode);
        /* mask out bits we are going to set */
        cs->hw_mode &= ~(SPMODE_CP_BEGIN_EDGECLK | SPMODE_CI_INACTIVEHIGH
                         | SPMODE_REV | SPMODE_LOOP);
@@ -465,45 +456,29 @@ static int mpc83xx_spi_setup(struct spi_device *spi)
        if (spi->mode & SPI_LOOP)
                cs->hw_mode |= SPMODE_LOOP;
-        retval = mpc83xx_spi_setup_transfer(spi, NULL);
+        retval = mpc8xxx_spi_setup_transfer(spi, NULL);
        if (retval < 0) {
                cs->hw_mode = hw_mode; /* Restore settings */
                return retval;
        }
-        dev_dbg(&spi->dev, "%s, mode %d, %u bits/w, %u Hz\n",
-                __func__, spi->mode & (SPI_CPOL | SPI_CPHA),
-                spi->bits_per_word, spi->max_speed_hz);
-#if 0 /* Don't think this is needed */
-        /* NOTE we _need_ to call chipselect() early, ideally with adapter
-         * setup, unless the hardware defaults cooperate to avoid confusion
-         * between normal (active low) and inverted chipselects.
-         */
-        /* deselect chip (low or high) */
-        spin_lock(&mpc83xx_spi->lock);
-        if (!mpc83xx_spi->busy)
-                mpc83xx_spi_chipselect(spi, BITBANG_CS_INACTIVE);
-        spin_unlock(&mpc83xx_spi->lock);
-#endif
        return 0;
 }
-static irqreturn_t mpc83xx_spi_irq(s32 irq, void *context_data)
+static irqreturn_t mpc8xxx_spi_irq(s32 irq, void *context_data)
 {
-        struct mpc83xx_spi *mpc83xx_spi = context_data;
+        struct mpc8xxx_spi *mpc8xxx_spi = context_data;
        u32 event;
        irqreturn_t ret = IRQ_NONE;
        /* Get interrupt events(tx/rx) */
-        event = mpc83xx_spi_read_reg(&mpc83xx_spi->base->event);
+        event = mpc8xxx_spi_read_reg(&mpc8xxx_spi->base->event);
        /* We need handle RX first */
        if (event & SPIE_NE) {
-                u32 rx_data = mpc83xx_spi_read_reg(&mpc83xx_spi->base->receive);
+                u32 rx_data = mpc8xxx_spi_read_reg(&mpc8xxx_spi->base->receive);
-                if (mpc83xx_spi->rx)
+                if (mpc8xxx_spi->rx)
-                        mpc83xx_spi->get_rx(rx_data, mpc83xx_spi);
+                        mpc8xxx_spi->get_rx(rx_data, mpc8xxx_spi);
                ret = IRQ_HANDLED;
        }
@@ -511,56 +486,56 @@ static irqreturn_t mpc83xx_spi_irq(s32 irq, void *context_data)
        if ((event & SPIE_NF) == 0)
                /* spin until TX is done */
                while (((event =
-                         mpc83xx_spi_read_reg(&mpc83xx_spi->base->event)) &
+                         mpc8xxx_spi_read_reg(&mpc8xxx_spi->base->event)) &
                                                SPIE_NF) == 0)
-                         cpu_relax();
+                        cpu_relax();
-        mpc83xx_spi->count -= 1;
+        mpc8xxx_spi->count -= 1;
-        if (mpc83xx_spi->count) {
+        if (mpc8xxx_spi->count) {
-                u32 word = mpc83xx_spi->get_tx(mpc83xx_spi);
+                u32 word = mpc8xxx_spi->get_tx(mpc8xxx_spi);
-                mpc83xx_spi_write_reg(&mpc83xx_spi->base->transmit, word);
+                mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->transmit, word);
        } else {
-                complete(&mpc83xx_spi->done);
+                complete(&mpc8xxx_spi->done);
        }
        /* Clear the events */
-        mpc83xx_spi_write_reg(&mpc83xx_spi->base->event, event);
+        mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->event, event);
        return ret;
 }
-static int mpc83xx_spi_transfer(struct spi_device *spi,
+static int mpc8xxx_spi_transfer(struct spi_device *spi,
                                struct spi_message *m)
 {
-        struct mpc83xx_spi *mpc83xx_spi = spi_master_get_devdata(spi->master);
+        struct mpc8xxx_spi *mpc8xxx_spi = spi_master_get_devdata(spi->master);
        unsigned long flags;
        m->actual_length = 0;
        m->status = -EINPROGRESS;
-        spin_lock_irqsave(&mpc83xx_spi->lock, flags);
+        spin_lock_irqsave(&mpc8xxx_spi->lock, flags);
-        list_add_tail(&m->queue, &mpc83xx_spi->queue);
+        list_add_tail(&m->queue, &mpc8xxx_spi->queue);
-        queue_work(mpc83xx_spi->workqueue, &mpc83xx_spi->work);
+        queue_work(mpc8xxx_spi->workqueue, &mpc8xxx_spi->work);
-        spin_unlock_irqrestore(&mpc83xx_spi->lock, flags);
+        spin_unlock_irqrestore(&mpc8xxx_spi->lock, flags);
        return 0;
 }
-static void mpc83xx_spi_cleanup(struct spi_device *spi)
+static void mpc8xxx_spi_cleanup(struct spi_device *spi)
 {
        kfree(spi->controller_state);
 }
 static struct spi_master * __devinit
-mpc83xx_spi_probe(struct device *dev, struct resource *mem, unsigned int irq)
+mpc8xxx_spi_probe(struct device *dev, struct resource *mem, unsigned int irq)
 {
        struct fsl_spi_platform_data *pdata = dev->platform_data;
        struct spi_master *master;
-        struct mpc83xx_spi *mpc83xx_spi;
+        struct mpc8xxx_spi *mpc8xxx_spi;
        u32 regval;
        int ret = 0;
-        master = spi_alloc_master(dev, sizeof(struct mpc83xx_spi));
+        master = spi_alloc_master(dev, sizeof(struct mpc8xxx_spi));
        if (master == NULL) {
                ret = -ENOMEM;
                goto err;
@@ -568,36 +543,40 @@ mpc83xx_spi_probe(struct device *dev, struct resource *mem, unsigned int irq)
        dev_set_drvdata(dev, master);
-        master->setup = mpc83xx_spi_setup;
+        /* the spi->mode bits understood by this driver: */
-        master->transfer = mpc83xx_spi_transfer;
+        master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH
-        master->cleanup = mpc83xx_spi_cleanup;
+                        | SPI_LSB_FIRST | SPI_LOOP;
-        mpc83xx_spi = spi_master_get_devdata(master);
+        master->setup = mpc8xxx_spi_setup;
-        mpc83xx_spi->qe_mode = pdata->qe_mode;
+        master->transfer = mpc8xxx_spi_transfer;
-        mpc83xx_spi->get_rx = mpc83xx_spi_rx_buf_u8;
+        master->cleanup = mpc8xxx_spi_cleanup;
-        mpc83xx_spi->get_tx = mpc83xx_spi_tx_buf_u8;
-        mpc83xx_spi->spibrg = pdata->sysclk;
+        mpc8xxx_spi = spi_master_get_devdata(master);
+        mpc8xxx_spi->qe_mode = pdata->qe_mode;
-        mpc83xx_spi->rx_shift = 0;
+        mpc8xxx_spi->get_rx = mpc8xxx_spi_rx_buf_u8;
-        mpc83xx_spi->tx_shift = 0;
+        mpc8xxx_spi->get_tx = mpc8xxx_spi_tx_buf_u8;
-        if (mpc83xx_spi->qe_mode) {
+        mpc8xxx_spi->spibrg = pdata->sysclk;
-                mpc83xx_spi->rx_shift = 16;
-                mpc83xx_spi->tx_shift = 24;
+        mpc8xxx_spi->rx_shift = 0;
+        mpc8xxx_spi->tx_shift = 0;
+        if (mpc8xxx_spi->qe_mode) {
+                mpc8xxx_spi->rx_shift = 16;
+                mpc8xxx_spi->tx_shift = 24;
        }
-        init_completion(&mpc83xx_spi->done);
+        init_completion(&mpc8xxx_spi->done);
-        mpc83xx_spi->base = ioremap(mem->start, mem->end - mem->start + 1);
+        mpc8xxx_spi->base = ioremap(mem->start, mem->end - mem->start + 1);
-        if (mpc83xx_spi->base == NULL) {
+        if (mpc8xxx_spi->base == NULL) {
                ret = -ENOMEM;
                goto put_master;
        }
-        mpc83xx_spi->irq = irq;
+        mpc8xxx_spi->irq = irq;
        /* Register for SPI Interrupt */
-        ret = request_irq(mpc83xx_spi->irq, mpc83xx_spi_irq,
+        ret = request_irq(mpc8xxx_spi->irq, mpc8xxx_spi_irq,
-                          0, "mpc83xx_spi", mpc83xx_spi);
+                          0, "mpc8xxx_spi", mpc8xxx_spi);
        if (ret != 0)
                goto unmap_io;
@@ -606,25 +585,25 @@ mpc83xx_spi_probe(struct device *dev, struct resource *mem, unsigned int irq)
        master->num_chipselect = pdata->max_chipselect;
        /* SPI controller initializations */
-        mpc83xx_spi_write_reg(&mpc83xx_spi->base->mode, 0);
+        mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->mode, 0);
-        mpc83xx_spi_write_reg(&mpc83xx_spi->base->mask, 0);
+        mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->mask, 0);
-        mpc83xx_spi_write_reg(&mpc83xx_spi->base->command, 0);
+        mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->command, 0);
-        mpc83xx_spi_write_reg(&mpc83xx_spi->base->event, 0xffffffff);
+        mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->event, 0xffffffff);
        /* Enable SPI interface */
        regval = pdata->initial_spmode | SPMODE_INIT_VAL | SPMODE_ENABLE;
        if (pdata->qe_mode)
                regval |= SPMODE_OP;
-        mpc83xx_spi_write_reg(&mpc83xx_spi->base->mode, regval);
+        mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->mode, regval);
-        spin_lock_init(&mpc83xx_spi->lock);
+        spin_lock_init(&mpc8xxx_spi->lock);
-        init_completion(&mpc83xx_spi->done);
+        init_completion(&mpc8xxx_spi->done);
-        INIT_WORK(&mpc83xx_spi->work, mpc83xx_spi_work);
+        INIT_WORK(&mpc8xxx_spi->work, mpc8xxx_spi_work);
-        INIT_LIST_HEAD(&mpc83xx_spi->queue);
+        INIT_LIST_HEAD(&mpc8xxx_spi->queue);
-        mpc83xx_spi->workqueue = create_singlethread_workqueue(
+        mpc8xxx_spi->workqueue = create_singlethread_workqueue(
                dev_name(master->dev.parent));
-        if (mpc83xx_spi->workqueue == NULL) {
+        if (mpc8xxx_spi->workqueue == NULL) {
                ret = -EBUSY;
                goto free_irq;
        }
@@ -634,57 +613,57 @@ mpc83xx_spi_probe(struct device *dev, struct resource *mem, unsigned int irq)
                goto unreg_master;
        printk(KERN_INFO
-               "%s: MPC83xx SPI Controller driver at 0x%p (irq = %d)\n",
+               "%s: MPC8xxx SPI Controller driver at 0x%p (irq = %d)\n",
-               dev_name(dev), mpc83xx_spi->base, mpc83xx_spi->irq);
+               dev_name(dev), mpc8xxx_spi->base, mpc8xxx_spi->irq);
        return master;
 unreg_master:
-        destroy_workqueue(mpc83xx_spi->workqueue);
+        destroy_workqueue(mpc8xxx_spi->workqueue);
 free_irq:
-        free_irq(mpc83xx_spi->irq, mpc83xx_spi);
+        free_irq(mpc8xxx_spi->irq, mpc8xxx_spi);
 unmap_io:
-        iounmap(mpc83xx_spi->base);
+        iounmap(mpc8xxx_spi->base);
 put_master:
        spi_master_put(master);
 err:
        return ERR_PTR(ret);
 }
-static int __devexit mpc83xx_spi_remove(struct device *dev)
+static int __devexit mpc8xxx_spi_remove(struct device *dev)
 {
-        struct mpc83xx_spi *mpc83xx_spi;
+        struct mpc8xxx_spi *mpc8xxx_spi;
        struct spi_master *master;
        master = dev_get_drvdata(dev);
-        mpc83xx_spi = spi_master_get_devdata(master);
+        mpc8xxx_spi = spi_master_get_devdata(master);
-        flush_workqueue(mpc83xx_spi->workqueue);
+        flush_workqueue(mpc8xxx_spi->workqueue);
-        destroy_workqueue(mpc83xx_spi->workqueue);
+        destroy_workqueue(mpc8xxx_spi->workqueue);
        spi_unregister_master(master);
-        free_irq(mpc83xx_spi->irq, mpc83xx_spi);
+        free_irq(mpc8xxx_spi->irq, mpc8xxx_spi);
-        iounmap(mpc83xx_spi->base);
+        iounmap(mpc8xxx_spi->base);
        return 0;
 }
-struct mpc83xx_spi_probe_info {
+struct mpc8xxx_spi_probe_info {
        struct fsl_spi_platform_data pdata;
        int *gpios;
        bool *alow_flags;
 };
-static struct mpc83xx_spi_probe_info *
+static struct mpc8xxx_spi_probe_info *
 to_of_pinfo(struct fsl_spi_platform_data *pdata)
 {
-        return container_of(pdata, struct mpc83xx_spi_probe_info, pdata);
+        return container_of(pdata, struct mpc8xxx_spi_probe_info, pdata);
 }
-static void mpc83xx_spi_cs_control(struct spi_device *spi, bool on)
+static void mpc8xxx_spi_cs_control(struct spi_device *spi, bool on)
 {
        struct device *dev = spi->dev.parent;
-        struct mpc83xx_spi_probe_info *pinfo = to_of_pinfo(dev->platform_data);
+        struct mpc8xxx_spi_probe_info *pinfo = to_of_pinfo(dev->platform_data);
        u16 cs = spi->chip_select;
        int gpio = pinfo->gpios[cs];
        bool alow = pinfo->alow_flags[cs];
@@ -692,11 +671,11 @@ static void mpc83xx_spi_cs_control(struct spi_device *spi, bool on)
        gpio_set_value(gpio, on ^ alow);
 }
-static int of_mpc83xx_spi_get_chipselects(struct device *dev)
+static int of_mpc8xxx_spi_get_chipselects(struct device *dev)
 {
        struct device_node *np = dev_archdata_get_node(&dev->archdata);
        struct fsl_spi_platform_data *pdata = dev->platform_data;
-        struct mpc83xx_spi_probe_info *pinfo = to_of_pinfo(pdata);
+        struct mpc8xxx_spi_probe_info *pinfo = to_of_pinfo(pdata);
        unsigned int ngpios;
        int i = 0;
        int ret;
@@ -752,7 +731,7 @@ static int of_mpc83xx_spi_get_chipselects(struct device *dev)
        }
        pdata->max_chipselect = ngpios;
-        pdata->cs_control = mpc83xx_spi_cs_control;
+        pdata->cs_control = mpc8xxx_spi_cs_control;
        return 0;
@@ -771,10 +750,10 @@ err_alloc_flags:
        return ret;
 }
-static int of_mpc83xx_spi_free_chipselects(struct device *dev)
+static int of_mpc8xxx_spi_free_chipselects(struct device *dev)
 {
        struct fsl_spi_platform_data *pdata = dev->platform_data;
-        struct mpc83xx_spi_probe_info *pinfo = to_of_pinfo(pdata);
+        struct mpc8xxx_spi_probe_info *pinfo = to_of_pinfo(pdata);
        int i;
        if (!pinfo->gpios)
@@ -790,12 +769,12 @@ static int of_mpc83xx_spi_free_chipselects(struct device *dev)
        return 0;
 }
-static int __devinit of_mpc83xx_spi_probe(struct of_device *ofdev,
+static int __devinit of_mpc8xxx_spi_probe(struct of_device *ofdev,
                                          const struct of_device_id *ofid)
 {
        struct device *dev = &ofdev->dev;
        struct device_node *np = ofdev->node;
-        struct mpc83xx_spi_probe_info *pinfo;
+        struct mpc8xxx_spi_probe_info *pinfo;
        struct fsl_spi_platform_data *pdata;
        struct spi_master *master;
        struct resource mem;
@@ -827,7 +806,7 @@ static int __devinit of_mpc83xx_spi_probe(struct of_device *ofdev,
        if (prop && !strcmp(prop, "cpu-qe"))
                pdata->qe_mode = 1;
-        ret = of_mpc83xx_spi_get_chipselects(dev);
+        ret = of_mpc8xxx_spi_get_chipselects(dev);
        if (ret)
                goto err;
@@ -841,7 +820,7 @@ static int __devinit of_mpc83xx_spi_probe(struct of_device *ofdev,
                goto err;
        }
-        master = mpc83xx_spi_probe(dev, &mem, irq.start);
+        master = mpc8xxx_spi_probe(dev, &mem, irq.start);
        if (IS_ERR(master)) {
                ret = PTR_ERR(master);
                goto err;
@@ -852,34 +831,34 @@ static int __devinit of_mpc83xx_spi_probe(struct of_device *ofdev,
        return 0;
 err:
-        of_mpc83xx_spi_free_chipselects(dev);
+        of_mpc8xxx_spi_free_chipselects(dev);
 err_clk:
        kfree(pinfo);
        return ret;
 }
-static int __devexit of_mpc83xx_spi_remove(struct of_device *ofdev)
+static int __devexit of_mpc8xxx_spi_remove(struct of_device *ofdev)
 {
        int ret;
-        ret = mpc83xx_spi_remove(&ofdev->dev);
+        ret = mpc8xxx_spi_remove(&ofdev->dev);
        if (ret)
                return ret;
-        of_mpc83xx_spi_free_chipselects(&ofdev->dev);
+        of_mpc8xxx_spi_free_chipselects(&ofdev->dev);
        return 0;
 }
-static const struct of_device_id of_mpc83xx_spi_match[] = {
+static const struct of_device_id of_mpc8xxx_spi_match[] = {
        { .compatible = "fsl,spi" },
        {},
 };
-MODULE_DEVICE_TABLE(of, of_mpc83xx_spi_match);
+MODULE_DEVICE_TABLE(of, of_mpc8xxx_spi_match);
-static struct of_platform_driver of_mpc83xx_spi_driver = {
+static struct of_platform_driver of_mpc8xxx_spi_driver = {
-        .name           = "mpc83xx_spi",
+        .name           = "mpc8xxx_spi",
-        .match_table    = of_mpc83xx_spi_match,
+        .match_table    = of_mpc8xxx_spi_match,
-        .probe          = of_mpc83xx_spi_probe,
+        .probe          = of_mpc8xxx_spi_probe,
-        .remove         = __devexit_p(of_mpc83xx_spi_remove),
+        .remove         = __devexit_p(of_mpc8xxx_spi_remove),
 };
 #ifdef CONFIG_MPC832x_RDB
@@ -890,7 +869,7 @@ static struct of_platform_driver of_mpc83xx_spi_driver = {
 * tree can work with OpenFirmware driver. But for now we support old trees
 * as well.
 */
-static int __devinit plat_mpc83xx_spi_probe(struct platform_device *pdev)
+static int __devinit plat_mpc8xxx_spi_probe(struct platform_device *pdev)
 {
        struct resource *mem;
        unsigned int irq;
@@ -907,23 +886,23 @@ static int __devinit plat_mpc83xx_spi_probe(struct platform_device *pdev)
        if (!irq)
                return -EINVAL;
-        master = mpc83xx_spi_probe(&pdev->dev, mem, irq);
+        master = mpc8xxx_spi_probe(&pdev->dev, mem, irq);
        if (IS_ERR(master))
                return PTR_ERR(master);
        return 0;
 }
-static int __devexit plat_mpc83xx_spi_remove(struct platform_device *pdev)
+static int __devexit plat_mpc8xxx_spi_remove(struct platform_device *pdev)
 {
-        return mpc83xx_spi_remove(&pdev->dev);
+        return mpc8xxx_spi_remove(&pdev->dev);
 }
-MODULE_ALIAS("platform:mpc83xx_spi");
+MODULE_ALIAS("platform:mpc8xxx_spi");
-static struct platform_driver mpc83xx_spi_driver = {
+static struct platform_driver mpc8xxx_spi_driver = {
-        .probe = plat_mpc83xx_spi_probe,
+        .probe = plat_mpc8xxx_spi_probe,
-        .remove = __exit_p(plat_mpc83xx_spi_remove),
+        .remove = __exit_p(plat_mpc8xxx_spi_remove),
        .driver = {
-                .name = "mpc83xx_spi",
+                .name = "mpc8xxx_spi",
                .owner = THIS_MODULE,
        },
 };
@@ -932,35 +911,35 @@ static bool legacy_driver_failed;
 static void __init legacy_driver_register(void)
 {
-        legacy_driver_failed = platform_driver_register(&mpc83xx_spi_driver);
+        legacy_driver_failed = platform_driver_register(&mpc8xxx_spi_driver);
 }
 static void __exit legacy_driver_unregister(void)
 {
        if (legacy_driver_failed)
                return;
-        platform_driver_unregister(&mpc83xx_spi_driver);
+        platform_driver_unregister(&mpc8xxx_spi_driver);
 }
 #else
 static void __init legacy_driver_register(void) {}
 static void __exit legacy_driver_unregister(void) {}
 #endif /* CONFIG_MPC832x_RDB */
-static int __init mpc83xx_spi_init(void)
+static int __init mpc8xxx_spi_init(void)
 {
        legacy_driver_register();
-        return of_register_platform_driver(&of_mpc83xx_spi_driver);
+        return of_register_platform_driver(&of_mpc8xxx_spi_driver);
 }
-static void __exit mpc83xx_spi_exit(void)
+static void __exit mpc8xxx_spi_exit(void)
 {
-        of_unregister_platform_driver(&of_mpc83xx_spi_driver);
+        of_unregister_platform_driver(&of_mpc8xxx_spi_driver);
        legacy_driver_unregister();
 }
-module_init(mpc83xx_spi_init);
+module_init(mpc8xxx_spi_init);
-module_exit(mpc83xx_spi_exit);
+module_exit(mpc8xxx_spi_exit);
 MODULE_AUTHOR("Kumar Gala");
-MODULE_DESCRIPTION("Simple MPC83xx SPI Driver");
+MODULE_DESCRIPTION("Simple MPC8xxx SPI Driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/spi/spi_s3c24xx.c b/drivers/spi/spi_s3c24xx.c
index b3ebc1d0f85f..e0d44af4745a 100644
--- a/drivers/spi/spi_s3c24xx.c
+++ b/drivers/spi/spi_s3c24xx.c
@@ -146,32 +146,16 @@ static int s3c24xx_spi_setupxfer(struct spi_device *spi,
        return 0;
 }
-/* the spi->mode bits understood by this driver: */
-#define MODEBITS (SPI_CPOL | SPI_CPHA | SPI_CS_HIGH)
 static int s3c24xx_spi_setup(struct spi_device *spi)
 {
        int ret;
-        if (!spi->bits_per_word)
-                spi->bits_per_word = 8;
-        if (spi->mode & ~MODEBITS) {
-                dev_dbg(&spi->dev, "setup: unsupported mode bits %x\n",
-                        spi->mode & ~MODEBITS);
-                return -EINVAL;
-        }
        ret = s3c24xx_spi_setupxfer(spi, NULL);
        if (ret < 0) {
                dev_err(&spi->dev, "setupxfer returned %d\n", ret);
                return ret;
        }
-        dev_dbg(&spi->dev, "%s: mode %d, %u bpw, %d hz\n",
-                __func__, spi->mode, spi->bits_per_word,
-                spi->max_speed_hz);
        return 0;
 }
@@ -290,6 +274,9 @@ static int __init s3c24xx_spi_probe(struct platform_device *pdev)
        /* setup the master state. */
+        /* the spi->mode bits understood by this driver: */
+        master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
        master->num_chipselect = hw->pdata->num_cs;
        master->bus_num = pdata->bus_num;
diff --git a/drivers/spi/spi_txx9.c b/drivers/spi/spi_txx9.c
index 29cbb065618a..96057de133ad 100644
--- a/drivers/spi/spi_txx9.c
+++ b/drivers/spi/spi_txx9.c
@@ -110,23 +110,17 @@ static void txx9spi_cs_func(struct spi_device *spi, struct txx9spi *c,
        ndelay(cs_delay);       /* CS Setup Time / CS Recovery Time */
 }
-/* the spi->mode bits understood by this driver: */
-#define MODEBITS        (SPI_CS_HIGH|SPI_CPOL|SPI_CPHA)
 static int txx9spi_setup(struct spi_device *spi)
 {
        struct txx9spi *c = spi_master_get_devdata(spi->master);
        u8 bits_per_word;
-        if (spi->mode & ~MODEBITS)
-                return -EINVAL;
        if (!spi->max_speed_hz
                        || spi->max_speed_hz > c->max_speed_hz
                        || spi->max_speed_hz < c->min_speed_hz)
                return -EINVAL;
-        bits_per_word = spi->bits_per_word ? : 8;
+        bits_per_word = spi->bits_per_word;
        if (bits_per_word != 8 && bits_per_word != 16)
                return -EINVAL;
@@ -414,6 +408,9 @@ static int __init txx9spi_probe(struct platform_device *dev)
                 (unsigned long long)res->start, irq,
                 (c->baseclk + 500000) / 1000000);
+        /* the spi->mode bits understood by this driver: */
+        master->mode_bits = SPI_CS_HIGH | SPI_CPOL | SPI_CPHA;
        master->bus_num = dev->id;
        master->setup = txx9spi_setup;
        master->transfer = txx9spi_transfer;
diff --git a/drivers/spi/xilinx_spi.c b/drivers/spi/xilinx_spi.c
index 494d3f756e29..46b8c5c2f45e 100644
--- a/drivers/spi/xilinx_spi.c
+++ b/drivers/spi/xilinx_spi.c
@@ -158,9 +158,6 @@ static int xilinx_spi_setup_transfer(struct spi_device *spi,
        return 0;
 }
-/* the spi->mode bits understood by this driver: */
-#define MODEBITS (SPI_CPOL | SPI_CPHA)
 static int xilinx_spi_setup(struct spi_device *spi)
 {
        struct spi_bitbang *bitbang;
@@ -170,22 +167,10 @@ static int xilinx_spi_setup(struct spi_device *spi)
        xspi = spi_master_get_devdata(spi->master);
        bitbang = &xspi->bitbang;
-        if (!spi->bits_per_word)
-                spi->bits_per_word = 8;
-        if (spi->mode & ~MODEBITS) {
-                dev_err(&spi->dev, "%s, unsupported mode bits %x\n",
-                        __func__, spi->mode & ~MODEBITS);
-                return -EINVAL;
-        }
        retval = xilinx_spi_setup_transfer(spi, NULL);
        if (retval < 0)
                return retval;
-        dev_dbg(&spi->dev, "%s, mode %d, %u bits/w, %u nsec/bit\n",
-                __func__, spi->mode & MODEBITS, spi->bits_per_word, 0);
        return 0;
 }
@@ -333,6 +318,9 @@ static int __init xilinx_spi_of_probe(struct of_device *ofdev,
                goto put_master;
        }
+        /* the spi->mode bits understood by this driver: */
+        master->mode_bits = SPI_CPOL | SPI_CPHA;
        xspi = spi_master_get_devdata(master);
        xspi->bitbang.master = spi_master_get(master);
        xspi->bitbang.chipselect = xilinx_spi_chipselect;
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index 932ffdbf86d9..d6d65ef85f54 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -1122,12 +1122,14 @@ config FB_INTEL
        select FB_CFB_FILLRECT
        select FB_CFB_COPYAREA
        select FB_CFB_IMAGEBLIT
-        select FB_BOOT_VESA_SUPPORT
+        select FB_BOOT_VESA_SUPPORT if FB_INTEL = y
        help
          This driver supports the on-board graphics built in to the Intel
          830M/845G/852GM/855GM/865G/915G/915GM/945G/945GM/965G/965GM chipsets.
          Say Y if you have and plan to use such a board.
+          To make FB_INTELFB=Y work you need to say AGP_INTEL=y too.
          To compile this driver as a module, choose M here: the
          module will be called intelfb.
@@ -1460,7 +1462,7 @@ config FB_SIS
        select FB_CFB_FILLRECT
        select FB_CFB_COPYAREA
        select FB_CFB_IMAGEBLIT
-        select FB_BOOT_VESA_SUPPORT
+        select FB_BOOT_VESA_SUPPORT if FB_SIS = y
        help
          This is the frame buffer device driver for the SiS 300, 315, 330
          and 340 series as well as XGI V3XT, V5, V8, Z7 graphics chipsets.
diff --git a/drivers/w1/masters/w1-gpio.c b/drivers/w1/masters/w1-gpio.c
index a411702413d6..6f8866d6a905 100644
--- a/drivers/w1/masters/w1-gpio.c
+++ b/drivers/w1/masters/w1-gpio.c
@@ -74,6 +74,9 @@ static int __init w1_gpio_probe(struct platform_device *pdev)
        if (err)
                goto free_gpio;
+        if (pdata->enable_external_pullup)
+                pdata->enable_external_pullup(1);
        platform_set_drvdata(pdev, master);
        return 0;
@@ -91,6 +94,9 @@ static int __exit w1_gpio_remove(struct platform_device *pdev)
        struct w1_bus_master *master = platform_get_drvdata(pdev);
        struct w1_gpio_platform_data *pdata = pdev->dev.platform_data;
+        if (pdata->enable_external_pullup)
+                pdata->enable_external_pullup(0);
        w1_remove_master_device(master);
        gpio_free(pdata->pin);
        kfree(master);
@@ -98,12 +104,41 @@ static int __exit w1_gpio_remove(struct platform_device *pdev)
        return 0;
 }
+#ifdef CONFIG_PM
+static int w1_gpio_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct w1_gpio_platform_data *pdata = pdev->dev.platform_data;
+        if (pdata->enable_external_pullup)
+                pdata->enable_external_pullup(0);
+        return 0;
+}
+static int w1_gpio_resume(struct platform_device *pdev)
+{
+        struct w1_gpio_platform_data *pdata = pdev->dev.platform_data;
+        if (pdata->enable_external_pullup)
+                pdata->enable_external_pullup(1);
+        return 0;
+}
+#else
+#define w1_gpio_suspend NULL
+#define w1_gpio_resume  NULL
+#endif
 static struct platform_driver w1_gpio_driver = {
        .driver = {
                .name   = "w1-gpio",
                .owner  = THIS_MODULE,
        },
        .remove = __exit_p(w1_gpio_remove),
+        .suspend = w1_gpio_suspend,
+        .resume = w1_gpio_resume,
 };
 static int __init w1_gpio_init(void)
diff --git a/drivers/watchdog/alim7101_wdt.c b/drivers/watchdog/alim7101_wdt.c
index 90f98df5f106..f90afdb1b255 100644
--- a/drivers/watchdog/alim7101_wdt.c
+++ b/drivers/watchdog/alim7101_wdt.c
@@ -322,7 +322,8 @@ static int wdt_notify_sys(struct notifier_block *this,
                 * watchdog on reboot with no heartbeat
                 */
                wdt_change(WDT_ENABLE);
-                printk(KERN_INFO PFX "Watchdog timer is now enabled with no heartbeat - should reboot in ~1 second.\n");
+                printk(KERN_INFO PFX "Watchdog timer is now enabled "
+                        "with no heartbeat - should reboot in ~1 second.\n");
        }
        return NOTIFY_DONE;
 }
@@ -374,12 +375,17 @@ static int __init alim7101_wdt_init(void)
        pci_dev_put(ali1543_south);
        if ((tmp & 0x1e) == 0x00) {
                if (!use_gpio) {
-                        printk(KERN_INFO PFX "Detected old alim7101 revision 'a1d'.  If this is a cobalt board, set the 'use_gpio' module parameter.\n");
+                        printk(KERN_INFO PFX
+                                "Detected old alim7101 revision 'a1d'.  "
+                                "If this is a cobalt board, set the 'use_gpio' "
+                                "module parameter.\n");
                        goto err_out;
                }
                nowayout = 1;
        } else if ((tmp & 0x1e) != 0x12 && (tmp & 0x1e) != 0x00) {
-                printk(KERN_INFO PFX "ALi 1543 South-Bridge does not have the correct revision number (???1001?) - WDT not set\n");
+                printk(KERN_INFO PFX
+                        "ALi 1543 South-Bridge does not have the correct "
+                        "revision number (???1001?) - WDT not set\n");
                goto err_out;
        }
@@ -409,7 +415,8 @@ static int __init alim7101_wdt_init(void)
        if (nowayout)
                __module_get(THIS_MODULE);
-        printk(KERN_INFO PFX "WDT driver for ALi M7101 initialised. timeout=%d sec (nowayout=%d)\n",
+        printk(KERN_INFO PFX "WDT driver for ALi M7101 initialised. "
+                                        "timeout=%d sec (nowayout=%d)\n",
                timeout, nowayout);
        return 0;
diff --git a/drivers/watchdog/ar7_wdt.c b/drivers/watchdog/ar7_wdt.c
index 55dcbfe2bb72..3fe9742c23ca 100644
--- a/drivers/watchdog/ar7_wdt.c
+++ b/drivers/watchdog/ar7_wdt.c
@@ -246,7 +246,8 @@ static long ar7_wdt_ioctl(struct file *file,
        static struct watchdog_info ident = {
                .identity = LONGNAME,
                .firmware_version = 1,
-                .options = (WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING),
+                .options = (WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING |
+                                                WDIOF_MAGICCLOSE),
        };
        int new_margin;
diff --git a/drivers/watchdog/at91rm9200_wdt.c b/drivers/watchdog/at91rm9200_wdt.c
index 29e52c237a3b..b185dafe1494 100644
--- a/drivers/watchdog/at91rm9200_wdt.c
+++ b/drivers/watchdog/at91rm9200_wdt.c
@@ -268,7 +268,8 @@ static int __init at91_wdt_init(void)
           if not reset to the default */
        if (at91_wdt_settimeout(wdt_time)) {
                at91_wdt_settimeout(WDT_DEFAULT_TIME);
-                pr_info("at91_wdt: wdt_time value must be 1 <= wdt_time <= 256, using %d\n", wdt_time);
+                pr_info("at91_wdt: wdt_time value must be 1 <= wdt_time <= 256"
+                                                ", using %d\n", wdt_time);
        }
        return platform_driver_register(&at91wdt_driver);
diff --git a/drivers/watchdog/at91sam9_wdt.c b/drivers/watchdog/at91sam9_wdt.c
index 435b0573fb0a..eac26021e8da 100644
--- a/drivers/watchdog/at91sam9_wdt.c
+++ b/drivers/watchdog/at91sam9_wdt.c
@@ -156,7 +156,8 @@ static int at91_wdt_settimeout(unsigned int timeout)
 static const struct watchdog_info at91_wdt_info = {
        .identity       = DRV_NAME,
-        .options        = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
+        .options        = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING |
+                                                WDIOF_MAGICCLOSE,
 };
 /*
diff --git a/drivers/watchdog/bfin_wdt.c b/drivers/watchdog/bfin_wdt.c
index 067a57cb3f82..c7b3f9df2317 100644
--- a/drivers/watchdog/bfin_wdt.c
+++ b/drivers/watchdog/bfin_wdt.c
@@ -27,10 +27,15 @@
 #include <linux/uaccess.h>
 #include <asm/blackfin.h>
-#define stamp(fmt, args...) pr_debug("%s:%i: " fmt "\n", __func__, __LINE__, ## args)
+#define stamp(fmt, args...) \
+        pr_debug("%s:%i: " fmt "\n", __func__, __LINE__, ## args)
 #define stampit() stamp("here i am")
-#define pr_devinit(fmt, args...) ({ static const __devinitconst char __fmt[] = fmt; printk(__fmt, ## args); })
+#define pr_devinit(fmt, args...) \
-#define pr_init(fmt, args...) ({ static const __initconst char __fmt[] = fmt; printk(__fmt, ## args); })
+        ({ static const __devinitconst char __fmt[] = fmt; \
+        printk(__fmt, ## args); })
+#define pr_init(fmt, args...) \
+        ({ static const __initconst char __fmt[] = fmt; \
+        printk(__fmt, ## args); })
 #define WATCHDOG_NAME "bfin-wdt"
 #define PFX WATCHDOG_NAME ": "
@@ -476,7 +481,8 @@ static int __init bfin_wdt_init(void)
                return ret;
        }
-        bfin_wdt_device = platform_device_register_simple(WATCHDOG_NAME, -1, NULL, 0);
+        bfin_wdt_device = platform_device_register_simple(WATCHDOG_NAME,
+                                                                -1, NULL, 0);
        if (IS_ERR(bfin_wdt_device)) {
                pr_init(KERN_ERR PFX "unable to register device\n");
                platform_driver_unregister(&bfin_wdt_driver);
diff --git a/drivers/watchdog/cpwd.c b/drivers/watchdog/cpwd.c
index 41070e4771a0..081f2955419e 100644
--- a/drivers/watchdog/cpwd.c
+++ b/drivers/watchdog/cpwd.c
@@ -154,9 +154,9 @@ static struct cpwd *cpwd_device;
 static struct timer_list cpwd_timer;
-static int wd0_timeout = 0;
+static int wd0_timeout;
-static int wd1_timeout = 0;
+static int wd1_timeout;
-static int wd2_timeout = 0;
+static int wd2_timeout;
 module_param(wd0_timeout, int, 0);
 MODULE_PARM_DESC(wd0_timeout, "Default watchdog0 timeout in 1/10secs");
diff --git a/drivers/watchdog/davinci_wdt.c b/drivers/watchdog/davinci_wdt.c
index c51d0b0ea0c4..83e22e7ea4a2 100644
--- a/drivers/watchdog/davinci_wdt.c
+++ b/drivers/watchdog/davinci_wdt.c
@@ -193,7 +193,7 @@ static struct miscdevice davinci_wdt_miscdev = {
        .fops = &davinci_wdt_fops,
 };
-static int davinci_wdt_probe(struct platform_device *pdev)
+static int __devinit davinci_wdt_probe(struct platform_device *pdev)
 {
        int ret = 0, size;
        struct resource *res;
@@ -237,7 +237,7 @@ static int davinci_wdt_probe(struct platform_device *pdev)
        return ret;
 }
-static int davinci_wdt_remove(struct platform_device *pdev)
+static int __devexit davinci_wdt_remove(struct platform_device *pdev)
 {
        misc_deregister(&davinci_wdt_miscdev);
        if (wdt_mem) {
@@ -254,7 +254,7 @@ static struct platform_driver platform_wdt_driver = {
                .owner  = THIS_MODULE,
        },
        .probe = davinci_wdt_probe,
-        .remove = davinci_wdt_remove,
+        .remove = __devexit_p(davinci_wdt_remove),
 };
 static int __init davinci_wdt_init(void)
diff --git a/drivers/watchdog/hpwdt.c b/drivers/watchdog/hpwdt.c
index 3137361ccbfe..c0b9169ba5d5 100644
--- a/drivers/watchdog/hpwdt.c
+++ b/drivers/watchdog/hpwdt.c
@@ -19,6 +19,7 @@
 #include <linux/interrupt.h>
 #include <linux/io.h>
 #include <linux/irq.h>
+#include <linux/nmi.h>
 #include <linux/kernel.h>
 #include <linux/miscdevice.h>
 #include <linux/mm.h>
@@ -47,7 +48,7 @@
 #define PCI_BIOS32_PARAGRAPH_LEN        16
 #define PCI_ROM_BASE1                   0x000F0000
 #define ROM_SIZE                        0x10000
-#define HPWDT_VERSION                   "1.01"
+#define HPWDT_VERSION                   "1.1.1"
 struct bios32_service_dir {
        u32 signature;
@@ -119,6 +120,7 @@ static int nowayout = WATCHDOG_NOWAYOUT;
 static char expect_release;
 static unsigned long hpwdt_is_open;
 static unsigned int allow_kdump;
+static int hpwdt_nmi_sourcing;
 static void __iomem *pci_mem_addr;              /* the PCI-memory address */
 static unsigned long __iomem *hpwdt_timer_reg;
@@ -468,21 +470,22 @@ static int hpwdt_pretimeout(struct notifier_block *nb, unsigned long ulReason,
        if (ulReason != DIE_NMI && ulReason != DIE_NMI_IPI)
                return NOTIFY_OK;
-        spin_lock_irqsave(&rom_lock, rom_pl);
+        if (hpwdt_nmi_sourcing) {
-        if (!die_nmi_called)
+                spin_lock_irqsave(&rom_lock, rom_pl);
-                asminline_call(&cmn_regs, cru_rom_addr);
+                if (!die_nmi_called)
-        die_nmi_called = 1;
+                        asminline_call(&cmn_regs, cru_rom_addr);
-        spin_unlock_irqrestore(&rom_lock, rom_pl);
+                die_nmi_called = 1;
-        if (cmn_regs.u1.ral == 0) {
+                spin_unlock_irqrestore(&rom_lock, rom_pl);
-                printk(KERN_WARNING "hpwdt: An NMI occurred, "
+                if (cmn_regs.u1.ral == 0) {
-                        "but unable to determine source.\n");
+                        printk(KERN_WARNING "hpwdt: An NMI occurred, "
-        } else {
+                                "but unable to determine source.\n");
-                if (allow_kdump)
+                } else {
-                        hpwdt_stop();
+                        if (allow_kdump)
-                panic("An NMI occurred, please see the Integrated "
+                                hpwdt_stop();
-                        "Management Log for details.\n");
+                        panic("An NMI occurred, please see the Integrated "
+                                "Management Log for details.\n");
+                }
        }
        return NOTIFY_OK;
 }
@@ -627,12 +630,38 @@ static struct notifier_block die_notifier = {
 *      Init & Exit
 */
+#ifdef ARCH_HAS_NMI_WATCHDOG
+static void __devinit hpwdt_check_nmi_sourcing(struct pci_dev *dev)
+{
+        /*
+         * If nmi_watchdog is turned off then we can turn on
+         * our nmi sourcing capability.
+         */
+        if (!nmi_watchdog_active())
+                hpwdt_nmi_sourcing = 1;
+        else
+                dev_warn(&dev->dev, "NMI sourcing is disabled. To enable this "
+                        "functionality you must reboot with nmi_watchdog=0.\n");
+}
+#else
+static void __devinit hpwdt_check_nmi_sourcing(struct pci_dev *dev)
+{
+        dev_warn(&dev->dev, "NMI sourcing is disabled. "
+                "Your kernel does not support a NMI Watchdog.\n");
+}
+#endif
 static int __devinit hpwdt_init_one(struct pci_dev *dev,
                                        const struct pci_device_id *ent)
 {
        int retval;
        /*
+         * Check if we can do NMI sourcing or not
+         */
+        hpwdt_check_nmi_sourcing(dev);
+        /*
         * First let's find out if we are on an iLO2 server. We will
         * not run on a legacy ASM box.
         * So we only support the G5 ProLiant servers and higher.
diff --git a/drivers/watchdog/iTCO_vendor_support.c b/drivers/watchdog/iTCO_vendor_support.c
index d3c0f6de5523..5133bca5ccbe 100644
--- a/drivers/watchdog/iTCO_vendor_support.c
+++ b/drivers/watchdog/iTCO_vendor_support.c
@@ -19,7 +19,7 @@
 /* Module and version information */
 #define DRV_NAME        "iTCO_vendor_support"
-#define DRV_VERSION     "1.03"
+#define DRV_VERSION     "1.04"
 #define PFX             DRV_NAME ": "
 /* Includes */
@@ -35,20 +35,23 @@
 #include "iTCO_vendor.h"
 /* iTCO defines */
-#define SMI_EN          acpibase + 0x30 /* SMI Control and Enable Register */
+#define SMI_EN          (acpibase + 0x30) /* SMI Control and Enable Register */
-#define TCOBASE         acpibase + 0x60 /* TCO base address */
+#define TCOBASE         (acpibase + 0x60) /* TCO base address */
-#define TCO1_STS        TCOBASE + 0x04  /* TCO1 Status Register */
+#define TCO1_STS        (TCOBASE + 0x04)  /* TCO1 Status Register */
 /* List of vendor support modes */
 /* SuperMicro Pentium 3 Era 370SSE+-OEM1/P3TSSE */
 #define SUPERMICRO_OLD_BOARD    1
 /* SuperMicro Pentium 4 / Xeon 4 / EMT64T Era Systems */
 #define SUPERMICRO_NEW_BOARD    2
+/* Broken BIOS */
+#define BROKEN_BIOS             911
 static int vendorsupport;
 module_param(vendorsupport, int, 0);
 MODULE_PARM_DESC(vendorsupport, "iTCO vendor specific support mode, default="
-                        "0 (none), 1=SuperMicro Pent3, 2=SuperMicro Pent4+");
+                        "0 (none), 1=SuperMicro Pent3, 2=SuperMicro Pent4+, "
+                                                        "911=Broken SMI BIOS");
 /*
 *      Vendor Specific Support
@@ -243,25 +246,92 @@ static void supermicro_new_pre_set_heartbeat(unsigned int heartbeat)
 }
 /*
+ *      Vendor Support: 911
+ *      Board: Some Intel ICHx based motherboards
+ *      iTCO chipset: ICH7+
+ *
+ *      Some Intel motherboards have a broken BIOS implementation: i.e.
+ *      the SMI handler clear's the TIMEOUT bit in the TC01_STS register
+ *      and does not reload the time. Thus the TCO watchdog does not reboot
+ *      the system.
+ *
+ *      These are the conclusions of Andriy Gapon <avg@icyb.net.ua> after
+ *      debugging: the SMI handler is quite simple - it tests value in
+ *      TCO1_CNT against 0x800, i.e. checks TCO_TMR_HLT. If the bit is set
+ *      the handler goes into an infinite loop, apparently to allow the
+ *      second timeout and reboot. Otherwise it simply clears TIMEOUT bit
+ *      in TCO1_STS and that's it.
+ *      So the logic seems to be reversed, because it is hard to see how
+ *      TIMEOUT can get set to 1 and SMI generated when TCO_TMR_HLT is set
+ *      (other than a transitional effect).
+ *
+ *      The only fix found to get the motherboard(s) to reboot is to put
+ *      the glb_smi_en bit to 0. This is a dirty hack that bypasses the
+ *      broken code by disabling Global SMI.
+ *
+ *      WARNING: globally disabling SMI could possibly lead to dramatic
+ *      problems, especially on laptops! I.e. various ACPI things where
+ *      SMI is used for communication between OS and firmware.
+ *
+ *      Don't use this fix if you don't need to!!!
+ */
+static void broken_bios_start(unsigned long acpibase)
+{
+        unsigned long val32;
+        val32 = inl(SMI_EN);
+        /* Bit 13: TCO_EN     -> 0 = Disables TCO logic generating an SMI#
+           Bit  0: GBL_SMI_EN -> 0 = No SMI# will be generated by ICH. */
+        val32 &= 0xffffdffe;
+        outl(val32, SMI_EN);
+}
+static void broken_bios_stop(unsigned long acpibase)
+{
+        unsigned long val32;
+        val32 = inl(SMI_EN);
+        /* Bit 13: TCO_EN     -> 1 = Enables TCO logic generating an SMI#
+           Bit  0: GBL_SMI_EN -> 1 = Turn global SMI on again. */
+        val32 |= 0x00002001;
+        outl(val32, SMI_EN);
+}
+/*
 *      Generic Support Functions
 */
 void iTCO_vendor_pre_start(unsigned long acpibase,
                           unsigned int heartbeat)
 {
-        if (vendorsupport == SUPERMICRO_OLD_BOARD)
+        switch (vendorsupport) {
+        case SUPERMICRO_OLD_BOARD:
                supermicro_old_pre_start(acpibase);
-        else if (vendorsupport == SUPERMICRO_NEW_BOARD)
+                break;
+        case SUPERMICRO_NEW_BOARD:
                supermicro_new_pre_start(heartbeat);
+                break;
+        case BROKEN_BIOS:
+                broken_bios_start(acpibase);
+                break;
+        }
 }
 EXPORT_SYMBOL(iTCO_vendor_pre_start);
 void iTCO_vendor_pre_stop(unsigned long acpibase)
 {
-        if (vendorsupport == SUPERMICRO_OLD_BOARD)
+        switch (vendorsupport) {
+        case SUPERMICRO_OLD_BOARD:
                supermicro_old_pre_stop(acpibase);
-        else if (vendorsupport == SUPERMICRO_NEW_BOARD)
+                break;
+        case SUPERMICRO_NEW_BOARD:
                supermicro_new_pre_stop();
+                break;
+        case BROKEN_BIOS:
+                broken_bios_stop(acpibase);
+                break;
+        }
 }
 EXPORT_SYMBOL(iTCO_vendor_pre_stop);
diff --git a/drivers/watchdog/iTCO_wdt.c b/drivers/watchdog/iTCO_wdt.c
index 648250b998c4..6a51edde6ea7 100644
--- a/drivers/watchdog/iTCO_wdt.c
+++ b/drivers/watchdog/iTCO_wdt.c
@@ -236,19 +236,19 @@ MODULE_DEVICE_TABLE(pci, iTCO_wdt_pci_tbl);
 /* Address definitions for the TCO */
 /* TCO base address */
-#define TCOBASE         iTCO_wdt_private.ACPIBASE + 0x60
+#define TCOBASE         (iTCO_wdt_private.ACPIBASE + 0x60)
 /* SMI Control and Enable Register */
-#define SMI_EN          iTCO_wdt_private.ACPIBASE + 0x30
+#define SMI_EN          (iTCO_wdt_private.ACPIBASE + 0x30)
-#define TCO_RLD         TCOBASE + 0x00  /* TCO Timer Reload and Curr. Value */
+#define TCO_RLD         (TCOBASE + 0x00) /* TCO Timer Reload and Curr. Value */
-#define TCOv1_TMR       TCOBASE + 0x01  /* TCOv1 Timer Initial Value    */
+#define TCOv1_TMR       (TCOBASE + 0x01) /* TCOv1 Timer Initial Value   */
-#define TCO_DAT_IN      TCOBASE + 0x02  /* TCO Data In Register         */
+#define TCO_DAT_IN      (TCOBASE + 0x02) /* TCO Data In Register        */
-#define TCO_DAT_OUT     TCOBASE + 0x03  /* TCO Data Out Register        */
+#define TCO_DAT_OUT     (TCOBASE + 0x03) /* TCO Data Out Register       */
-#define TCO1_STS        TCOBASE + 0x04  /* TCO1 Status Register         */
+#define TCO1_STS        (TCOBASE + 0x04) /* TCO1 Status Register        */
-#define TCO2_STS        TCOBASE + 0x06  /* TCO2 Status Register         */
+#define TCO2_STS        (TCOBASE + 0x06) /* TCO2 Status Register        */
-#define TCO1_CNT        TCOBASE + 0x08  /* TCO1 Control Register        */
+#define TCO1_CNT        (TCOBASE + 0x08) /* TCO1 Control Register       */
-#define TCO2_CNT        TCOBASE + 0x0a  /* TCO2 Control Register        */
+#define TCO2_CNT        (TCOBASE + 0x0a) /* TCO2 Control Register       */
-#define TCOv2_TMR       TCOBASE + 0x12  /* TCOv2 Timer Initial Value    */
+#define TCOv2_TMR       (TCOBASE + 0x12) /* TCOv2 Timer Initial Value   */
 /* internal variables */
 static unsigned long is_active;
@@ -666,6 +666,11 @@ static int __devinit iTCO_wdt_init(struct pci_dev *pdev,
           GCS = RCBA + ICH6_GCS(0x3410). */
        if (iTCO_wdt_private.iTCO_version == 2) {
                pci_read_config_dword(pdev, 0xf0, &base_address);
+                if ((base_address & 1) == 0) {
+                        printk(KERN_ERR PFX "RCBA is disabled by harddware\n");
+                        ret = -ENODEV;
+                        goto out;
+                }
                RCBA = base_address & 0xffffc000;
                iTCO_wdt_private.gcs = ioremap((RCBA + 0x3410), 4);
        }
@@ -675,7 +680,7 @@ static int __devinit iTCO_wdt_init(struct pci_dev *pdev,
                printk(KERN_ERR PFX "failed to reset NO_REBOOT flag, "
                                        "reboot disabled by hardware\n");
                ret = -ENODEV;  /* Cannot reset NO_REBOOT bit */
-                goto out;
+                goto out_unmap;
        }
        /* Set the NO_REBOOT bit to prevent later reboots, just for sure */
@@ -686,7 +691,7 @@ static int __devinit iTCO_wdt_init(struct pci_dev *pdev,
                printk(KERN_ERR PFX
                        "I/O address 0x%04lx already in use\n", SMI_EN);
                ret = -EIO;
-                goto out;
+                goto out_unmap;
        }
        /* Bit 13: TCO_EN -> 0 = Disables TCO logic generating an SMI# */
        val32 = inl(SMI_EN);
@@ -742,9 +747,10 @@ unreg_region:
        release_region(TCOBASE, 0x20);
 unreg_smi_en:
        release_region(SMI_EN, 4);
-out:
+out_unmap:
        if (iTCO_wdt_private.iTCO_version == 2)
                iounmap(iTCO_wdt_private.gcs);
+out:
        pci_dev_put(iTCO_wdt_private.pdev);
        iTCO_wdt_private.ACPIBASE = 0;
        return ret;
diff --git a/drivers/watchdog/indydog.c b/drivers/watchdog/indydog.c
index 0f761db9a27c..bea8a124a559 100644
--- a/drivers/watchdog/indydog.c
+++ b/drivers/watchdog/indydog.c
@@ -83,7 +83,6 @@ static int indydog_open(struct inode *inode, struct file *file)
        indydog_start();
        indydog_ping();
-        indydog_alive = 1;
        printk(KERN_INFO "Started watchdog timer.\n");
        return nonseekable_open(inode, file);
@@ -113,8 +112,7 @@ static long indydog_ioctl(struct file *file, unsigned int cmd,
 {
        int options, retval = -EINVAL;
        static struct watchdog_info ident = {
-                .options                = WDIOF_KEEPALIVEPING |
+                .options                = WDIOF_KEEPALIVEPING,
-                                          WDIOF_MAGICCLOSE,
                .firmware_version       = 0,
                .identity               = "Hardware Watchdog for SGI IP22",
        };
diff --git a/drivers/watchdog/it8712f_wdt.c b/drivers/watchdog/it8712f_wdt.c
index 2270ee07c01b..daed48ded7fe 100644
--- a/drivers/watchdog/it8712f_wdt.c
+++ b/drivers/watchdog/it8712f_wdt.c
@@ -239,7 +239,8 @@ static long it8712f_wdt_ioctl(struct file *file, unsigned int cmd,
        static struct watchdog_info ident = {
                .identity = "IT8712F Watchdog",
                .firmware_version = 1,
-                .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
+                .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING |
+                                                WDIOF_MAGICCLOSE,
        };
        int value;
diff --git a/drivers/watchdog/ks8695_wdt.c b/drivers/watchdog/ks8695_wdt.c
index ae3832110acb..00b03eb43bf0 100644
--- a/drivers/watchdog/ks8695_wdt.c
+++ b/drivers/watchdog/ks8695_wdt.c
@@ -293,8 +293,8 @@ static int __init ks8695_wdt_init(void)
           if not reset to the default */
        if (ks8695_wdt_settimeout(wdt_time)) {
                ks8695_wdt_settimeout(WDT_DEFAULT_TIME);
-                pr_info("ks8695_wdt: wdt_time value must be 1 <= wdt_time <= %i, using %d\n",
+                pr_info("ks8695_wdt: wdt_time value must be 1 <= wdt_time <= %i"
-                                                        wdt_time, WDT_MAX_TIME);
+                                        ", using %d\n", wdt_time, WDT_MAX_TIME);
        }
        return platform_driver_register(&ks8695wdt_driver);
 }
diff --git a/drivers/watchdog/machzwd.c b/drivers/watchdog/machzwd.c
index 2dfc27559bf7..b6b3f59ab446 100644
--- a/drivers/watchdog/machzwd.c
+++ b/drivers/watchdog/machzwd.c
@@ -118,7 +118,8 @@ static struct watchdog_info zf_info = {
 */
 static int action;
 module_param(action, int, 0);
-MODULE_PARM_DESC(action, "after watchdog resets, generate: 0 = RESET(*)  1 = SMI  2 = NMI  3 = SCI");
+MODULE_PARM_DESC(action, "after watchdog resets, generate: "
+                                "0 = RESET(*)  1 = SMI  2 = NMI  3 = SCI");
 static void zf_ping(unsigned long data);
@@ -142,7 +143,8 @@ static unsigned long next_heartbeat;
 #ifndef ZF_DEBUG
 #       define dprintk(format, args...)
 #else
-#       define dprintk(format, args...) printk(KERN_DEBUG PFX ":%s:%d: " format, __func__, __LINE__ , ## args)
+#       define dprintk(format, args...) printk(KERN_DEBUG PFX
+                                ":%s:%d: " format, __func__, __LINE__ , ## args)
 #endif
@@ -340,7 +342,8 @@ static int zf_close(struct inode *inode, struct file *file)
                zf_timer_off();
        else {
                del_timer(&zf_timer);
-                printk(KERN_ERR PFX ": device file closed unexpectedly. Will not stop the WDT!\n");
+                printk(KERN_ERR PFX ": device file closed unexpectedly. "
+                                                "Will not stop the WDT!\n");
        }
        clear_bit(0, &zf_is_open);
        zf_expect_close = 0;
diff --git a/drivers/watchdog/mpcore_wdt.c b/drivers/watchdog/mpcore_wdt.c
index 1512ab8b175b..83fa34b214b4 100644
--- a/drivers/watchdog/mpcore_wdt.c
+++ b/drivers/watchdog/mpcore_wdt.c
@@ -61,7 +61,9 @@ MODULE_PARM_DESC(nowayout,
 #define ONLY_TESTING    0
 static int mpcore_noboot = ONLY_TESTING;
 module_param(mpcore_noboot, int, 0);
-MODULE_PARM_DESC(mpcore_noboot, "MPcore watchdog action, set to 1 to ignore reboots, 0 to reboot (default=" __MODULE_STRING(ONLY_TESTING) ")");
+MODULE_PARM_DESC(mpcore_noboot, "MPcore watchdog action, "
+        "set to 1 to ignore reboots, 0 to reboot (default="
+                                        __MODULE_STRING(ONLY_TESTING) ")");
 /*
 *      This is the interrupt handler.  Note that we only use this
@@ -416,7 +418,8 @@ static struct platform_driver mpcore_wdt_driver = {
        },
 };
-static char banner[] __initdata = KERN_INFO "MPcore Watchdog Timer: 0.1. mpcore_noboot=%d mpcore_margin=%d sec (nowayout= %d)\n";
+static char banner[] __initdata = KERN_INFO "MPcore Watchdog Timer: 0.1. "
+                "mpcore_noboot=%d mpcore_margin=%d sec (nowayout= %d)\n";
 static int __init mpcore_wdt_init(void)
 {
diff --git a/drivers/watchdog/mtx-1_wdt.c b/drivers/watchdog/mtx-1_wdt.c
index 539b6f6ba7f1..08e8a6ab74e1 100644
--- a/drivers/watchdog/mtx-1_wdt.c
+++ b/drivers/watchdog/mtx-1_wdt.c
@@ -206,7 +206,7 @@ static struct miscdevice mtx1_wdt_misc = {
 };
-static int mtx1_wdt_probe(struct platform_device *pdev)
+static int __devinit mtx1_wdt_probe(struct platform_device *pdev)
 {
        int ret;
@@ -229,7 +229,7 @@ static int mtx1_wdt_probe(struct platform_device *pdev)
        return 0;
 }
-static int mtx1_wdt_remove(struct platform_device *pdev)
+static int __devexit mtx1_wdt_remove(struct platform_device *pdev)
 {
        /* FIXME: do we need to lock this test ? */
        if (mtx1_wdt_device.queue) {
@@ -242,7 +242,7 @@ static int mtx1_wdt_remove(struct platform_device *pdev)
 static struct platform_driver mtx1_wdt = {
        .probe = mtx1_wdt_probe,
-        .remove = mtx1_wdt_remove,
+        .remove = __devexit_p(mtx1_wdt_remove),
        .driver.name = "mtx1-wdt",
        .driver.owner = THIS_MODULE,
 };
diff --git a/drivers/watchdog/pnx4008_wdt.c b/drivers/watchdog/pnx4008_wdt.c
index 64135195f827..f24d04132eda 100644
--- a/drivers/watchdog/pnx4008_wdt.c
+++ b/drivers/watchdog/pnx4008_wdt.c
@@ -246,7 +246,7 @@ static struct miscdevice pnx4008_wdt_miscdev = {
        .fops = &pnx4008_wdt_fops,
 };
-static int pnx4008_wdt_probe(struct platform_device *pdev)
+static int __devinit pnx4008_wdt_probe(struct platform_device *pdev)
 {
        int ret = 0, size;
        struct resource *res;
@@ -299,7 +299,7 @@ out:
        return ret;
 }
-static int pnx4008_wdt_remove(struct platform_device *pdev)
+static int __devexit pnx4008_wdt_remove(struct platform_device *pdev)
 {
        misc_deregister(&pnx4008_wdt_miscdev);
        if (wdt_clk) {
@@ -321,7 +321,7 @@ static struct platform_driver platform_wdt_driver = {
                .owner  = THIS_MODULE,
        },
        .probe = pnx4008_wdt_probe,
-        .remove = pnx4008_wdt_remove,
+        .remove = __devexit_p(pnx4008_wdt_remove),
 };
 static int __init pnx4008_wdt_init(void)
diff --git a/drivers/watchdog/rdc321x_wdt.c b/drivers/watchdog/rdc321x_wdt.c
index 36e221beedcd..4976bfd1fce6 100644
--- a/drivers/watchdog/rdc321x_wdt.c
+++ b/drivers/watchdog/rdc321x_wdt.c
@@ -245,7 +245,7 @@ static int __devinit rdc321x_wdt_probe(struct platform_device *pdev)
        return 0;
 }
-static int rdc321x_wdt_remove(struct platform_device *pdev)
+static int __devexit rdc321x_wdt_remove(struct platform_device *pdev)
 {
        if (rdc321x_wdt_device.queue) {
                rdc321x_wdt_device.queue = 0;
@@ -259,7 +259,7 @@ static int rdc321x_wdt_remove(struct platform_device *pdev)
 static struct platform_driver rdc321x_wdt_driver = {
        .probe = rdc321x_wdt_probe,
-        .remove = rdc321x_wdt_remove,
+        .remove = __devexit_p(rdc321x_wdt_remove),
        .driver = {
                .owner = THIS_MODULE,
                .name = "rdc321x-wdt",
diff --git a/drivers/watchdog/rm9k_wdt.c b/drivers/watchdog/rm9k_wdt.c
index cce1982a1b58..2e4442642262 100644
--- a/drivers/watchdog/rm9k_wdt.c
+++ b/drivers/watchdog/rm9k_wdt.c
@@ -345,8 +345,8 @@ static const struct resource *wdt_gpi_get_resource(struct platform_device *pdv,
        return platform_get_resource_byname(pdv, type, buf);
 }
-/* No hotplugging on the platform bus - use __init */
+/* No hotplugging on the platform bus - use __devinit */
-static int __init wdt_gpi_probe(struct platform_device *pdv)
+static int __devinit wdt_gpi_probe(struct platform_device *pdv)
 {
        int res;
        const struct resource
@@ -373,7 +373,7 @@ static int __init wdt_gpi_probe(struct platform_device *pdv)
        return res;
 }
-static int __exit wdt_gpi_remove(struct platform_device *dev)
+static int __devexit wdt_gpi_remove(struct platform_device *dev)
 {
        int res;
diff --git a/drivers/watchdog/s3c2410_wdt.c b/drivers/watchdog/s3c2410_wdt.c
index e31925ee8346..b57ac6b49147 100644
--- a/drivers/watchdog/s3c2410_wdt.c
+++ b/drivers/watchdog/s3c2410_wdt.c
@@ -68,15 +68,10 @@ MODULE_PARM_DESC(tmr_atboot,
                        __MODULE_STRING(CONFIG_S3C2410_WATCHDOG_ATBOOT));
 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
                        __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
-MODULE_PARM_DESC(soft_noboot, "Watchdog action, set to 1 to ignore reboots, 0 to reboot (default depends on ONLY_TESTING)");
+MODULE_PARM_DESC(soft_noboot, "Watchdog action, set to 1 to ignore reboots, "
+                        "0 to reboot (default depends on ONLY_TESTING)");
 MODULE_PARM_DESC(debug, "Watchdog debug, set to >1 for debug, (default 0)");
-typedef enum close_state {
-        CLOSE_STATE_NOT,
-        CLOSE_STATE_ALLOW = 0x4021
-} close_state_t;
 static unsigned long open_lock;
 static struct device    *wdt_dev;       /* platform device attached to */
 static struct resource  *wdt_mem;
@@ -84,7 +79,7 @@ static struct resource	*wdt_irq;
 static struct clk       *wdt_clock;
 static void __iomem     *wdt_base;
 static unsigned int      wdt_count;
-static close_state_t     allow_close;
+static char              expect_close;
 static DEFINE_SPINLOCK(wdt_lock);
 /* watchdog control routines */
@@ -211,7 +206,7 @@ static int s3c2410wdt_open(struct inode *inode, struct file *file)
        if (nowayout)
                __module_get(THIS_MODULE);
-        allow_close = CLOSE_STATE_NOT;
+        expect_close = 0;
        /* start the timer */
        s3c2410wdt_start();
@@ -225,13 +220,13 @@ static int s3c2410wdt_release(struct inode *inode, struct file *file)
         *      Lock it in if it's a module and we set nowayout
         */
-        if (allow_close == CLOSE_STATE_ALLOW)
+        if (expect_close == 42)
                s3c2410wdt_stop();
        else {
                dev_err(wdt_dev, "Unexpected close, not stopping watchdog\n");
                s3c2410wdt_keepalive();
        }
-        allow_close = CLOSE_STATE_NOT;
+        expect_close = 0;
        clear_bit(0, &open_lock);
        return 0;
 }
@@ -247,7 +242,7 @@ static ssize_t s3c2410wdt_write(struct file *file, const char __user *data,
                        size_t i;
                        /* In case it was set long ago */
-                        allow_close = CLOSE_STATE_NOT;
+                        expect_close = 0;
                        for (i = 0; i != len; i++) {
                                char c;
@@ -255,7 +250,7 @@ static ssize_t s3c2410wdt_write(struct file *file, const char __user *data,
                                if (get_user(c, data + i))
                                        return -EFAULT;
                                if (c == 'V')
-                                        allow_close = CLOSE_STATE_ALLOW;
+                                        expect_close = 42;
                        }
                }
                s3c2410wdt_keepalive();
@@ -263,7 +258,7 @@ static ssize_t s3c2410wdt_write(struct file *file, const char __user *data,
        return len;
 }
-#define OPTIONS WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE
+#define OPTIONS (WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE)
 static const struct watchdog_info s3c2410_wdt_ident = {
        .options          =     OPTIONS,
@@ -331,7 +326,7 @@ static irqreturn_t s3c2410wdt_irq(int irqno, void *param)
 }
 /* device interface */
-static int s3c2410wdt_probe(struct platform_device *pdev)
+static int __devinit s3c2410wdt_probe(struct platform_device *pdev)
 {
        struct resource *res;
        struct device *dev;
@@ -404,7 +399,8 @@ static int s3c2410wdt_probe(struct platform_device *pdev)
                           "tmr_margin value out of range, default %d used\n",
                               CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME);
                else
-                        dev_info(dev, "default timer value is out of range, cannot start\n");
+                        dev_info(dev, "default timer value is out of range, "
+                                                        "cannot start\n");
        }
        ret = misc_register(&s3c2410wdt_miscdev);
@@ -453,7 +449,7 @@ static int s3c2410wdt_probe(struct platform_device *pdev)
        return ret;
 }
-static int s3c2410wdt_remove(struct platform_device *dev)
+static int __devexit s3c2410wdt_remove(struct platform_device *dev)
 {
        release_resource(wdt_mem);
        kfree(wdt_mem);
@@ -515,7 +511,7 @@ static int s3c2410wdt_resume(struct platform_device *dev)
 static struct platform_driver s3c2410wdt_driver = {
        .probe          = s3c2410wdt_probe,
-        .remove         = s3c2410wdt_remove,
+        .remove         = __devexit_p(s3c2410wdt_remove),
        .shutdown       = s3c2410wdt_shutdown,
        .suspend        = s3c2410wdt_suspend,
        .resume         = s3c2410wdt_resume,
diff --git a/drivers/watchdog/sb_wdog.c b/drivers/watchdog/sb_wdog.c
index 38f5831c9291..9748eed73196 100644
--- a/drivers/watchdog/sb_wdog.c
+++ b/drivers/watchdog/sb_wdog.c
@@ -93,7 +93,7 @@ static int expect_close;
 static const struct watchdog_info ident = {
        .options        = WDIOF_CARDRESET | WDIOF_SETTIMEOUT |
-                                                WDIOF_KEEPALIVEPING,
+                                        WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
        .identity       = "SiByte Watchdog",
 };
@@ -269,9 +269,10 @@ irqreturn_t sbwdog_interrupt(int irq, void *addr)
         * if it's the second watchdog timer, it's for those users
         */
        if (wd_cfg_reg == user_dog)
-                printk(KERN_CRIT
+                printk(KERN_CRIT "%s in danger of initiating system reset "
-                        "%s in danger of initiating system reset in %ld.%01ld seconds\n",
+                        "in %ld.%01ld seconds\n",
-                        ident.identity, wd_init / 1000000, (wd_init / 100000) % 10);
+                        ident.identity,
+                        wd_init / 1000000, (wd_init / 100000) % 10);
        else
                cfg |= 1;
diff --git a/drivers/watchdog/sbc60xxwdt.c b/drivers/watchdog/sbc60xxwdt.c
index d1c390c7155c..626d0e8e56c3 100644
--- a/drivers/watchdog/sbc60xxwdt.c
+++ b/drivers/watchdog/sbc60xxwdt.c
@@ -372,8 +372,9 @@ static int __init sbc60xxwdt_init(void)
                                                wdt_miscdev.minor, rc);
                goto err_out_reboot;
        }
-        printk(KERN_INFO PFX "WDT driver for 60XX single board computer initialised. timeout=%d sec (nowayout=%d)\n",
+        printk(KERN_INFO PFX
-                timeout, nowayout);
+                "WDT driver for 60XX single board computer initialised. "
+                "timeout=%d sec (nowayout=%d)\n", timeout, nowayout);
        return 0;
diff --git a/drivers/watchdog/sbc8360.c b/drivers/watchdog/sbc8360.c
index b6e6799ec45d..68e2e2d6f73d 100644
--- a/drivers/watchdog/sbc8360.c
+++ b/drivers/watchdog/sbc8360.c
@@ -280,8 +280,8 @@ static int sbc8360_close(struct inode *inode, struct file *file)
        if (expect_close == 42)
                sbc8360_stop();
        else
-                printk(KERN_CRIT PFX
+                printk(KERN_CRIT PFX "SBC8360 device closed unexpectedly.  "
-                        "SBC8360 device closed unexpectedly.  SBC8360 will not stop!\n");
+                                                "SBC8360 will not stop!\n");
        clear_bit(0, &sbc8360_is_open);
        expect_close = 0;
diff --git a/drivers/watchdog/sbc_epx_c3.c b/drivers/watchdog/sbc_epx_c3.c
index e467ddcf796a..28f1214457bd 100644
--- a/drivers/watchdog/sbc_epx_c3.c
+++ b/drivers/watchdog/sbc_epx_c3.c
@@ -107,8 +107,7 @@ static long epx_c3_ioctl(struct file *file, unsigned int cmd,
        int options, retval = -EINVAL;
        int __user *argp = (void __user *)arg;
        static const struct watchdog_info ident = {
-                .options                = WDIOF_KEEPALIVEPING |
+                .options                = WDIOF_KEEPALIVEPING,
-                                          WDIOF_MAGICCLOSE,
                .firmware_version       = 0,
                .identity               = "Winsystems EPX-C3 H/W Watchdog",
        };
@@ -174,8 +173,8 @@ static struct notifier_block epx_c3_notifier = {
        .notifier_call = epx_c3_notify_sys,
 };
-static const char banner[] __initdata =
+static const char banner[] __initdata = KERN_INFO PFX
-    KERN_INFO PFX "Hardware Watchdog Timer for Winsystems EPX-C3 SBC: 0.1\n";
+        "Hardware Watchdog Timer for Winsystems EPX-C3 SBC: 0.1\n";
 static int __init watchdog_init(void)
 {
@@ -219,6 +218,9 @@ module_init(watchdog_init);
 module_exit(watchdog_exit);
 MODULE_AUTHOR("Calin A. Culianu <calin@ajvar.org>");
-MODULE_DESCRIPTION("Hardware Watchdog Device for Winsystems EPX-C3 SBC.  Note that there is no way to probe for this device -- so only use it if you are *sure* you are runnning on this specific SBC system from Winsystems!  It writes to IO ports 0x1ee and 0x1ef!");
+MODULE_DESCRIPTION("Hardware Watchdog Device for Winsystems EPX-C3 SBC.  "
+        "Note that there is no way to probe for this device -- "
+        "so only use it if you are *sure* you are runnning on this specific "
+        "SBC system from Winsystems!  It writes to IO ports 0x1ee and 0x1ef!");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/scx200_wdt.c b/drivers/watchdog/scx200_wdt.c
index 9e19a10a5bb9..e67b76c0526c 100644
--- a/drivers/watchdog/scx200_wdt.c
+++ b/drivers/watchdog/scx200_wdt.c
@@ -108,7 +108,9 @@ static int scx200_wdt_open(struct inode *inode, struct file *file)
 static int scx200_wdt_release(struct inode *inode, struct file *file)
 {
        if (expect_close != 42)
-                printk(KERN_WARNING NAME ": watchdog device closed unexpectedly, will not disable the watchdog timer\n");
+                printk(KERN_WARNING NAME
+                        ": watchdog device closed unexpectedly, "
+                        "will not disable the watchdog timer\n");
        else if (!nowayout)
                scx200_wdt_disable();
        expect_close = 0;
@@ -163,7 +165,8 @@ static long scx200_wdt_ioctl(struct file *file, unsigned int cmd,
        static const struct watchdog_info ident = {
                .identity = "NatSemi SCx200 Watchdog",
                .firmware_version = 1,
-                .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
+                .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING |
+                                                WDIOF_MAGICCLOSE,
        };
        int new_margin;
diff --git a/drivers/watchdog/shwdt.c b/drivers/watchdog/shwdt.c
index cdc7138be301..a03f84e5ee1f 100644
--- a/drivers/watchdog/shwdt.c
+++ b/drivers/watchdog/shwdt.c
@@ -494,7 +494,9 @@ MODULE_LICENSE("GPL");
 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 module_param(clock_division_ratio, int, 0);
-MODULE_PARM_DESC(clock_division_ratio, "Clock division ratio. Valid ranges are from 0x5 (1.31ms) to 0x7 (5.25ms). (default=" __MODULE_STRING(clock_division_ratio) ")");
+MODULE_PARM_DESC(clock_division_ratio,
+        "Clock division ratio. Valid ranges are from 0x5 (1.31ms) "
+        "to 0x7 (5.25ms). (default=" __MODULE_STRING(clock_division_ratio) ")");
 module_param(heartbeat, int, 0);
 MODULE_PARM_DESC(heartbeat,
diff --git a/drivers/watchdog/softdog.c b/drivers/watchdog/softdog.c
index ebcc9cea5e99..833f49f43d43 100644
--- a/drivers/watchdog/softdog.c
+++ b/drivers/watchdog/softdog.c
@@ -71,7 +71,9 @@ static int soft_noboot = 0;
 #endif  /* ONLY_TESTING */
 module_param(soft_noboot, int, 0);
-MODULE_PARM_DESC(soft_noboot, "Softdog action, set to 1 to ignore reboots, 0 to reboot (default depends on ONLY_TESTING)");
+MODULE_PARM_DESC(soft_noboot,
+        "Softdog action, set to 1 to ignore reboots, 0 to reboot "
+                                        "(default depends on ONLY_TESTING)");
 /*
 *      Our timer
@@ -264,7 +266,8 @@ static struct notifier_block softdog_notifier = {
        .notifier_call  = softdog_notify_sys,
 };
-static char banner[] __initdata = KERN_INFO "Software Watchdog Timer: 0.07 initialized. soft_noboot=%d soft_margin=%d sec (nowayout= %d)\n";
+static char banner[] __initdata = KERN_INFO "Software Watchdog Timer: 0.07 "
+        "initialized. soft_noboot=%d soft_margin=%d sec (nowayout= %d)\n";
 static int __init watchdog_init(void)
 {
diff --git a/drivers/watchdog/w83697hf_wdt.c b/drivers/watchdog/w83697hf_wdt.c
index a9c7f352fcbf..af08972de506 100644
--- a/drivers/watchdog/w83697hf_wdt.c
+++ b/drivers/watchdog/w83697hf_wdt.c
@@ -413,7 +413,8 @@ static int __init wdt_init(void)
        w83697hf_init();
        if (early_disable) {
                if (wdt_running())
-                        printk(KERN_WARNING PFX "Stopping previously enabled watchdog until userland kicks in\n");
+                        printk(KERN_WARNING PFX "Stopping previously enabled "
+                                        "watchdog until userland kicks in\n");
                wdt_disable();
        }
diff --git a/drivers/watchdog/wdrtas.c b/drivers/watchdog/wdrtas.c
index a38fa4907c92..a4fe7a38d9b0 100644
--- a/drivers/watchdog/wdrtas.c
+++ b/drivers/watchdog/wdrtas.c
@@ -49,12 +49,7 @@ MODULE_LICENSE("GPL");
 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 MODULE_ALIAS_MISCDEV(TEMP_MINOR);
-#ifdef CONFIG_WATCHDOG_NOWAYOUT
+static int wdrtas_nowayout = WATCHDOG_NOWAYOUT;
-static int wdrtas_nowayout = 1;
-#else
-static int wdrtas_nowayout = 0;
-#endif
 static atomic_t wdrtas_miscdev_open = ATOMIC_INIT(0);
 static char wdrtas_expect_close;