post/board/lwmon5/gdc.c: Fix GCC 4.6 build warning
[platform/kernel/u-boot.git] / post / board / lwmon5 / gdc.c
1 /*
2  * (C) Copyright 2008 Dmitry Rakhchev, EmCraft Systems, rda@emcraft.com
3  *
4  * Developed for DENX Software Engineering GmbH
5  *
6  * See file CREDITS for list of people who contributed to this
7  * project.
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License as
11  * published by the Free Software Foundation; either version 2 of
12  * the License, or (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
22  * MA 02111-1307 USA
23  */
24 #include <common.h>
25
26 /* This test attempts to verify board GDC. A scratch register tested, then
27  * simple memory test (get_ram_size()) run over GDC memory.
28  */
29
30 #include <post.h>
31 #include <watchdog.h>
32 #include <asm/io.h>
33 #include <video.h>
34
35 DECLARE_GLOBAL_DATA_PTR;
36
37 #define GDC_SCRATCH_REG 0xC1FF8044
38 #define GDC_VERSION_REG 0xC1FF8084
39 #define GDC_HOST_BASE   0xC1FC0000
40 #define GDC_RAM_START   0xC0000000
41 #define GDC_RAM_END     (GDC_HOST_BASE - 1)
42 #define GDC_RAM_SIZE    (GDC_RAM_END - GDC_RAM_START)
43
44 #if CONFIG_POST & CONFIG_SYS_POST_BSPEC4
45
46 const static unsigned long pattern[] = {
47         0xffffffff,
48         0xaaaaaaaa,
49         0xcccccccc,
50         0xf0f0f0f0,
51         0xff00ff00,
52         0xffff0000,
53         0x0000ffff,
54         0x00ff00ff,
55         0x0f0f0f0f,
56         0x33333333,
57         0x55555555,
58         0x00000000
59 };
60
61 const static unsigned long otherpattern = 0x01234567;
62
63 /* test write/read og a given LIME Register */
64 static int gdc_test_reg_one(uint value)
65 {
66         uint read_value;
67
68         /* write test pattern */
69         out_be32((void *)GDC_SCRATCH_REG, value);
70         /* read other location (protect against data lines capacity) */
71         in_be32((void *)GDC_RAM_START);
72         /* verify test pattern */
73         read_value = in_be32((void *)GDC_SCRATCH_REG);
74         if (read_value != value) {
75                 post_log("GDC SCRATCH test failed write %08X, read %08X\n",
76                          value, read_value);
77         }
78
79         return (read_value != value);
80 }
81
82 /* test with a given static 32 bit pattern in a given memory addressrange */
83 static int gdc_post_test1(ulong *start, ulong size, ulong val)
84 {
85         int ret = 0;
86         ulong i = 0;
87         ulong *mem = start;
88         ulong readback;
89
90         for (i = 0; i < size / sizeof(ulong); i++) {
91                 mem[i] = val;
92                 if (i % 1024 == 0)
93                         WATCHDOG_RESET();
94         }
95
96         for (i = 0; i < size / sizeof(ulong); i++) {
97                 readback = mem[i];
98                 if (readback != val) {
99                         post_log("GDC Memory error at %08x, "
100                                  "wrote %08x, read %08x !\n",
101                                  mem + i, val, readback);
102                         ret = -1;
103                         break;
104                 }
105                 if (i % 1024 == 0)
106                         WATCHDOG_RESET();
107         }
108
109         return ret;
110 }
111
112 /* test with dynamic 32 bit pattern in a given memory addressrange */
113 static int gdc_post_test2(ulong *start, ulong size)
114 {
115         int ret = 0;
116         ulong i = 0;
117         ulong *mem = start;
118         ulong readback;
119
120         for (i = 0; i < size / sizeof(ulong); i++) {
121                 mem[i] = 1 << (i % 32);
122                 if (i % 1024 == 0)
123                         WATCHDOG_RESET();
124         }
125
126         for (i = 0; i < size / sizeof(ulong); i++) {
127                 readback = mem[i];
128                 if (readback != 1 << (i % 32)) {
129                         post_log("GDC Memory error at %08x, "
130                                  "wrote %08x, read %08x !\n",
131                                  mem + i, 1 << (i % 32), readback);
132                         ret = -1;
133                         break;
134                 }
135                 if (i % 1024 == 0)
136                         WATCHDOG_RESET();
137         }
138
139         return ret;
140 }
141
142 /* test with dynamic 32 bit pattern in a given memory addressrange */
143 static int gdc_post_test3(ulong *start, ulong size)
144 {
145         int ret = 0;
146         ulong i = 0;
147         ulong *mem = start;
148         ulong readback;
149
150         for (i = 0; i < size / sizeof(ulong); i++) {
151                 mem[i] = i;
152                 if (i % 1024 == 0)
153                         WATCHDOG_RESET();
154         }
155
156         for (i = 0; i < size / sizeof(ulong); i++) {
157                 readback = mem[i];
158                 if (readback != i) {
159                         post_log("GDC Memory error at %08x, "
160                                  "wrote %08x, read %08x !\n",
161                                  mem + i, i, readback);
162                         ret = -1;
163                         break;
164                 }
165                 if (i % 1024 == 0)
166                         WATCHDOG_RESET();
167         }
168
169         return ret;
170 }
171
172 /* test with dynamic 32 bit pattern in a given memory addressrange */
173 static int gdc_post_test4(ulong *start, ulong size)
174 {
175         int ret = 0;
176         ulong i = 0;
177         ulong *mem = start;
178         ulong readback;
179
180         for (i = 0; i < size / sizeof(ulong); i++) {
181                 mem[i] = ~i;
182                 if (i % 1024 == 0)
183                         WATCHDOG_RESET();
184         }
185
186         for (i = 0; i < size / sizeof(ulong); i++) {
187                 readback = mem[i];
188                 if (readback != ~i) {
189                         post_log("GDC Memory error at %08x, "
190                                  "wrote %08x, read %08x !\n",
191                                  mem + i, ~i, readback);
192                         ret = -1;
193                         break;
194                 }
195                 if (i % 1024 == 0)
196                         WATCHDOG_RESET();
197         }
198
199         return ret;
200 }
201
202 /* do some patterntests in a given addressrange */
203 int gdc_mem_test(ulong *start, ulong size)
204 {
205         int ret = 0;
206
207         /*
208          * check addressrange and do different static and dynamic
209          * pattern tests with it.
210          */
211         if (((void *)start) + size <= (void *)GDC_RAM_END) {
212                 if (ret == 0)
213                         ret = gdc_post_test1(start, size, 0x00000000);
214
215                 if (ret == 0)
216                         ret = gdc_post_test1(start, size, 0xffffffff);
217
218                 if (ret == 0)
219                         ret = gdc_post_test1(start, size, 0x55555555);
220
221                 if (ret == 0)
222                         ret = gdc_post_test1(start, size, 0xaaaaaaaa);
223
224                 if (ret == 0)
225                         ret = gdc_post_test2(start, size);
226
227                 if (ret == 0)
228                         ret = gdc_post_test3(start, size);
229
230                 if (ret == 0)
231                         ret = gdc_post_test4(start, size);
232         }
233
234         return ret;
235 }
236
237 /* test function of gdc memory addresslines*/
238 static int gdc_post_addrline(ulong *address, ulong *base, ulong size)
239 {
240         ulong *target;
241         ulong *end;
242         ulong readback = 0;
243         ulong xor = 0;
244         int ret = 0;
245
246         end = (ulong *)((ulong)base + size);
247
248         for (xor = sizeof(long); xor > 0; xor <<= 1) {
249                 target = (ulong *)((ulong)address ^ xor);
250                 if ((target >= base) && (target < end)) {
251                         *address = ~*target;
252                         readback = *target;
253                 }
254
255                 if (readback == *address) {
256                         post_log("GDC Memory (address line) error at %08x"
257                                  "XOR value %08x !\n",
258                                  address, target , xor);
259                         ret = -1;
260                         break;
261                 }
262         }
263
264         return ret;
265 }
266
267 static int gdc_post_dataline(ulong *address)
268 {
269         unsigned long temp32 = 0;
270         int i = 0;
271         int ret = 0;
272
273         for (i = 0; i < ARRAY_SIZE(pattern); i++) {
274                 *address = pattern[i];
275                 /*
276                  * Put a different pattern on the data lines: otherwise they
277                  * may float long enough to read back what we wrote.
278                  */
279                 *(address + 1) = otherpattern;
280                 temp32 = *address;
281
282                 if (temp32 != pattern[i]){
283                         post_log("GDC Memory (date line) error at %08x, "
284                                  "wrote %08x, read %08x !\n",
285                                  address, pattern[i], temp32);
286                         ret = 1;
287                 }
288         }
289
290         return ret;
291 }
292
293 /* Verify GDC, get memory size, verify GDC memory */
294 int gdc_post_test(int flags)
295 {
296         uint    old_value;
297         int     i = 0;
298         int     ret = 0;
299
300         post_log("\n");
301         old_value = in_be32((void *)GDC_SCRATCH_REG);
302
303         /*
304          * GPIOC2 register behaviour: the LIME graphics processor has a
305          * maximum of 5 GPIO ports that can be used in this hardware
306          * configuration. Thus only the  bits  for these 5 GPIOs can be
307          * activated in the GPIOC2 register. All other bits will always be
308          * read as zero.
309          */
310         if (gdc_test_reg_one(0x00150015))
311                 ret = 1;
312         if (gdc_test_reg_one(0x000A000A))
313                 ret = 1;
314
315         out_be32((void *)GDC_SCRATCH_REG, old_value);
316
317         old_value = in_be32((void *)GDC_VERSION_REG);
318         post_log("GDC chip version %u.%u, year %04X\n",
319                  (old_value >> 8) & 0xFF, old_value & 0xFF,
320                  (old_value >> 16) & 0xFFFF);
321
322         old_value = get_ram_size((void *)GDC_RAM_START,
323                                  0x02000000);
324
325         debug("GDC RAM size (ist):  %d bytes\n", old_value);
326         debug("GDC RAM size (soll): %d bytes\n", GDC_RAM_SIZE);
327         post_log("GDC RAM size: %d bytes\n", old_value);
328
329         /* Test SDRAM datalines */
330         if (gdc_post_dataline((ulong *)GDC_RAM_START)) {
331                 ret = 1;
332                 goto out;
333         }
334         WATCHDOG_RESET();
335
336         /* Test SDRAM adresslines */
337         if (gdc_post_addrline((ulong *)GDC_RAM_START,
338                               (ulong *)GDC_RAM_START, GDC_RAM_SIZE)) {
339                 ret = 1;
340                 goto out;
341         }
342         WATCHDOG_RESET();
343         if (gdc_post_addrline((ulong *)GDC_RAM_END - sizeof(long),
344                               (ulong *)GDC_RAM_START, GDC_RAM_SIZE)) {
345                 ret = 1;
346                 goto out;
347         }
348         WATCHDOG_RESET();
349
350         /* memory pattern test */
351         debug("GDC Memory test (flags %8x:%8x)\n", flags,
352               POST_SLOWTEST | POST_MANUAL);
353
354         if (flags & POST_MANUAL) {
355                 debug("Full memory test\n");
356                 if (gdc_mem_test((ulong *)GDC_RAM_START, GDC_RAM_SIZE)) {
357                         ret = 1;
358                         goto out;
359                 }
360                 /* load splashscreen again */
361         } else {
362                 debug("smart memory test\n");
363                 for (i = 0; i < (GDC_RAM_SIZE >> 20) && ret == 0; i++) {
364                         if (ret == 0)
365                                 ret = gdc_mem_test((ulong *)(GDC_RAM_START +
366                                                              (i << 20)),
367                                                    0x800);
368                         if (ret == 0)
369                                 ret = gdc_mem_test((ulong *)(GDC_RAM_START +
370                                                              (i << 20) + 0xff800),
371                                                    0x800);
372                 }
373         }
374         WATCHDOG_RESET();
375
376 out:
377         return ret;
378 }
379 #endif /* CONFIG_POST & CONFIG_SYS_POST_BSPEC4 */