2bea941741d595805ebc1b46e81e95ed8de76a98
[linux-2.6.git] / arch / arm / mach-omap1 / board-sx1.c
1 /*
2 * linux/arch/arm/mach-omap1/board-sx1.c
3 *
4 * Modified from board-generic.c
5 *
6 * Support for the Siemens SX1 mobile phone.
7 *
8 * Original version : Vladimir Ananiev (Vovan888-at-gmail com)
9 *
10 * Maintainters : Vladimir Ananiev (aka Vovan888), Sergge
11 *               oslik.ru
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 #include <linux/gpio.h>
18 #include <linux/kernel.h>
19 #include <linux/init.h>
20 #include <linux/input.h>
21 #include <linux/platform_device.h>
22 #include <linux/notifier.h>
23 #include <linux/mtd/mtd.h>
24 #include <linux/mtd/partitions.h>
25 #include <linux/mtd/physmap.h>
26 #include <linux/types.h>
27 #include <linux/i2c.h>
28 #include <linux/errno.h>
29
30 #include <mach/hardware.h>
31 #include <asm/mach-types.h>
32 #include <asm/mach/arch.h>
33 #include <asm/mach/map.h>
34
35 #include <plat/flash.h>
36 #include <plat/mux.h>
37 #include <plat/dma.h>
38 #include <plat/irda.h>
39 #include <plat/usb.h>
40 #include <plat/tc.h>
41 #include <plat/board.h>
42 #include <plat/common.h>
43 #include <plat/keypad.h>
44 #include <plat/board-sx1.h>
45
46 /* Write to I2C device */
47 int sx1_i2c_write_byte(u8 devaddr, u8 regoffset, u8 value)
48 {
49         struct i2c_adapter *adap;
50         int err;
51         struct i2c_msg msg[1];
52         unsigned char data[2];
53
54         adap = i2c_get_adapter(0);
55         if (!adap)
56                 return -ENODEV;
57         msg->addr = devaddr;    /* I2C address of chip */
58         msg->flags = 0;
59         msg->len = 2;
60         msg->buf = data;
61         data[0] = regoffset;    /* register num */
62         data[1] = value;                /* register data */
63         err = i2c_transfer(adap, msg, 1);
64         i2c_put_adapter(adap);
65         if (err >= 0)
66                 return 0;
67         return err;
68 }
69
70 /* Read from I2C device */
71 int sx1_i2c_read_byte(u8 devaddr, u8 regoffset, u8 *value)
72 {
73         struct i2c_adapter *adap;
74         int err;
75         struct i2c_msg msg[1];
76         unsigned char data[2];
77
78         adap = i2c_get_adapter(0);
79         if (!adap)
80                 return -ENODEV;
81
82         msg->addr = devaddr;    /* I2C address of chip */
83         msg->flags = 0;
84         msg->len = 1;
85         msg->buf = data;
86         data[0] = regoffset;    /* register num */
87         err = i2c_transfer(adap, msg, 1);
88
89         msg->addr = devaddr;    /* I2C address */
90         msg->flags = I2C_M_RD;
91         msg->len = 1;
92         msg->buf = data;
93         err = i2c_transfer(adap, msg, 1);
94         *value = data[0];
95         i2c_put_adapter(adap);
96
97         if (err >= 0)
98                 return 0;
99         return err;
100 }
101 /* set keyboard backlight intensity */
102 int sx1_setkeylight(u8 keylight)
103 {
104         if (keylight > SOFIA_MAX_LIGHT_VAL)
105                 keylight = SOFIA_MAX_LIGHT_VAL;
106         return sx1_i2c_write_byte(SOFIA_I2C_ADDR, SOFIA_KEYLIGHT_REG, keylight);
107 }
108 /* get current keylight intensity */
109 int sx1_getkeylight(u8 * keylight)
110 {
111         return sx1_i2c_read_byte(SOFIA_I2C_ADDR, SOFIA_KEYLIGHT_REG, keylight);
112 }
113 /* set LCD backlight intensity */
114 int sx1_setbacklight(u8 backlight)
115 {
116         if (backlight > SOFIA_MAX_LIGHT_VAL)
117                 backlight = SOFIA_MAX_LIGHT_VAL;
118         return sx1_i2c_write_byte(SOFIA_I2C_ADDR, SOFIA_BACKLIGHT_REG,
119                                   backlight);
120 }
121 /* get current LCD backlight intensity */
122 int sx1_getbacklight (u8 * backlight)
123 {
124         return sx1_i2c_read_byte(SOFIA_I2C_ADDR, SOFIA_BACKLIGHT_REG,
125                                  backlight);
126 }
127 /* set LCD backlight power on/off */
128 int sx1_setmmipower(u8 onoff)
129 {
130         int err;
131         u8 dat = 0;
132         err = sx1_i2c_read_byte(SOFIA_I2C_ADDR, SOFIA_POWER1_REG, &dat);
133         if (err < 0)
134                 return err;
135         if (onoff)
136                 dat |= SOFIA_MMILIGHT_POWER;
137         else
138                 dat &= ~SOFIA_MMILIGHT_POWER;
139         return sx1_i2c_write_byte(SOFIA_I2C_ADDR, SOFIA_POWER1_REG, dat);
140 }
141
142 /* set USB power on/off */
143 int sx1_setusbpower(u8 onoff)
144 {
145         int err;
146         u8 dat = 0;
147         err = sx1_i2c_read_byte(SOFIA_I2C_ADDR, SOFIA_POWER1_REG, &dat);
148         if (err < 0)
149                 return err;
150         if (onoff)
151                 dat |= SOFIA_USB_POWER;
152         else
153                 dat &= ~SOFIA_USB_POWER;
154         return sx1_i2c_write_byte(SOFIA_I2C_ADDR, SOFIA_POWER1_REG, dat);
155 }
156
157 EXPORT_SYMBOL(sx1_setkeylight);
158 EXPORT_SYMBOL(sx1_getkeylight);
159 EXPORT_SYMBOL(sx1_setbacklight);
160 EXPORT_SYMBOL(sx1_getbacklight);
161 EXPORT_SYMBOL(sx1_setmmipower);
162 EXPORT_SYMBOL(sx1_setusbpower);
163
164 /*----------- Keypad -------------------------*/
165
166 static const unsigned int sx1_keymap[] = {
167         KEY(3, 5, GROUP_0 | 117), /* camera Qt::Key_F17 */
168         KEY(4, 0, GROUP_0 | 114), /* voice memo Qt::Key_F14 */
169         KEY(4, 1, GROUP_2 | 114), /* voice memo */
170         KEY(4, 2, GROUP_3 | 114), /* voice memo */
171         KEY(0, 0, GROUP_1 | KEY_F12),   /* red button Qt::Key_Hangup */
172         KEY(3, 4, GROUP_1 | KEY_LEFT),
173         KEY(3, 2, GROUP_1 | KEY_DOWN),
174         KEY(3, 1, GROUP_1 | KEY_RIGHT),
175         KEY(3, 0, GROUP_1 | KEY_UP),
176         KEY(3, 3, GROUP_1 | KEY_POWER), /* joystick press or Qt::Key_Select */
177         KEY(0, 5, GROUP_1 | KEY_1),
178         KEY(0, 4, GROUP_1 | KEY_2),
179         KEY(0, 3, GROUP_1 | KEY_3),
180         KEY(4, 3, GROUP_1 | KEY_4),
181         KEY(4, 4, GROUP_1 | KEY_5),
182         KEY(4, 5, GROUP_1 | KEY_KPASTERISK),/* "*" */
183         KEY(1, 4, GROUP_1 | KEY_6),
184         KEY(1, 5, GROUP_1 | KEY_7),
185         KEY(1, 3, GROUP_1 | KEY_8),
186         KEY(2, 3, GROUP_1 | KEY_9),
187         KEY(2, 5, GROUP_1 | KEY_0),
188         KEY(2, 4, GROUP_1 | 113), /* # F13 Toggle input method Qt::Key_F13 */
189         KEY(1, 0, GROUP_1 | KEY_F11),   /* green button Qt::Key_Call */
190         KEY(2, 1, GROUP_1 | KEY_YEN),   /* left soft Qt::Key_Context1 */
191         KEY(2, 2, GROUP_1 | KEY_F8),    /* right soft Qt::Key_Back */
192         KEY(1, 2, GROUP_1 | KEY_LEFTSHIFT), /* shift */
193         KEY(1, 1, GROUP_1 | KEY_BACKSPACE), /* C (clear) */
194         KEY(2, 0, GROUP_1 | KEY_F7),    /* menu Qt::Key_Menu */
195 };
196
197 static struct resource sx1_kp_resources[] = {
198         [0] = {
199                 .start  = INT_KEYBOARD,
200                 .end    = INT_KEYBOARD,
201                 .flags  = IORESOURCE_IRQ,
202         },
203 };
204
205 static const struct matrix_keymap_data sx1_keymap_data = {
206         .keymap         = sx1_keymap,
207         .keymap_size    = ARRAY_SIZE(sx1_keymap),
208 };
209
210 static struct omap_kp_platform_data sx1_kp_data = {
211         .rows           = 6,
212         .cols           = 6,
213         .keymap_data    = &sx1_keymap_data,
214         .delay  = 80,
215 };
216
217 static struct platform_device sx1_kp_device = {
218         .name           = "omap-keypad",
219         .id             = -1,
220         .dev            = {
221                 .platform_data = &sx1_kp_data,
222         },
223         .num_resources  = ARRAY_SIZE(sx1_kp_resources),
224         .resource       = sx1_kp_resources,
225 };
226
227 /*----------- IRDA -------------------------*/
228
229 static struct omap_irda_config sx1_irda_data = {
230         .transceiver_cap        = IR_SIRMODE,
231         .rx_channel             = OMAP_DMA_UART3_RX,
232         .tx_channel             = OMAP_DMA_UART3_TX,
233         .dest_start             = UART3_THR,
234         .src_start              = UART3_RHR,
235         .tx_trigger             = 0,
236         .rx_trigger             = 0,
237 };
238
239 static struct resource sx1_irda_resources[] = {
240         [0] = {
241                 .start  = INT_UART3,
242                 .end    = INT_UART3,
243                 .flags  = IORESOURCE_IRQ,
244         },
245 };
246
247 static u64 irda_dmamask = 0xffffffff;
248
249 static struct platform_device sx1_irda_device = {
250         .name           = "omapirda",
251         .id             = 0,
252         .dev            = {
253                 .platform_data  = &sx1_irda_data,
254                 .dma_mask       = &irda_dmamask,
255         },
256         .num_resources  = ARRAY_SIZE(sx1_irda_resources),
257         .resource       = sx1_irda_resources,
258 };
259
260 /*----------- MTD -------------------------*/
261
262 static struct mtd_partition sx1_partitions[] = {
263         /* bootloader (U-Boot, etc) in first sector */
264         {
265                 .name           = "bootloader",
266                 .offset         = 0x01800000,
267                 .size           = SZ_128K,
268                 .mask_flags     = MTD_WRITEABLE, /* force read-only */
269         },
270         /* bootloader params in the next sector */
271         {
272                 .name           = "params",
273                 .offset         = MTDPART_OFS_APPEND,
274                 .size           = SZ_128K,
275                 .mask_flags     = 0,
276         },
277         /* kernel */
278         {
279                 .name           = "kernel",
280                 .offset         = MTDPART_OFS_APPEND,
281                 .size           = SZ_2M - 2 * SZ_128K,
282                 .mask_flags     = 0
283         },
284         /* file system */
285         {
286                 .name           = "filesystem",
287                 .offset         = MTDPART_OFS_APPEND,
288                 .size           = MTDPART_SIZ_FULL,
289                 .mask_flags     = 0
290         }
291 };
292
293 static struct physmap_flash_data sx1_flash_data = {
294         .width          = 2,
295         .set_vpp        = omap1_set_vpp,
296         .parts          = sx1_partitions,
297         .nr_parts       = ARRAY_SIZE(sx1_partitions),
298 };
299
300 #ifdef CONFIG_SX1_OLD_FLASH
301 /* MTD Intel StrataFlash - old flashes */
302 static struct resource sx1_old_flash_resource[] = {
303         [0] = {
304                 .start  = OMAP_CS0_PHYS,        /* Physical */
305                 .end    = OMAP_CS0_PHYS + SZ_16M - 1,,
306                 .flags  = IORESOURCE_MEM,
307         },
308         [1] = {
309                 .start  = OMAP_CS1_PHYS,
310                 .end    = OMAP_CS1_PHYS + SZ_8M - 1,
311                 .flags  = IORESOURCE_MEM,
312         },
313 };
314
315 static struct platform_device sx1_flash_device = {
316         .name           = "physmap-flash",
317         .id             = 0,
318         .dev            = {
319                 .platform_data  = &sx1_flash_data,
320         },
321         .num_resources  = 2,
322         .resource       = &sx1_old_flash_resource,
323 };
324 #else
325 /* MTD Intel 4000 flash - new flashes */
326 static struct resource sx1_new_flash_resource = {
327         .start          = OMAP_CS0_PHYS,
328         .end            = OMAP_CS0_PHYS + SZ_32M - 1,
329         .flags          = IORESOURCE_MEM,
330 };
331
332 static struct platform_device sx1_flash_device = {
333         .name           = "physmap-flash",
334         .id             = 0,
335         .dev            = {
336                 .platform_data  = &sx1_flash_data,
337         },
338         .num_resources  = 1,
339         .resource       = &sx1_new_flash_resource,
340 };
341 #endif
342
343 /*----------- USB -------------------------*/
344
345 static struct omap_usb_config sx1_usb_config __initdata = {
346         .otg            = 0,
347         .register_dev   = 1,
348         .register_host  = 0,
349         .hmc_mode       = 0,
350         .pins[0]        = 2,
351         .pins[1]        = 0,
352         .pins[2]        = 0,
353 };
354
355 /*----------- LCD -------------------------*/
356
357 static struct platform_device sx1_lcd_device = {
358         .name           = "lcd_sx1",
359         .id             = -1,
360 };
361
362 static struct omap_lcd_config sx1_lcd_config __initdata = {
363         .ctrl_name      = "internal",
364 };
365
366 /*-----------------------------------------*/
367 static struct platform_device *sx1_devices[] __initdata = {
368         &sx1_flash_device,
369         &sx1_kp_device,
370         &sx1_lcd_device,
371         &sx1_irda_device,
372 };
373 /*-----------------------------------------*/
374
375 static struct omap_board_config_kernel sx1_config[] __initdata = {
376         { OMAP_TAG_LCD, &sx1_lcd_config },
377 };
378
379 /*-----------------------------------------*/
380
381 static void __init omap_sx1_init(void)
382 {
383         /* mux pins for uarts */
384         omap_cfg_reg(UART1_TX);
385         omap_cfg_reg(UART1_RTS);
386         omap_cfg_reg(UART2_TX);
387         omap_cfg_reg(UART2_RTS);
388         omap_cfg_reg(UART3_TX);
389         omap_cfg_reg(UART3_RX);
390
391         platform_add_devices(sx1_devices, ARRAY_SIZE(sx1_devices));
392
393         omap_board_config = sx1_config;
394         omap_board_config_size = ARRAY_SIZE(sx1_config);
395         omap_serial_init();
396         omap_register_i2c_bus(1, 100, NULL, 0);
397         omap1_usb_init(&sx1_usb_config);
398         sx1_mmc_init();
399
400         /* turn on USB power */
401         /* sx1_setusbpower(1); can't do it here because i2c is not ready */
402         gpio_request(1, "A_IRDA_OFF");
403         gpio_request(11, "A_SWITCH");
404         gpio_request(15, "A_USB_ON");
405         gpio_direction_output(1, 1);    /*A_IRDA_OFF = 1 */
406         gpio_direction_output(11, 0);   /*A_SWITCH = 0 */
407         gpio_direction_output(15, 0);   /*A_USB_ON = 0 */
408 }
409 /*----------------------------------------*/
410 static void __init omap_sx1_init_irq(void)
411 {
412         omap1_init_common_hw();
413         omap1_init_irq();
414 }
415 /*----------------------------------------*/
416
417 static void __init omap_sx1_map_io(void)
418 {
419         omap1_map_common_io();
420 }
421
422 MACHINE_START(SX1, "OMAP310 based Siemens SX1")
423         .atag_offset    = 0x100,
424         .map_io         = omap_sx1_map_io,
425         .reserve        = omap_reserve,
426         .init_irq       = omap_sx1_init_irq,
427         .init_machine   = omap_sx1_init,
428         .timer          = &omap1_timer,
429 MACHINE_END