Tony Lindgren | 7c38cf0 | 2005-09-08 23:07:38 +0100 | [diff] [blame] | 1 | /* |
| 2 | * linux/arch/arm/mach-omap1/devices.c |
| 3 | * |
| 4 | * OMAP1 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 | |
Janusz Krzysztofik | 1a96edd | 2010-10-01 16:37:00 -0700 | [diff] [blame] | 12 | #include <linux/dma-mapping.h> |
Russell King | 2f8163b | 2011-07-26 10:53:52 +0100 | [diff] [blame] | 13 | #include <linux/gpio.h> |
Tony Lindgren | 7c38cf0 | 2005-09-08 23:07:38 +0100 | [diff] [blame] | 14 | #include <linux/module.h> |
| 15 | #include <linux/kernel.h> |
| 16 | #include <linux/init.h> |
Russell King | d052d1b | 2005-10-29 19:07:23 +0100 | [diff] [blame] | 17 | #include <linux/platform_device.h> |
Cory Maccarrone | c5c4dce | 2010-01-08 10:29:05 -0800 | [diff] [blame] | 18 | #include <linux/spi/spi.h> |
Tony Lindgren | 7c38cf0 | 2005-09-08 23:07:38 +0100 | [diff] [blame] | 19 | |
Tony Lindgren | 7c38cf0 | 2005-09-08 23:07:38 +0100 | [diff] [blame] | 20 | #include <asm/mach/map.h> |
| 21 | |
Tony Lindgren | 54b693d | 2012-10-02 13:39:28 -0700 | [diff] [blame] | 22 | #include <mach/tc.h> |
Tony Lindgren | 70c494c | 2012-09-19 10:46:56 -0700 | [diff] [blame] | 23 | #include <mach/mux.h> |
Tony Lindgren | 7c38cf0 | 2005-09-08 23:07:38 +0100 | [diff] [blame] | 24 | |
Tony Lindgren | 68cb700 | 2012-08-31 17:04:35 -0700 | [diff] [blame] | 25 | #include <mach/omap7xx.h> |
Tony Lindgren | 2e3ee9f | 2012-02-24 10:34:34 -0800 | [diff] [blame] | 26 | #include <mach/camera.h> |
| 27 | #include <mach/hardware.h> |
| 28 | |
Tony Lindgren | 622297f | 2012-10-02 14:19:52 -0700 | [diff] [blame] | 29 | #include "../plat-omap/sram.h" |
| 30 | |
Tony Lindgren | 2e3ee9f | 2012-02-24 10:34:34 -0800 | [diff] [blame] | 31 | #include "common.h" |
Tony Lindgren | e9b7086 | 2011-11-11 10:15:11 -0800 | [diff] [blame] | 32 | #include "clock.h" |
Lokesh Vutla | 8c4cc00 | 2012-10-15 14:01:01 -0700 | [diff] [blame] | 33 | #include "dma.h" |
Tony Lindgren | 68f39e7 | 2012-10-15 12:09:43 -0700 | [diff] [blame] | 34 | #include "mmc.h" |
Tony Lindgren | e9b7086 | 2011-11-11 10:15:11 -0800 | [diff] [blame] | 35 | |
Tony Lindgren | fcc76a8 | 2012-05-09 09:59:25 -0700 | [diff] [blame] | 36 | #if defined(CONFIG_SND_SOC) || defined(CONFIG_SND_SOC_MODULE) |
| 37 | |
| 38 | static struct platform_device omap_pcm = { |
| 39 | .name = "omap-pcm-audio", |
| 40 | .id = -1, |
| 41 | }; |
| 42 | |
| 43 | static void omap_init_audio(void) |
| 44 | { |
| 45 | platform_device_register(&omap_pcm); |
| 46 | } |
| 47 | |
| 48 | #else |
| 49 | static inline void omap_init_audio(void) {} |
| 50 | #endif |
| 51 | |
Tony Lindgren | 7c38cf0 | 2005-09-08 23:07:38 +0100 | [diff] [blame] | 52 | /*-------------------------------------------------------------------------*/ |
| 53 | |
David Brownell | db68b18 | 2006-12-06 20:38:36 -0800 | [diff] [blame] | 54 | #if defined(CONFIG_RTC_DRV_OMAP) || defined(CONFIG_RTC_DRV_OMAP_MODULE) |
Tony Lindgren | 7c38cf0 | 2005-09-08 23:07:38 +0100 | [diff] [blame] | 55 | |
| 56 | #define OMAP_RTC_BASE 0xfffb4800 |
| 57 | |
| 58 | static struct resource rtc_resources[] = { |
| 59 | { |
| 60 | .start = OMAP_RTC_BASE, |
| 61 | .end = OMAP_RTC_BASE + 0x5f, |
| 62 | .flags = IORESOURCE_MEM, |
| 63 | }, |
| 64 | { |
| 65 | .start = INT_RTC_TIMER, |
| 66 | .flags = IORESOURCE_IRQ, |
| 67 | }, |
| 68 | { |
| 69 | .start = INT_RTC_ALARM, |
| 70 | .flags = IORESOURCE_IRQ, |
| 71 | }, |
| 72 | }; |
| 73 | |
| 74 | static struct platform_device omap_rtc_device = { |
| 75 | .name = "omap_rtc", |
| 76 | .id = -1, |
Tony Lindgren | 7c38cf0 | 2005-09-08 23:07:38 +0100 | [diff] [blame] | 77 | .num_resources = ARRAY_SIZE(rtc_resources), |
| 78 | .resource = rtc_resources, |
| 79 | }; |
| 80 | |
| 81 | static void omap_init_rtc(void) |
| 82 | { |
| 83 | (void) platform_device_register(&omap_rtc_device); |
| 84 | } |
| 85 | #else |
| 86 | static inline void omap_init_rtc(void) {} |
| 87 | #endif |
| 88 | |
Tony Lindgren | c40fae95 | 2006-12-07 13:58:10 -0800 | [diff] [blame] | 89 | static inline void omap_init_mbox(void) { } |
Tony Lindgren | c40fae95 | 2006-12-07 13:58:10 -0800 | [diff] [blame] | 90 | |
Tony Lindgren | d887466 | 2008-12-10 17:37:16 -0800 | [diff] [blame] | 91 | /*-------------------------------------------------------------------------*/ |
| 92 | |
| 93 | #if defined(CONFIG_MMC_OMAP) || defined(CONFIG_MMC_OMAP_MODULE) |
| 94 | |
| 95 | static inline void omap1_mmc_mux(struct omap_mmc_platform_data *mmc_controller, |
| 96 | int controller_nr) |
| 97 | { |
| 98 | if (controller_nr == 0) { |
Cory Maccarrone | 490a566 | 2009-11-22 10:10:50 -0800 | [diff] [blame] | 99 | if (cpu_is_omap7xx()) { |
| 100 | omap_cfg_reg(MMC_7XX_CMD); |
| 101 | omap_cfg_reg(MMC_7XX_CLK); |
| 102 | omap_cfg_reg(MMC_7XX_DAT0); |
| 103 | } else { |
| 104 | omap_cfg_reg(MMC_CMD); |
| 105 | omap_cfg_reg(MMC_CLK); |
| 106 | omap_cfg_reg(MMC_DAT0); |
| 107 | } |
| 108 | |
Tony Lindgren | d887466 | 2008-12-10 17:37:16 -0800 | [diff] [blame] | 109 | if (cpu_is_omap1710()) { |
| 110 | omap_cfg_reg(M15_1710_MMC_CLKI); |
| 111 | omap_cfg_reg(P19_1710_MMC_CMDDIR); |
| 112 | omap_cfg_reg(P20_1710_MMC_DATDIR0); |
| 113 | } |
Cory Maccarrone | 490a566 | 2009-11-22 10:10:50 -0800 | [diff] [blame] | 114 | if (mmc_controller->slots[0].wires == 4 && !cpu_is_omap7xx()) { |
Tony Lindgren | d887466 | 2008-12-10 17:37:16 -0800 | [diff] [blame] | 115 | omap_cfg_reg(MMC_DAT1); |
| 116 | /* NOTE: DAT2 can be on W10 (here) or M15 */ |
| 117 | if (!mmc_controller->slots[0].nomux) |
| 118 | omap_cfg_reg(MMC_DAT2); |
| 119 | omap_cfg_reg(MMC_DAT3); |
| 120 | } |
| 121 | } |
| 122 | |
| 123 | /* Block 2 is on newer chips, and has many pinout options */ |
| 124 | if (cpu_is_omap16xx() && controller_nr == 1) { |
| 125 | if (!mmc_controller->slots[1].nomux) { |
| 126 | omap_cfg_reg(Y8_1610_MMC2_CMD); |
| 127 | omap_cfg_reg(Y10_1610_MMC2_CLK); |
| 128 | omap_cfg_reg(R18_1610_MMC2_CLKIN); |
| 129 | omap_cfg_reg(W8_1610_MMC2_DAT0); |
Tony Lindgren | 90c62bf | 2008-12-10 17:37:17 -0800 | [diff] [blame] | 130 | if (mmc_controller->slots[1].wires == 4) { |
Tony Lindgren | d887466 | 2008-12-10 17:37:16 -0800 | [diff] [blame] | 131 | omap_cfg_reg(V8_1610_MMC2_DAT1); |
| 132 | omap_cfg_reg(W15_1610_MMC2_DAT2); |
| 133 | omap_cfg_reg(R10_1610_MMC2_DAT3); |
| 134 | } |
| 135 | |
| 136 | /* These are needed for the level shifter */ |
| 137 | omap_cfg_reg(V9_1610_MMC2_CMDDIR); |
| 138 | omap_cfg_reg(V5_1610_MMC2_DATDIR0); |
| 139 | omap_cfg_reg(W19_1610_MMC2_DATDIR1); |
| 140 | } |
| 141 | |
| 142 | /* Feedback clock must be set on OMAP-1710 MMC2 */ |
| 143 | if (cpu_is_omap1710()) |
| 144 | omap_writel(omap_readl(MOD_CONF_CTRL_1) | (1 << 24), |
| 145 | MOD_CONF_CTRL_1); |
| 146 | } |
| 147 | } |
| 148 | |
Tony Lindgren | 6c432f7 | 2012-04-23 15:56:37 -0700 | [diff] [blame] | 149 | #define OMAP_MMC_NR_RES 4 |
Tony Lindgren | 5ff391d | 2012-04-23 15:56:36 -0700 | [diff] [blame] | 150 | |
| 151 | /* |
| 152 | * Register MMC devices. |
| 153 | */ |
| 154 | static int __init omap_mmc_add(const char *name, int id, unsigned long base, |
| 155 | unsigned long size, unsigned int irq, |
Tony Lindgren | 6c432f7 | 2012-04-23 15:56:37 -0700 | [diff] [blame] | 156 | unsigned rx_req, unsigned tx_req, |
Tony Lindgren | 5ff391d | 2012-04-23 15:56:36 -0700 | [diff] [blame] | 157 | struct omap_mmc_platform_data *data) |
| 158 | { |
| 159 | struct platform_device *pdev; |
| 160 | struct resource res[OMAP_MMC_NR_RES]; |
| 161 | int ret; |
| 162 | |
| 163 | pdev = platform_device_alloc(name, id); |
| 164 | if (!pdev) |
| 165 | return -ENOMEM; |
| 166 | |
| 167 | memset(res, 0, OMAP_MMC_NR_RES * sizeof(struct resource)); |
| 168 | res[0].start = base; |
| 169 | res[0].end = base + size - 1; |
| 170 | res[0].flags = IORESOURCE_MEM; |
| 171 | res[1].start = res[1].end = irq; |
| 172 | res[1].flags = IORESOURCE_IRQ; |
Tony Lindgren | 6c432f7 | 2012-04-23 15:56:37 -0700 | [diff] [blame] | 173 | res[2].start = rx_req; |
| 174 | res[2].name = "rx"; |
| 175 | res[2].flags = IORESOURCE_DMA; |
| 176 | res[3].start = tx_req; |
| 177 | res[3].name = "tx"; |
| 178 | res[3].flags = IORESOURCE_DMA; |
Tony Lindgren | 5ff391d | 2012-04-23 15:56:36 -0700 | [diff] [blame] | 179 | |
Tony Lindgren | 53db20d | 2012-10-15 12:10:33 -0700 | [diff] [blame] | 180 | if (cpu_is_omap7xx()) |
| 181 | data->slots[0].features = MMC_OMAP7XX; |
| 182 | if (cpu_is_omap15xx()) |
| 183 | data->slots[0].features = MMC_OMAP15XX; |
| 184 | if (cpu_is_omap16xx()) |
| 185 | data->slots[0].features = MMC_OMAP16XX; |
| 186 | |
Tony Lindgren | 5ff391d | 2012-04-23 15:56:36 -0700 | [diff] [blame] | 187 | ret = platform_device_add_resources(pdev, res, ARRAY_SIZE(res)); |
| 188 | if (ret == 0) |
| 189 | ret = platform_device_add_data(pdev, data, sizeof(*data)); |
| 190 | if (ret) |
| 191 | goto fail; |
| 192 | |
| 193 | ret = platform_device_add(pdev); |
| 194 | if (ret) |
| 195 | goto fail; |
| 196 | |
| 197 | /* return device handle to board setup code */ |
| 198 | data->dev = &pdev->dev; |
| 199 | return 0; |
| 200 | |
| 201 | fail: |
| 202 | platform_device_put(pdev); |
| 203 | return ret; |
| 204 | } |
| 205 | |
Tony Lindgren | d887466 | 2008-12-10 17:37:16 -0800 | [diff] [blame] | 206 | void __init omap1_init_mmc(struct omap_mmc_platform_data **mmc_data, |
| 207 | int nr_controllers) |
| 208 | { |
| 209 | int i; |
| 210 | |
| 211 | for (i = 0; i < nr_controllers; i++) { |
| 212 | unsigned long base, size; |
Tony Lindgren | 6c432f7 | 2012-04-23 15:56:37 -0700 | [diff] [blame] | 213 | unsigned rx_req, tx_req; |
Tony Lindgren | d887466 | 2008-12-10 17:37:16 -0800 | [diff] [blame] | 214 | unsigned int irq = 0; |
| 215 | |
| 216 | if (!mmc_data[i]) |
| 217 | continue; |
| 218 | |
| 219 | omap1_mmc_mux(mmc_data[i], i); |
| 220 | |
| 221 | switch (i) { |
| 222 | case 0: |
| 223 | base = OMAP1_MMC1_BASE; |
| 224 | irq = INT_MMC; |
Tony Lindgren | 6c432f7 | 2012-04-23 15:56:37 -0700 | [diff] [blame] | 225 | rx_req = OMAP_DMA_MMC_RX; |
| 226 | tx_req = OMAP_DMA_MMC_TX; |
Tony Lindgren | d887466 | 2008-12-10 17:37:16 -0800 | [diff] [blame] | 227 | break; |
| 228 | case 1: |
| 229 | if (!cpu_is_omap16xx()) |
| 230 | return; |
| 231 | base = OMAP1_MMC2_BASE; |
| 232 | irq = INT_1610_MMC2; |
Tony Lindgren | 6c432f7 | 2012-04-23 15:56:37 -0700 | [diff] [blame] | 233 | rx_req = OMAP_DMA_MMC2_RX; |
| 234 | tx_req = OMAP_DMA_MMC2_TX; |
Tony Lindgren | d887466 | 2008-12-10 17:37:16 -0800 | [diff] [blame] | 235 | break; |
| 236 | default: |
| 237 | continue; |
| 238 | } |
| 239 | size = OMAP1_MMC_SIZE; |
| 240 | |
Tony Lindgren | 6c432f7 | 2012-04-23 15:56:37 -0700 | [diff] [blame] | 241 | omap_mmc_add("mmci-omap", i, base, size, irq, |
| 242 | rx_req, tx_req, mmc_data[i]); |
Peter Senna Tschudin | 11eff27 | 2012-09-18 18:36:10 +0200 | [diff] [blame] | 243 | } |
Tony Lindgren | d887466 | 2008-12-10 17:37:16 -0800 | [diff] [blame] | 244 | } |
| 245 | |
| 246 | #endif |
| 247 | |
| 248 | /*-------------------------------------------------------------------------*/ |
| 249 | |
Cory Maccarrone | c5c4dce | 2010-01-08 10:29:05 -0800 | [diff] [blame] | 250 | /* OMAP7xx SPI support */ |
| 251 | #if defined(CONFIG_SPI_OMAP_100K) || defined(CONFIG_SPI_OMAP_100K_MODULE) |
| 252 | |
| 253 | struct platform_device omap_spi1 = { |
| 254 | .name = "omap1_spi100k", |
| 255 | .id = 1, |
| 256 | }; |
| 257 | |
| 258 | struct platform_device omap_spi2 = { |
| 259 | .name = "omap1_spi100k", |
| 260 | .id = 2, |
| 261 | }; |
| 262 | |
| 263 | static void omap_init_spi100k(void) |
| 264 | { |
| 265 | omap_spi1.dev.platform_data = ioremap(OMAP7XX_SPI1_BASE, 0x7ff); |
| 266 | if (omap_spi1.dev.platform_data) |
| 267 | platform_device_register(&omap_spi1); |
| 268 | |
| 269 | omap_spi2.dev.platform_data = ioremap(OMAP7XX_SPI2_BASE, 0x7ff); |
| 270 | if (omap_spi2.dev.platform_data) |
| 271 | platform_device_register(&omap_spi2); |
| 272 | } |
| 273 | |
| 274 | #else |
| 275 | static inline void omap_init_spi100k(void) |
| 276 | { |
| 277 | } |
| 278 | #endif |
| 279 | |
Janusz Krzysztofik | 1a96edd | 2010-10-01 16:37:00 -0700 | [diff] [blame] | 280 | |
| 281 | #define OMAP1_CAMERA_BASE 0xfffb6800 |
| 282 | #define OMAP1_CAMERA_IOSIZE 0x1c |
| 283 | |
| 284 | static struct resource omap1_camera_resources[] = { |
| 285 | [0] = { |
| 286 | .start = OMAP1_CAMERA_BASE, |
| 287 | .end = OMAP1_CAMERA_BASE + OMAP1_CAMERA_IOSIZE - 1, |
| 288 | .flags = IORESOURCE_MEM, |
| 289 | }, |
| 290 | [1] = { |
| 291 | .start = INT_CAMERA, |
| 292 | .flags = IORESOURCE_IRQ, |
| 293 | }, |
| 294 | }; |
| 295 | |
| 296 | static u64 omap1_camera_dma_mask = DMA_BIT_MASK(32); |
| 297 | |
| 298 | static struct platform_device omap1_camera_device = { |
| 299 | .name = "omap1-camera", |
| 300 | .id = 0, /* This is used to put cameras on this interface */ |
| 301 | .dev = { |
| 302 | .dma_mask = &omap1_camera_dma_mask, |
| 303 | .coherent_dma_mask = DMA_BIT_MASK(32), |
| 304 | }, |
| 305 | .num_resources = ARRAY_SIZE(omap1_camera_resources), |
| 306 | .resource = omap1_camera_resources, |
| 307 | }; |
| 308 | |
| 309 | void __init omap1_camera_init(void *info) |
| 310 | { |
| 311 | struct platform_device *dev = &omap1_camera_device; |
| 312 | int ret; |
| 313 | |
| 314 | dev->dev.platform_data = info; |
| 315 | |
| 316 | ret = platform_device_register(dev); |
| 317 | if (ret) |
| 318 | dev_err(&dev->dev, "unable to register device: %d\n", ret); |
| 319 | } |
| 320 | |
| 321 | |
Cory Maccarrone | c5c4dce | 2010-01-08 10:29:05 -0800 | [diff] [blame] | 322 | /*-------------------------------------------------------------------------*/ |
| 323 | |
Tony Lindgren | 9b6553c | 2006-04-02 17:46:30 +0100 | [diff] [blame] | 324 | static inline void omap_init_sti(void) {} |
Tony Lindgren | 7c38cf0 | 2005-09-08 23:07:38 +0100 | [diff] [blame] | 325 | |
Tony Lindgren | 49b1a61 | 2012-05-09 09:59:25 -0700 | [diff] [blame] | 326 | /* Numbering for the SPI-capable controllers when used for SPI: |
| 327 | * spi = 1 |
| 328 | * uwire = 2 |
| 329 | * mmc1..2 = 3..4 |
| 330 | * mcbsp1..3 = 5..7 |
| 331 | */ |
| 332 | |
| 333 | #if defined(CONFIG_SPI_OMAP_UWIRE) || defined(CONFIG_SPI_OMAP_UWIRE_MODULE) |
| 334 | |
| 335 | #define OMAP_UWIRE_BASE 0xfffb3000 |
| 336 | |
| 337 | static struct resource uwire_resources[] = { |
| 338 | { |
| 339 | .start = OMAP_UWIRE_BASE, |
| 340 | .end = OMAP_UWIRE_BASE + 0x20, |
| 341 | .flags = IORESOURCE_MEM, |
| 342 | }, |
| 343 | }; |
| 344 | |
| 345 | static struct platform_device omap_uwire_device = { |
| 346 | .name = "omap_uwire", |
| 347 | .id = -1, |
| 348 | .num_resources = ARRAY_SIZE(uwire_resources), |
| 349 | .resource = uwire_resources, |
| 350 | }; |
| 351 | |
| 352 | static void omap_init_uwire(void) |
| 353 | { |
| 354 | /* FIXME define and use a boot tag; not all boards will be hooking |
| 355 | * up devices to the microwire controller, and multi-board configs |
| 356 | * mean that CONFIG_SPI_OMAP_UWIRE may be configured anyway... |
| 357 | */ |
| 358 | |
| 359 | /* board-specific code must configure chipselects (only a few |
| 360 | * are normally used) and SCLK/SDI/SDO (each has two choices). |
| 361 | */ |
| 362 | (void) platform_device_register(&omap_uwire_device); |
| 363 | } |
| 364 | #else |
| 365 | static inline void omap_init_uwire(void) {} |
| 366 | #endif |
| 367 | |
| 368 | |
Paul Walmsley | 4848d46 | 2012-09-23 17:28:27 -0600 | [diff] [blame] | 369 | #define OMAP1_RNG_BASE 0xfffe5000 |
| 370 | |
| 371 | static struct resource omap1_rng_resources[] = { |
| 372 | { |
| 373 | .start = OMAP1_RNG_BASE, |
| 374 | .end = OMAP1_RNG_BASE + 0x4f, |
| 375 | .flags = IORESOURCE_MEM, |
| 376 | }, |
| 377 | }; |
| 378 | |
| 379 | static struct platform_device omap1_rng_device = { |
| 380 | .name = "omap_rng", |
| 381 | .id = -1, |
| 382 | .num_resources = ARRAY_SIZE(omap1_rng_resources), |
| 383 | .resource = omap1_rng_resources, |
| 384 | }; |
| 385 | |
| 386 | static void omap1_init_rng(void) |
| 387 | { |
Paul Walmsley | fe47c58 | 2012-09-23 17:28:27 -0600 | [diff] [blame] | 388 | if (!cpu_is_omap16xx()) |
| 389 | return; |
| 390 | |
Paul Walmsley | 4848d46 | 2012-09-23 17:28:27 -0600 | [diff] [blame] | 391 | (void) platform_device_register(&omap1_rng_device); |
| 392 | } |
| 393 | |
| 394 | /*-------------------------------------------------------------------------*/ |
| 395 | |
Tony Lindgren | 7c38cf0 | 2005-09-08 23:07:38 +0100 | [diff] [blame] | 396 | /* |
| 397 | * This gets called after board-specific INIT_MACHINE, and initializes most |
| 398 | * on-chip peripherals accessible on this board (except for few like USB): |
| 399 | * |
| 400 | * (a) Does any "standard config" pin muxing needed. Board-specific |
| 401 | * code will have muxed GPIO pins and done "nonstandard" setup; |
| 402 | * that code could live in the boot loader. |
| 403 | * (b) Populating board-specific platform_data with the data drivers |
| 404 | * rely on to handle wiring variations. |
| 405 | * (c) Creating platform devices as meaningful on this board and |
| 406 | * with this kernel configuration. |
| 407 | * |
| 408 | * Claiming GPIOs, and setting their direction and initial values, is the |
| 409 | * responsibility of the device drivers. So is responding to probe(). |
| 410 | * |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 411 | * Board-specific knowledge like creating devices or pin setup is to be |
Tony Lindgren | 7c38cf0 | 2005-09-08 23:07:38 +0100 | [diff] [blame] | 412 | * kept out of drivers as much as possible. In particular, pin setup |
| 413 | * may be handled by the boot loader, and drivers should expect it will |
| 414 | * normally have been done by the time they're probed. |
| 415 | */ |
Tony Lindgren | 3179a01 | 2005-11-10 14:26:48 +0000 | [diff] [blame] | 416 | static int __init omap1_init_devices(void) |
Tony Lindgren | 7c38cf0 | 2005-09-08 23:07:38 +0100 | [diff] [blame] | 417 | { |
Tony Lindgren | 7f9187c | 2010-12-10 09:46:24 -0800 | [diff] [blame] | 418 | if (!cpu_class_is_omap1()) |
| 419 | return -ENODEV; |
| 420 | |
Tony Lindgren | a66cb34 | 2011-10-04 13:52:57 -0700 | [diff] [blame] | 421 | omap_sram_init(); |
Tony Lindgren | e9b7086 | 2011-11-11 10:15:11 -0800 | [diff] [blame] | 422 | omap1_clk_late_init(); |
Tony Lindgren | a66cb34 | 2011-10-04 13:52:57 -0700 | [diff] [blame] | 423 | |
Tony Lindgren | 7c38cf0 | 2005-09-08 23:07:38 +0100 | [diff] [blame] | 424 | /* please keep these calls, and their implementations above, |
| 425 | * in alphabetical order so they're easier to sort through. |
| 426 | */ |
Tony Lindgren | c40fae95 | 2006-12-07 13:58:10 -0800 | [diff] [blame] | 427 | |
Tony Lindgren | fcc76a8 | 2012-05-09 09:59:25 -0700 | [diff] [blame] | 428 | omap_init_audio(); |
Tony Lindgren | c40fae95 | 2006-12-07 13:58:10 -0800 | [diff] [blame] | 429 | omap_init_mbox(); |
Tony Lindgren | 7c38cf0 | 2005-09-08 23:07:38 +0100 | [diff] [blame] | 430 | omap_init_rtc(); |
Cory Maccarrone | c5c4dce | 2010-01-08 10:29:05 -0800 | [diff] [blame] | 431 | omap_init_spi100k(); |
Tony Lindgren | 9b6553c | 2006-04-02 17:46:30 +0100 | [diff] [blame] | 432 | omap_init_sti(); |
Tony Lindgren | 49b1a61 | 2012-05-09 09:59:25 -0700 | [diff] [blame] | 433 | omap_init_uwire(); |
Paul Walmsley | 4848d46 | 2012-09-23 17:28:27 -0600 | [diff] [blame] | 434 | omap1_init_rng(); |
Tony Lindgren | 7c38cf0 | 2005-09-08 23:07:38 +0100 | [diff] [blame] | 435 | |
| 436 | return 0; |
| 437 | } |
Tony Lindgren | 3179a01 | 2005-11-10 14:26:48 +0000 | [diff] [blame] | 438 | arch_initcall(omap1_init_devices); |
Tony Lindgren | 7c38cf0 | 2005-09-08 23:07:38 +0100 | [diff] [blame] | 439 | |
Varadarajan, Charulatha | f2ce623 | 2010-09-23 20:02:42 +0530 | [diff] [blame] | 440 | #if defined(CONFIG_OMAP_WATCHDOG) || defined(CONFIG_OMAP_WATCHDOG_MODULE) |
| 441 | |
| 442 | static struct resource wdt_resources[] = { |
| 443 | { |
| 444 | .start = 0xfffeb000, |
| 445 | .end = 0xfffeb07F, |
| 446 | .flags = IORESOURCE_MEM, |
| 447 | }, |
| 448 | }; |
| 449 | |
| 450 | static struct platform_device omap_wdt_device = { |
| 451 | .name = "omap_wdt", |
| 452 | .id = -1, |
| 453 | .num_resources = ARRAY_SIZE(wdt_resources), |
| 454 | .resource = wdt_resources, |
| 455 | }; |
| 456 | |
| 457 | static int __init omap_init_wdt(void) |
| 458 | { |
| 459 | if (!cpu_is_omap16xx()) |
Felipe Balbi | dfcccd3 | 2010-11-08 06:48:00 +0000 | [diff] [blame] | 460 | return -ENODEV; |
Varadarajan, Charulatha | f2ce623 | 2010-09-23 20:02:42 +0530 | [diff] [blame] | 461 | |
Felipe Balbi | dfcccd3 | 2010-11-08 06:48:00 +0000 | [diff] [blame] | 462 | return platform_device_register(&omap_wdt_device); |
Varadarajan, Charulatha | f2ce623 | 2010-09-23 20:02:42 +0530 | [diff] [blame] | 463 | } |
| 464 | subsys_initcall(omap_init_wdt); |
| 465 | #endif |