Merge branch 'for-linus' of git://oss.sgi.com/xfs/xfs
[pandora-kernel.git] / arch / arm / mach-mx3 / mach-mx31moboard.c
1 /*
2  *  Copyright (C) 2008 Valentin Longchamp, EPFL Mobots group
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  */
14
15 #include <linux/delay.h>
16 #include <linux/dma-mapping.h>
17 #include <linux/gfp.h>
18 #include <linux/gpio.h>
19 #include <linux/init.h>
20 #include <linux/interrupt.h>
21 #include <linux/leds.h>
22 #include <linux/memory.h>
23 #include <linux/mtd/physmap.h>
24 #include <linux/mtd/partitions.h>
25 #include <linux/platform_device.h>
26 #include <linux/regulator/machine.h>
27 #include <linux/mfd/mc13783.h>
28 #include <linux/spi/spi.h>
29 #include <linux/types.h>
30
31 #include <linux/usb/otg.h>
32 #include <linux/usb/ulpi.h>
33
34 #include <asm/mach-types.h>
35 #include <asm/mach/arch.h>
36 #include <asm/mach/time.h>
37 #include <asm/mach/map.h>
38 #include <mach/board-mx31moboard.h>
39 #include <mach/common.h>
40 #include <mach/hardware.h>
41 #include <mach/iomux-mx3.h>
42 #include <mach/ipu.h>
43 #include <mach/mx3_camera.h>
44 #include <mach/spi.h>
45 #include <mach/ulpi.h>
46
47 #include "devices-imx31.h"
48 #include "devices.h"
49
50 static unsigned int moboard_pins[] = {
51         /* UART0 */
52         MX31_PIN_TXD1__TXD1, MX31_PIN_RXD1__RXD1,
53         MX31_PIN_CTS1__GPIO2_7,
54         /* UART4 */
55         MX31_PIN_PC_RST__CTS5, MX31_PIN_PC_VS2__RTS5,
56         MX31_PIN_PC_BVD2__TXD5, MX31_PIN_PC_BVD1__RXD5,
57         /* I2C0 */
58         MX31_PIN_I2C_DAT__I2C1_SDA, MX31_PIN_I2C_CLK__I2C1_SCL,
59         /* I2C1 */
60         MX31_PIN_DCD_DTE1__I2C2_SDA, MX31_PIN_RI_DTE1__I2C2_SCL,
61         /* SDHC1 */
62         MX31_PIN_SD1_DATA3__SD1_DATA3, MX31_PIN_SD1_DATA2__SD1_DATA2,
63         MX31_PIN_SD1_DATA1__SD1_DATA1, MX31_PIN_SD1_DATA0__SD1_DATA0,
64         MX31_PIN_SD1_CLK__SD1_CLK, MX31_PIN_SD1_CMD__SD1_CMD,
65         MX31_PIN_ATA_CS0__GPIO3_26, MX31_PIN_ATA_CS1__GPIO3_27,
66         /* USB reset */
67         MX31_PIN_GPIO1_0__GPIO1_0,
68         /* USB OTG */
69         MX31_PIN_USBOTG_DATA0__USBOTG_DATA0,
70         MX31_PIN_USBOTG_DATA1__USBOTG_DATA1,
71         MX31_PIN_USBOTG_DATA2__USBOTG_DATA2,
72         MX31_PIN_USBOTG_DATA3__USBOTG_DATA3,
73         MX31_PIN_USBOTG_DATA4__USBOTG_DATA4,
74         MX31_PIN_USBOTG_DATA5__USBOTG_DATA5,
75         MX31_PIN_USBOTG_DATA6__USBOTG_DATA6,
76         MX31_PIN_USBOTG_DATA7__USBOTG_DATA7,
77         MX31_PIN_USBOTG_CLK__USBOTG_CLK, MX31_PIN_USBOTG_DIR__USBOTG_DIR,
78         MX31_PIN_USBOTG_NXT__USBOTG_NXT, MX31_PIN_USBOTG_STP__USBOTG_STP,
79         MX31_PIN_USB_OC__GPIO1_30,
80         /* USB H2 */
81         MX31_PIN_USBH2_DATA0__USBH2_DATA0,
82         MX31_PIN_USBH2_DATA1__USBH2_DATA1,
83         MX31_PIN_STXD3__USBH2_DATA2, MX31_PIN_SRXD3__USBH2_DATA3,
84         MX31_PIN_SCK3__USBH2_DATA4, MX31_PIN_SFS3__USBH2_DATA5,
85         MX31_PIN_STXD6__USBH2_DATA6, MX31_PIN_SRXD6__USBH2_DATA7,
86         MX31_PIN_USBH2_CLK__USBH2_CLK, MX31_PIN_USBH2_DIR__USBH2_DIR,
87         MX31_PIN_USBH2_NXT__USBH2_NXT, MX31_PIN_USBH2_STP__USBH2_STP,
88         MX31_PIN_SCK6__GPIO1_25,
89         /* LEDs */
90         MX31_PIN_SVEN0__GPIO2_0, MX31_PIN_STX0__GPIO2_1,
91         MX31_PIN_SRX0__GPIO2_2, MX31_PIN_SIMPD0__GPIO2_3,
92         /* SPI1 */
93         MX31_PIN_CSPI2_MOSI__MOSI, MX31_PIN_CSPI2_MISO__MISO,
94         MX31_PIN_CSPI2_SCLK__SCLK, MX31_PIN_CSPI2_SPI_RDY__SPI_RDY,
95         MX31_PIN_CSPI2_SS0__SS0, MX31_PIN_CSPI2_SS2__SS2,
96         /* Atlas IRQ */
97         MX31_PIN_GPIO1_3__GPIO1_3,
98         /* SPI2 */
99         MX31_PIN_CSPI3_MOSI__MOSI, MX31_PIN_CSPI3_MISO__MISO,
100         MX31_PIN_CSPI3_SCLK__SCLK, MX31_PIN_CSPI3_SPI_RDY__SPI_RDY,
101         MX31_PIN_CSPI2_SS1__CSPI3_SS1,
102 };
103
104 static struct physmap_flash_data mx31moboard_flash_data = {
105         .width          = 2,
106 };
107
108 static struct resource mx31moboard_flash_resource = {
109         .start  = 0xa0000000,
110         .end    = 0xa1ffffff,
111         .flags  = IORESOURCE_MEM,
112 };
113
114 static struct platform_device mx31moboard_flash = {
115         .name   = "physmap-flash",
116         .id     = 0,
117         .dev    = {
118                 .platform_data  = &mx31moboard_flash_data,
119         },
120         .resource = &mx31moboard_flash_resource,
121         .num_resources = 1,
122 };
123
124 static int moboard_uart0_init(struct platform_device *pdev)
125 {
126         int ret = gpio_request(IOMUX_TO_GPIO(MX31_PIN_CTS1), "uart0-cts-hack");
127         if (ret)
128                 return ret;
129
130         ret = gpio_direction_output(IOMUX_TO_GPIO(MX31_PIN_CTS1), 0);
131         if (ret)
132                 gpio_free(IOMUX_TO_GPIO(MX31_PIN_CTS1));
133
134         return ret;
135 }
136
137 static void moboard_uart0_exit(struct platform_device *pdev)
138 {
139         gpio_free(IOMUX_TO_GPIO(MX31_PIN_CTS1));
140 }
141
142 static const struct imxuart_platform_data uart0_pdata __initconst = {
143         .init = moboard_uart0_init,
144         .exit = moboard_uart0_exit,
145 };
146
147 static const struct imxuart_platform_data uart4_pdata __initconst = {
148         .flags = IMXUART_HAVE_RTSCTS,
149 };
150
151 static const struct imxi2c_platform_data moboard_i2c0_data __initconst = {
152         .bitrate = 400000,
153 };
154
155 static const struct imxi2c_platform_data moboard_i2c1_data __initconst = {
156         .bitrate = 100000,
157 };
158
159 static int moboard_spi1_cs[] = {
160         MXC_SPI_CS(0),
161         MXC_SPI_CS(2),
162 };
163
164 static const struct spi_imx_master moboard_spi1_pdata __initconst = {
165         .chipselect     = moboard_spi1_cs,
166         .num_chipselect = ARRAY_SIZE(moboard_spi1_cs),
167 };
168
169 static struct regulator_consumer_supply sdhc_consumers[] = {
170         {
171                 .dev_name = "mxc-mmc.0",
172                 .supply = "sdhc0_vcc",
173         },
174         {
175                 .dev_name = "mxc-mmc.1",
176                 .supply = "sdhc1_vcc",
177         },
178 };
179
180 static struct regulator_init_data sdhc_vreg_data = {
181         .constraints = {
182                 .min_uV = 2700000,
183                 .max_uV = 3000000,
184                 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE |
185                         REGULATOR_CHANGE_MODE | REGULATOR_CHANGE_STATUS,
186                 .valid_modes_mask = REGULATOR_MODE_NORMAL |
187                         REGULATOR_MODE_FAST,
188                 .always_on = 0,
189                 .boot_on = 1,
190         },
191         .num_consumer_supplies = ARRAY_SIZE(sdhc_consumers),
192         .consumer_supplies = sdhc_consumers,
193 };
194
195 static struct regulator_consumer_supply cam_consumers[] = {
196         {
197                 .dev    = &mx3_camera.dev,
198                 .supply = "cam_vcc",
199         },
200 };
201
202 static struct regulator_init_data cam_vreg_data = {
203         .constraints = {
204                 .min_uV = 2700000,
205                 .max_uV = 3000000,
206                 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE |
207                         REGULATOR_CHANGE_MODE | REGULATOR_CHANGE_STATUS,
208                 .valid_modes_mask = REGULATOR_MODE_NORMAL |
209                         REGULATOR_MODE_FAST,
210                 .always_on = 0,
211                 .boot_on = 1,
212         },
213         .num_consumer_supplies = ARRAY_SIZE(cam_consumers),
214         .consumer_supplies = cam_consumers,
215 };
216
217 static struct mc13xxx_regulator_init_data moboard_regulators[] = {
218         {
219                 .id = MC13783_REG_VMMC1,
220                 .init_data = &sdhc_vreg_data,
221         },
222         {
223                 .id = MC13783_REG_VCAM,
224                 .init_data = &cam_vreg_data,
225         },
226 };
227
228 static struct mc13783_led_platform_data moboard_led[] = {
229         {
230                 .id = MC13783_LED_R1,
231                 .name = "coreboard-led-4:red",
232                 .max_current = 2,
233         },
234         {
235                 .id = MC13783_LED_G1,
236                 .name = "coreboard-led-4:green",
237                 .max_current = 2,
238         },
239         {
240                 .id = MC13783_LED_B1,
241                 .name = "coreboard-led-4:blue",
242                 .max_current = 2,
243         },
244         {
245                 .id = MC13783_LED_R2,
246                 .name = "coreboard-led-5:red",
247                 .max_current = 3,
248         },
249         {
250                 .id = MC13783_LED_G2,
251                 .name = "coreboard-led-5:green",
252                 .max_current = 3,
253         },
254         {
255                 .id = MC13783_LED_B2,
256                 .name = "coreboard-led-5:blue",
257                 .max_current = 3,
258         },
259 };
260
261 static struct mc13783_leds_platform_data moboard_leds = {
262         .num_leds = ARRAY_SIZE(moboard_led),
263         .led = moboard_led,
264         .flags = MC13783_LED_SLEWLIMTC,
265         .abmode = MC13783_LED_AB_DISABLED,
266         .tc1_period = MC13783_LED_PERIOD_10MS,
267         .tc2_period = MC13783_LED_PERIOD_10MS,
268 };
269
270 static struct mc13xxx_platform_data moboard_pmic = {
271         .regulators = {
272                 .regulators = moboard_regulators,
273                 .num_regulators = ARRAY_SIZE(moboard_regulators),
274         },
275         .leds = &moboard_leds,
276         .flags = MC13XXX_USE_REGULATOR | MC13XXX_USE_RTC |
277                 MC13XXX_USE_ADC | MC13XXX_USE_LED,
278 };
279
280 static struct spi_board_info moboard_spi_board_info[] __initdata = {
281         {
282                 .modalias = "mc13783",
283                 .irq = IOMUX_TO_IRQ(MX31_PIN_GPIO1_3),
284                 .max_speed_hz = 300000,
285                 .bus_num = 1,
286                 .chip_select = 0,
287                 .platform_data = &moboard_pmic,
288                 .mode = SPI_CS_HIGH,
289         },
290 };
291
292 static int moboard_spi2_cs[] = {
293         MXC_SPI_CS(1),
294 };
295
296 static const struct spi_imx_master moboard_spi2_pdata __initconst = {
297         .chipselect     = moboard_spi2_cs,
298         .num_chipselect = ARRAY_SIZE(moboard_spi2_cs),
299 };
300
301 #define SDHC1_CD IOMUX_TO_GPIO(MX31_PIN_ATA_CS0)
302 #define SDHC1_WP IOMUX_TO_GPIO(MX31_PIN_ATA_CS1)
303
304 static int moboard_sdhc1_get_ro(struct device *dev)
305 {
306         return !gpio_get_value(SDHC1_WP);
307 }
308
309 static int moboard_sdhc1_init(struct device *dev, irq_handler_t detect_irq,
310                 void *data)
311 {
312         int ret;
313
314         ret = gpio_request(SDHC1_CD, "sdhc-detect");
315         if (ret)
316                 return ret;
317
318         gpio_direction_input(SDHC1_CD);
319
320         ret = gpio_request(SDHC1_WP, "sdhc-wp");
321         if (ret)
322                 goto err_gpio_free;
323         gpio_direction_input(SDHC1_WP);
324
325         ret = request_irq(gpio_to_irq(SDHC1_CD), detect_irq,
326                 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
327                 "sdhc1-card-detect", data);
328         if (ret)
329                 goto err_gpio_free_2;
330
331         return 0;
332
333 err_gpio_free_2:
334         gpio_free(SDHC1_WP);
335 err_gpio_free:
336         gpio_free(SDHC1_CD);
337
338         return ret;
339 }
340
341 static void moboard_sdhc1_exit(struct device *dev, void *data)
342 {
343         free_irq(gpio_to_irq(SDHC1_CD), data);
344         gpio_free(SDHC1_WP);
345         gpio_free(SDHC1_CD);
346 }
347
348 static const struct imxmmc_platform_data sdhc1_pdata __initconst = {
349         .get_ro = moboard_sdhc1_get_ro,
350         .init   = moboard_sdhc1_init,
351         .exit   = moboard_sdhc1_exit,
352 };
353
354 /*
355  * this pin is dedicated for all mx31moboard systems, so we do it here
356  */
357 #define USB_RESET_B     IOMUX_TO_GPIO(MX31_PIN_GPIO1_0)
358 #define USB_PAD_CFG (PAD_CTL_DRV_MAX | PAD_CTL_SRE_FAST | PAD_CTL_HYS_CMOS | \
359                       PAD_CTL_ODE_CMOS)
360
361 #define OTG_EN_B IOMUX_TO_GPIO(MX31_PIN_USB_OC)
362 #define USBH2_EN_B IOMUX_TO_GPIO(MX31_PIN_SCK6)
363
364 static void usb_xcvr_reset(void)
365 {
366         mxc_iomux_set_pad(MX31_PIN_USBOTG_DATA0, USB_PAD_CFG | PAD_CTL_100K_PD);
367         mxc_iomux_set_pad(MX31_PIN_USBOTG_DATA1, USB_PAD_CFG | PAD_CTL_100K_PD);
368         mxc_iomux_set_pad(MX31_PIN_USBOTG_DATA2, USB_PAD_CFG | PAD_CTL_100K_PD);
369         mxc_iomux_set_pad(MX31_PIN_USBOTG_DATA3, USB_PAD_CFG | PAD_CTL_100K_PD);
370         mxc_iomux_set_pad(MX31_PIN_USBOTG_DATA4, USB_PAD_CFG | PAD_CTL_100K_PD);
371         mxc_iomux_set_pad(MX31_PIN_USBOTG_DATA5, USB_PAD_CFG | PAD_CTL_100K_PD);
372         mxc_iomux_set_pad(MX31_PIN_USBOTG_DATA6, USB_PAD_CFG | PAD_CTL_100K_PD);
373         mxc_iomux_set_pad(MX31_PIN_USBOTG_DATA7, USB_PAD_CFG | PAD_CTL_100K_PD);
374         mxc_iomux_set_pad(MX31_PIN_USBOTG_CLK, USB_PAD_CFG | PAD_CTL_100K_PU);
375         mxc_iomux_set_pad(MX31_PIN_USBOTG_DIR, USB_PAD_CFG | PAD_CTL_100K_PU);
376         mxc_iomux_set_pad(MX31_PIN_USBOTG_NXT, USB_PAD_CFG | PAD_CTL_100K_PU);
377         mxc_iomux_set_pad(MX31_PIN_USBOTG_STP, USB_PAD_CFG | PAD_CTL_100K_PU);
378
379         mxc_iomux_set_gpr(MUX_PGP_UH2, true);
380         mxc_iomux_set_pad(MX31_PIN_USBH2_CLK, USB_PAD_CFG | PAD_CTL_100K_PU);
381         mxc_iomux_set_pad(MX31_PIN_USBH2_DIR, USB_PAD_CFG | PAD_CTL_100K_PU);
382         mxc_iomux_set_pad(MX31_PIN_USBH2_NXT, USB_PAD_CFG | PAD_CTL_100K_PU);
383         mxc_iomux_set_pad(MX31_PIN_USBH2_STP, USB_PAD_CFG | PAD_CTL_100K_PU);
384         mxc_iomux_set_pad(MX31_PIN_USBH2_DATA0, USB_PAD_CFG | PAD_CTL_100K_PD);
385         mxc_iomux_set_pad(MX31_PIN_USBH2_DATA1, USB_PAD_CFG | PAD_CTL_100K_PD);
386         mxc_iomux_set_pad(MX31_PIN_SRXD6, USB_PAD_CFG | PAD_CTL_100K_PD);
387         mxc_iomux_set_pad(MX31_PIN_STXD6, USB_PAD_CFG | PAD_CTL_100K_PD);
388         mxc_iomux_set_pad(MX31_PIN_SFS3, USB_PAD_CFG | PAD_CTL_100K_PD);
389         mxc_iomux_set_pad(MX31_PIN_SCK3, USB_PAD_CFG | PAD_CTL_100K_PD);
390         mxc_iomux_set_pad(MX31_PIN_SRXD3, USB_PAD_CFG | PAD_CTL_100K_PD);
391         mxc_iomux_set_pad(MX31_PIN_STXD3, USB_PAD_CFG | PAD_CTL_100K_PD);
392
393         gpio_request(OTG_EN_B, "usb-udc-en");
394         gpio_direction_output(OTG_EN_B, 0);
395         gpio_request(USBH2_EN_B, "usbh2-en");
396         gpio_direction_output(USBH2_EN_B, 0);
397
398         gpio_request(USB_RESET_B, "usb-reset");
399         gpio_direction_output(USB_RESET_B, 0);
400         mdelay(1);
401         gpio_set_value(USB_RESET_B, 1);
402         mdelay(1);
403 }
404
405 static int moboard_usbh2_init_hw(struct platform_device *pdev)
406 {
407         return mx31_initialize_usb_hw(pdev->id, MXC_EHCI_POWER_PINS_ENABLED);
408 }
409
410 static struct mxc_usbh_platform_data usbh2_pdata __initdata = {
411         .init   = moboard_usbh2_init_hw,
412         .portsc = MXC_EHCI_MODE_ULPI | MXC_EHCI_UTMI_8BIT,
413 };
414
415 static int __init moboard_usbh2_init(void)
416 {
417         struct platform_device *pdev;
418
419         usbh2_pdata.otg = imx_otg_ulpi_create(ULPI_OTG_DRVVBUS |
420                         ULPI_OTG_DRVVBUS_EXT);
421         if (!usbh2_pdata.otg)
422                 return -ENODEV;
423
424         pdev = imx31_add_mxc_ehci_hs(2, &usbh2_pdata);
425         if (IS_ERR(pdev))
426                 return PTR_ERR(pdev);
427
428         return 0;
429 }
430
431 static struct gpio_led mx31moboard_leds[] = {
432         {
433                 .name   = "coreboard-led-0:red:running",
434                 .default_trigger = "heartbeat",
435                 .gpio   = IOMUX_TO_GPIO(MX31_PIN_SVEN0),
436         }, {
437                 .name   = "coreboard-led-1:red",
438                 .gpio   = IOMUX_TO_GPIO(MX31_PIN_STX0),
439         }, {
440                 .name   = "coreboard-led-2:red",
441                 .gpio   = IOMUX_TO_GPIO(MX31_PIN_SRX0),
442         }, {
443                 .name   = "coreboard-led-3:red",
444                 .gpio   = IOMUX_TO_GPIO(MX31_PIN_SIMPD0),
445         },
446 };
447
448 static struct gpio_led_platform_data mx31moboard_led_pdata = {
449         .num_leds       = ARRAY_SIZE(mx31moboard_leds),
450         .leds           = mx31moboard_leds,
451 };
452
453 static struct platform_device mx31moboard_leds_device = {
454         .name   = "leds-gpio",
455         .id     = -1,
456         .dev    = {
457                 .platform_data = &mx31moboard_led_pdata,
458         },
459 };
460
461 static struct ipu_platform_data mx3_ipu_data = {
462         .irq_base = MXC_IPU_IRQ_START,
463 };
464
465 static struct platform_device *devices[] __initdata = {
466         &mx31moboard_flash,
467         &mx31moboard_leds_device,
468 };
469
470 static struct mx3_camera_pdata camera_pdata = {
471         .dma_dev        = &mx3_ipu.dev,
472         .flags          = MX3_CAMERA_DATAWIDTH_8 | MX3_CAMERA_DATAWIDTH_10,
473         .mclk_10khz     = 4800,
474 };
475
476 #define CAMERA_BUF_SIZE (4*1024*1024)
477
478 static int __init mx31moboard_cam_alloc_dma(const size_t buf_size)
479 {
480         dma_addr_t dma_handle;
481         void *buf;
482         int dma;
483
484         if (buf_size < 2 * 1024 * 1024)
485                 return -EINVAL;
486
487         buf = dma_alloc_coherent(NULL, buf_size, &dma_handle, GFP_KERNEL);
488         if (!buf) {
489                 pr_err("%s: cannot allocate camera buffer-memory\n", __func__);
490                 return -ENOMEM;
491         }
492
493         memset(buf, 0, buf_size);
494
495         dma = dma_declare_coherent_memory(&mx3_camera.dev,
496                                         dma_handle, dma_handle, buf_size,
497                                         DMA_MEMORY_MAP | DMA_MEMORY_EXCLUSIVE);
498
499         /* The way we call dma_declare_coherent_memory only a malloc can fail */
500         return dma & DMA_MEMORY_MAP ? 0 : -ENOMEM;
501 }
502
503 static int mx31moboard_baseboard;
504 core_param(mx31moboard_baseboard, mx31moboard_baseboard, int, 0444);
505
506 /*
507  * Board specific initialization.
508  */
509 static void __init mx31moboard_init(void)
510 {
511         mxc_iomux_setup_multiple_pins(moboard_pins, ARRAY_SIZE(moboard_pins),
512                 "moboard");
513
514         platform_add_devices(devices, ARRAY_SIZE(devices));
515
516         imx31_add_imx_uart0(&uart0_pdata);
517         imx31_add_imx_uart4(&uart4_pdata);
518
519         imx31_add_imx_i2c0(&moboard_i2c0_data);
520         imx31_add_imx_i2c1(&moboard_i2c1_data);
521
522         imx31_add_spi_imx1(&moboard_spi1_pdata);
523         imx31_add_spi_imx2(&moboard_spi2_pdata);
524
525         gpio_request(IOMUX_TO_GPIO(MX31_PIN_GPIO1_3), "pmic-irq");
526         gpio_direction_input(IOMUX_TO_GPIO(MX31_PIN_GPIO1_3));
527         spi_register_board_info(moboard_spi_board_info,
528                 ARRAY_SIZE(moboard_spi_board_info));
529
530         imx31_add_mxc_mmc(0, &sdhc1_pdata);
531
532         mxc_register_device(&mx3_ipu, &mx3_ipu_data);
533         if (!mx31moboard_cam_alloc_dma(CAMERA_BUF_SIZE))
534                 mxc_register_device(&mx3_camera, &camera_pdata);
535
536         usb_xcvr_reset();
537
538         moboard_usbh2_init();
539
540         switch (mx31moboard_baseboard) {
541         case MX31NOBOARD:
542                 break;
543         case MX31DEVBOARD:
544                 mx31moboard_devboard_init();
545                 break;
546         case MX31MARXBOT:
547                 mx31moboard_marxbot_init();
548                 break;
549         case MX31SMARTBOT:
550         case MX31EYEBOT:
551                 mx31moboard_smartbot_init(mx31moboard_baseboard);
552                 break;
553         default:
554                 printk(KERN_ERR "Illegal mx31moboard_baseboard type %d\n",
555                         mx31moboard_baseboard);
556         }
557 }
558
559 static void __init mx31moboard_timer_init(void)
560 {
561         mx31_clocks_init(26000000);
562 }
563
564 struct sys_timer mx31moboard_timer = {
565         .init   = mx31moboard_timer_init,
566 };
567
568 MACHINE_START(MX31MOBOARD, "EPFL Mobots mx31moboard")
569         /* Maintainer: Valentin Longchamp, EPFL Mobots group */
570         .boot_params = MX3x_PHYS_OFFSET + 0x100,
571         .map_io = mx31_map_io,
572         .init_early = imx31_init_early,
573         .init_irq = mx31_init_irq,
574         .timer = &mx31moboard_timer,
575         .init_machine = mx31moboard_init,
576 MACHINE_END