From 9e9b8b3d5aabfc956bbe6c6177236259770f7792 Mon Sep 17 00:00:00 2001 From: Ian Date: Mon, 4 Dec 2006 03:18:29 +0000 Subject: [PATCH] hh.org updates --- arch/arm/mach-pxa/htcblueangel/Kconfig | 1 + arch/arm/mach-pxa/htcblueangel/Makefile | 1 + arch/arm/mach-pxa/htcblueangel/blueangel.c | 51 +- arch/arm/mach-pxa/htcblueangel/blueangel_battery.c | 145 ++-- arch/arm/mach-pxa/htcblueangel/blueangel_ds1wm.c | 181 +++++ arch/arm/mach-pxa/htcblueangel/blueangel_kp.c | 240 ++---- arch/arm/mach-pxa/htcblueangel/blueangel_lcd.c | 3 + arch/arm/mach-pxa/htcblueangel/blueangel_leds.c | 856 ++++++++++----------- arch/arm/mach-pxa/htcblueangel/blueangel_pcmcia.c | 5 +- arch/arm/mach-pxa/htcblueangel/blueangel_suspend.c | 1 + arch/arm/mach-pxa/htcblueangel/blueangel_tsc2200.c | 123 +++ 11 files changed, 902 insertions(+), 705 deletions(-) create mode 100644 arch/arm/mach-pxa/htcblueangel/blueangel_ds1wm.c rewrite arch/arm/mach-pxa/htcblueangel/blueangel_leds.c (62%) create mode 100644 arch/arm/mach-pxa/htcblueangel/blueangel_tsc2200.c diff --git a/arch/arm/mach-pxa/htcblueangel/Kconfig b/arch/arm/mach-pxa/htcblueangel/Kconfig index a1b51de245..9030368724 100644 --- a/arch/arm/mach-pxa/htcblueangel/Kconfig +++ b/arch/arm/mach-pxa/htcblueangel/Kconfig @@ -2,6 +2,7 @@ menuconfig MACH_BLUEANGEL bool "HTC Blueangel (VERY EXPERIMENTAL)" depends on ARCH_PXA select PXA25x + select PXA_SSP menuconfig MACH_BLUEANGEL_LCD tristate "HTC Blueangel LCD support" diff --git a/arch/arm/mach-pxa/htcblueangel/Makefile b/arch/arm/mach-pxa/htcblueangel/Makefile index 2c459a74e4..bab923eea4 100644 --- a/arch/arm/mach-pxa/htcblueangel/Makefile +++ b/arch/arm/mach-pxa/htcblueangel/Makefile @@ -3,6 +3,7 @@ # obj-$(CONFIG_MACH_BLUEANGEL) += blueangel.o +obj-$(CONFIG_MACH_BLUEANGEL) += blueangel_tsc2200.o obj-$(CONFIG_MACH_BLUEANGEL_LCD) += blueangel_lcd.o obj-$(CONFIG_MACH_BLUEANGEL_BACKLIGHT) += blueangel_bl.o obj-$(CONFIG_MACH_BLUEANGEL_PCMCIA) += blueangel_pcmcia.o diff --git a/arch/arm/mach-pxa/htcblueangel/blueangel.c b/arch/arm/mach-pxa/htcblueangel/blueangel.c index ede30e008f..1bc345c1e1 100644 --- a/arch/arm/mach-pxa/htcblueangel/blueangel.c +++ b/arch/arm/mach-pxa/htcblueangel/blueangel.c @@ -36,15 +36,18 @@ #include #include #include +#include #include #include +#include #include #include #include #include #include #include +#include #include "../generic.h" @@ -52,10 +55,13 @@ #include #include #include -#include "../drivers/serial/pxa-serial.h" +struct ipaq_model_ops ipaq_model_ops; +EXPORT_SYMBOL(ipaq_model_ops); + extern struct platform_device blueangel_asic3; +extern struct platform_device blueangel_tsc2200; struct platform_pxa_serial_funcs pxa_serial_funcs [] = { {}, /* No special FFUART options */ {}, /* No special BTUART options */ @@ -63,22 +69,29 @@ struct platform_pxa_serial_funcs pxa_serial_funcs [] = { {}, /* No special HWUART options */ }; +static struct ipaq_model_ops blueangel_model_ops __initdata = { + .generic_name = "blueangel", +}; + + static void __init blueangel_init_irq( void ) { /* Initialize standard IRQs */ pxa_init_irq(); } -static void ser_stuart_gpio_config(struct uart_pxa_port *up, int enable) +static void ser_stuart_gpio_config(int enable) { printk("ser_stuart_gpio_config %d\n", enable); - STISR=0; + if (enable == PXA_UART_CFG_PRE_STARTUP) { + STISR=0; + } } -static void ser_hwuart_gpio_config(struct uart_pxa_port *up, int enable) +static void ser_hwuart_gpio_config(int enable) { printk("ser_hwuart_gpio_config %d\n", enable); - if (enable) { + if (enable == PXA_UART_CFG_PRE_STARTUP) { GPDR(GPIO42_HWRXD) &= ~(GPIO_bit(GPIO42_HWRXD)); GPDR(GPIO43_HWTXD) |= GPIO_bit(GPIO43_HWTXD); GPDR(GPIO44_HWCTS) &= ~(GPIO_bit(GPIO44_HWCTS)); @@ -91,7 +104,7 @@ static void ser_hwuart_gpio_config(struct uart_pxa_port *up, int enable) asic3_set_gpio_out_a(&blueangel_asic3.dev, GPIOA_BT_PWR1_ON, GPIOA_BT_PWR1_ON); asic3_set_gpio_dir_b(&blueangel_asic3.dev, GPIOB_BT_PWR2_ON, GPIOB_BT_PWR2_ON); asic3_set_gpio_out_b(&blueangel_asic3.dev, GPIOB_BT_PWR2_ON, GPIOB_BT_PWR2_ON); - } else { + } else if (enable == PXA_UART_CFG_POST_SHUTDOWN) { asic3_set_gpio_out_a(&blueangel_asic3.dev, GPIOA_BT_PWR1_ON, 0); asic3_set_gpio_out_b(&blueangel_asic3.dev, GPIOB_BT_PWR2_ON, 0); } @@ -195,6 +208,7 @@ static void __init blueangel_map_io(void) PCFR = PCFR_OPDE; #endif + ipaq_model_ops = blueangel_model_ops; } /* @@ -235,6 +249,7 @@ static struct platform_device blueangel_asic3_keys = { } }; + static struct platform_device *blueangel_asic3_devices[] __initdata = { &blueangel_lcd, &blueangel_udc, @@ -252,7 +267,7 @@ static struct platform_device *blueangel_asic3_devices[] __initdata = { * which should really be used rather than macros. */ -static struct asic3_platform_data asic3_platform_data_toppoly = { +static struct asic3_platform_data asic3_platform_data_6 = { .gpio_a = { .dir = 0xbffd, .init = 0x0110, @@ -294,7 +309,7 @@ static struct asic3_platform_data asic3_platform_data_toppoly = { .num_child_platform_devs = ARRAY_SIZE(blueangel_asic3_devices), }; -static struct asic3_platform_data asic3_platform_data_sony = { +static struct asic3_platform_data asic3_platform_data_o = { .gpio_a = { .dir = 0xbffd, .init = 0x0110, @@ -367,6 +382,18 @@ struct platform_device blueangel_asic3 = { EXPORT_SYMBOL(blueangel_asic3); /* + * Magician LEDs + */ +static struct platform_device blueangel_led = { + .name = "htcblueangel-led", + .id = -1, +}; +/* +* +*/ + + +/* * GPIO buttons */ static struct gpio_keys_button blueangel_button_table[] = { @@ -391,6 +418,8 @@ static struct platform_device blueangel_pxa_keys = { static struct platform_device *devices[] __initdata = { &blueangel_asic3, + &blueangel_led, + &blueangel_tsc2200, &blueangel_pxa_keys, }; @@ -403,14 +432,14 @@ static void __init blueangel_init(void) switch (blueangel_boardid) { case 6: - blueangel_asic3.dev.platform_data=&asic3_platform_data_toppoly; + blueangel_asic3.dev.platform_data=&asic3_platform_data_6; break; case 4: case 5: - blueangel_asic3.dev.platform_data=&asic3_platform_data_sony; + blueangel_asic3.dev.platform_data=&asic3_platform_data_o; break; default: - blueangel_asic3.dev.platform_data=&asic3_platform_data_sony; + blueangel_asic3.dev.platform_data=&asic3_platform_data_o; } platform_add_devices (devices, ARRAY_SIZE (devices)); diff --git a/arch/arm/mach-pxa/htcblueangel/blueangel_battery.c b/arch/arm/mach-pxa/htcblueangel/blueangel_battery.c index e1bbd2858d..e256a82f25 100644 --- a/arch/arm/mach-pxa/htcblueangel/blueangel_battery.c +++ b/arch/arm/mach-pxa/htcblueangel/blueangel_battery.c @@ -1,5 +1,5 @@ /* -* Driver interface to the battery on the HTC Himalaya +* Driver interface to the battery on the HTC Blueangel * * Use consistent with the GNU GPL is permitted, * provided that this copyright notice is @@ -8,8 +8,11 @@ */ #include +#include #include +//#include #include +#include #include #include @@ -19,8 +22,7 @@ #include #include -#include "../himalaya/tsc2200.h" -//#include "../himalaya/pxa_nssp.h" +#include #ifdef DEBUG #define dprintk(x...) printk(x) @@ -28,12 +30,15 @@ #define dprintk(x...) #endif -extern struct platform_device blueangel_asic3; +extern struct platform_device blueangel_tsc2200; +DEFINE_LED_TRIGGER(ledtrig_cradle); + + static void bat_tsc2200_start_conv_scan(void) { - tsc2200_write(TSC2200_CTRLREG_REF, 31); - tsc2200_write(TSC2200_CTRLREG_ADC, + tsc2200_write(&blueangel_tsc2200.dev, TSC2200_CTRLREG_REF, 31); + tsc2200_write(&blueangel_tsc2200.dev, TSC2200_CTRLREG_ADC, TSC2200_CTRLREG_ADC_AD3 | TSC2200_CTRLREG_ADC_AD1 | TSC2200_CTRLREG_ADC_AD0 | @@ -45,8 +50,8 @@ static void bat_tsc2200_start_conv_scan(void) static void bat_tsc2200_start_conv_temp(void) { - tsc2200_write(TSC2200_CTRLREG_REF, 31); - tsc2200_write(TSC2200_CTRLREG_ADC, + tsc2200_write(&blueangel_tsc2200.dev, TSC2200_CTRLREG_REF, 31); + tsc2200_write(&blueangel_tsc2200.dev, TSC2200_CTRLREG_ADC, TSC2200_CTRLREG_ADC_AD3 | TSC2200_CTRLREG_ADC_AD1 | TSC2200_CTRLREG_ADC_RES (TSC2200_CTRLREG_ADC_RES_12BITP) | @@ -57,7 +62,7 @@ static void bat_tsc2200_start_conv_temp(void) static void bat_tsc2200_stop_conv(void) { - tsc2200_write(TSC2200_CTRLREG_ADC, + tsc2200_write(&blueangel_tsc2200.dev, TSC2200_CTRLREG_ADC, TSC2200_CTRLREG_ADC_STS | TSC2200_CTRLREG_ADC_AD0 | TSC2200_CTRLREG_ADC_RES (TSC2200_CTRLREG_ADC_RES_12BITP) | @@ -66,7 +71,7 @@ static void bat_tsc2200_stop_conv(void) TSC2200_CTRLREG_ADC_PV (TSC2200_CTRLREG_ADC_PV_500uS) ); } -static int himalaya_battery_get_status(struct battery *bat) +static int blueangel_battery_get_status(struct battery *bat) { dprintk("%s: in.\n", __FUNCTION__); @@ -77,80 +82,110 @@ static int himalaya_battery_get_status(struct battery *bat) } } -static int himalaya_battery_get_voltage(struct battery *bat) + +static int blueangel_battery_get_voltage1(struct battery *bat) { int retval; dprintk("%s: in.\n", __FUNCTION__); - down_interruptible(&tsc2200_sem); + //down_interruptible(&tsc2200_sem); + //tsc2200_lock(&blueangel_tsc2200.dev); bat_tsc2200_start_conv_scan(); - while ( !(tsc2200_read(TSC2200_CTRLREG_ADC) & 0x4000) && - !tsc2200_dav()) { - dprintk("B2: %X\n", tsc2200_read(TSC2200_CTRLREG_ADC)); + while ( !(tsc2200_read(&blueangel_tsc2200.dev, TSC2200_CTRLREG_ADC) & 0x4000) && + !tsc2200_dav(&blueangel_tsc2200.dev )) { + dprintk("B2: %X\n", tsc2200_read(&blueangel_tsc2200.dev, TSC2200_CTRLREG_ADC)); mdelay(1); } - retval = tsc2200_read(TSC2200_DATAREG_AUX2); - dprintk("%s: BAT1: %X\nBAT2: %x\nAUX1: %x\nAUX2: %x\nTEMP1: %x\nTEMP2: %x\n", __FUNCTION__, tsc2200_read(TSC2200_DATAREG_BAT1), tsc2200_read(TSC2200_DATAREG_BAT2), tsc2200_read(TSC2200_DATAREG_AUX1), tsc2200_read(TSC2200_DATAREG_AUX2), tsc2200_read(TSC2200_DATAREG_TEMP1), tsc2200_read(TSC2200_DATAREG_TEMP2)); + retval = tsc2200_read(&blueangel_tsc2200.dev, TSC2200_DATAREG_AUX1); bat_tsc2200_stop_conv(); - up(&tsc2200_sem); + //tsc2200_unlock(&blueangel_tsc2200.dev); + //up(&tsc2200_sem); return retval; } +static int blueangel_battery_get_voltage(struct battery *bat) +{ + int retval; + + dprintk("%s: in.\n", __FUNCTION__); + + //down_interruptible(&tsc2200_sem); + //tsc2200_lock(&blueangel_tsc2200.dev); + bat_tsc2200_start_conv_scan(); -static int himalaya_battery_get_temp(struct battery *bat) + while ( !(tsc2200_read(&blueangel_tsc2200.dev, TSC2200_CTRLREG_ADC) & 0x4000) && + !tsc2200_dav(&blueangel_tsc2200.dev )) { + dprintk("B2: %X\n", tsc2200_read(&blueangel_tsc2200.dev, TSC2200_CTRLREG_ADC)); + mdelay(1); + } + + retval = tsc2200_read(&blueangel_tsc2200.dev, TSC2200_DATAREG_AUX2); + + bat_tsc2200_stop_conv(); + //tsc2200_unlock(&blueangel_tsc2200.dev); + //up(&tsc2200_sem); + return retval; +} + +static int blueangel_battery_get_temp(struct battery *bat) { int retval; dprintk("%s: in.\n", __FUNCTION__); - down_interruptible(&tsc2200_sem); + //down_interruptible(&tsc2200_sem); + //tsc2200_lock(&blueangel_tsc2200.dev); bat_tsc2200_start_conv_temp(); - while ( !(tsc2200_read(TSC2200_CTRLREG_ADC) & 0x4000) && - !tsc2200_dav()) { - dprintk("1: %X\n", tsc2200_read(TSC2200_CTRLREG_ADC)); + while ( !(tsc2200_read(&blueangel_tsc2200.dev, TSC2200_CTRLREG_ADC) & 0x4000) && + !tsc2200_dav(&blueangel_tsc2200.dev)) { + dprintk("1: %X\n", tsc2200_read(&blueangel_tsc2200.dev, TSC2200_CTRLREG_ADC)); mdelay(1); } - retval = tsc2200_read(TSC2200_DATAREG_TEMP1); + retval = tsc2200_read(&blueangel_tsc2200.dev, TSC2200_DATAREG_TEMP1); dprintk("retval=0x%x\n", retval); - dprintk("%s: BAT1: %03X\nBAT2: %03x\nAUX1: %03x\nAUX2: %03x\nTEMP1: %03x\nTEMP2: %03x\n", __FUNCTION__, tsc2200_read(TSC2200_DATAREG_BAT1), tsc2200_read(TSC2200_DATAREG_BAT2), tsc2200_read(TSC2200_DATAREG_AUX1), tsc2200_read(TSC2200_DATAREG_AUX2), tsc2200_read(TSC2200_DATAREG_TEMP1), tsc2200_read(TSC2200_DATAREG_TEMP2)); bat_tsc2200_stop_conv(); - up(&tsc2200_sem); + //tsc2200_unlock(&blueangel_tsc2200.dev); + //up(&tsc2200_sem); dprintk("%s: out\n", __FUNCTION__); return retval; } struct battery battery_dev = { - .name = "main battery", + .name = "Main battery", .id = "battery0", - .get_voltage = himalaya_battery_get_voltage, - .get_status = himalaya_battery_get_status, - .get_temp = himalaya_battery_get_temp, + .get_voltage = blueangel_battery_get_voltage, + .get_status = blueangel_battery_get_status, + //.get_temp = blueangel_battery_get_temp, }; -#if 0 -static struct device bat_tsc2200_dev = { - .parent = &nssp_bus, - .bus = &nssp_bus_type, - .bus_id = "bat_tsc2200", +struct battery battery_dev1 = { + .name = "Backup battery", + .id = "battery1", + .get_voltage = blueangel_battery_get_voltage1, + .get_status = blueangel_battery_get_status, + //.get_temp = blueangel_battery_get_tempi1, }; -#endif static void blueangel_battery_get_power_status (struct apm_power_info *info) { int val; - int full=0x8a3; - int empty=0x8c3; + int val1; + int full=0x8ea; + int empty=0x8a3; - val=himalaya_battery_get_voltage(NULL); + int full1=0xb0f; + int empty1=0x8a3; + val=blueangel_battery_get_voltage(NULL); + val1=blueangel_battery_get_voltage1(NULL); - info->battery_life = (val-empty)*100/(full-empty); + info->battery_life = (val1-empty)*100/(full-empty); if (info->battery_life < 0 || info->battery_life > 100) printk("battery voltage (0x%x) not within [0x%x,0x%x]. Please report.\n", val, full, empty); if (info->battery_life < 0) @@ -158,7 +193,7 @@ blueangel_battery_get_power_status (struct apm_power_info *info) if (info->battery_life > 100) info->battery_life = 100; info->ac_line_status = APM_AC_OFFLINE; - if (!(asic3_get_gpio_status_d(&blueangel_asic3.dev) & GPIOD_AC_CHARGER_N)) { + if (!(asic3_get_gpio_status_d(&blueangel_tsc2200.dev) & GPIOD_AC_CHARGER_N)) { info->ac_line_status = APM_AC_ONLINE; } if (!(GPLR(GPIO_NR_BLUEANGEL_USB_DETECT_N) & GPIO_bit(GPIO_NR_BLUEANGEL_USB_DETECT_N))) { @@ -168,6 +203,9 @@ blueangel_battery_get_power_status (struct apm_power_info *info) info->time = 360 * info->battery_life/100; /* time remaining */ info->battery_flag = 0; if (info->ac_line_status == APM_AC_OFFLINE) { + #ifdef CONFIG_LEDS_TRIGGERS + led_trigger_event(ledtrig_cradle, LED_OFF); + #endif info->battery_status = APM_BATTERY_STATUS_CRITICAL; if(info->battery_life > 5) { info->battery_status = APM_BATTERY_STATUS_LOW; @@ -177,25 +215,29 @@ blueangel_battery_get_power_status (struct apm_power_info *info) } } else { info->battery_status = APM_BATTERY_STATUS_CHARGING; + #ifdef CONFIG_LEDS_TRIGGERS + led_trigger_event(ledtrig_cradle, LED_FULL); + #endif } } static int bat_setup(void) { -#if 0 - device_register(&bat_tsc2200_dev); -#endif battery_class_register(&battery_dev); - + battery_class_register(&battery_dev1); return 0; } static int __init bat_init(void) { bat_setup(); - himalaya_battery_get_voltage(NULL); - himalaya_battery_get_temp(NULL); + blueangel_battery_get_voltage(NULL); + blueangel_battery_get_voltage1(NULL); + blueangel_battery_get_temp(NULL); apm_get_power_status = blueangel_battery_get_power_status; + #ifdef CONFIG_LEDS_TRIGGERS + led_trigger_register_simple("charge", &ledtrig_cradle); + #endif return 0; } @@ -204,14 +246,15 @@ static void __exit bat_exit(void) { apm_get_power_status = NULL; battery_class_unregister(&battery_dev); -#if 0 - device_unregister(&bat_tsc2200_dev); -#endif + battery_class_unregister(&battery_dev1); + #ifdef CONFIG_LEDS_TRIGGERS + led_trigger_unregister_simple(ledtrig_cradle); + #endif } module_init(bat_init) module_exit(bat_exit) MODULE_AUTHOR("Matthias Burghardt"); -MODULE_DESCRIPTION("Battery (TI TSC2200) support for the HTC Himalaya"); +MODULE_DESCRIPTION("Battery (TI TSC2200) support for the HTC Blueangel"); MODULE_LICENSE("GPL"); diff --git a/arch/arm/mach-pxa/htcblueangel/blueangel_ds1wm.c b/arch/arm/mach-pxa/htcblueangel/blueangel_ds1wm.c new file mode 100644 index 0000000000..be09aa21a0 --- /dev/null +++ b/arch/arm/mach-pxa/htcblueangel/blueangel_ds1wm.c @@ -0,0 +1,181 @@ +/* + * blueangel_ds1wm.c - HTC Blueangel DS1WM-in-AICr2 driver + * + * Copyright (C) 2006 Philipp Zabel + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + */ + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +#include +#include +#include "../../../../drivers/w1/masters/ds1wm.h" + +extern struct platform_device blueangel_asic3; +unsigned int __iomem *iobase; + + +static int read_register(int reg) +{ + volatile unsigned short *addr=((volatile unsigned short *)(iobase+0xa)); + volatile unsigned char *data=((volatile unsigned char *)(iobase+0xc)); + + *addr |= 0x80; + *addr = (*addr & 0xff80) | (reg & 0x7f); + + printk("read_register[0x%x]=0x%x\n", reg, *data); + return *data; +} + +static void write_register(int reg, int val) +{ + volatile unsigned short *addr=((volatile unsigned short *)(iobase+0xa)); + volatile unsigned short *data=((volatile unsigned short *)(iobase+0xc)); + + printk("write_register[0x%x]=0x%x\n", reg, val); + *addr = (*addr & 0xff80) | (reg & 0x7f); + *addr &= 0xff7f; + + *data = (*data & 0xff00) | (val & 0xff); + +} + +static struct resource blueangel_ds1wm_resources[] = { + [0] = { + .start = 0x11000000, + .end = 0x11000000 + 0x08, + .flags = IORESOURCE_MEM, + }, +/* + [1] = { + .start = IRQ_GPIO(113), + .end = IRQ_GPIO(113), + .flags = IORESOURCE_IRQ, + + } +*/ +}; + +static struct ds1wm_platform_data blueangel_ds1wm_platform_data = { + .bus_shift = 1, +}; + +static struct platform_device *blueangel_ds1wm; +#if 0 + = { + .name = "ds1wm", + .id = -1, + .num_resources = ARRAY_SIZE(blueangel_ds1wm_resources), + .resource = blueangel_ds1wm_resources, + .dev = { + .platform_data = blueangel_ds1wm_platform_data, + }, +}; +#endif + +static void blueangel_ds1wm_enable(struct clk *clock) +{ + /* I don't know how to enable the 4MHz OWM clock here */ + asic3_set_gpio_out_b(&blueangel_asic3.dev,0x0400, 0); + //asic3_set_gpio_out_c(&blueangel_asic3.dev,11, 1); + //asic3_set_gpio_out_a(&blueangel_asic3.dev,13, 1); + + printk ("blueangel_ds1wm: OWM_EN Low (active)\n"); +} + +static void blueangel_ds1wm_disable(struct clk *clock) +{ + asic3_set_gpio_out_b(&blueangel_asic3.dev,0x0400,1); + //asic3_set_gpio_out_c(&blueangel_asic3.dev,11,0); + //asic3_set_gpio_out_a(&blueangel_asic3.dev,13, 0); + + printk ("blueangel_ds1wm: GPIOB10 High (inactive)\n"); + + /* I don't know how to disable the 4MHz OWM clock here */ +} + +static struct clk ds1wm_clk = { + .name = "ds1wm", + .rate = 4000000, + .parent = NULL, + .enable = blueangel_ds1wm_enable, + .disable = blueangel_ds1wm_disable, +}; + +/* + * This handles the interrupt from one port. + */ +static irqreturn_t +ds1wm_irq(int irq, void *dev_id, struct pt_regs *regs) +{ + printk("DS1WM IRQ %d\n",irq); + //receive_chars(dev_id); + return IRQ_HANDLED; +} + +static int __devinit blueangel_ds1wm_init(void) +{ + int ret; + int base_irq; + printk("HTC Blueangel DS1WM driver\n"); + iobase = ioremap_nocache( 0x11000000, 0x0c); // map PASIC3 for EGPIO registers + base_irq = asic3_irq_base(&blueangel_asic3.dev); + set_irq_type(base_irq + _IPAQ_ASIC3_GPIO_BANK_D + 2, IRQ_TYPE_EDGE_FALLING); + ret = request_irq(base_irq + _IPAQ_ASIC3_GPIO_BANK_D + 2, NULL, 0, "htcblueangel_ds1wm", &blueangel_ds1wm); + if (ret) { + printk("blueangel_ds1wm: failed to register irq to ASIC3 device\n"); + } + + + if (clk_register(&ds1wm_clk) < 0) + printk(KERN_ERR "failed to register DS1WM clock\n"); + + blueangel_ds1wm = platform_device_alloc("ds1wm", -1); + if (!blueangel_ds1wm) { + printk("blueangel_ds1wm: failed to allocate platform device\n"); + ret = -ENOMEM; + goto exit_unmap; + } + + blueangel_ds1wm->num_resources = ARRAY_SIZE(blueangel_ds1wm_resources); + blueangel_ds1wm->resource = blueangel_ds1wm_resources; + blueangel_ds1wm->dev.platform_data = &blueangel_ds1wm_platform_data; + ret = platform_device_add(blueangel_ds1wm); + + if (ret) { + platform_device_put(blueangel_ds1wm); + printk("blueangel_ds1wm: failed to add platform device\n"); + } + + return ret; + +exit_unmap: + iounmap((void __iomem *)iobase); + return ret; +} + +static void __devexit blueangel_ds1wm_exit(void) +{ + platform_device_unregister(blueangel_ds1wm); + iounmap((void __iomem *)iobase); +} + +MODULE_AUTHOR("Philipp Zabel "); +MODULE_DESCRIPTION("DS1WM driver"); +MODULE_LICENSE("GPL"); + +module_init(blueangel_ds1wm_init); +module_exit(blueangel_ds1wm_exit); diff --git a/arch/arm/mach-pxa/htcblueangel/blueangel_kp.c b/arch/arm/mach-pxa/htcblueangel/blueangel_kp.c index 50809a9a00..e316d4719c 100644 --- a/arch/arm/mach-pxa/htcblueangel/blueangel_kp.c +++ b/arch/arm/mach-pxa/htcblueangel/blueangel_kp.c @@ -17,19 +17,18 @@ #include #include #include -#include -#include #include +#include #include +#include #include #include #include +#include #include #include -#include "../himalaya/tsc2200.h" - #ifdef DEBUG #define dprintk(x...) printk(x) #else @@ -38,10 +37,6 @@ extern struct platform_device blueangel_asic3; -enum button_irq_type { - gpio, asic3d, tsc2200 -}; - #define FN_BIT 0x80 #define SHIFT_BIT 0x80 @@ -133,93 +128,43 @@ static struct qkey { static int num_qkeys=sizeof(qkeys)/sizeof(struct qkey); -static struct key { - char *name; - enum button_irq_type irq_type; - int irq; - int irq_level; - int key; -} keys[] = { - {"power_button", gpio, IRQ_NR_BLUEANGEL_POWER_BUTTON, IRQT_FALLING, KEY_POWER}, - {"menu_button", asic3d, 5, IRQT_FALLING, KEY_F3 /* KEY_MENU */}, - {"ok_button", asic3d, 7, IRQT_FALLING, KEY_F4 /* KEY_OK */}, - {"windows_button", asic3d, 8, IRQT_FALLING, KEY_F1}, - {"record_button", asic3d, 9, IRQT_FALLING, KEY_F9 /* KEY_RECORD */}, - {"camera_button", asic3d, 10, IRQT_FALLING, KEY_F10 /* KEY_CAMERA */}, - {"volume_slider_up", asic3d, 11, IRQT_FALLING, KEY_VOLUMEUP}, - {"volume_slider_down", asic3d, 12, IRQT_FALLING, KEY_VOLUMEDOWN}, - {"mail_button", asic3d, 15, IRQT_FALLING, KEY_F2 /* KEY_EMAIL */}, - {"contacts", tsc2200, 0, IRQT_RISING, KEY_F5 /* KEY_CONTACTS */}, - {"calendar", tsc2200, 1, IRQT_RISING, KEY_F6 /* KEY_CALENDAR */}, - {"up", tsc2200, 3, IRQT_RISING, KEY_UP}, - {"select", tsc2200, 6, IRQT_RISING, KEY_KPENTER /* KEY_SELECT */}, - {"left", tsc2200, 7, IRQT_RISING, KEY_LEFT}, - {"phone_lift", tsc2200, 9, IRQT_RISING, KEY_F7 /* KEY_PHONE */}, - {"down", tsc2200, 11, IRQT_RISING, KEY_DOWN }, - {"phone_hangup", tsc2200, 12, IRQT_RISING, KEY_F8 /* CANCEL */}, - {"right", tsc2200, 15, IRQT_RISING, KEY_RIGHT}, -}; - -static int num_keys=sizeof(keys)/sizeof(struct key); - static struct timer_list timer; #define KP_POLL_TIME 20 /* milliseconds */ extern struct platform_device blueangel_asic3; -static struct input_dev blueangel_kp_input_dev; - -static void -blueangel_kp_report_key(struct key *k, int pressed) -{ - input_report_key(&blueangel_kp_input_dev, k->key, pressed); - input_sync(&blueangel_kp_input_dev); +static struct input_dev *blueangel_kp_input_dev; - if (pressed) - dprintk("%s pressed\n", k->name); - else - dprintk("%s released\n", k->name); -} - -static int asic3d_old; -static int tsc2200_old; static int fn_bit; -static void -blueangel_kp_check_keys(int irq_type, int *old, int new) +static irqreturn_t blueangel_qkbd_irq(int irq, void *data, struct pt_regs *regs) { - int i; - int xor; - struct key *k; - - xor=new ^ *old; - for (i = 0 ; i < num_keys ; i++) { - k=&keys[i]; - if (k->irq_type == irq_type && (xor & (1 << k->irq))) - blueangel_kp_report_key(k, new & (1 << k->irq)); - } - *old=new; -} - -static irqreturn_t blueangel_qkbd_irq(int irq, void *data) -{ - int timeout=0,key,dummy,pressed,i,keysym,shift; + int timeout=0, + key, + dummy, + pressed, + i, + keysym, + shift; + dprintk("%s: got interrupt for %d...\n", __FUNCTION__, irq); -// input_regs(&blueangel_kp_input_dev, regs); + //input_regs(blueangel_kp_input_dev, regs); dummy=asic3_read_register(&blueangel_asic3.dev, _IPAQ_ASIC3_SPI_Base+_IPAQ_ASIC3_SPI_TxData); asic3_write_register(&blueangel_asic3.dev, _IPAQ_ASIC3_SPI_Base+_IPAQ_ASIC3_SPI_TxData, 0); asic3_write_register(&blueangel_asic3.dev, _IPAQ_ASIC3_SPI_Base+_IPAQ_ASIC3_SPI_Control, - asic3_read_register(&blueangel_asic3.dev, _IPAQ_ASIC3_SPI_Base+_IPAQ_ASIC3_SPI_Control) | 0x8000); + asic3_read_register(&blueangel_asic3.dev, _IPAQ_ASIC3_SPI_Base+_IPAQ_ASIC3_SPI_Control) | 0x8000); + asic3_write_register(&blueangel_asic3.dev, _IPAQ_ASIC3_SPI_Base+_IPAQ_ASIC3_SPI_Control, - asic3_read_register(&blueangel_asic3.dev, _IPAQ_ASIC3_SPI_Base+_IPAQ_ASIC3_SPI_Control) | 0x10); + asic3_read_register(&blueangel_asic3.dev, _IPAQ_ASIC3_SPI_Base+_IPAQ_ASIC3_SPI_Control) | 0x10); + for (;;) { if (!(asic3_read_register(&blueangel_asic3.dev, _IPAQ_ASIC3_SPI_Base+_IPAQ_ASIC3_SPI_Status) & 0x10)) break; udelay(10); if (timeout++ > 10) { - printk("Timeout reading key\n"); + printk("blueangel_kp: Timeout reading key\n"); break; } } @@ -239,14 +184,14 @@ static irqreturn_t blueangel_qkbd_irq(int irq, void *data) shift=keysym & SHIFT_BIT; keysym &= ~SHIFT_BIT; if (shift && pressed) { - input_report_key(&blueangel_kp_input_dev, KEY_RIGHTSHIFT, 1); - input_sync(&blueangel_kp_input_dev); + input_report_key(blueangel_kp_input_dev, KEY_RIGHTSHIFT, 1); + input_sync(blueangel_kp_input_dev); } - input_report_key(&blueangel_kp_input_dev, keysym, pressed); - input_sync(&blueangel_kp_input_dev); + input_report_key(blueangel_kp_input_dev, keysym, pressed); + input_sync(blueangel_kp_input_dev); if (shift && !pressed) { - input_report_key(&blueangel_kp_input_dev, KEY_RIGHTSHIFT, 0); - input_sync(&blueangel_kp_input_dev); + input_report_key(blueangel_kp_input_dev, KEY_RIGHTSHIFT, 0); + input_sync(blueangel_kp_input_dev); } } return IRQ_HANDLED; @@ -256,156 +201,57 @@ static irqreturn_t blueangel_qkbd_irq(int irq, void *data) return IRQ_HANDLED; } -static irqreturn_t blueangel_kp_irq(int irq, void *data) -{ - struct key *k=data; - dprintk("%s: got interrupt for %d...\n", __FUNCTION__, irq); -// input_regs(&blueangel_kp_input_dev, regs); - if (k->irq_level == IRQT_FALLING) - k->irq_level=IRQT_RISING; - else - k->irq_level=IRQT_FALLING; - set_irq_type(irq, k->irq_level); - if (k->irq_type == asic3d) - blueangel_kp_check_keys(asic3d, &asic3d_old, ~(asic3_get_gpio_status_d(&blueangel_asic3.dev))); - else - blueangel_kp_report_key(k, !(GPLR(GPIO_NR_BLUEANGEL_POWER_BUTTON_N) & GPIO_bit(GPIO_NR_BLUEANGEL_POWER_BUTTON_N))); - return IRQ_HANDLED; -} - -static void -blueangel_kp_timer(unsigned long dummy) -{ - int status, keys; - - status=tsc2200_read(TSC2200_CTRLREG_KEY); - if (status & 0x8000) - keys=tsc2200_read(TSC2200_DATAREG_KPDATA); - else - keys=0; - blueangel_kp_check_keys(tsc2200,&tsc2200_old, keys); - if (keys) - mod_timer (&timer, jiffies + (KP_POLL_TIME * HZ) / 1000); - else - enable_irq(IRQ_NR_BLUEANGEL_TSC2200_KB); -} - -static irqreturn_t blueangel_kp_tsc2200_irq(int irq, void *data) -{ - int status, keys; -// input_regs(&blueangel_kp_input_dev, regs); - status=tsc2200_read(TSC2200_CTRLREG_KEY); - if (status & 0x8000) - keys=tsc2200_read(TSC2200_DATAREG_KPDATA); - else - keys=0; - blueangel_kp_check_keys(tsc2200,&tsc2200_old, keys); - if (keys) { - dprintk("keys=0x%x\n", keys); - disable_irq(IRQ_NR_BLUEANGEL_TSC2200_KB); - mod_timer (&timer, jiffies + (KP_POLL_TIME * HZ) / 1000); - } - return IRQ_HANDLED; -} - static int blueangel_kp_init (void) { int i,irq,key; - struct key *k; dprintk("%s\n", __FUNCTION__); disable_irq(ASIC3_SPI_IRQ); asic3_write_register(&blueangel_asic3.dev, _IPAQ_ASIC3_SPI_Base+_IPAQ_ASIC3_SPI_Int, 0); - blueangel_kp_input_dev.evbit[0] = BIT(EV_KEY) | BIT(EV_REP); - init_input_dev(&blueangel_kp_input_dev); - for (i = 0 ; i < num_keys ; i++) { - k=&keys[i]; - irq=-1; - set_bit(k->key, blueangel_kp_input_dev.keybit); - switch (k->irq_type) { - case gpio: - irq=k->irq; - break; - case asic3d: - irq=asic3_irq_base(&blueangel_asic3.dev) + ASIC3_GPIOD_IRQ_BASE + k->irq; - break; - case tsc2200: - break; - } - if (irq != -1) { - dprintk("requesting irq %d\n", irq); - request_irq(irq, blueangel_kp_irq, SA_SAMPLE_RANDOM, k->name, k); - set_irq_type(irq, k->irq_level); - } -#if 0 - blueangel_kp_input_dev.keybit[k->key] |= BIT(k->key); -#endif - } + + blueangel_kp_input_dev = input_allocate_device(); + + blueangel_kp_input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP); + //init_input_dev(blueangel_kp_input_dev); + for (i = 0 ; i < num_qkeys ; i++) { key=qkeys[i].key; if (key) { dprintk("enabling key %d\n", qkeys[i].key); - set_bit(key, blueangel_kp_input_dev.keybit); + set_bit(key, blueangel_kp_input_dev->keybit); } } - request_irq(IRQ_NR_BLUEANGEL_TSC2200_KB, blueangel_kp_tsc2200_irq, SA_SAMPLE_RANDOM, "blueangel_tsc2200_kb", NULL); - set_irq_type(IRQ_NR_BLUEANGEL_TSC2200_KB, IRQT_FALLING); irq=asic3_irq_base(&blueangel_asic3.dev) + ASIC3_GPIOD_IRQ_BASE + GPIOD_QKBD_IRQ; request_irq(irq, blueangel_qkbd_irq, SA_SAMPLE_RANDOM, "blueangel_qkbd", NULL); set_irq_type(irq, IRQT_FALLING); - init_timer(&timer); - timer.function = blueangel_kp_timer; - timer.data = 0; - - - blueangel_kp_input_dev.name = "blueangelkb"; - blueangel_kp_input_dev.phys = "keyboard/blueangelkb"; + blueangel_kp_input_dev->name = "blueangelkb"; + blueangel_kp_input_dev->phys = "keyboard/blueangelkb"; // blueangel_kp_input_dev.id.bustype = BUS_PXA_NSSP; - blueangel_kp_input_dev.id.vendor = 0x0001; - blueangel_kp_input_dev.id.product = 0x0001; - blueangel_kp_input_dev.id.version = 0x0100; - - input_register_device(&blueangel_kp_input_dev); + blueangel_kp_input_dev->id.vendor = 0x0001; + blueangel_kp_input_dev->id.product = 0x0001; + blueangel_kp_input_dev->id.version = 0x0100; + input_register_device(blueangel_kp_input_dev); return 0; } static void blueangel_kp_exit (void) { - int i,irq; - struct key *k; + int irq; - dprintk("%s\n", __FUNCTION__); - input_unregister_device(&blueangel_kp_input_dev); - for (i = 0 ; i < num_keys ; i++) { - k=&keys[i]; - irq=-1; - switch (k->irq_type) { - case gpio: - irq=k->irq; - break; - case asic3d: - irq=asic3_irq_base(&blueangel_asic3.dev) + ASIC3_GPIOD_IRQ_BASE + k->irq; - break; - case tsc2200: - break; - } - if (irq != -1) { - dprintk("releasing irq %d\n", irq); - free_irq(irq, k); - } - } - free_irq(IRQ_NR_BLUEANGEL_TSC2200_KB, NULL); + printk("%s\n", __FUNCTION__); + input_unregister_device(blueangel_kp_input_dev); + irq=asic3_irq_base(&blueangel_asic3.dev) + ASIC3_GPIOD_IRQ_BASE + GPIOD_QKBD_IRQ; free_irq(irq, NULL); - del_timer_sync (&timer); +// del_timer_sync (&timer); } module_init (blueangel_kp_init); diff --git a/arch/arm/mach-pxa/htcblueangel/blueangel_lcd.c b/arch/arm/mach-pxa/htcblueangel/blueangel_lcd.c index 567024e2df..f87303878b 100644 --- a/arch/arm/mach-pxa/htcblueangel/blueangel_lcd.c +++ b/arch/arm/mach-pxa/htcblueangel/blueangel_lcd.c @@ -29,6 +29,7 @@ #include #include #include +#include #include #include