1 files changed, 174 insertions, 44 deletions

diff --git a/arch/arm/mach-omap2/serial.c b/arch/arm/mach-omap2/serial.c
index 54dfeb5d5667..3771254dfa81 100644
--- a/arch/arm/mach-omap2/serial.c
+++ b/arch/arm/mach-omap2/serial.c
@@ -23,19 +23,27 @@
 #include <linux/serial_reg.h>
 #include <linux/clk.h>
 #include <linux/io.h>
+#include <linux/delay.h>
 
-#include <mach/common.h>
-#include <mach/board.h>
-#include <mach/clock.h>
-#include <mach/control.h>
+#include <plat/common.h>
+#include <plat/board.h>
+#include <plat/clock.h>
+#include <plat/control.h>
 
 #include "prm.h"
 #include "pm.h"
 #include "prm-regbits-34xx.h"
 
+#define UART_OMAP_NO_EMPTY_FIFO_READ_IP_REV     0x52
 #define UART_OMAP_WER           0x17    /* Wake-up enable register */
 
-#define DEFAULT_TIMEOUT (5 * HZ)
+/*
+ * NOTE: By default the serial timeout is disabled as it causes lost characters
+ * over the serial ports. This means that the UART clocks will stay on until
+ * disabled via sysfs. This also causes that any deeper omap sleep states are
+ * blocked. 
+ */
+#define DEFAULT_TIMEOUT 0
 
 struct omap_uart_state {
         int num;
@@ -73,8 +81,6 @@ static LIST_HEAD(uart_list);
 
 static struct plat_serial8250_port serial_platform_data0[] = {
         {
-                .membase        = OMAP2_IO_ADDRESS(OMAP_UART1_BASE),
-                .mapbase        = OMAP_UART1_BASE,
                 .irq            = 72,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .iotype         = UPIO_MEM,
@@ -87,8 +93,6 @@ static struct plat_serial8250_port serial_platform_data0[] = {
 
 static struct plat_serial8250_port serial_platform_data1[] = {
         {
-                .membase        = OMAP2_IO_ADDRESS(OMAP_UART2_BASE),
-                .mapbase        = OMAP_UART2_BASE,
                 .irq            = 73,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .iotype         = UPIO_MEM,
@@ -101,8 +105,6 @@ static struct plat_serial8250_port serial_platform_data1[] = {
 
 static struct plat_serial8250_port serial_platform_data2[] = {
         {
-                .membase        = OMAP2_IO_ADDRESS(OMAP_UART3_BASE),
-                .mapbase        = OMAP_UART3_BASE,
                 .irq            = 74,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .iotype         = UPIO_MEM,
@@ -113,11 +115,8 @@ static struct plat_serial8250_port serial_platform_data2[] = {
         }
 };
 
-#ifdef CONFIG_ARCH_OMAP4
 static struct plat_serial8250_port serial_platform_data3[] = {
         {
-                .membase        = OMAP2_IO_ADDRESS(OMAP_UART4_BASE),
-                .mapbase        = OMAP_UART4_BASE,
                 .irq            = 70,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .iotype         = UPIO_MEM,
@@ -127,7 +126,22 @@ static struct plat_serial8250_port serial_platform_data3[] = {
                 .flags          = 0
         }
 };
-#endif
+
+void __init omap2_set_globals_uart(struct omap_globals *omap2_globals)
+{
+        serial_platform_data0[0].mapbase = omap2_globals->uart1_phys;
+        serial_platform_data1[0].mapbase = omap2_globals->uart2_phys;
+        serial_platform_data2[0].mapbase = omap2_globals->uart3_phys;
+        serial_platform_data3[0].mapbase = omap2_globals->uart4_phys;
+}
+
+static inline unsigned int __serial_read_reg(struct uart_port *up,
+                                           int offset)
+{
+        offset <<= up->regshift;
+        return (unsigned int)__raw_readb(up->membase + offset);
+}
+
 static inline unsigned int serial_read_reg(struct plat_serial8250_port *up,
                                            int offset)
 {
@@ -135,6 +149,13 @@ static inline unsigned int serial_read_reg(struct plat_serial8250_port *up,
         return (unsigned int)__raw_readb(up->membase + offset);
 }
 
+static inline void __serial_write_reg(struct uart_port *up, int offset,
+                int value)
+{
+        offset <<= up->regshift;
+        __raw_writeb(value, up->membase + offset);
+}
+
 static inline void serial_write_reg(struct plat_serial8250_port *p, int offset,
                                     int value)
 {
@@ -159,8 +180,6 @@ static inline void __init omap_uart_reset(struct omap_uart_state *uart)
 
 #if defined(CONFIG_PM) && defined(CONFIG_ARCH_OMAP3)
 
-static int enable_off_mode; /* to be removed by full off-mode patches */
-
 static void omap_uart_save_context(struct omap_uart_state *uart)
 {
         u16 lcr = 0;
@@ -420,7 +439,8 @@ static void omap_uart_idle_init(struct omap_uart_state *uart)
         uart->timeout = DEFAULT_TIMEOUT;
         setup_timer(&uart->timer, omap_uart_idle_timer,
                     (unsigned long) uart);
-        mod_timer(&uart->timer, jiffies + uart->timeout);
+        if (uart->timeout)
+                mod_timer(&uart->timer, jiffies + uart->timeout);
         omap_uart_smart_idle_enable(uart, 0);
 
         if (cpu_is_omap34xx()) {
@@ -518,7 +538,7 @@ static ssize_t sleep_timeout_store(struct device *dev,
         unsigned int value;
 
         if (sscanf(buf, "%u", &value) != 1) {
-                printk(KERN_ERR "sleep_timeout_store: Invalid value\n");
+                dev_err(dev, "sleep_timeout_store: Invalid value\n");
                 return -EINVAL;
         }
 
@@ -539,7 +559,7 @@ static inline void omap_uart_idle_init(struct omap_uart_state *uart) {}
 #define DEV_CREATE_FILE(dev, attr)
 #endif /* CONFIG_PM */
 
-static struct omap_uart_state omap_uart[OMAP_MAX_NR_PORTS] = {
+static struct omap_uart_state omap_uart[] = {
         {
                 .pdev = {
                         .name                   = "serial8250",
@@ -565,7 +585,7 @@ static struct omap_uart_state omap_uart[OMAP_MAX_NR_PORTS] = {
                         },
                 },
         },
-#ifdef CONFIG_ARCH_OMAP4
+#if defined(CONFIG_ARCH_OMAP3) || defined(CONFIG_ARCH_OMAP4)
         {
                 .pdev = {
                         .name                   = "serial8250",
@@ -578,34 +598,87 @@ static struct omap_uart_state omap_uart[OMAP_MAX_NR_PORTS] = {
 #endif
 };
 
+/*
+ * Override the default 8250 read handler: mem_serial_in()
+ * Empty RX fifo read causes an abort on omap3630 and omap4
+ * This function makes sure that an empty rx fifo is not read on these silicons
+ * (OMAP1/2/3430 are not affected)
+ */
+static unsigned int serial_in_override(struct uart_port *up, int offset)
+{
+        if (UART_RX == offset) {
+                unsigned int lsr;
+                lsr = __serial_read_reg(up, UART_LSR);
+                if (!(lsr & UART_LSR_DR))
+                        return -EPERM;
+        }
+
+        return __serial_read_reg(up, offset);
+}
+
+static void serial_out_override(struct uart_port *up, int offset, int value)
+{
+        unsigned int status, tmout = 10000;
+
+        status = __serial_read_reg(up, UART_LSR);
+        while (!(status & UART_LSR_THRE)) {
+                /* Wait up to 10ms for the character(s) to be sent. */
+                if (--tmout == 0)
+                        break;
+                udelay(1);
+                status = __serial_read_reg(up, UART_LSR);
+        }
+        __serial_write_reg(up, offset, value);
+}
 void __init omap_serial_early_init(void)
 {
-        int i;
+        int i, nr_ports;
         char name[16];
 
+        if (!(cpu_is_omap3630() || cpu_is_omap4430()))
+                nr_ports = 3;
+        else
+                nr_ports = ARRAY_SIZE(omap_uart);
+
         /*
          * Make sure the serial ports are muxed on at this point.
          * You have to mux them off in device drivers later on
          * if not needed.
          */
 
-        for (i = 0; i < OMAP_MAX_NR_PORTS; i++) {
+        for (i = 0; i < nr_ports; i++) {
                 struct omap_uart_state *uart = &omap_uart[i];
                 struct platform_device *pdev = &uart->pdev;
                 struct device *dev = &pdev->dev;
                 struct plat_serial8250_port *p = dev->platform_data;
 
-                sprintf(name, "uart%d_ick", i+1);
+                /* Don't map zero-based physical address */
+                if (p->mapbase == 0) {
+                        dev_warn(dev, "no physical address for uart#%d,"
+                                 " so skipping early_init...\n", i);
+                        continue;
+                }
+                /*
+                 * Module 4KB + L4 interconnect 4KB
+                 * Static mapping, never released
+                 */
+                p->membase = ioremap(p->mapbase, SZ_8K);
+                if (!p->membase) {
+                        dev_err(dev, "ioremap failed for uart%i\n", i + 1);
+                        continue;
+                }
+
+                sprintf(name, "uart%d_ick", i + 1);
                 uart->ick = clk_get(NULL, name);
                 if (IS_ERR(uart->ick)) {
-                        printk(KERN_ERR "Could not get uart%d_ick\n", i+1);
+                        dev_err(dev, "Could not get uart%d_ick\n", i + 1);
                         uart->ick = NULL;
                 }
 
                 sprintf(name, "uart%d_fck", i+1);
                 uart->fck = clk_get(NULL, name);
                 if (IS_ERR(uart->fck)) {
-                        printk(KERN_ERR "Could not get uart%d_fck\n", i+1);
+                        dev_err(dev, "Could not get uart%d_fck\n", i + 1);
                         uart->fck = NULL;
                 }
 
@@ -618,33 +691,90 @@ void __init omap_serial_early_init(void)
                 uart->num = i;
                 p->private_data = uart;
                 uart->p = p;
-                list_add_tail(&uart->node, &uart_list);
 
                 if (cpu_is_omap44xx())
                         p->irq += 32;
-
-                omap_uart_enable_clocks(uart);
         }
 }
 
-void __init omap_serial_init(void)
+/**
+ * omap_serial_init_port() - initialize single serial port
+ * @port: serial port number (0-3)
+ *
+ * This function initialies serial driver for given @port only.
+ * Platforms can call this function instead of omap_serial_init()
+ * if they don't plan to use all available UARTs as serial ports.
+ *
+ * Don't mix calls to omap_serial_init_port() and omap_serial_init(),
+ * use only one of the two.
+ */
+void __init omap_serial_init_port(int port)
 {
-        int i;
+        struct omap_uart_state *uart;
+        struct platform_device *pdev;
+        struct device *dev;
 
-        for (i = 0; i < OMAP_MAX_NR_PORTS; i++) {
-                struct omap_uart_state *uart = &omap_uart[i];
-                struct platform_device *pdev = &uart->pdev;
-                struct device *dev = &pdev->dev;
+        BUG_ON(port < 0);
+        BUG_ON(port >= ARRAY_SIZE(omap_uart));
 
-                omap_uart_reset(uart);
-                omap_uart_idle_init(uart);
+        uart = &omap_uart[port];
+        pdev = &uart->pdev;
+        dev = &pdev->dev;
 
-                if (WARN_ON(platform_device_register(pdev)))
-                        continue;
-                if ((cpu_is_omap34xx() && uart->padconf) ||
-                    (uart->wk_en && uart->wk_mask)) {
-                        device_init_wakeup(dev, true);
-                        DEV_CREATE_FILE(dev, &dev_attr_sleep_timeout);
-                }
+        /* Don't proceed if there's no clocks available */
+        if (unlikely(!uart->ick || !uart->fck)) {
+                WARN(1, "%s: can't init uart%d, no clocks available\n",
+                     kobject_name(&dev->kobj), port);
+                return;
         }
+
+        omap_uart_enable_clocks(uart);
+
+        omap_uart_reset(uart);
+        omap_uart_idle_init(uart);
+
+        list_add_tail(&uart->node, &uart_list);
+
+        if (WARN_ON(platform_device_register(pdev)))
+                return;
+
+        if ((cpu_is_omap34xx() && uart->padconf) ||
+            (uart->wk_en && uart->wk_mask)) {
+                device_init_wakeup(dev, true);
+                DEV_CREATE_FILE(dev, &dev_attr_sleep_timeout);
+        }
+
+        /*
+         * omap44xx: Never read empty UART fifo
+         * omap3xxx: Never read empty UART fifo on UARTs
+         * with IP rev >=0x52
+         */
+        if (cpu_is_omap44xx()) {
+                uart->p->serial_in = serial_in_override;
+                uart->p->serial_out = serial_out_override;
+        } else if ((serial_read_reg(uart->p, UART_OMAP_MVER) & 0xFF)
+                        >= UART_OMAP_NO_EMPTY_FIFO_READ_IP_REV) {
+                uart->p->serial_in = serial_in_override;
+                uart->p->serial_out = serial_out_override;
+        }
+}
+
+/**
+ * omap_serial_init() - intialize all supported serial ports
+ *
+ * Initializes all available UARTs as serial ports. Platforms
+ * can call this function when they want to have default behaviour
+ * for serial ports (e.g initialize them all as serial ports).
+ */
+void __init omap_serial_init(void)
+{
+        int i, nr_ports;
+
+        if (!(cpu_is_omap3630() || cpu_is_omap4430()))
+                nr_ports = 3;
+        else
+                nr_ports = ARRAY_SIZE(omap_uart);
+
+        for (i = 0; i < nr_ports; i++)
+                omap_serial_init_port(i);
 }