arch/arm/plat-omap/common.c

   1 /*
   2  * linux/arch/arm/plat-omap/common.c
   3  *
   4  * Code common to all OMAP machines.
   5  * The file is created by Tony Lindgren <tony@atomide.com>
   6  *
   7  * Copyright (C) 2009 Texas Instruments
   8  * Added OMAP4 support - Santosh Shilimkar <santosh.shilimkar@ti.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2 as
  12  * published by the Free Software Foundation.
  13  */
  14 #include <linux/module.h>
  15 #include <linux/kernel.h>
  16 #include <linux/init.h>
  17 #include <linux/delay.h>
  18 #include <linux/console.h>
  19 #include <linux/serial.h>
  20 #include <linux/tty.h>
  21 #include <linux/serial_8250.h>
  22 #include <linux/serial_reg.h>
  23 #include <linux/clk.h>
  24 #include <linux/io.h>
  25
  26 #include <mach/hardware.h>
  27 #include <asm/system.h>
  28 #include <asm/pgtable.h>
  29 #include <asm/mach/map.h>
  30 #include <asm/setup.h>
  31
  32 #include <plat/common.h>
  33 #include <plat/board.h>
  34 #include <plat/control.h>
  35 #include <plat/mux.h>
  36 #include <plat/fpga.h>
  37
  38 #include <plat/clock.h>
  39
  40 #if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
  41 # include "../mach-omap2/sdrc.h"
  42 #endif
  43
  44 #define NO_LENGTH_CHECK 0xffffffff
  45
  46 unsigned char omap_bootloader_tag[512];
  47 int omap_bootloader_tag_len;
  48
  49 struct omap_board_config_kernel *omap_board_config;
  50 int omap_board_config_size;
  51
  52 /* used by omap-smp.c and board-4430sdp.c */
  53 void __iomem *gic_cpu_base_addr;
  54
  55 static const void *get_config(u16 tag, size_t len, int skip, size_t *len_out)
  56 {
  57         struct omap_board_config_kernel *kinfo = NULL;
  58         int i;
  59
  60         /* Try to find the config from the board-specific structures
  61          * in the kernel. */
  62         for (i = 0; i < omap_board_config_size; i++) {
  63                 if (omap_board_config[i].tag == tag) {
  64                         if (skip == 0) {
  65                                 kinfo = &omap_board_config[i];
  66                                 break;
  67                         } else {
  68                                 skip--;
  69                         }
  70                 }
  71         }
  72         if (kinfo == NULL)
  73                 return NULL;
  74         return kinfo->data;
  75 }
  76
  77 const void *__omap_get_config(u16 tag, size_t len, int nr)
  78 {
  79         return get_config(tag, len, nr, NULL);
  80 }
  81 EXPORT_SYMBOL(__omap_get_config);
  82
  83 const void *omap_get_var_config(u16 tag, size_t *len)
  84 {
  85         return get_config(tag, NO_LENGTH_CHECK, 0, len);
  86 }
  87 EXPORT_SYMBOL(omap_get_var_config);
  88
  89 /*
  90  * 32KHz clocksource ... always available, on pretty most chips except
  91  * OMAP 730 and 1510.  Other timers could be used as clocksources, with
  92  * higher resolution in free-running counter modes (e.g. 12 MHz xtal),
  93  * but systems won't necessarily want to spend resources that way.
  94  */
  95
  96 #define OMAP16XX_TIMER_32K_SYNCHRONIZED         0xfffbc410
  97
  98 #if !(defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP15XX))
  99
 100 #include <linux/clocksource.h>
 101
 102 #ifdef CONFIG_ARCH_OMAP16XX
 103 static cycle_t omap16xx_32k_read(struct clocksource *cs)
 104 {
 105         return omap_readl(OMAP16XX_TIMER_32K_SYNCHRONIZED);
 106 }
 107 #else
 108 #define omap16xx_32k_read       NULL
 109 #endif
 110
 111 #ifdef CONFIG_ARCH_OMAP2420
 112 static cycle_t omap2420_32k_read(struct clocksource *cs)
 113 {
 114         return omap_readl(OMAP2420_32KSYNCT_BASE + 0x10);
 115 }
 116 #else
 117 #define omap2420_32k_read       NULL
 118 #endif
 119
 120 #ifdef CONFIG_ARCH_OMAP2430
 121 static cycle_t omap2430_32k_read(struct clocksource *cs)
 122 {
 123         return omap_readl(OMAP2430_32KSYNCT_BASE + 0x10);
 124 }
 125 #else
 126 #define omap2430_32k_read       NULL
 127 #endif
 128
 129 #ifdef CONFIG_ARCH_OMAP34XX
 130 static cycle_t omap34xx_32k_read(struct clocksource *cs)
 131 {
 132         return omap_readl(OMAP3430_32KSYNCT_BASE + 0x10);
 133 }
 134 #else
 135 #define omap34xx_32k_read       NULL
 136 #endif
 137
 138 #ifdef CONFIG_ARCH_OMAP4
 139 static cycle_t omap44xx_32k_read(struct clocksource *cs)
 140 {
 141         return omap_readl(OMAP4430_32KSYNCT_BASE + 0x10);
 142 }
 143 #else
 144 #define omap44xx_32k_read       NULL
 145 #endif
 146
 147 /*
 148  * Kernel assumes that sched_clock can be called early but may not have
 149  * things ready yet.
 150  */
 151 static cycle_t omap_32k_read_dummy(struct clocksource *cs)
 152 {
 153         return 0;
 154 }
 155
 156 static struct clocksource clocksource_32k = {
 157         .name           = "32k_counter",
 158         .rating         = 250,
 159         .read           = omap_32k_read_dummy,
 160         .mask           = CLOCKSOURCE_MASK(32),
 161         .shift          = 10,
 162         .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
 163 };
 164
 165 /*
 166  * Returns current time from boot in nsecs. It's OK for this to wrap
 167  * around for now, as it's just a relative time stamp.
 168  */
 169 unsigned long long sched_clock(void)
 170 {
 171         return clocksource_cyc2ns(clocksource_32k.read(&clocksource_32k),
 172                                   clocksource_32k.mult, clocksource_32k.shift);
 173 }
 174
 175 static int __init omap_init_clocksource_32k(void)
 176 {
 177         static char err[] __initdata = KERN_ERR
 178                         "%s: can't register clocksource!\n";
 179
 180         if (cpu_is_omap16xx() || cpu_class_is_omap2()) {
 181                 struct clk *sync_32k_ick;
 182
 183                 if (cpu_is_omap16xx())
 184                         clocksource_32k.read = omap16xx_32k_read;
 185                 else if (cpu_is_omap2420())
 186                         clocksource_32k.read = omap2420_32k_read;
 187                 else if (cpu_is_omap2430())
 188                         clocksource_32k.read = omap2430_32k_read;
 189                 else if (cpu_is_omap34xx())
 190                         clocksource_32k.read = omap34xx_32k_read;
 191                 else if (cpu_is_omap44xx())
 192                         clocksource_32k.read = omap44xx_32k_read;
 193                 else
 194                         return -ENODEV;
 195
 196                 sync_32k_ick = clk_get(NULL, "omap_32ksync_ick");
 197                 if (sync_32k_ick)
 198                         clk_enable(sync_32k_ick);
 199
 200                 clocksource_32k.mult = clocksource_hz2mult(32768,
 201                                             clocksource_32k.shift);
 202
 203                 if (clocksource_register(&clocksource_32k))
 204                         printk(err, clocksource_32k.name);
 205         }
 206         return 0;
 207 }
 208 arch_initcall(omap_init_clocksource_32k);
 209
 210 #endif  /* !(defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP15XX)) */
 211
 212 /* Global address base setup code */
 213
 214 #if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
 215
 216 static void __init __omap2_set_globals(struct omap_globals *omap2_globals)
 217 {
 218         omap2_set_globals_tap(omap2_globals);
 219         omap2_set_globals_sdrc(omap2_globals);
 220         omap2_set_globals_control(omap2_globals);
 221         omap2_set_globals_prcm(omap2_globals);
 222 }
 223
 224 #endif
 225
 226 #if defined(CONFIG_ARCH_OMAP2420)
 227
 228 static struct omap_globals omap242x_globals = {
 229         .class  = OMAP242X_CLASS,
 230         .tap    = OMAP2_L4_IO_ADDRESS(0x48014000),
 231         .sdrc   = OMAP2_L3_IO_ADDRESS(OMAP2420_SDRC_BASE),
 232         .sms    = OMAP2_L3_IO_ADDRESS(OMAP2420_SMS_BASE),
 233         .ctrl   = OMAP2_L4_IO_ADDRESS(OMAP2420_CTRL_BASE),
 234         .prm    = OMAP2_L4_IO_ADDRESS(OMAP2420_PRM_BASE),
 235         .cm     = OMAP2_L4_IO_ADDRESS(OMAP2420_CM_BASE),
 236 };
 237
 238 void __init omap2_set_globals_242x(void)
 239 {
 240         __omap2_set_globals(&omap242x_globals);
 241 }
 242 #endif
 243
 244 #if defined(CONFIG_ARCH_OMAP2430)
 245
 246 static struct omap_globals omap243x_globals = {
 247         .class  = OMAP243X_CLASS,
 248         .tap    = OMAP2_L4_IO_ADDRESS(0x4900a000),
 249         .sdrc   = OMAP2_L3_IO_ADDRESS(OMAP243X_SDRC_BASE),
 250         .sms    = OMAP2_L3_IO_ADDRESS(OMAP243X_SMS_BASE),
 251         .ctrl   = OMAP2_L4_IO_ADDRESS(OMAP243X_CTRL_BASE),
 252         .prm    = OMAP2_L4_IO_ADDRESS(OMAP2430_PRM_BASE),
 253         .cm     = OMAP2_L4_IO_ADDRESS(OMAP2430_CM_BASE),
 254 };
 255
 256 void __init omap2_set_globals_243x(void)
 257 {
 258         __omap2_set_globals(&omap243x_globals);
 259 }
 260 #endif
 261
 262 #if defined(CONFIG_ARCH_OMAP3430)
 263
 264 static struct omap_globals omap343x_globals = {
 265         .class  = OMAP343X_CLASS,
 266         .tap    = OMAP2_L4_IO_ADDRESS(0x4830A000),
 267         .sdrc   = OMAP2_L3_IO_ADDRESS(OMAP343X_SDRC_BASE),
 268         .sms    = OMAP2_L3_IO_ADDRESS(OMAP343X_SMS_BASE),
 269         .ctrl   = OMAP2_L4_IO_ADDRESS(OMAP343X_CTRL_BASE),
 270         .prm    = OMAP2_L4_IO_ADDRESS(OMAP3430_PRM_BASE),
 271         .cm     = OMAP2_L4_IO_ADDRESS(OMAP3430_CM_BASE),
 272 };
 273
 274 void __init omap2_set_globals_343x(void)
 275 {
 276         __omap2_set_globals(&omap343x_globals);
 277 }
 278 #endif
 279
 280 #if defined(CONFIG_ARCH_OMAP4)
 281 static struct omap_globals omap4_globals = {
 282         .class  = OMAP443X_CLASS,
 283         .tap    = OMAP2_L4_IO_ADDRESS(0x4830a000),
 284         .ctrl   = OMAP2_L4_IO_ADDRESS(OMAP443X_CTRL_BASE),
 285         .prm    = OMAP2_L4_IO_ADDRESS(OMAP4430_PRM_BASE),
 286         .cm     = OMAP2_L4_IO_ADDRESS(OMAP4430_CM_BASE),
 287 };
 288
 289 void __init omap2_set_globals_443x(void)
 290 {
 291         omap2_set_globals_tap(&omap4_globals);
 292         omap2_set_globals_control(&omap4_globals);
 293 }
 294 #endif
 295