[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>
#include <mach/mcbsp.h>
#include <mach/omap-alsa.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_mmc_config palmte_mmc_config __initdata = {
	.mmc[0]		= {
		.enabled 	= 1,
		.wp_pin		= PALMTE_MMC_WP_GPIO,
		.power_pin	= PALMTE_MMC_POWER_GPIO,
		.switch_pin	= PALMTE_MMC_SWITCH_GPIO,
	},
};

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

static struct omap_mcbsp_reg_cfg palmte_mcbsp1_regs = {
	.spcr2	= FRST | GRST | XRST | XINTM(3),
	.xcr2	= XDATDLY(1) | XFIG,
	.xcr1	= XWDLEN1(OMAP_MCBSP_WORD_32),
	.pcr0	= SCLKME | FSXP | CLKXP,
};

static struct omap_alsa_codec_config palmte_alsa_config = {
	.name			= "TSC2102 audio",
	.mcbsp_regs_alsa	= &palmte_mcbsp1_regs,
	.codec_configure_dev	= NULL,	/* tsc2102_configure, */
	.codec_set_samplerate	= NULL,	/* tsc2102_set_samplerate, */
	.codec_clock_setup	= NULL,	/* tsc2102_clock_setup, */
	.codec_clock_on		= NULL,	/* tsc2102_clock_on, */
	.codec_clock_off	= NULL,	/* tsc2102_clock_off, */
	.get_default_samplerate	= NULL,	/* tsc2102_get_default_samplerate, */
};

#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_MMC,		&palmte_mmc_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 (omap_request_gpio(PALMTE_PINTDAV_GPIO)) {
		printk(KERN_ERR "Could not reserve PINTDAV GPIO!\n");
		return;
	}
	omap_set_gpio_direction(PALMTE_PINTDAV_GPIO, 1);

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

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