ARM: OMAP2+: UART: Add default mux for all uarts.

Padconf wakeup is used to wakeup uart after uart fclks/iclks are gated.
Rx-Pad wakeup was done by writing to rx-pad offset value populated in
serial.c idle_init. Remove the direct reading and writing into rx pad.
Remove the padconf field part of omap_uart_state struct and pad offsets
populated.

Now with mux framework support we can use mux_utilities
along with hmwod framework to handle io-pad configuration and enable rx-pad
wake-up mechanism.

To avoid breaking any board support add default mux data for all uart's
if mux info is not passed from board file.
With the default pads populated in serial.c wakeup capability for
rx pads is set, this can be used to enable uart_rx io-pad wakeup from
hwmod framework. The pad values in 3430sdp/4430sdp/omap4panda board file
are same as the default pad values populated in serial.c. Remove pad values
from 3430sdp/4430sdp/omap4panda board file and use the default pads
from serial.c file.

Signed-off-by: Govindraj.R <govindraj.raja@ti.com>
Signed-off-by: Kevin Hilman <khilman@ti.com>

1 files changed, 130 insertions, 25 deletions

diff --git a/arch/arm/mach-omap2/serial.c b/arch/arm/mach-omap2/serial.c
index 5bdbc42e42a6..77feaab78059 100644
--- a/arch/arm/mach-omap2/serial.c
+++ b/arch/arm/mach-omap2/serial.c
@@ -62,7 +62,6 @@ struct omap_uart_state {
         void __iomem *wk_st;
         void __iomem *wk_en;
         u32 wk_mask;
-        u32 padconf;
         u32 dma_enabled;
 
         int clocked;
@@ -272,13 +271,6 @@ static void omap_uart_enable_wakeup(struct omap_uart_state *uart)
                 v |= uart->wk_mask;
                 __raw_writel(v, uart->wk_en);
         }
-
-        /* Ensure IOPAD wake-enables are set */
-        if (cpu_is_omap34xx() && uart->padconf) {
-                u16 v = omap_ctrl_readw(uart->padconf);
-                v |= OMAP3_PADCONF_WAKEUPENABLE0;
-                omap_ctrl_writew(v, uart->padconf);
-        }
 }
 
 static void omap_uart_disable_wakeup(struct omap_uart_state *uart)
@@ -289,13 +281,6 @@ static void omap_uart_disable_wakeup(struct omap_uart_state *uart)
                 v &= ~uart->wk_mask;
                 __raw_writel(v, uart->wk_en);
         }
-
-        /* Ensure IOPAD wake-enables are cleared */
-        if (cpu_is_omap34xx() && uart->padconf) {
-                u16 v = omap_ctrl_readw(uart->padconf);
-                v &= ~OMAP3_PADCONF_WAKEUPENABLE0;
-                omap_ctrl_writew(v, uart->padconf);
-        }
 }
 
 static void omap_uart_smart_idle_enable(struct omap_uart_state *uart,
@@ -358,7 +343,6 @@ static void omap_uart_idle_init(struct omap_uart_state *uart)
         if (cpu_is_omap34xx() && !(cpu_is_ti81xx() || cpu_is_am33xx())) {
                 u32 mod = (uart->num > 1) ? OMAP3430_PER_MOD : CORE_MOD;
                 u32 wk_mask = 0;
-                u32 padconf = 0;
 
                 /* XXX These PRM accesses do not belong here */
                 uart->wk_en = OMAP34XX_PRM_REGADDR(mod, PM_WKEN1);
@@ -366,23 +350,18 @@ static void omap_uart_idle_init(struct omap_uart_state *uart)
                 switch (uart->num) {
                 case 0:
                         wk_mask = OMAP3430_ST_UART1_MASK;
-                        padconf = 0x182;
                         break;
                 case 1:
                         wk_mask = OMAP3430_ST_UART2_MASK;
-                        padconf = 0x17a;
                         break;
                 case 2:
                         wk_mask = OMAP3430_ST_UART3_MASK;
-                        padconf = 0x19e;
                         break;
                 case 3:
                         wk_mask = OMAP3630_ST_UART4_MASK;
-                        padconf = 0x0d2;
                         break;
                 }
                 uart->wk_mask = wk_mask;
-                uart->padconf = padconf;
         } else if (cpu_is_omap24xx()) {
                 u32 wk_mask = 0;
                 u32 wk_en = PM_WKEN1, wk_st = PM_WKST1;
@@ -412,12 +391,10 @@ static void omap_uart_idle_init(struct omap_uart_state *uart)
                 uart->wk_en = NULL;
                 uart->wk_st = NULL;
                 uart->wk_mask = 0;
-                uart->padconf = 0;
         }
 }
 
 #else
-static inline void omap_uart_idle_init(struct omap_uart_state *uart) {}
 static void omap_uart_block_sleep(struct omap_uart_state *uart)
 {
         /* Needed to enable UART clocks when built without CONFIG_PM */
@@ -425,6 +402,130 @@ static void omap_uart_block_sleep(struct omap_uart_state *uart)
 }
 #endif /* CONFIG_PM */
 
+#ifdef CONFIG_OMAP_MUX
+static struct omap_device_pad default_uart1_pads[] __initdata = {
+        {
+                .name   = "uart1_cts.uart1_cts",
+                .enable = OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0,
+        },
+        {
+                .name   = "uart1_rts.uart1_rts",
+                .enable = OMAP_PIN_OUTPUT | OMAP_MUX_MODE0,
+        },
+        {
+                .name   = "uart1_tx.uart1_tx",
+                .enable = OMAP_PIN_OUTPUT | OMAP_MUX_MODE0,
+        },
+        {
+                .name   = "uart1_rx.uart1_rx",
+                .flags  = OMAP_DEVICE_PAD_REMUX | OMAP_DEVICE_PAD_WAKEUP,
+                .enable = OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0,
+                .idle   = OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0,
+        },
+};
+
+static struct omap_device_pad default_uart2_pads[] __initdata = {
+        {
+                .name   = "uart2_cts.uart2_cts",
+                .enable = OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0,
+        },
+        {
+                .name   = "uart2_rts.uart2_rts",
+                .enable = OMAP_PIN_OUTPUT | OMAP_MUX_MODE0,
+        },
+        {
+                .name   = "uart2_tx.uart2_tx",
+                .enable = OMAP_PIN_OUTPUT | OMAP_MUX_MODE0,
+        },
+        {
+                .name   = "uart2_rx.uart2_rx",
+                .flags  = OMAP_DEVICE_PAD_REMUX | OMAP_DEVICE_PAD_WAKEUP,
+                .enable = OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0,
+                .idle   = OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0,
+        },
+};
+
+static struct omap_device_pad default_uart3_pads[] __initdata = {
+        {
+                .name   = "uart3_cts_rctx.uart3_cts_rctx",
+                .enable = OMAP_PIN_INPUT_PULLUP | OMAP_MUX_MODE0,
+        },
+        {
+                .name   = "uart3_rts_sd.uart3_rts_sd",
+                .enable = OMAP_PIN_OUTPUT | OMAP_MUX_MODE0,
+        },
+        {
+                .name   = "uart3_tx_irtx.uart3_tx_irtx",
+                .enable = OMAP_PIN_OUTPUT | OMAP_MUX_MODE0,
+        },
+        {
+                .name   = "uart3_rx_irrx.uart3_rx_irrx",
+                .flags  = OMAP_DEVICE_PAD_REMUX | OMAP_DEVICE_PAD_WAKEUP,
+                .enable = OMAP_PIN_INPUT | OMAP_MUX_MODE0,
+                .idle   = OMAP_PIN_INPUT | OMAP_MUX_MODE0,
+        },
+};
+
+static struct omap_device_pad default_omap36xx_uart4_pads[] __initdata = {
+        {
+                .name   = "gpmc_wait2.uart4_tx",
+                .enable = OMAP_PIN_OUTPUT | OMAP_MUX_MODE0,
+        },
+        {
+                .name   = "gpmc_wait3.uart4_rx",
+                .flags  = OMAP_DEVICE_PAD_REMUX | OMAP_DEVICE_PAD_WAKEUP,
+                .enable = OMAP_PIN_INPUT | OMAP_MUX_MODE2,
+                .idle   = OMAP_PIN_INPUT | OMAP_MUX_MODE2,
+        },
+};
+
+static struct omap_device_pad default_omap4_uart4_pads[] __initdata = {
+        {
+                .name   = "uart4_tx.uart4_tx",
+                .enable = OMAP_PIN_OUTPUT | OMAP_MUX_MODE0,
+        },
+        {
+                .name   = "uart4_rx.uart4_rx",
+                .flags  = OMAP_DEVICE_PAD_REMUX | OMAP_DEVICE_PAD_WAKEUP,
+                .enable = OMAP_PIN_INPUT | OMAP_MUX_MODE0,
+                .idle   = OMAP_PIN_INPUT | OMAP_MUX_MODE0,
+        },
+};
+
+static void omap_serial_fill_default_pads(struct omap_board_data *bdata)
+{
+        switch (bdata->id) {
+        case 0:
+                bdata->pads = default_uart1_pads;
+                bdata->pads_cnt = ARRAY_SIZE(default_uart1_pads);
+                break;
+        case 1:
+                bdata->pads = default_uart2_pads;
+                bdata->pads_cnt = ARRAY_SIZE(default_uart2_pads);
+                break;
+        case 2:
+                bdata->pads = default_uart3_pads;
+                bdata->pads_cnt = ARRAY_SIZE(default_uart3_pads);
+                break;
+        case 3:
+                if (cpu_is_omap44xx()) {
+                        bdata->pads = default_omap4_uart4_pads;
+                        bdata->pads_cnt =
+                                ARRAY_SIZE(default_omap4_uart4_pads);
+                } else if (cpu_is_omap3630()) {
+                        bdata->pads = default_omap36xx_uart4_pads;
+                        bdata->pads_cnt =
+                                ARRAY_SIZE(default_omap36xx_uart4_pads);
+                }
+                break;
+        default:
+                break;
+        }
+}
+#else
+static void omap_serial_fill_default_pads(struct omap_board_data *bdata) {}
+#endif
+
 static int __init omap_serial_early_init(void)
 {
         int i = 0;
@@ -547,8 +648,8 @@ void __init omap_serial_init_port(struct omap_board_data *bdata)
         omap_uart_block_sleep(uart);
         console_unlock();
 
-        if ((cpu_is_omap34xx() && uart->padconf) ||
-            (uart->wk_en && uart->wk_mask))
+        if (((cpu_is_omap34xx() || cpu_is_omap44xx()) && bdata->pads) ||
+                (pdata->wk_en && pdata->wk_mask))
                 device_init_wakeup(&pdev->dev, true);
 
         /* Enable the MDR1 errata for OMAP3 */
@@ -573,6 +674,10 @@ void __init omap_serial_init(void)
                 bdata.flags = 0;
                 bdata.pads = NULL;
                 bdata.pads_cnt = 0;
+
+                if (cpu_is_omap44xx() || cpu_is_omap34xx())
+                        omap_serial_fill_default_pads(&bdata);
+
                 omap_serial_init_port(&bdata);
 
         }