1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/console.h>
15#include <linux/delay.h>
16#include <linux/gpio.h>
17#include <linux/gpio_keys.h>
18#include <linux/gpio/machine.h>
19#include <linux/init.h>
20#include <linux/kernel.h>
21#include <linux/leds.h>
22#include <linux/i2c.h>
23#include <linux/platform_data/at24.h>
24#include <linux/platform_data/pca953x.h>
25#include <linux/input.h>
26#include <linux/input/tps6507x-ts.h>
27#include <linux/mfd/tps6507x.h>
28#include <linux/mtd/mtd.h>
29#include <linux/mtd/rawnand.h>
30#include <linux/mtd/partitions.h>
31#include <linux/mtd/physmap.h>
32#include <linux/platform_device.h>
33#include <linux/platform_data/gpio-davinci.h>
34#include <linux/platform_data/mtd-davinci.h>
35#include <linux/platform_data/mtd-davinci-aemif.h>
36#include <linux/platform_data/spi-davinci.h>
37#include <linux/platform_data/uio_pruss.h>
38#include <linux/regulator/machine.h>
39#include <linux/regulator/tps6507x.h>
40#include <linux/regulator/fixed.h>
41#include <linux/spi/spi.h>
42#include <linux/spi/flash.h>
43
44#include <mach/common.h>
45#include "cp_intc.h"
46#include <mach/da8xx.h>
47#include <mach/mux.h>
48#include "sram.h"
49
50#include <asm/mach-types.h>
51#include <asm/mach/arch.h>
52#include <asm/system_info.h>
53
54#include <media/i2c/tvp514x.h>
55#include <media/i2c/adv7343.h>
56
57#define DA850_EVM_PHY_ID "davinci_mdio-0:00"
58#define DA850_LCD_PWR_PIN GPIO_TO_PIN(2, 8)
59#define DA850_LCD_BL_PIN GPIO_TO_PIN(2, 15)
60
61#define DA850_MII_MDIO_CLKEN_PIN GPIO_TO_PIN(2, 6)
62
63static struct mtd_partition da850evm_spiflash_part[] = {
64 [0] = {
65 .name = "UBL",
66 .offset = 0,
67 .size = SZ_64K,
68 .mask_flags = MTD_WRITEABLE,
69 },
70 [1] = {
71 .name = "U-Boot",
72 .offset = MTDPART_OFS_APPEND,
73 .size = SZ_512K,
74 .mask_flags = MTD_WRITEABLE,
75 },
76 [2] = {
77 .name = "U-Boot-Env",
78 .offset = MTDPART_OFS_APPEND,
79 .size = SZ_64K,
80 .mask_flags = MTD_WRITEABLE,
81 },
82 [3] = {
83 .name = "Kernel",
84 .offset = MTDPART_OFS_APPEND,
85 .size = SZ_2M + SZ_512K,
86 .mask_flags = 0,
87 },
88 [4] = {
89 .name = "Filesystem",
90 .offset = MTDPART_OFS_APPEND,
91 .size = SZ_4M,
92 .mask_flags = 0,
93 },
94 [5] = {
95 .name = "MAC-Address",
96 .offset = SZ_8M - SZ_64K,
97 .size = SZ_64K,
98 .mask_flags = MTD_WRITEABLE,
99 },
100};
101
102static struct flash_platform_data da850evm_spiflash_data = {
103 .name = "m25p80",
104 .parts = da850evm_spiflash_part,
105 .nr_parts = ARRAY_SIZE(da850evm_spiflash_part),
106 .type = "m25p64",
107};
108
109static struct davinci_spi_config da850evm_spiflash_cfg = {
110 .io_type = SPI_IO_TYPE_DMA,
111 .c2tdelay = 8,
112 .t2cdelay = 8,
113};
114
115static struct spi_board_info da850evm_spi_info[] = {
116 {
117 .modalias = "m25p80",
118 .platform_data = &da850evm_spiflash_data,
119 .controller_data = &da850evm_spiflash_cfg,
120 .mode = SPI_MODE_0,
121 .max_speed_hz = 30000000,
122 .bus_num = 1,
123 .chip_select = 0,
124 },
125};
126
127#ifdef CONFIG_MTD
128static void da850_evm_m25p80_notify_add(struct mtd_info *mtd)
129{
130 char *mac_addr = davinci_soc_info.emac_pdata->mac_addr;
131 size_t retlen;
132
133 if (!strcmp(mtd->name, "MAC-Address")) {
134 mtd_read(mtd, 0, ETH_ALEN, &retlen, mac_addr);
135 if (retlen == ETH_ALEN)
136 pr_info("Read MAC addr from SPI Flash: %pM\n",
137 mac_addr);
138 }
139}
140
141static struct mtd_notifier da850evm_spi_notifier = {
142 .add = da850_evm_m25p80_notify_add,
143};
144
145static void da850_evm_setup_mac_addr(void)
146{
147 register_mtd_user(&da850evm_spi_notifier);
148}
149#else
150static void da850_evm_setup_mac_addr(void) { }
151#endif
152
153static struct mtd_partition da850_evm_norflash_partition[] = {
154 {
155 .name = "bootloaders + env",
156 .offset = 0,
157 .size = SZ_512K,
158 .mask_flags = MTD_WRITEABLE,
159 },
160 {
161 .name = "kernel",
162 .offset = MTDPART_OFS_APPEND,
163 .size = SZ_2M,
164 .mask_flags = 0,
165 },
166 {
167 .name = "filesystem",
168 .offset = MTDPART_OFS_APPEND,
169 .size = MTDPART_SIZ_FULL,
170 .mask_flags = 0,
171 },
172};
173
174static struct physmap_flash_data da850_evm_norflash_data = {
175 .width = 2,
176 .parts = da850_evm_norflash_partition,
177 .nr_parts = ARRAY_SIZE(da850_evm_norflash_partition),
178};
179
180static struct resource da850_evm_norflash_resource[] = {
181 {
182 .start = DA8XX_AEMIF_CS2_BASE,
183 .end = DA8XX_AEMIF_CS2_BASE + SZ_32M - 1,
184 .flags = IORESOURCE_MEM,
185 },
186};
187
188static struct platform_device da850_evm_norflash_device = {
189 .name = "physmap-flash",
190 .id = 0,
191 .dev = {
192 .platform_data = &da850_evm_norflash_data,
193 },
194 .num_resources = 1,
195 .resource = da850_evm_norflash_resource,
196};
197
198
199
200
201
202
203static struct mtd_partition da850_evm_nandflash_partition[] = {
204 {
205 .name = "u-boot env",
206 .offset = 0,
207 .size = SZ_128K,
208 .mask_flags = MTD_WRITEABLE,
209 },
210 {
211 .name = "UBL",
212 .offset = MTDPART_OFS_APPEND,
213 .size = SZ_128K,
214 .mask_flags = MTD_WRITEABLE,
215 },
216 {
217 .name = "u-boot",
218 .offset = MTDPART_OFS_APPEND,
219 .size = 4 * SZ_128K,
220 .mask_flags = MTD_WRITEABLE,
221 },
222 {
223 .name = "kernel",
224 .offset = 0x200000,
225 .size = SZ_2M,
226 .mask_flags = 0,
227 },
228 {
229 .name = "filesystem",
230 .offset = MTDPART_OFS_APPEND,
231 .size = MTDPART_SIZ_FULL,
232 .mask_flags = 0,
233 },
234};
235
236static struct davinci_aemif_timing da850_evm_nandflash_timing = {
237 .wsetup = 24,
238 .wstrobe = 21,
239 .whold = 14,
240 .rsetup = 19,
241 .rstrobe = 50,
242 .rhold = 0,
243 .ta = 20,
244};
245
246static struct davinci_nand_pdata da850_evm_nandflash_data = {
247 .parts = da850_evm_nandflash_partition,
248 .nr_parts = ARRAY_SIZE(da850_evm_nandflash_partition),
249 .ecc_mode = NAND_ECC_HW,
250 .ecc_bits = 4,
251 .bbt_options = NAND_BBT_USE_FLASH,
252 .timing = &da850_evm_nandflash_timing,
253};
254
255static struct resource da850_evm_nandflash_resource[] = {
256 {
257 .start = DA8XX_AEMIF_CS3_BASE,
258 .end = DA8XX_AEMIF_CS3_BASE + SZ_512K + 2 * SZ_1K - 1,
259 .flags = IORESOURCE_MEM,
260 },
261 {
262 .start = DA8XX_AEMIF_CTL_BASE,
263 .end = DA8XX_AEMIF_CTL_BASE + SZ_32K - 1,
264 .flags = IORESOURCE_MEM,
265 },
266};
267
268static struct platform_device da850_evm_nandflash_device = {
269 .name = "davinci_nand",
270 .id = 1,
271 .dev = {
272 .platform_data = &da850_evm_nandflash_data,
273 },
274 .num_resources = ARRAY_SIZE(da850_evm_nandflash_resource),
275 .resource = da850_evm_nandflash_resource,
276};
277
278static struct platform_device *da850_evm_devices[] = {
279 &da850_evm_nandflash_device,
280 &da850_evm_norflash_device,
281};
282
283#define DA8XX_AEMIF_CE2CFG_OFFSET 0x10
284#define DA8XX_AEMIF_ASIZE_16BIT 0x1
285
286static void __init da850_evm_init_nor(void)
287{
288 void __iomem *aemif_addr;
289
290 aemif_addr = ioremap(DA8XX_AEMIF_CTL_BASE, SZ_32K);
291
292
293 writel(readl(aemif_addr + DA8XX_AEMIF_CE2CFG_OFFSET) |
294 DA8XX_AEMIF_ASIZE_16BIT,
295 aemif_addr + DA8XX_AEMIF_CE2CFG_OFFSET);
296
297 iounmap(aemif_addr);
298}
299
300static const short da850_evm_nand_pins[] = {
301 DA850_EMA_D_0, DA850_EMA_D_1, DA850_EMA_D_2, DA850_EMA_D_3,
302 DA850_EMA_D_4, DA850_EMA_D_5, DA850_EMA_D_6, DA850_EMA_D_7,
303 DA850_EMA_A_1, DA850_EMA_A_2, DA850_NEMA_CS_3, DA850_NEMA_CS_4,
304 DA850_NEMA_WE, DA850_NEMA_OE,
305 -1
306};
307
308static const short da850_evm_nor_pins[] = {
309 DA850_EMA_BA_1, DA850_EMA_CLK, DA850_EMA_WAIT_1, DA850_NEMA_CS_2,
310 DA850_NEMA_WE, DA850_NEMA_OE, DA850_EMA_D_0, DA850_EMA_D_1,
311 DA850_EMA_D_2, DA850_EMA_D_3, DA850_EMA_D_4, DA850_EMA_D_5,
312 DA850_EMA_D_6, DA850_EMA_D_7, DA850_EMA_D_8, DA850_EMA_D_9,
313 DA850_EMA_D_10, DA850_EMA_D_11, DA850_EMA_D_12, DA850_EMA_D_13,
314 DA850_EMA_D_14, DA850_EMA_D_15, DA850_EMA_A_0, DA850_EMA_A_1,
315 DA850_EMA_A_2, DA850_EMA_A_3, DA850_EMA_A_4, DA850_EMA_A_5,
316 DA850_EMA_A_6, DA850_EMA_A_7, DA850_EMA_A_8, DA850_EMA_A_9,
317 DA850_EMA_A_10, DA850_EMA_A_11, DA850_EMA_A_12, DA850_EMA_A_13,
318 DA850_EMA_A_14, DA850_EMA_A_15, DA850_EMA_A_16, DA850_EMA_A_17,
319 DA850_EMA_A_18, DA850_EMA_A_19, DA850_EMA_A_20, DA850_EMA_A_21,
320 DA850_EMA_A_22, DA850_EMA_A_23,
321 -1
322};
323
324#define HAS_MMC IS_ENABLED(CONFIG_MMC_DAVINCI)
325
326static inline void da850_evm_setup_nor_nand(void)
327{
328 int ret = 0;
329
330 if (!HAS_MMC) {
331 ret = davinci_cfg_reg_list(da850_evm_nand_pins);
332 if (ret)
333 pr_warn("%s: NAND mux setup failed: %d\n",
334 __func__, ret);
335
336 ret = davinci_cfg_reg_list(da850_evm_nor_pins);
337 if (ret)
338 pr_warn("%s: NOR mux setup failed: %d\n",
339 __func__, ret);
340
341 da850_evm_init_nor();
342
343 platform_add_devices(da850_evm_devices,
344 ARRAY_SIZE(da850_evm_devices));
345
346 if (davinci_aemif_setup(&da850_evm_nandflash_device))
347 pr_warn("%s: Cannot configure AEMIF.\n", __func__);
348 }
349}
350
351#ifdef CONFIG_DA850_UI_RMII
352static inline void da850_evm_setup_emac_rmii(int rmii_sel)
353{
354 struct davinci_soc_info *soc_info = &davinci_soc_info;
355
356 soc_info->emac_pdata->rmii_en = 1;
357 gpio_set_value_cansleep(rmii_sel, 0);
358}
359#else
360static inline void da850_evm_setup_emac_rmii(int rmii_sel) { }
361#endif
362
363
364#define DA850_KEYS_DEBOUNCE_MS 10
365
366
367
368
369
370
371
372#define DA850_GPIO_KEYS_POLL_MS 200
373
374enum da850_evm_ui_exp_pins {
375 DA850_EVM_UI_EXP_SEL_C = 5,
376 DA850_EVM_UI_EXP_SEL_B,
377 DA850_EVM_UI_EXP_SEL_A,
378 DA850_EVM_UI_EXP_PB8,
379 DA850_EVM_UI_EXP_PB7,
380 DA850_EVM_UI_EXP_PB6,
381 DA850_EVM_UI_EXP_PB5,
382 DA850_EVM_UI_EXP_PB4,
383 DA850_EVM_UI_EXP_PB3,
384 DA850_EVM_UI_EXP_PB2,
385 DA850_EVM_UI_EXP_PB1,
386};
387
388static const char * const da850_evm_ui_exp[] = {
389 [DA850_EVM_UI_EXP_SEL_C] = "sel_c",
390 [DA850_EVM_UI_EXP_SEL_B] = "sel_b",
391 [DA850_EVM_UI_EXP_SEL_A] = "sel_a",
392 [DA850_EVM_UI_EXP_PB8] = "pb8",
393 [DA850_EVM_UI_EXP_PB7] = "pb7",
394 [DA850_EVM_UI_EXP_PB6] = "pb6",
395 [DA850_EVM_UI_EXP_PB5] = "pb5",
396 [DA850_EVM_UI_EXP_PB4] = "pb4",
397 [DA850_EVM_UI_EXP_PB3] = "pb3",
398 [DA850_EVM_UI_EXP_PB2] = "pb2",
399 [DA850_EVM_UI_EXP_PB1] = "pb1",
400};
401
402#define DA850_N_UI_PB 8
403
404static struct gpio_keys_button da850_evm_ui_keys[] = {
405 [0 ... DA850_N_UI_PB - 1] = {
406 .type = EV_KEY,
407 .active_low = 1,
408 .wakeup = 0,
409 .debounce_interval = DA850_KEYS_DEBOUNCE_MS,
410 .code = -1,
411 .gpio = -1,
412 .desc = NULL,
413 },
414};
415
416static struct gpio_keys_platform_data da850_evm_ui_keys_pdata = {
417 .buttons = da850_evm_ui_keys,
418 .nbuttons = ARRAY_SIZE(da850_evm_ui_keys),
419 .poll_interval = DA850_GPIO_KEYS_POLL_MS,
420};
421
422static struct platform_device da850_evm_ui_keys_device = {
423 .name = "gpio-keys-polled",
424 .id = 0,
425 .dev = {
426 .platform_data = &da850_evm_ui_keys_pdata
427 },
428};
429
430static void da850_evm_ui_keys_init(unsigned gpio)
431{
432 int i;
433 struct gpio_keys_button *button;
434
435 for (i = 0; i < DA850_N_UI_PB; i++) {
436 button = &da850_evm_ui_keys[i];
437 button->code = KEY_F8 - i;
438 button->desc = da850_evm_ui_exp[DA850_EVM_UI_EXP_PB8 + i];
439 button->gpio = gpio + DA850_EVM_UI_EXP_PB8 + i;
440 }
441}
442
443#ifdef CONFIG_DA850_UI_SD_VIDEO_PORT
444static inline void da850_evm_setup_video_port(int video_sel)
445{
446 gpio_set_value_cansleep(video_sel, 0);
447}
448#else
449static inline void da850_evm_setup_video_port(int video_sel) { }
450#endif
451
452static int da850_evm_ui_expander_setup(struct i2c_client *client, unsigned gpio,
453 unsigned ngpio, void *c)
454{
455 int sel_a, sel_b, sel_c, ret;
456
457 sel_a = gpio + DA850_EVM_UI_EXP_SEL_A;
458 sel_b = gpio + DA850_EVM_UI_EXP_SEL_B;
459 sel_c = gpio + DA850_EVM_UI_EXP_SEL_C;
460
461 ret = gpio_request(sel_a, da850_evm_ui_exp[DA850_EVM_UI_EXP_SEL_A]);
462 if (ret) {
463 pr_warn("Cannot open UI expander pin %d\n", sel_a);
464 goto exp_setup_sela_fail;
465 }
466
467 ret = gpio_request(sel_b, da850_evm_ui_exp[DA850_EVM_UI_EXP_SEL_B]);
468 if (ret) {
469 pr_warn("Cannot open UI expander pin %d\n", sel_b);
470 goto exp_setup_selb_fail;
471 }
472
473 ret = gpio_request(sel_c, da850_evm_ui_exp[DA850_EVM_UI_EXP_SEL_C]);
474 if (ret) {
475 pr_warn("Cannot open UI expander pin %d\n", sel_c);
476 goto exp_setup_selc_fail;
477 }
478
479
480 gpio_direction_output(sel_a, 1);
481 gpio_direction_output(sel_b, 1);
482 gpio_direction_output(sel_c, 1);
483
484 da850_evm_ui_keys_init(gpio);
485 ret = platform_device_register(&da850_evm_ui_keys_device);
486 if (ret) {
487 pr_warn("Could not register UI GPIO expander push-buttons");
488 goto exp_setup_keys_fail;
489 }
490
491 pr_info("DA850/OMAP-L138 EVM UI card detected\n");
492
493 da850_evm_setup_nor_nand();
494
495 da850_evm_setup_emac_rmii(sel_a);
496
497 da850_evm_setup_video_port(sel_c);
498
499 return 0;
500
501exp_setup_keys_fail:
502 gpio_free(sel_c);
503exp_setup_selc_fail:
504 gpio_free(sel_b);
505exp_setup_selb_fail:
506 gpio_free(sel_a);
507exp_setup_sela_fail:
508 return ret;
509}
510
511static int da850_evm_ui_expander_teardown(struct i2c_client *client,
512 unsigned gpio, unsigned ngpio, void *c)
513{
514 platform_device_unregister(&da850_evm_ui_keys_device);
515
516
517 gpio_set_value_cansleep(gpio + DA850_EVM_UI_EXP_SEL_C, 1);
518 gpio_set_value_cansleep(gpio + DA850_EVM_UI_EXP_SEL_B, 1);
519 gpio_set_value_cansleep(gpio + DA850_EVM_UI_EXP_SEL_A, 1);
520
521 gpio_free(gpio + DA850_EVM_UI_EXP_SEL_C);
522 gpio_free(gpio + DA850_EVM_UI_EXP_SEL_B);
523 gpio_free(gpio + DA850_EVM_UI_EXP_SEL_A);
524
525 return 0;
526}
527
528
529#define DA850_UI_EXPANDER_N_GPIOS ARRAY_SIZE(da850_evm_ui_exp)
530#define DA850_BB_EXPANDER_GPIO_BASE (DAVINCI_N_GPIO + DA850_UI_EXPANDER_N_GPIOS)
531
532enum da850_evm_bb_exp_pins {
533 DA850_EVM_BB_EXP_DEEP_SLEEP_EN = 0,
534 DA850_EVM_BB_EXP_SW_RST,
535 DA850_EVM_BB_EXP_TP_23,
536 DA850_EVM_BB_EXP_TP_22,
537 DA850_EVM_BB_EXP_TP_21,
538 DA850_EVM_BB_EXP_USER_PB1,
539 DA850_EVM_BB_EXP_USER_LED2,
540 DA850_EVM_BB_EXP_USER_LED1,
541 DA850_EVM_BB_EXP_USER_SW1,
542 DA850_EVM_BB_EXP_USER_SW2,
543 DA850_EVM_BB_EXP_USER_SW3,
544 DA850_EVM_BB_EXP_USER_SW4,
545 DA850_EVM_BB_EXP_USER_SW5,
546 DA850_EVM_BB_EXP_USER_SW6,
547 DA850_EVM_BB_EXP_USER_SW7,
548 DA850_EVM_BB_EXP_USER_SW8
549};
550
551static const char * const da850_evm_bb_exp[] = {
552 [DA850_EVM_BB_EXP_DEEP_SLEEP_EN] = "deep_sleep_en",
553 [DA850_EVM_BB_EXP_SW_RST] = "sw_rst",
554 [DA850_EVM_BB_EXP_TP_23] = "tp_23",
555 [DA850_EVM_BB_EXP_TP_22] = "tp_22",
556 [DA850_EVM_BB_EXP_TP_21] = "tp_21",
557 [DA850_EVM_BB_EXP_USER_PB1] = "user_pb1",
558 [DA850_EVM_BB_EXP_USER_LED2] = "user_led2",
559 [DA850_EVM_BB_EXP_USER_LED1] = "user_led1",
560 [DA850_EVM_BB_EXP_USER_SW1] = "user_sw1",
561 [DA850_EVM_BB_EXP_USER_SW2] = "user_sw2",
562 [DA850_EVM_BB_EXP_USER_SW3] = "user_sw3",
563 [DA850_EVM_BB_EXP_USER_SW4] = "user_sw4",
564 [DA850_EVM_BB_EXP_USER_SW5] = "user_sw5",
565 [DA850_EVM_BB_EXP_USER_SW6] = "user_sw6",
566 [DA850_EVM_BB_EXP_USER_SW7] = "user_sw7",
567 [DA850_EVM_BB_EXP_USER_SW8] = "user_sw8",
568};
569
570#define DA850_N_BB_USER_SW 8
571
572static struct gpio_keys_button da850_evm_bb_keys[] = {
573 [0] = {
574 .type = EV_KEY,
575 .active_low = 1,
576 .wakeup = 0,
577 .debounce_interval = DA850_KEYS_DEBOUNCE_MS,
578 .code = KEY_PROG1,
579 .desc = NULL,
580 .gpio = -1,
581 },
582 [1 ... DA850_N_BB_USER_SW] = {
583 .type = EV_SW,
584 .active_low = 1,
585 .wakeup = 0,
586 .debounce_interval = DA850_KEYS_DEBOUNCE_MS,
587 .code = -1,
588 .desc = NULL,
589 .gpio = -1,
590 },
591};
592
593static struct gpio_keys_platform_data da850_evm_bb_keys_pdata = {
594 .buttons = da850_evm_bb_keys,
595 .nbuttons = ARRAY_SIZE(da850_evm_bb_keys),
596 .poll_interval = DA850_GPIO_KEYS_POLL_MS,
597};
598
599static struct platform_device da850_evm_bb_keys_device = {
600 .name = "gpio-keys-polled",
601 .id = 1,
602 .dev = {
603 .platform_data = &da850_evm_bb_keys_pdata
604 },
605};
606
607static void da850_evm_bb_keys_init(unsigned gpio)
608{
609 int i;
610 struct gpio_keys_button *button;
611
612 button = &da850_evm_bb_keys[0];
613 button->desc = da850_evm_bb_exp[DA850_EVM_BB_EXP_USER_PB1];
614 button->gpio = gpio + DA850_EVM_BB_EXP_USER_PB1;
615
616 for (i = 0; i < DA850_N_BB_USER_SW; i++) {
617 button = &da850_evm_bb_keys[i + 1];
618 button->code = SW_LID + i;
619 button->desc = da850_evm_bb_exp[DA850_EVM_BB_EXP_USER_SW1 + i];
620 button->gpio = gpio + DA850_EVM_BB_EXP_USER_SW1 + i;
621 }
622}
623
624#define DA850_N_BB_USER_LED 2
625
626static struct gpio_led da850_evm_bb_leds[] = {
627 [0 ... DA850_N_BB_USER_LED - 1] = {
628 .active_low = 1,
629 .gpio = -1,
630 .name = NULL,
631 },
632};
633
634static struct gpio_led_platform_data da850_evm_bb_leds_pdata = {
635 .leds = da850_evm_bb_leds,
636 .num_leds = ARRAY_SIZE(da850_evm_bb_leds),
637};
638
639static struct platform_device da850_evm_bb_leds_device = {
640 .name = "leds-gpio",
641 .id = -1,
642 .dev = {
643 .platform_data = &da850_evm_bb_leds_pdata
644 }
645};
646
647static void da850_evm_bb_leds_init(unsigned gpio)
648{
649 int i;
650 struct gpio_led *led;
651
652 for (i = 0; i < DA850_N_BB_USER_LED; i++) {
653 led = &da850_evm_bb_leds[i];
654
655 led->gpio = gpio + DA850_EVM_BB_EXP_USER_LED2 + i;
656 led->name =
657 da850_evm_bb_exp[DA850_EVM_BB_EXP_USER_LED2 + i];
658 }
659}
660
661static int da850_evm_bb_expander_setup(struct i2c_client *client,
662 unsigned gpio, unsigned ngpio,
663 void *c)
664{
665 int ret;
666
667
668
669
670
671 da850_evm_bb_keys_init(gpio);
672 ret = platform_device_register(&da850_evm_bb_keys_device);
673 if (ret) {
674 pr_warn("Could not register baseboard GPIO expander keys");
675 goto io_exp_setup_sw_fail;
676 }
677
678 da850_evm_bb_leds_init(gpio);
679 ret = platform_device_register(&da850_evm_bb_leds_device);
680 if (ret) {
681 pr_warn("Could not register baseboard GPIO expander LEDs");
682 goto io_exp_setup_leds_fail;
683 }
684
685 return 0;
686
687io_exp_setup_leds_fail:
688 platform_device_unregister(&da850_evm_bb_keys_device);
689io_exp_setup_sw_fail:
690 return ret;
691}
692
693static int da850_evm_bb_expander_teardown(struct i2c_client *client,
694 unsigned gpio, unsigned ngpio, void *c)
695{
696 platform_device_unregister(&da850_evm_bb_leds_device);
697 platform_device_unregister(&da850_evm_bb_keys_device);
698
699 return 0;
700}
701
702static struct pca953x_platform_data da850_evm_ui_expander_info = {
703 .gpio_base = DAVINCI_N_GPIO,
704 .setup = da850_evm_ui_expander_setup,
705 .teardown = da850_evm_ui_expander_teardown,
706 .names = da850_evm_ui_exp,
707};
708
709static struct pca953x_platform_data da850_evm_bb_expander_info = {
710 .gpio_base = DA850_BB_EXPANDER_GPIO_BASE,
711 .setup = da850_evm_bb_expander_setup,
712 .teardown = da850_evm_bb_expander_teardown,
713 .names = da850_evm_bb_exp,
714};
715
716static struct i2c_board_info __initdata da850_evm_i2c_devices[] = {
717 {
718 I2C_BOARD_INFO("tlv320aic3x", 0x18),
719 },
720 {
721 I2C_BOARD_INFO("tca6416", 0x20),
722 .platform_data = &da850_evm_ui_expander_info,
723 },
724 {
725 I2C_BOARD_INFO("tca6416", 0x21),
726 .platform_data = &da850_evm_bb_expander_info,
727 },
728};
729
730static struct davinci_i2c_platform_data da850_evm_i2c_0_pdata = {
731 .bus_freq = 100,
732 .bus_delay = 0,
733};
734
735
736static u8 da850_iis_serializer_direction[] = {
737 INACTIVE_MODE, INACTIVE_MODE, INACTIVE_MODE, INACTIVE_MODE,
738 INACTIVE_MODE, INACTIVE_MODE, INACTIVE_MODE, INACTIVE_MODE,
739 INACTIVE_MODE, INACTIVE_MODE, INACTIVE_MODE, TX_MODE,
740 RX_MODE, INACTIVE_MODE, INACTIVE_MODE, INACTIVE_MODE,
741};
742
743static struct snd_platform_data da850_evm_snd_data = {
744 .tx_dma_offset = 0x2000,
745 .rx_dma_offset = 0x2000,
746 .op_mode = DAVINCI_MCASP_IIS_MODE,
747 .num_serializer = ARRAY_SIZE(da850_iis_serializer_direction),
748 .tdm_slots = 2,
749 .serial_dir = da850_iis_serializer_direction,
750 .asp_chan_q = EVENTQ_0,
751 .ram_chan_q = EVENTQ_1,
752 .version = MCASP_VERSION_2,
753 .txnumevt = 1,
754 .rxnumevt = 1,
755 .sram_size_playback = SZ_8K,
756 .sram_size_capture = SZ_8K,
757};
758
759static const short da850_evm_mcasp_pins[] __initconst = {
760 DA850_AHCLKX, DA850_ACLKX, DA850_AFSX,
761 DA850_AHCLKR, DA850_ACLKR, DA850_AFSR, DA850_AMUTE,
762 DA850_AXR_11, DA850_AXR_12,
763 -1
764};
765
766#define DA850_MMCSD_CD_PIN GPIO_TO_PIN(4, 0)
767#define DA850_MMCSD_WP_PIN GPIO_TO_PIN(4, 1)
768
769static struct gpiod_lookup_table mmc_gpios_table = {
770 .dev_id = "da830-mmc.0",
771 .table = {
772
773 GPIO_LOOKUP("davinci_gpio.0", DA850_MMCSD_CD_PIN, "cd",
774 GPIO_ACTIVE_LOW),
775 GPIO_LOOKUP("davinci_gpio.0", DA850_MMCSD_WP_PIN, "wp",
776 GPIO_ACTIVE_LOW),
777 },
778};
779
780static struct davinci_mmc_config da850_mmc_config = {
781 .wires = 4,
782 .max_freq = 50000000,
783 .caps = MMC_CAP_MMC_HIGHSPEED | MMC_CAP_SD_HIGHSPEED,
784};
785
786static const short da850_evm_mmcsd0_pins[] __initconst = {
787 DA850_MMCSD0_DAT_0, DA850_MMCSD0_DAT_1, DA850_MMCSD0_DAT_2,
788 DA850_MMCSD0_DAT_3, DA850_MMCSD0_CLK, DA850_MMCSD0_CMD,
789 DA850_GPIO4_0, DA850_GPIO4_1,
790 -1
791};
792
793static void da850_panel_power_ctrl(int val)
794{
795
796 gpio_set_value(DA850_LCD_BL_PIN, val);
797
798
799 gpio_set_value(DA850_LCD_PWR_PIN, val);
800}
801
802static int da850_lcd_hw_init(void)
803{
804 int status;
805
806 status = gpio_request(DA850_LCD_BL_PIN, "lcd bl");
807 if (status < 0)
808 return status;
809
810 status = gpio_request(DA850_LCD_PWR_PIN, "lcd pwr");
811 if (status < 0) {
812 gpio_free(DA850_LCD_BL_PIN);
813 return status;
814 }
815
816 gpio_direction_output(DA850_LCD_BL_PIN, 0);
817 gpio_direction_output(DA850_LCD_PWR_PIN, 0);
818
819
820 da850_panel_power_ctrl(0);
821
822
823 da850_panel_power_ctrl(1);
824
825 return 0;
826}
827
828
829static struct regulator_consumer_supply fixed_supplies[] = {
830
831 REGULATOR_SUPPLY("AVDD", "1-0018"),
832 REGULATOR_SUPPLY("DRVDD", "1-0018"),
833
834
835 REGULATOR_SUPPLY("DVDD", "1-0018"),
836
837
838 REGULATOR_SUPPLY("vcc", "1-0020"),
839};
840
841
842
843
844static struct regulator_consumer_supply tps65070_dcdc1_consumers[] = {
845 {
846 .supply = "usb0_vdda33",
847 },
848 {
849 .supply = "usb1_vdda33",
850 },
851};
852
853
854static struct regulator_consumer_supply tps65070_dcdc2_consumers[] = {
855 {
856 .supply = "dvdd3318_a",
857 },
858 {
859 .supply = "dvdd3318_b",
860 },
861 {
862 .supply = "dvdd3318_c",
863 },
864 REGULATOR_SUPPLY("IOVDD", "1-0018"),
865};
866
867
868static struct regulator_consumer_supply tps65070_dcdc3_consumers[] = {
869 {
870 .supply = "cvdd",
871 },
872};
873
874
875static struct regulator_consumer_supply tps65070_ldo1_consumers[] = {
876 {
877 .supply = "sata_vddr",
878 },
879 {
880 .supply = "usb0_vdda18",
881 },
882 {
883 .supply = "usb1_vdda18",
884 },
885 {
886 .supply = "ddr_dvdd18",
887 },
888};
889
890
891static struct regulator_consumer_supply tps65070_ldo2_consumers[] = {
892 {
893 .supply = "sata_vdd",
894 },
895 {
896 .supply = "pll0_vdda",
897 },
898 {
899 .supply = "pll1_vdda",
900 },
901 {
902 .supply = "usbs_cvdd",
903 },
904 {
905 .supply = "vddarnwa1",
906 },
907};
908
909
910static struct tps6507x_reg_platform_data tps6507x_platform_data = {
911 .defdcdc_default = true,
912};
913
914static struct regulator_init_data tps65070_regulator_data[] = {
915
916 {
917 .constraints = {
918 .min_uV = 3150000,
919 .max_uV = 3450000,
920 .valid_ops_mask = (REGULATOR_CHANGE_VOLTAGE |
921 REGULATOR_CHANGE_STATUS),
922 .boot_on = 1,
923 },
924 .num_consumer_supplies = ARRAY_SIZE(tps65070_dcdc1_consumers),
925 .consumer_supplies = tps65070_dcdc1_consumers,
926 },
927
928
929 {
930 .constraints = {
931 .min_uV = 1710000,
932 .max_uV = 3450000,
933 .valid_ops_mask = (REGULATOR_CHANGE_VOLTAGE |
934 REGULATOR_CHANGE_STATUS),
935 .boot_on = 1,
936 .always_on = 1,
937 },
938 .num_consumer_supplies = ARRAY_SIZE(tps65070_dcdc2_consumers),
939 .consumer_supplies = tps65070_dcdc2_consumers,
940 .driver_data = &tps6507x_platform_data,
941 },
942
943
944 {
945 .constraints = {
946 .min_uV = 950000,
947 .max_uV = 1350000,
948 .valid_ops_mask = (REGULATOR_CHANGE_VOLTAGE |
949 REGULATOR_CHANGE_STATUS),
950 .boot_on = 1,
951 },
952 .num_consumer_supplies = ARRAY_SIZE(tps65070_dcdc3_consumers),
953 .consumer_supplies = tps65070_dcdc3_consumers,
954 .driver_data = &tps6507x_platform_data,
955 },
956
957
958 {
959 .constraints = {
960 .min_uV = 1710000,
961 .max_uV = 1890000,
962 .valid_ops_mask = (REGULATOR_CHANGE_VOLTAGE |
963 REGULATOR_CHANGE_STATUS),
964 .boot_on = 1,
965 },
966 .num_consumer_supplies = ARRAY_SIZE(tps65070_ldo1_consumers),
967 .consumer_supplies = tps65070_ldo1_consumers,
968 },
969
970
971 {
972 .constraints = {
973 .min_uV = 1140000,
974 .max_uV = 1320000,
975 .valid_ops_mask = (REGULATOR_CHANGE_VOLTAGE |
976 REGULATOR_CHANGE_STATUS),
977 .boot_on = 1,
978 },
979 .num_consumer_supplies = ARRAY_SIZE(tps65070_ldo2_consumers),
980 .consumer_supplies = tps65070_ldo2_consumers,
981 },
982};
983
984static struct touchscreen_init_data tps6507x_touchscreen_data = {
985 .poll_period = 30,
986 .min_pressure = 0x30,
987 .vendor = 0,
988 .product = 65070,
989 .version = 0x100,
990};
991
992static struct tps6507x_board tps_board = {
993 .tps6507x_pmic_init_data = &tps65070_regulator_data[0],
994 .tps6507x_ts_init_data = &tps6507x_touchscreen_data,
995};
996
997static struct i2c_board_info __initdata da850_evm_tps65070_info[] = {
998 {
999 I2C_BOARD_INFO("tps6507x", 0x48),
1000 .platform_data = &tps_board,
1001 },
1002};
1003
1004static int __init pmic_tps65070_init(void)
1005{
1006 return i2c_register_board_info(1, da850_evm_tps65070_info,
1007 ARRAY_SIZE(da850_evm_tps65070_info));
1008}
1009
1010static const short da850_evm_lcdc_pins[] = {
1011 DA850_GPIO2_8, DA850_GPIO2_15,
1012 -1
1013};
1014
1015static const short da850_evm_mii_pins[] = {
1016 DA850_MII_TXEN, DA850_MII_TXCLK, DA850_MII_COL, DA850_MII_TXD_3,
1017 DA850_MII_TXD_2, DA850_MII_TXD_1, DA850_MII_TXD_0, DA850_MII_RXER,
1018 DA850_MII_CRS, DA850_MII_RXCLK, DA850_MII_RXDV, DA850_MII_RXD_3,
1019 DA850_MII_RXD_2, DA850_MII_RXD_1, DA850_MII_RXD_0, DA850_MDIO_CLK,
1020 DA850_MDIO_D,
1021 -1
1022};
1023
1024static const short da850_evm_rmii_pins[] = {
1025 DA850_RMII_TXD_0, DA850_RMII_TXD_1, DA850_RMII_TXEN,
1026 DA850_RMII_CRS_DV, DA850_RMII_RXD_0, DA850_RMII_RXD_1,
1027 DA850_RMII_RXER, DA850_RMII_MHZ_50_CLK, DA850_MDIO_CLK,
1028 DA850_MDIO_D,
1029 -1
1030};
1031
1032static int __init da850_evm_config_emac(void)
1033{
1034 void __iomem *cfg_chip3_base;
1035 int ret;
1036 u32 val;
1037 struct davinci_soc_info *soc_info = &davinci_soc_info;
1038 u8 rmii_en = soc_info->emac_pdata->rmii_en;
1039
1040 if (!machine_is_davinci_da850_evm())
1041 return 0;
1042
1043 cfg_chip3_base = DA8XX_SYSCFG0_VIRT(DA8XX_CFGCHIP3_REG);
1044
1045 val = __raw_readl(cfg_chip3_base);
1046
1047 if (rmii_en) {
1048 val |= BIT(8);
1049 ret = davinci_cfg_reg_list(da850_evm_rmii_pins);
1050 pr_info("EMAC: RMII PHY configured, MII PHY will not be"
1051 " functional\n");
1052 } else {
1053 val &= ~BIT(8);
1054 ret = davinci_cfg_reg_list(da850_evm_mii_pins);
1055 pr_info("EMAC: MII PHY configured, RMII PHY will not be"
1056 " functional\n");
1057 }
1058
1059 if (ret)
1060 pr_warn("%s: CPGMAC/RMII mux setup failed: %d\n",
1061 __func__, ret);
1062
1063
1064 __raw_writel(val, cfg_chip3_base);
1065
1066 ret = davinci_cfg_reg(DA850_GPIO2_6);
1067 if (ret)
1068 pr_warn("%s:GPIO(2,6) mux setup failed\n", __func__);
1069
1070 ret = gpio_request(DA850_MII_MDIO_CLKEN_PIN, "mdio_clk_en");
1071 if (ret) {
1072 pr_warn("Cannot open GPIO %d\n", DA850_MII_MDIO_CLKEN_PIN);
1073 return ret;
1074 }
1075
1076
1077 gpio_direction_output(DA850_MII_MDIO_CLKEN_PIN, rmii_en);
1078
1079 soc_info->emac_pdata->phy_id = DA850_EVM_PHY_ID;
1080
1081 ret = da8xx_register_emac();
1082 if (ret)
1083 pr_warn("%s: EMAC registration failed: %d\n", __func__, ret);
1084
1085 return 0;
1086}
1087device_initcall(da850_evm_config_emac);
1088
1089
1090
1091
1092
1093
1094static const s16 da850_dma0_rsv_chans[][2] = {
1095
1096 { 8, 6},
1097 {24, 4},
1098 {30, 2},
1099 {-1, -1}
1100};
1101
1102static const s16 da850_dma0_rsv_slots[][2] = {
1103
1104 { 8, 6},
1105 {24, 4},
1106 {30, 50},
1107 {-1, -1}
1108};
1109
1110static const s16 da850_dma1_rsv_chans[][2] = {
1111
1112 { 0, 28},
1113 {30, 2},
1114 {-1, -1}
1115};
1116
1117static const s16 da850_dma1_rsv_slots[][2] = {
1118
1119 { 0, 28},
1120 {30, 90},
1121 {-1, -1}
1122};
1123
1124static struct edma_rsv_info da850_edma_cc0_rsv = {
1125 .rsv_chans = da850_dma0_rsv_chans,
1126 .rsv_slots = da850_dma0_rsv_slots,
1127};
1128
1129static struct edma_rsv_info da850_edma_cc1_rsv = {
1130 .rsv_chans = da850_dma1_rsv_chans,
1131 .rsv_slots = da850_dma1_rsv_slots,
1132};
1133
1134static struct edma_rsv_info *da850_edma_rsv[2] = {
1135 &da850_edma_cc0_rsv,
1136 &da850_edma_cc1_rsv,
1137};
1138
1139#ifdef CONFIG_CPU_FREQ
1140static __init int da850_evm_init_cpufreq(void)
1141{
1142 switch (system_rev & 0xF) {
1143 case 3:
1144 da850_max_speed = 456000;
1145 break;
1146 case 2:
1147 da850_max_speed = 408000;
1148 break;
1149 case 1:
1150 da850_max_speed = 372000;
1151 break;
1152 }
1153
1154 return da850_register_cpufreq("pll0_sysclk3");
1155}
1156#else
1157static __init int da850_evm_init_cpufreq(void) { return 0; }
1158#endif
1159
1160#if defined(CONFIG_DA850_UI_SD_VIDEO_PORT)
1161
1162#define TVP5147_CH0 "tvp514x-0"
1163#define TVP5147_CH1 "tvp514x-1"
1164
1165
1166static struct tvp514x_platform_data tvp5146_pdata = {
1167 .clk_polarity = 0,
1168 .hs_polarity = 1,
1169 .vs_polarity = 1,
1170};
1171
1172#define TVP514X_STD_ALL (V4L2_STD_NTSC | V4L2_STD_PAL)
1173
1174static struct vpif_input da850_ch0_inputs[] = {
1175 {
1176 .input = {
1177 .index = 0,
1178 .name = "Composite",
1179 .type = V4L2_INPUT_TYPE_CAMERA,
1180 .capabilities = V4L2_IN_CAP_STD,
1181 .std = TVP514X_STD_ALL,
1182 },
1183 .input_route = INPUT_CVBS_VI2B,
1184 .output_route = OUTPUT_10BIT_422_EMBEDDED_SYNC,
1185 .subdev_name = TVP5147_CH0,
1186 },
1187};
1188
1189static struct vpif_input da850_ch1_inputs[] = {
1190 {
1191 .input = {
1192 .index = 0,
1193 .name = "S-Video",
1194 .type = V4L2_INPUT_TYPE_CAMERA,
1195 .capabilities = V4L2_IN_CAP_STD,
1196 .std = TVP514X_STD_ALL,
1197 },
1198 .input_route = INPUT_SVIDEO_VI2C_VI1C,
1199 .output_route = OUTPUT_10BIT_422_EMBEDDED_SYNC,
1200 .subdev_name = TVP5147_CH1,
1201 },
1202};
1203
1204static struct vpif_subdev_info da850_vpif_capture_sdev_info[] = {
1205 {
1206 .name = TVP5147_CH0,
1207 .board_info = {
1208 I2C_BOARD_INFO("tvp5146", 0x5d),
1209 .platform_data = &tvp5146_pdata,
1210 },
1211 },
1212 {
1213 .name = TVP5147_CH1,
1214 .board_info = {
1215 I2C_BOARD_INFO("tvp5146", 0x5c),
1216 .platform_data = &tvp5146_pdata,
1217 },
1218 },
1219};
1220
1221static struct vpif_capture_config da850_vpif_capture_config = {
1222 .subdev_info = da850_vpif_capture_sdev_info,
1223 .subdev_count = ARRAY_SIZE(da850_vpif_capture_sdev_info),
1224 .i2c_adapter_id = 1,
1225 .chan_config[0] = {
1226 .inputs = da850_ch0_inputs,
1227 .input_count = ARRAY_SIZE(da850_ch0_inputs),
1228 .vpif_if = {
1229 .if_type = VPIF_IF_BT656,
1230 .hd_pol = 1,
1231 .vd_pol = 1,
1232 .fid_pol = 0,
1233 },
1234 },
1235 .chan_config[1] = {
1236 .inputs = da850_ch1_inputs,
1237 .input_count = ARRAY_SIZE(da850_ch1_inputs),
1238 .vpif_if = {
1239 .if_type = VPIF_IF_BT656,
1240 .hd_pol = 1,
1241 .vd_pol = 1,
1242 .fid_pol = 0,
1243 },
1244 },
1245 .card_name = "DA850/OMAP-L138 Video Capture",
1246};
1247
1248
1249
1250static struct adv7343_platform_data adv7343_pdata = {
1251 .mode_config = {
1252 .dac = { 1, 1, 1 },
1253 },
1254 .sd_config = {
1255 .sd_dac_out = { 1 },
1256 },
1257};
1258
1259static struct vpif_subdev_info da850_vpif_subdev[] = {
1260 {
1261 .name = "adv7343",
1262 .board_info = {
1263 I2C_BOARD_INFO("adv7343", 0x2a),
1264 .platform_data = &adv7343_pdata,
1265 },
1266 },
1267};
1268
1269static const struct vpif_output da850_ch0_outputs[] = {
1270 {
1271 .output = {
1272 .index = 0,
1273 .name = "Composite",
1274 .type = V4L2_OUTPUT_TYPE_ANALOG,
1275 .capabilities = V4L2_OUT_CAP_STD,
1276 .std = V4L2_STD_ALL,
1277 },
1278 .subdev_name = "adv7343",
1279 .output_route = ADV7343_COMPOSITE_ID,
1280 },
1281 {
1282 .output = {
1283 .index = 1,
1284 .name = "S-Video",
1285 .type = V4L2_OUTPUT_TYPE_ANALOG,
1286 .capabilities = V4L2_OUT_CAP_STD,
1287 .std = V4L2_STD_ALL,
1288 },
1289 .subdev_name = "adv7343",
1290 .output_route = ADV7343_SVIDEO_ID,
1291 },
1292};
1293
1294static struct vpif_display_config da850_vpif_display_config = {
1295 .subdevinfo = da850_vpif_subdev,
1296 .subdev_count = ARRAY_SIZE(da850_vpif_subdev),
1297 .chan_config[0] = {
1298 .outputs = da850_ch0_outputs,
1299 .output_count = ARRAY_SIZE(da850_ch0_outputs),
1300 },
1301 .card_name = "DA850/OMAP-L138 Video Display",
1302 .i2c_adapter_id = 1,
1303};
1304
1305static __init void da850_vpif_init(void)
1306{
1307 int ret;
1308
1309 ret = da850_register_vpif();
1310 if (ret)
1311 pr_warn("da850_evm_init: VPIF setup failed: %d\n", ret);
1312
1313 ret = davinci_cfg_reg_list(da850_vpif_capture_pins);
1314 if (ret)
1315 pr_warn("da850_evm_init: VPIF capture mux setup failed: %d\n",
1316 ret);
1317
1318 ret = da850_register_vpif_capture(&da850_vpif_capture_config);
1319 if (ret)
1320 pr_warn("da850_evm_init: VPIF capture setup failed: %d\n", ret);
1321
1322 ret = davinci_cfg_reg_list(da850_vpif_display_pins);
1323 if (ret)
1324 pr_warn("da850_evm_init: VPIF display mux setup failed: %d\n",
1325 ret);
1326
1327 ret = da850_register_vpif_display(&da850_vpif_display_config);
1328 if (ret)
1329 pr_warn("da850_evm_init: VPIF display setup failed: %d\n", ret);
1330}
1331
1332#else
1333static __init void da850_vpif_init(void) {}
1334#endif
1335
1336#define DA850EVM_SATA_REFCLKPN_RATE (100 * 1000 * 1000)
1337
1338static __init void da850_evm_init(void)
1339{
1340 int ret;
1341
1342 ret = da850_register_gpio();
1343 if (ret)
1344 pr_warn("%s: GPIO init failed: %d\n", __func__, ret);
1345
1346 regulator_register_fixed(0, fixed_supplies, ARRAY_SIZE(fixed_supplies));
1347
1348 ret = pmic_tps65070_init();
1349 if (ret)
1350 pr_warn("%s: TPS65070 PMIC init failed: %d\n", __func__, ret);
1351
1352 ret = da850_register_edma(da850_edma_rsv);
1353 if (ret)
1354 pr_warn("%s: EDMA registration failed: %d\n", __func__, ret);
1355
1356 ret = davinci_cfg_reg_list(da850_i2c0_pins);
1357 if (ret)
1358 pr_warn("%s: I2C0 mux setup failed: %d\n", __func__, ret);
1359
1360 ret = da8xx_register_i2c(0, &da850_evm_i2c_0_pdata);
1361 if (ret)
1362 pr_warn("%s: I2C0 registration failed: %d\n", __func__, ret);
1363
1364
1365 ret = da8xx_register_watchdog();
1366 if (ret)
1367 pr_warn("%s: watchdog registration failed: %d\n",
1368 __func__, ret);
1369
1370 if (HAS_MMC) {
1371 ret = davinci_cfg_reg_list(da850_evm_mmcsd0_pins);
1372 if (ret)
1373 pr_warn("%s: MMCSD0 mux setup failed: %d\n",
1374 __func__, ret);
1375
1376 gpiod_add_lookup_table(&mmc_gpios_table);
1377
1378 ret = da8xx_register_mmcsd0(&da850_mmc_config);
1379 if (ret)
1380 pr_warn("%s: MMCSD0 registration failed: %d\n",
1381 __func__, ret);
1382 }
1383
1384 davinci_serial_init(da8xx_serial_device);
1385
1386 i2c_register_board_info(1, da850_evm_i2c_devices,
1387 ARRAY_SIZE(da850_evm_i2c_devices));
1388
1389
1390
1391
1392
1393
1394 __raw_writel(0, IO_ADDRESS(DA8XX_UART1_BASE) + 0x30);
1395 __raw_writel(0, IO_ADDRESS(DA8XX_UART0_BASE) + 0x30);
1396
1397 ret = davinci_cfg_reg_list(da850_evm_mcasp_pins);
1398 if (ret)
1399 pr_warn("%s: McASP mux setup failed: %d\n", __func__, ret);
1400
1401 da850_evm_snd_data.sram_pool = sram_get_gen_pool();
1402 da8xx_register_mcasp(0, &da850_evm_snd_data);
1403
1404 ret = davinci_cfg_reg_list(da850_lcdcntl_pins);
1405 if (ret)
1406 pr_warn("%s: LCDC mux setup failed: %d\n", __func__, ret);
1407
1408 ret = da8xx_register_uio_pruss();
1409 if (ret)
1410 pr_warn("da850_evm_init: pruss initialization failed: %d\n",
1411 ret);
1412
1413
1414 ret = davinci_cfg_reg_list(da850_evm_lcdc_pins);
1415 if (ret)
1416 pr_warn("%s: EVM specific LCD mux setup failed: %d\n",
1417 __func__, ret);
1418
1419 ret = da850_lcd_hw_init();
1420 if (ret)
1421 pr_warn("%s: LCD initialization failed: %d\n", __func__, ret);
1422
1423 sharp_lk043t1dg01_pdata.panel_power_ctrl = da850_panel_power_ctrl,
1424 ret = da8xx_register_lcdc(&sharp_lk043t1dg01_pdata);
1425 if (ret)
1426 pr_warn("%s: LCDC registration failed: %d\n", __func__, ret);
1427
1428 ret = da8xx_register_rtc();
1429 if (ret)
1430 pr_warn("%s: RTC setup failed: %d\n", __func__, ret);
1431
1432 ret = da850_evm_init_cpufreq();
1433 if (ret)
1434 pr_warn("%s: cpufreq registration failed: %d\n", __func__, ret);
1435
1436 ret = da8xx_register_cpuidle();
1437 if (ret)
1438 pr_warn("%s: cpuidle registration failed: %d\n", __func__, ret);
1439
1440 davinci_pm_init();
1441 da850_vpif_init();
1442
1443 ret = spi_register_board_info(da850evm_spi_info,
1444 ARRAY_SIZE(da850evm_spi_info));
1445 if (ret)
1446 pr_warn("%s: spi info registration failed: %d\n", __func__,
1447 ret);
1448
1449 ret = da8xx_register_spi_bus(1, ARRAY_SIZE(da850evm_spi_info));
1450 if (ret)
1451 pr_warn("%s: SPI 1 registration failed: %d\n", __func__, ret);
1452
1453 ret = da850_register_sata(DA850EVM_SATA_REFCLKPN_RATE);
1454 if (ret)
1455 pr_warn("%s: SATA registration failed: %d\n", __func__, ret);
1456
1457 da850_evm_setup_mac_addr();
1458
1459 ret = da8xx_register_rproc();
1460 if (ret)
1461 pr_warn("%s: dsp/rproc registration failed: %d\n",
1462 __func__, ret);
1463}
1464
1465#ifdef CONFIG_SERIAL_8250_CONSOLE
1466static int __init da850_evm_console_init(void)
1467{
1468 if (!machine_is_davinci_da850_evm())
1469 return 0;
1470
1471 return add_preferred_console("ttyS", 2, "115200");
1472}
1473console_initcall(da850_evm_console_init);
1474#endif
1475
1476static void __init da850_evm_map_io(void)
1477{
1478 da850_init();
1479}
1480
1481MACHINE_START(DAVINCI_DA850_EVM, "DaVinci DA850/OMAP-L138/AM18x EVM")
1482 .atag_offset = 0x100,
1483 .map_io = da850_evm_map_io,
1484 .init_irq = cp_intc_init,
1485 .init_time = da850_init_time,
1486 .init_machine = da850_evm_init,
1487 .init_late = davinci_init_late,
1488 .dma_zone_size = SZ_128M,
1489 .reserve = da8xx_rproc_reserve_cma,
1490MACHINE_END
1491
