[deliverable/linux.git] / arch / arm / mach-pxa / generic.c

/*
 *  linux/arch/arm/mach-pxa/generic.c
 *
 *  Author:	Nicolas Pitre
 *  Created:	Jun 15, 2001
 *  Copyright:	MontaVista Software Inc.
 *
 * Code common to all PXA machines.
 *
 * 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.
 *
 * Since this file should be linked before any other machine specific file,
 * the __initcall() here will be executed first.  This serves as default
 * initialization stuff for PXA machines which can be overridden later if
 * need be.
 */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/ioport.h>
#include <linux/pm.h>
#include <linux/string.h>

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

#include <asm/arch/pxa-regs.h>
#include <asm/arch/udc.h>
#include <asm/arch/pxafb.h>
#include <asm/arch/mmc.h>
#include <asm/arch/irda.h>
#include <asm/arch/i2c.h>

#include "generic.h"

/*
 * Handy function to set GPIO alternate functions
 */

void pxa_gpio_mode(int gpio_mode)
{
	unsigned long flags;
	int gpio = gpio_mode & GPIO_MD_MASK_NR;
	int fn = (gpio_mode & GPIO_MD_MASK_FN) >> 8;
	int gafr;

	local_irq_save(flags);
	if (gpio_mode & GPIO_DFLT_LOW)
		GPCR(gpio) = GPIO_bit(gpio);
	else if (gpio_mode & GPIO_DFLT_HIGH)
		GPSR(gpio) = GPIO_bit(gpio);
	if (gpio_mode & GPIO_MD_MASK_DIR)
		GPDR(gpio) |= GPIO_bit(gpio);
	else
		GPDR(gpio) &= ~GPIO_bit(gpio);
	gafr = GAFR(gpio) & ~(0x3 << (((gpio) & 0xf)*2));
	GAFR(gpio) = gafr |  (fn  << (((gpio) & 0xf)*2));
	local_irq_restore(flags);
}

EXPORT_SYMBOL(pxa_gpio_mode);

/*
 * Routine to safely enable or disable a clock in the CKEN
 */
void pxa_set_cken(int clock, int enable)
{
	unsigned long flags;
	local_irq_save(flags);

	if (enable)
		CKEN |= clock;
	else
		CKEN &= ~clock;

	local_irq_restore(flags);
}

EXPORT_SYMBOL(pxa_set_cken);

/*
 * Intel PXA2xx internal register mapping.
 *
 * Note 1: not all PXA2xx variants implement all those addresses.
 *
 * Note 2: virtual 0xfffe0000-0xffffffff is reserved for the vector table
 *         and cache flush area.
 */
static struct map_desc standard_io_desc[] __initdata = {
  	{	/* Devs */
		.virtual	=  0xf2000000,
		.pfn		= __phys_to_pfn(0x40000000),
		.length		= 0x02000000,
		.type		= MT_DEVICE
	}, {	/* LCD */
		.virtual	=  0xf4000000,
		.pfn		= __phys_to_pfn(0x44000000),
		.length		= 0x00100000,
		.type		= MT_DEVICE
	}, {	/* Mem Ctl */
		.virtual	=  0xf6000000,
		.pfn		= __phys_to_pfn(0x48000000),
		.length		= 0x00100000,
		.type		= MT_DEVICE
	}, {	/* USB host */
		.virtual	=  0xf8000000,
		.pfn		= __phys_to_pfn(0x4c000000),
		.length		= 0x00100000,
		.type		= MT_DEVICE
	}, {	/* Camera */
		.virtual	=  0xfa000000,
		.pfn		= __phys_to_pfn(0x50000000),
		.length		= 0x00100000,
		.type		= MT_DEVICE
	}, {	/* IMem ctl */
		.virtual	=  0xfe000000,
		.pfn		= __phys_to_pfn(0x58000000),
		.length		= 0x00100000,
		.type		= MT_DEVICE
	}, {	/* UNCACHED_PHYS_0 */
		.virtual	= 0xff000000,
		.pfn		= __phys_to_pfn(0x00000000),
		.length		= 0x00100000,
		.type		= MT_DEVICE
	}
};

void __init pxa_map_io(void)
{
	iotable_init(standard_io_desc, ARRAY_SIZE(standard_io_desc));
	get_clk_frequency_khz(1);
}


static struct resource pxamci_resources[] = {
	[0] = {
		.start	= 0x41100000,
		.end	= 0x41100fff,
		.flags	= IORESOURCE_MEM,
	},
	[1] = {
		.start	= IRQ_MMC,
		.end	= IRQ_MMC,
		.flags	= IORESOURCE_IRQ,
	},
};

static u64 pxamci_dmamask = 0xffffffffUL;

static struct platform_device pxamci_device = {
	.name		= "pxa2xx-mci",
	.id		= -1,
	.dev		= {
		.dma_mask = &pxamci_dmamask,
		.coherent_dma_mask = 0xffffffff,
	},
	.num_resources	= ARRAY_SIZE(pxamci_resources),
	.resource	= pxamci_resources,
};

void __init pxa_set_mci_info(struct pxamci_platform_data *info)
{
	pxamci_device.dev.platform_data = info;
}


static struct pxa2xx_udc_mach_info pxa_udc_info;

void __init pxa_set_udc_info(struct pxa2xx_udc_mach_info *info)
{
	memcpy(&pxa_udc_info, info, sizeof *info);
}

static struct resource pxa2xx_udc_resources[] = {
	[0] = {
		.start	= 0x40600000,
		.end	= 0x4060ffff,
		.flags	= IORESOURCE_MEM,
	},
	[1] = {
		.start	= IRQ_USB,
		.end	= IRQ_USB,
		.flags	= IORESOURCE_IRQ,
	},
};

static u64 udc_dma_mask = ~(u32)0;

static struct platform_device udc_device = {
	.name		= "pxa2xx-udc",
	.id		= -1,
	.resource	= pxa2xx_udc_resources,
	.num_resources	= ARRAY_SIZE(pxa2xx_udc_resources),
	.dev		=  {
		.platform_data	= &pxa_udc_info,
		.dma_mask	= &udc_dma_mask,
	}
};

static struct resource pxafb_resources[] = {
	[0] = {
		.start	= 0x44000000,
		.end	= 0x4400ffff,
		.flags	= IORESOURCE_MEM,
	},
	[1] = {
		.start	= IRQ_LCD,
		.end	= IRQ_LCD,
		.flags	= IORESOURCE_IRQ,
	},
};

static u64 fb_dma_mask = ~(u64)0;

static struct platform_device pxafb_device = {
	.name		= "pxa2xx-fb",
	.id		= -1,
	.dev		= {
		.dma_mask	= &fb_dma_mask,
		.coherent_dma_mask = 0xffffffff,
	},
	.num_resources	= ARRAY_SIZE(pxafb_resources),
	.resource	= pxafb_resources,
};

void __init set_pxa_fb_info(struct pxafb_mach_info *info)
{
	pxafb_device.dev.platform_data = info;
}

void __init set_pxa_fb_parent(struct device *parent_dev)
{
	pxafb_device.dev.parent = parent_dev;
}

static struct platform_device ffuart_device = {
	.name		= "pxa2xx-uart",
	.id		= 0,
};
static struct platform_device btuart_device = {
	.name		= "pxa2xx-uart",
	.id		= 1,
};
static struct platform_device stuart_device = {
	.name		= "pxa2xx-uart",
	.id		= 2,
};
static struct platform_device hwuart_device = {
	.name		= "pxa2xx-uart",
	.id		= 3,
};

static struct resource i2c_resources[] = {
	{
		.start	= 0x40301680,
		.end	= 0x403016a3,
		.flags	= IORESOURCE_MEM,
	}, {
		.start	= IRQ_I2C,
		.end	= IRQ_I2C,
		.flags	= IORESOURCE_IRQ,
	},
};

static struct platform_device i2c_device = {
	.name		= "pxa2xx-i2c",
	.id		= 0,
	.resource	= i2c_resources,
	.num_resources	= ARRAY_SIZE(i2c_resources),
};

void __init pxa_set_i2c_info(struct i2c_pxa_platform_data *info)
{
	i2c_device.dev.platform_data = info;
}

static struct resource i2s_resources[] = {
	{
		.start	= 0x40400000,
		.end	= 0x40400083,
		.flags	= IORESOURCE_MEM,
	}, {
		.start	= IRQ_I2S,
		.end	= IRQ_I2S,
		.flags	= IORESOURCE_IRQ,
	},
};

static struct platform_device i2s_device = {
	.name		= "pxa2xx-i2s",
	.id		= -1,
	.resource	= i2s_resources,
	.num_resources	= ARRAY_SIZE(i2s_resources),
};

static u64 pxaficp_dmamask = ~(u32)0;

static struct platform_device pxaficp_device = {
	.name		= "pxa2xx-ir",
	.id		= -1,
	.dev		= {
		.dma_mask = &pxaficp_dmamask,
		.coherent_dma_mask = 0xffffffff,
	},
};

void __init pxa_set_ficp_info(struct pxaficp_platform_data *info)
{
	pxaficp_device.dev.platform_data = info;
}

static struct platform_device pxartc_device = {
	.name		= "sa1100-rtc",
	.id		= -1,
};

static struct platform_device *devices[] __initdata = {
	&pxamci_device,
	&udc_device,
	&pxafb_device,
	&ffuart_device,
	&btuart_device,
	&stuart_device,
	&pxaficp_device,
	&i2c_device,
	&i2s_device,
	&pxartc_device,
};

static int __init pxa_init(void)
{
	int cpuid, ret;

	ret = platform_add_devices(devices, ARRAY_SIZE(devices));
	if (ret)
		return ret;

	/* Only add HWUART for PXA255/26x; PXA210/250/27x do not have it. */
	cpuid = read_cpuid(CPUID_ID);
	if (((cpuid >> 4) & 0xfff) == 0x2d0 ||
	    ((cpuid >> 4) & 0xfff) == 0x290)
		ret = platform_device_register(&hwuart_device);

	return ret;
}

subsys_initcall(pxa_init);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/arch/arm/mach-pxa/generic.c
	3	*
	4	* Author: Nicolas Pitre
	5	* Created: Jun 15, 2001
	6	* Copyright: MontaVista Software Inc.
	7	*
	8	* Code common to all PXA machines.
	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	*
	14	* Since this file should be linked before any other machine specific file,
	15	* the __initcall() here will be executed first. This serves as default
	16	* initialization stuff for PXA machines which can be overridden later if
	17	* need be.
	18	*/
	19	#include <linux/module.h>
	20	#include <linux/kernel.h>
	21	#include <linux/init.h>
	22	#include <linux/delay.h>
d052d1be	23	#include <linux/platform_device.h>
1da177e4 LT	24	#include <linux/ioport.h>
1da177e4 LT	25	#include <linux/pm.h>
4e57b681	26	#include <linux/string.h>
1da177e4 LT	27
	28	#include <asm/hardware.h>
	29	#include <asm/irq.h>
	30	#include <asm/system.h>
	31	#include <asm/pgtable.h>
	32	#include <asm/mach/map.h>
	33
	34	#include <asm/arch/pxa-regs.h>
	35	#include <asm/arch/udc.h>
	36	#include <asm/arch/pxafb.h>
	37	#include <asm/arch/mmc.h>
6f475c01	38	#include <asm/arch/irda.h>
eb9181a2	39	#include <asm/arch/i2c.h>
1da177e4 LT	40
	41	#include "generic.h"
	42
	43	/*
	44	* Handy function to set GPIO alternate functions
	45	*/
	46
	47	void pxa_gpio_mode(int gpio_mode)
	48	{
	49	unsigned long flags;
	50	int gpio = gpio_mode & GPIO_MD_MASK_NR;
	51	int fn = (gpio_mode & GPIO_MD_MASK_FN) >> 8;
	52	int gafr;
	53
	54	local_irq_save(flags);
	55	if (gpio_mode & GPIO_DFLT_LOW)
	56	GPCR(gpio) = GPIO_bit(gpio);
	57	else if (gpio_mode & GPIO_DFLT_HIGH)
	58	GPSR(gpio) = GPIO_bit(gpio);
	59	if (gpio_mode & GPIO_MD_MASK_DIR)
	60	GPDR(gpio) \|= GPIO_bit(gpio);
	61	else
	62	GPDR(gpio) &= ~GPIO_bit(gpio);
	63	gafr = GAFR(gpio) & ~(0x3 << (((gpio) & 0xf)*2));
	64	GAFR(gpio) = gafr \| (fn << (((gpio) & 0xf)*2));
	65	local_irq_restore(flags);
	66	}
	67
	68	EXPORT_SYMBOL(pxa_gpio_mode);
	69
	70	/*
	71	* Routine to safely enable or disable a clock in the CKEN
	72	*/
	73	void pxa_set_cken(int clock, int enable)
	74	{
	75	unsigned long flags;
	76	local_irq_save(flags);
	77
	78	if (enable)
	79	CKEN \|= clock;
	80	else
	81	CKEN &= ~clock;
	82
	83	local_irq_restore(flags);
	84	}
	85
	86	EXPORT_SYMBOL(pxa_set_cken);
	87
	88	/*
	89	* Intel PXA2xx internal register mapping.
	90	*
	91	* Note 1: not all PXA2xx variants implement all those addresses.
	92	*
	93	* Note 2: virtual 0xfffe0000-0xffffffff is reserved for the vector table
	94	* and cache flush area.
	95	*/
	96	static struct map_desc standard_io_desc[] __initdata = {
6f9182eb DS	97	{ /* Devs */
	98	.virtual = 0xf2000000,
	99	.pfn = __phys_to_pfn(0x40000000),
	100	.length = 0x02000000,
	101	.type = MT_DEVICE
	102	}, { /* LCD */
	103	.virtual = 0xf4000000,
	104	.pfn = __phys_to_pfn(0x44000000),
	105	.length = 0x00100000,
	106	.type = MT_DEVICE
	107	}, { /* Mem Ctl */
	108	.virtual = 0xf6000000,
	109	.pfn = __phys_to_pfn(0x48000000),
	110	.length = 0x00100000,
	111	.type = MT_DEVICE
	112	}, { /* USB host */
	113	.virtual = 0xf8000000,
	114	.pfn = __phys_to_pfn(0x4c000000),
	115	.length = 0x00100000,
	116	.type = MT_DEVICE
	117	}, { /* Camera */
	118	.virtual = 0xfa000000,
	119	.pfn = __phys_to_pfn(0x50000000),
	120	.length = 0x00100000,
	121	.type = MT_DEVICE
	122	}, { /* IMem ctl */
	123	.virtual = 0xfe000000,
	124	.pfn = __phys_to_pfn(0x58000000),
	125	.length = 0x00100000,
	126	.type = MT_DEVICE
	127	}, { /* UNCACHED_PHYS_0 */
	128	.virtual = 0xff000000,
	129	.pfn = __phys_to_pfn(0x00000000),
	130	.length = 0x00100000,
	131	.type = MT_DEVICE
	132	}
1da177e4 LT	133	};
	134
	135	void __init pxa_map_io(void)
	136	{
	137	iotable_init(standard_io_desc, ARRAY_SIZE(standard_io_desc));
	138	get_clk_frequency_khz(1);
	139	}
	140
	141
	142	static struct resource pxamci_resources[] = {
	143	[0] = {
	144	.start = 0x41100000,
	145	.end = 0x41100fff,
	146	.flags = IORESOURCE_MEM,
	147	},
	148	[1] = {
	149	.start = IRQ_MMC,
	150	.end = IRQ_MMC,
	151	.flags = IORESOURCE_IRQ,
	152	},
	153	};
	154
	155	static u64 pxamci_dmamask = 0xffffffffUL;
	156
	157	static struct platform_device pxamci_device = {
	158	.name = "pxa2xx-mci",
	159	.id = -1,
	160	.dev = {
	161	.dma_mask = &pxamci_dmamask,
	162	.coherent_dma_mask = 0xffffffff,
	163	},
	164	.num_resources = ARRAY_SIZE(pxamci_resources),
	165	.resource = pxamci_resources,
	166	};
	167
	168	void __init pxa_set_mci_info(struct pxamci_platform_data *info)
	169	{
	170	pxamci_device.dev.platform_data = info;
	171	}
	172
	173
	174	static struct pxa2xx_udc_mach_info pxa_udc_info;
	175
	176	void __init pxa_set_udc_info(struct pxa2xx_udc_mach_info *info)
	177	{
	178	memcpy(&pxa_udc_info, info, sizeof *info);
	179	}
	180
	181	static struct resource pxa2xx_udc_resources[] = {
	182	[0] = {
	183	.start = 0x40600000,
	184	.end = 0x4060ffff,
	185	.flags = IORESOURCE_MEM,
	186	},
	187	[1] = {
	188	.start = IRQ_USB,
	189	.end = IRQ_USB,
	190	.flags = IORESOURCE_IRQ,
	191	},
	192	};
	193
	194	static u64 udc_dma_mask = ~(u32)0;
	195
	196	static struct platform_device udc_device = {
197	.name = "pxa2xx-udc",
198	.id = -1,
199	.resource = pxa2xx_udc_resources,
200	.num_resources = ARRAY_SIZE(pxa2xx_udc_resources),
201	.dev = {
202	.platform_data = &pxa_udc_info,
203	.dma_mask = &udc_dma_mask,
204	}
205	};
206
1da177e4 LT	207	static struct resource pxafb_resources[] = {
	208	[0] = {
	209	.start = 0x44000000,
	210	.end = 0x4400ffff,
	211	.flags = IORESOURCE_MEM,
	212	},
	213	[1] = {
	214	.start = IRQ_LCD,
	215	.end = IRQ_LCD,
	216	.flags = IORESOURCE_IRQ,
	217	},
	218	};
	219
	220	static u64 fb_dma_mask = ~(u64)0;
	221
	222	static struct platform_device pxafb_device = {
	223	.name = "pxa2xx-fb",
	224	.id = -1,
	225	.dev = {
1da177e4 LT	226	.dma_mask = &fb_dma_mask,
	227	.coherent_dma_mask = 0xffffffff,
	228	},
	229	.num_resources = ARRAY_SIZE(pxafb_resources),
	230	.resource = pxafb_resources,
	231	};
	232
d14b272b RP	233	void __init set_pxa_fb_info(struct pxafb_mach_info *info)
	234	{
	235	pxafb_device.dev.platform_data = info;
	236	}
	237
cb38c569 RP	238	void __init set_pxa_fb_parent(struct device *parent_dev)
	239	{
	240	pxafb_device.dev.parent = parent_dev;
	241	}
	242
1da177e4 LT	243	static struct platform_device ffuart_device = {
	244	.name = "pxa2xx-uart",
	245	.id = 0,
	246	};
	247	static struct platform_device btuart_device = {
	248	.name = "pxa2xx-uart",
	249	.id = 1,
	250	};
	251	static struct platform_device stuart_device = {
	252	.name = "pxa2xx-uart",
	253	.id = 2,
	254	};
d9e29649 MR	255	static struct platform_device hwuart_device = {
	256	.name = "pxa2xx-uart",
	257	.id = 3,
	258	};
1da177e4	259
bb9bffcb RK	260	static struct resource i2c_resources[] = {
	261	{
	262	.start = 0x40301680,
	263	.end = 0x403016a3,
	264	.flags = IORESOURCE_MEM,
	265	}, {
	266	.start = IRQ_I2C,
	267	.end = IRQ_I2C,
	268	.flags = IORESOURCE_IRQ,
	269	},
	270	};
	271
	272	static struct platform_device i2c_device = {
	273	.name = "pxa2xx-i2c",
	274	.id = 0,
	275	.resource = i2c_resources,
	276	.num_resources = ARRAY_SIZE(i2c_resources),
	277	};
	278
	279	void __init pxa_set_i2c_info(struct i2c_pxa_platform_data *info)
	280	{
	281	i2c_device.dev.platform_data = info;
	282	}
	283
b2640b42 MR	284	static struct resource i2s_resources[] = {
	285	{
	286	.start = 0x40400000,
	287	.end = 0x40400083,
	288	.flags = IORESOURCE_MEM,
	289	}, {
	290	.start = IRQ_I2S,
	291	.end = IRQ_I2S,
	292	.flags = IORESOURCE_IRQ,
	293	},
	294	};
	295
	296	static struct platform_device i2s_device = {
	297	.name = "pxa2xx-i2s",
	298	.id = -1,
b5723521	299	.resource = i2s_resources,
b2640b42 MR	300	.num_resources = ARRAY_SIZE(i2s_resources),
	301	};
	302
6f475c01 NP	303	static u64 pxaficp_dmamask = ~(u32)0;
	304
	305	static struct platform_device pxaficp_device = {
	306	.name = "pxa2xx-ir",
	307	.id = -1,
	308	.dev = {
	309	.dma_mask = &pxaficp_dmamask,
	310	.coherent_dma_mask = 0xffffffff,
	311	},
	312	};
	313
	314	void __init pxa_set_ficp_info(struct pxaficp_platform_data *info)
	315	{
	316	pxaficp_device.dev.platform_data = info;
	317	}
	318
e842f1c8 RP	319	static struct platform_device pxartc_device = {
	320	.name = "sa1100-rtc",
	321	.id = -1,
	322	};
	323
1da177e4 LT	324	static struct platform_device *devices[] __initdata = {
	325	&pxamci_device,
	326	&udc_device,
	327	&pxafb_device,
	328	&ffuart_device,
	329	&btuart_device,
	330	&stuart_device,
6f475c01	331	&pxaficp_device,
bb9bffcb	332	&i2c_device,
b2640b42	333	&i2s_device,
e842f1c8	334	&pxartc_device,
1da177e4 LT	335	};
	336
	337	static int __init pxa_init(void)
	338	{
d9e29649 MR	339	int cpuid, ret;
	340
	341	ret = platform_add_devices(devices, ARRAY_SIZE(devices));
	342	if (ret)
	343	return ret;
	344
	345	/* Only add HWUART for PXA255/26x; PXA210/250/27x do not have it. */
	346	cpuid = read_cpuid(CPUID_ID);
	347	if (((cpuid >> 4) & 0xfff) == 0x2d0 \|\|
	348	((cpuid >> 4) & 0xfff) == 0x290)
	349	ret = platform_device_register(&hwuart_device);
	350
	351	return ret;
1da177e4 LT	352	}
	353
	354	subsys_initcall(pxa_init);