[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 <plat/mux.h>
#include <plat/usb.h>
#include <plat/tc.h>
#include <plat/dma.h>
#include <plat/board.h>
#include <plat/irda.h>
#include <plat/keypad.h>
#include <plat/common.h>

#define PALMTE_USBDETECT_GPIO	0
#define PALMTE_USB_OR_DC_GPIO	1
#define PALMTE_TSC_GPIO		4
#define PALMTE_PINTDAV_GPIO	6
#define PALMTE_MMC_WP_GPIO	8
#define PALMTE_MMC_POWER_GPIO	9
#define PALMTE_HDQ_GPIO		11
#define PALMTE_HEADPHONES_GPIO	14
#define PALMTE_SPEAKER_GPIO	15
#define PALMTE_DC_GPIO		OMAP_MPUIO(2)
#define PALMTE_MMC_SWITCH_GPIO	OMAP_MPUIO(4)
#define PALMTE_MMC1_GPIO	OMAP_MPUIO(6)
#define PALMTE_MMC2_GPIO	OMAP_MPUIO(7)
#define PALMTE_MMC3_GPIO	OMAP_MPUIO(11)

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",
};

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