blob: b12011e04ab630dfd34a0b8ea156b42399e12034 [file] [log] [blame]
wdenk8ed96042005-01-09 23:16:25 +00001/*
2 * (C) Copyright 2004
3 * Texas Instruments, <www.ti.com>
4 * Richard Woodruff <r-woodruff2@ti.com>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation; either version 2 of
9 * the License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR /PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
19 * MA 02111-1307 USA
20 */
21
22#include <common.h>
23#include <asm/arch/omap2420.h>
24#include <asm/io.h>
25#include <asm/arch/bits.h>
26#include <asm/arch/mem.h> /* get mem tables */
27#include <asm/arch/sys_proto.h>
28#include <asm/arch/sys_info.h>
29#include <i2c.h>
30
31/**************************************************************************
Wolfgang Denk49a75812005-09-25 18:41:04 +020032 * get_prod_id() - get id info from chips
33 ***************************************************************************/
34static u32 get_prod_id(void)
35{
36 u32 p;
37 p = __raw_readl(PRODUCTION_ID); /* get production ID */
38 return((p & CPU_242X_PID_MASK) >> 16);
39}
40
41/**************************************************************************
wdenk8ed96042005-01-09 23:16:25 +000042 * get_cpu_type() - low level get cpu type
43 * - no C globals yet.
44 * - just looking to say if this is a 2422 or 2420 or ...
45 * - to start with we will look at switch settings..
46 * - 2422 id's same as 2420 for ES1 will rely on H4 board characteristics
47 * (mux for 2420, non-mux for 2422).
48 ***************************************************************************/
49u32 get_cpu_type(void)
50{
51 u32 v;
52
Wolfgang Denk49a75812005-09-25 18:41:04 +020053 switch(get_prod_id()){
54 case 1:;/* 2420 */
55 case 2: return(CPU_2420); break; /* 2420 pop */
56 case 4: return(CPU_2422); break;
57 case 8: return(CPU_2423); break;
58 default: break; /* early 2420/2422's unmarked */
59 }
60
wdenk8ed96042005-01-09 23:16:25 +000061 v = __raw_readl(TAP_IDCODE_REG);
62 v &= CPU_24XX_ID_MASK;
63 if (v == CPU_2420_CHIPID) { /* currently 2420 and 2422 have same id */
64 if (is_gpmc_muxed() == GPMC_MUXED) /* if mux'ed */
65 return(CPU_2420);
66 else
67 return(CPU_2422);
68 } else
69 return(CPU_2420); /* don't know, say 2420 */
70}
71
72/******************************************
73 * get_cpu_rev(void) - extract version info
74 ******************************************/
75u32 get_cpu_rev(void)
76{
77 u32 v;
78 v = __raw_readl(TAP_IDCODE_REG);
79 v = v >> 28;
80 return(v+1); /* currently 2422 and 2420 match up */
81}
Wolfgang Denk49a75812005-09-25 18:41:04 +020082/****************************************************
83 * is_mem_sdr() - return 1 if mem type in use is SDR
84 ****************************************************/
85u32 is_mem_sdr(void)
86{
87 volatile u32 *burst = (volatile u32 *)(SDRC_MR_0+SDRC_CS0_OSET);
88 if(*burst == H4_2420_SDRC_MR_0_SDR)
89 return(1);
90 return(0);
91}
wdenk8ed96042005-01-09 23:16:25 +000092
93/***********************************************************
94 * get_mem_type() - identify type of mDDR part used.
95 * 2422 uses stacked DDR, 2 parts CS0/CS1.
96 * 2420 may have 1 or 2, no good way to know...only init 1...
97 * when eeprom data is up we can select 1 more.
98 *************************************************************/
99u32 get_mem_type(void)
100{
Wolfgang Denk49a75812005-09-25 18:41:04 +0200101 u32 cpu, sdr = is_mem_sdr();
wdenk289f9322005-01-12 00:15:14 +0000102
Wolfgang Denk49a75812005-09-25 18:41:04 +0200103 cpu = get_cpu_type();
104 if (cpu == CPU_2422 || cpu == CPU_2423)
wdenk8ed96042005-01-09 23:16:25 +0000105 return(DDR_STACKED);
106
Wolfgang Denk49a75812005-09-25 18:41:04 +0200107 if(get_prod_id() == 0x2)
108 return(XDR_POP);
109
wdenk8ed96042005-01-09 23:16:25 +0000110 if (get_board_type() == BOARD_H4_MENELAUS)
Wolfgang Denk49a75812005-09-25 18:41:04 +0200111 if(sdr)
wdenk289f9322005-01-12 00:15:14 +0000112 return(SDR_DISCRETE);
113 else
114 return(DDR_COMBO);
wdenk8ed96042005-01-09 23:16:25 +0000115 else
Wolfgang Denk49a75812005-09-25 18:41:04 +0200116 if(sdr) /* SDP + SDR kit */
wdenk289f9322005-01-12 00:15:14 +0000117 return(SDR_DISCRETE);
118 else
119 return(DDR_DISCRETE); /* origional SDP */
wdenk8ed96042005-01-09 23:16:25 +0000120}
121
122/***********************************************************************
Wolfgang Denk49a75812005-09-25 18:41:04 +0200123 * get_cs0_size() - get size of chip select 0/1
124 ************************************************************************/
125u32 get_sdr_cs_size(u32 offset)
126{
127 u32 size;
128 size = __raw_readl(SDRC_MCFG_0+offset) >> 8; /* get ram size field */
129 size &= 0x2FF; /* remove unwanted bits */
130 size *= SZ_2M; /* find size in MB */
131 return(size);
132}
133
134/***********************************************************************
wdenk8ed96042005-01-09 23:16:25 +0000135 * get_board_type() - get board type based on current production stats.
136 * --- NOTE: 2 I2C EEPROMs will someday be populated with proper info.
137 * when they are available we can get info from there. This should
138 * be correct of all known boards up until today.
139 ************************************************************************/
140u32 get_board_type(void)
141{
142 if (i2c_probe(I2C_MENELAUS) == 0)
143 return(BOARD_H4_MENELAUS);
144 else
145 return(BOARD_H4_SDP);
146}
147
148/******************************************************************
149 * get_sysboot_value() - get init word settings (dip switch on h4)
150 ******************************************************************/
Wolfgang Denk49a75812005-09-25 18:41:04 +0200151inline u32 get_sysboot_value(void)
wdenk8ed96042005-01-09 23:16:25 +0000152{
153 return(0x00000FFF & __raw_readl(CONTROL_STATUS));
154}
155
156/***************************************************************************
157 * get_gpmc0_base() - Return current address hardware will be
158 * fetching from. The below effectively gives what is correct, its a bit
159 * mis-leading compared to the TRM. For the most general case the mask
160 * needs to be also taken into account this does work in practice.
161 * - for u-boot we currently map:
162 * -- 0 to nothing,
163 * -- 4 to flash
164 * -- 8 to enent
165 * -- c to wifi
166 ****************************************************************************/
167u32 get_gpmc0_base(void)
168{
169 u32 b;
170
171 b = __raw_readl(GPMC_CONFIG7_0);
172 b &= 0x1F; /* keep base [5:0] */
173 b = b << 24; /* ret 0x0b000000 */
174 return(b);
175}
176
177/*****************************************************************
178 * is_gpmc_muxed() - tells if address/data lines are multiplexed
179 *****************************************************************/
180u32 is_gpmc_muxed(void)
181{
182 u32 mux;
183 mux = get_sysboot_value();
wdenk289f9322005-01-12 00:15:14 +0000184 if ((mux & (BIT0 | BIT1 | BIT2 | BIT3)) == (BIT0 | BIT2 | BIT3))
185 return(GPMC_MUXED); /* NAND Boot mode */
wdenk8ed96042005-01-09 23:16:25 +0000186 if (mux & BIT1) /* if mux'ed */
187 return(GPMC_MUXED);
188 else
189 return(GPMC_NONMUXED);
190}
191
192/************************************************************************
193 * get_gpmc0_type() - read sysboot lines to see type of memory attached
194 ************************************************************************/
195u32 get_gpmc0_type(void)
196{
197 u32 type;
198 type = get_sysboot_value();
199 if ((type & (BIT3|BIT2)) == (BIT3|BIT2))
200 return(TYPE_NAND);
201 else
202 return(TYPE_NOR);
203}
204
205/*******************************************************************
206 * get_gpmc0_width() - See if bus is in x8 or x16 (mainly for nand)
207 *******************************************************************/
208u32 get_gpmc0_width(void)
209{
210 u32 width;
211 width = get_sysboot_value();
212 if ((width & 0xF) == (BIT3|BIT2))
213 return(WIDTH_8BIT);
214 else
215 return(WIDTH_16BIT);
216}
217
218/*********************************************************************
219 * wait_on_value() - common routine to allow waiting for changes in
220 * volatile regs.
221 *********************************************************************/
222u32 wait_on_value(u32 read_bit_mask, u32 match_value, u32 read_addr, u32 bound)
223{
224 u32 i = 0, val;
225 do {
226 ++i;
227 val = __raw_readl(read_addr) & read_bit_mask;
228 if (val == match_value)
229 return(1);
230 if (i==bound)
231 return(0);
232 } while (1);
233}
234
235/*********************************************************************
236 * display_board_info() - print banner with board info.
237 *********************************************************************/
238void display_board_info(u32 btype)
239{
Albert ARIBAUDb823fd92012-10-09 09:28:15 +0000240 static const char cpu_2420 [] = "2420"; /* cpu type */
241 static const char cpu_2422 [] = "2422";
242 static const char cpu_2423 [] = "2423";
243 static const char db_men [] = "Menelaus"; /* board type */
244 static const char db_ip [] = "IP";
245 static const char mem_sdr [] = "mSDR"; /* memory type */
246 static const char mem_ddr [] = "mDDR";
247 static const char t_tst [] = "TST"; /* security level */
248 static const char t_emu [] = "EMU";
249 static const char t_hs [] = "HS";
250 static const char t_gp [] = "GP";
251 static const char unk [] = "?";
wdenk8ed96042005-01-09 23:16:25 +0000252
Albert ARIBAUDb823fd92012-10-09 09:28:15 +0000253 const char *cpu_s, *db_s, *mem_s, *sec_s;
Wolfgang Denk49a75812005-09-25 18:41:04 +0200254 u32 cpu, rev, sec;
255
256 rev = get_cpu_rev();
257 cpu = get_cpu_type();
258 sec = get_device_type();
259
260 if(is_mem_sdr())
261 mem_s = mem_sdr;
wdenk8ed96042005-01-09 23:16:25 +0000262 else
Wolfgang Denk49a75812005-09-25 18:41:04 +0200263 mem_s = mem_ddr;
264
265 if(cpu == CPU_2423)
266 cpu_s = cpu_2423;
267 else if (cpu == CPU_2422)
wdenk8ed96042005-01-09 23:16:25 +0000268 cpu_s = cpu_2422;
Wolfgang Denk49a75812005-09-25 18:41:04 +0200269 else
270 cpu_s = cpu_2420;
271
wdenk8ed96042005-01-09 23:16:25 +0000272 if(btype == BOARD_H4_MENELAUS)
273 db_s = db_men;
274 else
275 db_s = db_ip;
Wolfgang Denk49a75812005-09-25 18:41:04 +0200276
277 switch(sec){
278 case TST_DEVICE: sec_s = t_tst; break;
279 case EMU_DEVICE: sec_s = t_emu; break;
280 case HS_DEVICE: sec_s = t_hs; break;
281 case GP_DEVICE: sec_s = t_gp; break;
282 default: sec_s = unk;
283 }
284
285 printf("OMAP%s-%s revision %d\n", cpu_s, sec_s, rev-1);
286 printf("TI H4 SDP Base Board + %s Daughter Board + %s \n", db_s, mem_s);
wdenk8ed96042005-01-09 23:16:25 +0000287}
wdenk289f9322005-01-12 00:15:14 +0000288
289/*************************************************************************
290 * get_board_rev() - setup to pass kernel board revision information
291 * 0 = 242x IP platform (first 2xx boards)
292 * 1 = 242x Menelaus platfrom.
293 *************************************************************************/
294u32 get_board_rev(void)
295{
296 u32 rev = 0;
297 u32 btype = get_board_type();
298
299 if (btype == BOARD_H4_MENELAUS){
300 rev = 1;
301 }
302 return(rev);
303}
304
305/********************************************************
306 * get_base(); get upper addr of current execution
307 *******************************************************/
Wolfgang Denk49a75812005-09-25 18:41:04 +0200308u32 get_base(void)
wdenk289f9322005-01-12 00:15:14 +0000309{
310 u32 val;
311 __asm__ __volatile__("mov %0, pc \n" : "=r" (val) : : "memory");
312 val &= 0xF0000000;
313 val >>= 28;
314 return(val);
315}
316
317/********************************************************
318 * get_base2(); get 2upper addr of current execution
319 *******************************************************/
Wolfgang Denk49a75812005-09-25 18:41:04 +0200320u32 get_base2(void)
wdenk289f9322005-01-12 00:15:14 +0000321{
322 u32 val;
323 __asm__ __volatile__("mov %0, pc \n" : "=r" (val) : : "memory");
324 val &= 0xFF000000;
325 val >>= 24;
326 return(val);
327}
328
wdenk289f9322005-01-12 00:15:14 +0000329/********************************************************
330 * running_in_flash() - tell if currently running in
331 * flash.
332 *******************************************************/
333u32 running_in_flash(void)
334{
335 if (get_base() < 4)
336 return(1); /* in flash */
337 return(0); /* running in SRAM or SDRAM */
338}
339
340/********************************************************
341 * running_in_sram() - tell if currently running in
342 * sram.
343 *******************************************************/
344u32 running_in_sram(void)
345{
346 if (get_base() == 4)
347 return(1); /* in SRAM */
348 return(0); /* running in FLASH or SDRAM */
349}
350/********************************************************
351 * running_in_sdram() - tell if currently running in
352 * flash.
353 *******************************************************/
354u32 running_in_sdram(void)
355{
356 if (get_base() > 4)
357 return(1); /* in sdram */
358 return(0); /* running in SRAM or FLASH */
359}
360
361/*************************************************************
362 * running_from_internal_boot() - am I a signed NOR image.
363 *************************************************************/
364u32 running_from_internal_boot(void)
365{
366 u32 v, base;
367
368 v = get_sysboot_value() & BIT3;
369 base = get_base2();
370 /* if running at mask rom flash address and
371 * sysboot3 says this was an internal boot
372 */
373 if ((base == 0x08) && v)
374 return(1);
375 else
376 return(0);
377}
Wolfgang Denk49a75812005-09-25 18:41:04 +0200378
379/*************************************************************
380 * get_device_type(): tell if GP/HS/EMU/TST
381 *************************************************************/
382u32 get_device_type(void)
383{
384 int mode;
385 mode = __raw_readl(CONTROL_STATUS) & (BIT10|BIT9|BIT8);
386 return(mode >>= 8);
387}