Merge branches 'omap1-upstream' and 'omap2-upstream' into devel
[linux-2.6] / arch / arm / mach-omap1 / board-palmte.c
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  *
10  * Maintainers : http://palmtelinux.sf.net
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>
20 #include <linux/input.h>
21 #include <linux/platform_device.h>
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>
27
28 #include <asm/apm.h>
29 #include <asm/hardware.h>
30 #include <asm/mach-types.h>
31 #include <asm/mach/arch.h>
32 #include <asm/mach/map.h>
33 #include <asm/mach/flash.h>
34
35 #include <asm/arch/gpio.h>
36 #include <asm/arch/mux.h>
37 #include <asm/arch/usb.h>
38 #include <asm/arch/tc.h>
39 #include <asm/arch/dma.h>
40 #include <asm/arch/board.h>
41 #include <asm/arch/irda.h>
42 #include <asm/arch/keypad.h>
43 #include <asm/arch/common.h>
44 #include <asm/arch/mcbsp.h>
45 #include <asm/arch/omap-alsa.h>
46
47 static void __init omap_palmte_init_irq(void)
48 {
49         omap1_init_common_hw();
50         omap_init_irq();
51         omap_gpio_init();
52 }
53
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
138 static struct platform_device palmte_lcd_device = {
139         .name           = "lcd_palmte",
140         .id             = -1,
141 };
142
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
183 static struct platform_device *devices[] __initdata = {
184         &palmte_rom_device,
185         &palmte_kp_device,
186         &palmte_lcd_device,
187         &palmte_backlight_device,
188         &palmte_irda_device,
189 };
190
191 static struct omap_usb_config palmte_usb_config __initdata = {
192         .register_dev   = 1,    /* Mini-B only receptacle */
193         .hmc_mode       = 0,
194         .pins[0]        = 2,
195 };
196
197 static struct omap_mmc_config palmte_mmc_config __initdata = {
198         .mmc[0]         = {
199                 .enabled        = 1,
200                 .wp_pin         = PALMTE_MMC_WP_GPIO,
201                 .power_pin      = PALMTE_MMC_POWER_GPIO,
202                 .switch_pin     = PALMTE_MMC_SWITCH_GPIO,
203         },
204 };
205
206 static struct omap_lcd_config palmte_lcd_config __initdata = {
207         .ctrl_name      = "internal",
208 };
209
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
324 static struct omap_board_config_kernel palmte_config[] = {
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 },
329 };
330
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)
413 {
414         omap_board_config = palmte_config;
415         omap_board_config_size = ARRAY_SIZE(palmte_config);
416
417         platform_add_devices(devices, ARRAY_SIZE(devices));
418
419         spi_register_board_info(palmte_spi_info, ARRAY_SIZE(palmte_spi_info));
420
421         omap_serial_init();
422         palmte_gpio_setup();
423 }
424
425 static void __init omap_palmte_map_io(void)
426 {
427         omap1_map_common_io();
428 }
429
430 MACHINE_START(OMAP_PALMTE, "OMAP310 based Palm Tungsten E")
431         .phys_io        = 0xfff00000,
432         .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
433         .boot_params    = 0x10000100,
434         .map_io         = omap_palmte_map_io,
435         .init_irq       = omap_palmte_init_irq,
436         .init_machine   = omap_palmte_init,
437         .timer          = &omap_timer,
438 MACHINE_END