[deliverable/linux.git] / arch / arm / mach-omap1 / board-palmte.c

/*
 * linux/arch/arm/mach-omap1/board-palmte.c
 *
 * Modified from board-generic.c
 *
 * Support for the Palm Tungsten E PDA.
 *
 * Original version : Laurent Gonzalez
 *
 * Maintainers : http://palmtelinux.sf.net
 *                palmtelinux-developpers@lists.sf.net
 *
 * Copyright (c) 2006 Andrzej Zaborowski  <balrog@zabor.org>
 *
 * 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/kernel.h>
#include <linux/init.h>
#include <linux/input.h>
#include <linux/platform_device.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/partitions.h>
#include <linux/spi/spi.h>
#include <linux/interrupt.h>
#include <linux/apm-emulation.h>

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

#include <mach/gpio.h>
#include <mach/mux.h>
#include <mach/usb.h>
#include <mach/tc.h>
#include <mach/dma.h>
#include <mach/board.h>
#include <mach/irda.h>
#include <mach/keypad.h>
#include <mach/common.h>

static void __init omap_palmte_init_irq(void)
{
	omap1_init_common_hw();
	omap_init_irq();
	omap_gpio_init();
}

static const int palmte_keymap[] = {
	KEY(0, 0, KEY_F1),		/* Calendar */
	KEY(0, 1, KEY_F2),		/* Contacts */
	KEY(0, 2, KEY_F3),		/* Tasks List */
	KEY(0, 3, KEY_F4),		/* Note Pad */
	KEY(0, 4, KEY_POWER),
	KEY(1, 0, KEY_LEFT),
	KEY(1, 1, KEY_DOWN),
	KEY(1, 2, KEY_UP),
	KEY(1, 3, KEY_RIGHT),
	KEY(1, 4, KEY_ENTER),
	0,
};

static struct omap_kp_platform_data palmte_kp_data = {
	.rows	= 8,
	.cols	= 8,
	.keymap = (int *) palmte_keymap,
	.rep	= 1,
	.delay	= 12,
};

static struct resource palmte_kp_resources[] = {
	[0]	= {
		.start	= INT_KEYBOARD,
		.end	= INT_KEYBOARD,
		.flags	= IORESOURCE_IRQ,
	},
};

static struct platform_device palmte_kp_device = {
	.name		= "omap-keypad",
	.id		= -1,
	.dev		= {
		.platform_data	= &palmte_kp_data,
	},
	.num_resources	= ARRAY_SIZE(palmte_kp_resources),
	.resource	= palmte_kp_resources,
};

static struct mtd_partition palmte_rom_partitions[] = {
	/* PalmOS "Small ROM", contains the bootloader and the debugger */
	{
		.name		= "smallrom",
		.offset		= 0,
		.size		= 0xa000,
		.mask_flags	= MTD_WRITEABLE,
	},
	/* PalmOS "Big ROM", a filesystem with all the OS code and data */
	{
		.name		= "bigrom",
		.offset		= SZ_128K,
		/*
		 * 0x5f0000 bytes big in the multi-language ("EFIGS") version,
		 * 0x7b0000 bytes in the English-only ("enUS") version.
		 */
		.size		= 0x7b0000,
		.mask_flags	= MTD_WRITEABLE,
	},
};

static struct flash_platform_data palmte_rom_data = {
	.map_name	= "map_rom",
	.width		= 2,
	.parts		= palmte_rom_partitions,
	.nr_parts	= ARRAY_SIZE(palmte_rom_partitions),
};

static struct resource palmte_rom_resource = {
	.start		= OMAP_CS0_PHYS,
	.end		= OMAP_CS0_PHYS + SZ_8M - 1,
	.flags		= IORESOURCE_MEM,
};

static struct platform_device palmte_rom_device = {
	.name		= "omapflash",
	.id		= -1,
	.dev		= {
		.platform_data	= &palmte_rom_data,
	},
	.num_resources	= 1,
	.resource	= &palmte_rom_resource,
};

static struct platform_device palmte_lcd_device = {
	.name		= "lcd_palmte",
	.id		= -1,
};

static struct omap_backlight_config palmte_backlight_config = {
	.default_intensity	= 0xa0,
};

static struct platform_device palmte_backlight_device = {
	.name		= "omap-bl",
	.id		= -1,
	.dev		= {
		.platform_data	= &palmte_backlight_config,
	},
};

static struct omap_irda_config palmte_irda_config = {
	.transceiver_cap	= IR_SIRMODE,
	.rx_channel		= OMAP_DMA_UART3_RX,
	.tx_channel		= OMAP_DMA_UART3_TX,
	.dest_start		= UART3_THR,
	.src_start		= UART3_RHR,
	.tx_trigger		= 0,
	.rx_trigger		= 0,
};

static struct resource palmte_irda_resources[] = {
	[0]	= {
		.start	= INT_UART3,
		.end	= INT_UART3,
		.flags	= IORESOURCE_IRQ,
	},
};

static struct platform_device palmte_irda_device = {
	.name		= "omapirda",
	.id		= -1,
	.dev		= {
		.platform_data	= &palmte_irda_config,
	},
	.num_resources	= ARRAY_SIZE(palmte_irda_resources),
	.resource	= palmte_irda_resources,
};

static struct platform_device *palmte_devices[] __initdata = {
	&palmte_rom_device,
	&palmte_kp_device,
	&palmte_lcd_device,
	&palmte_backlight_device,
	&palmte_irda_device,
};

static struct omap_usb_config palmte_usb_config __initdata = {
	.register_dev	= 1,	/* Mini-B only receptacle */
	.hmc_mode	= 0,
	.pins[0]	= 2,
};

static struct omap_lcd_config palmte_lcd_config __initdata = {
	.ctrl_name	= "internal",
};

static struct omap_uart_config palmte_uart_config __initdata = {
	.enabled_uarts = (1 << 0) | (1 << 1) | (0 << 2),
};

#ifdef CONFIG_APM
/*
 * Values measured in 10 minute intervals averaged over 10 samples.
 * May differ slightly from device to device but should be accurate
 * enough to give basic idea of battery life left and trigger
 * potential alerts.
 */
static const int palmte_battery_sample[] = {
	2194, 2157, 2138, 2120,
	2104, 2089, 2075, 2061,
	2048, 2038, 2026, 2016,
	2008, 1998, 1989, 1980,
	1970, 1958, 1945, 1928,
	1910, 1888, 1860, 1827,
	1791, 1751, 1709, 1656,
};

#define INTERVAL		10
#define BATTERY_HIGH_TRESHOLD	66
#define BATTERY_LOW_TRESHOLD	33

static void palmte_get_power_status(struct apm_power_info *info, int *battery)
{
	int charging, batt, hi, lo, mid;

	charging = !gpio_get_value(PALMTE_DC_GPIO);
	batt = battery[0];
	if (charging)
		batt -= 60;

	hi = ARRAY_SIZE(palmte_battery_sample);
	lo = 0;

	info->battery_flag = 0;
	info->units = APM_UNITS_MINS;

	if (batt > palmte_battery_sample[lo]) {
		info->battery_life = 100;
		info->time = INTERVAL * ARRAY_SIZE(palmte_battery_sample);
	} else if (batt <= palmte_battery_sample[hi - 1]) {
		info->battery_life = 0;
		info->time = 0;
	} else {
		while (hi > lo + 1) {
			mid = (hi + lo) >> 1;
			if (batt <= palmte_battery_sample[mid])
				lo = mid;
			else
				hi = mid;
		}

		mid = palmte_battery_sample[lo] - palmte_battery_sample[hi];
		hi = palmte_battery_sample[lo] - batt;
		info->battery_life = 100 - (100 * lo + 100 * hi / mid) /
			ARRAY_SIZE(palmte_battery_sample);
		info->time = INTERVAL * (ARRAY_SIZE(palmte_battery_sample) -
				lo) - INTERVAL * hi / mid;
	}

	if (charging) {
		info->ac_line_status = APM_AC_ONLINE;
		info->battery_status = APM_BATTERY_STATUS_CHARGING;
		info->battery_flag |= APM_BATTERY_FLAG_CHARGING;
	} else {
		info->ac_line_status = APM_AC_OFFLINE;
		if (info->battery_life > BATTERY_HIGH_TRESHOLD)
			info->battery_status = APM_BATTERY_STATUS_HIGH;
		else if (info->battery_life > BATTERY_LOW_TRESHOLD)
			info->battery_status = APM_BATTERY_STATUS_LOW;
		else
			info->battery_status = APM_BATTERY_STATUS_CRITICAL;
	}

	if (info->battery_life > BATTERY_HIGH_TRESHOLD)
		info->battery_flag |= APM_BATTERY_FLAG_HIGH;
	else if (info->battery_life > BATTERY_LOW_TRESHOLD)
		info->battery_flag |= APM_BATTERY_FLAG_LOW;
	else
		info->battery_flag |= APM_BATTERY_FLAG_CRITICAL;
}
#else
#define palmte_get_power_status	NULL
#endif

static struct omap_board_config_kernel palmte_config[] __initdata = {
	{ OMAP_TAG_USB,		&palmte_usb_config },
	{ OMAP_TAG_LCD,		&palmte_lcd_config },
	{ OMAP_TAG_UART,	&palmte_uart_config },
};

static struct spi_board_info palmte_spi_info[] __initdata = {
	{
		.modalias	= "tsc2102",
		.bus_num	= 2,	/* uWire (officially) */
		.chip_select	= 0,	/* As opposed to 3 */
		.irq		= OMAP_GPIO_IRQ(PALMTE_PINTDAV_GPIO),
		.max_speed_hz	= 8000000,
	},
};

static void palmte_headphones_detect(void *data, int state)
{
	if (state) {
		/* Headphones connected, disable speaker */
		gpio_set_value(PALMTE_SPEAKER_GPIO, 0);
		printk(KERN_INFO "PM: speaker off\n");
	} else {
		/* Headphones unplugged, re-enable speaker */
		gpio_set_value(PALMTE_SPEAKER_GPIO, 1);
		printk(KERN_INFO "PM: speaker on\n");
	}
}

static void __init palmte_misc_gpio_setup(void)
{
	/* Set TSC2102 PINTDAV pin as input (used by TSC2102 driver) */
	if (gpio_request(PALMTE_PINTDAV_GPIO, "TSC2102 PINTDAV") < 0) {
		printk(KERN_ERR "Could not reserve PINTDAV GPIO!\n");
		return;
	}
	gpio_direction_input(PALMTE_PINTDAV_GPIO);

	/* Set USB-or-DC-IN pin as input (unused) */
	if (gpio_request(PALMTE_USB_OR_DC_GPIO, "USB/DC-IN") < 0) {
		printk(KERN_ERR "Could not reserve cable signal GPIO!\n");
		return;
	}
	gpio_direction_input(PALMTE_USB_OR_DC_GPIO);
}

static void __init omap_palmte_init(void)
{
	omap_board_config = palmte_config;
	omap_board_config_size = ARRAY_SIZE(palmte_config);

	platform_add_devices(palmte_devices, ARRAY_SIZE(palmte_devices));

	spi_register_board_info(palmte_spi_info, ARRAY_SIZE(palmte_spi_info));
	palmte_misc_gpio_setup();
	omap_serial_init();
	omap_register_i2c_bus(1, 100, NULL, 0);
}

static void __init omap_palmte_map_io(void)
{
	omap1_map_common_io();
}

MACHINE_START(OMAP_PALMTE, "OMAP310 based Palm Tungsten E")
	.phys_io	= 0xfff00000,
	.io_pg_offst	= ((0xfef00000) >> 18) & 0xfffc,
	.boot_params	= 0x10000100,
	.map_io		= omap_palmte_map_io,
	.init_irq	= omap_palmte_init_irq,
	.init_machine	= omap_palmte_init,
	.timer		= &omap_timer,
MACHINE_END
Commit	Line	Data
3179a019 TL	1	/*
	2	* linux/arch/arm/mach-omap1/board-palmte.c
	3	*
	4	* Modified from board-generic.c
	5	*
	6	* Support for the Palm Tungsten E PDA.
	7	*
	8	* Original version : Laurent Gonzalez
	9	*
6cbdc8c5	10	* Maintainers : http://palmtelinux.sf.net
3179a019 TL	11	* palmtelinux-developpers@lists.sf.net
3179a019 TL	12	*
d7730cc0 AZ	13	* Copyright (c) 2006 Andrzej Zaborowski <balrog@zabor.org>
d7730cc0 AZ	14	*
3179a019 TL	15	* This program is free software; you can redistribute it and/or modify
	16	* it under the terms of the GNU General Public License version 2 as
	17	* published by the Free Software Foundation.
	18	*/
	19
	20	#include <linux/kernel.h>
	21	#include <linux/init.h>
c3695015	22	#include <linux/input.h>
3179a019	23	#include <linux/platform_device.h>
c3695015 AZ	24	#include <linux/mtd/mtd.h>
	25	#include <linux/mtd/partitions.h>
	26	#include <linux/spi/spi.h>
c3695015	27	#include <linux/interrupt.h>
d7730cc0	28	#include <linux/apm-emulation.h>
3179a019	29
a09e64fb	30	#include <mach/hardware.h>
3179a019 TL	31	#include <asm/mach-types.h>
	32	#include <asm/mach/arch.h>
	33	#include <asm/mach/map.h>
c3695015	34	#include <asm/mach/flash.h>
3179a019	35
a09e64fb RK	36	#include <mach/gpio.h>
	37	#include <mach/mux.h>
	38	#include <mach/usb.h>
	39	#include <mach/tc.h>
	40	#include <mach/dma.h>
	41	#include <mach/board.h>
	42	#include <mach/irda.h>
	43	#include <mach/keypad.h>
	44	#include <mach/common.h>
3179a019	45
c3695015	46	static void __init omap_palmte_init_irq(void)
3179a019	47	{
87bd63f6	48	omap1_init_common_hw();
3179a019	49	omap_init_irq();
c3695015	50	omap_gpio_init();
3179a019 TL	51	}
3179a019 TL	52
d7730cc0 AZ	53	static const int palmte_keymap[] = {
	54	KEY(0, 0, KEY_F1), /* Calendar */
	55	KEY(0, 1, KEY_F2), /* Contacts */
	56	KEY(0, 2, KEY_F3), /* Tasks List */
	57	KEY(0, 3, KEY_F4), /* Note Pad */
c3695015 AZ	58	KEY(0, 4, KEY_POWER),
	59	KEY(1, 0, KEY_LEFT),
	60	KEY(1, 1, KEY_DOWN),
	61	KEY(1, 2, KEY_UP),
	62	KEY(1, 3, KEY_RIGHT),
ec44dfa8	63	KEY(1, 4, KEY_ENTER),
c3695015 AZ	64	0,
	65	};
	66
	67	static struct omap_kp_platform_data palmte_kp_data = {
	68	.rows = 8,
	69	.cols = 8,
d7730cc0	70	.keymap = (int *) palmte_keymap,
c3695015 AZ	71	.rep = 1,
	72	.delay = 12,
	73	};
	74
	75	static struct resource palmte_kp_resources[] = {
	76	[0] = {
	77	.start = INT_KEYBOARD,
	78	.end = INT_KEYBOARD,
	79	.flags = IORESOURCE_IRQ,
	80	},
	81	};
	82
	83	static struct platform_device palmte_kp_device = {
	84	.name = "omap-keypad",
	85	.id = -1,
	86	.dev = {
	87	.platform_data = &palmte_kp_data,
	88	},
	89	.num_resources = ARRAY_SIZE(palmte_kp_resources),
	90	.resource = palmte_kp_resources,
	91	};
	92
	93	static struct mtd_partition palmte_rom_partitions[] = {
	94	/* PalmOS "Small ROM", contains the bootloader and the debugger */
	95	{
	96	.name = "smallrom",
	97	.offset = 0,
	98	.size = 0xa000,
	99	.mask_flags = MTD_WRITEABLE,
	100	},
	101	/* PalmOS "Big ROM", a filesystem with all the OS code and data */
	102	{
	103	.name = "bigrom",
	104	.offset = SZ_128K,
	105	/*
	106	* 0x5f0000 bytes big in the multi-language ("EFIGS") version,
	107	* 0x7b0000 bytes in the English-only ("enUS") version.
	108	*/
	109	.size = 0x7b0000,
	110	.mask_flags = MTD_WRITEABLE,
	111	},
	112	};
	113
	114	static struct flash_platform_data palmte_rom_data = {
	115	.map_name = "map_rom",
	116	.width = 2,
	117	.parts = palmte_rom_partitions,
	118	.nr_parts = ARRAY_SIZE(palmte_rom_partitions),
	119	};
	120
	121	static struct resource palmte_rom_resource = {
	122	.start = OMAP_CS0_PHYS,
	123	.end = OMAP_CS0_PHYS + SZ_8M - 1,
	124	.flags = IORESOURCE_MEM,
	125	};
	126
	127	static struct platform_device palmte_rom_device = {
	128	.name = "omapflash",
	129	.id = -1,
	130	.dev = {
	131	.platform_data = &palmte_rom_data,
	132	},
	133	.num_resources = 1,
	134	.resource = &palmte_rom_resource,
135	};
136
9b6553cd TL	137	static struct platform_device palmte_lcd_device = {
	138	.name = "lcd_palmte",
	139	.id = -1,
	140	};
	141
c3695015 AZ	142	static struct omap_backlight_config palmte_backlight_config = {
	143	.default_intensity = 0xa0,
	144	};
	145
	146	static struct platform_device palmte_backlight_device = {
	147	.name = "omap-bl",
	148	.id = -1,
	149	.dev = {
	150	.platform_data = &palmte_backlight_config,
	151	},
	152	};
	153
	154	static struct omap_irda_config palmte_irda_config = {
	155	.transceiver_cap = IR_SIRMODE,
	156	.rx_channel = OMAP_DMA_UART3_RX,
	157	.tx_channel = OMAP_DMA_UART3_TX,
	158	.dest_start = UART3_THR,
	159	.src_start = UART3_RHR,
	160	.tx_trigger = 0,
	161	.rx_trigger = 0,
	162	};
	163
	164	static struct resource palmte_irda_resources[] = {
	165	[0] = {
	166	.start = INT_UART3,
	167	.end = INT_UART3,
	168	.flags = IORESOURCE_IRQ,
	169	},
	170	};
	171
	172	static struct platform_device palmte_irda_device = {
	173	.name = "omapirda",
	174	.id = -1,
	175	.dev = {
	176	.platform_data = &palmte_irda_config,
	177	},
	178	.num_resources = ARRAY_SIZE(palmte_irda_resources),
	179	.resource = palmte_irda_resources,
	180	};
	181
d7730cc0	182	static struct platform_device *palmte_devices[] __initdata = {
c3695015 AZ	183	&palmte_rom_device,
c3695015 AZ	184	&palmte_kp_device,
9b6553cd	185	&palmte_lcd_device,
c3695015 AZ	186	&palmte_backlight_device,
c3695015 AZ	187	&palmte_irda_device,
9b6553cd TL	188	};
9b6553cd TL	189
3179a019	190	static struct omap_usb_config palmte_usb_config __initdata = {
c3695015	191	.register_dev = 1, /* Mini-B only receptacle */
3179a019	192	.hmc_mode = 0,
c3695015	193	.pins[0] = 2,
3179a019 TL	194	};
3179a019 TL	195
3179a019	196	static struct omap_lcd_config palmte_lcd_config __initdata = {
3179a019 TL	197	.ctrl_name = "internal",
	198	};
	199
c3695015 AZ	200	static struct omap_uart_config palmte_uart_config __initdata = {
	201	.enabled_uarts = (1 << 0) \| (1 << 1) \| (0 << 2),
	202	};
	203
c3695015 AZ	204	#ifdef CONFIG_APM
	205	/*
	206	* Values measured in 10 minute intervals averaged over 10 samples.
	207	* May differ slightly from device to device but should be accurate
	208	* enough to give basic idea of battery life left and trigger
	209	* potential alerts.
	210	*/
	211	static const int palmte_battery_sample[] = {
	212	2194, 2157, 2138, 2120,
	213	2104, 2089, 2075, 2061,
	214	2048, 2038, 2026, 2016,
	215	2008, 1998, 1989, 1980,
	216	1970, 1958, 1945, 1928,
	217	1910, 1888, 1860, 1827,
	218	1791, 1751, 1709, 1656,
	219	};
	220
	221	#define INTERVAL 10
	222	#define BATTERY_HIGH_TRESHOLD 66
	223	#define BATTERY_LOW_TRESHOLD 33
	224
	225	static void palmte_get_power_status(struct apm_power_info info, int battery)
	226	{
	227	int charging, batt, hi, lo, mid;
	228
0b84b5ca	229	charging = !gpio_get_value(PALMTE_DC_GPIO);
c3695015 AZ	230	batt = battery[0];
	231	if (charging)
	232	batt -= 60;
	233
	234	hi = ARRAY_SIZE(palmte_battery_sample);
	235	lo = 0;
	236
	237	info->battery_flag = 0;
	238	info->units = APM_UNITS_MINS;
	239
	240	if (batt > palmte_battery_sample[lo]) {
	241	info->battery_life = 100;
	242	info->time = INTERVAL * ARRAY_SIZE(palmte_battery_sample);
	243	} else if (batt <= palmte_battery_sample[hi - 1]) {
	244	info->battery_life = 0;
	245	info->time = 0;
	246	} else {
	247	while (hi > lo + 1) {
d7730cc0	248	mid = (hi + lo) >> 1;
c3695015 AZ	249	if (batt <= palmte_battery_sample[mid])
	250	lo = mid;
	251	else
	252	hi = mid;
	253	}
	254
	255	mid = palmte_battery_sample[lo] - palmte_battery_sample[hi];
	256	hi = palmte_battery_sample[lo] - batt;
	257	info->battery_life = 100 - (100 * lo + 100 * hi / mid) /
	258	ARRAY_SIZE(palmte_battery_sample);
	259	info->time = INTERVAL * (ARRAY_SIZE(palmte_battery_sample) -
	260	lo) - INTERVAL * hi / mid;
	261	}
	262
	263	if (charging) {
	264	info->ac_line_status = APM_AC_ONLINE;
	265	info->battery_status = APM_BATTERY_STATUS_CHARGING;
	266	info->battery_flag \|= APM_BATTERY_FLAG_CHARGING;
	267	} else {
	268	info->ac_line_status = APM_AC_OFFLINE;
	269	if (info->battery_life > BATTERY_HIGH_TRESHOLD)
	270	info->battery_status = APM_BATTERY_STATUS_HIGH;
	271	else if (info->battery_life > BATTERY_LOW_TRESHOLD)
	272	info->battery_status = APM_BATTERY_STATUS_LOW;
	273	else
	274	info->battery_status = APM_BATTERY_STATUS_CRITICAL;
	275	}
	276
	277	if (info->battery_life > BATTERY_HIGH_TRESHOLD)
	278	info->battery_flag \|= APM_BATTERY_FLAG_HIGH;
	279	else if (info->battery_life > BATTERY_LOW_TRESHOLD)
	280	info->battery_flag \|= APM_BATTERY_FLAG_LOW;
	281	else
	282	info->battery_flag \|= APM_BATTERY_FLAG_CRITICAL;
	283	}
	284	#else
	285	#define palmte_get_power_status NULL
	286	#endif
	287
d7730cc0	288	static struct omap_board_config_kernel palmte_config[] __initdata = {
c3695015	289	{ OMAP_TAG_USB, &palmte_usb_config },
c3695015 AZ	290	{ OMAP_TAG_LCD, &palmte_lcd_config },
c3695015 AZ	291	{ OMAP_TAG_UART, &palmte_uart_config },
3179a019 TL	292	};
3179a019 TL	293
c3695015 AZ	294	static struct spi_board_info palmte_spi_info[] __initdata = {
	295	{
	296	.modalias = "tsc2102",
	297	.bus_num = 2, /* uWire (officially) */
	298	.chip_select = 0, /* As opposed to 3 */
	299	.irq = OMAP_GPIO_IRQ(PALMTE_PINTDAV_GPIO),
c3695015 AZ	300	.max_speed_hz = 8000000,
	301	},
	302	};
	303
d7730cc0 AZ	304	static void palmte_headphones_detect(void *data, int state)
	305	{
	306	if (state) {
c3695015	307	/* Headphones connected, disable speaker */
0b84b5ca	308	gpio_set_value(PALMTE_SPEAKER_GPIO, 0);
c3695015	309	printk(KERN_INFO "PM: speaker off\n");
d7730cc0	310	} else {
c3695015	311	/* Headphones unplugged, re-enable speaker */
0b84b5ca	312	gpio_set_value(PALMTE_SPEAKER_GPIO, 1);
c3695015 AZ	313	printk(KERN_INFO "PM: speaker on\n");
c3695015 AZ	314	}
c3695015 AZ	315	}
c3695015 AZ	316
d7730cc0	317	static void __init palmte_misc_gpio_setup(void)
c3695015	318	{
d7730cc0	319	/* Set TSC2102 PINTDAV pin as input (used by TSC2102 driver) */
f2d18fea	320	if (gpio_request(PALMTE_PINTDAV_GPIO, "TSC2102 PINTDAV") < 0) {
c3695015 AZ	321	printk(KERN_ERR "Could not reserve PINTDAV GPIO!\n");
	322	return;
	323	}
40e3925b	324	gpio_direction_input(PALMTE_PINTDAV_GPIO);
c3695015	325
d7730cc0	326	/* Set USB-or-DC-IN pin as input (unused) */
f2d18fea	327	if (gpio_request(PALMTE_USB_OR_DC_GPIO, "USB/DC-IN") < 0) {
c3695015 AZ	328	printk(KERN_ERR "Could not reserve cable signal GPIO!\n");
	329	return;
	330	}
40e3925b	331	gpio_direction_input(PALMTE_USB_OR_DC_GPIO);
c3695015 AZ	332	}
	333
	334	static void __init omap_palmte_init(void)
3179a019 TL	335	{
	336	omap_board_config = palmte_config;
	337	omap_board_config_size = ARRAY_SIZE(palmte_config);
9b6553cd	338
d7730cc0	339	platform_add_devices(palmte_devices, ARRAY_SIZE(palmte_devices));
c3695015 AZ	340
c3695015 AZ	341	spi_register_board_info(palmte_spi_info, ARRAY_SIZE(palmte_spi_info));
d7730cc0	342	palmte_misc_gpio_setup();
c3695015	343	omap_serial_init();
1ed16a86	344	omap_register_i2c_bus(1, 100, NULL, 0);
3179a019 TL	345	}
3179a019 TL	346
c3695015	347	static void __init omap_palmte_map_io(void)
3179a019	348	{
87bd63f6	349	omap1_map_common_io();
3179a019 TL	350	}
	351
	352	MACHINE_START(OMAP_PALMTE, "OMAP310 based Palm Tungsten E")
3179a019 TL	353	.phys_io = 0xfff00000,
	354	.io_pg_offst = ((0xfef00000) >> 18) & 0xfffc,
	355	.boot_params = 0x10000100,
c3695015 AZ	356	.map_io = omap_palmte_map_io,
	357	.init_irq = omap_palmte_init_irq,
	358	.init_machine = omap_palmte_init,
3179a019 TL	359	.timer = &omap_timer,
3179a019 TL	360	MACHINE_END