Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
board-cm-t35.c
Go to the documentation of this file.
1 /*
2  * CompuLab CM-T35/CM-T3730 modules support
3  *
4  * Copyright (C) 2009-2011 CompuLab, Ltd.
5  * Authors: Mike Rapoport <[email protected]>
6  * Igor Grinberg <[email protected]>
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * version 2 as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * General Public License for more details.
16  *
17  */
18 
19 #include <linux/kernel.h>
20 #include <linux/init.h>
21 #include <linux/platform_device.h>
22 #include <linux/input.h>
24 #include <linux/delay.h>
25 #include <linux/gpio.h>
27 
28 #include <linux/i2c/at24.h>
29 #include <linux/i2c/twl.h>
30 #include <linux/regulator/fixed.h>
32 #include <linux/mmc/host.h>
33 
34 #include <linux/spi/spi.h>
35 #include <linux/spi/tdo24m.h>
36 
37 #include <asm/mach-types.h>
38 #include <asm/mach/arch.h>
39 #include <asm/mach/map.h>
40 
41 #include "common.h"
43 #include <plat/gpmc.h>
44 #include <plat/usb.h>
45 #include <video/omapdss.h>
49 
50 #include <mach/hardware.h>
51 
52 #include "mux.h"
54 #include "hsmmc.h"
55 #include "common-board-devices.h"
56 
57 #define CM_T35_GPIO_PENDOWN 57
58 #define SB_T35_USB_HUB_RESET_GPIO 167
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 #if defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE)
66 #include <linux/smsc911x.h>
67 #include "gpmc-smsc911x.h"
68 
69 static struct omap_smsc911x_platform_data cm_t35_smsc911x_cfg = {
70  .id = 0,
71  .cs = CM_T35_SMSC911X_CS,
72  .gpio_irq = CM_T35_SMSC911X_GPIO,
73  .gpio_reset = -EINVAL,
75 };
76 
77 static struct omap_smsc911x_platform_data sb_t35_smsc911x_cfg = {
78  .id = 1,
79  .cs = SB_T35_SMSC911X_CS,
80  .gpio_irq = SB_T35_SMSC911X_GPIO,
81  .gpio_reset = -EINVAL,
83 };
84 
85 static struct regulator_consumer_supply cm_t35_smsc911x_supplies[] = {
86  REGULATOR_SUPPLY("vddvario", "smsc911x.0"),
87  REGULATOR_SUPPLY("vdd33a", "smsc911x.0"),
88 };
89 
90 static struct regulator_consumer_supply sb_t35_smsc911x_supplies[] = {
91  REGULATOR_SUPPLY("vddvario", "smsc911x.1"),
92  REGULATOR_SUPPLY("vdd33a", "smsc911x.1"),
93 };
94 
95 static void __init cm_t35_init_ethernet(void)
96 {
97  regulator_register_fixed(0, cm_t35_smsc911x_supplies,
98  ARRAY_SIZE(cm_t35_smsc911x_supplies));
99  regulator_register_fixed(1, sb_t35_smsc911x_supplies,
100  ARRAY_SIZE(sb_t35_smsc911x_supplies));
101 
102  gpmc_smsc911x_init(&cm_t35_smsc911x_cfg);
103  gpmc_smsc911x_init(&sb_t35_smsc911x_cfg);
104 }
105 #else
106 static inline void __init cm_t35_init_ethernet(void) { return; }
107 #endif
108 
109 #if defined(CONFIG_LEDS_GPIO) || defined(CONFIG_LEDS_GPIO_MODULE)
110 #include <linux/leds.h>
111 
112 static struct gpio_led cm_t35_leds[] = {
113  [0] = {
114  .gpio = 186,
115  .name = "cm-t35:green",
116  .default_trigger = "heartbeat",
117  .active_low = 0,
118  },
119 };
120 
121 static struct gpio_led_platform_data cm_t35_led_pdata = {
122  .num_leds = ARRAY_SIZE(cm_t35_leds),
123  .leds = cm_t35_leds,
124 };
125 
126 static struct platform_device cm_t35_led_device = {
127  .name = "leds-gpio",
128  .id = -1,
129  .dev = {
130  .platform_data = &cm_t35_led_pdata,
131  },
132 };
133 
134 static void __init cm_t35_init_led(void)
135 {
136  platform_device_register(&cm_t35_led_device);
137 }
138 #else
139 static inline void cm_t35_init_led(void) {}
140 #endif
141 
142 #if defined(CONFIG_MTD_NAND_OMAP2) || defined(CONFIG_MTD_NAND_OMAP2_MODULE)
143 #include <linux/mtd/mtd.h>
144 #include <linux/mtd/nand.h>
145 #include <linux/mtd/partitions.h>
146 
147 static struct mtd_partition cm_t35_nand_partitions[] = {
148  {
149  .name = "xloader",
150  .offset = 0, /* Offset = 0x00000 */
151  .size = 4 * NAND_BLOCK_SIZE,
152  .mask_flags = MTD_WRITEABLE
153  },
154  {
155  .name = "uboot",
156  .offset = MTDPART_OFS_APPEND, /* Offset = 0x80000 */
157  .size = 15 * NAND_BLOCK_SIZE,
158  },
159  {
160  .name = "uboot environment",
161  .offset = MTDPART_OFS_APPEND, /* Offset = 0x260000 */
162  .size = 2 * NAND_BLOCK_SIZE,
163  },
164  {
165  .name = "linux",
166  .offset = MTDPART_OFS_APPEND, /* Offset = 0x2A0000 */
167  .size = 32 * NAND_BLOCK_SIZE,
168  },
169  {
170  .name = "rootfs",
171  .offset = MTDPART_OFS_APPEND, /* Offset = 0x6A0000 */
172  .size = MTDPART_SIZ_FULL,
173  },
174 };
175 
176 static struct omap_nand_platform_data cm_t35_nand_data = {
177  .parts = cm_t35_nand_partitions,
178  .nr_parts = ARRAY_SIZE(cm_t35_nand_partitions),
179  .cs = 0,
180 };
181 
182 static void __init cm_t35_init_nand(void)
183 {
184  if (gpmc_nand_init(&cm_t35_nand_data) < 0)
185  pr_err("CM-T35: Unable to register NAND device\n");
186 }
187 #else
188 static inline void cm_t35_init_nand(void) {}
189 #endif
190 
191 #define CM_T35_LCD_EN_GPIO 157
192 #define CM_T35_LCD_BL_GPIO 58
193 #define CM_T35_DVI_EN_GPIO 54
194 
195 static int lcd_enabled;
196 static int dvi_enabled;
197 
198 static int cm_t35_panel_enable_lcd(struct omap_dss_device *dssdev)
199 {
200  if (dvi_enabled) {
201  printk(KERN_ERR "cannot enable LCD, DVI is enabled\n");
202  return -EINVAL;
203  }
204 
207 
208  lcd_enabled = 1;
209 
210  return 0;
211 }
212 
213 static void cm_t35_panel_disable_lcd(struct omap_dss_device *dssdev)
214 {
215  lcd_enabled = 0;
216 
219 }
220 
221 static int cm_t35_panel_enable_tv(struct omap_dss_device *dssdev)
222 {
223  return 0;
224 }
225 
226 static void cm_t35_panel_disable_tv(struct omap_dss_device *dssdev)
227 {
228 }
229 
230 static struct panel_generic_dpi_data lcd_panel = {
231  .name = "toppoly_tdo35s",
232  .platform_enable = cm_t35_panel_enable_lcd,
233  .platform_disable = cm_t35_panel_disable_lcd,
234 };
235 
236 static struct omap_dss_device cm_t35_lcd_device = {
237  .name = "lcd",
238  .type = OMAP_DISPLAY_TYPE_DPI,
239  .driver_name = "generic_dpi_panel",
240  .data = &lcd_panel,
241  .phy.dpi.data_lines = 18,
242 };
243 
244 static struct tfp410_platform_data dvi_panel = {
245  .power_down_gpio = CM_T35_DVI_EN_GPIO,
246 };
247 
248 static struct omap_dss_device cm_t35_dvi_device = {
249  .name = "dvi",
250  .type = OMAP_DISPLAY_TYPE_DPI,
251  .driver_name = "tfp410",
252  .data = &dvi_panel,
253  .phy.dpi.data_lines = 24,
254 };
255 
256 static struct omap_dss_device cm_t35_tv_device = {
257  .name = "tv",
258  .driver_name = "venc",
259  .type = OMAP_DISPLAY_TYPE_VENC,
260  .phy.venc.type = OMAP_DSS_VENC_TYPE_SVIDEO,
261  .platform_enable = cm_t35_panel_enable_tv,
262  .platform_disable = cm_t35_panel_disable_tv,
263 };
264 
265 static struct omap_dss_device *cm_t35_dss_devices[] = {
266  &cm_t35_lcd_device,
267  &cm_t35_dvi_device,
268  &cm_t35_tv_device,
269 };
270 
271 static struct omap_dss_board_info cm_t35_dss_data = {
272  .num_devices = ARRAY_SIZE(cm_t35_dss_devices),
273  .devices = cm_t35_dss_devices,
274  .default_device = &cm_t35_dvi_device,
275 };
276 
277 static struct omap2_mcspi_device_config tdo24m_mcspi_config = {
278  .turbo_mode = 0,
279 };
280 
281 static struct tdo24m_platform_data tdo24m_config = {
282  .model = TDO35S,
283 };
284 
285 static struct spi_board_info cm_t35_lcd_spi_board_info[] __initdata = {
286  {
287  .modalias = "tdo24m",
288  .bus_num = 4,
289  .chip_select = 0,
290  .max_speed_hz = 1000000,
291  .controller_data = &tdo24m_mcspi_config,
292  .platform_data = &tdo24m_config,
293  },
294 };
295 
296 static struct gpio cm_t35_dss_gpios[] __initdata = {
297  { CM_T35_LCD_EN_GPIO, GPIOF_OUT_INIT_LOW, "lcd enable" },
298  { CM_T35_LCD_BL_GPIO, GPIOF_OUT_INIT_LOW, "lcd bl enable" },
299 };
300 
301 static void __init cm_t35_init_display(void)
302 {
303  int err;
304 
305  spi_register_board_info(cm_t35_lcd_spi_board_info,
306  ARRAY_SIZE(cm_t35_lcd_spi_board_info));
307 
308  err = gpio_request_array(cm_t35_dss_gpios,
309  ARRAY_SIZE(cm_t35_dss_gpios));
310  if (err) {
311  pr_err("CM-T35: failed to request DSS control GPIOs\n");
312  return;
313  }
314 
315  gpio_export(CM_T35_LCD_EN_GPIO, 0);
316  gpio_export(CM_T35_LCD_BL_GPIO, 0);
317 
318  msleep(50);
320 
321  err = omap_display_init(&cm_t35_dss_data);
322  if (err) {
323  pr_err("CM-T35: failed to register DSS device\n");
324  gpio_free_array(cm_t35_dss_gpios, ARRAY_SIZE(cm_t35_dss_gpios));
325  }
326 }
327 
328 static struct regulator_consumer_supply cm_t35_vmmc1_supply[] = {
329  REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
330 };
331 
332 static struct regulator_consumer_supply cm_t35_vsim_supply[] = {
333  REGULATOR_SUPPLY("vmmc_aux", "omap_hsmmc.0"),
334 };
335 
336 static struct regulator_consumer_supply cm_t35_vio_supplies[] = {
337  REGULATOR_SUPPLY("vcc", "spi1.0"),
338  REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
339  REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi1"),
340 };
341 
342 /* VMMC1 for MMC1 pins CMD, CLK, DAT0..DAT3 (20 mA, plus card == max 220 mA) */
343 static struct regulator_init_data cm_t35_vmmc1 = {
344  .constraints = {
345  .min_uV = 1850000,
346  .max_uV = 3150000,
347  .valid_modes_mask = REGULATOR_MODE_NORMAL
349  .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
352  },
353  .num_consumer_supplies = ARRAY_SIZE(cm_t35_vmmc1_supply),
354  .consumer_supplies = cm_t35_vmmc1_supply,
355 };
356 
357 /* VSIM for MMC1 pins DAT4..DAT7 (2 mA, plus card == max 50 mA) */
358 static struct regulator_init_data cm_t35_vsim = {
359  .constraints = {
360  .min_uV = 1800000,
361  .max_uV = 3000000,
362  .valid_modes_mask = REGULATOR_MODE_NORMAL
364  .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
367  },
368  .num_consumer_supplies = ARRAY_SIZE(cm_t35_vsim_supply),
369  .consumer_supplies = cm_t35_vsim_supply,
370 };
371 
372 static struct regulator_init_data cm_t35_vio = {
373  .constraints = {
374  .min_uV = 1800000,
375  .max_uV = 1800000,
376  .apply_uV = true,
377  .valid_modes_mask = REGULATOR_MODE_NORMAL
379  .valid_ops_mask = REGULATOR_CHANGE_MODE,
380  },
381  .num_consumer_supplies = ARRAY_SIZE(cm_t35_vio_supplies),
382  .consumer_supplies = cm_t35_vio_supplies,
383 };
384 
385 static uint32_t cm_t35_keymap[] = {
386  KEY(0, 0, KEY_A), KEY(0, 1, KEY_B), KEY(0, 2, KEY_LEFT),
387  KEY(1, 0, KEY_UP), KEY(1, 1, KEY_ENTER), KEY(1, 2, KEY_DOWN),
388  KEY(2, 0, KEY_RIGHT), KEY(2, 1, KEY_C), KEY(2, 2, KEY_D),
389 };
390 
391 static struct matrix_keymap_data cm_t35_keymap_data = {
392  .keymap = cm_t35_keymap,
393  .keymap_size = ARRAY_SIZE(cm_t35_keymap),
394 };
395 
396 static struct twl4030_keypad_data cm_t35_kp_data = {
397  .keymap_data = &cm_t35_keymap_data,
398  .rows = 3,
399  .cols = 3,
400  .rep = 1,
401 };
402 
403 static struct omap2_hsmmc_info mmc[] = {
404  {
405  .mmc = 1,
406  .caps = MMC_CAP_4_BIT_DATA,
407  .gpio_cd = -EINVAL,
408  .gpio_wp = -EINVAL,
409  .deferred = true,
410  },
411  {
412  .mmc = 2,
413  .caps = MMC_CAP_4_BIT_DATA,
414  .transceiver = 1,
415  .gpio_cd = -EINVAL,
416  .gpio_wp = -EINVAL,
417  .ocr_mask = 0x00100000, /* 3.3V */
418  },
419  {} /* Terminator */
420 };
421 
422 static struct usbhs_omap_board_data usbhs_bdata __initdata = {
423  .port_mode[0] = OMAP_EHCI_PORT_MODE_PHY,
424  .port_mode[1] = OMAP_EHCI_PORT_MODE_PHY,
425  .port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED,
426 
427  .phy_reset = true,
428  .reset_gpio_port[0] = OMAP_MAX_GPIO_LINES + 6,
429  .reset_gpio_port[1] = OMAP_MAX_GPIO_LINES + 7,
430  .reset_gpio_port[2] = -EINVAL
431 };
432 
433 static void __init cm_t35_init_usbh(void)
434 {
435  int err;
436 
438  GPIOF_OUT_INIT_LOW, "usb hub rst");
439  if (err) {
440  pr_err("SB-T35: usb hub rst gpio request failed: %d\n", err);
441  } else {
442  udelay(10);
444  msleep(1);
445  }
446 
447  usbhs_init(&usbhs_bdata);
448 }
449 
450 static int cm_t35_twl_gpio_setup(struct device *dev, unsigned gpio,
451  unsigned ngpio)
452 {
453  int wlan_rst = gpio + 2;
454 
455  if (gpio_request_one(wlan_rst, GPIOF_OUT_INIT_HIGH, "WLAN RST") == 0) {
456  gpio_export(wlan_rst, 0);
457  udelay(10);
458  gpio_set_value_cansleep(wlan_rst, 0);
459  udelay(10);
460  gpio_set_value_cansleep(wlan_rst, 1);
461  } else {
462  pr_err("CM-T35: could not obtain gpio for WiFi reset\n");
463  }
464 
465  /* gpio + 0 is "mmc0_cd" (input/IRQ) */
466  mmc[0].gpio_cd = gpio + 0;
467  omap_hsmmc_late_init(mmc);
468 
469  return 0;
470 }
471 
472 static struct twl4030_gpio_platform_data cm_t35_gpio_data = {
473  .setup = cm_t35_twl_gpio_setup,
474 };
475 
476 static struct twl4030_power_data cm_t35_power_data = {
477  .use_poweroff = true,
478 };
479 
480 static struct twl4030_platform_data cm_t35_twldata = {
481  /* platform_data for children goes here */
482  .keypad = &cm_t35_kp_data,
483  .gpio = &cm_t35_gpio_data,
484  .vmmc1 = &cm_t35_vmmc1,
485  .vsim = &cm_t35_vsim,
486  .vio = &cm_t35_vio,
487  .power = &cm_t35_power_data,
488 };
489 
490 #if defined(CONFIG_VIDEO_OMAP3) || defined(CONFIG_VIDEO_OMAP3_MODULE)
491 #include <media/omap3isp.h>
492 #include "devices.h"
493 
494 static struct i2c_board_info cm_t35_isp_i2c_boardinfo[] = {
495  {
496  I2C_BOARD_INFO("mt9t001", 0x5d),
497  },
498  {
499  I2C_BOARD_INFO("tvp5150", 0x5c),
500  },
501 };
502 
503 static struct isp_subdev_i2c_board_info cm_t35_isp_primary_subdevs[] = {
504  {
505  .board_info = &cm_t35_isp_i2c_boardinfo[0],
506  .i2c_adapter_id = 3,
507  },
508  { NULL, 0, },
509 };
510 
511 static struct isp_subdev_i2c_board_info cm_t35_isp_secondary_subdevs[] = {
512  {
513  .board_info = &cm_t35_isp_i2c_boardinfo[1],
514  .i2c_adapter_id = 3,
515  },
516  { NULL, 0, },
517 };
518 
519 static struct isp_v4l2_subdevs_group cm_t35_isp_subdevs[] = {
520  {
521  .subdevs = cm_t35_isp_primary_subdevs,
522  .interface = ISP_INTERFACE_PARALLEL,
523  .bus = {
524  .parallel = {
525  .clk_pol = 1,
526  },
527  },
528  },
529  {
530  .subdevs = cm_t35_isp_secondary_subdevs,
531  .interface = ISP_INTERFACE_PARALLEL,
532  .bus = {
533  .parallel = {
534  .clk_pol = 0,
535  },
536  },
537  },
538  { NULL, 0, },
539 };
540 
541 static struct isp_platform_data cm_t35_isp_pdata = {
542  .subdevs = cm_t35_isp_subdevs,
543 };
544 
545 static void __init cm_t35_init_camera(void)
546 {
547  if (omap3_init_camera(&cm_t35_isp_pdata) < 0)
548  pr_warn("CM-T3x: Failed registering camera device!\n");
549 }
550 
551 #else
552 static inline void cm_t35_init_camera(void) {}
553 #endif /* CONFIG_VIDEO_OMAP3 */
554 
555 static void __init cm_t35_init_i2c(void)
556 {
560 
561  omap3_pmic_init("tps65930", &cm_t35_twldata);
562 
563  omap_register_i2c_bus(3, 400, NULL, 0);
564 }
565 
566 #ifdef CONFIG_OMAP_MUX
567 static struct omap_board_mux board_mux[] __initdata = {
568  /* nCS and IRQ for CM-T35 ethernet */
569  OMAP3_MUX(GPMC_NCS5, OMAP_MUX_MODE0),
571 
572  /* nCS and IRQ for SB-T35 ethernet */
573  OMAP3_MUX(GPMC_NCS4, OMAP_MUX_MODE0),
575 
576  /* PENDOWN GPIO */
578 
579  /* mUSB */
580  OMAP3_MUX(HSUSB0_CLK, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
582  OMAP3_MUX(HSUSB0_DIR, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
583  OMAP3_MUX(HSUSB0_NXT, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
584  OMAP3_MUX(HSUSB0_DATA0, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
585  OMAP3_MUX(HSUSB0_DATA1, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
586  OMAP3_MUX(HSUSB0_DATA2, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
587  OMAP3_MUX(HSUSB0_DATA3, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
588  OMAP3_MUX(HSUSB0_DATA4, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
589  OMAP3_MUX(HSUSB0_DATA5, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
590  OMAP3_MUX(HSUSB0_DATA6, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
591  OMAP3_MUX(HSUSB0_DATA7, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
592 
593  /* MMC 2 */
594  OMAP3_MUX(SDMMC2_DAT4, OMAP_MUX_MODE1 | OMAP_PIN_OUTPUT),
595  OMAP3_MUX(SDMMC2_DAT5, OMAP_MUX_MODE1 | OMAP_PIN_OUTPUT),
596  OMAP3_MUX(SDMMC2_DAT6, OMAP_MUX_MODE1 | OMAP_PIN_OUTPUT),
597  OMAP3_MUX(SDMMC2_DAT7, OMAP_MUX_MODE1 | OMAP_PIN_INPUT),
598 
599  /* McSPI 1 */
600  OMAP3_MUX(MCSPI1_CLK, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
601  OMAP3_MUX(MCSPI1_SIMO, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
602  OMAP3_MUX(MCSPI1_SOMI, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
604 
605  /* McSPI 4 */
606  OMAP3_MUX(MCBSP1_CLKR, OMAP_MUX_MODE1 | OMAP_PIN_INPUT),
610 
611  /* McBSP 2 */
616 
617  /* serial ports */
619  OMAP3_MUX(MCBSP3_FSX, OMAP_MUX_MODE1 | OMAP_PIN_INPUT),
622 
623  /* common DSS */
640 
641  /* Camera */
657  OMAP3_MUX(CAM_STROBE, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
658 
661 
662  /* display controls */
666 
667  /* TPS IRQ */
668  OMAP3_MUX(SYS_NIRQ, OMAP_MUX_MODE0 | OMAP_WAKEUP_EN | \
670 
671  { .reg_offset = OMAP_MUX_TERMINATOR },
672 };
673 
674 static void __init cm_t3x_common_dss_mux_init(int mux_mode)
675 {
676  omap_mux_init_signal("dss_data18", mux_mode);
677  omap_mux_init_signal("dss_data19", mux_mode);
678  omap_mux_init_signal("dss_data20", mux_mode);
679  omap_mux_init_signal("dss_data21", mux_mode);
680  omap_mux_init_signal("dss_data22", mux_mode);
681  omap_mux_init_signal("dss_data23", mux_mode);
682 }
683 
684 static void __init cm_t35_init_mux(void)
685 {
686  int mux_mode = OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT;
687 
688  omap_mux_init_signal("dss_data0.dss_data0", mux_mode);
689  omap_mux_init_signal("dss_data1.dss_data1", mux_mode);
690  omap_mux_init_signal("dss_data2.dss_data2", mux_mode);
691  omap_mux_init_signal("dss_data3.dss_data3", mux_mode);
692  omap_mux_init_signal("dss_data4.dss_data4", mux_mode);
693  omap_mux_init_signal("dss_data5.dss_data5", mux_mode);
694  cm_t3x_common_dss_mux_init(mux_mode);
695 }
696 
697 static void __init cm_t3730_init_mux(void)
698 {
699  int mux_mode = OMAP_MUX_MODE3 | OMAP_PIN_OUTPUT;
700 
701  omap_mux_init_signal("sys_boot0", mux_mode);
702  omap_mux_init_signal("sys_boot1", mux_mode);
703  omap_mux_init_signal("sys_boot3", mux_mode);
704  omap_mux_init_signal("sys_boot4", mux_mode);
705  omap_mux_init_signal("sys_boot5", mux_mode);
706  omap_mux_init_signal("sys_boot6", mux_mode);
707  cm_t3x_common_dss_mux_init(mux_mode);
708 }
709 #else
710 static inline void cm_t35_init_mux(void) {}
711 static inline void cm_t3730_init_mux(void) {}
712 #endif
713 
714 static void __init cm_t3x_common_init(void)
715 {
718  omap_sdrc_init(mt46h32m32lf6_sdrc_params,
719  mt46h32m32lf6_sdrc_params);
720  omap_hsmmc_init(mmc);
721  cm_t35_init_i2c();
723  cm_t35_init_ethernet();
724  cm_t35_init_led();
725  cm_t35_init_display();
726  omap_twl4030_audio_init("cm-t3x");
727 
729  cm_t35_init_usbh();
730  cm_t35_init_camera();
731 }
732 
733 static void __init cm_t35_init(void)
734 {
735  cm_t3x_common_init();
736  cm_t35_init_mux();
737  cm_t35_init_nand();
738 }
739 
740 static void __init cm_t3730_init(void)
741 {
742  cm_t3x_common_init();
743  cm_t3730_init_mux();
744 }
745 
746 MACHINE_START(CM_T35, "Compulab CM-T35")
747  .atag_offset = 0x100,
748  .reserve = omap_reserve,
749  .map_io = omap3_map_io,
750  .init_early = omap35xx_init_early,
751  .init_irq = omap3_init_irq,
752  .handle_irq = omap3_intc_handle_irq,
753  .init_machine = cm_t35_init,
754  .init_late = omap35xx_init_late,
755  .timer = &omap3_timer,
756  .restart = omap_prcm_restart,
758 
759 MACHINE_START(CM_T3730, "Compulab CM-T3730")
760  .atag_offset = 0x100,
761  .reserve = omap_reserve,
762  .map_io = omap3_map_io,
763  .init_early = omap3630_init_early,
764  .init_irq = omap3_init_irq,
765  .handle_irq = omap3_intc_handle_irq,
766  .init_machine = cm_t3730_init,
767  .init_late = omap3630_init_late,
768  .timer = &omap3_timer,
769  .restart = omap_prcm_restart,