board-omap3pandora.c 15.9 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/*
 * board-omap3pandora.c (Pandora Handheld Console)
 *
 * 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.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 *
 */

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/platform_device.h>

#include <linux/spi/spi.h>
25
#include <linux/regulator/machine.h>
26
#include <linux/i2c/twl.h>
27
#include <linux/wl12xx.h>
28 29
#include <linux/mtd/partitions.h>
#include <linux/mtd/nand.h>
30 31
#include <linux/leds.h>
#include <linux/input.h>
32
#include <linux/input/matrix_keypad.h>
33
#include <linux/gpio.h>
34
#include <linux/gpio_keys.h>
35
#include <linux/mmc/host.h>
36
#include <linux/mmc/card.h>
37
#include <linux/regulator/fixed.h>
38 39 40 41 42

#include <asm/mach-types.h>
#include <asm/mach/arch.h>
#include <asm/mach/map.h>

43 44
#include <plat/board.h>
#include <plat/common.h>
45
#include <mach/hardware.h>
46 47
#include <plat/mcspi.h>
#include <plat/usb.h>
48
#include <video/omapdss.h>
49
#include <plat/nand.h>
50

51
#include "mux.h"
52
#include "sdram-micron-mt46h32m32lf-6.h"
53
#include "hsmmc.h"
54
#include "common-board-devices.h"
55

56 57
#define PANDORA_WIFI_IRQ_GPIO		21
#define PANDORA_WIFI_NRESET_GPIO	23
58 59
#define OMAP3_PANDORA_TS_GPIO		94

60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86
static struct mtd_partition omap3pandora_nand_partitions[] = {
	{
		.name           = "xloader",
		.offset         = 0,
		.size           = 4 * NAND_BLOCK_SIZE,
		.mask_flags     = MTD_WRITEABLE
	}, {
		.name           = "uboot",
		.offset         = MTDPART_OFS_APPEND,
		.size           = 15 * NAND_BLOCK_SIZE,
	}, {
		.name           = "uboot-env",
		.offset         = MTDPART_OFS_APPEND,
		.size           = 1 * NAND_BLOCK_SIZE,
	}, {
		.name           = "boot",
		.offset         = MTDPART_OFS_APPEND,
		.size           = 80 * NAND_BLOCK_SIZE,
	}, {
		.name           = "rootfs",
		.offset         = MTDPART_OFS_APPEND,
		.size           = MTDPART_SIZ_FULL,
	},
};

static struct omap_nand_platform_data pandora_nand_data = {
	.cs		= 0,
87 88
	.devsize	= NAND_BUSWIDTH_16,
	.xfer_type	= NAND_OMAP_PREFETCH_DMA,
89 90 91 92
	.parts		= omap3pandora_nand_partitions,
	.nr_parts	= ARRAY_SIZE(omap3pandora_nand_partitions),
};

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 124 125 126 127 128 129
static struct gpio_led pandora_gpio_leds[] = {
	{
		.name			= "pandora::sd1",
		.default_trigger	= "mmc0",
		.gpio			= 128,
	}, {
		.name			= "pandora::sd2",
		.default_trigger	= "mmc1",
		.gpio			= 129,
	}, {
		.name			= "pandora::bluetooth",
		.gpio			= 158,
	}, {
		.name			= "pandora::wifi",
		.gpio			= 159,
	},
};

static struct gpio_led_platform_data pandora_gpio_led_data = {
	.leds		= pandora_gpio_leds,
	.num_leds	= ARRAY_SIZE(pandora_gpio_leds),
};

static struct platform_device pandora_leds_gpio = {
	.name	= "leds-gpio",
	.id	= -1,
	.dev	= {
		.platform_data	= &pandora_gpio_led_data,
	},
};

#define GPIO_BUTTON(gpio_num, ev_type, ev_code, act_low, descr)	\
{								\
	.gpio		= gpio_num,				\
	.type		= ev_type,				\
	.code		= ev_code,				\
	.active_low	= act_low,				\
130
	.debounce_interval = 4,					\
131 132 133 134 135 136 137 138 139 140 141
	.desc		= "btn " descr,				\
}

#define GPIO_BUTTON_LOW(gpio_num, event_code, description)	\
	GPIO_BUTTON(gpio_num, EV_KEY, event_code, 1, description)

static struct gpio_keys_button pandora_gpio_keys[] = {
	GPIO_BUTTON_LOW(110,	KEY_UP,		"up"),
	GPIO_BUTTON_LOW(103,	KEY_DOWN,	"down"),
	GPIO_BUTTON_LOW(96,	KEY_LEFT,	"left"),
	GPIO_BUTTON_LOW(98,	KEY_RIGHT,	"right"),
142 143 144 145 146 147 148 149
	GPIO_BUTTON_LOW(109,	KEY_PAGEUP,	"game 1"),
	GPIO_BUTTON_LOW(111,	KEY_END,	"game 2"),
	GPIO_BUTTON_LOW(106,	KEY_PAGEDOWN,	"game 3"),
	GPIO_BUTTON_LOW(101,	KEY_HOME,	"game 4"),
	GPIO_BUTTON_LOW(102,	KEY_RIGHTSHIFT,	"l"),
	GPIO_BUTTON_LOW(97,	KEY_KPPLUS,	"l2"),
	GPIO_BUTTON_LOW(105,	KEY_RIGHTCTRL,	"r"),
	GPIO_BUTTON_LOW(107,	KEY_KPMINUS,	"r2"),
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
	GPIO_BUTTON_LOW(104,	KEY_LEFTCTRL,	"ctrl"),
	GPIO_BUTTON_LOW(99,	KEY_MENU,	"menu"),
	GPIO_BUTTON_LOW(176,	KEY_COFFEE,	"hold"),
	GPIO_BUTTON(100, EV_KEY, KEY_LEFTALT, 0, "alt"),
	GPIO_BUTTON(108, EV_SW, SW_LID, 1, "lid"),
};

static struct gpio_keys_platform_data pandora_gpio_key_info = {
	.buttons	= pandora_gpio_keys,
	.nbuttons	= ARRAY_SIZE(pandora_gpio_keys),
};

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

170
static const uint32_t board_keymap[] = {
171
	/* row, col, code */
172
	KEY(0, 0, KEY_9),
173 174 175 176 177 178
	KEY(0, 1, KEY_8),
	KEY(0, 2, KEY_I),
	KEY(0, 3, KEY_J),
	KEY(0, 4, KEY_N),
	KEY(0, 5, KEY_M),
	KEY(1, 0, KEY_0),
179
	KEY(1, 1, KEY_7),
180 181 182 183 184 185
	KEY(1, 2, KEY_U),
	KEY(1, 3, KEY_H),
	KEY(1, 4, KEY_B),
	KEY(1, 5, KEY_SPACE),
	KEY(2, 0, KEY_BACKSPACE),
	KEY(2, 1, KEY_6),
186
	KEY(2, 2, KEY_Y),
187 188 189 190 191 192
	KEY(2, 3, KEY_G),
	KEY(2, 4, KEY_V),
	KEY(2, 5, KEY_FN),
	KEY(3, 0, KEY_O),
	KEY(3, 1, KEY_5),
	KEY(3, 2, KEY_T),
193
	KEY(3, 3, KEY_F),
194 195 196 197 198
	KEY(3, 4, KEY_C),
	KEY(4, 0, KEY_P),
	KEY(4, 1, KEY_4),
	KEY(4, 2, KEY_R),
	KEY(4, 3, KEY_D),
199
	KEY(4, 4, KEY_X),
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214
	KEY(5, 0, KEY_K),
	KEY(5, 1, KEY_3),
	KEY(5, 2, KEY_E),
	KEY(5, 3, KEY_S),
	KEY(5, 4, KEY_Z),
	KEY(6, 0, KEY_L),
	KEY(6, 1, KEY_2),
	KEY(6, 2, KEY_W),
	KEY(6, 3, KEY_A),
	KEY(6, 4, KEY_DOT),
	KEY(7, 0, KEY_ENTER),
	KEY(7, 1, KEY_1),
	KEY(7, 2, KEY_Q),
	KEY(7, 3, KEY_LEFTSHIFT),
	KEY(7, 4, KEY_COMMA),
215 216
};

217 218 219 220 221
static struct matrix_keymap_data board_map_data = {
	.keymap			= board_keymap,
	.keymap_size		= ARRAY_SIZE(board_keymap),
};

222
static struct twl4030_keypad_data pandora_kp_data = {
223
	.keymap_data	= &board_map_data,
224 225 226 227 228
	.rows		= 8,
	.cols		= 6,
	.rep		= 1,
};

229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254
static struct omap_dss_device pandora_lcd_device = {
	.name			= "lcd",
	.driver_name		= "tpo_td043mtea1_panel",
	.type			= OMAP_DISPLAY_TYPE_DPI,
	.phy.dpi.data_lines	= 24,
	.reset_gpio		= 157,
};

static struct omap_dss_device pandora_tv_device = {
	.name			= "tv",
	.driver_name		= "venc",
	.type			= OMAP_DISPLAY_TYPE_VENC,
	.phy.venc.type		= OMAP_DSS_VENC_TYPE_SVIDEO,
};

static struct omap_dss_device *pandora_dss_devices[] = {
	&pandora_lcd_device,
	&pandora_tv_device,
};

static struct omap_dss_board_info pandora_dss_data = {
	.num_devices	= ARRAY_SIZE(pandora_dss_devices),
	.devices	= pandora_dss_devices,
	.default_device	= &pandora_lcd_device,
};

255 256 257 258 259 260 261 262 263 264 265 266 267 268
static void pandora_wl1251_init_card(struct mmc_card *card)
{
	/*
	 * We have TI wl1251 attached to MMC3. Pass this information to
	 * SDIO core because it can't be probed by normal methods.
	 */
	card->quirks |= MMC_QUIRK_NONSTD_SDIO;
	card->cccr.wide_bus = 1;
	card->cis.vendor = 0x104c;
	card->cis.device = 0x9066;
	card->cis.blksize = 512;
	card->cis.max_dtr = 20000000;
}

269
static struct omap2_hsmmc_info omap3pandora_mmc[] = {
270 271
	{
		.mmc		= 1,
272
		.caps		= MMC_CAP_4_BIT_DATA,
273 274 275 276 277 278
		.gpio_cd	= -EINVAL,
		.gpio_wp	= 126,
		.ext_clock	= 0,
	},
	{
		.mmc		= 2,
279
		.caps		= MMC_CAP_4_BIT_DATA,
280 281 282
		.gpio_cd	= -EINVAL,
		.gpio_wp	= 127,
		.ext_clock	= 1,
283
		.transceiver	= true,
284
	},
285 286
	{
		.mmc		= 3,
287
		.caps		= MMC_CAP_4_BIT_DATA | MMC_CAP_POWER_OFF_CARD,
288 289
		.gpio_cd	= -EINVAL,
		.gpio_wp	= -EINVAL,
290
		.init_card	= pandora_wl1251_init_card,
291
	},
292 293 294 295 296 297
	{}	/* Terminator */
};

static int omap3pandora_twl_gpio_setup(struct device *dev,
		unsigned gpio, unsigned ngpio)
{
298 299
	int ret, gpio_32khz;

300 301 302
	/* gpio + {0,1} is "mmc{0,1}_cd" (input/IRQ) */
	omap3pandora_mmc[0].gpio_cd = gpio + 0;
	omap3pandora_mmc[1].gpio_cd = gpio + 1;
303
	omap2_hsmmc_init(omap3pandora_mmc);
304

305 306
	/* gpio + 13 drives 32kHz buffer for wifi module */
	gpio_32khz = gpio + 13;
I
Igor Grinberg 已提交
307
	ret = gpio_request_one(gpio_32khz, GPIOF_OUT_INIT_HIGH, "wifi 32kHz");
308 309
	if (ret < 0) {
		pr_err("Cannot get GPIO line %d, ret=%d\n", gpio_32khz, ret);
I
Igor Grinberg 已提交
310
		return -ENODEV;
311 312
	}

313 314 315
	return 0;
}

316 317 318 319
static struct twl4030_gpio_platform_data omap3pandora_gpio_data = {
	.gpio_base	= OMAP_MAX_GPIO_LINES,
	.irq_base	= TWL4030_GPIO_IRQ_BASE,
	.irq_end	= TWL4030_GPIO_IRQ_END,
320
	.setup		= omap3pandora_twl_gpio_setup,
321 322
};

323 324 325
static struct regulator_consumer_supply pandora_vmmc1_supply[] = {
	REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
};
326

327 328 329
static struct regulator_consumer_supply pandora_vmmc2_supply[] = {
	REGULATOR_SUPPLY("vmmc", "omap_hsmmc.1")
};
330

331 332 333
static struct regulator_consumer_supply pandora_vmmc3_supply[] = {
	REGULATOR_SUPPLY("vmmc", "omap_hsmmc.2"),
};
334

335 336 337
static struct regulator_consumer_supply pandora_vdds_supplies[] = {
	REGULATOR_SUPPLY("vdds_sdi", "omapdss"),
	REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
338
	REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi.0"),
339 340
};

341 342 343
static struct regulator_consumer_supply pandora_vcc_lcd_supply[] = {
	REGULATOR_SUPPLY("vcc", "display0"),
};
344

345 346 347
static struct regulator_consumer_supply pandora_usb_phy_supply[] = {
	REGULATOR_SUPPLY("hsusb0", "ehci-omap.0"),
};
348 349 350 351 352 353 354 355

/* ads7846 on SPI and 2 nub controllers on I2C */
static struct regulator_consumer_supply pandora_vaux4_supplies[] = {
	REGULATOR_SUPPLY("vcc", "spi1.0"),
	REGULATOR_SUPPLY("vcc", "3-0066"),
	REGULATOR_SUPPLY("vcc", "3-0067"),
};

356 357 358
static struct regulator_consumer_supply pandora_adac_supply[] = {
	REGULATOR_SUPPLY("vcc", "soc-audio"),
};
359

360 361 362 363 364 365 366 367 368 369 370
/* VMMC1 for MMC1 pins CMD, CLK, DAT0..DAT3 (20 mA, plus card == max 220 mA) */
static struct regulator_init_data pandora_vmmc1 = {
	.constraints = {
		.min_uV			= 1850000,
		.max_uV			= 3150000,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_VOLTAGE
					| REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
371 372
	.num_consumer_supplies	= ARRAY_SIZE(pandora_vmmc1_supply),
	.consumer_supplies	= pandora_vmmc1_supply,
373 374 375 376 377 378 379 380 381 382 383 384 385
};

/* VMMC2 for MMC2 pins CMD, CLK, DAT0..DAT3 (max 100 mA) */
static struct regulator_init_data pandora_vmmc2 = {
	.constraints = {
		.min_uV			= 1850000,
		.max_uV			= 3150000,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_VOLTAGE
					| REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
386 387
	.num_consumer_supplies	= ARRAY_SIZE(pandora_vmmc2_supply),
	.consumer_supplies	= pandora_vmmc2_supply,
388 389
};

390 391 392 393 394 395 396 397 398 399 400
/* VAUX1 for LCD */
static struct regulator_init_data pandora_vaux1 = {
	.constraints = {
		.min_uV			= 3000000,
		.max_uV			= 3000000,
		.apply_uV		= true,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
401 402
	.num_consumer_supplies	= ARRAY_SIZE(pandora_vcc_lcd_supply),
	.consumer_supplies	= pandora_vcc_lcd_supply,
403 404
};

405 406 407 408 409 410 411 412 413 414 415
/* VAUX2 for USB host PHY */
static struct regulator_init_data pandora_vaux2 = {
	.constraints = {
		.min_uV			= 1800000,
		.max_uV			= 1800000,
		.apply_uV		= true,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
416 417
	.num_consumer_supplies	= ARRAY_SIZE(pandora_usb_phy_supply),
	.consumer_supplies	= pandora_usb_phy_supply,
418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445
};

/* VAUX4 for ads7846 and nubs */
static struct regulator_init_data pandora_vaux4 = {
	.constraints = {
		.min_uV			= 2800000,
		.max_uV			= 2800000,
		.apply_uV		= true,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
	.num_consumer_supplies	= ARRAY_SIZE(pandora_vaux4_supplies),
	.consumer_supplies	= pandora_vaux4_supplies,
};

/* VSIM for audio DAC */
static struct regulator_init_data pandora_vsim = {
	.constraints = {
		.min_uV			= 2800000,
		.max_uV			= 2800000,
		.apply_uV		= true,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
446 447
	.num_consumer_supplies	= ARRAY_SIZE(pandora_adac_supply),
	.consumer_supplies	= pandora_adac_supply,
448 449
};

450 451 452 453 454
/* Fixed regulator internal to Wifi module */
static struct regulator_init_data pandora_vmmc3 = {
	.constraints = {
		.valid_ops_mask		= REGULATOR_CHANGE_STATUS,
	},
455 456
	.num_consumer_supplies	= ARRAY_SIZE(pandora_vmmc3_supply),
	.consumer_supplies	= pandora_vmmc3_supply,
457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476
};

static struct fixed_voltage_config pandora_vwlan = {
	.supply_name		= "vwlan",
	.microvolts		= 1800000, /* 1.8V */
	.gpio			= PANDORA_WIFI_NRESET_GPIO,
	.startup_delay		= 50000, /* 50ms */
	.enable_high		= 1,
	.enabled_at_boot	= 0,
	.init_data		= &pandora_vmmc3,
};

static struct platform_device pandora_vwlan_device = {
	.name		= "reg-fixed-voltage",
	.id		= 1,
	.dev = {
		.platform_data = &pandora_vwlan,
	},
};

477 478
static struct twl4030_bci_platform_data pandora_bci_data;

479 480
static struct twl4030_platform_data omap3pandora_twldata = {
	.gpio		= &omap3pandora_gpio_data,
481 482
	.vmmc1		= &pandora_vmmc1,
	.vmmc2		= &pandora_vmmc2,
483
	.vaux1		= &pandora_vaux1,
484 485 486
	.vaux2		= &pandora_vaux2,
	.vaux4		= &pandora_vaux4,
	.vsim		= &pandora_vsim,
487
	.keypad		= &pandora_kp_data,
488
	.bci		= &pandora_bci_data,
489 490
};

491 492 493 494 495 496 497
static struct i2c_board_info __initdata omap3pandora_i2c3_boardinfo[] = {
	{
		I2C_BOARD_INFO("bq27500", 0x55),
		.flags = I2C_CLIENT_WAKE,
	},
};

498 499
static int __init omap3pandora_i2c_init(void)
{
500
	omap3_pmic_get_config(&omap3pandora_twldata,
501 502 503 504 505 506 507 508 509 510
			TWL_COMMON_PDATA_USB | TWL_COMMON_PDATA_AUDIO,
			TWL_COMMON_REGULATOR_VDAC | TWL_COMMON_REGULATOR_VPLL2);

	omap3pandora_twldata.vdac->constraints.apply_uV = true;

	omap3pandora_twldata.vpll2->constraints.apply_uV = true;
	omap3pandora_twldata.vpll2->num_consumer_supplies =
					ARRAY_SIZE(pandora_vdds_supplies);
	omap3pandora_twldata.vpll2->consumer_supplies = pandora_vdds_supplies;

511
	omap3_pmic_init("tps65950", &omap3pandora_twldata);
512
	/* i2c2 pins are not connected */
513 514
	omap_register_i2c_bus(3, 100, omap3pandora_i2c3_boardinfo,
			ARRAY_SIZE(omap3pandora_i2c3_boardinfo));
515 516 517 518 519
	return 0;
}

static struct spi_board_info omap3pandora_spi_board_info[] __initdata = {
	{
520 521 522 523 524
		.modalias		= "tpo_td043mtea1_panel_spi",
		.bus_num		= 1,
		.chip_select		= 1,
		.max_speed_hz		= 375000,
		.platform_data		= &pandora_lcd_device,
525 526 527
	}
};

528
static void __init pandora_wl1251_init(void)
529
{
530
	struct wl12xx_platform_data pandora_wl1251_pdata;
531 532
	int ret;

533 534
	memset(&pandora_wl1251_pdata, 0, sizeof(pandora_wl1251_pdata));

I
Igor Grinberg 已提交
535
	ret = gpio_request_one(PANDORA_WIFI_IRQ_GPIO, GPIOF_IN, "wl1251 irq");
536 537 538 539 540 541 542
	if (ret < 0)
		goto fail;

	pandora_wl1251_pdata.irq = gpio_to_irq(PANDORA_WIFI_IRQ_GPIO);
	if (pandora_wl1251_pdata.irq < 0)
		goto fail_irq;

543 544 545 546 547
	pandora_wl1251_pdata.use_eeprom = true;
	ret = wl12xx_set_platform_data(&pandora_wl1251_pdata);
	if (ret < 0)
		goto fail_irq;

548 549 550 551 552 553 554 555
	return;

fail_irq:
	gpio_free(PANDORA_WIFI_IRQ_GPIO);
fail:
	printk(KERN_ERR "wl1251 board initialisation failed\n");
}

556
static struct platform_device *omap3pandora_devices[] __initdata = {
557 558
	&pandora_leds_gpio,
	&pandora_keys_gpio,
559
	&pandora_vwlan_device,
560 561
};

562
static const struct usbhs_omap_board_data usbhs_bdata __initconst = {
563

564 565 566
	.port_mode[0] = OMAP_EHCI_PORT_MODE_PHY,
	.port_mode[1] = OMAP_USBHS_PORT_MODE_UNUSED,
	.port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
567 568 569 570 571 572 573

	.phy_reset  = true,
	.reset_gpio_port[0]  = 16,
	.reset_gpio_port[1]  = -EINVAL,
	.reset_gpio_port[2]  = -EINVAL
};

574 575 576 577 578 579
#ifdef CONFIG_OMAP_MUX
static struct omap_board_mux board_mux[] __initdata = {
	{ .reg_offset = OMAP_MUX_TERMINATOR },
};
#endif

580 581
static void __init omap3pandora_init(void)
{
582
	omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
583
	omap3pandora_i2c_init();
584
	pandora_wl1251_init();
585 586
	platform_add_devices(omap3pandora_devices,
			ARRAY_SIZE(omap3pandora_devices));
587
	omap_display_init(&pandora_dss_data);
588
	omap_serial_init();
589 590
	omap_sdrc_init(mt46h32m32lf6_sdrc_params,
				  mt46h32m32lf6_sdrc_params);
591 592
	spi_register_board_info(omap3pandora_spi_board_info,
			ARRAY_SIZE(omap3pandora_spi_board_info));
593
	omap_ads7846_init(1, OMAP3_PANDORA_TS_GPIO, 0, NULL);
594
	usbhs_init(&usbhs_bdata);
595
	usb_musb_init(NULL);
596
	gpmc_nand_init(&pandora_nand_data);
597 598

	/* Ensure SDRC pins are mux'd for self-refresh */
599 600
	omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
	omap_mux_init_signal("sdrc_cke1", OMAP_PIN_OUTPUT);
601 602 603
}

MACHINE_START(OMAP3_PANDORA, "Pandora Handheld Console")
604
	.atag_offset	= 0x100,
605
	.reserve	= omap_reserve,
606
	.map_io		= omap3_map_io,
607
	.init_early	= omap35xx_init_early,
608
	.init_irq	= omap3_init_irq,
609
	.init_machine	= omap3pandora_init,
610
	.timer		= &omap3_timer,
611
MACHINE_END