Merge branch 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/benh/powerpc

* 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/benh/powerpc: (88 commits)
  powerpc: Fix lwsync feature fixup vs. modules on 64-bit
  powerpc: Convert pmc_owner_lock to raw_spinlock
  powerpc: Convert die.lock to raw_spinlock
  powerpc: Convert tlbivax_lock to raw_spinlock
  powerpc: Convert mpic locks to raw_spinlock
  powerpc: Convert pmac_pic_lock to raw_spinlock
  powerpc: Convert big_irq_lock to raw_spinlock
  powerpc: Convert feature_lock to raw_spinlock
  powerpc: Convert i8259_lock to raw_spinlock
  powerpc: Convert beat_htab_lock to raw_spinlock
  powerpc: Convert confirm_error_lock to raw_spinlock
  powerpc: Convert ipic_lock to raw_spinlock
  powerpc: Convert native_tlbie_lock to raw_spinlock
  powerpc: Convert beatic_irq_mask_lock to raw_spinlock
  powerpc: Convert nv_lock to raw_spinlock
  powerpc: Convert context_lock to raw_spinlock
  powerpc/85xx: Add NOR, LEDs and PIB support for MPC8568E-MDS boards
  powerpc/86xx: Enable VME driver on the GE SBC610
  powerpc/86xx: Enable VME driver on the GE PPC9A
  powerpc/86xx: Add MSI section to GE PPC9A DTS
  ...

14 files changed, 718 insertions, 86 deletions

diff --git a/drivers/block/viodasd.c b/drivers/block/viodasd.c
index a8c8b56b275e..1b3def1e8591 100644
--- a/drivers/block/viodasd.c
+++ b/drivers/block/viodasd.c
@@ -28,6 +28,9 @@
  * All disk operations are performed by sending messages back and forth to
  * the OS/400 partition.
  */
+
+#define pr_fmt(fmt) "viod: " fmt
+
 #include <linux/major.h>
 #include <linux/fs.h>
 #include <linux/module.h>
@@ -63,9 +66,6 @@ MODULE_LICENSE("GPL");
 
 #define VIOD_VERS               "1.64"
 
-#define VIOD_KERN_WARNING       KERN_WARNING "viod: "
-#define VIOD_KERN_INFO          KERN_INFO "viod: "
-
 enum {
         PARTITION_SHIFT = 3,
         MAX_DISKNO = HVMAXARCHITECTEDVIRTUALDISKS,
@@ -156,7 +156,7 @@ static int viodasd_open(struct block_device *bdev, fmode_t mode)
                         ((u64)DEVICE_NO(d) << 48) | ((u64)flags << 32),
                         0, 0, 0);
         if (hvrc != 0) {
-                printk(VIOD_KERN_WARNING "HV open failed %d\n", (int)hvrc);
+                pr_warning("HV open failed %d\n", (int)hvrc);
                 return -EIO;
         }
 
@@ -167,9 +167,8 @@ static int viodasd_open(struct block_device *bdev, fmode_t mode)
                 const struct vio_error_entry *err =
                         vio_lookup_rc(viodasd_err_table, we.sub_result);
 
-                printk(VIOD_KERN_WARNING
-                                "bad rc opening disk: %d:0x%04x (%s)\n",
-                                (int)we.rc, we.sub_result, err->msg);
+                pr_warning("bad rc opening disk: %d:0x%04x (%s)\n",
+                           (int)we.rc, we.sub_result, err->msg);
                 return -EIO;
         }
 
@@ -195,8 +194,7 @@ static int viodasd_release(struct gendisk *disk, fmode_t mode)
                         ((u64)DEVICE_NO(d) << 48) /* | ((u64)flags << 32) */,
                         0, 0, 0);
         if (hvrc != 0)
-                printk(VIOD_KERN_WARNING "HV close call failed %d\n",
-                                (int)hvrc);
+                pr_warning("HV close call failed %d\n", (int)hvrc);
         return 0;
 }
 
@@ -288,8 +286,7 @@ static int send_request(struct request *req)
                 bevent = (struct vioblocklpevent *)
                         vio_get_event_buffer(viomajorsubtype_blockio);
                 if (bevent == NULL) {
-                        printk(VIOD_KERN_WARNING
-                               "error allocating disk event buffer\n");
+                        pr_warning("error allocating disk event buffer\n");
                         goto error_ret;
                 }
 
@@ -333,9 +330,8 @@ static int send_request(struct request *req)
         }
 
         if (hvrc != HvLpEvent_Rc_Good) {
-                printk(VIOD_KERN_WARNING
-                       "error sending disk event to OS/400 (rc %d)\n",
-                       (int)hvrc);
+                pr_warning("error sending disk event to OS/400 (rc %d)\n",
+                           (int)hvrc);
                 goto error_ret;
         }
         spin_unlock_irqrestore(&viodasd_spinlock, flags);
@@ -402,7 +398,7 @@ retry:
                         ((u64)dev_no << 48) | ((u64)flags<< 32),
                         0, 0, 0);
         if (hvrc != 0) {
-                printk(VIOD_KERN_WARNING "bad rc on HV open %d\n", (int)hvrc);
+                pr_warning("bad rc on HV open %d\n", (int)hvrc);
                 return 0;
         }
 
@@ -416,9 +412,8 @@ retry:
                 goto retry;
         }
         if (we.max_disk > (MAX_DISKNO - 1)) {
-                printk_once(VIOD_KERN_INFO
-                        "Only examining the first %d of %d disks connected\n",
-                        MAX_DISKNO, we.max_disk + 1);
+                printk_once(KERN_INFO pr_fmt("Only examining the first %d of %d disks connected\n"),
+                            MAX_DISKNO, we.max_disk + 1);
         }
 
         /* Send the close event to OS/400.  We DON'T expect a response */
@@ -432,17 +427,15 @@ retry:
                         ((u64)dev_no << 48) | ((u64)flags << 32),
                         0, 0, 0);
         if (hvrc != 0) {
-                printk(VIOD_KERN_WARNING
-                       "bad rc sending event to OS/400 %d\n", (int)hvrc);
+                pr_warning("bad rc sending event to OS/400 %d\n", (int)hvrc);
                 return 0;
         }
 
         if (d->dev == NULL) {
                 /* this is when we reprobe for new disks */
                 if (vio_create_viodasd(dev_no) == NULL) {
-                        printk(VIOD_KERN_WARNING
-                                "cannot allocate virtual device for disk %d\n",
-                                dev_no);
+                        pr_warning("cannot allocate virtual device for disk %d\n",
+                                   dev_no);
                         return 0;
                 }
                 /*
@@ -457,15 +450,13 @@ retry:
         spin_lock_init(&d->q_lock);
         q = blk_init_queue(do_viodasd_request, &d->q_lock);
         if (q == NULL) {
-                printk(VIOD_KERN_WARNING "cannot allocate queue for disk %d\n",
-                                dev_no);
+                pr_warning("cannot allocate queue for disk %d\n", dev_no);
                 return 0;
         }
         g = alloc_disk(1 << PARTITION_SHIFT);
         if (g == NULL) {
-                printk(VIOD_KERN_WARNING
-                                "cannot allocate disk structure for disk %d\n",
-                                dev_no);
+                pr_warning("cannot allocate disk structure for disk %d\n",
+                           dev_no);
                 blk_cleanup_queue(q);
                 return 0;
         }
@@ -489,13 +480,12 @@ retry:
         g->driverfs_dev = d->dev;
         set_capacity(g, d->size >> 9);
 
-        printk(VIOD_KERN_INFO "disk %d: %lu sectors (%lu MB) "
-                        "CHS=%d/%d/%d sector size %d%s\n",
-                        dev_no, (unsigned long)(d->size >> 9),
-                        (unsigned long)(d->size >> 20),
-                        (int)d->cylinders, (int)d->tracks,
-                        (int)d->sectors, (int)d->bytes_per_sector,
-                        d->read_only ? " (RO)" : "");
+        pr_info("disk %d: %lu sectors (%lu MB) CHS=%d/%d/%d sector size %d%s\n",
+                dev_no, (unsigned long)(d->size >> 9),
+                (unsigned long)(d->size >> 20),
+                (int)d->cylinders, (int)d->tracks,
+                (int)d->sectors, (int)d->bytes_per_sector,
+                d->read_only ? " (RO)" : "");
 
         /* register us in the global list */
         add_disk(g);
@@ -580,8 +570,8 @@ static int viodasd_handle_read_write(struct vioblocklpevent *bevent)
         if (error) {
                 const struct vio_error_entry *err;
                 err = vio_lookup_rc(viodasd_err_table, bevent->sub_result);
-                printk(VIOD_KERN_WARNING "read/write error %d:0x%04x (%s)\n",
-                                event->xRc, bevent->sub_result, err->msg);
+                pr_warning("read/write error %d:0x%04x (%s)\n",
+                           event->xRc, bevent->sub_result, err->msg);
                 num_sect = blk_rq_sectors(req);
         }
         qlock = req->q->queue_lock;
@@ -606,8 +596,7 @@ static void handle_block_event(struct HvLpEvent *event)
                 return;
         /* First, we should NEVER get an int here...only acks */
         if (hvlpevent_is_int(event)) {
-                printk(VIOD_KERN_WARNING
-                       "Yikes! got an int in viodasd event handler!\n");
+                pr_warning("Yikes! got an int in viodasd event handler!\n");
                 if (hvlpevent_need_ack(event)) {
                         event->xRc = HvLpEvent_Rc_InvalidSubtype;
                         HvCallEvent_ackLpEvent(event);
@@ -650,7 +639,7 @@ static void handle_block_event(struct HvLpEvent *event)
                 break;
 
         default:
-                printk(VIOD_KERN_WARNING "invalid subtype!");
+                pr_warning("invalid subtype!");
                 if (hvlpevent_need_ack(event)) {
                         event->xRc = HvLpEvent_Rc_InvalidSubtype;
                         HvCallEvent_ackLpEvent(event);
@@ -739,29 +728,26 @@ static int __init viodasd_init(void)
                 vio_set_hostlp();
 
         if (viopath_hostLp == HvLpIndexInvalid) {
-                printk(VIOD_KERN_WARNING "invalid hosting partition\n");
+                pr_warning("invalid hosting partition\n");
                 rc = -EIO;
                 goto early_fail;
         }
 
-        printk(VIOD_KERN_INFO "vers " VIOD_VERS ", hosting partition %d\n",
-                        viopath_hostLp);
+        pr_info("vers " VIOD_VERS ", hosting partition %d\n", viopath_hostLp);
 
         /* register the block device */
         rc =  register_blkdev(VIODASD_MAJOR, VIOD_GENHD_NAME);
         if (rc) {
-                printk(VIOD_KERN_WARNING
-                                "Unable to get major number %d for %s\n",
-                                VIODASD_MAJOR, VIOD_GENHD_NAME);
+                pr_warning("Unable to get major number %d for %s\n",
+                           VIODASD_MAJOR, VIOD_GENHD_NAME);
                 goto early_fail;
         }
         /* Actually open the path to the hosting partition */
         rc = viopath_open(viopath_hostLp, viomajorsubtype_blockio,
                                 VIOMAXREQ + 2);
         if (rc) {
-                printk(VIOD_KERN_WARNING
-                       "error opening path to host partition %d\n",
-                       viopath_hostLp);
+                pr_warning("error opening path to host partition %d\n",
+                           viopath_hostLp);
                 goto unregister_blk;
         }
 
@@ -770,7 +756,7 @@ static int __init viodasd_init(void)
 
         rc = vio_register_driver(&viodasd_driver);
         if (rc) {
-                printk(VIOD_KERN_WARNING "vio_register_driver failed\n");
+                pr_warning("vio_register_driver failed\n");
                 goto unset_handler;
         }
 
diff --git a/drivers/char/hvc_console.c b/drivers/char/hvc_console.c
index d8dac5820f0e..4c3b59be286a 100644
--- a/drivers/char/hvc_console.c
+++ b/drivers/char/hvc_console.c
@@ -748,9 +748,9 @@ static const struct tty_operations hvc_ops = {
         .chars_in_buffer = hvc_chars_in_buffer,
 };
 
-struct hvc_struct __devinit *hvc_alloc(uint32_t vtermno, int data,
-                                       const struct hv_ops *ops,
-                                       int outbuf_size)
+struct hvc_struct *hvc_alloc(uint32_t vtermno, int data,
+                             const struct hv_ops *ops,
+                             int outbuf_size)
 {
         struct hvc_struct *hp;
         int i;
diff --git a/drivers/char/hvc_console.h b/drivers/char/hvc_console.h
index 52ddf4d3716c..54381eba4e4a 100644
--- a/drivers/char/hvc_console.h
+++ b/drivers/char/hvc_console.h
@@ -80,8 +80,8 @@ extern int hvc_instantiate(uint32_t vtermno, int index,
                            const struct hv_ops *ops);
 
 /* register a vterm for hvc tty operation (module_init or hotplug add) */
-extern struct hvc_struct * __devinit hvc_alloc(uint32_t vtermno, int data,
-                                const struct hv_ops *ops, int outbuf_size);
+extern struct hvc_struct * hvc_alloc(uint32_t vtermno, int data,
+                                     const struct hv_ops *ops, int outbuf_size);
 /* remove a vterm from hvc tty operation (module_exit or hotplug remove) */
 extern int hvc_remove(struct hvc_struct *hp);
 
diff --git a/drivers/hwmon/ams/ams-core.c b/drivers/hwmon/ams/ams-core.c
index 6c9ace1b76f6..2ad62c339cd2 100644
--- a/drivers/hwmon/ams/ams-core.c
+++ b/drivers/hwmon/ams/ams-core.c
@@ -213,7 +213,7 @@ int __init ams_init(void)
         return -ENODEV;
 }
 
-void ams_exit(void)
+void ams_sensor_detach(void)
 {
         /* Remove input device */
         ams_input_exit();
@@ -221,9 +221,6 @@ void ams_exit(void)
         /* Remove attributes */
         device_remove_file(&ams_info.of_dev->dev, &dev_attr_current);
 
-        /* Shut down implementation */
-        ams_info.exit();
-
         /* Flush interrupt worker
          *
          * We do this after ams_info.exit(), because an interrupt might
@@ -239,6 +236,12 @@ void ams_exit(void)
         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");
diff --git a/drivers/hwmon/ams/ams-i2c.c b/drivers/hwmon/ams/ams-i2c.c
index 2cbf8a6506c7..abeecd27b484 100644
--- a/drivers/hwmon/ams/ams-i2c.c
+++ b/drivers/hwmon/ams/ams-i2c.c
@@ -238,6 +238,8 @@ static int ams_i2c_probe(struct i2c_client *client,
 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);
 
diff --git a/drivers/hwmon/ams/ams-pmu.c b/drivers/hwmon/ams/ams-pmu.c
index fb18b3d3162b..4f61b3ee1b08 100644
--- a/drivers/hwmon/ams/ams-pmu.c
+++ b/drivers/hwmon/ams/ams-pmu.c
@@ -133,6 +133,8 @@ static void ams_pmu_get_xyz(s8 *x, s8 *y, s8 *z)
 
 static void ams_pmu_exit(void)
 {
+        ams_sensor_detach();
+
         /* Disable interrupts */
         ams_pmu_set_irq(AMS_IRQ_ALL, 0);
 
diff --git a/drivers/hwmon/ams/ams.h b/drivers/hwmon/ams/ams.h
index 5ed387b0bd9a..b28d7e27a031 100644
--- a/drivers/hwmon/ams/ams.h
+++ b/drivers/hwmon/ams/ams.h
@@ -61,6 +61,7 @@ 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);
diff --git a/drivers/macintosh/therm_adt746x.c b/drivers/macintosh/therm_adt746x.c
index 5ff47ba7f2d0..c42eeb43042d 100644
--- a/drivers/macintosh/therm_adt746x.c
+++ b/drivers/macintosh/therm_adt746x.c
@@ -90,6 +90,8 @@ static struct task_struct *thread_therm = NULL;
 
 static void write_both_fan_speed(struct thermostat *th, int speed);
 static void write_fan_speed(struct thermostat *th, int speed, int fan);
+static void thermostat_create_files(void);
+static void thermostat_remove_files(void);
 
 static int
 write_reg(struct thermostat* th, int reg, u8 data)
@@ -161,6 +163,8 @@ remove_thermostat(struct i2c_client *client)
         struct thermostat *th = i2c_get_clientdata(client);
         int i;
         
+        thermostat_remove_files();
+
         if (thread_therm != NULL) {
                 kthread_stop(thread_therm);
         }
@@ -312,7 +316,7 @@ static void update_fans_speed (struct thermostat *th)
 
                         if (verbose)
                                 printk(KERN_DEBUG "adt746x: Setting fans speed to %d "
-                                                 "(limit exceeded by %d on %s) \n",
+                                                 "(limit exceeded by %d on %s)\n",
                                                 new_speed, var,
                                                 sensor_location[fan_number+1]);
                         write_both_fan_speed(th, new_speed);
@@ -449,6 +453,8 @@ static int probe_thermostat(struct i2c_client *client,
                 return -ENOMEM;
         }
 
+        thermostat_create_files();
+
         return 0;
 }
 
@@ -566,7 +572,6 @@ thermostat_init(void)
         struct device_node* np;
         const u32 *prop;
         int i = 0, offset = 0;
-        int err;
 
         np = of_find_node_by_name(NULL, "fan");
         if (!np)
@@ -633,6 +638,17 @@ thermostat_init(void)
                 return -ENODEV;
         }
 
+#ifndef CONFIG_I2C_POWERMAC
+        request_module("i2c-powermac");
+#endif
+
+        return i2c_add_driver(&thermostat_driver);
+}
+
+static void thermostat_create_files(void)
+{
+        int err;
+
         err = device_create_file(&of_dev->dev, &dev_attr_sensor1_temperature);
         err |= device_create_file(&of_dev->dev, &dev_attr_sensor2_temperature);
         err |= device_create_file(&of_dev->dev, &dev_attr_sensor1_limit);
@@ -647,16 +663,9 @@ thermostat_init(void)
         if (err)
                 printk(KERN_WARNING
                         "Failed to create tempertaure attribute file(s).\n");
-
-#ifndef CONFIG_I2C_POWERMAC
-        request_module("i2c-powermac");
-#endif
-
-        return i2c_add_driver(&thermostat_driver);
 }
 
-static void __exit
-thermostat_exit(void)
+static void thermostat_remove_files(void)
 {
         if (of_dev) {
                 device_remove_file(&of_dev->dev, &dev_attr_sensor1_temperature);
@@ -673,9 +682,14 @@ thermostat_exit(void)
                         device_remove_file(&of_dev->dev,
                                            &dev_attr_sensor2_fan_speed);
 
-                of_device_unregister(of_dev);
         }
+}
+
+static void __exit
+thermostat_exit(void)
+{
         i2c_del_driver(&thermostat_driver);
+        of_device_unregister(of_dev);
 }
 
 module_init(thermostat_init);
diff --git a/drivers/ps3/ps3av.c b/drivers/ps3/ps3av.c
index e82d8c9c6cda..95a689befc84 100644
--- a/drivers/ps3/ps3av.c
+++ b/drivers/ps3/ps3av.c
@@ -532,7 +532,7 @@ static void ps3av_set_videomode_packet(u32 id)
         res = ps3av_cmd_avb_param(&avb_param, len);
         if (res == PS3AV_STATUS_NO_SYNC_HEAD)
                 printk(KERN_WARNING
-                       "%s: Command failed. Please try your request again. \n",
+                       "%s: Command failed. Please try your request again.\n",
                        __func__);
         else if (res)
                 dev_dbg(&ps3av->dev->core, "ps3av_cmd_avb_param failed\n");
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 8167e9e6827a..2bb8a8b7ffaf 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -868,4 +868,14 @@ config RTC_DRV_MC13783
         help
           This enables support for the Freescale MC13783 PMIC RTC
 
+config RTC_DRV_MPC5121
+        tristate "Freescale MPC5121 built-in RTC"
+        depends on PPC_MPC512x && RTC_CLASS
+        help
+          If you say yes here you will get support for the
+          built-in RTC MPC5121.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-mpc5121.
+
 endif # RTC_CLASS
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index e5160fddc446..b7148afb8f55 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -55,6 +55,7 @@ obj-$(CONFIG_RTC_DRV_MAX6900)	+= rtc-max6900.o
 obj-$(CONFIG_RTC_DRV_MAX6902)   += rtc-max6902.o
 obj-$(CONFIG_RTC_DRV_MC13783)   += rtc-mc13783.o
 obj-$(CONFIG_RTC_DRV_MSM6242)   += rtc-msm6242.o
+obj-$(CONFIG_RTC_DRV_MPC5121)   += rtc-mpc5121.o
 obj-$(CONFIG_RTC_DRV_MV)        += rtc-mv.o
 obj-$(CONFIG_RTC_DRV_NUC900)    += rtc-nuc900.o
 obj-$(CONFIG_RTC_DRV_OMAP)      += rtc-omap.o
diff --git a/drivers/rtc/rtc-mpc5121.c b/drivers/rtc/rtc-mpc5121.c
new file mode 100644
index 000000000000..4313ca03a96d
--- /dev/null
+++ b/drivers/rtc/rtc-mpc5121.c
@@ -0,0 +1,387 @@
+/*
+ * Real-time clock driver for MPC5121
+ *
+ * Copyright 2007, Domen Puncer <domen.puncer@telargo.com>
+ * Copyright 2008, Freescale Semiconductor, Inc. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/rtc.h>
+#include <linux/of_device.h>
+#include <linux/of_platform.h>
+#include <linux/io.h>
+
+struct mpc5121_rtc_regs {
+        u8 set_time;            /* RTC + 0x00 */
+        u8 hour_set;            /* RTC + 0x01 */
+        u8 minute_set;          /* RTC + 0x02 */
+        u8 second_set;          /* RTC + 0x03 */
+
+        u8 set_date;            /* RTC + 0x04 */
+        u8 month_set;           /* RTC + 0x05 */
+        u8 weekday_set;         /* RTC + 0x06 */
+        u8 date_set;            /* RTC + 0x07 */
+
+        u8 write_sw;            /* RTC + 0x08 */
+        u8 sw_set;              /* RTC + 0x09 */
+        u16 year_set;           /* RTC + 0x0a */
+
+        u8 alm_enable;          /* RTC + 0x0c */
+        u8 alm_hour_set;        /* RTC + 0x0d */
+        u8 alm_min_set;         /* RTC + 0x0e */
+        u8 int_enable;          /* RTC + 0x0f */
+
+        u8 reserved1;
+        u8 hour;                /* RTC + 0x11 */
+        u8 minute;              /* RTC + 0x12 */
+        u8 second;              /* RTC + 0x13 */
+
+        u8 month;               /* RTC + 0x14 */
+        u8 wday_mday;           /* RTC + 0x15 */
+        u16 year;               /* RTC + 0x16 */
+
+        u8 int_alm;             /* RTC + 0x18 */
+        u8 int_sw;              /* RTC + 0x19 */
+        u8 alm_status;          /* RTC + 0x1a */
+        u8 sw_minute;           /* RTC + 0x1b */
+
+        u8 bus_error_1;         /* RTC + 0x1c */
+        u8 int_day;             /* RTC + 0x1d */
+        u8 int_min;             /* RTC + 0x1e */
+        u8 int_sec;             /* RTC + 0x1f */
+
+        /*
+         * target_time:
+         *      intended to be used for hibernation but hibernation
+         *      does not work on silicon rev 1.5 so use it for non-volatile
+         *      storage of offset between the actual_time register and linux
+         *      time
+         */
+        u32 target_time;        /* RTC + 0x20 */
+        /*
+         * actual_time:
+         *      readonly time since VBAT_RTC was last connected
+         */
+        u32 actual_time;        /* RTC + 0x24 */
+        u32 keep_alive;         /* RTC + 0x28 */
+};
+
+struct mpc5121_rtc_data {
+        unsigned irq;
+        unsigned irq_periodic;
+        struct mpc5121_rtc_regs __iomem *regs;
+        struct rtc_device *rtc;
+        struct rtc_wkalrm wkalarm;
+};
+
+/*
+ * Update second/minute/hour registers.
+ *
+ * This is just so alarm will work.
+ */
+static void mpc5121_rtc_update_smh(struct mpc5121_rtc_regs __iomem *regs,
+                                   struct rtc_time *tm)
+{
+        out_8(&regs->second_set, tm->tm_sec);
+        out_8(&regs->minute_set, tm->tm_min);
+        out_8(&regs->hour_set, tm->tm_hour);
+
+        /* set time sequence */
+        out_8(&regs->set_time, 0x1);
+        out_8(&regs->set_time, 0x3);
+        out_8(&regs->set_time, 0x1);
+        out_8(&regs->set_time, 0x0);
+}
+
+static int mpc5121_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct mpc5121_rtc_data *rtc = dev_get_drvdata(dev);
+        struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
+        unsigned long now;
+
+        /*
+         * linux time is actual_time plus the offset saved in target_time
+         */
+        now = in_be32(&regs->actual_time) + in_be32(&regs->target_time);
+
+        rtc_time_to_tm(now, tm);
+
+        /*
+         * update second minute hour registers
+         * so alarms will work
+         */
+        mpc5121_rtc_update_smh(regs, tm);
+
+        return rtc_valid_tm(tm);
+}
+
+static int mpc5121_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct mpc5121_rtc_data *rtc = dev_get_drvdata(dev);
+        struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
+        int ret;
+        unsigned long now;
+
+        /*
+         * The actual_time register is read only so we write the offset
+         * between it and linux time to the target_time register.
+         */
+        ret = rtc_tm_to_time(tm, &now);
+        if (ret == 0)
+                out_be32(&regs->target_time, now - in_be32(&regs->actual_time));
+
+        /*
+         * update second minute hour registers
+         * so alarms will work
+         */
+        mpc5121_rtc_update_smh(regs, tm);
+
+        return 0;
+}
+
+static int mpc5121_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct mpc5121_rtc_data *rtc = dev_get_drvdata(dev);
+        struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
+
+        *alarm = rtc->wkalarm;
+
+        alarm->pending = in_8(&regs->alm_status);
+
+        return 0;
+}
+
+static int mpc5121_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct mpc5121_rtc_data *rtc = dev_get_drvdata(dev);
+        struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
+
+        /*
+         * the alarm has no seconds so deal with it
+         */
+        if (alarm->time.tm_sec) {
+                alarm->time.tm_sec = 0;
+                alarm->time.tm_min++;
+                if (alarm->time.tm_min >= 60) {
+                        alarm->time.tm_min = 0;
+                        alarm->time.tm_hour++;
+                        if (alarm->time.tm_hour >= 24)
+                                alarm->time.tm_hour = 0;
+                }
+        }
+
+        alarm->time.tm_mday = -1;
+        alarm->time.tm_mon = -1;
+        alarm->time.tm_year = -1;
+
+        out_8(&regs->alm_min_set, alarm->time.tm_min);
+        out_8(&regs->alm_hour_set, alarm->time.tm_hour);
+
+        out_8(&regs->alm_enable, alarm->enabled);
+
+        rtc->wkalarm = *alarm;
+        return 0;
+}
+
+static irqreturn_t mpc5121_rtc_handler(int irq, void *dev)
+{
+        struct mpc5121_rtc_data *rtc = dev_get_drvdata((struct device *)dev);
+        struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
+
+        if (in_8(&regs->int_alm)) {
+                /* acknowledge and clear status */
+                out_8(&regs->int_alm, 1);
+                out_8(&regs->alm_status, 1);
+
+                rtc_update_irq(rtc->rtc, 1, RTC_IRQF | RTC_AF);
+                return IRQ_HANDLED;
+        }
+
+        return IRQ_NONE;
+}
+
+static irqreturn_t mpc5121_rtc_handler_upd(int irq, void *dev)
+{
+        struct mpc5121_rtc_data *rtc = dev_get_drvdata((struct device *)dev);
+        struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
+
+        if (in_8(&regs->int_sec) && (in_8(&regs->int_enable) & 0x1)) {
+                /* acknowledge */
+                out_8(&regs->int_sec, 1);
+
+                rtc_update_irq(rtc->rtc, 1, RTC_IRQF | RTC_UF);
+                return IRQ_HANDLED;
+        }
+
+        return IRQ_NONE;
+}
+
+static int mpc5121_rtc_alarm_irq_enable(struct device *dev,
+                                        unsigned int enabled)
+{
+        struct mpc5121_rtc_data *rtc = dev_get_drvdata(dev);
+        struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
+        int val;
+
+        if (enabled)
+                val = 1;
+        else
+                val = 0;
+
+        out_8(&regs->alm_enable, val);
+        rtc->wkalarm.enabled = val;
+
+        return 0;
+}
+
+static int mpc5121_rtc_update_irq_enable(struct device *dev,
+                                         unsigned int enabled)
+{
+        struct mpc5121_rtc_data *rtc = dev_get_drvdata(dev);
+        struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
+        int val;
+
+        val = in_8(&regs->int_enable);
+
+        if (enabled)
+                val = (val & ~0x8) | 0x1;
+        else
+                val &= ~0x1;
+
+        out_8(&regs->int_enable, val);
+
+        return 0;
+}
+
+static const struct rtc_class_ops mpc5121_rtc_ops = {
+        .read_time = mpc5121_rtc_read_time,
+        .set_time = mpc5121_rtc_set_time,
+        .read_alarm = mpc5121_rtc_read_alarm,
+        .set_alarm = mpc5121_rtc_set_alarm,
+        .alarm_irq_enable = mpc5121_rtc_alarm_irq_enable,
+        .update_irq_enable = mpc5121_rtc_update_irq_enable,
+};
+
+static int __devinit mpc5121_rtc_probe(struct of_device *op,
+                                        const struct of_device_id *match)
+{
+        struct mpc5121_rtc_data *rtc;
+        int err = 0;
+        u32 ka;
+
+        rtc = kzalloc(sizeof(*rtc), GFP_KERNEL);
+        if (!rtc)
+                return -ENOMEM;
+
+        rtc->regs = of_iomap(op->node, 0);
+        if (!rtc->regs) {
+                dev_err(&op->dev, "%s: couldn't map io space\n", __func__);
+                err = -ENOSYS;
+                goto out_free;
+        }
+
+        device_init_wakeup(&op->dev, 1);
+
+        dev_set_drvdata(&op->dev, rtc);
+
+        rtc->irq = irq_of_parse_and_map(op->node, 1);
+        err = request_irq(rtc->irq, mpc5121_rtc_handler, IRQF_DISABLED,
+                                                "mpc5121-rtc", &op->dev);
+        if (err) {
+                dev_err(&op->dev, "%s: could not request irq: %i\n",
+                                                        __func__, rtc->irq);
+                goto out_dispose;
+        }
+
+        rtc->irq_periodic = irq_of_parse_and_map(op->node, 0);
+        err = request_irq(rtc->irq_periodic, mpc5121_rtc_handler_upd,
+                                IRQF_DISABLED, "mpc5121-rtc_upd", &op->dev);
+        if (err) {
+                dev_err(&op->dev, "%s: could not request irq: %i\n",
+                                                __func__, rtc->irq_periodic);
+                goto out_dispose2;
+        }
+
+        ka = in_be32(&rtc->regs->keep_alive);
+        if (ka & 0x02) {
+                dev_warn(&op->dev,
+                        "mpc5121-rtc: Battery or oscillator failure!\n");
+                out_be32(&rtc->regs->keep_alive, ka);
+        }
+
+        rtc->rtc = rtc_device_register("mpc5121-rtc", &op->dev,
+                                        &mpc5121_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc->rtc)) {
+                err = PTR_ERR(rtc->rtc);
+                goto out_free_irq;
+        }
+
+        return 0;
+
+out_free_irq:
+        free_irq(rtc->irq_periodic, &op->dev);
+out_dispose2:
+        irq_dispose_mapping(rtc->irq_periodic);
+        free_irq(rtc->irq, &op->dev);
+out_dispose:
+        irq_dispose_mapping(rtc->irq);
+        iounmap(rtc->regs);
+out_free:
+        kfree(rtc);
+
+        return err;
+}
+
+static int __devexit mpc5121_rtc_remove(struct of_device *op)
+{
+        struct mpc5121_rtc_data *rtc = dev_get_drvdata(&op->dev);
+        struct mpc5121_rtc_regs __iomem *regs = rtc->regs;
+
+        /* disable interrupt, so there are no nasty surprises */
+        out_8(&regs->alm_enable, 0);
+        out_8(&regs->int_enable, in_8(&regs->int_enable) & ~0x1);
+
+        rtc_device_unregister(rtc->rtc);
+        iounmap(rtc->regs);
+        free_irq(rtc->irq, &op->dev);
+        free_irq(rtc->irq_periodic, &op->dev);
+        irq_dispose_mapping(rtc->irq);
+        irq_dispose_mapping(rtc->irq_periodic);
+        dev_set_drvdata(&op->dev, NULL);
+        kfree(rtc);
+
+        return 0;
+}
+
+static struct of_device_id mpc5121_rtc_match[] __devinitdata = {
+        { .compatible = "fsl,mpc5121-rtc", },
+        {},
+};
+
+static struct of_platform_driver mpc5121_rtc_driver = {
+        .owner = THIS_MODULE,
+        .name = "mpc5121-rtc",
+        .match_table = mpc5121_rtc_match,
+        .probe = mpc5121_rtc_probe,
+        .remove = __devexit_p(mpc5121_rtc_remove),
+};
+
+static int __init mpc5121_rtc_init(void)
+{
+        return of_register_platform_driver(&mpc5121_rtc_driver);
+}
+module_init(mpc5121_rtc_init);
+
+static void __exit mpc5121_rtc_exit(void)
+{
+        of_unregister_platform_driver(&mpc5121_rtc_driver);
+}
+module_exit(mpc5121_rtc_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("John Rigby <jcrigby@gmail.com>");
diff --git a/drivers/serial/mpc52xx_uart.c b/drivers/serial/mpc52xx_uart.c
index 7ce9e9f567a3..3119fddaedb5 100644
--- a/drivers/serial/mpc52xx_uart.c
+++ b/drivers/serial/mpc52xx_uart.c
@@ -74,6 +74,7 @@
 #include <linux/io.h>
 #include <linux/of.h>
 #include <linux/of_platform.h>
+#include <linux/clk.h>
 
 #include <asm/mpc52xx.h>
 #include <asm/mpc52xx_psc.h>
@@ -113,6 +114,7 @@ static void mpc52xx_uart_of_enumerate(void);
 
 /* Forward declaration of the interruption handling routine */
 static irqreturn_t mpc52xx_uart_int(int irq, void *dev_id);
+static irqreturn_t mpc5xxx_uart_process_int(struct uart_port *port);
 
 
 /* Simple macro to test if a port is console or not. This one is taken
@@ -145,6 +147,11 @@ struct psc_ops {
         void            (*cw_disable_ints)(struct uart_port *port);
         void            (*cw_restore_ints)(struct uart_port *port);
         unsigned long   (*getuartclk)(void *p);
+        int             (*clock)(struct uart_port *port, int enable);
+        int             (*fifoc_init)(void);
+        void            (*fifoc_uninit)(void);
+        void            (*get_irq)(struct uart_port *, struct device_node *);
+        irqreturn_t     (*handle_irq)(struct uart_port *port);
 };
 
 #ifdef CONFIG_PPC_MPC52xx
@@ -256,6 +263,18 @@ static unsigned long mpc52xx_getuartclk(void *p)
         return mpc5xxx_get_bus_frequency(p) / 2;
 }
 
+static void mpc52xx_psc_get_irq(struct uart_port *port, struct device_node *np)
+{
+        port->irqflags = IRQF_DISABLED;
+        port->irq = irq_of_parse_and_map(np, 0);
+}
+
+/* 52xx specific interrupt handler. The caller holds the port lock */
+static irqreturn_t mpc52xx_psc_handle_irq(struct uart_port *port)
+{
+        return mpc5xxx_uart_process_int(port);
+}
+
 static struct psc_ops mpc52xx_psc_ops = {
         .fifo_init = mpc52xx_psc_fifo_init,
         .raw_rx_rdy = mpc52xx_psc_raw_rx_rdy,
@@ -273,14 +292,32 @@ static struct psc_ops mpc52xx_psc_ops = {
         .cw_disable_ints = mpc52xx_psc_cw_disable_ints,
         .cw_restore_ints = mpc52xx_psc_cw_restore_ints,
         .getuartclk = mpc52xx_getuartclk,
+        .get_irq = mpc52xx_psc_get_irq,
+        .handle_irq = mpc52xx_psc_handle_irq,
 };
 
 #endif /* CONFIG_MPC52xx */
 
 #ifdef CONFIG_PPC_MPC512x
 #define FIFO_512x(port) ((struct mpc512x_psc_fifo __iomem *)(PSC(port)+1))
+
+/* PSC FIFO Controller for mpc512x */
+struct psc_fifoc {
+        u32 fifoc_cmd;
+        u32 fifoc_int;
+        u32 fifoc_dma;
+        u32 fifoc_axe;
+        u32 fifoc_debug;
+};
+
+static struct psc_fifoc __iomem *psc_fifoc;
+static unsigned int psc_fifoc_irq;
+
 static void mpc512x_psc_fifo_init(struct uart_port *port)
 {
+        /* /32 prescaler */
+        out_be16(&PSC(port)->mpc52xx_psc_clock_select, 0xdd00);
+
         out_be32(&FIFO_512x(port)->txcmd, MPC512x_PSC_FIFO_RESET_SLICE);
         out_be32(&FIFO_512x(port)->txcmd, MPC512x_PSC_FIFO_ENABLE_SLICE);
         out_be32(&FIFO_512x(port)->txalarm, 1);
@@ -393,6 +430,160 @@ static unsigned long mpc512x_getuartclk(void *p)
         return mpc5xxx_get_bus_frequency(p);
 }
 
+#define DEFAULT_FIFO_SIZE 16
+
+static unsigned int __init get_fifo_size(struct device_node *np,
+                                         char *fifo_name)
+{
+        const unsigned int *fp;
+
+        fp = of_get_property(np, fifo_name, NULL);
+        if (fp)
+                return *fp;
+
+        pr_warning("no %s property in %s node, defaulting to %d\n",
+                   fifo_name, np->full_name, DEFAULT_FIFO_SIZE);
+
+        return DEFAULT_FIFO_SIZE;
+}
+
+#define FIFOC(_base) ((struct mpc512x_psc_fifo __iomem *) \
+                    ((u32)(_base) + sizeof(struct mpc52xx_psc)))
+
+/* Init PSC FIFO Controller */
+static int __init mpc512x_psc_fifoc_init(void)
+{
+        struct device_node *np;
+        void __iomem *psc;
+        unsigned int tx_fifo_size;
+        unsigned int rx_fifo_size;
+        int fifobase = 0; /* current fifo address in 32 bit words */
+
+        np = of_find_compatible_node(NULL, NULL,
+                                     "fsl,mpc5121-psc-fifo");
+        if (!np) {
+                pr_err("%s: Can't find FIFOC node\n", __func__);
+                return -ENODEV;
+        }
+
+        psc_fifoc = of_iomap(np, 0);
+        if (!psc_fifoc) {
+                pr_err("%s: Can't map FIFOC\n", __func__);
+                return -ENODEV;
+        }
+
+        psc_fifoc_irq = irq_of_parse_and_map(np, 0);
+        of_node_put(np);
+        if (psc_fifoc_irq == NO_IRQ) {
+                pr_err("%s: Can't get FIFOC irq\n", __func__);
+                iounmap(psc_fifoc);
+                return -ENODEV;
+        }
+
+        for_each_compatible_node(np, NULL, "fsl,mpc5121-psc-uart") {
+                tx_fifo_size = get_fifo_size(np, "fsl,tx-fifo-size");
+                rx_fifo_size = get_fifo_size(np, "fsl,rx-fifo-size");
+
+                /* size in register is in 4 byte units */
+                tx_fifo_size /= 4;
+                rx_fifo_size /= 4;
+                if (!tx_fifo_size)
+                        tx_fifo_size = 1;
+                if (!rx_fifo_size)
+                        rx_fifo_size = 1;
+
+                psc = of_iomap(np, 0);
+                if (!psc) {
+                        pr_err("%s: Can't map %s device\n",
+                                __func__, np->full_name);
+                        continue;
+                }
+
+                /* FIFO space is 4KiB, check if requested size is available */
+                if ((fifobase + tx_fifo_size + rx_fifo_size) > 0x1000) {
+                        pr_err("%s: no fifo space available for %s\n",
+                                __func__, np->full_name);
+                        iounmap(psc);
+                        /*
+                         * chances are that another device requests less
+                         * fifo space, so we continue.
+                         */
+                        continue;
+                }
+                /* set tx and rx fifo size registers */
+                out_be32(&FIFOC(psc)->txsz, (fifobase << 16) | tx_fifo_size);
+                fifobase += tx_fifo_size;
+                out_be32(&FIFOC(psc)->rxsz, (fifobase << 16) | rx_fifo_size);
+                fifobase += rx_fifo_size;
+
+                /* reset and enable the slices */
+                out_be32(&FIFOC(psc)->txcmd, 0x80);
+                out_be32(&FIFOC(psc)->txcmd, 0x01);
+                out_be32(&FIFOC(psc)->rxcmd, 0x80);
+                out_be32(&FIFOC(psc)->rxcmd, 0x01);
+
+                iounmap(psc);
+        }
+
+        return 0;
+}
+
+static void __exit mpc512x_psc_fifoc_uninit(void)
+{
+        iounmap(psc_fifoc);
+}
+
+/* 512x specific interrupt handler. The caller holds the port lock */
+static irqreturn_t mpc512x_psc_handle_irq(struct uart_port *port)
+{
+        unsigned long fifoc_int;
+        int psc_num;
+
+        /* Read pending PSC FIFOC interrupts */
+        fifoc_int = in_be32(&psc_fifoc->fifoc_int);
+
+        /* Check if it is an interrupt for this port */
+        psc_num = (port->mapbase & 0xf00) >> 8;
+        if (test_bit(psc_num, &fifoc_int) ||
+            test_bit(psc_num + 16, &fifoc_int))
+                return mpc5xxx_uart_process_int(port);
+
+        return IRQ_NONE;
+}
+
+static int mpc512x_psc_clock(struct uart_port *port, int enable)
+{
+        struct clk *psc_clk;
+        int psc_num;
+        char clk_name[10];
+
+        if (uart_console(port))
+                return 0;
+
+        psc_num = (port->mapbase & 0xf00) >> 8;
+        snprintf(clk_name, sizeof(clk_name), "psc%d_clk", psc_num);
+        psc_clk = clk_get(port->dev, clk_name);
+        if (IS_ERR(psc_clk)) {
+                dev_err(port->dev, "Failed to get PSC clock entry!\n");
+                return -ENODEV;
+        }
+
+        dev_dbg(port->dev, "%s %sable\n", clk_name, enable ? "en" : "dis");
+
+        if (enable)
+                clk_enable(psc_clk);
+        else
+                clk_disable(psc_clk);
+
+        return 0;
+}
+
+static void mpc512x_psc_get_irq(struct uart_port *port, struct device_node *np)
+{
+        port->irqflags = IRQF_SHARED;
+        port->irq = psc_fifoc_irq;
+}
+
 static struct psc_ops mpc512x_psc_ops = {
         .fifo_init = mpc512x_psc_fifo_init,
         .raw_rx_rdy = mpc512x_psc_raw_rx_rdy,
@@ -410,6 +601,11 @@ static struct psc_ops mpc512x_psc_ops = {
         .cw_disable_ints = mpc512x_psc_cw_disable_ints,
         .cw_restore_ints = mpc512x_psc_cw_restore_ints,
         .getuartclk = mpc512x_getuartclk,
+        .clock = mpc512x_psc_clock,
+        .fifoc_init = mpc512x_psc_fifoc_init,
+        .fifoc_uninit = mpc512x_psc_fifoc_uninit,
+        .get_irq = mpc512x_psc_get_irq,
+        .handle_irq = mpc512x_psc_handle_irq,
 };
 #endif
 
@@ -519,10 +715,15 @@ mpc52xx_uart_startup(struct uart_port *port)
         struct mpc52xx_psc __iomem *psc = PSC(port);
         int ret;
 
+        if (psc_ops->clock) {
+                ret = psc_ops->clock(port, 1);
+                if (ret)
+                        return ret;
+        }
+
         /* Request IRQ */
         ret = request_irq(port->irq, mpc52xx_uart_int,
-                IRQF_DISABLED | IRQF_SAMPLE_RANDOM,
-                "mpc52xx_psc_uart", port);
+                          port->irqflags, "mpc52xx_psc_uart", port);
         if (ret)
                 return ret;
 
@@ -553,6 +754,9 @@ mpc52xx_uart_shutdown(struct uart_port *port)
         port->read_status_mask = 0;
         out_be16(&psc->mpc52xx_psc_imr, port->read_status_mask);
 
+        if (psc_ops->clock)
+                psc_ops->clock(port, 0);
+
         /* Release interrupt */
         free_irq(port->irq, port);
 }
@@ -851,15 +1055,12 @@ mpc52xx_uart_int_tx_chars(struct uart_port *port)
 }
 
 static irqreturn_t
-mpc52xx_uart_int(int irq, void *dev_id)
+mpc5xxx_uart_process_int(struct uart_port *port)
 {
-        struct uart_port *port = dev_id;
         unsigned long pass = ISR_PASS_LIMIT;
         unsigned int keepgoing;
         u8 status;
 
-        spin_lock(&port->lock);
-
         /* While we have stuff to do, we continue */
         do {
                 /* If we don't find anything to do, we stop */
@@ -886,11 +1087,23 @@ mpc52xx_uart_int(int irq, void *dev_id)
 
         } while (keepgoing);
 
-        spin_unlock(&port->lock);
-
         return IRQ_HANDLED;
 }
 
+static irqreturn_t
+mpc52xx_uart_int(int irq, void *dev_id)
+{
+        struct uart_port *port = dev_id;
+        irqreturn_t ret;
+
+        spin_lock(&port->lock);
+
+        ret = psc_ops->handle_irq(port);
+
+        spin_unlock(&port->lock);
+
+        return ret;
+}
 
 /* ======================================================================== */
 /* Console ( if applicable )                                                */
@@ -1152,7 +1365,7 @@ mpc52xx_uart_of_probe(struct of_device *op, const struct of_device_id *match)
                 return -EINVAL;
         }
 
-        port->irq = irq_of_parse_and_map(op->node, 0);
+        psc_ops->get_irq(port, op->node);
         if (port->irq == NO_IRQ) {
                 dev_dbg(&op->dev, "Could not get irq\n");
                 return -EINVAL;
@@ -1163,10 +1376,8 @@ mpc52xx_uart_of_probe(struct of_device *op, const struct of_device_id *match)
 
         /* Add the port to the uart sub-system */
         ret = uart_add_one_port(&mpc52xx_uart_driver, port);
-        if (ret) {
-                irq_dispose_mapping(port->irq);
+        if (ret)
                 return ret;
-        }
 
         dev_set_drvdata(&op->dev, (void *)port);
         return 0;
@@ -1178,10 +1389,8 @@ mpc52xx_uart_of_remove(struct of_device *op)
         struct uart_port *port = dev_get_drvdata(&op->dev);
         dev_set_drvdata(&op->dev, NULL);
 
-        if (port) {
+        if (port)
                 uart_remove_one_port(&mpc52xx_uart_driver, port);
-                irq_dispose_mapping(port->irq);
-        }
 
         return 0;
 }
@@ -1288,6 +1497,15 @@ mpc52xx_uart_init(void)
 
         mpc52xx_uart_of_enumerate();
 
+        /*
+         * Map the PSC FIFO Controller and init if on MPC512x.
+         */
+        if (psc_ops->fifoc_init) {
+                ret = psc_ops->fifoc_init();
+                if (ret)
+                        return ret;
+        }
+
         ret = of_register_platform_driver(&mpc52xx_uart_of_driver);
         if (ret) {
                 printk(KERN_ERR "%s: of_register_platform_driver failed (%i)\n",
@@ -1302,6 +1520,9 @@ mpc52xx_uart_init(void)
 static void __exit
 mpc52xx_uart_exit(void)
 {
+        if (psc_ops->fifoc_uninit)
+                psc_ops->fifoc_uninit();
+
         of_unregister_platform_driver(&mpc52xx_uart_of_driver);
         uart_unregister_driver(&mpc52xx_uart_driver);
 }
diff --git a/drivers/video/fsl-diu-fb.c b/drivers/video/fsl-diu-fb.c
index 72d68b3dc478..4637bcbe03a4 100644
--- a/drivers/video/fsl-diu-fb.c
+++ b/drivers/video/fsl-diu-fb.c
@@ -1633,6 +1633,11 @@ static int __init fsl_diu_setup(char *options)
 #endif
 
 static struct of_device_id fsl_diu_match[] = {
+#ifdef CONFIG_PPC_MPC512x
+        {
+                .compatible = "fsl,mpc5121-diu",
+        },
+#endif
         {
                 .compatible = "fsl,diu",
         },