Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

24 files changed, 1104 insertions, 153 deletions

diff --git a/drivers/macintosh/Kconfig b/drivers/macintosh/Kconfig
index fd85bde283a0..fa51af11c6f1 100644
--- a/drivers/macintosh/Kconfig
+++ b/drivers/macintosh/Kconfig
@@ -102,6 +102,7 @@ config ADB_PMU_LED
 config ADB_PMU_LED_IDE
         bool "Use front LED as IDE LED by default"
         depends on ADB_PMU_LED
+        depends on LEDS_CLASS
         select LEDS_TRIGGERS
         select LEDS_TRIGGER_IDE_DISK
         help
@@ -256,4 +257,30 @@ config PMAC_RACKMETER
           This driver provides some support to control the front panel
           blue LEDs "vu-meter" of the XServer macs.
 
+config SENSORS_AMS
+        tristate "Apple Motion Sensor driver"
+        depends on PPC_PMAC && !PPC64 && INPUT && ((ADB_PMU && I2C = y) || (ADB_PMU && !I2C) || I2C) && EXPERIMENTAL
+        select INPUT_POLLDEV
+        help
+          Support for the motion sensor included in PowerBooks. Includes
+          implementations for PMU and I2C.
+
+          This driver can also be built as a module. If so, the module
+          will be called ams.
+
+config SENSORS_AMS_PMU
+        bool "PMU variant"
+        depends on SENSORS_AMS && ADB_PMU
+        default y
+        help
+          PMU variant of motion sensor, found in late 2005 PowerBooks.
+
+config SENSORS_AMS_I2C
+        bool "I2C variant"
+        depends on SENSORS_AMS && I2C
+        default y
+        help
+          I2C variant of motion sensor, found in early 2005 PowerBooks and
+          iBooks.
+
 endif # MACINTOSH_DRIVERS
diff --git a/drivers/macintosh/Makefile b/drivers/macintosh/Makefile
index e3132efa17c0..6652a6ebb6fa 100644
--- a/drivers/macintosh/Makefile
+++ b/drivers/macintosh/Makefile
@@ -48,3 +48,5 @@ obj-$(CONFIG_WINDFARM_PM121)	+= windfarm_pm121.o windfarm_smu_sat.o \
                                    windfarm_max6690_sensor.o \
                                    windfarm_lm75_sensor.o windfarm_pid.o
 obj-$(CONFIG_PMAC_RACKMETER)    += rack-meter.o
+
+obj-$(CONFIG_SENSORS_AMS)       += ams/
diff --git a/drivers/macintosh/adb-iop.c b/drivers/macintosh/adb-iop.c
index 444696625171..f5f4da3d0b67 100644
--- a/drivers/macintosh/adb-iop.c
+++ b/drivers/macintosh/adb-iop.c
@@ -80,7 +80,7 @@ static void adb_iop_end_req(struct adb_request *req, int state)
 static void adb_iop_complete(struct iop_msg *msg)
 {
         struct adb_request *req;
-        uint flags;
+        unsigned long flags;
 
         local_irq_save(flags);
 
@@ -103,7 +103,7 @@ static void adb_iop_listen(struct iop_msg *msg)
 {
         struct adb_iopmsg *amsg = (struct adb_iopmsg *) msg->message;
         struct adb_request *req;
-        uint flags;
+        unsigned long flags;
 #ifdef DEBUG_ADB_IOP
         int i;
 #endif
diff --git a/drivers/macintosh/adb.c b/drivers/macintosh/adb.c
index 1c4ee6e77937..75049e765191 100644
--- a/drivers/macintosh/adb.c
+++ b/drivers/macintosh/adb.c
@@ -24,7 +24,6 @@
 #include <linux/fs.h>
 #include <linux/mm.h>
 #include <linux/sched.h>
-#include <linux/smp_lock.h>
 #include <linux/adb.h>
 #include <linux/cuda.h>
 #include <linux/pmu.h>
@@ -55,6 +54,7 @@ extern struct adb_driver adb_iop_driver;
 extern struct adb_driver via_pmu_driver;
 extern struct adb_driver macio_adb_driver;
 
+static DEFINE_MUTEX(adb_mutex);
 static struct adb_driver *adb_driver_list[] = {
 #ifdef CONFIG_ADB_MACII
         &via_macii_driver,
@@ -83,7 +83,7 @@ static struct adb_driver *adb_controller;
 BLOCKING_NOTIFIER_HEAD(adb_client_list);
 static int adb_got_sleep;
 static int adb_inited;
-static DECLARE_MUTEX(adb_probe_mutex);
+static DEFINE_SEMAPHORE(adb_probe_mutex);
 static int sleepy_trackpad;
 static int autopoll_devs;
 int __adb_probe_sync;
@@ -647,7 +647,7 @@ static int adb_open(struct inode *inode, struct file *file)
         struct adbdev_state *state;
         int ret = 0;
 
-        lock_kernel();
+        mutex_lock(&adb_mutex);
         if (iminor(inode) > 0 || adb_controller == NULL) {
                 ret = -ENXIO;
                 goto out;
@@ -665,7 +665,7 @@ static int adb_open(struct inode *inode, struct file *file)
         state->inuse = 1;
 
 out:
-        unlock_kernel();
+        mutex_unlock(&adb_mutex);
         return ret;
 }
 
@@ -674,7 +674,7 @@ static int adb_release(struct inode *inode, struct file *file)
         struct adbdev_state *state = file->private_data;
         unsigned long flags;
 
-        lock_kernel();
+        mutex_lock(&adb_mutex);
         if (state) {
                 file->private_data = NULL;
                 spin_lock_irqsave(&state->lock, flags);
@@ -687,7 +687,7 @@ static int adb_release(struct inode *inode, struct file *file)
                         spin_unlock_irqrestore(&state->lock, flags);
                 }
         }
-        unlock_kernel();
+        mutex_unlock(&adb_mutex);
         return 0;
 }
 
diff --git a/drivers/macintosh/adbhid.c b/drivers/macintosh/adbhid.c
index 5396c67ba0a4..09d72bb00d12 100644
--- a/drivers/macintosh/adbhid.c
+++ b/drivers/macintosh/adbhid.c
@@ -328,7 +328,7 @@ adbhid_input_keycode(int id, int scancode, int repeat)
         switch (keycode) {
         case ADB_KEY_CAPSLOCK:
                 if (!restore_capslock_events) {
-                        /* Generate down/up events for CapsLock everytime. */
+                        /* Generate down/up events for CapsLock every time. */
                         input_report_key(ahid->input, KEY_CAPSLOCK, 1);
                         input_sync(ahid->input);
                         input_report_key(ahid->input, KEY_CAPSLOCK, 0);
diff --git a/drivers/macintosh/ams/Makefile b/drivers/macintosh/ams/Makefile
new file mode 100644
index 000000000000..41c95b2089dc
--- /dev/null
+++ b/drivers/macintosh/ams/Makefile
@@ -0,0 +1,8 @@
+#
+# Makefile for Apple Motion Sensor driver
+#
+
+ams-y                                   := ams-core.o ams-input.o
+ams-$(CONFIG_SENSORS_AMS_PMU)           += ams-pmu.o
+ams-$(CONFIG_SENSORS_AMS_I2C)           += ams-i2c.o
+obj-$(CONFIG_SENSORS_AMS)               += ams.o
diff --git a/drivers/macintosh/ams/ams-core.c b/drivers/macintosh/ams/ams-core.c
new file mode 100644
index 000000000000..399beb1638d1
--- /dev/null
+++ b/drivers/macintosh/ams/ams-core.c
@@ -0,0 +1,250 @@
+/*
+ * Apple Motion Sensor driver
+ *
+ * Copyright (C) 2005 Stelian Pop (stelian@popies.net)
+ * Copyright (C) 2006 Michael Hanselmann (linux-kernel@hansmi.ch)
+ *
+ * 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/module.h>
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/of_platform.h>
+#include <asm/pmac_pfunc.h>
+
+#include "ams.h"
+
+/* There is only one motion sensor per machine */
+struct ams ams_info;
+
+static unsigned int verbose;
+module_param(verbose, bool, 0644);
+MODULE_PARM_DESC(verbose, "Show free falls and shocks in kernel output");
+
+/* Call with ams_info.lock held! */
+void ams_sensors(s8 *x, s8 *y, s8 *z)
+{
+        u32 orient = ams_info.vflag? ams_info.orient1 : ams_info.orient2;
+
+        if (orient & 0x80)
+                /* X and Y swapped */
+                ams_info.get_xyz(y, x, z);
+        else
+                ams_info.get_xyz(x, y, z);
+
+        if (orient & 0x04)
+                *z = ~(*z);
+        if (orient & 0x02)
+                *y = ~(*y);
+        if (orient & 0x01)
+                *x = ~(*x);
+}
+
+static ssize_t ams_show_current(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        s8 x, y, z;
+
+        mutex_lock(&ams_info.lock);
+        ams_sensors(&x, &y, &z);
+        mutex_unlock(&ams_info.lock);
+
+        return snprintf(buf, PAGE_SIZE, "%d %d %d\n", x, y, z);
+}
+
+static DEVICE_ATTR(current, S_IRUGO, ams_show_current, NULL);
+
+static void ams_handle_irq(void *data)
+{
+        enum ams_irq irq = *((enum ams_irq *)data);
+
+        spin_lock(&ams_info.irq_lock);
+
+        ams_info.worker_irqs |= irq;
+        schedule_work(&ams_info.worker);
+
+        spin_unlock(&ams_info.irq_lock);
+}
+
+static enum ams_irq ams_freefall_irq_data = AMS_IRQ_FREEFALL;
+static struct pmf_irq_client ams_freefall_client = {
+        .owner = THIS_MODULE,
+        .handler = ams_handle_irq,
+        .data = &ams_freefall_irq_data,
+};
+
+static enum ams_irq ams_shock_irq_data = AMS_IRQ_SHOCK;
+static struct pmf_irq_client ams_shock_client = {
+        .owner = THIS_MODULE,
+        .handler = ams_handle_irq,
+        .data = &ams_shock_irq_data,
+};
+
+/* Once hard disk parking is implemented in the kernel, this function can
+ * trigger it.
+ */
+static void ams_worker(struct work_struct *work)
+{
+        unsigned long flags;
+        u8 irqs_to_clear;
+
+        mutex_lock(&ams_info.lock);
+
+        spin_lock_irqsave(&ams_info.irq_lock, flags);
+        irqs_to_clear = ams_info.worker_irqs;
+
+        if (ams_info.worker_irqs & AMS_IRQ_FREEFALL) {
+                if (verbose)
+                        printk(KERN_INFO "ams: freefall detected!\n");
+
+                ams_info.worker_irqs &= ~AMS_IRQ_FREEFALL;
+        }
+
+        if (ams_info.worker_irqs & AMS_IRQ_SHOCK) {
+                if (verbose)
+                        printk(KERN_INFO "ams: shock detected!\n");
+
+                ams_info.worker_irqs &= ~AMS_IRQ_SHOCK;
+        }
+
+        spin_unlock_irqrestore(&ams_info.irq_lock, flags);
+
+        ams_info.clear_irq(irqs_to_clear);
+
+        mutex_unlock(&ams_info.lock);
+}
+
+/* Call with ams_info.lock held! */
+int ams_sensor_attach(void)
+{
+        int result;
+        const u32 *prop;
+
+        /* Get orientation */
+        prop = of_get_property(ams_info.of_node, "orientation", NULL);
+        if (!prop)
+                return -ENODEV;
+        ams_info.orient1 = *prop;
+        ams_info.orient2 = *(prop + 1);
+
+        /* Register freefall interrupt handler */
+        result = pmf_register_irq_client(ams_info.of_node,
+                        "accel-int-1",
+                        &ams_freefall_client);
+        if (result < 0)
+                return -ENODEV;
+
+        /* Reset saved irqs */
+        ams_info.worker_irqs = 0;
+
+        /* Register shock interrupt handler */
+        result = pmf_register_irq_client(ams_info.of_node,
+                        "accel-int-2",
+                        &ams_shock_client);
+        if (result < 0)
+                goto release_freefall;
+
+        /* Create device */
+        ams_info.of_dev = of_platform_device_create(ams_info.of_node, "ams", NULL);
+        if (!ams_info.of_dev) {
+                result = -ENODEV;
+                goto release_shock;
+        }
+
+        /* Create attributes */
+        result = device_create_file(&ams_info.of_dev->dev, &dev_attr_current);
+        if (result)
+                goto release_of;
+
+        ams_info.vflag = !!(ams_info.get_vendor() & 0x10);
+
+        /* Init input device */
+        result = ams_input_init();
+        if (result)
+                goto release_device_file;
+
+        return result;
+release_device_file:
+        device_remove_file(&ams_info.of_dev->dev, &dev_attr_current);
+release_of:
+        of_device_unregister(ams_info.of_dev);
+release_shock:
+        pmf_unregister_irq_client(&ams_shock_client);
+release_freefall:
+        pmf_unregister_irq_client(&ams_freefall_client);
+        return result;
+}
+
+int __init ams_init(void)
+{
+        struct device_node *np;
+
+        spin_lock_init(&ams_info.irq_lock);
+        mutex_init(&ams_info.lock);
+        INIT_WORK(&ams_info.worker, ams_worker);
+
+#ifdef CONFIG_SENSORS_AMS_I2C
+        np = of_find_node_by_name(NULL, "accelerometer");
+        if (np && of_device_is_compatible(np, "AAPL,accelerometer_1"))
+                /* Found I2C motion sensor */
+                return ams_i2c_init(np);
+#endif
+
+#ifdef CONFIG_SENSORS_AMS_PMU
+        np = of_find_node_by_name(NULL, "sms");
+        if (np && of_device_is_compatible(np, "sms"))
+                /* Found PMU motion sensor */
+                return ams_pmu_init(np);
+#endif
+        return -ENODEV;
+}
+
+void ams_sensor_detach(void)
+{
+        /* Remove input device */
+        ams_input_exit();
+
+        /* Remove attributes */
+        device_remove_file(&ams_info.of_dev->dev, &dev_attr_current);
+
+        /* Flush interrupt worker
+         *
+         * We do this after ams_info.exit(), because an interrupt might
+         * have arrived before disabling them.
+         */
+        flush_work_sync(&ams_info.worker);
+
+        /* Remove device */
+        of_device_unregister(ams_info.of_dev);
+
+        /* Remove handler */
+        pmf_unregister_irq_client(&ams_shock_client);
+        pmf_unregister_irq_client(&ams_freefall_client);
+}
+
+static void __exit ams_exit(void)
+{
+        /* Shut down implementation */
+        ams_info.exit();
+}
+
+MODULE_AUTHOR("Stelian Pop, Michael Hanselmann");
+MODULE_DESCRIPTION("Apple Motion Sensor driver");
+MODULE_LICENSE("GPL");
+
+module_init(ams_init);
+module_exit(ams_exit);
diff --git a/drivers/macintosh/ams/ams-i2c.c b/drivers/macintosh/ams/ams-i2c.c
new file mode 100644
index 000000000000..abeecd27b484
--- /dev/null
+++ b/drivers/macintosh/ams/ams-i2c.c
@@ -0,0 +1,277 @@
+/*
+ * Apple Motion Sensor driver (I2C variant)
+ *
+ * Copyright (C) 2005 Stelian Pop (stelian@popies.net)
+ * Copyright (C) 2006 Michael Hanselmann (linux-kernel@hansmi.ch)
+ *
+ * Clean room implementation based on the reverse engineered Mac OS X driver by
+ * Johannes Berg <johannes@sipsolutions.net>, documentation available at
+ * http://johannes.sipsolutions.net/PowerBook/Apple_Motion_Sensor_Specification
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+
+#include "ams.h"
+
+/* AMS registers */
+#define AMS_COMMAND     0x00    /* command register */
+#define AMS_STATUS      0x01    /* status register */
+#define AMS_CTRL1       0x02    /* read control 1 (number of values) */
+#define AMS_CTRL2       0x03    /* read control 2 (offset?) */
+#define AMS_CTRL3       0x04    /* read control 3 (size of each value?) */
+#define AMS_DATA1       0x05    /* read data 1 */
+#define AMS_DATA2       0x06    /* read data 2 */
+#define AMS_DATA3       0x07    /* read data 3 */
+#define AMS_DATA4       0x08    /* read data 4 */
+#define AMS_DATAX       0x20    /* data X */
+#define AMS_DATAY       0x21    /* data Y */
+#define AMS_DATAZ       0x22    /* data Z */
+#define AMS_FREEFALL    0x24    /* freefall int control */
+#define AMS_SHOCK       0x25    /* shock int control */
+#define AMS_SENSLOW     0x26    /* sensitivity low limit */
+#define AMS_SENSHIGH    0x27    /* sensitivity high limit */
+#define AMS_CTRLX       0x28    /* control X */
+#define AMS_CTRLY       0x29    /* control Y */
+#define AMS_CTRLZ       0x2A    /* control Z */
+#define AMS_UNKNOWN1    0x2B    /* unknown 1 */
+#define AMS_UNKNOWN2    0x2C    /* unknown 2 */
+#define AMS_UNKNOWN3    0x2D    /* unknown 3 */
+#define AMS_VENDOR      0x2E    /* vendor */
+
+/* AMS commands - use with the AMS_COMMAND register */
+enum ams_i2c_cmd {
+        AMS_CMD_NOOP = 0,
+        AMS_CMD_VERSION,
+        AMS_CMD_READMEM,
+        AMS_CMD_WRITEMEM,
+        AMS_CMD_ERASEMEM,
+        AMS_CMD_READEE,
+        AMS_CMD_WRITEEE,
+        AMS_CMD_RESET,
+        AMS_CMD_START,
+};
+
+static int ams_i2c_probe(struct i2c_client *client,
+                         const struct i2c_device_id *id);
+static int ams_i2c_remove(struct i2c_client *client);
+
+static const struct i2c_device_id ams_id[] = {
+        { "ams", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, ams_id);
+
+static struct i2c_driver ams_i2c_driver = {
+        .driver = {
+                .name   = "ams",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = ams_i2c_probe,
+        .remove         = ams_i2c_remove,
+        .id_table       = ams_id,
+};
+
+static s32 ams_i2c_read(u8 reg)
+{
+        return i2c_smbus_read_byte_data(ams_info.i2c_client, reg);
+}
+
+static int ams_i2c_write(u8 reg, u8 value)
+{
+        return i2c_smbus_write_byte_data(ams_info.i2c_client, reg, value);
+}
+
+static int ams_i2c_cmd(enum ams_i2c_cmd cmd)
+{
+        s32 result;
+        int count = 3;
+
+        ams_i2c_write(AMS_COMMAND, cmd);
+        msleep(5);
+
+        while (count--) {
+                result = ams_i2c_read(AMS_COMMAND);
+                if (result == 0 || result & 0x80)
+                        return 0;
+
+                schedule_timeout_uninterruptible(HZ / 20);
+        }
+
+        return -1;
+}
+
+static void ams_i2c_set_irq(enum ams_irq reg, char enable)
+{
+        if (reg & AMS_IRQ_FREEFALL) {
+                u8 val = ams_i2c_read(AMS_CTRLX);
+                if (enable)
+                        val |= 0x80;
+                else
+                        val &= ~0x80;
+                ams_i2c_write(AMS_CTRLX, val);
+        }
+
+        if (reg & AMS_IRQ_SHOCK) {
+                u8 val = ams_i2c_read(AMS_CTRLY);
+                if (enable)
+                        val |= 0x80;
+                else
+                        val &= ~0x80;
+                ams_i2c_write(AMS_CTRLY, val);
+        }
+
+        if (reg & AMS_IRQ_GLOBAL) {
+                u8 val = ams_i2c_read(AMS_CTRLZ);
+                if (enable)
+                        val |= 0x80;
+                else
+                        val &= ~0x80;
+                ams_i2c_write(AMS_CTRLZ, val);
+        }
+}
+
+static void ams_i2c_clear_irq(enum ams_irq reg)
+{
+        if (reg & AMS_IRQ_FREEFALL)
+                ams_i2c_write(AMS_FREEFALL, 0);
+
+        if (reg & AMS_IRQ_SHOCK)
+                ams_i2c_write(AMS_SHOCK, 0);
+}
+
+static u8 ams_i2c_get_vendor(void)
+{
+        return ams_i2c_read(AMS_VENDOR);
+}
+
+static void ams_i2c_get_xyz(s8 *x, s8 *y, s8 *z)
+{
+        *x = ams_i2c_read(AMS_DATAX);
+        *y = ams_i2c_read(AMS_DATAY);
+        *z = ams_i2c_read(AMS_DATAZ);
+}
+
+static int ams_i2c_probe(struct i2c_client *client,
+                         const struct i2c_device_id *id)
+{
+        int vmaj, vmin;
+        int result;
+
+        /* There can be only one */
+        if (unlikely(ams_info.has_device))
+                return -ENODEV;
+
+        ams_info.i2c_client = client;
+
+        if (ams_i2c_cmd(AMS_CMD_RESET)) {
+                printk(KERN_INFO "ams: Failed to reset the device\n");
+                return -ENODEV;
+        }
+
+        if (ams_i2c_cmd(AMS_CMD_START)) {
+                printk(KERN_INFO "ams: Failed to start the device\n");
+                return -ENODEV;
+        }
+
+        /* get version/vendor information */
+        ams_i2c_write(AMS_CTRL1, 0x02);
+        ams_i2c_write(AMS_CTRL2, 0x85);
+        ams_i2c_write(AMS_CTRL3, 0x01);
+
+        ams_i2c_cmd(AMS_CMD_READMEM);
+
+        vmaj = ams_i2c_read(AMS_DATA1);
+        vmin = ams_i2c_read(AMS_DATA2);
+        if (vmaj != 1 || vmin != 52) {
+                printk(KERN_INFO "ams: Incorrect device version (%d.%d)\n",
+                        vmaj, vmin);
+                return -ENODEV;
+        }
+
+        ams_i2c_cmd(AMS_CMD_VERSION);
+
+        vmaj = ams_i2c_read(AMS_DATA1);
+        vmin = ams_i2c_read(AMS_DATA2);
+        if (vmaj != 0 || vmin != 1) {
+                printk(KERN_INFO "ams: Incorrect firmware version (%d.%d)\n",
+                        vmaj, vmin);
+                return -ENODEV;
+        }
+
+        /* Disable interrupts */
+        ams_i2c_set_irq(AMS_IRQ_ALL, 0);
+
+        result = ams_sensor_attach();
+        if (result < 0)
+                return result;
+
+        /* Set default values */
+        ams_i2c_write(AMS_SENSLOW, 0x15);
+        ams_i2c_write(AMS_SENSHIGH, 0x60);
+        ams_i2c_write(AMS_CTRLX, 0x08);
+        ams_i2c_write(AMS_CTRLY, 0x0F);
+        ams_i2c_write(AMS_CTRLZ, 0x4F);
+        ams_i2c_write(AMS_UNKNOWN1, 0x14);
+
+        /* Clear interrupts */
+        ams_i2c_clear_irq(AMS_IRQ_ALL);
+
+        ams_info.has_device = 1;
+
+        /* Enable interrupts */
+        ams_i2c_set_irq(AMS_IRQ_ALL, 1);
+
+        printk(KERN_INFO "ams: Found I2C based motion sensor\n");
+
+        return 0;
+}
+
+static int ams_i2c_remove(struct i2c_client *client)
+{
+        if (ams_info.has_device) {
+                ams_sensor_detach();
+
+                /* Disable interrupts */
+                ams_i2c_set_irq(AMS_IRQ_ALL, 0);
+
+                /* Clear interrupts */
+                ams_i2c_clear_irq(AMS_IRQ_ALL);
+
+                printk(KERN_INFO "ams: Unloading\n");
+
+                ams_info.has_device = 0;
+        }
+
+        return 0;
+}
+
+static void ams_i2c_exit(void)
+{
+        i2c_del_driver(&ams_i2c_driver);
+}
+
+int __init ams_i2c_init(struct device_node *np)
+{
+        int result;
+
+        /* Set implementation stuff */
+        ams_info.of_node = np;
+        ams_info.exit = ams_i2c_exit;
+        ams_info.get_vendor = ams_i2c_get_vendor;
+        ams_info.get_xyz = ams_i2c_get_xyz;
+        ams_info.clear_irq = ams_i2c_clear_irq;
+        ams_info.bustype = BUS_I2C;
+
+        result = i2c_add_driver(&ams_i2c_driver);
+
+        return result;
+}
diff --git a/drivers/macintosh/ams/ams-input.c b/drivers/macintosh/ams/ams-input.c
new file mode 100644
index 000000000000..8a712392cd38
--- /dev/null
+++ b/drivers/macintosh/ams/ams-input.c
@@ -0,0 +1,157 @@
+/*
+ * Apple Motion Sensor driver (joystick emulation)
+ *
+ * Copyright (C) 2005 Stelian Pop (stelian@popies.net)
+ * Copyright (C) 2006 Michael Hanselmann (linux-kernel@hansmi.ch)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/module.h>
+
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+
+#include "ams.h"
+
+static unsigned int joystick;
+module_param(joystick, bool, S_IRUGO);
+MODULE_PARM_DESC(joystick, "Enable the input class device on module load");
+
+static unsigned int invert;
+module_param(invert, bool, S_IWUSR | S_IRUGO);
+MODULE_PARM_DESC(invert, "Invert input data on X and Y axis");
+
+static DEFINE_MUTEX(ams_input_mutex);
+
+static void ams_idev_poll(struct input_polled_dev *dev)
+{
+        struct input_dev *idev = dev->input;
+        s8 x, y, z;
+
+        mutex_lock(&ams_info.lock);
+
+        ams_sensors(&x, &y, &z);
+
+        x -= ams_info.xcalib;
+        y -= ams_info.ycalib;
+        z -= ams_info.zcalib;
+
+        input_report_abs(idev, ABS_X, invert ? -x : x);
+        input_report_abs(idev, ABS_Y, invert ? -y : y);
+        input_report_abs(idev, ABS_Z, z);
+
+        input_sync(idev);
+
+        mutex_unlock(&ams_info.lock);
+}
+
+/* Call with ams_info.lock held! */
+static int ams_input_enable(void)
+{
+        struct input_dev *input;
+        s8 x, y, z;
+        int error;
+
+        ams_sensors(&x, &y, &z);
+        ams_info.xcalib = x;
+        ams_info.ycalib = y;
+        ams_info.zcalib = z;
+
+        ams_info.idev = input_allocate_polled_device();
+        if (!ams_info.idev)
+                return -ENOMEM;
+
+        ams_info.idev->poll = ams_idev_poll;
+        ams_info.idev->poll_interval = 25;
+
+        input = ams_info.idev->input;
+        input->name = "Apple Motion Sensor";
+        input->id.bustype = ams_info.bustype;
+        input->id.vendor = 0;
+        input->dev.parent = &ams_info.of_dev->dev;
+
+        input_set_abs_params(input, ABS_X, -50, 50, 3, 0);
+        input_set_abs_params(input, ABS_Y, -50, 50, 3, 0);
+        input_set_abs_params(input, ABS_Z, -50, 50, 3, 0);
+
+        set_bit(EV_ABS, input->evbit);
+        set_bit(EV_KEY, input->evbit);
+        set_bit(BTN_TOUCH, input->keybit);
+
+        error = input_register_polled_device(ams_info.idev);
+        if (error) {
+                input_free_polled_device(ams_info.idev);
+                ams_info.idev = NULL;
+                return error;
+        }
+
+        joystick = 1;
+
+        return 0;
+}
+
+static void ams_input_disable(void)
+{
+        if (ams_info.idev) {
+                input_unregister_polled_device(ams_info.idev);
+                input_free_polled_device(ams_info.idev);
+                ams_info.idev = NULL;
+        }
+
+        joystick = 0;
+}
+
+static ssize_t ams_input_show_joystick(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        return sprintf(buf, "%d\n", joystick);
+}
+
+static ssize_t ams_input_store_joystick(struct device *dev,
+        struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long enable;
+        int error = 0;
+
+        if (strict_strtoul(buf, 0, &enable) || enable > 1)
+                return -EINVAL;
+
+        mutex_lock(&ams_input_mutex);
+
+        if (enable != joystick) {
+                if (enable)
+                        error = ams_input_enable();
+                else
+                        ams_input_disable();
+        }
+
+        mutex_unlock(&ams_input_mutex);
+
+        return error ? error : count;
+}
+
+static DEVICE_ATTR(joystick, S_IRUGO | S_IWUSR,
+        ams_input_show_joystick, ams_input_store_joystick);
+
+int ams_input_init(void)
+{
+        if (joystick)
+                ams_input_enable();
+
+        return device_create_file(&ams_info.of_dev->dev, &dev_attr_joystick);
+}
+
+void ams_input_exit(void)
+{
+        device_remove_file(&ams_info.of_dev->dev, &dev_attr_joystick);
+
+        mutex_lock(&ams_input_mutex);
+        ams_input_disable();
+        mutex_unlock(&ams_input_mutex);
+}
diff --git a/drivers/macintosh/ams/ams-pmu.c b/drivers/macintosh/ams/ams-pmu.c
new file mode 100644
index 000000000000..4f61b3ee1b08
--- /dev/null
+++ b/drivers/macintosh/ams/ams-pmu.c
@@ -0,0 +1,201 @@
+/*
+ * Apple Motion Sensor driver (PMU variant)
+ *
+ * Copyright (C) 2006 Michael Hanselmann (linux-kernel@hansmi.ch)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/adb.h>
+#include <linux/pmu.h>
+
+#include "ams.h"
+
+/* Attitude */
+#define AMS_X                   0x00
+#define AMS_Y                   0x01
+#define AMS_Z                   0x02
+
+/* Not exactly known, maybe chip vendor */
+#define AMS_VENDOR              0x03
+
+/* Freefall registers */
+#define AMS_FF_CLEAR            0x04
+#define AMS_FF_ENABLE           0x05
+#define AMS_FF_LOW_LIMIT        0x06
+#define AMS_FF_DEBOUNCE         0x07
+
+/* Shock registers */
+#define AMS_SHOCK_CLEAR         0x08
+#define AMS_SHOCK_ENABLE        0x09
+#define AMS_SHOCK_HIGH_LIMIT    0x0a
+#define AMS_SHOCK_DEBOUNCE      0x0b
+
+/* Global interrupt and power control register */
+#define AMS_CONTROL             0x0c
+
+static u8 ams_pmu_cmd;
+
+static void ams_pmu_req_complete(struct adb_request *req)
+{
+        complete((struct completion *)req->arg);
+}
+
+/* Only call this function from task context */
+static void ams_pmu_set_register(u8 reg, u8 value)
+{
+        static struct adb_request req;
+        DECLARE_COMPLETION(req_complete);
+
+        req.arg = &req_complete;
+        if (pmu_request(&req, ams_pmu_req_complete, 4, ams_pmu_cmd, 0x00, reg, value))
+                return;
+
+        wait_for_completion(&req_complete);
+}
+
+/* Only call this function from task context */
+static u8 ams_pmu_get_register(u8 reg)
+{
+        static struct adb_request req;
+        DECLARE_COMPLETION(req_complete);
+
+        req.arg = &req_complete;
+        if (pmu_request(&req, ams_pmu_req_complete, 3, ams_pmu_cmd, 0x01, reg))
+                return 0;
+
+        wait_for_completion(&req_complete);
+
+        if (req.reply_len > 0)
+                return req.reply[0];
+        else
+                return 0;
+}
+
+/* Enables or disables the specified interrupts */
+static void ams_pmu_set_irq(enum ams_irq reg, char enable)
+{
+        if (reg & AMS_IRQ_FREEFALL) {
+                u8 val = ams_pmu_get_register(AMS_FF_ENABLE);
+                if (enable)
+                        val |= 0x80;
+                else
+                        val &= ~0x80;
+                ams_pmu_set_register(AMS_FF_ENABLE, val);
+        }
+
+        if (reg & AMS_IRQ_SHOCK) {
+                u8 val = ams_pmu_get_register(AMS_SHOCK_ENABLE);
+                if (enable)
+                        val |= 0x80;
+                else
+                        val &= ~0x80;
+                ams_pmu_set_register(AMS_SHOCK_ENABLE, val);
+        }
+
+        if (reg & AMS_IRQ_GLOBAL) {
+                u8 val = ams_pmu_get_register(AMS_CONTROL);
+                if (enable)
+                        val |= 0x80;
+                else
+                        val &= ~0x80;
+                ams_pmu_set_register(AMS_CONTROL, val);
+        }
+}
+
+static void ams_pmu_clear_irq(enum ams_irq reg)
+{
+        if (reg & AMS_IRQ_FREEFALL)
+                ams_pmu_set_register(AMS_FF_CLEAR, 0x00);
+
+        if (reg & AMS_IRQ_SHOCK)
+                ams_pmu_set_register(AMS_SHOCK_CLEAR, 0x00);
+}
+
+static u8 ams_pmu_get_vendor(void)
+{
+        return ams_pmu_get_register(AMS_VENDOR);
+}
+
+static void ams_pmu_get_xyz(s8 *x, s8 *y, s8 *z)
+{
+        *x = ams_pmu_get_register(AMS_X);
+        *y = ams_pmu_get_register(AMS_Y);
+        *z = ams_pmu_get_register(AMS_Z);
+}
+
+static void ams_pmu_exit(void)
+{
+        ams_sensor_detach();
+
+        /* Disable interrupts */
+        ams_pmu_set_irq(AMS_IRQ_ALL, 0);
+
+        /* Clear interrupts */
+        ams_pmu_clear_irq(AMS_IRQ_ALL);
+
+        ams_info.has_device = 0;
+
+        printk(KERN_INFO "ams: Unloading\n");
+}
+
+int __init ams_pmu_init(struct device_node *np)
+{
+        const u32 *prop;
+        int result;
+
+        /* Set implementation stuff */
+        ams_info.of_node = np;
+        ams_info.exit = ams_pmu_exit;
+        ams_info.get_vendor = ams_pmu_get_vendor;
+        ams_info.get_xyz = ams_pmu_get_xyz;
+        ams_info.clear_irq = ams_pmu_clear_irq;
+        ams_info.bustype = BUS_HOST;
+
+        /* Get PMU command, should be 0x4e, but we can never know */
+        prop = of_get_property(ams_info.of_node, "reg", NULL);
+        if (!prop)
+                return -ENODEV;
+
+        ams_pmu_cmd = ((*prop) >> 8) & 0xff;
+
+        /* Disable interrupts */
+        ams_pmu_set_irq(AMS_IRQ_ALL, 0);
+
+        /* Clear interrupts */
+        ams_pmu_clear_irq(AMS_IRQ_ALL);
+
+        result = ams_sensor_attach();
+        if (result < 0)
+                return result;
+
+        /* Set default values */
+        ams_pmu_set_register(AMS_FF_LOW_LIMIT, 0x15);
+        ams_pmu_set_register(AMS_FF_ENABLE, 0x08);
+        ams_pmu_set_register(AMS_FF_DEBOUNCE, 0x14);
+
+        ams_pmu_set_register(AMS_SHOCK_HIGH_LIMIT, 0x60);
+        ams_pmu_set_register(AMS_SHOCK_ENABLE, 0x0f);
+        ams_pmu_set_register(AMS_SHOCK_DEBOUNCE, 0x14);
+
+        ams_pmu_set_register(AMS_CONTROL, 0x4f);
+
+        /* Clear interrupts */
+        ams_pmu_clear_irq(AMS_IRQ_ALL);
+
+        ams_info.has_device = 1;
+
+        /* Enable interrupts */
+        ams_pmu_set_irq(AMS_IRQ_ALL, 1);
+
+        printk(KERN_INFO "ams: Found PMU based motion sensor\n");
+
+        return 0;
+}
diff --git a/drivers/macintosh/ams/ams.h b/drivers/macintosh/ams/ams.h
new file mode 100644
index 000000000000..90f094d45450
--- /dev/null
+++ b/drivers/macintosh/ams/ams.h
@@ -0,0 +1,70 @@
+#include <linux/i2c.h>
+#include <linux/input-polldev.h>
+#include <linux/kthread.h>
+#include <linux/mutex.h>
+#include <linux/spinlock.h>
+#include <linux/types.h>
+#include <linux/of_device.h>
+
+enum ams_irq {
+        AMS_IRQ_FREEFALL = 0x01,
+        AMS_IRQ_SHOCK = 0x02,
+        AMS_IRQ_GLOBAL = 0x04,
+        AMS_IRQ_ALL =
+                AMS_IRQ_FREEFALL |
+                AMS_IRQ_SHOCK |
+                AMS_IRQ_GLOBAL,
+};
+
+struct ams {
+        /* Locks */
+        spinlock_t irq_lock;
+        struct mutex lock;
+
+        /* General properties */
+        struct device_node *of_node;
+        struct platform_device *of_dev;
+        char has_device;
+        char vflag;
+        u32 orient1;
+        u32 orient2;
+
+        /* Interrupt worker */
+        struct work_struct worker;
+        u8 worker_irqs;
+
+        /* Implementation
+         *
+         * Only call these functions with the main lock held.
+         */
+        void (*exit)(void);
+
+        void (*get_xyz)(s8 *x, s8 *y, s8 *z);
+        u8 (*get_vendor)(void);
+
+        void (*clear_irq)(enum ams_irq reg);
+
+#ifdef CONFIG_SENSORS_AMS_I2C
+        /* I2C properties */
+        struct i2c_client *i2c_client;
+#endif
+
+        /* Joystick emulation */
+        struct input_polled_dev *idev;
+        __u16 bustype;
+
+        /* calibrated null values */
+        int xcalib, ycalib, zcalib;
+};
+
+extern struct ams ams_info;
+
+extern void ams_sensors(s8 *x, s8 *y, s8 *z);
+extern int ams_sensor_attach(void);
+extern void ams_sensor_detach(void);
+
+extern int ams_pmu_init(struct device_node *np);
+extern int ams_i2c_init(struct device_node *np);
+
+extern int ams_input_init(void);
+extern void ams_input_exit(void);
diff --git a/drivers/macintosh/ans-lcd.c b/drivers/macintosh/ans-lcd.c
index a3d25da2f275..1a57e88a38f7 100644
--- a/drivers/macintosh/ans-lcd.c
+++ b/drivers/macintosh/ans-lcd.c
@@ -137,6 +137,7 @@ const struct file_operations anslcd_fops = {
         .write          = anslcd_write,
         .unlocked_ioctl = anslcd_ioctl,
         .open           = anslcd_open,
+        .llseek         = default_llseek,
 };
 
 static struct miscdevice anslcd_dev = {
diff --git a/drivers/macintosh/mac_hid.c b/drivers/macintosh/mac_hid.c
index 067f9962f499..6a82388505f0 100644
--- a/drivers/macintosh/mac_hid.c
+++ b/drivers/macintosh/mac_hid.c
@@ -23,6 +23,8 @@ static int mouse_button3_keycode = KEY_RIGHTALT;	/* right option key */
 
 static struct input_dev *mac_hid_emumouse_dev;
 
+static DEFINE_MUTEX(mac_hid_emumouse_mutex);
+
 static int mac_hid_create_emumouse(void)
 {
         static struct lock_class_key mac_hid_emumouse_dev_event_class;
@@ -187,6 +189,10 @@ static int mac_hid_toggle_emumouse(ctl_table *table, int write,
         int old_val = *valp;
         int rc;
 
+        rc = mutex_lock_killable(&mac_hid_emumouse_mutex);
+        if (rc)
+                return rc;
+
         rc = proc_dointvec(table, write, buffer, lenp, ppos);
 
         if (rc == 0 && write && *valp != old_val) {
@@ -202,6 +208,8 @@ static int mac_hid_toggle_emumouse(ctl_table *table, int write,
         if (rc)
                 *valp = old_val;
 
+        mutex_unlock(&mac_hid_emumouse_mutex);
+
         return rc;
 }
 
diff --git a/drivers/macintosh/macio-adb.c b/drivers/macintosh/macio-adb.c
index bd6da7a9c55b..b6ef8f590764 100644
--- a/drivers/macintosh/macio-adb.c
+++ b/drivers/macintosh/macio-adb.c
@@ -147,7 +147,7 @@ static int macio_adb_reset_bus(void)
 
         /* Hrm... we may want to not lock interrupts for so
          * long ... oh well, who uses that chip anyway ? :)
-         * That function will be seldomly used during boot
+         * That function will be seldom used during boot
          * on rare machines, so...
          */
         spin_lock_irqsave(&macio_lock, flags);
diff --git a/drivers/macintosh/macio_asic.c b/drivers/macintosh/macio_asic.c
index b6e7ddc09d76..4daf9e5a7736 100644
--- a/drivers/macintosh/macio_asic.c
+++ b/drivers/macintosh/macio_asic.c
@@ -387,11 +387,10 @@ static struct macio_dev * macio_add_one_device(struct macio_chip *chip,
         /* Set the DMA ops to the ones from the PCI device, this could be
          * fishy if we didn't know that on PowerMac it's always direct ops
          * or iommu ops that will work fine
+         *
+         * To get all the fields, copy all archdata
          */
-        dev->ofdev.dev.archdata.dma_ops =
-                chip->lbus.pdev->dev.archdata.dma_ops;
-        dev->ofdev.dev.archdata.dma_data =
-                chip->lbus.pdev->dev.archdata.dma_data;
+        dev->ofdev.dev.archdata = chip->lbus.pdev->dev.archdata;
 #endif /* CONFIG_PCI */
 
 #ifdef DEBUG
diff --git a/drivers/macintosh/rack-meter.c b/drivers/macintosh/rack-meter.c
index 53cce3a5da23..2637c139777b 100644
--- a/drivers/macintosh/rack-meter.c
+++ b/drivers/macintosh/rack-meter.c
@@ -283,10 +283,10 @@ static void __devinit rackmeter_init_cpu_sniffer(struct rackmeter *rm)
         }
 }
 
-static void __devexit rackmeter_stop_cpu_sniffer(struct rackmeter *rm)
+static void rackmeter_stop_cpu_sniffer(struct rackmeter *rm)
 {
-        cancel_rearming_delayed_work(&rm->cpu[0].sniffer);
-        cancel_rearming_delayed_work(&rm->cpu[1].sniffer);
+        cancel_delayed_work_sync(&rm->cpu[0].sniffer);
+        cancel_delayed_work_sync(&rm->cpu[1].sniffer);
 }
 
 static int __devinit rackmeter_setup(struct rackmeter *rm)
diff --git a/drivers/macintosh/smu.c b/drivers/macintosh/smu.c
index e58c3d33e035..116a49ce74b2 100644
--- a/drivers/macintosh/smu.c
+++ b/drivers/macintosh/smu.c
@@ -19,7 +19,6 @@
  *    the userland interface
  */
 
-#include <linux/smp_lock.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/device.h>
@@ -97,6 +96,7 @@ struct smu_device {
  * I don't think there will ever be more than one SMU, so
  * for now, just hard code that
  */
+static DEFINE_MUTEX(smu_mutex);
 static struct smu_device        *smu;
 static DEFINE_MUTEX(smu_part_access);
 static int smu_irq_inited;
@@ -645,8 +645,7 @@ static void smu_expose_childs(struct work_struct *unused)
 
 static DECLARE_WORK(smu_expose_childs_work, smu_expose_childs);
 
-static int smu_platform_probe(struct platform_device* dev,
-                              const struct of_device_id *match)
+static int smu_platform_probe(struct platform_device* dev)
 {
         if (!smu)
                 return -ENODEV;
@@ -669,7 +668,7 @@ static const struct of_device_id smu_platform_match[] =
         {},
 };
 
-static struct of_platform_driver smu_of_platform_driver =
+static struct platform_driver smu_of_platform_driver =
 {
         .driver = {
                 .name = "smu",
@@ -689,7 +688,7 @@ static int __init smu_init_sysfs(void)
          * I'm a bit too far from figuring out how that works with those
          * new chipsets, but that will come back and bite us
          */
-        of_register_platform_driver(&smu_of_platform_driver);
+        platform_driver_register(&smu_of_platform_driver);
         return 0;
 }
 
@@ -1095,12 +1094,12 @@ static int smu_open(struct inode *inode, struct file *file)
         pp->mode = smu_file_commands;
         init_waitqueue_head(&pp->wait);
 
-        lock_kernel();
+        mutex_lock(&smu_mutex);
         spin_lock_irqsave(&smu_clist_lock, flags);
         list_add(&pp->list, &smu_clist);
         spin_unlock_irqrestore(&smu_clist_lock, flags);
         file->private_data = pp;
-        unlock_kernel();
+        mutex_unlock(&smu_mutex);
 
         return 0;
 }
diff --git a/drivers/macintosh/therm_adt746x.c b/drivers/macintosh/therm_adt746x.c
index d0d221332db0..02367308ff2e 100644
--- a/drivers/macintosh/therm_adt746x.c
+++ b/drivers/macintosh/therm_adt746x.c
@@ -3,9 +3,9 @@
  *
  * Copyright (C) 2003, 2004 Colin Leroy, Rasmus Rohde, Benjamin Herrenschmidt
  *
- * Documentation from
- * http://www.analog.com/UploadedFiles/Data_Sheets/115254175ADT7467_pra.pdf
- * http://www.analog.com/UploadedFiles/Data_Sheets/3686221171167ADT7460_b.pdf
+ * Documentation from 115254175ADT7467_pra.pdf and 3686221171167ADT7460_b.pdf
+ * http://www.onsemi.com/PowerSolutions/product.do?id=ADT7467
+ * http://www.onsemi.com/PowerSolutions/product.do?id=ADT7460
  *
  */
 
@@ -662,7 +662,7 @@ static void thermostat_create_files(void)
                 err |= device_create_file(&of_dev->dev, &dev_attr_sensor2_fan_speed);
         if (err)
                 printk(KERN_WARNING
-                        "Failed to create tempertaure attribute file(s).\n");
+                        "Failed to create temperature attribute file(s).\n");
 }
 
 static void thermostat_remove_files(void)
diff --git a/drivers/macintosh/therm_pm72.c b/drivers/macintosh/therm_pm72.c
index 44549272333c..0ff92c208005 100644
--- a/drivers/macintosh/therm_pm72.c
+++ b/drivers/macintosh/therm_pm72.c
@@ -44,11 +44,11 @@
  * TODO:  - Check MPU structure version/signature
  *        - Add things like /sbin/overtemp for non-critical
  *          overtemp conditions so userland can take some policy
- *          decisions, like slewing down CPUs
+ *          decisions, like slowing down CPUs
  *        - Deal with fan and i2c failures in a better way
  *        - Maybe do a generic PID based on params used for
  *          U3 and Drives ? Definitely need to factor code a bit
- *          bettter... also make sensor detection more robust using
+ *          better... also make sensor detection more robust using
  *          the device-tree to probe for them
  *        - Figure out how to get the slots consumption and set the
  *          slots fan accordingly
@@ -91,7 +91,7 @@
  *
  *  Mar. 10, 2005 : 1.2
  *      - Add basic support for Xserve G5
- *      - Retreive pumps min/max from EEPROM image in device-tree (broken)
+ *      - Retrieve pumps min/max from EEPROM image in device-tree (broken)
  *      - Use min/max macros here or there
  *      - Latest darwin updated U3H min fan speed to 20% PWM
  *
@@ -153,7 +153,7 @@ static struct i2c_adapter *		u3_0;
 static struct i2c_adapter *             u3_1;
 static struct i2c_adapter *             k2;
 static struct i2c_client *              fcu;
-static struct cpu_pid_state             cpu_state[2];
+static struct cpu_pid_state             processor_state[2];
 static struct basckside_pid_params      backside_params;
 static struct backside_pid_state        backside_state;
 static struct drives_pid_state          drives_state;
@@ -375,7 +375,7 @@ static int read_smon_adc(struct cpu_pid_state *state, int chan)
                 rc = i2c_master_send(state->monitor, buf, 2);
                 if (rc <= 0)
                         goto error;
-                /* Wait for convertion */
+                /* Wait for conversion */
                 msleep(1);
                 /* Switch to data register */
                 buf[0] = 4;
@@ -443,7 +443,7 @@ static int fan_read_reg(int reg, unsigned char *buf, int nb)
         tries = 0;
         for (;;) {
                 nr = i2c_master_recv(fcu, buf, nb);
-                if (nr > 0 || (nr < 0 && nr != ENODEV) || tries >= 100)
+                if (nr > 0 || (nr < 0 && nr != -ENODEV) || tries >= 100)
                         break;
                 msleep(10);
                 ++tries;
@@ -464,7 +464,7 @@ static int fan_write_reg(int reg, const unsigned char *ptr, int nb)
         tries = 0;
         for (;;) {
                 nw = i2c_master_send(fcu, buf, nb);
-                if (nw > 0 || (nw < 0 && nw != EIO) || tries >= 100)
+                if (nw > 0 || (nw < 0 && nw != -EIO) || tries >= 100)
                         break;
                 msleep(10);
                 ++tries;
@@ -664,8 +664,8 @@ static int read_eeprom(int cpu, struct mpu_data *out)
 
 static void fetch_cpu_pumps_minmax(void)
 {
-        struct cpu_pid_state *state0 = &cpu_state[0];
-        struct cpu_pid_state *state1 = &cpu_state[1];
+        struct cpu_pid_state *state0 = &processor_state[0];
+        struct cpu_pid_state *state1 = &processor_state[1];
         u16 pump_min = 0, pump_max = 0xffff;
         u16 tmp[4];
 
@@ -717,17 +717,17 @@ static ssize_t show_##name(struct device *dev, struct device_attribute *attr, ch
         return sprintf(buf, "%d", data);                        \
 }
 
-BUILD_SHOW_FUNC_FIX(cpu0_temperature, cpu_state[0].last_temp)
-BUILD_SHOW_FUNC_FIX(cpu0_voltage, cpu_state[0].voltage)
-BUILD_SHOW_FUNC_FIX(cpu0_current, cpu_state[0].current_a)
-BUILD_SHOW_FUNC_INT(cpu0_exhaust_fan_rpm, cpu_state[0].rpm)
-BUILD_SHOW_FUNC_INT(cpu0_intake_fan_rpm, cpu_state[0].intake_rpm)
+BUILD_SHOW_FUNC_FIX(cpu0_temperature, processor_state[0].last_temp)
+BUILD_SHOW_FUNC_FIX(cpu0_voltage, processor_state[0].voltage)
+BUILD_SHOW_FUNC_FIX(cpu0_current, processor_state[0].current_a)
+BUILD_SHOW_FUNC_INT(cpu0_exhaust_fan_rpm, processor_state[0].rpm)
+BUILD_SHOW_FUNC_INT(cpu0_intake_fan_rpm, processor_state[0].intake_rpm)
 
-BUILD_SHOW_FUNC_FIX(cpu1_temperature, cpu_state[1].last_temp)
-BUILD_SHOW_FUNC_FIX(cpu1_voltage, cpu_state[1].voltage)
-BUILD_SHOW_FUNC_FIX(cpu1_current, cpu_state[1].current_a)
-BUILD_SHOW_FUNC_INT(cpu1_exhaust_fan_rpm, cpu_state[1].rpm)
-BUILD_SHOW_FUNC_INT(cpu1_intake_fan_rpm, cpu_state[1].intake_rpm)
+BUILD_SHOW_FUNC_FIX(cpu1_temperature, processor_state[1].last_temp)
+BUILD_SHOW_FUNC_FIX(cpu1_voltage, processor_state[1].voltage)
+BUILD_SHOW_FUNC_FIX(cpu1_current, processor_state[1].current_a)
+BUILD_SHOW_FUNC_INT(cpu1_exhaust_fan_rpm, processor_state[1].rpm)
+BUILD_SHOW_FUNC_INT(cpu1_intake_fan_rpm, processor_state[1].intake_rpm)
 
 BUILD_SHOW_FUNC_FIX(backside_temperature, backside_state.last_temp)
 BUILD_SHOW_FUNC_INT(backside_fan_pwm, backside_state.pwm)
@@ -919,8 +919,8 @@ static void do_cpu_pid(struct cpu_pid_state *state, s32 temp, s32 power)
 
 static void do_monitor_cpu_combined(void)
 {
-        struct cpu_pid_state *state0 = &cpu_state[0];
-        struct cpu_pid_state *state1 = &cpu_state[1];
+        struct cpu_pid_state *state0 = &processor_state[0];
+        struct cpu_pid_state *state1 = &processor_state[1];
         s32 temp0, power0, temp1, power1;
         s32 temp_combi, power_combi;
         int rc, intake, pump;
@@ -1150,7 +1150,7 @@ static void do_monitor_cpu_rack(struct cpu_pid_state *state)
 /*
  * Initialize the state structure for one CPU control loop
  */
-static int init_cpu_state(struct cpu_pid_state *state, int index)
+static int init_processor_state(struct cpu_pid_state *state, int index)
 {
         int err;
 
@@ -1192,7 +1192,7 @@ static int init_cpu_state(struct cpu_pid_state *state, int index)
                 err |= device_create_file(&of_dev->dev, &dev_attr_cpu1_intake_fan_rpm);
         }
         if (err)
-                printk(KERN_WARNING "Failed to create some of the atribute"
+                printk(KERN_WARNING "Failed to create some of the attribute"
                         "files for CPU %d\n", index);
 
         return 0;
@@ -1205,7 +1205,7 @@ static int init_cpu_state(struct cpu_pid_state *state, int index)
 /*
  * Dispose of the state data for one CPU control loop
  */
-static void dispose_cpu_state(struct cpu_pid_state *state)
+static void dispose_processor_state(struct cpu_pid_state *state)
 {
         if (state->monitor == NULL)
                 return;
@@ -1804,9 +1804,9 @@ static int main_control_loop(void *x)
                 set_pwm_fan(SLOTS_FAN_PWM_INDEX, SLOTS_FAN_DEFAULT_PWM);
 
         /* Initialize ADCs */
-        initialize_adc(&cpu_state[0]);
-        if (cpu_state[1].monitor != NULL)
-                initialize_adc(&cpu_state[1]);
+        initialize_adc(&processor_state[0]);
+        if (processor_state[1].monitor != NULL)
+                initialize_adc(&processor_state[1]);
 
         fcu_tickle_ticks = FCU_TICKLE_TICKS;
 
@@ -1833,14 +1833,14 @@ static int main_control_loop(void *x)
                 if (cpu_pid_type == CPU_PID_TYPE_COMBINED)
                         do_monitor_cpu_combined();
                 else if (cpu_pid_type == CPU_PID_TYPE_RACKMAC) {
-                        do_monitor_cpu_rack(&cpu_state[0]);
-                        if (cpu_state[1].monitor != NULL)
-                                do_monitor_cpu_rack(&cpu_state[1]);
+                        do_monitor_cpu_rack(&processor_state[0]);
+                        if (processor_state[1].monitor != NULL)
+                                do_monitor_cpu_rack(&processor_state[1]);
                         // better deal with UP
                 } else {
-                        do_monitor_cpu_split(&cpu_state[0]);
-                        if (cpu_state[1].monitor != NULL)
-                                do_monitor_cpu_split(&cpu_state[1]);
+                        do_monitor_cpu_split(&processor_state[0]);
+                        if (processor_state[1].monitor != NULL)
+                                do_monitor_cpu_split(&processor_state[1]);
                         // better deal with UP
                 }
                 /* Then, the rest */
@@ -1885,8 +1885,8 @@ static int main_control_loop(void *x)
  */
 static void dispose_control_loops(void)
 {
-        dispose_cpu_state(&cpu_state[0]);
-        dispose_cpu_state(&cpu_state[1]);
+        dispose_processor_state(&processor_state[0]);
+        dispose_processor_state(&processor_state[1]);
         dispose_backside_state(&backside_state);
         dispose_drives_state(&drives_state);
         dispose_slots_state(&slots_state);
@@ -1928,12 +1928,12 @@ static int create_control_loops(void)
         /* Create control loops for everything. If any fail, everything
          * fails
          */
-        if (init_cpu_state(&cpu_state[0], 0))
+        if (init_processor_state(&processor_state[0], 0))
                 goto fail;
         if (cpu_pid_type == CPU_PID_TYPE_COMBINED)
                 fetch_cpu_pumps_minmax();
 
-        if (cpu_count > 1 && init_cpu_state(&cpu_state[1], 1))
+        if (cpu_count > 1 && init_processor_state(&processor_state[1], 1))
                 goto fail;
         if (init_backside_state(&backside_state))
                 goto fail;
@@ -2210,9 +2210,12 @@ static void fcu_lookup_fans(struct device_node *fcu_node)
         }
 }
 
-static int fcu_of_probe(struct platform_device* dev, const struct of_device_id *match)
+static int fcu_of_probe(struct platform_device* dev)
 {
         state = state_detached;
+        of_dev = dev;
+
+        dev_info(&dev->dev, "PowerMac G5 Thermal control driver %s\n", VERSION);
 
         /* Lookup the fans in the device tree */
         fcu_lookup_fans(dev->dev.of_node);
@@ -2235,8 +2238,9 @@ static const struct of_device_id fcu_match[] =
         },
         {},
 };
+MODULE_DEVICE_TABLE(of, fcu_match);
 
-static struct of_platform_driver fcu_of_platform_driver = 
+static struct platform_driver fcu_of_platform_driver = 
 {
         .driver = {
                 .name = "temperature",
@@ -2252,8 +2256,6 @@ static struct of_platform_driver fcu_of_platform_driver =
  */
 static int __init therm_pm72_init(void)
 {
-        struct device_node *np;
-
         rackmac = of_machine_is_compatible("RackMac3,1");
 
         if (!of_machine_is_compatible("PowerMac7,2") &&
@@ -2261,34 +2263,12 @@ static int __init therm_pm72_init(void)
             !rackmac)
                 return -ENODEV;
 
-        printk(KERN_INFO "PowerMac G5 Thermal control driver %s\n", VERSION);
-
-        np = of_find_node_by_type(NULL, "fcu");
-        if (np == NULL) {
-                /* Some machines have strangely broken device-tree */
-                np = of_find_node_by_path("/u3@0,f8000000/i2c@f8001000/fan@15e");
-                if (np == NULL) {
-                            printk(KERN_ERR "Can't find FCU in device-tree !\n");
-                            return -ENODEV;
-                }
-        }
-        of_dev = of_platform_device_create(np, "temperature", NULL);
-        if (of_dev == NULL) {
-                printk(KERN_ERR "Can't register FCU platform device !\n");
-                return -ENODEV;
-        }
-
-        of_register_platform_driver(&fcu_of_platform_driver);
-        
-        return 0;
+        return platform_driver_register(&fcu_of_platform_driver);
 }
 
 static void __exit therm_pm72_exit(void)
 {
-        of_unregister_platform_driver(&fcu_of_platform_driver);
-
-        if (of_dev)
-                of_device_unregister(of_dev);
+        platform_driver_unregister(&fcu_of_platform_driver);
 }
 
 module_init(therm_pm72_init);
diff --git a/drivers/macintosh/therm_windtunnel.c b/drivers/macintosh/therm_windtunnel.c
index c89f396e4c53..46c4e95f10d6 100644
--- a/drivers/macintosh/therm_windtunnel.c
+++ b/drivers/macintosh/therm_windtunnel.c
@@ -45,7 +45,7 @@
 #include <asm/sections.h>
 #include <asm/macio.h>
 
-#define LOG_TEMP                0                       /* continously log temperature */
+#define LOG_TEMP                0                       /* continuously log temperature */
 
 static struct {
         volatile int            running;
@@ -443,8 +443,7 @@ static struct i2c_driver g4fan_driver = {
 /*      initialization / cleanup                                        */
 /************************************************************************/
 
-static int
-therm_of_probe( struct platform_device *dev, const struct of_device_id *match )
+static int therm_of_probe(struct platform_device *dev)
 {
         return i2c_add_driver( &g4fan_driver );
 }
@@ -462,7 +461,7 @@ static const struct of_device_id therm_of_match[] = {{
     }, {}
 };
 
-static struct of_platform_driver therm_of_driver = {
+static struct platform_driver therm_of_driver = {
         .driver = {
                 .name = "temperature",
                 .owner = THIS_MODULE,
@@ -509,14 +508,14 @@ g4fan_init( void )
                 return -ENODEV;
         }
 
-        of_register_platform_driver( &therm_of_driver );
+        platform_driver_register( &therm_of_driver );
         return 0;
 }
 
 static void __exit
 g4fan_exit( void )
 {
-        of_unregister_platform_driver( &therm_of_driver );
+        platform_driver_unregister( &therm_of_driver );
 
         if( x.of_dev )
                 of_device_unregister( x.of_dev );
diff --git a/drivers/macintosh/via-pmu-backlight.c b/drivers/macintosh/via-pmu-backlight.c
index 1cec02f6c431..b1d91170ded0 100644
--- a/drivers/macintosh/via-pmu-backlight.c
+++ b/drivers/macintosh/via-pmu-backlight.c
@@ -15,7 +15,7 @@
 
 #define MAX_PMU_LEVEL 0xFF
 
-static struct backlight_ops pmu_backlight_data;
+static const struct backlight_ops pmu_backlight_data;
 static DEFINE_SPINLOCK(pmu_backlight_lock);
 static int sleeping, uses_pmu_bl;
 static u8 bl_curve[FB_BACKLIGHT_LEVELS];
@@ -115,7 +115,7 @@ static int pmu_backlight_get_brightness(struct backlight_device *bd)
         return bd->props.brightness;
 }
 
-static struct backlight_ops pmu_backlight_data = {
+static const struct backlight_ops pmu_backlight_data = {
         .get_brightness = pmu_backlight_get_brightness,
         .update_status  = pmu_backlight_update_status,
 
@@ -163,6 +163,7 @@ void __init pmu_backlight_init()
         snprintf(name, sizeof(name), "pmubl");
 
         memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_PLATFORM;
         props.max_brightness = FB_BACKLIGHT_LEVELS - 1;
         bd = backlight_device_register(name, NULL, NULL, &pmu_backlight_data,
                                        &props);
diff --git a/drivers/macintosh/via-pmu-led.c b/drivers/macintosh/via-pmu-led.c
index d242976bcfe7..19c371809d77 100644
--- a/drivers/macintosh/via-pmu-led.c
+++ b/drivers/macintosh/via-pmu-led.c
@@ -92,8 +92,10 @@ static int __init via_pmu_led_init(void)
         if (dt == NULL)
                 return -ENODEV;
         model = of_get_property(dt, "model", NULL);
-        if (model == NULL)
+        if (model == NULL) {
+                of_node_put(dt);
                 return -ENODEV;
+        }
         if (strncmp(model, "PowerBook", strlen("PowerBook")) != 0 &&
             strncmp(model, "iBook", strlen("iBook")) != 0 &&
             strcmp(model, "PowerMac7,2") != 0 &&
diff --git a/drivers/macintosh/via-pmu.c b/drivers/macintosh/via-pmu.c
index 2d17e76066bd..6cccd60c594e 100644
--- a/drivers/macintosh/via-pmu.c
+++ b/drivers/macintosh/via-pmu.c
@@ -18,7 +18,7 @@
  *
  */
 #include <stdarg.h>
-#include <linux/smp_lock.h>
+#include <linux/mutex.h>
 #include <linux/types.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
@@ -40,7 +40,7 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/device.h>
-#include <linux/sysdev.h>
+#include <linux/syscore_ops.h>
 #include <linux/freezer.h>
 #include <linux/syscalls.h>
 #include <linux/suspend.h>
@@ -73,6 +73,7 @@
 /* How many iterations between battery polls */
 #define BATTERY_POLLING_COUNT   2
 
+static DEFINE_MUTEX(pmu_info_proc_mutex);
 static volatile unsigned char __iomem *via;
 
 /* VIA registers - spaced 0x200 bytes apart */
@@ -2078,7 +2079,7 @@ pmu_open(struct inode *inode, struct file *file)
         pp->rb_get = pp->rb_put = 0;
         spin_lock_init(&pp->lock);
         init_waitqueue_head(&pp->wait);
-        lock_kernel();
+        mutex_lock(&pmu_info_proc_mutex);
         spin_lock_irqsave(&all_pvt_lock, flags);
 #if defined(CONFIG_INPUT_ADBHID) && defined(CONFIG_PMAC_BACKLIGHT)
         pp->backlight_locker = 0;
@@ -2086,7 +2087,7 @@ pmu_open(struct inode *inode, struct file *file)
         list_add(&pp->list, &all_pmu_pvt);
         spin_unlock_irqrestore(&all_pvt_lock, flags);
         file->private_data = pp;
-        unlock_kernel();
+        mutex_unlock(&pmu_info_proc_mutex);
         return 0;
 }
 
@@ -2256,7 +2257,7 @@ static int pmu_sleep_valid(suspend_state_t state)
                 && (pmac_call_feature(PMAC_FTR_SLEEP_STATE, NULL, 0, -1) >= 0);
 }
 
-static struct platform_suspend_ops pmu_pm_ops = {
+static const struct platform_suspend_ops pmu_pm_ops = {
         .enter = powerbook_sleep,
         .valid = pmu_sleep_valid,
 };
@@ -2343,9 +2344,9 @@ static long pmu_unlocked_ioctl(struct file *filp,
 {
         int ret;
 
-        lock_kernel();
+        mutex_lock(&pmu_info_proc_mutex);
         ret = pmu_ioctl(filp, cmd, arg);
-        unlock_kernel();
+        mutex_unlock(&pmu_info_proc_mutex);
 
         return ret;
 }
@@ -2398,6 +2399,7 @@ static const struct file_operations pmu_device_fops = {
 #endif
         .open           = pmu_open,
         .release        = pmu_release,
+        .llseek         = noop_llseek,
 };
 
 static struct miscdevice pmu_device = {
@@ -2525,12 +2527,9 @@ void pmu_blink(int n)
 #if defined(CONFIG_SUSPEND) && defined(CONFIG_PPC32)
 int pmu_sys_suspended;
 
-static int pmu_sys_suspend(struct sys_device *sysdev, pm_message_t state)
+static int pmu_syscore_suspend(void)
 {
-        if (state.event != PM_EVENT_SUSPEND || pmu_sys_suspended)
-                return 0;
-
-        /* Suspend PMU event interrupts */\
+        /* Suspend PMU event interrupts */
         pmu_suspend();
         pmu_sys_suspended = 1;
 
@@ -2542,12 +2541,12 @@ static int pmu_sys_suspend(struct sys_device *sysdev, pm_message_t state)
         return 0;
 }
 
-static int pmu_sys_resume(struct sys_device *sysdev)
+static void pmu_syscore_resume(void)
 {
         struct adb_request req;
 
         if (!pmu_sys_suspended)
-                return 0;
+                return;
 
         /* Tell PMU we are ready */
         pmu_request(&req, NULL, 2, PMU_SYSTEM_READY, 2);
@@ -2560,50 +2559,21 @@ static int pmu_sys_resume(struct sys_device *sysdev)
         /* Resume PMU event interrupts */
         pmu_resume();
         pmu_sys_suspended = 0;
-
-        return 0;
 }
 
-#endif /* CONFIG_SUSPEND && CONFIG_PPC32 */
-
-static struct sysdev_class pmu_sysclass = {
-        .name = "pmu",
-};
-
-static struct sys_device device_pmu = {
-        .cls            = &pmu_sysclass,
-};
-
-static struct sysdev_driver driver_pmu = {
-#if defined(CONFIG_SUSPEND) && defined(CONFIG_PPC32)
-        .suspend        = &pmu_sys_suspend,
-        .resume         = &pmu_sys_resume,
-#endif /* CONFIG_SUSPEND && CONFIG_PPC32 */
+static struct syscore_ops pmu_syscore_ops = {
+        .suspend = pmu_syscore_suspend,
+        .resume = pmu_syscore_resume,
 };
 
-static int __init init_pmu_sysfs(void)
+static int pmu_syscore_register(void)
 {
-        int rc;
+        register_syscore_ops(&pmu_syscore_ops);
 
-        rc = sysdev_class_register(&pmu_sysclass);
-        if (rc) {
-                printk(KERN_ERR "Failed registering PMU sys class\n");
-                return -ENODEV;
-        }
-        rc = sysdev_register(&device_pmu);
-        if (rc) {
-                printk(KERN_ERR "Failed registering PMU sys device\n");
-                return -ENODEV;
-        }
-        rc = sysdev_driver_register(&pmu_sysclass, &driver_pmu);
-        if (rc) {
-                printk(KERN_ERR "Failed registering PMU sys driver\n");
-                return -ENODEV;
-        }
         return 0;
 }
-
-subsys_initcall(init_pmu_sysfs);
+subsys_initcall(pmu_syscore_register);
+#endif /* CONFIG_SUSPEND && CONFIG_PPC32 */
 
 EXPORT_SYMBOL(pmu_request);
 EXPORT_SYMBOL(pmu_queue_request);
diff --git a/drivers/macintosh/windfarm_pm121.c b/drivers/macintosh/windfarm_pm121.c
index 947d4afa25ca..30e6195e19d4 100644
--- a/drivers/macintosh/windfarm_pm121.c
+++ b/drivers/macintosh/windfarm_pm121.c
@@ -482,7 +482,7 @@ static s32 pm121_correct(s32 new_setpoint,
         new_min += correction->offset;
         new_min = (new_min >> 16) + min;
 
-        return max(new_setpoint, max(new_min, 0));
+        return max3(new_setpoint, new_min, 0);
 }
 
 static s32 pm121_connect(unsigned int control_id, s32 setpoint)