integrator_cp.c 11.9 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13
/*
 *  linux/arch/arm/mach-integrator/integrator_cp.c
 *
 *  Copyright (C) 2003 Deep Blue Solutions Ltd
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License.
 */
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/list.h>
14
#include <linux/platform_device.h>
L
Linus Torvalds 已提交
15 16
#include <linux/dma-mapping.h>
#include <linux/string.h>
K
Kay Sievers 已提交
17
#include <linux/device.h>
18 19 20
#include <linux/amba/bus.h>
#include <linux/amba/kmi.h>
#include <linux/amba/clcd.h>
21
#include <linux/amba/mmci.h>
22
#include <linux/io.h>
23
#include <linux/gfp.h>
24
#include <linux/clkdev.h>
25
#include <linux/mtd/physmap.h>
L
Linus Torvalds 已提交
26

27
#include <mach/hardware.h>
28
#include <mach/platform.h>
L
Linus Torvalds 已提交
29 30 31
#include <asm/irq.h>
#include <asm/setup.h>
#include <asm/mach-types.h>
32
#include <asm/hardware/arm_timer.h>
33
#include <asm/hardware/icst.h>
L
Linus Torvalds 已提交
34

35 36
#include <mach/cm.h>
#include <mach/lm.h>
L
Linus Torvalds 已提交
37 38 39 40 41 42

#include <asm/mach/arch.h>
#include <asm/mach/irq.h>
#include <asm/mach/map.h>
#include <asm/mach/time.h>

43
#include <asm/hardware/timer-sp.h>
44

45
#include <plat/clcd.h>
46
#include <plat/fpga-irq.h>
47
#include <plat/sched_clock.h>
48

49 50
#include "common.h"

L
Linus Torvalds 已提交
51 52 53 54 55
#define INTCP_PA_FLASH_BASE		0x24000000
#define INTCP_FLASH_SIZE		SZ_32M

#define INTCP_PA_CLCD_BASE		0xc0000000

56 57 58
#define INTCP_VA_CIC_BASE		__io_address(INTEGRATOR_HDR_BASE + 0x40)
#define INTCP_VA_PIC_BASE		__io_address(INTEGRATOR_IC_BASE)
#define INTCP_VA_SIC_BASE		__io_address(INTEGRATOR_CP_SIC_BASE)
L
Linus Torvalds 已提交
59 60 61

#define INTCP_ETH_SIZE			0x10

62
#define INTCP_VA_CTRL_BASE		IO_ADDRESS(INTEGRATOR_CP_CTL_BASE)
L
Linus Torvalds 已提交
63 64 65 66 67 68 69 70 71 72 73 74 75 76
#define INTCP_FLASHPROG			0x04
#define CINTEGRATOR_FLASHPROG_FLVPPEN	(1 << 0)
#define CINTEGRATOR_FLASHPROG_FLWREN	(1 << 1)

/*
 * Logical      Physical
 * f1000000	10000000	Core module registers
 * f1100000	11000000	System controller registers
 * f1200000	12000000	EBI registers
 * f1300000	13000000	Counter/Timer
 * f1400000	14000000	Interrupt controller
 * f1600000	16000000	UART 0
 * f1700000	17000000	UART 1
 * f1a00000	1a000000	Debug LEDs
77 78 79
 * fc900000	c9000000	GPIO
 * fca00000	ca000000	SIC
 * fcb00000	cb000000	CP system control
L
Linus Torvalds 已提交
80 81 82
 */

static struct map_desc intcp_io_desc[] __initdata = {
83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123
	{
		.virtual	= IO_ADDRESS(INTEGRATOR_HDR_BASE),
		.pfn		= __phys_to_pfn(INTEGRATOR_HDR_BASE),
		.length		= SZ_4K,
		.type		= MT_DEVICE
	}, {
		.virtual	= IO_ADDRESS(INTEGRATOR_SC_BASE),
		.pfn		= __phys_to_pfn(INTEGRATOR_SC_BASE),
		.length		= SZ_4K,
		.type		= MT_DEVICE
	}, {
		.virtual	= IO_ADDRESS(INTEGRATOR_EBI_BASE),
		.pfn		= __phys_to_pfn(INTEGRATOR_EBI_BASE),
		.length		= SZ_4K,
		.type		= MT_DEVICE
	}, {
		.virtual	= IO_ADDRESS(INTEGRATOR_CT_BASE),
		.pfn		= __phys_to_pfn(INTEGRATOR_CT_BASE),
		.length		= SZ_4K,
		.type		= MT_DEVICE
	}, {
		.virtual	= IO_ADDRESS(INTEGRATOR_IC_BASE),
		.pfn		= __phys_to_pfn(INTEGRATOR_IC_BASE),
		.length		= SZ_4K,
		.type		= MT_DEVICE
	}, {
		.virtual	= IO_ADDRESS(INTEGRATOR_UART0_BASE),
		.pfn		= __phys_to_pfn(INTEGRATOR_UART0_BASE),
		.length		= SZ_4K,
		.type		= MT_DEVICE
	}, {
		.virtual	= IO_ADDRESS(INTEGRATOR_UART1_BASE),
		.pfn		= __phys_to_pfn(INTEGRATOR_UART1_BASE),
		.length		= SZ_4K,
		.type		= MT_DEVICE
	}, {
		.virtual	= IO_ADDRESS(INTEGRATOR_DBG_BASE),
		.pfn		= __phys_to_pfn(INTEGRATOR_DBG_BASE),
		.length		= SZ_4K,
		.type		= MT_DEVICE
	}, {
124 125
		.virtual	= IO_ADDRESS(INTEGRATOR_CP_GPIO_BASE),
		.pfn		= __phys_to_pfn(INTEGRATOR_CP_GPIO_BASE),
126 127 128
		.length		= SZ_4K,
		.type		= MT_DEVICE
	}, {
129 130
		.virtual	= IO_ADDRESS(INTEGRATOR_CP_SIC_BASE),
		.pfn		= __phys_to_pfn(INTEGRATOR_CP_SIC_BASE),
131 132 133
		.length		= SZ_4K,
		.type		= MT_DEVICE
	}, {
134 135
		.virtual	= IO_ADDRESS(INTEGRATOR_CP_CTL_BASE),
		.pfn		= __phys_to_pfn(INTEGRATOR_CP_CTL_BASE),
136 137 138
		.length		= SZ_4K,
		.type		= MT_DEVICE
	}
L
Linus Torvalds 已提交
139 140 141 142 143 144 145
};

static void __init intcp_map_io(void)
{
	iotable_init(intcp_io_desc, ARRAY_SIZE(intcp_io_desc));
}

146 147 148 149
static struct fpga_irq_data cic_irq_data = {
	.base		= INTCP_VA_CIC_BASE,
	.irq_start	= IRQ_CIC_START,
	.chip.name	= "CIC",
L
Linus Torvalds 已提交
150 151
};

152 153 154 155
static struct fpga_irq_data pic_irq_data = {
	.base		= INTCP_VA_PIC_BASE,
	.irq_start	= IRQ_PIC_START,
	.chip.name	= "PIC",
L
Linus Torvalds 已提交
156 157
};

158 159 160 161
static struct fpga_irq_data sic_irq_data = {
	.base		= INTCP_VA_SIC_BASE,
	.irq_start	= IRQ_SIC_START,
	.chip.name	= "SIC",
L
Linus Torvalds 已提交
162 163 164 165
};

static void __init intcp_init_irq(void)
{
166 167 168 169 170
	u32 pic_mask, sic_mask;

	pic_mask = ~((~0u) << (11 - IRQ_PIC_START));
	pic_mask |= (~((~0u) << (29 - 22))) << 22;
	sic_mask = ~((~0u) << (1 + IRQ_SIC_END - IRQ_SIC_START));
L
Linus Torvalds 已提交
171 172 173 174

	/*
	 * Disable all interrupt sources
	 */
175 176 177 178 179 180
	writel(0xffffffff, INTCP_VA_PIC_BASE + IRQ_ENABLE_CLEAR);
	writel(0xffffffff, INTCP_VA_PIC_BASE + FIQ_ENABLE_CLEAR);
	writel(0xffffffff, INTCP_VA_CIC_BASE + IRQ_ENABLE_CLEAR);
	writel(0xffffffff, INTCP_VA_CIC_BASE + FIQ_ENABLE_CLEAR);
	writel(sic_mask, INTCP_VA_SIC_BASE + IRQ_ENABLE_CLEAR);
	writel(sic_mask, INTCP_VA_SIC_BASE + FIQ_ENABLE_CLEAR);
L
Linus Torvalds 已提交
181

182
	fpga_irq_init(-1, pic_mask, &pic_irq_data);
L
Linus Torvalds 已提交
183

184 185
	fpga_irq_init(-1, ~((~0u) << (1 + IRQ_CIC_END - IRQ_CIC_START)),
		&cic_irq_data);
L
Linus Torvalds 已提交
186

187
	fpga_irq_init(IRQ_CP_CPPLDINT, sic_mask, &sic_irq_data);
L
Linus Torvalds 已提交
188 189 190 191 192
}

/*
 * Clock handling
 */
193 194
#define CM_LOCK		(__io_address(INTEGRATOR_HDR_BASE)+INTEGRATOR_HDR_LOCK_OFFSET)
#define CM_AUXOSC	(__io_address(INTEGRATOR_HDR_BASE)+0x1c)
L
Linus Torvalds 已提交
195

196
static const struct icst_params cp_auxvco_params = {
R
Russell King 已提交
197
	.ref		= 24000000,
198
	.vco_max	= ICST525_VCO_MAX_5V,
199
	.vco_min	= ICST525_VCO_MIN,
L
Linus Torvalds 已提交
200 201 202 203
	.vd_min 	= 8,
	.vd_max 	= 263,
	.rd_min 	= 3,
	.rd_max 	= 65,
204 205
	.s2div		= icst525_s2div,
	.idx2s		= icst525_idx2s,
L
Linus Torvalds 已提交
206 207
};

208
static void cp_auxvco_set(struct clk *clk, struct icst_vco vco)
L
Linus Torvalds 已提交
209 210 211
{
	u32 val;

212
	val = readl(clk->vcoreg) & ~0x7ffff;
L
Linus Torvalds 已提交
213 214 215
	val |= vco.v | (vco.r << 9) | (vco.s << 16);

	writel(0xa05f, CM_LOCK);
216
	writel(val, clk->vcoreg);
L
Linus Torvalds 已提交
217 218 219
	writel(0, CM_LOCK);
}

220 221 222 223 224 225
static const struct clk_ops cp_auxclk_ops = {
	.round	= icst_clk_round,
	.set	= icst_clk_set,
	.setvco	= cp_auxvco_set,
};

226
static struct clk cp_auxclk = {
227
	.ops	= &cp_auxclk_ops,
L
Linus Torvalds 已提交
228
	.params	= &cp_auxvco_params,
229
	.vcoreg	= CM_AUXOSC,
L
Linus Torvalds 已提交
230 231
};

232 233 234 235
static struct clk sp804_clk = {
	.rate	= 1000000,
};

236 237 238 239
static struct clk_lookup cp_lookups[] = {
	{	/* CLCD */
		.dev_id		= "mb:c0",
		.clk		= &cp_auxclk,
240 241 242
	}, {	/* SP804 timers */
		.dev_id		= "sp804",
		.clk		= &sp804_clk,
243
	},
L
Linus Torvalds 已提交
244 245 246 247 248
};

/*
 * Flash handling.
 */
249
static int intcp_flash_init(struct platform_device *dev)
L
Linus Torvalds 已提交
250 251 252 253 254 255 256 257 258 259
{
	u32 val;

	val = readl(INTCP_VA_CTRL_BASE + INTCP_FLASHPROG);
	val |= CINTEGRATOR_FLASHPROG_FLWREN;
	writel(val, INTCP_VA_CTRL_BASE + INTCP_FLASHPROG);

	return 0;
}

260
static void intcp_flash_exit(struct platform_device *dev)
L
Linus Torvalds 已提交
261 262 263 264 265 266 267 268
{
	u32 val;

	val = readl(INTCP_VA_CTRL_BASE + INTCP_FLASHPROG);
	val &= ~(CINTEGRATOR_FLASHPROG_FLVPPEN|CINTEGRATOR_FLASHPROG_FLWREN);
	writel(val, INTCP_VA_CTRL_BASE + INTCP_FLASHPROG);
}

269
static void intcp_flash_set_vpp(struct platform_device *pdev, int on)
L
Linus Torvalds 已提交
270 271 272 273 274 275 276 277 278 279 280
{
	u32 val;

	val = readl(INTCP_VA_CTRL_BASE + INTCP_FLASHPROG);
	if (on)
		val |= CINTEGRATOR_FLASHPROG_FLVPPEN;
	else
		val &= ~CINTEGRATOR_FLASHPROG_FLVPPEN;
	writel(val, INTCP_VA_CTRL_BASE + INTCP_FLASHPROG);
}

281
static struct physmap_flash_data intcp_flash_data = {
L
Linus Torvalds 已提交
282 283 284 285 286 287 288 289 290 291 292 293 294
	.width		= 4,
	.init		= intcp_flash_init,
	.exit		= intcp_flash_exit,
	.set_vpp	= intcp_flash_set_vpp,
};

static struct resource intcp_flash_resource = {
	.start		= INTCP_PA_FLASH_BASE,
	.end		= INTCP_PA_FLASH_BASE + INTCP_FLASH_SIZE - 1,
	.flags		= IORESOURCE_MEM,
};

static struct platform_device intcp_flash_device = {
295
	.name		= "physmap-flash",
L
Linus Torvalds 已提交
296 297 298 299 300 301 302 303 304 305
	.id		= 0,
	.dev		= {
		.platform_data	= &intcp_flash_data,
	},
	.num_resources	= 1,
	.resource	= &intcp_flash_resource,
};

static struct resource smc91x_resources[] = {
	[0] = {
306 307
		.start	= INTEGRATOR_CP_ETH_BASE,
		.end	= INTEGRATOR_CP_ETH_BASE + INTCP_ETH_SIZE - 1,
L
Linus Torvalds 已提交
308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
		.flags	= IORESOURCE_MEM,
	},
	[1] = {
		.start	= IRQ_CP_ETHINT,
		.end	= IRQ_CP_ETHINT,
		.flags	= IORESOURCE_IRQ,
	},
};

static struct platform_device smc91x_device = {
	.name		= "smc91x",
	.id		= 0,
	.num_resources	= ARRAY_SIZE(smc91x_resources),
	.resource	= smc91x_resources,
};

static struct platform_device *intcp_devs[] __initdata = {
	&intcp_flash_device,
	&smc91x_device,
};

/*
 * It seems that the card insertion interrupt remains active after
 * we've acknowledged it.  We therefore ignore the interrupt, and
 * rely on reading it from the SIC.  This also means that we must
 * clear the latched interrupt.
 */
static unsigned int mmc_status(struct device *dev)
{
337 338
	unsigned int status = readl(IO_ADDRESS(0xca000000 + 4));
	writel(8, IO_ADDRESS(INTEGRATOR_CP_CTL_BASE + 8));
L
Linus Torvalds 已提交
339 340 341 342

	return status & 8;
}

343
static struct mmci_platform_data mmc_data = {
L
Linus Torvalds 已提交
344 345
	.ocr_mask	= MMC_VDD_32_33|MMC_VDD_33_34,
	.status		= mmc_status,
346 347
	.gpio_wp	= -1,
	.gpio_cd	= -1,
L
Linus Torvalds 已提交
348 349 350 351
};

static struct amba_device mmc_device = {
	.dev		= {
352
		.init_name = "mb:1c",
L
Linus Torvalds 已提交
353 354 355
		.platform_data = &mmc_data,
	},
	.res		= {
356 357
		.start	= INTEGRATOR_CP_MMC_BASE,
		.end	= INTEGRATOR_CP_MMC_BASE + SZ_4K - 1,
L
Linus Torvalds 已提交
358 359 360 361 362 363 364 365
		.flags	= IORESOURCE_MEM,
	},
	.irq		= { IRQ_CP_MMCIINT0, IRQ_CP_MMCIINT1 },
	.periphid	= 0,
};

static struct amba_device aaci_device = {
	.dev		= {
366
		.init_name = "mb:1d",
L
Linus Torvalds 已提交
367 368
	},
	.res		= {
369 370
		.start	= INTEGRATOR_CP_AACI_BASE,
		.end	= INTEGRATOR_CP_AACI_BASE + SZ_4K - 1,
L
Linus Torvalds 已提交
371 372
		.flags	= IORESOURCE_MEM,
	},
373
	.irq		= { IRQ_CP_AACIINT },
L
Linus Torvalds 已提交
374 375 376 377 378 379 380 381 382 383 384 385
	.periphid	= 0,
};


/*
 * CLCD support
 */
/*
 * Ensure VGA is selected.
 */
static void cp_clcd_enable(struct clcd_fb *fb)
{
386 387
	struct fb_var_screeninfo *var = &fb->fb.var;
	u32 val = CM_CTRL_STATIC1 | CM_CTRL_STATIC2;
388

389 390 391 392
	if (var->bits_per_pixel <= 8 ||
	    (var->bits_per_pixel == 16 && var->green.length == 5))
		/* Pseudocolor, RGB555, BGR555 */
		val |= CM_CTRL_LCDMUXSEL_VGA555_TFT555;
393
	else if (fb->fb.var.bits_per_pixel <= 16)
394 395
		/* truecolor RGB565 */
		val |= CM_CTRL_LCDMUXSEL_VGA565_TFT555;
396 397 398 399 400 401 402 403 404 405
	else
		val = 0; /* no idea for this, don't trust the docs */

	cm_control(CM_CTRL_LCDMUXSEL_MASK|
		   CM_CTRL_LCDEN0|
		   CM_CTRL_LCDEN1|
		   CM_CTRL_STATIC1|
		   CM_CTRL_STATIC2|
		   CM_CTRL_STATIC|
		   CM_CTRL_n24BITEN, val);
L
Linus Torvalds 已提交
406 407 408 409
}

static int cp_clcd_setup(struct clcd_fb *fb)
{
410 411 412
	fb->panel = versatile_clcd_get_panel("VGA");
	if (!fb->panel)
		return -EINVAL;
L
Linus Torvalds 已提交
413

414
	return versatile_clcd_setup_dma(fb, SZ_1M);
L
Linus Torvalds 已提交
415 416 417 418
}

static struct clcd_board clcd_data = {
	.name		= "Integrator/CP",
419
	.caps		= CLCD_CAP_5551 | CLCD_CAP_RGB565 | CLCD_CAP_888,
L
Linus Torvalds 已提交
420 421 422 423
	.check		= clcdfb_check,
	.decode		= clcdfb_decode,
	.enable		= cp_clcd_enable,
	.setup		= cp_clcd_setup,
424 425
	.mmap		= versatile_clcd_mmap_dma,
	.remove		= versatile_clcd_remove_dma,
L
Linus Torvalds 已提交
426 427 428 429
};

static struct amba_device clcd_device = {
	.dev		= {
430
		.init_name = "mb:c0",
L
Linus Torvalds 已提交
431 432 433 434 435 436 437 438 439
		.coherent_dma_mask = ~0,
		.platform_data = &clcd_data,
	},
	.res		= {
		.start	= INTCP_PA_CLCD_BASE,
		.end	= INTCP_PA_CLCD_BASE + SZ_4K - 1,
		.flags	= IORESOURCE_MEM,
	},
	.dma_mask	= ~0,
440
	.irq		= { IRQ_CP_CLCDCINT },
L
Linus Torvalds 已提交
441 442 443 444 445 446 447 448 449
	.periphid	= 0,
};

static struct amba_device *amba_devs[] __initdata = {
	&mmc_device,
	&aaci_device,
	&clcd_device,
};

450 451
#define REFCOUNTER (__io_address(INTEGRATOR_HDR_BASE) + 0x28)

452 453 454 455 456
static void __init intcp_init_early(void)
{
	clkdev_add_table(cp_lookups, ARRAY_SIZE(cp_lookups));

	integrator_init_early();
457 458 459 460

#ifdef CONFIG_PLAT_VERSATILE_SCHED_CLOCK
	versatile_sched_clock_init(REFCOUNTER, 24000000);
#endif
461 462
}

L
Linus Torvalds 已提交
463 464 465 466 467 468 469 470 471 472 473 474
static void __init intcp_init(void)
{
	int i;

	platform_add_devices(intcp_devs, ARRAY_SIZE(intcp_devs));

	for (i = 0; i < ARRAY_SIZE(amba_devs); i++) {
		struct amba_device *d = amba_devs[i];
		amba_device_register(d, &iomem_resource);
	}
}

475 476 477
#define TIMER0_VA_BASE __io_address(INTEGRATOR_TIMER0_BASE)
#define TIMER1_VA_BASE __io_address(INTEGRATOR_TIMER1_BASE)
#define TIMER2_VA_BASE __io_address(INTEGRATOR_TIMER2_BASE)
L
Linus Torvalds 已提交
478 479 480

static void __init intcp_timer_init(void)
{
481 482 483 484
	writel(0, TIMER0_VA_BASE + TIMER_CTRL);
	writel(0, TIMER1_VA_BASE + TIMER_CTRL);
	writel(0, TIMER2_VA_BASE + TIMER_CTRL);

485
	sp804_clocksource_init(TIMER2_VA_BASE, "timer2");
486
	sp804_clockevents_init(TIMER1_VA_BASE, IRQ_TIMERINT1, "timer1");
L
Linus Torvalds 已提交
487 488 489 490 491 492 493
}

static struct sys_timer cp_timer = {
	.init		= intcp_timer_init,
};

MACHINE_START(CINTEGRATOR, "ARM-IntegratorCP")
494
	/* Maintainer: ARM Ltd/Deep Blue Solutions Ltd */
495
	.atag_offset	= 0x100,
496
	.reserve	= integrator_reserve,
497 498
	.map_io		= intcp_map_io,
	.init_early	= intcp_init_early,
499
	.init_irq	= intcp_init_irq,
L
Linus Torvalds 已提交
500
	.timer		= &cp_timer,
501
	.init_machine	= intcp_init,
502
	.restart	= integrator_restart,
L
Linus Torvalds 已提交
503
MACHINE_END