arch/arm/plat-omap/devices.c

   1 /*
   2  * linux/arch/arm/plat-omap/devices.c
   3  *
   4  * Common platform device setup/initialization for OMAP1 and OMAP2
   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/module.h>
  13 #include <linux/kernel.h>
  14 #include <linux/init.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/io.h>
  17 #include <linux/slab.h>
  18 #include <linux/memblock.h>
  19
  20 #include <mach/hardware.h>
  21 #include <asm/mach-types.h>
  22 #include <asm/mach/map.h>
  23
  24 #include <plat/tc.h>
  25 #include <plat/board.h>
  26 #include <plat/mmc.h>
  27 #include <plat/menelaus.h>
  28 #include <plat/omap44xx.h>
  29
  30 #if defined(CONFIG_MMC_OMAP) || defined(CONFIG_MMC_OMAP_MODULE) || \
  31         defined(CONFIG_MMC_OMAP_HS) || defined(CONFIG_MMC_OMAP_HS_MODULE)
  32
  33 #define OMAP_MMC_NR_RES         2
  34
  35 /*
  36  * Register MMC devices. Called from mach-omap1 and mach-omap2 device init.
  37  */
  38 int __init omap_mmc_add(const char *name, int id, unsigned long base,
  39                                 unsigned long size, unsigned int irq,
  40                                 struct omap_mmc_platform_data *data)
  41 {
  42         struct platform_device *pdev;
  43         struct resource res[OMAP_MMC_NR_RES];
  44         int ret;
  45
  46         pdev = platform_device_alloc(name, id);
  47         if (!pdev)
  48                 return -ENOMEM;
  49
  50         memset(res, 0, OMAP_MMC_NR_RES * sizeof(struct resource));
  51         res[0].start = base;
  52         res[0].end = base + size - 1;
  53         res[0].flags = IORESOURCE_MEM;
  54         res[1].start = res[1].end = irq;
  55         res[1].flags = IORESOURCE_IRQ;
  56
  57         ret = platform_device_add_resources(pdev, res, ARRAY_SIZE(res));
  58         if (ret == 0)
  59                 ret = platform_device_add_data(pdev, data, sizeof(*data));
  60         if (ret)
  61                 goto fail;
  62
  63         ret = platform_device_add(pdev);
  64         if (ret)
  65                 goto fail;
  66
  67         /* return device handle to board setup code */
  68         data->dev = &pdev->dev;
  69         return 0;
  70
  71 fail:
  72         platform_device_put(pdev);
  73         return ret;
  74 }
  75
  76 #endif
  77
  78 /*-------------------------------------------------------------------------*/
  79
  80 #if defined(CONFIG_HW_RANDOM_OMAP) || defined(CONFIG_HW_RANDOM_OMAP_MODULE)
  81
  82 #ifdef CONFIG_ARCH_OMAP2
  83 #define OMAP_RNG_BASE           0x480A0000
  84 #else
  85 #define OMAP_RNG_BASE           0xfffe5000
  86 #endif
  87
  88 static struct resource rng_resources[] = {
  89         {
  90                 .start          = OMAP_RNG_BASE,
  91                 .end            = OMAP_RNG_BASE + 0x4f,
  92                 .flags          = IORESOURCE_MEM,
  93         },
  94 };
  95
  96 static struct platform_device omap_rng_device = {
  97         .name           = "omap_rng",
  98         .id             = -1,
  99         .num_resources  = ARRAY_SIZE(rng_resources),
 100         .resource       = rng_resources,
 101 };
 102
 103 static void omap_init_rng(void)
 104 {
 105         (void) platform_device_register(&omap_rng_device);
 106 }
 107 #else
 108 static inline void omap_init_rng(void) {}
 109 #endif
 110
 111 /*-------------------------------------------------------------------------*/
 112
 113 /* Numbering for the SPI-capable controllers when used for SPI:
 114  * spi          = 1
 115  * uwire        = 2
 116  * mmc1..2      = 3..4
 117  * mcbsp1..3    = 5..7
 118  */
 119
 120 #if defined(CONFIG_SPI_OMAP_UWIRE) || defined(CONFIG_SPI_OMAP_UWIRE_MODULE)
 121
 122 #define OMAP_UWIRE_BASE         0xfffb3000
 123
 124 static struct resource uwire_resources[] = {
 125         {
 126                 .start          = OMAP_UWIRE_BASE,
 127                 .end            = OMAP_UWIRE_BASE + 0x20,
 128                 .flags          = IORESOURCE_MEM,
 129         },
 130 };
 131
 132 static struct platform_device omap_uwire_device = {
 133         .name      = "omap_uwire",
 134         .id          = -1,
 135         .num_resources  = ARRAY_SIZE(uwire_resources),
 136         .resource       = uwire_resources,
 137 };
 138
 139 static void omap_init_uwire(void)
 140 {
 141         /* FIXME define and use a boot tag; not all boards will be hooking
 142          * up devices to the microwire controller, and multi-board configs
 143          * mean that CONFIG_SPI_OMAP_UWIRE may be configured anyway...
 144          */
 145
 146         /* board-specific code must configure chipselects (only a few
 147          * are normally used) and SCLK/SDI/SDO (each has two choices).
 148          */
 149         (void) platform_device_register(&omap_uwire_device);
 150 }
 151 #else
 152 static inline void omap_init_uwire(void) {}
 153 #endif
 154
 155 #if defined(CONFIG_TIDSPBRIDGE) || defined(CONFIG_TIDSPBRIDGE_MODULE)
 156
 157 static phys_addr_t omap_dsp_phys_mempool_base;
 158
 159 void __init omap_dsp_reserve_sdram_memblock(void)
 160 {
 161         phys_addr_t size = CONFIG_TIDSPBRIDGE_MEMPOOL_SIZE;
 162         phys_addr_t paddr;
 163
 164         if (!size)
 165                 return;
 166
 167         paddr = memblock_alloc(size, SZ_1M);
 168         if (!paddr) {
 169                 pr_err("%s: failed to reserve %x bytes\n",
 170                                 __func__, size);
 171                 return;
 172         }
 173         memblock_free(paddr, size);
 174         memblock_remove(paddr, size);
 175
 176         omap_dsp_phys_mempool_base = paddr;
 177 }
 178
 179 phys_addr_t omap_dsp_get_mempool_base(void)
 180 {
 181         return omap_dsp_phys_mempool_base;
 182 }
 183 EXPORT_SYMBOL(omap_dsp_get_mempool_base);
 184 #endif
 185
 186 /*
 187  * This gets called after board-specific INIT_MACHINE, and initializes most
 188  * on-chip peripherals accessible on this board (except for few like USB):
 189  *
 190  *  (a) Does any "standard config" pin muxing needed.  Board-specific
 191  *      code will have muxed GPIO pins and done "nonstandard" setup;
 192  *      that code could live in the boot loader.
 193  *  (b) Populating board-specific platform_data with the data drivers
 194  *      rely on to handle wiring variations.
 195  *  (c) Creating platform devices as meaningful on this board and
 196  *      with this kernel configuration.
 197  *
 198  * Claiming GPIOs, and setting their direction and initial values, is the
 199  * responsibility of the device drivers.  So is responding to probe().
 200  *
 201  * Board-specific knowledge like creating devices or pin setup is to be
 202  * kept out of drivers as much as possible.  In particular, pin setup
 203  * may be handled by the boot loader, and drivers should expect it will
 204  * normally have been done by the time they're probed.
 205  */
 206 static int __init omap_init_devices(void)
 207 {
 208         /* please keep these calls, and their implementations above,
 209          * in alphabetical order so they're easier to sort through.
 210          */
 211         omap_init_rng();
 212         omap_init_uwire();
 213         return 0;
 214 }
 215 arch_initcall(omap_init_devices);