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 21 #include <mach/hardware.h> 22 #include <mach/irqs.h> 23 #include <asm/mach-types.h> 24 #include <asm/mach/map.h> 25 #include <asm/pmu.h> 26 27 #include <plat/tc.h> 28 #include <plat/board.h> 29 #include <plat/mcbsp.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 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 /* 308 * OMAP2420 has 2 McBSP ports 309 * OMAP2430 has 5 McBSP ports 310 * OMAP3 has 5 McBSP ports 311 * OMAP4 has 4 McBSP ports 312 */ 313 OMAP_MCBSP_PLATFORM_DEVICE(1); 314 OMAP_MCBSP_PLATFORM_DEVICE(2); 315 OMAP_MCBSP_PLATFORM_DEVICE(3); 316 OMAP_MCBSP_PLATFORM_DEVICE(4); 317 OMAP_MCBSP_PLATFORM_DEVICE(5); 318 319 static void omap_init_audio(void) 320 { 321 platform_device_register(&omap_mcbsp1); 322 platform_device_register(&omap_mcbsp2); 323 if (cpu_is_omap243x() || cpu_is_omap34xx() || cpu_is_omap44xx()) { 324 platform_device_register(&omap_mcbsp3); 325 platform_device_register(&omap_mcbsp4); 326 } 327 if (cpu_is_omap243x() || cpu_is_omap34xx()) 328 platform_device_register(&omap_mcbsp5); 329 330 platform_device_register(&omap_pcm); 331 } 332 333 #else 334 static inline void omap_init_audio(void) {} 335 #endif 336 337 #if defined(CONFIG_SND_OMAP_SOC_MCPDM) || \ 338 defined(CONFIG_SND_OMAP_SOC_MCPDM_MODULE) 339 340 static void omap_init_mcpdm(void) 341 { 342 struct omap_hwmod *oh; 343 struct platform_device *pdev; 344 345 oh = omap_hwmod_lookup("mcpdm"); 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-mcpdm", -1, oh, NULL, 0, NULL, 0, 0); 352 WARN(IS_ERR(pdev), "Can't build omap_device for omap-mcpdm.\n"); 353 } 354 #else 355 static inline void omap_init_mcpdm(void) {} 356 #endif 357 358 #if defined(CONFIG_SND_OMAP_SOC_DMIC) || \ 359 defined(CONFIG_SND_OMAP_SOC_DMIC_MODULE) 360 361 static void omap_init_dmic(void) 362 { 363 struct omap_hwmod *oh; 364 struct platform_device *pdev; 365 366 oh = omap_hwmod_lookup("dmic"); 367 if (!oh) { 368 printk(KERN_ERR "Could not look up mcpdm hw_mod\n"); 369 return; 370 } 371 372 pdev = omap_device_build("omap-dmic", -1, oh, NULL, 0, NULL, 0, 0); 373 WARN(IS_ERR(pdev), "Can't build omap_device for omap-dmic.\n"); 374 } 375 #else 376 static inline void omap_init_dmic(void) {} 377 #endif 378 379 #if defined(CONFIG_SPI_OMAP24XX) || defined(CONFIG_SPI_OMAP24XX_MODULE) 380 381 #include <plat/mcspi.h> 382 383 static int omap_mcspi_init(struct omap_hwmod *oh, void *unused) 384 { 385 struct platform_device *pdev; 386 char *name = "omap2_mcspi"; 387 struct omap2_mcspi_platform_config *pdata; 388 static int spi_num; 389 struct omap2_mcspi_dev_attr *mcspi_attrib = oh->dev_attr; 390 391 pdata = kzalloc(sizeof(*pdata), GFP_KERNEL); 392 if (!pdata) { 393 pr_err("Memory allocation for McSPI device failed\n"); 394 return -ENOMEM; 395 } 396 397 pdata->num_cs = mcspi_attrib->num_chipselect; 398 switch (oh->class->rev) { 399 case OMAP2_MCSPI_REV: 400 case OMAP3_MCSPI_REV: 401 pdata->regs_offset = 0; 402 break; 403 case OMAP4_MCSPI_REV: 404 pdata->regs_offset = OMAP4_MCSPI_REG_OFFSET; 405 break; 406 default: 407 pr_err("Invalid McSPI Revision value\n"); 408 return -EINVAL; 409 } 410 411 spi_num++; 412 pdev = omap_device_build(name, spi_num, oh, pdata, 413 sizeof(*pdata), NULL, 0, 0); 414 WARN(IS_ERR(pdev), "Can't build omap_device for %s:%s\n", 415 name, oh->name); 416 kfree(pdata); 417 return 0; 418 } 419 420 static void omap_init_mcspi(void) 421 { 422 omap_hwmod_for_each_by_class("mcspi", omap_mcspi_init, NULL); 423 } 424 425 #else 426 static inline void omap_init_mcspi(void) {} 427 #endif 428 429 static struct resource omap2_pmu_resource = { 430 .start = 3, 431 .end = 3, 432 .flags = IORESOURCE_IRQ, 433 }; 434 435 static struct resource omap3_pmu_resource = { 436 .start = INT_34XX_BENCH_MPU_EMUL, 437 .end = INT_34XX_BENCH_MPU_EMUL, 438 .flags = IORESOURCE_IRQ, 439 }; 440 441 static struct platform_device omap_pmu_device = { 442 .name = "arm-pmu", 443 .id = ARM_PMU_DEVICE_CPU, 444 .num_resources = 1, 445 }; 446 447 static void omap_init_pmu(void) 448 { 449 if (cpu_is_omap24xx()) 450 omap_pmu_device.resource = &omap2_pmu_resource; 451 else if (cpu_is_omap34xx()) 452 omap_pmu_device.resource = &omap3_pmu_resource; 453 else 454 return; 455 456 platform_device_register(&omap_pmu_device); 457 } 458 459 460 #if defined(CONFIG_CRYPTO_DEV_OMAP_SHAM) || defined(CONFIG_CRYPTO_DEV_OMAP_SHAM_MODULE) 461 462 #ifdef CONFIG_ARCH_OMAP2 463 static struct resource omap2_sham_resources[] = { 464 { 465 .start = OMAP24XX_SEC_SHA1MD5_BASE, 466 .end = OMAP24XX_SEC_SHA1MD5_BASE + 0x64, 467 .flags = IORESOURCE_MEM, 468 }, 469 { 470 .start = INT_24XX_SHA1MD5, 471 .flags = IORESOURCE_IRQ, 472 } 473 }; 474 static int omap2_sham_resources_sz = ARRAY_SIZE(omap2_sham_resources); 475 #else 476 #define omap2_sham_resources NULL 477 #define omap2_sham_resources_sz 0 478 #endif 479 480 #ifdef CONFIG_ARCH_OMAP3 481 static struct resource omap3_sham_resources[] = { 482 { 483 .start = OMAP34XX_SEC_SHA1MD5_BASE, 484 .end = OMAP34XX_SEC_SHA1MD5_BASE + 0x64, 485 .flags = IORESOURCE_MEM, 486 }, 487 { 488 .start = INT_34XX_SHA1MD52_IRQ, 489 .flags = IORESOURCE_IRQ, 490 }, 491 { 492 .start = OMAP34XX_DMA_SHA1MD5_RX, 493 .flags = IORESOURCE_DMA, 494 } 495 }; 496 static int omap3_sham_resources_sz = ARRAY_SIZE(omap3_sham_resources); 497 #else 498 #define omap3_sham_resources NULL 499 #define omap3_sham_resources_sz 0 500 #endif 501 502 static struct platform_device sham_device = { 503 .name = "omap-sham", 504 .id = -1, 505 }; 506 507 static void omap_init_sham(void) 508 { 509 if (cpu_is_omap24xx()) { 510 sham_device.resource = omap2_sham_resources; 511 sham_device.num_resources = omap2_sham_resources_sz; 512 } else if (cpu_is_omap34xx()) { 513 sham_device.resource = omap3_sham_resources; 514 sham_device.num_resources = omap3_sham_resources_sz; 515 } else { 516 pr_err("%s: platform not supported\n", __func__); 517 return; 518 } 519 platform_device_register(&sham_device); 520 } 521 #else 522 static inline void omap_init_sham(void) { } 523 #endif 524 525 #if defined(CONFIG_CRYPTO_DEV_OMAP_AES) || defined(CONFIG_CRYPTO_DEV_OMAP_AES_MODULE) 526 527 #ifdef CONFIG_ARCH_OMAP2 528 static struct resource omap2_aes_resources[] = { 529 { 530 .start = OMAP24XX_SEC_AES_BASE, 531 .end = OMAP24XX_SEC_AES_BASE + 0x4C, 532 .flags = IORESOURCE_MEM, 533 }, 534 { 535 .start = OMAP24XX_DMA_AES_TX, 536 .flags = IORESOURCE_DMA, 537 }, 538 { 539 .start = OMAP24XX_DMA_AES_RX, 540 .flags = IORESOURCE_DMA, 541 } 542 }; 543 static int omap2_aes_resources_sz = ARRAY_SIZE(omap2_aes_resources); 544 #else 545 #define omap2_aes_resources NULL 546 #define omap2_aes_resources_sz 0 547 #endif 548 549 #ifdef CONFIG_ARCH_OMAP3 550 static struct resource omap3_aes_resources[] = { 551 { 552 .start = OMAP34XX_SEC_AES_BASE, 553 .end = OMAP34XX_SEC_AES_BASE + 0x4C, 554 .flags = IORESOURCE_MEM, 555 }, 556 { 557 .start = OMAP34XX_DMA_AES2_TX, 558 .flags = IORESOURCE_DMA, 559 }, 560 { 561 .start = OMAP34XX_DMA_AES2_RX, 562 .flags = IORESOURCE_DMA, 563 } 564 }; 565 static int omap3_aes_resources_sz = ARRAY_SIZE(omap3_aes_resources); 566 #else 567 #define omap3_aes_resources NULL 568 #define omap3_aes_resources_sz 0 569 #endif 570 571 static struct platform_device aes_device = { 572 .name = "omap-aes", 573 .id = -1, 574 }; 575 576 static void omap_init_aes(void) 577 { 578 if (cpu_is_omap24xx()) { 579 aes_device.resource = omap2_aes_resources; 580 aes_device.num_resources = omap2_aes_resources_sz; 581 } else if (cpu_is_omap34xx()) { 582 aes_device.resource = omap3_aes_resources; 583 aes_device.num_resources = omap3_aes_resources_sz; 584 } else { 585 pr_err("%s: platform not supported\n", __func__); 586 return; 587 } 588 platform_device_register(&aes_device); 589 } 590 591 #else 592 static inline void omap_init_aes(void) { } 593 #endif 594 595 /*-------------------------------------------------------------------------*/ 596 597 #if defined(CONFIG_MMC_OMAP) || defined(CONFIG_MMC_OMAP_MODULE) 598 599 static inline void omap242x_mmc_mux(struct omap_mmc_platform_data 600 *mmc_controller) 601 { 602 if ((mmc_controller->slots[0].switch_pin > 0) && \ 603 (mmc_controller->slots[0].switch_pin < OMAP_MAX_GPIO_LINES)) 604 omap_mux_init_gpio(mmc_controller->slots[0].switch_pin, 605 OMAP_PIN_INPUT_PULLUP); 606 if ((mmc_controller->slots[0].gpio_wp > 0) && \ 607 (mmc_controller->slots[0].gpio_wp < OMAP_MAX_GPIO_LINES)) 608 omap_mux_init_gpio(mmc_controller->slots[0].gpio_wp, 609 OMAP_PIN_INPUT_PULLUP); 610 611 omap_mux_init_signal("sdmmc_cmd", 0); 612 omap_mux_init_signal("sdmmc_clki", 0); 613 omap_mux_init_signal("sdmmc_clko", 0); 614 omap_mux_init_signal("sdmmc_dat0", 0); 615 omap_mux_init_signal("sdmmc_dat_dir0", 0); 616 omap_mux_init_signal("sdmmc_cmd_dir", 0); 617 if (mmc_controller->slots[0].caps & MMC_CAP_4_BIT_DATA) { 618 omap_mux_init_signal("sdmmc_dat1", 0); 619 omap_mux_init_signal("sdmmc_dat2", 0); 620 omap_mux_init_signal("sdmmc_dat3", 0); 621 omap_mux_init_signal("sdmmc_dat_dir1", 0); 622 omap_mux_init_signal("sdmmc_dat_dir2", 0); 623 omap_mux_init_signal("sdmmc_dat_dir3", 0); 624 } 625 626 /* 627 * Use internal loop-back in MMC/SDIO Module Input Clock 628 * selection 629 */ 630 if (mmc_controller->slots[0].internal_clock) { 631 u32 v = omap_ctrl_readl(OMAP2_CONTROL_DEVCONF0); 632 v |= (1 << 24); 633 omap_ctrl_writel(v, OMAP2_CONTROL_DEVCONF0); 634 } 635 } 636 637 void __init omap242x_init_mmc(struct omap_mmc_platform_data **mmc_data) 638 { 639 char *name = "mmci-omap"; 640 641 if (!mmc_data[0]) { 642 pr_err("%s fails: Incomplete platform data\n", __func__); 643 return; 644 } 645 646 omap242x_mmc_mux(mmc_data[0]); 647 omap_mmc_add(name, 0, OMAP2_MMC1_BASE, OMAP2420_MMC_SIZE, 648 INT_24XX_MMC_IRQ, mmc_data[0]); 649 } 650 651 #endif 652 653 /*-------------------------------------------------------------------------*/ 654 655 #if defined(CONFIG_HDQ_MASTER_OMAP) || defined(CONFIG_HDQ_MASTER_OMAP_MODULE) 656 #if defined(CONFIG_SOC_OMAP2430) || defined(CONFIG_SOC_OMAP3430) 657 #define OMAP_HDQ_BASE 0x480B2000 658 #endif 659 static struct resource omap_hdq_resources[] = { 660 { 661 .start = OMAP_HDQ_BASE, 662 .end = OMAP_HDQ_BASE + 0x1C, 663 .flags = IORESOURCE_MEM, 664 }, 665 { 666 .start = INT_24XX_HDQ_IRQ, 667 .flags = IORESOURCE_IRQ, 668 }, 669 }; 670 static struct platform_device omap_hdq_dev = { 671 .name = "omap_hdq", 672 .id = 0, 673 .dev = { 674 .platform_data = NULL, 675 }, 676 .num_resources = ARRAY_SIZE(omap_hdq_resources), 677 .resource = omap_hdq_resources, 678 }; 679 static inline void omap_hdq_init(void) 680 { 681 (void) platform_device_register(&omap_hdq_dev); 682 } 683 #else 684 static inline void omap_hdq_init(void) {} 685 #endif 686 687 /*---------------------------------------------------------------------------*/ 688 689 #if defined(CONFIG_VIDEO_OMAP2_VOUT) || \ 690 defined(CONFIG_VIDEO_OMAP2_VOUT_MODULE) 691 #if defined(CONFIG_FB_OMAP2) || defined(CONFIG_FB_OMAP2_MODULE) 692 static struct resource omap_vout_resource[3 - CONFIG_FB_OMAP2_NUM_FBS] = { 693 }; 694 #else 695 static struct resource omap_vout_resource[2] = { 696 }; 697 #endif 698 699 static struct platform_device omap_vout_device = { 700 .name = "omap_vout", 701 .num_resources = ARRAY_SIZE(omap_vout_resource), 702 .resource = &omap_vout_resource[0], 703 .id = -1, 704 }; 705 static void omap_init_vout(void) 706 { 707 if (platform_device_register(&omap_vout_device) < 0) 708 printk(KERN_ERR "Unable to register OMAP-VOUT device\n"); 709 } 710 #else 711 static inline void omap_init_vout(void) {} 712 #endif 713 714 /*-------------------------------------------------------------------------*/ 715 716 static int __init omap2_init_devices(void) 717 { 718 /* 719 * please keep these calls, and their implementations above, 720 * in alphabetical order so they're easier to sort through. 721 */ 722 omap_init_audio(); 723 omap_init_mcpdm(); 724 omap_init_dmic(); 725 omap_init_camera(); 726 omap_init_mbox(); 727 omap_init_mcspi(); 728 omap_init_pmu(); 729 omap_hdq_init(); 730 omap_init_sti(); 731 omap_init_sham(); 732 omap_init_aes(); 733 omap_init_vout(); 734 735 return 0; 736 } 737 arch_initcall(omap2_init_devices); 738 739 #if defined(CONFIG_OMAP_WATCHDOG) || defined(CONFIG_OMAP_WATCHDOG_MODULE) 740 static int __init omap_init_wdt(void) 741 { 742 int id = -1; 743 struct platform_device *pdev; 744 struct omap_hwmod *oh; 745 char *oh_name = "wd_timer2"; 746 char *dev_name = "omap_wdt"; 747 748 if (!cpu_class_is_omap2()) 749 return 0; 750 751 oh = omap_hwmod_lookup(oh_name); 752 if (!oh) { 753 pr_err("Could not look up wd_timer%d hwmod\n", id); 754 return -EINVAL; 755 } 756 757 pdev = omap_device_build(dev_name, id, oh, NULL, 0, NULL, 0, 0); 758 WARN(IS_ERR(pdev), "Can't build omap_device for %s:%s.\n", 759 dev_name, oh->name); 760 return 0; 761 } 762 subsys_initcall(omap_init_wdt); 763 #endif 764