[net-next-2.6.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/mtd/physmap.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 <mach/gpio.h>
#include <plat/flash.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 physmap_flash_data palmte_rom_data = {
	.width		= 2,
	.set_vpp	= omap1_set_vpp,
	.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		= "physmap-flash",
	.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)
{
	/* mux pins for uarts */
	omap_cfg_reg(UART1_TX);
	omap_cfg_reg(UART1_RTS);
	omap_cfg_reg(UART2_TX);
	omap_cfg_reg(UART2_RTS);
	omap_cfg_reg(UART3_TX);
	omap_cfg_reg(UART3_RX);

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