1 /* 2 * linux/arch/arm/mach-omap2/devices.c 3 * 4 * OMAP2 platform device setup/initialization 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 */ 11 #include <linux/gpio.h> 12 #include <linux/kernel.h> 13 #include <linux/init.h> 14 #include <linux/platform_device.h> 15 #include <linux/io.h> 16 #include <linux/clk.h> 17 #include <linux/err.h> 18 #include <linux/slab.h> 19 #include <linux/of.h> 20 #include <linux/pinctrl/machine.h> 21 #include <linux/platform_data/omap4-keypad.h> 22 #include <linux/platform_data/omap_ocp2scp.h> 23 24 #include <asm/mach-types.h> 25 #include <asm/mach/map.h> 26 27 #include <linux/omap-dma.h> 28 29 #include "iomap.h" 30 #include "omap_hwmod.h" 31 #include "omap_device.h" 32 #include "omap4-keypad.h" 33 34 #include "soc.h" 35 #include "common.h" 36 #include "mux.h" 37 #include "control.h" 38 #include "devices.h" 39 #include "dma.h" 40 41 #define L3_MODULES_MAX_LEN 12 42 #define L3_MODULES 3 43 44 static int __init omap3_l3_init(void) 45 { 46 struct omap_hwmod *oh; 47 struct platform_device *pdev; 48 char oh_name[L3_MODULES_MAX_LEN]; 49 50 /* 51 * To avoid code running on other OMAPs in 52 * multi-omap builds 53 */ 54 if (!(cpu_is_omap34xx())) 55 return -ENODEV; 56 57 snprintf(oh_name, L3_MODULES_MAX_LEN, "l3_main"); 58 59 oh = omap_hwmod_lookup(oh_name); 60 61 if (!oh) 62 pr_err("could not look up %s\n", oh_name); 63 64 pdev = omap_device_build("omap_l3_smx", 0, oh, NULL, 0, 65 NULL, 0, 0); 66 67 WARN(IS_ERR(pdev), "could not build omap_device for %s\n", oh_name); 68 69 return IS_ERR(pdev) ? PTR_ERR(pdev) : 0; 70 } 71 postcore_initcall(omap3_l3_init); 72 73 static int __init omap4_l3_init(void) 74 { 75 int i; 76 struct omap_hwmod *oh[3]; 77 struct platform_device *pdev; 78 char oh_name[L3_MODULES_MAX_LEN]; 79 80 /* If dtb is there, the devices will be created dynamically */ 81 if (of_have_populated_dt()) 82 return -ENODEV; 83 84 /* 85 * To avoid code running on other OMAPs in 86 * multi-omap builds 87 */ 88 if (!cpu_is_omap44xx() && !soc_is_omap54xx()) 89 return -ENODEV; 90 91 for (i = 0; i < L3_MODULES; i++) { 92 snprintf(oh_name, L3_MODULES_MAX_LEN, "l3_main_%d", i+1); 93 94 oh[i] = omap_hwmod_lookup(oh_name); 95 if (!(oh[i])) 96 pr_err("could not look up %s\n", oh_name); 97 } 98 99 pdev = omap_device_build_ss("omap_l3_noc", 0, oh, 3, NULL, 100 0, NULL, 0, 0); 101 102 WARN(IS_ERR(pdev), "could not build omap_device for %s\n", oh_name); 103 104 return IS_ERR(pdev) ? PTR_ERR(pdev) : 0; 105 } 106 postcore_initcall(omap4_l3_init); 107 108 #if defined(CONFIG_VIDEO_OMAP2) || defined(CONFIG_VIDEO_OMAP2_MODULE) 109 110 static struct resource omap2cam_resources[] = { 111 { 112 .start = OMAP24XX_CAMERA_BASE, 113 .end = OMAP24XX_CAMERA_BASE + 0xfff, 114 .flags = IORESOURCE_MEM, 115 }, 116 { 117 .start = 24 + OMAP_INTC_START, 118 .flags = IORESOURCE_IRQ, 119 } 120 }; 121 122 static struct platform_device omap2cam_device = { 123 .name = "omap24xxcam", 124 .id = -1, 125 .num_resources = ARRAY_SIZE(omap2cam_resources), 126 .resource = omap2cam_resources, 127 }; 128 #endif 129 130 #if defined(CONFIG_IOMMU_API) 131 132 #include <linux/platform_data/iommu-omap.h> 133 134 static struct resource omap3isp_resources[] = { 135 { 136 .start = OMAP3430_ISP_BASE, 137 .end = OMAP3430_ISP_END, 138 .flags = IORESOURCE_MEM, 139 }, 140 { 141 .start = OMAP3430_ISP_CCP2_BASE, 142 .end = OMAP3430_ISP_CCP2_END, 143 .flags = IORESOURCE_MEM, 144 }, 145 { 146 .start = OMAP3430_ISP_CCDC_BASE, 147 .end = OMAP3430_ISP_CCDC_END, 148 .flags = IORESOURCE_MEM, 149 }, 150 { 151 .start = OMAP3430_ISP_HIST_BASE, 152 .end = OMAP3430_ISP_HIST_END, 153 .flags = IORESOURCE_MEM, 154 }, 155 { 156 .start = OMAP3430_ISP_H3A_BASE, 157 .end = OMAP3430_ISP_H3A_END, 158 .flags = IORESOURCE_MEM, 159 }, 160 { 161 .start = OMAP3430_ISP_PREV_BASE, 162 .end = OMAP3430_ISP_PREV_END, 163 .flags = IORESOURCE_MEM, 164 }, 165 { 166 .start = OMAP3430_ISP_RESZ_BASE, 167 .end = OMAP3430_ISP_RESZ_END, 168 .flags = IORESOURCE_MEM, 169 }, 170 { 171 .start = OMAP3430_ISP_SBL_BASE, 172 .end = OMAP3430_ISP_SBL_END, 173 .flags = IORESOURCE_MEM, 174 }, 175 { 176 .start = OMAP3430_ISP_CSI2A_REGS1_BASE, 177 .end = OMAP3430_ISP_CSI2A_REGS1_END, 178 .flags = IORESOURCE_MEM, 179 }, 180 { 181 .start = OMAP3430_ISP_CSIPHY2_BASE, 182 .end = OMAP3430_ISP_CSIPHY2_END, 183 .flags = IORESOURCE_MEM, 184 }, 185 { 186 .start = OMAP3630_ISP_CSI2A_REGS2_BASE, 187 .end = OMAP3630_ISP_CSI2A_REGS2_END, 188 .flags = IORESOURCE_MEM, 189 }, 190 { 191 .start = OMAP3630_ISP_CSI2C_REGS1_BASE, 192 .end = OMAP3630_ISP_CSI2C_REGS1_END, 193 .flags = IORESOURCE_MEM, 194 }, 195 { 196 .start = OMAP3630_ISP_CSIPHY1_BASE, 197 .end = OMAP3630_ISP_CSIPHY1_END, 198 .flags = IORESOURCE_MEM, 199 }, 200 { 201 .start = OMAP3630_ISP_CSI2C_REGS2_BASE, 202 .end = OMAP3630_ISP_CSI2C_REGS2_END, 203 .flags = IORESOURCE_MEM, 204 }, 205 { 206 .start = OMAP343X_CTRL_BASE + OMAP343X_CONTROL_CSIRXFE, 207 .end = OMAP343X_CTRL_BASE + OMAP343X_CONTROL_CSIRXFE + 3, 208 .flags = IORESOURCE_MEM, 209 }, 210 { 211 .start = OMAP343X_CTRL_BASE + OMAP3630_CONTROL_CAMERA_PHY_CTRL, 212 .end = OMAP343X_CTRL_BASE + OMAP3630_CONTROL_CAMERA_PHY_CTRL + 3, 213 .flags = IORESOURCE_MEM, 214 }, 215 { 216 .start = 24 + OMAP_INTC_START, 217 .flags = IORESOURCE_IRQ, 218 } 219 }; 220 221 static struct platform_device omap3isp_device = { 222 .name = "omap3isp", 223 .id = -1, 224 .num_resources = ARRAY_SIZE(omap3isp_resources), 225 .resource = omap3isp_resources, 226 }; 227 228 static struct omap_iommu_arch_data omap3_isp_iommu = { 229 .name = "mmu_isp", 230 }; 231 232 int omap3_init_camera(struct isp_platform_data *pdata) 233 { 234 omap3isp_device.dev.platform_data = pdata; 235 omap3isp_device.dev.archdata.iommu = &omap3_isp_iommu; 236 237 return platform_device_register(&omap3isp_device); 238 } 239 240 #else /* !CONFIG_IOMMU_API */ 241 242 int omap3_init_camera(struct isp_platform_data *pdata) 243 { 244 return 0; 245 } 246 247 #endif 248 249 static inline void omap_init_camera(void) 250 { 251 #if defined(CONFIG_VIDEO_OMAP2) || defined(CONFIG_VIDEO_OMAP2_MODULE) 252 if (cpu_is_omap24xx()) 253 platform_device_register(&omap2cam_device); 254 #endif 255 } 256 257 int __init omap4_keyboard_init(struct omap4_keypad_platform_data 258 *sdp4430_keypad_data, struct omap_board_data *bdata) 259 { 260 struct platform_device *pdev; 261 struct omap_hwmod *oh; 262 struct omap4_keypad_platform_data *keypad_data; 263 unsigned int id = -1; 264 char *oh_name = "kbd"; 265 char *name = "omap4-keypad"; 266 267 oh = omap_hwmod_lookup(oh_name); 268 if (!oh) { 269 pr_err("Could not look up %s\n", oh_name); 270 return -ENODEV; 271 } 272 273 keypad_data = sdp4430_keypad_data; 274 275 pdev = omap_device_build(name, id, oh, keypad_data, 276 sizeof(struct omap4_keypad_platform_data), NULL, 0, 0); 277 278 if (IS_ERR(pdev)) { 279 WARN(1, "Can't build omap_device for %s:%s.\n", 280 name, oh->name); 281 return PTR_ERR(pdev); 282 } 283 oh->mux = omap_hwmod_mux_init(bdata->pads, bdata->pads_cnt); 284 285 return 0; 286 } 287 288 #if defined(CONFIG_OMAP_MBOX_FWK) || defined(CONFIG_OMAP_MBOX_FWK_MODULE) 289 static inline void __init omap_init_mbox(void) 290 { 291 struct omap_hwmod *oh; 292 struct platform_device *pdev; 293 294 oh = omap_hwmod_lookup("mailbox"); 295 if (!oh) { 296 pr_err("%s: unable to find hwmod\n", __func__); 297 return; 298 } 299 300 pdev = omap_device_build("omap-mailbox", -1, oh, NULL, 0, NULL, 0, 0); 301 WARN(IS_ERR(pdev), "%s: could not build device, err %ld\n", 302 __func__, PTR_ERR(pdev)); 303 } 304 #else 305 static inline void omap_init_mbox(void) { } 306 #endif /* CONFIG_OMAP_MBOX_FWK */ 307 308 static inline void omap_init_sti(void) {} 309 310 #if defined(CONFIG_SND_SOC) || defined(CONFIG_SND_SOC_MODULE) 311 312 static struct platform_device omap_pcm = { 313 .name = "omap-pcm-audio", 314 .id = -1, 315 }; 316 317 static void omap_init_audio(void) 318 { 319 platform_device_register(&omap_pcm); 320 } 321 322 #else 323 static inline void omap_init_audio(void) {} 324 #endif 325 326 #if defined(CONFIG_SND_OMAP_SOC_MCPDM) || \ 327 defined(CONFIG_SND_OMAP_SOC_MCPDM_MODULE) 328 329 static void __init omap_init_mcpdm(void) 330 { 331 struct omap_hwmod *oh; 332 struct platform_device *pdev; 333 334 oh = omap_hwmod_lookup("mcpdm"); 335 if (!oh) { 336 printk(KERN_ERR "Could not look up mcpdm hw_mod\n"); 337 return; 338 } 339 340 pdev = omap_device_build("omap-mcpdm", -1, oh, NULL, 0, NULL, 0, 0); 341 WARN(IS_ERR(pdev), "Can't build omap_device for omap-mcpdm.\n"); 342 } 343 #else 344 static inline void omap_init_mcpdm(void) {} 345 #endif 346 347 #if defined(CONFIG_SND_OMAP_SOC_DMIC) || \ 348 defined(CONFIG_SND_OMAP_SOC_DMIC_MODULE) 349 350 static void __init omap_init_dmic(void) 351 { 352 struct omap_hwmod *oh; 353 struct platform_device *pdev; 354 355 oh = omap_hwmod_lookup("dmic"); 356 if (!oh) { 357 pr_err("Could not look up dmic hw_mod\n"); 358 return; 359 } 360 361 pdev = omap_device_build("omap-dmic", -1, oh, NULL, 0, NULL, 0, 0); 362 WARN(IS_ERR(pdev), "Can't build omap_device for omap-dmic.\n"); 363 } 364 #else 365 static inline void omap_init_dmic(void) {} 366 #endif 367 368 #if defined(CONFIG_SND_OMAP_SOC_OMAP_HDMI) || \ 369 defined(CONFIG_SND_OMAP_SOC_OMAP_HDMI_MODULE) 370 371 static struct platform_device omap_hdmi_audio = { 372 .name = "omap-hdmi-audio", 373 .id = -1, 374 }; 375 376 static void __init omap_init_hdmi_audio(void) 377 { 378 struct omap_hwmod *oh; 379 struct platform_device *pdev; 380 381 oh = omap_hwmod_lookup("dss_hdmi"); 382 if (!oh) { 383 printk(KERN_ERR "Could not look up dss_hdmi hw_mod\n"); 384 return; 385 } 386 387 pdev = omap_device_build("omap-hdmi-audio-dai", 388 -1, oh, NULL, 0, NULL, 0, 0); 389 WARN(IS_ERR(pdev), 390 "Can't build omap_device for omap-hdmi-audio-dai.\n"); 391 392 platform_device_register(&omap_hdmi_audio); 393 } 394 #else 395 static inline void omap_init_hdmi_audio(void) {} 396 #endif 397 398 #if defined(CONFIG_SPI_OMAP24XX) || defined(CONFIG_SPI_OMAP24XX_MODULE) 399 400 #include <linux/platform_data/spi-omap2-mcspi.h> 401 402 static int __init omap_mcspi_init(struct omap_hwmod *oh, void *unused) 403 { 404 struct platform_device *pdev; 405 char *name = "omap2_mcspi"; 406 struct omap2_mcspi_platform_config *pdata; 407 static int spi_num; 408 struct omap2_mcspi_dev_attr *mcspi_attrib = oh->dev_attr; 409 410 pdata = kzalloc(sizeof(*pdata), GFP_KERNEL); 411 if (!pdata) { 412 pr_err("Memory allocation for McSPI device failed\n"); 413 return -ENOMEM; 414 } 415 416 pdata->num_cs = mcspi_attrib->num_chipselect; 417 switch (oh->class->rev) { 418 case OMAP2_MCSPI_REV: 419 case OMAP3_MCSPI_REV: 420 pdata->regs_offset = 0; 421 break; 422 case OMAP4_MCSPI_REV: 423 pdata->regs_offset = OMAP4_MCSPI_REG_OFFSET; 424 break; 425 default: 426 pr_err("Invalid McSPI Revision value\n"); 427 kfree(pdata); 428 return -EINVAL; 429 } 430 431 spi_num++; 432 pdev = omap_device_build(name, spi_num, oh, pdata, 433 sizeof(*pdata), NULL, 0, 0); 434 WARN(IS_ERR(pdev), "Can't build omap_device for %s:%s\n", 435 name, oh->name); 436 kfree(pdata); 437 return 0; 438 } 439 440 static void omap_init_mcspi(void) 441 { 442 omap_hwmod_for_each_by_class("mcspi", omap_mcspi_init, NULL); 443 } 444 445 #else 446 static inline void omap_init_mcspi(void) {} 447 #endif 448 449 /** 450 * omap_init_rng - bind the RNG hwmod to the RNG omap_device 451 * 452 * Bind the RNG hwmod to the RNG omap_device. No return value. 453 */ 454 static void omap_init_rng(void) 455 { 456 struct omap_hwmod *oh; 457 struct platform_device *pdev; 458 459 oh = omap_hwmod_lookup("rng"); 460 if (!oh) 461 return; 462 463 pdev = omap_device_build("omap_rng", -1, oh, NULL, 0, NULL, 0, 0); 464 WARN(IS_ERR(pdev), "Can't build omap_device for omap_rng\n"); 465 } 466 467 #if defined(CONFIG_CRYPTO_DEV_OMAP_SHAM) || defined(CONFIG_CRYPTO_DEV_OMAP_SHAM_MODULE) 468 469 #ifdef CONFIG_ARCH_OMAP2 470 static struct resource omap2_sham_resources[] = { 471 { 472 .start = OMAP24XX_SEC_SHA1MD5_BASE, 473 .end = OMAP24XX_SEC_SHA1MD5_BASE + 0x64, 474 .flags = IORESOURCE_MEM, 475 }, 476 { 477 .start = 51 + OMAP_INTC_START, 478 .flags = IORESOURCE_IRQ, 479 } 480 }; 481 static int omap2_sham_resources_sz = ARRAY_SIZE(omap2_sham_resources); 482 #else 483 #define omap2_sham_resources NULL 484 #define omap2_sham_resources_sz 0 485 #endif 486 487 #ifdef CONFIG_ARCH_OMAP3 488 static struct resource omap3_sham_resources[] = { 489 { 490 .start = OMAP34XX_SEC_SHA1MD5_BASE, 491 .end = OMAP34XX_SEC_SHA1MD5_BASE + 0x64, 492 .flags = IORESOURCE_MEM, 493 }, 494 { 495 .start = 49 + OMAP_INTC_START, 496 .flags = IORESOURCE_IRQ, 497 }, 498 { 499 .start = OMAP34XX_DMA_SHA1MD5_RX, 500 .flags = IORESOURCE_DMA, 501 } 502 }; 503 static int omap3_sham_resources_sz = ARRAY_SIZE(omap3_sham_resources); 504 #else 505 #define omap3_sham_resources NULL 506 #define omap3_sham_resources_sz 0 507 #endif 508 509 static struct platform_device sham_device = { 510 .name = "omap-sham", 511 .id = -1, 512 }; 513 514 static void omap_init_sham(void) 515 { 516 if (cpu_is_omap24xx()) { 517 sham_device.resource = omap2_sham_resources; 518 sham_device.num_resources = omap2_sham_resources_sz; 519 } else if (cpu_is_omap34xx()) { 520 sham_device.resource = omap3_sham_resources; 521 sham_device.num_resources = omap3_sham_resources_sz; 522 } else { 523 pr_err("%s: platform not supported\n", __func__); 524 return; 525 } 526 platform_device_register(&sham_device); 527 } 528 #else 529 static inline void omap_init_sham(void) { } 530 #endif 531 532 #if defined(CONFIG_CRYPTO_DEV_OMAP_AES) || defined(CONFIG_CRYPTO_DEV_OMAP_AES_MODULE) 533 534 #ifdef CONFIG_ARCH_OMAP2 535 static struct resource omap2_aes_resources[] = { 536 { 537 .start = OMAP24XX_SEC_AES_BASE, 538 .end = OMAP24XX_SEC_AES_BASE + 0x4C, 539 .flags = IORESOURCE_MEM, 540 }, 541 { 542 .start = OMAP24XX_DMA_AES_TX, 543 .flags = IORESOURCE_DMA, 544 }, 545 { 546 .start = OMAP24XX_DMA_AES_RX, 547 .flags = IORESOURCE_DMA, 548 } 549 }; 550 static int omap2_aes_resources_sz = ARRAY_SIZE(omap2_aes_resources); 551 #else 552 #define omap2_aes_resources NULL 553 #define omap2_aes_resources_sz 0 554 #endif 555 556 #ifdef CONFIG_ARCH_OMAP3 557 static struct resource omap3_aes_resources[] = { 558 { 559 .start = OMAP34XX_SEC_AES_BASE, 560 .end = OMAP34XX_SEC_AES_BASE + 0x4C, 561 .flags = IORESOURCE_MEM, 562 }, 563 { 564 .start = OMAP34XX_DMA_AES2_TX, 565 .flags = IORESOURCE_DMA, 566 }, 567 { 568 .start = OMAP34XX_DMA_AES2_RX, 569 .flags = IORESOURCE_DMA, 570 } 571 }; 572 static int omap3_aes_resources_sz = ARRAY_SIZE(omap3_aes_resources); 573 #else 574 #define omap3_aes_resources NULL 575 #define omap3_aes_resources_sz 0 576 #endif 577 578 static struct platform_device aes_device = { 579 .name = "omap-aes", 580 .id = -1, 581 }; 582 583 static void omap_init_aes(void) 584 { 585 if (cpu_is_omap24xx()) { 586 aes_device.resource = omap2_aes_resources; 587 aes_device.num_resources = omap2_aes_resources_sz; 588 } else if (cpu_is_omap34xx()) { 589 aes_device.resource = omap3_aes_resources; 590 aes_device.num_resources = omap3_aes_resources_sz; 591 } else { 592 pr_err("%s: platform not supported\n", __func__); 593 return; 594 } 595 platform_device_register(&aes_device); 596 } 597 598 #else 599 static inline void omap_init_aes(void) { } 600 #endif 601 602 /*-------------------------------------------------------------------------*/ 603 604 #if defined(CONFIG_VIDEO_OMAP2_VOUT) || \ 605 defined(CONFIG_VIDEO_OMAP2_VOUT_MODULE) 606 #if defined(CONFIG_FB_OMAP2) || defined(CONFIG_FB_OMAP2_MODULE) 607 static struct resource omap_vout_resource[3 - CONFIG_FB_OMAP2_NUM_FBS] = { 608 }; 609 #else 610 static struct resource omap_vout_resource[2] = { 611 }; 612 #endif 613 614 static struct platform_device omap_vout_device = { 615 .name = "omap_vout", 616 .num_resources = ARRAY_SIZE(omap_vout_resource), 617 .resource = &omap_vout_resource[0], 618 .id = -1, 619 }; 620 static void omap_init_vout(void) 621 { 622 if (platform_device_register(&omap_vout_device) < 0) 623 printk(KERN_ERR "Unable to register OMAP-VOUT device\n"); 624 } 625 #else 626 static inline void omap_init_vout(void) {} 627 #endif 628 629 #if defined(CONFIG_OMAP_OCP2SCP) || defined(CONFIG_OMAP_OCP2SCP_MODULE) 630 static int count_ocp2scp_devices(struct omap_ocp2scp_dev *ocp2scp_dev) 631 { 632 int cnt = 0; 633 634 while (ocp2scp_dev->drv_name != NULL) { 635 cnt++; 636 ocp2scp_dev++; 637 } 638 639 return cnt; 640 } 641 642 static void __init omap_init_ocp2scp(void) 643 { 644 struct omap_hwmod *oh; 645 struct platform_device *pdev; 646 int bus_id = -1, dev_cnt = 0, i; 647 struct omap_ocp2scp_dev *ocp2scp_dev; 648 const char *oh_name, *name; 649 struct omap_ocp2scp_platform_data *pdata; 650 651 if (!cpu_is_omap44xx()) 652 return; 653 654 oh_name = "ocp2scp_usb_phy"; 655 name = "omap-ocp2scp"; 656 657 oh = omap_hwmod_lookup(oh_name); 658 if (!oh) { 659 pr_err("%s: could not find omap_hwmod for %s\n", __func__, 660 oh_name); 661 return; 662 } 663 664 pdata = kzalloc(sizeof(*pdata), GFP_KERNEL); 665 if (!pdata) { 666 pr_err("%s: No memory for ocp2scp pdata\n", __func__); 667 return; 668 } 669 670 ocp2scp_dev = oh->dev_attr; 671 dev_cnt = count_ocp2scp_devices(ocp2scp_dev); 672 673 if (!dev_cnt) { 674 pr_err("%s: No devices connected to ocp2scp\n", __func__); 675 kfree(pdata); 676 return; 677 } 678 679 pdata->devices = kzalloc(sizeof(struct omap_ocp2scp_dev *) 680 * dev_cnt, GFP_KERNEL); 681 if (!pdata->devices) { 682 pr_err("%s: No memory for ocp2scp pdata devices\n", __func__); 683 kfree(pdata); 684 return; 685 } 686 687 for (i = 0; i < dev_cnt; i++, ocp2scp_dev++) 688 pdata->devices[i] = ocp2scp_dev; 689 690 pdata->dev_cnt = dev_cnt; 691 692 pdev = omap_device_build(name, bus_id, oh, pdata, sizeof(*pdata), NULL, 693 0, false); 694 if (IS_ERR(pdev)) { 695 pr_err("Could not build omap_device for %s %s\n", 696 name, oh_name); 697 kfree(pdata->devices); 698 kfree(pdata); 699 return; 700 } 701 } 702 #else 703 static inline void omap_init_ocp2scp(void) { } 704 #endif 705 706 /*-------------------------------------------------------------------------*/ 707 708 static int __init omap2_init_devices(void) 709 { 710 /* Enable dummy states for those platforms without pinctrl support */ 711 if (!of_have_populated_dt()) 712 pinctrl_provide_dummies(); 713 714 /* 715 * please keep these calls, and their implementations above, 716 * in alphabetical order so they're easier to sort through. 717 */ 718 omap_init_audio(); 719 omap_init_camera(); 720 omap_init_hdmi_audio(); 721 omap_init_mbox(); 722 /* If dtb is there, the devices will be created dynamically */ 723 if (!of_have_populated_dt()) { 724 omap_init_dmic(); 725 omap_init_mcpdm(); 726 omap_init_mcspi(); 727 } 728 omap_init_sti(); 729 omap_init_rng(); 730 omap_init_sham(); 731 omap_init_aes(); 732 omap_init_vout(); 733 omap_init_ocp2scp(); 734 735 return 0; 736 } 737 arch_initcall(omap2_init_devices); 738