arch/arm/mach-omap2/pdata-quirks.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Legacy platform_data quirks
   4  *
   5  * Copyright (C) 2013 Texas Instruments
   6  */
   7 #include <linux/clk.h>
   8 #include <linux/davinci_emac.h>
   9 #include <linux/gpio.h>
  10 #include <linux/init.h>
  11 #include <linux/kernel.h>
  12 #include <linux/of_platform.h>
  13 #include <linux/ti_wilink_st.h>
  14 #include <linux/wl12xx.h>
  15 #include <linux/mmc/card.h>
  16 #include <linux/mmc/host.h>
  17 #include <linux/power/smartreflex.h>
  18 #include <linux/regulator/machine.h>
  19 #include <linux/regulator/fixed.h>
  20
  21 #include <linux/platform_data/pinctrl-single.h>
  22 #include <linux/platform_data/hsmmc-omap.h>
  23 #include <linux/platform_data/iommu-omap.h>
  24 #include <linux/platform_data/ti-sysc.h>
  25 #include <linux/platform_data/wkup_m3.h>
  26 #include <linux/platform_data/asoc-ti-mcbsp.h>
  27
  28 #include "clockdomain.h"
  29 #include "common.h"
  30 #include "common-board-devices.h"
  31 #include "control.h"
  32 #include "omap_device.h"
  33 #include "omap-secure.h"
  34 #include "soc.h"
  35 #include "hsmmc.h"
  36
  37 static struct omap_hsmmc_platform_data __maybe_unused mmc_pdata[2];
  38
  39 struct pdata_init {
  40         const char *compatible;
  41         void (*fn)(void);
  42 };
  43
  44 static struct of_dev_auxdata omap_auxdata_lookup[];
  45 static struct twl4030_gpio_platform_data twl_gpio_auxdata;
  46
  47 #if IS_ENABLED(CONFIG_OMAP_IOMMU)
  48 int omap_iommu_set_pwrdm_constraint(struct platform_device *pdev, bool request,
  49                                     u8 *pwrst);
  50 #else
  51 static inline int omap_iommu_set_pwrdm_constraint(struct platform_device *pdev,
  52                                                   bool request, u8 *pwrst)
  53 {
  54         return 0;
  55 }
  56 #endif
  57
  58 #ifdef CONFIG_MACH_NOKIA_N8X0
  59 static void __init omap2420_n8x0_legacy_init(void)
  60 {
  61         omap_auxdata_lookup[0].platform_data = n8x0_legacy_init();
  62 }
  63 #else
  64 #define omap2420_n8x0_legacy_init       NULL
  65 #endif
  66
  67 #ifdef CONFIG_ARCH_OMAP3
  68 /*
  69  * Configures GPIOs 126, 127 and 129 to 1.8V mode instead of 3.0V
  70  * mode for MMC1 in case bootloader did not configure things.
  71  * Note that if the pins are used for MMC1, pbias-regulator
  72  * manages the IO voltage.
  73  */
  74 static void __init omap3_gpio126_127_129(void)
  75 {
  76         u32 reg;
  77
  78         reg = omap_ctrl_readl(OMAP343X_CONTROL_PBIAS_LITE);
  79         reg &= ~OMAP343X_PBIASLITEVMODE1;
  80         reg |= OMAP343X_PBIASLITEPWRDNZ1;
  81         omap_ctrl_writel(reg, OMAP343X_CONTROL_PBIAS_LITE);
  82         if (cpu_is_omap3630()) {
  83                 reg = omap_ctrl_readl(OMAP34XX_CONTROL_WKUP_CTRL);
  84                 reg |= OMAP36XX_GPIO_IO_PWRDNZ;
  85                 omap_ctrl_writel(reg, OMAP34XX_CONTROL_WKUP_CTRL);
  86         }
  87 }
  88
  89 static void __init hsmmc2_internal_input_clk(void)
  90 {
  91         u32 reg;
  92
  93         reg = omap_ctrl_readl(OMAP343X_CONTROL_DEVCONF1);
  94         reg |= OMAP2_MMCSDIO2ADPCLKISEL;
  95         omap_ctrl_writel(reg, OMAP343X_CONTROL_DEVCONF1);
  96 }
  97
  98 static struct iommu_platform_data omap3_iommu_pdata = {
  99         .reset_name = "mmu",
 100         .assert_reset = omap_device_assert_hardreset,
 101         .deassert_reset = omap_device_deassert_hardreset,
 102         .device_enable = omap_device_enable,
 103         .device_idle = omap_device_idle,
 104 };
 105
 106 static struct iommu_platform_data omap3_iommu_isp_pdata = {
 107         .device_enable = omap_device_enable,
 108         .device_idle = omap_device_idle,
 109 };
 110
 111 static int omap3_sbc_t3730_twl_callback(struct device *dev,
 112                                            unsigned gpio,
 113                                            unsigned ngpio)
 114 {
 115         int res;
 116
 117         res = gpio_request_one(gpio + 2, GPIOF_OUT_INIT_HIGH,
 118                                "wlan pwr");
 119         if (res)
 120                 return res;
 121
 122         gpio_export(gpio, 0);
 123
 124         return 0;
 125 }
 126
 127 static void __init omap3_sbc_t3x_usb_hub_init(int gpio, char *hub_name)
 128 {
 129         int err = gpio_request_one(gpio, GPIOF_OUT_INIT_LOW, hub_name);
 130
 131         if (err) {
 132                 pr_err("SBC-T3x: %s reset gpio request failed: %d\n",
 133                         hub_name, err);
 134                 return;
 135         }
 136
 137         gpio_export(gpio, 0);
 138
 139         udelay(10);
 140         gpio_set_value(gpio, 1);
 141         msleep(1);
 142 }
 143
 144 static void __init omap3_sbc_t3730_twl_init(void)
 145 {
 146         twl_gpio_auxdata.setup = omap3_sbc_t3730_twl_callback;
 147 }
 148
 149 static void __init omap3_sbc_t3730_legacy_init(void)
 150 {
 151         omap3_sbc_t3x_usb_hub_init(167, "sb-t35 usb hub");
 152 }
 153
 154 static void __init omap3_sbc_t3530_legacy_init(void)
 155 {
 156         omap3_sbc_t3x_usb_hub_init(167, "sb-t35 usb hub");
 157 }
 158
 159 static struct ti_st_plat_data wilink_pdata = {
 160         .nshutdown_gpio = 137,
 161         .dev_name = "/dev/ttyO1",
 162         .flow_cntrl = 1,
 163         .baud_rate = 300000,
 164 };
 165
 166 static struct platform_device wl18xx_device = {
 167         .name   = "kim",
 168         .id     = -1,
 169         .dev    = {
 170                 .platform_data = &wilink_pdata,
 171         }
 172 };
 173
 174 static struct ti_st_plat_data wilink7_pdata = {
 175         .nshutdown_gpio = 162,
 176         .dev_name = "/dev/ttyO1",
 177         .flow_cntrl = 1,
 178         .baud_rate = 3000000,
 179 };
 180
 181 static struct platform_device wl128x_device = {
 182         .name   = "kim",
 183         .id     = -1,
 184         .dev    = {
 185                 .platform_data = &wilink7_pdata,
 186         }
 187 };
 188
 189 static struct platform_device btwilink_device = {
 190         .name   = "btwilink",
 191         .id     = -1,
 192 };
 193
 194 static void __init omap3_igep0020_rev_f_legacy_init(void)
 195 {
 196         platform_device_register(&wl18xx_device);
 197         platform_device_register(&btwilink_device);
 198 }
 199
 200 static void __init omap3_igep0030_rev_g_legacy_init(void)
 201 {
 202         platform_device_register(&wl18xx_device);
 203         platform_device_register(&btwilink_device);
 204 }
 205
 206 static void __init omap3_evm_legacy_init(void)
 207 {
 208         hsmmc2_internal_input_clk();
 209 }
 210
 211 static void am35xx_enable_emac_int(void)
 212 {
 213         u32 v;
 214
 215         v = omap_ctrl_readl(AM35XX_CONTROL_LVL_INTR_CLEAR);
 216         v |= (AM35XX_CPGMAC_C0_RX_PULSE_CLR | AM35XX_CPGMAC_C0_TX_PULSE_CLR |
 217               AM35XX_CPGMAC_C0_MISC_PULSE_CLR | AM35XX_CPGMAC_C0_RX_THRESH_CLR);
 218         omap_ctrl_writel(v, AM35XX_CONTROL_LVL_INTR_CLEAR);
 219         omap_ctrl_readl(AM35XX_CONTROL_LVL_INTR_CLEAR); /* OCP barrier */
 220 }
 221
 222 static void am35xx_disable_emac_int(void)
 223 {
 224         u32 v;
 225
 226         v = omap_ctrl_readl(AM35XX_CONTROL_LVL_INTR_CLEAR);
 227         v |= (AM35XX_CPGMAC_C0_RX_PULSE_CLR | AM35XX_CPGMAC_C0_TX_PULSE_CLR);
 228         omap_ctrl_writel(v, AM35XX_CONTROL_LVL_INTR_CLEAR);
 229         omap_ctrl_readl(AM35XX_CONTROL_LVL_INTR_CLEAR); /* OCP barrier */
 230 }
 231
 232 static struct emac_platform_data am35xx_emac_pdata = {
 233         .interrupt_enable       = am35xx_enable_emac_int,
 234         .interrupt_disable      = am35xx_disable_emac_int,
 235 };
 236
 237 static void __init am35xx_emac_reset(void)
 238 {
 239         u32 v;
 240
 241         v = omap_ctrl_readl(AM35XX_CONTROL_IP_SW_RESET);
 242         v &= ~AM35XX_CPGMACSS_SW_RST;
 243         omap_ctrl_writel(v, AM35XX_CONTROL_IP_SW_RESET);
 244         omap_ctrl_readl(AM35XX_CONTROL_IP_SW_RESET); /* OCP barrier */
 245 }
 246
 247 static struct gpio cm_t3517_wlan_gpios[] __initdata = {
 248         { 56,   GPIOF_OUT_INIT_HIGH,    "wlan pwr" },
 249         { 4,    GPIOF_OUT_INIT_HIGH,    "xcvr noe" },
 250 };
 251
 252 static void __init omap3_sbc_t3517_wifi_init(void)
 253 {
 254         int err = gpio_request_array(cm_t3517_wlan_gpios,
 255                                 ARRAY_SIZE(cm_t3517_wlan_gpios));
 256         if (err) {
 257                 pr_err("SBC-T3517: wl12xx gpios request failed: %d\n", err);
 258                 return;
 259         }
 260
 261         gpio_export(cm_t3517_wlan_gpios[0].gpio, 0);
 262         gpio_export(cm_t3517_wlan_gpios[1].gpio, 0);
 263
 264         msleep(100);
 265         gpio_set_value(cm_t3517_wlan_gpios[1].gpio, 0);
 266 }
 267
 268 static void __init omap3_sbc_t3517_legacy_init(void)
 269 {
 270         omap3_sbc_t3x_usb_hub_init(152, "cm-t3517 usb hub");
 271         omap3_sbc_t3x_usb_hub_init(98, "sb-t35 usb hub");
 272         am35xx_emac_reset();
 273         hsmmc2_internal_input_clk();
 274         omap3_sbc_t3517_wifi_init();
 275 }
 276
 277 static void __init am3517_evm_legacy_init(void)
 278 {
 279         am35xx_emac_reset();
 280 }
 281
 282 static void __init nokia_n900_legacy_init(void)
 283 {
 284         hsmmc2_internal_input_clk();
 285         mmc_pdata[0].name = "external";
 286         mmc_pdata[1].name = "internal";
 287
 288         if (omap_type() == OMAP2_DEVICE_TYPE_SEC) {
 289                 if (IS_ENABLED(CONFIG_ARM_ERRATA_430973)) {
 290                         pr_info("RX-51: Enabling ARM errata 430973 workaround\n");
 291                         /* set IBE to 1 */
 292                         rx51_secure_update_aux_cr(BIT(6), 0);
 293                 } else {
 294                         pr_warn("RX-51: Not enabling ARM errata 430973 workaround\n");
 295                         pr_warn("Thumb binaries may crash randomly without this workaround\n");
 296                 }
 297         }
 298 }
 299
 300 static void __init omap3_tao3530_legacy_init(void)
 301 {
 302         hsmmc2_internal_input_clk();
 303 }
 304
 305 static void __init omap3_logicpd_torpedo_init(void)
 306 {
 307         omap3_gpio126_127_129();
 308         platform_device_register(&wl128x_device);
 309         platform_device_register(&btwilink_device);
 310 }
 311
 312 /* omap3pandora legacy devices */
 313
 314 static struct platform_device pandora_backlight = {
 315         .name   = "pandora-backlight",
 316         .id     = -1,
 317 };
 318
 319 static void __init omap3_pandora_legacy_init(void)
 320 {
 321         platform_device_register(&pandora_backlight);
 322 }
 323 #endif /* CONFIG_ARCH_OMAP3 */
 324
 325 #if defined(CONFIG_SOC_AM33XX) || defined(CONFIG_SOC_AM43XX)
 326 static struct wkup_m3_platform_data wkup_m3_data = {
 327         .reset_name = "wkup_m3",
 328         .assert_reset = omap_device_assert_hardreset,
 329         .deassert_reset = omap_device_deassert_hardreset,
 330 };
 331 #endif
 332
 333 #ifdef CONFIG_SOC_OMAP5
 334 static void __init omap5_uevm_legacy_init(void)
 335 {
 336 }
 337 #endif
 338
 339 #ifdef CONFIG_SOC_DRA7XX
 340 static struct iommu_platform_data dra7_ipu1_dsp_iommu_pdata = {
 341         .set_pwrdm_constraint = omap_iommu_set_pwrdm_constraint,
 342 };
 343
 344 static struct omap_hsmmc_platform_data dra7_hsmmc_data_mmc1;
 345 static struct omap_hsmmc_platform_data dra7_hsmmc_data_mmc2;
 346 static struct omap_hsmmc_platform_data dra7_hsmmc_data_mmc3;
 347
 348 static void __init dra7x_evm_mmc_quirk(void)
 349 {
 350         if (omap_rev() == DRA752_REV_ES1_1 || omap_rev() == DRA752_REV_ES1_0) {
 351                 dra7_hsmmc_data_mmc1.version = "rev11";
 352                 dra7_hsmmc_data_mmc1.max_freq = 96000000;
 353
 354                 dra7_hsmmc_data_mmc2.version = "rev11";
 355                 dra7_hsmmc_data_mmc2.max_freq = 48000000;
 356
 357                 dra7_hsmmc_data_mmc3.version = "rev11";
 358                 dra7_hsmmc_data_mmc3.max_freq = 48000000;
 359         }
 360 }
 361 #endif
 362
 363 static struct clockdomain *ti_sysc_find_one_clockdomain(struct clk *clk)
 364 {
 365         struct clk_hw *hw = __clk_get_hw(clk);
 366         struct clockdomain *clkdm = NULL;
 367         struct clk_hw_omap *hwclk;
 368
 369         hwclk = to_clk_hw_omap(hw);
 370         if (!omap2_clk_is_hw_omap(hw))
 371                 return NULL;
 372
 373         if (hwclk && hwclk->clkdm_name)
 374                 clkdm = clkdm_lookup(hwclk->clkdm_name);
 375
 376         return clkdm;
 377 }
 378
 379 /**
 380  * ti_sysc_clkdm_init - find clockdomain based on clock
 381  * @fck: device functional clock
 382  * @ick: device interface clock
 383  * @dev: struct device
 384  *
 385  * Populate clockdomain based on clock. It is needed for
 386  * clkdm_deny_idle() and clkdm_allow_idle() for blocking clockdomain
 387  * clockdomain idle during reset, enable and idle.
 388  *
 389  * Note that we assume interconnect driver manages the clocks
 390  * and do not need to populate oh->_clk for dynamically
 391  * allocated modules.
 392  */
 393 static int ti_sysc_clkdm_init(struct device *dev,
 394                               struct clk *fck, struct clk *ick,
 395                               struct ti_sysc_cookie *cookie)
 396 {
 397         if (!IS_ERR(fck))
 398                 cookie->clkdm = ti_sysc_find_one_clockdomain(fck);
 399         if (cookie->clkdm)
 400                 return 0;
 401         if (!IS_ERR(ick))
 402                 cookie->clkdm = ti_sysc_find_one_clockdomain(ick);
 403         if (cookie->clkdm)
 404                 return 0;
 405
 406         return -ENODEV;
 407 }
 408
 409 static void ti_sysc_clkdm_deny_idle(struct device *dev,
 410                                     const struct ti_sysc_cookie *cookie)
 411 {
 412         if (cookie->clkdm)
 413                 clkdm_deny_idle(cookie->clkdm);
 414 }
 415
 416 static void ti_sysc_clkdm_allow_idle(struct device *dev,
 417                                      const struct ti_sysc_cookie *cookie)
 418 {
 419         if (cookie->clkdm)
 420                 clkdm_allow_idle(cookie->clkdm);
 421 }
 422
 423 static int ti_sysc_enable_module(struct device *dev,
 424                                  const struct ti_sysc_cookie *cookie)
 425 {
 426         if (!cookie->data)
 427                 return -EINVAL;
 428
 429         return omap_hwmod_enable(cookie->data);
 430 }
 431
 432 static int ti_sysc_idle_module(struct device *dev,
 433                                const struct ti_sysc_cookie *cookie)
 434 {
 435         if (!cookie->data)
 436                 return -EINVAL;
 437
 438         return omap_hwmod_idle(cookie->data);
 439 }
 440
 441 static int ti_sysc_shutdown_module(struct device *dev,
 442                                    const struct ti_sysc_cookie *cookie)
 443 {
 444         if (!cookie->data)
 445                 return -EINVAL;
 446
 447         return omap_hwmod_shutdown(cookie->data);
 448 }
 449
 450 static struct of_dev_auxdata omap_auxdata_lookup[];
 451
 452 static struct ti_sysc_platform_data ti_sysc_pdata = {
 453         .auxdata = omap_auxdata_lookup,
 454         .init_clockdomain = ti_sysc_clkdm_init,
 455         .clkdm_deny_idle = ti_sysc_clkdm_deny_idle,
 456         .clkdm_allow_idle = ti_sysc_clkdm_allow_idle,
 457         .init_module = omap_hwmod_init_module,
 458         .enable_module = ti_sysc_enable_module,
 459         .idle_module = ti_sysc_idle_module,
 460         .shutdown_module = ti_sysc_shutdown_module,
 461 };
 462
 463 static struct pcs_pdata pcs_pdata;
 464
 465 void omap_pcs_legacy_init(int irq, void (*rearm)(void))
 466 {
 467         pcs_pdata.irq = irq;
 468         pcs_pdata.rearm = rearm;
 469 }
 470
 471 /*
 472  * GPIOs for TWL are initialized by the I2C bus and need custom
 473  * handing until DSS has device tree bindings.
 474  */
 475 void omap_auxdata_legacy_init(struct device *dev)
 476 {
 477         if (dev->platform_data)
 478                 return;
 479
 480         if (strcmp("twl4030-gpio", dev_name(dev)))
 481                 return;
 482
 483         dev->platform_data = &twl_gpio_auxdata;
 484 }
 485
 486 #if IS_ENABLED(CONFIG_SND_SOC_OMAP_MCBSP)
 487 static struct omap_mcbsp_platform_data mcbsp_pdata;
 488 static void __init omap3_mcbsp_init(void)
 489 {
 490         omap3_mcbsp_init_pdata_callback(&mcbsp_pdata);
 491 }
 492 #else
 493 static void __init omap3_mcbsp_init(void) {}
 494 #endif
 495
 496 /*
 497  * Few boards still need auxdata populated before we populate
 498  * the dev entries in of_platform_populate().
 499  */
 500 static struct pdata_init auxdata_quirks[] __initdata = {
 501 #ifdef CONFIG_SOC_OMAP2420
 502         { "nokia,n800", omap2420_n8x0_legacy_init, },
 503         { "nokia,n810", omap2420_n8x0_legacy_init, },
 504         { "nokia,n810-wimax", omap2420_n8x0_legacy_init, },
 505 #endif
 506 #ifdef CONFIG_ARCH_OMAP3
 507         { "compulab,omap3-sbc-t3730", omap3_sbc_t3730_twl_init, },
 508 #endif
 509         { /* sentinel */ },
 510 };
 511
 512 struct omap_sr_data __maybe_unused omap_sr_pdata[OMAP_SR_NR];
 513
 514 static struct of_dev_auxdata omap_auxdata_lookup[] = {
 515 #ifdef CONFIG_MACH_NOKIA_N8X0
 516         OF_DEV_AUXDATA("ti,omap2420-mmc", 0x4809c000, "mmci-omap.0", NULL),
 517         OF_DEV_AUXDATA("menelaus", 0x72, "1-0072", &n8x0_menelaus_platform_data),
 518         OF_DEV_AUXDATA("tlv320aic3x", 0x18, "2-0018", &n810_aic33_data),
 519 #endif
 520 #ifdef CONFIG_ARCH_OMAP3
 521         OF_DEV_AUXDATA("ti,omap2-iommu", 0x5d000000, "5d000000.mmu",
 522                        &omap3_iommu_pdata),
 523         OF_DEV_AUXDATA("ti,omap2-iommu", 0x480bd400, "480bd400.mmu",
 524                        &omap3_iommu_isp_pdata),
 525         OF_DEV_AUXDATA("ti,omap3-smartreflex-core", 0x480cb000,
 526                        "480cb000.smartreflex", &omap_sr_pdata[OMAP_SR_CORE]),
 527         OF_DEV_AUXDATA("ti,omap3-smartreflex-mpu-iva", 0x480c9000,
 528                        "480c9000.smartreflex", &omap_sr_pdata[OMAP_SR_MPU]),
 529         OF_DEV_AUXDATA("ti,omap3-hsmmc", 0x4809c000, "4809c000.mmc", &mmc_pdata[0]),
 530         OF_DEV_AUXDATA("ti,omap3-hsmmc", 0x480b4000, "480b4000.mmc", &mmc_pdata[1]),
 531         /* Only on am3517 */
 532         OF_DEV_AUXDATA("ti,davinci_mdio", 0x5c030000, "davinci_mdio.0", NULL),
 533         OF_DEV_AUXDATA("ti,am3517-emac", 0x5c000000, "davinci_emac.0",
 534                        &am35xx_emac_pdata),
 535         OF_DEV_AUXDATA("nokia,n900-rom-rng", 0, NULL, rx51_secure_rng_call),
 536         /* McBSP modules with sidetone core */
 537 #if IS_ENABLED(CONFIG_SND_SOC_OMAP_MCBSP)
 538         OF_DEV_AUXDATA("ti,omap3-mcbsp", 0x49022000, "49022000.mcbsp", &mcbsp_pdata),
 539         OF_DEV_AUXDATA("ti,omap3-mcbsp", 0x49024000, "49024000.mcbsp", &mcbsp_pdata),
 540 #endif
 541 #endif
 542 #ifdef CONFIG_SOC_AM33XX
 543         OF_DEV_AUXDATA("ti,am3352-wkup-m3", 0x44d00000, "44d00000.wkup_m3",
 544                        &wkup_m3_data),
 545 #endif
 546 #ifdef CONFIG_SOC_AM43XX
 547         OF_DEV_AUXDATA("ti,am4372-wkup-m3", 0x44d00000, "44d00000.wkup_m3",
 548                        &wkup_m3_data),
 549 #endif
 550 #if defined(CONFIG_ARCH_OMAP4) || defined(CONFIG_SOC_OMAP5)
 551         OF_DEV_AUXDATA("ti,omap4-smartreflex-iva", 0x4a0db000,
 552                        "4a0db000.smartreflex", &omap_sr_pdata[OMAP_SR_IVA]),
 553         OF_DEV_AUXDATA("ti,omap4-smartreflex-core", 0x4a0dd000,
 554                        "4a0dd000.smartreflex", &omap_sr_pdata[OMAP_SR_CORE]),
 555         OF_DEV_AUXDATA("ti,omap4-smartreflex-mpu", 0x4a0d9000,
 556                        "4a0d9000.smartreflex", &omap_sr_pdata[OMAP_SR_MPU]),
 557 #endif
 558 #ifdef CONFIG_SOC_DRA7XX
 559         OF_DEV_AUXDATA("ti,dra7-hsmmc", 0x4809c000, "4809c000.mmc",
 560                        &dra7_hsmmc_data_mmc1),
 561         OF_DEV_AUXDATA("ti,dra7-hsmmc", 0x480b4000, "480b4000.mmc",
 562                        &dra7_hsmmc_data_mmc2),
 563         OF_DEV_AUXDATA("ti,dra7-hsmmc", 0x480ad000, "480ad000.mmc",
 564                        &dra7_hsmmc_data_mmc3),
 565         OF_DEV_AUXDATA("ti,dra7-dsp-iommu", 0x40d01000, "40d01000.mmu",
 566                        &dra7_ipu1_dsp_iommu_pdata),
 567         OF_DEV_AUXDATA("ti,dra7-dsp-iommu", 0x41501000, "41501000.mmu",
 568                        &dra7_ipu1_dsp_iommu_pdata),
 569         OF_DEV_AUXDATA("ti,dra7-iommu", 0x58882000, "58882000.mmu",
 570                        &dra7_ipu1_dsp_iommu_pdata),
 571 #endif
 572         /* Common auxdata */
 573         OF_DEV_AUXDATA("ti,sysc", 0, NULL, &ti_sysc_pdata),
 574         OF_DEV_AUXDATA("pinctrl-single", 0, NULL, &pcs_pdata),
 575         { /* sentinel */ },
 576 };
 577
 578 /*
 579  * Few boards still need to initialize some legacy devices with
 580  * platform data until the drivers support device tree.
 581  */
 582 static struct pdata_init pdata_quirks[] __initdata = {
 583 #ifdef CONFIG_ARCH_OMAP3
 584         { "compulab,omap3-sbc-t3517", omap3_sbc_t3517_legacy_init, },
 585         { "compulab,omap3-sbc-t3530", omap3_sbc_t3530_legacy_init, },
 586         { "compulab,omap3-sbc-t3730", omap3_sbc_t3730_legacy_init, },
 587         { "nokia,omap3-n900", nokia_n900_legacy_init, },
 588         { "nokia,omap3-n9", hsmmc2_internal_input_clk, },
 589         { "nokia,omap3-n950", hsmmc2_internal_input_clk, },
 590         { "isee,omap3-igep0020-rev-f", omap3_igep0020_rev_f_legacy_init, },
 591         { "isee,omap3-igep0030-rev-g", omap3_igep0030_rev_g_legacy_init, },
 592         { "logicpd,dm3730-torpedo-devkit", omap3_logicpd_torpedo_init, },
 593         { "ti,omap3-evm-37xx", omap3_evm_legacy_init, },
 594         { "ti,am3517-evm", am3517_evm_legacy_init, },
 595         { "technexion,omap3-tao3530", omap3_tao3530_legacy_init, },
 596         { "openpandora,omap3-pandora-600mhz", omap3_pandora_legacy_init, },
 597         { "openpandora,omap3-pandora-1ghz", omap3_pandora_legacy_init, },
 598 #endif
 599 #ifdef CONFIG_SOC_OMAP5
 600         { "ti,omap5-uevm", omap5_uevm_legacy_init, },
 601 #endif
 602 #ifdef CONFIG_SOC_DRA7XX
 603         { "ti,dra7-evm", dra7x_evm_mmc_quirk, },
 604 #endif
 605         { /* sentinel */ },
 606 };
 607
 608 static void pdata_quirks_check(struct pdata_init *quirks)
 609 {
 610         while (quirks->compatible) {
 611                 if (of_machine_is_compatible(quirks->compatible)) {
 612                         if (quirks->fn)
 613                                 quirks->fn();
 614                 }
 615                 quirks++;
 616         }
 617 }
 618
 619 void __init pdata_quirks_init(const struct of_device_id *omap_dt_match_table)
 620 {
 621         /*
 622          * We still need this for omap2420 and omap3 PM to work, others are
 623          * using drivers/misc/sram.c already.
 624          */
 625         if (of_machine_is_compatible("ti,omap2420") ||
 626             of_machine_is_compatible("ti,omap3"))
 627                 omap_sdrc_init(NULL, NULL);
 628
 629         if (of_machine_is_compatible("ti,omap3"))
 630                 omap3_mcbsp_init();
 631         pdata_quirks_check(auxdata_quirks);
 632         of_platform_populate(NULL, omap_dt_match_table,
 633                              omap_auxdata_lookup, NULL);
 634         pdata_quirks_check(pdata_quirks);
 635 }