1/* 2 * arch/arm/mach-omap2/serial.c 3 * 4 * OMAP2 serial support. 5 * 6 * Copyright (C) 2005-2008 Nokia Corporation 7 * Author: Paul Mundt <paul.mundt@nokia.com> 8 * 9 * Major rework for PM support by Kevin Hilman 10 * 11 * Based off of arch/arm/mach-omap/omap1/serial.c 12 * 13 * Copyright (C) 2009 Texas Instruments 14 * Added OMAP4 support - Santosh Shilimkar <santosh.shilimkar@ti.com 15 * 16 * This file is subject to the terms and conditions of the GNU General Public 17 * License. See the file "COPYING" in the main directory of this archive 18 * for more details. 19 */ 20#include <linux/kernel.h> 21#include <linux/init.h> 22#include <linux/clk.h> 23#include <linux/io.h> 24#include <linux/delay.h> 25#include <linux/platform_device.h> 26#include <linux/slab.h> 27#include <linux/pm_runtime.h> 28#include <linux/console.h> 29#include <linux/omap-dma.h> 30#include <linux/platform_data/serial-omap.h> 31 32#include "common.h" 33#include "omap_hwmod.h" 34#include "omap_device.h" 35#include "omap-pm.h" 36#include "soc.h" 37#include "prm2xxx_3xxx.h" 38#include "pm.h" 39#include "cm2xxx_3xxx.h" 40#include "prm-regbits-34xx.h" 41#include "control.h" 42#include "mux.h" 43#include "serial.h" 44 45/* 46 * NOTE: By default the serial auto_suspend timeout is disabled as it causes 47 * lost characters over the serial ports. This means that the UART clocks will 48 * stay on until power/autosuspend_delay is set for the uart from sysfs. 49 * This also causes that any deeper omap sleep states are blocked. 50 */ 51#define DEFAULT_AUTOSUSPEND_DELAY -1 52 53#define MAX_UART_HWMOD_NAME_LEN 16 54 55struct omap_uart_state { 56 int num; 57 58 struct list_head node; 59 struct omap_hwmod *oh; 60 struct omap_device_pad default_omap_uart_pads[2]; 61}; 62 63static LIST_HEAD(uart_list); 64static u8 num_uarts; 65static u8 console_uart_id = -1; 66static u8 uart_debug; 67 68#define DEFAULT_RXDMA_POLLRATE 1 /* RX DMA polling rate (us) */ 69#define DEFAULT_RXDMA_BUFSIZE 4096 /* RX DMA buffer size */ 70#define DEFAULT_RXDMA_TIMEOUT (3 * HZ)/* RX DMA timeout (jiffies) */ 71 72static struct omap_uart_port_info omap_serial_default_info[] __initdata = { 73 { 74 .dma_enabled = false, 75 .dma_rx_buf_size = DEFAULT_RXDMA_BUFSIZE, 76 .dma_rx_poll_rate = DEFAULT_RXDMA_POLLRATE, 77 .dma_rx_timeout = DEFAULT_RXDMA_TIMEOUT, 78 .autosuspend_timeout = DEFAULT_AUTOSUSPEND_DELAY, 79 }, 80}; 81 82#ifdef CONFIG_PM 83static void omap_uart_enable_wakeup(struct device *dev, bool enable) 84{ 85 struct platform_device *pdev = to_platform_device(dev); 86 struct omap_device *od = to_omap_device(pdev); 87 88 if (!od) 89 return; 90 91 if (enable) 92 omap_hwmod_enable_wakeup(od->hwmods[0]); 93 else 94 omap_hwmod_disable_wakeup(od->hwmods[0]); 95} 96 97#else 98static void omap_uart_enable_wakeup(struct device *dev, bool enable) 99{} 100#endif /* CONFIG_PM */ 101 102#ifdef CONFIG_OMAP_MUX 103 104#define OMAP_UART_DEFAULT_PAD_NAME_LEN 28 105static char rx_pad_name[OMAP_UART_DEFAULT_PAD_NAME_LEN], 106 tx_pad_name[OMAP_UART_DEFAULT_PAD_NAME_LEN] __initdata; 107 108static void __init 109omap_serial_fill_uart_tx_rx_pads(struct omap_board_data *bdata, 110 struct omap_uart_state *uart) 111{ 112 uart->default_omap_uart_pads[0].name = rx_pad_name; 113 uart->default_omap_uart_pads[0].flags = OMAP_DEVICE_PAD_REMUX | 114 OMAP_DEVICE_PAD_WAKEUP; 115 uart->default_omap_uart_pads[0].enable = OMAP_PIN_INPUT | 116 OMAP_MUX_MODE0; 117 uart->default_omap_uart_pads[0].idle = OMAP_PIN_INPUT | OMAP_MUX_MODE0; 118 uart->default_omap_uart_pads[1].name = tx_pad_name; 119 uart->default_omap_uart_pads[1].enable = OMAP_PIN_OUTPUT | 120 OMAP_MUX_MODE0; 121 bdata->pads = uart->default_omap_uart_pads; 122 bdata->pads_cnt = ARRAY_SIZE(uart->default_omap_uart_pads); 123} 124 125static void __init omap_serial_check_wakeup(struct omap_board_data *bdata, 126 struct omap_uart_state *uart) 127{ 128 struct omap_mux_partition *tx_partition = NULL, *rx_partition = NULL; 129 struct omap_mux *rx_mux = NULL, *tx_mux = NULL; 130 char *rx_fmt, *tx_fmt; 131 int uart_nr = bdata->id + 1; 132 133 if (bdata->id != 2) { 134 rx_fmt = "uart%d_rx.uart%d_rx"; 135 tx_fmt = "uart%d_tx.uart%d_tx"; 136 } else { 137 rx_fmt = "uart%d_rx_irrx.uart%d_rx_irrx"; 138 tx_fmt = "uart%d_tx_irtx.uart%d_tx_irtx"; 139 } 140 141 snprintf(rx_pad_name, OMAP_UART_DEFAULT_PAD_NAME_LEN, rx_fmt, 142 uart_nr, uart_nr); 143 snprintf(tx_pad_name, OMAP_UART_DEFAULT_PAD_NAME_LEN, tx_fmt, 144 uart_nr, uart_nr); 145 146 if (omap_mux_get_by_name(rx_pad_name, &rx_partition, &rx_mux) >= 0 && 147 omap_mux_get_by_name 148 (tx_pad_name, &tx_partition, &tx_mux) >= 0) { 149 u16 tx_mode, rx_mode; 150 151 tx_mode = omap_mux_read(tx_partition, tx_mux->reg_offset); 152 rx_mode = omap_mux_read(rx_partition, rx_mux->reg_offset); 153 154 /* 155 * Check if uart is used in default tx/rx mode i.e. in mux mode0 156 * if yes then configure rx pin for wake up capability 157 */ 158 if (OMAP_MODE_UART(rx_mode) && OMAP_MODE_UART(tx_mode)) 159 omap_serial_fill_uart_tx_rx_pads(bdata, uart); 160 } 161} 162#else 163static void __init omap_serial_check_wakeup(struct omap_board_data *bdata, 164 struct omap_uart_state *uart) 165{ 166} 167#endif 168 169static char *cmdline_find_option(char *str) 170{ 171 extern char *saved_command_line; 172 173 return strstr(saved_command_line, str); 174} 175 176static int __init omap_serial_early_init(void) 177{ 178 if (of_have_populated_dt()) 179 return -ENODEV; 180 181 do { 182 char oh_name[MAX_UART_HWMOD_NAME_LEN]; 183 struct omap_hwmod *oh; 184 struct omap_uart_state *uart; 185 char uart_name[MAX_UART_HWMOD_NAME_LEN]; 186 187 snprintf(oh_name, MAX_UART_HWMOD_NAME_LEN, 188 "uart%d", num_uarts + 1); 189 oh = omap_hwmod_lookup(oh_name); 190 if (!oh) 191 break; 192 193 uart = kzalloc(sizeof(struct omap_uart_state), GFP_KERNEL); 194 if (WARN_ON(!uart)) 195 return -ENODEV; 196 197 uart->oh = oh; 198 uart->num = num_uarts++; 199 list_add_tail(&uart->node, &uart_list); 200 snprintf(uart_name, MAX_UART_HWMOD_NAME_LEN, 201 "%s%d", OMAP_SERIAL_NAME, uart->num); 202 203 if (cmdline_find_option(uart_name)) { 204 console_uart_id = uart->num; 205 206 if (console_loglevel >= 10) { 207 uart_debug = true; 208 pr_info("%s used as console in debug mode: uart%d clocks will not be gated", 209 uart_name, uart->num); 210 } 211 } 212 } while (1); 213 214 return 0; 215} 216omap_core_initcall(omap_serial_early_init); 217 218/** 219 * omap_serial_init_port() - initialize single serial port 220 * @bdata: port specific board data pointer 221 * @info: platform specific data pointer 222 * 223 * This function initialies serial driver for given port only. 224 * Platforms can call this function instead of omap_serial_init() 225 * if they don't plan to use all available UARTs as serial ports. 226 * 227 * Don't mix calls to omap_serial_init_port() and omap_serial_init(), 228 * use only one of the two. 229 */ 230void __init omap_serial_init_port(struct omap_board_data *bdata, 231 struct omap_uart_port_info *info) 232{ 233 struct omap_uart_state *uart; 234 struct omap_hwmod *oh; 235 struct platform_device *pdev; 236 void *pdata = NULL; 237 u32 pdata_size = 0; 238 char *name; 239 struct omap_uart_port_info omap_up; 240 241 if (WARN_ON(!bdata)) 242 return; 243 if (WARN_ON(bdata->id < 0)) 244 return; 245 if (WARN_ON(bdata->id >= num_uarts)) 246 return; 247 248 list_for_each_entry(uart, &uart_list, node) 249 if (bdata->id == uart->num) 250 break; 251 if (!info) 252 info = omap_serial_default_info; 253 254 oh = uart->oh; 255 name = DRIVER_NAME; 256 257 omap_up.dma_enabled = info->dma_enabled; 258 omap_up.uartclk = OMAP24XX_BASE_BAUD * 16; 259 omap_up.flags = UPF_BOOT_AUTOCONF; 260 omap_up.get_context_loss_count = omap_pm_get_dev_context_loss_count; 261 omap_up.enable_wakeup = omap_uart_enable_wakeup; 262 omap_up.dma_rx_buf_size = info->dma_rx_buf_size; 263 omap_up.dma_rx_timeout = info->dma_rx_timeout; 264 omap_up.dma_rx_poll_rate = info->dma_rx_poll_rate; 265 omap_up.autosuspend_timeout = info->autosuspend_timeout; 266 267 pdata = &omap_up; 268 pdata_size = sizeof(struct omap_uart_port_info); 269 270 if (WARN_ON(!oh)) 271 return; 272 273 pdev = omap_device_build(name, uart->num, oh, pdata, pdata_size); 274 if (IS_ERR(pdev)) { 275 WARN(1, "Could not build omap_device for %s: %s.\n", name, 276 oh->name); 277 return; 278 } 279 280 oh->mux = omap_hwmod_mux_init(bdata->pads, bdata->pads_cnt); 281 282 if (console_uart_id == bdata->id) { 283 omap_device_enable(pdev); 284 pm_runtime_set_active(&pdev->dev); 285 } 286 287 oh->dev_attr = uart; 288 289 if (((cpu_is_omap34xx() || cpu_is_omap44xx()) && bdata->pads) 290 && !uart_debug) 291 device_init_wakeup(&pdev->dev, true); 292} 293 294/** 295 * omap_serial_board_init() - initialize all supported serial ports 296 * @info: platform specific data pointer 297 * 298 * Initializes all available UARTs as serial ports. Platforms 299 * can call this function when they want to have default behaviour 300 * for serial ports (e.g initialize them all as serial ports). 301 */ 302void __init omap_serial_board_init(struct omap_uart_port_info *info) 303{ 304 struct omap_uart_state *uart; 305 struct omap_board_data bdata; 306 307 list_for_each_entry(uart, &uart_list, node) { 308 bdata.id = uart->num; 309 bdata.flags = 0; 310 bdata.pads = NULL; 311 bdata.pads_cnt = 0; 312 313 omap_serial_check_wakeup(&bdata, uart); 314 315 if (!info) 316 omap_serial_init_port(&bdata, NULL); 317 else 318 omap_serial_init_port(&bdata, &info[uart->num]); 319 } 320} 321 322/** 323 * omap_serial_init() - initialize all supported serial ports 324 * 325 * Initializes all available UARTs. 326 * Platforms can call this function when they want to have default behaviour 327 * for serial ports (e.g initialize them all as serial ports). 328 */ 329void __init omap_serial_init(void) 330{ 331 omap_serial_board_init(NULL); 332} 333