arch/arm/mach-davinci/board-da850-evm.c

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