← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to roms/u-boot/board/Marvell/db64460/db64460.c

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
roms/u-boot/board/Marvell/db64460/db64460.c
 
1
/*
 
2
 * (C) Copyright 2001
 
3
 * Josh Huber <huber@mclx.com>, Mission Critical Linux, Inc.
 
4
 *
 
5
 * SPDX-License-Identifier:     GPL-2.0+
 
6
 *
 
7
 * modifications for the DB64460 eval board based by Ingo.Assmus@keymile.com
 
8
 */
 
9
 
 
10
/*
 
11
 * db64460.c - main board support/init for the Galileo Eval board.
 
12
 */
 
13
 
 
14
#include <common.h>
 
15
#include <74xx_7xx.h>
 
16
#include "../include/memory.h"
 
17
#include "../include/pci.h"
 
18
#include "../include/mv_gen_reg.h"
 
19
#include <net.h>
 
20
#include <netdev.h>
 
21
#include <linux/compiler.h>
 
22
 
 
23
#include "eth.h"
 
24
#include "mpsc.h"
 
25
#include "i2c.h"
 
26
#include "64460.h"
 
27
#include "mv_regs.h"
 
28
 
 
29
#undef  DEBUG
 
30
/*#define       DEBUG */
 
31
 
 
32
#define MAP_PCI
 
33
 
 
34
#ifdef DEBUG
 
35
#define DP(x) x
 
36
#else
 
37
#define DP(x)
 
38
#endif
 
39
 
 
40
/* ------------------------------------------------------------------------- */
 
41
 
 
42
/* this is the current GT register space location */
 
43
/* it starts at CONFIG_SYS_DFL_GT_REGS but moves later to CONFIG_SYS_GT_REGS */
 
44
 
 
45
/* Unfortunately, we cant change it while we are in flash, so we initialize it
 
46
 * to the "final" value. This means that any debug_led calls before
 
47
 * board_early_init_f wont work right (like in cpu_init_f).
 
48
 * See also my_remap_gt_regs below. (NTL)
 
49
 */
 
50
 
 
51
void board_prebootm_init (void);
 
52
unsigned int INTERNAL_REG_BASE_ADDR = CONFIG_SYS_GT_REGS;
 
53
int display_mem_map (void);
 
54
 
 
55
/* ------------------------------------------------------------------------- */
 
56
 
 
57
/*
 
58
 * This is a version of the GT register space remapping function that
 
59
 * doesn't touch globals (meaning, it's ok to run from flash.)
 
60
 *
 
61
 * Unfortunately, this has the side effect that a writable
 
62
 * INTERNAL_REG_BASE_ADDR is impossible. Oh well.
 
63
 */
 
64
 
 
65
void my_remap_gt_regs (u32 cur_loc, u32 new_loc)
 
66
{
 
67
        u32 temp;
 
68
 
 
69
        /* check and see if it's already moved */
 
70
 
 
71
/* original ppcboot 1.1.6 source
 
72
 
 
73
        temp = in_le32((u32 *)(new_loc + INTERNAL_SPACE_DECODE));
 
74
        if ((temp & 0xffff) == new_loc >> 20)
 
75
                return;
 
76
 
 
77
        temp = (in_le32((u32 *)(cur_loc + INTERNAL_SPACE_DECODE)) &
 
78
                0xffff0000) | (new_loc >> 20);
 
79
 
 
80
        out_le32((u32 *)(cur_loc + INTERNAL_SPACE_DECODE), temp);
 
81
 
 
82
        while (GTREGREAD(INTERNAL_SPACE_DECODE) != temp);
 
83
original ppcboot 1.1.6 source end */
 
84
 
 
85
        temp = in_le32 ((u32 *) (new_loc + INTERNAL_SPACE_DECODE));
 
86
        if ((temp & 0xffff) == new_loc >> 16)
 
87
                return;
 
88
 
 
89
        temp = (in_le32 ((u32 *) (cur_loc + INTERNAL_SPACE_DECODE)) &
 
90
                0xffff0000) | (new_loc >> 16);
 
91
 
 
92
        out_le32 ((u32 *) (cur_loc + INTERNAL_SPACE_DECODE), temp);
 
93
 
 
94
        while (GTREGREAD (INTERNAL_SPACE_DECODE) != temp);
 
95
}
 
96
 
 
97
#ifdef CONFIG_PCI
 
98
 
 
99
static void gt_pci_config (void)
 
100
{
 
101
        unsigned int stat;
 
102
        unsigned int val = 0x00fff864;  /* DINK32: BusNum 23:16,  DevNum 15:11, FuncNum 10:8, RegNum 7:2 */
 
103
 
 
104
        /* In PCIX mode devices provide their own bus and device numbers. We query the Discovery II's
 
105
         * config registers by writing ones to the bus and device.
 
106
         * We then update the Virtual register with the correct value for the bus and device.
 
107
         */
 
108
        if ((GTREGREAD (PCI_0_MODE) & (BIT4 | BIT5)) != 0) {    /*if  PCI-X */
 
109
                GT_REG_WRITE (PCI_0_CONFIG_ADDR, BIT31 | val);
 
110
 
 
111
                GT_REG_READ (PCI_0_CONFIG_DATA_VIRTUAL_REG, &stat);
 
112
 
 
113
                GT_REG_WRITE (PCI_0_CONFIG_ADDR, BIT31 | val);
 
114
                GT_REG_WRITE (PCI_0_CONFIG_DATA_VIRTUAL_REG,
 
115
                              (stat & 0xffff0000) | CONFIG_SYS_PCI_IDSEL);
 
116
 
 
117
        }
 
118
        if ((GTREGREAD (PCI_1_MODE) & (BIT4 | BIT5)) != 0) {    /*if  PCI-X */
 
119
                GT_REG_WRITE (PCI_1_CONFIG_ADDR, BIT31 | val);
 
120
                GT_REG_READ (PCI_1_CONFIG_DATA_VIRTUAL_REG, &stat);
 
121
 
 
122
                GT_REG_WRITE (PCI_1_CONFIG_ADDR, BIT31 | val);
 
123
                GT_REG_WRITE (PCI_1_CONFIG_DATA_VIRTUAL_REG,
 
124
                              (stat & 0xffff0000) | CONFIG_SYS_PCI_IDSEL);
 
125
        }
 
126
 
 
127
        /* Enable master */
 
128
        PCI_MASTER_ENABLE (0, SELF);
 
129
        PCI_MASTER_ENABLE (1, SELF);
 
130
 
 
131
        /* Enable PCI0/1 Mem0 and IO 0 disable all others */
 
132
        GT_REG_READ (BASE_ADDR_ENABLE, &stat);
 
133
        stat |= (1 << 11) | (1 << 12) | (1 << 13) | (1 << 16) | (1 << 17) | (1
 
134
                                                                             <<
 
135
                                                                             18);
 
136
        stat &= ~((1 << 9) | (1 << 10) | (1 << 14) | (1 << 15));
 
137
        GT_REG_WRITE (BASE_ADDR_ENABLE, stat);
 
138
 
 
139
        /* ronen- add write to pci remap registers for 64460.
 
140
           in 64360 when writing to pci base go and overide remap automaticaly,
 
141
           in 64460 it doesn't */
 
142
        GT_REG_WRITE (PCI_0_IO_BASE_ADDR, CONFIG_SYS_PCI0_IO_BASE >> 16);
 
143
        GT_REG_WRITE (PCI_0I_O_ADDRESS_REMAP, CONFIG_SYS_PCI0_IO_BASE >> 16);
 
144
        GT_REG_WRITE (PCI_0_IO_SIZE, (CONFIG_SYS_PCI0_IO_SIZE - 1) >> 16);
 
145
 
 
146
        GT_REG_WRITE (PCI_0_MEMORY0_BASE_ADDR, CONFIG_SYS_PCI0_MEM_BASE >> 16);
 
147
        GT_REG_WRITE (PCI_0MEMORY0_ADDRESS_REMAP, CONFIG_SYS_PCI0_MEM_BASE >> 16);
 
148
        GT_REG_WRITE (PCI_0_MEMORY0_SIZE, (CONFIG_SYS_PCI0_MEM_SIZE - 1) >> 16);
 
149
 
 
150
        GT_REG_WRITE (PCI_1_IO_BASE_ADDR, CONFIG_SYS_PCI1_IO_BASE >> 16);
 
151
        GT_REG_WRITE (PCI_1I_O_ADDRESS_REMAP, CONFIG_SYS_PCI1_IO_BASE >> 16);
 
152
        GT_REG_WRITE (PCI_1_IO_SIZE, (CONFIG_SYS_PCI1_IO_SIZE - 1) >> 16);
 
153
 
 
154
        GT_REG_WRITE (PCI_1_MEMORY0_BASE_ADDR, CONFIG_SYS_PCI1_MEM_BASE >> 16);
 
155
        GT_REG_WRITE (PCI_1MEMORY0_ADDRESS_REMAP, CONFIG_SYS_PCI1_MEM_BASE >> 16);
 
156
        GT_REG_WRITE (PCI_1_MEMORY0_SIZE, (CONFIG_SYS_PCI1_MEM_SIZE - 1) >> 16);
 
157
 
 
158
        /* PCI interface settings */
 
159
        /* Timeout set to retry forever */
 
160
        GT_REG_WRITE (PCI_0TIMEOUT_RETRY, 0x0);
 
161
        GT_REG_WRITE (PCI_1TIMEOUT_RETRY, 0x0);
 
162
 
 
163
        /* ronen - enable only CS0 and Internal reg!! */
 
164
        GT_REG_WRITE (PCI_0BASE_ADDRESS_REGISTERS_ENABLE, 0xfffffdfe);
 
165
        GT_REG_WRITE (PCI_1BASE_ADDRESS_REGISTERS_ENABLE, 0xfffffdfe);
 
166
 
 
167
/*ronen update the pci internal registers base address.*/
 
168
#ifdef MAP_PCI
 
169
        for (stat = 0; stat <= PCI_HOST1; stat++)
 
170
                pciWriteConfigReg (stat,
 
171
                                   PCI_INTERNAL_REGISTERS_MEMORY_MAPPED_BASE_ADDRESS,
 
172
                                   SELF, CONFIG_SYS_GT_REGS);
 
173
#endif
 
174
 
 
175
}
 
176
#endif
 
177
 
 
178
/* Setup CPU interface paramaters */
 
179
static void gt_cpu_config (void)
 
180
{
 
181
        cpu_t cpu = get_cpu_type ();
 
182
        ulong tmp;
 
183
 
 
184
        /* cpu configuration register */
 
185
        tmp = GTREGREAD (CPU_CONFIGURATION);
 
186
 
 
187
        /* set the SINGLE_CPU bit  see MV64460 P.399 */
 
188
#ifndef CONFIG_SYS_GT_DUAL_CPU          /* SINGLE_CPU seems to cause JTAG problems */
 
189
        tmp |= CPU_CONF_SINGLE_CPU;
 
190
#endif
 
191
 
 
192
        tmp &= ~CPU_CONF_AACK_DELAY_2;
 
193
 
 
194
        tmp |= CPU_CONF_DP_VALID;
 
195
        tmp |= CPU_CONF_AP_VALID;
 
196
 
 
197
        tmp |= CPU_CONF_PIPELINE;
 
198
 
 
199
        GT_REG_WRITE (CPU_CONFIGURATION, tmp);  /* Marvell (VXWorks) writes 0x20220FF */
 
200
 
 
201
        /* CPU master control register */
 
202
        tmp = GTREGREAD (CPU_MASTER_CONTROL);
 
203
 
 
204
        tmp |= CPU_MAST_CTL_ARB_EN;
 
205
 
 
206
        if ((cpu == CPU_7400) ||
 
207
            (cpu == CPU_7410) || (cpu == CPU_7455) || (cpu == CPU_7450)) {
 
208
 
 
209
                tmp |= CPU_MAST_CTL_CLEAN_BLK;
 
210
                tmp |= CPU_MAST_CTL_FLUSH_BLK;
 
211
 
 
212
        } else {
 
213
                /* cleanblock must be cleared for CPUs
 
214
                 * that do not support this command (603e, 750)
 
215
                 * see Res#1 */
 
216
                tmp &= ~CPU_MAST_CTL_CLEAN_BLK;
 
217
                tmp &= ~CPU_MAST_CTL_FLUSH_BLK;
 
218
        }
 
219
        GT_REG_WRITE (CPU_MASTER_CONTROL, tmp);
 
220
}
 
221
 
 
222
/*
 
223
 * board_early_init_f.
 
224
 *
 
225
 * set up gal. device mappings, etc.
 
226
 */
 
227
int board_early_init_f (void)
 
228
{
 
229
        uchar sram_boot = 0;
 
230
 
 
231
        /*
 
232
         * set up the GT the way the kernel wants it
 
233
         * the call to move the GT register space will obviously
 
234
         * fail if it has already been done, but we're going to assume
 
235
         * that if it's not at the power-on location, it's where we put
 
236
         * it last time. (huber)
 
237
         */
 
238
 
 
239
        my_remap_gt_regs (CONFIG_SYS_DFL_GT_REGS, CONFIG_SYS_GT_REGS);
 
240
 
 
241
        /* No PCI in first release of Port To_do: enable it. */
 
242
#ifdef CONFIG_PCI
 
243
        gt_pci_config ();
 
244
#endif
 
245
        /* mask all external interrupt sources */
 
246
        GT_REG_WRITE (CPU_INTERRUPT_MASK_REGISTER_LOW, 0);
 
247
        GT_REG_WRITE (CPU_INTERRUPT_MASK_REGISTER_HIGH, 0);
 
248
        /* new in MV6446x */
 
249
        GT_REG_WRITE (CPU_INTERRUPT_1_MASK_REGISTER_LOW, 0);
 
250
        GT_REG_WRITE (CPU_INTERRUPT_1_MASK_REGISTER_HIGH, 0);
 
251
        /* --------------------- */
 
252
        GT_REG_WRITE (PCI_0INTERRUPT_CAUSE_MASK_REGISTER_LOW, 0);
 
253
        GT_REG_WRITE (PCI_0INTERRUPT_CAUSE_MASK_REGISTER_HIGH, 0);
 
254
        GT_REG_WRITE (PCI_1INTERRUPT_CAUSE_MASK_REGISTER_LOW, 0);
 
255
        GT_REG_WRITE (PCI_1INTERRUPT_CAUSE_MASK_REGISTER_HIGH, 0);
 
256
        /* does not exist in MV6446x
 
257
           GT_REG_WRITE(CPU_INT_0_MASK, 0);
 
258
           GT_REG_WRITE(CPU_INT_1_MASK, 0);
 
259
           GT_REG_WRITE(CPU_INT_2_MASK, 0);
 
260
           GT_REG_WRITE(CPU_INT_3_MASK, 0);
 
261
           --------------------- */
 
262
 
 
263
 
 
264
        /* ----- DEVICE BUS SETTINGS ------ */
 
265
 
 
266
        /*
 
267
         * EVB
 
268
         * 0 - SRAM   ????
 
269
         * 1 - RTC      ????
 
270
         * 2 - UART     ????
 
271
         * 3 - Flash    checked 32Bit Intel Strata
 
272
         * boot - BootCS checked 8Bit 29LV040B
 
273
         *
 
274
         * Zuma
 
275
         * 0 - Flash
 
276
         * boot - BootCS
 
277
         */
 
278
 
 
279
        /*
 
280
         * the dual 7450 module requires burst access to the boot
 
281
         * device, so the serial rom copies the boot device to the
 
282
         * on-board sram on the eval board, and updates the correct
 
283
         * registers to boot from the sram. (device0)
 
284
         */
 
285
        if (memoryGetDeviceBaseAddress (DEVICE0) == CONFIG_SYS_DFL_BOOTCS_BASE)
 
286
                sram_boot = 1;
 
287
        if (!sram_boot)
 
288
                memoryMapDeviceSpace (DEVICE0, CONFIG_SYS_DEV0_SPACE, CONFIG_SYS_DEV0_SIZE);
 
289
 
 
290
        memoryMapDeviceSpace (DEVICE1, CONFIG_SYS_DEV1_SPACE, CONFIG_SYS_DEV1_SIZE);
 
291
        memoryMapDeviceSpace (DEVICE2, CONFIG_SYS_DEV2_SPACE, CONFIG_SYS_DEV2_SIZE);
 
292
        memoryMapDeviceSpace (DEVICE3, CONFIG_SYS_DEV3_SPACE, CONFIG_SYS_DEV3_SIZE);
 
293
 
 
294
 
 
295
        /* configure device timing */
 
296
#ifdef CONFIG_SYS_DEV0_PAR              /* set port parameters for SRAM device module access */
 
297
        if (!sram_boot)
 
298
                GT_REG_WRITE (DEVICE_BANK0PARAMETERS, CONFIG_SYS_DEV0_PAR);
 
299
#endif
 
300
 
 
301
#ifdef CONFIG_SYS_DEV1_PAR              /* set port parameters for RTC device module access */
 
302
        GT_REG_WRITE (DEVICE_BANK1PARAMETERS, CONFIG_SYS_DEV1_PAR);
 
303
#endif
 
304
#ifdef CONFIG_SYS_DEV2_PAR              /* set port parameters for DUART device module access */
 
305
        GT_REG_WRITE (DEVICE_BANK2PARAMETERS, CONFIG_SYS_DEV2_PAR);
 
306
#endif
 
307
 
 
308
#ifdef CONFIG_SYS_32BIT_BOOT_PAR        /* set port parameters for Flash device module access */
 
309
        /* detect if we are booting from the 32 bit flash */
 
310
        if (GTREGREAD (DEVICE_BOOT_BANK_PARAMETERS) & (0x3 << 20)) {
 
311
                /* 32 bit boot flash */
 
312
                GT_REG_WRITE (DEVICE_BANK3PARAMETERS, CONFIG_SYS_8BIT_BOOT_PAR);
 
313
                GT_REG_WRITE (DEVICE_BOOT_BANK_PARAMETERS,
 
314
                              CONFIG_SYS_32BIT_BOOT_PAR);
 
315
        } else {
 
316
                /* 8 bit boot flash */
 
317
                GT_REG_WRITE (DEVICE_BANK3PARAMETERS, CONFIG_SYS_32BIT_BOOT_PAR);
 
318
                GT_REG_WRITE (DEVICE_BOOT_BANK_PARAMETERS, CONFIG_SYS_8BIT_BOOT_PAR);
 
319
        }
 
320
#else
 
321
        /* 8 bit boot flash only */
 
322
/*      GT_REG_WRITE(DEVICE_BOOT_BANK_PARAMETERS, CONFIG_SYS_8BIT_BOOT_PAR);*/
 
323
#endif
 
324
 
 
325
 
 
326
        gt_cpu_config ();
 
327
 
 
328
        /* MPP setup */
 
329
        GT_REG_WRITE (MPP_CONTROL0, CONFIG_SYS_MPP_CONTROL_0);
 
330
        GT_REG_WRITE (MPP_CONTROL1, CONFIG_SYS_MPP_CONTROL_1);
 
331
        GT_REG_WRITE (MPP_CONTROL2, CONFIG_SYS_MPP_CONTROL_2);
 
332
        GT_REG_WRITE (MPP_CONTROL3, CONFIG_SYS_MPP_CONTROL_3);
 
333
 
 
334
        GT_REG_WRITE (GPP_LEVEL_CONTROL, CONFIG_SYS_GPP_LEVEL_CONTROL);
 
335
        DEBUG_LED0_ON ();
 
336
        DEBUG_LED1_ON ();
 
337
        DEBUG_LED2_ON ();
 
338
 
 
339
        return 0;
 
340
}
 
341
 
 
342
/* various things to do after relocation */
 
343
 
 
344
int misc_init_r ()
 
345
{
 
346
        icache_enable ();
 
347
#ifdef CONFIG_SYS_L2
 
348
        l2cache_enable ();
 
349
#endif
 
350
#ifdef CONFIG_MPSC
 
351
 
 
352
        mpsc_sdma_init ();
 
353
        mpsc_init2 ();
 
354
#endif
 
355
 
 
356
#if 0
 
357
        /* disable the dcache and MMU */
 
358
        dcache_lock ();
 
359
#endif
 
360
        return 0;
 
361
}
 
362
 
 
363
void after_reloc (ulong dest_addr, gd_t * gd)
 
364
{
 
365
        /* check to see if we booted from the sram.  If so, move things
 
366
         * back to the way they should be. (we're running from main
 
367
         * memory at this point now */
 
368
        if (memoryGetDeviceBaseAddress (DEVICE0) == CONFIG_SYS_DFL_BOOTCS_BASE) {
 
369
                memoryMapDeviceSpace (DEVICE0, CONFIG_SYS_DEV0_SPACE, CONFIG_SYS_DEV0_SIZE);
 
370
                memoryMapDeviceSpace (BOOT_DEVICE, CONFIG_SYS_DFL_BOOTCS_BASE, _8M);
 
371
        }
 
372
        display_mem_map ();
 
373
        /* now, jump to the main ppcboot board init code */
 
374
        board_init_r (gd, dest_addr);
 
375
        /* NOTREACHED */
 
376
}
 
377
 
 
378
/* ------------------------------------------------------------------------- */
 
379
 
 
380
/*
 
381
 * Check Board Identity:
 
382
 *
 
383
 * right now, assume borad type. (there is just one...after all)
 
384
 */
 
385
 
 
386
int checkboard (void)
 
387
{
 
388
        int l_type = 0;
 
389
 
 
390
        printf ("BOARD: %s\n", CONFIG_SYS_BOARD_NAME);
 
391
        return (l_type);
 
392
}
 
393
 
 
394
/* utility functions */
 
395
void debug_led (int led, int mode)
 
396
{
 
397
        volatile int *addr = 0;
 
398
        __maybe_unused int dummy;
 
399
 
 
400
        if (mode == 1) {
 
401
                switch (led) {
 
402
                case 0:
 
403
                        addr = (int *) ((unsigned int) CONFIG_SYS_DEV1_SPACE |
 
404
                                        0x08000);
 
405
                        break;
 
406
 
 
407
                case 1:
 
408
                        addr = (int *) ((unsigned int) CONFIG_SYS_DEV1_SPACE |
 
409
                                        0x0c000);
 
410
                        break;
 
411
 
 
412
                case 2:
 
413
                        addr = (int *) ((unsigned int) CONFIG_SYS_DEV1_SPACE |
 
414
                                        0x10000);
 
415
                        break;
 
416
                }
 
417
        } else if (mode == 0) {
 
418
                switch (led) {
 
419
                case 0:
 
420
                        addr = (int *) ((unsigned int) CONFIG_SYS_DEV1_SPACE |
 
421
                                        0x14000);
 
422
                        break;
 
423
 
 
424
                case 1:
 
425
                        addr = (int *) ((unsigned int) CONFIG_SYS_DEV1_SPACE |
 
426
                                        0x18000);
 
427
                        break;
 
428
 
 
429
                case 2:
 
430
                        addr = (int *) ((unsigned int) CONFIG_SYS_DEV1_SPACE |
 
431
                                        0x1c000);
 
432
                        break;
 
433
                }
 
434
        }
 
435
 
 
436
        dummy = *addr;
 
437
}
 
438
 
 
439
int display_mem_map (void)
 
440
{
 
441
        int i, j;
 
442
        unsigned int base, size, width;
 
443
 
 
444
        /* SDRAM */
 
445
        printf ("SD (DDR) RAM\n");
 
446
        for (i = 0; i <= BANK3; i++) {
 
447
                base = memoryGetBankBaseAddress (i);
 
448
                size = memoryGetBankSize (i);
 
449
                if (size != 0) {
 
450
                        printf ("BANK%d: base - 0x%08x\tsize - %dM bytes\n",
 
451
                                i, base, size >> 20);
 
452
                }
 
453
        }
 
454
 
 
455
        /* CPU's PCI windows */
 
456
        for (i = 0; i <= PCI_HOST1; i++) {
 
457
                printf ("\nCPU's PCI %d windows\n", i);
 
458
                base = pciGetSpaceBase (i, PCI_IO);
 
459
                size = pciGetSpaceSize (i, PCI_IO);
 
460
                printf ("      IO: base - 0x%08x\tsize - %dM bytes\n", base,
 
461
                        size >> 20);
 
462
                for (j = 0;
 
463
                     j <=
 
464
                     PCI_REGION0
 
465
                     /*ronen currently only first PCI MEM is used 3 */ ;
 
466
                     j++) {
 
467
                        base = pciGetSpaceBase (i, j);
 
468
                        size = pciGetSpaceSize (i, j);
 
469
                        printf ("MEMORY %d: base - 0x%08x\tsize - %dM bytes\n", j, base, size >> 20);
 
470
                }
 
471
        }
 
472
 
 
473
        /* Devices */
 
474
        printf ("\nDEVICES\n");
 
475
        for (i = 0; i <= DEVICE3; i++) {
 
476
                base = memoryGetDeviceBaseAddress (i);
 
477
                size = memoryGetDeviceSize (i);
 
478
                width = memoryGetDeviceWidth (i) * 8;
 
479
                printf ("DEV %d:  base - 0x%08x  size - %dM bytes\twidth - %d bits", i, base, size >> 20, width);
 
480
                if (i == 0)
 
481
                        printf ("\t- EXT SRAM (actual - 1M)\n");
 
482
                else if (i == 1)
 
483
                        printf ("\t- RTC\n");
 
484
                else if (i == 2)
 
485
                        printf ("\t- UART\n");
 
486
                else
 
487
                        printf ("\t- LARGE FLASH\n");
 
488
        }
 
489
 
 
490
        /* Bootrom */
 
491
        base = memoryGetDeviceBaseAddress (BOOT_DEVICE);        /* Boot */
 
492
        size = memoryGetDeviceSize (BOOT_DEVICE);
 
493
        width = memoryGetDeviceWidth (BOOT_DEVICE) * 8;
 
494
        printf (" BOOT:  base - 0x%08x  size - %dM bytes\twidth - %d bits\n",
 
495
                base, size >> 20, width);
 
496
        return (0);
 
497
}
 
498
 
 
499
/* DRAM check routines copied from gw8260 */
 
500
 
 
501
#if defined (CONFIG_SYS_DRAM_TEST)
 
502
 
 
503
/*********************************************************************/
 
504
/* NAME:  move64() -  moves a double word (64-bit)                   */
 
505
/*                                                                   */
 
506
/* DESCRIPTION:                                                      */
 
507
/*   this function performs a double word move from the data at      */
 
508
/*   the source pointer to the location at the destination pointer.  */
 
509
/*                                                                   */
 
510
/* INPUTS:                                                           */
 
511
/*   unsigned long long *src  - pointer to data to move              */
 
512
/*                                                                   */
 
513
/* OUTPUTS:                                                          */
 
514
/*   unsigned long long *dest - pointer to locate to move data       */
 
515
/*                                                                   */
 
516
/* RETURNS:                                                          */
 
517
/*   None                                                            */
 
518
/*                                                                   */
 
519
/* RESTRICTIONS/LIMITATIONS:                                         */
 
520
/*   May cloober fr0.                                                */
 
521
/*                                                                   */
 
522
/*********************************************************************/
 
523
static void move64 (unsigned long long *src, unsigned long long *dest)
 
524
{
 
525
        asm ("lfd  0, 0(3)\n\t" /* fpr0   =  *scr       */
 
526
             "stfd 0, 0(4)"     /* *dest  =  fpr0       */
 
527
      : : : "fr0");             /* Clobbers fr0         */
 
528
        return;
 
529
}
 
530
 
 
531
 
 
532
#if defined (CONFIG_SYS_DRAM_TEST_DATA)
 
533
 
 
534
unsigned long long pattern[] = {
 
535
        0xaaaaaaaaaaaaaaaaULL,
 
536
        0xccccccccccccccccULL,
 
537
        0xf0f0f0f0f0f0f0f0ULL,
 
538
        0xff00ff00ff00ff00ULL,
 
539
        0xffff0000ffff0000ULL,
 
540
        0xffffffff00000000ULL,
 
541
        0x00000000ffffffffULL,
 
542
        0x0000ffff0000ffffULL,
 
543
        0x00ff00ff00ff00ffULL,
 
544
        0x0f0f0f0f0f0f0f0fULL,
 
545
        0x3333333333333333ULL,
 
546
        0x5555555555555555ULL,
 
547
};
 
548
 
 
549
/*********************************************************************/
 
550
/* NAME:  mem_test_data() -  test data lines for shorts and opens    */
 
551
/*                                                                   */
 
552
/* DESCRIPTION:                                                      */
 
553
/*   Tests data lines for shorts and opens by forcing adjacent data  */
 
554
/*   to opposite states. Because the data lines could be routed in   */
 
555
/*   an arbitrary manner the must ensure test patterns ensure that   */
 
556
/*   every case is tested. By using the following series of binary   */
 
557
/*   patterns every combination of adjacent bits is test regardless  */
 
558
/*   of routing.                                                     */
 
559
/*                                                                   */
 
560
/*     ...101010101010101010101010                                   */
 
561
/*     ...110011001100110011001100                                   */
 
562
/*     ...111100001111000011110000                                   */
 
563
/*     ...111111110000000011111111                                   */
 
564
/*                                                                   */
 
565
/*   Carrying this out, gives us six hex patterns as follows:        */
 
566
/*                                                                   */
 
567
/*     0xaaaaaaaaaaaaaaaa                                            */
 
568
/*     0xcccccccccccccccc                                            */
 
569
/*     0xf0f0f0f0f0f0f0f0                                            */
 
570
/*     0xff00ff00ff00ff00                                            */
 
571
/*     0xffff0000ffff0000                                            */
 
572
/*     0xffffffff00000000                                            */
 
573
/*                                                                   */
 
574
/*   The number test patterns will always be given by:               */
 
575
/*                                                                   */
 
576
/*   log(base 2)(number data bits) = log2 (64) = 6                   */
 
577
/*                                                                   */
 
578
/*   To test for short and opens to other signals on our boards. we  */
 
579
/*   simply                                                          */
 
580
/*   test with the 1's complemnt of the paterns as well.             */
 
581
/*                                                                   */
 
582
/* OUTPUTS:                                                          */
 
583
/*   Displays failing test pattern                                   */
 
584
/*                                                                   */
 
585
/* RETURNS:                                                          */
 
586
/*   0 -  Passed test                                                */
 
587
/*   1 -  Failed test                                                */
 
588
/*                                                                   */
 
589
/* RESTRICTIONS/LIMITATIONS:                                         */
 
590
/*  Assumes only one one SDRAM bank                                  */
 
591
/*                                                                   */
 
592
/*********************************************************************/
 
593
int mem_test_data (void)
 
594
{
 
595
        unsigned long long *pmem = (unsigned long long *) CONFIG_SYS_MEMTEST_START;
 
596
        unsigned long long temp64 = 0;
 
597
        int num_patterns = sizeof (pattern) / sizeof (pattern[0]);
 
598
        int i;
 
599
        unsigned int hi, lo;
 
600
 
 
601
        for (i = 0; i < num_patterns; i++) {
 
602
                move64 (&(pattern[i]), pmem);
 
603
                move64 (pmem, &temp64);
 
604
 
 
605
                /* hi = (temp64>>32) & 0xffffffff;          */
 
606
                /* lo = temp64 & 0xffffffff;                */
 
607
                /* printf("\ntemp64 = 0x%08x%08x", hi, lo); */
 
608
 
 
609
                hi = (pattern[i] >> 32) & 0xffffffff;
 
610
                lo = pattern[i] & 0xffffffff;
 
611
                /* printf("\npattern[%d] = 0x%08x%08x", i, hi, lo);  */
 
612
 
 
613
                if (temp64 != pattern[i]) {
 
614
                        printf ("\n   Data Test Failed, pattern 0x%08x%08x",
 
615
                                hi, lo);
 
616
                        return 1;
 
617
                }
 
618
        }
 
619
 
 
620
        return 0;
 
621
}
 
622
#endif /* CONFIG_SYS_DRAM_TEST_DATA */
 
623
 
 
624
#if defined (CONFIG_SYS_DRAM_TEST_ADDRESS)
 
625
/*********************************************************************/
 
626
/* NAME:  mem_test_address() -  test address lines                   */
 
627
/*                                                                   */
 
628
/* DESCRIPTION:                                                      */
 
629
/*   This function performs a test to verify that each word im       */
 
630
/*   memory is uniquly addressable. The test sequence is as follows: */
 
631
/*                                                                   */
 
632
/*   1) write the address of each word to each word.                 */
 
633
/*   2) verify that each location equals its address                 */
 
634
/*                                                                   */
 
635
/* OUTPUTS:                                                          */
 
636
/*   Displays failing test pattern and address                       */
 
637
/*                                                                   */
 
638
/* RETURNS:                                                          */
 
639
/*   0 -  Passed test                                                */
 
640
/*   1 -  Failed test                                                */
 
641
/*                                                                   */
 
642
/* RESTRICTIONS/LIMITATIONS:                                         */
 
643
/*                                                                   */
 
644
/*                                                                   */
 
645
/*********************************************************************/
 
646
int mem_test_address (void)
 
647
{
 
648
        volatile unsigned int *pmem =
 
649
                (volatile unsigned int *) CONFIG_SYS_MEMTEST_START;
 
650
        const unsigned int size = (CONFIG_SYS_MEMTEST_END - CONFIG_SYS_MEMTEST_START) / 4;
 
651
        unsigned int i;
 
652
 
 
653
        /* write address to each location */
 
654
        for (i = 0; i < size; i++) {
 
655
                pmem[i] = i;
 
656
        }
 
657
 
 
658
        /* verify each loaction */
 
659
        for (i = 0; i < size; i++) {
 
660
                if (pmem[i] != i) {
 
661
                        printf ("\n   Address Test Failed at 0x%x", i);
 
662
                        return 1;
 
663
                }
 
664
        }
 
665
        return 0;
 
666
}
 
667
#endif /* CONFIG_SYS_DRAM_TEST_ADDRESS */
 
668
 
 
669
#if defined (CONFIG_SYS_DRAM_TEST_WALK)
 
670
/*********************************************************************/
 
671
/* NAME:   mem_march() -  memory march                               */
 
672
/*                                                                   */
 
673
/* DESCRIPTION:                                                      */
 
674
/*   Marches up through memory. At each location verifies rmask if   */
 
675
/*   read = 1. At each location write wmask if  write = 1. Displays  */
 
676
/*   failing address and pattern.                                    */
 
677
/*                                                                   */
 
678
/* INPUTS:                                                           */
 
679
/*   volatile unsigned long long * base - start address of test      */
 
680
/*   unsigned int size - number of dwords(64-bit) to test            */
 
681
/*   unsigned long long rmask - read verify mask                     */
 
682
/*   unsigned long long wmask - wrtie verify mask                    */
 
683
/*   short read - verifies rmask if read = 1                         */
 
684
/*   short write  - writes wmask if write = 1                        */
 
685
/*                                                                   */
 
686
/* OUTPUTS:                                                          */
 
687
/*   Displays failing test pattern and address                       */
 
688
/*                                                                   */
 
689
/* RETURNS:                                                          */
 
690
/*   0 -  Passed test                                                */
 
691
/*   1 -  Failed test                                                */
 
692
/*                                                                   */
 
693
/* RESTRICTIONS/LIMITATIONS:                                         */
 
694
/*                                                                   */
 
695
/*                                                                   */
 
696
/*********************************************************************/
 
697
int mem_march (volatile unsigned long long *base,
 
698
               unsigned int size,
 
699
               unsigned long long rmask,
 
700
               unsigned long long wmask, short read, short write)
 
701
{
 
702
        unsigned int i;
 
703
        unsigned long long temp = 0;
 
704
        unsigned int hitemp, lotemp, himask, lomask;
 
705
 
 
706
        for (i = 0; i < size; i++) {
 
707
                if (read != 0) {
 
708
                        /* temp = base[i]; */
 
709
                        move64 ((unsigned long long *) &(base[i]), &temp);
 
710
                        if (rmask != temp) {
 
711
                                hitemp = (temp >> 32) & 0xffffffff;
 
712
                                lotemp = temp & 0xffffffff;
 
713
                                himask = (rmask >> 32) & 0xffffffff;
 
714
                                lomask = rmask & 0xffffffff;
 
715
 
 
716
                                printf ("\n Walking one's test failed: address = 0x%08x," "\n\texpected 0x%08x%08x, found 0x%08x%08x", i << 3, himask, lomask, hitemp, lotemp);
 
717
                                return 1;
 
718
                        }
 
719
                }
 
720
                if (write != 0) {
 
721
                        /*  base[i] = wmask; */
 
722
                        move64 (&wmask, (unsigned long long *) &(base[i]));
 
723
                }
 
724
        }
 
725
        return 0;
 
726
}
 
727
#endif /* CONFIG_SYS_DRAM_TEST_WALK */
 
728
 
 
729
/*********************************************************************/
 
730
/* NAME:   mem_test_walk() -  a simple walking ones test             */
 
731
/*                                                                   */
 
732
/* DESCRIPTION:                                                      */
 
733
/*   Performs a walking ones through entire physical memory. The     */
 
734
/*   test uses as series of memory marches, mem_march(), to verify   */
 
735
/*   and write the test patterns to memory. The test sequence is as  */
 
736
/*   follows:                                                        */
 
737
/*     1) march writing 0000...0001                                  */
 
738
/*     2) march verifying 0000...0001  , writing  0000...0010        */
 
739
/*     3) repeat step 2 shifting masks left 1 bit each time unitl    */
 
740
/*         the write mask equals 1000...0000                         */
 
741
/*     4) march verifying 1000...0000                                */
 
742
/*   The test fails if any of the memory marches return a failure.   */
 
743
/*                                                                   */
 
744
/* OUTPUTS:                                                          */
 
745
/*   Displays which pass on the memory test is executing             */
 
746
/*                                                                   */
 
747
/* RETURNS:                                                          */
 
748
/*   0 -  Passed test                                                */
 
749
/*   1 -  Failed test                                                */
 
750
/*                                                                   */
 
751
/* RESTRICTIONS/LIMITATIONS:                                         */
 
752
/*                                                                   */
 
753
/*                                                                   */
 
754
/*********************************************************************/
 
755
int mem_test_walk (void)
 
756
{
 
757
        unsigned long long mask;
 
758
        volatile unsigned long long *pmem =
 
759
                (volatile unsigned long long *) CONFIG_SYS_MEMTEST_START;
 
760
        const unsigned long size = (CONFIG_SYS_MEMTEST_END - CONFIG_SYS_MEMTEST_START) / 8;
 
761
 
 
762
        unsigned int i;
 
763
 
 
764
        mask = 0x01;
 
765
 
 
766
        printf ("Initial Pass");
 
767
        mem_march (pmem, size, 0x0, 0x1, 0, 1);
 
768
 
 
769
        printf ("\b\b\b\b\b\b\b\b\b\b\b\b");
 
770
        printf ("               ");
 
771
        printf ("         ");
 
772
        printf ("\b\b\b\b\b\b\b\b\b\b\b\b");
 
773
 
 
774
        for (i = 0; i < 63; i++) {
 
775
                printf ("Pass %2d", i + 2);
 
776
                if (mem_march (pmem, size, mask, mask << 1, 1, 1) != 0) {
 
777
                        /*printf("mask: 0x%x, pass: %d, ", mask, i); */
 
778
                        return 1;
 
779
                }
 
780
                mask = mask << 1;
 
781
                printf ("\b\b\b\b\b\b\b");
 
782
        }
 
783
 
 
784
        printf ("Last Pass");
 
785
        if (mem_march (pmem, size, 0, mask, 0, 1) != 0) {
 
786
                /* printf("mask: 0x%x", mask); */
 
787
                return 1;
 
788
        }
 
789
        printf ("\b\b\b\b\b\b\b\b\b");
 
790
        printf ("            ");
 
791
        printf ("\b\b\b\b\b\b\b\b\b");
 
792
 
 
793
        return 0;
 
794
}
 
795
 
 
796
/*********************************************************************/
 
797
/* NAME:    testdram() -  calls any enabled memory tests             */
 
798
/*                                                                   */
 
799
/* DESCRIPTION:                                                      */
 
800
/*   Runs memory tests if the environment test variables are set to  */
 
801
/*   'y'.                                                            */
 
802
/*                                                                   */
 
803
/* INPUTS:                                                           */
 
804
/*   testdramdata    - If set to 'y', data test is run.              */
 
805
/*   testdramaddress - If set to 'y', address test is run.           */
 
806
/*   testdramwalk    - If set to 'y', walking ones test is run       */
 
807
/*                                                                   */
 
808
/* OUTPUTS:                                                          */
 
809
/*   None                                                            */
 
810
/*                                                                   */
 
811
/* RETURNS:                                                          */
 
812
/*   0 -  Passed test                                                */
 
813
/*   1 -  Failed test                                                */
 
814
/*                                                                   */
 
815
/* RESTRICTIONS/LIMITATIONS:                                         */
 
816
/*                                                                   */
 
817
/*                                                                   */
 
818
/*********************************************************************/
 
819
int testdram (void)
 
820
{
 
821
        int rundata, runaddress, runwalk;
 
822
 
 
823
        rundata = getenv_yesno("testdramdata") == 1;
 
824
        runaddress = getenv_yesno("testdramaddress") == 1;
 
825
        runwalk = getenv_yesno("testdramwalk") == 1;
 
826
 
 
827
/*    rundata = 1; */
 
828
/*    runaddress = 0; */
 
829
/*    runwalk = 0; */
 
830
 
 
831
        if ((rundata == 1) || (runaddress == 1) || (runwalk == 1)) {
 
832
                printf ("Testing RAM from 0x%08x to 0x%08x ...  (don't panic... that will take a moment !!!!)\n", CONFIG_SYS_MEMTEST_START, CONFIG_SYS_MEMTEST_END);
 
833
        }
 
834
#ifdef CONFIG_SYS_DRAM_TEST_DATA
 
835
        if (rundata == 1) {
 
836
                printf ("Test DATA ...  ");
 
837
                if (mem_test_data () == 1) {
 
838
                        printf ("failed \n");
 
839
                        return 1;
 
840
                } else
 
841
                        printf ("ok \n");
 
842
        }
 
843
#endif
 
844
#ifdef CONFIG_SYS_DRAM_TEST_ADDRESS
 
845
        if (runaddress == 1) {
 
846
                printf ("Test ADDRESS ...  ");
 
847
                if (mem_test_address () == 1) {
 
848
                        printf ("failed \n");
 
849
                        return 1;
 
850
                } else
 
851
                        printf ("ok \n");
 
852
        }
 
853
#endif
 
854
#ifdef CONFIG_SYS_DRAM_TEST_WALK
 
855
        if (runwalk == 1) {
 
856
                printf ("Test WALKING ONEs ...  ");
 
857
                if (mem_test_walk () == 1) {
 
858
                        printf ("failed \n");
 
859
                        return 1;
 
860
                } else
 
861
                        printf ("ok \n");
 
862
        }
 
863
#endif
 
864
        if ((rundata == 1) || (runaddress == 1) || (runwalk == 1)) {
 
865
                printf ("passed\n");
 
866
        }
 
867
        return 0;
 
868
 
 
869
}
 
870
#endif /* CONFIG_SYS_DRAM_TEST */
 
871
 
 
872
/* ronen - the below functions are used by the bootm function           */
 
873
/*  - we map the base register to fbe00000 (same mapping as in the LSP) */
 
874
/*  - we turn off the RX gig dmas - to prevent the dma from overunning  */
 
875
/*    the kernel data areas.                                            */
 
876
/*  - we diable and invalidate the icache and dcache.                   */
 
877
void my_remap_gt_regs_bootm (u32 cur_loc, u32 new_loc)
 
878
{
 
879
        u32 temp;
 
880
 
 
881
        temp = in_le32 ((u32 *) (new_loc + INTERNAL_SPACE_DECODE));
 
882
        if ((temp & 0xffff) == new_loc >> 16)
 
883
                return;
 
884
 
 
885
        temp = (in_le32 ((u32 *) (cur_loc + INTERNAL_SPACE_DECODE)) &
 
886
                0xffff0000) | (new_loc >> 16);
 
887
 
 
888
        out_le32 ((u32 *) (cur_loc + INTERNAL_SPACE_DECODE), temp);
 
889
 
 
890
        while ((WORD_SWAP (*((volatile unsigned int *) (NONE_CACHEABLE |
 
891
                                                        new_loc |
 
892
                                                        (INTERNAL_SPACE_DECODE)))))
 
893
               != temp);
 
894
 
 
895
}
 
896
 
 
897
void board_prebootm_init ()
 
898
{
 
899
 
 
900
/* change window size of PCI1 IO in order tp prevent overlaping with REG BASE. */
 
901
                GT_REG_WRITE (PCI_1_IO_SIZE, (_64K - 1) >> 16);
 
902
 
 
903
/* Stop GigE Rx DMA engines */
 
904
        GT_REG_WRITE (MV64460_ETH_RECEIVE_QUEUE_COMMAND_REG (0), 0x0000ff00);
 
905
        GT_REG_WRITE (MV64460_ETH_RECEIVE_QUEUE_COMMAND_REG (1), 0x0000ff00);
 
906
        GT_REG_WRITE (MV64460_ETH_RECEIVE_QUEUE_COMMAND_REG (2), 0x0000ff00);
 
907
 
 
908
/* Relocate MV64460 internal regs */
 
909
        my_remap_gt_regs_bootm (CONFIG_SYS_GT_REGS, BRIDGE_REG_BASE_BOOTM);
 
910
 
 
911
        icache_disable ();
 
912
        dcache_disable ();
 
913
}
 
914
 
 
915
int board_eth_init(bd_t *bis)
 
916
{
 
917
        int ret;
 
918
        ret = pci_eth_init(bis);
 
919
        if (!ret)
 
920
                ret = mv6446x_eth_initialize(bis);
 
921
        return ret;
 
922
}