mainstone.c 14.9 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/*
 *  linux/arch/arm/mach-pxa/mainstone.c
 *
 *  Support for the Intel HCDDBBVA0 Development Platform.
 *  (go figure how they came up with such name...)
 *
 *  Author:	Nicolas Pitre
 *  Created:	Nov 05, 2002
 *  Copyright:	MontaVista Software Inc.
 *
 *  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/init.h>
17
#include <linux/platform_device.h>
18
#include <linux/syscore_ops.h>
Linus Torvalds's avatar
Linus Torvalds committed
19 20 21 22
#include <linux/interrupt.h>
#include <linux/sched.h>
#include <linux/bitops.h>
#include <linux/fb.h>
23 24 25
#include <linux/ioport.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/partitions.h>
26 27
#include <linux/input.h>
#include <linux/gpio_keys.h>
28
#include <linux/pwm_backlight.h>
29
#include <linux/smc91x.h>
30
#include <linux/i2c/pxa-i2c.h>
Linus Torvalds's avatar
Linus Torvalds committed
31 32 33 34 35

#include <asm/types.h>
#include <asm/setup.h>
#include <asm/memory.h>
#include <asm/mach-types.h>
36
#include <mach/hardware.h>
Linus Torvalds's avatar
Linus Torvalds committed
37
#include <asm/irq.h>
38
#include <asm/sizes.h>
Linus Torvalds's avatar
Linus Torvalds committed
39 40 41 42

#include <asm/mach/arch.h>
#include <asm/mach/map.h>
#include <asm/mach/irq.h>
43
#include <asm/mach/flash.h>
Linus Torvalds's avatar
Linus Torvalds committed
44

45
#include <mach/pxa27x.h>
46
#include <mach/gpio.h>
47 48 49 50 51 52
#include <mach/mainstone.h>
#include <mach/audio.h>
#include <mach/pxafb.h>
#include <mach/mmc.h>
#include <mach/irda.h>
#include <mach/ohci.h>
53
#include <plat/pxa27x_keypad.h>
54
#include <mach/smemc.h>
Linus Torvalds's avatar
Linus Torvalds committed
55 56

#include "generic.h"
57
#include "devices.h"
Linus Torvalds's avatar
Linus Torvalds committed
58

59 60 61 62 63
static unsigned long mainstone_pin_config[] = {
	/* Chip Select */
	GPIO15_nCS_1,

	/* LCD - 16bpp Active TFT */
64
	GPIOxx_LCD_TFT_16BPP,
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91
	GPIO16_PWM0_OUT,	/* Backlight */

	/* MMC */
	GPIO32_MMC_CLK,
	GPIO112_MMC_CMD,
	GPIO92_MMC_DAT_0,
	GPIO109_MMC_DAT_1,
	GPIO110_MMC_DAT_2,
	GPIO111_MMC_DAT_3,

	/* USB Host Port 1 */
	GPIO88_USBH1_PWR,
	GPIO89_USBH1_PEN,

	/* PC Card */
	GPIO48_nPOE,
	GPIO49_nPWE,
	GPIO50_nPIOR,
	GPIO51_nPIOW,
	GPIO85_nPCE_1,
	GPIO54_nPCE_2,
	GPIO79_PSKTSEL,
	GPIO55_nPREG,
	GPIO56_nPWAIT,
	GPIO57_nIOIS16,

	/* AC97 */
92 93 94 95
	GPIO28_AC97_BITCLK,
	GPIO29_AC97_SDATA_IN_0,
	GPIO30_AC97_SDATA_OUT,
	GPIO31_AC97_SYNC,
96 97 98
	GPIO45_AC97_SYSCLK,

	/* Keypad */
99 100 101
	GPIO93_KP_DKIN_0,
	GPIO94_KP_DKIN_1,
	GPIO95_KP_DKIN_2,
102 103 104 105 106 107 108 109 110 111 112 113 114 115
	GPIO100_KP_MKIN_0	| WAKEUP_ON_LEVEL_HIGH,
	GPIO101_KP_MKIN_1	| WAKEUP_ON_LEVEL_HIGH,
	GPIO102_KP_MKIN_2	| WAKEUP_ON_LEVEL_HIGH,
	GPIO97_KP_MKIN_3	| WAKEUP_ON_LEVEL_HIGH,
	GPIO98_KP_MKIN_4	| WAKEUP_ON_LEVEL_HIGH,
	GPIO99_KP_MKIN_5	| WAKEUP_ON_LEVEL_HIGH,
	GPIO103_KP_MKOUT_0,
	GPIO104_KP_MKOUT_1,
	GPIO105_KP_MKOUT_2,
	GPIO106_KP_MKOUT_3,
	GPIO107_KP_MKOUT_4,
	GPIO108_KP_MKOUT_5,
	GPIO96_KP_MKOUT_6,

116 117 118 119
	/* I2C */
	GPIO117_I2C_SCL,
	GPIO118_I2C_SDA,

120 121 122
	/* GPIO */
	GPIO1_GPIO | WAKEUP_ON_EDGE_BOTH,
};
Linus Torvalds's avatar
Linus Torvalds committed
123 124 125

static unsigned long mainstone_irq_enabled;

126
static void mainstone_mask_irq(struct irq_data *d)
Linus Torvalds's avatar
Linus Torvalds committed
127
{
128
	int mainstone_irq = (d->irq - MAINSTONE_IRQ(0));
Linus Torvalds's avatar
Linus Torvalds committed
129 130 131
	MST_INTMSKENA = (mainstone_irq_enabled &= ~(1 << mainstone_irq));
}

132
static void mainstone_unmask_irq(struct irq_data *d)
Linus Torvalds's avatar
Linus Torvalds committed
133
{
134
	int mainstone_irq = (d->irq - MAINSTONE_IRQ(0));
Linus Torvalds's avatar
Linus Torvalds committed
135 136 137 138 139
	/* the irq can be acknowledged only if deasserted, so it's done here */
	MST_INTSETCLR &= ~(1 << mainstone_irq);
	MST_INTMSKENA = (mainstone_irq_enabled |= (1 << mainstone_irq));
}

140 141
static struct irq_chip mainstone_irq_chip = {
	.name		= "FPGA",
142 143 144
	.irq_ack	= mainstone_mask_irq,
	.irq_mask	= mainstone_mask_irq,
	.irq_unmask	= mainstone_unmask_irq,
Linus Torvalds's avatar
Linus Torvalds committed
145 146
};

147
static void mainstone_irq_handler(unsigned int irq, struct irq_desc *desc)
Linus Torvalds's avatar
Linus Torvalds committed
148 149 150
{
	unsigned long pending = MST_INTSETCLR & mainstone_irq_enabled;
	do {
151 152
		/* clear useless edge notification */
		desc->irq_data.chip->irq_ack(&desc->irq_data);
Linus Torvalds's avatar
Linus Torvalds committed
153 154
		if (likely(pending)) {
			irq = MAINSTONE_IRQ(0) + __ffs(pending);
155
			generic_handle_irq(irq);
Linus Torvalds's avatar
Linus Torvalds committed
156 157 158 159 160 161 162 163 164
		}
		pending = MST_INTSETCLR & mainstone_irq_enabled;
	} while (pending);
}

static void __init mainstone_init_irq(void)
{
	int irq;

165
	pxa27x_init_irq();
Linus Torvalds's avatar
Linus Torvalds committed
166 167 168

	/* setup extra Mainstone irqs */
	for(irq = MAINSTONE_IRQ(0); irq <= MAINSTONE_IRQ(15); irq++) {
169 170
		irq_set_chip_and_handler(irq, &mainstone_irq_chip,
					 handle_level_irq);
171 172 173 174
		if (irq == MAINSTONE_IRQ(10) || irq == MAINSTONE_IRQ(14))
			set_irq_flags(irq, IRQF_VALID | IRQF_PROBE | IRQF_NOAUTOEN);
		else
			set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
Linus Torvalds's avatar
Linus Torvalds committed
175 176 177 178 179 180 181
	}
	set_irq_flags(MAINSTONE_IRQ(8), 0);
	set_irq_flags(MAINSTONE_IRQ(12), 0);

	MST_INTMSKENA = 0;
	MST_INTSETCLR = 0;

182 183
	irq_set_chained_handler(IRQ_GPIO(0), mainstone_irq_handler);
	irq_set_irq_type(IRQ_GPIO(0), IRQ_TYPE_EDGE_FALLING);
Linus Torvalds's avatar
Linus Torvalds committed
184 185
}

186 187
#ifdef CONFIG_PM

188
static void mainstone_irq_resume(void)
189 190 191 192
{
	MST_INTMSKENA = mainstone_irq_enabled;
}

193
static struct syscore_ops mainstone_irq_syscore_ops = {
194 195 196 197 198
	.resume = mainstone_irq_resume,
};

static int __init mainstone_irq_device_init(void)
{
199 200
	if (machine_is_mainstone())
		register_syscore_ops(&mainstone_irq_syscore_ops);
201

202
	return 0;
203 204 205 206 207 208
}

device_initcall(mainstone_irq_device_init);

#endif

Linus Torvalds's avatar
Linus Torvalds committed
209 210 211 212 213 214 215 216 217 218

static struct resource smc91x_resources[] = {
	[0] = {
		.start	= (MST_ETH_PHYS + 0x300),
		.end	= (MST_ETH_PHYS + 0xfffff),
		.flags	= IORESOURCE_MEM,
	},
	[1] = {
		.start	= MAINSTONE_IRQ(3),
		.end	= MAINSTONE_IRQ(3),
219
		.flags	= IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE,
Linus Torvalds's avatar
Linus Torvalds committed
220 221 222
	}
};

223 224 225 226 227
static struct smc91x_platdata mainstone_smc91x_info = {
	.flags	= SMC91X_USE_8BIT | SMC91X_USE_16BIT | SMC91X_USE_32BIT |
		  SMC91X_NOWAIT | SMC91X_USE_DMA,
};

Linus Torvalds's avatar
Linus Torvalds committed
228 229 230 231 232
static struct platform_device smc91x_device = {
	.name		= "smc91x",
	.id		= 0,
	.num_resources	= ARRAY_SIZE(smc91x_resources),
	.resource	= smc91x_resources,
233 234 235
	.dev		= {
		.platform_data = &mainstone_smc91x_info,
	},
Linus Torvalds's avatar
Linus Torvalds committed
236 237
};

Takashi Iwai's avatar
Takashi Iwai committed
238
static int mst_audio_startup(struct snd_pcm_substream *substream, void *priv)
Linus Torvalds's avatar
Linus Torvalds committed
239 240 241 242 243 244
{
	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
		MST_MSCWR2 &= ~MST_MSCWR2_AC97_SPKROFF;
	return 0;
}

Takashi Iwai's avatar
Takashi Iwai committed
245
static void mst_audio_shutdown(struct snd_pcm_substream *substream, void *priv)
Linus Torvalds's avatar
Linus Torvalds committed
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270
{
	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
		MST_MSCWR2 |= MST_MSCWR2_AC97_SPKROFF;
}

static long mst_audio_suspend_mask;

static void mst_audio_suspend(void *priv)
{
	mst_audio_suspend_mask = MST_MSCWR2;
	MST_MSCWR2 |= MST_MSCWR2_AC97_SPKROFF;
}

static void mst_audio_resume(void *priv)
{
	MST_MSCWR2 &= mst_audio_suspend_mask | ~MST_MSCWR2_AC97_SPKROFF;
}

static pxa2xx_audio_ops_t mst_audio_ops = {
	.startup	= mst_audio_startup,
	.shutdown	= mst_audio_shutdown,
	.suspend	= mst_audio_suspend,
	.resume		= mst_audio_resume,
};

271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 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
static struct resource flash_resources[] = {
	[0] = {
		.start	= PXA_CS0_PHYS,
		.end	= PXA_CS0_PHYS + SZ_64M - 1,
		.flags	= IORESOURCE_MEM,
	},
	[1] = {
		.start	= PXA_CS1_PHYS,
		.end	= PXA_CS1_PHYS + SZ_64M - 1,
		.flags	= IORESOURCE_MEM,
	},
};

static struct mtd_partition mainstoneflash0_partitions[] = {
	{
		.name =		"Bootloader",
		.size =		0x00040000,
		.offset =	0,
		.mask_flags =	MTD_WRITEABLE  /* force read-only */
	},{
		.name =		"Kernel",
		.size =		0x00400000,
		.offset =	0x00040000,
	},{
		.name =		"Filesystem",
		.size =		MTDPART_SIZ_FULL,
		.offset =	0x00440000
	}
};

static struct flash_platform_data mst_flash_data[2] = {
	{
		.map_name	= "cfi_probe",
		.parts		= mainstoneflash0_partitions,
		.nr_parts	= ARRAY_SIZE(mainstoneflash0_partitions),
	}, {
		.map_name	= "cfi_probe",
		.parts		= NULL,
		.nr_parts	= 0,
	}
};

static struct platform_device mst_flash_device[2] = {
	{
		.name		= "pxa2xx-flash",
		.id		= 0,
		.dev = {
			.platform_data = &mst_flash_data[0],
		},
		.resource = &flash_resources[0],
		.num_resources = 1,
	},
	{
		.name		= "pxa2xx-flash",
		.id		= 1,
		.dev = {
			.platform_data = &mst_flash_data[1],
		},
		.resource = &flash_resources[1],
		.num_resources = 1,
	},
};

334 335 336 337 338 339 340
#if defined(CONFIG_FB_PXA) || defined(CONFIG_FB_PXA_MODULE)
static struct platform_pwm_backlight_data mainstone_backlight_data = {
	.pwm_id		= 0,
	.max_brightness	= 1023,
	.dft_brightness	= 1023,
	.pwm_period_ns	= 78770,
};
341

342 343 344 345 346 347
static struct platform_device mainstone_backlight_device = {
	.name		= "pwm-backlight",
	.dev		= {
		.parent = &pxa27x_device_pwm0.dev,
		.platform_data = &mainstone_backlight_data,
	},
348 349 350 351
};

static void __init mainstone_backlight_register(void)
{
352 353 354
	int ret = platform_device_register(&mainstone_backlight_device);
	if (ret)
		printk(KERN_ERR "mainstone: failed to register backlight device: %d\n", ret);
Linus Torvalds's avatar
Linus Torvalds committed
355
}
356 357 358
#else
#define mainstone_backlight_register()	do { } while (0)
#endif
Linus Torvalds's avatar
Linus Torvalds committed
359

360
static struct pxafb_mode_info toshiba_ltm04c380k_mode = {
Linus Torvalds's avatar
Linus Torvalds committed
361 362 363 364 365 366 367 368 369 370 371 372 373
	.pixclock		= 50000,
	.xres			= 640,
	.yres			= 480,
	.bpp			= 16,
	.hsync_len		= 1,
	.left_margin		= 0x9f,
	.right_margin		= 1,
	.vsync_len		= 44,
	.upper_margin		= 0,
	.lower_margin		= 0,
	.sync			= FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT,
};

374
static struct pxafb_mode_info toshiba_ltm035a776c_mode = {
Linus Torvalds's avatar
Linus Torvalds committed
375 376 377 378 379 380 381 382 383 384 385
	.pixclock		= 110000,
	.xres			= 240,
	.yres			= 320,
	.bpp			= 16,
	.hsync_len		= 4,
	.left_margin		= 8,
	.right_margin		= 20,
	.vsync_len		= 3,
	.upper_margin		= 1,
	.lower_margin		= 10,
	.sync			= FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT,
386 387 388 389
};

static struct pxafb_mach_info mainstone_pxafb_info = {
	.num_modes      	= 1,
390
	.lcd_conn		= LCD_COLOR_TFT_16BPP | LCD_PCLK_EDGE_FALL,
Linus Torvalds's avatar
Linus Torvalds committed
391 392
};

393
static int mainstone_mci_init(struct device *dev, irq_handler_t mstone_detect_int, void *data)
Linus Torvalds's avatar
Linus Torvalds committed
394 395 396 397 398 399 400 401
{
	int err;

	/* make sure SD/Memory Stick multiplexer's signals
	 * are routed to MMC controller
	 */
	MST_MSCWR1 &= ~MST_MSCWR1_MS_SEL;

402
	err = request_irq(MAINSTONE_MMC_IRQ, mstone_detect_int, IRQF_DISABLED,
Linus Torvalds's avatar
Linus Torvalds committed
403
			     "MMC card detect", data);
404
	if (err)
Linus Torvalds's avatar
Linus Torvalds committed
405 406
		printk(KERN_ERR "mainstone_mci_init: MMC/SD: can't request MMC card detect IRQ\n");

407
	return err;
Linus Torvalds's avatar
Linus Torvalds committed
408 409 410 411 412 413 414
}

static void mainstone_mci_setpower(struct device *dev, unsigned int vdd)
{
	struct pxamci_platform_data* p_d = dev->platform_data;

	if (( 1 << vdd) & p_d->ocr_mask) {
415
		printk(KERN_DEBUG "%s: on\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
416 417 418
		MST_MSCWR1 |= MST_MSCWR1_MMC_ON;
		MST_MSCWR1 &= ~MST_MSCWR1_MS_SEL;
	} else {
419
		printk(KERN_DEBUG "%s: off\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
420 421 422 423 424 425 426 427 428 429
		MST_MSCWR1 &= ~MST_MSCWR1_MMC_ON;
	}
}

static void mainstone_mci_exit(struct device *dev, void *data)
{
	free_irq(MAINSTONE_MMC_IRQ, data);
}

static struct pxamci_platform_data mainstone_mci_platform_data = {
430 431 432 433 434 435 436
	.ocr_mask		= MMC_VDD_32_33|MMC_VDD_33_34,
	.init 			= mainstone_mci_init,
	.setpower 		= mainstone_mci_setpower,
	.exit			= mainstone_mci_exit,
	.gpio_card_detect	= -1,
	.gpio_card_ro		= -1,
	.gpio_power		= -1,
Linus Torvalds's avatar
Linus Torvalds committed
437 438
};

439 440 441 442 443 444 445 446 447 448
static void mainstone_irda_transceiver_mode(struct device *dev, int mode)
{
	unsigned long flags;

	local_irq_save(flags);
	if (mode & IR_SIRMODE) {
		MST_MSCWR1 &= ~MST_MSCWR1_IRDA_FIR;
	} else if (mode & IR_FIRMODE) {
		MST_MSCWR1 |= MST_MSCWR1_IRDA_FIR;
	}
449
	pxa2xx_transceiver_mode(dev, mode);
450 451 452 453 454 455 456 457 458
	if (mode & IR_OFF) {
		MST_MSCWR1 = (MST_MSCWR1 & ~MST_MSCWR1_IRDA_MASK) | MST_MSCWR1_IRDA_OFF;
	} else {
		MST_MSCWR1 = (MST_MSCWR1 & ~MST_MSCWR1_IRDA_MASK) | MST_MSCWR1_IRDA_FULL;
	}
	local_irq_restore(flags);
}

static struct pxaficp_platform_data mainstone_ficp_platform_data = {
459 460 461
	.gpio_pwdown		= -1,
	.transceiver_cap	= IR_SIRMODE | IR_FIRMODE | IR_OFF,
	.transceiver_mode	= mainstone_irda_transceiver_mode,
462 463
};

464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
static struct gpio_keys_button gpio_keys_button[] = {
	[0] = {
		.desc	= "wakeup",
		.code	= KEY_SUSPEND,
		.type	= EV_KEY,
		.gpio	= 1,
		.wakeup	= 1,
	},
};

static struct gpio_keys_platform_data mainstone_gpio_keys = {
	.buttons	= gpio_keys_button,
	.nbuttons	= 1,
};

static struct platform_device mst_gpio_keys_device = {
	.name		= "gpio-keys",
	.id		= -1,
	.dev		= {
		.platform_data	= &mainstone_gpio_keys,
	},
};

487 488 489 490
static struct platform_device *platform_devices[] __initdata = {
	&smc91x_device,
	&mst_flash_device[0],
	&mst_flash_device[1],
491
	&mst_gpio_keys_device,
492 493
};

494 495
static struct pxaohci_platform_data mainstone_ohci_platform_data = {
	.port_mode	= PMM_PERPORT_MODE,
496
	.flags		= ENABLE_PORT_ALL | POWER_CONTROL_LOW | POWER_SENSE_LOW,
497 498
};

499
#if defined(CONFIG_KEYBOARD_PXA27x) || defined(CONFIG_KEYBOARD_PXA27x_MODULE)
500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549
static unsigned int mainstone_matrix_keys[] = {
	KEY(0, 0, KEY_A), KEY(1, 0, KEY_B), KEY(2, 0, KEY_C),
	KEY(3, 0, KEY_D), KEY(4, 0, KEY_E), KEY(5, 0, KEY_F),
	KEY(0, 1, KEY_G), KEY(1, 1, KEY_H), KEY(2, 1, KEY_I),
	KEY(3, 1, KEY_J), KEY(4, 1, KEY_K), KEY(5, 1, KEY_L),
	KEY(0, 2, KEY_M), KEY(1, 2, KEY_N), KEY(2, 2, KEY_O),
	KEY(3, 2, KEY_P), KEY(4, 2, KEY_Q), KEY(5, 2, KEY_R),
	KEY(0, 3, KEY_S), KEY(1, 3, KEY_T), KEY(2, 3, KEY_U),
	KEY(3, 3, KEY_V), KEY(4, 3, KEY_W), KEY(5, 3, KEY_X),
	KEY(2, 4, KEY_Y), KEY(3, 4, KEY_Z),

	KEY(0, 4, KEY_DOT),	/* . */
	KEY(1, 4, KEY_CLOSE),	/* @ */
	KEY(4, 4, KEY_SLASH),
	KEY(5, 4, KEY_BACKSLASH),
	KEY(0, 5, KEY_HOME),
	KEY(1, 5, KEY_LEFTSHIFT),
	KEY(2, 5, KEY_SPACE),
	KEY(3, 5, KEY_SPACE),
	KEY(4, 5, KEY_ENTER),
	KEY(5, 5, KEY_BACKSPACE),

	KEY(0, 6, KEY_UP),
	KEY(1, 6, KEY_DOWN),
	KEY(2, 6, KEY_LEFT),
	KEY(3, 6, KEY_RIGHT),
	KEY(4, 6, KEY_SELECT),
};

struct pxa27x_keypad_platform_data mainstone_keypad_info = {
	.matrix_key_rows	= 6,
	.matrix_key_cols	= 7,
	.matrix_key_map		= mainstone_matrix_keys,
	.matrix_key_map_size	= ARRAY_SIZE(mainstone_matrix_keys),

	.enable_rotary0		= 1,
	.rotary0_up_key		= KEY_UP,
	.rotary0_down_key	= KEY_DOWN,

	.debounce_interval	= 30,
};

static void __init mainstone_init_keypad(void)
{
	pxa_set_keypad_info(&mainstone_keypad_info);
}
#else
static inline void mainstone_init_keypad(void) {}
#endif

Linus Torvalds's avatar
Linus Torvalds committed
550 551
static void __init mainstone_init(void)
{
552 553
	int SW7 = 0;  /* FIXME: get from SCR (Mst doc section 3.2.1.1) */

554 555
	pxa2xx_mfp_config(ARRAY_AND_SIZE(mainstone_pin_config));

556 557 558 559
	pxa_set_ffuart_info(NULL);
	pxa_set_btuart_info(NULL);
	pxa_set_stuart_info(NULL);

560
	mst_flash_data[0].width = (__raw_readl(BOOT_DEF) & 1) ? 2 : 4;
561 562 563 564 565 566 567 568 569
	mst_flash_data[1].width = 4;

	/* Compensate for SW7 which swaps the flash banks */
	mst_flash_data[SW7].name = "processor-flash";
	mst_flash_data[SW7 ^ 1].name = "mainboard-flash";

	printk(KERN_NOTICE "Mainstone configured to boot from %s\n",
	       mst_flash_data[0].name);

570 571 572 573 574 575
	/* system bus arbiter setting
	 * - Core_Park
	 * - LCD_wt:DMA_wt:CORE_Wt = 2:3:4
	 */
	ARB_CNTRL = ARB_CORE_PARK | 0x234;

576
	platform_add_devices(platform_devices, ARRAY_SIZE(platform_devices));
Linus Torvalds's avatar
Linus Torvalds committed
577 578 579 580

	/* reading Mainstone's "Virtual Configuration Register"
	   might be handy to select LCD type here */
	if (0)
581
		mainstone_pxafb_info.modes = &toshiba_ltm04c380k_mode;
Linus Torvalds's avatar
Linus Torvalds committed
582
	else
583 584
		mainstone_pxafb_info.modes = &toshiba_ltm035a776c_mode;

585
	pxa_set_fb_info(NULL, &mainstone_pxafb_info);
586
	mainstone_backlight_register();
Linus Torvalds's avatar
Linus Torvalds committed
587 588

	pxa_set_mci_info(&mainstone_mci_platform_data);
589
	pxa_set_ficp_info(&mainstone_ficp_platform_data);
590
	pxa_set_ohci_info(&mainstone_ohci_platform_data);
591
	pxa_set_i2c_info(NULL);
592
	pxa_set_ac97_info(&mst_audio_ops);
593 594

	mainstone_init_keypad();
Linus Torvalds's avatar
Linus Torvalds committed
595 596 597 598
}


static struct map_desc mainstone_io_desc[] __initdata = {
599 600 601 602 603 604
  	{	/* CPLD */
		.virtual	=  MST_FPGA_VIRT,
		.pfn		= __phys_to_pfn(MST_FPGA_PHYS),
		.length		= 0x00100000,
		.type		= MT_DEVICE
	}
Linus Torvalds's avatar
Linus Torvalds committed
605 606 607 608
};

static void __init mainstone_map_io(void)
{
609
	pxa27x_map_io();
Linus Torvalds's avatar
Linus Torvalds committed
610 611
	iotable_init(mainstone_io_desc, ARRAY_SIZE(mainstone_io_desc));

612 613 614
 	/*	for use I SRAM as framebuffer.	*/
 	PSLR |= 0xF04;
 	PCFR = 0x66;
Linus Torvalds's avatar
Linus Torvalds committed
615 616 617
}

MACHINE_START(MAINSTONE, "Intel HCDDBBVA0 Development Platform (aka Mainstone)")
618
	/* Maintainer: MontaVista Software Inc. */
619
	.boot_params	= 0xa0000100,	/* BLOB boot parameter setting */
620
	.map_io		= mainstone_map_io,
621
	.nr_irqs	= MAINSTONE_NR_IRQS,
622
	.init_irq	= mainstone_init_irq,
623
	.handle_irq	= pxa27x_handle_irq,
Linus Torvalds's avatar
Linus Torvalds committed
624
	.timer		= &pxa_timer,
625
	.init_machine	= mainstone_init,
Linus Torvalds's avatar
Linus Torvalds committed
626
MACHINE_END