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