devices.c 17.0 KB
Newer Older
1 2 3 4 5 6 7 8 9 10
/*
 * linux/arch/arm/mach-omap2/devices.c
 *
 * OMAP2 platform device setup/initialization
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */
11
#include <linux/gpio.h>
12 13 14
#include <linux/kernel.h>
#include <linux/init.h>
#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 25
#include <asm/mach-types.h>
#include <asm/mach/map.h>
26
#include <asm/pmu.h>
27

28 29 30
#include <plat/tc.h>
#include <plat/board.h>
#include <plat/mmc.h>
31
#include <plat/dma.h>
32 33
#include <plat/omap_hwmod.h>
#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 44 45 46

static int __init omap3_l3_init(void)
{
	int l;
	struct omap_hwmod *oh;
47
	struct platform_device *pdev;
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
	char oh_name[L3_MODULES_MAX_LEN];

	/*
	 * To avoid code running on other OMAPs in
	 * multi-omap builds
	 */
	if (!(cpu_is_omap34xx()))
		return -ENODEV;

	l = snprintf(oh_name, L3_MODULES_MAX_LEN, "l3_main");

	oh = omap_hwmod_lookup(oh_name);

	if (!oh)
		pr_err("could not look up %s\n", oh_name);

64
	pdev = omap_device_build("omap_l3_smx", 0, oh, NULL, 0,
65 66
							   NULL, 0, 0);

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 72
}
postcore_initcall(omap3_l3_init);

73 74 75 76
static int __init omap4_l3_init(void)
{
	int l, i;
	struct omap_hwmod *oh[3];
77
	struct platform_device *pdev;
78 79
	char oh_name[L3_MODULES_MAX_LEN];

80 81 82 83
	/* If dtb is there, the devices will be created dynamically */
	if (of_have_populated_dt())
		return -ENODEV;

84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
	/*
	 * To avoid code running on other OMAPs in
	 * multi-omap builds
	 */
	if (!(cpu_is_omap44xx()))
		return -ENODEV;

	for (i = 0; i < L3_MODULES; i++) {
		l = snprintf(oh_name, L3_MODULES_MAX_LEN, "l3_main_%d", i+1);

		oh[i] = omap_hwmod_lookup(oh_name);
		if (!(oh[i]))
			pr_err("could not look up %s\n", oh_name);
	}

99
	pdev = omap_device_build_ss("omap_l3_noc", 0, oh, 3, NULL,
100 101
						     0, NULL, 0, 0);

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 107
}
postcore_initcall(omap4_l3_init);

108
#if defined(CONFIG_VIDEO_OMAP2) || defined(CONFIG_VIDEO_OMAP2_MODULE)
109

110
static struct resource omap2cam_resources[] = {
111
	{
112 113 114 115 116 117 118 119 120 121
		.start		= OMAP24XX_CAMERA_BASE,
		.end		= OMAP24XX_CAMERA_BASE + 0xfff,
		.flags		= IORESOURCE_MEM,
	},
	{
		.start		= INT_24XX_CAM_IRQ,
		.flags		= IORESOURCE_IRQ,
	}
};

122
static struct platform_device omap2cam_device = {
123 124
	.name		= "omap24xxcam",
	.id		= -1,
125 126
	.num_resources	= ARRAY_SIZE(omap2cam_resources),
	.resource	= omap2cam_resources,
127
};
128
#endif
129

130 131 132 133
#if defined(CONFIG_IOMMU_API)

#include <plat/iommu.h>

134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
static struct resource omap3isp_resources[] = {
	{
		.start		= OMAP3430_ISP_BASE,
		.end		= OMAP3430_ISP_END,
		.flags		= IORESOURCE_MEM,
	},
	{
		.start		= OMAP3430_ISP_CCP2_BASE,
		.end		= OMAP3430_ISP_CCP2_END,
		.flags		= IORESOURCE_MEM,
	},
	{
		.start		= OMAP3430_ISP_CCDC_BASE,
		.end		= OMAP3430_ISP_CCDC_END,
		.flags		= IORESOURCE_MEM,
	},
	{
		.start		= OMAP3430_ISP_HIST_BASE,
		.end		= OMAP3430_ISP_HIST_END,
		.flags		= IORESOURCE_MEM,
	},
	{
		.start		= OMAP3430_ISP_H3A_BASE,
		.end		= OMAP3430_ISP_H3A_END,
		.flags		= IORESOURCE_MEM,
	},
	{
		.start		= OMAP3430_ISP_PREV_BASE,
		.end		= OMAP3430_ISP_PREV_END,
		.flags		= IORESOURCE_MEM,
	},
	{
		.start		= OMAP3430_ISP_RESZ_BASE,
		.end		= OMAP3430_ISP_RESZ_END,
		.flags		= IORESOURCE_MEM,
	},
	{
		.start		= OMAP3430_ISP_SBL_BASE,
		.end		= OMAP3430_ISP_SBL_END,
		.flags		= IORESOURCE_MEM,
	},
	{
176 177
		.start		= OMAP3430_ISP_CSI2A_REGS1_BASE,
		.end		= OMAP3430_ISP_CSI2A_REGS1_END,
178 179 180
		.flags		= IORESOURCE_MEM,
	},
	{
181 182 183 184 185 186 187
		.start		= OMAP3430_ISP_CSIPHY2_BASE,
		.end		= OMAP3430_ISP_CSIPHY2_END,
		.flags		= IORESOURCE_MEM,
	},
	{
		.start		= OMAP3630_ISP_CSI2A_REGS2_BASE,
		.end		= OMAP3630_ISP_CSI2A_REGS2_END,
188 189 190
		.flags		= IORESOURCE_MEM,
	},
	{
191 192 193 194 195 196 197 198 199 200 201 202
		.start		= OMAP3630_ISP_CSI2C_REGS1_BASE,
		.end		= OMAP3630_ISP_CSI2C_REGS1_END,
		.flags		= IORESOURCE_MEM,
	},
	{
		.start		= OMAP3630_ISP_CSIPHY1_BASE,
		.end		= OMAP3630_ISP_CSIPHY1_END,
		.flags		= IORESOURCE_MEM,
	},
	{
		.start		= OMAP3630_ISP_CSI2C_REGS2_BASE,
		.end		= OMAP3630_ISP_CSI2C_REGS2_END,
203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
		.flags		= IORESOURCE_MEM,
	},
	{
		.start		= INT_34XX_CAM_IRQ,
		.flags		= IORESOURCE_IRQ,
	}
};

static struct platform_device omap3isp_device = {
	.name		= "omap3isp",
	.id		= -1,
	.num_resources	= ARRAY_SIZE(omap3isp_resources),
	.resource	= omap3isp_resources,
};

218 219 220 221
static struct omap_iommu_arch_data omap3_isp_iommu = {
	.name = "isp",
};

222
int omap3_init_camera(struct isp_platform_data *pdata)
223
{
224
	omap3isp_device.dev.platform_data = pdata;
225 226
	omap3isp_device.dev.archdata.iommu = &omap3_isp_iommu;

227
	return platform_device_register(&omap3isp_device);
228 229
}

230 231 232 233 234 235 236 237 238
#else /* !CONFIG_IOMMU_API */

int omap3_init_camera(struct isp_platform_data *pdata)
{
	return 0;
}

#endif

239 240
static inline void omap_init_camera(void)
{
241 242 243
#if defined(CONFIG_VIDEO_OMAP2) || defined(CONFIG_VIDEO_OMAP2_MODULE)
	if (cpu_is_omap24xx())
		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 252 253 254 255 256 257 258 259 260 261 262 263 264
	struct omap_hwmod *oh;
	struct omap4_keypad_platform_data *keypad_data;
	unsigned int id = -1;
	char *oh_name = "kbd";
	char *name = "omap4-keypad";

	oh = omap_hwmod_lookup(oh_name);
	if (!oh) {
		pr_err("Could not look up %s\n", oh_name);
		return -ENODEV;
	}

	keypad_data = sdp4430_keypad_data;

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)) {
L
Lucas De Marchi 已提交
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 276 277

	return 0;
}

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 285 286

	oh = omap_hwmod_lookup("mailbox");
	if (!oh) {
		pr_err("%s: unable to find hwmod\n", __func__);
287 288
		return;
	}
289

290
	pdev = omap_device_build("omap-mailbox", -1, oh, NULL, 0, NULL, 0, 0);
291 292
	WARN(IS_ERR(pdev), "%s: could not build device, err %ld\n",
						__func__, PTR_ERR(pdev));
293 294 295
}
#else
static inline void omap_init_mbox(void) { }
296
#endif /* CONFIG_OMAP_MBOX_FWK */
297

298 299
static inline void omap_init_sti(void) {}

300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315
#if defined(CONFIG_SND_SOC) || defined(CONFIG_SND_SOC_MODULE)

static struct platform_device omap_pcm = {
	.name	= "omap-pcm-audio",
	.id	= -1,
};

static void omap_init_audio(void)
{
	platform_device_register(&omap_pcm);
}

#else
static inline void omap_init_audio(void) {}
#endif

316 317 318
#if defined(CONFIG_SND_OMAP_SOC_MCPDM) || \
		defined(CONFIG_SND_OMAP_SOC_MCPDM_MODULE)

319
static void __init omap_init_mcpdm(void)
320 321
{
	struct omap_hwmod *oh;
322
	struct platform_device *pdev;
323 324 325 326 327 328 329

	oh = omap_hwmod_lookup("mcpdm");
	if (!oh) {
		printk(KERN_ERR "Could not look up mcpdm hw_mod\n");
		return;
	}

330 331
	pdev = omap_device_build("omap-mcpdm", -1, oh, NULL, 0, NULL, 0, 0);
	WARN(IS_ERR(pdev), "Can't build omap_device for omap-mcpdm.\n");
332 333 334 335 336
}
#else
static inline void omap_init_mcpdm(void) {}
#endif

337 338 339
#if defined(CONFIG_SND_OMAP_SOC_DMIC) || \
		defined(CONFIG_SND_OMAP_SOC_DMIC_MODULE)

340
static void __init omap_init_dmic(void)
341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
{
	struct omap_hwmod *oh;
	struct platform_device *pdev;

	oh = omap_hwmod_lookup("dmic");
	if (!oh) {
		printk(KERN_ERR "Could not look up mcpdm hw_mod\n");
		return;
	}

	pdev = omap_device_build("omap-dmic", -1, oh, NULL, 0, NULL, 0, 0);
	WARN(IS_ERR(pdev), "Can't build omap_device for omap-dmic.\n");
}
#else
static inline void omap_init_dmic(void) {}
#endif

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)
T
Tony Lindgren 已提交
363
{
364
	struct platform_device *pdev;
365 366 367 368 369 370 371 372 373 374
	char *name = "omap2_mcspi";
	struct omap2_mcspi_platform_config *pdata;
	static int spi_num;
	struct omap2_mcspi_dev_attr *mcspi_attrib = oh->dev_attr;

	pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
	if (!pdata) {
		pr_err("Memory allocation for McSPI device failed\n");
		return -ENOMEM;
	}
T
Tony Lindgren 已提交
375

376 377 378 379 380 381 382 383 384 385 386
	pdata->num_cs = mcspi_attrib->num_chipselect;
	switch (oh->class->rev) {
	case OMAP2_MCSPI_REV:
	case OMAP3_MCSPI_REV:
			pdata->regs_offset = 0;
			break;
	case OMAP4_MCSPI_REV:
			pdata->regs_offset = OMAP4_MCSPI_REG_OFFSET;
			break;
	default:
			pr_err("Invalid McSPI Revision value\n");
387
			kfree(pdata);
388 389
			return -EINVAL;
	}
T
Tony Lindgren 已提交
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 396 397
				name, oh->name);
	kfree(pdata);
	return 0;
T
Tony Lindgren 已提交
398 399 400 401
}

static void omap_init_mcspi(void)
{
402
	omap_hwmod_for_each_by_class("mcspi", omap_mcspi_init, NULL);
403 404 405 406 407 408
}

#else
static inline void omap_init_mcspi(void) {}
#endif

409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439
static struct resource omap2_pmu_resource = {
	.start	= 3,
	.end	= 3,
	.flags	= IORESOURCE_IRQ,
};

static struct resource omap3_pmu_resource = {
	.start	= INT_34XX_BENCH_MPU_EMUL,
	.end	= INT_34XX_BENCH_MPU_EMUL,
	.flags	= IORESOURCE_IRQ,
};

static struct platform_device omap_pmu_device = {
	.name		= "arm-pmu",
	.id		= ARM_PMU_DEVICE_CPU,
	.num_resources	= 1,
};

static void omap_init_pmu(void)
{
	if (cpu_is_omap24xx())
		omap_pmu_device.resource = &omap2_pmu_resource;
	else if (cpu_is_omap34xx())
		omap_pmu_device.resource = &omap3_pmu_resource;
	else
		return;

	platform_device_register(&omap_pmu_device);
}


440 441
#if defined(CONFIG_CRYPTO_DEV_OMAP_SHAM) || defined(CONFIG_CRYPTO_DEV_OMAP_SHAM_MODULE)

442
#ifdef CONFIG_ARCH_OMAP2
443
static struct resource omap2_sham_resources[] = {
444 445 446 447 448 449 450 451 452 453
	{
		.start	= OMAP24XX_SEC_SHA1MD5_BASE,
		.end	= OMAP24XX_SEC_SHA1MD5_BASE + 0x64,
		.flags	= IORESOURCE_MEM,
	},
	{
		.start	= INT_24XX_SHA1MD5,
		.flags	= IORESOURCE_IRQ,
	}
};
454 455 456 457 458
static int omap2_sham_resources_sz = ARRAY_SIZE(omap2_sham_resources);
#else
#define omap2_sham_resources		NULL
#define omap2_sham_resources_sz		0
#endif
459

460
#ifdef CONFIG_ARCH_OMAP3
461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483
static struct resource omap3_sham_resources[] = {
	{
		.start	= OMAP34XX_SEC_SHA1MD5_BASE,
		.end	= OMAP34XX_SEC_SHA1MD5_BASE + 0x64,
		.flags	= IORESOURCE_MEM,
	},
	{
		.start	= INT_34XX_SHA1MD52_IRQ,
		.flags	= IORESOURCE_IRQ,
	},
	{
		.start	= OMAP34XX_DMA_SHA1MD5_RX,
		.flags	= IORESOURCE_DMA,
	}
};
static int omap3_sham_resources_sz = ARRAY_SIZE(omap3_sham_resources);
#else
#define omap3_sham_resources		NULL
#define omap3_sham_resources_sz		0
#endif

static struct platform_device sham_device = {
	.name		= "omap-sham",
484 485 486
	.id		= -1,
};

487
static void omap_init_sham(void)
488
{
489 490 491 492 493 494 495 496 497 498 499
	if (cpu_is_omap24xx()) {
		sham_device.resource = omap2_sham_resources;
		sham_device.num_resources = omap2_sham_resources_sz;
	} else if (cpu_is_omap34xx()) {
		sham_device.resource = omap3_sham_resources;
		sham_device.num_resources = omap3_sham_resources_sz;
	} else {
		pr_err("%s: platform not supported\n", __func__);
		return;
	}
	platform_device_register(&sham_device);
500 501
}
#else
502
static inline void omap_init_sham(void) { }
503 504
#endif

505 506
#if defined(CONFIG_CRYPTO_DEV_OMAP_AES) || defined(CONFIG_CRYPTO_DEV_OMAP_AES_MODULE)

507
#ifdef CONFIG_ARCH_OMAP2
508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528
static struct resource omap2_aes_resources[] = {
	{
		.start	= OMAP24XX_SEC_AES_BASE,
		.end	= OMAP24XX_SEC_AES_BASE + 0x4C,
		.flags	= IORESOURCE_MEM,
	},
	{
		.start	= OMAP24XX_DMA_AES_TX,
		.flags	= IORESOURCE_DMA,
	},
	{
		.start	= OMAP24XX_DMA_AES_RX,
		.flags	= IORESOURCE_DMA,
	}
};
static int omap2_aes_resources_sz = ARRAY_SIZE(omap2_aes_resources);
#else
#define omap2_aes_resources		NULL
#define omap2_aes_resources_sz		0
#endif

529
#ifdef CONFIG_ARCH_OMAP3
530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574
static struct resource omap3_aes_resources[] = {
	{
		.start	= OMAP34XX_SEC_AES_BASE,
		.end	= OMAP34XX_SEC_AES_BASE + 0x4C,
		.flags	= IORESOURCE_MEM,
	},
	{
		.start	= OMAP34XX_DMA_AES2_TX,
		.flags	= IORESOURCE_DMA,
	},
	{
		.start	= OMAP34XX_DMA_AES2_RX,
		.flags	= IORESOURCE_DMA,
	}
};
static int omap3_aes_resources_sz = ARRAY_SIZE(omap3_aes_resources);
#else
#define omap3_aes_resources		NULL
#define omap3_aes_resources_sz		0
#endif

static struct platform_device aes_device = {
	.name		= "omap-aes",
	.id		= -1,
};

static void omap_init_aes(void)
{
	if (cpu_is_omap24xx()) {
		aes_device.resource = omap2_aes_resources;
		aes_device.num_resources = omap2_aes_resources_sz;
	} else if (cpu_is_omap34xx()) {
		aes_device.resource = omap3_aes_resources;
		aes_device.num_resources = omap3_aes_resources_sz;
	} else {
		pr_err("%s: platform not supported\n", __func__);
		return;
	}
	platform_device_register(&aes_device);
}

#else
static inline void omap_init_aes(void) { }
#endif

575 576
/*-------------------------------------------------------------------------*/

577
#if defined(CONFIG_MMC_OMAP) || defined(CONFIG_MMC_OMAP_MODULE)
578

579 580
static inline void omap242x_mmc_mux(struct omap_mmc_platform_data
							*mmc_controller)
581
{
582 583 584 585 586 587 588 589 590
	if ((mmc_controller->slots[0].switch_pin > 0) && \
		(mmc_controller->slots[0].switch_pin < OMAP_MAX_GPIO_LINES))
		omap_mux_init_gpio(mmc_controller->slots[0].switch_pin,
					OMAP_PIN_INPUT_PULLUP);
	if ((mmc_controller->slots[0].gpio_wp > 0) && \
		(mmc_controller->slots[0].gpio_wp < OMAP_MAX_GPIO_LINES))
		omap_mux_init_gpio(mmc_controller->slots[0].gpio_wp,
					OMAP_PIN_INPUT_PULLUP);

591 592 593 594 595 596 597 598 599 600 601 602 603
	omap_mux_init_signal("sdmmc_cmd", 0);
	omap_mux_init_signal("sdmmc_clki", 0);
	omap_mux_init_signal("sdmmc_clko", 0);
	omap_mux_init_signal("sdmmc_dat0", 0);
	omap_mux_init_signal("sdmmc_dat_dir0", 0);
	omap_mux_init_signal("sdmmc_cmd_dir", 0);
	if (mmc_controller->slots[0].caps & MMC_CAP_4_BIT_DATA) {
		omap_mux_init_signal("sdmmc_dat1", 0);
		omap_mux_init_signal("sdmmc_dat2", 0);
		omap_mux_init_signal("sdmmc_dat3", 0);
		omap_mux_init_signal("sdmmc_dat_dir1", 0);
		omap_mux_init_signal("sdmmc_dat_dir2", 0);
		omap_mux_init_signal("sdmmc_dat_dir3", 0);
604
	}
V
Vikram Pandita 已提交
605

606 607 608 609 610 611 612 613
	/*
	 * Use internal loop-back in MMC/SDIO Module Input Clock
	 * selection
	 */
	if (mmc_controller->slots[0].internal_clock) {
		u32 v = omap_ctrl_readl(OMAP2_CONTROL_DEVCONF0);
		v |= (1 << 24);
		omap_ctrl_writel(v, OMAP2_CONTROL_DEVCONF0);
V
Vikram Pandita 已提交
614
	}
615 616
}

617
void __init omap242x_init_mmc(struct omap_mmc_platform_data **mmc_data)
618
{
619
	char *name = "mmci-omap";
620

621 622 623 624
	if (!mmc_data[0]) {
		pr_err("%s fails: Incomplete platform data\n", __func__);
		return;
	}
625

626 627 628
	omap242x_mmc_mux(mmc_data[0]);
	omap_mmc_add(name, 0, OMAP2_MMC1_BASE, OMAP2420_MMC_SIZE,
					INT_24XX_MMC_IRQ, mmc_data[0]);
629 630 631 632 633 634
}

#endif

/*-------------------------------------------------------------------------*/

635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658
#if defined(CONFIG_HDQ_MASTER_OMAP) || defined(CONFIG_HDQ_MASTER_OMAP_MODULE)
#define OMAP_HDQ_BASE	0x480B2000
static struct resource omap_hdq_resources[] = {
	{
		.start		= OMAP_HDQ_BASE,
		.end		= OMAP_HDQ_BASE + 0x1C,
		.flags		= IORESOURCE_MEM,
	},
	{
		.start		= INT_24XX_HDQ_IRQ,
		.flags		= IORESOURCE_IRQ,
	},
};
static struct platform_device omap_hdq_dev = {
	.name = "omap_hdq",
	.id = 0,
	.dev = {
		.platform_data = NULL,
	},
	.num_resources	= ARRAY_SIZE(omap_hdq_resources),
	.resource	= omap_hdq_resources,
};
static inline void omap_hdq_init(void)
{
659 660 661 662
	if (cpu_is_omap2420())
		return;

	platform_device_register(&omap_hdq_dev);
663 664 665 666 667
}
#else
static inline void omap_hdq_init(void) {}
#endif

668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694
/*---------------------------------------------------------------------------*/

#if defined(CONFIG_VIDEO_OMAP2_VOUT) || \
	defined(CONFIG_VIDEO_OMAP2_VOUT_MODULE)
#if defined(CONFIG_FB_OMAP2) || defined(CONFIG_FB_OMAP2_MODULE)
static struct resource omap_vout_resource[3 - CONFIG_FB_OMAP2_NUM_FBS] = {
};
#else
static struct resource omap_vout_resource[2] = {
};
#endif

static struct platform_device omap_vout_device = {
	.name		= "omap_vout",
	.num_resources	= ARRAY_SIZE(omap_vout_resource),
	.resource 	= &omap_vout_resource[0],
	.id		= -1,
};
static void omap_init_vout(void)
{
	if (platform_device_register(&omap_vout_device) < 0)
		printk(KERN_ERR "Unable to register OMAP-VOUT device\n");
}
#else
static inline void omap_init_vout(void) {}
#endif

695 696 697 698
/*-------------------------------------------------------------------------*/

static int __init omap2_init_devices(void)
{
699 700
	/*
	 * please keep these calls, and their implementations above,
701 702
	 * in alphabetical order so they're easier to sort through.
	 */
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 717 718

	return 0;
}
arch_initcall(omap2_init_devices);
719 720 721 722 723

#if defined(CONFIG_OMAP_WATCHDOG) || defined(CONFIG_OMAP_WATCHDOG_MODULE)
static int __init omap_init_wdt(void)
{
	int id = -1;
724
	struct platform_device *pdev;
725 726 727 728 729 730 731 732 733 734 735 736 737
	struct omap_hwmod *oh;
	char *oh_name = "wd_timer2";
	char *dev_name = "omap_wdt";

	if (!cpu_class_is_omap2())
		return 0;

	oh = omap_hwmod_lookup(oh_name);
	if (!oh) {
		pr_err("Could not look up wd_timer%d hwmod\n", id);
		return -EINVAL;
	}

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 741 742 743 744
				dev_name, oh->name);
	return 0;
}
subsys_initcall(omap_init_wdt);
#endif