2005-11-10 21:26:51 +07:00
|
|
|
/*
|
2006-10-04 04:01:26 +07:00
|
|
|
* arch/arm/mach-omap2/serial.c
|
2005-11-10 21:26:51 +07:00
|
|
|
*
|
|
|
|
* OMAP2 serial support.
|
|
|
|
*
|
2008-10-06 19:49:15 +07:00
|
|
|
* Copyright (C) 2005-2008 Nokia Corporation
|
2005-11-10 21:26:51 +07:00
|
|
|
* Author: Paul Mundt <paul.mundt@nokia.com>
|
|
|
|
*
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
* Major rework for PM support by Kevin Hilman
|
|
|
|
*
|
2005-11-10 21:26:51 +07:00
|
|
|
* Based off of arch/arm/mach-omap/omap1/serial.c
|
|
|
|
*
|
2009-05-29 04:16:04 +07:00
|
|
|
* Copyright (C) 2009 Texas Instruments
|
|
|
|
* Added OMAP4 support - Santosh Shilimkar <santosh.shilimkar@ti.com
|
|
|
|
*
|
2005-11-10 21:26:51 +07:00
|
|
|
* This file is subject to the terms and conditions of the GNU General Public
|
|
|
|
* License. See the file "COPYING" in the main directory of this archive
|
|
|
|
* for more details.
|
|
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/serial_8250.h>
|
|
|
|
#include <linux/serial_reg.h>
|
2006-01-07 23:15:52 +07:00
|
|
|
#include <linux/clk.h>
|
2008-09-06 18:10:45 +07:00
|
|
|
#include <linux/io.h>
|
2010-02-18 15:59:06 +07:00
|
|
|
#include <linux/delay.h>
|
2005-11-10 21:26:51 +07:00
|
|
|
|
2009-10-20 23:40:47 +07:00
|
|
|
#include <plat/common.h>
|
|
|
|
#include <plat/board.h>
|
|
|
|
#include <plat/clock.h>
|
|
|
|
#include <plat/control.h>
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
|
|
|
|
#include "prm.h"
|
|
|
|
#include "pm.h"
|
|
|
|
#include "prm-regbits-34xx.h"
|
|
|
|
|
2009-12-12 07:16:37 +07:00
|
|
|
#define UART_OMAP_NO_EMPTY_FIFO_READ_IP_REV 0x52
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
#define UART_OMAP_WER 0x17 /* Wake-up enable register */
|
|
|
|
|
2010-02-02 03:34:31 +07:00
|
|
|
/*
|
|
|
|
* 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
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
|
|
|
|
struct omap_uart_state {
|
|
|
|
int num;
|
|
|
|
int can_sleep;
|
|
|
|
struct timer_list timer;
|
|
|
|
u32 timeout;
|
|
|
|
|
|
|
|
void __iomem *wk_st;
|
|
|
|
void __iomem *wk_en;
|
|
|
|
u32 wk_mask;
|
|
|
|
u32 padconf;
|
|
|
|
|
|
|
|
struct clk *ick;
|
|
|
|
struct clk *fck;
|
|
|
|
int clocked;
|
|
|
|
|
|
|
|
struct plat_serial8250_port *p;
|
|
|
|
struct list_head node;
|
2009-04-28 02:27:36 +07:00
|
|
|
struct platform_device pdev;
|
2005-11-10 21:26:51 +07:00
|
|
|
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
#if defined(CONFIG_ARCH_OMAP3) && defined(CONFIG_PM)
|
|
|
|
int context_valid;
|
|
|
|
|
|
|
|
/* Registers to be saved/restored for OFF-mode */
|
|
|
|
u16 dll;
|
|
|
|
u16 dlh;
|
|
|
|
u16 ier;
|
|
|
|
u16 sysc;
|
|
|
|
u16 scr;
|
|
|
|
u16 wer;
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
|
|
static LIST_HEAD(uart_list);
|
2005-11-10 21:26:51 +07:00
|
|
|
|
2009-04-28 02:27:36 +07:00
|
|
|
static struct plat_serial8250_port serial_platform_data0[] = {
|
2005-11-10 21:26:51 +07:00
|
|
|
{
|
|
|
|
.irq = 72,
|
|
|
|
.flags = UPF_BOOT_AUTOCONF,
|
|
|
|
.iotype = UPIO_MEM,
|
|
|
|
.regshift = 2,
|
2008-10-06 19:49:15 +07:00
|
|
|
.uartclk = OMAP24XX_BASE_BAUD * 16,
|
2005-11-10 21:26:51 +07:00
|
|
|
}, {
|
2009-04-28 02:27:36 +07:00
|
|
|
.flags = 0
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct plat_serial8250_port serial_platform_data1[] = {
|
|
|
|
{
|
2005-11-10 21:26:51 +07:00
|
|
|
.irq = 73,
|
|
|
|
.flags = UPF_BOOT_AUTOCONF,
|
|
|
|
.iotype = UPIO_MEM,
|
|
|
|
.regshift = 2,
|
2008-10-06 19:49:15 +07:00
|
|
|
.uartclk = OMAP24XX_BASE_BAUD * 16,
|
2005-11-10 21:26:51 +07:00
|
|
|
}, {
|
2009-04-28 02:27:36 +07:00
|
|
|
.flags = 0
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct plat_serial8250_port serial_platform_data2[] = {
|
|
|
|
{
|
2005-11-10 21:26:51 +07:00
|
|
|
.irq = 74,
|
|
|
|
.flags = UPF_BOOT_AUTOCONF,
|
|
|
|
.iotype = UPIO_MEM,
|
|
|
|
.regshift = 2,
|
2008-10-06 19:49:15 +07:00
|
|
|
.uartclk = OMAP24XX_BASE_BAUD * 16,
|
2005-11-10 21:26:51 +07:00
|
|
|
}, {
|
|
|
|
.flags = 0
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2009-08-22 15:00:11 +07:00
|
|
|
static struct plat_serial8250_port serial_platform_data3[] = {
|
|
|
|
{
|
|
|
|
.irq = 70,
|
|
|
|
.flags = UPF_BOOT_AUTOCONF,
|
|
|
|
.iotype = UPIO_MEM,
|
|
|
|
.regshift = 2,
|
|
|
|
.uartclk = OMAP24XX_BASE_BAUD * 16,
|
|
|
|
}, {
|
|
|
|
.flags = 0
|
|
|
|
}
|
|
|
|
};
|
2010-02-16 00:27:25 +07:00
|
|
|
|
2010-02-15 23:48:53 +07:00
|
|
|
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;
|
2010-02-27 08:58:47 +07:00
|
|
|
serial_platform_data3[0].mapbase = omap2_globals->uart4_phys;
|
2010-02-15 23:48:53 +07:00
|
|
|
}
|
|
|
|
|
2010-01-09 01:29:06 +07:00
|
|
|
static inline unsigned int __serial_read_reg(struct uart_port *up,
|
|
|
|
int offset)
|
|
|
|
{
|
|
|
|
offset <<= up->regshift;
|
|
|
|
return (unsigned int)__raw_readb(up->membase + offset);
|
|
|
|
}
|
|
|
|
|
2005-11-10 21:26:51 +07:00
|
|
|
static inline unsigned int serial_read_reg(struct plat_serial8250_port *up,
|
|
|
|
int offset)
|
|
|
|
{
|
|
|
|
offset <<= up->regshift;
|
|
|
|
return (unsigned int)__raw_readb(up->membase + offset);
|
|
|
|
}
|
|
|
|
|
2010-02-18 15:59:06 +07:00
|
|
|
static inline void __serial_write_reg(struct uart_port *up, int offset,
|
|
|
|
int value)
|
|
|
|
{
|
|
|
|
offset <<= up->regshift;
|
|
|
|
__raw_writeb(value, up->membase + offset);
|
|
|
|
}
|
|
|
|
|
2005-11-10 21:26:51 +07:00
|
|
|
static inline void serial_write_reg(struct plat_serial8250_port *p, int offset,
|
|
|
|
int value)
|
|
|
|
{
|
|
|
|
offset <<= p->regshift;
|
2008-09-02 04:07:37 +07:00
|
|
|
__raw_writeb(value, p->membase + offset);
|
2005-11-10 21:26:51 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Internal UARTs need to be initialized for the 8250 autoconfig to work
|
|
|
|
* properly. Note that the TX watermark initialization may not be needed
|
|
|
|
* once the 8250.c watermark handling code is merged.
|
|
|
|
*/
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
static inline void __init omap_uart_reset(struct omap_uart_state *uart)
|
2005-11-10 21:26:51 +07:00
|
|
|
{
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
struct plat_serial8250_port *p = uart->p;
|
|
|
|
|
2005-11-10 21:26:51 +07:00
|
|
|
serial_write_reg(p, UART_OMAP_MDR1, 0x07);
|
|
|
|
serial_write_reg(p, UART_OMAP_SCR, 0x08);
|
|
|
|
serial_write_reg(p, UART_OMAP_MDR1, 0x00);
|
2006-12-07 08:13:49 +07:00
|
|
|
serial_write_reg(p, UART_OMAP_SYSC, (0x02 << 3) | (1 << 2) | (1 << 0));
|
2005-11-10 21:26:51 +07:00
|
|
|
}
|
|
|
|
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
#if defined(CONFIG_PM) && defined(CONFIG_ARCH_OMAP3)
|
|
|
|
|
|
|
|
static void omap_uart_save_context(struct omap_uart_state *uart)
|
2008-10-06 19:49:15 +07:00
|
|
|
{
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
u16 lcr = 0;
|
|
|
|
struct plat_serial8250_port *p = uart->p;
|
|
|
|
|
|
|
|
if (!enable_off_mode)
|
|
|
|
return;
|
|
|
|
|
|
|
|
lcr = serial_read_reg(p, UART_LCR);
|
|
|
|
serial_write_reg(p, UART_LCR, 0xBF);
|
|
|
|
uart->dll = serial_read_reg(p, UART_DLL);
|
|
|
|
uart->dlh = serial_read_reg(p, UART_DLM);
|
|
|
|
serial_write_reg(p, UART_LCR, lcr);
|
|
|
|
uart->ier = serial_read_reg(p, UART_IER);
|
|
|
|
uart->sysc = serial_read_reg(p, UART_OMAP_SYSC);
|
|
|
|
uart->scr = serial_read_reg(p, UART_OMAP_SCR);
|
|
|
|
uart->wer = serial_read_reg(p, UART_OMAP_WER);
|
|
|
|
|
|
|
|
uart->context_valid = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void omap_uart_restore_context(struct omap_uart_state *uart)
|
|
|
|
{
|
|
|
|
u16 efr = 0;
|
|
|
|
struct plat_serial8250_port *p = uart->p;
|
|
|
|
|
|
|
|
if (!enable_off_mode)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!uart->context_valid)
|
|
|
|
return;
|
|
|
|
|
|
|
|
uart->context_valid = 0;
|
|
|
|
|
|
|
|
serial_write_reg(p, UART_OMAP_MDR1, 0x7);
|
|
|
|
serial_write_reg(p, UART_LCR, 0xBF); /* Config B mode */
|
|
|
|
efr = serial_read_reg(p, UART_EFR);
|
|
|
|
serial_write_reg(p, UART_EFR, UART_EFR_ECB);
|
|
|
|
serial_write_reg(p, UART_LCR, 0x0); /* Operational mode */
|
|
|
|
serial_write_reg(p, UART_IER, 0x0);
|
|
|
|
serial_write_reg(p, UART_LCR, 0xBF); /* Config B mode */
|
|
|
|
serial_write_reg(p, UART_DLL, uart->dll);
|
|
|
|
serial_write_reg(p, UART_DLM, uart->dlh);
|
|
|
|
serial_write_reg(p, UART_LCR, 0x0); /* Operational mode */
|
|
|
|
serial_write_reg(p, UART_IER, uart->ier);
|
|
|
|
serial_write_reg(p, UART_FCR, 0xA1);
|
|
|
|
serial_write_reg(p, UART_LCR, 0xBF); /* Config B mode */
|
|
|
|
serial_write_reg(p, UART_EFR, efr);
|
|
|
|
serial_write_reg(p, UART_LCR, UART_LCR_WLEN8);
|
|
|
|
serial_write_reg(p, UART_OMAP_SCR, uart->scr);
|
|
|
|
serial_write_reg(p, UART_OMAP_WER, uart->wer);
|
|
|
|
serial_write_reg(p, UART_OMAP_SYSC, uart->sysc);
|
|
|
|
serial_write_reg(p, UART_OMAP_MDR1, 0x00); /* UART 16x mode */
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void omap_uart_save_context(struct omap_uart_state *uart) {}
|
|
|
|
static inline void omap_uart_restore_context(struct omap_uart_state *uart) {}
|
|
|
|
#endif /* CONFIG_PM && CONFIG_ARCH_OMAP3 */
|
|
|
|
|
|
|
|
static inline void omap_uart_enable_clocks(struct omap_uart_state *uart)
|
|
|
|
{
|
|
|
|
if (uart->clocked)
|
|
|
|
return;
|
|
|
|
|
|
|
|
clk_enable(uart->ick);
|
|
|
|
clk_enable(uart->fck);
|
|
|
|
uart->clocked = 1;
|
|
|
|
omap_uart_restore_context(uart);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_PM
|
|
|
|
|
|
|
|
static inline void omap_uart_disable_clocks(struct omap_uart_state *uart)
|
|
|
|
{
|
|
|
|
if (!uart->clocked)
|
|
|
|
return;
|
|
|
|
|
|
|
|
omap_uart_save_context(uart);
|
|
|
|
uart->clocked = 0;
|
|
|
|
clk_disable(uart->ick);
|
|
|
|
clk_disable(uart->fck);
|
|
|
|
}
|
|
|
|
|
2009-04-28 02:27:36 +07:00
|
|
|
static void omap_uart_enable_wakeup(struct omap_uart_state *uart)
|
|
|
|
{
|
|
|
|
/* Set wake-enable bit */
|
|
|
|
if (uart->wk_en && uart->wk_mask) {
|
|
|
|
u32 v = __raw_readl(uart->wk_en);
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
/* Clear wake-enable bit */
|
|
|
|
if (uart->wk_en && uart->wk_mask) {
|
|
|
|
u32 v = __raw_readl(uart->wk_en);
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
static void omap_uart_smart_idle_enable(struct omap_uart_state *uart,
|
|
|
|
int enable)
|
|
|
|
{
|
|
|
|
struct plat_serial8250_port *p = uart->p;
|
|
|
|
u16 sysc;
|
|
|
|
|
|
|
|
sysc = serial_read_reg(p, UART_OMAP_SYSC) & 0x7;
|
|
|
|
if (enable)
|
|
|
|
sysc |= 0x2 << 3;
|
|
|
|
else
|
|
|
|
sysc |= 0x1 << 3;
|
|
|
|
|
|
|
|
serial_write_reg(p, UART_OMAP_SYSC, sysc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void omap_uart_block_sleep(struct omap_uart_state *uart)
|
|
|
|
{
|
|
|
|
omap_uart_enable_clocks(uart);
|
|
|
|
|
|
|
|
omap_uart_smart_idle_enable(uart, 0);
|
|
|
|
uart->can_sleep = 0;
|
2008-12-09 18:36:50 +07:00
|
|
|
if (uart->timeout)
|
|
|
|
mod_timer(&uart->timer, jiffies + uart->timeout);
|
|
|
|
else
|
|
|
|
del_timer(&uart->timer);
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void omap_uart_allow_sleep(struct omap_uart_state *uart)
|
|
|
|
{
|
2009-04-28 02:27:36 +07:00
|
|
|
if (device_may_wakeup(&uart->pdev.dev))
|
|
|
|
omap_uart_enable_wakeup(uart);
|
|
|
|
else
|
|
|
|
omap_uart_disable_wakeup(uart);
|
|
|
|
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
if (!uart->clocked)
|
|
|
|
return;
|
|
|
|
|
|
|
|
omap_uart_smart_idle_enable(uart, 1);
|
|
|
|
uart->can_sleep = 1;
|
|
|
|
del_timer(&uart->timer);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void omap_uart_idle_timer(unsigned long data)
|
|
|
|
{
|
|
|
|
struct omap_uart_state *uart = (struct omap_uart_state *)data;
|
|
|
|
|
|
|
|
omap_uart_allow_sleep(uart);
|
|
|
|
}
|
|
|
|
|
|
|
|
void omap_uart_prepare_idle(int num)
|
|
|
|
{
|
|
|
|
struct omap_uart_state *uart;
|
|
|
|
|
|
|
|
list_for_each_entry(uart, &uart_list, node) {
|
|
|
|
if (num == uart->num && uart->can_sleep) {
|
|
|
|
omap_uart_disable_clocks(uart);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void omap_uart_resume_idle(int num)
|
|
|
|
{
|
|
|
|
struct omap_uart_state *uart;
|
|
|
|
|
|
|
|
list_for_each_entry(uart, &uart_list, node) {
|
|
|
|
if (num == uart->num) {
|
|
|
|
omap_uart_enable_clocks(uart);
|
|
|
|
|
|
|
|
/* Check for IO pad wakeup */
|
|
|
|
if (cpu_is_omap34xx() && uart->padconf) {
|
|
|
|
u16 p = omap_ctrl_readw(uart->padconf);
|
|
|
|
|
|
|
|
if (p & OMAP3_PADCONF_WAKEUPEVENT0)
|
|
|
|
omap_uart_block_sleep(uart);
|
2008-10-06 19:49:15 +07:00
|
|
|
}
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
|
|
|
|
/* Check for normal UART wakeup */
|
|
|
|
if (__raw_readl(uart->wk_st) & uart->wk_mask)
|
|
|
|
omap_uart_block_sleep(uart);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void omap_uart_prepare_suspend(void)
|
|
|
|
{
|
|
|
|
struct omap_uart_state *uart;
|
|
|
|
|
|
|
|
list_for_each_entry(uart, &uart_list, node) {
|
|
|
|
omap_uart_allow_sleep(uart);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int omap_uart_can_sleep(void)
|
|
|
|
{
|
|
|
|
struct omap_uart_state *uart;
|
|
|
|
int can_sleep = 1;
|
|
|
|
|
|
|
|
list_for_each_entry(uart, &uart_list, node) {
|
|
|
|
if (!uart->clocked)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!uart->can_sleep) {
|
|
|
|
can_sleep = 0;
|
|
|
|
continue;
|
2008-10-06 19:49:15 +07:00
|
|
|
}
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
|
|
|
|
/* This UART can now safely sleep. */
|
|
|
|
omap_uart_allow_sleep(uart);
|
2008-10-06 19:49:15 +07:00
|
|
|
}
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
|
|
|
|
return can_sleep;
|
2008-10-06 19:49:15 +07:00
|
|
|
}
|
|
|
|
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
/**
|
|
|
|
* omap_uart_interrupt()
|
|
|
|
*
|
|
|
|
* This handler is used only to detect that *any* UART interrupt has
|
|
|
|
* occurred. It does _nothing_ to handle the interrupt. Rather,
|
|
|
|
* any UART interrupt will trigger the inactivity timer so the
|
|
|
|
* UART will not idle or sleep for its timeout period.
|
|
|
|
*
|
|
|
|
**/
|
|
|
|
static irqreturn_t omap_uart_interrupt(int irq, void *dev_id)
|
|
|
|
{
|
|
|
|
struct omap_uart_state *uart = dev_id;
|
|
|
|
|
|
|
|
omap_uart_block_sleep(uart);
|
|
|
|
|
|
|
|
return IRQ_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void omap_uart_idle_init(struct omap_uart_state *uart)
|
|
|
|
{
|
|
|
|
struct plat_serial8250_port *p = uart->p;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
uart->can_sleep = 0;
|
2009-04-28 02:27:36 +07:00
|
|
|
uart->timeout = DEFAULT_TIMEOUT;
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
setup_timer(&uart->timer, omap_uart_idle_timer,
|
|
|
|
(unsigned long) uart);
|
2010-02-02 03:34:31 +07:00
|
|
|
if (uart->timeout)
|
|
|
|
mod_timer(&uart->timer, jiffies + uart->timeout);
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
omap_uart_smart_idle_enable(uart, 0);
|
|
|
|
|
|
|
|
if (cpu_is_omap34xx()) {
|
|
|
|
u32 mod = (uart->num == 2) ? OMAP3430_PER_MOD : CORE_MOD;
|
|
|
|
u32 wk_mask = 0;
|
|
|
|
u32 padconf = 0;
|
|
|
|
|
|
|
|
uart->wk_en = OMAP34XX_PRM_REGADDR(mod, PM_WKEN1);
|
|
|
|
uart->wk_st = OMAP34XX_PRM_REGADDR(mod, PM_WKST1);
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
uart->wk_mask = wk_mask;
|
|
|
|
uart->padconf = padconf;
|
|
|
|
} else if (cpu_is_omap24xx()) {
|
|
|
|
u32 wk_mask = 0;
|
|
|
|
|
|
|
|
if (cpu_is_omap2430()) {
|
|
|
|
uart->wk_en = OMAP2430_PRM_REGADDR(CORE_MOD, PM_WKEN1);
|
|
|
|
uart->wk_st = OMAP2430_PRM_REGADDR(CORE_MOD, PM_WKST1);
|
|
|
|
} else if (cpu_is_omap2420()) {
|
|
|
|
uart->wk_en = OMAP2420_PRM_REGADDR(CORE_MOD, PM_WKEN1);
|
|
|
|
uart->wk_st = OMAP2420_PRM_REGADDR(CORE_MOD, PM_WKST1);
|
|
|
|
}
|
|
|
|
switch (uart->num) {
|
|
|
|
case 0:
|
|
|
|
wk_mask = OMAP24XX_ST_UART1_MASK;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
wk_mask = OMAP24XX_ST_UART2_MASK;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
wk_mask = OMAP24XX_ST_UART3_MASK;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
uart->wk_mask = wk_mask;
|
|
|
|
} else {
|
|
|
|
uart->wk_en = 0;
|
|
|
|
uart->wk_st = 0;
|
|
|
|
uart->wk_mask = 0;
|
|
|
|
uart->padconf = 0;
|
|
|
|
}
|
|
|
|
|
2009-08-29 01:24:08 +07:00
|
|
|
p->irqflags |= IRQF_SHARED;
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
ret = request_irq(p->irq, omap_uart_interrupt, IRQF_SHARED,
|
|
|
|
"serial idle", (void *)uart);
|
|
|
|
WARN_ON(ret);
|
|
|
|
}
|
|
|
|
|
2009-03-05 21:32:23 +07:00
|
|
|
void omap_uart_enable_irqs(int enable)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct omap_uart_state *uart;
|
|
|
|
|
|
|
|
list_for_each_entry(uart, &uart_list, node) {
|
|
|
|
if (enable)
|
|
|
|
ret = request_irq(uart->p->irq, omap_uart_interrupt,
|
|
|
|
IRQF_SHARED, "serial idle", (void *)uart);
|
|
|
|
else
|
|
|
|
free_irq(uart->p->irq, (void *)uart);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-28 02:27:36 +07:00
|
|
|
static ssize_t sleep_timeout_show(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
2008-12-09 18:36:50 +07:00
|
|
|
char *buf)
|
|
|
|
{
|
2009-04-28 02:27:36 +07:00
|
|
|
struct platform_device *pdev = container_of(dev,
|
|
|
|
struct platform_device, dev);
|
|
|
|
struct omap_uart_state *uart = container_of(pdev,
|
|
|
|
struct omap_uart_state, pdev);
|
|
|
|
|
|
|
|
return sprintf(buf, "%u\n", uart->timeout / HZ);
|
2008-12-09 18:36:50 +07:00
|
|
|
}
|
|
|
|
|
2009-04-28 02:27:36 +07:00
|
|
|
static ssize_t sleep_timeout_store(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
2008-12-09 18:36:50 +07:00
|
|
|
const char *buf, size_t n)
|
|
|
|
{
|
2009-04-28 02:27:36 +07:00
|
|
|
struct platform_device *pdev = container_of(dev,
|
|
|
|
struct platform_device, dev);
|
|
|
|
struct omap_uart_state *uart = container_of(pdev,
|
|
|
|
struct omap_uart_state, pdev);
|
2008-12-09 18:36:50 +07:00
|
|
|
unsigned int value;
|
|
|
|
|
|
|
|
if (sscanf(buf, "%u", &value) != 1) {
|
2010-03-10 02:22:14 +07:00
|
|
|
dev_err(dev, "sleep_timeout_store: Invalid value\n");
|
2008-12-09 18:36:50 +07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2009-04-28 02:27:36 +07:00
|
|
|
|
|
|
|
uart->timeout = value * HZ;
|
|
|
|
if (uart->timeout)
|
|
|
|
mod_timer(&uart->timer, jiffies + uart->timeout);
|
|
|
|
else
|
|
|
|
/* A zero value means disable timeout feature */
|
|
|
|
omap_uart_block_sleep(uart);
|
|
|
|
|
2008-12-09 18:36:50 +07:00
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2009-04-28 02:27:36 +07:00
|
|
|
DEVICE_ATTR(sleep_timeout, 0644, sleep_timeout_show, sleep_timeout_store);
|
|
|
|
#define DEV_CREATE_FILE(dev, attr) WARN_ON(device_create_file(dev, attr))
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
#else
|
|
|
|
static inline void omap_uart_idle_init(struct omap_uart_state *uart) {}
|
2009-04-28 02:27:36 +07:00
|
|
|
#define DEV_CREATE_FILE(dev, attr)
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
#endif /* CONFIG_PM */
|
|
|
|
|
2009-11-23 01:10:47 +07:00
|
|
|
static struct omap_uart_state omap_uart[] = {
|
2009-04-28 02:27:36 +07:00
|
|
|
{
|
|
|
|
.pdev = {
|
|
|
|
.name = "serial8250",
|
|
|
|
.id = PLAT8250_DEV_PLATFORM,
|
|
|
|
.dev = {
|
|
|
|
.platform_data = serial_platform_data0,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}, {
|
|
|
|
.pdev = {
|
|
|
|
.name = "serial8250",
|
|
|
|
.id = PLAT8250_DEV_PLATFORM1,
|
|
|
|
.dev = {
|
|
|
|
.platform_data = serial_platform_data1,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}, {
|
|
|
|
.pdev = {
|
|
|
|
.name = "serial8250",
|
|
|
|
.id = PLAT8250_DEV_PLATFORM2,
|
|
|
|
.dev = {
|
|
|
|
.platform_data = serial_platform_data2,
|
|
|
|
},
|
|
|
|
},
|
2009-05-29 04:03:59 +07:00
|
|
|
},
|
2010-02-16 00:27:25 +07:00
|
|
|
#if defined(CONFIG_ARCH_OMAP3) || defined(CONFIG_ARCH_OMAP4)
|
2009-08-22 15:00:11 +07:00
|
|
|
{
|
|
|
|
.pdev = {
|
|
|
|
.name = "serial8250",
|
2009-09-25 06:23:07 +07:00
|
|
|
.id = 3,
|
2009-08-22 15:00:11 +07:00
|
|
|
.dev = {
|
|
|
|
.platform_data = serial_platform_data3,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
#endif
|
2009-05-29 04:03:59 +07:00
|
|
|
};
|
|
|
|
|
2009-12-12 07:16:37 +07:00
|
|
|
/*
|
|
|
|
* 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;
|
2010-01-09 01:29:06 +07:00
|
|
|
lsr = __serial_read_reg(up, UART_LSR);
|
2009-12-12 07:16:37 +07:00
|
|
|
if (!(lsr & UART_LSR_DR))
|
|
|
|
return -EPERM;
|
|
|
|
}
|
2010-01-09 01:29:06 +07:00
|
|
|
|
|
|
|
return __serial_read_reg(up, offset);
|
2009-12-12 07:16:37 +07:00
|
|
|
}
|
|
|
|
|
2010-02-18 15:59:06 +07:00
|
|
|
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);
|
|
|
|
}
|
2009-09-04 00:14:02 +07:00
|
|
|
void __init omap_serial_early_init(void)
|
2005-11-10 21:26:51 +07:00
|
|
|
{
|
2010-02-25 16:40:19 +07:00
|
|
|
int i, nr_ports;
|
2008-10-06 19:49:15 +07:00
|
|
|
char name[16];
|
2005-11-10 21:26:51 +07:00
|
|
|
|
2010-02-25 16:40:19 +07:00
|
|
|
if (!(cpu_is_omap3630() || cpu_is_omap4430()))
|
|
|
|
nr_ports = 3;
|
|
|
|
else
|
|
|
|
nr_ports = ARRAY_SIZE(omap_uart);
|
|
|
|
|
2005-11-10 21:26:51 +07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2010-02-25 16:40:19 +07:00
|
|
|
for (i = 0; i < nr_ports; i++) {
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
struct omap_uart_state *uart = &omap_uart[i];
|
2009-04-28 02:27:36 +07:00
|
|
|
struct platform_device *pdev = &uart->pdev;
|
|
|
|
struct device *dev = &pdev->dev;
|
|
|
|
struct plat_serial8250_port *p = dev->platform_data;
|
2005-11-10 21:26:51 +07:00
|
|
|
|
2010-02-28 03:13:43 +07:00
|
|
|
/* Don't map zero-based physical address */
|
|
|
|
if (p->mapbase == 0) {
|
2010-03-10 02:22:14 +07:00
|
|
|
dev_warn(dev, "no physical address for uart#%d,"
|
|
|
|
" so skipping early_init...\n", i);
|
2010-02-28 03:13:43 +07:00
|
|
|
continue;
|
|
|
|
}
|
2009-10-16 23:53:00 +07:00
|
|
|
/*
|
|
|
|
* Module 4KB + L4 interconnect 4KB
|
|
|
|
* Static mapping, never released
|
|
|
|
*/
|
|
|
|
p->membase = ioremap(p->mapbase, SZ_8K);
|
|
|
|
if (!p->membase) {
|
2010-03-10 02:22:14 +07:00
|
|
|
dev_err(dev, "ioremap failed for uart%i\n", i + 1);
|
2009-10-16 23:53:00 +07:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2010-02-25 16:40:19 +07:00
|
|
|
sprintf(name, "uart%d_ick", i + 1);
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
uart->ick = clk_get(NULL, name);
|
|
|
|
if (IS_ERR(uart->ick)) {
|
2010-03-10 02:22:14 +07:00
|
|
|
dev_err(dev, "Could not get uart%d_ick\n", i + 1);
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
uart->ick = NULL;
|
|
|
|
}
|
2008-10-06 19:49:15 +07:00
|
|
|
|
|
|
|
sprintf(name, "uart%d_fck", i+1);
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
uart->fck = clk_get(NULL, name);
|
|
|
|
if (IS_ERR(uart->fck)) {
|
2010-03-10 02:22:14 +07:00
|
|
|
dev_err(dev, "Could not get uart%d_fck\n", i + 1);
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
uart->fck = NULL;
|
|
|
|
}
|
|
|
|
|
2009-08-22 15:00:12 +07:00
|
|
|
/* FIXME: Remove this once the clkdev is ready */
|
|
|
|
if (!cpu_is_omap44xx()) {
|
|
|
|
if (!uart->ick || !uart->fck)
|
|
|
|
continue;
|
|
|
|
}
|
OMAP3: PM: UART: disable clocks when idle and off-mode support
This patch allows the UART clocks to be disabled when the OMAP UARTs
are inactive, thus permitting the chip to hit retention in idle.
After the expiration of an activity timer, each UART is allowed to
disable its clocks so the system can enter retention. The activity
timer is (re)activated on any UART interrupt, UART wake event or any
IO pad wakeup. The actual disable of the UART clocks is done in the
'prepare_idle' hook called from the OMAP idle loop.
While the activity timer is active, the smart-idle mode of the UART is
also disabled. This is due to a "feature" of the UART module that
after a UART wakeup, the smart-idle mode may be entered before the
UART has communicated the interrupt, or upon TX, an idle mode may be
entered before the TX FIFOs are emptied.
Upon suspend, the 'prepare_suspend' hook cancels any pending activity
timers and allows the clocks to be disabled immediately.
In addition, upon disabling clocks the UART state is saved in case
of an off-mode transition while clocks are off.
Special thanks to Tero Kristo for the initial ideas and first versions
of UART idle support, and to Jouni Hogander for extra testing and
bugfixes.
Tested on OMAP3 (Beagle, RX51, SDP, EVM) and OMAP2 (n810)
Cc: Tero Kristo <tero.kristo@nokia.com>
Cc: Jouni Hogander <jouni.hogander@nokia.com>
Signed-off-by: Kevin Hilman <khilman@deeprootsystems.com>
2009-02-05 01:51:40 +07:00
|
|
|
|
|
|
|
uart->num = i;
|
|
|
|
p->private_data = uart;
|
|
|
|
uart->p = p;
|
2005-11-10 21:26:51 +07:00
|
|
|
|
2009-06-25 00:32:03 +07:00
|
|
|
if (cpu_is_omap44xx())
|
|
|
|
p->irq += 32;
|
2009-09-04 00:14:02 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-12 07:16:35 +07:00
|
|
|
/**
|
|
|
|
* 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)
|
2009-09-04 00:14:02 +07:00
|
|
|
{
|
2009-12-12 07:16:35 +07:00
|
|
|
struct omap_uart_state *uart;
|
|
|
|
struct platform_device *pdev;
|
|
|
|
struct device *dev;
|
2009-09-04 00:14:02 +07:00
|
|
|
|
2009-12-12 07:16:35 +07:00
|
|
|
BUG_ON(port < 0);
|
|
|
|
BUG_ON(port >= ARRAY_SIZE(omap_uart));
|
2009-09-04 00:14:02 +07:00
|
|
|
|
2009-12-12 07:16:35 +07:00
|
|
|
uart = &omap_uart[port];
|
|
|
|
pdev = &uart->pdev;
|
|
|
|
dev = &pdev->dev;
|
2009-05-29 05:44:54 +07:00
|
|
|
|
2010-02-28 03:13:43 +07:00
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
2009-12-14 20:59:18 +07:00
|
|
|
omap_uart_enable_clocks(uart);
|
|
|
|
|
2009-12-12 07:16:35 +07:00
|
|
|
omap_uart_reset(uart);
|
|
|
|
omap_uart_idle_init(uart);
|
|
|
|
|
2009-12-14 20:59:18 +07:00
|
|
|
list_add_tail(&uart->node, &uart_list);
|
|
|
|
|
2009-12-12 07:16:35 +07:00
|
|
|
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);
|
2009-04-28 02:27:36 +07:00
|
|
|
}
|
2009-12-12 07:16:35 +07:00
|
|
|
|
2010-02-16 01:03:33 +07:00
|
|
|
/*
|
|
|
|
* omap44xx: Never read empty UART fifo
|
|
|
|
* omap3xxx: Never read empty UART fifo on UARTs
|
|
|
|
* with IP rev >=0x52
|
|
|
|
*/
|
2010-02-18 15:59:06 +07:00
|
|
|
if (cpu_is_omap44xx()) {
|
2010-02-16 01:03:33 +07:00
|
|
|
uart->p->serial_in = serial_in_override;
|
2010-02-18 15:59:06 +07:00
|
|
|
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) {
|
2010-02-16 01:03:33 +07:00
|
|
|
uart->p->serial_in = serial_in_override;
|
2010-02-18 15:59:06 +07:00
|
|
|
uart->p->serial_out = serial_out_override;
|
|
|
|
}
|
2009-12-12 07:16:35 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2010-02-16 00:27:25 +07:00
|
|
|
int i, nr_ports;
|
|
|
|
|
|
|
|
if (!(cpu_is_omap3630() || cpu_is_omap4430()))
|
|
|
|
nr_ports = 3;
|
|
|
|
else
|
|
|
|
nr_ports = ARRAY_SIZE(omap_uart);
|
2009-12-12 07:16:35 +07:00
|
|
|
|
2010-02-16 00:27:25 +07:00
|
|
|
for (i = 0; i < nr_ports; i++)
|
2009-12-12 07:16:35 +07:00
|
|
|
omap_serial_init_port(i);
|
2005-11-10 21:26:51 +07:00
|
|
|
}
|