cpu/arm_cortexa8/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 gpmc_t *gpmc_base = (gpmc_t *)GPMC_BASE;
  36 static sdrc_t *sdrc_base = (sdrc_t *)OMAP34XX_SDRC_BASE;
  37 static ctrl_t *ctrl_base = (ctrl_t *)OMAP34XX_CTRL_BASE;
  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
  45 /*****************************************************************
  46  * dieid_num_r(void) - read and set die ID
  47  *****************************************************************/
  48 void dieid_num_r(void)
  49 {
  50         ctrl_id_t *id_base = (ctrl_id_t *)OMAP34XX_ID_L4_IO_BASE;
  51         char *uid_s, die_id[34];
  52         u32 id[4];
  53
  54         memset(die_id, 0, sizeof(die_id));
  55
  56         uid_s = getenv("dieid#");
  57
  58         if (uid_s == NULL) {
  59                 id[3] = readl(&id_base->die_id_0);
  60                 id[2] = readl(&id_base->die_id_1);
  61                 id[1] = readl(&id_base->die_id_2);
  62                 id[0] = readl(&id_base->die_id_3);
  63                 sprintf(die_id, "%08x%08x%08x%08x", id[0], id[1], id[2], id[3]);
  64                 setenv("dieid#", die_id);
  65                 uid_s = die_id;
  66         }
  67
  68         printf("Die ID #%s\n", uid_s);
  69 }
  70
  71 /******************************************
  72  * get_cpu_type(void) - extract cpu info
  73  ******************************************/
  74 u32 get_cpu_type(void)
  75 {
  76         return readl(&ctrl_base->ctrl_omap_stat);
  77 }
  78
  79 /******************************************
  80  * get_cpu_rev(void) - extract version info
  81  ******************************************/
  82 u32 get_cpu_rev(void)
  83 {
  84         u32 cpuid = 0;
  85         ctrl_id_t *id_base;
  86
  87         /*
  88          * On ES1.0 the IDCODE register is not exposed on L4
  89          * so using CPU ID to differentiate between ES1.0 and > ES1.0.
  90          */
  91         __asm__ __volatile__("mrc p15, 0, %0, c0, c0, 0":"=r"(cpuid));
  92         if ((cpuid & 0xf) == 0x0)
  93                 return CPU_3XX_ES10;
  94         else {
  95                 /* Decode the IDs on > ES1.0 */
  96                 id_base = (ctrl_id_t *) OMAP34XX_ID_L4_IO_BASE;
  97
  98                 cpuid = (readl(&id_base->idcode) >> CPU_3XX_ID_SHIFT) & 0xf;
  99
 100                 /* Some early ES2.0 seem to report ID 0, fix this */
 101                 if(cpuid == 0)
 102                         cpuid = CPU_3XX_ES20;
 103
 104                 return cpuid;
 105         }
 106 }
 107
 108 /****************************************************
 109  * is_mem_sdr() - return 1 if mem type in use is SDR
 110  ****************************************************/
 111 u32 is_mem_sdr(void)
 112 {
 113         if (readl(&sdrc_base->cs[CS0].mr) == SDP_SDRC_MR_0_SDR)
 114                 return 1;
 115         return 0;
 116 }
 117
 118 /***********************************************************************
 119  * get_cs0_size() - get size of chip select 0/1
 120  ************************************************************************/
 121 u32 get_sdr_cs_size(u32 cs)
 122 {
 123         u32 size;
 124
 125         /* get ram size field */
 126         size = readl(&sdrc_base->cs[cs].mcfg) >> 8;
 127         size &= 0x3FF;          /* remove unwanted bits */
 128         size *= SZ_2M;          /* find size in MB */
 129         return size;
 130 }
 131
 132 /***********************************************************************
 133  * get_sdr_cs_offset() - get offset of cs from cs0 start
 134  ************************************************************************/
 135 u32 get_sdr_cs_offset(u32 cs)
 136 {
 137         u32 offset;
 138
 139         if (!cs)
 140                 return 0;
 141
 142         offset = readl(&sdrc_base->cs_cfg);
 143         offset = (offset & 15) << 27 | (offset & 0x30) >> 17;
 144
 145         return offset;
 146 }
 147
 148 /***************************************************************************
 149  *  get_gpmc0_base() - Return current address hardware will be
 150  *     fetching from. The below effectively gives what is correct, its a bit
 151  *   mis-leading compared to the TRM.  For the most general case the mask
 152  *   needs to be also taken into account this does work in practice.
 153  *   - for u-boot we currently map:
 154  *       -- 0 to nothing,
 155  *       -- 4 to flash
 156  *       -- 8 to enent
 157  *       -- c to wifi
 158  ****************************************************************************/
 159 u32 get_gpmc0_base(void)
 160 {
 161         u32 b;
 162
 163         b = readl(&gpmc_base->cs[0].config7);
 164         b &= 0x1F;              /* keep base [5:0] */
 165         b = b << 24;            /* ret 0x0b000000 */
 166         return b;
 167 }
 168
 169 /*******************************************************************
 170  * get_gpmc0_width() - See if bus is in x8 or x16 (mainly for nand)
 171  *******************************************************************/
 172 u32 get_gpmc0_width(void)
 173 {
 174         return WIDTH_16BIT;
 175 }
 176
 177 /*************************************************************************
 178  * get_board_rev() - setup to pass kernel board revision information
 179  * returns:(bit[0-3] sub version, higher bit[7-4] is higher version)
 180  *************************************************************************/
 181 u32 get_board_rev(void)
 182 {
 183         return 0x20;
 184 }
 185
 186 /********************************************************
 187  *  get_base(); get upper addr of current execution
 188  *******************************************************/
 189 u32 get_base(void)
 190 {
 191         u32 val;
 192
 193         __asm__ __volatile__("mov %0, pc \n":"=r"(val)::"memory");
 194         val &= 0xF0000000;
 195         val >>= 28;
 196         return val;
 197 }
 198
 199 /********************************************************
 200  *  is_running_in_flash() - tell if currently running in
 201  *  FLASH.
 202  *******************************************************/
 203 u32 is_running_in_flash(void)
 204 {
 205         if (get_base() < 4)
 206                 return 1;       /* in FLASH */
 207
 208         return 0;               /* running in SRAM or SDRAM */
 209 }
 210
 211 /********************************************************
 212  *  is_running_in_sram() - tell if currently running in
 213  *  SRAM.
 214  *******************************************************/
 215 u32 is_running_in_sram(void)
 216 {
 217         if (get_base() == 4)
 218                 return 1;       /* in SRAM */
 219
 220         return 0;               /* running in FLASH or SDRAM */
 221 }
 222
 223 /********************************************************
 224  *  is_running_in_sdram() - tell if currently running in
 225  *  SDRAM.
 226  *******************************************************/
 227 u32 is_running_in_sdram(void)
 228 {
 229         if (get_base() > 4)
 230                 return 1;       /* in SDRAM */
 231
 232         return 0;               /* running in SRAM or FLASH */
 233 }
 234
 235 /***************************************************************
 236  *  get_boot_type() - Is this an XIP type device or a stream one
 237  *  bits 4-0 specify type. Bit 5 says mem/perif
 238  ***************************************************************/
 239 u32 get_boot_type(void)
 240 {
 241         return (readl(&ctrl_base->status) & SYSBOOT_MASK);
 242 }
 243
 244 /*************************************************************
 245  *  get_device_type(): tell if GP/HS/EMU/TST
 246  *************************************************************/
 247 u32 get_device_type(void)
 248 {
 249         return ((readl(&ctrl_base->status) & (DEVICE_MASK)) >> 8);
 250 }
 251
 252 #ifdef CONFIG_DISPLAY_CPUINFO
 253 /**
 254  * Print CPU information
 255  */
 256 int print_cpuinfo (void)
 257 {
 258         char *cpu_s, *sec_s;
 259
 260         switch (get_cpu_type()) {
 261         case OMAP3503:
 262                 cpu_s = "3503";
 263                 break;
 264         case OMAP3515:
 265                 cpu_s = "3515";
 266                 break;
 267         case OMAP3525:
 268                 cpu_s = "3525";
 269                 break;
 270         case OMAP3530:
 271                 cpu_s = "3530";
 272                 break;
 273         default:
 274                 cpu_s = "35XX";
 275                 break;
 276         }
 277
 278         switch (get_device_type()) {
 279         case TST_DEVICE:
 280                 sec_s = "TST";
 281                 break;
 282         case EMU_DEVICE:
 283                 sec_s = "EMU";
 284                 break;
 285         case HS_DEVICE:
 286                 sec_s = "HS";
 287                 break;
 288         case GP_DEVICE:
 289                 sec_s = "GP";
 290                 break;
 291         default:
 292                 sec_s = "?";
 293         }
 294
 295         printf("OMAP%s-%s ES%s, CPU-OPP2 L3-165MHz\n",
 296                         cpu_s, sec_s, rev_s[get_cpu_rev()]);
 297
 298         return 0;
 299 }
 300 #endif  /* CONFIG_DISPLAY_CPUINFO */