[GitHub/mt8127/android_kernel_alcatel_ttab.git] / arch / arm / mach-omap2 / devices.c

/*
 * 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.
 */
#include <linux/gpio.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/clk.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/of.h>
#include <linux/pinctrl/machine.h>
#include <linux/platform_data/omap4-keypad.h>
#include <linux/platform_data/omap_ocp2scp.h>

#include <asm/mach-types.h>
#include <asm/mach/map.h>

#include <linux/omap-dma.h>

#include "iomap.h"
#include "omap_hwmod.h"
#include "omap_device.h"
#include "omap4-keypad.h"

#include "soc.h"
#include "common.h"
#include "mux.h"
#include "control.h"
#include "devices.h"
#include "dma.h"

#define L3_MODULES_MAX_LEN 12
#define L3_MODULES 3

static int __init omap3_l3_init(void)
{
	struct omap_hwmod *oh;
	struct platform_device *pdev;
	char oh_name[L3_MODULES_MAX_LEN];

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

	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);

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

	WARN(IS_ERR(pdev), "could not build omap_device for %s\n", oh_name);

	return IS_ERR(pdev) ? PTR_ERR(pdev) : 0;
}
postcore_initcall(omap3_l3_init);

static int __init omap4_l3_init(void)
{
	int i;
	struct omap_hwmod *oh[3];
	struct platform_device *pdev;
	char oh_name[L3_MODULES_MAX_LEN];

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

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

	for (i = 0; i < L3_MODULES; i++) {
		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);
	}

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

	WARN(IS_ERR(pdev), "could not build omap_device for %s\n", oh_name);

	return IS_ERR(pdev) ? PTR_ERR(pdev) : 0;
}
postcore_initcall(omap4_l3_init);

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

static struct resource omap2cam_resources[] = {
	{
		.start		= OMAP24XX_CAMERA_BASE,
		.end		= OMAP24XX_CAMERA_BASE + 0xfff,
		.flags		= IORESOURCE_MEM,
	},
	{
		.start		= 24 + OMAP_INTC_START,
		.flags		= IORESOURCE_IRQ,
	}
};

static struct platform_device omap2cam_device = {
	.name		= "omap24xxcam",
	.id		= -1,
	.num_resources	= ARRAY_SIZE(omap2cam_resources),
	.resource	= omap2cam_resources,
};
#endif

#if defined(CONFIG_IOMMU_API)

#include <linux/platform_data/iommu-omap.h>

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,
	},
	{
		.start		= OMAP3430_ISP_CSI2A_REGS1_BASE,
		.end		= OMAP3430_ISP_CSI2A_REGS1_END,
		.flags		= IORESOURCE_MEM,
	},
	{
		.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,
		.flags		= IORESOURCE_MEM,
	},
	{
		.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,
		.flags		= IORESOURCE_MEM,
	},
	{
		.start		= OMAP343X_CTRL_BASE + OMAP343X_CONTROL_CSIRXFE,
		.end		= OMAP343X_CTRL_BASE + OMAP343X_CONTROL_CSIRXFE + 3,
		.flags		= IORESOURCE_MEM,
	},
	{
		.start		= OMAP343X_CTRL_BASE + OMAP3630_CONTROL_CAMERA_PHY_CTRL,
		.end		= OMAP343X_CTRL_BASE + OMAP3630_CONTROL_CAMERA_PHY_CTRL + 3,
		.flags		= IORESOURCE_MEM,
	},
	{
		.start		= 24 + OMAP_INTC_START,
		.flags		= IORESOURCE_IRQ,
	}
};

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

static struct omap_iommu_arch_data omap3_isp_iommu = {
	.name = "isp",
};

int omap3_init_camera(struct isp_platform_data *pdata)
{
	omap3isp_device.dev.platform_data = pdata;
	omap3isp_device.dev.archdata.iommu = &omap3_isp_iommu;

	return platform_device_register(&omap3isp_device);
}

#else /* !CONFIG_IOMMU_API */

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

#endif

static inline void omap_init_camera(void)
{
#if defined(CONFIG_VIDEO_OMAP2) || defined(CONFIG_VIDEO_OMAP2_MODULE)
	if (cpu_is_omap24xx())
		platform_device_register(&omap2cam_device);
#endif
}

int __init omap4_keyboard_init(struct omap4_keypad_platform_data
			*sdp4430_keypad_data, struct omap_board_data *bdata)
{
	struct platform_device *pdev;
	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;

	pdev = omap_device_build(name, id, oh, keypad_data,
			sizeof(struct omap4_keypad_platform_data), NULL, 0, 0);

	if (IS_ERR(pdev)) {
		WARN(1, "Can't build omap_device for %s:%s.\n",
						name, oh->name);
		return PTR_ERR(pdev);
	}
	oh->mux = omap_hwmod_mux_init(bdata->pads, bdata->pads_cnt);

	return 0;
}

#if defined(CONFIG_OMAP_MBOX_FWK) || defined(CONFIG_OMAP_MBOX_FWK_MODULE)
static inline void __init omap_init_mbox(void)
{
	struct omap_hwmod *oh;
	struct platform_device *pdev;

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

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

static inline void omap_init_sti(void) {}

#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

#if defined(CONFIG_SND_OMAP_SOC_MCPDM) || \
		defined(CONFIG_SND_OMAP_SOC_MCPDM_MODULE)

static void __init omap_init_mcpdm(void)
{
	struct omap_hwmod *oh;
	struct platform_device *pdev;

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

	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");
}
#else
static inline void omap_init_mcpdm(void) {}
#endif

#if defined(CONFIG_SND_OMAP_SOC_DMIC) || \
		defined(CONFIG_SND_OMAP_SOC_DMIC_MODULE)

static void __init omap_init_dmic(void)
{
	struct omap_hwmod *oh;
	struct platform_device *pdev;

	oh = omap_hwmod_lookup("dmic");
	if (!oh) {
		pr_err("Could not look up dmic 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

#if defined(CONFIG_SND_OMAP_SOC_OMAP_HDMI) || \
		defined(CONFIG_SND_OMAP_SOC_OMAP_HDMI_MODULE)

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

static void __init omap_init_hdmi_audio(void)
{
	struct omap_hwmod *oh;
	struct platform_device *pdev;

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

	pdev = omap_device_build("omap-hdmi-audio-dai",
		-1, oh, NULL, 0, NULL, 0, 0);
	WARN(IS_ERR(pdev),
	     "Can't build omap_device for omap-hdmi-audio-dai.\n");

	platform_device_register(&omap_hdmi_audio);
}
#else
static inline void omap_init_hdmi_audio(void) {}
#endif

#if defined(CONFIG_SPI_OMAP24XX) || defined(CONFIG_SPI_OMAP24XX_MODULE)

#include <linux/platform_data/spi-omap2-mcspi.h>

static int __init omap_mcspi_init(struct omap_hwmod *oh, void *unused)
{
	struct platform_device *pdev;
	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;
	}

	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");
			kfree(pdata);
			return -EINVAL;
	}

	spi_num++;
	pdev = omap_device_build(name, spi_num, oh, pdata,
				sizeof(*pdata),	NULL, 0, 0);
	WARN(IS_ERR(pdev), "Can't build omap_device for %s:%s\n",
				name, oh->name);
	kfree(pdata);
	return 0;
}

static void omap_init_mcspi(void)
{
	omap_hwmod_for_each_by_class("mcspi", omap_mcspi_init, NULL);
}

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

/**
 * omap_init_rng - bind the RNG hwmod to the RNG omap_device
 *
 * Bind the RNG hwmod to the RNG omap_device.  No return value.
 */
static void omap_init_rng(void)
{
	struct omap_hwmod *oh;
	struct platform_device *pdev;

	oh = omap_hwmod_lookup("rng");
	if (!oh)
		return;

	pdev = omap_device_build("omap_rng", -1, oh, NULL, 0, NULL, 0, 0);
	WARN(IS_ERR(pdev), "Can't build omap_device for omap_rng\n");
}

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

#ifdef CONFIG_ARCH_OMAP2
static struct resource omap2_sham_resources[] = {
	{
		.start	= OMAP24XX_SEC_SHA1MD5_BASE,
		.end	= OMAP24XX_SEC_SHA1MD5_BASE + 0x64,
		.flags	= IORESOURCE_MEM,
	},
	{
		.start	= 51 + OMAP_INTC_START,
		.flags	= IORESOURCE_IRQ,
	}
};
static int omap2_sham_resources_sz = ARRAY_SIZE(omap2_sham_resources);
#else
#define omap2_sham_resources		NULL
#define omap2_sham_resources_sz		0
#endif

#ifdef CONFIG_ARCH_OMAP3
static struct resource omap3_sham_resources[] = {
	{
		.start	= OMAP34XX_SEC_SHA1MD5_BASE,
		.end	= OMAP34XX_SEC_SHA1MD5_BASE + 0x64,
		.flags	= IORESOURCE_MEM,
	},
	{
		.start	= 49 + OMAP_INTC_START,
		.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",
	.id		= -1,
};

static void omap_init_sham(void)
{
	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);
}
#else
static inline void omap_init_sham(void) { }
#endif

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

#ifdef CONFIG_ARCH_OMAP2
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

#ifdef CONFIG_ARCH_OMAP3
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

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

#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

#if defined(CONFIG_OMAP_OCP2SCP) || defined(CONFIG_OMAP_OCP2SCP_MODULE)
static int count_ocp2scp_devices(struct omap_ocp2scp_dev *ocp2scp_dev)
{
	int cnt	= 0;

	while (ocp2scp_dev->drv_name != NULL) {
		cnt++;
		ocp2scp_dev++;
	}

	return cnt;
}

static void omap_init_ocp2scp(void)
{
	struct omap_hwmod	*oh;
	struct platform_device	*pdev;
	int			bus_id = -1, dev_cnt = 0, i;
	struct omap_ocp2scp_dev	*ocp2scp_dev;
	const char		*oh_name, *name;
	struct omap_ocp2scp_platform_data *pdata;

	if (!cpu_is_omap44xx())
		return;

	oh_name = "ocp2scp_usb_phy";
	name	= "omap-ocp2scp";

	oh = omap_hwmod_lookup(oh_name);
	if (!oh) {
		pr_err("%s: could not find omap_hwmod for %s\n", __func__,
								oh_name);
		return;
	}

	pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
	if (!pdata) {
		pr_err("%s: No memory for ocp2scp pdata\n", __func__);
		return;
	}

	ocp2scp_dev = oh->dev_attr;
	dev_cnt = count_ocp2scp_devices(ocp2scp_dev);

	if (!dev_cnt) {
		pr_err("%s: No devices connected to ocp2scp\n", __func__);
		kfree(pdata);
		return;
	}

	pdata->devices = kzalloc(sizeof(struct omap_ocp2scp_dev *)
					* dev_cnt, GFP_KERNEL);
	if (!pdata->devices) {
		pr_err("%s: No memory for ocp2scp pdata devices\n", __func__);
		kfree(pdata);
		return;
	}

	for (i = 0; i < dev_cnt; i++, ocp2scp_dev++)
		pdata->devices[i] = ocp2scp_dev;

	pdata->dev_cnt	= dev_cnt;

	pdev = omap_device_build(name, bus_id, oh, pdata, sizeof(*pdata), NULL,
								0, false);
	if (IS_ERR(pdev)) {
		pr_err("Could not build omap_device for %s %s\n",
						name, oh_name);
		kfree(pdata->devices);
		kfree(pdata);
		return;
	}
}
#else
static inline void omap_init_ocp2scp(void) { }
#endif

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

static int __init omap2_init_devices(void)
{
	/* Enable dummy states for those platforms without pinctrl support */
	if (!of_have_populated_dt())
		pinctrl_provide_dummies();

	/*
	 * please keep these calls, and their implementations above,
	 * in alphabetical order so they're easier to sort through.
	 */
	omap_init_audio();
	omap_init_camera();
	omap_init_hdmi_audio();
	omap_init_mbox();
	/* If dtb is there, the devices will be created dynamically */
	if (!of_have_populated_dt()) {
		omap_init_dmic();
		omap_init_mcpdm();
		omap_init_mcspi();
	}
	omap_init_sti();
	omap_init_rng();
	omap_init_sham();
	omap_init_aes();
	omap_init_vout();
	omap_init_ocp2scp();

	return 0;
}
arch_initcall(omap2_init_devices);
Commit	Line	Data
1dbae815 TL	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	*/
2f8163ba	11	#include <linux/gpio.h>
1dbae815 TL	12	#include <linux/kernel.h>
	13	#include <linux/init.h>
	14	#include <linux/platform_device.h>
fced80c7	15	#include <linux/io.h>
917fa280	16	#include <linux/clk.h>
f2ce6231	17	#include <linux/err.h>
1a5d8190	18	#include <linux/slab.h>
ad8dfac6	19	#include <linux/of.h>
484202f4	20	#include <linux/pinctrl/machine.h>
0f1142a5	21	#include <linux/platform_data/omap4-keypad.h>
459bc971	22	#include <linux/platform_data/omap_ocp2scp.h>
1dbae815	23
1dbae815 TL	24	#include <asm/mach-types.h>
	25	#include <asm/mach/map.h>
	26
45c3eb7d	27	#include <linux/omap-dma.h>
2a296c8f	28
ee0839c2	29	#include "iomap.h"
2a296c8f	30	#include "omap_hwmod.h"
25c7d49e	31	#include "omap_device.h"
0e70156d	32	#include "omap4-keypad.h"
1dbae815	33
7d7e1eba TL	34	#include "soc.h"
7d7e1eba TL	35	#include "common.h"
4896e394	36	#include "mux.h"
4814ced5	37	#include "control.h"
a11f6706	38	#include "devices.h"
d5e7c864	39	#include "dma.h"
4896e394	40
0abcf618	41	#define L3_MODULES_MAX_LEN 12
a4dc616a	42	#define L3_MODULES 3
0abcf618	43
	44	static int __init omap3_l3_init(void)
	45	{
0abcf618	46	struct omap_hwmod *oh;
3528c58e	47	struct platform_device *pdev;
0abcf618	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
eeb3711b	57	snprintf(oh_name, L3_MODULES_MAX_LEN, "l3_main");
0abcf618	58
	59	oh = omap_hwmod_lookup(oh_name);
	60
	61	if (!oh)
	62	pr_err("could not look up %s\n", oh_name);
	63
3528c58e	64	pdev = omap_device_build("omap_l3_smx", 0, oh, NULL, 0,
0abcf618	65	NULL, 0, 0);
0abcf618	66
3528c58e	67	WARN(IS_ERR(pdev), "could not build omap_device for %s\n", oh_name);
0abcf618	68
3528c58e	69	return IS_ERR(pdev) ? PTR_ERR(pdev) : 0;
0abcf618	70	}
	71	postcore_initcall(omap3_l3_init);
	72
a4dc616a	73	static int __init omap4_l3_init(void)
a4dc616a	74	{
eeb3711b	75	int i;
a4dc616a	76	struct omap_hwmod *oh[3];
3528c58e	77	struct platform_device *pdev;
a4dc616a	78	char oh_name[L3_MODULES_MAX_LEN];
a4dc616a	79
ad8dfac6 BC	80	/* If dtb is there, the devices will be created dynamically */
	81	if (of_have_populated_dt())
	82	return -ENODEV;
	83
a4dc616a	84	/*
	85	* To avoid code running on other OMAPs in
	86	* multi-omap builds
	87	*/
e17933c2	88	if (!cpu_is_omap44xx() && !soc_is_omap54xx())
a4dc616a	89	return -ENODEV;
	90
	91	for (i = 0; i < L3_MODULES; i++) {
eeb3711b	92	snprintf(oh_name, L3_MODULES_MAX_LEN, "l3_main_%d", i+1);
a4dc616a	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
3528c58e	99	pdev = omap_device_build_ss("omap_l3_noc", 0, oh, 3, NULL,
a4dc616a	100	0, NULL, 0, 0);
a4dc616a	101
3528c58e	102	WARN(IS_ERR(pdev), "could not build omap_device for %s\n", oh_name);
a4dc616a	103
3528c58e	104	return IS_ERR(pdev) ? PTR_ERR(pdev) : 0;
a4dc616a	105	}
	106	postcore_initcall(omap4_l3_init);
	107
828c707e	108	#if defined(CONFIG_VIDEO_OMAP2) \|\| defined(CONFIG_VIDEO_OMAP2_MODULE)
c40fae95	109
cfe2cde6	110	static struct resource omap2cam_resources[] = {
c40fae95	111	{
828c707e TL	112	.start = OMAP24XX_CAMERA_BASE,
	113	.end = OMAP24XX_CAMERA_BASE + 0xfff,
	114	.flags = IORESOURCE_MEM,
	115	},
	116	{
7d7e1eba	117	.start = 24 + OMAP_INTC_START,
828c707e TL	118	.flags = IORESOURCE_IRQ,
	119	}
	120	};
	121
cfe2cde6	122	static struct platform_device omap2cam_device = {
828c707e TL	123	.name = "omap24xxcam",
828c707e TL	124	.id = -1,
cfe2cde6 SA	125	.num_resources = ARRAY_SIZE(omap2cam_resources),
cfe2cde6 SA	126	.resource = omap2cam_resources,
828c707e	127	};
a11f6706	128	#endif
828c707e	129
1a51a0ce OBC	130	#if defined(CONFIG_IOMMU_API)
1a51a0ce OBC	131
2ab7c848	132	#include <linux/platform_data/iommu-omap.h>
1a51a0ce	133
828c707e TL	134	static struct resource omap3isp_resources[] = {
	135	{
	136	.start = OMAP3430_ISP_BASE,
	137	.end = OMAP3430_ISP_END,
	138	.flags = IORESOURCE_MEM,
	139	},
828c707e TL	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	{
6817a69a TT	176	.start = OMAP3430_ISP_CSI2A_REGS1_BASE,
6817a69a TT	177	.end = OMAP3430_ISP_CSI2A_REGS1_END,
828c707e TL	178	.flags = IORESOURCE_MEM,
	179	},
	180	{
6817a69a TT	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,
828c707e TL	188	.flags = IORESOURCE_MEM,
	189	},
	190	{
6817a69a TT	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,
828c707e TL	203	.flags = IORESOURCE_MEM,
828c707e TL	204	},
c19d19eb SA	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	},
828c707e	215	{
7d7e1eba	216	.start = 24 + OMAP_INTC_START,
828c707e TL	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
c8eaab3b OBC	228	static struct omap_iommu_arch_data omap3_isp_iommu = {
	229	.name = "isp",
	230	};
	231
a11f6706	232	int omap3_init_camera(struct isp_platform_data *pdata)
828c707e	233	{
a11f6706	234	omap3isp_device.dev.platform_data = pdata;
c8eaab3b OBC	235	omap3isp_device.dev.archdata.iommu = &omap3_isp_iommu;
c8eaab3b OBC	236
a11f6706	237	return platform_device_register(&omap3isp_device);
828c707e	238	}
828c707e	239
1a51a0ce OBC	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
828c707e TL	249	static inline void omap_init_camera(void)
828c707e TL	250	{
cfe2cde6 SA	251	#if defined(CONFIG_VIDEO_OMAP2) \|\| defined(CONFIG_VIDEO_OMAP2_MODULE)
	252	if (cpu_is_omap24xx())
	253	platform_device_register(&omap2cam_device);
828c707e	254	#endif
cfe2cde6	255	}
828c707e	256
59556765	257	int __init omap4_keyboard_init(struct omap4_keypad_platform_data
f67df6c6	258	sdp4430_keypad_data, struct omap_board_data bdata)
59556765	259	{
3528c58e	260	struct platform_device *pdev;
59556765 SR	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
3528c58e	275	pdev = omap_device_build(name, id, oh, keypad_data,
f718e2c0	276	sizeof(struct omap4_keypad_platform_data), NULL, 0, 0);
59556765	277
3528c58e	278	if (IS_ERR(pdev)) {
25985edc	279	WARN(1, "Can't build omap_device for %s:%s.\n",
59556765	280	name, oh->name);
3528c58e	281	return PTR_ERR(pdev);
59556765	282	}
f67df6c6	283	oh->mux = omap_hwmod_mux_init(bdata->pads, bdata->pads_cnt);
59556765 SR	284
	285	return 0;
	286	}
	287
6c20a683	288	#if defined(CONFIG_OMAP_MBOX_FWK) \|\| defined(CONFIG_OMAP_MBOX_FWK_MODULE)
9cf793f9	289	static inline void __init omap_init_mbox(void)
c40fae95	290	{
69dbf857	291	struct omap_hwmod *oh;
3528c58e	292	struct platform_device *pdev;
69dbf857 FC	293
	294	oh = omap_hwmod_lookup("mailbox");
	295	if (!oh) {
	296	pr_err("%s: unable to find hwmod\n", __func__);
6c20a683 HD	297	return;
6c20a683 HD	298	}
69dbf857	299
f718e2c0	300	pdev = omap_device_build("omap-mailbox", -1, oh, NULL, 0, NULL, 0, 0);
3528c58e KH	301	WARN(IS_ERR(pdev), "%s: could not build device, err %ld\n",
3528c58e KH	302	__func__, PTR_ERR(pdev));
c40fae95 TL	303	}
	304	#else
	305	static inline void omap_init_mbox(void) { }
6c20a683	306	#endif /* CONFIG_OMAP_MBOX_FWK */
c40fae95	307
9b6553cd	308	static inline void omap_init_sti(void) {}
9b6553cd	309
f0fba2ad LG	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
f0fba2ad LG	317	static void omap_init_audio(void)
f0fba2ad LG	318	{
f0fba2ad LG	319	platform_device_register(&omap_pcm);
	320	}
	321
	322	#else
	323	static inline void omap_init_audio(void) {}
	324	#endif
	325
d231f5cb PU	326	#if defined(CONFIG_SND_OMAP_SOC_MCPDM) \|\| \
	327	defined(CONFIG_SND_OMAP_SOC_MCPDM_MODULE)
	328
9cf793f9	329	static void __init omap_init_mcpdm(void)
d231f5cb PU	330	{
d231f5cb PU	331	struct omap_hwmod *oh;
927dbbb2	332	struct platform_device *pdev;
d231f5cb PU	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
927dbbb2 PU	340	pdev = omap_device_build("omap-mcpdm", -1, oh, NULL, 0, NULL, 0, 0);
927dbbb2 PU	341	WARN(IS_ERR(pdev), "Can't build omap_device for omap-mcpdm.\n");
d231f5cb PU	342	}
	343	#else
	344	static inline void omap_init_mcpdm(void) {}
	345	#endif
	346
de9eb097 PU	347	#if defined(CONFIG_SND_OMAP_SOC_DMIC) \|\| \
	348	defined(CONFIG_SND_OMAP_SOC_DMIC_MODULE)
	349
9cf793f9	350	static void __init omap_init_dmic(void)
de9eb097 PU	351	{
	352	struct omap_hwmod *oh;
	353	struct platform_device *pdev;
	354
	355	oh = omap_hwmod_lookup("dmic");
	356	if (!oh) {
49c58e82	357	pr_err("Could not look up dmic hw_mod\n");
de9eb097 PU	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
5eeec215 RN	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
646e3ed1	398	#if defined(CONFIG_SPI_OMAP24XX) \|\| defined(CONFIG_SPI_OMAP24XX_MODULE)
ed7eb9d9	399
2203747c	400	#include <linux/platform_data/spi-omap2-mcspi.h>
ed7eb9d9	401
9cf793f9	402	static int __init omap_mcspi_init(struct omap_hwmod oh, void unused)
af41a12f	403	{
3528c58e	404	struct platform_device *pdev;
1a5d8190 C	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	}
af41a12f	415
1a5d8190 C	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");
e0feca89	427	kfree(pdata);
1a5d8190 C	428	return -EINVAL;
1a5d8190 C	429	}
af41a12f	430
1a5d8190	431	spi_num++;
3528c58e	432	pdev = omap_device_build(name, spi_num, oh, pdata,
f718e2c0	433	sizeof(*pdata), NULL, 0, 0);
3528c58e	434	WARN(IS_ERR(pdev), "Can't build omap_device for %s:%s\n",
1a5d8190 C	435	name, oh->name);
	436	kfree(pdata);
	437	return 0;
af41a12f	438	}
af41a12f TL	439
	440	static void omap_init_mcspi(void)
	441	{
1a5d8190	442	omap_hwmod_for_each_by_class("mcspi", omap_mcspi_init, NULL);
ed7eb9d9 JY	443	}
	444
	445	#else
	446	static inline void omap_init_mcspi(void) {}
	447	#endif
	448
4848d460 PW	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	}
88341334	466
ee5500c4 DK	467	#if defined(CONFIG_CRYPTO_DEV_OMAP_SHAM) \|\| defined(CONFIG_CRYPTO_DEV_OMAP_SHAM_MODULE)
ee5500c4 DK	468
edc774ed	469	#ifdef CONFIG_ARCH_OMAP2
ee5500c4	470	static struct resource omap2_sham_resources[] = {
646e3ed1 TL	471	{
	472	.start = OMAP24XX_SEC_SHA1MD5_BASE,
	473	.end = OMAP24XX_SEC_SHA1MD5_BASE + 0x64,
	474	.flags = IORESOURCE_MEM,
	475	},
	476	{
7d7e1eba	477	.start = 51 + OMAP_INTC_START,
646e3ed1 TL	478	.flags = IORESOURCE_IRQ,
	479	}
	480	};
ee5500c4 DK	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
646e3ed1	486
edc774ed	487	#ifdef CONFIG_ARCH_OMAP3
ee5500c4 DK	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	{
7d7e1eba	495	.start = 49 + OMAP_INTC_START,
ee5500c4 DK	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",
646e3ed1	511	.id = -1,
646e3ed1 TL	512	};
646e3ed1 TL	513
ee5500c4	514	static void omap_init_sham(void)
646e3ed1	515	{
ee5500c4 DK	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);
646e3ed1 TL	527	}
646e3ed1 TL	528	#else
ee5500c4	529	static inline void omap_init_sham(void) { }
646e3ed1 TL	530	#endif
646e3ed1 TL	531
b744c679 DK	532	#if defined(CONFIG_CRYPTO_DEV_OMAP_AES) \|\| defined(CONFIG_CRYPTO_DEV_OMAP_AES_MODULE)
b744c679 DK	533
82a0c149	534	#ifdef CONFIG_ARCH_OMAP2
b744c679 DK	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
82a0c149	556	#ifdef CONFIG_ARCH_OMAP3
b744c679 DK	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
d8874665 TL	602	/-------------------------------------------------------------------------/
d8874665 TL	603
b227358d VH	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
459bc971 KVA	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 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
1dbae815 TL	706	/-------------------------------------------------------------------------/
	707
	708	static int __init omap2_init_devices(void)
	709	{
484202f4 MP	710	/* Enable dummy states for those platforms without pinctrl support */
	711	if (!of_have_populated_dt())
	712	pinctrl_provide_dummies();
	713
81fbc5ef PW	714	/*
81fbc5ef PW	715	* please keep these calls, and their implementations above,
1dbae815 TL	716	* in alphabetical order so they're easier to sort through.
1dbae815 TL	717	*/
f0fba2ad	718	omap_init_audio();
828c707e	719	omap_init_camera();
5eeec215	720	omap_init_hdmi_audio();
c40fae95	721	omap_init_mbox();
efcf1e50	722	/* If dtb is there, the devices will be created dynamically */
259bd6ce PU	723	if (!of_have_populated_dt()) {
259bd6ce PU	724	omap_init_dmic();
4b21ffcf	725	omap_init_mcpdm();
efcf1e50	726	omap_init_mcspi();
259bd6ce	727	}
9b6553cd	728	omap_init_sti();
4848d460	729	omap_init_rng();
ee5500c4	730	omap_init_sham();
b744c679	731	omap_init_aes();
b227358d	732	omap_init_vout();
459bc971	733	omap_init_ocp2scp();
1dbae815 TL	734
	735	return 0;
	736	}
	737	arch_initcall(omap2_init_devices);