[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
 *
 * 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/spi/tsc2102.h>
#include <linux/interrupt.h>

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

#include <asm/arch/gpio.h>
#include <asm/arch/mux.h>
#include <asm/arch/usb.h>
#include <asm/arch/tc.h>
#include <asm/arch/dma.h>
#include <asm/arch/board.h>
#include <asm/arch/irda.h>
#include <asm/arch/keypad.h>
#include <asm/arch/common.h>
#include <asm/arch/mcbsp.h>
#include <asm/arch/omap-alsa.h>

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

static int palmte_keymap[] = {
	KEY(0, 0, KEY_F1),
	KEY(0, 1, KEY_F2),
	KEY(0, 2, KEY_F3),
	KEY(0, 3, KEY_F4),
	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_CENTER),
	0,
};

static struct omap_kp_platform_data palmte_kp_data = {
	.rows	= 8,
	.cols	= 8,
	.keymap = 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 *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 = !omap_get_gpio_datain(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) >> 2;
			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 tsc2102_config palmte_tsc2102_config = {
	.use_internal	= 0,
	.monitor	= TSC_BAT1 | TSC_AUX | TSC_TEMP,
	.temp_at25c	= { 2200, 2615 },
	.apm_report	= palmte_get_power_status,
	.alsa_config	= &palmte_alsa_config,
};

static struct omap_board_config_kernel palmte_config[] = {
	{ 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),
		.platform_data	= &palmte_tsc2102_config,
		.max_speed_hz	= 8000000,
	},
};

/* Periodically check for changes on important input pins */
struct timer_list palmte_pin_timer;
int prev_power, prev_headphones;

static void palmte_pin_handler(unsigned long data) {
	int power, headphones;

	power = !omap_get_gpio_datain(PALMTE_DC_GPIO);
	headphones = omap_get_gpio_datain(PALMTE_HEADPHONES_GPIO);

	if (power && !prev_power)
		printk(KERN_INFO "PM: cable connected\n");
	else if (!power && prev_power)
		printk(KERN_INFO "PM: cable disconnected\n");

	if (headphones && !prev_headphones) {
		/* Headphones connected, disable speaker */
		omap_set_gpio_dataout(PALMTE_SPEAKER_GPIO, 0);
		printk(KERN_INFO "PM: speaker off\n");
	} else if (!headphones && prev_headphones) {
		/* Headphones unplugged, re-enable speaker */
		omap_set_gpio_dataout(PALMTE_SPEAKER_GPIO, 1);
		printk(KERN_INFO "PM: speaker on\n");
	}

	prev_power = power;
	prev_headphones = headphones;
	mod_timer(&palmte_pin_timer, jiffies + msecs_to_jiffies(500));
}

static void __init palmte_gpio_setup(void)
{
	/* Set TSC2102 PINTDAV pin as input */
	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);

	/* Monitor cable-connected signals */
	if (omap_request_gpio(PALMTE_DC_GPIO) ||
			omap_request_gpio(PALMTE_USB_OR_DC_GPIO) ||
			omap_request_gpio(PALMTE_USBDETECT_GPIO)) {
		printk(KERN_ERR "Could not reserve cable signal GPIO!\n");
		return;
	}
	omap_set_gpio_direction(PALMTE_DC_GPIO, 1);
	omap_set_gpio_direction(PALMTE_USB_OR_DC_GPIO, 1);
	omap_set_gpio_direction(PALMTE_USBDETECT_GPIO, 1);

	/* Set speaker-enable pin as output */
	if (omap_request_gpio(PALMTE_SPEAKER_GPIO)) {
		printk(KERN_ERR "Could not reserve speaker GPIO!\n");
		return;
	}
	omap_set_gpio_direction(PALMTE_SPEAKER_GPIO, 0);

	/* Monitor the headphones-connected signal */
	if (omap_request_gpio(PALMTE_HEADPHONES_GPIO)) {
		printk(KERN_ERR "Could not reserve headphones signal GPIO!\n");
		return;
	}
	omap_set_gpio_direction(PALMTE_HEADPHONES_GPIO, 1);

	prev_power = omap_get_gpio_datain(PALMTE_DC_GPIO);
	prev_headphones = !omap_get_gpio_datain(PALMTE_HEADPHONES_GPIO);
	setup_timer(&palmte_pin_timer, palmte_pin_handler, 0);
	palmte_pin_handler(0);
}

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

	platform_add_devices(devices, ARRAY_SIZE(devices));

	spi_register_board_info(palmte_spi_info, ARRAY_SIZE(palmte_spi_info));

	omap_serial_init();
	omap_register_i2c_bus(1, 100, NULL, 0);
	palmte_gpio_setup();
}

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