arch/arm/cpu/armv7/omap3/sys_info.c

   1 /*
   2  * (C) Copyright 2008
   3  * Texas Instruments, <www.ti.com>
   4  *
   5  * Author :
   6  *      Manikandan Pillai <mani.pillai@ti.com>
   7  *
   8  * Derived from Beagle Board and 3430 SDP code by
   9  *      Richard Woodruff <r-woodruff2@ti.com>
  10  *      Syed Mohammed Khasim <khasim@ti.com>
  11  *
  12  * SPDX-License-Identifier:     GPL-2.0+
  13  */
  14
  15 #include <common.h>
  16 #include <asm/io.h>
  17 #include <asm/arch/mem.h>       /* get mem tables */
  18 #include <asm/arch/sys_proto.h>
  19 #include <asm/bootm.h>
  20
  21 #include <i2c.h>
  22 #include <linux/compiler.h>
  23
  24 extern omap3_sysinfo sysinfo;
  25 static struct ctrl *ctrl_base = (struct ctrl *)OMAP34XX_CTRL_BASE;
  26
  27 #ifdef CONFIG_DISPLAY_CPUINFO
  28 static char *rev_s[CPU_3XX_MAX_REV] = {
  29                                 "1.0",
  30                                 "2.0",
  31                                 "2.1",
  32                                 "3.0",
  33                                 "3.1",
  34                                 "UNKNOWN",
  35                                 "UNKNOWN",
  36                                 "3.1.2"};
  37
  38 /* this is the revision table for 37xx CPUs */
  39 static char *rev_s_37xx[CPU_37XX_MAX_REV] = {
  40                                 "1.0",
  41                                 "1.1",
  42                                 "1.2"};
  43 #endif /* CONFIG_DISPLAY_CPUINFO */
  44
  45 /*****************************************************************
  46  * get_dieid(u32 *id) - read die ID
  47  *****************************************************************/
  48 void get_dieid(u32 *id)
  49 {
  50         struct ctrl_id *id_base = (struct ctrl_id *)OMAP34XX_ID_L4_IO_BASE;
  51
  52         id[3] = readl(&id_base->die_id_0);
  53         id[2] = readl(&id_base->die_id_1);
  54         id[1] = readl(&id_base->die_id_2);
  55         id[0] = readl(&id_base->die_id_3);
  56 }
  57
  58 /*****************************************************************
  59  * dieid_num_r(void) - read and set die ID
  60  *****************************************************************/
  61 void dieid_num_r(void)
  62 {
  63         char *uid_s, die_id[34];
  64         u32 id[4];
  65
  66         memset(die_id, 0, sizeof(die_id));
  67
  68         uid_s = getenv("dieid#");
  69
  70         if (uid_s == NULL) {
  71                 get_dieid(id);
  72                 sprintf(die_id, "%08x%08x%08x%08x", id[0], id[1], id[2], id[3]);
  73                 setenv("dieid#", die_id);
  74                 uid_s = die_id;
  75         }
  76
  77         printf("Die ID #%s\n", uid_s);
  78 }
  79
  80 /******************************************
  81  * get_cpu_type(void) - extract cpu info
  82  ******************************************/
  83 u32 get_cpu_type(void)
  84 {
  85         return readl(&ctrl_base->ctrl_omap_stat);
  86 }
  87
  88 /******************************************
  89  * get_cpu_id(void) - extract cpu id
  90  * returns 0 for ES1.0, cpuid otherwise
  91  ******************************************/
  92 u32 get_cpu_id(void)
  93 {
  94         struct ctrl_id *id_base;
  95         u32 cpuid = 0;
  96
  97         /*
  98          * On ES1.0 the IDCODE register is not exposed on L4
  99          * so using CPU ID to differentiate between ES1.0 and > ES1.0.
 100          */
 101         __asm__ __volatile__("mrc p15, 0, %0, c0, c0, 0":"=r"(cpuid));
 102         if ((cpuid & 0xf) == 0x0) {
 103                 return 0;
 104         } else {
 105                 /* Decode the IDs on > ES1.0 */
 106                 id_base = (struct ctrl_id *) OMAP34XX_ID_L4_IO_BASE;
 107
 108                 cpuid = readl(&id_base->idcode);
 109         }
 110
 111         return cpuid;
 112 }
 113
 114 /******************************************
 115  * get_cpu_family(void) - extract cpu info
 116  ******************************************/
 117 u32 get_cpu_family(void)
 118 {
 119         u16 hawkeye;
 120         u32 cpu_family;
 121         u32 cpuid = get_cpu_id();
 122
 123         if (cpuid == 0)
 124                 return CPU_OMAP34XX;
 125
 126         hawkeye = (cpuid >> HAWKEYE_SHIFT) & 0xffff;
 127         switch (hawkeye) {
 128         case HAWKEYE_OMAP34XX:
 129                 cpu_family = CPU_OMAP34XX;
 130                 break;
 131         case HAWKEYE_AM35XX:
 132                 cpu_family = CPU_AM35XX;
 133                 break;
 134         case HAWKEYE_OMAP36XX:
 135                 cpu_family = CPU_OMAP36XX;
 136                 break;
 137         default:
 138                 cpu_family = CPU_OMAP34XX;
 139         }
 140
 141         return cpu_family;
 142 }
 143
 144 /******************************************
 145  * get_cpu_rev(void) - extract version info
 146  ******************************************/
 147 u32 get_cpu_rev(void)
 148 {
 149         u32 cpuid = get_cpu_id();
 150
 151         if (cpuid == 0)
 152                 return CPU_3XX_ES10;
 153         else
 154                 return (cpuid >> CPU_3XX_ID_SHIFT) & 0xf;
 155 }
 156
 157 /*****************************************************************
 158  * get_sku_id(void) - read sku_id to get info on max clock rate
 159  *****************************************************************/
 160 u32 get_sku_id(void)
 161 {
 162         struct ctrl_id *id_base = (struct ctrl_id *)OMAP34XX_ID_L4_IO_BASE;
 163         return readl(&id_base->sku_id) & SKUID_CLK_MASK;
 164 }
 165
 166 /***************************************************************************
 167  *  get_gpmc0_base() - Return current address hardware will be
 168  *     fetching from. The below effectively gives what is correct, its a bit
 169  *   mis-leading compared to the TRM.  For the most general case the mask
 170  *   needs to be also taken into account this does work in practice.
 171  *   - for u-boot we currently map:
 172  *       -- 0 to nothing,
 173  *       -- 4 to flash
 174  *       -- 8 to enent
 175  *       -- c to wifi
 176  ****************************************************************************/
 177 u32 get_gpmc0_base(void)
 178 {
 179         u32 b;
 180
 181         b = readl(&gpmc_cfg->cs[0].config7);
 182         b &= 0x1F;              /* keep base [5:0] */
 183         b = b << 24;            /* ret 0x0b000000 */
 184         return b;
 185 }
 186
 187 /*******************************************************************
 188  * get_gpmc0_width() - See if bus is in x8 or x16 (mainly for nand)
 189  *******************************************************************/
 190 u32 get_gpmc0_width(void)
 191 {
 192         return WIDTH_16BIT;
 193 }
 194
 195 /*************************************************************************
 196  * get_board_rev() - setup to pass kernel board revision information
 197  * returns:(bit[0-3] sub version, higher bit[7-4] is higher version)
 198  *************************************************************************/
 199 u32 __weak get_board_rev(void)
 200 {
 201         return 0x20;
 202 }
 203
 204 /********************************************************
 205  *  get_base(); get upper addr of current execution
 206  *******************************************************/
 207 static u32 get_base(void)
 208 {
 209         u32 val;
 210
 211         __asm__ __volatile__("mov %0, pc \n":"=r"(val)::"memory");
 212         val &= 0xF0000000;
 213         val >>= 28;
 214         return val;
 215 }
 216
 217 /********************************************************
 218  *  is_running_in_flash() - tell if currently running in
 219  *  FLASH.
 220  *******************************************************/
 221 u32 is_running_in_flash(void)
 222 {
 223         if (get_base() < 4)
 224                 return 1;       /* in FLASH */
 225
 226         return 0;               /* running in SRAM or SDRAM */
 227 }
 228
 229 /********************************************************
 230  *  is_running_in_sram() - tell if currently running in
 231  *  SRAM.
 232  *******************************************************/
 233 u32 is_running_in_sram(void)
 234 {
 235         if (get_base() == 4)
 236                 return 1;       /* in SRAM */
 237
 238         return 0;               /* running in FLASH or SDRAM */
 239 }
 240
 241 /********************************************************
 242  *  is_running_in_sdram() - tell if currently running in
 243  *  SDRAM.
 244  *******************************************************/
 245 u32 is_running_in_sdram(void)
 246 {
 247         if (get_base() > 4)
 248                 return 1;       /* in SDRAM */
 249
 250         return 0;               /* running in SRAM or FLASH */
 251 }
 252
 253 /***************************************************************
 254  *  get_boot_type() - Is this an XIP type device or a stream one
 255  *  bits 4-0 specify type. Bit 5 says mem/perif
 256  ***************************************************************/
 257 u32 get_boot_type(void)
 258 {
 259         return (readl(&ctrl_base->status) & SYSBOOT_MASK);
 260 }
 261
 262 /*************************************************************
 263  *  get_device_type(): tell if GP/HS/EMU/TST
 264  *************************************************************/
 265 u32 get_device_type(void)
 266 {
 267         return ((readl(&ctrl_base->status) & (DEVICE_MASK)) >> 8);
 268 }
 269
 270 #ifdef CONFIG_DISPLAY_CPUINFO
 271 /**
 272  * Print CPU information
 273  */
 274 int print_cpuinfo (void)
 275 {
 276         char *cpu_family_s, *cpu_s, *sec_s, *max_clk;
 277
 278         switch (get_cpu_family()) {
 279         case CPU_OMAP34XX:
 280                 cpu_family_s = "OMAP";
 281                 switch (get_cpu_type()) {
 282                 case OMAP3503:
 283                         cpu_s = "3503";
 284                         break;
 285                 case OMAP3515:
 286                         cpu_s = "3515";
 287                         break;
 288                 case OMAP3525:
 289                         cpu_s = "3525";
 290                         break;
 291                 case OMAP3530:
 292                         cpu_s = "3530";
 293                         break;
 294                 default:
 295                         cpu_s = "35XX";
 296                         break;
 297                 }
 298                 if ((get_cpu_rev() >= CPU_3XX_ES31) &&
 299                     (get_sku_id() == SKUID_CLK_720MHZ))
 300                         max_clk = "720 MHz";
 301                 else
 302                         max_clk = "600 MHz";
 303
 304                 break;
 305         case CPU_AM35XX:
 306                 cpu_family_s = "AM";
 307                 switch (get_cpu_type()) {
 308                 case AM3505:
 309                         cpu_s = "3505";
 310                         break;
 311                 case AM3517:
 312                         cpu_s = "3517";
 313                         break;
 314                 default:
 315                         cpu_s = "35XX";
 316                         break;
 317                 }
 318                 max_clk = "600 Mhz";
 319                 break;
 320         case CPU_OMAP36XX:
 321                 cpu_family_s = "OMAP";
 322                 switch (get_cpu_type()) {
 323                 case OMAP3730:
 324                         cpu_s = "3630/3730";
 325                         break;
 326                 default:
 327                         cpu_s = "36XX/37XX";
 328                         break;
 329                 }
 330                 max_clk = "1 Ghz";
 331                 break;
 332         default:
 333                 cpu_family_s = "OMAP";
 334                 cpu_s = "35XX";
 335                 max_clk = "600 Mhz";
 336         }
 337
 338         switch (get_device_type()) {
 339         case TST_DEVICE:
 340                 sec_s = "TST";
 341                 break;
 342         case EMU_DEVICE:
 343                 sec_s = "EMU";
 344                 break;
 345         case HS_DEVICE:
 346                 sec_s = "HS";
 347                 break;
 348         case GP_DEVICE:
 349                 sec_s = "GP";
 350                 break;
 351         default:
 352                 sec_s = "?";
 353         }
 354
 355         if (CPU_OMAP36XX == get_cpu_family())
 356                 printf("%s%s-%s ES%s, CPU-OPP2, L3-200MHz, Max CPU Clock %s\n",
 357                        cpu_family_s, cpu_s, sec_s,
 358                        rev_s_37xx[get_cpu_rev()], max_clk);
 359         else
 360                 printf("%s%s-%s ES%s, CPU-OPP2, L3-165MHz, Max CPU Clock %s\n",
 361                         cpu_family_s, cpu_s, sec_s,
 362                         rev_s[get_cpu_rev()], max_clk);
 363
 364         return 0;
 365 }
 366 #endif  /* CONFIG_DISPLAY_CPUINFO */