URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [bootloaders/] [orpmon/] [cmds/] [memory.c] - Blame information for rev 574

Go to most recent revision | Details | Compare with Previous | View Log


#include "common.h"
#include "support.h"
#include "spr-defs.h"
 
void show_mem(int start, int stop)
{
        unsigned long i = start;
        if ((i & 0xf) != 0x0)
                printf("\n%08lx: ", i);
        for (; i <= stop; i += 4) {
                if ((i & 0xf) == 0x0)
                        printf("\n%08lx: ", i);
                /* Read one word */
                printf("%08lx ", REG32(i));
        }
        printf("\n");
}
 
void testram(unsigned long start_addr, unsigned long stop_addr,
             unsigned long testno)
{
        unsigned long addr;
        unsigned long err_addr = 0;
        unsigned long err_no = 0;
 
        unsigned long stack_top = (unsigned long) &_stack_top;
 
        if (start_addr < stack_top)
        {
                printf("\n");
                printf("Warning: RAM test will overwrite stack.\n");
                printf("         Moving start of test to 0x%08x to avoid stack\n",
                       stack_top);
                start_addr = stack_top;
        }
 
        if (start_addr >= stop_addr)
        {
                printf("ram_test: Start of test must be after end (0x%08x !< 0x%08x)\n",
                       start_addr, stop_addr);
                printf("ram_test: Aborting.\n");
                return;
        }
 
        /* Test 1: Write locations with their addresses */
        if ((testno == 1) || (testno == 0)) {
                printf("\n1. Writing locations with their addresses: ");
                for (addr = start_addr; addr <= stop_addr; addr += 4)
                        REG32(addr) = addr;
 
                /* Verify */
                for (addr = start_addr; addr <= stop_addr; addr += 4)
                        if (REG32(addr) != addr) {
                                err_no++;
                                err_addr = addr;
                        }
                if (err_no)
                        printf("%04lx times failed. Last at location %08lx",
                               err_no, err_addr);
                else
                        printf("Passed");
                err_no = 0;
        }
 
        /* Test 2: Write locations with their inverse address */
        if ((testno == 2) || (testno == 0)) {
                printf("\n2. Writing locations with their inverse addresses: ");
                for (addr = start_addr; addr <= stop_addr; addr += 4)
                        REG32(addr) = ~addr;
 
                /* Verify */
                for (addr = start_addr; addr <= stop_addr; addr += 4)
                        if (REG32(addr) != ~addr) {
                                err_no++;
                                err_addr = addr;
                        }
                if (err_no)
                        printf("%04lx times failed. Last at location %08lx",
                               err_no, err_addr);
                else
                        printf("Passed");
                err_no = 0;
        }
 
        /* Test 3: Write locations with walking ones */
        if ((testno == 3) || (testno == 0)) {
                printf("\n3. Writing locations with walking ones: ");
                for (addr = start_addr; addr <= stop_addr; addr += 4)
                        REG32(addr) = 1 << (addr >> 2);
 
                /* Verify */
                for (addr = start_addr; addr <= stop_addr; addr += 4)
                        if (REG32(addr) != (1 << (addr >> 2))) {
                                err_no++;
                                err_addr = addr;
                        }
                if (err_no)
                        printf("%04lx times failed. Last at location %08lx",
                               err_no, err_addr);
                else
                        printf("Passed");
                err_no = 0;
        }
 
        /* Test 4: Write locations with walking zeros */
        if ((testno == 4) || (testno == 0)) {
                printf("\n4. Writing locations with walking zeros: ");
                for (addr = start_addr; addr <= stop_addr; addr += 4)
                        REG32(addr) = ~(1 << (addr >> 2));
 
                /* Verify */
                for (addr = start_addr; addr <= stop_addr; addr += 4)
                        if (REG32(addr) != ~(1 << (addr >> 2))) {
                                err_no++;
                                err_addr = addr;
                        }
                if (err_no)
                        printf("%04lx times failed. Last at location %08lx",
                               err_no, err_addr);
                else
                        printf("Passed");
                err_no = 0;
        }
}
 
// Do proper walking 0 as byte writes
void better_ram_test(unsigned long start_addr, unsigned long stop_addr,
                     unsigned test_no)
{
        unsigned long addr;
        unsigned long err_addr = 0;
        unsigned long err_no = 0;
        int b;
        printf("\nSetting memory contents to all 1'b1  ");
        for (addr = start_addr; addr <= stop_addr; addr += 1)
                REG8(addr) = 0xff;
        printf("\rVerifying memory contents all set to 1'b1:  ");
        /* Verify */
        for (addr = start_addr; addr <= stop_addr; addr += 1) {
                if (REG8(addr) != 0xff) {
                        err_no++;
                        err_addr = addr;
                        printf("\n%04lx times failed. Last at location %08lx  ",
                               err_no, err_addr);
                }
        }
 
        if (err_no == 0)
                printf("Passed");
        else
                printf("Finished");
 
        err_no = 0;
 
        printf("\nWalking zero through memory, verify just itself: ");
        for (addr = start_addr; addr <= stop_addr; addr += 1) {
                for (b = 0; b < 8; b++) {
                        // Write, verify
                        REG8(addr) = ~(1 << b);
 
                        if (REG8(addr) != ~(1 << b)) {
                                err_no++;
                                err_addr = addr;
                                printf
                                    ("\n%04lx times failed. Last at location %08lx",
                                     err_no, err_addr);
                        }
                        REG8(addr) = 0xff;
                }
        }
        if (err_no == 0)
                printf("Passed");
        else
                printf("Finished");
        err_no = 0;
 
        printf("\nWriting across rows, row size configured as %d bytes",
               SDRAM_ROW_SIZE);
        unsigned long start_row = start_addr / SDRAM_ROW_SIZE;
        unsigned long end_row = stop_addr / SDRAM_ROW_SIZE;
        for (addr = start_row; addr <= end_row; addr += 1) {
                REG32(addr * SDRAM_ROW_SIZE) = addr;
        }
 
        printf("\rVerifying row write test: ");
 
        for (addr = start_row; addr <= end_row; addr += 1) {
                if (REG32(addr * SDRAM_ROW_SIZE) != addr) {
                        err_no++;
                        err_addr = addr * SDRAM_ROW_SIZE;
                        printf
                            ("\n%04lx times failed. Last at location %08lx (row %d)",
                             err_no, err_addr, addr);
                }
        }
 
        if (err_no == 0)
                printf("Passed");
        else
                printf("Finished");
        err_no = 0;
 
}
 
int dm_cmd(int argc, char *argv[])
{
        unsigned long a1, a2;
        a1 = strtoul(argv[0], 0, 0);
        switch (argc) {
        case 1:
                show_mem(a1, a1);
                return 0;
        case 2:
                a2 = strtoul(argv[1], 0, 0);
                show_mem(a1, a2);
                return 0;
        default:
                return -1;
        }
}
 
int pm_cmd(int argc, char *argv[])
{
        unsigned long addr, stop_addr, value;
        if ((argc == 3) || (argc == 2)) {
                addr = strtoul(argv[0], 0, 0);
 
                if (argc == 2) {
                        stop_addr = strtoul(argv[0], 0, 0);
                        value = strtoul(argv[1], 0, 0);
                } else {
                        stop_addr = strtoul(argv[1], 0, 0);
                        value = strtoul(argv[2], 0, 0);
                }
 
                for (; addr <= stop_addr; addr += 4)
                        REG32(addr) = value;
 
                /*show_mem(strtoul (argv[0], 0, 0), stop_addr); */
        } else
                return -1;
        return 0;
}
 
int ram_test_cmd(int argc, char *argv[])
{
        switch (argc) {
        case 2:
                testram(strtoul(argv[0], 0, 0), strtoul(argv[1], 0, 0), 0);
                return 0;
        case 3:
                testram(strtoul(argv[0], 0, 0), strtoul(argv[1], 0, 0),
                        strtoul(argv[2], 0, 0));
                return 0;
        default:
                return -1;
        }
}
 
int better_ram_test_cmd(int argc, char *argv[])
{
        if (argc < 2)
                return -1;
 
        better_ram_test(strtoul(argv[0], 0, 0), strtoul(argv[1], 0, 0), 0);
        return 0;
}
 
unsigned long crc32(unsigned long crc, const unsigned char *buf,
                    unsigned long len)
{
        /* Create bitwise CRC table first */
        unsigned long crc_table[256];
        int i, k;
        for (i = 0; i < 256; i++) {
                unsigned long c = (unsigned long)i;
                for (k = 0; k < 8; k++)
                        c = c & 1 ? 0xedb88320 ^ (c >> 1) : c >> 1;
                crc_table[i] = c;
        }
 
        /* Calculate crc on buf */
        crc = crc ^ 0xffffffffL;
        while (len--)
                crc = crc_table[((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8);
        return crc ^ 0xffffffffL;
}
 
int crc_cmd(int argc, char *argv[])
{
        unsigned long addr = global.src_addr;
        unsigned long len = global.length;
        unsigned long init_crc = 0;
 
        switch (argc) {
        case 3:
                init_crc = strtoul(argv[2], 0, 0);
        case 2:
                len = strtoul(argv[1], 0, 0);
        case 1:
                addr = strtoul(argv[0], 0, 0);
        case 0:
                printf("CRC [%08lx-%08lx] = %08lx\n", addr, addr + len - 1,
                       crc32(init_crc, (unsigned char *)addr, len));
                return 0;
        }
        return -1;
}
 
void module_memory_init(void)
{
        register_command("dm", "<start addr> [<end addr>]",
                         "display 32-bit memory location(s)", dm_cmd);
        register_command("pm", "<addr> [<stop_addr>] <value>",
                         "patch 32-bit memory location(s)", pm_cmd);
        register_command("ram_test", "<start_addr> <stop_addr> [<test_no>]",
                         "run a simple RAM test", ram_test_cmd);
        register_command("better_ram_test", "<start_addr> <stop_addr>",
                         "run a better RAM test", better_ram_test_cmd);
 
        register_command("crc", "[<src_addr> [<length> [<init_crc>]]]",
                         "Calculates a 32-bit CRC on specified memory region",
                         crc_cmd);
}

Line No.	Rev	Author	Line
1	2	marcus.erl	`#include "common.h"`
2			`#include "support.h"`
3	246	julius	`#include "spr-defs.h"`
4	2	marcus.erl
5	406	julius	`void show_mem(int start, int stop)`
6	2	marcus.erl	`{`
7	406	julius	`unsigned long i = start;`
8			`if ((i & 0xf) != 0x0)`
9			`printf("\n%08lx: ", i);`
10			`for (; i <= stop; i += 4) {`
11			`if ((i & 0xf) == 0x0)`
12			`printf("\n%08lx: ", i);`
13			`/* Read one word */`
14			`printf("%08lx ", REG32(i));`
15			`}`
16			`printf("\n");`
17	2	marcus.erl	`}`
18
19	406	julius	`void testram(unsigned long start_addr, unsigned long stop_addr,`
20			`unsigned long testno)`
21	2	marcus.erl	`{`
22	406	julius	`unsigned long addr;`
23			`unsigned long err_addr = 0;`
24			`unsigned long err_no = 0;`
25	2	marcus.erl
26	467	julius	`unsigned long stack_top = (unsigned long) &_stack_top;`
27	464	julius
28			`if (start_addr < stack_top)`
29			`{`
30			`printf("\n");`
31			`printf("Warning: RAM test will overwrite stack.\n");`
32			`printf(" Moving start of test to 0x%08x to avoid stack\n",`
33			`stack_top);`
34			`start_addr = stack_top;`
35			`}`
36
37			`if (start_addr >= stop_addr)`
38			`{`
39			`printf("ram_test: Start of test must be after end (0x%08x !< 0x%08x)\n",`
40			`start_addr, stop_addr);`
41			`printf("ram_test: Aborting.\n");`
42			`return;`
43			`}`
44
45	406	julius	`/* Test 1: Write locations with their addresses */`
46			`if ((testno == 1) \|\| (testno == 0)) {`
47			`printf("\n1. Writing locations with their addresses: ");`
48			`for (addr = start_addr; addr <= stop_addr; addr += 4)`
49			`REG32(addr) = addr;`
50	2	marcus.erl
51	406	julius	`/* Verify */`
52			`for (addr = start_addr; addr <= stop_addr; addr += 4)`
53			`if (REG32(addr) != addr) {`
54			`err_no++;`
55			`err_addr = addr;`
56			`}`
57			`if (err_no)`
58			`printf("%04lx times failed. Last at location %08lx",`
59			`err_no, err_addr);`
60			`else`
61			`printf("Passed");`
62			`err_no = 0;`
63			`}`
64	2	marcus.erl
65	406	julius	`/* Test 2: Write locations with their inverse address */`
66			`if ((testno == 2) \|\| (testno == 0)) {`
67			`printf("\n2. Writing locations with their inverse addresses: ");`
68			`for (addr = start_addr; addr <= stop_addr; addr += 4)`
69			`REG32(addr) = ~addr;`
70	2	marcus.erl
71	406	julius	`/* Verify */`
72			`for (addr = start_addr; addr <= stop_addr; addr += 4)`
73			`if (REG32(addr) != ~addr) {`
74			`err_no++;`
75			`err_addr = addr;`
76			`}`
77			`if (err_no)`
78			`printf("%04lx times failed. Last at location %08lx",`
79			`err_no, err_addr);`
80			`else`
81			`printf("Passed");`
82			`err_no = 0;`
83			`}`
84	2	marcus.erl
85	406	julius	`/* Test 3: Write locations with walking ones */`
86			`if ((testno == 3) \|\| (testno == 0)) {`
87			`printf("\n3. Writing locations with walking ones: ");`
88			`for (addr = start_addr; addr <= stop_addr; addr += 4)`
89			`REG32(addr) = 1 << (addr >> 2);`
90	2	marcus.erl
91	406	julius	`/* Verify */`
92			`for (addr = start_addr; addr <= stop_addr; addr += 4)`
93			`if (REG32(addr) != (1 << (addr >> 2))) {`
94			`err_no++;`
95			`err_addr = addr;`
96			`}`
97			`if (err_no)`
98			`printf("%04lx times failed. Last at location %08lx",`
99			`err_no, err_addr);`
100			`else`
101			`printf("Passed");`
102			`err_no = 0;`
103			`}`
104
105			`/* Test 4: Write locations with walking zeros */`
106			`if ((testno == 4) \|\| (testno == 0)) {`
107			`printf("\n4. Writing locations with walking zeros: ");`
108			`for (addr = start_addr; addr <= stop_addr; addr += 4)`
109			`REG32(addr) = ~(1 << (addr >> 2));`
110
111			`/* Verify */`
112			`for (addr = start_addr; addr <= stop_addr; addr += 4)`
113			`if (REG32(addr) != ~(1 << (addr >> 2))) {`
114			`err_no++;`
115			`err_addr = addr;`
116			`}`
117			`if (err_no)`
118			`printf("%04lx times failed. Last at location %08lx",`
119			`err_no, err_addr);`
120			`else`
121			`printf("Passed");`
122			`err_no = 0;`
123			`}`
124	2	marcus.erl	`}`
125
126	140	julius	`// Do proper walking 0 as byte writes`
127	406	julius	`void better_ram_test(unsigned long start_addr, unsigned long stop_addr,`
128			`unsigned test_no)`
129	140	julius	`{`
130	406	julius	`unsigned long addr;`
131			`unsigned long err_addr = 0;`
132			`unsigned long err_no = 0;`
133			`int b;`
134			`printf("\nSetting memory contents to all 1'b1 ");`
135			`for (addr = start_addr; addr <= stop_addr; addr += 1)`
136			`REG8(addr) = 0xff;`
137			`printf("\rVerifying memory contents all set to 1'b1: ");`
138			`/* Verify */`
139			`for (addr = start_addr; addr <= stop_addr; addr += 1) {`
140			`if (REG8(addr) != 0xff) {`
141			`err_no++;`
142			`err_addr = addr;`
143			`printf("\n%04lx times failed. Last at location %08lx ",`
144			`err_no, err_addr);`
145			`}`
146			`}`
147	140	julius
148	406	julius	`if (err_no == 0)`
149			`printf("Passed");`
150			`else`
151			`printf("Finished");`
152
153			`err_no = 0;`
154
155			`printf("\nWalking zero through memory, verify just itself: ");`
156			`for (addr = start_addr; addr <= stop_addr; addr += 1) {`
157			`for (b = 0; b < 8; b++) {`
158			`// Write, verify`
159			`REG8(addr) = ~(1 << b);`
160
161			`if (REG8(addr) != ~(1 << b)) {`
162			`err_no++;`
163			`err_addr = addr;`
164			`printf`
165			`("\n%04lx times failed. Last at location %08lx",`
166			`err_no, err_addr);`
167			`}`
168			`REG8(addr) = 0xff;`
169			`}`
170	140	julius	`}`
171	406	julius	`if (err_no == 0)`
172			`printf("Passed");`
173			`else`
174			`printf("Finished");`
175			`err_no = 0;`
176
177			`printf("\nWriting across rows, row size configured as %d bytes",`
178			`SDRAM_ROW_SIZE);`
179			`unsigned long start_row = start_addr / SDRAM_ROW_SIZE;`
180			`unsigned long end_row = stop_addr / SDRAM_ROW_SIZE;`
181			`for (addr = start_row; addr <= end_row; addr += 1) {`
182			`REG32(addr * SDRAM_ROW_SIZE) = addr;`
183	140	julius	`}`
184	406	julius
185			`printf("\rVerifying row write test: ");`
186
187			`for (addr = start_row; addr <= end_row; addr += 1) {`
188			`if (REG32(addr * SDRAM_ROW_SIZE) != addr) {`
189			`err_no++;`
190			`err_addr = addr * SDRAM_ROW_SIZE;`
191			`printf`
192			`("\n%04lx times failed. Last at location %08lx (row %d)",`
193			`err_no, err_addr, addr);`
194			`}`
195			`}`
196
197			`if (err_no == 0)`
198			`printf("Passed");`
199			`else`
200			`printf("Finished");`
201			`err_no = 0;`
202
203	140	julius	`}`
204
205	406	julius	`int dm_cmd(int argc, char *argv[])`
206	2	marcus.erl	`{`
207	406	julius	`unsigned long a1, a2;`
208			`a1 = strtoul(argv[0], 0, 0);`
209			`switch (argc) {`
210			`case 1:`
211			`show_mem(a1, a1);`
212			`return 0;`
213			`case 2:`
214			`a2 = strtoul(argv[1], 0, 0);`
215			`show_mem(a1, a2);`
216			`return 0;`
217			`default:`
218			`return -1;`
219			`}`
220	2	marcus.erl	`}`
221
222	406	julius	`int pm_cmd(int argc, char *argv[])`
223	2	marcus.erl	`{`
224	406	julius	`unsigned long addr, stop_addr, value;`
225			`if ((argc == 3) \|\| (argc == 2)) {`
226			`addr = strtoul(argv[0], 0, 0);`
227
228			`if (argc == 2) {`
229			`stop_addr = strtoul(argv[0], 0, 0);`
230			`value = strtoul(argv[1], 0, 0);`
231			`} else {`
232			`stop_addr = strtoul(argv[1], 0, 0);`
233			`value = strtoul(argv[2], 0, 0);`
234			`}`
235
236			`for (; addr <= stop_addr; addr += 4)`
237			`REG32(addr) = value;`
238
239			`/show_mem(strtoul (argv[0], 0, 0), stop_addr); /`
240			`} else`
241			`return -1;`
242			`return 0;`
243	2	marcus.erl	`}`
244
245	406	julius	`int ram_test_cmd(int argc, char *argv[])`
246	2	marcus.erl	`{`
247	406	julius	`switch (argc) {`
248			`case 2:`
249			`testram(strtoul(argv[0], 0, 0), strtoul(argv[1], 0, 0), 0);`
250			`return 0;`
251			`case 3:`
252			`testram(strtoul(argv[0], 0, 0), strtoul(argv[1], 0, 0),`
253			`strtoul(argv[2], 0, 0));`
254			`return 0;`
255			`default:`
256			`return -1;`
257			`}`
258	2	marcus.erl	`}`
259
260	406	julius	`int better_ram_test_cmd(int argc, char *argv[])`
261	140	julius	`{`
262	406	julius	`if (argc < 2)`
263			`return -1;`
264
265			`better_ram_test(strtoul(argv[0], 0, 0), strtoul(argv[1], 0, 0), 0);`
266			`return 0;`
267	140	julius	`}`
268
269	406	julius	`unsigned long crc32(unsigned long crc, const unsigned char *buf,`
270			`unsigned long len)`
271	2	marcus.erl	`{`
272	406	julius	`/* Create bitwise CRC table first */`
273			`unsigned long crc_table[256];`
274			`int i, k;`
275			`for (i = 0; i < 256; i++) {`
276			`unsigned long c = (unsigned long)i;`
277			`for (k = 0; k < 8; k++)`
278			`c = c & 1 ? 0xedb88320 ^ (c >> 1) : c >> 1;`
279			`crc_table[i] = c;`
280			`}`
281	2	marcus.erl
282	406	julius	`/* Calculate crc on buf */`
283			`crc = crc ^ 0xffffffffL;`
284			`while (len--)`
285			`crc = crc_table[((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8);`
286			`return crc ^ 0xffffffffL;`
287	2	marcus.erl	`}`
288
289	406	julius	`int crc_cmd(int argc, char *argv[])`
290	2	marcus.erl	`{`
291	406	julius	`unsigned long addr = global.src_addr;`
292			`unsigned long len = global.length;`
293			`unsigned long init_crc = 0;`
294
295			`switch (argc) {`
296			`case 3:`
297			`init_crc = strtoul(argv[2], 0, 0);`
298			`case 2:`
299			`len = strtoul(argv[1], 0, 0);`
300			`case 1:`
301			`addr = strtoul(argv[0], 0, 0);`
302			`case 0:`
303			`printf("CRC [%08lx-%08lx] = %08lx\n", addr, addr + len - 1,`
304			`crc32(init_crc, (unsigned char *)addr, len));`
305			`return 0;`
306			`}`
307			`return -1;`
308	2	marcus.erl	`}`
309
310	406	julius	`void module_memory_init(void)`
311	2	marcus.erl	`{`
312	406	julius	`register_command("dm", "<start addr> [<end addr>]",`
313			`"display 32-bit memory location(s)", dm_cmd);`
314			`register_command("pm", "<addr> [<stop_addr>] <value>",`
315			`"patch 32-bit memory location(s)", pm_cmd);`
316			`register_command("ram_test", "<start_addr> <stop_addr> [<test_no>]",`
317			`"run a simple RAM test", ram_test_cmd);`
318			`register_command("better_ram_test", "<start_addr> <stop_addr>",`
319			`"run a better RAM test", better_ram_test_cmd);`
320	140	julius
321	406	julius	`register_command("crc", "[<src_addr> [<length> [<init_crc>]]]",`
322			`"Calculates a 32-bit CRC on specified memory region",`
323			`crc_cmd);`
324	2	marcus.erl	`}`

Browse

Tools

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [bootloaders/] [orpmon/] [cmds/] [memory.c] - Blame information for rev 574