[linux-2.6-block.git] / arch / arm / plat-omap / common.c

/*
 * linux/arch/arm/plat-omap/common.c
 *
 * Code common to all OMAP machines.
 * The file is created by Tony Lindgren <tony@atomide.com>
 *
 * Copyright (C) 2009 Texas Instruments
 * Added OMAP4 support - Santosh Shilimkar <santosh.shilimkar@ti.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/console.h>
#include <linux/serial.h>
#include <linux/tty.h>
#include <linux/serial_8250.h>
#include <linux/serial_reg.h>
#include <linux/clk.h>
#include <linux/io.h>

#include <mach/hardware.h>
#include <asm/system.h>
#include <asm/pgtable.h>
#include <asm/mach/map.h>
#include <asm/setup.h>

#include <plat/common.h>
#include <plat/board.h>
#include <plat/control.h>
#include <plat/mux.h>
#include <plat/fpga.h>

#include <plat/clock.h>

#if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
# include "../mach-omap2/sdrc.h"
#endif

#define NO_LENGTH_CHECK 0xffffffff

unsigned char omap_bootloader_tag[512];
int omap_bootloader_tag_len;

struct omap_board_config_kernel *omap_board_config;
int omap_board_config_size;

/* used by omap-smp.c and board-4430sdp.c */
void __iomem *gic_cpu_base_addr;

static const void *get_config(u16 tag, size_t len, int skip, size_t *len_out)
{
	struct omap_board_config_kernel *kinfo = NULL;
	int i;

	/* Try to find the config from the board-specific structures
	 * in the kernel. */
	for (i = 0; i < omap_board_config_size; i++) {
		if (omap_board_config[i].tag == tag) {
			if (skip == 0) {
				kinfo = &omap_board_config[i];
				break;
			} else {
				skip--;
			}
		}
	}
	if (kinfo == NULL)
		return NULL;
	return kinfo->data;
}

const void *__omap_get_config(u16 tag, size_t len, int nr)
{
        return get_config(tag, len, nr, NULL);
}
EXPORT_SYMBOL(__omap_get_config);

const void *omap_get_var_config(u16 tag, size_t *len)
{
        return get_config(tag, NO_LENGTH_CHECK, 0, len);
}
EXPORT_SYMBOL(omap_get_var_config);

/*
 * 32KHz clocksource ... always available, on pretty most chips except
 * OMAP 730 and 1510.  Other timers could be used as clocksources, with
 * higher resolution in free-running counter modes (e.g. 12 MHz xtal),
 * but systems won't necessarily want to spend resources that way.
 */

#define OMAP16XX_TIMER_32K_SYNCHRONIZED		0xfffbc410

#if !(defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP15XX))

#include <linux/clocksource.h>

#ifdef CONFIG_ARCH_OMAP16XX
static cycle_t omap16xx_32k_read(struct clocksource *cs)
{
	return omap_readl(OMAP16XX_TIMER_32K_SYNCHRONIZED);
}
#else
#define omap16xx_32k_read	NULL
#endif

#ifdef CONFIG_ARCH_OMAP2420
static cycle_t omap2420_32k_read(struct clocksource *cs)
{
	return omap_readl(OMAP2420_32KSYNCT_BASE + 0x10);
}
#else
#define omap2420_32k_read	NULL
#endif

#ifdef CONFIG_ARCH_OMAP2430
static cycle_t omap2430_32k_read(struct clocksource *cs)
{
	return omap_readl(OMAP2430_32KSYNCT_BASE + 0x10);
}
#else
#define omap2430_32k_read	NULL
#endif

#ifdef CONFIG_ARCH_OMAP34XX
static cycle_t omap34xx_32k_read(struct clocksource *cs)
{
	return omap_readl(OMAP3430_32KSYNCT_BASE + 0x10);
}
#else
#define omap34xx_32k_read	NULL
#endif

#ifdef CONFIG_ARCH_OMAP4
static cycle_t omap44xx_32k_read(struct clocksource *cs)
{
	return omap_readl(OMAP4430_32KSYNCT_BASE + 0x10);
}
#else
#define omap44xx_32k_read	NULL
#endif

/*
 * Kernel assumes that sched_clock can be called early but may not have
 * things ready yet.
 */
static cycle_t omap_32k_read_dummy(struct clocksource *cs)
{
	return 0;
}

static struct clocksource clocksource_32k = {
	.name		= "32k_counter",
	.rating		= 250,
	.read		= omap_32k_read_dummy,
	.mask		= CLOCKSOURCE_MASK(32),
	.shift		= 10,
	.flags		= CLOCK_SOURCE_IS_CONTINUOUS,
};

/*
 * Returns current time from boot in nsecs. It's OK for this to wrap
 * around for now, as it's just a relative time stamp.
 */
unsigned long long sched_clock(void)
{
	return clocksource_cyc2ns(clocksource_32k.read(&clocksource_32k),
				  clocksource_32k.mult, clocksource_32k.shift);
}

static int __init omap_init_clocksource_32k(void)
{
	static char err[] __initdata = KERN_ERR
			"%s: can't register clocksource!\n";

	if (cpu_is_omap16xx() || cpu_class_is_omap2()) {
		struct clk *sync_32k_ick;

		if (cpu_is_omap16xx())
			clocksource_32k.read = omap16xx_32k_read;
		else if (cpu_is_omap2420())
			clocksource_32k.read = omap2420_32k_read;
		else if (cpu_is_omap2430())
			clocksource_32k.read = omap2430_32k_read;
		else if (cpu_is_omap34xx())
			clocksource_32k.read = omap34xx_32k_read;
		else if (cpu_is_omap44xx())
			clocksource_32k.read = omap44xx_32k_read;
		else
			return -ENODEV;

		sync_32k_ick = clk_get(NULL, "omap_32ksync_ick");
		if (sync_32k_ick)
			clk_enable(sync_32k_ick);

		clocksource_32k.mult = clocksource_hz2mult(32768,
					    clocksource_32k.shift);

		if (clocksource_register(&clocksource_32k))
			printk(err, clocksource_32k.name);
	}
	return 0;
}
arch_initcall(omap_init_clocksource_32k);

#endif	/* !(defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP15XX)) */

/* Global address base setup code */

#if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)

static void __init __omap2_set_globals(struct omap_globals *omap2_globals)
{
	omap2_set_globals_tap(omap2_globals);
	omap2_set_globals_sdrc(omap2_globals);
	omap2_set_globals_control(omap2_globals);
	omap2_set_globals_prcm(omap2_globals);
}

#endif

#if defined(CONFIG_ARCH_OMAP2420)

static struct omap_globals omap242x_globals = {
	.class	= OMAP242X_CLASS,
	.tap	= OMAP2_L4_IO_ADDRESS(0x48014000),
	.sdrc	= OMAP2_L3_IO_ADDRESS(OMAP2420_SDRC_BASE),
	.sms	= OMAP2_L3_IO_ADDRESS(OMAP2420_SMS_BASE),
	.ctrl	= OMAP2_L4_IO_ADDRESS(OMAP2420_CTRL_BASE),
	.prm	= OMAP2_L4_IO_ADDRESS(OMAP2420_PRM_BASE),
	.cm	= OMAP2_L4_IO_ADDRESS(OMAP2420_CM_BASE),
};

void __init omap2_set_globals_242x(void)
{
	__omap2_set_globals(&omap242x_globals);
}
#endif

#if defined(CONFIG_ARCH_OMAP2430)

static struct omap_globals omap243x_globals = {
	.class	= OMAP243X_CLASS,
	.tap	= OMAP2_L4_IO_ADDRESS(0x4900a000),
	.sdrc	= OMAP2_L3_IO_ADDRESS(OMAP243X_SDRC_BASE),
	.sms	= OMAP2_L3_IO_ADDRESS(OMAP243X_SMS_BASE),
	.ctrl	= OMAP2_L4_IO_ADDRESS(OMAP243X_CTRL_BASE),
	.prm	= OMAP2_L4_IO_ADDRESS(OMAP2430_PRM_BASE),
	.cm	= OMAP2_L4_IO_ADDRESS(OMAP2430_CM_BASE),
};

void __init omap2_set_globals_243x(void)
{
	__omap2_set_globals(&omap243x_globals);
}
#endif

#if defined(CONFIG_ARCH_OMAP3430)

static struct omap_globals omap343x_globals = {
	.class	= OMAP343X_CLASS,
	.tap	= OMAP2_L4_IO_ADDRESS(0x4830A000),
	.sdrc	= OMAP2_L3_IO_ADDRESS(OMAP343X_SDRC_BASE),
	.sms	= OMAP2_L3_IO_ADDRESS(OMAP343X_SMS_BASE),
	.ctrl	= OMAP2_L4_IO_ADDRESS(OMAP343X_CTRL_BASE),
	.prm	= OMAP2_L4_IO_ADDRESS(OMAP3430_PRM_BASE),
	.cm	= OMAP2_L4_IO_ADDRESS(OMAP3430_CM_BASE),
};

void __init omap2_set_globals_343x(void)
{
	__omap2_set_globals(&omap343x_globals);
}
#endif

#if defined(CONFIG_ARCH_OMAP4)
static struct omap_globals omap4_globals = {
	.class	= OMAP443X_CLASS,
	.tap	= OMAP2_L4_IO_ADDRESS(OMAP443X_SCM_BASE),
	.ctrl	= OMAP2_L4_IO_ADDRESS(OMAP443X_CTRL_BASE),
	.prm	= OMAP2_L4_IO_ADDRESS(OMAP4430_PRM_BASE),
	.cm	= OMAP2_L4_IO_ADDRESS(OMAP4430_CM_BASE),
	.cm2	= OMAP2_L4_IO_ADDRESS(OMAP4430_CM2_BASE),
};

void __init omap2_set_globals_443x(void)
{
	omap2_set_globals_tap(&omap4_globals);
	omap2_set_globals_control(&omap4_globals);
	omap2_set_globals_prcm(&omap4_globals);
}
#endif
Commit	Line	Data
5e1c5ff4 TL	1	/*
	2	* linux/arch/arm/plat-omap/common.c
	3	*
	4	* Code common to all OMAP machines.
44169075 SS	5	* The file is created by Tony Lindgren <tony@atomide.com>
	6	*
	7	* Copyright (C) 2009 Texas Instruments
	8	* Added OMAP4 support - Santosh Shilimkar <santosh.shilimkar@ti.com>
5e1c5ff4 TL	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License version 2 as
	12	* published by the Free Software Foundation.
	13	*/
5e1c5ff4 TL	14	#include <linux/module.h>
	15	#include <linux/kernel.h>
	16	#include <linux/init.h>
	17	#include <linux/delay.h>
5e1c5ff4 TL	18	#include <linux/console.h>
	19	#include <linux/serial.h>
	20	#include <linux/tty.h>
	21	#include <linux/serial_8250.h>
	22	#include <linux/serial_reg.h>
f8ce2547	23	#include <linux/clk.h>
fced80c7	24	#include <linux/io.h>
5e1c5ff4	25
a09e64fb	26	#include <mach/hardware.h>
5e1c5ff4 TL	27	#include <asm/system.h>
	28	#include <asm/pgtable.h>
	29	#include <asm/mach/map.h>
92105bb7	30	#include <asm/setup.h>
5e1c5ff4	31
ce491cf8 TL	32	#include <plat/common.h>
	33	#include <plat/board.h>
	34	#include <plat/control.h>
	35	#include <plat/mux.h>
	36	#include <plat/fpga.h>
5e1c5ff4	37
ce491cf8	38	#include <plat/clock.h>
5e1c5ff4	39
44595982 PW	40	#if defined(CONFIG_ARCH_OMAP2) \|\| defined(CONFIG_ARCH_OMAP3)
	41	# include "../mach-omap2/sdrc.h"
	42	#endif
	43
5e1c5ff4 TL	44	#define NO_LENGTH_CHECK 0xffffffff
5e1c5ff4 TL	45
92105bb7 TL	46	unsigned char omap_bootloader_tag[512];
92105bb7 TL	47	int omap_bootloader_tag_len;
5e1c5ff4 TL	48
5e1c5ff4 TL	49	struct omap_board_config_kernel *omap_board_config;
92105bb7	50	int omap_board_config_size;
5e1c5ff4	51
e4e7a13a TL	52	/* used by omap-smp.c and board-4430sdp.c */
	53	void __iomem *gic_cpu_base_addr;
	54
5e1c5ff4 TL	55	static const void get_config(u16 tag, size_t len, int skip, size_t len_out)
	56	{
	57	struct omap_board_config_kernel *kinfo = NULL;
	58	int i;
	59
5e1c5ff4 TL	60	/* Try to find the config from the board-specific structures
	61	* in the kernel. */
	62	for (i = 0; i < omap_board_config_size; i++) {
	63	if (omap_board_config[i].tag == tag) {
c40fae95 TL	64	if (skip == 0) {
	65	kinfo = &omap_board_config[i];
	66	break;
	67	} else {
	68	skip--;
	69	}
5e1c5ff4 TL	70	}
	71	}
	72	if (kinfo == NULL)
	73	return NULL;
	74	return kinfo->data;
	75	}
	76
	77	const void *__omap_get_config(u16 tag, size_t len, int nr)
	78	{
	79	return get_config(tag, len, nr, NULL);
	80	}
	81	EXPORT_SYMBOL(__omap_get_config);
	82
	83	const void omap_get_var_config(u16 tag, size_t len)
	84	{
	85	return get_config(tag, NO_LENGTH_CHECK, 0, len);
	86	}
	87	EXPORT_SYMBOL(omap_get_var_config);
	88
075192ae KH	89	/*
	90	* 32KHz clocksource ... always available, on pretty most chips except
	91	* OMAP 730 and 1510. Other timers could be used as clocksources, with
	92	* higher resolution in free-running counter modes (e.g. 12 MHz xtal),
	93	* but systems won't necessarily want to spend resources that way.
	94	*/
	95
a4ab0d83	96	#define OMAP16XX_TIMER_32K_SYNCHRONIZED 0xfffbc410
075192ae	97
a4ab0d83	98	#if !(defined(CONFIG_ARCH_OMAP730) \|\| defined(CONFIG_ARCH_OMAP15XX))
075192ae KH	99
	100	#include <linux/clocksource.h>
	101
a4ab0d83 TL	102	#ifdef CONFIG_ARCH_OMAP16XX
	103	static cycle_t omap16xx_32k_read(struct clocksource *cs)
	104	{
	105	return omap_readl(OMAP16XX_TIMER_32K_SYNCHRONIZED);
	106	}
	107	#else
	108	#define omap16xx_32k_read NULL
	109	#endif
	110
	111	#ifdef CONFIG_ARCH_OMAP2420
	112	static cycle_t omap2420_32k_read(struct clocksource *cs)
	113	{
	114	return omap_readl(OMAP2420_32KSYNCT_BASE + 0x10);
	115	}
	116	#else
	117	#define omap2420_32k_read NULL
	118	#endif
	119
	120	#ifdef CONFIG_ARCH_OMAP2430
	121	static cycle_t omap2430_32k_read(struct clocksource *cs)
	122	{
	123	return omap_readl(OMAP2430_32KSYNCT_BASE + 0x10);
	124	}
	125	#else
	126	#define omap2430_32k_read NULL
	127	#endif
	128
	129	#ifdef CONFIG_ARCH_OMAP34XX
	130	static cycle_t omap34xx_32k_read(struct clocksource *cs)
075192ae	131	{
a4ab0d83 TL	132	return omap_readl(OMAP3430_32KSYNCT_BASE + 0x10);
	133	}
	134	#else
	135	#define omap34xx_32k_read NULL
	136	#endif
	137
44169075 SS	138	#ifdef CONFIG_ARCH_OMAP4
	139	static cycle_t omap44xx_32k_read(struct clocksource *cs)
	140	{
	141	return omap_readl(OMAP4430_32KSYNCT_BASE + 0x10);
	142	}
	143	#else
	144	#define omap44xx_32k_read NULL
	145	#endif
	146
a4ab0d83 TL	147	/*
	148	* Kernel assumes that sched_clock can be called early but may not have
	149	* things ready yet.
	150	*/
	151	static cycle_t omap_32k_read_dummy(struct clocksource *cs)
	152	{
	153	return 0;
075192ae KH	154	}
	155
	156	static struct clocksource clocksource_32k = {
	157	.name = "32k_counter",
	158	.rating = 250,
a4ab0d83	159	.read = omap_32k_read_dummy,
075192ae KH	160	.mask = CLOCKSOURCE_MASK(32),
	161	.shift = 10,
	162	.flags = CLOCK_SOURCE_IS_CONTINUOUS,
	163	};
	164
f258b0c6 KH	165	/*
	166	* Returns current time from boot in nsecs. It's OK for this to wrap
	167	* around for now, as it's just a relative time stamp.
	168	*/
	169	unsigned long long sched_clock(void)
	170	{
0a544198 MS	171	return clocksource_cyc2ns(clocksource_32k.read(&clocksource_32k),
0a544198 MS	172	clocksource_32k.mult, clocksource_32k.shift);
f258b0c6 KH	173	}
f258b0c6 KH	174
075192ae KH	175	static int __init omap_init_clocksource_32k(void)
	176	{
	177	static char err[] __initdata = KERN_ERR
	178	"%s: can't register clocksource!\n";
	179
44595982 PW	180	if (cpu_is_omap16xx() \|\| cpu_class_is_omap2()) {
	181	struct clk *sync_32k_ick;
	182
a4ab0d83 TL	183	if (cpu_is_omap16xx())
	184	clocksource_32k.read = omap16xx_32k_read;
	185	else if (cpu_is_omap2420())
	186	clocksource_32k.read = omap2420_32k_read;
	187	else if (cpu_is_omap2430())
	188	clocksource_32k.read = omap2430_32k_read;
	189	else if (cpu_is_omap34xx())
	190	clocksource_32k.read = omap34xx_32k_read;
44169075 SS	191	else if (cpu_is_omap44xx())
44169075 SS	192	clocksource_32k.read = omap44xx_32k_read;
a4ab0d83 TL	193	else
	194	return -ENODEV;
	195
44595982 PW	196	sync_32k_ick = clk_get(NULL, "omap_32ksync_ick");
	197	if (sync_32k_ick)
	198	clk_enable(sync_32k_ick);
	199
075192ae KH	200	clocksource_32k.mult = clocksource_hz2mult(32768,
	201	clocksource_32k.shift);
	202
	203	if (clocksource_register(&clocksource_32k))
	204	printk(err, clocksource_32k.name);
	205	}
	206	return 0;
	207	}
	208	arch_initcall(omap_init_clocksource_32k);
	209
a4ab0d83	210	#endif /* !(defined(CONFIG_ARCH_OMAP730) \|\| defined(CONFIG_ARCH_OMAP15XX)) */
44595982 PW	211
	212	/* Global address base setup code */
	213
a58caad1 TL	214	#if defined(CONFIG_ARCH_OMAP2) \|\| defined(CONFIG_ARCH_OMAP3)
a58caad1 TL	215
8f9ccfee	216	static void __init __omap2_set_globals(struct omap_globals *omap2_globals)
a58caad1	217	{
0e564848	218	omap2_set_globals_tap(omap2_globals);
f2ab9977	219	omap2_set_globals_sdrc(omap2_globals);
a58caad1 TL	220	omap2_set_globals_control(omap2_globals);
	221	omap2_set_globals_prcm(omap2_globals);
	222	}
	223
	224	#endif
	225
44595982	226	#if defined(CONFIG_ARCH_OMAP2420)
a58caad1 TL	227
a58caad1 TL	228	static struct omap_globals omap242x_globals = {
0e564848	229	.class = OMAP242X_CLASS,
233fd64e SS	230	.tap = OMAP2_L4_IO_ADDRESS(0x48014000),
	231	.sdrc = OMAP2_L3_IO_ADDRESS(OMAP2420_SDRC_BASE),
	232	.sms = OMAP2_L3_IO_ADDRESS(OMAP2420_SMS_BASE),
	233	.ctrl = OMAP2_L4_IO_ADDRESS(OMAP2420_CTRL_BASE),
	234	.prm = OMAP2_L4_IO_ADDRESS(OMAP2420_PRM_BASE),
	235	.cm = OMAP2_L4_IO_ADDRESS(OMAP2420_CM_BASE),
a58caad1 TL	236	};
a58caad1 TL	237
44595982 PW	238	void __init omap2_set_globals_242x(void)
44595982 PW	239	{
8f9ccfee	240	__omap2_set_globals(&omap242x_globals);
44595982 PW	241	}
	242	#endif
	243
	244	#if defined(CONFIG_ARCH_OMAP2430)
a58caad1 TL	245
a58caad1 TL	246	static struct omap_globals omap243x_globals = {
0e564848	247	.class = OMAP243X_CLASS,
233fd64e SS	248	.tap = OMAP2_L4_IO_ADDRESS(0x4900a000),
	249	.sdrc = OMAP2_L3_IO_ADDRESS(OMAP243X_SDRC_BASE),
	250	.sms = OMAP2_L3_IO_ADDRESS(OMAP243X_SMS_BASE),
	251	.ctrl = OMAP2_L4_IO_ADDRESS(OMAP243X_CTRL_BASE),
	252	.prm = OMAP2_L4_IO_ADDRESS(OMAP2430_PRM_BASE),
	253	.cm = OMAP2_L4_IO_ADDRESS(OMAP2430_CM_BASE),
a58caad1 TL	254	};
a58caad1 TL	255
44595982 PW	256	void __init omap2_set_globals_243x(void)
44595982 PW	257	{
8f9ccfee	258	__omap2_set_globals(&omap243x_globals);
44595982 PW	259	}
	260	#endif
	261
	262	#if defined(CONFIG_ARCH_OMAP3430)
a58caad1 TL	263
a58caad1 TL	264	static struct omap_globals omap343x_globals = {
0e564848	265	.class = OMAP343X_CLASS,
233fd64e SS	266	.tap = OMAP2_L4_IO_ADDRESS(0x4830A000),
	267	.sdrc = OMAP2_L3_IO_ADDRESS(OMAP343X_SDRC_BASE),
	268	.sms = OMAP2_L3_IO_ADDRESS(OMAP343X_SMS_BASE),
	269	.ctrl = OMAP2_L4_IO_ADDRESS(OMAP343X_CTRL_BASE),
	270	.prm = OMAP2_L4_IO_ADDRESS(OMAP3430_PRM_BASE),
	271	.cm = OMAP2_L4_IO_ADDRESS(OMAP3430_CM_BASE),
a58caad1 TL	272	};
a58caad1 TL	273
44595982 PW	274	void __init omap2_set_globals_343x(void)
44595982 PW	275	{
8f9ccfee	276	__omap2_set_globals(&omap343x_globals);
44595982 PW	277	}
	278	#endif
	279
44169075 SS	280	#if defined(CONFIG_ARCH_OMAP4)
	281	static struct omap_globals omap4_globals = {
	282	.class = OMAP443X_CLASS,
b570e0ec	283	.tap = OMAP2_L4_IO_ADDRESS(OMAP443X_SCM_BASE),
233fd64e SS	284	.ctrl = OMAP2_L4_IO_ADDRESS(OMAP443X_CTRL_BASE),
	285	.prm = OMAP2_L4_IO_ADDRESS(OMAP4430_PRM_BASE),
	286	.cm = OMAP2_L4_IO_ADDRESS(OMAP4430_CM_BASE),
9ef89150	287	.cm2 = OMAP2_L4_IO_ADDRESS(OMAP4430_CM2_BASE),
44169075 SS	288	};
	289
	290	void __init omap2_set_globals_443x(void)
	291	{
	292	omap2_set_globals_tap(&omap4_globals);
	293	omap2_set_globals_control(&omap4_globals);
9ef89150	294	omap2_set_globals_prcm(&omap4_globals);
44169075 SS	295	}
	296	#endif
	297