Merge git://git.kernel.org/pub/scm/linux/kernel/git/pkl/squashfs-linus
[pandora-kernel.git] / arch / arm / mach-omap2 / board-cm-t35.c
1 /*
2  * board-cm-t35.c (CompuLab CM-T35 module)
3  *
4  * Copyright (C) 2009 CompuLab, Ltd.
5  * Author: Mike Rapoport <mike@compulab.co.il>
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License
9  * version 2 as published by the Free Software Foundation.
10  *
11  * This program is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
19  * 02110-1301 USA
20  *
21  */
22
23 #include <linux/kernel.h>
24 #include <linux/init.h>
25 #include <linux/platform_device.h>
26 #include <linux/input.h>
27 #include <linux/input/matrix_keypad.h>
28 #include <linux/delay.h>
29 #include <linux/gpio.h>
30
31 #include <linux/i2c/at24.h>
32 #include <linux/i2c/twl.h>
33 #include <linux/regulator/machine.h>
34 #include <linux/mmc/host.h>
35
36 #include <linux/spi/spi.h>
37 #include <linux/spi/tdo24m.h>
38
39 #include <asm/mach-types.h>
40 #include <asm/mach/arch.h>
41 #include <asm/mach/map.h>
42
43 #include <plat/board.h>
44 #include <plat/common.h>
45 #include <plat/nand.h>
46 #include <plat/gpmc.h>
47 #include <plat/usb.h>
48 #include <plat/display.h>
49 #include <plat/panel-generic-dpi.h>
50 #include <plat/mcspi.h>
51
52 #include <mach/hardware.h>
53
54 #include "mux.h"
55 #include "sdram-micron-mt46h32m32lf-6.h"
56 #include "hsmmc.h"
57
58 #define CM_T35_GPIO_PENDOWN     57
59
60 #define CM_T35_SMSC911X_CS      5
61 #define CM_T35_SMSC911X_GPIO    163
62 #define SB_T35_SMSC911X_CS      4
63 #define SB_T35_SMSC911X_GPIO    65
64
65 #define NAND_BLOCK_SIZE         SZ_128K
66
67 #if defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE)
68 #include <linux/smsc911x.h>
69
70 static struct smsc911x_platform_config cm_t35_smsc911x_config = {
71         .irq_polarity   = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
72         .irq_type       = SMSC911X_IRQ_TYPE_OPEN_DRAIN,
73         .flags          = SMSC911X_USE_32BIT | SMSC911X_SAVE_MAC_ADDRESS,
74         .phy_interface  = PHY_INTERFACE_MODE_MII,
75 };
76
77 static struct resource cm_t35_smsc911x_resources[] = {
78         {
79                 .flags  = IORESOURCE_MEM,
80         },
81         {
82                 .start  = OMAP_GPIO_IRQ(CM_T35_SMSC911X_GPIO),
83                 .end    = OMAP_GPIO_IRQ(CM_T35_SMSC911X_GPIO),
84                 .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
85         },
86 };
87
88 static struct platform_device cm_t35_smsc911x_device = {
89         .name           = "smsc911x",
90         .id             = 0,
91         .num_resources  = ARRAY_SIZE(cm_t35_smsc911x_resources),
92         .resource       = cm_t35_smsc911x_resources,
93         .dev            = {
94                 .platform_data = &cm_t35_smsc911x_config,
95         },
96 };
97
98 static struct resource sb_t35_smsc911x_resources[] = {
99         {
100                 .flags  = IORESOURCE_MEM,
101         },
102         {
103                 .start  = OMAP_GPIO_IRQ(SB_T35_SMSC911X_GPIO),
104                 .end    = OMAP_GPIO_IRQ(SB_T35_SMSC911X_GPIO),
105                 .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
106         },
107 };
108
109 static struct platform_device sb_t35_smsc911x_device = {
110         .name           = "smsc911x",
111         .id             = 1,
112         .num_resources  = ARRAY_SIZE(sb_t35_smsc911x_resources),
113         .resource       = sb_t35_smsc911x_resources,
114         .dev            = {
115                 .platform_data = &cm_t35_smsc911x_config,
116         },
117 };
118
119 static void __init cm_t35_init_smsc911x(struct platform_device *dev,
120                                         int cs, int irq_gpio)
121 {
122         unsigned long cs_mem_base;
123
124         if (gpmc_cs_request(cs, SZ_16M, &cs_mem_base) < 0) {
125                 pr_err("CM-T35: Failed request for GPMC mem for smsc911x\n");
126                 return;
127         }
128
129         dev->resource[0].start = cs_mem_base + 0x0;
130         dev->resource[0].end   = cs_mem_base + 0xff;
131
132         if ((gpio_request(irq_gpio, "ETH IRQ") == 0) &&
133             (gpio_direction_input(irq_gpio) == 0)) {
134                 gpio_export(irq_gpio, 0);
135         } else {
136                 pr_err("CM-T35: could not obtain gpio for SMSC911X IRQ\n");
137                 return;
138         }
139
140         platform_device_register(dev);
141 }
142
143 static void __init cm_t35_init_ethernet(void)
144 {
145         cm_t35_init_smsc911x(&cm_t35_smsc911x_device,
146                              CM_T35_SMSC911X_CS, CM_T35_SMSC911X_GPIO);
147         cm_t35_init_smsc911x(&sb_t35_smsc911x_device,
148                              SB_T35_SMSC911X_CS, SB_T35_SMSC911X_GPIO);
149 }
150 #else
151 static inline void __init cm_t35_init_ethernet(void) { return; }
152 #endif
153
154 #if defined(CONFIG_LEDS_GPIO) || defined(CONFIG_LEDS_GPIO_MODULE)
155 #include <linux/leds.h>
156
157 static struct gpio_led cm_t35_leds[] = {
158         [0] = {
159                 .gpio                   = 186,
160                 .name                   = "cm-t35:green",
161                 .default_trigger        = "heartbeat",
162                 .active_low             = 0,
163         },
164 };
165
166 static struct gpio_led_platform_data cm_t35_led_pdata = {
167         .num_leds       = ARRAY_SIZE(cm_t35_leds),
168         .leds           = cm_t35_leds,
169 };
170
171 static struct platform_device cm_t35_led_device = {
172         .name           = "leds-gpio",
173         .id             = -1,
174         .dev            = {
175                 .platform_data  = &cm_t35_led_pdata,
176         },
177 };
178
179 static void __init cm_t35_init_led(void)
180 {
181         platform_device_register(&cm_t35_led_device);
182 }
183 #else
184 static inline void cm_t35_init_led(void) {}
185 #endif
186
187 #if defined(CONFIG_MTD_NAND_OMAP2) || defined(CONFIG_MTD_NAND_OMAP2_MODULE)
188 #include <linux/mtd/mtd.h>
189 #include <linux/mtd/nand.h>
190 #include <linux/mtd/partitions.h>
191
192 static struct mtd_partition cm_t35_nand_partitions[] = {
193         {
194                 .name           = "xloader",
195                 .offset         = 0,                    /* Offset = 0x00000 */
196                 .size           = 4 * NAND_BLOCK_SIZE,
197                 .mask_flags     = MTD_WRITEABLE
198         },
199         {
200                 .name           = "uboot",
201                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x80000 */
202                 .size           = 15 * NAND_BLOCK_SIZE,
203         },
204         {
205                 .name           = "uboot environment",
206                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x260000 */
207                 .size           = 2 * NAND_BLOCK_SIZE,
208         },
209         {
210                 .name           = "linux",
211                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x280000 */
212                 .size           = 32 * NAND_BLOCK_SIZE,
213         },
214         {
215                 .name           = "rootfs",
216                 .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x680000 */
217                 .size           = MTDPART_SIZ_FULL,
218         },
219 };
220
221 static struct omap_nand_platform_data cm_t35_nand_data = {
222         .parts                  = cm_t35_nand_partitions,
223         .nr_parts               = ARRAY_SIZE(cm_t35_nand_partitions),
224         .dma_channel            = -1,   /* disable DMA in OMAP NAND driver */
225         .cs                     = 0,
226
227 };
228
229 static void __init cm_t35_init_nand(void)
230 {
231         if (gpmc_nand_init(&cm_t35_nand_data) < 0)
232                 pr_err("CM-T35: Unable to register NAND device\n");
233 }
234 #else
235 static inline void cm_t35_init_nand(void) {}
236 #endif
237
238 #if defined(CONFIG_TOUCHSCREEN_ADS7846) || \
239         defined(CONFIG_TOUCHSCREEN_ADS7846_MODULE)
240 #include <linux/spi/ads7846.h>
241
242 static struct omap2_mcspi_device_config ads7846_mcspi_config = {
243         .turbo_mode     = 0,
244         .single_channel = 1,    /* 0: slave, 1: master */
245 };
246
247 static int ads7846_get_pendown_state(void)
248 {
249         return !gpio_get_value(CM_T35_GPIO_PENDOWN);
250 }
251
252 static struct ads7846_platform_data ads7846_config = {
253         .x_max                  = 0x0fff,
254         .y_max                  = 0x0fff,
255         .x_plate_ohms           = 180,
256         .pressure_max           = 255,
257         .debounce_max           = 10,
258         .debounce_tol           = 3,
259         .debounce_rep           = 1,
260         .get_pendown_state      = ads7846_get_pendown_state,
261         .keep_vref_on           = 1,
262 };
263
264 static struct spi_board_info cm_t35_spi_board_info[] __initdata = {
265         {
266                 .modalias               = "ads7846",
267                 .bus_num                = 1,
268                 .chip_select            = 0,
269                 .max_speed_hz           = 1500000,
270                 .controller_data        = &ads7846_mcspi_config,
271                 .irq                    = OMAP_GPIO_IRQ(CM_T35_GPIO_PENDOWN),
272                 .platform_data          = &ads7846_config,
273         },
274 };
275
276 static void __init cm_t35_init_ads7846(void)
277 {
278         if ((gpio_request(CM_T35_GPIO_PENDOWN, "ADS7846_PENDOWN") == 0) &&
279             (gpio_direction_input(CM_T35_GPIO_PENDOWN) == 0)) {
280                 gpio_export(CM_T35_GPIO_PENDOWN, 0);
281         } else {
282                 pr_err("CM-T35: could not obtain gpio for ADS7846_PENDOWN\n");
283                 return;
284         }
285
286         spi_register_board_info(cm_t35_spi_board_info,
287                                 ARRAY_SIZE(cm_t35_spi_board_info));
288 }
289 #else
290 static inline void cm_t35_init_ads7846(void) {}
291 #endif
292
293 #define CM_T35_LCD_EN_GPIO 157
294 #define CM_T35_LCD_BL_GPIO 58
295 #define CM_T35_DVI_EN_GPIO 54
296
297 static int lcd_bl_gpio;
298 static int lcd_en_gpio;
299 static int dvi_en_gpio;
300
301 static int lcd_enabled;
302 static int dvi_enabled;
303
304 static int cm_t35_panel_enable_lcd(struct omap_dss_device *dssdev)
305 {
306         if (dvi_enabled) {
307                 printk(KERN_ERR "cannot enable LCD, DVI is enabled\n");
308                 return -EINVAL;
309         }
310
311         gpio_set_value(lcd_en_gpio, 1);
312         gpio_set_value(lcd_bl_gpio, 1);
313
314         lcd_enabled = 1;
315
316         return 0;
317 }
318
319 static void cm_t35_panel_disable_lcd(struct omap_dss_device *dssdev)
320 {
321         lcd_enabled = 0;
322
323         gpio_set_value(lcd_bl_gpio, 0);
324         gpio_set_value(lcd_en_gpio, 0);
325 }
326
327 static int cm_t35_panel_enable_dvi(struct omap_dss_device *dssdev)
328 {
329         if (lcd_enabled) {
330                 printk(KERN_ERR "cannot enable DVI, LCD is enabled\n");
331                 return -EINVAL;
332         }
333
334         gpio_set_value(dvi_en_gpio, 0);
335         dvi_enabled = 1;
336
337         return 0;
338 }
339
340 static void cm_t35_panel_disable_dvi(struct omap_dss_device *dssdev)
341 {
342         gpio_set_value(dvi_en_gpio, 1);
343         dvi_enabled = 0;
344 }
345
346 static int cm_t35_panel_enable_tv(struct omap_dss_device *dssdev)
347 {
348         return 0;
349 }
350
351 static void cm_t35_panel_disable_tv(struct omap_dss_device *dssdev)
352 {
353 }
354
355 static struct panel_generic_dpi_data lcd_panel = {
356         .name                   = "toppoly_tdo35s",
357         .platform_enable        = cm_t35_panel_enable_lcd,
358         .platform_disable       = cm_t35_panel_disable_lcd,
359 };
360
361 static struct omap_dss_device cm_t35_lcd_device = {
362         .name                   = "lcd",
363         .type                   = OMAP_DISPLAY_TYPE_DPI,
364         .driver_name            = "generic_dpi_panel",
365         .data                   = &lcd_panel,
366         .phy.dpi.data_lines     = 18,
367 };
368
369 static struct panel_generic_dpi_data dvi_panel = {
370         .name                   = "generic",
371         .platform_enable        = cm_t35_panel_enable_dvi,
372         .platform_disable       = cm_t35_panel_disable_dvi,
373 };
374
375 static struct omap_dss_device cm_t35_dvi_device = {
376         .name                   = "dvi",
377         .type                   = OMAP_DISPLAY_TYPE_DPI,
378         .driver_name            = "generic_dpi_panel",
379         .data                   = &dvi_panel,
380         .phy.dpi.data_lines     = 24,
381 };
382
383 static struct omap_dss_device cm_t35_tv_device = {
384         .name                   = "tv",
385         .driver_name            = "venc",
386         .type                   = OMAP_DISPLAY_TYPE_VENC,
387         .phy.venc.type          = OMAP_DSS_VENC_TYPE_SVIDEO,
388         .platform_enable        = cm_t35_panel_enable_tv,
389         .platform_disable       = cm_t35_panel_disable_tv,
390 };
391
392 static struct omap_dss_device *cm_t35_dss_devices[] = {
393         &cm_t35_lcd_device,
394         &cm_t35_dvi_device,
395         &cm_t35_tv_device,
396 };
397
398 static struct omap_dss_board_info cm_t35_dss_data = {
399         .num_devices    = ARRAY_SIZE(cm_t35_dss_devices),
400         .devices        = cm_t35_dss_devices,
401         .default_device = &cm_t35_dvi_device,
402 };
403
404 static struct omap2_mcspi_device_config tdo24m_mcspi_config = {
405         .turbo_mode     = 0,
406         .single_channel = 1,    /* 0: slave, 1: master */
407 };
408
409 static struct tdo24m_platform_data tdo24m_config = {
410         .model = TDO35S,
411 };
412
413 static struct spi_board_info cm_t35_lcd_spi_board_info[] __initdata = {
414         {
415                 .modalias               = "tdo24m",
416                 .bus_num                = 4,
417                 .chip_select            = 0,
418                 .max_speed_hz           = 1000000,
419                 .controller_data        = &tdo24m_mcspi_config,
420                 .platform_data          = &tdo24m_config,
421         },
422 };
423
424 static void __init cm_t35_init_display(void)
425 {
426         int err;
427
428         lcd_en_gpio = CM_T35_LCD_EN_GPIO;
429         lcd_bl_gpio = CM_T35_LCD_BL_GPIO;
430         dvi_en_gpio = CM_T35_DVI_EN_GPIO;
431
432         spi_register_board_info(cm_t35_lcd_spi_board_info,
433                                 ARRAY_SIZE(cm_t35_lcd_spi_board_info));
434
435         err = gpio_request(lcd_en_gpio, "LCD RST");
436         if (err) {
437                 pr_err("CM-T35: failed to get LCD reset GPIO\n");
438                 goto out;
439         }
440
441         err = gpio_request(lcd_bl_gpio, "LCD BL");
442         if (err) {
443                 pr_err("CM-T35: failed to get LCD backlight control GPIO\n");
444                 goto err_lcd_bl;
445         }
446
447         err = gpio_request(dvi_en_gpio, "DVI EN");
448         if (err) {
449                 pr_err("CM-T35: failed to get DVI reset GPIO\n");
450                 goto err_dvi_en;
451         }
452
453         gpio_export(lcd_en_gpio, 0);
454         gpio_export(lcd_bl_gpio, 0);
455         gpio_export(dvi_en_gpio, 0);
456         gpio_direction_output(lcd_en_gpio, 0);
457         gpio_direction_output(lcd_bl_gpio, 0);
458         gpio_direction_output(dvi_en_gpio, 1);
459
460         msleep(50);
461         gpio_set_value(lcd_en_gpio, 1);
462
463         err = omap_display_init(&cm_t35_dss_data);
464         if (err) {
465                 pr_err("CM-T35: failed to register DSS device\n");
466                 goto err_dev_reg;
467         }
468
469         return;
470
471 err_dev_reg:
472         gpio_free(dvi_en_gpio);
473 err_dvi_en:
474         gpio_free(lcd_bl_gpio);
475 err_lcd_bl:
476         gpio_free(lcd_en_gpio);
477 out:
478
479         return;
480 }
481
482 static struct regulator_consumer_supply cm_t35_vmmc1_supply = {
483         .supply                 = "vmmc",
484 };
485
486 static struct regulator_consumer_supply cm_t35_vsim_supply = {
487         .supply                 = "vmmc_aux",
488 };
489
490 static struct regulator_consumer_supply cm_t35_vdac_supply =
491         REGULATOR_SUPPLY("vdda_dac", "omapdss_venc");
492
493 static struct regulator_consumer_supply cm_t35_vdvi_supply =
494         REGULATOR_SUPPLY("vdvi", "omapdss");
495
496 /* VMMC1 for MMC1 pins CMD, CLK, DAT0..DAT3 (20 mA, plus card == max 220 mA) */
497 static struct regulator_init_data cm_t35_vmmc1 = {
498         .constraints = {
499                 .min_uV                 = 1850000,
500                 .max_uV                 = 3150000,
501                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
502                                         | REGULATOR_MODE_STANDBY,
503                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
504                                         | REGULATOR_CHANGE_MODE
505                                         | REGULATOR_CHANGE_STATUS,
506         },
507         .num_consumer_supplies  = 1,
508         .consumer_supplies      = &cm_t35_vmmc1_supply,
509 };
510
511 /* VSIM for MMC1 pins DAT4..DAT7 (2 mA, plus card == max 50 mA) */
512 static struct regulator_init_data cm_t35_vsim = {
513         .constraints = {
514                 .min_uV                 = 1800000,
515                 .max_uV                 = 3000000,
516                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
517                                         | REGULATOR_MODE_STANDBY,
518                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
519                                         | REGULATOR_CHANGE_MODE
520                                         | REGULATOR_CHANGE_STATUS,
521         },
522         .num_consumer_supplies  = 1,
523         .consumer_supplies      = &cm_t35_vsim_supply,
524 };
525
526 /* VDAC for DSS driving S-Video (8 mA unloaded, max 65 mA) */
527 static struct regulator_init_data cm_t35_vdac = {
528         .constraints = {
529                 .min_uV                 = 1800000,
530                 .max_uV                 = 1800000,
531                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
532                                         | REGULATOR_MODE_STANDBY,
533                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
534                                         | REGULATOR_CHANGE_STATUS,
535         },
536         .num_consumer_supplies  = 1,
537         .consumer_supplies      = &cm_t35_vdac_supply,
538 };
539
540 /* VPLL2 for digital video outputs */
541 static struct regulator_init_data cm_t35_vpll2 = {
542         .constraints = {
543                 .name                   = "VDVI",
544                 .min_uV                 = 1800000,
545                 .max_uV                 = 1800000,
546                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
547                                         | REGULATOR_MODE_STANDBY,
548                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
549                                         | REGULATOR_CHANGE_STATUS,
550         },
551         .num_consumer_supplies  = 1,
552         .consumer_supplies      = &cm_t35_vdvi_supply,
553 };
554
555 static struct twl4030_usb_data cm_t35_usb_data = {
556         .usb_mode       = T2_USB_MODE_ULPI,
557 };
558
559 static uint32_t cm_t35_keymap[] = {
560         KEY(0, 0, KEY_A),       KEY(0, 1, KEY_B),       KEY(0, 2, KEY_LEFT),
561         KEY(1, 0, KEY_UP),      KEY(1, 1, KEY_ENTER),   KEY(1, 2, KEY_DOWN),
562         KEY(2, 0, KEY_RIGHT),   KEY(2, 1, KEY_C),       KEY(2, 2, KEY_D),
563 };
564
565 static struct matrix_keymap_data cm_t35_keymap_data = {
566         .keymap                 = cm_t35_keymap,
567         .keymap_size            = ARRAY_SIZE(cm_t35_keymap),
568 };
569
570 static struct twl4030_keypad_data cm_t35_kp_data = {
571         .keymap_data    = &cm_t35_keymap_data,
572         .rows           = 3,
573         .cols           = 3,
574         .rep            = 1,
575 };
576
577 static struct omap2_hsmmc_info mmc[] = {
578         {
579                 .mmc            = 1,
580                 .caps           = MMC_CAP_4_BIT_DATA,
581                 .gpio_cd        = -EINVAL,
582                 .gpio_wp        = -EINVAL,
583
584         },
585         {
586                 .mmc            = 2,
587                 .caps           = MMC_CAP_4_BIT_DATA,
588                 .transceiver    = 1,
589                 .gpio_cd        = -EINVAL,
590                 .gpio_wp        = -EINVAL,
591                 .ocr_mask       = 0x00100000,   /* 3.3V */
592         },
593         {}      /* Terminator */
594 };
595
596 static struct usbhs_omap_board_data usbhs_bdata __initdata = {
597         .port_mode[0] = OMAP_EHCI_PORT_MODE_PHY,
598         .port_mode[1] = OMAP_EHCI_PORT_MODE_PHY,
599         .port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
600
601         .phy_reset  = true,
602         .reset_gpio_port[0]  = OMAP_MAX_GPIO_LINES + 6,
603         .reset_gpio_port[1]  = OMAP_MAX_GPIO_LINES + 7,
604         .reset_gpio_port[2]  = -EINVAL
605 };
606
607 static int cm_t35_twl_gpio_setup(struct device *dev, unsigned gpio,
608                                  unsigned ngpio)
609 {
610         int wlan_rst = gpio + 2;
611
612         if ((gpio_request(wlan_rst, "WLAN RST") == 0) &&
613             (gpio_direction_output(wlan_rst, 1) == 0)) {
614                 gpio_export(wlan_rst, 0);
615
616                 udelay(10);
617                 gpio_set_value(wlan_rst, 0);
618                 udelay(10);
619                 gpio_set_value(wlan_rst, 1);
620         } else {
621                 pr_err("CM-T35: could not obtain gpio for WiFi reset\n");
622         }
623
624         /* gpio + 0 is "mmc0_cd" (input/IRQ) */
625         mmc[0].gpio_cd = gpio + 0;
626         omap2_hsmmc_init(mmc);
627
628         /* link regulators to MMC adapters */
629         cm_t35_vmmc1_supply.dev = mmc[0].dev;
630         cm_t35_vsim_supply.dev = mmc[0].dev;
631
632         return 0;
633 }
634
635 static struct twl4030_gpio_platform_data cm_t35_gpio_data = {
636         .gpio_base      = OMAP_MAX_GPIO_LINES,
637         .irq_base       = TWL4030_GPIO_IRQ_BASE,
638         .irq_end        = TWL4030_GPIO_IRQ_END,
639         .setup          = cm_t35_twl_gpio_setup,
640 };
641
642 static struct twl4030_platform_data cm_t35_twldata = {
643         .irq_base       = TWL4030_IRQ_BASE,
644         .irq_end        = TWL4030_IRQ_END,
645
646         /* platform_data for children goes here */
647         .keypad         = &cm_t35_kp_data,
648         .usb            = &cm_t35_usb_data,
649         .gpio           = &cm_t35_gpio_data,
650         .vmmc1          = &cm_t35_vmmc1,
651         .vsim           = &cm_t35_vsim,
652         .vdac           = &cm_t35_vdac,
653         .vpll2          = &cm_t35_vpll2,
654 };
655
656 static struct i2c_board_info __initdata cm_t35_i2c_boardinfo[] = {
657         {
658                 I2C_BOARD_INFO("tps65930", 0x48),
659                 .flags          = I2C_CLIENT_WAKE,
660                 .irq            = INT_34XX_SYS_NIRQ,
661                 .platform_data  = &cm_t35_twldata,
662         },
663 };
664
665 static void __init cm_t35_init_i2c(void)
666 {
667         omap_register_i2c_bus(1, 2600, cm_t35_i2c_boardinfo,
668                               ARRAY_SIZE(cm_t35_i2c_boardinfo));
669 }
670
671 static void __init cm_t35_init_early(void)
672 {
673         omap2_init_common_infrastructure();
674         omap2_init_common_devices(mt46h32m32lf6_sdrc_params,
675                              mt46h32m32lf6_sdrc_params);
676 }
677
678 #ifdef CONFIG_OMAP_MUX
679 static struct omap_board_mux board_mux[] __initdata = {
680         /* nCS and IRQ for CM-T35 ethernet */
681         OMAP3_MUX(GPMC_NCS5, OMAP_MUX_MODE0),
682         OMAP3_MUX(UART3_CTS_RCTX, OMAP_MUX_MODE4 | OMAP_PIN_INPUT_PULLUP),
683
684         /* nCS and IRQ for SB-T35 ethernet */
685         OMAP3_MUX(GPMC_NCS4, OMAP_MUX_MODE0),
686         OMAP3_MUX(GPMC_WAIT3, OMAP_MUX_MODE4 | OMAP_PIN_INPUT_PULLUP),
687
688         /* PENDOWN GPIO */
689         OMAP3_MUX(GPMC_NCS6, OMAP_MUX_MODE4 | OMAP_PIN_INPUT),
690
691         /* mUSB */
692         OMAP3_MUX(HSUSB0_CLK, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
693         OMAP3_MUX(HSUSB0_STP, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
694         OMAP3_MUX(HSUSB0_DIR, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
695         OMAP3_MUX(HSUSB0_NXT, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
696         OMAP3_MUX(HSUSB0_DATA0, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
697         OMAP3_MUX(HSUSB0_DATA1, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
698         OMAP3_MUX(HSUSB0_DATA2, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
699         OMAP3_MUX(HSUSB0_DATA3, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
700         OMAP3_MUX(HSUSB0_DATA4, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
701         OMAP3_MUX(HSUSB0_DATA5, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
702         OMAP3_MUX(HSUSB0_DATA6, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
703         OMAP3_MUX(HSUSB0_DATA7, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
704
705         /* MMC 2 */
706         OMAP3_MUX(SDMMC2_DAT4, OMAP_MUX_MODE1 | OMAP_PIN_OUTPUT),
707         OMAP3_MUX(SDMMC2_DAT5, OMAP_MUX_MODE1 | OMAP_PIN_OUTPUT),
708         OMAP3_MUX(SDMMC2_DAT6, OMAP_MUX_MODE1 | OMAP_PIN_OUTPUT),
709         OMAP3_MUX(SDMMC2_DAT7, OMAP_MUX_MODE1 | OMAP_PIN_INPUT),
710
711         /* McSPI 1 */
712         OMAP3_MUX(MCSPI1_CLK, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
713         OMAP3_MUX(MCSPI1_SIMO, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
714         OMAP3_MUX(MCSPI1_SOMI, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
715         OMAP3_MUX(MCSPI1_CS0, OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLDOWN),
716
717         /* McSPI 4 */
718         OMAP3_MUX(MCBSP1_CLKR, OMAP_MUX_MODE1 | OMAP_PIN_INPUT),
719         OMAP3_MUX(MCBSP1_DX, OMAP_MUX_MODE1 | OMAP_PIN_INPUT),
720         OMAP3_MUX(MCBSP1_DR, OMAP_MUX_MODE1 | OMAP_PIN_INPUT),
721         OMAP3_MUX(MCBSP1_FSX, OMAP_MUX_MODE1 | OMAP_PIN_INPUT_PULLUP),
722
723         /* McBSP 2 */
724         OMAP3_MUX(MCBSP2_FSX, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
725         OMAP3_MUX(MCBSP2_CLKX, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
726         OMAP3_MUX(MCBSP2_DR, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
727         OMAP3_MUX(MCBSP2_DX, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
728
729         /* serial ports */
730         OMAP3_MUX(MCBSP3_CLKX, OMAP_MUX_MODE1 | OMAP_PIN_OUTPUT),
731         OMAP3_MUX(MCBSP3_FSX, OMAP_MUX_MODE1 | OMAP_PIN_INPUT),
732         OMAP3_MUX(UART1_TX, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
733         OMAP3_MUX(UART1_RX, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
734
735         /* DSS */
736         OMAP3_MUX(DSS_PCLK, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
737         OMAP3_MUX(DSS_HSYNC, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
738         OMAP3_MUX(DSS_VSYNC, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
739         OMAP3_MUX(DSS_ACBIAS, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
740         OMAP3_MUX(DSS_DATA0, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
741         OMAP3_MUX(DSS_DATA1, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
742         OMAP3_MUX(DSS_DATA2, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
743         OMAP3_MUX(DSS_DATA3, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
744         OMAP3_MUX(DSS_DATA4, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
745         OMAP3_MUX(DSS_DATA5, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
746         OMAP3_MUX(DSS_DATA6, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
747         OMAP3_MUX(DSS_DATA7, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
748         OMAP3_MUX(DSS_DATA8, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
749         OMAP3_MUX(DSS_DATA9, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
750         OMAP3_MUX(DSS_DATA10, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
751         OMAP3_MUX(DSS_DATA11, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
752         OMAP3_MUX(DSS_DATA12, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
753         OMAP3_MUX(DSS_DATA13, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
754         OMAP3_MUX(DSS_DATA14, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
755         OMAP3_MUX(DSS_DATA15, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
756         OMAP3_MUX(DSS_DATA16, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
757         OMAP3_MUX(DSS_DATA17, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
758         OMAP3_MUX(DSS_DATA18, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
759         OMAP3_MUX(DSS_DATA19, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
760         OMAP3_MUX(DSS_DATA20, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
761         OMAP3_MUX(DSS_DATA21, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
762         OMAP3_MUX(DSS_DATA22, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
763         OMAP3_MUX(DSS_DATA23, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
764
765         /* display controls */
766         OMAP3_MUX(MCBSP1_FSR, OMAP_MUX_MODE4 | OMAP_PIN_OUTPUT),
767         OMAP3_MUX(GPMC_NCS7, OMAP_MUX_MODE4 | OMAP_PIN_OUTPUT),
768         OMAP3_MUX(GPMC_NCS3, OMAP_MUX_MODE4 | OMAP_PIN_OUTPUT),
769
770         /* TPS IRQ */
771         OMAP3_MUX(SYS_NIRQ, OMAP_MUX_MODE0 | OMAP_WAKEUP_EN | \
772                   OMAP_PIN_INPUT_PULLUP),
773
774         { .reg_offset = OMAP_MUX_TERMINATOR },
775 };
776 #endif
777
778 static struct omap_musb_board_data musb_board_data = {
779         .interface_type         = MUSB_INTERFACE_ULPI,
780         .mode                   = MUSB_OTG,
781         .power                  = 100,
782 };
783
784 static struct omap_board_config_kernel cm_t35_config[] __initdata = {
785 };
786
787 static void __init cm_t35_init(void)
788 {
789         omap_board_config = cm_t35_config;
790         omap_board_config_size = ARRAY_SIZE(cm_t35_config);
791         omap3_mux_init(board_mux, OMAP_PACKAGE_CUS);
792         omap_serial_init();
793         cm_t35_init_i2c();
794         cm_t35_init_nand();
795         cm_t35_init_ads7846();
796         cm_t35_init_ethernet();
797         cm_t35_init_led();
798         cm_t35_init_display();
799
800         usb_musb_init(&musb_board_data);
801         usbhs_init(&usbhs_bdata);
802 }
803
804 MACHINE_START(CM_T35, "Compulab CM-T35")
805         .boot_params    = 0x80000100,
806         .reserve        = omap_reserve,
807         .map_io         = omap3_map_io,
808         .init_early     = cm_t35_init_early,
809         .init_irq       = omap_init_irq,
810         .init_machine   = cm_t35_init,
811         .timer          = &omap_timer,
812 MACHINE_END