2 * arch/arm/mach-omap2/serial.c
4 * OMAP2 serial support.
6 * Copyright (C) 2005-2008 Nokia Corporation
7 * Author: Paul Mundt <paul.mundt@nokia.com>
9 * Major rework for PM support by Kevin Hilman
11 * Based off of arch/arm/mach-omap/omap1/serial.c
13 * This file is subject to the terms and conditions of the GNU General Public
14 * License. See the file "COPYING" in the main directory of this archive
17 #include <linux/kernel.h>
18 #include <linux/init.h>
19 #include <linux/serial_8250.h>
20 #include <linux/serial_reg.h>
21 #include <linux/clk.h>
24 #include <mach/common.h>
25 #include <mach/board.h>
26 #include <mach/clock.h>
27 #include <mach/control.h>
31 #include "prm-regbits-34xx.h"
33 #define UART_OMAP_WER 0x17 /* Wake-up enable register */
35 #define DEFAULT_TIMEOUT (5 * HZ)
37 struct omap_uart_state {
40 struct timer_list timer;
52 struct plat_serial8250_port *p;
53 struct list_head node;
55 #if defined(CONFIG_ARCH_OMAP3) && defined(CONFIG_PM)
58 /* Registers to be saved/restored for OFF-mode */
68 static struct omap_uart_state omap_uart[OMAP_MAX_NR_PORTS];
69 static LIST_HEAD(uart_list);
71 static struct plat_serial8250_port serial_platform_data[] = {
73 .membase = IO_ADDRESS(OMAP_UART1_BASE),
74 .mapbase = OMAP_UART1_BASE,
76 .flags = UPF_BOOT_AUTOCONF,
79 .uartclk = OMAP24XX_BASE_BAUD * 16,
81 .membase = IO_ADDRESS(OMAP_UART2_BASE),
82 .mapbase = OMAP_UART2_BASE,
84 .flags = UPF_BOOT_AUTOCONF,
87 .uartclk = OMAP24XX_BASE_BAUD * 16,
89 .membase = IO_ADDRESS(OMAP_UART3_BASE),
90 .mapbase = OMAP_UART3_BASE,
92 .flags = UPF_BOOT_AUTOCONF,
95 .uartclk = OMAP24XX_BASE_BAUD * 16,
101 static inline unsigned int serial_read_reg(struct plat_serial8250_port *up,
104 offset <<= up->regshift;
105 return (unsigned int)__raw_readb(up->membase + offset);
108 static inline void serial_write_reg(struct plat_serial8250_port *p, int offset,
111 offset <<= p->regshift;
112 __raw_writeb(value, p->membase + offset);
116 * Internal UARTs need to be initialized for the 8250 autoconfig to work
117 * properly. Note that the TX watermark initialization may not be needed
118 * once the 8250.c watermark handling code is merged.
120 static inline void __init omap_uart_reset(struct omap_uart_state *uart)
122 struct plat_serial8250_port *p = uart->p;
124 serial_write_reg(p, UART_OMAP_MDR1, 0x07);
125 serial_write_reg(p, UART_OMAP_SCR, 0x08);
126 serial_write_reg(p, UART_OMAP_MDR1, 0x00);
127 serial_write_reg(p, UART_OMAP_SYSC, (0x02 << 3) | (1 << 2) | (1 << 0));
130 #if defined(CONFIG_PM) && defined(CONFIG_ARCH_OMAP3)
132 static int enable_off_mode; /* to be removed by full off-mode patches */
134 static void omap_uart_save_context(struct omap_uart_state *uart)
137 struct plat_serial8250_port *p = uart->p;
139 if (!enable_off_mode)
142 lcr = serial_read_reg(p, UART_LCR);
143 serial_write_reg(p, UART_LCR, 0xBF);
144 uart->dll = serial_read_reg(p, UART_DLL);
145 uart->dlh = serial_read_reg(p, UART_DLM);
146 serial_write_reg(p, UART_LCR, lcr);
147 uart->ier = serial_read_reg(p, UART_IER);
148 uart->sysc = serial_read_reg(p, UART_OMAP_SYSC);
149 uart->scr = serial_read_reg(p, UART_OMAP_SCR);
150 uart->wer = serial_read_reg(p, UART_OMAP_WER);
152 uart->context_valid = 1;
155 static void omap_uart_restore_context(struct omap_uart_state *uart)
158 struct plat_serial8250_port *p = uart->p;
160 if (!enable_off_mode)
163 if (!uart->context_valid)
166 uart->context_valid = 0;
168 serial_write_reg(p, UART_OMAP_MDR1, 0x7);
169 serial_write_reg(p, UART_LCR, 0xBF); /* Config B mode */
170 efr = serial_read_reg(p, UART_EFR);
171 serial_write_reg(p, UART_EFR, UART_EFR_ECB);
172 serial_write_reg(p, UART_LCR, 0x0); /* Operational mode */
173 serial_write_reg(p, UART_IER, 0x0);
174 serial_write_reg(p, UART_LCR, 0xBF); /* Config B mode */
175 serial_write_reg(p, UART_DLL, uart->dll);
176 serial_write_reg(p, UART_DLM, uart->dlh);
177 serial_write_reg(p, UART_LCR, 0x0); /* Operational mode */
178 serial_write_reg(p, UART_IER, uart->ier);
179 serial_write_reg(p, UART_FCR, 0xA1);
180 serial_write_reg(p, UART_LCR, 0xBF); /* Config B mode */
181 serial_write_reg(p, UART_EFR, efr);
182 serial_write_reg(p, UART_LCR, UART_LCR_WLEN8);
183 serial_write_reg(p, UART_OMAP_SCR, uart->scr);
184 serial_write_reg(p, UART_OMAP_WER, uart->wer);
185 serial_write_reg(p, UART_OMAP_SYSC, uart->sysc);
186 serial_write_reg(p, UART_OMAP_MDR1, 0x00); /* UART 16x mode */
189 static inline void omap_uart_save_context(struct omap_uart_state *uart) {}
190 static inline void omap_uart_restore_context(struct omap_uart_state *uart) {}
191 #endif /* CONFIG_PM && CONFIG_ARCH_OMAP3 */
193 static inline void omap_uart_enable_clocks(struct omap_uart_state *uart)
198 clk_enable(uart->ick);
199 clk_enable(uart->fck);
201 omap_uart_restore_context(uart);
206 static inline void omap_uart_disable_clocks(struct omap_uart_state *uart)
211 omap_uart_save_context(uart);
213 clk_disable(uart->ick);
214 clk_disable(uart->fck);
217 static void omap_uart_smart_idle_enable(struct omap_uart_state *uart,
220 struct plat_serial8250_port *p = uart->p;
223 sysc = serial_read_reg(p, UART_OMAP_SYSC) & 0x7;
229 serial_write_reg(p, UART_OMAP_SYSC, sysc);
232 static void omap_uart_block_sleep(struct omap_uart_state *uart)
234 omap_uart_enable_clocks(uart);
236 omap_uart_smart_idle_enable(uart, 0);
239 mod_timer(&uart->timer, jiffies + uart->timeout);
241 del_timer(&uart->timer);
244 static void omap_uart_allow_sleep(struct omap_uart_state *uart)
249 omap_uart_smart_idle_enable(uart, 1);
251 del_timer(&uart->timer);
254 static void omap_uart_idle_timer(unsigned long data)
256 struct omap_uart_state *uart = (struct omap_uart_state *)data;
258 omap_uart_allow_sleep(uart);
261 void omap_uart_prepare_idle(int num)
263 struct omap_uart_state *uart;
265 list_for_each_entry(uart, &uart_list, node) {
266 if (num == uart->num && uart->can_sleep) {
267 omap_uart_disable_clocks(uart);
273 void omap_uart_resume_idle(int num)
275 struct omap_uart_state *uart;
277 list_for_each_entry(uart, &uart_list, node) {
278 if (num == uart->num) {
279 omap_uart_enable_clocks(uart);
281 /* Check for IO pad wakeup */
282 if (cpu_is_omap34xx() && uart->padconf) {
283 u16 p = omap_ctrl_readw(uart->padconf);
285 if (p & OMAP3_PADCONF_WAKEUPEVENT0)
286 omap_uart_block_sleep(uart);
289 /* Check for normal UART wakeup */
290 if (__raw_readl(uart->wk_st) & uart->wk_mask)
291 omap_uart_block_sleep(uart);
298 void omap_uart_prepare_suspend(void)
300 struct omap_uart_state *uart;
302 list_for_each_entry(uart, &uart_list, node) {
303 omap_uart_allow_sleep(uart);
307 int omap_uart_can_sleep(void)
309 struct omap_uart_state *uart;
312 list_for_each_entry(uart, &uart_list, node) {
316 if (!uart->can_sleep) {
321 /* This UART can now safely sleep. */
322 omap_uart_allow_sleep(uart);
329 * omap_uart_interrupt()
331 * This handler is used only to detect that *any* UART interrupt has
332 * occurred. It does _nothing_ to handle the interrupt. Rather,
333 * any UART interrupt will trigger the inactivity timer so the
334 * UART will not idle or sleep for its timeout period.
337 static irqreturn_t omap_uart_interrupt(int irq, void *dev_id)
339 struct omap_uart_state *uart = dev_id;
341 omap_uart_block_sleep(uart);
346 static u32 sleep_timeout = DEFAULT_TIMEOUT;
348 static void omap_uart_idle_init(struct omap_uart_state *uart)
351 struct plat_serial8250_port *p = uart->p;
355 uart->timeout = sleep_timeout;
356 setup_timer(&uart->timer, omap_uart_idle_timer,
357 (unsigned long) uart);
358 mod_timer(&uart->timer, jiffies + uart->timeout);
359 omap_uart_smart_idle_enable(uart, 0);
361 if (cpu_is_omap34xx()) {
362 u32 mod = (uart->num == 2) ? OMAP3430_PER_MOD : CORE_MOD;
366 uart->wk_en = OMAP34XX_PRM_REGADDR(mod, PM_WKEN1);
367 uart->wk_st = OMAP34XX_PRM_REGADDR(mod, PM_WKST1);
370 wk_mask = OMAP3430_ST_UART1_MASK;
374 wk_mask = OMAP3430_ST_UART2_MASK;
378 wk_mask = OMAP3430_ST_UART3_MASK;
382 uart->wk_mask = wk_mask;
383 uart->padconf = padconf;
384 } else if (cpu_is_omap24xx()) {
387 if (cpu_is_omap2430()) {
388 uart->wk_en = OMAP2430_PRM_REGADDR(CORE_MOD, PM_WKEN1);
389 uart->wk_st = OMAP2430_PRM_REGADDR(CORE_MOD, PM_WKST1);
390 } else if (cpu_is_omap2420()) {
391 uart->wk_en = OMAP2420_PRM_REGADDR(CORE_MOD, PM_WKEN1);
392 uart->wk_st = OMAP2420_PRM_REGADDR(CORE_MOD, PM_WKST1);
396 wk_mask = OMAP24XX_ST_UART1_MASK;
399 wk_mask = OMAP24XX_ST_UART2_MASK;
402 wk_mask = OMAP24XX_ST_UART3_MASK;
405 uart->wk_mask = wk_mask;
413 /* Set wake-enable bit */
414 if (uart->wk_en && uart->wk_mask) {
415 v = __raw_readl(uart->wk_en);
417 __raw_writel(v, uart->wk_en);
420 /* Ensure IOPAD wake-enables are set */
421 if (cpu_is_omap34xx() && uart->padconf) {
424 v = omap_ctrl_readw(uart->padconf);
425 v |= OMAP3_PADCONF_WAKEUPENABLE0;
426 omap_ctrl_writew(v, uart->padconf);
429 p->flags |= UPF_SHARE_IRQ;
430 ret = request_irq(p->irq, omap_uart_interrupt, IRQF_SHARED,
431 "serial idle", (void *)uart);
435 static ssize_t sleep_timeout_show(struct kobject *kobj,
436 struct kobj_attribute *attr,
439 return sprintf(buf, "%u\n", sleep_timeout / HZ);
442 static ssize_t sleep_timeout_store(struct kobject *kobj,
443 struct kobj_attribute *attr,
444 const char *buf, size_t n)
446 struct omap_uart_state *uart;
449 if (sscanf(buf, "%u", &value) != 1) {
450 printk(KERN_ERR "sleep_timeout_store: Invalid value\n");
453 sleep_timeout = value * HZ;
454 list_for_each_entry(uart, &uart_list, node) {
455 uart->timeout = sleep_timeout;
457 mod_timer(&uart->timer, jiffies + uart->timeout);
459 /* A zero value means disable timeout feature */
460 omap_uart_block_sleep(uart);
465 static struct kobj_attribute sleep_timeout_attr =
466 __ATTR(sleep_timeout, 0644, sleep_timeout_show, sleep_timeout_store);
469 static inline void omap_uart_idle_init(struct omap_uart_state *uart) {}
470 #endif /* CONFIG_PM */
472 static struct platform_device serial_device = {
473 .name = "serial8250",
474 .id = PLAT8250_DEV_PLATFORM,
476 .platform_data = serial_platform_data,
480 void __init omap_serial_init(void)
483 const struct omap_uart_config *info;
487 * Make sure the serial ports are muxed on at this point.
488 * You have to mux them off in device drivers later on
492 info = omap_get_config(OMAP_TAG_UART, struct omap_uart_config);
497 for (i = 0; i < OMAP_MAX_NR_PORTS; i++) {
498 struct plat_serial8250_port *p = serial_platform_data + i;
499 struct omap_uart_state *uart = &omap_uart[i];
501 if (!(info->enabled_uarts & (1 << i))) {
507 sprintf(name, "uart%d_ick", i+1);
508 uart->ick = clk_get(NULL, name);
509 if (IS_ERR(uart->ick)) {
510 printk(KERN_ERR "Could not get uart%d_ick\n", i+1);
514 sprintf(name, "uart%d_fck", i+1);
515 uart->fck = clk_get(NULL, name);
516 if (IS_ERR(uart->fck)) {
517 printk(KERN_ERR "Could not get uart%d_fck\n", i+1);
521 if (!uart->ick || !uart->fck)
525 p->private_data = uart;
527 list_add(&uart->node, &uart_list);
529 omap_uart_enable_clocks(uart);
530 omap_uart_reset(uart);
531 omap_uart_idle_init(uart);
534 err = platform_device_register(&serial_device);
538 err = sysfs_create_file(&serial_device.dev.kobj,
539 &sleep_timeout_attr.attr);