117 files changed, 4312 insertions, 1394 deletions

diff --git a/drivers/char/hw_random/Kconfig b/drivers/char/hw_random/Kconfig
index efd0b4db7c8e..8822eca58ffa 100644
--- a/drivers/char/hw_random/Kconfig
+++ b/drivers/char/hw_random/Kconfig
@@ -59,6 +59,19 @@ config HW_RANDOM_GEODE
 
           If unsure, say Y.
 
+config HW_RANDOM_N2RNG
+        tristate "Niagara2 Random Number Generator support"
+        depends on HW_RANDOM && SPARC64
+        default HW_RANDOM
+        ---help---
+          This driver provides kernel-side support for the Random Number
+          Generator hardware found on Niagara2 cpus.
+
+          To compile this driver as a module, choose M here: the
+          module will be called n2-rng.
+
+          If unsure, say Y.
+
 config HW_RANDOM_VIA
         tristate "VIA HW Random Number Generator support"
         depends on HW_RANDOM && X86_32
diff --git a/drivers/char/hw_random/Makefile b/drivers/char/hw_random/Makefile
index b4940ddbb35f..b6effb7522c2 100644
--- a/drivers/char/hw_random/Makefile
+++ b/drivers/char/hw_random/Makefile
@@ -7,6 +7,8 @@ rng-core-y := core.o
 obj-$(CONFIG_HW_RANDOM_INTEL) += intel-rng.o
 obj-$(CONFIG_HW_RANDOM_AMD) += amd-rng.o
 obj-$(CONFIG_HW_RANDOM_GEODE) += geode-rng.o
+obj-$(CONFIG_HW_RANDOM_N2RNG) += n2-rng.o
+n2-rng-y := n2-drv.o n2-asm.o
 obj-$(CONFIG_HW_RANDOM_VIA) += via-rng.o
 obj-$(CONFIG_HW_RANDOM_IXP4XX) += ixp4xx-rng.o
 obj-$(CONFIG_HW_RANDOM_OMAP) += omap-rng.o
diff --git a/drivers/char/hw_random/n2-asm.S b/drivers/char/hw_random/n2-asm.S
new file mode 100644
index 000000000000..9b6eb5cd59f6
--- /dev/null
+++ b/drivers/char/hw_random/n2-asm.S
@@ -0,0 +1,79 @@
+/* n2-asm.S: Niagara2 RNG hypervisor call assembler.
+ *
+ * Copyright (C) 2008 David S. Miller <davem@davemloft.net>
+ */
+#include <linux/linkage.h>
+#include <asm/hypervisor.h>
+#include "n2rng.h"
+
+        .text
+
+ENTRY(sun4v_rng_get_diag_ctl)
+        mov     HV_FAST_RNG_GET_DIAG_CTL, %o5
+        ta      HV_FAST_TRAP
+        retl
+         nop
+ENDPROC(sun4v_rng_get_diag_ctl)
+
+ENTRY(sun4v_rng_ctl_read_v1)
+        mov     %o1, %o3
+        mov     %o2, %o4
+        mov     HV_FAST_RNG_CTL_READ, %o5
+        ta      HV_FAST_TRAP
+        stx     %o1, [%o3]
+        retl
+         stx    %o2, [%o4]
+ENDPROC(sun4v_rng_ctl_read_v1)
+
+ENTRY(sun4v_rng_ctl_read_v2)
+        save    %sp, -192, %sp
+        mov     %i0, %o0
+        mov     %i1, %o1
+        mov     HV_FAST_RNG_CTL_READ, %o5
+        ta      HV_FAST_TRAP
+        stx     %o1, [%i2]
+        stx     %o2, [%i3]
+        stx     %o3, [%i4]
+        stx     %o4, [%i5]
+        ret
+        restore %g0, %o0, %o0
+ENDPROC(sun4v_rng_ctl_read_v2)
+
+ENTRY(sun4v_rng_ctl_write_v1)
+        mov     %o3, %o4
+        mov     HV_FAST_RNG_CTL_WRITE, %o5
+        ta      HV_FAST_TRAP
+        retl
+         stx    %o1, [%o4]
+ENDPROC(sun4v_rng_ctl_write_v1)
+
+ENTRY(sun4v_rng_ctl_write_v2)
+        mov     HV_FAST_RNG_CTL_WRITE, %o5
+        ta      HV_FAST_TRAP
+        retl
+         nop
+ENDPROC(sun4v_rng_ctl_write_v2)
+
+ENTRY(sun4v_rng_data_read_diag_v1)
+        mov     %o2, %o4
+        mov     HV_FAST_RNG_DATA_READ_DIAG, %o5
+        ta      HV_FAST_TRAP
+        retl
+         stx    %o1, [%o4]
+ENDPROC(sun4v_rng_data_read_diag_v1)
+
+ENTRY(sun4v_rng_data_read_diag_v2)
+        mov     %o3, %o4
+        mov     HV_FAST_RNG_DATA_READ_DIAG, %o5
+        ta      HV_FAST_TRAP
+        retl
+         stx    %o1, [%o4]
+ENDPROC(sun4v_rng_data_read_diag_v2)
+
+ENTRY(sun4v_rng_data_read)
+        mov     %o1, %o4
+        mov     HV_FAST_RNG_DATA_READ, %o5
+        ta      HV_FAST_TRAP
+        retl
+         stx    %o1, [%o4]
+ENDPROC(sun4v_rng_data_read)
diff --git a/drivers/char/hw_random/n2-drv.c b/drivers/char/hw_random/n2-drv.c
new file mode 100644
index 000000000000..5220f541df25
--- /dev/null
+++ b/drivers/char/hw_random/n2-drv.c
@@ -0,0 +1,771 @@
+/* n2-drv.c: Niagara-2 RNG driver.
+ *
+ * Copyright (C) 2008 David S. Miller <davem@davemloft.net>
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/delay.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/workqueue.h>
+#include <linux/preempt.h>
+#include <linux/hw_random.h>
+
+#include <linux/of.h>
+#include <linux/of_device.h>
+
+#include <asm/hypervisor.h>
+
+#include "n2rng.h"
+
+#define DRV_MODULE_NAME         "n2rng"
+#define PFX DRV_MODULE_NAME     ": "
+#define DRV_MODULE_VERSION      "0.1"
+#define DRV_MODULE_RELDATE      "May 15, 2008"
+
+static char version[] __devinitdata =
+        DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
+
+MODULE_AUTHOR("David S. Miller (davem@davemloft.net)");
+MODULE_DESCRIPTION("Niagara2 RNG driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_MODULE_VERSION);
+
+/* The Niagara2 RNG provides a 64-bit read-only random number
+ * register, plus a control register.  Access to the RNG is
+ * virtualized through the hypervisor so that both guests and control
+ * nodes can access the device.
+ *
+ * The entropy source consists of raw entropy sources, each
+ * constructed from a voltage controlled oscillator whose phase is
+ * jittered by thermal noise sources.
+ *
+ * The oscillator in each of the three raw entropy sources run at
+ * different frequencies.  Normally, all three generator outputs are
+ * gathered, xored together, and fed into a CRC circuit, the output of
+ * which is the 64-bit read-only register.
+ *
+ * Some time is necessary for all the necessary entropy to build up
+ * such that a full 64-bits of entropy are available in the register.
+ * In normal operating mode (RNG_CTL_LFSR is set), the chip implements
+ * an interlock which blocks register reads until sufficient entropy
+ * is available.
+ *
+ * A control register is provided for adjusting various aspects of RNG
+ * operation, and to enable diagnostic modes.  Each of the three raw
+ * entropy sources has an enable bit (RNG_CTL_ES{1,2,3}).  Also
+ * provided are fields for controlling the minimum time in cycles
+ * between read accesses to the register (RNG_CTL_WAIT, this controls
+ * the interlock described in the previous paragraph).
+ *
+ * The standard setting is to have the mode bit (RNG_CTL_LFSR) set,
+ * all three entropy sources enabled, and the interlock time set
+ * appropriately.
+ *
+ * The CRC polynomial used by the chip is:
+ *
+ * P(X) = x64 + x61 + x57 + x56 + x52 + x51 + x50 + x48 + x47 + x46 +
+ *        x43 + x42 + x41 + x39 + x38 + x37 + x35 + x32 + x28 + x25 +
+ *        x22 + x21 + x17 + x15 + x13 + x12 + x11 + x7 + x5 + x + 1
+ *
+ * The RNG_CTL_VCO value of each noise cell must be programmed
+ * seperately.  This is why 4 control register values must be provided
+ * to the hypervisor.  During a write, the hypervisor writes them all,
+ * one at a time, to the actual RNG_CTL register.  The first three
+ * values are used to setup the desired RNG_CTL_VCO for each entropy
+ * source, for example:
+ *
+ *      control 0: (1 << RNG_CTL_VCO_SHIFT) | RNG_CTL_ES1
+ *      control 1: (2 << RNG_CTL_VCO_SHIFT) | RNG_CTL_ES2
+ *      control 2: (3 << RNG_CTL_VCO_SHIFT) | RNG_CTL_ES3
+ *
+ * And then the fourth value sets the final chip state and enables
+ * desired.
+ */
+
+static int n2rng_hv_err_trans(unsigned long hv_err)
+{
+        switch (hv_err) {
+        case HV_EOK:
+                return 0;
+        case HV_EWOULDBLOCK:
+                return -EAGAIN;
+        case HV_ENOACCESS:
+                return -EPERM;
+        case HV_EIO:
+                return -EIO;
+        case HV_EBUSY:
+                return -EBUSY;
+        case HV_EBADALIGN:
+        case HV_ENORADDR:
+                return -EFAULT;
+        default:
+                return -EINVAL;
+        }
+}
+
+static unsigned long n2rng_generic_read_control_v2(unsigned long ra,
+                                                   unsigned long unit)
+{
+        unsigned long hv_err, state, ticks, watchdog_delta, watchdog_status;
+        int block = 0, busy = 0;
+
+        while (1) {
+                hv_err = sun4v_rng_ctl_read_v2(ra, unit, &state,
+                                               &ticks,
+                                               &watchdog_delta,
+                                               &watchdog_status);
+                if (hv_err == HV_EOK)
+                        break;
+
+                if (hv_err == HV_EBUSY) {
+                        if (++busy >= N2RNG_BUSY_LIMIT)
+                                break;
+
+                        udelay(1);
+                } else if (hv_err == HV_EWOULDBLOCK) {
+                        if (++block >= N2RNG_BLOCK_LIMIT)
+                                break;
+
+                        __delay(ticks);
+                } else
+                        break;
+        }
+
+        return hv_err;
+}
+
+/* In multi-socket situations, the hypervisor might need to
+ * queue up the RNG control register write if it's for a unit
+ * that is on a cpu socket other than the one we are executing on.
+ *
+ * We poll here waiting for a successful read of that control
+ * register to make sure the write has been actually performed.
+ */
+static unsigned long n2rng_control_settle_v2(struct n2rng *np, int unit)
+{
+        unsigned long ra = __pa(&np->scratch_control[0]);
+
+        return n2rng_generic_read_control_v2(ra, unit);
+}
+
+static unsigned long n2rng_write_ctl_one(struct n2rng *np, int unit,
+                                         unsigned long state,
+                                         unsigned long control_ra,
+                                         unsigned long watchdog_timeout,
+                                         unsigned long *ticks)
+{
+        unsigned long hv_err;
+
+        if (np->hvapi_major == 1) {
+                hv_err = sun4v_rng_ctl_write_v1(control_ra, state,
+                                                watchdog_timeout, ticks);
+        } else {
+                hv_err = sun4v_rng_ctl_write_v2(control_ra, state,
+                                                watchdog_timeout, unit);
+                if (hv_err == HV_EOK)
+                        hv_err = n2rng_control_settle_v2(np, unit);
+                *ticks = N2RNG_ACCUM_CYCLES_DEFAULT;
+        }
+
+        return hv_err;
+}
+
+static int n2rng_generic_read_data(unsigned long data_ra)
+{
+        unsigned long ticks, hv_err;
+        int block = 0, hcheck = 0;
+
+        while (1) {
+                hv_err = sun4v_rng_data_read(data_ra, &ticks);
+                if (hv_err == HV_EOK)
+                        return 0;
+
+                if (hv_err == HV_EWOULDBLOCK) {
+                        if (++block >= N2RNG_BLOCK_LIMIT)
+                                return -EWOULDBLOCK;
+                        __delay(ticks);
+                } else if (hv_err == HV_ENOACCESS) {
+                        return -EPERM;
+                } else if (hv_err == HV_EIO) {
+                        if (++hcheck >= N2RNG_HCHECK_LIMIT)
+                                return -EIO;
+                        udelay(10000);
+                } else
+                        return -ENODEV;
+        }
+}
+
+static unsigned long n2rng_read_diag_data_one(struct n2rng *np,
+                                              unsigned long unit,
+                                              unsigned long data_ra,
+                                              unsigned long data_len,
+                                              unsigned long *ticks)
+{
+        unsigned long hv_err;
+
+        if (np->hvapi_major == 1) {
+                hv_err = sun4v_rng_data_read_diag_v1(data_ra, data_len, ticks);
+        } else {
+                hv_err = sun4v_rng_data_read_diag_v2(data_ra, data_len,
+                                                     unit, ticks);
+                if (!*ticks)
+                        *ticks = N2RNG_ACCUM_CYCLES_DEFAULT;
+        }
+        return hv_err;
+}
+
+static int n2rng_generic_read_diag_data(struct n2rng *np,
+                                        unsigned long unit,
+                                        unsigned long data_ra,
+                                        unsigned long data_len)
+{
+        unsigned long ticks, hv_err;
+        int block = 0;
+
+        while (1) {
+                hv_err = n2rng_read_diag_data_one(np, unit,
+                                                  data_ra, data_len,
+                                                  &ticks);
+                if (hv_err == HV_EOK)
+                        return 0;
+
+                if (hv_err == HV_EWOULDBLOCK) {
+                        if (++block >= N2RNG_BLOCK_LIMIT)
+                                return -EWOULDBLOCK;
+                        __delay(ticks);
+                } else if (hv_err == HV_ENOACCESS) {
+                        return -EPERM;
+                } else if (hv_err == HV_EIO) {
+                        return -EIO;
+                } else
+                        return -ENODEV;
+        }
+}
+
+
+static int n2rng_generic_write_control(struct n2rng *np,
+                                       unsigned long control_ra,
+                                       unsigned long unit,
+                                       unsigned long state)
+{
+        unsigned long hv_err, ticks;
+        int block = 0, busy = 0;
+
+        while (1) {
+                hv_err = n2rng_write_ctl_one(np, unit, state, control_ra,
+                                             np->wd_timeo, &ticks);
+                if (hv_err == HV_EOK)
+                        return 0;
+
+                if (hv_err == HV_EWOULDBLOCK) {
+                        if (++block >= N2RNG_BLOCK_LIMIT)
+                                return -EWOULDBLOCK;
+                        __delay(ticks);
+                } else if (hv_err == HV_EBUSY) {
+                        if (++busy >= N2RNG_BUSY_LIMIT)
+                                return -EBUSY;
+                        udelay(1);
+                } else
+                        return -ENODEV;
+        }
+}
+
+/* Just try to see if we can successfully access the control register
+ * of the RNG on the domain on which we are currently executing.
+ */
+static int n2rng_try_read_ctl(struct n2rng *np)
+{
+        unsigned long hv_err;
+        unsigned long x;
+
+        if (np->hvapi_major == 1) {
+                hv_err = sun4v_rng_get_diag_ctl();
+        } else {
+                /* We purposefully give invalid arguments, HV_NOACCESS
+                 * is higher priority than the errors we'd get from
+                 * these other cases, and that's the error we are
+                 * truly interested in.
+                 */
+                hv_err = sun4v_rng_ctl_read_v2(0UL, ~0UL, &x, &x, &x, &x);
+                switch (hv_err) {
+                case HV_EWOULDBLOCK:
+                case HV_ENOACCESS:
+                        break;
+                default:
+                        hv_err = HV_EOK;
+                        break;
+                }
+        }
+
+        return n2rng_hv_err_trans(hv_err);
+}
+
+#define CONTROL_DEFAULT_BASE            \
+        ((2 << RNG_CTL_ASEL_SHIFT) |    \
+         (N2RNG_ACCUM_CYCLES_DEFAULT << RNG_CTL_WAIT_SHIFT) |   \
+         RNG_CTL_LFSR)
+
+#define CONTROL_DEFAULT_0               \
+        (CONTROL_DEFAULT_BASE |         \
+         (1 << RNG_CTL_VCO_SHIFT) |     \
+         RNG_CTL_ES1)
+#define CONTROL_DEFAULT_1               \
+        (CONTROL_DEFAULT_BASE |         \
+         (2 << RNG_CTL_VCO_SHIFT) |     \
+         RNG_CTL_ES2)
+#define CONTROL_DEFAULT_2               \
+        (CONTROL_DEFAULT_BASE |         \
+         (3 << RNG_CTL_VCO_SHIFT) |     \
+         RNG_CTL_ES3)
+#define CONTROL_DEFAULT_3               \
+        (CONTROL_DEFAULT_BASE |         \
+         RNG_CTL_ES1 | RNG_CTL_ES2 | RNG_CTL_ES3)
+
+static void n2rng_control_swstate_init(struct n2rng *np)
+{
+        int i;
+
+        np->flags |= N2RNG_FLAG_CONTROL;
+
+        np->health_check_sec = N2RNG_HEALTH_CHECK_SEC_DEFAULT;
+        np->accum_cycles = N2RNG_ACCUM_CYCLES_DEFAULT;
+        np->wd_timeo = N2RNG_WD_TIMEO_DEFAULT;
+
+        for (i = 0; i < np->num_units; i++) {
+                struct n2rng_unit *up = &np->units[i];
+
+                up->control[0] = CONTROL_DEFAULT_0;
+                up->control[1] = CONTROL_DEFAULT_1;
+                up->control[2] = CONTROL_DEFAULT_2;
+                up->control[3] = CONTROL_DEFAULT_3;
+        }
+
+        np->hv_state = HV_RNG_STATE_UNCONFIGURED;
+}
+
+static int n2rng_grab_diag_control(struct n2rng *np)
+{
+        int i, busy_count, err = -ENODEV;
+
+        busy_count = 0;
+        for (i = 0; i < 100; i++) {
+                err = n2rng_try_read_ctl(np);
+                if (err != -EAGAIN)
+                        break;
+
+                if (++busy_count > 100) {
+                        dev_err(&np->op->dev,
+                                "Grab diag control timeout.\n");
+                        return -ENODEV;
+                }
+
+                udelay(1);
+        }
+
+        return err;
+}
+
+static int n2rng_init_control(struct n2rng *np)
+{
+        int err = n2rng_grab_diag_control(np);
+
+        /* Not in the control domain, that's OK we are only a consumer
+         * of the RNG data, we don't setup and program it.
+         */
+        if (err == -EPERM)
+                return 0;
+        if (err)
+                return err;
+
+        n2rng_control_swstate_init(np);
+
+        return 0;
+}
+
+static int n2rng_data_read(struct hwrng *rng, u32 *data)
+{
+        struct n2rng *np = (struct n2rng *) rng->priv;
+        unsigned long ra = __pa(&np->test_data);
+        int len;
+
+        if (!(np->flags & N2RNG_FLAG_READY)) {
+                len = 0;
+        } else if (np->flags & N2RNG_FLAG_BUFFER_VALID) {
+                np->flags &= ~N2RNG_FLAG_BUFFER_VALID;
+                *data = np->buffer;
+                len = 4;
+        } else {
+                int err = n2rng_generic_read_data(ra);
+                if (!err) {
+                        np->buffer = np->test_data >> 32;
+                        *data = np->test_data & 0xffffffff;
+                        len = 4;
+                } else {
+                        dev_err(&np->op->dev, "RNG error, restesting\n");
+                        np->flags &= ~N2RNG_FLAG_READY;
+                        if (!(np->flags & N2RNG_FLAG_SHUTDOWN))
+                                schedule_delayed_work(&np->work, 0);
+                        len = 0;
+                }
+        }
+
+        return len;
+}
+
+/* On a guest node, just make sure we can read random data properly.
+ * If a control node reboots or reloads it's n2rng driver, this won't
+ * work during that time.  So we have to keep probing until the device
+ * becomes usable.
+ */
+static int n2rng_guest_check(struct n2rng *np)
+{
+        unsigned long ra = __pa(&np->test_data);
+
+        return n2rng_generic_read_data(ra);
+}
+
+static int n2rng_entropy_diag_read(struct n2rng *np, unsigned long unit,
+                                   u64 *pre_control, u64 pre_state,
+                                   u64 *buffer, unsigned long buf_len,
+                                   u64 *post_control, u64 post_state)
+{
+        unsigned long post_ctl_ra = __pa(post_control);
+        unsigned long pre_ctl_ra = __pa(pre_control);
+        unsigned long buffer_ra = __pa(buffer);
+        int err;
+
+        err = n2rng_generic_write_control(np, pre_ctl_ra, unit, pre_state);
+        if (err)
+                return err;
+
+        err = n2rng_generic_read_diag_data(np, unit,
+                                           buffer_ra, buf_len);
+
+        (void) n2rng_generic_write_control(np, post_ctl_ra, unit,
+                                           post_state);
+
+        return err;
+}
+
+static u64 advance_polynomial(u64 poly, u64 val, int count)
+{
+        int i;
+
+        for (i = 0; i < count; i++) {
+                int highbit_set = ((s64)val < 0);
+
+                val <<= 1;
+                if (highbit_set)
+                        val ^= poly;
+        }
+
+        return val;
+}
+
+static int n2rng_test_buffer_find(struct n2rng *np, u64 val)
+{
+        int i, count = 0;
+
+        /* Purposefully skip over the first word.  */
+        for (i = 1; i < SELFTEST_BUFFER_WORDS; i++) {
+                if (np->test_buffer[i] == val)
+                        count++;
+        }
+        return count;
+}
+
+static void n2rng_dump_test_buffer(struct n2rng *np)
+{
+        int i;
+
+        for (i = 0; i < SELFTEST_BUFFER_WORDS; i++)
+                dev_err(&np->op->dev, "Test buffer slot %d [0x%016lx]\n",
+                        i, np->test_buffer[i]);
+}
+
+static int n2rng_check_selftest_buffer(struct n2rng *np, unsigned long unit)
+{
+        u64 val = SELFTEST_VAL;
+        int err, matches, limit;
+
+        matches = 0;
+        for (limit = 0; limit < SELFTEST_LOOPS_MAX; limit++) {
+                matches += n2rng_test_buffer_find(np, val);
+                if (matches >= SELFTEST_MATCH_GOAL)
+                        break;
+                val = advance_polynomial(SELFTEST_POLY, val, 1);
+        }
+
+        err = 0;
+        if (limit >= SELFTEST_LOOPS_MAX) {
+                err = -ENODEV;
+                dev_err(&np->op->dev, "Selftest failed on unit %lu\n", unit);
+                n2rng_dump_test_buffer(np);
+        } else
+                dev_info(&np->op->dev, "Selftest passed on unit %lu\n", unit);
+
+        return err;
+}
+
+static int n2rng_control_selftest(struct n2rng *np, unsigned long unit)
+{
+        int err;
+
+        np->test_control[0] = (0x2 << RNG_CTL_ASEL_SHIFT);
+        np->test_control[1] = (0x2 << RNG_CTL_ASEL_SHIFT);
+        np->test_control[2] = (0x2 << RNG_CTL_ASEL_SHIFT);
+        np->test_control[3] = ((0x2 << RNG_CTL_ASEL_SHIFT) |
+                               RNG_CTL_LFSR |
+                               ((SELFTEST_TICKS - 2) << RNG_CTL_WAIT_SHIFT));
+
+
+        err = n2rng_entropy_diag_read(np, unit, np->test_control,
+                                      HV_RNG_STATE_HEALTHCHECK,
+                                      np->test_buffer,
+                                      sizeof(np->test_buffer),
+                                      &np->units[unit].control[0],
+                                      np->hv_state);
+        if (err)
+                return err;
+
+        return n2rng_check_selftest_buffer(np, unit);
+}
+
+static int n2rng_control_check(struct n2rng *np)
+{
+        int i;
+
+        for (i = 0; i < np->num_units; i++) {
+                int err = n2rng_control_selftest(np, i);
+                if (err)
+                        return err;
+        }
+        return 0;
+}
+
+/* The sanity checks passed, install the final configuration into the
+ * chip, it's ready to use.
+ */
+static int n2rng_control_configure_units(struct n2rng *np)
+{
+        int unit, err;
+
+        err = 0;
+        for (unit = 0; unit < np->num_units; unit++) {
+                struct n2rng_unit *up = &np->units[unit];
+                unsigned long ctl_ra = __pa(&up->control[0]);
+                int esrc;
+                u64 base;
+
+                base = ((np->accum_cycles << RNG_CTL_WAIT_SHIFT) |
+                        (2 << RNG_CTL_ASEL_SHIFT) |
+                        RNG_CTL_LFSR);
+
+                /* XXX This isn't the best.  We should fetch a bunch
+                 * XXX of words using each entropy source combined XXX
+                 * with each VCO setting, and see which combinations
+                 * XXX give the best random data.
+                 */
+                for (esrc = 0; esrc < 3; esrc++)
+                        up->control[esrc] = base |
+                                (esrc << RNG_CTL_VCO_SHIFT) |
+                                (RNG_CTL_ES1 << esrc);
+
+                up->control[3] = base |
+                        (RNG_CTL_ES1 | RNG_CTL_ES2 | RNG_CTL_ES3);
+
+                err = n2rng_generic_write_control(np, ctl_ra, unit,
+                                                  HV_RNG_STATE_CONFIGURED);
+                if (err)
+                        break;
+        }
+
+        return err;
+}
+
+static void n2rng_work(struct work_struct *work)
+{
+        struct n2rng *np = container_of(work, struct n2rng, work.work);
+        int err = 0;
+
+        if (!(np->flags & N2RNG_FLAG_CONTROL)) {
+                err = n2rng_guest_check(np);
+        } else {
+                preempt_disable();
+                err = n2rng_control_check(np);
+                preempt_enable();
+
+                if (!err)
+                        err = n2rng_control_configure_units(np);
+        }
+
+        if (!err) {
+                np->flags |= N2RNG_FLAG_READY;
+                dev_info(&np->op->dev, "RNG ready\n");
+        }
+
+        if (err && !(np->flags & N2RNG_FLAG_SHUTDOWN))
+                schedule_delayed_work(&np->work, HZ * 2);
+}
+
+static void __devinit n2rng_driver_version(void)
+{
+        static int n2rng_version_printed;
+
+        if (n2rng_version_printed++ == 0)
+                pr_info("%s", version);
+}
+
+static int __devinit n2rng_probe(struct of_device *op,
+                                 const struct of_device_id *match)
+{
+        int victoria_falls = (match->data != NULL);
+        int err = -ENOMEM;
+        struct n2rng *np;
+
+        n2rng_driver_version();
+
+        np = kzalloc(sizeof(*np), GFP_KERNEL);
+        if (!np)
+                goto out;
+        np->op = op;
+
+        INIT_DELAYED_WORK(&np->work, n2rng_work);
+
+        if (victoria_falls)
+                np->flags |= N2RNG_FLAG_VF;
+
+        err = -ENODEV;
+        np->hvapi_major = 2;
+        if (sun4v_hvapi_register(HV_GRP_RNG,
+                                 np->hvapi_major,
+                                 &np->hvapi_minor)) {
+                np->hvapi_major = 1;
+                if (sun4v_hvapi_register(HV_GRP_RNG,
+                                         np->hvapi_major,
+                                         &np->hvapi_minor)) {
+                        dev_err(&op->dev, "Cannot register suitable "
+                                "HVAPI version.\n");
+                        goto out_free;
+                }
+        }
+
+        if (np->flags & N2RNG_FLAG_VF) {
+                if (np->hvapi_major < 2) {
+                        dev_err(&op->dev, "VF RNG requires HVAPI major "
+                                "version 2 or later, got %lu\n",
+                                np->hvapi_major);
+                        goto out_hvapi_unregister;
+                }
+                np->num_units = of_getintprop_default(op->node,
+                                                      "rng-#units", 0);
+                if (!np->num_units) {
+                        dev_err(&op->dev, "VF RNG lacks rng-#units property\n");
+                        goto out_hvapi_unregister;
+                }
+        } else
+                np->num_units = 1;
+
+        dev_info(&op->dev, "Registered RNG HVAPI major %lu minor %lu\n",
+                 np->hvapi_major, np->hvapi_minor);
+
+        np->units = kzalloc(sizeof(struct n2rng_unit) * np->num_units,
+                            GFP_KERNEL);
+        err = -ENOMEM;
+        if (!np->units)
+                goto out_hvapi_unregister;
+
+        err = n2rng_init_control(np);
+        if (err)
+                goto out_free_units;
+
+        dev_info(&op->dev, "Found %s RNG, units: %d\n",
+                 ((np->flags & N2RNG_FLAG_VF) ?
+                  "Victoria Falls" : "Niagara2"),
+                 np->num_units);
+
+        np->hwrng.name = "n2rng";
+        np->hwrng.data_read = n2rng_data_read;
+        np->hwrng.priv = (unsigned long) np;
+
+        err = hwrng_register(&np->hwrng);
+        if (err)
+                goto out_free_units;
+
+        dev_set_drvdata(&op->dev, np);
+
+        schedule_delayed_work(&np->work, 0);
+
+        return 0;
+
+out_free_units:
+        kfree(np->units);
+        np->units = NULL;
+
+out_hvapi_unregister:
+        sun4v_hvapi_unregister(HV_GRP_RNG);
+
+out_free:
+        kfree(np);
+out:
+        return err;
+}
+
+static int __devexit n2rng_remove(struct of_device *op)
+{
+        struct n2rng *np = dev_get_drvdata(&op->dev);
+
+        np->flags |= N2RNG_FLAG_SHUTDOWN;
+
+        cancel_delayed_work_sync(&np->work);
+
+        hwrng_unregister(&np->hwrng);
+
+        sun4v_hvapi_unregister(HV_GRP_RNG);
+
+        kfree(np->units);
+        np->units = NULL;
+
+        kfree(np);
+
+        dev_set_drvdata(&op->dev, NULL);
+
+        return 0;
+}
+
+static struct of_device_id n2rng_match[] = {
+        {
+                .name           = "random-number-generator",
+                .compatible     = "SUNW,n2-rng",
+        },
+        {
+                .name           = "random-number-generator",
+                .compatible     = "SUNW,vf-rng",
+                .data           = (void *) 1,
+        },
+        {},
+};
+MODULE_DEVICE_TABLE(of, n2rng_match);
+
+static struct of_platform_driver n2rng_driver = {
+        .name           = "n2rng",
+        .match_table    = n2rng_match,
+        .probe          = n2rng_probe,
+        .remove         = __devexit_p(n2rng_remove),
+};
+
+static int __init n2rng_init(void)
+{
+        return of_register_driver(&n2rng_driver, &of_bus_type);
+}
+
+static void __exit n2rng_exit(void)
+{
+        of_unregister_driver(&n2rng_driver);
+}
+
+module_init(n2rng_init);
+module_exit(n2rng_exit);
diff --git a/drivers/char/hw_random/n2rng.h b/drivers/char/hw_random/n2rng.h
new file mode 100644
index 000000000000..a2b81e7bfc18
--- /dev/null
+++ b/drivers/char/hw_random/n2rng.h
@@ -0,0 +1,118 @@
+/* n2rng.h: Niagara2 RNG defines.
+ *
+ * Copyright (C) 2008 David S. Miller <davem@davemloft.net>
+ */
+
+#ifndef _N2RNG_H
+#define _N2RNG_H
+
+#define RNG_CTL_WAIT       0x0000000001fffe00ULL /* Minimum wait time       */
+#define RNG_CTL_WAIT_SHIFT 9
+#define RNG_CTL_BYPASS     0x0000000000000100ULL /* VCO voltage source      */
+#define RNG_CTL_VCO        0x00000000000000c0ULL /* VCO rate control        */
+#define RNG_CTL_VCO_SHIFT  6
+#define RNG_CTL_ASEL       0x0000000000000030ULL /* Analog MUX select       */
+#define RNG_CTL_ASEL_SHIFT 4
+#define RNG_CTL_LFSR       0x0000000000000008ULL /* Use LFSR or plain shift */
+#define RNG_CTL_ES3        0x0000000000000004ULL /* Enable entropy source 3 */
+#define RNG_CTL_ES2        0x0000000000000002ULL /* Enable entropy source 2 */
+#define RNG_CTL_ES1        0x0000000000000001ULL /* Enable entropy source 1 */
+
+#define HV_FAST_RNG_GET_DIAG_CTL        0x130
+#define HV_FAST_RNG_CTL_READ            0x131
+#define HV_FAST_RNG_CTL_WRITE           0x132
+#define HV_FAST_RNG_DATA_READ_DIAG      0x133
+#define HV_FAST_RNG_DATA_READ           0x134
+
+#define HV_RNG_STATE_UNCONFIGURED       0
+#define HV_RNG_STATE_CONFIGURED         1
+#define HV_RNG_STATE_HEALTHCHECK        2
+#define HV_RNG_STATE_ERROR              3
+
+#define HV_RNG_NUM_CONTROL              4
+
+#ifndef __ASSEMBLY__
+extern unsigned long sun4v_rng_get_diag_ctl(void);
+extern unsigned long sun4v_rng_ctl_read_v1(unsigned long ctl_regs_ra,
+                                           unsigned long *state,
+                                           unsigned long *tick_delta);
+extern unsigned long sun4v_rng_ctl_read_v2(unsigned long ctl_regs_ra,
+                                           unsigned long unit,
+                                           unsigned long *state,
+                                           unsigned long *tick_delta,
+                                           unsigned long *watchdog,
+                                           unsigned long *write_status);
+extern unsigned long sun4v_rng_ctl_write_v1(unsigned long ctl_regs_ra,
+                                            unsigned long state,
+                                            unsigned long write_timeout,
+                                            unsigned long *tick_delta);
+extern unsigned long sun4v_rng_ctl_write_v2(unsigned long ctl_regs_ra,
+                                            unsigned long state,
+                                            unsigned long write_timeout,
+                                            unsigned long unit);
+extern unsigned long sun4v_rng_data_read_diag_v1(unsigned long data_ra,
+                                                 unsigned long len,
+                                                 unsigned long *tick_delta);
+extern unsigned long sun4v_rng_data_read_diag_v2(unsigned long data_ra,
+                                                 unsigned long len,
+                                                 unsigned long unit,
+                                                 unsigned long *tick_delta);
+extern unsigned long sun4v_rng_data_read(unsigned long data_ra,
+                                         unsigned long *tick_delta);
+
+struct n2rng_unit {
+        u64                     control[HV_RNG_NUM_CONTROL];
+};
+
+struct n2rng {
+        struct of_device        *op;
+
+        unsigned long           flags;
+#define N2RNG_FLAG_VF           0x00000001 /* Victoria Falls RNG, else N2 */
+#define N2RNG_FLAG_CONTROL      0x00000002 /* Operating in control domain */
+#define N2RNG_FLAG_READY        0x00000008 /* Ready for hw-rng layer      */
+#define N2RNG_FLAG_SHUTDOWN     0x00000010 /* Driver unregistering        */
+#define N2RNG_FLAG_BUFFER_VALID 0x00000020 /* u32 buffer holds valid data */
+
+        int                     num_units;
+        struct n2rng_unit       *units;
+
+        struct hwrng            hwrng;
+        u32                     buffer;
+
+        /* Registered hypervisor group API major and minor version.  */
+        unsigned long           hvapi_major;
+        unsigned long           hvapi_minor;
+
+        struct delayed_work     work;
+
+        unsigned long           hv_state; /* HV_RNG_STATE_foo */
+
+        unsigned long           health_check_sec;
+        unsigned long           accum_cycles;
+        unsigned long           wd_timeo;
+#define N2RNG_HEALTH_CHECK_SEC_DEFAULT  0
+#define N2RNG_ACCUM_CYCLES_DEFAULT      2048
+#define N2RNG_WD_TIMEO_DEFAULT          0
+
+        u64                     scratch_control[HV_RNG_NUM_CONTROL];
+
+#define SELFTEST_TICKS          38859
+#define SELFTEST_VAL            ((u64)0xB8820C7BD387E32C)
+#define SELFTEST_POLY           ((u64)0x231DCEE91262B8A3)
+#define SELFTEST_MATCH_GOAL     6
+#define SELFTEST_LOOPS_MAX      40000
+#define SELFTEST_BUFFER_WORDS   8
+
+        u64                     test_data;
+        u64                     test_control[HV_RNG_NUM_CONTROL];
+        u64                     test_buffer[SELFTEST_BUFFER_WORDS];
+};
+
+#define N2RNG_BLOCK_LIMIT       60000
+#define N2RNG_BUSY_LIMIT        100
+#define N2RNG_HCHECK_LIMIT      100
+
+#endif /* !(__ASSEMBLY__) */
+
+#endif /* _N2RNG_H */
diff --git a/drivers/char/istallion.c b/drivers/char/istallion.c
index 6ef1c565705c..7930fba4bafc 100644
--- a/drivers/char/istallion.c
+++ b/drivers/char/istallion.c
@@ -598,7 +598,7 @@ static int	stli_parsebrd(struct stlconf *confp, char **argp);
 static int      stli_open(struct tty_struct *tty, struct file *filp);
 static void     stli_close(struct tty_struct *tty, struct file *filp);
 static int      stli_write(struct tty_struct *tty, const unsigned char *buf, int count);
-static void     stli_putchar(struct tty_struct *tty, unsigned char ch);
+static int      stli_putchar(struct tty_struct *tty, unsigned char ch);
 static void     stli_flushchars(struct tty_struct *tty);
 static int      stli_writeroom(struct tty_struct *tty);
 static int      stli_charsinbuffer(struct tty_struct *tty);
@@ -826,7 +826,7 @@ static int stli_open(struct tty_struct *tty, struct file *filp)
  */
         portp->port.tty = tty;
         tty->driver_data = portp;
-        portp->refcount++;
+        portp->port.count++;
 
         wait_event_interruptible(portp->raw_wait,
                         !test_bit(ST_INITIALIZING, &portp->state));
@@ -888,9 +888,9 @@ static void stli_close(struct tty_struct *tty, struct file *filp)
                 spin_unlock_irqrestore(&stli_lock, flags);
                 return;
         }
-        if ((tty->count == 1) && (portp->refcount != 1))
-                portp->refcount = 1;
-        if (portp->refcount-- > 1) {
+        if ((tty->count == 1) && (portp->port.count != 1))
+                portp->port.count = 1;
+        if (portp->port.count-- > 1) {
                 spin_unlock_irqrestore(&stli_lock, flags);
                 return;
         }
@@ -925,8 +925,8 @@ static void stli_close(struct tty_struct *tty, struct file *filp)
         clear_bit(ST_TXBUSY, &portp->state);
         clear_bit(ST_RXSTOP, &portp->state);
         set_bit(TTY_IO_ERROR, &tty->flags);
-        if (tty->ldisc.flush_buffer)
-                (tty->ldisc.flush_buffer)(tty);
+        if (tty->ldisc.ops->flush_buffer)
+                (tty->ldisc.ops->flush_buffer)(tty);
         set_bit(ST_DOFLUSHRX, &portp->state);
         stli_flushbuffer(tty);
 
@@ -1202,7 +1202,7 @@ static int stli_waitcarrier(struct stlibrd *brdp, struct stliport *portp, struct
         spin_lock_irqsave(&stli_lock, flags);
         portp->openwaitcnt++;
         if (! tty_hung_up_p(filp))
-                portp->refcount--;
+                portp->port.count--;
         spin_unlock_irqrestore(&stli_lock, flags);
 
         for (;;) {
@@ -1231,7 +1231,7 @@ static int stli_waitcarrier(struct stlibrd *brdp, struct stliport *portp, struct
 
         spin_lock_irqsave(&stli_lock, flags);
         if (! tty_hung_up_p(filp))
-                portp->refcount++;
+                portp->port.count++;
         portp->openwaitcnt--;
         spin_unlock_irqrestore(&stli_lock, flags);
 
@@ -1333,7 +1333,7 @@ static int stli_write(struct tty_struct *tty, const unsigned char *buf, int coun
  *      first them do the new ports.
  */
 
-static void stli_putchar(struct tty_struct *tty, unsigned char ch)
+static int stli_putchar(struct tty_struct *tty, unsigned char ch)
 {
         if (tty != stli_txcooktty) {
                 if (stli_txcooktty != NULL)
@@ -1342,6 +1342,7 @@ static void stli_putchar(struct tty_struct *tty, unsigned char ch)
         }
 
         stli_txcookbuf[stli_txcooksize++] = ch;
+        return 0;
 }
 
 /*****************************************************************************/
@@ -1660,7 +1661,6 @@ static int stli_ioctl(struct tty_struct *tty, struct file *file, unsigned int cm
 {
         struct stliport *portp;
         struct stlibrd *brdp;
-        unsigned int ival;
         int rc;
         void __user *argp = (void __user *)arg;
 
@@ -1857,7 +1857,7 @@ static void stli_hangup(struct tty_struct *tty)
         set_bit(TTY_IO_ERROR, &tty->flags);
         portp->port.tty = NULL;
         portp->port.flags &= ~ASYNC_NORMAL_ACTIVE;
-        portp->refcount = 0;
+        portp->port.count = 0;
         spin_unlock_irqrestore(&stli_lock, flags);
 
         wake_up_interruptible(&portp->port.open_wait);
@@ -4246,7 +4246,7 @@ static int stli_portcmdstats(struct stliport *portp)
         stli_comstats.panel = portp->panelnr;
         stli_comstats.port = portp->portnr;
         stli_comstats.state = portp->state;
-        stli_comstats.flags = portp->port.flag;
+        stli_comstats.flags = portp->port.flags;
 
         spin_lock_irqsave(&brd_lock, flags);
         if (portp->port.tty != NULL) {
diff --git a/drivers/char/keyboard.c b/drivers/char/keyboard.c
index d9a0a53c842d..7b3a212c86b1 100644
--- a/drivers/char/keyboard.c
+++ b/drivers/char/keyboard.c
@@ -46,6 +46,8 @@
 
 extern void ctrl_alt_del(void);
 
+#define to_handle_h(n) container_of(n, struct input_handle, h_node)
+
 /*
  * Exported functions/variables
  */
diff --git a/drivers/hwmon/hdaps.c b/drivers/hwmon/hdaps.c
index 50f22690d611..a4d92d246d52 100644
--- a/drivers/hwmon/hdaps.c
+++ b/drivers/hwmon/hdaps.c
@@ -581,6 +581,8 @@ static int __init hdaps_init(void)
         /* initialize the input class */
         idev = hdaps_idev->input;
         idev->name = "hdaps";
+        idev->phys = "isa1600/input0";
+        idev->id.bustype = BUS_ISA;
         idev->dev.parent = &pdev->dev;
         idev->evbit[0] = BIT_MASK(EV_ABS);
         input_set_abs_params(idev, ABS_X,
diff --git a/drivers/input/evbug.c b/drivers/input/evbug.c
index c21f2f127234..0353601ac3b5 100644
--- a/drivers/input/evbug.c
+++ b/drivers/input/evbug.c
@@ -1,6 +1,4 @@
 /*
- * $Id: evbug.c,v 1.10 2001/09/25 10:12:07 vojtech Exp $
- *
  *  Copyright (c) 1999-2001 Vojtech Pavlik
  */
 
@@ -41,7 +39,7 @@ MODULE_LICENSE("GPL");
 static void evbug_event(struct input_handle *handle, unsigned int type, unsigned int code, int value)
 {
         printk(KERN_DEBUG "evbug.c: Event. Dev: %s, Type: %d, Code: %d, Value: %d\n",
-                handle->dev->phys, type, code, value);
+                handle->dev->dev.bus_id, type, code, value);
 }
 
 static int evbug_connect(struct input_handler *handler, struct input_dev *dev,
@@ -66,7 +64,10 @@ static int evbug_connect(struct input_handler *handler, struct input_dev *dev,
         if (error)
                 goto err_unregister_handle;
 
-        printk(KERN_DEBUG "evbug.c: Connected device: \"%s\", %s\n", dev->name, dev->phys);
+        printk(KERN_DEBUG "evbug.c: Connected device: %s (%s at %s)\n",
+                dev->dev.bus_id,
+                dev->name ?: "unknown",
+                dev->phys ?: "unknown");
 
         return 0;
 
@@ -79,7 +80,8 @@ static int evbug_connect(struct input_handler *handler, struct input_dev *dev,
 
 static void evbug_disconnect(struct input_handle *handle)
 {
-        printk(KERN_DEBUG "evbug.c: Disconnected device: %s\n", handle->dev->phys);
+        printk(KERN_DEBUG "evbug.c: Disconnected device: %s\n",
+                handle->dev->dev.bus_id);
 
         input_close_device(handle);
         input_unregister_handle(handle);
diff --git a/drivers/input/evdev.c b/drivers/input/evdev.c
index b32984bc516f..2d65411f6763 100644
--- a/drivers/input/evdev.c
+++ b/drivers/input/evdev.c
@@ -300,6 +300,35 @@ struct input_event_compat {
         __s32 value;
 };
 
+struct ff_periodic_effect_compat {
+        __u16 waveform;
+        __u16 period;
+        __s16 magnitude;
+        __s16 offset;
+        __u16 phase;
+
+        struct ff_envelope envelope;
+
+        __u32 custom_len;
+        compat_uptr_t custom_data;
+};
+
+struct ff_effect_compat {
+        __u16 type;
+        __s16 id;
+        __u16 direction;
+        struct ff_trigger trigger;
+        struct ff_replay replay;
+
+        union {
+                struct ff_constant_effect constant;
+                struct ff_ramp_effect ramp;
+                struct ff_periodic_effect_compat periodic;
+                struct ff_condition_effect condition[2]; /* One for each axis */
+                struct ff_rumble_effect rumble;
+        } u;
+};
+
 /* Note to the author of this code: did it ever occur to
    you why the ifdefs are needed? Think about it again. -AK */
 #ifdef CONFIG_X86_64
@@ -368,6 +397,42 @@ static int evdev_event_to_user(char __user *buffer,
         return 0;
 }
 
+static int evdev_ff_effect_from_user(const char __user *buffer, size_t size,
+                                     struct ff_effect *effect)
+{
+        if (COMPAT_TEST) {
+                struct ff_effect_compat *compat_effect;
+
+                if (size != sizeof(struct ff_effect_compat))
+                        return -EINVAL;
+
+                /*
+                 * It so happens that the pointer which needs to be changed
+                 * is the last field in the structure, so we can copy the
+                 * whole thing and replace just the pointer.
+                 */
+
+                compat_effect = (struct ff_effect_compat *)effect;
+
+                if (copy_from_user(compat_effect, buffer,
+                                   sizeof(struct ff_effect_compat)))
+                        return -EFAULT;
+
+                if (compat_effect->type == FF_PERIODIC &&
+                    compat_effect->u.periodic.waveform == FF_CUSTOM)
+                        effect->u.periodic.custom_data =
+                                compat_ptr(compat_effect->u.periodic.custom_data);
+        } else {
+                if (size != sizeof(struct ff_effect))
+                        return -EINVAL;
+
+                if (copy_from_user(effect, buffer, sizeof(struct ff_effect)))
+                        return -EFAULT;
+        }
+
+        return 0;
+}
+
 #else
 
 static inline size_t evdev_event_size(void)
@@ -393,6 +458,18 @@ static int evdev_event_to_user(char __user *buffer,
         return 0;
 }
 
+static int evdev_ff_effect_from_user(const char __user *buffer, size_t size,
+                                     struct ff_effect *effect)
+{
+        if (size != sizeof(struct ff_effect))
+                return -EINVAL;
+
+        if (copy_from_user(effect, buffer, sizeof(struct ff_effect)))
+                return -EFAULT;
+
+        return 0;
+}
+
 #endif /* CONFIG_COMPAT */
 
 static ssize_t evdev_write(struct file *file, const char __user *buffer,
@@ -633,17 +710,6 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,
 
                 return input_set_keycode(dev, t, v);
 
-        case EVIOCSFF:
-                if (copy_from_user(&effect, p, sizeof(effect)))
-                        return -EFAULT;
-
-                error = input_ff_upload(dev, &effect, file);
-
-                if (put_user(effect.id, &(((struct ff_effect __user *)p)->id)))
-                        return -EFAULT;
-
-                return error;
-
         case EVIOCRMFF:
                 return input_ff_erase(dev, (int)(unsigned long) p, file);
 
@@ -733,6 +799,19 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,
 
                 if (_IOC_DIR(cmd) == _IOC_WRITE) {
 
+                        if (_IOC_NR(cmd) == _IOC_NR(EVIOCSFF)) {
+
+                                if (evdev_ff_effect_from_user(p, _IOC_SIZE(cmd), &effect))
+                                        return -EFAULT;
+
+                                error = input_ff_upload(dev, &effect, file);
+
+                                if (put_user(effect.id, &(((struct ff_effect __user *)p)->id)))
+                                        return -EFAULT;
+
+                                return error;
+                        }
+
                         if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0))) {
 
                                 t = _IOC_NR(cmd) & ABS_MAX;
diff --git a/drivers/input/ff-memless.c b/drivers/input/ff-memless.c
index d226d935b0dc..6790e975a98c 100644
--- a/drivers/input/ff-memless.c
+++ b/drivers/input/ff-memless.c
@@ -247,9 +247,9 @@ static void ml_combine_effects(struct ff_effect *effect,
                  * in s8, this should be changed to something more generic
                  */
                 effect->u.ramp.start_level =
-                        max(min(effect->u.ramp.start_level + x, 0x7f), -0x80);
+                        clamp_val(effect->u.ramp.start_level + x, -0x80, 0x7f);
                 effect->u.ramp.end_level =
-                        max(min(effect->u.ramp.end_level + y, 0x7f), -0x80);
+                        clamp_val(effect->u.ramp.end_level + y, -0x80, 0x7f);
                 break;
 
         case FF_RUMBLE:
diff --git a/drivers/input/gameport/emu10k1-gp.c b/drivers/input/gameport/emu10k1-gp.c
index 9793ac36d17f..b04930f7ea7d 100644
--- a/drivers/input/gameport/emu10k1-gp.c
+++ b/drivers/input/gameport/emu10k1-gp.c
@@ -1,6 +1,4 @@
 /*
- * $Id: emu10k1-gp.c,v 1.8 2002/01/22 20:40:46 vojtech Exp $
- *
  *  Copyright (c) 2001 Vojtech Pavlik
  */
 
diff --git a/drivers/input/gameport/gameport.c b/drivers/input/gameport/gameport.c
index c5600ac5feb3..078e4eed0894 100644
--- a/drivers/input/gameport/gameport.c
+++ b/drivers/input/gameport/gameport.c
@@ -36,7 +36,6 @@ EXPORT_SYMBOL(__gameport_register_driver);
 EXPORT_SYMBOL(gameport_unregister_driver);
 EXPORT_SYMBOL(gameport_open);
 EXPORT_SYMBOL(gameport_close);
-EXPORT_SYMBOL(gameport_rescan);
 EXPORT_SYMBOL(gameport_set_phys);
 EXPORT_SYMBOL(gameport_start_polling);
 EXPORT_SYMBOL(gameport_stop_polling);
@@ -230,8 +229,6 @@ static void gameport_find_driver(struct gameport *gameport)
  */
 
 enum gameport_event_type {
-        GAMEPORT_RESCAN,
-        GAMEPORT_RECONNECT,
         GAMEPORT_REGISTER_PORT,
         GAMEPORT_REGISTER_DRIVER,
 };
@@ -365,15 +362,6 @@ static void gameport_handle_event(void)
                                 gameport_add_port(event->object);
                                 break;
 
-                        case GAMEPORT_RECONNECT:
-                                gameport_reconnect_port(event->object);
-                                break;
-
-                        case GAMEPORT_RESCAN:
-                                gameport_disconnect_port(event->object);
-                                gameport_find_driver(event->object);
-                                break;
-
                         case GAMEPORT_REGISTER_DRIVER:
                                 gameport_add_driver(event->object);
                                 break;
@@ -651,16 +639,6 @@ static void gameport_disconnect_port(struct gameport *gameport)
         device_release_driver(&gameport->dev);
 }
 
-void gameport_rescan(struct gameport *gameport)
-{
-        gameport_queue_event(gameport, NULL, GAMEPORT_RESCAN);
-}
-
-void gameport_reconnect(struct gameport *gameport)
-{
-        gameport_queue_event(gameport, NULL, GAMEPORT_RECONNECT);
-}
-
 /*
  * Submits register request to kgameportd for subsequent execution.
  * Note that port registration is always asynchronous.
diff --git a/drivers/input/gameport/lightning.c b/drivers/input/gameport/lightning.c
index 6b4d4561d465..06ad36ed3483 100644
--- a/drivers/input/gameport/lightning.c
+++ b/drivers/input/gameport/lightning.c
@@ -1,6 +1,4 @@
 /*
- * $Id: lightning.c,v 1.20 2002/01/22 20:41:31 vojtech Exp $
- *
  *  Copyright (c) 1998-2001 Vojtech Pavlik
  */
 
diff --git a/drivers/input/gameport/ns558.c b/drivers/input/gameport/ns558.c
index 7b7a546323cf..2b282cde4b89 100644
--- a/drivers/input/gameport/ns558.c
+++ b/drivers/input/gameport/ns558.c
@@ -1,6 +1,4 @@
 /*
- * $Id: ns558.c,v 1.43 2002/01/24 19:23:21 vojtech Exp $
- *
  *  Copyright (c) 1999-2001 Vojtech Pavlik
  *  Copyright (c) 1999 Brian Gerst
  */
diff --git a/drivers/input/input.c b/drivers/input/input.c
index 408df0bd6be5..c13ced3e0d3d 100644
--- a/drivers/input/input.c
+++ b/drivers/input/input.c
@@ -242,7 +242,7 @@ static void input_handle_event(struct input_dev *dev,
                 break;
         }
 
-        if (type != EV_SYN)
+        if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
                 dev->sync = 0;
 
         if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
diff --git a/drivers/input/joystick/a3d.c b/drivers/input/joystick/a3d.c
index 52ba16f487c7..92498d470b1f 100644
--- a/drivers/input/joystick/a3d.c
+++ b/drivers/input/joystick/a3d.c
@@ -1,6 +1,4 @@
 /*
- * $Id: a3d.c,v 1.21 2002/01/22 20:11:50 vojtech Exp $
- *
  *  Copyright (c) 1998-2001 Vojtech Pavlik
  */
 
diff --git a/drivers/input/joystick/amijoy.c b/drivers/input/joystick/amijoy.c
index deb9f825f92c..05022f07ec77 100644
--- a/drivers/input/joystick/amijoy.c
+++ b/drivers/input/joystick/amijoy.c
@@ -1,6 +1,4 @@
 /*
- * $Id: amijoy.c,v 1.13 2002/01/22 20:26:32 vojtech Exp $
- *
  *  Copyright (c) 1998-2001 Vojtech Pavlik
  */
 
diff --git a/drivers/input/joystick/cobra.c b/drivers/input/joystick/cobra.c
index 55646a6d89f5..639b975a8ed7 100644
--- a/drivers/input/joystick/cobra.c
+++ b/drivers/input/joystick/cobra.c
@@ -1,6 +1,4 @@
 /*
- * $Id: cobra.c,v 1.19 2002/01/22 20:26:52 vojtech Exp $
- *
  *  Copyright (c) 1999-2001 Vojtech Pavlik
  */
 
diff --git a/drivers/input/joystick/db9.c b/drivers/input/joystick/db9.c
index 960e501c60c8..523959484753 100644
--- a/drivers/input/joystick/db9.c
+++ b/drivers/input/joystick/db9.c
@@ -1,6 +1,4 @@
 /*
- * $Id: db9.c,v 1.13 2002/04/07 20:13:37 vojtech Exp $
- *
  *  Copyright (c) 1999-2001 Vojtech Pavlik
  *
  *  Based on the work of:
diff --git a/drivers/input/joystick/gf2k.c b/drivers/input/joystick/gf2k.c
index 1f6302c0eb3f..cb6eef1f2d99 100644
--- a/drivers/input/joystick/gf2k.c
+++ b/drivers/input/joystick/gf2k.c
@@ -1,6 +1,4 @@
 /*
- * $Id: gf2k.c,v 1.19 2002/01/22 20:27:43 vojtech Exp $
- *
  *  Copyright (c) 1998-2001 Vojtech Pavlik
  */
 
diff --git a/drivers/input/joystick/grip.c b/drivers/input/joystick/grip.c
index fd3853ab1aad..684e07cfccc8 100644
--- a/drivers/input/joystick/grip.c
+++ b/drivers/input/joystick/grip.c
@@ -1,6 +1,4 @@
 /*
- * $Id: grip.c,v 1.21 2002/01/22 20:27:57 vojtech Exp $
- *
  *  Copyright (c) 1998-2001 Vojtech Pavlik
  */
 
diff --git a/drivers/input/joystick/grip_mp.c b/drivers/input/joystick/grip_mp.c
index c57e21d68c00..8279481b16e7 100644
--- a/drivers/input/joystick/grip_mp.c
+++ b/drivers/input/joystick/grip_mp.c
@@ -1,6 +1,4 @@
 /*
- * $Id: grip_mp.c,v 1.9 2002/07/20 19:28:45 bonnland Exp $
- *
  *  Driver for the Gravis Grip Multiport, a gamepad "hub" that
  *  connects up to four 9-pin digital gamepads/joysticks.
  *  Driver tested on SMP and UP kernel versions 2.4.18-4 and 2.4.18-5.
diff --git a/drivers/input/joystick/guillemot.c b/drivers/input/joystick/guillemot.c
index aa6bfb3fb8cd..25ec3fad9f27 100644
--- a/drivers/input/joystick/guillemot.c
+++ b/drivers/input/joystick/guillemot.c
@@ -1,6 +1,4 @@
 /*
- * $Id: guillemot.c,v 1.10 2002/01/22 20:28:12 vojtech Exp $
- *
  *  Copyright (c) 2001 Vojtech Pavlik
  */
 
diff --git a/drivers/input/joystick/iforce/iforce-ff.c b/drivers/input/joystick/iforce/iforce-ff.c
index f2a4381d0ab8..7839b7b6fa96 100644
--- a/drivers/input/joystick/iforce/iforce-ff.c
+++ b/drivers/input/joystick/iforce/iforce-ff.c
@@ -1,6 +1,4 @@
 /*
- * $Id: iforce-ff.c,v 1.9 2002/02/02 19:28:35 jdeneux Exp $
- *
  *  Copyright (c) 2000-2002 Vojtech Pavlik <vojtech@ucw.cz>
  *  Copyright (c) 2001-2002, 2007 Johann Deneux <johann.deneux@gmail.com>
  *
diff --git a/drivers/input/joystick/iforce/iforce-main.c b/drivers/input/joystick/iforce/iforce-main.c
index a2517fa72eb8..61ee6e38739d 100644
--- a/drivers/input/joystick/iforce/iforce-main.c
+++ b/drivers/input/joystick/iforce/iforce-main.c
@@ -1,6 +1,4 @@
 /*
- * $Id: iforce-main.c,v 1.19 2002/07/07 10:22:50 jdeneux Exp $
- *
  *  Copyright (c) 2000-2002 Vojtech Pavlik <vojtech@ucw.cz>
  *  Copyright (c) 2001-2002, 2007 Johann Deneux <johann.deneux@gmail.com>
  *
diff --git a/drivers/input/joystick/iforce/iforce-packets.c b/drivers/input/joystick/iforce/iforce-packets.c
index 45c4939ced75..015b50aa76fc 100644
--- a/drivers/input/joystick/iforce/iforce-packets.c
+++ b/drivers/input/joystick/iforce/iforce-packets.c
@@ -1,6 +1,4 @@
 /*
- * $Id: iforce-packets.c,v 1.16 2002/07/07 10:22:50 jdeneux Exp $
- *
  *  Copyright (c) 2000-2002 Vojtech Pavlik <vojtech@ucw.cz>
  *  Copyright (c) 2001-2002, 2007 Johann Deneux <johann.deneux@gmail.com>
  *
diff --git a/drivers/input/joystick/iforce/iforce-serio.c b/drivers/input/joystick/iforce/iforce-serio.c
index 7b4bc19cef27..46d5041d2d9d 100644
--- a/drivers/input/joystick/iforce/iforce-serio.c
+++ b/drivers/input/joystick/iforce/iforce-serio.c
@@ -1,6 +1,4 @@
 /*
- * $Id: iforce-serio.c,v 1.4 2002/01/28 22:45:00 jdeneux Exp $
- *
  *  Copyright (c) 2000-2001 Vojtech Pavlik <vojtech@ucw.cz>
  *  Copyright (c) 2001, 2007 Johann Deneux <johann.deneux@gmail.com>
  *
diff --git a/drivers/input/joystick/iforce/iforce-usb.c b/drivers/input/joystick/iforce/iforce-usb.c
index 7fb3cf81cfbf..851cc4087c2f 100644
--- a/drivers/input/joystick/iforce/iforce-usb.c
+++ b/drivers/input/joystick/iforce/iforce-usb.c
@@ -1,6 +1,4 @@
  /*
- * $Id: iforce-usb.c,v 1.16 2002/06/09 11:08:04 jdeneux Exp $
- *
  *  Copyright (c) 2000-2002 Vojtech Pavlik <vojtech@ucw.cz>
  *  Copyright (c) 2001-2002, 2007 Johann Deneux <johann.deneux@gmail.com>
  *
@@ -89,10 +87,10 @@ static void iforce_usb_irq(struct urb *urb)
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
                 dbg("%s - urb shutting down with status: %d",
-                    __FUNCTION__, urb->status);
+                    __func__, urb->status);
                 return;
         default:
-                dbg("%s - urb has status of: %d", __FUNCTION__, urb->status);
+                dbg("%s - urb has status of: %d", __func__, urb->status);
                 goto exit;
         }
 
@@ -103,7 +101,7 @@ exit:
         status = usb_submit_urb (urb, GFP_ATOMIC);
         if (status)
                 err ("%s - usb_submit_urb failed with result %d",
-                     __FUNCTION__, status);
+                     __func__, status);
 }
 
 static void iforce_usb_out(struct urb *urb)
diff --git a/drivers/input/joystick/iforce/iforce.h b/drivers/input/joystick/iforce/iforce.h
index a964a7cfd210..f2d91f4028ca 100644
--- a/drivers/input/joystick/iforce/iforce.h
+++ b/drivers/input/joystick/iforce/iforce.h
@@ -1,6 +1,4 @@
 /*
- * $Id: iforce.h,v 1.13 2002/07/07 10:22:50 jdeneux Exp $
- *
  *  Copyright (c) 2000-2002 Vojtech Pavlik <vojtech@ucw.cz>
  *  Copyright (c) 2001-2002, 2007 Johann Deneux <johann.deneux@gmail.com>
  *
diff --git a/drivers/input/joystick/interact.c b/drivers/input/joystick/interact.c
index bc8ea95dfd0e..8c3290b68205 100644
--- a/drivers/input/joystick/interact.c
+++ b/drivers/input/joystick/interact.c
@@ -1,6 +1,4 @@
 /*
- * $Id: interact.c,v 1.16 2002/01/22 20:28:25 vojtech Exp $
- *
  *  Copyright (c) 2001 Vojtech Pavlik
  *
  *  Based on the work of:
diff --git a/drivers/input/joystick/joydump.c b/drivers/input/joystick/joydump.c
index 88ec5a918f2e..2a1b82c8b31c 100644
--- a/drivers/input/joystick/joydump.c
+++ b/drivers/input/joystick/joydump.c
@@ -1,6 +1,4 @@
 /*
- * $Id: joydump.c,v 1.1 2002/01/23 06:56:16 jsimmons Exp $
- *
  *  Copyright (c) 1996-2001 Vojtech Pavlik
  */
 
diff --git a/drivers/input/joystick/magellan.c b/drivers/input/joystick/magellan.c
index 54e676948ebb..40e40780747d 100644
--- a/drivers/input/joystick/magellan.c
+++ b/drivers/input/joystick/magellan.c
@@ -1,6 +1,4 @@
 /*
- * $Id: magellan.c,v 1.16 2002/01/22 20:28:39 vojtech Exp $
- *
  *  Copyright (c) 1999-2001 Vojtech Pavlik
  */
 
diff --git a/drivers/input/joystick/spaceball.c b/drivers/input/joystick/spaceball.c
index d4087fd49656..0cd9b29356a8 100644
--- a/drivers/input/joystick/spaceball.c
+++ b/drivers/input/joystick/spaceball.c
@@ -1,6 +1,4 @@
 /*
- * $Id: spaceball.c,v 1.17 2002/01/22 20:29:03 vojtech Exp $
- *
  *  Copyright (c) 1999-2001 Vojtech Pavlik
  *
  *  Based on the work of:
diff --git a/drivers/input/joystick/spaceorb.c b/drivers/input/joystick/spaceorb.c
index f7ce4004f4ba..a694bf8e557b 100644
--- a/drivers/input/joystick/spaceorb.c
+++ b/drivers/input/joystick/spaceorb.c
@@ -1,6 +1,4 @@
 /*
- * $Id: spaceorb.c,v 1.15 2002/01/22 20:29:19 vojtech Exp $
- *
  *  Copyright (c) 1999-2001 Vojtech Pavlik
  *
  *  Based on the work of:
diff --git a/drivers/input/joystick/stinger.c b/drivers/input/joystick/stinger.c
index baa10b2f7ba1..e0db9f5e4b41 100644
--- a/drivers/input/joystick/stinger.c
+++ b/drivers/input/joystick/stinger.c
@@ -1,6 +1,4 @@
 /*
- * $Id: stinger.c,v 1.10 2002/01/22 20:29:31 vojtech Exp $
- *
  *  Copyright (c) 2000-2001 Vojtech Pavlik
  *  Copyright (c) 2000 Mark Fletcher
  */
diff --git a/drivers/input/joystick/tmdc.c b/drivers/input/joystick/tmdc.c
index 0feeb8acb532..60c37bcb938d 100644
--- a/drivers/input/joystick/tmdc.c
+++ b/drivers/input/joystick/tmdc.c
@@ -1,6 +1,4 @@
 /*
- * $Id: tmdc.c,v 1.31 2002/01/22 20:29:52 vojtech Exp $
- *
  *  Copyright (c) 1998-2001 Vojtech Pavlik
  *
  *   Based on the work of:
diff --git a/drivers/input/joystick/turbografx.c b/drivers/input/joystick/turbografx.c
index 989483f53160..b6f859869540 100644
--- a/drivers/input/joystick/turbografx.c
+++ b/drivers/input/joystick/turbografx.c
@@ -1,6 +1,4 @@
 /*
- * $Id: turbografx.c,v 1.14 2002/01/22 20:30:39 vojtech Exp $
- *
  *  Copyright (c) 1998-2001 Vojtech Pavlik
  *
  *  Based on the work of:
diff --git a/drivers/input/joystick/twidjoy.c b/drivers/input/joystick/twidjoy.c
index 1085c841fec4..3f4ec73c9553 100644
--- a/drivers/input/joystick/twidjoy.c
+++ b/drivers/input/joystick/twidjoy.c
@@ -1,8 +1,4 @@
 /*
- * $Id: twidjoy.c,v 1.5 2002/01/22 20:31:53 vojtech Exp $
- *
- *  derived from CVS-ID "stinger.c,v 1.5 2001/05/29 12:57:18 vojtech Exp"
- *
  *  Copyright (c) 2001 Arndt Schoenewald
  *  Copyright (c) 2000-2001 Vojtech Pavlik
  *  Copyright (c) 2000 Mark Fletcher
diff --git a/drivers/input/joystick/warrior.c b/drivers/input/joystick/warrior.c
index e928b6e3724a..f72c83e15e60 100644
--- a/drivers/input/joystick/warrior.c
+++ b/drivers/input/joystick/warrior.c
@@ -1,6 +1,4 @@
 /*
- * $Id: warrior.c,v 1.14 2002/01/22 20:32:10 vojtech Exp $
- *
  *  Copyright (c) 1999-2001 Vojtech Pavlik
  */
 
diff --git a/drivers/input/joystick/xpad.c b/drivers/input/joystick/xpad.c
index b29e3affb805..87d3e7eabffd 100644
--- a/drivers/input/joystick/xpad.c
+++ b/drivers/input/joystick/xpad.c
@@ -418,11 +418,11 @@ static void xpad_irq_in(struct urb *urb)
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
                 dbg("%s - urb shutting down with status: %d",
-                        __FUNCTION__, status);
+                        __func__, status);
                 return;
         default:
                 dbg("%s - nonzero urb status received: %d",
-                        __FUNCTION__, status);
+                        __func__, status);
                 goto exit;
         }
 
@@ -441,7 +441,7 @@ exit:
         retval = usb_submit_urb (urb, GFP_ATOMIC);
         if (retval)
                 err ("%s - usb_submit_urb failed with result %d",
-                     __FUNCTION__, retval);
+                     __func__, retval);
 }
 
 static void xpad_bulk_out(struct urb *urb)
@@ -477,11 +477,11 @@ static void xpad_irq_out(struct urb *urb)
                 case -ESHUTDOWN:
                         /* this urb is terminated, clean up */
                         dbg("%s - urb shutting down with status: %d",
-                                __FUNCTION__, status);
+                                __func__, status);
                         return;
                 default:
                         dbg("%s - nonzero urb status received: %d",
-                                __FUNCTION__, status);
+                                __func__, status);
                         goto exit;
         }
 
@@ -489,7 +489,7 @@ exit:
         retval = usb_submit_urb(urb, GFP_ATOMIC);
         if (retval)
                 err("%s - usb_submit_urb failed with result %d",
-                    __FUNCTION__, retval);
+                    __func__, retval);
 }
 
 static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad)
diff --git a/drivers/input/keyboard/amikbd.c b/drivers/input/keyboard/amikbd.c
index 81bf7562aca0..35149ec455a9 100644
--- a/drivers/input/keyboard/amikbd.c
+++ b/drivers/input/keyboard/amikbd.c
@@ -1,6 +1,4 @@
 /*
- * $Id: amikbd.c,v 1.13 2002/02/01 16:02:24 vojtech Exp $
- *
  *  Copyright (c) 2000-2001 Vojtech Pavlik
  *
  *  Based on the work of:
diff --git a/drivers/input/keyboard/atkbd.c b/drivers/input/keyboard/atkbd.c
index af58a6f1e898..b1ce10f50bcf 100644
--- a/drivers/input/keyboard/atkbd.c
+++ b/drivers/input/keyboard/atkbd.c
@@ -68,7 +68,7 @@ MODULE_PARM_DESC(extra, "Enable extra LEDs and keys on IBM RapidAcces, EzKey and
  * are loadable via an userland utility.
  */
 
-static unsigned char atkbd_set2_keycode[512] = {
+static const unsigned short atkbd_set2_keycode[512] = {
 
 #ifdef CONFIG_KEYBOARD_ATKBD_HP_KEYCODES
 
@@ -99,7 +99,7 @@ static unsigned char atkbd_set2_keycode[512] = {
 #endif
 };
 
-static unsigned char atkbd_set3_keycode[512] = {
+static const unsigned short atkbd_set3_keycode[512] = {
 
           0,  0,  0,  0,  0,  0,  0, 59,  1,138,128,129,130, 15, 41, 60,
         131, 29, 42, 86, 58, 16,  2, 61,133, 56, 44, 31, 30, 17,  3, 62,
@@ -115,7 +115,7 @@ static unsigned char atkbd_set3_keycode[512] = {
         148,149,147,140
 };
 
-static unsigned char atkbd_unxlate_table[128] = {
+static const unsigned short atkbd_unxlate_table[128] = {
           0,118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85,102, 13,
          21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
          35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
@@ -161,7 +161,7 @@ static unsigned char atkbd_unxlate_table[128] = {
 #define ATKBD_SCR_LEFT          249
 #define ATKBD_SCR_RIGHT         248
 
-#define ATKBD_SPECIAL           248
+#define ATKBD_SPECIAL           ATKBD_SCR_RIGHT
 
 #define ATKBD_LED_EVENT_BIT     0
 #define ATKBD_REP_EVENT_BIT     1
@@ -173,7 +173,7 @@ static unsigned char atkbd_unxlate_table[128] = {
 #define ATKBD_XL_HANGEUL        0x10
 #define ATKBD_XL_HANJA          0x20
 
-static struct {
+static const struct {
         unsigned char keycode;
         unsigned char set2;
 } atkbd_scroll_keys[] = {
@@ -200,7 +200,7 @@ struct atkbd {
         char phys[32];
 
         unsigned short id;
-        unsigned char keycode[512];
+        unsigned short keycode[512];
         DECLARE_BITMAP(force_release_mask, 512);
         unsigned char set;
         unsigned char translated;
@@ -357,7 +357,7 @@ static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
         unsigned int code = data;
         int scroll = 0, hscroll = 0, click = -1;
         int value;
-        unsigned char keycode;
+        unsigned short keycode;
 
 #ifdef ATKBD_DEBUG
         printk(KERN_DEBUG "atkbd.c: Received %02x flags %02x\n", data, flags);
@@ -851,6 +851,23 @@ static void atkbd_latitude_keymap_fixup(struct atkbd *atkbd)
 }
 
 /*
+ * Perform fixup for HP system that doesn't generate release
+ * for its video switch
+ */
+static void atkbd_hp_keymap_fixup(struct atkbd *atkbd)
+{
+        const unsigned int forced_release_keys[] = {
+                0x94,
+        };
+        int i;
+
+        if (atkbd->set == 2)
+                for (i = 0; i < ARRAY_SIZE(forced_release_keys); i++)
+                        __set_bit(forced_release_keys[i],
+                                        atkbd->force_release_mask);
+}
+
+/*
  * atkbd_set_keycode_table() initializes keyboard's keycode table
  * according to the selected scancode set
  */
@@ -961,16 +978,16 @@ static void atkbd_set_device_attrs(struct atkbd *atkbd)
                 input_dev->evbit[0] |= BIT_MASK(EV_REL);
                 input_dev->relbit[0] = BIT_MASK(REL_WHEEL) |
                         BIT_MASK(REL_HWHEEL);
-                set_bit(BTN_MIDDLE, input_dev->keybit);
+                __set_bit(BTN_MIDDLE, input_dev->keybit);
         }
 
         input_dev->keycode = atkbd->keycode;
-        input_dev->keycodesize = sizeof(unsigned char);
+        input_dev->keycodesize = sizeof(unsigned short);
         input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
 
         for (i = 0; i < 512; i++)
                 if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL)
-                        set_bit(atkbd->keycode[i], input_dev->keybit);
+                        __set_bit(atkbd->keycode[i], input_dev->keybit);
 }
 
 /*
@@ -1452,6 +1469,15 @@ static struct dmi_system_id atkbd_dmi_quirk_table[] __initdata = {
                 .callback = atkbd_setup_fixup,
                 .driver_data = atkbd_latitude_keymap_fixup,
         },
+        {
+                .ident = "HP 2133",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "HP 2133"),
+                },
+                .callback = atkbd_setup_fixup,
+                .driver_data = atkbd_hp_keymap_fixup,
+        },
         { }
 };
 
diff --git a/drivers/input/keyboard/gpio_keys.c b/drivers/input/keyboard/gpio_keys.c
index bbd00c3fe98c..be58730e636a 100644
--- a/drivers/input/keyboard/gpio_keys.c
+++ b/drivers/input/keyboard/gpio_keys.c
@@ -26,23 +26,54 @@
 
 #include <asm/gpio.h>
 
+struct gpio_button_data {
+        struct gpio_keys_button *button;
+        struct input_dev *input;
+        struct timer_list timer;
+};
+
+struct gpio_keys_drvdata {
+        struct input_dev *input;
+        struct gpio_button_data data[0];
+};
+
+static void gpio_keys_report_event(struct gpio_keys_button *button,
+                                   struct input_dev *input)
+{
+        unsigned int type = button->type ?: EV_KEY;
+        int state = (gpio_get_value(button->gpio) ? 1 : 0) ^ button->active_low;
+
+        input_event(input, type, button->code, !!state);
+        input_sync(input);
+}
+
+static void gpio_check_button(unsigned long _data)
+{
+        struct gpio_button_data *data = (struct gpio_button_data *)_data;
+
+        gpio_keys_report_event(data->button, data->input);
+}
+
 static irqreturn_t gpio_keys_isr(int irq, void *dev_id)
 {
-        int i;
         struct platform_device *pdev = dev_id;
         struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
-        struct input_dev *input = platform_get_drvdata(pdev);
+        struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev);
+        int i;
 
         for (i = 0; i < pdata->nbuttons; i++) {
                 struct gpio_keys_button *button = &pdata->buttons[i];
-                int gpio = button->gpio;
 
-                if (irq == gpio_to_irq(gpio)) {
-                        unsigned int type = button->type ?: EV_KEY;
-                        int state = (gpio_get_value(gpio) ? 1 : 0) ^ button->active_low;
+                if (irq == gpio_to_irq(button->gpio)) {
+                        struct gpio_button_data *bdata = &ddata->data[i];
+
+                        if (button->debounce_interval)
+                                mod_timer(&bdata->timer,
+                                          jiffies +
+                                          msecs_to_jiffies(button->debounce_interval));
+                        else
+                                gpio_keys_report_event(button, bdata->input);
 
-                        input_event(input, type, button->code, !!state);
-                        input_sync(input);
                         return IRQ_HANDLED;
                 }
         }
@@ -53,17 +84,21 @@ static irqreturn_t gpio_keys_isr(int irq, void *dev_id)
 static int __devinit gpio_keys_probe(struct platform_device *pdev)
 {
         struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
+        struct gpio_keys_drvdata *ddata;
         struct input_dev *input;
         int i, error;
         int wakeup = 0;
 
+        ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
+                        pdata->nbuttons * sizeof(struct gpio_button_data),
+                        GFP_KERNEL);
         input = input_allocate_device();
-        if (!input)
-                return -ENOMEM;
-
-        platform_set_drvdata(pdev, input);
+        if (!ddata || !input) {
+                error = -ENOMEM;
+                goto fail1;
+        }
 
-        input->evbit[0] = BIT_MASK(EV_KEY);
+        platform_set_drvdata(pdev, ddata);
 
         input->name = pdev->name;
         input->phys = "gpio-keys/input0";
@@ -74,16 +109,23 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
         input->id.product = 0x0001;
         input->id.version = 0x0100;
 
+        ddata->input = input;
+
         for (i = 0; i < pdata->nbuttons; i++) {
                 struct gpio_keys_button *button = &pdata->buttons[i];
+                struct gpio_button_data *bdata = &ddata->data[i];
                 int irq;
                 unsigned int type = button->type ?: EV_KEY;
 
+                bdata->input = input;
+                setup_timer(&bdata->timer,
+                            gpio_check_button, (unsigned long)bdata);
+
                 error = gpio_request(button->gpio, button->desc ?: "gpio_keys");
                 if (error < 0) {
                         pr_err("gpio-keys: failed to request GPIO %d,"
                                 " error %d\n", button->gpio, error);
-                        goto fail;
+                        goto fail2;
                 }
 
                 error = gpio_direction_input(button->gpio);
@@ -92,7 +134,7 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
                                 " direction for GPIO %d, error %d\n",
                                 button->gpio, error);
                         gpio_free(button->gpio);
-                        goto fail;
+                        goto fail2;
                 }
 
                 irq = gpio_to_irq(button->gpio);
@@ -102,7 +144,7 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
                                 " for GPIO %d, error %d\n",
                                 button->gpio, error);
                         gpio_free(button->gpio);
-                        goto fail;
+                        goto fail2;
                 }
 
                 error = request_irq(irq, gpio_keys_isr,
@@ -114,7 +156,7 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
                         pr_err("gpio-keys: Unable to claim irq %d; error %d\n",
                                 irq, error);
                         gpio_free(button->gpio);
-                        goto fail;
+                        goto fail2;
                 }
 
                 if (button->wakeup)
@@ -127,21 +169,25 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
         if (error) {
                 pr_err("gpio-keys: Unable to register input device, "
                         "error: %d\n", error);
-                goto fail;
+                goto fail2;
         }
 
         device_init_wakeup(&pdev->dev, wakeup);
 
         return 0;
 
- fail:
+ fail2:
         while (--i >= 0) {
                 free_irq(gpio_to_irq(pdata->buttons[i].gpio), pdev);
+                if (pdata->buttons[i].debounce_interval)
+                        del_timer_sync(&ddata->data[i].timer);
                 gpio_free(pdata->buttons[i].gpio);
         }
 
         platform_set_drvdata(pdev, NULL);
+ fail1:
         input_free_device(input);
+        kfree(ddata);
 
         return error;
 }
@@ -149,7 +195,8 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
 static int __devexit gpio_keys_remove(struct platform_device *pdev)
 {
         struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
-        struct input_dev *input = platform_get_drvdata(pdev);
+        struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev);
+        struct input_dev *input = ddata->input;
         int i;
 
         device_init_wakeup(&pdev->dev, 0);
@@ -157,6 +204,8 @@ static int __devexit gpio_keys_remove(struct platform_device *pdev)
         for (i = 0; i < pdata->nbuttons; i++) {
                 int irq = gpio_to_irq(pdata->buttons[i].gpio);
                 free_irq(irq, pdev);
+                if (pdata->buttons[i].debounce_interval)
+                        del_timer_sync(&ddata->data[i].timer);
                 gpio_free(pdata->buttons[i].gpio);
         }
 
diff --git a/drivers/input/keyboard/lkkbd.c b/drivers/input/keyboard/lkkbd.c
index 32e2c2605d95..4730ef35c732 100644
--- a/drivers/input/keyboard/lkkbd.c
+++ b/drivers/input/keyboard/lkkbd.c
@@ -538,11 +538,11 @@ lkkbd_event (struct input_dev *dev, unsigned int type, unsigned int code,
                         switch (code) {
                                 case SND_CLICK:
                                         if (value == 0) {
-                                                DBG ("%s: Deactivating key clicks\n", __FUNCTION__);
+                                                DBG ("%s: Deactivating key clicks\n", __func__);
                                                 lk->serio->write (lk->serio, LK_CMD_DISABLE_KEYCLICK);
                                                 lk->serio->write (lk->serio, LK_CMD_DISABLE_CTRCLICK);
                                         } else {
-                                                DBG ("%s: Activating key clicks\n", __FUNCTION__);
+                                                DBG ("%s: Activating key clicks\n", __func__);
                                                 lk->serio->write (lk->serio, LK_CMD_ENABLE_KEYCLICK);
                                                 lk->serio->write (lk->serio, volume_to_hw (lk->keyclick_volume));
                                                 lk->serio->write (lk->serio, LK_CMD_ENABLE_CTRCLICK);
@@ -560,7 +560,7 @@ lkkbd_event (struct input_dev *dev, unsigned int type, unsigned int code,
 
                 default:
                         printk (KERN_ERR "%s (): Got unknown type %d, code %d, value %d\n",
-                                        __FUNCTION__, type, code, value);
+                                        __func__, type, code, value);
         }
 
         return -1;
diff --git a/drivers/input/keyboard/pxa27x_keypad.c b/drivers/input/keyboard/pxa27x_keypad.c
index 45767e73f071..6f1516f50750 100644
--- a/drivers/input/keyboard/pxa27x_keypad.c
+++ b/drivers/input/keyboard/pxa27x_keypad.c
@@ -105,6 +105,8 @@ struct pxa27x_keypad {
         struct input_dev *input_dev;
         void __iomem *mmio_base;
 
+        int irq;
+
         /* matrix key code map */
         unsigned int matrix_keycodes[MAX_MATRIX_KEY_NUM];
 
@@ -392,6 +394,10 @@ static int pxa27x_keypad_suspend(struct platform_device *pdev, pm_message_t stat
         struct pxa27x_keypad *keypad = platform_get_drvdata(pdev);
 
         clk_disable(keypad->clk);
+
+        if (device_may_wakeup(&pdev->dev))
+                enable_irq_wake(keypad->irq);
+
         return 0;
 }
 
@@ -400,6 +406,9 @@ static int pxa27x_keypad_resume(struct platform_device *pdev)
         struct pxa27x_keypad *keypad = platform_get_drvdata(pdev);
         struct input_dev *input_dev = keypad->input_dev;
 
+        if (device_may_wakeup(&pdev->dev))
+                disable_irq_wake(keypad->irq);
+
         mutex_lock(&input_dev->mutex);
 
         if (input_dev->users) {
@@ -509,6 +518,8 @@ static int __devinit pxa27x_keypad_probe(struct platform_device *pdev)
                 goto failed_free_dev;
         }
 
+        keypad->irq = irq;
+
         /* Register the input device */
         error = input_register_device(input_dev);
         if (error) {
@@ -516,6 +527,8 @@ static int __devinit pxa27x_keypad_probe(struct platform_device *pdev)
                 goto failed_free_irq;
         }
 
+        device_init_wakeup(&pdev->dev, 1);
+
         return 0;
 
 failed_free_irq:
@@ -539,7 +552,7 @@ static int __devexit pxa27x_keypad_remove(struct platform_device *pdev)
         struct pxa27x_keypad *keypad = platform_get_drvdata(pdev);
         struct resource *res;
 
-        free_irq(platform_get_irq(pdev, 0), pdev);
+        free_irq(keypad->irq, pdev);
 
         clk_disable(keypad->clk);
         clk_put(keypad->clk);
diff --git a/drivers/input/keyboard/sunkbd.c b/drivers/input/keyboard/sunkbd.c
index be0f5d19d023..9fce6d1e29b2 100644
--- a/drivers/input/keyboard/sunkbd.c
+++ b/drivers/input/keyboard/sunkbd.c
@@ -1,6 +1,4 @@
 /*
- * $Id: sunkbd.c,v 1.14 2001/09/25 10:12:07 vojtech Exp $
- *
  *  Copyright (c) 1999-2001 Vojtech Pavlik
  */
 
diff --git a/drivers/input/keyboard/xtkbd.c b/drivers/input/keyboard/xtkbd.c
index 152a2c070508..37b01d777a4a 100644
--- a/drivers/input/keyboard/xtkbd.c
+++ b/drivers/input/keyboard/xtkbd.c
@@ -1,6 +1,4 @@
 /*
- * $Id: xtkbd.c,v 1.11 2001/09/25 10:12:07 vojtech Exp $
- *
  *  Copyright (c) 1999-2001 Vojtech Pavlik
  */
 
diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
index 432699d61c58..e99b7882f382 100644
--- a/drivers/input/misc/Kconfig
+++ b/drivers/input/misc/Kconfig
@@ -189,6 +189,16 @@ config INPUT_UINPUT
           To compile this driver as a module, choose M here: the
           module will be called uinput.
 
+config INPUT_SGI_BTNS
+        tristate "SGI Indy/O2 volume button interface"
+        depends on SGI_IP22 || SGI_IP32
+        select INPUT_POLLDEV
+        help
+          Say Y here if you want to support SGI Indy/O2 volume button interface.
+
+          To compile this driver as a module, choose M here: the
+          module will be called sgi_btns.
+
 config HP_SDC_RTC
         tristate "HP SDC Real Time Clock"
         depends on GSC || HP300
diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile
index ebd39f291d25..f48009b52226 100644
--- a/drivers/input/misc/Makefile
+++ b/drivers/input/misc/Makefile
@@ -19,3 +19,4 @@ obj-$(CONFIG_INPUT_YEALINK)		+= yealink.o
 obj-$(CONFIG_HP_SDC_RTC)                += hp_sdc_rtc.o
 obj-$(CONFIG_INPUT_UINPUT)              += uinput.o
 obj-$(CONFIG_INPUT_APANEL)              += apanel.o
+obj-$(CONFIG_INPUT_SGI_BTNS)            += sgi_btns.o
diff --git a/drivers/input/misc/ati_remote.c b/drivers/input/misc/ati_remote.c
index f3b86c2b0797..debfc1af9d95 100644
--- a/drivers/input/misc/ati_remote.c
+++ b/drivers/input/misc/ati_remote.c
@@ -330,7 +330,7 @@ static int ati_remote_open(struct input_dev *inputdev)
         ati_remote->irq_urb->dev = ati_remote->udev;
         if (usb_submit_urb(ati_remote->irq_urb, GFP_KERNEL)) {
                 dev_err(&ati_remote->interface->dev,
-                        "%s: usb_submit_urb failed!\n", __FUNCTION__);
+                        "%s: usb_submit_urb failed!\n", __func__);
                 return -EIO;
         }
 
@@ -356,7 +356,7 @@ static void ati_remote_irq_out(struct urb *urb)
 
         if (urb->status) {
                 dev_dbg(&ati_remote->interface->dev, "%s: status %d\n",
-                        __FUNCTION__, urb->status);
+                        __func__, urb->status);
                 return;
         }
 
@@ -601,17 +601,17 @@ static void ati_remote_irq_in(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 dev_dbg(&ati_remote->interface->dev, "%s: urb error status, unlink? \n",
-                        __FUNCTION__);
+                        __func__);
                 return;
         default:                /* error */
                 dev_dbg(&ati_remote->interface->dev, "%s: Nonzero urb status %d\n",
-                        __FUNCTION__, urb->status);
+                        __func__, urb->status);
         }
 
         retval = usb_submit_urb(urb, GFP_ATOMIC);
         if (retval)
                 dev_err(&ati_remote->interface->dev, "%s: usb_submit_urb()=%d\n",
-                        __FUNCTION__, retval);
+                        __func__, retval);
 }
 
 /*
@@ -734,7 +734,7 @@ static int ati_remote_probe(struct usb_interface *interface, const struct usb_de
         int err = -ENOMEM;
 
         if (iface_host->desc.bNumEndpoints != 2) {
-                err("%s: Unexpected desc.bNumEndpoints\n", __FUNCTION__);
+                err("%s: Unexpected desc.bNumEndpoints\n", __func__);
                 return -ENODEV;
         }
 
@@ -742,11 +742,11 @@ static int ati_remote_probe(struct usb_interface *interface, const struct usb_de
         endpoint_out = &iface_host->endpoint[1].desc;
 
         if (!usb_endpoint_is_int_in(endpoint_in)) {
-                err("%s: Unexpected endpoint_in\n", __FUNCTION__);
+                err("%s: Unexpected endpoint_in\n", __func__);
                 return -ENODEV;
         }
         if (le16_to_cpu(endpoint_in->wMaxPacketSize) == 0) {
-                err("%s: endpoint_in message size==0? \n", __FUNCTION__);
+                err("%s: endpoint_in message size==0? \n", __func__);
                 return -ENODEV;
         }
 
@@ -814,7 +814,7 @@ static void ati_remote_disconnect(struct usb_interface *interface)
         ati_remote = usb_get_intfdata(interface);
         usb_set_intfdata(interface, NULL);
         if (!ati_remote) {
-                warn("%s - null device?\n", __FUNCTION__);
+                warn("%s - null device?\n", __func__);
                 return;
         }
 
diff --git a/drivers/input/misc/ati_remote2.c b/drivers/input/misc/ati_remote2.c
index f2709b82485c..a7fabafbd94c 100644
--- a/drivers/input/misc/ati_remote2.c
+++ b/drivers/input/misc/ati_remote2.c
@@ -137,14 +137,14 @@ static int ati_remote2_open(struct input_dev *idev)
         r = usb_submit_urb(ar2->urb[0], GFP_KERNEL);
         if (r) {
                 dev_err(&ar2->intf[0]->dev,
-                        "%s: usb_submit_urb() = %d\n", __FUNCTION__, r);
+                        "%s: usb_submit_urb() = %d\n", __func__, r);
                 return r;
         }
         r = usb_submit_urb(ar2->urb[1], GFP_KERNEL);
         if (r) {
                 usb_kill_urb(ar2->urb[0]);
                 dev_err(&ar2->intf[1]->dev,
-                        "%s: usb_submit_urb() = %d\n", __FUNCTION__, r);
+                        "%s: usb_submit_urb() = %d\n", __func__, r);
                 return r;
         }
 
@@ -294,17 +294,17 @@ static void ati_remote2_complete_mouse(struct urb *urb)
         case -ECONNRESET:
         case -ESHUTDOWN:
                 dev_dbg(&ar2->intf[0]->dev,
-                        "%s(): urb status = %d\n", __FUNCTION__, urb->status);
+                        "%s(): urb status = %d\n", __func__, urb->status);
                 return;
         default:
                 dev_err(&ar2->intf[0]->dev,
-                        "%s(): urb status = %d\n", __FUNCTION__, urb->status);
+                        "%s(): urb status = %d\n", __func__, urb->status);
         }
 
         r = usb_submit_urb(urb, GFP_ATOMIC);
         if (r)
                 dev_err(&ar2->intf[0]->dev,
-                        "%s(): usb_submit_urb() = %d\n", __FUNCTION__, r);
+                        "%s(): usb_submit_urb() = %d\n", __func__, r);
 }
 
 static void ati_remote2_complete_key(struct urb *urb)
@@ -321,17 +321,17 @@ static void ati_remote2_complete_key(struct urb *urb)
         case -ECONNRESET:
         case -ESHUTDOWN:
                 dev_dbg(&ar2->intf[1]->dev,
-                        "%s(): urb status = %d\n", __FUNCTION__, urb->status);
+                        "%s(): urb status = %d\n", __func__, urb->status);
                 return;
         default:
                 dev_err(&ar2->intf[1]->dev,
-                        "%s(): urb status = %d\n", __FUNCTION__, urb->status);
+                        "%s(): urb status = %d\n", __func__, urb->status);
         }
 
         r = usb_submit_urb(urb, GFP_ATOMIC);
         if (r)
                 dev_err(&ar2->intf[1]->dev,
-                        "%s(): usb_submit_urb() = %d\n", __FUNCTION__, r);
+                        "%s(): usb_submit_urb() = %d\n", __func__, r);
 }
 
 static int ati_remote2_input_init(struct ati_remote2 *ar2)
@@ -438,7 +438,7 @@ static int ati_remote2_setup(struct ati_remote2 *ar2)
                             channel, 0x0, NULL, 0, USB_CTRL_SET_TIMEOUT);
         if (r) {
                 dev_err(&ar2->udev->dev, "%s - failed to set channel due to error: %d\n",
-                        __FUNCTION__, r);
+                        __func__, r);
                 return r;
         }
 
diff --git a/drivers/input/misc/keyspan_remote.c b/drivers/input/misc/keyspan_remote.c
index 952938a8e991..86afdd1fdf9d 100644
--- a/drivers/input/misc/keyspan_remote.c
+++ b/drivers/input/misc/keyspan_remote.c
@@ -159,7 +159,7 @@ static int keyspan_load_tester(struct usb_keyspan* dev, int bits_needed)
         if (dev->data.pos >= dev->data.len) {
                 dev_dbg(&dev->udev->dev,
                         "%s - Error ran out of data. pos: %d, len: %d\n",
-                        __FUNCTION__, dev->data.pos, dev->data.len);
+                        __func__, dev->data.pos, dev->data.len);
                 return -1;
         }
 
@@ -267,7 +267,7 @@ static void keyspan_check_data(struct usb_keyspan *remote)
                                 remote->data.tester = remote->data.tester >> 6;
                                 remote->data.bits_left -= 6;
                         } else {
-                                err("%s - Unknown sequence found in system data.\n", __FUNCTION__);
+                                err("%s - Unknown sequence found in system data.\n", __func__);
                                 remote->stage = 0;
                                 return;
                         }
@@ -286,7 +286,7 @@ static void keyspan_check_data(struct usb_keyspan *remote)
                                 remote->data.tester = remote->data.tester >> 6;
                                 remote->data.bits_left -= 6;
                         } else {
-                                err("%s - Unknown sequence found in button data.\n", __FUNCTION__);
+                                err("%s - Unknown sequence found in button data.\n", __func__);
                                 remote->stage = 0;
                                 return;
                         }
@@ -302,7 +302,7 @@ static void keyspan_check_data(struct usb_keyspan *remote)
                         remote->data.tester = remote->data.tester >> 6;
                         remote->data.bits_left -= 6;
                 } else {
-                        err("%s - Error in message, invalid toggle.\n", __FUNCTION__);
+                        err("%s - Error in message, invalid toggle.\n", __func__);
                         remote->stage = 0;
                         return;
                 }
@@ -317,7 +317,7 @@ static void keyspan_check_data(struct usb_keyspan *remote)
 
                 dev_dbg(&remote->udev->dev,
                         "%s found valid message: system: %d, button: %d, toggle: %d\n",
-                        __FUNCTION__, message.system, message.button, message.toggle);
+                        __func__, message.system, message.button, message.toggle);
 
                 if (message.toggle != remote->toggle) {
                         keyspan_report_button(remote, message.button, 1);
@@ -341,7 +341,7 @@ static int keyspan_setup(struct usb_device* dev)
                                  0x11, 0x40, 0x5601, 0x0, NULL, 0, 0);
         if (retval) {
                 dev_dbg(&dev->dev, "%s - failed to set bit rate due to error: %d\n",
-                        __FUNCTION__, retval);
+                        __func__, retval);
                 return(retval);
         }
 
@@ -349,7 +349,7 @@ static int keyspan_setup(struct usb_device* dev)
                                  0x44, 0x40, 0x0, 0x0, NULL, 0, 0);
         if (retval) {
                 dev_dbg(&dev->dev, "%s - failed to set resume sensitivity due to error: %d\n",
-                        __FUNCTION__, retval);
+                        __func__, retval);
                 return(retval);
         }
 
@@ -357,11 +357,11 @@ static int keyspan_setup(struct usb_device* dev)
                                  0x22, 0x40, 0x0, 0x0, NULL, 0, 0);
         if (retval) {
                 dev_dbg(&dev->dev, "%s - failed to turn receive on due to error: %d\n",
-                        __FUNCTION__, retval);
+                        __func__, retval);
                 return(retval);
         }
 
-        dev_dbg(&dev->dev, "%s - Setup complete.\n", __FUNCTION__);
+        dev_dbg(&dev->dev, "%s - Setup complete.\n", __func__);
         return(retval);
 }
 
@@ -397,7 +397,7 @@ static void keyspan_irq_recv(struct urb *urb)
 resubmit:
         retval = usb_submit_urb(urb, GFP_ATOMIC);
         if (retval)
-                err ("%s - usb_submit_urb failed with result: %d", __FUNCTION__, retval);
+                err ("%s - usb_submit_urb failed with result: %d", __func__, retval);
 }
 
 static int keyspan_open(struct input_dev *dev)
diff --git a/drivers/input/misc/powermate.c b/drivers/input/misc/powermate.c
index 7a7b8c7b9633..a53c4885fbad 100644
--- a/drivers/input/misc/powermate.c
+++ b/drivers/input/misc/powermate.c
@@ -96,10 +96,10 @@ static void powermate_irq(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
+                dbg("%s - urb shutting down with status: %d", __func__, urb->status);
                 return;
         default:
-                dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
+                dbg("%s - nonzero urb status received: %d", __func__, urb->status);
                 goto exit;
         }
 
@@ -112,7 +112,7 @@ exit:
         retval = usb_submit_urb (urb, GFP_ATOMIC);
         if (retval)
                 err ("%s - usb_submit_urb failed with result %d",
-                     __FUNCTION__, retval);
+                     __func__, retval);
 }
 
 /* Decide if we need to issue a control message and do so. Must be called with pm->lock taken */
diff --git a/drivers/input/misc/sgi_btns.c b/drivers/input/misc/sgi_btns.c
new file mode 100644
index 000000000000..ce238f59b3c8
--- /dev/null
+++ b/drivers/input/misc/sgi_btns.c
@@ -0,0 +1,178 @@
+/*
+ *  SGI Volume Button interface driver
+ *
+ *  Copyright (C) 2008  Thomas Bogendoerfer <tsbogend@alpha.franken.de>
+ *
+ *  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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+#include <linux/init.h>
+#include <linux/input-polldev.h>
+#include <linux/ioport.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+
+#ifdef CONFIG_SGI_IP22
+#include <asm/sgi/ioc.h>
+
+static inline u8 button_status(void)
+{
+        u8 status;
+
+        status = readb(&sgioc->panel) ^ 0xa0;
+        return ((status & 0x80) >> 6) | ((status & 0x20) >> 5);
+}
+#endif
+
+#ifdef CONFIG_SGI_IP32
+#include <asm/ip32/mace.h>
+
+static inline u8 button_status(void)
+{
+        u64 status;
+
+        status = readq(&mace->perif.audio.control);
+        writeq(status & ~(3U << 23), &mace->perif.audio.control);
+
+        return (status >> 23) & 3;
+}
+#endif
+
+#define BUTTONS_POLL_INTERVAL   30      /* msec */
+#define BUTTONS_COUNT_THRESHOLD 3
+
+static const unsigned short sgi_map[] = {
+        KEY_VOLUMEDOWN,
+        KEY_VOLUMEUP
+};
+
+struct buttons_dev {
+        struct input_polled_dev *poll_dev;
+        unsigned short keymap[ARRAY_SIZE(sgi_map)];
+        int count[ARRAY_SIZE(sgi_map)];
+};
+
+static void handle_buttons(struct input_polled_dev *dev)
+{
+        struct buttons_dev *bdev = dev->private;
+        struct input_dev *input = dev->input;
+        u8 status;
+        int i;
+
+        status = button_status();
+
+        for (i = 0; i < ARRAY_SIZE(bdev->keymap); i++) {
+                if (status & (1U << i)) {
+                        if (++bdev->count[i] == BUTTONS_COUNT_THRESHOLD) {
+                                input_event(input, EV_MSC, MSC_SCAN, i);
+                                input_report_key(input, bdev->keymap[i], 1);
+                                input_sync(input);
+                        }
+                } else {
+                        if (bdev->count[i] >= BUTTONS_COUNT_THRESHOLD) {
+                                input_event(input, EV_MSC, MSC_SCAN, i);
+                                input_report_key(input, bdev->keymap[i], 0);
+                                input_sync(input);
+                        }
+                        bdev->count[i] = 0;
+                }
+        }
+}
+
+static int __devinit sgi_buttons_probe(struct platform_device *pdev)
+{
+        struct buttons_dev *bdev;
+        struct input_polled_dev *poll_dev;
+        struct input_dev *input;
+        int error, i;
+
+        bdev = kzalloc(sizeof(struct buttons_dev), GFP_KERNEL);
+        poll_dev = input_allocate_polled_device();
+        if (!bdev || !poll_dev) {
+                error = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        memcpy(bdev->keymap, sgi_map, sizeof(bdev->keymap));
+
+        poll_dev->private = bdev;
+        poll_dev->poll = handle_buttons;
+        poll_dev->poll_interval = BUTTONS_POLL_INTERVAL;
+
+        input = poll_dev->input;
+        input->name = "SGI buttons";
+        input->phys = "sgi/input0";
+        input->id.bustype = BUS_HOST;
+        input->dev.parent = &pdev->dev;
+
+        input->keycode = bdev->keymap;
+        input->keycodemax = ARRAY_SIZE(bdev->keymap);
+        input->keycodesize = sizeof(unsigned short);
+
+        input_set_capability(input, EV_MSC, MSC_SCAN);
+        __set_bit(EV_KEY, input->evbit);
+        for (i = 0; i < ARRAY_SIZE(sgi_map); i++)
+                __set_bit(bdev->keymap[i], input->keybit);
+        __clear_bit(KEY_RESERVED, input->keybit);
+
+        bdev->poll_dev = poll_dev;
+        dev_set_drvdata(&pdev->dev, bdev);
+
+        error = input_register_polled_device(poll_dev);
+        if (error)
+                goto err_free_mem;
+
+        return 0;
+
+ err_free_mem:
+        input_free_polled_device(poll_dev);
+        kfree(bdev);
+        dev_set_drvdata(&pdev->dev, NULL);
+        return error;
+}
+
+static int __devexit sgi_buttons_remove(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct buttons_dev *bdev = dev_get_drvdata(dev);
+
+        input_unregister_polled_device(bdev->poll_dev);
+        input_free_polled_device(bdev->poll_dev);
+        kfree(bdev);
+        dev_set_drvdata(dev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver sgi_buttons_driver = {
+        .probe  = sgi_buttons_probe,
+        .remove = __devexit_p(sgi_buttons_remove),
+        .driver = {
+                .name   = "sgibtns",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init sgi_buttons_init(void)
+{
+        return platform_driver_register(&sgi_buttons_driver);
+}
+
+static void __exit sgi_buttons_exit(void)
+{
+        platform_driver_unregister(&sgi_buttons_driver);
+}
+
+module_init(sgi_buttons_init);
+module_exit(sgi_buttons_exit);
diff --git a/drivers/input/misc/wistron_btns.c b/drivers/input/misc/wistron_btns.c
index 72176f3d49cb..fe268be3293b 100644
--- a/drivers/input/misc/wistron_btns.c
+++ b/drivers/input/misc/wistron_btns.c
@@ -1186,7 +1186,7 @@ static int wistron_setkeycode(struct input_dev *dev, int scancode, int keycode)
 
 static int __devinit setup_input_dev(void)
 {
-        const struct key_entry *key;
+        struct key_entry *key;
         struct input_dev *input_dev;
         int error;
 
@@ -1219,6 +1219,23 @@ static int __devinit setup_input_dev(void)
                                 set_bit(key->sw.code, input_dev->swbit);
                                 break;
 
+                        /* if wifi or bluetooth are not available, create normal keys */
+                        case KE_WIFI:
+                                if (!have_wifi) {
+                                        key->type = KE_KEY;
+                                        key->keycode = KEY_WLAN;
+                                        key--;
+                                }
+                                break;
+
+                        case KE_BLUETOOTH:
+                                if (!have_bluetooth) {
+                                        key->type = KE_KEY;
+                                        key->keycode = KEY_BLUETOOTH;
+                                        key--;
+                                }
+                                break;
+
                         default:
                                 break;
                 }
diff --git a/drivers/input/misc/yealink.c b/drivers/input/misc/yealink.c
index 46279ef2b649..facefd3dba29 100644
--- a/drivers/input/misc/yealink.c
+++ b/drivers/input/misc/yealink.c
@@ -119,6 +119,8 @@ struct yealink_dev {
         u8 lcdMap[ARRAY_SIZE(lcdMap)];  /* state of LCD, LED ... */
         int key_code;                   /* last reported key     */
 
+        unsigned int shutdown:1;
+
         int     stat_ix;
         union {
                 struct yld_status s;
@@ -424,10 +426,10 @@ send_update:
 static void urb_irq_callback(struct urb *urb)
 {
         struct yealink_dev *yld = urb->context;
-        int ret;
+        int ret, status = urb->status;
 
-        if (urb->status)
-                err("%s - urb status %d", __FUNCTION__, urb->status);
+        if (status)
+                err("%s - urb status %d", __func__, status);
 
         switch (yld->irq_data->cmd) {
         case CMD_KEYPRESS:
@@ -447,33 +449,38 @@ static void urb_irq_callback(struct urb *urb)
 
         yealink_do_idle_tasks(yld);
 
-        ret = usb_submit_urb(yld->urb_ctl, GFP_ATOMIC);
-        if (ret)
-                err("%s - usb_submit_urb failed %d", __FUNCTION__, ret);
+        if (!yld->shutdown) {
+                ret = usb_submit_urb(yld->urb_ctl, GFP_ATOMIC);
+                if (ret && ret != -EPERM)
+                        err("%s - usb_submit_urb failed %d", __func__, ret);
+        }
 }
 
 static void urb_ctl_callback(struct urb *urb)
 {
         struct yealink_dev *yld = urb->context;
-        int ret;
+        int ret = 0, status = urb->status;
 
-        if (urb->status)
-                err("%s - urb status %d", __FUNCTION__, urb->status);
+        if (status)
+                err("%s - urb status %d", __func__, status);
 
         switch (yld->ctl_data->cmd) {
         case CMD_KEYPRESS:
         case CMD_SCANCODE:
                 /* ask for a response */
-                ret = usb_submit_urb(yld->urb_irq, GFP_ATOMIC);
+                if (!yld->shutdown)
+                        ret = usb_submit_urb(yld->urb_irq, GFP_ATOMIC);
                 break;
         default:
                 /* send new command */
                 yealink_do_idle_tasks(yld);
-                ret = usb_submit_urb(yld->urb_ctl, GFP_ATOMIC);
+                if (!yld->shutdown)
+                        ret = usb_submit_urb(yld->urb_ctl, GFP_ATOMIC);
+                break;
         }
 
-        if (ret)
-                err("%s - usb_submit_urb failed %d", __FUNCTION__, ret);
+        if (ret && ret != -EPERM)
+                err("%s - usb_submit_urb failed %d", __func__, ret);
 }
 
 /*******************************************************************************
@@ -505,7 +512,7 @@ static int input_open(struct input_dev *dev)
         struct yealink_dev *yld = input_get_drvdata(dev);
         int i, ret;
 
-        dbg("%s", __FUNCTION__);
+        dbg("%s", __func__);
 
         /* force updates to device */
         for (i = 0; i<sizeof(yld->master); i++)
@@ -521,7 +528,7 @@ static int input_open(struct input_dev *dev)
         yld->ctl_data->sum      = 0x100-CMD_INIT-10;
         if ((ret = usb_submit_urb(yld->urb_ctl, GFP_KERNEL)) != 0) {
                 dbg("%s - usb_submit_urb failed with result %d",
-                     __FUNCTION__, ret);
+                     __func__, ret);
                 return ret;
         }
         return 0;
@@ -531,8 +538,18 @@ static void input_close(struct input_dev *dev)
 {
         struct yealink_dev *yld = input_get_drvdata(dev);
 
+        yld->shutdown = 1;
+        /*
+         * Make sure the flag is seen by other CPUs before we start
+         * killing URBs so new URBs won't be submitted
+         */
+        smp_wmb();
+
         usb_kill_urb(yld->urb_ctl);
         usb_kill_urb(yld->urb_irq);
+
+        yld->shutdown = 0;
+        smp_wmb();
 }
 
 /*******************************************************************************
@@ -809,9 +826,6 @@ static int usb_cleanup(struct yealink_dev *yld, int err)
         if (yld == NULL)
                 return err;
 
-        usb_kill_urb(yld->urb_irq);     /* parameter validation in core/urb */
-        usb_kill_urb(yld->urb_ctl);     /* parameter validation in core/urb */
-
         if (yld->idev) {
                 if (err)
                         input_free_device(yld->idev);
diff --git a/drivers/input/mouse/appletouch.c b/drivers/input/mouse/appletouch.c
index ce6fdec19e14..1f41ae94f26b 100644
--- a/drivers/input/mouse/appletouch.c
+++ b/drivers/input/mouse/appletouch.c
@@ -2,12 +2,13 @@
  * Apple USB Touchpad (for post-February 2005 PowerBooks and MacBooks) driver
  *
  * Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.com)
- * Copyright (C) 2005      Johannes Berg (johannes@sipsolutions.net)
+ * Copyright (C) 2005-2008 Johannes Berg (johannes@sipsolutions.net)
  * Copyright (C) 2005      Stelian Pop (stelian@popies.net)
  * Copyright (C) 2005      Frank Arnold (frank@scirocco-5v-turbo.de)
  * Copyright (C) 2005      Peter Osterlund (petero2@telia.com)
  * Copyright (C) 2005      Michael Hanselmann (linux-kernel@hansmi.ch)
  * Copyright (C) 2006      Nicolas Boichat (nicolas@boichat.ch)
+ * Copyright (C) 2007-2008 Sven Anders (anders@anduras.de)
  *
  * Thanks to Alex Harper <basilisk@foobox.net> for his inputs.
  *
@@ -34,77 +35,64 @@
 #include <linux/module.h>
 #include <linux/usb/input.h>
 
-/* Apple has powerbooks which have the keyboard with different Product IDs */
-#define APPLE_VENDOR_ID         0x05AC
-
-/* These names come from Info.plist in AppleUSBTrackpad.kext */
-#define FOUNTAIN_ANSI_PRODUCT_ID        0x020E
-#define FOUNTAIN_ISO_PRODUCT_ID         0x020F
-
-#define FOUNTAIN_TP_ONLY_PRODUCT_ID     0x030A
-
-#define GEYSER1_TP_ONLY_PRODUCT_ID      0x030B
-
-#define GEYSER_ANSI_PRODUCT_ID          0x0214
-#define GEYSER_ISO_PRODUCT_ID           0x0215
-#define GEYSER_JIS_PRODUCT_ID           0x0216
-
-/* MacBook devices */
-#define GEYSER3_ANSI_PRODUCT_ID         0x0217
-#define GEYSER3_ISO_PRODUCT_ID          0x0218
-#define GEYSER3_JIS_PRODUCT_ID          0x0219
-
-/*
- * Geyser IV: same as Geyser III according to Info.plist in AppleUSBTrackpad.kext
- * -> same IOClass (AppleUSBGrIIITrackpad), same acceleration tables
- */
-#define GEYSER4_ANSI_PRODUCT_ID 0x021A
-#define GEYSER4_ISO_PRODUCT_ID  0x021B
-#define GEYSER4_JIS_PRODUCT_ID  0x021C
-
-#define GEYSER4_HF_ANSI_PRODUCT_ID      0x0229
-#define GEYSER4_HF_ISO_PRODUCT_ID       0x022A
-#define GEYSER4_HF_JIS_PRODUCT_ID       0x022B
+/* Type of touchpad */
+enum atp_touchpad_type {
+        ATP_FOUNTAIN,
+        ATP_GEYSER1,
+        ATP_GEYSER2,
+        ATP_GEYSER3,
+        ATP_GEYSER4
+};
 
-#define ATP_DEVICE(prod)                                        \
+#define ATP_DEVICE(prod, type)                                  \
+{                                                               \
         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |             \
                        USB_DEVICE_ID_MATCH_INT_CLASS |          \
                        USB_DEVICE_ID_MATCH_INT_PROTOCOL,        \
-        .idVendor = APPLE_VENDOR_ID,                            \
+        .idVendor = 0x05ac, /* Apple */                         \
         .idProduct = (prod),                                    \
         .bInterfaceClass = 0x03,                                \
-        .bInterfaceProtocol = 0x02
+        .bInterfaceProtocol = 0x02,                             \
+        .driver_info = ATP_ ## type,                            \
+}
+
+/*
+ * Table of devices (Product IDs) that work with this driver.
+ * (The names come from Info.plist in AppleUSBTrackpad.kext,
+ *  According to Info.plist Geyser IV is the same as Geyser III.)
+ */
 
-/* table of devices that work with this driver */
 static struct usb_device_id atp_table [] = {
-        { ATP_DEVICE(FOUNTAIN_ANSI_PRODUCT_ID) },
-        { ATP_DEVICE(FOUNTAIN_ISO_PRODUCT_ID) },
-        { ATP_DEVICE(FOUNTAIN_TP_ONLY_PRODUCT_ID) },
-        { ATP_DEVICE(GEYSER1_TP_ONLY_PRODUCT_ID) },
+        /* PowerBooks Feb 2005, iBooks G4 */
+        ATP_DEVICE(0x020e, FOUNTAIN),   /* FOUNTAIN ANSI */
+        ATP_DEVICE(0x020f, FOUNTAIN),   /* FOUNTAIN ISO */
+        ATP_DEVICE(0x030a, FOUNTAIN),   /* FOUNTAIN TP ONLY */
+        ATP_DEVICE(0x030b, GEYSER1),    /* GEYSER 1 TP ONLY */
 
         /* PowerBooks Oct 2005 */
-        { ATP_DEVICE(GEYSER_ANSI_PRODUCT_ID) },
-        { ATP_DEVICE(GEYSER_ISO_PRODUCT_ID) },
-        { ATP_DEVICE(GEYSER_JIS_PRODUCT_ID) },
+        ATP_DEVICE(0x0214, GEYSER2),    /* GEYSER 2 ANSI */
+        ATP_DEVICE(0x0215, GEYSER2),    /* GEYSER 2 ISO */
+        ATP_DEVICE(0x0216, GEYSER2),    /* GEYSER 2 JIS */
 
         /* Core Duo MacBook & MacBook Pro */
-        { ATP_DEVICE(GEYSER3_ANSI_PRODUCT_ID) },
-        { ATP_DEVICE(GEYSER3_ISO_PRODUCT_ID) },
-        { ATP_DEVICE(GEYSER3_JIS_PRODUCT_ID) },
+        ATP_DEVICE(0x0217, GEYSER3),    /* GEYSER 3 ANSI */
+        ATP_DEVICE(0x0218, GEYSER3),    /* GEYSER 3 ISO */
+        ATP_DEVICE(0x0219, GEYSER3),    /* GEYSER 3 JIS */
 
         /* Core2 Duo MacBook & MacBook Pro */
-        { ATP_DEVICE(GEYSER4_ANSI_PRODUCT_ID) },
-        { ATP_DEVICE(GEYSER4_ISO_PRODUCT_ID) },
-        { ATP_DEVICE(GEYSER4_JIS_PRODUCT_ID) },
+        ATP_DEVICE(0x021a, GEYSER4),    /* GEYSER 4 ANSI */
+        ATP_DEVICE(0x021b, GEYSER4),    /* GEYSER 4 ISO */
+        ATP_DEVICE(0x021c, GEYSER4),    /* GEYSER 4 JIS */
 
-        { ATP_DEVICE(GEYSER4_HF_ANSI_PRODUCT_ID) },
-        { ATP_DEVICE(GEYSER4_HF_ISO_PRODUCT_ID) },
-        { ATP_DEVICE(GEYSER4_HF_JIS_PRODUCT_ID) },
+        /* Core2 Duo MacBook3,1 */
+        ATP_DEVICE(0x0229, GEYSER4),    /* GEYSER 4 HF ANSI */
+        ATP_DEVICE(0x022a, GEYSER4),    /* GEYSER 4 HF ISO */
+        ATP_DEVICE(0x022b, GEYSER4),    /* GEYSER 4 HF JIS */
 
         /* Terminating entry */
         { }
 };
-MODULE_DEVICE_TABLE (usb, atp_table);
+MODULE_DEVICE_TABLE(usb, atp_table);
 
 /*
  * number of sensors. Note that only 16 instead of 26 X (horizontal)
@@ -124,9 +112,13 @@ MODULE_DEVICE_TABLE (usb, atp_table);
  * We try to keep the touchpad aspect ratio while still doing only simple
  * arithmetics.
  * The factors below give coordinates like:
- *      0 <= x <  960 on 12" and 15" Powerbooks
- *      0 <= x < 1600 on 17" Powerbooks
- *      0 <= y <  646
+ *
+ *      0 <= x <  960 on 12" and 15" Powerbooks
+ *      0 <= x < 1600 on 17" Powerbooks and 17" MacBook Pro
+ *      0 <= x < 1216 on MacBooks and 15" MacBook Pro
+ *
+ *      0 <= y <  646 on all Powerbooks
+ *      0 <= y <  774 on all MacBooks
  */
 #define ATP_XFACT       64
 #define ATP_YFACT       43
@@ -147,43 +139,46 @@ MODULE_DEVICE_TABLE (usb, atp_table);
 /* Structure to hold all of our device specific stuff */
 struct atp {
         char                    phys[64];
-        struct usb_device *     udev;           /* usb device */
-        struct urb *            urb;            /* usb request block */
-        signed char *           data;           /* transferred data */
-        struct input_dev *      input;          /* input dev */
-        unsigned char           open;           /* non-zero if opened */
-        unsigned char           valid;          /* are the sensors valid ? */
-        unsigned char           size_detect_done;
-        unsigned char           overflowwarn;   /* overflow warning printed? */
+        struct usb_device       *udev;          /* usb device */
+        struct urb              *urb;           /* usb request block */
+        signed char             *data;          /* transferred data */
+        struct input_dev        *input;         /* input dev */
+        enum atp_touchpad_type  type;           /* type of touchpad */
+        bool                    open;
+        bool                    valid;          /* are the samples valid? */
+        bool                    size_detect_done;
+        bool                    overflow_warned;
         int                     x_old;          /* last reported x/y, */
         int                     y_old;          /* used for smoothing */
-                                                /* current value of the sensors */
         signed char             xy_cur[ATP_XSENSORS + ATP_YSENSORS];
-                                                /* last value of the sensors */
         signed char             xy_old[ATP_XSENSORS + ATP_YSENSORS];
-                                                /* accumulated sensors */
         int                     xy_acc[ATP_XSENSORS + ATP_YSENSORS];
-        int                     datalen;        /* size of an USB urb transfer */
-        int                     idlecount;      /* number of empty packets */
-        struct work_struct      work;
+        int                     datalen;        /* size of USB transfer */
+        int                     idlecount;      /* number of empty packets */
+        struct work_struct      work;
 };
 
 #define dbg_dump(msg, tab) \
         if (debug > 1) {                                                \
-                int i;                                                  \
-                printk("appletouch: %s %lld", msg, (long long)jiffies); \
-                for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++)       \
-                        printk(" %02x", tab[i]);                        \
+                int __i;                                                \
+                printk(KERN_DEBUG "appletouch: %s", msg);               \
+                for (__i = 0; __i < ATP_XSENSORS + ATP_YSENSORS; __i++) \
+                        printk(" %02x", tab[__i]);                      \
                 printk("\n");                                           \
         }
 
 #define dprintk(format, a...)                                           \
         do {                                                            \
-                if (debug) printk(KERN_DEBUG format, ##a);              \
+                if (debug)                                              \
+                        printk(KERN_DEBUG format, ##a);                 \
         } while (0)
 
-MODULE_AUTHOR("Johannes Berg, Stelian Pop, Frank Arnold, Michael Hanselmann");
-MODULE_DESCRIPTION("Apple PowerBooks USB touchpad driver");
+MODULE_AUTHOR("Johannes Berg");
+MODULE_AUTHOR("Stelian Pop");
+MODULE_AUTHOR("Frank Arnold");
+MODULE_AUTHOR("Michael Hanselmann");
+MODULE_AUTHOR("Sven Anders");
+MODULE_DESCRIPTION("Apple PowerBook and MacBook USB touchpad driver");
 MODULE_LICENSE("GPL");
 
 /*
@@ -191,46 +186,14 @@ MODULE_LICENSE("GPL");
  */
 static int threshold = ATP_THRESHOLD;
 module_param(threshold, int, 0644);
-MODULE_PARM_DESC(threshold, "Discards any change in data from a sensor (trackpad has hundreds of these sensors) less than this value");
+MODULE_PARM_DESC(threshold, "Discard any change in data from a sensor"
+                            " (the trackpad has many of these sensors)"
+                            " less than this value.");
 
-static int debug = 1;
+static int debug;
 module_param(debug, int, 0644);
 MODULE_PARM_DESC(debug, "Activate debugging output");
 
-static inline int atp_is_fountain(struct atp *dev)
-{
-        u16 productId = le16_to_cpu(dev->udev->descriptor.idProduct);
-
-        return productId == FOUNTAIN_ANSI_PRODUCT_ID ||
-               productId == FOUNTAIN_ISO_PRODUCT_ID ||
-               productId == FOUNTAIN_TP_ONLY_PRODUCT_ID;
-}
-
-/* Checks if the device a Geyser 2 (ANSI, ISO, JIS) */
-static inline int atp_is_geyser_2(struct atp *dev)
-{
-        u16 productId = le16_to_cpu(dev->udev->descriptor.idProduct);
-
-        return (productId == GEYSER_ANSI_PRODUCT_ID) ||
-                (productId == GEYSER_ISO_PRODUCT_ID) ||
-                (productId == GEYSER_JIS_PRODUCT_ID);
-}
-
-static inline int atp_is_geyser_3(struct atp *dev)
-{
-        u16 productId = le16_to_cpu(dev->udev->descriptor.idProduct);
-
-        return (productId == GEYSER3_ANSI_PRODUCT_ID) ||
-                (productId == GEYSER3_ISO_PRODUCT_ID) ||
-                (productId == GEYSER3_JIS_PRODUCT_ID) ||
-                (productId == GEYSER4_ANSI_PRODUCT_ID) ||
-                (productId == GEYSER4_ISO_PRODUCT_ID) ||
-                (productId == GEYSER4_JIS_PRODUCT_ID) ||
-                (productId == GEYSER4_HF_ANSI_PRODUCT_ID) ||
-                (productId == GEYSER4_HF_ISO_PRODUCT_ID) ||
-                (productId == GEYSER4_HF_JIS_PRODUCT_ID);
-}
-
 /*
  * By default newer Geyser devices send standard USB HID mouse
  * packets (Report ID 2). This code changes device mode, so it
@@ -240,6 +203,7 @@ static int atp_geyser_init(struct usb_device *udev)
 {
         char data[8];
         int size;
+        int i;
 
         size = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
                         ATP_GEYSER_MODE_READ_REQUEST_ID,
@@ -248,8 +212,11 @@ static int atp_geyser_init(struct usb_device *udev)
                         ATP_GEYSER_MODE_REQUEST_INDEX, &data, 8, 5000);
 
         if (size != 8) {
-                err("Could not do mode read request from device"
-                    " (Geyser Raw mode)");
+                dprintk("atp_geyser_init: read error\n");
+                for (i = 0; i < 8; i++)
+                        dprintk("appletouch[%d]: %d\n", i, data[i]);
+
+                err("Failed to read mode from device.");
                 return -EIO;
         }
 
@@ -263,8 +230,11 @@ static int atp_geyser_init(struct usb_device *udev)
                         ATP_GEYSER_MODE_REQUEST_INDEX, &data, 8, 5000);
 
         if (size != 8) {
-                err("Could not do mode write request to device"
-                    " (Geyser Raw mode)");
+                dprintk("atp_geyser_init: write error\n");
+                for (i = 0; i < 8; i++)
+                        dprintk("appletouch[%d]: %d\n", i, data[i]);
+
+                err("Failed to request geyser raw mode");
                 return -EIO;
         }
         return 0;
@@ -280,15 +250,15 @@ static void atp_reinit(struct work_struct *work)
         struct usb_device *udev = dev->udev;
         int retval;
 
+        dprintk("appletouch: putting appletouch to sleep (reinit)\n");
         dev->idlecount = 0;
 
         atp_geyser_init(udev);
 
         retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
-        if (retval) {
-                err("%s - usb_submit_urb failed with result %d",
-                    __FUNCTION__, retval);
-        }
+        if (retval)
+                err("atp_reinit: usb_submit_urb failed with error %d",
+                    retval);
 }
 
 static int atp_calculate_abs(int *xy_sensors, int nb_sensors, int fact,
@@ -323,7 +293,8 @@ static int atp_calculate_abs(int *xy_sensors, int nb_sensors, int fact,
                  *
                  * - Jason Parekh <jasonparekh@gmail.com>
                  */
-                if (i < 1 || (!is_increasing && xy_sensors[i - 1] < xy_sensors[i])) {
+                if (i < 1 ||
+                    (!is_increasing && xy_sensors[i - 1] < xy_sensors[i])) {
                         (*fingers)++;
                         is_increasing = 1;
                 } else if (i > 0 && xy_sensors[i - 1] >= xy_sensors[i]) {
@@ -331,11 +302,11 @@ static int atp_calculate_abs(int *xy_sensors, int nb_sensors, int fact,
                 }
 
                 /*
-                 * Subtracts threshold so a high sensor that just passes the threshold
-                 * won't skew the calculated absolute coordinate.  Fixes an issue
-                 * where slowly moving the mouse would occassionaly jump a number of
-                 * pixels (let me restate--slowly moving the mouse makes this issue
-                 * most apparent).
+                 * Subtracts threshold so a high sensor that just passes the
+                 * threshold won't skew the calculated absolute coordinate.
+                 * Fixes an issue where slowly moving the mouse would
+                 * occasionally jump a number of pixels (slowly moving the
+                 * finger makes this issue most apparent.)
                  */
                 pcum += (xy_sensors[i] - threshold) * i;
                 psum += (xy_sensors[i] - threshold);
@@ -356,7 +327,7 @@ static inline void atp_report_fingers(struct input_dev *input, int fingers)
         input_report_key(input, BTN_TOOL_TRIPLETAP, fingers > 2);
 }
 
-static void atp_complete(struct urb* urb)
+static void atp_complete(struct urb *urb)
 {
         int x, y, x_z, y_z, x_f, y_f;
         int retval, i, j;
@@ -368,22 +339,22 @@ static void atp_complete(struct urb* urb)
                 /* success */
                 break;
         case -EOVERFLOW:
-                if(!dev->overflowwarn) {
+                if (!dev->overflow_warned) {
                         printk(KERN_WARNING "appletouch: OVERFLOW with data "
                                 "length %d, actual length is %d\n",
                                 dev->datalen, dev->urb->actual_length);
-                        dev->overflowwarn = 1;
+                        dev->overflow_warned = true;
                 }
         case -ECONNRESET:
         case -ENOENT:
         case -ESHUTDOWN:
                 /* This urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d",
-                    __FUNCTION__, urb->status);
+                dbg("atp_complete: urb shutting down with status: %d",
+                    urb->status);
                 return;
         default:
-                dbg("%s - nonzero urb status received: %d",
-                    __FUNCTION__, urb->status);
+                dbg("atp_complete: nonzero urb status received: %d",
+                    urb->status);
                 goto exit;
         }
 
@@ -396,7 +367,7 @@ static void atp_complete(struct urb* urb)
         }
 
         /* reorder the sensors values */
-        if (atp_is_geyser_3(dev)) {
+        if (dev->type == ATP_GEYSER3 || dev->type == ATP_GEYSER4) {
                 memset(dev->xy_cur, 0, sizeof(dev->xy_cur));
 
                 /*
@@ -415,7 +386,7 @@ static void atp_complete(struct urb* urb)
                         dev->xy_cur[ATP_XSENSORS + i] = dev->data[j + 1];
                         dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 2];
                 }
-        } else if (atp_is_geyser_2(dev)) {
+        } else if (dev->type == ATP_GEYSER2) {
                 memset(dev->xy_cur, 0, sizeof(dev->xy_cur));
 
                 /*
@@ -438,7 +409,7 @@ static void atp_complete(struct urb* urb)
         } else {
                 for (i = 0; i < 8; i++) {
                         /* X values */
-                        dev->xy_cur[i     ] = dev->data[5 * i +  2];
+                        dev->xy_cur[i +  0] = dev->data[5 * i +  2];
                         dev->xy_cur[i +  8] = dev->data[5 * i +  4];
                         dev->xy_cur[i + 16] = dev->data[5 * i + 42];
                         if (i < 2)
@@ -454,21 +425,22 @@ static void atp_complete(struct urb* urb)
 
         if (!dev->valid) {
                 /* first sample */
-                dev->valid = 1;
+                dev->valid = true;
                 dev->x_old = dev->y_old = -1;
                 memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
 
                 if (dev->size_detect_done ||
-                    atp_is_geyser_3(dev)) /* No 17" Macbooks (yet) */
+                    dev->type == ATP_GEYSER3) /* No 17" Macbooks (yet) */
                         goto exit;
 
                 /* 17" Powerbooks have extra X sensors */
-                for (i = (atp_is_geyser_2(dev) ? 15 : 16); i < ATP_XSENSORS; i++) {
+                for (i = (dev->type == ATP_GEYSER2 ? 15 : 16);
+                     i < ATP_XSENSORS; i++) {
                         if (!dev->xy_cur[i])
                                 continue;
 
                         printk(KERN_INFO "appletouch: 17\" model detected.\n");
-                        if (atp_is_geyser_2(dev))
+                        if (dev->type == ATP_GEYSER2)
                                 input_set_abs_params(dev->input, ABS_X, 0,
                                                      (20 - 1) *
                                                      ATP_XFACT - 1,
@@ -548,11 +520,15 @@ static void atp_complete(struct urb* urb)
          * several hundred times a second. Re-initialization does not
          * work on Fountain touchpads.
          */
-        if (!atp_is_fountain(dev)) {
+        if (dev->type != ATP_FOUNTAIN) {
+                /*
+                 * Button must not be pressed when entering suspend,
+                 * otherwise we will never release the button.
+                 */
                 if (!x && !y && !key) {
                         dev->idlecount++;
                         if (dev->idlecount == 10) {
-                                dev->valid = 0;
+                                dev->valid = false;
                                 schedule_work(&dev->work);
                                 /* Don't resubmit urb here, wait for reinit */
                                 return;
@@ -561,12 +537,11 @@ static void atp_complete(struct urb* urb)
                         dev->idlecount = 0;
         }
 
-exit:
+ exit:
         retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
-        if (retval) {
-                err("%s - usb_submit_urb failed with result %d",
-                    __FUNCTION__, retval);
-        }
+        if (retval)
+                err("atp_complete: usb_submit_urb failed with result %d",
+                    retval);
 }
 
 static int atp_open(struct input_dev *input)
@@ -593,7 +568,7 @@ static int atp_handle_geyser(struct atp *dev)
 {
         struct usb_device *udev = dev->udev;
 
-        if (!atp_is_fountain(dev)) {
+        if (dev->type != ATP_FOUNTAIN) {
                 /* switch to raw sensor mode */
                 if (atp_geyser_init(udev))
                         return -EIO;
@@ -604,7 +579,8 @@ static int atp_handle_geyser(struct atp *dev)
         return 0;
 }
 
-static int atp_probe(struct usb_interface *iface, const struct usb_device_id *id)
+static int atp_probe(struct usb_interface *iface,
+                     const struct usb_device_id *id)
 {
         struct atp *dev;
         struct input_dev *input_dev;
@@ -640,13 +616,12 @@ static int atp_probe(struct usb_interface *iface, const struct usb_device_id *id
 
         dev->udev = udev;
         dev->input = input_dev;
-        dev->overflowwarn = 0;
-        if (atp_is_geyser_3(dev))
-                dev->datalen = 64;
-        else if (atp_is_geyser_2(dev))
-                dev->datalen = 64;
-        else
+        dev->type = id->driver_info;
+        dev->overflow_warned = false;
+        if (dev->type == ATP_FOUNTAIN || dev->type == ATP_GEYSER1)
                 dev->datalen = 81;
+        else
+                dev->datalen = 64;
 
         dev->urb = usb_alloc_urb(0, GFP_KERNEL);
         if (!dev->urb)
@@ -680,7 +655,7 @@ static int atp_probe(struct usb_interface *iface, const struct usb_device_id *id
 
         set_bit(EV_ABS, input_dev->evbit);
 
-        if (atp_is_geyser_3(dev)) {
+        if (dev->type == ATP_GEYSER3 || dev->type == ATP_GEYSER4) {
                 /*
                  * MacBook have 20 X sensors, 10 Y sensors
                  */
@@ -688,7 +663,7 @@ static int atp_probe(struct usb_interface *iface, const struct usb_device_id *id
                                      ((20 - 1) * ATP_XFACT) - 1, ATP_FUZZ, 0);
                 input_set_abs_params(input_dev, ABS_Y, 0,
                                      ((10 - 1) * ATP_YFACT) - 1, ATP_FUZZ, 0);
-        } else if (atp_is_geyser_2(dev)) {
+        } else if (dev->type == ATP_GEYSER2) {
                 /*
                  * Oct 2005 15" PowerBooks have 15 X sensors, 17" are detected
                  * later.
@@ -703,9 +678,11 @@ static int atp_probe(struct usb_interface *iface, const struct usb_device_id *id
                  * 17" models are detected later.
                  */
                 input_set_abs_params(input_dev, ABS_X, 0,
-                                     (16 - 1) * ATP_XFACT - 1, ATP_FUZZ, 0);
+                                     (16 - 1) * ATP_XFACT - 1,
+                                     ATP_FUZZ, 0);
                 input_set_abs_params(input_dev, ABS_Y, 0,
-                                     (ATP_YSENSORS - 1) * ATP_YFACT - 1, ATP_FUZZ, 0);
+                                     (ATP_YSENSORS - 1) * ATP_YFACT - 1,
+                                     ATP_FUZZ, 0);
         }
         input_set_abs_params(input_dev, ABS_PRESSURE, 0, ATP_PRESSURE, 0, 0);
 
@@ -774,7 +751,7 @@ static int atp_suspend(struct usb_interface *iface, pm_message_t message)
         struct atp *dev = usb_get_intfdata(iface);
 
         usb_kill_urb(dev->urb);
-        dev->valid = 0;
+        dev->valid = false;
 
         return 0;
 }
diff --git a/drivers/input/mouse/atarimouse.c b/drivers/input/mouse/atarimouse.c
index 98a3561d4b05..adf45b3040e9 100644
--- a/drivers/input/mouse/atarimouse.c
+++ b/drivers/input/mouse/atarimouse.c
@@ -57,15 +57,12 @@ MODULE_AUTHOR("Michael Schmitz <schmitz@biophys.uni-duesseldorf.de>");
 MODULE_DESCRIPTION("Atari mouse driver");
 MODULE_LICENSE("GPL");
 
-static int mouse_threshold[2] = {2,2};
+static int mouse_threshold[2] = {2, 2};
+module_param_array(mouse_threshold, int, NULL, 0);
 
-#ifdef __MODULE__
-MODULE_PARM(mouse_threshold, "2i");
-#endif
 #ifdef FIXED_ATARI_JOYSTICK
 extern int atari_mouse_buttons;
 #endif
-static int atamouse_used = 0;
 
 static struct input_dev *atamouse_dev;
 
@@ -97,9 +94,6 @@ static void atamouse_interrupt(char *buf)
 
 static int atamouse_open(struct input_dev *dev)
 {
-        if (atamouse_used++)
-                return 0;
-
 #ifdef FIXED_ATARI_JOYSTICK
         atari_mouse_buttons = 0;
 #endif
@@ -107,23 +101,24 @@ static int atamouse_open(struct input_dev *dev)
         ikbd_mouse_thresh(mouse_threshold[0], mouse_threshold[1]);
         ikbd_mouse_rel_pos();
         atari_input_mouse_interrupt_hook = atamouse_interrupt;
+
         return 0;
 }
 
 static void atamouse_close(struct input_dev *dev)
 {
-        if (!--atamouse_used) {
-                ikbd_mouse_disable();
-                atari_mouse_interrupt_hook = NULL;
-        }
+        ikbd_mouse_disable();
+        atari_mouse_interrupt_hook = NULL;
 }
 
 static int __init atamouse_init(void)
 {
+        int error;
+
         if (!MACH_IS_ATARI || !ATARIHW_PRESENT(ST_MFP))
                 return -ENODEV;
 
-        if (!(atari_keyb_init()))
+        if (!atari_keyb_init())
                 return -ENODEV;
 
         atamouse_dev = input_allocate_device();
@@ -141,12 +136,14 @@ static int __init atamouse_init(void)
         atamouse_dev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);
         atamouse_dev->keybit[BIT_WORD(BTN_LEFT)] = BIT_MASK(BTN_LEFT) |
                 BIT_MASK(BTN_MIDDLE) | BIT_MASK(BTN_RIGHT);
+
         atamouse_dev->open = atamouse_open;
         atamouse_dev->close = atamouse_close;
 
-        if (input_register_device(atamouse_dev)) {
+        error = input_register_device(atamouse_dev);
+        if (error) {
                 input_free_device(atamouse_dev);
-                return -ENOMEM;
+                return error;
         }
 
         return 0;
diff --git a/drivers/input/mouse/hil_ptr.c b/drivers/input/mouse/hil_ptr.c
index 27f88fbb7136..e532c48410ea 100644
--- a/drivers/input/mouse/hil_ptr.c
+++ b/drivers/input/mouse/hil_ptr.c
@@ -247,19 +247,24 @@ static void hil_ptr_disconnect(struct serio *serio)
 
 static int hil_ptr_connect(struct serio *serio, struct serio_driver *driver)
 {
-        struct hil_ptr   *ptr;
-        const char       *txt;
-        unsigned int     i, naxsets, btntype;
-        uint8_t          did, *idd;
-
-        if (!(ptr = kzalloc(sizeof(struct hil_ptr), GFP_KERNEL)))
+        struct hil_ptr  *ptr;
+        const char      *txt;
+        unsigned int    i, naxsets, btntype;
+        uint8_t         did, *idd;
+        int             error;
+
+        ptr = kzalloc(sizeof(struct hil_ptr), GFP_KERNEL);
+        if (!ptr)
                 return -ENOMEM;
 
         ptr->dev = input_allocate_device();
-        if (!ptr->dev)
+        if (!ptr->dev) {
+                error = -ENOMEM;
                 goto bail0;
+        }
 
-        if (serio_open(serio, driver))
+        error = serio_open(serio, driver);
+        if (error)
                 goto bail1;
 
         serio_set_drvdata(serio, ptr);
@@ -297,6 +302,7 @@ static int hil_ptr_connect(struct serio *serio, struct serio_driver *driver)
         did = ptr->idd[0];
         idd = ptr->idd + 1;
         txt = "unknown";
+
         if ((did & HIL_IDD_DID_TYPE_MASK) == HIL_IDD_DID_TYPE_REL) {
                 ptr->dev->evbit[0] = BIT_MASK(EV_REL);
                 txt = "relative";
@@ -306,8 +312,11 @@ static int hil_ptr_connect(struct serio *serio, struct serio_driver *driver)
                 ptr->dev->evbit[0] = BIT_MASK(EV_ABS);
                 txt = "absolute";
         }
-        if (!ptr->dev->evbit[0])
+
+        if (!ptr->dev->evbit[0]) {
+                error = -ENODEV;
                 goto bail2;
+        }
 
         ptr->nbtn = HIL_IDD_NUM_BUTTONS(idd);
         if (ptr->nbtn)
@@ -380,13 +389,19 @@ static int hil_ptr_connect(struct serio *serio, struct serio_driver *driver)
         ptr->dev->id.version    = 0x0100; /* TODO: get from ptr->rsc */
         ptr->dev->dev.parent    = &serio->dev;
 
-        input_register_device(ptr->dev);
+        error = input_register_device(ptr->dev);
+        if (error) {
+                printk(KERN_INFO PREFIX "Unable to register input device\n");
+                goto bail2;
+        }
+
         printk(KERN_INFO "input: %s (%s), ID: %d\n",
                 ptr->dev->name,
                 (btntype == BTN_MOUSE) ? "HIL mouse":"HIL tablet or touchpad",
                 did);
 
         return 0;
+
  bail2:
         serio_close(serio);
  bail1:
@@ -394,7 +409,7 @@ static int hil_ptr_connect(struct serio *serio, struct serio_driver *driver)
  bail0:
         kfree(ptr);
         serio_set_drvdata(serio, NULL);
-        return -ENODEV;
+        return error;
 }
 
 static struct serio_device_id hil_ptr_ids[] = {
diff --git a/drivers/input/mouse/inport.c b/drivers/input/mouse/inport.c
index 06c35fc553c0..3827a22362de 100644
--- a/drivers/input/mouse/inport.c
+++ b/drivers/input/mouse/inport.c
@@ -1,6 +1,4 @@
 /*
- * $Id: inport.c,v 1.11 2001/09/25 10:12:07 vojtech Exp $
- *
  *  Copyright (c) 1999-2001 Vojtech Pavlik
  *
  *  Based on the work of:
diff --git a/drivers/input/mouse/logibm.c b/drivers/input/mouse/logibm.c
index 9ea895593b27..e2413113df22 100644
--- a/drivers/input/mouse/logibm.c
+++ b/drivers/input/mouse/logibm.c
@@ -1,6 +1,4 @@
 /*
- * $Id: logibm.c,v 1.11 2001/09/25 10:12:07 vojtech Exp $
- *
  *  Copyright (c) 1999-2001 Vojtech Pavlik
  *
  *  Based on the work of:
diff --git a/drivers/input/mouse/pc110pad.c b/drivers/input/mouse/pc110pad.c
index 61cff8374e6c..fd09c8df81f2 100644
--- a/drivers/input/mouse/pc110pad.c
+++ b/drivers/input/mouse/pc110pad.c
@@ -1,6 +1,4 @@
 /*
- * $Id: pc110pad.c,v 1.12 2001/09/25 10:12:07 vojtech Exp $
- *
  *  Copyright (c) 2000-2001 Vojtech Pavlik
  *
  *  Based on the work of:
diff --git a/drivers/input/mouse/sermouse.c b/drivers/input/mouse/sermouse.c
index ed917bfd086a..17ff137b9bd5 100644
--- a/drivers/input/mouse/sermouse.c
+++ b/drivers/input/mouse/sermouse.c
@@ -1,6 +1,4 @@
 /*
- * $Id: sermouse.c,v 1.17 2002/03/13 10:03:43 vojtech Exp $
- *
  *  Copyright (c) 1999-2001 Vojtech Pavlik
  */
 
diff --git a/drivers/input/serio/Kconfig b/drivers/input/serio/Kconfig
index ec4b6610f730..27d70d326ff3 100644
--- a/drivers/input/serio/Kconfig
+++ b/drivers/input/serio/Kconfig
@@ -190,4 +190,14 @@ config SERIO_RAW
           To compile this driver as a module, choose M here: the
           module will be called serio_raw.
 
+config SERIO_XILINX_XPS_PS2
+        tristate "Xilinx XPS PS/2 Controller Support"
+        depends on PPC
+        help
+          This driver supports XPS PS/2 IP from the Xilinx EDK on
+          PowerPC platform.
+
+          To compile this driver as a module, choose M here: the
+          module will be called xilinx_ps2.
+
 endif
diff --git a/drivers/input/serio/Makefile b/drivers/input/serio/Makefile
index 38b886887cbc..9b6c8135955f 100644
--- a/drivers/input/serio/Makefile
+++ b/drivers/input/serio/Makefile
@@ -21,3 +21,4 @@ obj-$(CONFIG_SERIO_PCIPS2)	+= pcips2.o
 obj-$(CONFIG_SERIO_MACEPS2)     += maceps2.o
 obj-$(CONFIG_SERIO_LIBPS2)      += libps2.o
 obj-$(CONFIG_SERIO_RAW)         += serio_raw.o
+obj-$(CONFIG_SERIO_XILINX_XPS_PS2)      += xilinx_ps2.o
diff --git a/drivers/input/serio/ct82c710.c b/drivers/input/serio/ct82c710.c
index 0d35018c23a9..d1380fc72cc6 100644
--- a/drivers/input/serio/ct82c710.c
+++ b/drivers/input/serio/ct82c710.c
@@ -1,6 +1,4 @@
 /*
- * $Id: ct82c710.c,v 1.11 2001/09/25 10:12:07 vojtech Exp $
- *
  *  Copyright (c) 1999-2001 Vojtech Pavlik
  */
 
diff --git a/drivers/input/serio/hil_mlc.c b/drivers/input/serio/hil_mlc.c
index 93a1a6ba216a..37586a68d345 100644
--- a/drivers/input/serio/hil_mlc.c
+++ b/drivers/input/serio/hil_mlc.c
@@ -76,7 +76,7 @@ static struct timer_list	hil_mlcs_kicker;
 static int                      hil_mlcs_probe;
 
 static void hil_mlcs_process(unsigned long unused);
-DECLARE_TASKLET_DISABLED(hil_mlcs_tasklet, hil_mlcs_process, 0);
+static DECLARE_TASKLET_DISABLED(hil_mlcs_tasklet, hil_mlcs_process, 0);
 
 
 /* #define HIL_MLC_DEBUG */
@@ -459,7 +459,7 @@ static int hilse_operate(hil_mlc *mlc, int repoll)
 #define OUT_LAST(pack) \
 { HILSE_OUT_LAST,       { .packet = pack }, 0, 0, 0, 0 },
 
-const struct hilse_node hil_mlc_se[HILSEN_END] = {
+static const struct hilse_node hil_mlc_se[HILSEN_END] = {
 
         /* 0  HILSEN_START */
         FUNC(hilse_init_lcv, 0, HILSEN_NEXT,    HILSEN_SLEEP,   0)
@@ -784,7 +784,7 @@ static void hil_mlcs_process(unsigned long unused)
 
 /************************* Keepalive timer task *********************/
 
-void hil_mlcs_timer(unsigned long data)
+static void hil_mlcs_timer(unsigned long data)
 {
         hil_mlcs_probe = 1;
         tasklet_schedule(&hil_mlcs_tasklet);
diff --git a/drivers/input/serio/hp_sdc.c b/drivers/input/serio/hp_sdc.c
index edfedd9a166c..7b233a492ad5 100644
--- a/drivers/input/serio/hp_sdc.c
+++ b/drivers/input/serio/hp_sdc.c
@@ -105,6 +105,10 @@ EXPORT_SYMBOL(__hp_sdc_enqueue_transaction);
 EXPORT_SYMBOL(hp_sdc_enqueue_transaction);
 EXPORT_SYMBOL(hp_sdc_dequeue_transaction);
 
+static unsigned int hp_sdc_disabled;
+module_param_named(no_hpsdc, hp_sdc_disabled, bool, 0);
+MODULE_PARM_DESC(no_hpsdc, "Do not enable HP SDC driver.");
+
 static hp_i8042_sdc     hp_sdc; /* All driver state is kept in here. */
 
 /*************** primitives for use in any context *********************/
@@ -980,6 +984,11 @@ static int __init hp_sdc_register(void)
         unsigned char i;
 #endif
 
+        if (hp_sdc_disabled) {
+                printk(KERN_WARNING PREFIX "HP SDC driver disabled by no_hpsdc=1.\n");
+                return -ENODEV;
+        }
+
         hp_sdc.dev = NULL;
         hp_sdc.dev_err = 0;
 #if defined(__hppa__)
diff --git a/drivers/input/serio/hp_sdc_mlc.c b/drivers/input/serio/hp_sdc_mlc.c
index 587398f5c9df..b587e2d576ac 100644
--- a/drivers/input/serio/hp_sdc_mlc.c
+++ b/drivers/input/serio/hp_sdc_mlc.c
@@ -50,7 +50,7 @@ MODULE_AUTHOR("Brian S. Julin <bri@calyx.com>");
 MODULE_DESCRIPTION("Glue for onboard HIL MLC in HP-PARISC machines");
 MODULE_LICENSE("Dual BSD/GPL");
 
-struct hp_sdc_mlc_priv_s {
+static struct hp_sdc_mlc_priv_s {
         int emtestmode;
         hp_sdc_transaction trans;
         u8 tseq[16];
diff --git a/drivers/input/serio/i8042-x86ia64io.h b/drivers/input/serio/i8042-x86ia64io.h
index 78eb7841174c..fe732a574ec2 100644
--- a/drivers/input/serio/i8042-x86ia64io.h
+++ b/drivers/input/serio/i8042-x86ia64io.h
@@ -63,13 +63,22 @@ static inline void i8042_write_command(int val)
         outb(val, I8042_COMMAND_REG);
 }
 
-#if defined(__i386__) || defined(__x86_64__)
+#ifdef CONFIG_X86
 
 #include <linux/dmi.h>
 
 static struct dmi_system_id __initdata i8042_dmi_noloop_table[] = {
         {
                 /* AUX LOOP command does not raise AUX IRQ */
+                .ident = "Arima-Rioworks HDAMB",
+                .matches = {
+                        DMI_MATCH(DMI_BOARD_VENDOR, "RIOWORKS"),
+                        DMI_MATCH(DMI_BOARD_NAME, "HDAMB"),
+                        DMI_MATCH(DMI_BOARD_VERSION, "Rev E"),
+                },
+        },
+        {
+                /* AUX LOOP command does not raise AUX IRQ */
                 .ident = "ASUS P65UP5",
                 .matches = {
                         DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
@@ -118,6 +127,14 @@ static struct dmi_system_id __initdata i8042_dmi_noloop_table[] = {
                         DMI_MATCH(DMI_PRODUCT_VERSION, "VS2005R2"),
                 },
         },
+        {
+                .ident = "Medion MAM 2070",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Notebook"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "MAM 2070"),
+                        DMI_MATCH(DMI_PRODUCT_VERSION, "5a"),
+                },
+        },
         { }
 };
 
@@ -291,17 +308,36 @@ static struct dmi_system_id __initdata i8042_dmi_nomux_table[] = {
                         DMI_MATCH(DMI_PRODUCT_VERSION, "3000 N100"),
                 },
         },
+        {
+                .ident = "Acer Aspire 1360",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 1360"),
+                },
+        },
+        {
+                .ident = "Gericom Bellagio",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Gericom"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "N34AS6"),
+                },
+        },
         { }
 };
 
-
-
+#ifdef CONFIG_PNP
+static struct dmi_system_id __initdata i8042_dmi_nopnp_table[] = {
+        {
+                .ident = "Intel MBO Desktop D845PESV",
+                .matches = {
+                        DMI_MATCH(DMI_BOARD_NAME, "D845PESV"),
+                        DMI_MATCH(DMI_BOARD_VENDOR, "Intel Corporation"),
+                },
+        },
+        { }
+};
 #endif
 
-#ifdef CONFIG_X86
-
-#include <linux/dmi.h>
-
 /*
  * Some Wistron based laptops need us to explicitly enable the 'Dritek
  * keyboard extension' to make their extra keys start generating scancodes.
@@ -331,6 +367,13 @@ static struct dmi_system_id __initdata i8042_dmi_dritek_table[] = {
                 },
         },
         {
+                .ident = "Acer Aspire 5720",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5720"),
+                },
+        },
+        {
                 .ident = "Acer Aspire 9110",
                 .matches = {
                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
@@ -356,7 +399,6 @@ static struct dmi_system_id __initdata i8042_dmi_dritek_table[] = {
 
 #endif /* CONFIG_X86 */
 
-
 #ifdef CONFIG_PNP
 #include <linux/pnp.h>
 
@@ -466,6 +508,11 @@ static int __init i8042_pnp_init(void)
         int pnp_data_busted = 0;
         int err;
 
+#ifdef CONFIG_X86
+        if (dmi_check_system(i8042_dmi_nopnp_table))
+                i8042_nopnp = 1;
+#endif
+
         if (i8042_nopnp) {
                 printk(KERN_INFO "i8042: PNP detection disabled\n");
                 return 0;
@@ -591,15 +638,13 @@ static int __init i8042_platform_init(void)
         i8042_reset = 1;
 #endif
 
-#if defined(__i386__) || defined(__x86_64__)
+#ifdef CONFIG_X86
         if (dmi_check_system(i8042_dmi_noloop_table))
                 i8042_noloop = 1;
 
         if (dmi_check_system(i8042_dmi_nomux_table))
                 i8042_nomux = 1;
-#endif
 
-#ifdef CONFIG_X86
         if (dmi_check_system(i8042_dmi_dritek_table))
                 i8042_dritek = 1;
 #endif /* CONFIG_X86 */
diff --git a/drivers/input/serio/libps2.c b/drivers/input/serio/libps2.c
index b819239d74dc..2b304c22c200 100644
--- a/drivers/input/serio/libps2.c
+++ b/drivers/input/serio/libps2.c
@@ -26,15 +26,6 @@ MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>");
 MODULE_DESCRIPTION("PS/2 driver library");
 MODULE_LICENSE("GPL");
 
-/* Work structure to schedule execution of a command */
-struct ps2work {
-        struct work_struct work;
-        struct ps2dev *ps2dev;
-        int command;
-        unsigned char param[0];
-};
-
-
 /*
  * ps2_sendbyte() sends a byte to the device and waits for acknowledge.
  * It doesn't handle retransmission, though it could - because if there
@@ -246,49 +237,6 @@ int ps2_command(struct ps2dev *ps2dev, unsigned char *param, int command)
 EXPORT_SYMBOL(ps2_command);
 
 /*
- * ps2_execute_scheduled_command() sends a command, previously scheduled by
- * ps2_schedule_command(), to a PS/2 device (keyboard, mouse, etc.)
- */
-
-static void ps2_execute_scheduled_command(struct work_struct *work)
-{
-        struct ps2work *ps2work = container_of(work, struct ps2work, work);
-
-        ps2_command(ps2work->ps2dev, ps2work->param, ps2work->command);
-        kfree(ps2work);
-}
-
-/*
- * ps2_schedule_command() allows to schedule delayed execution of a PS/2
- * command and can be used to issue a command from an interrupt or softirq
- * context.
- */
-
-int ps2_schedule_command(struct ps2dev *ps2dev, unsigned char *param, int command)
-{
-        struct ps2work *ps2work;
-        int send = (command >> 12) & 0xf;
-        int receive = (command >> 8) & 0xf;
-
-        if (!(ps2work = kmalloc(sizeof(struct ps2work) + max(send, receive), GFP_ATOMIC)))
-                return -1;
-
-        memset(ps2work, 0, sizeof(struct ps2work));
-        ps2work->ps2dev = ps2dev;
-        ps2work->command = command;
-        memcpy(ps2work->param, param, send);
-        INIT_WORK(&ps2work->work, ps2_execute_scheduled_command);
-
-        if (!schedule_work(&ps2work->work)) {
-                kfree(ps2work);
-                return -1;
-        }
-
-        return 0;
-}
-EXPORT_SYMBOL(ps2_schedule_command);
-
-/*
  * ps2_init() initializes ps2dev structure
  */
 
diff --git a/drivers/input/serio/q40kbd.c b/drivers/input/serio/q40kbd.c
index d962a8d78b14..e36a0901646c 100644
--- a/drivers/input/serio/q40kbd.c
+++ b/drivers/input/serio/q40kbd.c
@@ -1,6 +1,4 @@
 /*
- * $Id: q40kbd.c,v 1.12 2002/02/02 22:26:44 vojtech Exp $
- *
  *  Copyright (c) 2000-2001 Vojtech Pavlik
  *
  *  Based on the work of:
@@ -49,7 +47,7 @@ MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
 MODULE_DESCRIPTION("Q40 PS/2 keyboard controller driver");
 MODULE_LICENSE("GPL");
 
-DEFINE_SPINLOCK(q40kbd_lock);
+static DEFINE_SPINLOCK(q40kbd_lock);
 static struct serio *q40kbd_port;
 static struct platform_device *q40kbd_device;
 
diff --git a/drivers/input/serio/rpckbd.c b/drivers/input/serio/rpckbd.c
index 34c59d9c6205..1567b7782478 100644
--- a/drivers/input/serio/rpckbd.c
+++ b/drivers/input/serio/rpckbd.c
@@ -1,6 +1,4 @@
 /*
- * $Id: rpckbd.c,v 1.7 2001/09/25 10:12:07 vojtech Exp $
- *
  *  Copyright (c) 2000-2001 Vojtech Pavlik
  *  Copyright (c) 2002 Russell King
  */
diff --git a/drivers/input/serio/serio.c b/drivers/input/serio/serio.c
index 7f5293828fbf..78f2abb5c11b 100644
--- a/drivers/input/serio/serio.c
+++ b/drivers/input/serio/serio.c
@@ -331,9 +331,10 @@ static void serio_handle_event(void)
 }
 
 /*
- * Remove all events that have been submitted for a given serio port.
+ * Remove all events that have been submitted for a given
+ * object, be it serio port or driver.
  */
-static void serio_remove_pending_events(struct serio *serio)
+static void serio_remove_pending_events(void *object)
 {
         struct list_head *node, *next;
         struct serio_event *event;
@@ -343,7 +344,7 @@ static void serio_remove_pending_events(struct serio *serio)
 
         list_for_each_safe(node, next, &serio_event_list) {
                 event = list_entry(node, struct serio_event, node);
-                if (event->object == serio) {
+                if (event->object == object) {
                         list_del_init(node);
                         serio_free_event(event);
                 }
@@ -837,7 +838,9 @@ void serio_unregister_driver(struct serio_driver *drv)
         struct serio *serio;
 
         mutex_lock(&serio_mutex);
+
         drv->manual_bind = 1;   /* so serio_find_driver ignores it */
+        serio_remove_pending_events(drv);
 
 start_over:
         list_for_each_entry(serio, &serio_list, node) {
diff --git a/drivers/input/serio/xilinx_ps2.c b/drivers/input/serio/xilinx_ps2.c
new file mode 100644
index 000000000000..0ed044d5e685
--- /dev/null
+++ b/drivers/input/serio/xilinx_ps2.c
@@ -0,0 +1,380 @@
+/*
+ * Xilinx XPS PS/2 device driver
+ *
+ * (c) 2005 MontaVista Software, Inc.
+ * (c) 2008 Xilinx, Inc.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <linux/module.h>
+#include <linux/serio.h>
+#include <linux/interrupt.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/list.h>
+#include <linux/io.h>
+
+#include <linux/of_device.h>
+#include <linux/of_platform.h>
+
+#define DRIVER_NAME             "xilinx_ps2"
+
+/* Register offsets for the xps2 device */
+#define XPS2_SRST_OFFSET        0x00000000 /* Software Reset register */
+#define XPS2_STATUS_OFFSET      0x00000004 /* Status register */
+#define XPS2_RX_DATA_OFFSET     0x00000008 /* Receive Data register */
+#define XPS2_TX_DATA_OFFSET     0x0000000C /* Transmit Data register */
+#define XPS2_GIER_OFFSET        0x0000002C /* Global Interrupt Enable reg */
+#define XPS2_IPISR_OFFSET       0x00000030 /* Interrupt Status register */
+#define XPS2_IPIER_OFFSET       0x00000038 /* Interrupt Enable register */
+
+/* Reset Register Bit Definitions */
+#define XPS2_SRST_RESET         0x0000000A /* Software Reset  */
+
+/* Status Register Bit Positions */
+#define XPS2_STATUS_RX_FULL     0x00000001 /* Receive Full  */
+#define XPS2_STATUS_TX_FULL     0x00000002 /* Transmit Full  */
+
+/* Bit definitions for ISR/IER registers. Both the registers have the same bit
+ * definitions and are only defined once. */
+#define XPS2_IPIXR_WDT_TOUT     0x00000001 /* Watchdog Timeout Interrupt */
+#define XPS2_IPIXR_TX_NOACK     0x00000002 /* Transmit No ACK Interrupt */
+#define XPS2_IPIXR_TX_ACK       0x00000004 /* Transmit ACK (Data) Interrupt */
+#define XPS2_IPIXR_RX_OVF       0x00000008 /* Receive Overflow Interrupt */
+#define XPS2_IPIXR_RX_ERR       0x00000010 /* Receive Error Interrupt */
+#define XPS2_IPIXR_RX_FULL      0x00000020 /* Receive Data Interrupt */
+
+/* Mask for all the Transmit Interrupts */
+#define XPS2_IPIXR_TX_ALL       (XPS2_IPIXR_TX_NOACK | XPS2_IPIXR_TX_ACK)
+
+/* Mask for all the Receive Interrupts */
+#define XPS2_IPIXR_RX_ALL       (XPS2_IPIXR_RX_OVF | XPS2_IPIXR_RX_ERR |  \
+                                        XPS2_IPIXR_RX_FULL)
+
+/* Mask for all the Interrupts */
+#define XPS2_IPIXR_ALL          (XPS2_IPIXR_TX_ALL | XPS2_IPIXR_RX_ALL |  \
+                                        XPS2_IPIXR_WDT_TOUT)
+
+/* Global Interrupt Enable mask */
+#define XPS2_GIER_GIE_MASK      0x80000000
+
+struct xps2data {
+        int irq;
+        u32 phys_addr;
+        u32 remap_size;
+        spinlock_t lock;
+        u8 rxb;                         /* Rx buffer */
+        void __iomem *base_address;     /* virt. address of control registers */
+        unsigned int dfl;
+        struct serio serio;             /* serio */
+};
+
+/************************************/
+/* XPS PS/2 data transmission calls */
+/************************************/
+
+/*
+ * xps2_recv() will attempt to receive a byte of data from the PS/2 port.
+ */
+static int xps2_recv(struct xps2data *drvdata, u8 *byte)
+{
+        u32 sr;
+        int status = -1;
+
+        /* If there is data available in the PS/2 receiver, read it */
+        sr = in_be32(drvdata->base_address + XPS2_STATUS_OFFSET);
+        if (sr & XPS2_STATUS_RX_FULL) {
+                *byte = in_be32(drvdata->base_address + XPS2_RX_DATA_OFFSET);
+                status = 0;
+        }
+
+        return status;
+}
+
+/*********************/
+/* Interrupt handler */
+/*********************/
+static irqreturn_t xps2_interrupt(int irq, void *dev_id)
+{
+        struct xps2data *drvdata = dev_id;
+        u32 intr_sr;
+        u8 c;
+        int status;
+
+        /* Get the PS/2 interrupts and clear them */
+        intr_sr = in_be32(drvdata->base_address + XPS2_IPISR_OFFSET);
+        out_be32(drvdata->base_address + XPS2_IPISR_OFFSET, intr_sr);
+
+        /* Check which interrupt is active */
+        if (intr_sr & XPS2_IPIXR_RX_OVF)
+                printk(KERN_WARNING "%s: receive overrun error\n",
+                        drvdata->serio.name);
+
+        if (intr_sr & XPS2_IPIXR_RX_ERR)
+                drvdata->dfl |= SERIO_PARITY;
+
+        if (intr_sr & (XPS2_IPIXR_TX_NOACK | XPS2_IPIXR_WDT_TOUT))
+                drvdata->dfl |= SERIO_TIMEOUT;
+
+        if (intr_sr & XPS2_IPIXR_RX_FULL) {
+                status = xps2_recv(drvdata, &drvdata->rxb);
+
+                /* Error, if a byte is not received */
+                if (status) {
+                        printk(KERN_ERR
+                                "%s: wrong rcvd byte count (%d)\n",
+                                drvdata->serio.name, status);
+                } else {
+                        c = drvdata->rxb;
+                        serio_interrupt(&drvdata->serio, c, drvdata->dfl);
+                        drvdata->dfl = 0;
+                }
+        }
+
+        if (intr_sr & XPS2_IPIXR_TX_ACK)
+                drvdata->dfl = 0;
+
+        return IRQ_HANDLED;
+}
+
+/*******************/
+/* serio callbacks */
+/*******************/
+
+/*
+ * sxps2_write() sends a byte out through the PS/2 interface.
+ */
+static int sxps2_write(struct serio *pserio, unsigned char c)
+{
+        struct xps2data *drvdata = pserio->port_data;
+        unsigned long flags;
+        u32 sr;
+        int status = -1;
+
+        spin_lock_irqsave(&drvdata->lock, flags);
+
+        /* If the PS/2 transmitter is empty send a byte of data */
+        sr = in_be32(drvdata->base_address + XPS2_STATUS_OFFSET);
+        if (!(sr & XPS2_STATUS_TX_FULL)) {
+                out_be32(drvdata->base_address + XPS2_TX_DATA_OFFSET, c);
+                status = 0;
+        }
+
+        spin_unlock_irqrestore(&drvdata->lock, flags);
+
+        return status;
+}
+
+/*
+ * sxps2_open() is called when a port is open by the higher layer.
+ */
+static int sxps2_open(struct serio *pserio)
+{
+        struct xps2data *drvdata = pserio->port_data;
+        int retval;
+
+        retval = request_irq(drvdata->irq, &xps2_interrupt, 0,
+                                DRIVER_NAME, drvdata);
+        if (retval) {
+                printk(KERN_ERR
+                        "%s: Couldn't allocate interrupt %d\n",
+                        drvdata->serio.name, drvdata->irq);
+                return retval;
+        }
+
+        /* start reception by enabling the interrupts */
+        out_be32(drvdata->base_address + XPS2_GIER_OFFSET, XPS2_GIER_GIE_MASK);
+        out_be32(drvdata->base_address + XPS2_IPIER_OFFSET, XPS2_IPIXR_RX_ALL);
+        (void)xps2_recv(drvdata, &drvdata->rxb);
+
+        return 0;               /* success */
+}
+
+/*
+ * sxps2_close() frees the interrupt.
+ */
+static void sxps2_close(struct serio *pserio)
+{
+        struct xps2data *drvdata = pserio->port_data;
+
+        /* Disable the PS2 interrupts */
+        out_be32(drvdata->base_address + XPS2_GIER_OFFSET, 0x00);
+        out_be32(drvdata->base_address + XPS2_IPIER_OFFSET, 0x00);
+        free_irq(drvdata->irq, drvdata);
+}
+
+/*********************/
+/* Device setup code */
+/*********************/
+
+static int xps2_setup(struct device *dev, struct resource *regs_res,
+                      struct resource *irq_res)
+{
+        struct xps2data *drvdata;
+        struct serio *serio;
+        unsigned long remap_size;
+        int retval;
+
+        if (!dev)
+                return -EINVAL;
+
+        if (!regs_res || !irq_res) {
+                dev_err(dev, "IO resource(s) not found\n");
+                return -EINVAL;
+        }
+
+        drvdata = kzalloc(sizeof(struct xps2data), GFP_KERNEL);
+        if (!drvdata) {
+                dev_err(dev, "Couldn't allocate device private record\n");
+                return -ENOMEM;
+        }
+
+        dev_set_drvdata(dev, drvdata);
+
+        spin_lock_init(&drvdata->lock);
+        drvdata->irq = irq_res->start;
+
+        remap_size = regs_res->end - regs_res->start + 1;
+        if (!request_mem_region(regs_res->start, remap_size, DRIVER_NAME)) {
+                dev_err(dev, "Couldn't lock memory region at 0x%08X\n",
+                        (unsigned int)regs_res->start);
+                retval = -EBUSY;
+                goto failed1;
+        }
+
+        /* Fill in configuration data and add them to the list */
+        drvdata->phys_addr = regs_res->start;
+        drvdata->remap_size = remap_size;
+        drvdata->base_address = ioremap(regs_res->start, remap_size);
+        if (drvdata->base_address == NULL) {
+                dev_err(dev, "Couldn't ioremap memory at 0x%08X\n",
+                        (unsigned int)regs_res->start);
+                retval = -EFAULT;
+                goto failed2;
+        }
+
+        /* Disable all the interrupts, just in case */
+        out_be32(drvdata->base_address + XPS2_IPIER_OFFSET, 0);
+
+        /* Reset the PS2 device and abort any current transaction, to make sure
+         * we have the PS2 in a good state */
+        out_be32(drvdata->base_address + XPS2_SRST_OFFSET, XPS2_SRST_RESET);
+
+        dev_info(dev, "Xilinx PS2 at 0x%08X mapped to 0x%08X, irq=%d\n",
+                drvdata->phys_addr, (u32)drvdata->base_address, drvdata->irq);
+
+        serio = &drvdata->serio;
+        serio->id.type = SERIO_8042;
+        serio->write = sxps2_write;
+        serio->open = sxps2_open;
+        serio->close = sxps2_close;
+        serio->port_data = drvdata;
+        serio->dev.parent = dev;
+        snprintf(serio->name, sizeof(serio->name),
+                 "Xilinx XPS PS/2 at %08X", drvdata->phys_addr);
+        snprintf(serio->phys, sizeof(serio->phys),
+                 "xilinxps2/serio at %08X", drvdata->phys_addr);
+        serio_register_port(serio);
+
+        return 0;               /* success */
+
+failed2:
+        release_mem_region(regs_res->start, remap_size);
+failed1:
+        kfree(drvdata);
+        dev_set_drvdata(dev, NULL);
+
+        return retval;
+}
+
+/***************************/
+/* OF Platform Bus Support */
+/***************************/
+
+static int __devinit xps2_of_probe(struct of_device *ofdev, const struct
+                                   of_device_id * match)
+{
+        struct resource r_irq; /* Interrupt resources */
+        struct resource r_mem; /* IO mem resources */
+        int rc = 0;
+
+        printk(KERN_INFO "Device Tree Probing \'%s\'\n",
+                        ofdev->node->name);
+
+        /* Get iospace for the device */
+        rc = of_address_to_resource(ofdev->node, 0, &r_mem);
+        if (rc) {
+                dev_err(&ofdev->dev, "invalid address\n");
+                return rc;
+        }
+
+        /* Get IRQ for the device */
+        rc = of_irq_to_resource(ofdev->node, 0, &r_irq);
+        if (rc == NO_IRQ) {
+                dev_err(&ofdev->dev, "no IRQ found\n");
+                return rc;
+        }
+
+        return xps2_setup(&ofdev->dev, &r_mem, &r_irq);
+}
+
+static int __devexit xps2_of_remove(struct of_device *of_dev)
+{
+        struct device *dev = &of_dev->dev;
+        struct xps2data *drvdata;
+
+        if (!dev)
+                return -EINVAL;
+
+        drvdata = dev_get_drvdata(dev);
+
+        serio_unregister_port(&drvdata->serio);
+        iounmap(drvdata->base_address);
+        release_mem_region(drvdata->phys_addr, drvdata->remap_size);
+        kfree(drvdata);
+
+        dev_set_drvdata(dev, NULL);
+
+        return 0;               /* success */
+}
+
+/* Match table for of_platform binding */
+static struct of_device_id xps2_of_match[] __devinitdata = {
+        { .compatible = "xlnx,xps-ps2-1.00.a", },
+        { /* end of list */ },
+};
+MODULE_DEVICE_TABLE(of, xps2_of_match);
+
+static struct of_platform_driver xps2_of_driver = {
+        .name           = DRIVER_NAME,
+        .match_table    = xps2_of_match,
+        .probe          = xps2_of_probe,
+        .remove         = __devexit_p(xps2_of_remove),
+};
+
+static int __init xps2_init(void)
+{
+        return of_register_platform_driver(&xps2_of_driver);
+}
+
+static void __exit xps2_cleanup(void)
+{
+        of_unregister_platform_driver(&xps2_of_driver);
+}
+
+module_init(xps2_init);
+module_exit(xps2_cleanup);
+
+MODULE_AUTHOR("Xilinx, Inc.");
+MODULE_DESCRIPTION("Xilinx XPS PS/2 driver");
+MODULE_LICENSE("GPL");
+
diff --git a/drivers/input/tablet/acecad.c b/drivers/input/tablet/acecad.c
index b973d0ef6d16..570e0e83ac46 100644
--- a/drivers/input/tablet/acecad.c
+++ b/drivers/input/tablet/acecad.c
@@ -73,10 +73,10 @@ static void usb_acecad_irq(struct urb *urb)
                 case -ENOENT:
                 case -ESHUTDOWN:
                         /* this urb is terminated, clean up */
-                        dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
+                        dbg("%s - urb shutting down with status: %d", __func__, urb->status);
                         return;
                 default:
-                        dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
+                        dbg("%s - nonzero urb status received: %d", __func__, urb->status);
                         goto resubmit;
         }
 
diff --git a/drivers/input/tablet/aiptek.c b/drivers/input/tablet/aiptek.c
index 55c1134d6137..8f037a1d44a6 100644
--- a/drivers/input/tablet/aiptek.c
+++ b/drivers/input/tablet/aiptek.c
@@ -449,12 +449,12 @@ static void aiptek_irq(struct urb *urb)
         case -ESHUTDOWN:
                 /* This urb is terminated, clean up */
                 dbg("%s - urb shutting down with status: %d",
-                    __FUNCTION__, urb->status);
+                    __func__, urb->status);
                 return;
 
         default:
                 dbg("%s - nonzero urb status received: %d",
-                    __FUNCTION__, urb->status);
+                    __func__, urb->status);
                 goto exit;
         }
 
@@ -813,7 +813,7 @@ exit:
         retval = usb_submit_urb(urb, GFP_ATOMIC);
         if (retval != 0) {
                 err("%s - usb_submit_urb failed with result %d",
-                    __FUNCTION__, retval);
+                    __func__, retval);
         }
 }
 
diff --git a/drivers/input/tablet/gtco.c b/drivers/input/tablet/gtco.c
index 1e748e46d12e..b9b7a98bc5a5 100644
--- a/drivers/input/tablet/gtco.c
+++ b/drivers/input/tablet/gtco.c
@@ -863,7 +863,7 @@ static int gtco_probe(struct usb_interface *usbinterface,
         gtco->urbinfo = usb_alloc_urb(0, GFP_KERNEL);
         if (!gtco->urbinfo) {
                 err("Failed to allocate URB");
-                return -ENOMEM;
+                error = -ENOMEM;
                 goto err_free_buf;
         }
 
diff --git a/drivers/input/tablet/kbtab.c b/drivers/input/tablet/kbtab.c
index f23f5a97fb38..d89112fa6e6b 100644
--- a/drivers/input/tablet/kbtab.c
+++ b/drivers/input/tablet/kbtab.c
@@ -56,10 +56,10 @@ static void kbtab_irq(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
+                dbg("%s - urb shutting down with status: %d", __func__, urb->status);
                 return;
         default:
-                dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
+                dbg("%s - nonzero urb status received: %d", __func__, urb->status);
                 goto exit;
         }
 
@@ -88,7 +88,7 @@ static void kbtab_irq(struct urb *urb)
         retval = usb_submit_urb (urb, GFP_ATOMIC);
         if (retval)
                 err ("%s - usb_submit_urb failed with result %d",
-                     __FUNCTION__, retval);
+                     __func__, retval);
 }
 
 static struct usb_device_id kbtab_ids[] = {
diff --git a/drivers/input/tablet/wacom.h b/drivers/input/tablet/wacom.h
index 706619d06f71..ca62ec639f8f 100644
--- a/drivers/input/tablet/wacom.h
+++ b/drivers/input/tablet/wacom.h
@@ -105,7 +105,7 @@ struct wacom {
         struct urb *irq;
         struct wacom_wac * wacom_wac;
         struct mutex lock;
-        int open:1;
+        unsigned int open:1;
         char phys[32];
 };
 
diff --git a/drivers/input/tablet/wacom_sys.c b/drivers/input/tablet/wacom_sys.c
index 71cc0c140790..5fbc463baf5a 100644
--- a/drivers/input/tablet/wacom_sys.c
+++ b/drivers/input/tablet/wacom_sys.c
@@ -56,10 +56,10 @@ static void wacom_sys_irq(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
+                dbg("%s - urb shutting down with status: %d", __func__, urb->status);
                 return;
         default:
-                dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
+                dbg("%s - nonzero urb status received: %d", __func__, urb->status);
                 goto exit;
         }
 
@@ -74,7 +74,7 @@ static void wacom_sys_irq(struct urb *urb)
         retval = usb_submit_urb (urb, GFP_ATOMIC);
         if (retval)
                 err ("%s - usb_submit_urb failed with result %d",
-                     __FUNCTION__, retval);
+                     __func__, retval);
 }
 
 void wacom_report_key(void *wcombo, unsigned int key_type, int key_data)
diff --git a/drivers/input/tablet/wacom_wac.c b/drivers/input/tablet/wacom_wac.c
index 192513e1f04c..bf3d9a8b2c1b 100644
--- a/drivers/input/tablet/wacom_wac.c
+++ b/drivers/input/tablet/wacom_wac.c
@@ -56,7 +56,7 @@ static int wacom_penpartner_irq(struct wacom_wac *wacom, void *wcombo)
 static int wacom_pl_irq(struct wacom_wac *wacom, void *wcombo)
 {
         unsigned char *data = wacom->data;
-        int prox, id, pressure;
+        int prox, pressure;
 
         if (data[0] != 2) {
                 dbg("wacom_pl_irq: received unknown report #%d", data[0]);
@@ -65,7 +65,7 @@ static int wacom_pl_irq(struct wacom_wac *wacom, void *wcombo)
 
         prox = data[1] & 0x40;
 
-        id = ERASER_DEVICE_ID;
+        wacom->id[0] = ERASER_DEVICE_ID;
         if (prox) {
 
                 pressure = (signed char)((data[7] << 1) | ((data[4] >> 2) & 1));
@@ -99,10 +99,10 @@ static int wacom_pl_irq(struct wacom_wac *wacom, void *wcombo)
                 if (wacom->tool[1] != BTN_TOOL_RUBBER) {
                         /* Unknown tool selected default to pen tool */
                         wacom->tool[1] = BTN_TOOL_PEN;
-                        id = STYLUS_DEVICE_ID;
+                        wacom->id[0] = STYLUS_DEVICE_ID;
                 }
                 wacom_report_key(wcombo, wacom->tool[1], prox); /* report in proximity for tool */
-                wacom_report_abs(wcombo, ABS_MISC, id); /* report tool id */
+                wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]); /* report tool id */
                 wacom_report_abs(wcombo, ABS_X, data[3] | (data[2] << 7) | ((data[1] & 0x03) << 14));
                 wacom_report_abs(wcombo, ABS_Y, data[6] | (data[5] << 7) | ((data[4] & 0x03) << 14));
                 wacom_report_abs(wcombo, ABS_PRESSURE, pressure);
@@ -127,7 +127,6 @@ static int wacom_pl_irq(struct wacom_wac *wacom, void *wcombo)
 static int wacom_ptu_irq(struct wacom_wac *wacom, void *wcombo)
 {
         unsigned char *data = wacom->data;
-        int id;
 
         if (data[0] != 2) {
                 printk(KERN_INFO "wacom_ptu_irq: received unknown report #%d\n", data[0]);
@@ -137,13 +136,13 @@ static int wacom_ptu_irq(struct wacom_wac *wacom, void *wcombo)
         if (data[1] & 0x04) {
                 wacom_report_key(wcombo, BTN_TOOL_RUBBER, data[1] & 0x20);
                 wacom_report_key(wcombo, BTN_TOUCH, data[1] & 0x08);
-                id = ERASER_DEVICE_ID;
+                wacom->id[0] = ERASER_DEVICE_ID;
         } else {
                 wacom_report_key(wcombo, BTN_TOOL_PEN, data[1] & 0x20);
                 wacom_report_key(wcombo, BTN_TOUCH, data[1] & 0x01);
-                id = STYLUS_DEVICE_ID;
+                wacom->id[0] = STYLUS_DEVICE_ID;
         }
-        wacom_report_abs(wcombo, ABS_MISC, id); /* report tool id */
+        wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]); /* report tool id */
         wacom_report_abs(wcombo, ABS_X, wacom_le16_to_cpu(&data[2]));
         wacom_report_abs(wcombo, ABS_Y, wacom_le16_to_cpu(&data[4]));
         wacom_report_abs(wcombo, ABS_PRESSURE, wacom_le16_to_cpu(&data[6]));
@@ -155,27 +154,26 @@ static int wacom_ptu_irq(struct wacom_wac *wacom, void *wcombo)
 static int wacom_graphire_irq(struct wacom_wac *wacom, void *wcombo)
 {
         unsigned char *data = wacom->data;
-        int x, y, id, rw;
+        int x, y, rw;
 
         if (data[0] != 2) {
                 dbg("wacom_graphire_irq: received unknown report #%d", data[0]);
                 return 0;
         }
 
-        id = STYLUS_DEVICE_ID;
-        if ((data[1] & 0x80) && ((data[1] & 0x07) || data[2] || data[3] || data[4]
-                        || data[5] || data[6] || (data[7] & 0x07))) {
+        if (data[1] & 0x80) {
                 /* in prox and not a pad data */
 
                 switch ((data[1] >> 5) & 3) {
 
                         case 0: /* Pen */
                                 wacom->tool[0] = BTN_TOOL_PEN;
+                                wacom->id[0] = STYLUS_DEVICE_ID;
                                 break;
 
                         case 1: /* Rubber */
                                 wacom->tool[0] = BTN_TOOL_RUBBER;
-                                id = ERASER_DEVICE_ID;
+                                wacom->id[0] = ERASER_DEVICE_ID;
                                 break;
 
                         case 2: /* Mouse with wheel */
@@ -190,7 +188,7 @@ static int wacom_graphire_irq(struct wacom_wac *wacom, void *wcombo)
 
                         case 3: /* Mouse without wheel */
                                 wacom->tool[0] = BTN_TOOL_MOUSE;
-                                id = CURSOR_DEVICE_ID;
+                                wacom->id[0] = CURSOR_DEVICE_ID;
                                 wacom_report_key(wcombo, BTN_LEFT, data[1] & 0x01);
                                 wacom_report_key(wcombo, BTN_RIGHT, data[1] & 0x02);
                                 if (wacom->features->type == WACOM_G4 ||
@@ -210,9 +208,9 @@ static int wacom_graphire_irq(struct wacom_wac *wacom, void *wcombo)
                         wacom_report_key(wcombo, BTN_STYLUS, data[1] & 0x02);
                         wacom_report_key(wcombo, BTN_STYLUS2, data[1] & 0x04);
                 }
-                wacom_report_abs(wcombo, ABS_MISC, id); /* report tool id */
+                wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]); /* report tool id */
                 wacom_report_key(wcombo, wacom->tool[0], 1);
-        } else if (!(data[1] & 0x90)) {
+        } else if (wacom->id[0]) {
                 wacom_report_abs(wcombo, ABS_X, 0);
                 wacom_report_abs(wcombo, ABS_Y, 0);
                 if (wacom->tool[0] == BTN_TOOL_MOUSE) {
@@ -225,6 +223,7 @@ static int wacom_graphire_irq(struct wacom_wac *wacom, void *wcombo)
                         wacom_report_key(wcombo, BTN_STYLUS, 0);
                         wacom_report_key(wcombo, BTN_STYLUS2, 0);
                 }
+                wacom->id[0] = 0;
                 wacom_report_abs(wcombo, ABS_MISC, 0); /* reset tool id */
                 wacom_report_key(wcombo, wacom->tool[0], 0);
         }
@@ -234,13 +233,13 @@ static int wacom_graphire_irq(struct wacom_wac *wacom, void *wcombo)
             case WACOM_G4:
                 if (data[7] & 0xf8) {
                         wacom_input_sync(wcombo); /* sync last event */
-                        wacom->id[1] = 1;
+                        wacom->id[1] = PAD_DEVICE_ID;
                         wacom_report_key(wcombo, BTN_0, (data[7] & 0x40));
                         wacom_report_key(wcombo, BTN_4, (data[7] & 0x80));
                         rw = ((data[7] & 0x18) >> 3) - ((data[7] & 0x20) >> 3);
                         wacom_report_rel(wcombo, REL_WHEEL, rw);
                         wacom_report_key(wcombo, BTN_TOOL_FINGER, 0xf0);
-                        wacom_report_abs(wcombo, ABS_MISC, PAD_DEVICE_ID);
+                        wacom_report_abs(wcombo, ABS_MISC, wacom->id[1]);
                         wacom_input_event(wcombo, EV_MSC, MSC_SERIAL, 0xf0);
                 } else if (wacom->id[1]) {
                         wacom_input_sync(wcombo); /* sync last event */
@@ -255,14 +254,14 @@ static int wacom_graphire_irq(struct wacom_wac *wacom, void *wcombo)
             case WACOM_MO:
                 if ((data[7] & 0xf8) || (data[8] & 0xff)) {
                         wacom_input_sync(wcombo); /* sync last event */
-                        wacom->id[1] = 1;
+                        wacom->id[1] = PAD_DEVICE_ID;
                         wacom_report_key(wcombo, BTN_0, (data[7] & 0x08));
                         wacom_report_key(wcombo, BTN_1, (data[7] & 0x20));
                         wacom_report_key(wcombo, BTN_4, (data[7] & 0x10));
                         wacom_report_key(wcombo, BTN_5, (data[7] & 0x40));
                         wacom_report_abs(wcombo, ABS_WHEEL, (data[8] & 0x7f));
                         wacom_report_key(wcombo, BTN_TOOL_FINGER, 0xf0);
-                        wacom_report_abs(wcombo, ABS_MISC, PAD_DEVICE_ID);
+                        wacom_report_abs(wcombo, ABS_MISC, wacom->id[1]);
                         wacom_input_event(wcombo, EV_MSC, MSC_SERIAL, 0xf0);
                 } else if (wacom->id[1]) {
                         wacom_input_sync(wcombo); /* sync last event */
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index 565ec711c2ee..e57366521572 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -103,6 +103,18 @@ config TOUCHSCREEN_MTOUCH
           To compile this driver as a module, choose M here: the
           module will be called mtouch.
 
+config TOUCHSCREEN_INEXIO
+        tristate "iNexio serial touchscreens"
+        select SERIO
+        help
+          Say Y here if you have an iNexio serial touchscreen connected to
+          your system.
+
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called inexio.
+
 config TOUCHSCREEN_MK712
         tristate "ICS MicroClock MK712 touchscreen"
         help
@@ -134,6 +146,18 @@ config TOUCHSCREEN_HP7XX
           To compile this driver as a module, choose M here: the
           module will be called jornada720_ts.
 
+config TOUCHSCREEN_HTCPEN
+        tristate "HTC Shift X9500 touchscreen"
+        depends on ISA
+        help
+          Say Y here if you have an HTC Shift UMPC also known as HTC X9500
+          Clio / Shangrila and want to support the built-in touchscreen.
+
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called htcpen.
+
 config TOUCHSCREEN_PENMOUNT
         tristate "Penmount serial touchscreen"
         select SERIO
@@ -146,6 +170,17 @@ config TOUCHSCREEN_PENMOUNT
           To compile this driver as a module, choose M here: the
           module will be called penmount.
 
+config TOUCHSCREEN_MIGOR
+        tristate "Renesas MIGO-R touchscreen"
+        depends on SH_MIGOR && I2C
+        help
+          Say Y here to enable MIGO-R touchscreen support.
+
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called migor_ts.
+
 config TOUCHSCREEN_TOUCHRIGHT
         tristate "Touchright serial touchscreen"
         select SERIO
@@ -316,4 +351,15 @@ config TOUCHSCREEN_USB_GOTOP
         bool "GoTop Super_Q2/GogoPen/PenPower tablet device support" if EMBEDDED
         depends on TOUCHSCREEN_USB_COMPOSITE
 
+config TOUCHSCREEN_TOUCHIT213
+        tristate "Sahara TouchIT-213 touchscreen"
+        select SERIO
+        help
+          Say Y here if you have a Sahara TouchIT-213 Tablet PC.
+
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called touchit213.
+
 endif
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index 3c096d75651d..39a804cd80f1 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -12,12 +12,16 @@ obj-$(CONFIG_TOUCHSCREEN_CORGI)		+= corgi_ts.o
 obj-$(CONFIG_TOUCHSCREEN_GUNZE)         += gunze.o
 obj-$(CONFIG_TOUCHSCREEN_ELO)           += elo.o
 obj-$(CONFIG_TOUCHSCREEN_FUJITSU)       += fujitsu_ts.o
+obj-$(CONFIG_TOUCHSCREEN_INEXIO)        += inexio.o
+obj-$(CONFIG_TOUCHSCREEN_MIGOR)         += migor_ts.o
 obj-$(CONFIG_TOUCHSCREEN_MTOUCH)        += mtouch.o
 obj-$(CONFIG_TOUCHSCREEN_MK712)         += mk712.o
 obj-$(CONFIG_TOUCHSCREEN_HP600)         += hp680_ts_input.o
 obj-$(CONFIG_TOUCHSCREEN_HP7XX)         += jornada720_ts.o
+obj-$(CONFIG_TOUCHSCREEN_HTCPEN)        += htcpen.o
 obj-$(CONFIG_TOUCHSCREEN_USB_COMPOSITE) += usbtouchscreen.o
 obj-$(CONFIG_TOUCHSCREEN_PENMOUNT)      += penmount.o
+obj-$(CONFIG_TOUCHSCREEN_TOUCHIT213)    += touchit213.o
 obj-$(CONFIG_TOUCHSCREEN_TOUCHRIGHT)    += touchright.o
 obj-$(CONFIG_TOUCHSCREEN_TOUCHWIN)      += touchwin.o
 obj-$(CONFIG_TOUCHSCREEN_UCB1400)       += ucb1400_ts.o
diff --git a/drivers/input/touchscreen/gunze.c b/drivers/input/touchscreen/gunze.c
index a48a15868c4a..a54f90e02ab6 100644
--- a/drivers/input/touchscreen/gunze.c
+++ b/drivers/input/touchscreen/gunze.c
@@ -1,6 +1,4 @@
 /*
- * $Id: gunze.c,v 1.12 2001/09/25 10:12:07 vojtech Exp $
- *
  *  Copyright (c) 2000-2001 Vojtech Pavlik
  */
 
diff --git a/drivers/input/touchscreen/h3600_ts_input.c b/drivers/input/touchscreen/h3600_ts_input.c
index 28ae15ed12c5..4f86081dc7fc 100644
--- a/drivers/input/touchscreen/h3600_ts_input.c
+++ b/drivers/input/touchscreen/h3600_ts_input.c
@@ -1,6 +1,4 @@
 /*
- * $Id: h3600_ts_input.c,v 1.4 2002/01/23 06:39:37 jsimmons Exp $
- *
  *  Copyright (c) 2001 "Crazy" James Simmons jsimmons@transvirtual.com
  *
  *  Sponsored by Transvirtual Technology.
diff --git a/drivers/input/touchscreen/htcpen.c b/drivers/input/touchscreen/htcpen.c
new file mode 100644
index 000000000000..62811de6f18f
--- /dev/null
+++ b/drivers/input/touchscreen/htcpen.c
@@ -0,0 +1,255 @@
+/*
+ * HTC Shift touchscreen driver
+ *
+ * Copyright (C) 2008 Pau Oliva Fora <pof@eslack.org>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published
+ * by the Free Software Foundation.
+ */
+
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/init.h>
+#include <linux/irq.h>
+#include <linux/isa.h>
+#include <linux/ioport.h>
+#include <linux/dmi.h>
+
+MODULE_AUTHOR("Pau Oliva Fora <pau@eslack.org>");
+MODULE_DESCRIPTION("HTC Shift touchscreen driver");
+MODULE_LICENSE("GPL");
+
+#define HTCPEN_PORT_IRQ_CLEAR   0x068
+#define HTCPEN_PORT_INIT        0x06c
+#define HTCPEN_PORT_INDEX       0x0250
+#define HTCPEN_PORT_DATA        0x0251
+#define HTCPEN_IRQ              3
+
+#define DEVICE_ENABLE           0xa2
+#define DEVICE_DISABLE          0xa3
+
+#define X_INDEX                 3
+#define Y_INDEX                 5
+#define TOUCH_INDEX             0xb
+#define LSB_XY_INDEX            0xc
+#define X_AXIS_MAX              2040
+#define Y_AXIS_MAX              2040
+
+static int invert_x;
+module_param(invert_x, bool, 0644);
+MODULE_PARM_DESC(invert_x, "If set, X axis is inverted");
+static int invert_y;
+module_param(invert_y, bool, 0644);
+MODULE_PARM_DESC(invert_y, "If set, Y axis is inverted");
+
+static struct pnp_device_id pnp_ids[] = {
+        { .id = "PNP0cc0" },
+        { .id = "" }
+};
+MODULE_DEVICE_TABLE(pnp, pnp_ids);
+
+static irqreturn_t htcpen_interrupt(int irq, void *handle)
+{
+        struct input_dev *htcpen_dev = handle;
+        unsigned short x, y, xy;
+
+        /* 0 = press; 1 = release */
+        outb_p(TOUCH_INDEX, HTCPEN_PORT_INDEX);
+
+        if (inb_p(HTCPEN_PORT_DATA)) {
+                input_report_key(htcpen_dev, BTN_TOUCH, 0);
+        } else {
+                outb_p(X_INDEX, HTCPEN_PORT_INDEX);
+                x = inb_p(HTCPEN_PORT_DATA);
+
+                outb_p(Y_INDEX, HTCPEN_PORT_INDEX);
+                y = inb_p(HTCPEN_PORT_DATA);
+
+                outb_p(LSB_XY_INDEX, HTCPEN_PORT_INDEX);
+                xy = inb_p(HTCPEN_PORT_DATA);
+
+                /* get high resolution value of X and Y using LSB */
+                x = X_AXIS_MAX - ((x * 8) + ((xy >> 4) & 0xf));
+                y = (y * 8) + (xy & 0xf);
+                if (invert_x)
+                        x = X_AXIS_MAX - x;
+                if (invert_y)
+                        y = Y_AXIS_MAX - y;
+
+                if (x != X_AXIS_MAX && x != 0) {
+                        input_report_key(htcpen_dev, BTN_TOUCH, 1);
+                        input_report_abs(htcpen_dev, ABS_X, x);
+                        input_report_abs(htcpen_dev, ABS_Y, y);
+                }
+        }
+
+        input_sync(htcpen_dev);
+
+        inb_p(HTCPEN_PORT_IRQ_CLEAR);
+
+        return IRQ_HANDLED;
+}
+
+static int htcpen_open(struct input_dev *dev)
+{
+        outb_p(DEVICE_ENABLE, HTCPEN_PORT_INIT);
+
+        return 0;
+}
+
+static void htcpen_close(struct input_dev *dev)
+{
+        outb_p(DEVICE_DISABLE, HTCPEN_PORT_INIT);
+        synchronize_irq(HTCPEN_IRQ);
+}
+
+static int __devinit htcpen_isa_probe(struct device *dev, unsigned int id)
+{
+        struct input_dev *htcpen_dev;
+        int err = -EBUSY;
+
+        if (!request_region(HTCPEN_PORT_IRQ_CLEAR, 1, "htcpen")) {
+                printk(KERN_ERR "htcpen: unable to get IO region 0x%x\n",
+                        HTCPEN_PORT_IRQ_CLEAR);
+                goto request_region1_failed;
+        }
+
+        if (!request_region(HTCPEN_PORT_INIT, 1, "htcpen")) {
+                printk(KERN_ERR "htcpen: unable to get IO region 0x%x\n",
+                        HTCPEN_PORT_INIT);
+                goto request_region2_failed;
+        }
+
+        if (!request_region(HTCPEN_PORT_INDEX, 2, "htcpen")) {
+                printk(KERN_ERR "htcpen: unable to get IO region 0x%x\n",
+                        HTCPEN_PORT_INDEX);
+                goto request_region3_failed;
+        }
+
+        htcpen_dev = input_allocate_device();
+        if (!htcpen_dev) {
+                printk(KERN_ERR "htcpen: can't allocate device\n");
+                err = -ENOMEM;
+                goto input_alloc_failed;
+        }
+
+        htcpen_dev->name = "HTC Shift EC TouchScreen";
+        htcpen_dev->id.bustype = BUS_ISA;
+
+        htcpen_dev->evbit[0] = BIT_MASK(EV_ABS) | BIT_MASK(EV_KEY);
+        htcpen_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
+        input_set_abs_params(htcpen_dev, ABS_X, 0, X_AXIS_MAX, 0, 0);
+        input_set_abs_params(htcpen_dev, ABS_Y, 0, Y_AXIS_MAX, 0, 0);
+
+        htcpen_dev->open = htcpen_open;
+        htcpen_dev->close = htcpen_close;
+
+        err = request_irq(HTCPEN_IRQ, htcpen_interrupt, 0, "htcpen",
+                        htcpen_dev);
+        if (err) {
+                printk(KERN_ERR "htcpen: irq busy\n");
+                goto request_irq_failed;
+        }
+
+        inb_p(HTCPEN_PORT_IRQ_CLEAR);
+
+        err = input_register_device(htcpen_dev);
+        if (err)
+                goto input_register_failed;
+
+        dev_set_drvdata(dev, htcpen_dev);
+
+        return 0;
+
+ input_register_failed:
+        free_irq(HTCPEN_IRQ, htcpen_dev);
+ request_irq_failed:
+        input_free_device(htcpen_dev);
+ input_alloc_failed:
+        release_region(HTCPEN_PORT_INDEX, 2);
+ request_region3_failed:
+        release_region(HTCPEN_PORT_INIT, 1);
+ request_region2_failed:
+        release_region(HTCPEN_PORT_IRQ_CLEAR, 1);
+ request_region1_failed:
+        return err;
+}
+
+static int __devexit htcpen_isa_remove(struct device *dev, unsigned int id)
+{
+        struct input_dev *htcpen_dev = dev_get_drvdata(dev);
+
+        input_unregister_device(htcpen_dev);
+
+        free_irq(HTCPEN_IRQ, htcpen_dev);
+
+        release_region(HTCPEN_PORT_INDEX, 2);
+        release_region(HTCPEN_PORT_INIT, 1);
+        release_region(HTCPEN_PORT_IRQ_CLEAR, 1);
+
+        dev_set_drvdata(dev, NULL);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int htcpen_isa_suspend(struct device *dev, unsigned int n,
+                                pm_message_t state)
+{
+        outb_p(DEVICE_DISABLE, HTCPEN_PORT_INIT);
+
+        return 0;
+}
+
+static int htcpen_isa_resume(struct device *dev, unsigned int n)
+{
+        outb_p(DEVICE_ENABLE, HTCPEN_PORT_INIT);
+
+        return 0;
+}
+#endif
+
+static struct isa_driver htcpen_isa_driver = {
+        .probe          = htcpen_isa_probe,
+        .remove         = __devexit_p(htcpen_isa_remove),
+#ifdef CONFIG_PM
+        .suspend        = htcpen_isa_suspend,
+        .resume         = htcpen_isa_resume,
+#endif
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = "htcpen",
+        }
+};
+
+static struct dmi_system_id __initdata htcshift_dmi_table[] = {
+        {
+                .ident = "Shift",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "High Tech Computer Corp"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Shift"),
+                },
+        },
+        { }
+};
+
+static int __init htcpen_isa_init(void)
+{
+        if (!dmi_check_system(htcshift_dmi_table))
+                return -ENODEV;
+
+        return isa_register_driver(&htcpen_isa_driver, 1);
+}
+
+static void __exit htcpen_isa_exit(void)
+{
+        isa_unregister_driver(&htcpen_isa_driver);
+}
+
+module_init(htcpen_isa_init);
+module_exit(htcpen_isa_exit);
diff --git a/drivers/input/touchscreen/inexio.c b/drivers/input/touchscreen/inexio.c
new file mode 100644
index 000000000000..192ade0a0fb9
--- /dev/null
+++ b/drivers/input/touchscreen/inexio.c
@@ -0,0 +1,207 @@
+/*
+ * iNexio serial touchscreen driver
+ *
+ * Copyright (c) 2008 Richard Lemon
+ * Based on the mtouch driver (c) Vojtech Pavlik and Dan Streetman
+ *
+ */
+
+/*
+ * 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.
+ */
+
+/*
+ * 2008/06/19 Richard Lemon <richard@codelemon.com>
+ *   Copied mtouch.c and edited for iNexio protocol
+ */
+
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/serio.h>
+#include <linux/init.h>
+
+#define DRIVER_DESC     "iNexio serial touchscreen driver"
+
+MODULE_AUTHOR("Richard Lemon <richard@codelemon.com>");
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
+
+/*
+ * Definitions & global arrays.
+ */
+
+#define INEXIO_FORMAT_TOUCH_BIT 0x01
+#define INEXIO_FORMAT_LENGTH 5
+#define INEXIO_RESPONSE_BEGIN_BYTE 0x80
+
+/* todo: check specs for max length of all responses */
+#define INEXIO_MAX_LENGTH 16
+
+#define INEXIO_MIN_XC 0
+#define INEXIO_MAX_XC 0x3fff
+#define INEXIO_MIN_YC 0
+#define INEXIO_MAX_YC 0x3fff
+
+#define INEXIO_GET_XC(data) (((data[1])<<7) | data[2])
+#define INEXIO_GET_YC(data) (((data[3])<<7) | data[4])
+#define INEXIO_GET_TOUCHED(data) (INEXIO_FORMAT_TOUCH_BIT & data[0])
+
+/*
+ * Per-touchscreen data.
+ */
+
+struct inexio {
+        struct input_dev *dev;
+        struct serio *serio;
+        int idx;
+        unsigned char data[INEXIO_MAX_LENGTH];
+        char phys[32];
+};
+
+static void inexio_process_data(struct inexio *pinexio)
+{
+        struct input_dev *dev = pinexio->dev;
+
+        if (INEXIO_FORMAT_LENGTH == ++pinexio->idx) {
+                input_report_abs(dev, ABS_X, INEXIO_GET_XC(pinexio->data));
+                input_report_abs(dev, ABS_Y, INEXIO_GET_YC(pinexio->data));
+                input_report_key(dev, BTN_TOUCH, INEXIO_GET_TOUCHED(pinexio->data));
+                input_sync(dev);
+
+                pinexio->idx = 0;
+        }
+}
+
+static irqreturn_t inexio_interrupt(struct serio *serio,
+                unsigned char data, unsigned int flags)
+{
+        struct inexio* pinexio = serio_get_drvdata(serio);
+
+        pinexio->data[pinexio->idx] = data;
+
+        if (INEXIO_RESPONSE_BEGIN_BYTE&pinexio->data[0])
+                inexio_process_data(pinexio);
+        else
+                printk(KERN_DEBUG "inexio.c: unknown/unsynchronized data from device, byte %x\n",pinexio->data[0]);
+
+        return IRQ_HANDLED;
+}
+
+/*
+ * inexio_disconnect() is the opposite of inexio_connect()
+ */
+
+static void inexio_disconnect(struct serio *serio)
+{
+        struct inexio* pinexio = serio_get_drvdata(serio);
+
+        input_get_device(pinexio->dev);
+        input_unregister_device(pinexio->dev);
+        serio_close(serio);
+        serio_set_drvdata(serio, NULL);
+        input_put_device(pinexio->dev);
+        kfree(pinexio);
+}
+
+/*
+ * inexio_connect() is the routine that is called when someone adds a
+ * new serio device that supports iNexio protocol and registers it as
+ * an input device. This is usually accomplished using inputattach.
+ */
+
+static int inexio_connect(struct serio *serio, struct serio_driver *drv)
+{
+        struct inexio *pinexio;
+        struct input_dev *input_dev;
+        int err;
+
+        pinexio = kzalloc(sizeof(struct inexio), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!pinexio || !input_dev) {
+                err = -ENOMEM;
+                goto fail1;
+        }
+
+        pinexio->serio = serio;
+        pinexio->dev = input_dev;
+        snprintf(pinexio->phys, sizeof(pinexio->phys), "%s/input0", serio->phys);
+
+        input_dev->name = "iNexio Serial TouchScreen";
+        input_dev->phys = pinexio->phys;
+        input_dev->id.bustype = BUS_RS232;
+        input_dev->id.vendor = SERIO_INEXIO;
+        input_dev->id.product = 0;
+        input_dev->id.version = 0x0001;
+        input_dev->dev.parent = &serio->dev;
+        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+        input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
+        input_set_abs_params(pinexio->dev, ABS_X, INEXIO_MIN_XC, INEXIO_MAX_XC, 0, 0);
+        input_set_abs_params(pinexio->dev, ABS_Y, INEXIO_MIN_YC, INEXIO_MAX_YC, 0, 0);
+
+        serio_set_drvdata(serio, pinexio);
+
+        err = serio_open(serio, drv);
+        if (err)
+                goto fail2;
+
+        err = input_register_device(pinexio->dev);
+        if (err)
+                goto fail3;
+
+        return 0;
+
+ fail3: serio_close(serio);
+ fail2: serio_set_drvdata(serio, NULL);
+ fail1: input_free_device(input_dev);
+        kfree(pinexio);
+        return err;
+}
+
+/*
+ * The serio driver structure.
+ */
+
+static struct serio_device_id inexio_serio_ids[] = {
+        {
+                .type   = SERIO_RS232,
+                .proto  = SERIO_INEXIO,
+                .id     = SERIO_ANY,
+                .extra  = SERIO_ANY,
+        },
+        { 0 }
+};
+
+MODULE_DEVICE_TABLE(serio, inexio_serio_ids);
+
+static struct serio_driver inexio_drv = {
+        .driver         = {
+                .name   = "inexio",
+        },
+        .description    = DRIVER_DESC,
+        .id_table       = inexio_serio_ids,
+        .interrupt      = inexio_interrupt,
+        .connect        = inexio_connect,
+        .disconnect     = inexio_disconnect,
+};
+
+/*
+ * The functions for inserting/removing us as a module.
+ */
+
+static int __init inexio_init(void)
+{
+        return serio_register_driver(&inexio_drv);
+}
+
+static void __exit inexio_exit(void)
+{
+        serio_unregister_driver(&inexio_drv);
+}
+
+module_init(inexio_init);
+module_exit(inexio_exit);
diff --git a/drivers/input/touchscreen/migor_ts.c b/drivers/input/touchscreen/migor_ts.c
new file mode 100644
index 000000000000..c1cd99d58981
--- /dev/null
+++ b/drivers/input/touchscreen/migor_ts.c
@@ -0,0 +1,250 @@
+/*
+ * Touch Screen driver for Renesas MIGO-R Platform
+ *
+ * Copyright (c) 2008 Magnus Damm
+ * Copyright (c) 2007 Ujjwal Pande <ujjwal@kenati.com>,
+ *  Kenati Technologies Pvt Ltd.
+ *
+ * This file 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 file 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 library; 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/kernel.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <asm/io.h>
+#include <linux/i2c.h>
+#include <linux/timer.h>
+
+#define EVENT_PENDOWN 1
+#define EVENT_REPEAT  2
+#define EVENT_PENUP   3
+
+struct migor_ts_priv {
+        struct i2c_client *client;
+        struct input_dev *input;
+        struct delayed_work work;
+        int irq;
+};
+
+static const u_int8_t migor_ts_ena_seq[17] = { 0x33, 0x22, 0x11,
+                                               0x01, 0x06, 0x07, };
+static const u_int8_t migor_ts_dis_seq[17] = { };
+
+static void migor_ts_poscheck(struct work_struct *work)
+{
+        struct migor_ts_priv *priv = container_of(work,
+                                                  struct migor_ts_priv,
+                                                  work.work);
+        unsigned short xpos, ypos;
+        unsigned char event;
+        u_int8_t buf[16];
+
+        memset(buf, 0, sizeof(buf));
+
+        /* Set Index 0 */
+        buf[0] = 0;
+        if (i2c_master_send(priv->client, buf, 1) != 1) {
+                dev_err(&priv->client->dev, "Unable to write i2c index\n");
+                goto out;
+        }
+
+        /* Now do Page Read */
+        if (i2c_master_recv(priv->client, buf, sizeof(buf)) != sizeof(buf)) {
+                dev_err(&priv->client->dev, "Unable to read i2c page\n");
+                goto out;
+        }
+
+        ypos = ((buf[9] & 0x03) << 8 | buf[8]);
+        xpos = ((buf[11] & 0x03) << 8 | buf[10]);
+        event = buf[12];
+
+        if (event == EVENT_PENDOWN || event == EVENT_REPEAT) {
+                input_report_key(priv->input, BTN_TOUCH, 1);
+                input_report_abs(priv->input, ABS_X, ypos); /*X-Y swap*/
+                input_report_abs(priv->input, ABS_Y, xpos);
+                input_sync(priv->input);
+        } else if (event == EVENT_PENUP) {
+                input_report_key(priv->input, BTN_TOUCH, 0);
+                input_sync(priv->input);
+        }
+ out:
+        enable_irq(priv->irq);
+}
+
+static irqreturn_t migor_ts_isr(int irq, void *dev_id)
+{
+        struct migor_ts_priv *priv = dev_id;
+
+        /* the touch screen controller chip is hooked up to the cpu
+         * using i2c and a single interrupt line. the interrupt line
+         * is pulled low whenever someone taps the screen. to deassert
+         * the interrupt line we need to acknowledge the interrupt by
+         * communicating with the controller over the slow i2c bus.
+         *
+         * we can't acknowledge from interrupt context since the i2c
+         * bus controller may sleep, so we just disable the interrupt
+         * here and handle the acknowledge using delayed work.
+         */
+
+        disable_irq_nosync(irq);
+        schedule_delayed_work(&priv->work, HZ / 20);
+
+        return IRQ_HANDLED;
+}
+
+
+static int migor_ts_open(struct input_dev *dev)
+{
+        struct migor_ts_priv *priv = input_get_drvdata(dev);
+        struct i2c_client *client = priv->client;
+        int count;
+
+        /* enable controller */
+        count = i2c_master_send(client, migor_ts_ena_seq,
+                                sizeof(migor_ts_ena_seq));
+        if (count != sizeof(migor_ts_ena_seq)) {
+                dev_err(&client->dev, "Unable to enable touchscreen.\n");
+                return -ENXIO;
+        }
+
+        return 0;
+}
+
+static void migor_ts_close(struct input_dev *dev)
+{
+        struct migor_ts_priv *priv = input_get_drvdata(dev);
+        struct i2c_client *client = priv->client;
+
+        disable_irq(priv->irq);
+
+        /* cancel pending work and wait for migor_ts_poscheck() to finish */
+        if (cancel_delayed_work_sync(&priv->work)) {
+                /*
+                 * if migor_ts_poscheck was canceled we need to enable IRQ
+                 * here to balance disable done in migor_ts_isr.
+                 */
+                enable_irq(priv->irq);
+        }
+
+        /* disable controller */
+        i2c_master_send(client, migor_ts_dis_seq, sizeof(migor_ts_dis_seq));
+
+        enable_irq(priv->irq);
+}
+
+static int migor_ts_probe(struct i2c_client *client,
+                          const struct i2c_device_id *idp)
+{
+        struct migor_ts_priv *priv;
+        struct input_dev *input;
+        int error;
+
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (!priv) {
+                dev_err(&client->dev, "failed to allocate driver data\n");
+                error = -ENOMEM;
+                goto err0;
+        }
+
+        dev_set_drvdata(&client->dev, priv);
+
+        input = input_allocate_device();
+        if (!input) {
+                dev_err(&client->dev, "Failed to allocate input device.\n");
+                error = -ENOMEM;
+                goto err1;
+        }
+
+        input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+        input->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
+
+        input_set_abs_params(input, ABS_X, 95, 955, 0, 0);
+        input_set_abs_params(input, ABS_Y, 85, 935, 0, 0);
+
+        input->name = client->driver_name;
+        input->id.bustype = BUS_I2C;
+        input->dev.parent = &client->dev;
+
+        input->open = migor_ts_open;
+        input->close = migor_ts_close;
+
+        input_set_drvdata(input, priv);
+
+        priv->client = client;
+        priv->input = input;
+        INIT_DELAYED_WORK(&priv->work, migor_ts_poscheck);
+        priv->irq = client->irq;
+
+        error = input_register_device(input);
+        if (error)
+                goto err1;
+
+        error = request_irq(priv->irq, migor_ts_isr, IRQF_TRIGGER_LOW,
+                            client->driver_name, priv);
+        if (error) {
+                dev_err(&client->dev, "Unable to request touchscreen IRQ.\n");
+                goto err2;
+        }
+
+        return 0;
+
+ err2:
+        input_unregister_device(input);
+        input = NULL; /* so we dont try to free it below */
+ err1:
+        input_free_device(input);
+        kfree(priv);
+ err0:
+        dev_set_drvdata(&client->dev, NULL);
+        return error;
+}
+
+static int migor_ts_remove(struct i2c_client *client)
+{
+        struct migor_ts_priv *priv = dev_get_drvdata(&client->dev);
+
+        free_irq(priv->irq, priv);
+        input_unregister_device(priv->input);
+        kfree(priv);
+
+        dev_set_drvdata(&client->dev, NULL);
+
+        return 0;
+}
+
+static struct i2c_driver migor_ts_driver = {
+        .driver = {
+                .name = "migor_ts",
+        },
+        .probe = migor_ts_probe,
+        .remove = migor_ts_remove,
+};
+
+static int __init migor_ts_init(void)
+{
+        return i2c_add_driver(&migor_ts_driver);
+}
+
+static void __exit migor_ts_exit(void)
+{
+        i2c_del_driver(&migor_ts_driver);
+}
+
+MODULE_DESCRIPTION("MigoR Touchscreen driver");
+MODULE_AUTHOR("Magnus Damm <damm@opensource.se>");
+MODULE_LICENSE("GPL");
+
+module_init(migor_ts_init);
+module_exit(migor_ts_exit);
diff --git a/drivers/input/touchscreen/touchit213.c b/drivers/input/touchscreen/touchit213.c
new file mode 100644
index 000000000000..d1297ba19daf
--- /dev/null
+++ b/drivers/input/touchscreen/touchit213.c
@@ -0,0 +1,234 @@
+/*
+ * Sahara TouchIT-213 serial touchscreen driver
+ *
+ * Copyright (c) 2007-2008 Claudio Nieder <private@claudio.ch>
+ *
+ * Based on Touchright driver (drivers/input/touchscreen/touchright.c)
+ * Copyright (c) 2006 Rick Koch <n1gp@hotmail.com>
+ * Copyright (c) 2004 Vojtech Pavlik
+ * and Dan Streetman <ddstreet@ieee.org>
+ */
+
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published
+ * by the Free Software Foundation.
+ */
+
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/serio.h>
+#include <linux/init.h>
+
+#define DRIVER_DESC     "Sahara TouchIT-213 serial touchscreen driver"
+
+MODULE_AUTHOR("Claudio Nieder <private@claudio.ch>");
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
+
+/*
+ * Definitions & global arrays.
+ */
+
+/*
+ * Data is received through COM1 at 9600bit/s,8bit,no parity in packets
+ * of 5 byte each.
+ *
+ *   +--------+   +--------+   +--------+   +--------+   +--------+
+ *   |1000000p|   |0xxxxxxx|   |0xxxxxxx|   |0yyyyyyy|   |0yyyyyyy|
+ *   +--------+   +--------+   +--------+   +--------+   +--------+
+ *                    MSB          LSB          MSB          LSB
+ *
+ * The value of p is 1 as long as the screen is touched and 0 when
+ * reporting the location where touching stopped, e.g. where the pen was
+ * lifted from the screen.
+ *
+ * When holding the screen in landscape mode as the BIOS text output is
+ * presented, x is the horizontal axis with values growing from left to
+ * right and y is the vertical axis with values growing from top to
+ * bottom.
+ *
+ * When holding the screen in portrait mode with the Sahara logo in its
+ * correct position, x ist the vertical axis with values growing from
+ * top to bottom and y is the horizontal axis with values growing from
+ * right to left.
+ */
+
+#define T213_FORMAT_TOUCH_BIT   0x01
+#define T213_FORMAT_STATUS_BYTE 0x80
+#define T213_FORMAT_STATUS_MASK ~T213_FORMAT_TOUCH_BIT
+
+/*
+ * On my Sahara Touch-IT 213 I have observed x values from 0 to 0x7f0
+ * and y values from 0x1d to 0x7e9, so the actual measurement is
+ * probably done with an 11 bit precision.
+ */
+#define T213_MIN_XC 0
+#define T213_MAX_XC 0x07ff
+#define T213_MIN_YC 0
+#define T213_MAX_YC 0x07ff
+
+/*
+ * Per-touchscreen data.
+ */
+
+struct touchit213 {
+        struct input_dev *dev;
+        struct serio *serio;
+        int idx;
+        unsigned char csum;
+        unsigned char data[5];
+        char phys[32];
+};
+
+static irqreturn_t touchit213_interrupt(struct serio *serio,
+                unsigned char data, unsigned int flags)
+{
+        struct touchit213 *touchit213 = serio_get_drvdata(serio);
+        struct input_dev *dev = touchit213->dev;
+
+        touchit213->data[touchit213->idx] = data;
+
+        switch (touchit213->idx++) {
+        case 0:
+                if ((touchit213->data[0] & T213_FORMAT_STATUS_MASK) !=
+                                T213_FORMAT_STATUS_BYTE) {
+                        pr_debug("unsynchronized data: 0x%02x\n", data);
+                        touchit213->idx = 0;
+                }
+                break;
+
+        case 4:
+                touchit213->idx = 0;
+                input_report_abs(dev, ABS_X,
+                        (touchit213->data[1] << 7) | touchit213->data[2]);
+                input_report_abs(dev, ABS_Y,
+                        (touchit213->data[3] << 7) | touchit213->data[4]);
+                input_report_key(dev, BTN_TOUCH,
+                        touchit213->data[0] & T213_FORMAT_TOUCH_BIT);
+                input_sync(dev);
+                break;
+        }
+
+        return IRQ_HANDLED;
+}
+
+/*
+ * touchit213_disconnect() is the opposite of touchit213_connect()
+ */
+
+static void touchit213_disconnect(struct serio *serio)
+{
+        struct touchit213 *touchit213 = serio_get_drvdata(serio);
+
+        input_get_device(touchit213->dev);
+        input_unregister_device(touchit213->dev);
+        serio_close(serio);
+        serio_set_drvdata(serio, NULL);
+        input_put_device(touchit213->dev);
+        kfree(touchit213);
+}
+
+/*
+ * touchit213_connect() is the routine that is called when someone adds a
+ * new serio device that supports the Touchright protocol and registers it as
+ * an input device.
+ */
+
+static int touchit213_connect(struct serio *serio, struct serio_driver *drv)
+{
+        struct touchit213 *touchit213;
+        struct input_dev *input_dev;
+        int err;
+
+        touchit213 = kzalloc(sizeof(struct touchit213), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!touchit213 || !input_dev) {
+                err = -ENOMEM;
+                goto fail1;
+        }
+
+        touchit213->serio = serio;
+        touchit213->dev = input_dev;
+        snprintf(touchit213->phys, sizeof(touchit213->phys),
+                 "%s/input0", serio->phys);
+
+        input_dev->name = "Sahara Touch-iT213 Serial TouchScreen";
+        input_dev->phys = touchit213->phys;
+        input_dev->id.bustype = BUS_RS232;
+        input_dev->id.vendor = SERIO_TOUCHIT213;
+        input_dev->id.product = 0;
+        input_dev->id.version = 0x0100;
+        input_dev->dev.parent = &serio->dev;
+        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+        input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
+        input_set_abs_params(touchit213->dev, ABS_X,
+                             T213_MIN_XC, T213_MAX_XC, 0, 0);
+        input_set_abs_params(touchit213->dev, ABS_Y,
+                             T213_MIN_YC, T213_MAX_YC, 0, 0);
+
+        serio_set_drvdata(serio, touchit213);
+
+        err = serio_open(serio, drv);
+        if (err)
+                goto fail2;
+
+        err = input_register_device(touchit213->dev);
+        if (err)
+                goto fail3;
+
+        return 0;
+
+ fail3: serio_close(serio);
+ fail2: serio_set_drvdata(serio, NULL);
+ fail1: input_free_device(input_dev);
+        kfree(touchit213);
+        return err;
+}
+
+/*
+ * The serio driver structure.
+ */
+
+static struct serio_device_id touchit213_serio_ids[] = {
+        {
+                .type   = SERIO_RS232,
+                .proto  = SERIO_TOUCHIT213,
+                .id     = SERIO_ANY,
+                .extra  = SERIO_ANY,
+        },
+        { 0 }
+};
+
+MODULE_DEVICE_TABLE(serio, touchit213_serio_ids);
+
+static struct serio_driver touchit213_drv = {
+        .driver         = {
+                .name   = "touchit213",
+        },
+        .description    = DRIVER_DESC,
+        .id_table       = touchit213_serio_ids,
+        .interrupt      = touchit213_interrupt,
+        .connect        = touchit213_connect,
+        .disconnect     = touchit213_disconnect,
+};
+
+/*
+ * The functions for inserting/removing us as a module.
+ */
+
+static int __init touchit213_init(void)
+{
+        return serio_register_driver(&touchit213_drv);
+}
+
+static void __exit touchit213_exit(void)
+{
+        serio_unregister_driver(&touchit213_drv);
+}
+
+module_init(touchit213_init);
+module_exit(touchit213_exit);
diff --git a/drivers/input/touchscreen/usbtouchscreen.c b/drivers/input/touchscreen/usbtouchscreen.c
index 3a0a8ca57076..fdd645c214a2 100644
--- a/drivers/input/touchscreen/usbtouchscreen.c
+++ b/drivers/input/touchscreen/usbtouchscreen.c
@@ -49,6 +49,7 @@
 #include <linux/init.h>
 #include <linux/usb.h>
 #include <linux/usb/input.h>
+#include <linux/hid.h>
 
 
 #define DRIVER_VERSION          "v0.6"
@@ -101,7 +102,7 @@ struct usbtouch_usb {
 
 /* device types */
 enum {
-        DEVTPYE_DUMMY = -1,
+        DEVTYPE_IGNORE = -1,
         DEVTYPE_EGALAX,
         DEVTYPE_PANJIT,
         DEVTYPE_3M,
@@ -115,8 +116,21 @@ enum {
         DEVTYPE_GOTOP,
 };
 
+#define USB_DEVICE_HID_CLASS(vend, prod) \
+        .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS \
+                | USB_DEVICE_ID_MATCH_DEVICE, \
+        .idVendor = (vend), \
+        .idProduct = (prod), \
+        .bInterfaceClass = USB_INTERFACE_CLASS_HID, \
+        .bInterfaceProtocol = USB_INTERFACE_PROTOCOL_MOUSE
+
 static struct usb_device_id usbtouch_devices[] = {
 #ifdef CONFIG_TOUCHSCREEN_USB_EGALAX
+        /* ignore the HID capable devices, handled by usbhid */
+        {USB_DEVICE_HID_CLASS(0x0eef, 0x0001), .driver_info = DEVTYPE_IGNORE},
+        {USB_DEVICE_HID_CLASS(0x0eef, 0x0002), .driver_info = DEVTYPE_IGNORE},
+
+        /* normal device IDs */
         {USB_DEVICE(0x3823, 0x0001), .driver_info = DEVTYPE_EGALAX},
         {USB_DEVICE(0x3823, 0x0002), .driver_info = DEVTYPE_EGALAX},
         {USB_DEVICE(0x0123, 0x0001), .driver_info = DEVTYPE_EGALAX},
@@ -262,7 +276,7 @@ static int mtouch_init(struct usbtouch_usb *usbtouch)
                               USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                               1, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
         dbg("%s - usb_control_msg - MTOUCHUSB_RESET - bytes|err: %d",
-            __FUNCTION__, ret);
+            __func__, ret);
         if (ret < 0)
                 return ret;
         msleep(150);
@@ -273,7 +287,7 @@ static int mtouch_init(struct usbtouch_usb *usbtouch)
                                       USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                                       1, 1, NULL, 0, USB_CTRL_SET_TIMEOUT);
                 dbg("%s - usb_control_msg - MTOUCHUSB_ASYNC_REPORT - bytes|err: %d",
-                    __FUNCTION__, ret);
+                    __func__, ret);
                 if (ret >= 0)
                         break;
                 if (ret != -EPIPE)
@@ -793,18 +807,18 @@ static void usbtouch_irq(struct urb *urb)
         case -ETIME:
                 /* this urb is timing out */
                 dbg("%s - urb timed out - was the device unplugged?",
-                    __FUNCTION__);
+                    __func__);
                 return;
         case -ECONNRESET:
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
                 dbg("%s - urb shutting down with status: %d",
-                    __FUNCTION__, urb->status);
+                    __func__, urb->status);
                 return;
         default:
                 dbg("%s - nonzero urb status received: %d",
-                    __FUNCTION__, urb->status);
+                    __func__, urb->status);
                 goto exit;
         }
 
@@ -814,7 +828,7 @@ exit:
         retval = usb_submit_urb(urb, GFP_ATOMIC);
         if (retval)
                 err("%s - usb_submit_urb failed with result: %d",
-                    __FUNCTION__, retval);
+                    __func__, retval);
 }
 
 static int usbtouch_open(struct input_dev *input)
@@ -857,6 +871,10 @@ static int usbtouch_probe(struct usb_interface *intf,
         struct usbtouch_device_info *type;
         int err = -ENOMEM;
 
+        /* some devices are ignored */
+        if (id->driver_info == DEVTYPE_IGNORE)
+                return -ENODEV;
+
         interface = intf->cur_altsetting;
         endpoint = &interface->endpoint[0].desc;
 
@@ -883,7 +901,7 @@ static int usbtouch_probe(struct usb_interface *intf,
 
         usbtouch->irq = usb_alloc_urb(0, GFP_KERNEL);
         if (!usbtouch->irq) {
-                dbg("%s - usb_alloc_urb failed: usbtouch->irq", __FUNCTION__);
+                dbg("%s - usb_alloc_urb failed: usbtouch->irq", __func__);
                 goto out_free_buffers;
         }
 
@@ -939,14 +957,14 @@ static int usbtouch_probe(struct usb_interface *intf,
         if (type->init) {
                 err = type->init(usbtouch);
                 if (err) {
-                        dbg("%s - type->init() failed, err: %d", __FUNCTION__, err);
+                        dbg("%s - type->init() failed, err: %d", __func__, err);
                         goto out_free_buffers;
                 }
         }
 
         err = input_register_device(usbtouch->input);
         if (err) {
-                dbg("%s - input_register_device failed, err: %d", __FUNCTION__, err);
+                dbg("%s - input_register_device failed, err: %d", __func__, err);
                 goto out_free_buffers;
         }
 
@@ -966,12 +984,12 @@ static void usbtouch_disconnect(struct usb_interface *intf)
 {
         struct usbtouch_usb *usbtouch = usb_get_intfdata(intf);
 
-        dbg("%s - called", __FUNCTION__);
+        dbg("%s - called", __func__);
 
         if (!usbtouch)
                 return;
 
-        dbg("%s - usbtouch is initialized, cleaning up", __FUNCTION__);
+        dbg("%s - usbtouch is initialized, cleaning up", __func__);
         usb_set_intfdata(intf, NULL);
         usb_kill_urb(usbtouch->irq);
         input_unregister_device(usbtouch->input);
diff --git a/drivers/input/touchscreen/wm9712.c b/drivers/input/touchscreen/wm9712.c
index 0b6e4cfa6a21..4c5d85a249ae 100644
--- a/drivers/input/touchscreen/wm9712.c
+++ b/drivers/input/touchscreen/wm9712.c
@@ -168,6 +168,18 @@ static void wm9712_phy_init(struct wm97xx *wm)
                         64000 / rpu);
         }
 
+        /* WM9712 five wire */
+        if (five_wire) {
+                dig2 |= WM9712_45W;
+                dev_dbg(wm->dev, "setting 5-wire touchscreen mode.");
+
+                if (pil) {
+                        dev_warn(wm->dev, "pressure measurement is not "
+                                 "supported in 5-wire mode\n");
+                        pil = 0;
+                }
+        }
+
         /* touchpanel pressure current*/
         if (pil == 2) {
                 dig2 |= WM9712_PIL;
@@ -179,12 +191,6 @@ static void wm9712_phy_init(struct wm97xx *wm)
         if (!pil)
                 pressure = 0;
 
-        /* WM9712 five wire */
-        if (five_wire) {
-                dig2 |= WM9712_45W;
-                dev_dbg(wm->dev, "setting 5-wire touchscreen mode.");
-        }
-
         /* polling mode sample settling delay */
         if (delay < 0 || delay > 15) {
                 dev_dbg(wm->dev, "supplied delay out of range.");
diff --git a/drivers/macintosh/adbhid.c b/drivers/macintosh/adbhid.c
index 59ea520a5d7a..5396c67ba0a4 100644
--- a/drivers/macintosh/adbhid.c
+++ b/drivers/macintosh/adbhid.c
@@ -219,11 +219,13 @@ struct adbhid {
         int flags;
 };
 
-#define FLAG_FN_KEY_PRESSED     0x00000001
-#define FLAG_POWER_FROM_FN      0x00000002
-#define FLAG_EMU_FWDEL_DOWN     0x00000004
-#define FLAG_CAPSLOCK_TRANSLATE 0x00000008
-#define FLAG_CAPSLOCK_DOWN      0x00000010
+#define FLAG_FN_KEY_PRESSED             0x00000001
+#define FLAG_POWER_FROM_FN              0x00000002
+#define FLAG_EMU_FWDEL_DOWN             0x00000004
+#define FLAG_CAPSLOCK_TRANSLATE         0x00000008
+#define FLAG_CAPSLOCK_DOWN              0x00000010
+#define FLAG_CAPSLOCK_IGNORE_NEXT       0x00000020
+#define FLAG_POWER_KEY_PRESSED          0x00000040
 
 static struct adbhid *adbhid[16];
 
@@ -291,11 +293,20 @@ adbhid_input_keycode(int id, int scancode, int repeat)
                 if (keycode == ADB_KEY_CAPSLOCK && !up_flag) {
                         /* Key pressed, turning on the CapsLock LED.
                          * The next 0xff will be interpreted as a release. */
-                        ahid->flags |= FLAG_CAPSLOCK_TRANSLATE
+                        if (ahid->flags & FLAG_CAPSLOCK_IGNORE_NEXT) {
+                                /* Throw away this key event if it happens
+                                 * just after resume. */
+                                ahid->flags &= ~FLAG_CAPSLOCK_IGNORE_NEXT;
+                                return;
+                        } else {
+                                ahid->flags |= FLAG_CAPSLOCK_TRANSLATE
                                         | FLAG_CAPSLOCK_DOWN;
-                } else if (scancode == 0xff) {
+                        }
+                } else if (scancode == 0xff &&
+                           !(ahid->flags & FLAG_POWER_KEY_PRESSED)) {
                         /* Scancode 0xff usually signifies that the capslock
-                         * key was either pressed or released. */
+                         * key was either pressed or released, or that the
+                         * power button was released. */
                         if (ahid->flags & FLAG_CAPSLOCK_TRANSLATE) {
                                 keycode = ADB_KEY_CAPSLOCK;
                                 if (ahid->flags & FLAG_CAPSLOCK_DOWN) {
@@ -309,7 +320,7 @@ adbhid_input_keycode(int id, int scancode, int repeat)
                                 }
                         } else {
                                 printk(KERN_INFO "Spurious caps lock event "
-                                                "(scancode 0xff).");
+                                                 "(scancode 0xff).\n");
                         }
                 }
         }
@@ -336,6 +347,12 @@ adbhid_input_keycode(int id, int scancode, int repeat)
                 }
                 break;
         case ADB_KEY_POWER:
+                /* Keep track of the power key state */
+                if (up_flag)
+                        ahid->flags &= ~FLAG_POWER_KEY_PRESSED;
+                else
+                        ahid->flags |= FLAG_POWER_KEY_PRESSED;
+
                 /* Fn + Command will produce a bogus "power" keycode */
                 if (ahid->flags & FLAG_FN_KEY_PRESSED) {
                         keycode = ADB_KEY_CMD;
@@ -681,6 +698,21 @@ static int adbhid_kbd_event(struct input_dev *dev, unsigned int type, unsigned i
         return -1;
 }
 
+static void
+adbhid_kbd_capslock_remember(void)
+{
+        struct adbhid *ahid;
+        int i;
+
+        for (i = 1; i < 16; i++) {
+                ahid = adbhid[i];
+
+                if (ahid && ahid->id == ADB_KEYBOARD)
+                        if (ahid->flags & FLAG_CAPSLOCK_TRANSLATE)
+                                ahid->flags |= FLAG_CAPSLOCK_IGNORE_NEXT;
+        }
+}
+
 static int
 adb_message_handler(struct notifier_block *this, unsigned long code, void *x)
 {
@@ -697,8 +729,17 @@ adb_message_handler(struct notifier_block *this, unsigned long code, void *x)
                 }
 
                 /* Stop pending led requests */
-                while(leds_req_pending)
+                while (leds_req_pending)
                         adb_poll();
+
+                /* After resume, and if the capslock LED is on, the PMU will
+                 * send a "capslock down" key event. This confuses the
+                 * restore_capslock_events logic. Remember if the capslock
+                 * LED was on before suspend so the unwanted key event can
+                 * be ignored after resume. */
+                if (restore_capslock_events)
+                        adbhid_kbd_capslock_remember();
+
                 break;
 
         case ADB_MSG_POST_RESET:
diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
index b26927ce889c..621a272a2c74 100644
--- a/drivers/md/bitmap.c
+++ b/drivers/md/bitmap.c
@@ -225,7 +225,7 @@ static struct page *read_sb_page(mddev_t *mddev, long offset, unsigned long inde
                     || test_bit(Faulty, &rdev->flags))
                         continue;
 
-                target = (rdev->sb_offset << 1) + offset + index * (PAGE_SIZE/512);
+                target = rdev->sb_start + offset + index * (PAGE_SIZE/512);
 
                 if (sync_page_io(rdev->bdev, target, PAGE_SIZE, page, READ)) {
                         page->index = index;
@@ -241,10 +241,10 @@ static struct page *read_sb_page(mddev_t *mddev, long offset, unsigned long inde
 static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait)
 {
         mdk_rdev_t *rdev;
-        struct list_head *tmp;
         mddev_t *mddev = bitmap->mddev;
 
-        rdev_for_each(rdev, tmp, mddev)
+        rcu_read_lock();
+        rdev_for_each_rcu(rdev, mddev)
                 if (test_bit(In_sync, &rdev->flags)
                     && !test_bit(Faulty, &rdev->flags)) {
                         int size = PAGE_SIZE;
@@ -260,32 +260,37 @@ static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait)
                                     + (long)(page->index * (PAGE_SIZE/512))
                                     + size/512 > 0)
                                         /* bitmap runs in to metadata */
-                                        return -EINVAL;
+                                        goto bad_alignment;
                                 if (rdev->data_offset + mddev->size*2
-                                    > rdev->sb_offset*2 + bitmap->offset)
+                                    > rdev->sb_start + bitmap->offset)
                                         /* data runs in to bitmap */
-                                        return -EINVAL;
-                        } else if (rdev->sb_offset*2 < rdev->data_offset) {
+                                        goto bad_alignment;
+                        } else if (rdev->sb_start < rdev->data_offset) {
                                 /* METADATA BITMAP DATA */
-                                if (rdev->sb_offset*2
+                                if (rdev->sb_start
                                     + bitmap->offset
                                     + page->index*(PAGE_SIZE/512) + size/512
                                     > rdev->data_offset)
                                         /* bitmap runs in to data */
-                                        return -EINVAL;
+                                        goto bad_alignment;
                         } else {
                                 /* DATA METADATA BITMAP - no problems */
                         }
                         md_super_write(mddev, rdev,
-                                       (rdev->sb_offset<<1) + bitmap->offset
+                                       rdev->sb_start + bitmap->offset
                                        + page->index * (PAGE_SIZE/512),
                                        size,
                                        page);
                 }
+        rcu_read_unlock();
 
         if (wait)
                 md_super_wait(mddev);
         return 0;
+
+ bad_alignment:
+        rcu_read_unlock();
+        return -EINVAL;
 }
 
 static void bitmap_file_kick(struct bitmap *bitmap);
@@ -454,8 +459,11 @@ void bitmap_update_sb(struct bitmap *bitmap)
         spin_unlock_irqrestore(&bitmap->lock, flags);
         sb = (bitmap_super_t *)kmap_atomic(bitmap->sb_page, KM_USER0);
         sb->events = cpu_to_le64(bitmap->mddev->events);
-        if (!bitmap->mddev->degraded)
-                sb->events_cleared = cpu_to_le64(bitmap->mddev->events);
+        if (bitmap->mddev->events < bitmap->events_cleared) {
+                /* rocking back to read-only */
+                bitmap->events_cleared = bitmap->mddev->events;
+                sb->events_cleared = cpu_to_le64(bitmap->events_cleared);
+        }
         kunmap_atomic(sb, KM_USER0);
         write_page(bitmap, bitmap->sb_page, 1);
 }
@@ -1085,9 +1093,19 @@ void bitmap_daemon_work(struct bitmap *bitmap)
                         } else
                                 spin_unlock_irqrestore(&bitmap->lock, flags);
                         lastpage = page;
-/*
-                        printk("bitmap clean at page %lu\n", j);
-*/
+
+                        /* We are possibly going to clear some bits, so make
+                         * sure that events_cleared is up-to-date.
+                         */
+                        if (bitmap->need_sync) {
+                                bitmap_super_t *sb;
+                                bitmap->need_sync = 0;
+                                sb = kmap_atomic(bitmap->sb_page, KM_USER0);
+                                sb->events_cleared =
+                                        cpu_to_le64(bitmap->events_cleared);
+                                kunmap_atomic(sb, KM_USER0);
+                                write_page(bitmap, bitmap->sb_page, 1);
+                        }
                         spin_lock_irqsave(&bitmap->lock, flags);
                         clear_page_attr(bitmap, page, BITMAP_PAGE_CLEAN);
                 }
@@ -1257,6 +1275,12 @@ void bitmap_endwrite(struct bitmap *bitmap, sector_t offset, unsigned long secto
                         return;
                 }
 
+                if (success &&
+                    bitmap->events_cleared < bitmap->mddev->events) {
+                        bitmap->events_cleared = bitmap->mddev->events;
+                        bitmap->need_sync = 1;
+                }
+
                 if (!success && ! (*bmc & NEEDED_MASK))
                         *bmc |= NEEDED_MASK;
 
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index ab6a61db63ce..13956437bc81 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -1216,9 +1216,24 @@ error:
         return -EINVAL;
 }
 
+static int crypt_merge(struct dm_target *ti, struct bvec_merge_data *bvm,
+                       struct bio_vec *biovec, int max_size)
+{
+        struct crypt_config *cc = ti->private;
+        struct request_queue *q = bdev_get_queue(cc->dev->bdev);
+
+        if (!q->merge_bvec_fn)
+                return max_size;
+
+        bvm->bi_bdev = cc->dev->bdev;
+        bvm->bi_sector = cc->start + bvm->bi_sector - ti->begin;
+
+        return min(max_size, q->merge_bvec_fn(q, bvm, biovec));
+}
+
 static struct target_type crypt_target = {
         .name   = "crypt",
-        .version= {1, 5, 0},
+        .version= {1, 6, 0},
         .module = THIS_MODULE,
         .ctr    = crypt_ctr,
         .dtr    = crypt_dtr,
@@ -1228,6 +1243,7 @@ static struct target_type crypt_target = {
         .preresume = crypt_preresume,
         .resume = crypt_resume,
         .message = crypt_message,
+        .merge  = crypt_merge,
 };
 
 static int __init dm_crypt_init(void)
diff --git a/drivers/md/dm-linear.c b/drivers/md/dm-linear.c
index 17753d80ad22..6449bcdf84ca 100644
--- a/drivers/md/dm-linear.c
+++ b/drivers/md/dm-linear.c
@@ -69,13 +69,25 @@ static void linear_dtr(struct dm_target *ti)
         kfree(lc);
 }
 
-static int linear_map(struct dm_target *ti, struct bio *bio,
-                      union map_info *map_context)
+static sector_t linear_map_sector(struct dm_target *ti, sector_t bi_sector)
 {
-        struct linear_c *lc = (struct linear_c *) ti->private;
+        struct linear_c *lc = ti->private;
+
+        return lc->start + (bi_sector - ti->begin);
+}
+
+static void linear_map_bio(struct dm_target *ti, struct bio *bio)
+{
+        struct linear_c *lc = ti->private;
 
         bio->bi_bdev = lc->dev->bdev;
-        bio->bi_sector = lc->start + (bio->bi_sector - ti->begin);
+        bio->bi_sector = linear_map_sector(ti, bio->bi_sector);
+}
+
+static int linear_map(struct dm_target *ti, struct bio *bio,
+                      union map_info *map_context)
+{
+        linear_map_bio(ti, bio);
 
         return DM_MAPIO_REMAPPED;
 }
@@ -114,15 +126,31 @@ static int linear_ioctl(struct dm_target *ti, struct inode *inode,
         return blkdev_driver_ioctl(bdev->bd_inode, &fake_file, bdev->bd_disk, cmd, arg);
 }
 
+static int linear_merge(struct dm_target *ti, struct bvec_merge_data *bvm,
+                        struct bio_vec *biovec, int max_size)
+{
+        struct linear_c *lc = ti->private;
+        struct request_queue *q = bdev_get_queue(lc->dev->bdev);
+
+        if (!q->merge_bvec_fn)
+                return max_size;
+
+        bvm->bi_bdev = lc->dev->bdev;
+        bvm->bi_sector = linear_map_sector(ti, bvm->bi_sector);
+
+        return min(max_size, q->merge_bvec_fn(q, bvm, biovec));
+}
+
 static struct target_type linear_target = {
         .name   = "linear",
-        .version= {1, 0, 2},
+        .version= {1, 0, 3},
         .module = THIS_MODULE,
         .ctr    = linear_ctr,
         .dtr    = linear_dtr,
         .map    = linear_map,
         .status = linear_status,
         .ioctl  = linear_ioctl,
+        .merge  = linear_merge,
 };
 
 int __init dm_linear_init(void)
diff --git a/drivers/md/dm-log.c b/drivers/md/dm-log.c
index 67a6f31b7fc3..5b48478c79f5 100644
--- a/drivers/md/dm-log.c
+++ b/drivers/md/dm-log.c
@@ -831,7 +831,7 @@ static struct dm_dirty_log_type _disk_type = {
         .status = disk_status,
 };
 
-int __init dm_dirty_log_init(void)
+static int __init dm_dirty_log_init(void)
 {
         int r;
 
@@ -848,7 +848,7 @@ int __init dm_dirty_log_init(void)
         return r;
 }
 
-void __exit dm_dirty_log_exit(void)
+static void __exit dm_dirty_log_exit(void)
 {
         dm_dirty_log_type_unregister(&_disk_type);
         dm_dirty_log_type_unregister(&_core_type);
diff --git a/drivers/md/dm-mpath.c b/drivers/md/dm-mpath.c
index 9f7302d4878d..fea966d66f98 100644
--- a/drivers/md/dm-mpath.c
+++ b/drivers/md/dm-mpath.c
@@ -525,8 +525,10 @@ static int parse_path_selector(struct arg_set *as, struct priority_group *pg,
         }
 
         r = read_param(_params, shift(as), &ps_argc, &ti->error);
-        if (r)
+        if (r) {
+                dm_put_path_selector(pst);
                 return -EINVAL;
+        }
 
         r = pst->create(&pg->ps, ps_argc, as->argv);
         if (r) {
@@ -623,8 +625,10 @@ static struct priority_group *parse_priority_group(struct arg_set *as,
                 struct pgpath *pgpath;
                 struct arg_set path_args;
 
-                if (as->argc < nr_params)
+                if (as->argc < nr_params) {
+                        ti->error = "not enough path parameters";
                         goto bad;
+                }
 
                 path_args.argc = nr_params;
                 path_args.argv = as->argv;
@@ -867,7 +871,7 @@ static int reinstate_path(struct pgpath *pgpath)
         if (pgpath->path.is_active)
                 goto out;
 
-        if (!pgpath->pg->ps.type) {
+        if (!pgpath->pg->ps.type->reinstate_path) {
                 DMWARN("Reinstate path not supported by path selector %s",
                        pgpath->pg->ps.type->name);
                 r = -EINVAL;
diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
index 1ba8a47d61b1..6e5528aecc98 100644
--- a/drivers/md/dm-snap.c
+++ b/drivers/md/dm-snap.c
@@ -40,6 +40,11 @@
  */
 #define SNAPSHOT_PAGES (((1UL << 20) >> PAGE_SHIFT) ? : 1)
 
+/*
+ * The size of the mempool used to track chunks in use.
+ */
+#define MIN_IOS 256
+
 static struct workqueue_struct *ksnapd;
 static void flush_queued_bios(struct work_struct *work);
 
@@ -91,7 +96,63 @@ struct dm_snap_pending_exception {
  */
 static struct kmem_cache *exception_cache;
 static struct kmem_cache *pending_cache;
-static mempool_t *pending_pool;
+
+struct dm_snap_tracked_chunk {
+        struct hlist_node node;
+        chunk_t chunk;
+};
+
+static struct kmem_cache *tracked_chunk_cache;
+
+static struct dm_snap_tracked_chunk *track_chunk(struct dm_snapshot *s,
+                                                 chunk_t chunk)
+{
+        struct dm_snap_tracked_chunk *c = mempool_alloc(s->tracked_chunk_pool,
+                                                        GFP_NOIO);
+        unsigned long flags;
+
+        c->chunk = chunk;
+
+        spin_lock_irqsave(&s->tracked_chunk_lock, flags);
+        hlist_add_head(&c->node,
+                       &s->tracked_chunk_hash[DM_TRACKED_CHUNK_HASH(chunk)]);
+        spin_unlock_irqrestore(&s->tracked_chunk_lock, flags);
+
+        return c;
+}
+
+static void stop_tracking_chunk(struct dm_snapshot *s,
+                                struct dm_snap_tracked_chunk *c)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&s->tracked_chunk_lock, flags);
+        hlist_del(&c->node);
+        spin_unlock_irqrestore(&s->tracked_chunk_lock, flags);
+
+        mempool_free(c, s->tracked_chunk_pool);
+}
+
+static int __chunk_is_tracked(struct dm_snapshot *s, chunk_t chunk)
+{
+        struct dm_snap_tracked_chunk *c;
+        struct hlist_node *hn;
+        int found = 0;
+
+        spin_lock_irq(&s->tracked_chunk_lock);
+
+        hlist_for_each_entry(c, hn,
+            &s->tracked_chunk_hash[DM_TRACKED_CHUNK_HASH(chunk)], node) {
+                if (c->chunk == chunk) {
+                        found = 1;
+                        break;
+                }
+        }
+
+        spin_unlock_irq(&s->tracked_chunk_lock);
+
+        return found;
+}
 
 /*
  * One of these per registered origin, held in the snapshot_origins hash
@@ -302,14 +363,19 @@ static void free_exception(struct dm_snap_exception *e)
         kmem_cache_free(exception_cache, e);
 }
 
-static struct dm_snap_pending_exception *alloc_pending_exception(void)
+static struct dm_snap_pending_exception *alloc_pending_exception(struct dm_snapshot *s)
 {
-        return mempool_alloc(pending_pool, GFP_NOIO);
+        struct dm_snap_pending_exception *pe = mempool_alloc(s->pending_pool,
+                                                             GFP_NOIO);
+
+        pe->snap = s;
+
+        return pe;
 }
 
 static void free_pending_exception(struct dm_snap_pending_exception *pe)
 {
-        mempool_free(pe, pending_pool);
+        mempool_free(pe, pe->snap->pending_pool);
 }
 
 static void insert_completed_exception(struct dm_snapshot *s,
@@ -482,6 +548,7 @@ static int set_chunk_size(struct dm_snapshot *s, const char *chunk_size_arg,
 static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 {
         struct dm_snapshot *s;
+        int i;
         int r = -EINVAL;
         char persistent;
         char *origin_path;
@@ -564,11 +631,30 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                 goto bad5;
         }
 
+        s->pending_pool = mempool_create_slab_pool(MIN_IOS, pending_cache);
+        if (!s->pending_pool) {
+                ti->error = "Could not allocate mempool for pending exceptions";
+                goto bad6;
+        }
+
+        s->tracked_chunk_pool = mempool_create_slab_pool(MIN_IOS,
+                                                         tracked_chunk_cache);
+        if (!s->tracked_chunk_pool) {
+                ti->error = "Could not allocate tracked_chunk mempool for "
+                            "tracking reads";
+                goto bad_tracked_chunk_pool;
+        }
+
+        for (i = 0; i < DM_TRACKED_CHUNK_HASH_SIZE; i++)
+                INIT_HLIST_HEAD(&s->tracked_chunk_hash[i]);
+
+        spin_lock_init(&s->tracked_chunk_lock);
+
         /* Metadata must only be loaded into one table at once */
         r = s->store.read_metadata(&s->store);
         if (r < 0) {
                 ti->error = "Failed to read snapshot metadata";
-                goto bad6;
+                goto bad_load_and_register;
         } else if (r > 0) {
                 s->valid = 0;
                 DMWARN("Snapshot is marked invalid.");
@@ -582,7 +668,7 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
         if (register_snapshot(s)) {
                 r = -EINVAL;
                 ti->error = "Cannot register snapshot origin";
-                goto bad6;
+                goto bad_load_and_register;
         }
 
         ti->private = s;
@@ -590,6 +676,12 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 
         return 0;
 
+ bad_load_and_register:
+        mempool_destroy(s->tracked_chunk_pool);
+
+ bad_tracked_chunk_pool:
+        mempool_destroy(s->pending_pool);
+
  bad6:
         dm_kcopyd_client_destroy(s->kcopyd_client);
 
@@ -624,6 +716,9 @@ static void __free_exceptions(struct dm_snapshot *s)
 
 static void snapshot_dtr(struct dm_target *ti)
 {
+#ifdef CONFIG_DM_DEBUG
+        int i;
+#endif
         struct dm_snapshot *s = ti->private;
 
         flush_workqueue(ksnapd);
@@ -632,8 +727,17 @@ static void snapshot_dtr(struct dm_target *ti)
         /* After this returns there can be no new kcopyd jobs. */
         unregister_snapshot(s);
 
+#ifdef CONFIG_DM_DEBUG
+        for (i = 0; i < DM_TRACKED_CHUNK_HASH_SIZE; i++)
+                BUG_ON(!hlist_empty(&s->tracked_chunk_hash[i]));
+#endif
+
+        mempool_destroy(s->tracked_chunk_pool);
+
         __free_exceptions(s);
 
+        mempool_destroy(s->pending_pool);
+
         dm_put_device(ti, s->origin);
         dm_put_device(ti, s->cow);
 
@@ -772,6 +876,13 @@ static void pending_complete(struct dm_snap_pending_exception *pe, int success)
         }
 
         /*
+         * Check for conflicting reads. This is extremely improbable,
+         * so yield() is sufficient and there is no need for a wait queue.
+         */
+        while (__chunk_is_tracked(s, pe->e.old_chunk))
+                yield();
+
+        /*
          * Add a proper exception, and remove the
          * in-flight exception from the list.
          */
@@ -873,7 +984,7 @@ __find_pending_exception(struct dm_snapshot *s, struct bio *bio)
          * to hold the lock while we do this.
          */
         up_write(&s->lock);
-        pe = alloc_pending_exception();
+        pe = alloc_pending_exception(s);
         down_write(&s->lock);
 
         if (!s->valid) {
@@ -893,7 +1004,6 @@ __find_pending_exception(struct dm_snapshot *s, struct bio *bio)
         bio_list_init(&pe->snapshot_bios);
         pe->primary_pe = NULL;
         atomic_set(&pe->ref_count, 0);
-        pe->snap = s;
         pe->started = 0;
 
         if (s->store.prepare_exception(&s->store, &pe->e)) {
@@ -974,14 +1084,10 @@ static int snapshot_map(struct dm_target *ti, struct bio *bio,
                         start_copy(pe);
                         goto out;
                 }
-        } else
-                /*
-                 * FIXME: this read path scares me because we
-                 * always use the origin when we have a pending
-                 * exception.  However I can't think of a
-                 * situation where this is wrong - ejt.
-                 */
+        } else {
                 bio->bi_bdev = s->origin->bdev;
+                map_context->ptr = track_chunk(s, chunk);
+        }
 
  out_unlock:
         up_write(&s->lock);
@@ -989,6 +1095,18 @@ static int snapshot_map(struct dm_target *ti, struct bio *bio,
         return r;
 }
 
+static int snapshot_end_io(struct dm_target *ti, struct bio *bio,
+                           int error, union map_info *map_context)
+{
+        struct dm_snapshot *s = ti->private;
+        struct dm_snap_tracked_chunk *c = map_context->ptr;
+
+        if (c)
+                stop_tracking_chunk(s, c);
+
+        return 0;
+}
+
 static void snapshot_resume(struct dm_target *ti)
 {
         struct dm_snapshot *s = ti->private;
@@ -1266,6 +1384,7 @@ static struct target_type snapshot_target = {
         .ctr     = snapshot_ctr,
         .dtr     = snapshot_dtr,
         .map     = snapshot_map,
+        .end_io  = snapshot_end_io,
         .resume  = snapshot_resume,
         .status  = snapshot_status,
 };
@@ -1306,9 +1425,9 @@ static int __init dm_snapshot_init(void)
                 goto bad4;
         }
 
-        pending_pool = mempool_create_slab_pool(128, pending_cache);
-        if (!pending_pool) {
-                DMERR("Couldn't create pending pool.");
+        tracked_chunk_cache = KMEM_CACHE(dm_snap_tracked_chunk, 0);
+        if (!tracked_chunk_cache) {
+                DMERR("Couldn't create cache to track chunks in use.");
                 r = -ENOMEM;
                 goto bad5;
         }
@@ -1317,13 +1436,13 @@ static int __init dm_snapshot_init(void)
         if (!ksnapd) {
                 DMERR("Failed to create ksnapd workqueue.");
                 r = -ENOMEM;
-                goto bad6;
+                goto bad_pending_pool;
         }
 
         return 0;
 
-      bad6:
-        mempool_destroy(pending_pool);
+      bad_pending_pool:
+        kmem_cache_destroy(tracked_chunk_cache);
       bad5:
         kmem_cache_destroy(pending_cache);
       bad4:
@@ -1352,9 +1471,9 @@ static void __exit dm_snapshot_exit(void)
                 DMERR("origin unregister failed %d", r);
 
         exit_origin_hash();
-        mempool_destroy(pending_pool);
         kmem_cache_destroy(pending_cache);
         kmem_cache_destroy(exception_cache);
+        kmem_cache_destroy(tracked_chunk_cache);
 }
 
 /* Module hooks */
diff --git a/drivers/md/dm-snap.h b/drivers/md/dm-snap.h
index 24f9fb73b982..292c15609ae3 100644
--- a/drivers/md/dm-snap.h
+++ b/drivers/md/dm-snap.h
@@ -130,6 +130,10 @@ struct exception_store {
         void *context;
 };
 
+#define DM_TRACKED_CHUNK_HASH_SIZE      16
+#define DM_TRACKED_CHUNK_HASH(x)        ((unsigned long)(x) & \
+                                         (DM_TRACKED_CHUNK_HASH_SIZE - 1))
+
 struct dm_snapshot {
         struct rw_semaphore lock;
         struct dm_target *ti;
@@ -157,6 +161,8 @@ struct dm_snapshot {
         /* The last percentage we notified */
         int last_percent;
 
+        mempool_t *pending_pool;
+
         struct exception_table pending;
         struct exception_table complete;
 
@@ -174,6 +180,11 @@ struct dm_snapshot {
         /* Queue of snapshot writes for ksnapd to flush */
         struct bio_list queued_bios;
         struct work_struct queued_bios_work;
+
+        /* Chunks with outstanding reads */
+        mempool_t *tracked_chunk_pool;
+        spinlock_t tracked_chunk_lock;
+        struct hlist_head tracked_chunk_hash[DM_TRACKED_CHUNK_HASH_SIZE];
 };
 
 /*
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 94116eaf4709..798e468103b8 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -506,14 +506,13 @@ void dm_set_device_limits(struct dm_target *ti, struct block_device *bdev)
         rs->max_sectors =
                 min_not_zero(rs->max_sectors, q->max_sectors);
 
-        /* FIXME: Device-Mapper on top of RAID-0 breaks because DM
-         *        currently doesn't honor MD's merge_bvec_fn routine.
-         *        In this case, we'll force DM to use PAGE_SIZE or
-         *        smaller I/O, just to be safe. A better fix is in the
-         *        works, but add this for the time being so it will at
-         *        least operate correctly.
+        /*
+         * Check if merge fn is supported.
+         * If not we'll force DM to use PAGE_SIZE or
+         * smaller I/O, just to be safe.
          */
-        if (q->merge_bvec_fn)
+
+        if (q->merge_bvec_fn && !ti->type->merge)
                 rs->max_sectors =
                         min_not_zero(rs->max_sectors,
                                      (unsigned int) (PAGE_SIZE >> 9));
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 372369b1cc20..bca448e11878 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -37,8 +37,8 @@ static DEFINE_SPINLOCK(_minor_lock);
 struct dm_io {
         struct mapped_device *md;
         int error;
-        struct bio *bio;
         atomic_t io_count;
+        struct bio *bio;
         unsigned long start_time;
 };
 
@@ -829,6 +829,49 @@ static int __split_bio(struct mapped_device *md, struct bio *bio)
  * CRUD END
  *---------------------------------------------------------------*/
 
+static int dm_merge_bvec(struct request_queue *q,
+                         struct bvec_merge_data *bvm,
+                         struct bio_vec *biovec)
+{
+        struct mapped_device *md = q->queuedata;
+        struct dm_table *map = dm_get_table(md);
+        struct dm_target *ti;
+        sector_t max_sectors;
+        int max_size;
+
+        if (unlikely(!map))
+                return 0;
+
+        ti = dm_table_find_target(map, bvm->bi_sector);
+
+        /*
+         * Find maximum amount of I/O that won't need splitting
+         */
+        max_sectors = min(max_io_len(md, bvm->bi_sector, ti),
+                          (sector_t) BIO_MAX_SECTORS);
+        max_size = (max_sectors << SECTOR_SHIFT) - bvm->bi_size;
+        if (max_size < 0)
+                max_size = 0;
+
+        /*
+         * merge_bvec_fn() returns number of bytes
+         * it can accept at this offset
+         * max is precomputed maximal io size
+         */
+        if (max_size && ti->type->merge)
+                max_size = ti->type->merge(ti, bvm, biovec, max_size);
+
+        /*
+         * Always allow an entire first page
+         */
+        if (max_size <= biovec->bv_len && !(bvm->bi_size >> SECTOR_SHIFT))
+                max_size = biovec->bv_len;
+
+        dm_table_put(map);
+
+        return max_size;
+}
+
 /*
  * The request function that just remaps the bio built up by
  * dm_merge_bvec.
@@ -1032,6 +1075,7 @@ static struct mapped_device *alloc_dev(int minor)
         blk_queue_make_request(md->queue, dm_request);
         blk_queue_bounce_limit(md->queue, BLK_BOUNCE_ANY);
         md->queue->unplug_fn = dm_unplug_all;
+        blk_queue_merge_bvec(md->queue, dm_merge_bvec);
 
         md->io_pool = mempool_create_slab_pool(MIN_IOS, _io_cache);
         if (!md->io_pool)
diff --git a/drivers/md/dm.h b/drivers/md/dm.h
index 8c03b634e62e..1e59a0b0a78a 100644
--- a/drivers/md/dm.h
+++ b/drivers/md/dm.h
@@ -100,12 +100,6 @@ int dm_lock_for_deletion(struct mapped_device *md);
 
 void dm_kobject_uevent(struct mapped_device *md);
 
-/*
- * Dirty log
- */
-int dm_dirty_log_init(void);
-void dm_dirty_log_exit(void);
-
 int dm_kcopyd_init(void);
 void dm_kcopyd_exit(void);
 
diff --git a/drivers/md/faulty.c b/drivers/md/faulty.c
index d107ddceefcd..268547dbfbd3 100644
--- a/drivers/md/faulty.c
+++ b/drivers/md/faulty.c
@@ -297,7 +297,7 @@ static int run(mddev_t *mddev)
         rdev_for_each(rdev, tmp, mddev)
                 conf->rdev = rdev;
 
-        mddev->array_size = mddev->size;
+        mddev->array_sectors = mddev->size * 2;
         mddev->private = conf;
 
         reconfig(mddev, mddev->layout, -1);
diff --git a/drivers/md/linear.c b/drivers/md/linear.c
index 6a866d7c8ae5..b1eebf88c209 100644
--- a/drivers/md/linear.c
+++ b/drivers/md/linear.c
@@ -122,13 +122,13 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks)
                 return NULL;
 
         cnt = 0;
-        conf->array_size = 0;
+        conf->array_sectors = 0;
 
         rdev_for_each(rdev, tmp, mddev) {
                 int j = rdev->raid_disk;
                 dev_info_t *disk = conf->disks + j;
 
-                if (j < 0 || j > raid_disks || disk->rdev) {
+                if (j < 0 || j >= raid_disks || disk->rdev) {
                         printk("linear: disk numbering problem. Aborting!\n");
                         goto out;
                 }
@@ -146,7 +146,7 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks)
                         blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
 
                 disk->size = rdev->size;
-                conf->array_size += rdev->size;
+                conf->array_sectors += rdev->size * 2;
 
                 cnt++;
         }
@@ -155,7 +155,7 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks)
                 goto out;
         }
 
-        min_spacing = conf->array_size;
+        min_spacing = conf->array_sectors / 2;
         sector_div(min_spacing, PAGE_SIZE/sizeof(struct dev_info *));
 
         /* min_spacing is the minimum spacing that will fit the hash
@@ -164,7 +164,7 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks)
          * that is larger than min_spacing as use the size of that as
          * the actual spacing
          */
-        conf->hash_spacing = conf->array_size;
+        conf->hash_spacing = conf->array_sectors / 2;
         for (i=0; i < cnt-1 ; i++) {
                 sector_t sz = 0;
                 int j;
@@ -194,7 +194,7 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks)
                 unsigned round;
                 unsigned long base;
 
-                sz = conf->array_size >> conf->preshift;
+                sz = conf->array_sectors >> (conf->preshift + 1);
                 sz += 1; /* force round-up */
                 base = conf->hash_spacing >> conf->preshift;
                 round = sector_div(sz, base);
@@ -221,7 +221,7 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks)
         curr_offset = 0;
         i = 0;
         for (curr_offset = 0;
-             curr_offset < conf->array_size;
+             curr_offset < conf->array_sectors / 2;
              curr_offset += conf->hash_spacing) {
 
                 while (i < raid_disks-1 &&
@@ -258,7 +258,7 @@ static int linear_run (mddev_t *mddev)
         if (!conf)
                 return 1;
         mddev->private = conf;
-        mddev->array_size = conf->array_size;
+        mddev->array_sectors = conf->array_sectors;
 
         blk_queue_merge_bvec(mddev->queue, linear_mergeable_bvec);
         mddev->queue->unplug_fn = linear_unplug;
@@ -292,8 +292,8 @@ static int linear_add(mddev_t *mddev, mdk_rdev_t *rdev)
         newconf->prev = mddev_to_conf(mddev);
         mddev->private = newconf;
         mddev->raid_disks++;
-        mddev->array_size = newconf->array_size;
-        set_capacity(mddev->gendisk, mddev->array_size << 1);
+        mddev->array_sectors = newconf->array_sectors;
+        set_capacity(mddev->gendisk, mddev->array_sectors);
         return 0;
 }
 
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 2580ac1b9b0f..c2ff77ccec50 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -169,7 +169,6 @@ void md_new_event(mddev_t *mddev)
 {
         atomic_inc(&md_event_count);
         wake_up(&md_event_waiters);
-        sysfs_notify(&mddev->kobj, NULL, "sync_action");
 }
 EXPORT_SYMBOL_GPL(md_new_event);
 
@@ -274,10 +273,12 @@ static mddev_t * mddev_find(dev_t unit)
         INIT_LIST_HEAD(&new->all_mddevs);
         init_timer(&new->safemode_timer);
         atomic_set(&new->active, 1);
+        atomic_set(&new->openers, 0);
         spin_lock_init(&new->write_lock);
         init_waitqueue_head(&new->sb_wait);
         init_waitqueue_head(&new->recovery_wait);
         new->reshape_position = MaxSector;
+        new->resync_min = 0;
         new->resync_max = MaxSector;
         new->level = LEVEL_NONE;
 
@@ -347,21 +348,20 @@ static struct mdk_personality *find_pers(int level, char *clevel)
         return NULL;
 }
 
+/* return the offset of the super block in 512byte sectors */
 static inline sector_t calc_dev_sboffset(struct block_device *bdev)
 {
-        sector_t size = bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
-        return MD_NEW_SIZE_BLOCKS(size);
+        sector_t num_sectors = bdev->bd_inode->i_size / 512;
+        return MD_NEW_SIZE_SECTORS(num_sectors);
 }
 
-static sector_t calc_dev_size(mdk_rdev_t *rdev, unsigned chunk_size)
+static sector_t calc_num_sectors(mdk_rdev_t *rdev, unsigned chunk_size)
 {
-        sector_t size;
-
-        size = rdev->sb_offset;
+        sector_t num_sectors = rdev->sb_start;
 
         if (chunk_size)
-                size &= ~((sector_t)chunk_size/1024 - 1);
-        return size;
+                num_sectors &= ~((sector_t)chunk_size/512 - 1);
+        return num_sectors;
 }
 
 static int alloc_disk_sb(mdk_rdev_t * rdev)
@@ -372,7 +372,7 @@ static int alloc_disk_sb(mdk_rdev_t * rdev)
         rdev->sb_page = alloc_page(GFP_KERNEL);
         if (!rdev->sb_page) {
                 printk(KERN_ALERT "md: out of memory.\n");
-                return -EINVAL;
+                return -ENOMEM;
         }
 
         return 0;
@@ -384,7 +384,7 @@ static void free_disk_sb(mdk_rdev_t * rdev)
                 put_page(rdev->sb_page);
                 rdev->sb_loaded = 0;
                 rdev->sb_page = NULL;
-                rdev->sb_offset = 0;
+                rdev->sb_start = 0;
                 rdev->size = 0;
         }
 }
@@ -530,7 +530,7 @@ static int read_disk_sb(mdk_rdev_t * rdev, int size)
                 return 0;
 
 
-        if (!sync_page_io(rdev->bdev, rdev->sb_offset<<1, size, rdev->sb_page, READ))
+        if (!sync_page_io(rdev->bdev, rdev->sb_start, size, rdev->sb_page, READ))
                 goto fail;
         rdev->sb_loaded = 1;
         return 0;
@@ -543,17 +543,12 @@ fail:
 
 static int uuid_equal(mdp_super_t *sb1, mdp_super_t *sb2)
 {
-        if (    (sb1->set_uuid0 == sb2->set_uuid0) &&
-                (sb1->set_uuid1 == sb2->set_uuid1) &&
-                (sb1->set_uuid2 == sb2->set_uuid2) &&
-                (sb1->set_uuid3 == sb2->set_uuid3))
-
-                return 1;
-
-        return 0;
+        return  sb1->set_uuid0 == sb2->set_uuid0 &&
+                sb1->set_uuid1 == sb2->set_uuid1 &&
+                sb1->set_uuid2 == sb2->set_uuid2 &&
+                sb1->set_uuid3 == sb2->set_uuid3;
 }
 
-
 static int sb_equal(mdp_super_t *sb1, mdp_super_t *sb2)
 {
         int ret;
@@ -564,7 +559,7 @@ static int sb_equal(mdp_super_t *sb1, mdp_super_t *sb2)
 
         if (!tmp1 || !tmp2) {
                 ret = 0;
-                printk(KERN_INFO "md.c: sb1 is not equal to sb2!\n");
+                printk(KERN_INFO "md.c sb_equal(): failed to allocate memory!\n");
                 goto abort;
         }
 
@@ -577,11 +572,7 @@ static int sb_equal(mdp_super_t *sb1, mdp_super_t *sb2)
         tmp1->nr_disks = 0;
         tmp2->nr_disks = 0;
 
-        if (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4))
-                ret = 0;
-        else
-                ret = 1;
-
+        ret = (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4) == 0);
 abort:
         kfree(tmp1);
         kfree(tmp2);
@@ -658,11 +649,14 @@ static unsigned int calc_sb_csum(mdp_super_t * sb)
  */
 
 struct super_type  {
-        char            *name;
-        struct module   *owner;
-        int             (*load_super)(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version);
-        int             (*validate_super)(mddev_t *mddev, mdk_rdev_t *rdev);
-        void            (*sync_super)(mddev_t *mddev, mdk_rdev_t *rdev);
+        char                *name;
+        struct module       *owner;
+        int                 (*load_super)(mdk_rdev_t *rdev, mdk_rdev_t *refdev,
+                                          int minor_version);
+        int                 (*validate_super)(mddev_t *mddev, mdk_rdev_t *rdev);
+        void                (*sync_super)(mddev_t *mddev, mdk_rdev_t *rdev);
+        unsigned long long  (*rdev_size_change)(mdk_rdev_t *rdev,
+                                                sector_t num_sectors);
 };
 
 /*
@@ -673,16 +667,14 @@ static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version
         char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
         mdp_super_t *sb;
         int ret;
-        sector_t sb_offset;
 
         /*
-         * Calculate the position of the superblock,
+         * Calculate the position of the superblock (512byte sectors),
          * it's at the end of the disk.
          *
          * It also happens to be a multiple of 4Kb.
          */
-        sb_offset = calc_dev_sboffset(rdev->bdev);
-        rdev->sb_offset = sb_offset;
+        rdev->sb_start = calc_dev_sboffset(rdev->bdev);
 
         ret = read_disk_sb(rdev, MD_SB_BYTES);
         if (ret) return ret;
@@ -759,7 +751,7 @@ static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version
                 else 
                         ret = 0;
         }
-        rdev->size = calc_dev_size(rdev, sb->chunk_size);
+        rdev->size = calc_num_sectors(rdev, sb->chunk_size) / 2;
 
         if (rdev->size < sb->size && sb->level > 1)
                 /* "this cannot possibly happen" ... */
@@ -1004,6 +996,26 @@ static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev)
 }
 
 /*
+ * rdev_size_change for 0.90.0
+ */
+static unsigned long long
+super_90_rdev_size_change(mdk_rdev_t *rdev, sector_t num_sectors)
+{
+        if (num_sectors && num_sectors < rdev->mddev->size * 2)
+                return 0; /* component must fit device */
+        if (rdev->mddev->bitmap_offset)
+                return 0; /* can't move bitmap */
+        rdev->sb_start = calc_dev_sboffset(rdev->bdev);
+        if (!num_sectors || num_sectors > rdev->sb_start)
+                num_sectors = rdev->sb_start;
+        md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
+                       rdev->sb_page);
+        md_super_wait(rdev->mddev);
+        return num_sectors / 2; /* kB for sysfs */
+}
+
+
+/*
  * version 1 superblock
  */
 
@@ -1034,12 +1046,12 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
 {
         struct mdp_superblock_1 *sb;
         int ret;
-        sector_t sb_offset;
+        sector_t sb_start;
         char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
         int bmask;
 
         /*
-         * Calculate the position of the superblock.
+         * Calculate the position of the superblock in 512byte sectors.
          * It is always aligned to a 4K boundary and
          * depeding on minor_version, it can be:
          * 0: At least 8K, but less than 12K, from end of device
@@ -1048,22 +1060,20 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
          */
         switch(minor_version) {
         case 0:
-                sb_offset = rdev->bdev->bd_inode->i_size >> 9;
-                sb_offset -= 8*2;
-                sb_offset &= ~(sector_t)(4*2-1);
-                /* convert from sectors to K */
-                sb_offset /= 2;
+                sb_start = rdev->bdev->bd_inode->i_size >> 9;
+                sb_start -= 8*2;
+                sb_start &= ~(sector_t)(4*2-1);
                 break;
         case 1:
-                sb_offset = 0;
+                sb_start = 0;
                 break;
         case 2:
-                sb_offset = 4;
+                sb_start = 8;
                 break;
         default:
                 return -EINVAL;
         }
-        rdev->sb_offset = sb_offset;
+        rdev->sb_start = sb_start;
 
         /* superblock is rarely larger than 1K, but it can be larger,
          * and it is safe to read 4k, so we do that
@@ -1077,7 +1087,7 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
         if (sb->magic != cpu_to_le32(MD_SB_MAGIC) ||
             sb->major_version != cpu_to_le32(1) ||
             le32_to_cpu(sb->max_dev) > (4096-256)/2 ||
-            le64_to_cpu(sb->super_offset) != (rdev->sb_offset<<1) ||
+            le64_to_cpu(sb->super_offset) != rdev->sb_start ||
             (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)
                 return -EINVAL;
 
@@ -1113,7 +1123,7 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
                 rdev->sb_size = (rdev->sb_size | bmask) + 1;
 
         if (minor_version
-            && rdev->data_offset < sb_offset + (rdev->sb_size/512))
+            && rdev->data_offset < sb_start + (rdev->sb_size/512))
                 return -EINVAL;
 
         if (sb->level == cpu_to_le32(LEVEL_MULTIPATH))
@@ -1149,7 +1159,7 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
         if (minor_version)
                 rdev->size = ((rdev->bdev->bd_inode->i_size>>9) - le64_to_cpu(sb->data_offset)) / 2;
         else
-                rdev->size = rdev->sb_offset;
+                rdev->size = rdev->sb_start / 2;
         if (rdev->size < le64_to_cpu(sb->data_size)/2)
                 return -EINVAL;
         rdev->size = le64_to_cpu(sb->data_size)/2;
@@ -1328,35 +1338,74 @@ static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
         sb->sb_csum = calc_sb_1_csum(sb);
 }
 
+static unsigned long long
+super_1_rdev_size_change(mdk_rdev_t *rdev, sector_t num_sectors)
+{
+        struct mdp_superblock_1 *sb;
+        sector_t max_sectors;
+        if (num_sectors && num_sectors < rdev->mddev->size * 2)
+                return 0; /* component must fit device */
+        if (rdev->sb_start < rdev->data_offset) {
+                /* minor versions 1 and 2; superblock before data */
+                max_sectors = rdev->bdev->bd_inode->i_size >> 9;
+                max_sectors -= rdev->data_offset;
+                if (!num_sectors || num_sectors > max_sectors)
+                        num_sectors = max_sectors;
+        } else if (rdev->mddev->bitmap_offset) {
+                /* minor version 0 with bitmap we can't move */
+                return 0;
+        } else {
+                /* minor version 0; superblock after data */
+                sector_t sb_start;
+                sb_start = (rdev->bdev->bd_inode->i_size >> 9) - 8*2;
+                sb_start &= ~(sector_t)(4*2 - 1);
+                max_sectors = rdev->size * 2 + sb_start - rdev->sb_start;
+                if (!num_sectors || num_sectors > max_sectors)
+                        num_sectors = max_sectors;
+                rdev->sb_start = sb_start;
+        }
+        sb = (struct mdp_superblock_1 *) page_address(rdev->sb_page);
+        sb->data_size = cpu_to_le64(num_sectors);
+        sb->super_offset = rdev->sb_start;
+        sb->sb_csum = calc_sb_1_csum(sb);
+        md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
+                       rdev->sb_page);
+        md_super_wait(rdev->mddev);
+        return num_sectors / 2; /* kB for sysfs */
+}
 
 static struct super_type super_types[] = {
         [0] = {
                 .name   = "0.90.0",
                 .owner  = THIS_MODULE,
-                .load_super     = super_90_load,
-                .validate_super = super_90_validate,
-                .sync_super     = super_90_sync,
+                .load_super         = super_90_load,
+                .validate_super     = super_90_validate,
+                .sync_super         = super_90_sync,
+                .rdev_size_change   = super_90_rdev_size_change,
         },
         [1] = {
                 .name   = "md-1",
                 .owner  = THIS_MODULE,
-                .load_super     = super_1_load,
-                .validate_super = super_1_validate,
-                .sync_super     = super_1_sync,
+                .load_super         = super_1_load,
+                .validate_super     = super_1_validate,
+                .sync_super         = super_1_sync,
+                .rdev_size_change   = super_1_rdev_size_change,
         },
 };
 
 static int match_mddev_units(mddev_t *mddev1, mddev_t *mddev2)
 {
-        struct list_head *tmp, *tmp2;
         mdk_rdev_t *rdev, *rdev2;
 
-        rdev_for_each(rdev, tmp, mddev1)
-                rdev_for_each(rdev2, tmp2, mddev2)
+        rcu_read_lock();
+        rdev_for_each_rcu(rdev, mddev1)
+                rdev_for_each_rcu(rdev2, mddev2)
                         if (rdev->bdev->bd_contains ==
-                            rdev2->bdev->bd_contains)
+                            rdev2->bdev->bd_contains) {
+                                rcu_read_unlock();
                                 return 1;
-
+                        }
+        rcu_read_unlock();
         return 0;
 }
 
@@ -1423,7 +1472,7 @@ static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
                 kobject_del(&rdev->kobj);
                 goto fail;
         }
-        list_add(&rdev->same_set, &mddev->disks);
+        list_add_rcu(&rdev->same_set, &mddev->disks);
         bd_claim_by_disk(rdev->bdev, rdev->bdev->bd_holder, mddev->gendisk);
         return 0;
 
@@ -1448,14 +1497,16 @@ static void unbind_rdev_from_array(mdk_rdev_t * rdev)
                 return;
         }
         bd_release_from_disk(rdev->bdev, rdev->mddev->gendisk);
-        list_del_init(&rdev->same_set);
+        list_del_rcu(&rdev->same_set);
         printk(KERN_INFO "md: unbind<%s>\n", bdevname(rdev->bdev,b));
         rdev->mddev = NULL;
         sysfs_remove_link(&rdev->kobj, "block");
 
         /* We need to delay this, otherwise we can deadlock when
-         * writing to 'remove' to "dev/state"
+         * writing to 'remove' to "dev/state".  We also need
+         * to delay it due to rcu usage.
          */
+        synchronize_rcu();
         INIT_WORK(&rdev->del_work, md_delayed_delete);
         kobject_get(&rdev->kobj);
         schedule_work(&rdev->del_work);
@@ -1511,7 +1562,6 @@ static void export_rdev(mdk_rdev_t * rdev)
         if (rdev->mddev)
                 MD_BUG();
         free_disk_sb(rdev);
-        list_del_init(&rdev->same_set);
 #ifndef MODULE
         if (test_bit(AutoDetected, &rdev->flags))
                 md_autodetect_dev(rdev->bdev->bd_dev);
@@ -1758,11 +1808,11 @@ repeat:
                 dprintk("%s ", bdevname(rdev->bdev,b));
                 if (!test_bit(Faulty, &rdev->flags)) {
                         md_super_write(mddev,rdev,
-                                       rdev->sb_offset<<1, rdev->sb_size,
+                                       rdev->sb_start, rdev->sb_size,
                                        rdev->sb_page);
                         dprintk(KERN_INFO "(write) %s's sb offset: %llu\n",
                                 bdevname(rdev->bdev,b),
-                                (unsigned long long)rdev->sb_offset);
+                                (unsigned long long)rdev->sb_start);
                         rdev->sb_events = mddev->events;
 
                 } else
@@ -1787,7 +1837,7 @@ repeat:
 
 }
 
-/* words written to sysfs files may, or my not, be \n terminated.
+/* words written to sysfs files may, or may not, be \n terminated.
  * We want to accept with case. For this we use cmd_match.
  */
 static int cmd_match(const char *cmd, const char *str)
@@ -1886,6 +1936,8 @@ state_store(mdk_rdev_t *rdev, const char *buf, size_t len)
 
                 err = 0;
         }
+        if (!err)
+                sysfs_notify(&rdev->kobj, NULL, "state");
         return err ? err : len;
 }
 static struct rdev_sysfs_entry rdev_state =
@@ -1931,7 +1983,7 @@ slot_store(mdk_rdev_t *rdev, const char *buf, size_t len)
                 slot = -1;
         else if (e==buf || (*e && *e!= '\n'))
                 return -EINVAL;
-        if (rdev->mddev->pers) {
+        if (rdev->mddev->pers && slot == -1) {
                 /* Setting 'slot' on an active array requires also
                  * updating the 'rd%d' link, and communicating
                  * with the personality with ->hot_*_disk.
@@ -1939,8 +1991,6 @@ slot_store(mdk_rdev_t *rdev, const char *buf, size_t len)
                  * failed/spare devices.  This normally happens automatically,
                  * but not when the metadata is externally managed.
                  */
-                if (slot != -1)
-                        return -EBUSY;
                 if (rdev->raid_disk == -1)
                         return -EEXIST;
                 /* personality does all needed checks */
@@ -1954,6 +2004,43 @@ slot_store(mdk_rdev_t *rdev, const char *buf, size_t len)
                 sysfs_remove_link(&rdev->mddev->kobj, nm);
                 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
                 md_wakeup_thread(rdev->mddev->thread);
+        } else if (rdev->mddev->pers) {
+                mdk_rdev_t *rdev2;
+                struct list_head *tmp;
+                /* Activating a spare .. or possibly reactivating
+                 * if we every get bitmaps working here.
+                 */
+
+                if (rdev->raid_disk != -1)
+                        return -EBUSY;
+
+                if (rdev->mddev->pers->hot_add_disk == NULL)
+                        return -EINVAL;
+
+                rdev_for_each(rdev2, tmp, rdev->mddev)
+                        if (rdev2->raid_disk == slot)
+                                return -EEXIST;
+
+                rdev->raid_disk = slot;
+                if (test_bit(In_sync, &rdev->flags))
+                        rdev->saved_raid_disk = slot;
+                else
+                        rdev->saved_raid_disk = -1;
+                err = rdev->mddev->pers->
+                        hot_add_disk(rdev->mddev, rdev);
+                if (err) {
+                        rdev->raid_disk = -1;
+                        return err;
+                } else
+                        sysfs_notify(&rdev->kobj, NULL, "state");
+                sprintf(nm, "rd%d", rdev->raid_disk);
+                if (sysfs_create_link(&rdev->mddev->kobj, &rdev->kobj, nm))
+                        printk(KERN_WARNING
+                               "md: cannot register "
+                               "%s for %s\n",
+                               nm, mdname(rdev->mddev));
+
+                /* don't wakeup anyone, leave that to userspace. */
         } else {
                 if (slot >= rdev->mddev->raid_disks)
                         return -ENOSPC;
@@ -1962,6 +2049,7 @@ slot_store(mdk_rdev_t *rdev, const char *buf, size_t len)
                 clear_bit(Faulty, &rdev->flags);
                 clear_bit(WriteMostly, &rdev->flags);
                 set_bit(In_sync, &rdev->flags);
+                sysfs_notify(&rdev->kobj, NULL, "state");
         }
         return len;
 }
@@ -1983,7 +2071,7 @@ offset_store(mdk_rdev_t *rdev, const char *buf, size_t len)
         unsigned long long offset = simple_strtoull(buf, &e, 10);
         if (e==buf || (*e && *e != '\n'))
                 return -EINVAL;
-        if (rdev->mddev->pers)
+        if (rdev->mddev->pers && rdev->raid_disk >= 0)
                 return -EBUSY;
         if (rdev->size && rdev->mddev->external)
                 /* Must set offset before size, so overlap checks
@@ -2015,17 +2103,30 @@ static int overlaps(sector_t s1, sector_t l1, sector_t s2, sector_t l2)
 static ssize_t
 rdev_size_store(mdk_rdev_t *rdev, const char *buf, size_t len)
 {
-        char *e;
-        unsigned long long size = simple_strtoull(buf, &e, 10);
+        unsigned long long size;
         unsigned long long oldsize = rdev->size;
         mddev_t *my_mddev = rdev->mddev;
 
-        if (e==buf || (*e && *e != '\n'))
+        if (strict_strtoull(buf, 10, &size) < 0)
                 return -EINVAL;
-        if (my_mddev->pers)
-                return -EBUSY;
+        if (size < my_mddev->size)
+                return -EINVAL;
+        if (my_mddev->pers && rdev->raid_disk >= 0) {
+                if (my_mddev->persistent) {
+                        size = super_types[my_mddev->major_version].
+                                rdev_size_change(rdev, size * 2);
+                        if (!size)
+                                return -EBUSY;
+                } else if (!size) {
+                        size = (rdev->bdev->bd_inode->i_size >> 10);
+                        size -= rdev->data_offset/2;
+                }
+                if (size < my_mddev->size)
+                        return -EINVAL; /* component must fit device */
+        }
+
         rdev->size = size;
-        if (size > oldsize && rdev->mddev->external) {
+        if (size > oldsize && my_mddev->external) {
                 /* need to check that all other rdevs with the same ->bdev
                  * do not overlap.  We need to unlock the mddev to avoid
                  * a deadlock.  We have already changed rdev->size, and if
@@ -2044,8 +2145,9 @@ rdev_size_store(mdk_rdev_t *rdev, const char *buf, size_t len)
                                 if (test_bit(AllReserved, &rdev2->flags) ||
                                     (rdev->bdev == rdev2->bdev &&
                                      rdev != rdev2 &&
-                                     overlaps(rdev->data_offset, rdev->size,
-                                            rdev2->data_offset, rdev2->size))) {
+                                     overlaps(rdev->data_offset, rdev->size * 2,
+                                              rdev2->data_offset,
+                                              rdev2->size * 2))) {
                                         overlap = 1;
                                         break;
                                 }
@@ -2067,8 +2169,6 @@ rdev_size_store(mdk_rdev_t *rdev, const char *buf, size_t len)
                         return -EBUSY;
                 }
         }
-        if (size < my_mddev->size || my_mddev->size == 0)
-                my_mddev->size = size;
         return len;
 }
 
@@ -2512,7 +2612,7 @@ __ATTR(resync_start, S_IRUGO|S_IWUSR, resync_start_show, resync_start_store);
  *     When written, doesn't tear down array, but just stops it
  * suspended (not supported yet)
  *     All IO requests will block. The array can be reconfigured.
- *     Writing this, if accepted, will block until array is quiessent
+ *     Writing this, if accepted, will block until array is quiescent
  * readonly
  *     no resync can happen.  no superblocks get written.
  *     write requests fail
@@ -2585,7 +2685,7 @@ array_state_show(mddev_t *mddev, char *page)
         return sprintf(page, "%s\n", array_states[st]);
 }
 
-static int do_md_stop(mddev_t * mddev, int ro);
+static int do_md_stop(mddev_t * mddev, int ro, int is_open);
 static int do_md_run(mddev_t * mddev);
 static int restart_array(mddev_t *mddev);
 
@@ -2599,16 +2699,16 @@ array_state_store(mddev_t *mddev, const char *buf, size_t len)
                 break;
         case clear:
                 /* stopping an active array */
-                if (atomic_read(&mddev->active) > 1)
+                if (atomic_read(&mddev->openers) > 0)
                         return -EBUSY;
-                err = do_md_stop(mddev, 0);
+                err = do_md_stop(mddev, 0, 0);
                 break;
         case inactive:
                 /* stopping an active array */
                 if (mddev->pers) {
-                        if (atomic_read(&mddev->active) > 1)
+                        if (atomic_read(&mddev->openers) > 0)
                                 return -EBUSY;
-                        err = do_md_stop(mddev, 2);
+                        err = do_md_stop(mddev, 2, 0);
                 } else
                         err = 0; /* already inactive */
                 break;
@@ -2616,7 +2716,7 @@ array_state_store(mddev_t *mddev, const char *buf, size_t len)
                 break; /* not supported yet */
         case readonly:
                 if (mddev->pers)
-                        err = do_md_stop(mddev, 1);
+                        err = do_md_stop(mddev, 1, 0);
                 else {
                         mddev->ro = 1;
                         set_disk_ro(mddev->gendisk, 1);
@@ -2626,7 +2726,7 @@ array_state_store(mddev_t *mddev, const char *buf, size_t len)
         case read_auto:
                 if (mddev->pers) {
                         if (mddev->ro != 1)
-                                err = do_md_stop(mddev, 1);
+                                err = do_md_stop(mddev, 1, 0);
                         else
                                 err = restart_array(mddev);
                         if (err == 0) {
@@ -2681,8 +2781,10 @@ array_state_store(mddev_t *mddev, const char *buf, size_t len)
         }
         if (err)
                 return err;
-        else
+        else {
+                sysfs_notify(&mddev->kobj, NULL, "array_state");
                 return len;
+        }
 }
 static struct md_sysfs_entry md_array_state =
 __ATTR(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store);
@@ -2785,7 +2887,7 @@ size_show(mddev_t *mddev, char *page)
         return sprintf(page, "%llu\n", (unsigned long long)mddev->size);
 }
 
-static int update_size(mddev_t *mddev, unsigned long size);
+static int update_size(mddev_t *mddev, sector_t num_sectors);
 
 static ssize_t
 size_store(mddev_t *mddev, const char *buf, size_t len)
@@ -2802,7 +2904,7 @@ size_store(mddev_t *mddev, const char *buf, size_t len)
                 return -EINVAL;
 
         if (mddev->pers) {
-                err = update_size(mddev, size);
+                err = update_size(mddev, size * 2);
                 md_update_sb(mddev, 1);
         } else {
                 if (mddev->size == 0 ||
@@ -2899,7 +3001,7 @@ action_show(mddev_t *mddev, char *page)
                                 type = "check";
                         else
                                 type = "repair";
-                } else
+                } else if (test_bit(MD_RECOVERY_RECOVER, &mddev->recovery))
                         type = "recover";
         }
         return sprintf(page, "%s\n", type);
@@ -2921,15 +3023,19 @@ action_store(mddev_t *mddev, const char *page, size_t len)
         } else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
                    test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
                 return -EBUSY;
-        else if (cmd_match(page, "resync") || cmd_match(page, "recover"))
+        else if (cmd_match(page, "resync"))
+                set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
+        else if (cmd_match(page, "recover")) {
+                set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
-        else if (cmd_match(page, "reshape")) {
+        } else if (cmd_match(page, "reshape")) {
                 int err;
                 if (mddev->pers->start_reshape == NULL)
                         return -EINVAL;
                 err = mddev->pers->start_reshape(mddev);
                 if (err)
                         return err;
+                sysfs_notify(&mddev->kobj, NULL, "degraded");
         } else {
                 if (cmd_match(page, "check"))
                         set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
@@ -2940,6 +3046,7 @@ action_store(mddev_t *mddev, const char *page, size_t len)
         }
         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
         md_wakeup_thread(mddev->thread);
+        sysfs_notify(&mddev->kobj, NULL, "sync_action");
         return len;
 }
 
@@ -3049,11 +3156,11 @@ static ssize_t
 sync_speed_show(mddev_t *mddev, char *page)
 {
         unsigned long resync, dt, db;
-        resync = (mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active));
-        dt = ((jiffies - mddev->resync_mark) / HZ);
+        resync = mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active);
+        dt = (jiffies - mddev->resync_mark) / HZ;
         if (!dt) dt++;
-        db = resync - (mddev->resync_mark_cnt);
-        return sprintf(page, "%ld\n", db/dt/2); /* K/sec */
+        db = resync - mddev->resync_mark_cnt;
+        return sprintf(page, "%lu\n", db/dt/2); /* K/sec */
 }
 
 static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed);
@@ -3075,6 +3182,36 @@ sync_completed_show(mddev_t *mddev, char *page)
 static struct md_sysfs_entry md_sync_completed = __ATTR_RO(sync_completed);
 
 static ssize_t
+min_sync_show(mddev_t *mddev, char *page)
+{
+        return sprintf(page, "%llu\n",
+                       (unsigned long long)mddev->resync_min);
+}
+static ssize_t
+min_sync_store(mddev_t *mddev, const char *buf, size_t len)
+{
+        unsigned long long min;
+        if (strict_strtoull(buf, 10, &min))
+                return -EINVAL;
+        if (min > mddev->resync_max)
+                return -EINVAL;
+        if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
+                return -EBUSY;
+
+        /* Must be a multiple of chunk_size */
+        if (mddev->chunk_size) {
+                if (min & (sector_t)((mddev->chunk_size>>9)-1))
+                        return -EINVAL;
+        }
+        mddev->resync_min = min;
+
+        return len;
+}
+
+static struct md_sysfs_entry md_min_sync =
+__ATTR(sync_min, S_IRUGO|S_IWUSR, min_sync_show, min_sync_store);
+
+static ssize_t
 max_sync_show(mddev_t *mddev, char *page)
 {
         if (mddev->resync_max == MaxSector)
@@ -3089,9 +3226,10 @@ max_sync_store(mddev_t *mddev, const char *buf, size_t len)
         if (strncmp(buf, "max", 3) == 0)
                 mddev->resync_max = MaxSector;
         else {
-                char *ep;
-                unsigned long long max = simple_strtoull(buf, &ep, 10);
-                if (ep == buf || (*ep != 0 && *ep != '\n'))
+                unsigned long long max;
+                if (strict_strtoull(buf, 10, &max))
+                        return -EINVAL;
+                if (max < mddev->resync_min)
                         return -EINVAL;
                 if (max < mddev->resync_max &&
                     test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
@@ -3222,6 +3360,7 @@ static struct attribute *md_redundancy_attrs[] = {
         &md_sync_speed.attr,
         &md_sync_force_parallel.attr,
         &md_sync_completed.attr,
+        &md_min_sync.attr,
         &md_max_sync.attr,
         &md_suspend_lo.attr,
         &md_suspend_hi.attr,
@@ -3326,9 +3465,9 @@ static struct kobject *md_probe(dev_t dev, int *part, void *data)
         disk->queue = mddev->queue;
         add_disk(disk);
         mddev->gendisk = disk;
-        mutex_unlock(&disks_mutex);
         error = kobject_init_and_add(&mddev->kobj, &md_ktype, &disk->dev.kobj,
                                      "%s", "md");
+        mutex_unlock(&disks_mutex);
         if (error)
                 printk(KERN_WARNING "md: cannot register %s/md - name in use\n",
                        disk->disk_name);
@@ -3341,7 +3480,11 @@ static void md_safemode_timeout(unsigned long data)
 {
         mddev_t *mddev = (mddev_t *) data;
 
-        mddev->safemode = 1;
+        if (!atomic_read(&mddev->writes_pending)) {
+                mddev->safemode = 1;
+                if (mddev->external)
+                        sysfs_notify(&mddev->kobj, NULL, "array_state");
+        }
         md_wakeup_thread(mddev->thread);
 }
 
@@ -3432,22 +3575,23 @@ static int do_md_run(mddev_t * mddev)
                  * We don't want the data to overlap the metadata,
                  * Internal Bitmap issues has handled elsewhere.
                  */
-                if (rdev->data_offset < rdev->sb_offset) {
+                if (rdev->data_offset < rdev->sb_start) {
                         if (mddev->size &&
                             rdev->data_offset + mddev->size*2
-                            > rdev->sb_offset*2) {
+                            > rdev->sb_start) {
                                 printk("md: %s: data overlaps metadata\n",
                                        mdname(mddev));
                                 return -EINVAL;
                         }
                 } else {
-                        if (rdev->sb_offset*2 + rdev->sb_size/512
+                        if (rdev->sb_start + rdev->sb_size/512
                             > rdev->data_offset) {
                                 printk("md: %s: metadata overlaps data\n",
                                        mdname(mddev));
                                 return -EINVAL;
                         }
                 }
+                sysfs_notify(&rdev->kobj, NULL, "state");
         }
 
         md_probe(mddev->unit, NULL, NULL);
@@ -3519,7 +3663,9 @@ static int do_md_run(mddev_t * mddev)
                 mddev->ro = 2; /* read-only, but switch on first write */
 
         err = mddev->pers->run(mddev);
-        if (!err && mddev->pers->sync_request) {
+        if (err)
+                printk(KERN_ERR "md: pers->run() failed ...\n");
+        else if (mddev->pers->sync_request) {
                 err = bitmap_create(mddev);
                 if (err) {
                         printk(KERN_ERR "%s: failed to create bitmap (%d)\n",
@@ -3528,7 +3674,6 @@ static int do_md_run(mddev_t * mddev)
                 }
         }
         if (err) {
-                printk(KERN_ERR "md: pers->run() failed ...\n");
                 module_put(mddev->pers->owner);
                 mddev->pers = NULL;
                 bitmap_destroy(mddev);
@@ -3563,7 +3708,7 @@ static int do_md_run(mddev_t * mddev)
         if (mddev->flags)
                 md_update_sb(mddev, 0);
 
-        set_capacity(disk, mddev->array_size<<1);
+        set_capacity(disk, mddev->array_sectors);
 
         /* If we call blk_queue_make_request here, it will
          * re-initialise max_sectors etc which may have been
@@ -3608,6 +3753,9 @@ static int do_md_run(mddev_t * mddev)
 
         mddev->changed = 1;
         md_new_event(mddev);
+        sysfs_notify(&mddev->kobj, NULL, "array_state");
+        sysfs_notify(&mddev->kobj, NULL, "sync_action");
+        sysfs_notify(&mddev->kobj, NULL, "degraded");
         kobject_uevent(&mddev->gendisk->dev.kobj, KOBJ_CHANGE);
         return 0;
 }
@@ -3615,38 +3763,25 @@ static int do_md_run(mddev_t * mddev)
 static int restart_array(mddev_t *mddev)
 {
         struct gendisk *disk = mddev->gendisk;
-        int err;
 
-        /*
-         * Complain if it has no devices
-         */
-        err = -ENXIO;
+        /* Complain if it has no devices */
         if (list_empty(&mddev->disks))
-                goto out;
-
-        if (mddev->pers) {
-                err = -EBUSY;
-                if (!mddev->ro)
-                        goto out;
-
-                mddev->safemode = 0;
-                mddev->ro = 0;
-                set_disk_ro(disk, 0);
-
-                printk(KERN_INFO "md: %s switched to read-write mode.\n",
-                        mdname(mddev));
-                /*
-                 * Kick recovery or resync if necessary
-                 */
-                set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
-                md_wakeup_thread(mddev->thread);
-                md_wakeup_thread(mddev->sync_thread);
-                err = 0;
-        } else
-                err = -EINVAL;
-
-out:
-        return err;
+                return -ENXIO;
+        if (!mddev->pers)
+                return -EINVAL;
+        if (!mddev->ro)
+                return -EBUSY;
+        mddev->safemode = 0;
+        mddev->ro = 0;
+        set_disk_ro(disk, 0);
+        printk(KERN_INFO "md: %s switched to read-write mode.\n",
+                mdname(mddev));
+        /* Kick recovery or resync if necessary */
+        set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
+        md_wakeup_thread(mddev->thread);
+        md_wakeup_thread(mddev->sync_thread);
+        sysfs_notify(&mddev->kobj, NULL, "array_state");
+        return 0;
 }
 
 /* similar to deny_write_access, but accounts for our holding a reference
@@ -3680,16 +3815,17 @@ static void restore_bitmap_write_access(struct file *file)
  *   1 - switch to readonly
  *   2 - stop but do not disassemble array
  */
-static int do_md_stop(mddev_t * mddev, int mode)
+static int do_md_stop(mddev_t * mddev, int mode, int is_open)
 {
         int err = 0;
         struct gendisk *disk = mddev->gendisk;
 
+        if (atomic_read(&mddev->openers) > is_open) {
+                printk("md: %s still in use.\n",mdname(mddev));
+                return -EBUSY;
+        }
+
         if (mddev->pers) {
-                if (atomic_read(&mddev->active)>2) {
-                        printk("md: %s still in use.\n",mdname(mddev));
-                        return -EBUSY;
-                }
 
                 if (mddev->sync_thread) {
                         set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
@@ -3773,10 +3909,11 @@ static int do_md_stop(mddev_t * mddev, int mode)
 
                 export_array(mddev);
 
-                mddev->array_size = 0;
+                mddev->array_sectors = 0;
                 mddev->size = 0;
                 mddev->raid_disks = 0;
                 mddev->recovery_cp = 0;
+                mddev->resync_min = 0;
                 mddev->resync_max = MaxSector;
                 mddev->reshape_position = MaxSector;
                 mddev->external = 0;
@@ -3811,6 +3948,7 @@ static int do_md_stop(mddev_t * mddev, int mode)
                         mdname(mddev));
         err = 0;
         md_new_event(mddev);
+        sysfs_notify(&mddev->kobj, NULL, "array_state");
 out:
         return err;
 }
@@ -3836,7 +3974,7 @@ static void autorun_array(mddev_t *mddev)
         err = do_md_run (mddev);
         if (err) {
                 printk(KERN_WARNING "md: do_md_run() returned %d\n", err);
-                do_md_stop (mddev, 0);
+                do_md_stop (mddev, 0, 0);
         }
 }
 
@@ -3927,8 +4065,10 @@ static void autorun_devices(int part)
                 /* on success, candidates will be empty, on error
                  * it won't...
                  */
-                rdev_for_each_list(rdev, tmp, candidates)
+                rdev_for_each_list(rdev, tmp, candidates) {
+                        list_del_init(&rdev->same_set);
                         export_rdev(rdev);
+                }
                 mddev_put(mddev);
         }
         printk(KERN_INFO "md: ... autorun DONE.\n");
@@ -4009,9 +4149,11 @@ static int get_bitmap_file(mddev_t * mddev, void __user * arg)
         char *ptr, *buf = NULL;
         int err = -ENOMEM;
 
-        md_allow_write(mddev);
+        if (md_allow_write(mddev))
+                file = kmalloc(sizeof(*file), GFP_NOIO);
+        else
+                file = kmalloc(sizeof(*file), GFP_KERNEL);
 
-        file = kmalloc(sizeof(*file), GFP_KERNEL);
         if (!file)
                 goto out;
 
@@ -4044,15 +4186,12 @@ out:
 static int get_disk_info(mddev_t * mddev, void __user * arg)
 {
         mdu_disk_info_t info;
-        unsigned int nr;
         mdk_rdev_t *rdev;
 
         if (copy_from_user(&info, arg, sizeof(info)))
                 return -EFAULT;
 
-        nr = info.number;
-
-        rdev = find_rdev_nr(mddev, nr);
+        rdev = find_rdev_nr(mddev, info.number);
         if (rdev) {
                 info.major = MAJOR(rdev->bdev->bd_dev);
                 info.minor = MINOR(rdev->bdev->bd_dev);
@@ -4172,8 +4311,12 @@ static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info)
                 }
                 if (err)
                         export_rdev(rdev);
+                else
+                        sysfs_notify(&rdev->kobj, NULL, "state");
 
                 md_update_sb(mddev, 1);
+                if (mddev->degraded)
+                        set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
                 md_wakeup_thread(mddev->thread);
                 return err;
@@ -4212,10 +4355,10 @@ static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info)
 
                 if (!mddev->persistent) {
                         printk(KERN_INFO "md: nonpersistent superblock ...\n");
-                        rdev->sb_offset = rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
+                        rdev->sb_start = rdev->bdev->bd_inode->i_size / 512;
                 } else 
-                        rdev->sb_offset = calc_dev_sboffset(rdev->bdev);
-                rdev->size = calc_dev_size(rdev, mddev->chunk_size);
+                        rdev->sb_start = calc_dev_sboffset(rdev->bdev);
+                rdev->size = calc_num_sectors(rdev, mddev->chunk_size) / 2;
 
                 err = bind_rdev_to_array(rdev, mddev);
                 if (err) {
@@ -4232,9 +4375,6 @@ static int hot_remove_disk(mddev_t * mddev, dev_t dev)
         char b[BDEVNAME_SIZE];
         mdk_rdev_t *rdev;
 
-        if (!mddev->pers)
-                return -ENODEV;
-
         rdev = find_rdev(mddev, dev);
         if (!rdev)
                 return -ENXIO;
@@ -4257,7 +4397,6 @@ static int hot_add_disk(mddev_t * mddev, dev_t dev)
 {
         char b[BDEVNAME_SIZE];
         int err;
-        unsigned int size;
         mdk_rdev_t *rdev;
 
         if (!mddev->pers)
@@ -4285,13 +4424,11 @@ static int hot_add_disk(mddev_t * mddev, dev_t dev)
         }
 
         if (mddev->persistent)
-                rdev->sb_offset = calc_dev_sboffset(rdev->bdev);
+                rdev->sb_start = calc_dev_sboffset(rdev->bdev);
         else
-                rdev->sb_offset =
-                        rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
+                rdev->sb_start = rdev->bdev->bd_inode->i_size / 512;
 
-        size = calc_dev_size(rdev, mddev->chunk_size);
-        rdev->size = size;
+        rdev->size = calc_num_sectors(rdev, mddev->chunk_size) / 2;
 
         if (test_bit(Faulty, &rdev->flags)) {
                 printk(KERN_WARNING 
@@ -4476,24 +4613,24 @@ static int set_array_info(mddev_t * mddev, mdu_array_info_t *info)
         return 0;
 }
 
-static int update_size(mddev_t *mddev, unsigned long size)
+static int update_size(mddev_t *mddev, sector_t num_sectors)
 {
         mdk_rdev_t * rdev;
         int rv;
         struct list_head *tmp;
-        int fit = (size == 0);
+        int fit = (num_sectors == 0);
 
         if (mddev->pers->resize == NULL)
                 return -EINVAL;
-        /* The "size" is the amount of each device that is used.
-         * This can only make sense for arrays with redundancy.
-         * linear and raid0 always use whatever space is available
-         * We can only consider changing the size if no resync
-         * or reconstruction is happening, and if the new size
-         * is acceptable. It must fit before the sb_offset or,
-         * if that is <data_offset, it must fit before the
-         * size of each device.
-         * If size is zero, we find the largest size that fits.
+        /* The "num_sectors" is the number of sectors of each device that
+         * is used.  This can only make sense for arrays with redundancy.
+         * linear and raid0 always use whatever space is available. We can only
+         * consider changing this number if no resync or reconstruction is
+         * happening, and if the new size is acceptable. It must fit before the
+         * sb_start or, if that is <data_offset, it must fit before the size
+         * of each device.  If num_sectors is zero, we find the largest size
+         * that fits.
+
          */
         if (mddev->sync_thread)
                 return -EBUSY;
@@ -4501,19 +4638,20 @@ static int update_size(mddev_t *mddev, unsigned long size)
                 sector_t avail;
                 avail = rdev->size * 2;
 
-                if (fit && (size == 0 || size > avail/2))
-                        size = avail/2;
-                if (avail < ((sector_t)size << 1))
+                if (fit && (num_sectors == 0 || num_sectors > avail))
+                        num_sectors = avail;
+                if (avail < num_sectors)
                         return -ENOSPC;
         }
-        rv = mddev->pers->resize(mddev, (sector_t)size *2);
+        rv = mddev->pers->resize(mddev, num_sectors);
         if (!rv) {
                 struct block_device *bdev;
 
                 bdev = bdget_disk(mddev->gendisk, 0);
                 if (bdev) {
                         mutex_lock(&bdev->bd_inode->i_mutex);
-                        i_size_write(bdev->bd_inode, (loff_t)mddev->array_size << 10);
+                        i_size_write(bdev->bd_inode,
+                                     (loff_t)mddev->array_sectors << 9);
                         mutex_unlock(&bdev->bd_inode->i_mutex);
                         bdput(bdev);
                 }
@@ -4588,7 +4726,7 @@ static int update_array_info(mddev_t *mddev, mdu_array_info_t *info)
                         return mddev->pers->reconfig(mddev, info->layout, -1);
         }
         if (info->size >= 0 && mddev->size != info->size)
-                rv = update_size(mddev, info->size);
+                rv = update_size(mddev, (sector_t)info->size * 2);
 
         if (mddev->raid_disks    != info->raid_disks)
                 rv = update_raid_disks(mddev, info->raid_disks);
@@ -4641,6 +4779,12 @@ static int set_disk_faulty(mddev_t *mddev, dev_t dev)
         return 0;
 }
 
+/*
+ * We have a problem here : there is no easy way to give a CHS
+ * virtual geometry. We currently pretend that we have a 2 heads
+ * 4 sectors (with a BIG number of cylinders...). This drives
+ * dosfs just mad... ;-)
+ */
 static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo)
 {
         mddev_t *mddev = bdev->bd_disk->private_data;
@@ -4785,19 +4929,13 @@ static int md_ioctl(struct inode *inode, struct file *file,
                         goto done_unlock;
 
                 case STOP_ARRAY:
-                        err = do_md_stop (mddev, 0);
+                        err = do_md_stop (mddev, 0, 1);
                         goto done_unlock;
 
                 case STOP_ARRAY_RO:
-                        err = do_md_stop (mddev, 1);
+                        err = do_md_stop (mddev, 1, 1);
                         goto done_unlock;
 
-        /*
-         * We have a problem here : there is no easy way to give a CHS
-         * virtual geometry. We currently pretend that we have a 2 heads
-         * 4 sectors (with a BIG number of cylinders...). This drives
-         * dosfs just mad... ;-)
-         */
         }
 
         /*
@@ -4807,13 +4945,12 @@ static int md_ioctl(struct inode *inode, struct file *file,
          * here and hit the 'default' below, so only disallow
          * 'md' ioctls, and switch to rw mode if started auto-readonly.
          */
-        if (_IOC_TYPE(cmd) == MD_MAJOR &&
-            mddev->ro && mddev->pers) {
+        if (_IOC_TYPE(cmd) == MD_MAJOR && mddev->ro && mddev->pers) {
                 if (mddev->ro == 2) {
                         mddev->ro = 0;
-                set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
-                md_wakeup_thread(mddev->thread);
-
+                        sysfs_notify(&mddev->kobj, NULL, "array_state");
+                        set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
+                        md_wakeup_thread(mddev->thread);
                 } else {
                         err = -EROFS;
                         goto abort_unlock;
@@ -4883,6 +5020,7 @@ static int md_open(struct inode *inode, struct file *file)
 
         err = 0;
         mddev_get(mddev);
+        atomic_inc(&mddev->openers);
         mddev_unlock(mddev);
 
         check_disk_change(inode->i_bdev);
@@ -4895,6 +5033,7 @@ static int md_release(struct inode *inode, struct file * file)
         mddev_t *mddev = inode->i_bdev->bd_disk->private_data;
 
         BUG_ON(!mddev);
+        atomic_dec(&mddev->openers);
         mddev_put(mddev);
 
         return 0;
@@ -5029,6 +5168,9 @@ void md_error(mddev_t *mddev, mdk_rdev_t *rdev)
         if (!mddev->pers->error_handler)
                 return;
         mddev->pers->error_handler(mddev,rdev);
+        if (mddev->degraded)
+                set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
+        set_bit(StateChanged, &rdev->flags);
         set_bit(MD_RECOVERY_INTR, &mddev->recovery);
         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
         md_wakeup_thread(mddev->thread);
@@ -5258,10 +5400,11 @@ static int md_seq_show(struct seq_file *seq, void *v)
                 if (!list_empty(&mddev->disks)) {
                         if (mddev->pers)
                                 seq_printf(seq, "\n      %llu blocks",
-                                        (unsigned long long)mddev->array_size);
+                                           (unsigned long long)
+                                           mddev->array_sectors / 2);
                         else
                                 seq_printf(seq, "\n      %llu blocks",
-                                        (unsigned long long)size);
+                                           (unsigned long long)size);
                 }
                 if (mddev->persistent) {
                         if (mddev->major_version != 0 ||
@@ -5391,12 +5534,12 @@ int unregister_md_personality(struct mdk_personality *p)
 static int is_mddev_idle(mddev_t *mddev)
 {
         mdk_rdev_t * rdev;
-        struct list_head *tmp;
         int idle;
         long curr_events;
 
         idle = 1;
-        rdev_for_each(rdev, tmp, mddev) {
+        rcu_read_lock();
+        rdev_for_each_rcu(rdev, mddev) {
                 struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
                 curr_events = disk_stat_read(disk, sectors[0]) + 
                                 disk_stat_read(disk, sectors[1]) - 
@@ -5428,6 +5571,7 @@ static int is_mddev_idle(mddev_t *mddev)
                         idle = 0;
                 }
         }
+        rcu_read_unlock();
         return idle;
 }
 
@@ -5451,6 +5595,7 @@ void md_done_sync(mddev_t *mddev, int blocks, int ok)
  */
 void md_write_start(mddev_t *mddev, struct bio *bi)
 {
+        int did_change = 0;
         if (bio_data_dir(bi) != WRITE)
                 return;
 
@@ -5461,6 +5606,7 @@ void md_write_start(mddev_t *mddev, struct bio *bi)
                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
                 md_wakeup_thread(mddev->thread);
                 md_wakeup_thread(mddev->sync_thread);
+                did_change = 1;
         }
         atomic_inc(&mddev->writes_pending);
         if (mddev->safemode == 1)
@@ -5471,10 +5617,12 @@ void md_write_start(mddev_t *mddev, struct bio *bi)
                         mddev->in_sync = 0;
                         set_bit(MD_CHANGE_CLEAN, &mddev->flags);
                         md_wakeup_thread(mddev->thread);
+                        did_change = 1;
                 }
                 spin_unlock_irq(&mddev->write_lock);
-                sysfs_notify(&mddev->kobj, NULL, "array_state");
         }
+        if (did_change)
+                sysfs_notify(&mddev->kobj, NULL, "array_state");
         wait_event(mddev->sb_wait,
                    !test_bit(MD_CHANGE_CLEAN, &mddev->flags) &&
                    !test_bit(MD_CHANGE_PENDING, &mddev->flags));
@@ -5495,13 +5643,18 @@ void md_write_end(mddev_t *mddev)
  * may proceed without blocking.  It is important to call this before
  * attempting a GFP_KERNEL allocation while holding the mddev lock.
  * Must be called with mddev_lock held.
+ *
+ * In the ->external case MD_CHANGE_CLEAN can not be cleared until mddev->lock
+ * is dropped, so return -EAGAIN after notifying userspace.
  */
-void md_allow_write(mddev_t *mddev)
+int md_allow_write(mddev_t *mddev)
 {
         if (!mddev->pers)
-                return;
+                return 0;
         if (mddev->ro)
-                return;
+                return 0;
+        if (!mddev->pers->sync_request)
+                return 0;
 
         spin_lock_irq(&mddev->write_lock);
         if (mddev->in_sync) {
@@ -5512,14 +5665,14 @@ void md_allow_write(mddev_t *mddev)
                         mddev->safemode = 1;
                 spin_unlock_irq(&mddev->write_lock);
                 md_update_sb(mddev, 0);
-
                 sysfs_notify(&mddev->kobj, NULL, "array_state");
-                /* wait for the dirty state to be recorded in the metadata */
-                wait_event(mddev->sb_wait,
-                           !test_bit(MD_CHANGE_CLEAN, &mddev->flags) &&
-                           !test_bit(MD_CHANGE_PENDING, &mddev->flags));
         } else
                 spin_unlock_irq(&mddev->write_lock);
+
+        if (test_bit(MD_CHANGE_CLEAN, &mddev->flags))
+                return -EAGAIN;
+        else
+                return 0;
 }
 EXPORT_SYMBOL_GPL(md_allow_write);
 
@@ -5625,9 +5778,11 @@ void md_do_sync(mddev_t *mddev)
                 max_sectors = mddev->resync_max_sectors;
                 mddev->resync_mismatches = 0;
                 /* we don't use the checkpoint if there's a bitmap */
-                if (!mddev->bitmap &&
-                    !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
+                if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
+                        j = mddev->resync_min;
+                else if (!mddev->bitmap)
                         j = mddev->recovery_cp;
+
         } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
                 max_sectors = mddev->size << 1;
         else {
@@ -5796,6 +5951,7 @@ void md_do_sync(mddev_t *mddev)
 
  skip:
         mddev->curr_resync = 0;
+        mddev->resync_min = 0;
         mddev->resync_max = MaxSector;
         sysfs_notify(&mddev->kobj, NULL, "sync_completed");
         wake_up(&resync_wait);
@@ -5845,7 +6001,8 @@ static int remove_and_add_spares(mddev_t *mddev)
                         if (rdev->raid_disk < 0
                             && !test_bit(Faulty, &rdev->flags)) {
                                 rdev->recovery_offset = 0;
-                                if (mddev->pers->hot_add_disk(mddev,rdev)) {
+                                if (mddev->pers->
+                                    hot_add_disk(mddev, rdev) == 0) {
                                         char nm[20];
                                         sprintf(nm, "rd%d", rdev->raid_disk);
                                         if (sysfs_create_link(&mddev->kobj,
@@ -5920,23 +6077,31 @@ void md_check_recovery(mddev_t *mddev)
                 int spares = 0;
 
                 if (!mddev->external) {
+                        int did_change = 0;
                         spin_lock_irq(&mddev->write_lock);
                         if (mddev->safemode &&
                             !atomic_read(&mddev->writes_pending) &&
                             !mddev->in_sync &&
                             mddev->recovery_cp == MaxSector) {
                                 mddev->in_sync = 1;
+                                did_change = 1;
                                 if (mddev->persistent)
                                         set_bit(MD_CHANGE_CLEAN, &mddev->flags);
                         }
                         if (mddev->safemode == 1)
                                 mddev->safemode = 0;
                         spin_unlock_irq(&mddev->write_lock);
+                        if (did_change)
+                                sysfs_notify(&mddev->kobj, NULL, "array_state");
                 }
 
                 if (mddev->flags)
                         md_update_sb(mddev, 0);
 
+                rdev_for_each(rdev, rtmp, mddev)
+                        if (test_and_clear_bit(StateChanged, &rdev->flags))
+                                sysfs_notify(&rdev->kobj, NULL, "state");
+
 
                 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
                     !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
@@ -5951,7 +6116,9 @@ void md_check_recovery(mddev_t *mddev)
                         if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
                                 /* success...*/
                                 /* activate any spares */
-                                mddev->pers->spare_active(mddev);
+                                if (mddev->pers->spare_active(mddev))
+                                        sysfs_notify(&mddev->kobj, NULL,
+                                                     "degraded");
                         }
                         md_update_sb(mddev, 1);
 
@@ -5965,13 +6132,18 @@ void md_check_recovery(mddev_t *mddev)
                         mddev->recovery = 0;
                         /* flag recovery needed just to double check */
                         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
+                        sysfs_notify(&mddev->kobj, NULL, "sync_action");
                         md_new_event(mddev);
                         goto unlock;
                 }
+                /* Set RUNNING before clearing NEEDED to avoid
+                 * any transients in the value of "sync_action".
+                 */
+                set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
+                clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
                 /* Clear some bits that don't mean anything, but
                  * might be left set
                  */
-                clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
                 clear_bit(MD_RECOVERY_INTR, &mddev->recovery);
                 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
 
@@ -5989,17 +6161,19 @@ void md_check_recovery(mddev_t *mddev)
                                 /* Cannot proceed */
                                 goto unlock;
                         set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
+                        clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
                 } else if ((spares = remove_and_add_spares(mddev))) {
                         clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
                         clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
+                        set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
                 } else if (mddev->recovery_cp < MaxSector) {
                         set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
+                        clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
                 } else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
                         /* nothing to be done ... */
                         goto unlock;
 
                 if (mddev->pers->sync_request) {
-                        set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
                         if (spares && mddev->bitmap && ! mddev->bitmap->file) {
                                 /* We are adding a device or devices to an array
                                  * which has the bitmap stored on all devices.
@@ -6018,9 +6192,16 @@ void md_check_recovery(mddev_t *mddev)
                                 mddev->recovery = 0;
                         } else
                                 md_wakeup_thread(mddev->sync_thread);
+                        sysfs_notify(&mddev->kobj, NULL, "sync_action");
                         md_new_event(mddev);
                 }
         unlock:
+                if (!mddev->sync_thread) {
+                        clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
+                        if (test_and_clear_bit(MD_RECOVERY_RECOVER,
+                                               &mddev->recovery))
+                                sysfs_notify(&mddev->kobj, NULL, "sync_action");
+                }
                 mddev_unlock(mddev);
         }
 }
@@ -6047,7 +6228,7 @@ static int md_notify_reboot(struct notifier_block *this,
 
                 for_each_mddev(mddev, tmp)
                         if (mddev_trylock(mddev)) {
-                                do_md_stop (mddev, 1);
+                                do_md_stop (mddev, 1, 0);
                                 mddev_unlock(mddev);
                         }
                 /*
diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c
index e968116e0de9..c4779ccba1c3 100644
--- a/drivers/md/multipath.c
+++ b/drivers/md/multipath.c
@@ -281,13 +281,18 @@ static int multipath_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
 {
         multipath_conf_t *conf = mddev->private;
         struct request_queue *q;
-        int found = 0;
+        int err = -EEXIST;
         int path;
         struct multipath_info *p;
+        int first = 0;
+        int last = mddev->raid_disks - 1;
+
+        if (rdev->raid_disk >= 0)
+                first = last = rdev->raid_disk;
 
         print_multipath_conf(conf);
 
-        for (path=0; path<mddev->raid_disks; path++) 
+        for (path = first; path <= last; path++)
                 if ((p=conf->multipaths+path)->rdev == NULL) {
                         q = rdev->bdev->bd_disk->queue;
                         blk_queue_stack_limits(mddev->queue, q);
@@ -307,11 +312,13 @@ static int multipath_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
                         rdev->raid_disk = path;
                         set_bit(In_sync, &rdev->flags);
                         rcu_assign_pointer(p->rdev, rdev);
-                        found = 1;
+                        err = 0;
+                        break;
                 }
 
         print_multipath_conf(conf);
-        return found;
+
+        return err;
 }
 
 static int multipath_remove_disk(mddev_t *mddev, int number)
@@ -497,7 +504,7 @@ static int multipath_run (mddev_t *mddev)
         /*
          * Ok, everything is just fine now
          */
-        mddev->array_size = mddev->size;
+        mddev->array_sectors = mddev->size * 2;
 
         mddev->queue->unplug_fn = multipath_unplug;
         mddev->queue->backing_dev_info.congested_fn = multipath_congested;
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index bcbb82594a19..183610635661 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -295,16 +295,16 @@ static int raid0_run (mddev_t *mddev)
                 goto out_free_conf;
 
         /* calculate array device size */
-        mddev->array_size = 0;
+        mddev->array_sectors = 0;
         rdev_for_each(rdev, tmp, mddev)
-                mddev->array_size += rdev->size;
+                mddev->array_sectors += rdev->size * 2;
 
         printk("raid0 : md_size is %llu blocks.\n", 
-                (unsigned long long)mddev->array_size);
+                (unsigned long long)mddev->array_sectors / 2);
         printk("raid0 : conf->hash_spacing is %llu blocks.\n",
                 (unsigned long long)conf->hash_spacing);
         {
-                sector_t s = mddev->array_size;
+                sector_t s = mddev->array_sectors / 2;
                 sector_t space = conf->hash_spacing;
                 int round;
                 conf->preshift = 0;
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index c610b947218a..03a5ab705c20 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -1100,11 +1100,16 @@ static int raid1_spare_active(mddev_t *mddev)
 static int raid1_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
 {
         conf_t *conf = mddev->private;
-        int found = 0;
+        int err = -EEXIST;
         int mirror = 0;
         mirror_info_t *p;
+        int first = 0;
+        int last = mddev->raid_disks - 1;
 
-        for (mirror=0; mirror < mddev->raid_disks; mirror++)
+        if (rdev->raid_disk >= 0)
+                first = last = rdev->raid_disk;
+
+        for (mirror = first; mirror <= last; mirror++)
                 if ( !(p=conf->mirrors+mirror)->rdev) {
 
                         blk_queue_stack_limits(mddev->queue,
@@ -1119,7 +1124,7 @@ static int raid1_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
 
                         p->head_position = 0;
                         rdev->raid_disk = mirror;
-                        found = 1;
+                        err = 0;
                         /* As all devices are equivalent, we don't need a full recovery
                          * if this was recently any drive of the array
                          */
@@ -1130,7 +1135,7 @@ static int raid1_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
                 }
 
         print_conf(conf);
-        return found;
+        return err;
 }
 
 static int raid1_remove_disk(mddev_t *mddev, int number)
@@ -2038,7 +2043,7 @@ static int run(mddev_t *mddev)
         /*
          * Ok, everything is just fine now
          */
-        mddev->array_size = mddev->size;
+        mddev->array_sectors = mddev->size * 2;
 
         mddev->queue->unplug_fn = raid1_unplug;
         mddev->queue->backing_dev_info.congested_fn = raid1_congested;
@@ -2100,14 +2105,15 @@ static int raid1_resize(mddev_t *mddev, sector_t sectors)
          * any io in the removed space completes, but it hardly seems
          * worth it.
          */
-        mddev->array_size = sectors>>1;
-        set_capacity(mddev->gendisk, mddev->array_size << 1);
+        mddev->array_sectors = sectors;
+        set_capacity(mddev->gendisk, mddev->array_sectors);
         mddev->changed = 1;
-        if (mddev->array_size > mddev->size && mddev->recovery_cp == MaxSector) {
+        if (mddev->array_sectors / 2 > mddev->size &&
+            mddev->recovery_cp == MaxSector) {
                 mddev->recovery_cp = mddev->size << 1;
                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
         }
-        mddev->size = mddev->array_size;
+        mddev->size = mddev->array_sectors / 2;
         mddev->resync_max_sectors = sectors;
         return 0;
 }
@@ -2131,7 +2137,7 @@ static int raid1_reshape(mddev_t *mddev)
         conf_t *conf = mddev_to_conf(mddev);
         int cnt, raid_disks;
         unsigned long flags;
-        int d, d2;
+        int d, d2, err;
 
         /* Cannot change chunk_size, layout, or level */
         if (mddev->chunk_size != mddev->new_chunk ||
@@ -2143,7 +2149,9 @@ static int raid1_reshape(mddev_t *mddev)
                 return -EINVAL;
         }
 
-        md_allow_write(mddev);
+        err = md_allow_write(mddev);
+        if (err)
+                return err;
 
         raid_disks = mddev->raid_disks + mddev->delta_disks;
 
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 22bb2b1b886d..159535d73567 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -1114,24 +1114,30 @@ static int raid10_spare_active(mddev_t *mddev)
 static int raid10_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
 {
         conf_t *conf = mddev->private;
-        int found = 0;
+        int err = -EEXIST;
         int mirror;
         mirror_info_t *p;
+        int first = 0;
+        int last = mddev->raid_disks - 1;
 
         if (mddev->recovery_cp < MaxSector)
                 /* only hot-add to in-sync arrays, as recovery is
                  * very different from resync
                  */
-                return 0;
+                return -EBUSY;
         if (!enough(conf))
-                return 0;
+                return -EINVAL;
+
+        if (rdev->raid_disk)
+                first = last = rdev->raid_disk;
 
         if (rdev->saved_raid_disk >= 0 &&
+            rdev->saved_raid_disk >= first &&
             conf->mirrors[rdev->saved_raid_disk].rdev == NULL)
                 mirror = rdev->saved_raid_disk;
         else
-                mirror = 0;
-        for ( ; mirror < mddev->raid_disks; mirror++)
+                mirror = first;
+        for ( ; mirror <= last ; mirror++)
                 if ( !(p=conf->mirrors+mirror)->rdev) {
 
                         blk_queue_stack_limits(mddev->queue,
@@ -1146,7 +1152,7 @@ static int raid10_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
 
                         p->head_position = 0;
                         rdev->raid_disk = mirror;
-                        found = 1;
+                        err = 0;
                         if (rdev->saved_raid_disk != mirror)
                                 conf->fullsync = 1;
                         rcu_assign_pointer(p->rdev, rdev);
@@ -1154,7 +1160,7 @@ static int raid10_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
                 }
 
         print_conf(conf);
-        return found;
+        return err;
 }
 
 static int raid10_remove_disk(mddev_t *mddev, int number)
@@ -2159,7 +2165,7 @@ static int run(mddev_t *mddev)
         /*
          * Ok, everything is just fine now
          */
-        mddev->array_size = size << (conf->chunk_shift-1);
+        mddev->array_sectors = size << conf->chunk_shift;
         mddev->resync_max_sectors = size << conf->chunk_shift;
 
         mddev->queue->unplug_fn = raid10_unplug;
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 9ce7154845c6..55e7c56045a0 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -115,15 +115,20 @@ static void return_io(struct bio *return_bi)
                 return_bi = bi->bi_next;
                 bi->bi_next = NULL;
                 bi->bi_size = 0;
-                bi->bi_end_io(bi,
-                              test_bit(BIO_UPTODATE, &bi->bi_flags)
-                                ? 0 : -EIO);
+                bio_endio(bi, 0);
                 bi = return_bi;
         }
 }
 
 static void print_raid5_conf (raid5_conf_t *conf);
 
+static int stripe_operations_active(struct stripe_head *sh)
+{
+        return sh->check_state || sh->reconstruct_state ||
+               test_bit(STRIPE_BIOFILL_RUN, &sh->state) ||
+               test_bit(STRIPE_COMPUTE_RUN, &sh->state);
+}
+
 static void __release_stripe(raid5_conf_t *conf, struct stripe_head *sh)
 {
         if (atomic_dec_and_test(&sh->count)) {
@@ -143,7 +148,7 @@ static void __release_stripe(raid5_conf_t *conf, struct stripe_head *sh)
                         }
                         md_wakeup_thread(conf->mddev->thread);
                 } else {
-                        BUG_ON(sh->ops.pending);
+                        BUG_ON(stripe_operations_active(sh));
                         if (test_and_clear_bit(STRIPE_PREREAD_ACTIVE, &sh->state)) {
                                 atomic_dec(&conf->preread_active_stripes);
                                 if (atomic_read(&conf->preread_active_stripes) < IO_THRESHOLD)
@@ -245,7 +250,7 @@ static void init_stripe(struct stripe_head *sh, sector_t sector, int pd_idx, int
 
         BUG_ON(atomic_read(&sh->count) != 0);
         BUG_ON(test_bit(STRIPE_HANDLE, &sh->state));
-        BUG_ON(sh->ops.pending || sh->ops.ack || sh->ops.complete);
+        BUG_ON(stripe_operations_active(sh));
 
         CHECK_DEVLOCK();
         pr_debug("init_stripe called, stripe %llu\n",
@@ -346,62 +351,18 @@ static struct stripe_head *get_active_stripe(raid5_conf_t *conf, sector_t sector
         return sh;
 }
 
-/* test_and_ack_op() ensures that we only dequeue an operation once */
-#define test_and_ack_op(op, pend) \
-do {                                                    \
-        if (test_bit(op, &sh->ops.pending) &&           \
-                !test_bit(op, &sh->ops.complete)) {     \
-                if (test_and_set_bit(op, &sh->ops.ack)) \
-                        clear_bit(op, &pend);           \
-                else                                    \
-                        ack++;                          \
-        } else                                          \
-                clear_bit(op, &pend);                   \
-} while (0)
-
-/* find new work to run, do not resubmit work that is already
- * in flight
- */
-static unsigned long get_stripe_work(struct stripe_head *sh)
-{
-        unsigned long pending;
-        int ack = 0;
-
-        pending = sh->ops.pending;
-
-        test_and_ack_op(STRIPE_OP_BIOFILL, pending);
-        test_and_ack_op(STRIPE_OP_COMPUTE_BLK, pending);
-        test_and_ack_op(STRIPE_OP_PREXOR, pending);
-        test_and_ack_op(STRIPE_OP_BIODRAIN, pending);
-        test_and_ack_op(STRIPE_OP_POSTXOR, pending);
-        test_and_ack_op(STRIPE_OP_CHECK, pending);
-        if (test_and_clear_bit(STRIPE_OP_IO, &sh->ops.pending))
-                ack++;
-
-        sh->ops.count -= ack;
-        if (unlikely(sh->ops.count < 0)) {
-                printk(KERN_ERR "pending: %#lx ops.pending: %#lx ops.ack: %#lx "
-                        "ops.complete: %#lx\n", pending, sh->ops.pending,
-                        sh->ops.ack, sh->ops.complete);
-                BUG();
-        }
-
-        return pending;
-}
-
 static void
 raid5_end_read_request(struct bio *bi, int error);
 static void
 raid5_end_write_request(struct bio *bi, int error);
 
-static void ops_run_io(struct stripe_head *sh)
+static void ops_run_io(struct stripe_head *sh, struct stripe_head_state *s)
 {
         raid5_conf_t *conf = sh->raid_conf;
         int i, disks = sh->disks;
 
         might_sleep();
 
-        set_bit(STRIPE_IO_STARTED, &sh->state);
         for (i = disks; i--; ) {
                 int rw;
                 struct bio *bi;
@@ -430,11 +391,11 @@ static void ops_run_io(struct stripe_head *sh)
                 rcu_read_unlock();
 
                 if (rdev) {
-                        if (test_bit(STRIPE_SYNCING, &sh->state) ||
-                                test_bit(STRIPE_EXPAND_SOURCE, &sh->state) ||
-                                test_bit(STRIPE_EXPAND_READY, &sh->state))
+                        if (s->syncing || s->expanding || s->expanded)
                                 md_sync_acct(rdev->bdev, STRIPE_SECTORS);
 
+                        set_bit(STRIPE_IO_STARTED, &sh->state);
+
                         bi->bi_bdev = rdev->bdev;
                         pr_debug("%s: for %llu schedule op %ld on disc %d\n",
                                 __func__, (unsigned long long)sh->sector,
@@ -528,38 +489,34 @@ static void ops_complete_biofill(void *stripe_head_ref)
                 (unsigned long long)sh->sector);
 
         /* clear completed biofills */
+        spin_lock_irq(&conf->device_lock);
         for (i = sh->disks; i--; ) {
                 struct r5dev *dev = &sh->dev[i];
 
                 /* acknowledge completion of a biofill operation */
                 /* and check if we need to reply to a read request,
                  * new R5_Wantfill requests are held off until
-                 * !test_bit(STRIPE_OP_BIOFILL, &sh->ops.pending)
+                 * !STRIPE_BIOFILL_RUN
                  */
                 if (test_and_clear_bit(R5_Wantfill, &dev->flags)) {
                         struct bio *rbi, *rbi2;
 
-                        /* The access to dev->read is outside of the
-                         * spin_lock_irq(&conf->device_lock), but is protected
-                         * by the STRIPE_OP_BIOFILL pending bit
-                         */
                         BUG_ON(!dev->read);
                         rbi = dev->read;
                         dev->read = NULL;
                         while (rbi && rbi->bi_sector <
                                 dev->sector + STRIPE_SECTORS) {
                                 rbi2 = r5_next_bio(rbi, dev->sector);
-                                spin_lock_irq(&conf->device_lock);
                                 if (--rbi->bi_phys_segments == 0) {
                                         rbi->bi_next = return_bi;
                                         return_bi = rbi;
                                 }
-                                spin_unlock_irq(&conf->device_lock);
                                 rbi = rbi2;
                         }
                 }
         }
-        set_bit(STRIPE_OP_BIOFILL, &sh->ops.complete);
+        spin_unlock_irq(&conf->device_lock);
+        clear_bit(STRIPE_BIOFILL_RUN, &sh->state);
 
         return_io(return_bi);
 
@@ -610,13 +567,14 @@ static void ops_complete_compute5(void *stripe_head_ref)
         set_bit(R5_UPTODATE, &tgt->flags);
         BUG_ON(!test_bit(R5_Wantcompute, &tgt->flags));
         clear_bit(R5_Wantcompute, &tgt->flags);
-        set_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.complete);
+        clear_bit(STRIPE_COMPUTE_RUN, &sh->state);
+        if (sh->check_state == check_state_compute_run)
+                sh->check_state = check_state_compute_result;
         set_bit(STRIPE_HANDLE, &sh->state);
         release_stripe(sh);
 }
 
-static struct dma_async_tx_descriptor *
-ops_run_compute5(struct stripe_head *sh, unsigned long pending)
+static struct dma_async_tx_descriptor *ops_run_compute5(struct stripe_head *sh)
 {
         /* kernel stack size limits the total number of disks */
         int disks = sh->disks;
@@ -646,10 +604,6 @@ ops_run_compute5(struct stripe_head *sh, unsigned long pending)
                         ASYNC_TX_XOR_ZERO_DST, NULL,
                         ops_complete_compute5, sh);
 
-        /* ack now if postxor is not set to be run */
-        if (tx && !test_bit(STRIPE_OP_POSTXOR, &pending))
-                async_tx_ack(tx);
-
         return tx;
 }
 
@@ -659,8 +613,6 @@ static void ops_complete_prexor(void *stripe_head_ref)
 
         pr_debug("%s: stripe %llu\n", __func__,
                 (unsigned long long)sh->sector);
-
-        set_bit(STRIPE_OP_PREXOR, &sh->ops.complete);
 }
 
 static struct dma_async_tx_descriptor *
@@ -680,7 +632,7 @@ ops_run_prexor(struct stripe_head *sh, struct dma_async_tx_descriptor *tx)
         for (i = disks; i--; ) {
                 struct r5dev *dev = &sh->dev[i];
                 /* Only process blocks that are known to be uptodate */
-                if (dev->towrite && test_bit(R5_Wantprexor, &dev->flags))
+                if (test_bit(R5_Wantdrain, &dev->flags))
                         xor_srcs[count++] = dev->page;
         }
 
@@ -692,16 +644,10 @@ ops_run_prexor(struct stripe_head *sh, struct dma_async_tx_descriptor *tx)
 }
 
 static struct dma_async_tx_descriptor *
-ops_run_biodrain(struct stripe_head *sh, struct dma_async_tx_descriptor *tx,
-                 unsigned long pending)
+ops_run_biodrain(struct stripe_head *sh, struct dma_async_tx_descriptor *tx)
 {
         int disks = sh->disks;
-        int pd_idx = sh->pd_idx, i;
-
-        /* check if prexor is active which means only process blocks
-         * that are part of a read-modify-write (Wantprexor)
-         */
-        int prexor = test_bit(STRIPE_OP_PREXOR, &pending);
+        int i;
 
         pr_debug("%s: stripe %llu\n", __func__,
                 (unsigned long long)sh->sector);
@@ -709,20 +655,8 @@ ops_run_biodrain(struct stripe_head *sh, struct dma_async_tx_descriptor *tx,
         for (i = disks; i--; ) {
                 struct r5dev *dev = &sh->dev[i];
                 struct bio *chosen;
-                int towrite;
-
-                towrite = 0;
-                if (prexor) { /* rmw */
-                        if (dev->towrite &&
-                            test_bit(R5_Wantprexor, &dev->flags))
-                                towrite = 1;
-                } else { /* rcw */
-                        if (i != pd_idx && dev->towrite &&
-                                test_bit(R5_LOCKED, &dev->flags))
-                                towrite = 1;
-                }
 
-                if (towrite) {
+                if (test_and_clear_bit(R5_Wantdrain, &dev->flags)) {
                         struct bio *wbi;
 
                         spin_lock(&sh->lock);
@@ -747,18 +681,6 @@ ops_run_biodrain(struct stripe_head *sh, struct dma_async_tx_descriptor *tx,
 static void ops_complete_postxor(void *stripe_head_ref)
 {
         struct stripe_head *sh = stripe_head_ref;
-
-        pr_debug("%s: stripe %llu\n", __func__,
-                (unsigned long long)sh->sector);
-
-        set_bit(STRIPE_OP_POSTXOR, &sh->ops.complete);
-        set_bit(STRIPE_HANDLE, &sh->state);
-        release_stripe(sh);
-}
-
-static void ops_complete_write(void *stripe_head_ref)
-{
-        struct stripe_head *sh = stripe_head_ref;
         int disks = sh->disks, i, pd_idx = sh->pd_idx;
 
         pr_debug("%s: stripe %llu\n", __func__,
@@ -770,16 +692,21 @@ static void ops_complete_write(void *stripe_head_ref)
                         set_bit(R5_UPTODATE, &dev->flags);
         }
 
-        set_bit(STRIPE_OP_BIODRAIN, &sh->ops.complete);
-        set_bit(STRIPE_OP_POSTXOR, &sh->ops.complete);
+        if (sh->reconstruct_state == reconstruct_state_drain_run)
+                sh->reconstruct_state = reconstruct_state_drain_result;
+        else if (sh->reconstruct_state == reconstruct_state_prexor_drain_run)
+                sh->reconstruct_state = reconstruct_state_prexor_drain_result;
+        else {
+                BUG_ON(sh->reconstruct_state != reconstruct_state_run);
+                sh->reconstruct_state = reconstruct_state_result;
+        }
 
         set_bit(STRIPE_HANDLE, &sh->state);
         release_stripe(sh);
 }
 
 static void
-ops_run_postxor(struct stripe_head *sh, struct dma_async_tx_descriptor *tx,
-                unsigned long pending)
+ops_run_postxor(struct stripe_head *sh, struct dma_async_tx_descriptor *tx)
 {
         /* kernel stack size limits the total number of disks */
         int disks = sh->disks;
@@ -787,9 +714,8 @@ ops_run_postxor(struct stripe_head *sh, struct dma_async_tx_descriptor *tx,
 
         int count = 0, pd_idx = sh->pd_idx, i;
         struct page *xor_dest;
-        int prexor = test_bit(STRIPE_OP_PREXOR, &pending);
+        int prexor = 0;
         unsigned long flags;
-        dma_async_tx_callback callback;
 
         pr_debug("%s: stripe %llu\n", __func__,
                 (unsigned long long)sh->sector);
@@ -797,7 +723,8 @@ ops_run_postxor(struct stripe_head *sh, struct dma_async_tx_descriptor *tx,
         /* check if prexor is active which means only process blocks
          * that are part of a read-modify-write (written)
          */
-        if (prexor) {
+        if (sh->reconstruct_state == reconstruct_state_prexor_drain_run) {
+                prexor = 1;
                 xor_dest = xor_srcs[count++] = sh->dev[pd_idx].page;
                 for (i = disks; i--; ) {
                         struct r5dev *dev = &sh->dev[i];
@@ -813,10 +740,6 @@ ops_run_postxor(struct stripe_head *sh, struct dma_async_tx_descriptor *tx,
                 }
         }
 
-        /* check whether this postxor is part of a write */
-        callback = test_bit(STRIPE_OP_BIODRAIN, &pending) ?
-                ops_complete_write : ops_complete_postxor;
-
         /* 1/ if we prexor'd then the dest is reused as a source
          * 2/ if we did not prexor then we are redoing the parity
          * set ASYNC_TX_XOR_DROP_DST and ASYNC_TX_XOR_ZERO_DST
@@ -830,25 +753,20 @@ ops_run_postxor(struct stripe_head *sh, struct dma_async_tx_descriptor *tx,
         if (unlikely(count == 1)) {
                 flags &= ~(ASYNC_TX_XOR_DROP_DST | ASYNC_TX_XOR_ZERO_DST);
                 tx = async_memcpy(xor_dest, xor_srcs[0], 0, 0, STRIPE_SIZE,
-                        flags, tx, callback, sh);
+                        flags, tx, ops_complete_postxor, sh);
         } else
                 tx = async_xor(xor_dest, xor_srcs, 0, count, STRIPE_SIZE,
-                        flags, tx, callback, sh);
+                        flags, tx, ops_complete_postxor, sh);
 }
 
 static void ops_complete_check(void *stripe_head_ref)
 {
         struct stripe_head *sh = stripe_head_ref;
-        int pd_idx = sh->pd_idx;
 
         pr_debug("%s: stripe %llu\n", __func__,
                 (unsigned long long)sh->sector);
 
-        if (test_and_clear_bit(STRIPE_OP_MOD_DMA_CHECK, &sh->ops.pending) &&
-                sh->ops.zero_sum_result == 0)
-                set_bit(R5_UPTODATE, &sh->dev[pd_idx].flags);
-
-        set_bit(STRIPE_OP_CHECK, &sh->ops.complete);
+        sh->check_state = check_state_check_result;
         set_bit(STRIPE_HANDLE, &sh->state);
         release_stripe(sh);
 }
@@ -875,46 +793,42 @@ static void ops_run_check(struct stripe_head *sh)
         tx = async_xor_zero_sum(xor_dest, xor_srcs, 0, count, STRIPE_SIZE,
                 &sh->ops.zero_sum_result, 0, NULL, NULL, NULL);
 
-        if (tx)
-                set_bit(STRIPE_OP_MOD_DMA_CHECK, &sh->ops.pending);
-        else
-                clear_bit(STRIPE_OP_MOD_DMA_CHECK, &sh->ops.pending);
-
         atomic_inc(&sh->count);
         tx = async_trigger_callback(ASYNC_TX_DEP_ACK | ASYNC_TX_ACK, tx,
                 ops_complete_check, sh);
 }
 
-static void raid5_run_ops(struct stripe_head *sh, unsigned long pending)
+static void raid5_run_ops(struct stripe_head *sh, unsigned long ops_request)
 {
         int overlap_clear = 0, i, disks = sh->disks;
         struct dma_async_tx_descriptor *tx = NULL;
 
-        if (test_bit(STRIPE_OP_BIOFILL, &pending)) {
+        if (test_bit(STRIPE_OP_BIOFILL, &ops_request)) {
                 ops_run_biofill(sh);
                 overlap_clear++;
         }
 
-        if (test_bit(STRIPE_OP_COMPUTE_BLK, &pending))
-                tx = ops_run_compute5(sh, pending);
+        if (test_bit(STRIPE_OP_COMPUTE_BLK, &ops_request)) {
+                tx = ops_run_compute5(sh);
+                /* terminate the chain if postxor is not set to be run */
+                if (tx && !test_bit(STRIPE_OP_POSTXOR, &ops_request))
+                        async_tx_ack(tx);
+        }
 
-        if (test_bit(STRIPE_OP_PREXOR, &pending))
+        if (test_bit(STRIPE_OP_PREXOR, &ops_request))
                 tx = ops_run_prexor(sh, tx);
 
-        if (test_bit(STRIPE_OP_BIODRAIN, &pending)) {
-                tx = ops_run_biodrain(sh, tx, pending);
+        if (test_bit(STRIPE_OP_BIODRAIN, &ops_request)) {
+                tx = ops_run_biodrain(sh, tx);
                 overlap_clear++;
         }
 
-        if (test_bit(STRIPE_OP_POSTXOR, &pending))
-                ops_run_postxor(sh, tx, pending);
+        if (test_bit(STRIPE_OP_POSTXOR, &ops_request))
+                ops_run_postxor(sh, tx);
 
-        if (test_bit(STRIPE_OP_CHECK, &pending))
+        if (test_bit(STRIPE_OP_CHECK, &ops_request))
                 ops_run_check(sh);
 
-        if (test_bit(STRIPE_OP_IO, &pending))
-                ops_run_io(sh);
-
         if (overlap_clear)
                 for (i = disks; i--; ) {
                         struct r5dev *dev = &sh->dev[i];
@@ -997,14 +911,16 @@ static int resize_stripes(raid5_conf_t *conf, int newsize)
         struct stripe_head *osh, *nsh;
         LIST_HEAD(newstripes);
         struct disk_info *ndisks;
-        int err = 0;
+        int err;
         struct kmem_cache *sc;
         int i;
 
         if (newsize <= conf->pool_size)
                 return 0; /* never bother to shrink */
 
-        md_allow_write(conf->mddev);
+        err = md_allow_write(conf->mddev);
+        if (err)
+                return err;
 
         /* Step 1 */
         sc = kmem_cache_create(conf->cache_name[1-conf->active_name],
@@ -1703,11 +1619,11 @@ static void compute_block_2(struct stripe_head *sh, int dd_idx1, int dd_idx2)
         }
 }
 
-static int
-handle_write_operations5(struct stripe_head *sh, int rcw, int expand)
+static void
+schedule_reconstruction5(struct stripe_head *sh, struct stripe_head_state *s,
+                         int rcw, int expand)
 {
         int i, pd_idx = sh->pd_idx, disks = sh->disks;
-        int locked = 0;
 
         if (rcw) {
                 /* if we are not expanding this is a proper write request, and
@@ -1715,53 +1631,48 @@ handle_write_operations5(struct stripe_head *sh, int rcw, int expand)
                  * stripe cache
                  */
                 if (!expand) {
-                        set_bit(STRIPE_OP_BIODRAIN, &sh->ops.pending);
-                        sh->ops.count++;
-                }
+                        sh->reconstruct_state = reconstruct_state_drain_run;
+                        set_bit(STRIPE_OP_BIODRAIN, &s->ops_request);
+                } else
+                        sh->reconstruct_state = reconstruct_state_run;
 
-                set_bit(STRIPE_OP_POSTXOR, &sh->ops.pending);
-                sh->ops.count++;
+                set_bit(STRIPE_OP_POSTXOR, &s->ops_request);
 
                 for (i = disks; i--; ) {
                         struct r5dev *dev = &sh->dev[i];
 
                         if (dev->towrite) {
                                 set_bit(R5_LOCKED, &dev->flags);
+                                set_bit(R5_Wantdrain, &dev->flags);
                                 if (!expand)
                                         clear_bit(R5_UPTODATE, &dev->flags);
-                                locked++;
+                                s->locked++;
                         }
                 }
-                if (locked + 1 == disks)
+                if (s->locked + 1 == disks)
                         if (!test_and_set_bit(STRIPE_FULL_WRITE, &sh->state))
                                 atomic_inc(&sh->raid_conf->pending_full_writes);
         } else {
                 BUG_ON(!(test_bit(R5_UPTODATE, &sh->dev[pd_idx].flags) ||
                         test_bit(R5_Wantcompute, &sh->dev[pd_idx].flags)));
 
-                set_bit(STRIPE_OP_PREXOR, &sh->ops.pending);
-                set_bit(STRIPE_OP_BIODRAIN, &sh->ops.pending);
-                set_bit(STRIPE_OP_POSTXOR, &sh->ops.pending);
-
-                sh->ops.count += 3;
+                sh->reconstruct_state = reconstruct_state_prexor_drain_run;
+                set_bit(STRIPE_OP_PREXOR, &s->ops_request);
+                set_bit(STRIPE_OP_BIODRAIN, &s->ops_request);
+                set_bit(STRIPE_OP_POSTXOR, &s->ops_request);
 
                 for (i = disks; i--; ) {
                         struct r5dev *dev = &sh->dev[i];
                         if (i == pd_idx)
                                 continue;
 
-                        /* For a read-modify write there may be blocks that are
-                         * locked for reading while others are ready to be
-                         * written so we distinguish these blocks by the
-                         * R5_Wantprexor bit
-                         */
                         if (dev->towrite &&
                             (test_bit(R5_UPTODATE, &dev->flags) ||
-                            test_bit(R5_Wantcompute, &dev->flags))) {
-                                set_bit(R5_Wantprexor, &dev->flags);
+                             test_bit(R5_Wantcompute, &dev->flags))) {
+                                set_bit(R5_Wantdrain, &dev->flags);
                                 set_bit(R5_LOCKED, &dev->flags);
                                 clear_bit(R5_UPTODATE, &dev->flags);
-                                locked++;
+                                s->locked++;
                         }
                 }
         }
@@ -1771,13 +1682,11 @@ handle_write_operations5(struct stripe_head *sh, int rcw, int expand)
          */
         set_bit(R5_LOCKED, &sh->dev[pd_idx].flags);
         clear_bit(R5_UPTODATE, &sh->dev[pd_idx].flags);
-        locked++;
+        s->locked++;
 
-        pr_debug("%s: stripe %llu locked: %d pending: %lx\n",
+        pr_debug("%s: stripe %llu locked: %d ops_request: %lx\n",
                 __func__, (unsigned long long)sh->sector,
-                locked, sh->ops.pending);
-
-        return locked;
+                s->locked, s->ops_request);
 }
 
 /*
@@ -1876,7 +1785,7 @@ static int stripe_to_pdidx(sector_t stripe, raid5_conf_t *conf, int disks)
 }
 
 static void
-handle_requests_to_failed_array(raid5_conf_t *conf, struct stripe_head *sh,
+handle_failed_stripe(raid5_conf_t *conf, struct stripe_head *sh,
                                 struct stripe_head_state *s, int disks,
                                 struct bio **return_bi)
 {
@@ -1967,48 +1876,38 @@ handle_requests_to_failed_array(raid5_conf_t *conf, struct stripe_head *sh,
                         md_wakeup_thread(conf->mddev->thread);
 }
 
-/* __handle_issuing_new_read_requests5 - returns 0 if there are no more disks
- * to process
+/* fetch_block5 - checks the given member device to see if its data needs
+ * to be read or computed to satisfy a request.
+ *
+ * Returns 1 when no more member devices need to be checked, otherwise returns
+ * 0 to tell the loop in handle_stripe_fill5 to continue
  */
-static int __handle_issuing_new_read_requests5(struct stripe_head *sh,
-                        struct stripe_head_state *s, int disk_idx, int disks)
+static int fetch_block5(struct stripe_head *sh, struct stripe_head_state *s,
+                        int disk_idx, int disks)
 {
         struct r5dev *dev = &sh->dev[disk_idx];
         struct r5dev *failed_dev = &sh->dev[s->failed_num];
 
-        /* don't schedule compute operations or reads on the parity block while
-         * a check is in flight
-         */
-        if ((disk_idx == sh->pd_idx) &&
-             test_bit(STRIPE_OP_CHECK, &sh->ops.pending))
-                return ~0;
-
         /* is the data in this block needed, and can we get it? */
         if (!test_bit(R5_LOCKED, &dev->flags) &&
-            !test_bit(R5_UPTODATE, &dev->flags) && (dev->toread ||
-            (dev->towrite && !test_bit(R5_OVERWRITE, &dev->flags)) ||
-             s->syncing || s->expanding || (s->failed &&
-             (failed_dev->toread || (failed_dev->towrite &&
-             !test_bit(R5_OVERWRITE, &failed_dev->flags)
-             ))))) {
-                /* 1/ We would like to get this block, possibly by computing it,
-                 * but we might not be able to.
-                 *
-                 * 2/ Since parity check operations potentially make the parity
-                 * block !uptodate it will need to be refreshed before any
-                 * compute operations on data disks are scheduled.
-                 *
-                 * 3/ We hold off parity block re-reads until check operations
-                 * have quiesced.
+            !test_bit(R5_UPTODATE, &dev->flags) &&
+            (dev->toread ||
+             (dev->towrite && !test_bit(R5_OVERWRITE, &dev->flags)) ||
+             s->syncing || s->expanding ||
+             (s->failed &&
+              (failed_dev->toread ||
+               (failed_dev->towrite &&
+                !test_bit(R5_OVERWRITE, &failed_dev->flags)))))) {
+                /* We would like to get this block, possibly by computing it,
+                 * otherwise read it if the backing disk is insync
                  */
                 if ((s->uptodate == disks - 1) &&
-                    (s->failed && disk_idx == s->failed_num) &&
-                    !test_bit(STRIPE_OP_CHECK, &sh->ops.pending)) {
-                        set_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.pending);
+                    (s->failed && disk_idx == s->failed_num)) {
+                        set_bit(STRIPE_COMPUTE_RUN, &sh->state);
+                        set_bit(STRIPE_OP_COMPUTE_BLK, &s->ops_request);
                         set_bit(R5_Wantcompute, &dev->flags);
                         sh->ops.target = disk_idx;
                         s->req_compute = 1;
-                        sh->ops.count++;
                         /* Careful: from this point on 'uptodate' is in the eye
                          * of raid5_run_ops which services 'compute' operations
                          * before writes. R5_Wantcompute flags a block that will
@@ -2016,53 +1915,40 @@ static int __handle_issuing_new_read_requests5(struct stripe_head *sh,
                          * subsequent operation.
                          */
                         s->uptodate++;
-                        return 0; /* uptodate + compute == disks */
+                        return 1; /* uptodate + compute == disks */
                 } else if (test_bit(R5_Insync, &dev->flags)) {
                         set_bit(R5_LOCKED, &dev->flags);
                         set_bit(R5_Wantread, &dev->flags);
-                        if (!test_and_set_bit(STRIPE_OP_IO, &sh->ops.pending))
-                                sh->ops.count++;
                         s->locked++;
                         pr_debug("Reading block %d (sync=%d)\n", disk_idx,
                                 s->syncing);
                 }
         }
 
-        return ~0;
+        return 0;
 }
 
-static void handle_issuing_new_read_requests5(struct stripe_head *sh,
+/**
+ * handle_stripe_fill5 - read or compute data to satisfy pending requests.
+ */
+static void handle_stripe_fill5(struct stripe_head *sh,
                         struct stripe_head_state *s, int disks)
 {
         int i;
 
-        /* Clear completed compute operations.  Parity recovery
-         * (STRIPE_OP_MOD_REPAIR_PD) implies a write-back which is handled
-         * later on in this routine
-         */
-        if (test_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.complete) &&
-                !test_bit(STRIPE_OP_MOD_REPAIR_PD, &sh->ops.pending)) {
-                clear_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.complete);
-                clear_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.ack);
-                clear_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.pending);
-        }
-
         /* look for blocks to read/compute, skip this if a compute
          * is already in flight, or if the stripe contents are in the
          * midst of changing due to a write
          */
-        if (!test_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.pending) &&
-                !test_bit(STRIPE_OP_PREXOR, &sh->ops.pending) &&
-                !test_bit(STRIPE_OP_POSTXOR, &sh->ops.pending)) {
+        if (!test_bit(STRIPE_COMPUTE_RUN, &sh->state) && !sh->check_state &&
+            !sh->reconstruct_state)
                 for (i = disks; i--; )
-                        if (__handle_issuing_new_read_requests5(
-                                sh, s, i, disks) == 0)
+                        if (fetch_block5(sh, s, i, disks))
                                 break;
-        }
         set_bit(STRIPE_HANDLE, &sh->state);
 }
 
-static void handle_issuing_new_read_requests6(struct stripe_head *sh,
+static void handle_stripe_fill6(struct stripe_head *sh,
                         struct stripe_head_state *s, struct r6_state *r6s,
                         int disks)
 {
@@ -2121,12 +2007,12 @@ static void handle_issuing_new_read_requests6(struct stripe_head *sh,
 }
 
 
-/* handle_completed_write_requests
+/* handle_stripe_clean_event
  * any written block on an uptodate or failed drive can be returned.
  * Note that if we 'wrote' to a failed drive, it will be UPTODATE, but
  * never LOCKED, so we don't need to test 'failed' directly.
  */
-static void handle_completed_write_requests(raid5_conf_t *conf,
+static void handle_stripe_clean_event(raid5_conf_t *conf,
         struct stripe_head *sh, int disks, struct bio **return_bi)
 {
         int i;
@@ -2171,7 +2057,7 @@ static void handle_completed_write_requests(raid5_conf_t *conf,
                         md_wakeup_thread(conf->mddev->thread);
 }
 
-static void handle_issuing_new_write_requests5(raid5_conf_t *conf,
+static void handle_stripe_dirtying5(raid5_conf_t *conf,
                 struct stripe_head *sh, struct stripe_head_state *s, int disks)
 {
         int rmw = 0, rcw = 0, i;
@@ -2215,9 +2101,6 @@ static void handle_issuing_new_write_requests5(raid5_conf_t *conf,
                                                 "%d for r-m-w\n", i);
                                         set_bit(R5_LOCKED, &dev->flags);
                                         set_bit(R5_Wantread, &dev->flags);
-                                        if (!test_and_set_bit(
-                                                STRIPE_OP_IO, &sh->ops.pending))
-                                                sh->ops.count++;
                                         s->locked++;
                                 } else {
                                         set_bit(STRIPE_DELAYED, &sh->state);
@@ -2241,9 +2124,6 @@ static void handle_issuing_new_write_requests5(raid5_conf_t *conf,
                                                 "%d for Reconstruct\n", i);
                                         set_bit(R5_LOCKED, &dev->flags);
                                         set_bit(R5_Wantread, &dev->flags);
-                                        if (!test_and_set_bit(
-                                                STRIPE_OP_IO, &sh->ops.pending))
-                                                sh->ops.count++;
                                         s->locked++;
                                 } else {
                                         set_bit(STRIPE_DELAYED, &sh->state);
@@ -2261,14 +2141,13 @@ static void handle_issuing_new_write_requests5(raid5_conf_t *conf,
          * simultaneously.  If this is not the case then new writes need to be
          * held off until the compute completes.
          */
-        if ((s->req_compute ||
-            !test_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.pending)) &&
-                (s->locked == 0 && (rcw == 0 || rmw == 0) &&
-                !test_bit(STRIPE_BIT_DELAY, &sh->state)))
-                s->locked += handle_write_operations5(sh, rcw == 0, 0);
+        if ((s->req_compute || !test_bit(STRIPE_COMPUTE_RUN, &sh->state)) &&
+            (s->locked == 0 && (rcw == 0 || rmw == 0) &&
+            !test_bit(STRIPE_BIT_DELAY, &sh->state)))
+                schedule_reconstruction5(sh, s, rcw == 0, 0);
 }
 
-static void handle_issuing_new_write_requests6(raid5_conf_t *conf,
+static void handle_stripe_dirtying6(raid5_conf_t *conf,
                 struct stripe_head *sh, struct stripe_head_state *s,
                 struct r6_state *r6s, int disks)
 {
@@ -2371,92 +2250,86 @@ static void handle_issuing_new_write_requests6(raid5_conf_t *conf,
 static void handle_parity_checks5(raid5_conf_t *conf, struct stripe_head *sh,
                                 struct stripe_head_state *s, int disks)
 {
-        int canceled_check = 0;
+        struct r5dev *dev = NULL;
 
         set_bit(STRIPE_HANDLE, &sh->state);
 
-        /* complete a check operation */
-        if (test_and_clear_bit(STRIPE_OP_CHECK, &sh->ops.complete)) {
-                clear_bit(STRIPE_OP_CHECK, &sh->ops.ack);
-                clear_bit(STRIPE_OP_CHECK, &sh->ops.pending);
+        switch (sh->check_state) {
+        case check_state_idle:
+                /* start a new check operation if there are no failures */
                 if (s->failed == 0) {
-                        if (sh->ops.zero_sum_result == 0)
-                                /* parity is correct (on disc,
-                                 * not in buffer any more)
-                                 */
-                                set_bit(STRIPE_INSYNC, &sh->state);
-                        else {
-                                conf->mddev->resync_mismatches +=
-                                        STRIPE_SECTORS;
-                                if (test_bit(
-                                     MD_RECOVERY_CHECK, &conf->mddev->recovery))
-                                        /* don't try to repair!! */
-                                        set_bit(STRIPE_INSYNC, &sh->state);
-                                else {
-                                        set_bit(STRIPE_OP_COMPUTE_BLK,
-                                                &sh->ops.pending);
-                                        set_bit(STRIPE_OP_MOD_REPAIR_PD,
-                                                &sh->ops.pending);
-                                        set_bit(R5_Wantcompute,
-                                                &sh->dev[sh->pd_idx].flags);
-                                        sh->ops.target = sh->pd_idx;
-                                        sh->ops.count++;
-                                        s->uptodate++;
-                                }
-                        }
-                } else
-                        canceled_check = 1; /* STRIPE_INSYNC is not set */
-        }
-
-        /* start a new check operation if there are no failures, the stripe is
-         * not insync, and a repair is not in flight
-         */
-        if (s->failed == 0 &&
-            !test_bit(STRIPE_INSYNC, &sh->state) &&
-            !test_bit(STRIPE_OP_MOD_REPAIR_PD, &sh->ops.pending)) {
-                if (!test_and_set_bit(STRIPE_OP_CHECK, &sh->ops.pending)) {
                         BUG_ON(s->uptodate != disks);
+                        sh->check_state = check_state_run;
+                        set_bit(STRIPE_OP_CHECK, &s->ops_request);
                         clear_bit(R5_UPTODATE, &sh->dev[sh->pd_idx].flags);
-                        sh->ops.count++;
                         s->uptodate--;
+                        break;
                 }
-        }
-
-        /* check if we can clear a parity disk reconstruct */
-        if (test_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.complete) &&
-            test_bit(STRIPE_OP_MOD_REPAIR_PD, &sh->ops.pending)) {
-
-                clear_bit(STRIPE_OP_MOD_REPAIR_PD, &sh->ops.pending);
-                clear_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.complete);
-                clear_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.ack);
-                clear_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.pending);
-        }
-
+                dev = &sh->dev[s->failed_num];
+                /* fall through */
+        case check_state_compute_result:
+                sh->check_state = check_state_idle;
+                if (!dev)
+                        dev = &sh->dev[sh->pd_idx];
+
+                /* check that a write has not made the stripe insync */
+                if (test_bit(STRIPE_INSYNC, &sh->state))
+                        break;
 
-        /* Wait for check parity and compute block operations to complete
-         * before write-back.  If a failure occurred while the check operation
-         * was in flight we need to cycle this stripe through handle_stripe
-         * since the parity block may not be uptodate
-         */
-        if (!canceled_check && !test_bit(STRIPE_INSYNC, &sh->state) &&
-            !test_bit(STRIPE_OP_CHECK, &sh->ops.pending) &&
-            !test_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.pending)) {
-                struct r5dev *dev;
                 /* either failed parity check, or recovery is happening */
-                if (s->failed == 0)
-                        s->failed_num = sh->pd_idx;
-                dev = &sh->dev[s->failed_num];
                 BUG_ON(!test_bit(R5_UPTODATE, &dev->flags));
                 BUG_ON(s->uptodate != disks);
 
                 set_bit(R5_LOCKED, &dev->flags);
+                s->locked++;
                 set_bit(R5_Wantwrite, &dev->flags);
-                if (!test_and_set_bit(STRIPE_OP_IO, &sh->ops.pending))
-                        sh->ops.count++;
 
                 clear_bit(STRIPE_DEGRADED, &sh->state);
-                s->locked++;
                 set_bit(STRIPE_INSYNC, &sh->state);
+                break;
+        case check_state_run:
+                break; /* we will be called again upon completion */
+        case check_state_check_result:
+                sh->check_state = check_state_idle;
+
+                /* if a failure occurred during the check operation, leave
+                 * STRIPE_INSYNC not set and let the stripe be handled again
+                 */
+                if (s->failed)
+                        break;
+
+                /* handle a successful check operation, if parity is correct
+                 * we are done.  Otherwise update the mismatch count and repair
+                 * parity if !MD_RECOVERY_CHECK
+                 */
+                if (sh->ops.zero_sum_result == 0)
+                        /* parity is correct (on disc,
+                         * not in buffer any more)
+                         */
+                        set_bit(STRIPE_INSYNC, &sh->state);
+                else {
+                        conf->mddev->resync_mismatches += STRIPE_SECTORS;
+                        if (test_bit(MD_RECOVERY_CHECK, &conf->mddev->recovery))
+                                /* don't try to repair!! */
+                                set_bit(STRIPE_INSYNC, &sh->state);
+                        else {
+                                sh->check_state = check_state_compute_run;
+                                set_bit(STRIPE_COMPUTE_RUN, &sh->state);
+                                set_bit(STRIPE_OP_COMPUTE_BLK, &s->ops_request);
+                                set_bit(R5_Wantcompute,
+                                        &sh->dev[sh->pd_idx].flags);
+                                sh->ops.target = sh->pd_idx;
+                                s->uptodate++;
+                        }
+                }
+                break;
+        case check_state_compute_run:
+                break;
+        default:
+                printk(KERN_ERR "%s: unknown check_state: %d sector: %llu\n",
+                       __func__, sh->check_state,
+                       (unsigned long long) sh->sector);
+                BUG();
         }
 }
 
@@ -2641,15 +2514,14 @@ static void handle_stripe5(struct stripe_head *sh)
         struct bio *return_bi = NULL;
         struct stripe_head_state s;
         struct r5dev *dev;
-        unsigned long pending = 0;
         mdk_rdev_t *blocked_rdev = NULL;
         int prexor;
 
         memset(&s, 0, sizeof(s));
-        pr_debug("handling stripe %llu, state=%#lx cnt=%d, pd_idx=%d "
-                "ops=%lx:%lx:%lx\n", (unsigned long long)sh->sector, sh->state,
-                atomic_read(&sh->count), sh->pd_idx,
-                sh->ops.pending, sh->ops.ack, sh->ops.complete);
+        pr_debug("handling stripe %llu, state=%#lx cnt=%d, pd_idx=%d check:%d "
+                 "reconstruct:%d\n", (unsigned long long)sh->sector, sh->state,
+                 atomic_read(&sh->count), sh->pd_idx, sh->check_state,
+                 sh->reconstruct_state);
 
         spin_lock(&sh->lock);
         clear_bit(STRIPE_HANDLE, &sh->state);
@@ -2658,15 +2530,8 @@ static void handle_stripe5(struct stripe_head *sh)
         s.syncing = test_bit(STRIPE_SYNCING, &sh->state);
         s.expanding = test_bit(STRIPE_EXPAND_SOURCE, &sh->state);
         s.expanded = test_bit(STRIPE_EXPAND_READY, &sh->state);
-        /* Now to look around and see what can be done */
-
-        /* clean-up completed biofill operations */
-        if (test_bit(STRIPE_OP_BIOFILL, &sh->ops.complete)) {
-                clear_bit(STRIPE_OP_BIOFILL, &sh->ops.pending);
-                clear_bit(STRIPE_OP_BIOFILL, &sh->ops.ack);
-                clear_bit(STRIPE_OP_BIOFILL, &sh->ops.complete);
-        }
 
+        /* Now to look around and see what can be done */
         rcu_read_lock();
         for (i=disks; i--; ) {
                 mdk_rdev_t *rdev;
@@ -2680,10 +2545,10 @@ static void handle_stripe5(struct stripe_head *sh)
                 /* maybe we can request a biofill operation
                  *
                  * new wantfill requests are only permitted while
-                 * STRIPE_OP_BIOFILL is clear
+                 * ops_complete_biofill is guaranteed to be inactive
                  */
                 if (test_bit(R5_UPTODATE, &dev->flags) && dev->toread &&
-                        !test_bit(STRIPE_OP_BIOFILL, &sh->ops.pending))
+                    !test_bit(STRIPE_BIOFILL_RUN, &sh->state))
                         set_bit(R5_Wantfill, &dev->flags);
 
                 /* now count some things */
@@ -2727,8 +2592,10 @@ static void handle_stripe5(struct stripe_head *sh)
                 goto unlock;
         }
 
-        if (s.to_fill && !test_and_set_bit(STRIPE_OP_BIOFILL, &sh->ops.pending))
-                sh->ops.count++;
+        if (s.to_fill && !test_bit(STRIPE_BIOFILL_RUN, &sh->state)) {
+                set_bit(STRIPE_OP_BIOFILL, &s.ops_request);
+                set_bit(STRIPE_BIOFILL_RUN, &sh->state);
+        }
 
         pr_debug("locked=%d uptodate=%d to_read=%d"
                 " to_write=%d failed=%d failed_num=%d\n",
@@ -2738,8 +2605,7 @@ static void handle_stripe5(struct stripe_head *sh)
          * need to be failed
          */
         if (s.failed > 1 && s.to_read+s.to_write+s.written)
-                handle_requests_to_failed_array(conf, sh, &s, disks,
-                                                &return_bi);
+                handle_failed_stripe(conf, sh, &s, disks, &return_bi);
         if (s.failed > 1 && s.syncing) {
                 md_done_sync(conf->mddev, STRIPE_SECTORS,0);
                 clear_bit(STRIPE_SYNCING, &sh->state);
@@ -2755,48 +2621,25 @@ static void handle_stripe5(struct stripe_head *sh)
                !test_bit(R5_LOCKED, &dev->flags) &&
                test_bit(R5_UPTODATE, &dev->flags)) ||
                (s.failed == 1 && s.failed_num == sh->pd_idx)))
-                handle_completed_write_requests(conf, sh, disks, &return_bi);
+                handle_stripe_clean_event(conf, sh, disks, &return_bi);
 
         /* Now we might consider reading some blocks, either to check/generate
          * parity, or to satisfy requests
          * or to load a block that is being partially written.
          */
         if (s.to_read || s.non_overwrite ||
-            (s.syncing && (s.uptodate + s.compute < disks)) || s.expanding ||
-            test_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.pending))
-                handle_issuing_new_read_requests5(sh, &s, disks);
+            (s.syncing && (s.uptodate + s.compute < disks)) || s.expanding)
+                handle_stripe_fill5(sh, &s, disks);
 
         /* Now we check to see if any write operations have recently
          * completed
          */
-
-        /* leave prexor set until postxor is done, allows us to distinguish
-         * a rmw from a rcw during biodrain
-         */
         prexor = 0;
-        if (test_bit(STRIPE_OP_PREXOR, &sh->ops.complete) &&
-                test_bit(STRIPE_OP_POSTXOR, &sh->ops.complete)) {
-
+        if (sh->reconstruct_state == reconstruct_state_prexor_drain_result)
                 prexor = 1;
-                clear_bit(STRIPE_OP_PREXOR, &sh->ops.complete);
-                clear_bit(STRIPE_OP_PREXOR, &sh->ops.ack);
-                clear_bit(STRIPE_OP_PREXOR, &sh->ops.pending);
-
-                for (i = disks; i--; )
-                        clear_bit(R5_Wantprexor, &sh->dev[i].flags);
-        }
-
-        /* if only POSTXOR is set then this is an 'expand' postxor */
-        if (test_bit(STRIPE_OP_BIODRAIN, &sh->ops.complete) &&
-                test_bit(STRIPE_OP_POSTXOR, &sh->ops.complete)) {
-
-                clear_bit(STRIPE_OP_BIODRAIN, &sh->ops.complete);
-                clear_bit(STRIPE_OP_BIODRAIN, &sh->ops.ack);
-                clear_bit(STRIPE_OP_BIODRAIN, &sh->ops.pending);
-
-                clear_bit(STRIPE_OP_POSTXOR, &sh->ops.complete);
-                clear_bit(STRIPE_OP_POSTXOR, &sh->ops.ack);
-                clear_bit(STRIPE_OP_POSTXOR, &sh->ops.pending);
+        if (sh->reconstruct_state == reconstruct_state_drain_result ||
+            sh->reconstruct_state == reconstruct_state_prexor_drain_result) {
+                sh->reconstruct_state = reconstruct_state_idle;
 
                 /* All the 'written' buffers and the parity block are ready to
                  * be written back to disk
@@ -2808,9 +2651,6 @@ static void handle_stripe5(struct stripe_head *sh)
                                 (i == sh->pd_idx || dev->written)) {
                                 pr_debug("Writing block %d\n", i);
                                 set_bit(R5_Wantwrite, &dev->flags);
-                                if (!test_and_set_bit(
-                                    STRIPE_OP_IO, &sh->ops.pending))
-                                        sh->ops.count++;
                                 if (prexor)
                                         continue;
                                 if (!test_bit(R5_Insync, &dev->flags) ||
@@ -2832,20 +2672,18 @@ static void handle_stripe5(struct stripe_head *sh)
          * 2/ A 'check' operation is in flight, as it may clobber the parity
          *    block.
          */
-        if (s.to_write && !test_bit(STRIPE_OP_POSTXOR, &sh->ops.pending) &&
-                          !test_bit(STRIPE_OP_CHECK, &sh->ops.pending))
-                handle_issuing_new_write_requests5(conf, sh, &s, disks);
+        if (s.to_write && !sh->reconstruct_state && !sh->check_state)
+                handle_stripe_dirtying5(conf, sh, &s, disks);
 
         /* maybe we need to check and possibly fix the parity for this stripe
          * Any reads will already have been scheduled, so we just see if enough
          * data is available.  The parity check is held off while parity
          * dependent operations are in flight.
          */
-        if ((s.syncing && s.locked == 0 &&
-             !test_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.pending) &&
-             !test_bit(STRIPE_INSYNC, &sh->state)) ||
-              test_bit(STRIPE_OP_CHECK, &sh->ops.pending) ||
-              test_bit(STRIPE_OP_MOD_REPAIR_PD, &sh->ops.pending))
+        if (sh->check_state ||
+            (s.syncing && s.locked == 0 &&
+             !test_bit(STRIPE_COMPUTE_RUN, &sh->state) &&
+             !test_bit(STRIPE_INSYNC, &sh->state)))
                 handle_parity_checks5(conf, sh, &s, disks);
 
         if (s.syncing && s.locked == 0 && test_bit(STRIPE_INSYNC, &sh->state)) {
@@ -2864,52 +2702,35 @@ static void handle_stripe5(struct stripe_head *sh)
                 dev = &sh->dev[s.failed_num];
                 if (!test_bit(R5_ReWrite, &dev->flags)) {
                         set_bit(R5_Wantwrite, &dev->flags);
-                        if (!test_and_set_bit(STRIPE_OP_IO, &sh->ops.pending))
-                                sh->ops.count++;
                         set_bit(R5_ReWrite, &dev->flags);
                         set_bit(R5_LOCKED, &dev->flags);
                         s.locked++;
                 } else {
                         /* let's read it back */
                         set_bit(R5_Wantread, &dev->flags);
-                        if (!test_and_set_bit(STRIPE_OP_IO, &sh->ops.pending))
-                                sh->ops.count++;
                         set_bit(R5_LOCKED, &dev->flags);
                         s.locked++;
                 }
         }
 
-        /* Finish postxor operations initiated by the expansion
-         * process
-         */
-        if (test_bit(STRIPE_OP_POSTXOR, &sh->ops.complete) &&
-                !test_bit(STRIPE_OP_BIODRAIN, &sh->ops.pending)) {
-
+        /* Finish reconstruct operations initiated by the expansion process */
+        if (sh->reconstruct_state == reconstruct_state_result) {
+                sh->reconstruct_state = reconstruct_state_idle;
                 clear_bit(STRIPE_EXPANDING, &sh->state);
-
-                clear_bit(STRIPE_OP_POSTXOR, &sh->ops.pending);
-                clear_bit(STRIPE_OP_POSTXOR, &sh->ops.ack);
-                clear_bit(STRIPE_OP_POSTXOR, &sh->ops.complete);
-
-                for (i = conf->raid_disks; i--; ) {
+                for (i = conf->raid_disks; i--; )
                         set_bit(R5_Wantwrite, &sh->dev[i].flags);
                         set_bit(R5_LOCKED, &dev->flags);
                         s.locked++;
-                        if (!test_and_set_bit(STRIPE_OP_IO, &sh->ops.pending))
-                                sh->ops.count++;
-                }
         }
 
         if (s.expanded && test_bit(STRIPE_EXPANDING, &sh->state) &&
-                !test_bit(STRIPE_OP_POSTXOR, &sh->ops.pending)) {
+            !sh->reconstruct_state) {
                 /* Need to write out all blocks after computing parity */
                 sh->disks = conf->raid_disks;
                 sh->pd_idx = stripe_to_pdidx(sh->sector, conf,
                         conf->raid_disks);
-                s.locked += handle_write_operations5(sh, 1, 1);
-        } else if (s.expanded &&
-                   s.locked == 0 &&
-                !test_bit(STRIPE_OP_POSTXOR, &sh->ops.pending)) {
+                schedule_reconstruction5(sh, &s, 1, 1);
+        } else if (s.expanded && !sh->reconstruct_state && s.locked == 0) {
                 clear_bit(STRIPE_EXPAND_READY, &sh->state);
                 atomic_dec(&conf->reshape_stripes);
                 wake_up(&conf->wait_for_overlap);
@@ -2917,12 +2738,9 @@ static void handle_stripe5(struct stripe_head *sh)
         }
 
         if (s.expanding && s.locked == 0 &&
-            !test_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.pending))
+            !test_bit(STRIPE_COMPUTE_RUN, &sh->state))
                 handle_stripe_expansion(conf, sh, NULL);
 
-        if (sh->ops.count)
-                pending = get_stripe_work(sh);
-
  unlock:
         spin_unlock(&sh->lock);
 
@@ -2930,11 +2748,12 @@ static void handle_stripe5(struct stripe_head *sh)
         if (unlikely(blocked_rdev))
                 md_wait_for_blocked_rdev(blocked_rdev, conf->mddev);
 
-        if (pending)
-                raid5_run_ops(sh, pending);
+        if (s.ops_request)
+                raid5_run_ops(sh, s.ops_request);
 
-        return_io(return_bi);
+        ops_run_io(sh, &s);
 
+        return_io(return_bi);
 }
 
 static void handle_stripe6(struct stripe_head *sh, struct page *tmp_page)
@@ -3042,8 +2861,7 @@ static void handle_stripe6(struct stripe_head *sh, struct page *tmp_page)
          * might need to be failed
          */
         if (s.failed > 2 && s.to_read+s.to_write+s.written)
-                handle_requests_to_failed_array(conf, sh, &s, disks,
-                                                &return_bi);
+                handle_failed_stripe(conf, sh, &s, disks, &return_bi);
         if (s.failed > 2 && s.syncing) {
                 md_done_sync(conf->mddev, STRIPE_SECTORS,0);
                 clear_bit(STRIPE_SYNCING, &sh->state);
@@ -3068,7 +2886,7 @@ static void handle_stripe6(struct stripe_head *sh, struct page *tmp_page)
              ( r6s.q_failed || ((test_bit(R5_Insync, &qdev->flags)
                              && !test_bit(R5_LOCKED, &qdev->flags)
                              && test_bit(R5_UPTODATE, &qdev->flags)))))
-                handle_completed_write_requests(conf, sh, disks, &return_bi);
+                handle_stripe_clean_event(conf, sh, disks, &return_bi);
 
         /* Now we might consider reading some blocks, either to check/generate
          * parity, or to satisfy requests
@@ -3076,11 +2894,11 @@ static void handle_stripe6(struct stripe_head *sh, struct page *tmp_page)
          */
         if (s.to_read || s.non_overwrite || (s.to_write && s.failed) ||
             (s.syncing && (s.uptodate < disks)) || s.expanding)
-                handle_issuing_new_read_requests6(sh, &s, &r6s, disks);
+                handle_stripe_fill6(sh, &s, &r6s, disks);
 
         /* now to consider writing and what else, if anything should be read */
         if (s.to_write)
-                handle_issuing_new_write_requests6(conf, sh, &s, &r6s, disks);
+                handle_stripe_dirtying6(conf, sh, &s, &r6s, disks);
 
         /* maybe we need to check and possibly fix the parity for this stripe
          * Any reads will already have been scheduled, so we just see if enough
@@ -3136,7 +2954,7 @@ static void handle_stripe6(struct stripe_head *sh, struct page *tmp_page)
         }
 
         if (s.expanding && s.locked == 0 &&
-            !test_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.pending))
+            !test_bit(STRIPE_COMPUTE_RUN, &sh->state))
                 handle_stripe_expansion(conf, sh, &r6s);
 
  unlock:
@@ -3146,68 +2964,9 @@ static void handle_stripe6(struct stripe_head *sh, struct page *tmp_page)
         if (unlikely(blocked_rdev))
                 md_wait_for_blocked_rdev(blocked_rdev, conf->mddev);
 
-        return_io(return_bi);
-
-        for (i=disks; i-- ;) {
-                int rw;
-                struct bio *bi;
-                mdk_rdev_t *rdev;
-                if (test_and_clear_bit(R5_Wantwrite, &sh->dev[i].flags))
-                        rw = WRITE;
-                else if (test_and_clear_bit(R5_Wantread, &sh->dev[i].flags))
-                        rw = READ;
-                else
-                        continue;
-
-                set_bit(STRIPE_IO_STARTED, &sh->state);
-
-                bi = &sh->dev[i].req;
-
-                bi->bi_rw = rw;
-                if (rw == WRITE)
-                        bi->bi_end_io = raid5_end_write_request;
-                else
-                        bi->bi_end_io = raid5_end_read_request;
-
-                rcu_read_lock();
-                rdev = rcu_dereference(conf->disks[i].rdev);
-                if (rdev && test_bit(Faulty, &rdev->flags))
-                        rdev = NULL;
-                if (rdev)
-                        atomic_inc(&rdev->nr_pending);
-                rcu_read_unlock();
+        ops_run_io(sh, &s);
 
-                if (rdev) {
-                        if (s.syncing || s.expanding || s.expanded)
-                                md_sync_acct(rdev->bdev, STRIPE_SECTORS);
-
-                        bi->bi_bdev = rdev->bdev;
-                        pr_debug("for %llu schedule op %ld on disc %d\n",
-                                (unsigned long long)sh->sector, bi->bi_rw, i);
-                        atomic_inc(&sh->count);
-                        bi->bi_sector = sh->sector + rdev->data_offset;
-                        bi->bi_flags = 1 << BIO_UPTODATE;
-                        bi->bi_vcnt = 1;
-                        bi->bi_max_vecs = 1;
-                        bi->bi_idx = 0;
-                        bi->bi_io_vec = &sh->dev[i].vec;
-                        bi->bi_io_vec[0].bv_len = STRIPE_SIZE;
-                        bi->bi_io_vec[0].bv_offset = 0;
-                        bi->bi_size = STRIPE_SIZE;
-                        bi->bi_next = NULL;
-                        if (rw == WRITE &&
-                            test_bit(R5_ReWrite, &sh->dev[i].flags))
-                                atomic_add(STRIPE_SECTORS, &rdev->corrected_errors);
-                        generic_make_request(bi);
-                } else {
-                        if (rw == WRITE)
-                                set_bit(STRIPE_DEGRADED, &sh->state);
-                        pr_debug("skip op %ld on disc %d for sector %llu\n",
-                                bi->bi_rw, i, (unsigned long long)sh->sector);
-                        clear_bit(R5_LOCKED, &sh->dev[i].flags);
-                        set_bit(STRIPE_HANDLE, &sh->state);
-                }
-        }
+        return_io(return_bi);
 }
 
 static void handle_stripe(struct stripe_head *sh, struct page *tmp_page)
@@ -3697,9 +3456,7 @@ static int make_request(struct request_queue *q, struct bio * bi)
                 if ( rw == WRITE )
                         md_write_end(mddev);
 
-                bi->bi_end_io(bi,
-                              test_bit(BIO_UPTODATE, &bi->bi_flags)
-                                ? 0 : -EIO);
+                bio_endio(bi, 0);
         }
         return 0;
 }
@@ -3785,7 +3542,7 @@ static sector_t reshape_request(mddev_t *mddev, sector_t sector_nr, int *skipped
                             j == raid6_next_disk(sh->pd_idx, sh->disks))
                                 continue;
                         s = compute_blocknr(sh, j);
-                        if (s < (mddev->array_size<<1)) {
+                        if (s < mddev->array_sectors) {
                                 skipped = 1;
                                 continue;
                         }
@@ -4002,12 +3759,8 @@ static int  retry_aligned_read(raid5_conf_t *conf, struct bio *raid_bio)
         spin_lock_irq(&conf->device_lock);
         remaining = --raid_bio->bi_phys_segments;
         spin_unlock_irq(&conf->device_lock);
-        if (remaining == 0) {
-
-                raid_bio->bi_end_io(raid_bio,
-                              test_bit(BIO_UPTODATE, &raid_bio->bi_flags)
-                                ? 0 : -EIO);
-        }
+        if (remaining == 0)
+                bio_endio(raid_bio, 0);
         if (atomic_dec_and_test(&conf->active_aligned_reads))
                 wake_up(&conf->wait_for_stripe);
         return handled;
@@ -4094,6 +3847,8 @@ raid5_store_stripe_cache_size(mddev_t *mddev, const char *page, size_t len)
 {
         raid5_conf_t *conf = mddev_to_conf(mddev);
         unsigned long new;
+        int err;
+
         if (len >= PAGE_SIZE)
                 return -EINVAL;
         if (!conf)
@@ -4109,7 +3864,9 @@ raid5_store_stripe_cache_size(mddev_t *mddev, const char *page, size_t len)
                 else
                         break;
         }
-        md_allow_write(mddev);
+        err = md_allow_write(mddev);
+        if (err)
+                return err;
         while (new > conf->max_nr_stripes) {
                 if (grow_one_stripe(conf))
                         conf->max_nr_stripes++;
@@ -4434,7 +4191,7 @@ static int run(mddev_t *mddev)
         mddev->queue->backing_dev_info.congested_data = mddev;
         mddev->queue->backing_dev_info.congested_fn = raid5_congested;
 
-        mddev->array_size =  mddev->size * (conf->previous_raid_disks -
+        mddev->array_sectors = 2 * mddev->size * (conf->previous_raid_disks -
                                             conf->max_degraded);
 
         blk_queue_merge_bvec(mddev->queue, raid5_mergeable_bvec);
@@ -4609,35 +4366,41 @@ abort:
 static int raid5_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
 {
         raid5_conf_t *conf = mddev->private;
-        int found = 0;
+        int err = -EEXIST;
         int disk;
         struct disk_info *p;
+        int first = 0;
+        int last = conf->raid_disks - 1;
 
         if (mddev->degraded > conf->max_degraded)
                 /* no point adding a device */
-                return 0;
+                return -EINVAL;
+
+        if (rdev->raid_disk >= 0)
+                first = last = rdev->raid_disk;
 
         /*
          * find the disk ... but prefer rdev->saved_raid_disk
          * if possible.
          */
         if (rdev->saved_raid_disk >= 0 &&
+            rdev->saved_raid_disk >= first &&
             conf->disks[rdev->saved_raid_disk].rdev == NULL)
                 disk = rdev->saved_raid_disk;
         else
-                disk = 0;
-        for ( ; disk < conf->raid_disks; disk++)
+                disk = first;
+        for ( ; disk <= last ; disk++)
                 if ((p=conf->disks + disk)->rdev == NULL) {
                         clear_bit(In_sync, &rdev->flags);
                         rdev->raid_disk = disk;
-                        found = 1;
+                        err = 0;
                         if (rdev->saved_raid_disk != disk)
                                 conf->fullsync = 1;
                         rcu_assign_pointer(p->rdev, rdev);
                         break;
                 }
         print_raid5_conf(conf);
-        return found;
+        return err;
 }
 
 static int raid5_resize(mddev_t *mddev, sector_t sectors)
@@ -4652,8 +4415,9 @@ static int raid5_resize(mddev_t *mddev, sector_t sectors)
         raid5_conf_t *conf = mddev_to_conf(mddev);
 
         sectors &= ~((sector_t)mddev->chunk_size/512 - 1);
-        mddev->array_size = (sectors * (mddev->raid_disks-conf->max_degraded))>>1;
-        set_capacity(mddev->gendisk, mddev->array_size << 1);
+        mddev->array_sectors = sectors * (mddev->raid_disks
+                                          - conf->max_degraded);
+        set_capacity(mddev->gendisk, mddev->array_sectors);
         mddev->changed = 1;
         if (sectors/2  > mddev->size && mddev->recovery_cp == MaxSector) {
                 mddev->recovery_cp = mddev->size << 1;
@@ -4738,7 +4502,7 @@ static int raid5_start_reshape(mddev_t *mddev)
         rdev_for_each(rdev, rtmp, mddev)
                 if (rdev->raid_disk < 0 &&
                     !test_bit(Faulty, &rdev->flags)) {
-                        if (raid5_add_disk(mddev, rdev)) {
+                        if (raid5_add_disk(mddev, rdev) == 0) {
                                 char nm[20];
                                 set_bit(In_sync, &rdev->flags);
                                 added_devices++;
@@ -4786,15 +4550,16 @@ static void end_reshape(raid5_conf_t *conf)
         struct block_device *bdev;
 
         if (!test_bit(MD_RECOVERY_INTR, &conf->mddev->recovery)) {
-                conf->mddev->array_size = conf->mddev->size *
+                conf->mddev->array_sectors = 2 * conf->mddev->size *
                         (conf->raid_disks - conf->max_degraded);
-                set_capacity(conf->mddev->gendisk, conf->mddev->array_size << 1);
+                set_capacity(conf->mddev->gendisk, conf->mddev->array_sectors);
                 conf->mddev->changed = 1;
 
                 bdev = bdget_disk(conf->mddev->gendisk, 0);
                 if (bdev) {
                         mutex_lock(&bdev->bd_inode->i_mutex);
-                        i_size_write(bdev->bd_inode, (loff_t)conf->mddev->array_size << 10);
+                        i_size_write(bdev->bd_inode,
+                                     (loff_t)conf->mddev->array_sectors << 9);
                         mutex_unlock(&bdev->bd_inode->i_mutex);
                         bdput(bdev);
                 }
diff --git a/drivers/sbus/char/uctrl.c b/drivers/sbus/char/uctrl.c
index 513ba61ae966..777637594acd 100644
--- a/drivers/sbus/char/uctrl.c
+++ b/drivers/sbus/char/uctrl.c
@@ -195,8 +195,8 @@ struct uctrl_driver {
 
 static struct uctrl_driver drv;
 
-void uctrl_get_event_status(void);
-void uctrl_get_external_status(void);
+static void uctrl_get_event_status(void);
+static void uctrl_get_external_status(void);
 
 static int
 uctrl_ioctl(struct inode *inode, struct file *file,
@@ -266,12 +266,6 @@ static struct miscdevice uctrl_dev = {
   driver->regs->uctrl_stat = UCTRL_STAT_RXNE_STA; \
 }
 
-void uctrl_set_video(int status)
-{
-        struct uctrl_driver *driver = &drv;
-        
-}
-
 static void uctrl_do_txn(struct uctrl_txn *txn)
 {
         struct uctrl_driver *driver = &drv;
@@ -311,7 +305,7 @@ static void uctrl_do_txn(struct uctrl_txn *txn)
         }
 }
 
-void uctrl_get_event_status(void)
+static void uctrl_get_event_status(void)
 {
         struct uctrl_driver *driver = &drv;
         struct uctrl_txn txn;
@@ -331,7 +325,7 @@ void uctrl_get_event_status(void)
         dprintk(("ev is %x\n", driver->status.event_status));
 }
 
-void uctrl_get_external_status(void)
+static void uctrl_get_external_status(void)
 {
         struct uctrl_driver *driver = &drv;
         struct uctrl_txn txn;
@@ -363,7 +357,7 @@ void uctrl_get_external_status(void)
 static int __init ts102_uctrl_init(void)
 {
         struct uctrl_driver *driver = &drv;
-        int len, i;
+        int len;
         struct linux_prom_irqs tmp_irq[2];
         unsigned int vaddr[2] = { 0, 0 };
         int tmpnode, uctrlnode = prom_getchild(prom_root_node);
diff --git a/drivers/sbus/char/vfc.h b/drivers/sbus/char/vfc.h
index f1aa1389ea4a..a5240c52aa0b 100644
--- a/drivers/sbus/char/vfc.h
+++ b/drivers/sbus/char/vfc.h
@@ -133,8 +133,6 @@ struct vfc_dev {
         unsigned char saa9051_state_array[VFC_SAA9051_NR];
 };
 
-extern struct vfc_dev **vfc_dev_lst;
-
 void captstat_reset(struct vfc_dev *);
 void memptr_reset(struct vfc_dev *);
 
@@ -145,8 +143,6 @@ int vfc_i2c_sendbuf(struct vfc_dev *, unsigned char, char *, int) ;
 int vfc_i2c_recvbuf(struct vfc_dev *, unsigned char, char *, int) ;
 int vfc_i2c_reset_bus(struct vfc_dev *);
 int vfc_init_i2c_bus(struct vfc_dev *);
-void vfc_lock_device(struct vfc_dev *);
-void vfc_unlock_device(struct vfc_dev *);
 
 #define VFC_CONTROL_DIAGMODE  0x10000000
 #define VFC_CONTROL_MEMPTR    0x20000000
diff --git a/drivers/sbus/char/vfc_dev.c b/drivers/sbus/char/vfc_dev.c
index 1f6cb8ae2784..25181bb7d627 100644
--- a/drivers/sbus/char/vfc_dev.c
+++ b/drivers/sbus/char/vfc_dev.c
@@ -45,7 +45,7 @@
 #include <asm/vfc_ioctls.h>
 
 static const struct file_operations vfc_fops;
-struct vfc_dev **vfc_dev_lst;
+static struct vfc_dev **vfc_dev_lst;
 static char vfcstr[]="vfc";
 static unsigned char saa9051_init_array[VFC_SAA9051_NR] = {
         0x00, 0x64, 0x72, 0x52,
@@ -54,18 +54,18 @@ static unsigned char saa9051_init_array[VFC_SAA9051_NR] = {
         0x3e
 };
 
-void vfc_lock_device(struct vfc_dev *dev)
+static void vfc_lock_device(struct vfc_dev *dev)
 {
         mutex_lock(&dev->device_lock_mtx);
 }
 
-void vfc_unlock_device(struct vfc_dev *dev)
+static void vfc_unlock_device(struct vfc_dev *dev)
 {
         mutex_unlock(&dev->device_lock_mtx);
 }
 
 
-void vfc_captstat_reset(struct vfc_dev *dev) 
+static void vfc_captstat_reset(struct vfc_dev *dev)
 {
         dev->control_reg |= VFC_CONTROL_CAPTRESET;
         sbus_writel(dev->control_reg, &dev->regs->control);
@@ -75,7 +75,7 @@ void vfc_captstat_reset(struct vfc_dev *dev)
         sbus_writel(dev->control_reg, &dev->regs->control);
 }
 
-void vfc_memptr_reset(struct vfc_dev *dev) 
+static void vfc_memptr_reset(struct vfc_dev *dev)
 {
         dev->control_reg |= VFC_CONTROL_MEMPTR;
         sbus_writel(dev->control_reg, &dev->regs->control);
@@ -85,7 +85,7 @@ void vfc_memptr_reset(struct vfc_dev *dev)
         sbus_writel(dev->control_reg, &dev->regs->control);
 }
 
-int vfc_csr_init(struct vfc_dev *dev)
+static int vfc_csr_init(struct vfc_dev *dev)
 {
         dev->control_reg = 0x80000000;
         sbus_writel(dev->control_reg, &dev->regs->control);
@@ -107,7 +107,7 @@ int vfc_csr_init(struct vfc_dev *dev)
         return 0;
 }
 
-int vfc_saa9051_init(struct vfc_dev *dev)
+static int vfc_saa9051_init(struct vfc_dev *dev)
 {
         int i;
 
@@ -119,7 +119,7 @@ int vfc_saa9051_init(struct vfc_dev *dev)
         return 0;
 }
 
-int init_vfc_hw(struct vfc_dev *dev) 
+static int init_vfc_hw(struct vfc_dev *dev)
 {
         vfc_lock_device(dev);
         vfc_csr_init(dev);
@@ -132,7 +132,7 @@ int init_vfc_hw(struct vfc_dev *dev)
         return 0; 
 }
 
-int init_vfc_devstruct(struct vfc_dev *dev, int instance) 
+static int init_vfc_devstruct(struct vfc_dev *dev, int instance)
 {
         dev->instance=instance;
         mutex_init(&dev->device_lock_mtx);
@@ -141,7 +141,8 @@ int init_vfc_devstruct(struct vfc_dev *dev, int instance)
         return 0;
 }
 
-int init_vfc_device(struct sbus_dev *sdev,struct vfc_dev *dev, int instance)
+static int init_vfc_device(struct sbus_dev *sdev,struct vfc_dev *dev,
+                           int instance)
 {
         if(dev == NULL) {
                 printk(KERN_ERR "VFC: Bogus pointer passed\n");
@@ -168,7 +169,7 @@ int init_vfc_device(struct sbus_dev *sdev,struct vfc_dev *dev, int instance)
 }
 
 
-struct vfc_dev *vfc_get_dev_ptr(int instance) 
+static struct vfc_dev *vfc_get_dev_ptr(int instance)
 {
         return vfc_dev_lst[instance];
 }
@@ -292,7 +293,7 @@ static int vfc_debug(struct vfc_dev *dev, int cmd, void __user *argp)
         return 0;
 }
 
-int vfc_capture_start(struct vfc_dev *dev) 
+static int vfc_capture_start(struct vfc_dev *dev)
 {
         vfc_captstat_reset(dev);
         dev->control_reg = sbus_readl(&dev->regs->control);
@@ -314,7 +315,7 @@ int vfc_capture_start(struct vfc_dev *dev)
         return 0;
 }
 
-int vfc_capture_poll(struct vfc_dev *dev) 
+static int vfc_capture_poll(struct vfc_dev *dev)
 {
         int timeout = 1000;
 
@@ -390,8 +391,8 @@ static int vfc_set_control_ioctl(struct inode *inode, struct file *file,
 }
 
 
-int vfc_port_change_ioctl(struct inode *inode, struct file *file, 
-                          struct vfc_dev *dev, unsigned long arg) 
+static int vfc_port_change_ioctl(struct inode *inode, struct file *file,
+                                 struct vfc_dev *dev, unsigned long arg)
 {
         int ret = 0;
         int cmd;
@@ -460,8 +461,8 @@ int vfc_port_change_ioctl(struct inode *inode, struct file *file,
         return ret;
 }
 
-int vfc_set_video_ioctl(struct inode *inode, struct file *file, 
-                        struct vfc_dev *dev, unsigned long arg) 
+static int vfc_set_video_ioctl(struct inode *inode, struct file *file,
+                               struct vfc_dev *dev, unsigned long arg)
 {
         int ret = 0;
         int cmd;
@@ -511,8 +512,8 @@ int vfc_set_video_ioctl(struct inode *inode, struct file *file,
         return ret;
 }
 
-int vfc_get_video_ioctl(struct inode *inode, struct file *file, 
-                        struct vfc_dev *dev, unsigned long arg) 
+static int vfc_get_video_ioctl(struct inode *inode, struct file *file,
+                               struct vfc_dev *dev, unsigned long arg)
 {
         int ret = 0;
         unsigned int status = NO_LOCK;
diff --git a/drivers/sbus/char/vfc_i2c.c b/drivers/sbus/char/vfc_i2c.c
index 9efed771f6c0..32b986e0ed78 100644
--- a/drivers/sbus/char/vfc_i2c.c
+++ b/drivers/sbus/char/vfc_i2c.c
@@ -114,7 +114,7 @@ int vfc_i2c_reset_bus(struct vfc_dev *dev)
         return 0;
 }
 
-int vfc_i2c_wait_for_bus(struct vfc_dev *dev) 
+static int vfc_i2c_wait_for_bus(struct vfc_dev *dev)
 {
         int timeout = 1000; 
 
@@ -126,7 +126,7 @@ int vfc_i2c_wait_for_bus(struct vfc_dev *dev)
         return 0;
 }
 
-int vfc_i2c_wait_for_pin(struct vfc_dev *dev, int ack)
+static int vfc_i2c_wait_for_pin(struct vfc_dev *dev, int ack)
 {
         int timeout = 1000; 
         int s1;
@@ -144,7 +144,8 @@ int vfc_i2c_wait_for_pin(struct vfc_dev *dev, int ack)
 }
 
 #define SHIFT(a) ((a) << 24)
-int vfc_i2c_xmit_addr(struct vfc_dev *dev, unsigned char addr, char mode) 
+static int vfc_i2c_xmit_addr(struct vfc_dev *dev, unsigned char addr,
+                             char mode)
 { 
         int ret, raddr;
 #if 1
@@ -195,7 +196,7 @@ int vfc_i2c_xmit_addr(struct vfc_dev *dev, unsigned char addr, char mode)
         return 0;
 }
 
-int vfc_i2c_xmit_byte(struct vfc_dev *dev,unsigned char *byte) 
+static int vfc_i2c_xmit_byte(struct vfc_dev *dev,unsigned char *byte)
 {
         int ret;
         u32 val = SHIFT((unsigned int)*byte);
@@ -218,7 +219,8 @@ int vfc_i2c_xmit_byte(struct vfc_dev *dev,unsigned char *byte)
         return ret;
 }
 
-int vfc_i2c_recv_byte(struct vfc_dev *dev, unsigned char *byte, int last) 
+static int vfc_i2c_recv_byte(struct vfc_dev *dev, unsigned char *byte,
+                             int last)
 {
         int ret;
 
diff --git a/drivers/sbus/dvma.c b/drivers/sbus/dvma.c
index 57e1526746a2..ab0d2de3324c 100644
--- a/drivers/sbus/dvma.c
+++ b/drivers/sbus/dvma.c
@@ -16,7 +16,7 @@
 
 struct sbus_dma *dma_chain;
 
-void __init init_one_dvma(struct sbus_dma *dma, int num_dma)
+static void __init init_one_dvma(struct sbus_dma *dma, int num_dma)
 {
         printk("dma%d: ", num_dma);