source: SVN/rincon/u-boot/board/hymod/bsp.c @ 55

Last change on this file since 55 was 55, checked in by Tim Harvey, 22 months ago

rincon: added latest u-boot source

restored form server backup

Signed-off-by: Tim Harvey <tharvey@…>

File size: 9.8 KB
Line 
1/*
2 * (C) Copyright 2000
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4 *
5 * See file CREDITS for list of people who contributed to this
6 * project.
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation; either version 2 of
11 * the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21 * MA 02111-1307 USA
22 *
23 * hacked for Hymod FPGA support by Murray.Jensen@csiro.au, 29-Jan-01
24 */
25
26#include <common.h>
27#include <command.h>
28#include <net.h>
29#include <asm/iopin_8260.h>
30
31DECLARE_GLOBAL_DATA_PTR;
32
33/*-----------------------------------------------------------------------
34 * Board Special Commands: FPGA load/store, EEPROM erase
35 */
36
37#if defined(CONFIG_CMD_BSP)
38
39#define LOAD_SUCCESS            0
40#define LOAD_FAIL_NOCONF        1
41#define LOAD_FAIL_NOINIT        2
42#define LOAD_FAIL_NODONE        3
43
44#define STORE_SUCCESS           0
45
46/*
47 * Programming the Hymod FPGAs
48 *
49 * The 8260 io port config table is set up so that the INIT pin is
50 * held Low (Open Drain output 0) - this will delay the automatic
51 * Power-On config until INIT is released (by making it an input).
52 *
53 * If the FPGA has been programmed before, then the assertion of PROGRAM
54 * will initiate configuration (i.e. it begins clearing the RAM).
55 *
56 * When the FPGA is ready to receive configuration data (either after
57 * releasing INIT after Power-On, or after asserting PROGRAM), it will
58 * pull INIT high.
59 *
60 * Notes from Paul Dunn:
61 *
62 *  1. program pin should be forced low for >= 300ns
63 *     (about 20 bus clock cycles minimum).
64 *
65 *  2. then wait for init to go high, which signals
66 *     that the FPGA has cleared its internal memory
67 *     and is ready to load
68 *
69 *  3. perform load writes of entire config file
70 *
71 *  4. wait for done to go high, which should be
72 *     within a few bus clock cycles. If done has not
73 *     gone high after reasonable period, then load
74 *     has not worked (wait several ms?)
75 */
76
77int
78fpga_load (int mezz, uchar *addr, ulong size)
79{
80        hymod_conf_t *cp = &gd->bd->bi_hymod_conf;
81        xlx_info_t *fp;
82        xlx_iopins_t *fpgaio;
83        volatile uchar *fpgabase;
84        volatile uint cnt;
85        uchar *eaddr = addr + size;
86        int result;
87
88        if (mezz)
89                fp = &cp->mezz.xlx[0];
90        else
91                fp = &cp->main.xlx[0];
92
93        if (!fp->mmap.prog.exists)
94                return (LOAD_FAIL_NOCONF);
95
96        fpgabase = (uchar *)fp->mmap.prog.base;
97        fpgaio = &fp->iopins;
98
99        /* set enable HIGH if required */
100        if (fpgaio->enable_pin.flag)
101                iopin_set_high (&fpgaio->enable_pin);
102
103        /* ensure INIT is released (set it to be an input) */
104        iopin_set_in (&fpgaio->init_pin);
105
106        /* toggle PROG Low then High (will already be Low after Power-On) */
107        iopin_set_low (&fpgaio->prog_pin);
108        udelay (1);     /* minimum 300ns - 1usec should do it */
109        iopin_set_high (&fpgaio->prog_pin);
110
111        /* wait for INIT High */
112        cnt = 0;
113        while (!iopin_is_high (&fpgaio->init_pin))
114                if (++cnt == 10000000) {
115                        result = LOAD_FAIL_NOINIT;
116                        goto done;
117                }
118
119        /* write configuration data */
120        while (addr < eaddr)
121                *fpgabase = *addr++;
122
123        /* wait for DONE High */
124        cnt = 0;
125        while (!iopin_is_high (&fpgaio->done_pin))
126                if (++cnt == 100000000) {
127                        result = LOAD_FAIL_NODONE;
128                        goto done;
129                }
130
131        /* success */
132        result = LOAD_SUCCESS;
133
134  done:
135
136        if (fpgaio->enable_pin.flag)
137                iopin_set_low (&fpgaio->enable_pin);
138
139        return (result);
140}
141
142/* ------------------------------------------------------------------------- */
143int
144do_fpga (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
145{
146        uchar *addr, *save_addr;
147        ulong size;
148        int mezz, arg, result;
149
150        switch (argc) {
151
152        case 0:
153        case 1:
154                break;
155
156        case 2:
157                if (strcmp (argv[1], "info") == 0) {
158                        printf ("\nHymod FPGA Info...\n");
159                        printf ("\t\t\t\tAddress\t\tSize\n");
160                        printf ("\tMain Configuration:\t0x%08x\t%d\n",
161                                FPGA_MAIN_CFG_BASE, FPGA_MAIN_CFG_SIZE);
162                        printf ("\tMain Register:\t\t0x%08x\t%d\n",
163                                FPGA_MAIN_REG_BASE, FPGA_MAIN_REG_SIZE);
164                        printf ("\tMain Port:\t\t0x%08x\t%d\n",
165                                FPGA_MAIN_PORT_BASE, FPGA_MAIN_PORT_SIZE);
166                        printf ("\tMezz Configuration:\t0x%08x\t%d\n",
167                                FPGA_MEZZ_CFG_BASE, FPGA_MEZZ_CFG_SIZE);
168                        return 0;
169                }
170                break;
171
172        case 3:
173                if (strcmp (argv[1], "store") == 0) {
174                        addr = (uchar *) simple_strtoul (argv[2], NULL, 16);
175
176                        save_addr = addr;
177#if 0
178                        /* fpga readback unimplemented */
179                        while (more readback data)
180                                *addr++ = *fpga;
181                        result = error ? STORE_FAIL_XXX : STORE_SUCCESS;
182#else
183                        result = STORE_SUCCESS;
184#endif
185
186                        if (result == STORE_SUCCESS) {
187                                printf ("SUCCEEDED (%d bytes)\n",
188                                        addr - save_addr);
189                                return 0;
190                        } else
191                                printf ("FAILED (%d bytes)\n",
192                                        addr - save_addr);
193                        return 1;
194                }
195                break;
196
197        case 4:
198                if (strcmp (argv[1], "tftp") == 0) {
199                        copy_filename (BootFile, argv[2], sizeof (BootFile));
200                        load_addr = simple_strtoul (argv[3], NULL, 16);
201                        NetBootFileXferSize = 0;
202
203                        if (NetLoop (TFTP) <= 0) {
204                                printf ("tftp transfer failed - aborting "
205                                        "fgpa load\n");
206                                return 1;
207                        }
208
209                        if (NetBootFileXferSize == 0) {
210                                printf ("can't determine file size - "
211                                        "aborting fpga load\n");
212                                return 1;
213                        }
214
215                        printf ("File transfer succeeded - "
216                                "beginning fpga load...");
217
218                        result = fpga_load (0, (uchar *) load_addr,
219                                NetBootFileXferSize);
220
221                        if (result == LOAD_SUCCESS) {
222                                printf ("SUCCEEDED\n");
223                                return 0;
224                        } else if (result == LOAD_FAIL_NOCONF)
225                                printf ("FAILED (no CONF)\n");
226                        else if (result == LOAD_FAIL_NOINIT)
227                                printf ("FAILED (no INIT)\n");
228                        else
229                                printf ("FAILED (no DONE)\n");
230                        return 1;
231
232                }
233                /* fall through ... */
234
235        case 5:
236                if (strcmp (argv[1], "load") == 0) {
237                        if (argc == 5) {
238                                if (strcmp (argv[2], "main") == 0)
239                                        mezz = 0;
240                                else if (strcmp (argv[2], "mezz") == 0)
241                                        mezz = 1;
242                                else {
243                                        printf ("FPGA type must be either "
244                                                "`main' or `mezz'\n");
245                                        return 1;
246                                }
247                                arg = 3;
248                        } else {
249                                mezz = 0;
250                                arg = 2;
251                        }
252
253                        addr = (uchar *) simple_strtoul (argv[arg++], NULL, 16);
254                        size = (ulong) simple_strtoul (argv[arg], NULL, 16);
255
256                        result = fpga_load (mezz, addr, size);
257
258                        if (result == LOAD_SUCCESS) {
259                                printf ("SUCCEEDED\n");
260                                return 0;
261                        } else if (result == LOAD_FAIL_NOCONF)
262                                printf ("FAILED (no CONF)\n");
263                        else if (result == LOAD_FAIL_NOINIT)
264                                printf ("FAILED (no INIT)\n");
265                        else
266                                printf ("FAILED (no DONE)\n");
267                        return 1;
268                }
269                break;
270
271        default:
272                break;
273        }
274
275        printf ("Usage:\n%s\n", cmdtp->usage);
276        return 1;
277}
278U_BOOT_CMD(
279        fpga,   6,      1,      do_fpga,
280        "fpga    - FPGA sub-system\n",
281        "load [type] addr size\n"
282        "  - write the configuration data at memory address `addr',\n"
283        "    size `size' bytes, into the FPGA of type `type' (either\n"
284        "    `main' or `mezz', default `main'). e.g.\n"
285        "        `fpga load 100000 7d8f'\n"
286        "    loads the main FPGA with config data at address 100000\n"
287        "    HEX, size 7d8f HEX (32143 DEC) bytes\n"
288        "fpga tftp file addr\n"
289        "  - transfers `file' from the tftp server into memory at\n"
290        "    address `addr', then writes the entire file contents\n"
291        "    into the main FPGA\n"
292        "fpga store addr\n"
293        "  - read configuration data from the main FPGA (the mezz\n"
294        "    FPGA is write-only), into address `addr'. There must be\n"
295        "    enough memory available at `addr' to hold all the config\n"
296        "    data - the size of which is determined by VC:???\n"
297        "fpga info\n"
298        "  - print information about the Hymod FPGA, namely the\n"
299        "    memory addresses at which the four FPGA local bus\n"
300        "    address spaces appear in the physical address space\n"
301);
302/* ------------------------------------------------------------------------- */
303int
304do_eecl (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
305{
306        uchar data[HYMOD_EEPROM_SIZE];
307        uint addr = CFG_I2C_EEPROM_ADDR;
308
309        switch (argc) {
310
311        case 1:
312                addr |= HYMOD_EEOFF_MAIN;
313                break;
314
315        case 2:
316                if (strcmp (argv[1], "main") == 0) {
317                        addr |= HYMOD_EEOFF_MAIN;
318                        break;
319                }
320                if (strcmp (argv[1], "mezz") == 0) {
321                        addr |= HYMOD_EEOFF_MEZZ;
322                        break;
323                }
324                /* fall through ... */
325
326        default:
327                printf ("Usage:\n%s\n", cmdtp->usage);
328                return 1;
329        }
330
331        memset (data, 0, HYMOD_EEPROM_SIZE);
332
333        eeprom_write (addr, 0, data, HYMOD_EEPROM_SIZE);
334
335        return 0;
336}
337U_BOOT_CMD(
338        eeclear,        1,      0,      do_eecl,
339        "eeclear - Clear the eeprom on a Hymod board \n",
340        "[type]\n"
341        "  - write zeroes into the EEPROM on the board of type `type'\n"
342        "    (`type' is either `main' or `mezz' - default `main')\n"
343        "    Note: the EEPROM write enable jumper must be installed\n"
344);
345
346/* ------------------------------------------------------------------------- */
347
348int
349do_htest (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
350{
351#if 0
352        int rc;
353#endif
354#ifdef CONFIG_ETHER_LOOPBACK_TEST
355        extern void eth_loopback_test (void);
356#endif /* CONFIG_ETHER_LOOPBACK_TEST */
357
358        printf ("HYMOD tests - ensure loopbacks etc. are connected\n\n");
359
360#if 0
361        /* Load FPGA with test program */
362
363        printf ("Loading test FPGA program ...");
364
365        rc = fpga_load (0, test_bitfile, sizeof (test_bitfile));
366
367        switch (rc) {
368
369        case LOAD_SUCCESS:
370                printf (" SUCCEEDED\n");
371                break;
372
373        case LOAD_FAIL_NOCONF:
374                printf (" FAILED (no configuration space defined)\n");
375                return 1;
376
377        case LOAD_FAIL_NOINIT:
378                printf (" FAILED (timeout - no INIT signal seen)\n");
379                return 1;
380
381        case LOAD_FAIL_NODONE:
382                printf (" FAILED (timeout - no DONE signal seen)\n");
383                return 1;
384
385        default:
386                printf (" FAILED (unknown return code from fpga_load\n");
387                return 1;
388        }
389
390        /* run Local Bus <=> Xilinx tests */
391
392        /* tell Xilinx to run ZBT Ram, High Speed serial and Mezzanine tests */
393
394        /* run SDRAM test */
395#endif
396
397#ifdef CONFIG_ETHER_LOOPBACK_TEST
398        /* run Ethernet test */
399        eth_loopback_test ();
400#endif /* CONFIG_ETHER_LOOPBACK_TEST */
401
402        return 0;
403}
404
405#endif
Note: See TracBrowser for help on using the repository browser.