1 /* 2 * linux/arch/arm/mach-omap2/devices.c 3 * 4 * OMAP2 platform device setup/initialization 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 */ 11 #include <linux/gpio.h> 12 #include <linux/kernel.h> 13 #include <linux/init.h> 14 #include <linux/platform_device.h> 15 #include <linux/io.h> 16 #include <linux/clk.h> 17 #include <linux/err.h> 18 #include <linux/slab.h> 19 #include <linux/of.h> 20 #include <linux/pinctrl/machine.h> 21 #include <linux/platform_data/mailbox-omap.h> 22 23 #include <asm/mach-types.h> 24 #include <asm/mach/map.h> 25 26 #include <linux/omap-dma.h> 27 28 #include "iomap.h" 29 #include "omap_hwmod.h" 30 #include "omap_device.h" 31 32 #include "soc.h" 33 #include "common.h" 34 #include "mux.h" 35 #include "control.h" 36 #include "devices.h" 37 #include "display.h" 38 39 #define L3_MODULES_MAX_LEN 12 40 #define L3_MODULES 3 41 42 static int __init omap3_l3_init(void) 43 { 44 struct omap_hwmod *oh; 45 struct platform_device *pdev; 46 char oh_name[L3_MODULES_MAX_LEN]; 47 48 /* 49 * To avoid code running on other OMAPs in 50 * multi-omap builds 51 */ 52 if (!(cpu_is_omap34xx())) 53 return -ENODEV; 54 55 snprintf(oh_name, L3_MODULES_MAX_LEN, "l3_main"); 56 57 oh = omap_hwmod_lookup(oh_name); 58 59 if (!oh) 60 pr_err("could not look up %s\n", oh_name); 61 62 pdev = omap_device_build("omap_l3_smx", 0, oh, NULL, 0); 63 64 WARN(IS_ERR(pdev), "could not build omap_device for %s\n", oh_name); 65 66 return PTR_RET(pdev); 67 } 68 omap_postcore_initcall(omap3_l3_init); 69 70 static int __init omap4_l3_init(void) 71 { 72 int i; 73 struct omap_hwmod *oh[3]; 74 struct platform_device *pdev; 75 char oh_name[L3_MODULES_MAX_LEN]; 76 77 /* If dtb is there, the devices will be created dynamically */ 78 if (of_have_populated_dt()) 79 return -ENODEV; 80 81 /* 82 * To avoid code running on other OMAPs in 83 * multi-omap builds 84 */ 85 if (!cpu_is_omap44xx() && !soc_is_omap54xx()) 86 return -ENODEV; 87 88 for (i = 0; i < L3_MODULES; i++) { 89 snprintf(oh_name, L3_MODULES_MAX_LEN, "l3_main_%d", i+1); 90 91 oh[i] = omap_hwmod_lookup(oh_name); 92 if (!(oh[i])) 93 pr_err("could not look up %s\n", oh_name); 94 } 95 96 pdev = omap_device_build_ss("omap_l3_noc", 0, oh, 3, NULL, 0); 97 98 WARN(IS_ERR(pdev), "could not build omap_device for %s\n", oh_name); 99 100 return PTR_RET(pdev); 101 } 102 omap_postcore_initcall(omap4_l3_init); 103 104 #if defined(CONFIG_VIDEO_OMAP2) || defined(CONFIG_VIDEO_OMAP2_MODULE) 105 106 static struct resource omap2cam_resources[] = { 107 { 108 .start = OMAP24XX_CAMERA_BASE, 109 .end = OMAP24XX_CAMERA_BASE + 0xfff, 110 .flags = IORESOURCE_MEM, 111 }, 112 { 113 .start = 24 + OMAP_INTC_START, 114 .flags = IORESOURCE_IRQ, 115 } 116 }; 117 118 static struct platform_device omap2cam_device = { 119 .name = "omap24xxcam", 120 .id = -1, 121 .num_resources = ARRAY_SIZE(omap2cam_resources), 122 .resource = omap2cam_resources, 123 }; 124 #endif 125 126 #if defined(CONFIG_IOMMU_API) 127 128 #include <linux/platform_data/iommu-omap.h> 129 130 static struct resource omap3isp_resources[] = { 131 { 132 .start = OMAP3430_ISP_BASE, 133 .end = OMAP3430_ISP_END, 134 .flags = IORESOURCE_MEM, 135 }, 136 { 137 .start = OMAP3430_ISP_CCP2_BASE, 138 .end = OMAP3430_ISP_CCP2_END, 139 .flags = IORESOURCE_MEM, 140 }, 141 { 142 .start = OMAP3430_ISP_CCDC_BASE, 143 .end = OMAP3430_ISP_CCDC_END, 144 .flags = IORESOURCE_MEM, 145 }, 146 { 147 .start = OMAP3430_ISP_HIST_BASE, 148 .end = OMAP3430_ISP_HIST_END, 149 .flags = IORESOURCE_MEM, 150 }, 151 { 152 .start = OMAP3430_ISP_H3A_BASE, 153 .end = OMAP3430_ISP_H3A_END, 154 .flags = IORESOURCE_MEM, 155 }, 156 { 157 .start = OMAP3430_ISP_PREV_BASE, 158 .end = OMAP3430_ISP_PREV_END, 159 .flags = IORESOURCE_MEM, 160 }, 161 { 162 .start = OMAP3430_ISP_RESZ_BASE, 163 .end = OMAP3430_ISP_RESZ_END, 164 .flags = IORESOURCE_MEM, 165 }, 166 { 167 .start = OMAP3430_ISP_SBL_BASE, 168 .end = OMAP3430_ISP_SBL_END, 169 .flags = IORESOURCE_MEM, 170 }, 171 { 172 .start = OMAP3430_ISP_CSI2A_REGS1_BASE, 173 .end = OMAP3430_ISP_CSI2A_REGS1_END, 174 .flags = IORESOURCE_MEM, 175 }, 176 { 177 .start = OMAP3430_ISP_CSIPHY2_BASE, 178 .end = OMAP3430_ISP_CSIPHY2_END, 179 .flags = IORESOURCE_MEM, 180 }, 181 { 182 .start = OMAP3630_ISP_CSI2A_REGS2_BASE, 183 .end = OMAP3630_ISP_CSI2A_REGS2_END, 184 .flags = IORESOURCE_MEM, 185 }, 186 { 187 .start = OMAP3630_ISP_CSI2C_REGS1_BASE, 188 .end = OMAP3630_ISP_CSI2C_REGS1_END, 189 .flags = IORESOURCE_MEM, 190 }, 191 { 192 .start = OMAP3630_ISP_CSIPHY1_BASE, 193 .end = OMAP3630_ISP_CSIPHY1_END, 194 .flags = IORESOURCE_MEM, 195 }, 196 { 197 .start = OMAP3630_ISP_CSI2C_REGS2_BASE, 198 .end = OMAP3630_ISP_CSI2C_REGS2_END, 199 .flags = IORESOURCE_MEM, 200 }, 201 { 202 .start = OMAP343X_CTRL_BASE + OMAP343X_CONTROL_CSIRXFE, 203 .end = OMAP343X_CTRL_BASE + OMAP343X_CONTROL_CSIRXFE + 3, 204 .flags = IORESOURCE_MEM, 205 }, 206 { 207 .start = OMAP343X_CTRL_BASE + OMAP3630_CONTROL_CAMERA_PHY_CTRL, 208 .end = OMAP343X_CTRL_BASE + OMAP3630_CONTROL_CAMERA_PHY_CTRL + 3, 209 .flags = IORESOURCE_MEM, 210 }, 211 { 212 .start = 24 + OMAP_INTC_START, 213 .flags = IORESOURCE_IRQ, 214 } 215 }; 216 217 static struct platform_device omap3isp_device = { 218 .name = "omap3isp", 219 .id = -1, 220 .num_resources = ARRAY_SIZE(omap3isp_resources), 221 .resource = omap3isp_resources, 222 }; 223 224 static struct omap_iommu_arch_data omap3_isp_iommu = { 225 .name = "mmu_isp", 226 }; 227 228 int omap3_init_camera(struct isp_platform_data *pdata) 229 { 230 if (of_have_populated_dt()) 231 omap3_isp_iommu.name = "480bd400.mmu"; 232 233 omap3isp_device.dev.platform_data = pdata; 234 omap3isp_device.dev.archdata.iommu = &omap3_isp_iommu; 235 236 return platform_device_register(&omap3isp_device); 237 } 238 239 #else /* !CONFIG_IOMMU_API */ 240 241 int omap3_init_camera(struct isp_platform_data *pdata) 242 { 243 return 0; 244 } 245 246 #endif 247 248 static inline void omap_init_camera(void) 249 { 250 #if defined(CONFIG_VIDEO_OMAP2) || defined(CONFIG_VIDEO_OMAP2_MODULE) 251 if (cpu_is_omap24xx()) 252 platform_device_register(&omap2cam_device); 253 #endif 254 } 255 256 #if defined(CONFIG_OMAP2PLUS_MBOX) || defined(CONFIG_OMAP2PLUS_MBOX_MODULE) 257 static inline void __init omap_init_mbox(void) 258 { 259 struct omap_hwmod *oh; 260 struct platform_device *pdev; 261 struct omap_mbox_pdata *pdata; 262 263 oh = omap_hwmod_lookup("mailbox"); 264 if (!oh) { 265 pr_err("%s: unable to find hwmod\n", __func__); 266 return; 267 } 268 if (!oh->dev_attr) { 269 pr_err("%s: hwmod doesn't have valid attrs\n", __func__); 270 return; 271 } 272 273 pdata = (struct omap_mbox_pdata *)oh->dev_attr; 274 pdev = omap_device_build("omap-mailbox", -1, oh, pdata, sizeof(*pdata)); 275 WARN(IS_ERR(pdev), "%s: could not build device, err %ld\n", 276 __func__, PTR_ERR(pdev)); 277 } 278 #else 279 static inline void omap_init_mbox(void) { } 280 #endif /* CONFIG_OMAP2PLUS_MBOX */ 281 282 static inline void omap_init_sti(void) {} 283 284 #if defined(CONFIG_SND_SOC) || defined(CONFIG_SND_SOC_MODULE) 285 286 static struct platform_device omap_pcm = { 287 .name = "omap-pcm-audio", 288 .id = -1, 289 }; 290 291 static void omap_init_audio(void) 292 { 293 platform_device_register(&omap_pcm); 294 } 295 296 #else 297 static inline void omap_init_audio(void) {} 298 #endif 299 300 #if defined(CONFIG_SND_OMAP_SOC_OMAP_HDMI) || \ 301 defined(CONFIG_SND_OMAP_SOC_OMAP_HDMI_MODULE) 302 303 static struct platform_device omap_hdmi_audio = { 304 .name = "omap-hdmi-audio", 305 .id = -1, 306 }; 307 308 static void __init omap_init_hdmi_audio(void) 309 { 310 struct omap_hwmod *oh; 311 struct platform_device *pdev; 312 313 oh = omap_hwmod_lookup("dss_hdmi"); 314 if (!oh) 315 return; 316 317 pdev = omap_device_build("omap-hdmi-audio-dai", -1, oh, NULL, 0); 318 WARN(IS_ERR(pdev), 319 "Can't build omap_device for omap-hdmi-audio-dai.\n"); 320 321 platform_device_register(&omap_hdmi_audio); 322 } 323 #else 324 static inline void omap_init_hdmi_audio(void) {} 325 #endif 326 327 #if defined(CONFIG_SPI_OMAP24XX) || defined(CONFIG_SPI_OMAP24XX_MODULE) 328 329 #include <linux/platform_data/spi-omap2-mcspi.h> 330 331 static int __init omap_mcspi_init(struct omap_hwmod *oh, void *unused) 332 { 333 struct platform_device *pdev; 334 char *name = "omap2_mcspi"; 335 struct omap2_mcspi_platform_config *pdata; 336 static int spi_num; 337 struct omap2_mcspi_dev_attr *mcspi_attrib = oh->dev_attr; 338 339 pdata = kzalloc(sizeof(*pdata), GFP_KERNEL); 340 if (!pdata) { 341 pr_err("Memory allocation for McSPI device failed\n"); 342 return -ENOMEM; 343 } 344 345 pdata->num_cs = mcspi_attrib->num_chipselect; 346 switch (oh->class->rev) { 347 case OMAP2_MCSPI_REV: 348 case OMAP3_MCSPI_REV: 349 pdata->regs_offset = 0; 350 break; 351 case OMAP4_MCSPI_REV: 352 pdata->regs_offset = OMAP4_MCSPI_REG_OFFSET; 353 break; 354 default: 355 pr_err("Invalid McSPI Revision value\n"); 356 kfree(pdata); 357 return -EINVAL; 358 } 359 360 spi_num++; 361 pdev = omap_device_build(name, spi_num, oh, pdata, sizeof(*pdata)); 362 WARN(IS_ERR(pdev), "Can't build omap_device for %s:%s\n", 363 name, oh->name); 364 kfree(pdata); 365 return 0; 366 } 367 368 static void omap_init_mcspi(void) 369 { 370 omap_hwmod_for_each_by_class("mcspi", omap_mcspi_init, NULL); 371 } 372 373 #else 374 static inline void omap_init_mcspi(void) {} 375 #endif 376 377 /** 378 * omap_init_rng - bind the RNG hwmod to the RNG omap_device 379 * 380 * Bind the RNG hwmod to the RNG omap_device. No return value. 381 */ 382 static void omap_init_rng(void) 383 { 384 struct omap_hwmod *oh; 385 struct platform_device *pdev; 386 387 oh = omap_hwmod_lookup("rng"); 388 if (!oh) 389 return; 390 391 pdev = omap_device_build("omap_rng", -1, oh, NULL, 0); 392 WARN(IS_ERR(pdev), "Can't build omap_device for omap_rng\n"); 393 } 394 395 static void __init omap_init_sham(void) 396 { 397 struct omap_hwmod *oh; 398 struct platform_device *pdev; 399 400 oh = omap_hwmod_lookup("sham"); 401 if (!oh) 402 return; 403 404 pdev = omap_device_build("omap-sham", -1, oh, NULL, 0); 405 WARN(IS_ERR(pdev), "Can't build omap_device for omap-sham\n"); 406 } 407 408 static void __init omap_init_aes(void) 409 { 410 struct omap_hwmod *oh; 411 struct platform_device *pdev; 412 413 oh = omap_hwmod_lookup("aes"); 414 if (!oh) 415 return; 416 417 pdev = omap_device_build("omap-aes", -1, oh, NULL, 0); 418 WARN(IS_ERR(pdev), "Can't build omap_device for omap-aes\n"); 419 } 420 421 /*-------------------------------------------------------------------------*/ 422 423 #if defined(CONFIG_VIDEO_OMAP2_VOUT) || \ 424 defined(CONFIG_VIDEO_OMAP2_VOUT_MODULE) 425 #if defined(CONFIG_FB_OMAP2) || defined(CONFIG_FB_OMAP2_MODULE) 426 static struct resource omap_vout_resource[3 - CONFIG_FB_OMAP2_NUM_FBS] = { 427 }; 428 #else 429 static struct resource omap_vout_resource[2] = { 430 }; 431 #endif 432 433 static struct platform_device omap_vout_device = { 434 .name = "omap_vout", 435 .num_resources = ARRAY_SIZE(omap_vout_resource), 436 .resource = &omap_vout_resource[0], 437 .id = -1, 438 }; 439 440 int __init omap_init_vout(void) 441 { 442 return platform_device_register(&omap_vout_device); 443 } 444 #else 445 int __init omap_init_vout(void) { return 0; } 446 #endif 447 448 /*-------------------------------------------------------------------------*/ 449 450 static int __init omap2_init_devices(void) 451 { 452 /* Enable dummy states for those platforms without pinctrl support */ 453 if (!of_have_populated_dt()) 454 pinctrl_provide_dummies(); 455 456 /* 457 * please keep these calls, and their implementations above, 458 * in alphabetical order so they're easier to sort through. 459 */ 460 omap_init_audio(); 461 omap_init_camera(); 462 omap_init_hdmi_audio(); 463 omap_init_mbox(); 464 /* If dtb is there, the devices will be created dynamically */ 465 if (!of_have_populated_dt()) { 466 omap_init_mcspi(); 467 omap_init_sham(); 468 omap_init_aes(); 469 omap_init_rng(); 470 } 471 omap_init_sti(); 472 473 return 0; 474 } 475 omap_arch_initcall(omap2_init_devices); 476