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/platform_data/omap4-keypad.h> 21 22 #include <mach/hardware.h> 23 #include <mach/irqs.h> 24 #include <asm/mach-types.h> 25 #include <asm/mach/map.h> 26 #include <asm/pmu.h> 27 28 #include "iomap.h" 29 #include <plat/board.h> 30 #include <plat/mmc.h> 31 #include <plat/dma.h> 32 #include <plat/omap_hwmod.h> 33 #include <plat/omap_device.h> 34 #include <plat/omap4-keypad.h> 35 36 #include "mux.h" 37 #include "control.h" 38 #include "devices.h" 39 40 #define L3_MODULES_MAX_LEN 12 41 #define L3_MODULES 3 42 43 static int __init omap3_l3_init(void) 44 { 45 int l; 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 l = 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 l, 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())) 89 return -ENODEV; 90 91 for (i = 0; i < L3_MODULES; i++) { 92 l = 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 = INT_24XX_CAM_IRQ, 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 <plat/iommu.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 = INT_34XX_CAM_IRQ, 207 .flags = IORESOURCE_IRQ, 208 } 209 }; 210 211 static struct platform_device omap3isp_device = { 212 .name = "omap3isp", 213 .id = -1, 214 .num_resources = ARRAY_SIZE(omap3isp_resources), 215 .resource = omap3isp_resources, 216 }; 217 218 static struct omap_iommu_arch_data omap3_isp_iommu = { 219 .name = "isp", 220 }; 221 222 int omap3_init_camera(struct isp_platform_data *pdata) 223 { 224 omap3isp_device.dev.platform_data = pdata; 225 omap3isp_device.dev.archdata.iommu = &omap3_isp_iommu; 226 227 return platform_device_register(&omap3isp_device); 228 } 229 230 #else /* !CONFIG_IOMMU_API */ 231 232 int omap3_init_camera(struct isp_platform_data *pdata) 233 { 234 return 0; 235 } 236 237 #endif 238 239 static inline void omap_init_camera(void) 240 { 241 #if defined(CONFIG_VIDEO_OMAP2) || defined(CONFIG_VIDEO_OMAP2_MODULE) 242 if (cpu_is_omap24xx()) 243 platform_device_register(&omap2cam_device); 244 #endif 245 } 246 247 int __init omap4_keyboard_init(struct omap4_keypad_platform_data 248 *sdp4430_keypad_data, struct omap_board_data *bdata) 249 { 250 struct platform_device *pdev; 251 struct omap_hwmod *oh; 252 struct omap4_keypad_platform_data *keypad_data; 253 unsigned int id = -1; 254 char *oh_name = "kbd"; 255 char *name = "omap4-keypad"; 256 257 oh = omap_hwmod_lookup(oh_name); 258 if (!oh) { 259 pr_err("Could not look up %s\n", oh_name); 260 return -ENODEV; 261 } 262 263 keypad_data = sdp4430_keypad_data; 264 265 pdev = omap_device_build(name, id, oh, keypad_data, 266 sizeof(struct omap4_keypad_platform_data), NULL, 0, 0); 267 268 if (IS_ERR(pdev)) { 269 WARN(1, "Can't build omap_device for %s:%s.\n", 270 name, oh->name); 271 return PTR_ERR(pdev); 272 } 273 oh->mux = omap_hwmod_mux_init(bdata->pads, bdata->pads_cnt); 274 275 return 0; 276 } 277 278 #if defined(CONFIG_OMAP_MBOX_FWK) || defined(CONFIG_OMAP_MBOX_FWK_MODULE) 279 static inline void __init omap_init_mbox(void) 280 { 281 struct omap_hwmod *oh; 282 struct platform_device *pdev; 283 284 oh = omap_hwmod_lookup("mailbox"); 285 if (!oh) { 286 pr_err("%s: unable to find hwmod\n", __func__); 287 return; 288 } 289 290 pdev = omap_device_build("omap-mailbox", -1, oh, NULL, 0, NULL, 0, 0); 291 WARN(IS_ERR(pdev), "%s: could not build device, err %ld\n", 292 __func__, PTR_ERR(pdev)); 293 } 294 #else 295 static inline void omap_init_mbox(void) { } 296 #endif /* CONFIG_OMAP_MBOX_FWK */ 297 298 static inline void omap_init_sti(void) {} 299 300 #if defined(CONFIG_SND_SOC) || defined(CONFIG_SND_SOC_MODULE) 301 302 static struct platform_device omap_pcm = { 303 .name = "omap-pcm-audio", 304 .id = -1, 305 }; 306 307 static void omap_init_audio(void) 308 { 309 platform_device_register(&omap_pcm); 310 } 311 312 #else 313 static inline void omap_init_audio(void) {} 314 #endif 315 316 #if defined(CONFIG_SND_OMAP_SOC_MCPDM) || \ 317 defined(CONFIG_SND_OMAP_SOC_MCPDM_MODULE) 318 319 static void __init omap_init_mcpdm(void) 320 { 321 struct omap_hwmod *oh; 322 struct platform_device *pdev; 323 324 oh = omap_hwmod_lookup("mcpdm"); 325 if (!oh) { 326 printk(KERN_ERR "Could not look up mcpdm hw_mod\n"); 327 return; 328 } 329 330 pdev = omap_device_build("omap-mcpdm", -1, oh, NULL, 0, NULL, 0, 0); 331 WARN(IS_ERR(pdev), "Can't build omap_device for omap-mcpdm.\n"); 332 } 333 #else 334 static inline void omap_init_mcpdm(void) {} 335 #endif 336 337 #if defined(CONFIG_SND_OMAP_SOC_DMIC) || \ 338 defined(CONFIG_SND_OMAP_SOC_DMIC_MODULE) 339 340 static void __init omap_init_dmic(void) 341 { 342 struct omap_hwmod *oh; 343 struct platform_device *pdev; 344 345 oh = omap_hwmod_lookup("dmic"); 346 if (!oh) { 347 printk(KERN_ERR "Could not look up mcpdm hw_mod\n"); 348 return; 349 } 350 351 pdev = omap_device_build("omap-dmic", -1, oh, NULL, 0, NULL, 0, 0); 352 WARN(IS_ERR(pdev), "Can't build omap_device for omap-dmic.\n"); 353 } 354 #else 355 static inline void omap_init_dmic(void) {} 356 #endif 357 358 #if defined(CONFIG_SPI_OMAP24XX) || defined(CONFIG_SPI_OMAP24XX_MODULE) 359 360 #include <plat/mcspi.h> 361 362 static int __init omap_mcspi_init(struct omap_hwmod *oh, void *unused) 363 { 364 struct platform_device *pdev; 365 char *name = "omap2_mcspi"; 366 struct omap2_mcspi_platform_config *pdata; 367 static int spi_num; 368 struct omap2_mcspi_dev_attr *mcspi_attrib = oh->dev_attr; 369 370 pdata = kzalloc(sizeof(*pdata), GFP_KERNEL); 371 if (!pdata) { 372 pr_err("Memory allocation for McSPI device failed\n"); 373 return -ENOMEM; 374 } 375 376 pdata->num_cs = mcspi_attrib->num_chipselect; 377 switch (oh->class->rev) { 378 case OMAP2_MCSPI_REV: 379 case OMAP3_MCSPI_REV: 380 pdata->regs_offset = 0; 381 break; 382 case OMAP4_MCSPI_REV: 383 pdata->regs_offset = OMAP4_MCSPI_REG_OFFSET; 384 break; 385 default: 386 pr_err("Invalid McSPI Revision value\n"); 387 kfree(pdata); 388 return -EINVAL; 389 } 390 391 spi_num++; 392 pdev = omap_device_build(name, spi_num, oh, pdata, 393 sizeof(*pdata), NULL, 0, 0); 394 WARN(IS_ERR(pdev), "Can't build omap_device for %s:%s\n", 395 name, oh->name); 396 kfree(pdata); 397 return 0; 398 } 399 400 static void omap_init_mcspi(void) 401 { 402 omap_hwmod_for_each_by_class("mcspi", omap_mcspi_init, NULL); 403 } 404 405 #else 406 static inline void omap_init_mcspi(void) {} 407 #endif 408 409 static struct resource omap2_pmu_resource = { 410 .start = 3, 411 .end = 3, 412 .flags = IORESOURCE_IRQ, 413 }; 414 415 static struct resource omap3_pmu_resource = { 416 .start = INT_34XX_BENCH_MPU_EMUL, 417 .end = INT_34XX_BENCH_MPU_EMUL, 418 .flags = IORESOURCE_IRQ, 419 }; 420 421 static struct platform_device omap_pmu_device = { 422 .name = "arm-pmu", 423 .id = ARM_PMU_DEVICE_CPU, 424 .num_resources = 1, 425 }; 426 427 static void omap_init_pmu(void) 428 { 429 if (cpu_is_omap24xx()) 430 omap_pmu_device.resource = &omap2_pmu_resource; 431 else if (cpu_is_omap34xx()) 432 omap_pmu_device.resource = &omap3_pmu_resource; 433 else 434 return; 435 436 platform_device_register(&omap_pmu_device); 437 } 438 439 440 #if defined(CONFIG_CRYPTO_DEV_OMAP_SHAM) || defined(CONFIG_CRYPTO_DEV_OMAP_SHAM_MODULE) 441 442 #ifdef CONFIG_ARCH_OMAP2 443 static struct resource omap2_sham_resources[] = { 444 { 445 .start = OMAP24XX_SEC_SHA1MD5_BASE, 446 .end = OMAP24XX_SEC_SHA1MD5_BASE + 0x64, 447 .flags = IORESOURCE_MEM, 448 }, 449 { 450 .start = INT_24XX_SHA1MD5, 451 .flags = IORESOURCE_IRQ, 452 } 453 }; 454 static int omap2_sham_resources_sz = ARRAY_SIZE(omap2_sham_resources); 455 #else 456 #define omap2_sham_resources NULL 457 #define omap2_sham_resources_sz 0 458 #endif 459 460 #ifdef CONFIG_ARCH_OMAP3 461 static struct resource omap3_sham_resources[] = { 462 { 463 .start = OMAP34XX_SEC_SHA1MD5_BASE, 464 .end = OMAP34XX_SEC_SHA1MD5_BASE + 0x64, 465 .flags = IORESOURCE_MEM, 466 }, 467 { 468 .start = INT_34XX_SHA1MD52_IRQ, 469 .flags = IORESOURCE_IRQ, 470 }, 471 { 472 .start = OMAP34XX_DMA_SHA1MD5_RX, 473 .flags = IORESOURCE_DMA, 474 } 475 }; 476 static int omap3_sham_resources_sz = ARRAY_SIZE(omap3_sham_resources); 477 #else 478 #define omap3_sham_resources NULL 479 #define omap3_sham_resources_sz 0 480 #endif 481 482 static struct platform_device sham_device = { 483 .name = "omap-sham", 484 .id = -1, 485 }; 486 487 static void omap_init_sham(void) 488 { 489 if (cpu_is_omap24xx()) { 490 sham_device.resource = omap2_sham_resources; 491 sham_device.num_resources = omap2_sham_resources_sz; 492 } else if (cpu_is_omap34xx()) { 493 sham_device.resource = omap3_sham_resources; 494 sham_device.num_resources = omap3_sham_resources_sz; 495 } else { 496 pr_err("%s: platform not supported\n", __func__); 497 return; 498 } 499 platform_device_register(&sham_device); 500 } 501 #else 502 static inline void omap_init_sham(void) { } 503 #endif 504 505 #if defined(CONFIG_CRYPTO_DEV_OMAP_AES) || defined(CONFIG_CRYPTO_DEV_OMAP_AES_MODULE) 506 507 #ifdef CONFIG_ARCH_OMAP2 508 static struct resource omap2_aes_resources[] = { 509 { 510 .start = OMAP24XX_SEC_AES_BASE, 511 .end = OMAP24XX_SEC_AES_BASE + 0x4C, 512 .flags = IORESOURCE_MEM, 513 }, 514 { 515 .start = OMAP24XX_DMA_AES_TX, 516 .flags = IORESOURCE_DMA, 517 }, 518 { 519 .start = OMAP24XX_DMA_AES_RX, 520 .flags = IORESOURCE_DMA, 521 } 522 }; 523 static int omap2_aes_resources_sz = ARRAY_SIZE(omap2_aes_resources); 524 #else 525 #define omap2_aes_resources NULL 526 #define omap2_aes_resources_sz 0 527 #endif 528 529 #ifdef CONFIG_ARCH_OMAP3 530 static struct resource omap3_aes_resources[] = { 531 { 532 .start = OMAP34XX_SEC_AES_BASE, 533 .end = OMAP34XX_SEC_AES_BASE + 0x4C, 534 .flags = IORESOURCE_MEM, 535 }, 536 { 537 .start = OMAP34XX_DMA_AES2_TX, 538 .flags = IORESOURCE_DMA, 539 }, 540 { 541 .start = OMAP34XX_DMA_AES2_RX, 542 .flags = IORESOURCE_DMA, 543 } 544 }; 545 static int omap3_aes_resources_sz = ARRAY_SIZE(omap3_aes_resources); 546 #else 547 #define omap3_aes_resources NULL 548 #define omap3_aes_resources_sz 0 549 #endif 550 551 static struct platform_device aes_device = { 552 .name = "omap-aes", 553 .id = -1, 554 }; 555 556 static void omap_init_aes(void) 557 { 558 if (cpu_is_omap24xx()) { 559 aes_device.resource = omap2_aes_resources; 560 aes_device.num_resources = omap2_aes_resources_sz; 561 } else if (cpu_is_omap34xx()) { 562 aes_device.resource = omap3_aes_resources; 563 aes_device.num_resources = omap3_aes_resources_sz; 564 } else { 565 pr_err("%s: platform not supported\n", __func__); 566 return; 567 } 568 platform_device_register(&aes_device); 569 } 570 571 #else 572 static inline void omap_init_aes(void) { } 573 #endif 574 575 /*-------------------------------------------------------------------------*/ 576 577 #if defined(CONFIG_MMC_OMAP) || defined(CONFIG_MMC_OMAP_MODULE) 578 579 static inline void omap242x_mmc_mux(struct omap_mmc_platform_data 580 *mmc_controller) 581 { 582 if ((mmc_controller->slots[0].switch_pin > 0) && \ 583 (mmc_controller->slots[0].switch_pin < OMAP_MAX_GPIO_LINES)) 584 omap_mux_init_gpio(mmc_controller->slots[0].switch_pin, 585 OMAP_PIN_INPUT_PULLUP); 586 if ((mmc_controller->slots[0].gpio_wp > 0) && \ 587 (mmc_controller->slots[0].gpio_wp < OMAP_MAX_GPIO_LINES)) 588 omap_mux_init_gpio(mmc_controller->slots[0].gpio_wp, 589 OMAP_PIN_INPUT_PULLUP); 590 591 omap_mux_init_signal("sdmmc_cmd", 0); 592 omap_mux_init_signal("sdmmc_clki", 0); 593 omap_mux_init_signal("sdmmc_clko", 0); 594 omap_mux_init_signal("sdmmc_dat0", 0); 595 omap_mux_init_signal("sdmmc_dat_dir0", 0); 596 omap_mux_init_signal("sdmmc_cmd_dir", 0); 597 if (mmc_controller->slots[0].caps & MMC_CAP_4_BIT_DATA) { 598 omap_mux_init_signal("sdmmc_dat1", 0); 599 omap_mux_init_signal("sdmmc_dat2", 0); 600 omap_mux_init_signal("sdmmc_dat3", 0); 601 omap_mux_init_signal("sdmmc_dat_dir1", 0); 602 omap_mux_init_signal("sdmmc_dat_dir2", 0); 603 omap_mux_init_signal("sdmmc_dat_dir3", 0); 604 } 605 606 /* 607 * Use internal loop-back in MMC/SDIO Module Input Clock 608 * selection 609 */ 610 if (mmc_controller->slots[0].internal_clock) { 611 u32 v = omap_ctrl_readl(OMAP2_CONTROL_DEVCONF0); 612 v |= (1 << 24); 613 omap_ctrl_writel(v, OMAP2_CONTROL_DEVCONF0); 614 } 615 } 616 617 void __init omap242x_init_mmc(struct omap_mmc_platform_data **mmc_data) 618 { 619 char *name = "mmci-omap"; 620 621 if (!mmc_data[0]) { 622 pr_err("%s fails: Incomplete platform data\n", __func__); 623 return; 624 } 625 626 omap242x_mmc_mux(mmc_data[0]); 627 omap_mmc_add(name, 0, OMAP2_MMC1_BASE, OMAP2420_MMC_SIZE, 628 INT_24XX_MMC_IRQ, mmc_data[0]); 629 } 630 631 #endif 632 633 /*-------------------------------------------------------------------------*/ 634 635 #if defined(CONFIG_HDQ_MASTER_OMAP) || defined(CONFIG_HDQ_MASTER_OMAP_MODULE) 636 #define OMAP_HDQ_BASE 0x480B2000 637 static struct resource omap_hdq_resources[] = { 638 { 639 .start = OMAP_HDQ_BASE, 640 .end = OMAP_HDQ_BASE + 0x1C, 641 .flags = IORESOURCE_MEM, 642 }, 643 { 644 .start = INT_24XX_HDQ_IRQ, 645 .flags = IORESOURCE_IRQ, 646 }, 647 }; 648 static struct platform_device omap_hdq_dev = { 649 .name = "omap_hdq", 650 .id = 0, 651 .dev = { 652 .platform_data = NULL, 653 }, 654 .num_resources = ARRAY_SIZE(omap_hdq_resources), 655 .resource = omap_hdq_resources, 656 }; 657 static inline void omap_hdq_init(void) 658 { 659 if (cpu_is_omap2420()) 660 return; 661 662 platform_device_register(&omap_hdq_dev); 663 } 664 #else 665 static inline void omap_hdq_init(void) {} 666 #endif 667 668 /*---------------------------------------------------------------------------*/ 669 670 #if defined(CONFIG_VIDEO_OMAP2_VOUT) || \ 671 defined(CONFIG_VIDEO_OMAP2_VOUT_MODULE) 672 #if defined(CONFIG_FB_OMAP2) || defined(CONFIG_FB_OMAP2_MODULE) 673 static struct resource omap_vout_resource[3 - CONFIG_FB_OMAP2_NUM_FBS] = { 674 }; 675 #else 676 static struct resource omap_vout_resource[2] = { 677 }; 678 #endif 679 680 static struct platform_device omap_vout_device = { 681 .name = "omap_vout", 682 .num_resources = ARRAY_SIZE(omap_vout_resource), 683 .resource = &omap_vout_resource[0], 684 .id = -1, 685 }; 686 static void omap_init_vout(void) 687 { 688 if (platform_device_register(&omap_vout_device) < 0) 689 printk(KERN_ERR "Unable to register OMAP-VOUT device\n"); 690 } 691 #else 692 static inline void omap_init_vout(void) {} 693 #endif 694 695 /*-------------------------------------------------------------------------*/ 696 697 static int __init omap2_init_devices(void) 698 { 699 /* 700 * please keep these calls, and their implementations above, 701 * in alphabetical order so they're easier to sort through. 702 */ 703 omap_init_audio(); 704 omap_init_mcpdm(); 705 omap_init_dmic(); 706 omap_init_camera(); 707 omap_init_mbox(); 708 omap_init_mcspi(); 709 omap_init_pmu(); 710 omap_hdq_init(); 711 omap_init_sti(); 712 omap_init_sham(); 713 omap_init_aes(); 714 omap_init_vout(); 715 716 return 0; 717 } 718 arch_initcall(omap2_init_devices); 719 720 #if defined(CONFIG_OMAP_WATCHDOG) || defined(CONFIG_OMAP_WATCHDOG_MODULE) 721 static int __init omap_init_wdt(void) 722 { 723 int id = -1; 724 struct platform_device *pdev; 725 struct omap_hwmod *oh; 726 char *oh_name = "wd_timer2"; 727 char *dev_name = "omap_wdt"; 728 729 if (!cpu_class_is_omap2()) 730 return 0; 731 732 oh = omap_hwmod_lookup(oh_name); 733 if (!oh) { 734 pr_err("Could not look up wd_timer%d hwmod\n", id); 735 return -EINVAL; 736 } 737 738 pdev = omap_device_build(dev_name, id, oh, NULL, 0, NULL, 0, 0); 739 WARN(IS_ERR(pdev), "Can't build omap_device for %s:%s.\n", 740 dev_name, oh->name); 741 return 0; 742 } 743 subsys_initcall(omap_init_wdt); 744 #endif 745