arch/arm/mach-omap2/io.c

   1 /*
   2  * linux/arch/arm/mach-omap2/io.c
   3  *
   4  * OMAP2 I/O mapping code
   5  *
   6  * Copyright (C) 2005 Nokia Corporation
   7  * Copyright (C) 2007-2009 Texas Instruments
   8  *
   9  * Author:
  10  *      Juha Yrjola <juha.yrjola@nokia.com>
  11  *      Syed Khasim <x0khasim@ti.com>
  12  *
  13  * Added OMAP4 support - Santosh Shilimkar <santosh.shilimkar@ti.com>
  14  *
  15  * This program is free software; you can redistribute it and/or modify
  16  * it under the terms of the GNU General Public License version 2 as
  17  * published by the Free Software Foundation.
  18  */
  19
  20 #include <linux/module.h>
  21 #include <linux/kernel.h>
  22 #include <linux/init.h>
  23 #include <linux/io.h>
  24
  25 #include <asm/tlb.h>
  26
  27 #include <asm/mach/map.h>
  28
  29 #include <mach/mux.h>
  30 #include <mach/omapfb.h>
  31 #include <mach/sram.h>
  32 #include <mach/sdrc.h>
  33 #include <mach/gpmc.h>
  34
  35 #ifndef CONFIG_ARCH_OMAP4       /* FIXME: Remove this once clkdev is ready */
  36 #include "clock.h"
  37
  38 #include <mach/powerdomain.h>
  39
  40 #include "powerdomains.h"
  41
  42 #include <mach/clockdomain.h>
  43 #include "clockdomains.h"
  44 #endif
  45 /*
  46  * The machine specific code may provide the extra mapping besides the
  47  * default mapping provided here.
  48  */
  49
  50 #ifdef CONFIG_ARCH_OMAP24XX
  51 static struct map_desc omap24xx_io_desc[] __initdata = {
  52         {
  53                 .virtual        = L3_24XX_VIRT,
  54                 .pfn            = __phys_to_pfn(L3_24XX_PHYS),
  55                 .length         = L3_24XX_SIZE,
  56                 .type           = MT_DEVICE
  57         },
  58         {
  59                 .virtual        = L4_24XX_VIRT,
  60                 .pfn            = __phys_to_pfn(L4_24XX_PHYS),
  61                 .length         = L4_24XX_SIZE,
  62                 .type           = MT_DEVICE
  63         },
  64 };
  65
  66 #ifdef CONFIG_ARCH_OMAP2420
  67 static struct map_desc omap242x_io_desc[] __initdata = {
  68         {
  69                 .virtual        = DSP_MEM_24XX_VIRT,
  70                 .pfn            = __phys_to_pfn(DSP_MEM_24XX_PHYS),
  71                 .length         = DSP_MEM_24XX_SIZE,
  72                 .type           = MT_DEVICE
  73         },
  74         {
  75                 .virtual        = DSP_IPI_24XX_VIRT,
  76                 .pfn            = __phys_to_pfn(DSP_IPI_24XX_PHYS),
  77                 .length         = DSP_IPI_24XX_SIZE,
  78                 .type           = MT_DEVICE
  79         },
  80         {
  81                 .virtual        = DSP_MMU_24XX_VIRT,
  82                 .pfn            = __phys_to_pfn(DSP_MMU_24XX_PHYS),
  83                 .length         = DSP_MMU_24XX_SIZE,
  84                 .type           = MT_DEVICE
  85         },
  86 };
  87
  88 #endif
  89
  90 #ifdef CONFIG_ARCH_OMAP2430
  91 static struct map_desc omap243x_io_desc[] __initdata = {
  92         {
  93                 .virtual        = L4_WK_243X_VIRT,
  94                 .pfn            = __phys_to_pfn(L4_WK_243X_PHYS),
  95                 .length         = L4_WK_243X_SIZE,
  96                 .type           = MT_DEVICE
  97         },
  98         {
  99                 .virtual        = OMAP243X_GPMC_VIRT,
 100                 .pfn            = __phys_to_pfn(OMAP243X_GPMC_PHYS),
 101                 .length         = OMAP243X_GPMC_SIZE,
 102                 .type           = MT_DEVICE
 103         },
 104         {
 105                 .virtual        = OMAP243X_SDRC_VIRT,
 106                 .pfn            = __phys_to_pfn(OMAP243X_SDRC_PHYS),
 107                 .length         = OMAP243X_SDRC_SIZE,
 108                 .type           = MT_DEVICE
 109         },
 110         {
 111                 .virtual        = OMAP243X_SMS_VIRT,
 112                 .pfn            = __phys_to_pfn(OMAP243X_SMS_PHYS),
 113                 .length         = OMAP243X_SMS_SIZE,
 114                 .type           = MT_DEVICE
 115         },
 116 };
 117 #endif
 118 #endif
 119
 120 #ifdef  CONFIG_ARCH_OMAP34XX
 121 static struct map_desc omap34xx_io_desc[] __initdata = {
 122         {
 123                 .virtual        = L3_34XX_VIRT,
 124                 .pfn            = __phys_to_pfn(L3_34XX_PHYS),
 125                 .length         = L3_34XX_SIZE,
 126                 .type           = MT_DEVICE
 127         },
 128         {
 129                 .virtual        = L4_34XX_VIRT,
 130                 .pfn            = __phys_to_pfn(L4_34XX_PHYS),
 131                 .length         = L4_34XX_SIZE,
 132                 .type           = MT_DEVICE
 133         },
 134         {
 135                 .virtual        = L4_WK_34XX_VIRT,
 136                 .pfn            = __phys_to_pfn(L4_WK_34XX_PHYS),
 137                 .length         = L4_WK_34XX_SIZE,
 138                 .type           = MT_DEVICE
 139         },
 140         {
 141                 .virtual        = OMAP34XX_GPMC_VIRT,
 142                 .pfn            = __phys_to_pfn(OMAP34XX_GPMC_PHYS),
 143                 .length         = OMAP34XX_GPMC_SIZE,
 144                 .type           = MT_DEVICE
 145         },
 146         {
 147                 .virtual        = OMAP343X_SMS_VIRT,
 148                 .pfn            = __phys_to_pfn(OMAP343X_SMS_PHYS),
 149                 .length         = OMAP343X_SMS_SIZE,
 150                 .type           = MT_DEVICE
 151         },
 152         {
 153                 .virtual        = OMAP343X_SDRC_VIRT,
 154                 .pfn            = __phys_to_pfn(OMAP343X_SDRC_PHYS),
 155                 .length         = OMAP343X_SDRC_SIZE,
 156                 .type           = MT_DEVICE
 157         },
 158         {
 159                 .virtual        = L4_PER_34XX_VIRT,
 160                 .pfn            = __phys_to_pfn(L4_PER_34XX_PHYS),
 161                 .length         = L4_PER_34XX_SIZE,
 162                 .type           = MT_DEVICE
 163         },
 164         {
 165                 .virtual        = L4_EMU_34XX_VIRT,
 166                 .pfn            = __phys_to_pfn(L4_EMU_34XX_PHYS),
 167                 .length         = L4_EMU_34XX_SIZE,
 168                 .type           = MT_DEVICE
 169         },
 170 };
 171 #endif
 172 #ifdef  CONFIG_ARCH_OMAP4
 173 static struct map_desc omap44xx_io_desc[] __initdata = {
 174         {
 175                 .virtual        = L3_44XX_VIRT,
 176                 .pfn            = __phys_to_pfn(L3_44XX_PHYS),
 177                 .length         = L3_44XX_SIZE,
 178                 .type           = MT_DEVICE,
 179         },
 180         {
 181                 .virtual        = L4_44XX_VIRT,
 182                 .pfn            = __phys_to_pfn(L4_44XX_PHYS),
 183                 .length         = L4_44XX_SIZE,
 184                 .type           = MT_DEVICE,
 185         },
 186         {
 187                 .virtual        = L4_WK_44XX_VIRT,
 188                 .pfn            = __phys_to_pfn(L4_WK_44XX_PHYS),
 189                 .length         = L4_WK_44XX_SIZE,
 190                 .type           = MT_DEVICE,
 191         },
 192         {
 193                 .virtual        = OMAP44XX_GPMC_VIRT,
 194                 .pfn            = __phys_to_pfn(OMAP44XX_GPMC_PHYS),
 195                 .length         = OMAP44XX_GPMC_SIZE,
 196                 .type           = MT_DEVICE,
 197         },
 198         {
 199                 .virtual        = L4_PER_44XX_VIRT,
 200                 .pfn            = __phys_to_pfn(L4_PER_44XX_PHYS),
 201                 .length         = L4_PER_44XX_SIZE,
 202                 .type           = MT_DEVICE,
 203         },
 204         {
 205                 .virtual        = L4_EMU_44XX_VIRT,
 206                 .pfn            = __phys_to_pfn(L4_EMU_44XX_PHYS),
 207                 .length         = L4_EMU_44XX_SIZE,
 208                 .type           = MT_DEVICE,
 209         },
 210 };
 211 #endif
 212
 213 void __init omap2_map_common_io(void)
 214 {
 215 #if defined(CONFIG_ARCH_OMAP2420)
 216         iotable_init(omap24xx_io_desc, ARRAY_SIZE(omap24xx_io_desc));
 217         iotable_init(omap242x_io_desc, ARRAY_SIZE(omap242x_io_desc));
 218 #endif
 219
 220 #if defined(CONFIG_ARCH_OMAP2430)
 221         iotable_init(omap24xx_io_desc, ARRAY_SIZE(omap24xx_io_desc));
 222         iotable_init(omap243x_io_desc, ARRAY_SIZE(omap243x_io_desc));
 223 #endif
 224
 225 #if defined(CONFIG_ARCH_OMAP34XX)
 226         iotable_init(omap34xx_io_desc, ARRAY_SIZE(omap34xx_io_desc));
 227 #endif
 228
 229 #if defined(CONFIG_ARCH_OMAP4)
 230         iotable_init(omap44xx_io_desc, ARRAY_SIZE(omap44xx_io_desc));
 231 #endif
 232         /* Normally devicemaps_init() would flush caches and tlb after
 233          * mdesc->map_io(), but we must also do it here because of the CPU
 234          * revision check below.
 235          */
 236         local_flush_tlb_all();
 237         flush_cache_all();
 238
 239         omap2_check_revision();
 240         omap_sram_init();
 241         omapfb_reserve_sdram();
 242 }
 243
 244 void __init omap2_init_common_hw(struct omap_sdrc_params *sp)
 245 {
 246         omap2_mux_init();
 247 #ifndef CONFIG_ARCH_OMAP4 /* FIXME: Remove this once the clkdev is ready */
 248         pwrdm_init(powerdomains_omap);
 249         clkdm_init(clockdomains_omap, clkdm_pwrdm_autodeps);
 250         omap2_clk_init();
 251         omap2_sdrc_init(sp);
 252 #endif
 253         gpmc_init();
 254 }