board_f: Drop return value from initdram()
[oweals/u-boot.git] / board / cm5200 / cm5200.c
1 /*
2  * (C) Copyright 2003-2007
3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4  *
5  * (C) Copyright 2004
6  * Mark Jonas, Freescale Semiconductor, mark.jonas@motorola.com.
7  *
8  * (C) Copyright 2004-2005
9  * Martin Krause, TQ-Systems GmbH, martin.krause@tqs.de
10  *
11  * Adapted to U-Boot 1.2 by:
12  *   Bartlomiej Sieka <tur@semihalf.com>:
13  *      - HW ID readout from EEPROM
14  *      - module detection
15  *   Grzegorz Bernacki <gjb@semihalf.com>:
16  *      - run-time SDRAM controller configuration
17  *      - LIBFDT support
18  *
19  * SPDX-License-Identifier:     GPL-2.0+
20  */
21
22 #include <common.h>
23 #include <mpc5xxx.h>
24 #include <pci.h>
25 #include <asm/processor.h>
26 #include <i2c.h>
27 #include <linux/ctype.h>
28
29 #ifdef CONFIG_OF_LIBFDT
30 #include <libfdt.h>
31 #include <fdt_support.h>
32 #endif /* CONFIG_OF_LIBFDT */
33
34
35 #include "cm5200.h"
36 #include "fwupdate.h"
37
38 DECLARE_GLOBAL_DATA_PTR;
39
40 static hw_id_t hw_id;
41
42
43 #ifndef CONFIG_SYS_RAMBOOT
44 /*
45  * Helper function to initialize SDRAM controller.
46  */
47 static void sdram_start(int hi_addr, mem_conf_t *mem_conf)
48 {
49         long hi_addr_bit = hi_addr ? 0x01000000 : 0;
50
51         /* unlock mode register */
52         *(vu_long *)MPC5XXX_SDRAM_CTRL = mem_conf->control | 0x80000000 |
53                                                 hi_addr_bit;
54
55         /* precharge all banks */
56         *(vu_long *)MPC5XXX_SDRAM_CTRL = mem_conf->control | 0x80000002 |
57                                                 hi_addr_bit;
58
59         /* auto refresh */
60         *(vu_long *)MPC5XXX_SDRAM_CTRL = mem_conf->control | 0x80000004 |
61                                                 hi_addr_bit;
62
63         /* auto refresh, second time */
64         *(vu_long *)MPC5XXX_SDRAM_CTRL = mem_conf->control | 0x80000004 |
65                                                 hi_addr_bit;
66
67         /* set mode register */
68         *(vu_long *)MPC5XXX_SDRAM_MODE = mem_conf->mode;
69
70         /* normal operation */
71         *(vu_long *)MPC5XXX_SDRAM_CTRL = mem_conf->control | hi_addr_bit;
72 }
73 #endif /* CONFIG_SYS_RAMBOOT */
74
75
76 /*
77  * Retrieve memory configuration for a given module. board_type is the index
78  * in hw_id_list[] corresponding to the module we are executing on; we return
79  * SDRAM controller settings approprate for this module.
80  */
81 static mem_conf_t* get_mem_config(int board_type)
82 {
83         switch(board_type){
84                 case CM1_QA:
85                         return memory_config[0];
86                 case CM11_QA:
87                 case CMU1_QA:
88                         return memory_config[1];
89                 default:
90                         printf("ERROR: Unknown module, using a default SDRAM "
91                                 "configuration - things may not work!!!.\n");
92                         return memory_config[0];
93         }
94 }
95
96
97 /*
98  * Initalize SDRAM - configure SDRAM controller, detect memory size.
99  */
100 int initdram(void)
101 {
102         ulong dramsize = 0;
103 #ifndef CONFIG_SYS_RAMBOOT
104         ulong test1, test2;
105         mem_conf_t *mem_conf;
106
107         mem_conf = get_mem_config(gd->board_type);
108
109         /* configure SDRAM start/end for detection */
110         *(vu_long *)MPC5XXX_SDRAM_CS0CFG = 0x0000001e; /* 2G at 0x0 */
111
112         /* setup config registers */
113         *(vu_long *)MPC5XXX_SDRAM_CONFIG1 = mem_conf->config1;
114         *(vu_long *)MPC5XXX_SDRAM_CONFIG2 = mem_conf->config2;
115
116         sdram_start(0, mem_conf);
117         test1 = get_ram_size((long *)CONFIG_SYS_SDRAM_BASE, 0x80000000);
118         sdram_start(1, mem_conf);
119         test2 = get_ram_size((long *)CONFIG_SYS_SDRAM_BASE, 0x80000000);
120         if (test1 > test2) {
121                 sdram_start(0, mem_conf);
122                 dramsize = test1;
123         } else
124                 dramsize = test2;
125
126         /* memory smaller than 1MB is impossible */
127         if (dramsize < (1 << 20))
128                 dramsize = 0;
129
130         /* set SDRAM CS0 size according to the amount of RAM found */
131         if (dramsize > 0) {
132                 *(vu_long *)MPC5XXX_SDRAM_CS0CFG = 0x13 +
133                         __builtin_ffs(dramsize >> 20) - 1;
134         } else
135                 *(vu_long *)MPC5XXX_SDRAM_CS0CFG = 0; /* disabled */
136 #else /* CONFIG_SYS_RAMBOOT */
137         /* retrieve size of memory connected to SDRAM CS0 */
138         dramsize = *(vu_long *)MPC5XXX_SDRAM_CS0CFG & 0xFF;
139         if (dramsize >= 0x13)
140                 dramsize = (1 << (dramsize - 0x13)) << 20;
141         else
142                 dramsize = 0;
143 #endif /* !CONFIG_SYS_RAMBOOT */
144
145         /*
146          * On MPC5200B we need to set the special configuration delay in the
147          * DDR controller.  Refer to chapter 8.7.5 SDelay--MBAR + 0x0190 of
148          * the MPC5200B User's Manual.
149          */
150         *(vu_long *)MPC5XXX_SDRAM_SDELAY = 0x04;
151         __asm__ volatile ("sync");
152
153         gd->ram_size = dramsize;
154
155         return 0;
156 }
157
158
159 /*
160  * Read module hardware identification data from the I2C EEPROM.
161  */
162 static void read_hw_id(hw_id_t hw_id)
163 {
164         int i;
165         for (i = 0; i < HW_ID_ELEM_COUNT; ++i)
166                 if (i2c_read(CONFIG_SYS_I2C_EEPROM,
167                                 hw_id_format[i].offset,
168                                 2,
169                                 (uchar *)&hw_id[i][0],
170                                 hw_id_format[i].length) != 0)
171                         printf("ERROR: can't read HW ID from EEPROM\n");
172 }
173
174
175 /*
176  * Identify module we are running on, set gd->board_type to the index in
177  * hw_id_list[] corresponding to the module identifed, or to
178  * CM5200_UNKNOWN_MODULE if we can't identify the module.
179  */
180 static void identify_module(hw_id_t hw_id)
181 {
182         int i, j, element;
183         char match;
184         gd->board_type = CM5200_UNKNOWN_MODULE;
185         for (i = 0; i < sizeof (hw_id_list) / sizeof (char **); ++i) {
186                 match = 1;
187                 for (j = 0; j < sizeof (hw_id_identify) / sizeof (int); ++j) {
188                         element = hw_id_identify[j];
189                         if (strncmp(hw_id_list[i][element],
190                                         &hw_id[element][0],
191                                         hw_id_format[element].length) != 0) {
192                                 match = 0;
193                                 break;
194                         }
195                 }
196                 if (match) {
197                         gd->board_type = i;
198                         break;
199                 }
200         }
201 }
202
203
204 /*
205  * Compose string with module name.
206  * buf is assumed to have enough space, and be null-terminated.
207  */
208 static void compose_module_name(hw_id_t hw_id, char *buf)
209 {
210         char tmp[MODULE_NAME_MAXLEN];
211         strncat(buf, &hw_id[PCB_NAME][0], hw_id_format[PCB_NAME].length);
212         strncat(buf, ".", 1);
213         strncat(buf, &hw_id[FORM][0], hw_id_format[FORM].length);
214         strncat(buf, &hw_id[VERSION][0], hw_id_format[VERSION].length);
215         strncat(buf, " (", 2);
216         strncat(buf, &hw_id[IDENTIFICATION_NUMBER][0],
217                 hw_id_format[IDENTIFICATION_NUMBER].length);
218         sprintf(tmp, " / %u.%u)",
219                 hw_id[MAJOR_SW_VERSION][0],
220                 hw_id[MINOR_SW_VERSION][0]);
221         strcat(buf, tmp);
222 }
223
224
225 /*
226  * Compose string with hostname.
227  * buf is assumed to have enough space, and be null-terminated.
228  */
229 static void compose_hostname(hw_id_t hw_id, char *buf)
230 {
231         char *p;
232         strncat(buf, &hw_id[PCB_NAME][0], hw_id_format[PCB_NAME].length);
233         strncat(buf, "_", 1);
234         strncat(buf, &hw_id[FORM][0], hw_id_format[FORM].length);
235         strncat(buf, &hw_id[VERSION][0], hw_id_format[VERSION].length);
236         for (p = buf; *p; ++p)
237                 *p = tolower(*p);
238
239 }
240
241
242 #ifdef CONFIG_OF_BOARD_SETUP
243 /*
244  * Update 'model' and 'memory' properties in the blob according to the module
245  * that we are running on.
246  */
247 static void ft_blob_update(void *blob, bd_t *bd)
248 {
249         int len, ret, nodeoffset = 0;
250         char module_name[MODULE_NAME_MAXLEN] = {0};
251
252         compose_module_name(hw_id, module_name);
253         len = strlen(module_name) + 1;
254
255         ret = fdt_setprop(blob, nodeoffset, "model", module_name, len);
256         if (ret < 0)
257         printf("ft_blob_update(): cannot set /model property err:%s\n",
258                 fdt_strerror(ret));
259 }
260 #endif /* CONFIG_OF_BOARD_SETUP */
261
262
263 /*
264  * Read HW ID from I2C EEPROM and detect the modue we are running on. Note
265  * that we need to use local variable for readout, because global data is not
266  * writable yet (and we'll have to redo the readout later on).
267  */
268 int checkboard(void)
269 {
270         hw_id_t hw_id_tmp;
271         char module_name_tmp[MODULE_NAME_MAXLEN] = "";
272
273         /*
274          * We need I2C to access HW ID data from EEPROM, so we call i2c_init()
275          * here despite the fact that it will be called again later on. We
276          * also use a little trick to silence I2C-related output.
277          */
278         gd->flags |= GD_FLG_SILENT;
279         i2c_init (CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE);
280         gd->flags &= ~GD_FLG_SILENT;
281
282         read_hw_id(hw_id_tmp);
283         identify_module(hw_id_tmp);     /* this sets gd->board_type */
284         compose_module_name(hw_id_tmp, module_name_tmp);
285
286         if (gd->board_type != CM5200_UNKNOWN_MODULE)
287                 printf("Board: %s\n", module_name_tmp);
288         else
289                 printf("Board: unrecognized cm5200 module (%s)\n",
290                         module_name_tmp);
291
292         return 0;
293 }
294
295
296 int board_early_init_r(void)
297 {
298         /*
299          * Now, when we are in RAM, enable flash write access for detection
300          * process. Note that CS_BOOT cannot be cleared when executing in
301          * flash.
302          */
303         *(vu_long *)MPC5XXX_BOOTCS_CFG &= ~0x1; /* clear RO */
304
305         /* Now that we can write to global data, read HW ID again. */
306         read_hw_id(hw_id);
307         return 0;
308 }
309
310
311 #ifdef CONFIG_MISC_INIT_R
312 int misc_init_r(void)
313 {
314 #if defined(CONFIG_HARD_I2C) || defined(CONFIG_SYS_I2C_SOFT)
315         uchar buf[6];
316         char str[18];
317         char hostname[MODULE_NAME_MAXLEN];
318
319         /* Read ethaddr from EEPROM */
320         if (i2c_read(CONFIG_SYS_I2C_EEPROM, CONFIG_MAC_OFFSET, 2, buf, 6) == 0) {
321                 sprintf(str, "%02X:%02X:%02X:%02X:%02X:%02X",
322                         buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
323                 /* Check if MAC addr is owned by Schindler */
324                 if (strstr(str, "00:06:C3") != str)
325                         printf(LOG_PREFIX "Warning - Illegal MAC address (%s)"
326                                 " in EEPROM.\n", str);
327                 else {
328                         printf(LOG_PREFIX "Using MAC (%s) from I2C EEPROM\n",
329                                 str);
330                         setenv("ethaddr", str);
331                 }
332         } else {
333                 printf(LOG_PREFIX "Warning - Unable to read MAC from I2C"
334                         " device at address %02X:%04X\n", CONFIG_SYS_I2C_EEPROM,
335                         CONFIG_MAC_OFFSET);
336         }
337 #endif /* defined(CONFIG_HARD_I2C) || defined(CONFIG_SYS_I2C_SOFT) */
338         if (!getenv("ethaddr"))
339                 printf(LOG_PREFIX "MAC address not set, networking is not "
340                                         "operational\n");
341
342         /* set the hostname appropriate to the module we're running on */
343         hostname[0] = 0x00;
344         compose_hostname(hw_id, hostname);
345         setenv("hostname", hostname);
346
347         return 0;
348 }
349 #endif /* CONFIG_MISC_INIT_R */
350
351
352 #ifdef CONFIG_LAST_STAGE_INIT
353 int last_stage_init(void)
354 {
355 #ifdef CONFIG_USB_STORAGE
356         cm5200_fwupdate();
357 #endif /* CONFIG_USB_STORAGE */
358         return 0;
359 }
360 #endif /* CONFIG_LAST_STAGE_INIT */
361
362
363 #ifdef CONFIG_OF_BOARD_SETUP
364 int ft_board_setup(void *blob, bd_t *bd)
365 {
366         ft_cpu_setup(blob, bd);
367         ft_blob_update(blob, bd);
368
369         return 0;
370 }
371 #endif /* CONFIG_OF_BOARD_SETUP */