arch/arm/cpu/armv7/omap-common/hwinit-common.c

   1 /*
   2  *
   3  * Common functions for OMAP4/5 based boards
   4  *
   5  * (C) Copyright 2010
   6  * Texas Instruments, <www.ti.com>
   7  *
   8  * Author :
   9  *      Aneesh V        <aneesh@ti.com>
  10  *      Steve Sakoman   <steve@sakoman.com>
  11  *
  12  * SPDX-License-Identifier:     GPL-2.0+
  13  */
  14 #include <common.h>
  15 #include <spl.h>
  16 #include <asm/arch/sys_proto.h>
  17 #include <linux/sizes.h>
  18 #include <asm/emif.h>
  19 #include <asm/omap_common.h>
  20 #include <linux/compiler.h>
  21 #include <asm/system.h>
  22
  23 DECLARE_GLOBAL_DATA_PTR;
  24
  25 void do_set_mux(u32 base, struct pad_conf_entry const *array, int size)
  26 {
  27         int i;
  28         struct pad_conf_entry *pad = (struct pad_conf_entry *) array;
  29
  30         for (i = 0; i < size; i++, pad++)
  31                 writew(pad->val, base + pad->offset);
  32 }
  33
  34 static void set_mux_conf_regs(void)
  35 {
  36         switch (omap_hw_init_context()) {
  37         case OMAP_INIT_CONTEXT_SPL:
  38                 set_muxconf_regs();
  39                 break;
  40         case OMAP_INIT_CONTEXT_UBOOT_AFTER_SPL:
  41                 break;
  42         case OMAP_INIT_CONTEXT_UBOOT_FROM_NOR:
  43         case OMAP_INIT_CONTEXT_UBOOT_AFTER_CH:
  44                 set_muxconf_regs();
  45                 break;
  46         }
  47 }
  48
  49 u32 cortex_rev(void)
  50 {
  51
  52         unsigned int rev;
  53
  54         /* Read Main ID Register (MIDR) */
  55         asm ("mrc p15, 0, %0, c0, c0, 0" : "=r" (rev));
  56
  57         return rev;
  58 }
  59
  60 static void omap_rev_string(void)
  61 {
  62         u32 omap_rev = omap_revision();
  63         u32 soc_variant = (omap_rev & 0xF0000000) >> 28;
  64         u32 omap_variant = (omap_rev & 0xFFFF0000) >> 16;
  65         u32 major_rev = (omap_rev & 0x00000F00) >> 8;
  66         u32 minor_rev = (omap_rev & 0x000000F0) >> 4;
  67
  68         if (soc_variant)
  69                 printf("OMAP");
  70         else
  71                 printf("DRA");
  72         printf("%x ES%x.%x\n", omap_variant, major_rev,
  73                minor_rev);
  74 }
  75
  76 #ifdef CONFIG_SPL_BUILD
  77 void spl_display_print(void)
  78 {
  79         omap_rev_string();
  80 }
  81 #endif
  82
  83 void __weak srcomp_enable(void)
  84 {
  85 }
  86
  87 /**
  88  * do_board_detect() - Detect board description
  89  *
  90  * Function to detect board description. This is expected to be
  91  * overridden in the SoC family board file where desired.
  92  */
  93 void __weak do_board_detect(void)
  94 {
  95 }
  96
  97 void s_init(void)
  98 {
  99 }
 100
 101 /**
 102  * early_system_init - Does Early system initialization.
 103  *
 104  * Does early system init of watchdog, muxing,  andclocks
 105  * Watchdog disable is done always. For the rest what gets done
 106  * depends on the boot mode in which this function is executed when
 107  *   1. SPL running from SRAM
 108  *   2. U-Boot running from FLASH
 109  *   3. U-Boot loaded to SDRAM by SPL
 110  *   4. U-Boot loaded to SDRAM by ROM code using the
 111  *      Configuration Header feature
 112  * Please have a look at the respective functions to see what gets
 113  * done in each of these cases
 114  * This function is called with SRAM stack.
 115  */
 116 void early_system_init(void)
 117 {
 118         init_omap_revision();
 119         hw_data_init();
 120
 121 #ifdef CONFIG_SPL_BUILD
 122         if (warm_reset() &&
 123             (is_omap44xx() || (omap_revision() == OMAP5430_ES1_0)))
 124                 force_emif_self_refresh();
 125 #endif
 126         watchdog_init();
 127         set_mux_conf_regs();
 128 #ifdef CONFIG_SPL_BUILD
 129         srcomp_enable();
 130         do_io_settings();
 131 #endif
 132         setup_early_clocks();
 133         do_board_detect();
 134         prcm_init();
 135 }
 136
 137 #ifdef CONFIG_SPL_BUILD
 138 void board_init_f(ulong dummy)
 139 {
 140         early_system_init();
 141 #ifdef CONFIG_BOARD_EARLY_INIT_F
 142         board_early_init_f();
 143 #endif
 144         /* For regular u-boot sdram_init() is called from dram_init() */
 145         sdram_init();
 146 }
 147 #endif
 148
 149 int arch_cpu_init_dm(void)
 150 {
 151         early_system_init();
 152         return 0;
 153 }
 154
 155 /*
 156  * Routine: wait_for_command_complete
 157  * Description: Wait for posting to finish on watchdog
 158  */
 159 void wait_for_command_complete(struct watchdog *wd_base)
 160 {
 161         int pending = 1;
 162         do {
 163                 pending = readl(&wd_base->wwps);
 164         } while (pending);
 165 }
 166
 167 /*
 168  * Routine: watchdog_init
 169  * Description: Shut down watch dogs
 170  */
 171 void watchdog_init(void)
 172 {
 173         struct watchdog *wd2_base = (struct watchdog *)WDT2_BASE;
 174
 175         writel(WD_UNLOCK1, &wd2_base->wspr);
 176         wait_for_command_complete(wd2_base);
 177         writel(WD_UNLOCK2, &wd2_base->wspr);
 178 }
 179
 180
 181 /*
 182  * This function finds the SDRAM size available in the system
 183  * based on DMM section configurations
 184  * This is needed because the size of memory installed may be
 185  * different on different versions of the board
 186  */
 187 u32 omap_sdram_size(void)
 188 {
 189         u32 section, i, valid;
 190         u64 sdram_start = 0, sdram_end = 0, addr,
 191             size, total_size = 0, trap_size = 0, trap_start = 0;
 192
 193         for (i = 0; i < 4; i++) {
 194                 section = __raw_readl(DMM_BASE + i*4);
 195                 valid = (section & EMIF_SDRC_ADDRSPC_MASK) >>
 196                         (EMIF_SDRC_ADDRSPC_SHIFT);
 197                 addr = section & EMIF_SYS_ADDR_MASK;
 198
 199                 /* See if the address is valid */
 200                 if ((addr >= TI_ARMV7_DRAM_ADDR_SPACE_START) &&
 201                     (addr < TI_ARMV7_DRAM_ADDR_SPACE_END)) {
 202                         size = ((section & EMIF_SYS_SIZE_MASK) >>
 203                                    EMIF_SYS_SIZE_SHIFT);
 204                         size = 1 << size;
 205                         size *= SZ_16M;
 206
 207                         if (valid != DMM_SDRC_ADDR_SPC_INVALID) {
 208                                 if (!sdram_start || (addr < sdram_start))
 209                                         sdram_start = addr;
 210                                 if (!sdram_end || ((addr + size) > sdram_end))
 211                                         sdram_end = addr + size;
 212                         } else {
 213                                 trap_size = size;
 214                                 trap_start = addr;
 215                         }
 216                 }
 217         }
 218
 219         if ((trap_start >= sdram_start) && (trap_start < sdram_end))
 220                 total_size = (sdram_end - sdram_start) - (trap_size);
 221         else
 222                 total_size = sdram_end - sdram_start;
 223
 224         return total_size;
 225 }
 226
 227
 228 /*
 229  * Routine: dram_init
 230  * Description: sets uboots idea of sdram size
 231  */
 232 int dram_init(void)
 233 {
 234         sdram_init();
 235         gd->ram_size = omap_sdram_size();
 236         return 0;
 237 }
 238
 239 /*
 240  * Print board information
 241  */
 242 int checkboard(void)
 243 {
 244         puts(sysinfo.board_string);
 245         return 0;
 246 }
 247
 248 /*
 249  *  get_device_type(): tell if GP/HS/EMU/TST
 250  */
 251 u32 get_device_type(void)
 252 {
 253         return (readl((*ctrl)->control_status) &
 254                                       (DEVICE_TYPE_MASK)) >> DEVICE_TYPE_SHIFT;
 255 }
 256
 257 #if defined(CONFIG_DISPLAY_CPUINFO)
 258 /*
 259  * Print CPU information
 260  */
 261 int print_cpuinfo(void)
 262 {
 263         puts("CPU  : ");
 264         omap_rev_string();
 265
 266         return 0;
 267 }
 268 #endif