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: (72 commits)
  powerpc/pseries: Fix build of topology stuff without CONFIG_NUMA
  powerpc/pseries: Fix VPHN build errors on non-SMP systems
  powerpc/83xx: add mpc8308_p1m DMA controller device-tree node
  powerpc/83xx: add DMA controller to mpc8308 device-tree node
  powerpc/512x: try to free dma descriptors in case of allocation failure
  powerpc/512x: add MPC8308 dma support
  powerpc/512x: fix the hanged dma transfer issue
  powerpc/512x: scatter/gather dma fix
  powerpc/powermac: Make auto-loading of therm_pm72 possible
  of/address: Use propper endianess in get_flags
  powerpc/pci: Use printf extension %pR for struct resource
  powerpc: Remove unnecessary casts of void ptr
  powerpc: Disable VPHN polling during a suspend operation
  powerpc/pseries: Poll VPA for topology changes and update NUMA maps
  powerpc: iommu: Add device name to iommu error printks
  powerpc: Record vma->phys_addr in ioremap()
  powerpc: Update compat_arch_ptrace
  powerpc: Fix PPC_PTRACE_SETHWDEBUG on PPC_BOOK3S
  powerpc/time: printk time stamp init not correct
  powerpc: Minor cleanups for machdep.h
  ...

5 files changed, 419 insertions, 20 deletions

diff --git a/arch/powerpc/sysdev/Makefile b/arch/powerpc/sysdev/Makefile
index 0bef9dacb64e..9c2973479142 100644
--- a/arch/powerpc/sysdev/Makefile
+++ b/arch/powerpc/sysdev/Makefile
@@ -41,6 +41,7 @@ obj-$(CONFIG_OF_RTC)		+= of_rtc.o
 ifeq ($(CONFIG_PCI),y)
 obj-$(CONFIG_4xx)               += ppc4xx_pci.o
 endif
+obj-$(CONFIG_PPC4xx_CPM)        += ppc4xx_cpm.o
 obj-$(CONFIG_PPC4xx_GPIO)       += ppc4xx_gpio.o
 
 obj-$(CONFIG_CPM)               += cpm_common.o
diff --git a/arch/powerpc/sysdev/dart_iommu.c b/arch/powerpc/sysdev/dart_iommu.c
index 17cf15ec38be..8e9e06a7ca59 100644
--- a/arch/powerpc/sysdev/dart_iommu.c
+++ b/arch/powerpc/sysdev/dart_iommu.c
@@ -312,17 +312,10 @@ static void pci_dma_dev_setup_dart(struct pci_dev *dev)
 
 static void pci_dma_bus_setup_dart(struct pci_bus *bus)
 {
-        struct device_node *dn;
-
         if (!iommu_table_dart_inited) {
                 iommu_table_dart_inited = 1;
                 iommu_table_dart_setup();
         }
-
-        dn = pci_bus_to_OF_node(bus);
-
-        if (dn)
-                PCI_DN(dn)->iommu_table = &iommu_table_dart;
 }
 
 static bool dart_device_on_pcie(struct device *dev)
@@ -373,7 +366,7 @@ void __init iommu_init_early_dart(void)
         if (dn == NULL) {
                 dn = of_find_compatible_node(NULL, "dart", "u4-dart");
                 if (dn == NULL)
-                        goto bail;
+                        return; /* use default direct_dma_ops */
                 dart_is_u4 = 1;
         }
 
diff --git a/arch/powerpc/sysdev/mpc8xxx_gpio.c b/arch/powerpc/sysdev/mpc8xxx_gpio.c
index c0ea05e87f1d..c48cd8178079 100644
--- a/arch/powerpc/sysdev/mpc8xxx_gpio.c
+++ b/arch/powerpc/sysdev/mpc8xxx_gpio.c
@@ -1,5 +1,5 @@
 /*
- * GPIOs on MPC8349/8572/8610 and compatible
+ * GPIOs on MPC512x/8349/8572/8610 and compatible
  *
  * Copyright (C) 2008 Peter Korsgaard <jacmet@sunsite.dk>
  *
@@ -26,6 +26,7 @@
 #define GPIO_IER                0x0c
 #define GPIO_IMR                0x10
 #define GPIO_ICR                0x14
+#define GPIO_ICR2               0x18
 
 struct mpc8xxx_gpio_chip {
         struct of_mm_gpio_chip mm_gc;
@@ -37,6 +38,7 @@ struct mpc8xxx_gpio_chip {
          */
         u32 data;
         struct irq_host *irq;
+        void *of_dev_id_data;
 };
 
 static inline u32 mpc8xxx_gpio2mask(unsigned int gpio)
@@ -215,6 +217,51 @@ static int mpc8xxx_irq_set_type(unsigned int virq, unsigned int flow_type)
         return 0;
 }
 
+static int mpc512x_irq_set_type(unsigned int virq, unsigned int flow_type)
+{
+        struct mpc8xxx_gpio_chip *mpc8xxx_gc = get_irq_chip_data(virq);
+        struct of_mm_gpio_chip *mm = &mpc8xxx_gc->mm_gc;
+        unsigned long gpio = virq_to_hw(virq);
+        void __iomem *reg;
+        unsigned int shift;
+        unsigned long flags;
+
+        if (gpio < 16) {
+                reg = mm->regs + GPIO_ICR;
+                shift = (15 - gpio) * 2;
+        } else {
+                reg = mm->regs + GPIO_ICR2;
+                shift = (15 - (gpio % 16)) * 2;
+        }
+
+        switch (flow_type) {
+        case IRQ_TYPE_EDGE_FALLING:
+        case IRQ_TYPE_LEVEL_LOW:
+                spin_lock_irqsave(&mpc8xxx_gc->lock, flags);
+                clrsetbits_be32(reg, 3 << shift, 2 << shift);
+                spin_unlock_irqrestore(&mpc8xxx_gc->lock, flags);
+                break;
+
+        case IRQ_TYPE_EDGE_RISING:
+        case IRQ_TYPE_LEVEL_HIGH:
+                spin_lock_irqsave(&mpc8xxx_gc->lock, flags);
+                clrsetbits_be32(reg, 3 << shift, 1 << shift);
+                spin_unlock_irqrestore(&mpc8xxx_gc->lock, flags);
+                break;
+
+        case IRQ_TYPE_EDGE_BOTH:
+                spin_lock_irqsave(&mpc8xxx_gc->lock, flags);
+                clrbits32(reg, 3 << shift);
+                spin_unlock_irqrestore(&mpc8xxx_gc->lock, flags);
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
 static struct irq_chip mpc8xxx_irq_chip = {
         .name           = "mpc8xxx-gpio",
         .unmask         = mpc8xxx_irq_unmask,
@@ -226,6 +273,11 @@ static struct irq_chip mpc8xxx_irq_chip = {
 static int mpc8xxx_gpio_irq_map(struct irq_host *h, unsigned int virq,
                                 irq_hw_number_t hw)
 {
+        struct mpc8xxx_gpio_chip *mpc8xxx_gc = h->host_data;
+
+        if (mpc8xxx_gc->of_dev_id_data)
+                mpc8xxx_irq_chip.set_type = mpc8xxx_gc->of_dev_id_data;
+
         set_irq_chip_data(virq, h->host_data);
         set_irq_chip_and_handler(virq, &mpc8xxx_irq_chip, handle_level_irq);
         set_irq_type(virq, IRQ_TYPE_NONE);
@@ -253,11 +305,20 @@ static struct irq_host_ops mpc8xxx_gpio_irq_ops = {
         .xlate  = mpc8xxx_gpio_irq_xlate,
 };
 
+static struct of_device_id mpc8xxx_gpio_ids[] __initdata = {
+        { .compatible = "fsl,mpc8349-gpio", },
+        { .compatible = "fsl,mpc8572-gpio", },
+        { .compatible = "fsl,mpc8610-gpio", },
+        { .compatible = "fsl,mpc5121-gpio", .data = mpc512x_irq_set_type, },
+        {}
+};
+
 static void __init mpc8xxx_add_controller(struct device_node *np)
 {
         struct mpc8xxx_gpio_chip *mpc8xxx_gc;
         struct of_mm_gpio_chip *mm_gc;
         struct gpio_chip *gc;
+        const struct of_device_id *id;
         unsigned hwirq;
         int ret;
 
@@ -297,6 +358,10 @@ static void __init mpc8xxx_add_controller(struct device_node *np)
         if (!mpc8xxx_gc->irq)
                 goto skip_irq;
 
+        id = of_match_node(mpc8xxx_gpio_ids, np);
+        if (id)
+                mpc8xxx_gc->of_dev_id_data = id->data;
+
         mpc8xxx_gc->irq->host_data = mpc8xxx_gc;
 
         /* ack and mask all irqs */
@@ -321,13 +386,7 @@ static int __init mpc8xxx_add_gpiochips(void)
 {
         struct device_node *np;
 
-        for_each_compatible_node(np, NULL, "fsl,mpc8349-gpio")
-                mpc8xxx_add_controller(np);
-
-        for_each_compatible_node(np, NULL, "fsl,mpc8572-gpio")
-                mpc8xxx_add_controller(np);
-
-        for_each_compatible_node(np, NULL, "fsl,mpc8610-gpio")
+        for_each_matching_node(np, mpc8xxx_gpio_ids)
                 mpc8xxx_add_controller(np);
 
         for_each_compatible_node(np, NULL, "fsl,qoriq-gpio")
diff --git a/arch/powerpc/sysdev/ppc4xx_cpm.c b/arch/powerpc/sysdev/ppc4xx_cpm.c
new file mode 100644
index 000000000000..73b86cc5ea74
--- /dev/null
+++ b/arch/powerpc/sysdev/ppc4xx_cpm.c
@@ -0,0 +1,346 @@
+/*
+ * PowerPC 4xx Clock and Power Management
+ *
+ * Copyright (C) 2010, Applied Micro Circuits Corporation
+ * Victor Gallardo (vgallardo@apm.com)
+ *
+ * Based on arch/powerpc/platforms/44x/idle.c:
+ * Jerone Young <jyoung5@us.ibm.com>
+ * Copyright 2008 IBM Corp.
+ *
+ * Based on arch/powerpc/sysdev/fsl_pmc.c:
+ * Anton Vorontsov <avorontsov@ru.mvista.com>
+ * Copyright 2009  MontaVista Software, Inc.
+ *
+ * See file CREDITS for list of people who contributed to this
+ * project.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#include <linux/kernel.h>
+#include <linux/of_platform.h>
+#include <linux/sysfs.h>
+#include <linux/cpu.h>
+#include <linux/suspend.h>
+#include <asm/dcr.h>
+#include <asm/dcr-native.h>
+#include <asm/machdep.h>
+
+#define CPM_ER  0
+#define CPM_FR  1
+#define CPM_SR  2
+
+#define CPM_IDLE_WAIT   0
+#define CPM_IDLE_DOZE   1
+
+struct cpm {
+        dcr_host_t      dcr_host;
+        unsigned int    dcr_offset[3];
+        unsigned int    powersave_off;
+        unsigned int    unused;
+        unsigned int    idle_doze;
+        unsigned int    standby;
+        unsigned int    suspend;
+};
+
+static struct cpm cpm;
+
+struct cpm_idle_mode {
+        unsigned int enabled;
+        const char  *name;
+};
+
+static struct cpm_idle_mode idle_mode[] = {
+        [CPM_IDLE_WAIT] = { 1, "wait" }, /* default */
+        [CPM_IDLE_DOZE] = { 0, "doze" },
+};
+
+static unsigned int cpm_set(unsigned int cpm_reg, unsigned int mask)
+{
+        unsigned int value;
+
+        /* CPM controller supports 3 different types of sleep interface
+         * known as class 1, 2 and 3. For class 1 units, they are
+         * unconditionally put to sleep when the corresponding CPM bit is
+         * set. For class 2 and 3 units this is not case; if they can be
+         * put to to sleep, they will. Here we do not verify, we just
+         * set them and expect them to eventually go off when they can.
+         */
+        value = dcr_read(cpm.dcr_host, cpm.dcr_offset[cpm_reg]);
+        dcr_write(cpm.dcr_host, cpm.dcr_offset[cpm_reg], value | mask);
+
+        /* return old state, to restore later if needed */
+        return value;
+}
+
+static void cpm_idle_wait(void)
+{
+        unsigned long msr_save;
+
+        /* save off initial state */
+        msr_save = mfmsr();
+        /* sync required when CPM0_ER[CPU] is set */
+        mb();
+        /* set wait state MSR */
+        mtmsr(msr_save|MSR_WE|MSR_EE|MSR_CE|MSR_DE);
+        isync();
+        /* return to initial state */
+        mtmsr(msr_save);
+        isync();
+}
+
+static void cpm_idle_sleep(unsigned int mask)
+{
+        unsigned int er_save;
+
+        /* update CPM_ER state */
+        er_save = cpm_set(CPM_ER, mask);
+
+        /* go to wait state so that CPM0_ER[CPU] can take effect */
+        cpm_idle_wait();
+
+        /* restore CPM_ER state */
+        dcr_write(cpm.dcr_host, cpm.dcr_offset[CPM_ER], er_save);
+}
+
+static void cpm_idle_doze(void)
+{
+        cpm_idle_sleep(cpm.idle_doze);
+}
+
+static void cpm_idle_config(int mode)
+{
+        int i;
+
+        if (idle_mode[mode].enabled)
+                return;
+
+        for (i = 0; i < ARRAY_SIZE(idle_mode); i++)
+                idle_mode[i].enabled = 0;
+
+        idle_mode[mode].enabled = 1;
+}
+
+static ssize_t cpm_idle_show(struct kobject *kobj,
+                             struct kobj_attribute *attr, char *buf)
+{
+        char *s = buf;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(idle_mode); i++) {
+                if (idle_mode[i].enabled)
+                        s += sprintf(s, "[%s] ", idle_mode[i].name);
+                else
+                        s += sprintf(s, "%s ", idle_mode[i].name);
+        }
+
+        *(s-1) = '\n'; /* convert the last space to a newline */
+
+        return s - buf;
+}
+
+static ssize_t cpm_idle_store(struct kobject *kobj,
+                              struct kobj_attribute *attr,
+                              const char *buf, size_t n)
+{
+        int i;
+        char *p;
+        int len;
+
+        p = memchr(buf, '\n', n);
+        len = p ? p - buf : n;
+
+        for (i = 0; i < ARRAY_SIZE(idle_mode); i++) {
+                if (strncmp(buf, idle_mode[i].name, len) == 0) {
+                        cpm_idle_config(i);
+                        return n;
+                }
+        }
+
+        return -EINVAL;
+}
+
+static struct kobj_attribute cpm_idle_attr =
+        __ATTR(idle, 0644, cpm_idle_show, cpm_idle_store);
+
+static void cpm_idle_config_sysfs(void)
+{
+        struct sys_device *sys_dev;
+        unsigned long ret;
+
+        sys_dev = get_cpu_sysdev(0);
+
+        ret = sysfs_create_file(&sys_dev->kobj,
+                                &cpm_idle_attr.attr);
+        if (ret)
+                printk(KERN_WARNING
+                       "cpm: failed to create idle sysfs entry\n");
+}
+
+static void cpm_idle(void)
+{
+        if (idle_mode[CPM_IDLE_DOZE].enabled)
+                cpm_idle_doze();
+        else
+                cpm_idle_wait();
+}
+
+static int cpm_suspend_valid(suspend_state_t state)
+{
+        switch (state) {
+        case PM_SUSPEND_STANDBY:
+                return !!cpm.standby;
+        case PM_SUSPEND_MEM:
+                return !!cpm.suspend;
+        default:
+                return 0;
+        }
+}
+
+static void cpm_suspend_standby(unsigned int mask)
+{
+        unsigned long tcr_save;
+
+        /* disable decrement interrupt */
+        tcr_save = mfspr(SPRN_TCR);
+        mtspr(SPRN_TCR, tcr_save & ~TCR_DIE);
+
+        /* go to sleep state */
+        cpm_idle_sleep(mask);
+
+        /* restore decrement interrupt */
+        mtspr(SPRN_TCR, tcr_save);
+}
+
+static int cpm_suspend_enter(suspend_state_t state)
+{
+        switch (state) {
+        case PM_SUSPEND_STANDBY:
+                cpm_suspend_standby(cpm.standby);
+                break;
+        case PM_SUSPEND_MEM:
+                cpm_suspend_standby(cpm.suspend);
+                break;
+        }
+
+        return 0;
+}
+
+static struct platform_suspend_ops cpm_suspend_ops = {
+        .valid          = cpm_suspend_valid,
+        .enter          = cpm_suspend_enter,
+};
+
+static int cpm_get_uint_property(struct device_node *np,
+                                 const char *name)
+{
+        int len;
+        const unsigned int *prop = of_get_property(np, name, &len);
+
+        if (prop == NULL || len < sizeof(u32))
+                return 0;
+
+        return *prop;
+}
+
+static int __init cpm_init(void)
+{
+        struct device_node *np;
+        int dcr_base, dcr_len;
+        int ret = 0;
+
+        if (!cpm.powersave_off) {
+                cpm_idle_config(CPM_IDLE_WAIT);
+                ppc_md.power_save = &cpm_idle;
+        }
+
+        np = of_find_compatible_node(NULL, NULL, "ibm,cpm");
+        if (!np) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        dcr_base = dcr_resource_start(np, 0);
+        dcr_len = dcr_resource_len(np, 0);
+
+        if (dcr_base == 0 || dcr_len == 0) {
+                printk(KERN_ERR "cpm: could not parse dcr property for %s\n",
+                       np->full_name);
+                ret = -EINVAL;
+                goto out;
+        }
+
+        cpm.dcr_host = dcr_map(np, dcr_base, dcr_len);
+
+        if (!DCR_MAP_OK(cpm.dcr_host)) {
+                printk(KERN_ERR "cpm: failed to map dcr property for %s\n",
+                       np->full_name);
+                ret = -EINVAL;
+                goto out;
+        }
+
+        /* All 4xx SoCs with a CPM controller have one of two
+         * different order for the CPM registers. Some have the
+         * CPM registers in the following order (ER,FR,SR). The
+         * others have them in the following order (SR,ER,FR).
+         */
+
+        if (cpm_get_uint_property(np, "er-offset") == 0) {
+                cpm.dcr_offset[CPM_ER] = 0;
+                cpm.dcr_offset[CPM_FR] = 1;
+                cpm.dcr_offset[CPM_SR] = 2;
+        } else {
+                cpm.dcr_offset[CPM_ER] = 1;
+                cpm.dcr_offset[CPM_FR] = 2;
+                cpm.dcr_offset[CPM_SR] = 0;
+        }
+
+        /* Now let's see what IPs to turn off for the following modes */
+
+        cpm.unused = cpm_get_uint_property(np, "unused-units");
+        cpm.idle_doze = cpm_get_uint_property(np, "idle-doze");
+        cpm.standby = cpm_get_uint_property(np, "standby");
+        cpm.suspend = cpm_get_uint_property(np, "suspend");
+
+        /* If some IPs are unused let's turn them off now */
+
+        if (cpm.unused) {
+                cpm_set(CPM_ER, cpm.unused);
+                cpm_set(CPM_FR, cpm.unused);
+        }
+
+        /* Now let's export interfaces */
+
+        if (!cpm.powersave_off && cpm.idle_doze)
+                cpm_idle_config_sysfs();
+
+        if (cpm.standby || cpm.suspend)
+                suspend_set_ops(&cpm_suspend_ops);
+out:
+        if (np)
+                of_node_put(np);
+        return ret;
+}
+
+late_initcall(cpm_init);
+
+static int __init cpm_powersave_off(char *arg)
+{
+        cpm.powersave_off = 1;
+        return 0;
+}
+__setup("powersave=off", cpm_powersave_off);
diff --git a/arch/powerpc/sysdev/tsi108_dev.c b/arch/powerpc/sysdev/tsi108_dev.c
index c2d675b6392c..ee056807b52c 100644
--- a/arch/powerpc/sysdev/tsi108_dev.c
+++ b/arch/powerpc/sysdev/tsi108_dev.c
@@ -84,8 +84,8 @@ static int __init tsi108_eth_of_init(void)
                 memset(&tsi_eth_data, 0, sizeof(tsi_eth_data));
 
                 ret = of_address_to_resource(np, 0, &r[0]);
-                DBG("%s: name:start->end = %s:0x%lx-> 0x%lx\n",
-                        __func__,r[0].name, r[0].start, r[0].end);
+                DBG("%s: name:start->end = %s:%pR\n",
+                    __func__, r[0].name, &r[0]);
                 if (ret)
                         goto err;
 
@@ -93,8 +93,8 @@ static int __init tsi108_eth_of_init(void)
                 r[1].start = irq_of_parse_and_map(np, 0);
                 r[1].end = irq_of_parse_and_map(np, 0);
                 r[1].flags = IORESOURCE_IRQ;
-                DBG("%s: name:start->end = %s:0x%lx-> 0x%lx\n",
-                        __func__,r[1].name, r[1].start, r[1].end);
+                DBG("%s: name:start->end = %s:%pR\n",
+                        __func__, r[1].name, &r[1]);
 
                 tsi_eth_dev =
                     platform_device_register_simple("tsi-ethernet", i++, &r[0],