← Back to branch summary

~ubuntu-branches/ubuntu/maverick/u-boot-omap3/maverick

« back to all changes in this revision

Viewing changes to board/MAI/AmigaOneG3SE/articiaS.c

  • Committer: Bazaar Package Importer
  • Author(s): Oliver Grawert
  • Date: 2010-03-22 15:06:23 UTC
  • Revision ID: james.westby@ubuntu.com-20100322150623-i21g8rgiyl5dohag
Tags: upstream-2010.3git20100315
Import upstream version 2010.3git20100315

Show diffs side-by-side

added added

removed removed

Lines of Context:
board/MAI/AmigaOneG3SE/articiaS.c
 
1
/*
 
2
 * (C) Copyright 2002
 
3
 * Hyperion Entertainment, ThomasF@hyperion-entertainment.com
 
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 <pci.h>
 
26
#include <asm/processor.h>
 
27
#include "memio.h"
 
28
#include "articiaS.h"
 
29
#include "smbus.h"
 
30
#include "via686.h"
 
31
 
 
32
DECLARE_GLOBAL_DATA_PTR;
 
33
 
 
34
#undef DEBUG
 
35
 
 
36
struct dimm_bank {
 
37
        uint8 used;                     /* Bank is populated */
 
38
        uint32 rows;                    /* Number of row addresses */
 
39
        uint32 columns;                 /* Number of column addresses */
 
40
        uint8 registered;               /* SIMM is registered */
 
41
        uint8 ecc;                      /* SIMM has ecc */
 
42
        uint8 burst_len;                /* Supported burst lengths */
 
43
        uint32 cas_lat;                 /* Supported CAS latencies */
 
44
        uint32 cas_used;                /* CAS to use (not set by user) */
 
45
        uint32 trcd;                    /* RAS to CAS latency */
 
46
        uint32 trp;                     /* Precharge latency */
 
47
        uint32 tclk_hi;                 /* SDRAM cycle time (highest CAS latency) */
 
48
        uint32 tclk_2hi;                /* SDRAM second highest CAS latency */
 
49
        uint32 size;                    /* Size of bank in bytes */
 
50
        uint8 auto_refresh;             /* Module supports auto refresh */
 
51
        uint32 refresh_time;            /* Refresh time (in ns) */
 
52
};
 
53
 
 
54
 
 
55
/*
 
56
** Based in part on the evb64260 code
 
57
*/
 
58
 
 
59
/*
 
60
 * translate ns.ns/10 coding of SPD timing values
 
61
 * into 10 ps unit values
 
62
 */
 
63
static inline unsigned short NS10to10PS (unsigned char spd_byte)
 
64
{
 
65
        unsigned short ns, ns10;
 
66
 
 
67
        /* isolate upper nibble */
 
68
        ns = (spd_byte >> 4) & 0x0F;
 
69
        /* isolate lower nibble */
 
70
        ns10 = (spd_byte & 0x0F);
 
71
 
 
72
        return (ns * 100 + ns10 * 10);
 
73
}
 
74
 
 
75
/*
 
76
 * translate ns coding of SPD timing values
 
77
 * into 10 ps unit values
 
78
 */
 
79
static inline unsigned short NSto10PS (unsigned char spd_byte)
 
80
{
 
81
        return (spd_byte * 100);
 
82
}
 
83
 
 
84
 
 
85
long detect_sdram (uint8 * rom, int dimmNum, struct dimm_bank *banks)
 
86
{
 
87
        int dimm_address = (dimmNum == 0) ? SM_DIMM0_ADDR : SM_DIMM1_ADDR;
 
88
        uint32 busclock = gd->bus_clk;
 
89
        uint32 memclock = busclock;
 
90
        uint32 tmemclock = 1000000000 / (memclock / 100);
 
91
        uint32 datawidth;
 
92
 
 
93
        if (sm_get_data (rom, dimm_address) == 0) {
 
94
                /* Nothing in slot, make both banks empty */
 
95
                debug ("Slot %d: vacant\n", dimmNum);
 
96
                banks[0].used = 0;
 
97
                banks[1].used = 0;
 
98
                return 0;
 
99
        }
 
100
 
 
101
        if (rom[2] != 0x04) {
 
102
                debug ("Slot %d: No SDRAM\n", dimmNum);
 
103
                banks[0].used = 0;
 
104
                banks[1].used = 0;
 
105
                return 0;
 
106
        }
 
107
 
 
108
        /* Determine number of banks/rows */
 
109
        if (rom[5] == 1) {
 
110
                banks[0].used = 1;
 
111
                banks[1].used = 0;
 
112
        } else {
 
113
                banks[0].used = 1;
 
114
                banks[1].used = 1;
 
115
        }
 
116
 
 
117
        /* Determine number of row addresses */
 
118
        if (rom[3] & 0xf0) {
 
119
                /* Different banks sizes */
 
120
                banks[0].rows = rom[3] & 0x0f;
 
121
                banks[1].rows = (rom[3] & 0xf0) >> 4;
 
122
        } else {
 
123
                /* Equal sized banks */
 
124
                banks[0].rows = rom[3] & 0x0f;
 
125
                banks[1].rows = banks[0].rows;
 
126
        }
 
127
 
 
128
        /* Determine number of column addresses */
 
129
        if (rom[4] & 0xf0) {
 
130
                /* Different bank sizes */
 
131
                banks[0].columns = rom[4] & 0x0f;
 
132
                banks[1].columns = (rom[4] & 0xf0) >> 4;
 
133
        } else {
 
134
                banks[0].columns = rom[4] & 0x0f;
 
135
                banks[1].columns = banks[0].columns;
 
136
        }
 
137
 
 
138
        /* Check Jedec revision, and modify row/column accordingly */
 
139
        if (rom[62] > 0x10) {
 
140
                if (banks[0].rows <= 3)
 
141
                        banks[0].rows += 15;
 
142
                if (banks[1].rows <= 3)
 
143
                        banks[1].rows += 15;
 
144
                if (banks[0].columns <= 3)
 
145
                        banks[0].columns += 15;
 
146
                if (banks[0].columns <= 3)
 
147
                        banks[0].columns += 15;
 
148
        }
 
149
 
 
150
        /* Check registered/unregisterd */
 
151
        if (rom[21] & 0x12) {
 
152
                banks[0].registered = 1;
 
153
                banks[1].registered = 1;
 
154
        } else {
 
155
                banks[0].registered = 0;
 
156
                banks[1].registered = 0;
 
157
        }
 
158
 
 
159
#ifdef CONFIG_ECC
 
160
        /* Check parity/ECC */
 
161
        banks[0].ecc = (rom[11] == 0x02);
 
162
        banks[1].ecc = (rom[11] == 0x02);
 
163
#endif
 
164
 
 
165
        /* Find burst lengths supported */
 
166
        banks[0].burst_len = rom[16] & 0x8f;
 
167
        banks[1].burst_len = rom[16] & 0x8f;
 
168
 
 
169
        /* Find possible cas latencies */
 
170
        banks[0].cas_lat = rom[18] & 0x7F;
 
171
        banks[1].cas_lat = rom[18] & 0x7F;
 
172
 
 
173
        /* RAS/CAS latency */
 
174
        banks[0].trcd = (NSto10PS (rom[29]) + (tmemclock - 1)) / tmemclock;
 
175
        banks[1].trcd = (NSto10PS (rom[29]) + (tmemclock - 1)) / tmemclock;
 
176
 
 
177
        /* Precharge latency */
 
178
        banks[0].trp = (NSto10PS (rom[27]) + (tmemclock - 1)) / tmemclock;
 
179
        banks[1].trp = (NSto10PS (rom[27]) + (tmemclock - 1)) / tmemclock;
 
180
 
 
181
        /* highest CAS latency */
 
182
        banks[0].tclk_hi = NS10to10PS (rom[9]);
 
183
        banks[1].tclk_hi = NS10to10PS (rom[9]);
 
184
 
 
185
        /* second highest CAS latency */
 
186
        banks[0].tclk_2hi = NS10to10PS (rom[23]);
 
187
        banks[1].tclk_2hi = NS10to10PS (rom[23]);
 
188
 
 
189
        /* bank sizes */
 
190
        datawidth = rom[13] & 0x7f;
 
191
        banks[0].size =
 
192
                        (1L << (banks[0].rows + banks[0].columns)) *
 
193
                        /* FIXME datawidth */ 8 * rom[17];
 
194
        if (rom[13] & 0x80)
 
195
                banks[1].size = 2 * banks[0].size;
 
196
        else
 
197
                banks[1].size = (1L << (banks[1].rows + banks[1].columns)) *
 
198
                                /* FIXME datawidth */ 8 * rom[17];
 
199
 
 
200
        /* Refresh */
 
201
        if (rom[12] & 0x80) {
 
202
                banks[0].auto_refresh = 1;
 
203
                banks[1].auto_refresh = 1;
 
204
        } else {
 
205
                banks[0].auto_refresh = 0;
 
206
                banks[1].auto_refresh = 0;
 
207
        }
 
208
 
 
209
        switch (rom[12] & 0x7f) {
 
210
        case 0:
 
211
                banks[0].refresh_time = (1562500 + (tmemclock - 1)) / tmemclock;
 
212
                banks[1].refresh_time = (1562500 + (tmemclock - 1)) / tmemclock;
 
213
                break;
 
214
        case 1:
 
215
                banks[0].refresh_time = (390600 + (tmemclock - 1)) / tmemclock;
 
216
                banks[1].refresh_time = (390600 + (tmemclock - 1)) / tmemclock;
 
217
                break;
 
218
        case 2:
 
219
                banks[0].refresh_time = (781200 + (tmemclock - 1)) / tmemclock;
 
220
                banks[1].refresh_time = (781200 + (tmemclock - 1)) / tmemclock;
 
221
                break;
 
222
        case 3:
 
223
                banks[0].refresh_time = (3125000 + (tmemclock - 1)) / tmemclock;
 
224
                banks[1].refresh_time = (3125000 + (tmemclock - 1)) / tmemclock;
 
225
                break;
 
226
        case 4:
 
227
                banks[0].refresh_time = (6250000 + (tmemclock - 1)) / tmemclock;
 
228
                banks[1].refresh_time = (6250000 + (tmemclock - 1)) / tmemclock;
 
229
                break;
 
230
        case 5:
 
231
                banks[0].refresh_time = (12500000 + (tmemclock - 1)) / tmemclock;
 
232
                banks[1].refresh_time = (12500000 + (tmemclock - 1)) / tmemclock;
 
233
                break;
 
234
        default:
 
235
                banks[0].refresh_time = 0x100;  /* Default of Articia S */
 
236
                banks[1].refresh_time = 0x100;
 
237
                break;
 
238
        }
 
239
 
 
240
#ifdef DEBUG
 
241
        printf ("\nInformation for SIMM bank %ld:\n", dimmNum);
 
242
        printf ("Number of banks: %ld\n", banks[0].used + banks[1].used);
 
243
        printf ("Number of row addresses: %ld\n", banks[0].rows);
 
244
        printf ("Number of coumns addresses: %ld\n", banks[0].columns);
 
245
        printf ("SIMM is %sregistered\n",
 
246
                        banks[0].registered == 0 ? "not " : "");
 
247
#ifdef CONFIG_ECC
 
248
        printf ("SIMM %s ECC\n",
 
249
                        banks[0].ecc == 1 ? "supports" : "doesn't support");
 
250
#endif
 
251
        printf ("Supported burst lenghts: %s %s %s %s %s\n",
 
252
                        banks[0].burst_len & 0x08 ? "8" : " ",
 
253
                        banks[0].burst_len & 0x04 ? "4" : " ",
 
254
                        banks[0].burst_len & 0x02 ? "2" : " ",
 
255
                        banks[0].burst_len & 0x01 ? "1" : " ",
 
256
                        banks[0].burst_len & 0x80 ? "PAGE" : "    ");
 
257
        printf ("Supported CAS latencies: %s %s %s\n",
 
258
                        banks[0].cas_lat & 0x04 ? "CAS 3" : "     ",
 
259
                        banks[0].cas_lat & 0x02 ? "CAS 2" : "     ",
 
260
                        banks[0].cas_lat & 0x01 ? "CAS 1" : "     ");
 
261
        printf ("RAS to CAS latency: %ld\n", banks[0].trcd);
 
262
        printf ("Precharge latency: %ld\n", banks[0].trp);
 
263
        printf ("SDRAM highest CAS latency: %ld\n", banks[0].tclk_hi);
 
264
        printf ("SDRAM 2nd highest CAS latency: %ld\n", banks[0].tclk_2hi);
 
265
        printf ("SDRAM data width: %ld\n", datawidth);
 
266
        printf ("Auto Refresh %ssupported\n",
 
267
                        banks[0].auto_refresh ? "" : "not ");
 
268
        printf ("Refresh time: %ld clocks\n", banks[0].refresh_time);
 
269
        if (banks[0].used)
 
270
                printf ("Bank 0 size: %ld MB\n", banks[0].size / 1024 / 1024);
 
271
        if (banks[1].used)
 
272
                printf ("Bank 1 size: %ld MB\n", banks[1].size / 1024 / 1024);
 
273
 
 
274
        printf ("\n");
 
275
#endif
 
276
 
 
277
        sm_term ();
 
278
        return 1;
 
279
}
 
280
 
 
281
void select_cas (struct dimm_bank *banks, uint8 fast)
 
282
{
 
283
        if (!banks[0].used) {
 
284
                banks[0].cas_used = 0;
 
285
                banks[0].cas_used = 0;
 
286
                return;
 
287
        }
 
288
 
 
289
        if (fast) {
 
290
                /* Search for fast CAS */
 
291
                uint32 i;
 
292
                uint32 c = 0x01;
 
293
 
 
294
                for (i = 1; i < 5; i++) {
 
295
                        if (banks[0].cas_lat & c) {
 
296
                                banks[0].cas_used = i;
 
297
                                banks[1].cas_used = i;
 
298
                                debug ("Using CAS %d (fast)\n", i);
 
299
                                return;
 
300
                        }
 
301
                        c <<= 1;
 
302
                }
 
303
 
 
304
                /* Default to CAS 3 */
 
305
                banks[0].cas_used = 3;
 
306
                banks[1].cas_used = 3;
 
307
                debug ("Using CAS 3 (fast)\n");
 
308
 
 
309
                return;
 
310
        } else {
 
311
                /* Search for slow cas */
 
312
                uint32 i;
 
313
                uint32 c = 0x08;
 
314
 
 
315
                for (i = 4; i > 1; i--) {
 
316
                        if (banks[0].cas_lat & c) {
 
317
                                banks[0].cas_used = i;
 
318
                                banks[1].cas_used = i;
 
319
                                debug ("Using CAS %d (slow)\n", i);
 
320
                                return;
 
321
                        }
 
322
                        c >>= 1;
 
323
                }
 
324
 
 
325
                /* Default to CAS 3 */
 
326
                banks[0].cas_used = 3;
 
327
                banks[1].cas_used = 3;
 
328
                debug ("Using CAS 3 (slow)\n");
 
329
 
 
330
                return;
 
331
        }
 
332
 
 
333
        banks[0].cas_used = 3;
 
334
        banks[1].cas_used = 3;
 
335
        debug ("Using CAS 3\n");
 
336
 
 
337
        return;
 
338
}
 
339
 
 
340
uint32 get_reg_setting (uint32 banks, uint32 rows, uint32 columns, uint32 size)
 
341
{
 
342
        uint32 i;
 
343
 
 
344
        struct RowColumnSize {
 
345
                uint32 banks;
 
346
                uint32 rows;
 
347
                uint32 columns;
 
348
                uint32 size;
 
349
                uint32 register_value;
 
350
        };
 
351
 
 
352
        struct RowColumnSize rcs_map[] = {
 
353
                /*  Sbk Radr Cadr   MB     Value */
 
354
                {1, 11, 8, 8, 0x00840f00},
 
355
                {1, 11, 9, 16, 0x00925f00},
 
356
                {1, 11, 10, 32, 0x00a64f00},
 
357
                {2, 12, 8, 32, 0x00c55f00},
 
358
                {2, 12, 9, 64, 0x00d66f00},
 
359
                {2, 12, 10, 128, 0x00e77f00},
 
360
                {2, 12, 11, 256, 0x00ff8f00},
 
361
                {2, 13, 11, 512, 0x00ff9f00},
 
362
                {0, 0, 0, 0, 0x00000000}
 
363
        };
 
364
 
 
365
 
 
366
        i = 0;
 
367
 
 
368
        while (rcs_map[i].banks != 0) {
 
369
                if (rows == rcs_map[i].rows
 
370
                        && columns == rcs_map[i].columns
 
371
                        && (size / 1024 / 1024) == rcs_map[i].size)
 
372
                        return rcs_map[i].register_value;
 
373
 
 
374
                i++;
 
375
        }
 
376
 
 
377
        return 0;
 
378
}
 
379
 
 
380
uint32 burst_to_len (uint32 support)
 
381
{
 
382
        if (support & 0x80)
 
383
                return 0x7;
 
384
        else if (support & 0x8)
 
385
                return 0x3;
 
386
        else if (support & 0x4)
 
387
                return 0x2;
 
388
        else if (support & 0x2)
 
389
                return 0x1;
 
390
        else if (support & 0x1)
 
391
                return 0x0;
 
392
 
 
393
        return 0;
 
394
}
 
395
 
 
396
long articiaS_ram_init (void)
 
397
{
 
398
        register uint32 i;
 
399
        register uint32 value1;
 
400
        register uint32 value2;
 
401
        uint8 rom[128];
 
402
        uint32 burst_len;
 
403
        uint32 burst_support;
 
404
        uint32 total_ram = 0;
 
405
 
 
406
        struct dimm_bank banks[4];      /* FIXME: Move to initram */
 
407
        uint32 busclock = gd->bus_clk;
 
408
        uint32 memclock = busclock;
 
409
        uint32 reg32;
 
410
        uint32 refresh_clocks;
 
411
        uint8 auto_refresh;
 
412
 
 
413
        memset (banks, 0, sizeof (struct dimm_bank) * 4);
 
414
 
 
415
        detect_sdram (rom, 0, &banks[0]);
 
416
        detect_sdram (rom, 1, &banks[2]);
 
417
 
 
418
        for (i = 0; i < 4; i++) {
 
419
                total_ram = total_ram + (banks[i].used * banks[i].size);
 
420
        }
 
421
 
 
422
        pci_write_cfg_long (0, 0, GLOBALINFO0, 0x117430c0);
 
423
        pci_write_cfg_long (0, 0, HBUSACR0, 0x1f0100b0);
 
424
        pci_write_cfg_long (0, 0, SRAM_CR, 0x00f12000); /* Note: Might also try 0x00f10000 (original: 0x00f12000) */
 
425
        pci_write_cfg_byte (0, 0, DRAM_RAS_CTL0, 0x3f);
 
426
        pci_write_cfg_byte (0, 0, DRAM_RAS_CTL1, 0x00); /*  was: 0x04); */
 
427
        pci_write_cfg_word (0, 0, DRAM_ECC0, 0x2020);   /*  was: 0x2400);  No ECC yet */
 
428
 
 
429
        /* FIXME: Move this stuff to seperate function, like setup_dimm_bank */
 
430
        if (banks[0].used) {
 
431
                value1 = get_reg_setting (banks[0].used + banks[1].used,
 
432
                                          banks[0].rows, banks[0].columns,
 
433
                                          banks[0].size);
 
434
        } else {
 
435
                value1 = 0;
 
436
        }
 
437
 
 
438
        if (banks[1].used) {
 
439
                value2 = get_reg_setting (banks[0].used + banks[1].used,
 
440
                                          banks[1].rows, banks[1].columns,
 
441
                                          banks[1].size);
 
442
        } else {
 
443
                value2 = 0;
 
444
        }
 
445
 
 
446
        pci_write_cfg_long (0, 0, DIMM0_B0_SCR0, value1);
 
447
        pci_write_cfg_long (0, 0, DIMM0_B1_SCR0, value2);
 
448
 
 
449
        debug ("DIMM0_B0_SCR0 = 0x%08x\n", value1);
 
450
        debug ("DIMM0_B1_SCR0 = 0x%08x\n", value2);
 
451
 
 
452
        if (banks[2].used) {
 
453
                value1 = get_reg_setting (banks[2].used + banks[3].used,
 
454
                                          banks[2].rows, banks[2].columns,
 
455
                                          banks[2].size);
 
456
        } else {
 
457
                value1 = 0;
 
458
        }
 
459
 
 
460
        if (banks[3].used) {
 
461
                value2 = get_reg_setting (banks[2].used + banks[3].used,
 
462
                                          banks[3].rows, banks[3].columns,
 
463
                                          banks[3].size);
 
464
        } else {
 
465
                value2 = 0;
 
466
        }
 
467
 
 
468
        pci_write_cfg_long (0, 0, DIMM1_B2_SCR0, value1);
 
469
        pci_write_cfg_long (0, 0, DIMM1_B3_SCR0, value2);
 
470
 
 
471
        debug ("DIMM0_B2_SCR0 = 0x%08x\n", value1);
 
472
        debug ("DIMM0_B3_SCR0 = 0x%08x\n", value2);
 
473
 
 
474
        pci_write_cfg_long (0, 0, DIMM2_B4_SCR0, 0);
 
475
        pci_write_cfg_long (0, 0, DIMM2_B5_SCR0, 0);
 
476
        pci_write_cfg_long (0, 0, DIMM3_B6_SCR0, 0);
 
477
        pci_write_cfg_long (0, 0, DIMM3_B7_SCR0, 0);
 
478
 
 
479
        /* Determine timing */
 
480
        select_cas (&banks[0], 0);
 
481
        select_cas (&banks[2], 0);
 
482
 
 
483
        /* FIXME: What about write recovery */
 
484
        /*                    Auto refresh    Precharge */
 
485
#if 0
 
486
        reg32 = (0x3 << 13) | (0x7 << 10) | ((banks[0].trp - 2) << 8) |
 
487
        /*    Write recovery  CAS Latency */
 
488
                (0x1 << 6) | (banks[0].cas_used << 4) |
 
489
        /*      RAS/CAS latency */
 
490
                ((banks[0].trcd - 1) << 0);
 
491
 
 
492
        reg32 |= ((0x3 << 13) | (0x7 << 10) | ((banks[2].trp - 2) << 8) |
 
493
                  (0x1 << 6) | (banks[2].cas_used << 4) |
 
494
                  ((banks[2].trcd - 1) << 0)) << 16;
 
495
#else
 
496
        if (100000000 == gd->bus_clk)
 
497
                reg32 = 0x71737173;
 
498
        else
 
499
                reg32 = 0x69736973;
 
500
#endif
 
501
        pci_write_cfg_long (0, 0, DIMM0_TCR0, reg32);
 
502
        debug ("DIMM0_TCR0 = 0x%08x\n", reg32);
 
503
 
 
504
        /* Write default in DIMM2/3 (not used on A1) */
 
505
        pci_write_cfg_long (0, 0, DIMM2_TCR0, 0x7d737d73);
 
506
 
 
507
 
 
508
        /* Determine buffered/unbuffered mode for each SIMM. Uses first bank as reference (second, if present, uses the same) */
 
509
        reg32 = pci_read_cfg_long (0, 0, DRAM_GCR0);
 
510
        reg32 &= 0xFF00FFFF;
 
511
 
 
512
#if 0
 
513
        if (banks[0].used && banks[0].registered)
 
514
                reg32 |= 0x1 << 16;
 
515
 
 
516
        if (banks[2].used && banks[2].registered)
 
517
                reg32 |= 0x1 << 18;
 
518
#else
 
519
        if (banks[0].registered || banks[2].registered)
 
520
                reg32 |= 0x55 << 16;
 
521
#endif
 
522
        pci_write_cfg_long (0, 0, DRAM_GCR0, reg32);
 
523
        debug ("DRAM_GCR0 = 0x%08x\n", reg32);
 
524
 
 
525
        /* Determine refresh */
 
526
        refresh_clocks = 0xffffffff;
 
527
        auto_refresh = 1;
 
528
 
 
529
        for (i = 0; i < 4; i++) {
 
530
                if (banks[i].used) {
 
531
                        if (banks[i].auto_refresh == 0)
 
532
                                auto_refresh = 0;
 
533
                        if (banks[i].refresh_time < refresh_clocks)
 
534
                                refresh_clocks = banks[i].refresh_time;
 
535
                }
 
536
        }
 
537
 
 
538
 
 
539
#if 1
 
540
        /*  It seems this is suggested by the ArticiaS data book */
 
541
        if (100000000 == gd->bus_clk)
 
542
                refresh_clocks = 1561;
 
543
        else
 
544
                refresh_clocks = 2083;
 
545
#endif
 
546
 
 
547
 
 
548
        debug ("Refresh set to %ld clocks, auto refresh %s\n",
 
549
                   refresh_clocks, auto_refresh ? "on" : "off");
 
550
 
 
551
        pci_write_cfg_long (0, 0, DRAM_REFRESH0,
 
552
                        (1 << 16) | (1 << 15) | (auto_refresh << 12) |
 
553
                        (refresh_clocks));
 
554
        debug ("DRAM_REFRESH0 = 0x%08x\n",
 
555
                        (1 << 16) | (1 << 15) | (auto_refresh << 12) |
 
556
                        (refresh_clocks));
 
557
 
 
558
/*     pci_write_cfg_long(0, 0, DRAM_REFRESH0,   0x00019400);  */
 
559
 
 
560
        /* Set mode registers */
 
561
        /* FIXME: For now, set same burst len for all modules. Dunno if that's necessary */
 
562
        /* Find a common burst len */
 
563
        burst_support = 0xff;
 
564
 
 
565
        if (banks[0].used)
 
566
                burst_support = banks[0].burst_len;
 
567
        if (banks[1].used)
 
568
                burst_support = banks[1].burst_len;
 
569
        if (banks[2].used)
 
570
                burst_support = banks[2].burst_len;
 
571
        if (banks[3].used)
 
572
                burst_support = banks[3].burst_len;
 
573
 
 
574
        /*
 
575
           ** Mode register:
 
576
           ** Bits         Use
 
577
           ** 0-2          Burst len
 
578
           ** 3            Burst type (0 = sequential, 1 = interleave)
 
579
           ** 4-6          CAS latency
 
580
           ** 7-8          Operation mode (0 = default, all others invalid)
 
581
           ** 9            Write burst
 
582
           ** 10-11        Reserved
 
583
           **
 
584
           ** Mode register burst table:
 
585
           ** A2 A1 A0     lenght
 
586
           ** 0  0  0      1
 
587
           ** 0  0  1      2
 
588
           ** 0  1  0      4
 
589
           ** 0  1  1      8
 
590
           ** 1  0  0      invalid
 
591
           ** 1  0  1      invalid
 
592
           ** 1  1  0      invalid
 
593
           ** 1  1  1      page (only valid for non-interleaved)
 
594
         */
 
595
 
 
596
        burst_len = burst_to_len (burst_support);
 
597
        burst_len = 2;                          /* FIXME */
 
598
 
 
599
        if (banks[0].used) {
 
600
                pci_write_cfg_word (0, 0, DRAM_PCR0,
 
601
                        0x8000 | burst_len | (banks[0].cas_used << 4));
 
602
                debug ("Mode bank 0: 0x%08x\n",
 
603
                        0x8000 | burst_len | (banks[0].cas_used << 4));
 
604
        } else {
 
605
                /*  Seems to be needed to disable the bank */
 
606
                pci_write_cfg_word (0, 0, DRAM_PCR0, 0x0000 | 0x032);
 
607
        }
 
608
 
 
609
        if (banks[1].used) {
 
610
                pci_write_cfg_word (0, 0, DRAM_PCR0,
 
611
                        0x9000 | burst_len | (banks[1].cas_used << 4));
 
612
                debug ("Mode bank 1: 0x%08x\n",
 
613
                        0x8000 | burst_len | (banks[1].cas_used << 4));
 
614
        } else {
 
615
                /*  Seems to be needed to disable the bank */
 
616
                pci_write_cfg_word (0, 0, DRAM_PCR0, 0x1000 | 0x032);
 
617
        }
 
618
 
 
619
 
 
620
        if (banks[2].used) {
 
621
                pci_write_cfg_word (0, 0, DRAM_PCR0,
 
622
                        0xa000 | burst_len | (banks[2].cas_used << 4));
 
623
                debug ("Mode bank 2: 0x%08x\n",
 
624
                        0x8000 | burst_len | (banks[2].cas_used << 4));
 
625
        } else {
 
626
                /*  Seems to be needed to disable the bank */
 
627
                pci_write_cfg_word (0, 0, DRAM_PCR0, 0x2000 | 0x032);
 
628
        }
 
629
 
 
630
 
 
631
        if (banks[3].used) {
 
632
                pci_write_cfg_word (0, 0, DRAM_PCR0,
 
633
                        0xb000 | burst_len | (banks[3].cas_used << 4));
 
634
                debug ("Mode bank 3: 0x%08x\n",
 
635
                        0x8000 | burst_len | (banks[3].cas_used << 4));
 
636
        } else {
 
637
                /*  Seems to be needed to disable the bank */
 
638
                pci_write_cfg_word (0, 0, DRAM_PCR0, 0x3000 | 0x032);
 
639
        }
 
640
 
 
641
 
 
642
        pci_write_cfg_word (0, 0, 0xba, 0x00);
 
643
 
 
644
        return total_ram;
 
645
}
 
646
 
 
647
extern int drv_isa_kbd_init (void);
 
648
 
 
649
int last_stage_init (void)
 
650
{
 
651
        drv_isa_kbd_init ();
 
652
        return 0;
 
653
}
 
654
 
 
655
int overwrite_console (void)
 
656
{
 
657
        return (0);
 
658
}
 
659
 
 
660
#define in_8 read_byte
 
661
#define out_8 write_byte
 
662
 
 
663
static __inline__ unsigned long get_msr (void)
 
664
{
 
665
        unsigned long msr;
 
666
 
 
667
        asm volatile ("mfmsr %0":"=r" (msr):);
 
668
 
 
669
        return msr;
 
670
}
 
671
 
 
672
static __inline__ void set_msr (unsigned long msr)
 
673
{
 
674
        asm volatile ("mtmsr %0"::"r" (msr));
 
675
}
 
676
 
 
677
int board_early_init_f (void)
 
678
{
 
679
        unsigned char c_value = 0;
 
680
        unsigned long msr;
 
681
 
 
682
        /* Basic init of PS/2 keyboard (needed for some reason)... */
 
683
        /* Ripped from John's code */
 
684
        while ((in_8 ((unsigned char *) 0xfe000064) & 0x02) != 0);
 
685
        out_8 ((unsigned char *) 0xfe000064, 0xaa);
 
686
        while ((in_8 ((unsigned char *) 0xfe000064) & 0x01) == 0);
 
687
        c_value = in_8 ((unsigned char *) 0xfe000060);
 
688
        while ((in_8 ((unsigned char *) 0xfe000064) & 0x02) != 0);
 
689
        out_8 ((unsigned char *) 0xfe000064, 0xab);
 
690
        while ((in_8 ((unsigned char *) 0xfe000064) & 0x01) == 0);
 
691
        c_value = in_8 ((unsigned char *) 0xfe000060);
 
692
        while ((in_8 ((unsigned char *) 0xfe000064) & 0x02) != 0);
 
693
        out_8 ((unsigned char *) 0xfe000064, 0xae);
 
694
/*     while ((in_8((unsigned char *)0xfe000064) & 0x01) == 0); */
 
695
/*     c_value = in_8((unsigned char *)0xfe000060); */
 
696
 
 
697
        /*  Enable FPU */
 
698
        msr = get_msr ();
 
699
        set_msr (msr | MSR_FP);
 
700
 
 
701
        via_calibrate_bus_freq ();
 
702
 
 
703
        return 0;
 
704
}