Fix SDRAM timing on Purple board
[karo-tx-uboot.git] / board / purple / purple.c
1 /*
2  * (C) Copyright 2003
3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4  *
5  * See file CREDITS for list of people who contributed to this
6  * project.
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License as
10  * published by the Free Software Foundation; either version 2 of
11  * the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21  * MA 02111-1307 USA
22  */
23
24 #include <common.h>
25 #include <command.h>
26 #include <asm/inca-ip.h>
27 #include <asm/regdef.h>
28 #include <asm/mipsregs.h>
29 #include <asm/addrspace.h>
30 #include <asm/cacheops.h>
31
32 #include "sconsole.h"
33
34 #define cache_unroll(base,op)                   \
35         __asm__ __volatile__("                  \
36                 .set noreorder;                 \
37                 .set mips3;                     \
38                 cache %1, (%0);                 \
39                 .set mips0;                     \
40                 .set reorder"                   \
41                 :                               \
42                 : "r" (base),                   \
43                   "i" (op));
44
45 typedef void (*FUNCPTR)(ulong *source, ulong *destination, ulong nlongs);
46
47 extern void     asc_serial_init         (void);
48 extern void     asc_serial_putc         (char);
49 extern void     asc_serial_puts         (const char *);
50 extern int      asc_serial_getc         (void);
51 extern int      asc_serial_tstc         (void);
52 extern void     asc_serial_setbrg       (void);
53
54 static void sdram_timing_init (ulong size)
55 {
56         register uint pass;
57         register uint done;
58         register uint count;
59         register uint p0, p1, p2, p3, p4;
60         register uint addr;
61
62 #define WRITE_MC_IOGP_1 *(uint *)0xbf800800 = (p1<<14)+(p2<<13)+(p4<<8)+(p0<<4)+p3;
63 #define WRITE_MC_IOGP_2 *(uint *)0xbf800800 = (p1<<14)+(p2<<13)+((p4-16)<<8)+(p0<<4)+p3;
64
65         done = 0;
66         p0 = 2;
67         while (p0 < 4 && done == 0) {
68             p1 = 0;
69             while (p1 < 2 && done == 0) {
70                 p2 = 0;
71                 while (p2 < 2 && done == 0) {
72                     p3 = 0;
73                     while (p3 < 16 && done == 0) {
74                         count = 0;
75                         p4 = 0;
76                         while (p4 < 32 && done == 0) {
77                             WRITE_MC_IOGP_1;
78
79                             for (addr = KSEG1 + 0x4000;
80                                  addr < KSEG1ADDR (size);
81                                  addr = addr + 4) {
82                                         *(uint *) addr = 0xaa55aa55;
83                             }
84
85                             pass = 1;
86
87                             for (addr = KSEG1 + 0x4000;
88                                  addr < KSEG1ADDR (size) && pass == 1;
89                                  addr = addr + 4) {
90                                         if (*(uint *) addr != 0xaa55aa55)
91                                                 pass = 0;
92                             }
93
94                             if (pass == 1) {
95                                 count++;
96                             } else {
97                                 count = 0;
98                             }
99
100                             if (count == 32) {
101                                 WRITE_MC_IOGP_2;
102                                 done = 1;
103                             }
104                             p4++;
105                         }
106                         p3++;
107                     }
108                     p2++;
109                 }
110                 p1++;
111             }
112             p0++;
113             if (p0 == 1)
114                 p0++;
115         }
116 }
117
118 long int initdram(int board_type)
119 {
120         /* The only supported number of SDRAM banks is 4.
121          */
122 #define CFG_NB  4
123
124         ulong   cfgpb0  = *INCA_IP_SDRAM_MC_CFGPB0;
125         ulong   cfgdw   = *INCA_IP_SDRAM_MC_CFGDW;
126         int     cols    = cfgpb0 & 0xF;
127         int     rows    = (cfgpb0 & 0xF0) >> 4;
128         int     dw      = cfgdw & 0xF;
129         ulong   size    = (1 << (rows + cols)) * (1 << (dw - 1)) * CFG_NB;
130         void (*  sdram_init) (ulong);
131
132         sdram_init = (void (*)(ulong)) KSEG0ADDR(&sdram_timing_init);
133
134         sdram_init(0x10000);
135
136         return size;
137 }
138
139 int checkboard (void)
140 {
141
142         unsigned long chipid = *(unsigned long *)0xB800C800;
143
144         printf ("Board: Purple PLB 2800 chip version %ld, ", chipid & 0xF);
145
146         printf("CPU Speed %d MHz\n", CPU_CLOCK_RATE/1000000);
147
148         return 0;
149 }
150
151 int misc_init_r (void)
152 {
153         asc_serial_init ();
154
155         sconsole_putc   = asc_serial_putc;
156         sconsole_puts   = asc_serial_puts;
157         sconsole_getc   = asc_serial_getc;
158         sconsole_tstc   = asc_serial_tstc;
159         sconsole_setbrg = asc_serial_setbrg;
160
161         sconsole_flush ();
162         return (0);
163 }
164
165 /*******************************************************************************
166 *
167 * copydwords - copy one buffer to another a long at a time
168 *
169 * This routine copies the first <nlongs> longs from <source> to <destination>.
170 */
171 static void copydwords (ulong *source, ulong *destination, ulong nlongs)
172 {
173         ulong temp,temp1;
174         ulong *dstend = destination + nlongs;
175
176         while (destination < dstend)
177         {
178                 temp = *source++;
179                 /* dummy read from sdram */
180                 temp1 = *(ulong *)0xa0000000;
181                 /* avoid optimization from compliler */
182                 *(ulong *)0xbf0081f8 = temp1 + temp;
183                 *destination++ = temp;
184
185         } 
186 }
187
188 /*******************************************************************************
189 *
190 * copyLongs - copy one buffer to another a long at a time
191 *
192 * This routine copies the first <nlongs> longs from <source> to <destination>.
193 */
194 static void copyLongs (ulong *source, ulong *destination, ulong nlongs)
195 {
196         FUNCPTR absEntry;
197
198         absEntry = (FUNCPTR)(0xbf008000+((ulong)copydwords & 0x7));
199         absEntry(source, destination, nlongs);
200 }
201
202 /*******************************************************************************
203 *
204 * programLoad - load program into ram
205 *
206 * This routine load copydwords into ram
207 *
208 */
209 static void programLoad(void)
210 {
211         FUNCPTR absEntry;
212         ulong *src,*dst;
213
214         src = (ulong *)(TEXT_BASE + 0x428);
215         dst = (ulong *)0xbf0081d0;
216
217         absEntry = (FUNCPTR)(TEXT_BASE + 0x400);   
218         absEntry(src,dst,0x6);          
219
220         src = (ulong *)((ulong)copydwords & 0xfffffff8);
221         dst = (ulong *)0xbf008000;
222
223         absEntry(src,dst,0x38);
224 }
225
226 /*******************************************************************************
227 *
228 * copy_code - copy u-boot image from flash to RAM
229 *
230 * This routine is needed to solve flash problems on this board
231 *
232 */
233 void copy_code (ulong dest_addr)
234 {
235         unsigned long start;
236         unsigned long end;
237
238         /* load copydwords into ram
239          */
240         programLoad();
241
242         /* copy u-boot code
243          */
244         copyLongs((ulong *)CFG_MONITOR_BASE,
245                   (ulong *)dest_addr,
246                   (CFG_MONITOR_LEN + 3) / 4);
247
248
249         /* flush caches
250          */
251
252         start = KSEG0;
253         end = start + CFG_DCACHE_SIZE;
254         while(start < end) {
255                 cache_unroll(start,Index_Writeback_Inv_D);
256                 start += CFG_CACHELINE_SIZE;
257         }
258
259         start = KSEG0;
260         end = start + CFG_ICACHE_SIZE;
261         while(start < end) {
262                 cache_unroll(start,Index_Invalidate_I);
263                 start += CFG_CACHELINE_SIZE;
264         }
265 }