[deliverable/linux.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/mailbox-omap.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 "display.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);

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

	return PTR_RET(pdev);
}
omap_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);

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

	return PTR_RET(pdev);
}
omap_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 = "mmu_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));

	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_OMAP2PLUS_MBOX) || defined(CONFIG_OMAP2PLUS_MBOX_MODULE)
static inline void __init omap_init_mbox(void)
{
	struct omap_hwmod *oh;
	struct platform_device *pdev;
	struct omap_mbox_pdata *pdata;

	oh = omap_hwmod_lookup("mailbox");
	if (!oh) {
		pr_err("%s: unable to find hwmod\n", __func__);
		return;
	}
	if (!oh->dev_attr) {
		pr_err("%s: hwmod doesn't have valid attrs\n", __func__);
		return;
	}

	pdata = (struct omap_mbox_pdata *)oh->dev_attr;
	pdev = omap_device_build("omap-mailbox", -1, oh, pdata, sizeof(*pdata));
	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_OMAP2PLUS_MBOX */

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

	pdev = omap_device_build("omap-hdmi-audio-dai", -1, oh, NULL, 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));
	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);
	WARN(IS_ERR(pdev), "Can't build omap_device for omap_rng\n");
}

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

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

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

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

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

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

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

#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,
};

int __init omap_init_vout(void)
{
	return platform_device_register(&omap_vout_device);
}
#else
int __init omap_init_vout(void) { return 0; }
#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_mcspi();
		omap_init_sham();
		omap_init_aes();
		omap_init_rng();
	}
	omap_init_sti();

	return 0;
}
omap_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>
b8a7cf8e	22	#include <linux/platform_data/mailbox-omap.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"
576e5bda	39	#include "display.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
c1d1cd59	64	pdev = omap_device_build("omap_l3_smx", 0, oh, NULL, 0);
0abcf618	65
3528c58e	66	WARN(IS_ERR(pdev), "could not build omap_device for %s\n", oh_name);
0abcf618	67
1261674a	68	return PTR_RET(pdev);
0abcf618	69	}
b76c8b19	70	omap_postcore_initcall(omap3_l3_init);
0abcf618	71
a4dc616a	72	static int __init omap4_l3_init(void)
a4dc616a	73	{
eeb3711b	74	int i;
a4dc616a	75	struct omap_hwmod *oh[3];
3528c58e	76	struct platform_device *pdev;
a4dc616a	77	char oh_name[L3_MODULES_MAX_LEN];
a4dc616a	78
ad8dfac6 BC	79	/* If dtb is there, the devices will be created dynamically */
	80	if (of_have_populated_dt())
	81	return -ENODEV;
	82
a4dc616a	83	/*
	84	* To avoid code running on other OMAPs in
	85	* multi-omap builds
	86	*/
e17933c2	87	if (!cpu_is_omap44xx() && !soc_is_omap54xx())
a4dc616a	88	return -ENODEV;
	89
	90	for (i = 0; i < L3_MODULES; i++) {
eeb3711b	91	snprintf(oh_name, L3_MODULES_MAX_LEN, "l3_main_%d", i+1);
a4dc616a	92
	93	oh[i] = omap_hwmod_lookup(oh_name);
	94	if (!(oh[i]))
	95	pr_err("could not look up %s\n", oh_name);
	96	}
	97
c1d1cd59	98	pdev = omap_device_build_ss("omap_l3_noc", 0, oh, 3, NULL, 0);
a4dc616a	99
3528c58e	100	WARN(IS_ERR(pdev), "could not build omap_device for %s\n", oh_name);
a4dc616a	101
1261674a	102	return PTR_RET(pdev);
a4dc616a	103	}
b76c8b19	104	omap_postcore_initcall(omap4_l3_init);
a4dc616a	105
828c707e	106	#if defined(CONFIG_VIDEO_OMAP2) \|\| defined(CONFIG_VIDEO_OMAP2_MODULE)
c40fae95	107
cfe2cde6	108	static struct resource omap2cam_resources[] = {
c40fae95	109	{
828c707e TL	110	.start = OMAP24XX_CAMERA_BASE,
	111	.end = OMAP24XX_CAMERA_BASE + 0xfff,
	112	.flags = IORESOURCE_MEM,
	113	},
	114	{
7d7e1eba	115	.start = 24 + OMAP_INTC_START,
828c707e TL	116	.flags = IORESOURCE_IRQ,
	117	}
	118	};
	119
cfe2cde6	120	static struct platform_device omap2cam_device = {
828c707e TL	121	.name = "omap24xxcam",
828c707e TL	122	.id = -1,
cfe2cde6 SA	123	.num_resources = ARRAY_SIZE(omap2cam_resources),
cfe2cde6 SA	124	.resource = omap2cam_resources,
828c707e	125	};
a11f6706	126	#endif
828c707e	127
1a51a0ce OBC	128	#if defined(CONFIG_IOMMU_API)
1a51a0ce OBC	129
2ab7c848	130	#include <linux/platform_data/iommu-omap.h>
1a51a0ce	131
828c707e TL	132	static struct resource omap3isp_resources[] = {
	133	{
	134	.start = OMAP3430_ISP_BASE,
	135	.end = OMAP3430_ISP_END,
	136	.flags = IORESOURCE_MEM,
	137	},
828c707e TL	138	{
	139	.start = OMAP3430_ISP_CCP2_BASE,
	140	.end = OMAP3430_ISP_CCP2_END,
	141	.flags = IORESOURCE_MEM,
	142	},
	143	{
	144	.start = OMAP3430_ISP_CCDC_BASE,
	145	.end = OMAP3430_ISP_CCDC_END,
	146	.flags = IORESOURCE_MEM,
	147	},
	148	{
	149	.start = OMAP3430_ISP_HIST_BASE,
	150	.end = OMAP3430_ISP_HIST_END,
	151	.flags = IORESOURCE_MEM,
	152	},
	153	{
	154	.start = OMAP3430_ISP_H3A_BASE,
	155	.end = OMAP3430_ISP_H3A_END,
	156	.flags = IORESOURCE_MEM,
	157	},
	158	{
	159	.start = OMAP3430_ISP_PREV_BASE,
	160	.end = OMAP3430_ISP_PREV_END,
	161	.flags = IORESOURCE_MEM,
	162	},
	163	{
	164	.start = OMAP3430_ISP_RESZ_BASE,
	165	.end = OMAP3430_ISP_RESZ_END,
	166	.flags = IORESOURCE_MEM,
	167	},
	168	{
	169	.start = OMAP3430_ISP_SBL_BASE,
	170	.end = OMAP3430_ISP_SBL_END,
	171	.flags = IORESOURCE_MEM,
	172	},
	173	{
6817a69a TT	174	.start = OMAP3430_ISP_CSI2A_REGS1_BASE,
6817a69a TT	175	.end = OMAP3430_ISP_CSI2A_REGS1_END,
828c707e TL	176	.flags = IORESOURCE_MEM,
	177	},
	178	{
6817a69a TT	179	.start = OMAP3430_ISP_CSIPHY2_BASE,
	180	.end = OMAP3430_ISP_CSIPHY2_END,
	181	.flags = IORESOURCE_MEM,
	182	},
	183	{
	184	.start = OMAP3630_ISP_CSI2A_REGS2_BASE,
	185	.end = OMAP3630_ISP_CSI2A_REGS2_END,
828c707e TL	186	.flags = IORESOURCE_MEM,
	187	},
	188	{
6817a69a TT	189	.start = OMAP3630_ISP_CSI2C_REGS1_BASE,
	190	.end = OMAP3630_ISP_CSI2C_REGS1_END,
	191	.flags = IORESOURCE_MEM,
	192	},
	193	{
	194	.start = OMAP3630_ISP_CSIPHY1_BASE,
	195	.end = OMAP3630_ISP_CSIPHY1_END,
	196	.flags = IORESOURCE_MEM,
	197	},
	198	{
	199	.start = OMAP3630_ISP_CSI2C_REGS2_BASE,
	200	.end = OMAP3630_ISP_CSI2C_REGS2_END,
828c707e TL	201	.flags = IORESOURCE_MEM,
828c707e TL	202	},
c19d19eb SA	203	{
	204	.start = OMAP343X_CTRL_BASE + OMAP343X_CONTROL_CSIRXFE,
	205	.end = OMAP343X_CTRL_BASE + OMAP343X_CONTROL_CSIRXFE + 3,
	206	.flags = IORESOURCE_MEM,
	207	},
	208	{
	209	.start = OMAP343X_CTRL_BASE + OMAP3630_CONTROL_CAMERA_PHY_CTRL,
	210	.end = OMAP343X_CTRL_BASE + OMAP3630_CONTROL_CAMERA_PHY_CTRL + 3,
	211	.flags = IORESOURCE_MEM,
	212	},
828c707e	213	{
7d7e1eba	214	.start = 24 + OMAP_INTC_START,
828c707e TL	215	.flags = IORESOURCE_IRQ,
	216	}
	217	};
	218
	219	static struct platform_device omap3isp_device = {
	220	.name = "omap3isp",
	221	.id = -1,
	222	.num_resources = ARRAY_SIZE(omap3isp_resources),
	223	.resource = omap3isp_resources,
	224	};
	225
c8eaab3b	226	static struct omap_iommu_arch_data omap3_isp_iommu = {
72b15b6a	227	.name = "mmu_isp",
c8eaab3b OBC	228	};
c8eaab3b OBC	229
a11f6706	230	int omap3_init_camera(struct isp_platform_data *pdata)
828c707e	231	{
a11f6706	232	omap3isp_device.dev.platform_data = pdata;
c8eaab3b OBC	233	omap3isp_device.dev.archdata.iommu = &omap3_isp_iommu;
c8eaab3b OBC	234
a11f6706	235	return platform_device_register(&omap3isp_device);
828c707e	236	}
828c707e	237
1a51a0ce OBC	238	#else /* !CONFIG_IOMMU_API */
	239
	240	int omap3_init_camera(struct isp_platform_data *pdata)
	241	{
	242	return 0;
	243	}
	244
	245	#endif
	246
828c707e TL	247	static inline void omap_init_camera(void)
828c707e TL	248	{
cfe2cde6 SA	249	#if defined(CONFIG_VIDEO_OMAP2) \|\| defined(CONFIG_VIDEO_OMAP2_MODULE)
	250	if (cpu_is_omap24xx())
	251	platform_device_register(&omap2cam_device);
828c707e	252	#endif
cfe2cde6	253	}
828c707e	254
59556765	255	int __init omap4_keyboard_init(struct omap4_keypad_platform_data
f67df6c6	256	sdp4430_keypad_data, struct omap_board_data bdata)
59556765	257	{
3528c58e	258	struct platform_device *pdev;
59556765 SR	259	struct omap_hwmod *oh;
	260	struct omap4_keypad_platform_data *keypad_data;
	261	unsigned int id = -1;
	262	char *oh_name = "kbd";
	263	char *name = "omap4-keypad";
	264
	265	oh = omap_hwmod_lookup(oh_name);
	266	if (!oh) {
	267	pr_err("Could not look up %s\n", oh_name);
	268	return -ENODEV;
	269	}
	270
	271	keypad_data = sdp4430_keypad_data;
	272
3528c58e	273	pdev = omap_device_build(name, id, oh, keypad_data,
c1d1cd59	274	sizeof(struct omap4_keypad_platform_data));
59556765	275
3528c58e	276	if (IS_ERR(pdev)) {
25985edc	277	WARN(1, "Can't build omap_device for %s:%s.\n",
59556765	278	name, oh->name);
3528c58e	279	return PTR_ERR(pdev);
59556765	280	}
f67df6c6	281	oh->mux = omap_hwmod_mux_init(bdata->pads, bdata->pads_cnt);
59556765 SR	282
	283	return 0;
	284	}
	285
c869c75c	286	#if defined(CONFIG_OMAP2PLUS_MBOX) \|\| defined(CONFIG_OMAP2PLUS_MBOX_MODULE)
9cf793f9	287	static inline void __init omap_init_mbox(void)
c40fae95	288	{
69dbf857	289	struct omap_hwmod *oh;
3528c58e	290	struct platform_device *pdev;
b8a7cf8e	291	struct omap_mbox_pdata *pdata;
69dbf857 FC	292
	293	oh = omap_hwmod_lookup("mailbox");
	294	if (!oh) {
	295	pr_err("%s: unable to find hwmod\n", __func__);
6c20a683 HD	296	return;
6c20a683 HD	297	}
b8a7cf8e SA	298	if (!oh->dev_attr) {
	299	pr_err("%s: hwmod doesn't have valid attrs\n", __func__);
	300	return;
	301	}
69dbf857	302
b8a7cf8e SA	303	pdata = (struct omap_mbox_pdata *)oh->dev_attr;
b8a7cf8e SA	304	pdev = omap_device_build("omap-mailbox", -1, oh, pdata, sizeof(*pdata));
3528c58e KH	305	WARN(IS_ERR(pdev), "%s: could not build device, err %ld\n",
3528c58e KH	306	__func__, PTR_ERR(pdev));
c40fae95 TL	307	}
	308	#else
	309	static inline void omap_init_mbox(void) { }
c869c75c	310	#endif /* CONFIG_OMAP2PLUS_MBOX */
c40fae95	311
9b6553cd	312	static inline void omap_init_sti(void) {}
9b6553cd	313
f0fba2ad LG	314	#if defined(CONFIG_SND_SOC) \|\| defined(CONFIG_SND_SOC_MODULE)
	315
	316	static struct platform_device omap_pcm = {
	317	.name = "omap-pcm-audio",
	318	.id = -1,
	319	};
	320
f0fba2ad LG	321	static void omap_init_audio(void)
f0fba2ad LG	322	{
f0fba2ad LG	323	platform_device_register(&omap_pcm);
	324	}
	325
	326	#else
	327	static inline void omap_init_audio(void) {}
	328	#endif
	329
5eeec215 RN	330	#if defined(CONFIG_SND_OMAP_SOC_OMAP_HDMI) \|\| \
	331	defined(CONFIG_SND_OMAP_SOC_OMAP_HDMI_MODULE)
	332
	333	static struct platform_device omap_hdmi_audio = {
	334	.name = "omap-hdmi-audio",
	335	.id = -1,
	336	};
	337
	338	static void __init omap_init_hdmi_audio(void)
	339	{
	340	struct omap_hwmod *oh;
	341	struct platform_device *pdev;
	342
	343	oh = omap_hwmod_lookup("dss_hdmi");
7252db5f	344	if (!oh)
5eeec215	345	return;
5eeec215	346
6efc3fe0	347	pdev = omap_device_build("omap-hdmi-audio-dai", -1, oh, NULL, 0);
5eeec215 RN	348	WARN(IS_ERR(pdev),
	349	"Can't build omap_device for omap-hdmi-audio-dai.\n");
	350
	351	platform_device_register(&omap_hdmi_audio);
	352	}
	353	#else
	354	static inline void omap_init_hdmi_audio(void) {}
	355	#endif
	356
646e3ed1	357	#if defined(CONFIG_SPI_OMAP24XX) \|\| defined(CONFIG_SPI_OMAP24XX_MODULE)
ed7eb9d9	358
2203747c	359	#include <linux/platform_data/spi-omap2-mcspi.h>
ed7eb9d9	360
9cf793f9	361	static int __init omap_mcspi_init(struct omap_hwmod oh, void unused)
af41a12f	362	{
3528c58e	363	struct platform_device *pdev;
1a5d8190 C	364	char *name = "omap2_mcspi";
	365	struct omap2_mcspi_platform_config *pdata;
	366	static int spi_num;
	367	struct omap2_mcspi_dev_attr *mcspi_attrib = oh->dev_attr;
	368
	369	pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
	370	if (!pdata) {
	371	pr_err("Memory allocation for McSPI device failed\n");
	372	return -ENOMEM;
	373	}
af41a12f	374
1a5d8190 C	375	pdata->num_cs = mcspi_attrib->num_chipselect;
	376	switch (oh->class->rev) {
	377	case OMAP2_MCSPI_REV:
	378	case OMAP3_MCSPI_REV:
	379	pdata->regs_offset = 0;
	380	break;
	381	case OMAP4_MCSPI_REV:
	382	pdata->regs_offset = OMAP4_MCSPI_REG_OFFSET;
	383	break;
	384	default:
	385	pr_err("Invalid McSPI Revision value\n");
e0feca89	386	kfree(pdata);
1a5d8190 C	387	return -EINVAL;
1a5d8190 C	388	}
af41a12f	389
1a5d8190	390	spi_num++;
c1d1cd59	391	pdev = omap_device_build(name, spi_num, oh, pdata, sizeof(*pdata));
3528c58e	392	WARN(IS_ERR(pdev), "Can't build omap_device for %s:%s\n",
1a5d8190 C	393	name, oh->name);
	394	kfree(pdata);
	395	return 0;
af41a12f	396	}
af41a12f TL	397
	398	static void omap_init_mcspi(void)
	399	{
1a5d8190	400	omap_hwmod_for_each_by_class("mcspi", omap_mcspi_init, NULL);
ed7eb9d9 JY	401	}
	402
	403	#else
	404	static inline void omap_init_mcspi(void) {}
	405	#endif
	406
4848d460 PW	407	/**
	408	* omap_init_rng - bind the RNG hwmod to the RNG omap_device
	409	*
	410	* Bind the RNG hwmod to the RNG omap_device. No return value.
	411	*/
	412	static void omap_init_rng(void)
	413	{
	414	struct omap_hwmod *oh;
	415	struct platform_device *pdev;
	416
	417	oh = omap_hwmod_lookup("rng");
	418	if (!oh)
	419	return;
	420
c1d1cd59	421	pdev = omap_device_build("omap_rng", -1, oh, NULL, 0);
4848d460 PW	422	WARN(IS_ERR(pdev), "Can't build omap_device for omap_rng\n");
4848d460 PW	423	}
88341334	424
26f88e6e	425	static void __init omap_init_sham(void)
646e3ed1	426	{
8c7bb573 MG	427	struct omap_hwmod *oh;
	428	struct platform_device *pdev;
	429
	430	oh = omap_hwmod_lookup("sham");
	431	if (!oh)
	432	return;
	433
	434	pdev = omap_device_build("omap-sham", -1, oh, NULL, 0);
	435	WARN(IS_ERR(pdev), "Can't build omap_device for omap-sham\n");
646e3ed1	436	}
646e3ed1	437
14ae5564	438	static void __init omap_init_aes(void)
b744c679	439	{
77e2fd84 MG	440	struct omap_hwmod *oh;
	441	struct platform_device *pdev;
	442
	443	oh = omap_hwmod_lookup("aes");
	444	if (!oh)
	445	return;
	446
	447	pdev = omap_device_build("omap-aes", -1, oh, NULL, 0);
	448	WARN(IS_ERR(pdev), "Can't build omap_device for omap-aes\n");
b744c679 DK	449	}
b744c679 DK	450
d8874665 TL	451	/-------------------------------------------------------------------------/
d8874665 TL	452
b227358d VH	453	#if defined(CONFIG_VIDEO_OMAP2_VOUT) \|\| \
	454	defined(CONFIG_VIDEO_OMAP2_VOUT_MODULE)
	455	#if defined(CONFIG_FB_OMAP2) \|\| defined(CONFIG_FB_OMAP2_MODULE)
	456	static struct resource omap_vout_resource[3 - CONFIG_FB_OMAP2_NUM_FBS] = {
	457	};
	458	#else
	459	static struct resource omap_vout_resource[2] = {
	460	};
	461	#endif
	462
	463	static struct platform_device omap_vout_device = {
	464	.name = "omap_vout",
	465	.num_resources = ARRAY_SIZE(omap_vout_resource),
	466	.resource = &omap_vout_resource[0],
	467	.id = -1,
	468	};
576e5bda AT	469
576e5bda AT	470	int __init omap_init_vout(void)
b227358d	471	{
576e5bda	472	return platform_device_register(&omap_vout_device);
b227358d VH	473	}
b227358d VH	474	#else
576e5bda	475	int __init omap_init_vout(void) { return 0; }
b227358d VH	476	#endif
b227358d VH	477
1dbae815 TL	478	/-------------------------------------------------------------------------/
	479
	480	static int __init omap2_init_devices(void)
	481	{
484202f4 MP	482	/* Enable dummy states for those platforms without pinctrl support */
	483	if (!of_have_populated_dt())
	484	pinctrl_provide_dummies();
	485
81fbc5ef PW	486	/*
81fbc5ef PW	487	* please keep these calls, and their implementations above,
1dbae815 TL	488	* in alphabetical order so they're easier to sort through.
1dbae815 TL	489	*/
f0fba2ad	490	omap_init_audio();
828c707e	491	omap_init_camera();
5eeec215	492	omap_init_hdmi_audio();
c40fae95	493	omap_init_mbox();
efcf1e50	494	/* If dtb is there, the devices will be created dynamically */
259bd6ce	495	if (!of_have_populated_dt()) {
efcf1e50	496	omap_init_mcspi();
114d7a8b	497	omap_init_sham();
53335acc	498	omap_init_aes();
674ee08f	499	omap_init_rng();
259bd6ce	500	}
9b6553cd	501	omap_init_sti();
1dbae815 TL	502
	503	return 0;
	504	}
b76c8b19	505	omap_arch_initcall(omap2_init_devices);