9 files changed, 468 insertions, 56 deletions

diff --git a/drivers/tty/Kconfig b/drivers/tty/Kconfig
index 8816f53e004d..b3d17416d86a 100644
--- a/drivers/tty/Kconfig
+++ b/drivers/tty/Kconfig
@@ -1,6 +1,6 @@
 config VT
         bool "Virtual terminal" if EXPERT
-        depends on !S390
+        depends on !S390 && !UML
         select INPUT
         default y
         ---help---
diff --git a/drivers/tty/hvc/Kconfig b/drivers/tty/hvc/Kconfig
index e371753ba921..4222035acfb7 100644
--- a/drivers/tty/hvc/Kconfig
+++ b/drivers/tty/hvc/Kconfig
@@ -34,6 +34,15 @@ config HVC_ISERIES
         help
           iSeries machines support a hypervisor virtual console.
 
+config HVC_OPAL
+        bool "OPAL Console support"
+        depends on PPC_POWERNV
+        select HVC_DRIVER
+        select HVC_IRQ
+        default y
+        help
+          PowerNV machines running under OPAL need that driver to get a console
+
 config HVC_RTAS
         bool "IBM RTAS Console support"
         depends on PPC_RTAS
diff --git a/drivers/tty/hvc/Makefile b/drivers/tty/hvc/Makefile
index e29205316376..89abf40bc73d 100644
--- a/drivers/tty/hvc/Makefile
+++ b/drivers/tty/hvc/Makefile
@@ -1,4 +1,5 @@
 obj-$(CONFIG_HVC_CONSOLE)       += hvc_vio.o hvsi_lib.o
+obj-$(CONFIG_HVC_OPAL)          += hvc_opal.o hvsi_lib.o
 obj-$(CONFIG_HVC_OLD_HVSI)      += hvsi.o
 obj-$(CONFIG_HVC_ISERIES)       += hvc_iseries.o
 obj-$(CONFIG_HVC_RTAS)          += hvc_rtas.o
diff --git a/drivers/tty/hvc/hvc_opal.c b/drivers/tty/hvc/hvc_opal.c
new file mode 100644
index 000000000000..7b38512d6c41
--- /dev/null
+++ b/drivers/tty/hvc/hvc_opal.c
@@ -0,0 +1,424 @@
+/*
+ * opal driver interface to hvc_console.c
+ *
+ * Copyright 2011 Benjamin Herrenschmidt <benh@kernel.crashing.org>, IBM Corp.
+ *
+ * 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
+ *
+ */
+
+#undef DEBUG
+
+#include <linux/types.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/console.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
+
+#include <asm/hvconsole.h>
+#include <asm/prom.h>
+#include <asm/firmware.h>
+#include <asm/hvsi.h>
+#include <asm/udbg.h>
+#include <asm/opal.h>
+
+#include "hvc_console.h"
+
+static const char hvc_opal_name[] = "hvc_opal";
+
+static struct of_device_id hvc_opal_match[] __devinitdata = {
+        { .name = "serial", .compatible = "ibm,opal-console-raw" },
+        { .name = "serial", .compatible = "ibm,opal-console-hvsi" },
+        { },
+};
+
+typedef enum hv_protocol {
+        HV_PROTOCOL_RAW,
+        HV_PROTOCOL_HVSI
+} hv_protocol_t;
+
+struct hvc_opal_priv {
+        hv_protocol_t           proto;  /* Raw data or HVSI packets */
+        struct hvsi_priv        hvsi;   /* HVSI specific data */
+};
+static struct hvc_opal_priv *hvc_opal_privs[MAX_NR_HVC_CONSOLES];
+
+/* For early boot console */
+static struct hvc_opal_priv hvc_opal_boot_priv;
+static u32 hvc_opal_boot_termno;
+
+static const struct hv_ops hvc_opal_raw_ops = {
+        .get_chars = opal_get_chars,
+        .put_chars = opal_put_chars,
+        .notifier_add = notifier_add_irq,
+        .notifier_del = notifier_del_irq,
+        .notifier_hangup = notifier_hangup_irq,
+};
+
+static int hvc_opal_hvsi_get_chars(uint32_t vtermno, char *buf, int count)
+{
+        struct hvc_opal_priv *pv = hvc_opal_privs[vtermno];
+
+        if (WARN_ON(!pv))
+                return -ENODEV;
+
+        return hvsilib_get_chars(&pv->hvsi, buf, count);
+}
+
+static int hvc_opal_hvsi_put_chars(uint32_t vtermno, const char *buf, int count)
+{
+        struct hvc_opal_priv *pv = hvc_opal_privs[vtermno];
+
+        if (WARN_ON(!pv))
+                return -ENODEV;
+
+        return hvsilib_put_chars(&pv->hvsi, buf, count);
+}
+
+static int hvc_opal_hvsi_open(struct hvc_struct *hp, int data)
+{
+        struct hvc_opal_priv *pv = hvc_opal_privs[hp->vtermno];
+        int rc;
+
+        pr_devel("HVSI@%x: do open !\n", hp->vtermno);
+
+        rc = notifier_add_irq(hp, data);
+        if (rc)
+                return rc;
+
+        return hvsilib_open(&pv->hvsi, hp);
+}
+
+static void hvc_opal_hvsi_close(struct hvc_struct *hp, int data)
+{
+        struct hvc_opal_priv *pv = hvc_opal_privs[hp->vtermno];
+
+        pr_devel("HVSI@%x: do close !\n", hp->vtermno);
+
+        hvsilib_close(&pv->hvsi, hp);
+
+        notifier_del_irq(hp, data);
+}
+
+void hvc_opal_hvsi_hangup(struct hvc_struct *hp, int data)
+{
+        struct hvc_opal_priv *pv = hvc_opal_privs[hp->vtermno];
+
+        pr_devel("HVSI@%x: do hangup !\n", hp->vtermno);
+
+        hvsilib_close(&pv->hvsi, hp);
+
+        notifier_hangup_irq(hp, data);
+}
+
+static int hvc_opal_hvsi_tiocmget(struct hvc_struct *hp)
+{
+        struct hvc_opal_priv *pv = hvc_opal_privs[hp->vtermno];
+
+        if (!pv)
+                return -EINVAL;
+        return pv->hvsi.mctrl;
+}
+
+static int hvc_opal_hvsi_tiocmset(struct hvc_struct *hp, unsigned int set,
+                                unsigned int clear)
+{
+        struct hvc_opal_priv *pv = hvc_opal_privs[hp->vtermno];
+
+        pr_devel("HVSI@%x: Set modem control, set=%x,clr=%x\n",
+                 hp->vtermno, set, clear);
+
+        if (set & TIOCM_DTR)
+                hvsilib_write_mctrl(&pv->hvsi, 1);
+        else if (clear & TIOCM_DTR)
+                hvsilib_write_mctrl(&pv->hvsi, 0);
+
+        return 0;
+}
+
+static const struct hv_ops hvc_opal_hvsi_ops = {
+        .get_chars = hvc_opal_hvsi_get_chars,
+        .put_chars = hvc_opal_hvsi_put_chars,
+        .notifier_add = hvc_opal_hvsi_open,
+        .notifier_del = hvc_opal_hvsi_close,
+        .notifier_hangup = hvc_opal_hvsi_hangup,
+        .tiocmget = hvc_opal_hvsi_tiocmget,
+        .tiocmset = hvc_opal_hvsi_tiocmset,
+};
+
+static int __devinit hvc_opal_probe(struct platform_device *dev)
+{
+        const struct hv_ops *ops;
+        struct hvc_struct *hp;
+        struct hvc_opal_priv *pv;
+        hv_protocol_t proto;
+        unsigned int termno, boot = 0;
+        const __be32 *reg;
+
+        if (of_device_is_compatible(dev->dev.of_node, "ibm,opal-console-raw")) {
+                proto = HV_PROTOCOL_RAW;
+                ops = &hvc_opal_raw_ops;
+        } else if (of_device_is_compatible(dev->dev.of_node,
+                                           "ibm,opal-console-hvsi")) {
+                proto = HV_PROTOCOL_HVSI;
+                ops = &hvc_opal_hvsi_ops;
+        } else {
+                pr_err("hvc_opal: Unkown protocol for %s\n",
+                       dev->dev.of_node->full_name);
+                return -ENXIO;
+        }
+
+        reg = of_get_property(dev->dev.of_node, "reg", NULL);
+        termno = reg ? be32_to_cpup(reg) : 0;
+
+        /* Is it our boot one ? */
+        if (hvc_opal_privs[termno] == &hvc_opal_boot_priv) {
+                pv = hvc_opal_privs[termno];
+                boot = 1;
+        } else if (hvc_opal_privs[termno] == NULL) {
+                pv = kzalloc(sizeof(struct hvc_opal_priv), GFP_KERNEL);
+                if (!pv)
+                        return -ENOMEM;
+                pv->proto = proto;
+                hvc_opal_privs[termno] = pv;
+                if (proto == HV_PROTOCOL_HVSI)
+                        hvsilib_init(&pv->hvsi, opal_get_chars, opal_put_chars,
+                                     termno, 0);
+
+                /* Instanciate now to establish a mapping index==vtermno */
+                hvc_instantiate(termno, termno, ops);
+        } else {
+                pr_err("hvc_opal: Device %s has duplicate terminal number #%d\n",
+                       dev->dev.of_node->full_name, termno);
+                return -ENXIO;
+        }
+
+        pr_info("hvc%d: %s protocol on %s%s\n", termno,
+                proto == HV_PROTOCOL_RAW ? "raw" : "hvsi",
+                dev->dev.of_node->full_name,
+                boot ? " (boot console)" : "");
+
+        /* We don't do IRQ yet */
+        hp = hvc_alloc(termno, 0, ops, MAX_VIO_PUT_CHARS);
+        if (IS_ERR(hp))
+                return PTR_ERR(hp);
+        dev_set_drvdata(&dev->dev, hp);
+
+        return 0;
+}
+
+static int __devexit hvc_opal_remove(struct platform_device *dev)
+{
+        struct hvc_struct *hp = dev_get_drvdata(&dev->dev);
+        int rc, termno;
+
+        termno = hp->vtermno;
+        rc = hvc_remove(hp);
+        if (rc == 0) {
+                if (hvc_opal_privs[termno] != &hvc_opal_boot_priv)
+                        kfree(hvc_opal_privs[termno]);
+                hvc_opal_privs[termno] = NULL;
+        }
+        return rc;
+}
+
+static struct platform_driver hvc_opal_driver = {
+        .probe          = hvc_opal_probe,
+        .remove         = __devexit_p(hvc_opal_remove),
+        .driver         = {
+                .name   = hvc_opal_name,
+                .owner  = THIS_MODULE,
+                .of_match_table = hvc_opal_match,
+        }
+};
+
+static int __init hvc_opal_init(void)
+{
+        if (!firmware_has_feature(FW_FEATURE_OPAL))
+                return -ENODEV;
+
+        /* Register as a vio device to receive callbacks */
+        return platform_driver_register(&hvc_opal_driver);
+}
+module_init(hvc_opal_init);
+
+static void __exit hvc_opal_exit(void)
+{
+        platform_driver_unregister(&hvc_opal_driver);
+}
+module_exit(hvc_opal_exit);
+
+static void udbg_opal_putc(char c)
+{
+        unsigned int termno = hvc_opal_boot_termno;
+        int count = -1;
+
+        if (c == '\n')
+                udbg_opal_putc('\r');
+
+        do {
+                switch(hvc_opal_boot_priv.proto) {
+                case HV_PROTOCOL_RAW:
+                        count = opal_put_chars(termno, &c, 1);
+                        break;
+                case HV_PROTOCOL_HVSI:
+                        count = hvc_opal_hvsi_put_chars(termno, &c, 1);
+                        break;
+                }
+        } while(count == 0 || count == -EAGAIN);
+}
+
+static int udbg_opal_getc_poll(void)
+{
+        unsigned int termno = hvc_opal_boot_termno;
+        int rc = 0;
+        char c;
+
+        switch(hvc_opal_boot_priv.proto) {
+        case HV_PROTOCOL_RAW:
+                rc = opal_get_chars(termno, &c, 1);
+                break;
+        case HV_PROTOCOL_HVSI:
+                rc = hvc_opal_hvsi_get_chars(termno, &c, 1);
+                break;
+        }
+        if (!rc)
+                return -1;
+        return c;
+}
+
+static int udbg_opal_getc(void)
+{
+        int ch;
+        for (;;) {
+                ch = udbg_opal_getc_poll();
+                if (ch == -1) {
+                        /* This shouldn't be needed...but... */
+                        volatile unsigned long delay;
+                        for (delay=0; delay < 2000000; delay++)
+                                ;
+                } else {
+                        return ch;
+                }
+        }
+}
+
+static void udbg_init_opal_common(void)
+{
+        udbg_putc = udbg_opal_putc;
+        udbg_getc = udbg_opal_getc;
+        udbg_getc_poll = udbg_opal_getc_poll;
+        tb_ticks_per_usec = 0x200; /* Make udelay not suck */
+}
+
+void __init hvc_opal_init_early(void)
+{
+        struct device_node *stdout_node = NULL;
+        const u32 *termno;
+        const char *name = NULL;
+        const struct hv_ops *ops;
+        u32 index;
+
+        /* find the boot console from /chosen/stdout */
+        if (of_chosen)
+                name = of_get_property(of_chosen, "linux,stdout-path", NULL);
+        if (name) {
+                stdout_node = of_find_node_by_path(name);
+                if (!stdout_node) {
+                        pr_err("hvc_opal: Failed to locate default console!\n");
+                        return;
+                }
+        } else {
+                struct device_node *opal, *np;
+
+                /* Current OPAL takeover doesn't provide the stdout
+                 * path, so we hard wire it
+                 */
+                opal = of_find_node_by_path("/ibm,opal/consoles");
+                if (opal)
+                        pr_devel("hvc_opal: Found consoles in new location\n");
+                if (!opal) {
+                        opal = of_find_node_by_path("/ibm,opal");
+                        if (opal)
+                                pr_devel("hvc_opal: "
+                                         "Found consoles in old location\n");
+                }
+                if (!opal)
+                        return;
+                for_each_child_of_node(opal, np) {
+                        if (!strcmp(np->name, "serial")) {
+                                stdout_node = np;
+                                break;
+                        }
+                }
+                of_node_put(opal);
+        }
+        if (!stdout_node)
+                return;
+        termno = of_get_property(stdout_node, "reg", NULL);
+        index = termno ? *termno : 0;
+        if (index >= MAX_NR_HVC_CONSOLES)
+                return;
+        hvc_opal_privs[index] = &hvc_opal_boot_priv;
+
+        /* Check the protocol */
+        if (of_device_is_compatible(stdout_node, "ibm,opal-console-raw")) {
+                hvc_opal_boot_priv.proto = HV_PROTOCOL_RAW;
+                ops = &hvc_opal_raw_ops;
+                pr_devel("hvc_opal: Found RAW console\n");
+        }
+        else if (of_device_is_compatible(stdout_node,"ibm,opal-console-hvsi")) {
+                hvc_opal_boot_priv.proto = HV_PROTOCOL_HVSI;
+                ops = &hvc_opal_hvsi_ops;
+                hvsilib_init(&hvc_opal_boot_priv.hvsi, opal_get_chars,
+                             opal_put_chars, index, 1);
+                /* HVSI, perform the handshake now */
+                hvsilib_establish(&hvc_opal_boot_priv.hvsi);
+                pr_devel("hvc_opal: Found HVSI console\n");
+        } else
+                goto out;
+        hvc_opal_boot_termno = index;
+        udbg_init_opal_common();
+        add_preferred_console("hvc", index, NULL);
+        hvc_instantiate(index, index, ops);
+out:
+        of_node_put(stdout_node);
+}
+
+#ifdef CONFIG_PPC_EARLY_DEBUG_OPAL_RAW
+void __init udbg_init_debug_opal(void)
+{
+        u32 index = CONFIG_PPC_EARLY_DEBUG_OPAL_VTERMNO;
+        hvc_opal_privs[index] = &hvc_opal_boot_priv;
+        hvc_opal_boot_priv.proto = HV_PROTOCOL_RAW;
+        hvc_opal_boot_termno = index;
+        udbg_init_opal_common();
+}
+#endif /* CONFIG_PPC_EARLY_DEBUG_OPAL_RAW */
+
+#ifdef CONFIG_PPC_EARLY_DEBUG_OPAL_HVSI
+void __init udbg_init_debug_opal_hvsi(void)
+{
+        u32 index = CONFIG_PPC_EARLY_DEBUG_OPAL_VTERMNO;
+        hvc_opal_privs[index] = &hvc_opal_boot_priv;
+        hvc_opal_boot_termno = index;
+        udbg_init_opal_common();
+        hvsilib_init(&hvc_opal_boot_priv.hvsi, opal_get_chars, opal_put_chars,
+                     index, 1);
+        hvsilib_establish(&hvc_opal_boot_priv.hvsi);
+}
+#endif /* CONFIG_PPC_EARLY_DEBUG_OPAL_HVSI */
diff --git a/drivers/tty/hvc/hvcs.c b/drivers/tty/hvc/hvcs.c
index 55882b5930a6..b9040bec36bd 100644
--- a/drivers/tty/hvc/hvcs.c
+++ b/drivers/tty/hvc/hvcs.c
@@ -1532,7 +1532,7 @@ static int __devinit hvcs_initialize(void)
                 goto register_fail;
         }
 
-        hvcs_pi_buff = kmalloc(PAGE_SIZE, GFP_KERNEL);
+        hvcs_pi_buff = (unsigned long *) __get_free_page(GFP_KERNEL);
         if (!hvcs_pi_buff) {
                 rc = -ENOMEM;
                 goto buff_alloc_fail;
@@ -1548,7 +1548,7 @@ static int __devinit hvcs_initialize(void)
         return 0;
 
 kthread_fail:
-        kfree(hvcs_pi_buff);
+        free_page((unsigned long)hvcs_pi_buff);
 buff_alloc_fail:
         tty_unregister_driver(hvcs_tty_driver);
 register_fail:
@@ -1597,7 +1597,7 @@ static void __exit hvcs_module_exit(void)
         kthread_stop(hvcs_task);
 
         spin_lock(&hvcs_pi_lock);
-        kfree(hvcs_pi_buff);
+        free_page((unsigned long)hvcs_pi_buff);
         hvcs_pi_buff = NULL;
         spin_unlock(&hvcs_pi_lock);
 
diff --git a/drivers/tty/hvc/hvsi_lib.c b/drivers/tty/hvc/hvsi_lib.c
index bd9b09827b24..6f4dd83d8695 100644
--- a/drivers/tty/hvc/hvsi_lib.c
+++ b/drivers/tty/hvc/hvsi_lib.c
@@ -183,7 +183,7 @@ int hvsilib_get_chars(struct hvsi_priv *pv, char *buf, int count)
         unsigned int tries, read = 0;
 
         if (WARN_ON(!pv))
-                return 0;
+                return -ENXIO;
 
         /* If we aren't open, don't do anything in order to avoid races
          * with connection establishment. The hvc core will call this
@@ -234,7 +234,7 @@ int hvsilib_put_chars(struct hvsi_priv *pv, const char *buf, int count)
         int rc, adjcount = min(count, HVSI_MAX_OUTGOING_DATA);
 
         if (WARN_ON(!pv))
-                return 0;
+                return -ENODEV;
 
         dp.hdr.type = VS_DATA_PACKET_HEADER;
         dp.hdr.len = adjcount + sizeof(struct hvsi_header);
diff --git a/drivers/tty/serial/8250.c b/drivers/tty/serial/8250.c
index a87a56cb5417..eeadf1b8e093 100644
--- a/drivers/tty/serial/8250.c
+++ b/drivers/tty/serial/8250.c
@@ -450,24 +450,6 @@ static void au_serial_out(struct uart_port *p, int offset, int value)
         __raw_writel(value, p->membase + offset);
 }
 
-static unsigned int tsi_serial_in(struct uart_port *p, int offset)
-{
-        unsigned int tmp;
-        offset = map_8250_in_reg(p, offset) << p->regshift;
-        if (offset == UART_IIR) {
-                tmp = readl(p->membase + (UART_IIR & ~3));
-                return (tmp >> 16) & 0xff; /* UART_IIR % 4 == 2 */
-        } else
-                return readb(p->membase + offset);
-}
-
-static void tsi_serial_out(struct uart_port *p, int offset, int value)
-{
-        offset = map_8250_out_reg(p, offset) << p->regshift;
-        if (!((offset == UART_IER) && (value & UART_IER_UUE)))
-                writeb(value, p->membase + offset);
-}
-
 static unsigned int io_serial_in(struct uart_port *p, int offset)
 {
         offset = map_8250_in_reg(p, offset) << p->regshift;
@@ -508,11 +490,6 @@ static void set_io_from_upio(struct uart_port *p)
                 p->serial_out = au_serial_out;
                 break;
 
-        case UPIO_TSI:
-                p->serial_in = tsi_serial_in;
-                p->serial_out = tsi_serial_out;
-                break;
-
         default:
                 p->serial_in = io_serial_in;
                 p->serial_out = io_serial_out;
diff --git a/drivers/tty/serial/msm_serial.c b/drivers/tty/serial/msm_serial.c
index 29cbfd8c4e7c..8131e2c28015 100644
--- a/drivers/tty/serial/msm_serial.c
+++ b/drivers/tty/serial/msm_serial.c
@@ -19,6 +19,7 @@
 # define SUPPORT_SYSRQ
 #endif
 
+#include <linux/atomic.h>
 #include <linux/hrtimer.h>
 #include <linux/module.h>
 #include <linux/io.h>
@@ -33,6 +34,8 @@
 #include <linux/clk.h>
 #include <linux/platform_device.h>
 #include <linux/delay.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
 
 #include "msm_serial.h"
 
@@ -589,9 +592,8 @@ static void msm_release_port(struct uart_port *port)
                 iowrite32(GSBI_PROTOCOL_IDLE, msm_port->gsbi_base +
                           GSBI_CONTROL);
 
-                gsbi_resource = platform_get_resource_byname(pdev,
-                                                             IORESOURCE_MEM,
-                                                             "gsbi_resource");
+                gsbi_resource = platform_get_resource(pdev,
+                                                        IORESOURCE_MEM, 1);
 
                 if (unlikely(!gsbi_resource))
                         return;
@@ -612,8 +614,7 @@ static int msm_request_port(struct uart_port *port)
         resource_size_t size;
         int ret;
 
-        uart_resource = platform_get_resource_byname(pdev, IORESOURCE_MEM,
-                                                     "uart_resource");
+        uart_resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (unlikely(!uart_resource))
                 return -ENXIO;
 
@@ -628,8 +629,7 @@ static int msm_request_port(struct uart_port *port)
                 goto fail_release_port;
         }
 
-        gsbi_resource = platform_get_resource_byname(pdev, IORESOURCE_MEM,
-                                                     "gsbi_resource");
+        gsbi_resource = platform_get_resource(pdev, IORESOURCE_MEM, 1);
         /* Is this a GSBI-based port? */
         if (gsbi_resource) {
                 size = resource_size(gsbi_resource);
@@ -857,6 +857,8 @@ static struct uart_driver msm_uart_driver = {
         .cons = MSM_CONSOLE,
 };
 
+static atomic_t msm_uart_next_id = ATOMIC_INIT(0);
+
 static int __init msm_serial_probe(struct platform_device *pdev)
 {
         struct msm_port *msm_port;
@@ -864,6 +866,9 @@ static int __init msm_serial_probe(struct platform_device *pdev)
         struct uart_port *port;
         int irq;
 
+        if (pdev->id == -1)
+                pdev->id = atomic_inc_return(&msm_uart_next_id) - 1;
+
         if (unlikely(pdev->id < 0 || pdev->id >= UART_NR))
                 return -ENXIO;
 
@@ -873,7 +878,7 @@ static int __init msm_serial_probe(struct platform_device *pdev)
         port->dev = &pdev->dev;
         msm_port = UART_TO_MSM(port);
 
-        if (platform_get_resource_byname(pdev, IORESOURCE_MEM, "gsbi_resource"))
+        if (platform_get_resource(pdev, IORESOURCE_MEM, 1))
                 msm_port->is_uartdm = 1;
         else
                 msm_port->is_uartdm = 0;
@@ -897,8 +902,7 @@ static int __init msm_serial_probe(struct platform_device *pdev)
         printk(KERN_INFO "uartclk = %d\n", port->uartclk);
 
 
-        resource = platform_get_resource_byname(pdev, IORESOURCE_MEM,
-                                                     "uart_resource");
+        resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (unlikely(!resource))
                 return -ENXIO;
         port->mapbase = resource->start;
@@ -922,11 +926,17 @@ static int __devexit msm_serial_remove(struct platform_device *pdev)
         return 0;
 }
 
+static struct of_device_id msm_match_table[] = {
+        { .compatible = "qcom,msm-uart" },
+        {}
+};
+
 static struct platform_driver msm_platform_driver = {
         .remove = msm_serial_remove,
         .driver = {
                 .name = "msm_serial",
                 .owner = THIS_MODULE,
+                .of_match_table = msm_match_table,
         },
 };
 
diff --git a/drivers/tty/serial/sh-sci.c b/drivers/tty/serial/sh-sci.c
index 9871c57b348e..1945c70539c2 100644
--- a/drivers/tty/serial/sh-sci.c
+++ b/drivers/tty/serial/sh-sci.c
@@ -1446,12 +1446,8 @@ static bool filter(struct dma_chan *chan, void *slave)
         dev_dbg(chan->device->dev, "%s: slave ID %d\n", __func__,
                 param->slave_id);
 
-        if (param->dma_dev == chan->device->dev) {
-                chan->private = param;
-                return true;
-        } else {
-                return false;
-        }
+        chan->private = param;
+        return true;
 }
 
 static void rx_timer_fn(unsigned long arg)
@@ -1477,10 +1473,10 @@ static void sci_request_dma(struct uart_port *port)
         dma_cap_mask_t mask;
         int nent;
 
-        dev_dbg(port->dev, "%s: port %d DMA %p\n", __func__,
-                port->line, s->cfg->dma_dev);
+        dev_dbg(port->dev, "%s: port %d\n", __func__,
+                port->line);
 
-        if (!s->cfg->dma_dev)
+        if (s->cfg->dma_slave_tx <= 0 || s->cfg->dma_slave_rx <= 0)
                 return;
 
         dma_cap_zero(mask);
@@ -1490,7 +1486,6 @@ static void sci_request_dma(struct uart_port *port)
 
         /* Slave ID, e.g., SHDMA_SLAVE_SCIF0_TX */
         param->slave_id = s->cfg->dma_slave_tx;
-        param->dma_dev = s->cfg->dma_dev;
 
         s->cookie_tx = -EINVAL;
         chan = dma_request_channel(mask, filter, param);
@@ -1519,7 +1514,6 @@ static void sci_request_dma(struct uart_port *port)
 
         /* Slave ID, e.g., SHDMA_SLAVE_SCIF0_RX */
         param->slave_id = s->cfg->dma_slave_rx;
-        param->dma_dev = s->cfg->dma_dev;
 
         chan = dma_request_channel(mask, filter, param);
         dev_dbg(port->dev, "%s: RX: got channel %p\n", __func__, chan);
@@ -1564,9 +1558,6 @@ static void sci_free_dma(struct uart_port *port)
 {
         struct sci_port *s = to_sci_port(port);
 
-        if (!s->cfg->dma_dev)
-                return;
-
         if (s->chan_tx)
                 sci_tx_dma_release(s, false);
         if (s->chan_rx)
@@ -1981,9 +1972,9 @@ static int __devinit sci_init_single(struct platform_device *dev,
         port->serial_in         = sci_serial_in;
         port->serial_out        = sci_serial_out;
 
-        if (p->dma_dev)
-                dev_dbg(port->dev, "DMA device %p, tx %d, rx %d\n",
-                        p->dma_dev, p->dma_slave_tx, p->dma_slave_rx);
+        if (p->dma_slave_tx > 0 && p->dma_slave_rx > 0)
+                dev_dbg(port->dev, "DMA tx %d, rx %d\n",
+                        p->dma_slave_tx, p->dma_slave_rx);
 
         return 0;
 }