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