]> git.sur5r.net Git - u-boot/blob - drivers/fpga/virtex2.c
TI ARMv7: Don't use GD before crt0.S has set it
[u-boot] / drivers / fpga / virtex2.c
1 /*
2  * (C) Copyright 2002
3  * Rich Ireland, Enterasys Networks, rireland@enterasys.com.
4  * Keith Outwater, keith_outwater@mvis.com
5  *
6  * SPDX-License-Identifier:     GPL-2.0+
7  */
8
9 /*
10  * Configuration support for Xilinx Virtex2 devices.  Based
11  * on spartan2.c (Rich Ireland, rireland@enterasys.com).
12  */
13
14 #include <common.h>
15 #include <virtex2.h>
16
17 #if 0
18 #define FPGA_DEBUG
19 #endif
20
21 #ifdef  FPGA_DEBUG
22 #define PRINTF(fmt,args...)     printf (fmt ,##args)
23 #else
24 #define PRINTF(fmt,args...)
25 #endif
26
27 /*
28  * If the SelectMap interface can be overrun by the processor, define
29  * CONFIG_SYS_FPGA_CHECK_BUSY and/or CONFIG_FPGA_DELAY in the board configuration
30  * file and add board-specific support for checking BUSY status. By default,
31  * assume that the SelectMap interface cannot be overrun.
32  */
33 #ifndef CONFIG_SYS_FPGA_CHECK_BUSY
34 #undef CONFIG_SYS_FPGA_CHECK_BUSY
35 #endif
36
37 #ifndef CONFIG_FPGA_DELAY
38 #define CONFIG_FPGA_DELAY()
39 #endif
40
41 #ifndef CONFIG_SYS_FPGA_PROG_FEEDBACK
42 #define CONFIG_SYS_FPGA_PROG_FEEDBACK
43 #endif
44
45 /*
46  * Don't allow config cycle to be interrupted
47  */
48 #ifndef CONFIG_SYS_FPGA_CHECK_CTRLC
49 #undef CONFIG_SYS_FPGA_CHECK_CTRLC
50 #endif
51
52 /*
53  * Check for errors during configuration by default
54  */
55 #ifndef CONFIG_SYS_FPGA_CHECK_ERROR
56 #define CONFIG_SYS_FPGA_CHECK_ERROR
57 #endif
58
59 /*
60  * The default timeout in mS for INIT_B to deassert after PROG_B has
61  * been deasserted. Per the latest Virtex II Handbook (page 347), the
62  * max time from PORG_B deassertion to INIT_B deassertion is 4uS per
63  * data frame for the XC2V8000.  The XC2V8000 has 2860 data frames
64  * which yields 11.44 mS.  So let's make it bigger in order to handle
65  * an XC2V1000, if anyone can ever get ahold of one.
66  */
67 #ifndef CONFIG_SYS_FPGA_WAIT_INIT
68 #define CONFIG_SYS_FPGA_WAIT_INIT       CONFIG_SYS_HZ/2 /* 500 ms */
69 #endif
70
71 /*
72  * The default timeout for waiting for BUSY to deassert during configuration.
73  * This is normally not necessary since for most reasonable configuration
74  * clock frequencies (i.e. 66 MHz or less), BUSY monitoring is unnecessary.
75  */
76 #ifndef CONFIG_SYS_FPGA_WAIT_BUSY
77 #define CONFIG_SYS_FPGA_WAIT_BUSY       CONFIG_SYS_HZ/200       /* 5 ms*/
78 #endif
79
80 /* Default timeout for waiting for FPGA to enter operational mode after
81  * configuration data has been written.
82  */
83 #ifndef CONFIG_SYS_FPGA_WAIT_CONFIG
84 #define CONFIG_SYS_FPGA_WAIT_CONFIG     CONFIG_SYS_HZ/5 /* 200 ms */
85 #endif
86
87 static int virtex2_ssm_load(xilinx_desc *desc, const void *buf, size_t bsize);
88 static int virtex2_ssm_dump(xilinx_desc *desc, const void *buf, size_t bsize);
89
90 static int virtex2_ss_load(xilinx_desc *desc, const void *buf, size_t bsize);
91 static int virtex2_ss_dump(xilinx_desc *desc, const void *buf, size_t bsize);
92
93 static int virtex2_load(xilinx_desc *desc, const void *buf, size_t bsize,
94                         bitstream_type bstype)
95 {
96         int ret_val = FPGA_FAIL;
97
98         switch (desc->iface) {
99         case slave_serial:
100                 PRINTF ("%s: Launching Slave Serial Load\n", __FUNCTION__);
101                 ret_val = virtex2_ss_load(desc, buf, bsize);
102                 break;
103
104         case slave_selectmap:
105                 PRINTF ("%s: Launching Slave Parallel Load\n", __FUNCTION__);
106                 ret_val = virtex2_ssm_load(desc, buf, bsize);
107                 break;
108
109         default:
110                 printf ("%s: Unsupported interface type, %d\n",
111                                 __FUNCTION__, desc->iface);
112         }
113         return ret_val;
114 }
115
116 static int virtex2_dump(xilinx_desc *desc, const void *buf, size_t bsize)
117 {
118         int ret_val = FPGA_FAIL;
119
120         switch (desc->iface) {
121         case slave_serial:
122                 PRINTF ("%s: Launching Slave Serial Dump\n", __FUNCTION__);
123                 ret_val = virtex2_ss_dump(desc, buf, bsize);
124                 break;
125
126         case slave_parallel:
127                 PRINTF ("%s: Launching Slave Parallel Dump\n", __FUNCTION__);
128                 ret_val = virtex2_ssm_dump(desc, buf, bsize);
129                 break;
130
131         default:
132                 printf ("%s: Unsupported interface type, %d\n",
133                                 __FUNCTION__, desc->iface);
134         }
135         return ret_val;
136 }
137
138 static int virtex2_info(xilinx_desc *desc)
139 {
140         return FPGA_SUCCESS;
141 }
142
143 /*
144  * Virtex-II Slave SelectMap configuration loader. Configuration via
145  * SelectMap is as follows:
146  * 1. Set the FPGA's PROG_B line low.
147  * 2. Set the FPGA's PROG_B line high.  Wait for INIT_B to go high.
148  * 3. Write data to the SelectMap port.  If INIT_B goes low at any time
149  *    this process, a configuration error (most likely CRC failure) has
150  *    ocurred.  At this point a status word may be read from the
151  *    SelectMap interface to determine the source of the problem (You
152  *    could, for instance, put this in your 'abort' function handler).
153  * 4. After all data has been written, test the state of the FPGA
154  *    INIT_B and DONE lines.  If both are high, configuration has
155  *    succeeded. Congratulations!
156  */
157 static int virtex2_ssm_load(xilinx_desc *desc, const void *buf, size_t bsize)
158 {
159         int ret_val = FPGA_FAIL;
160         xilinx_virtex2_slave_selectmap_fns *fn = desc->iface_fns;
161
162         PRINTF ("%s:%d: Start with interface functions @ 0x%p\n",
163                         __FUNCTION__, __LINE__, fn);
164
165         if (fn) {
166                 size_t bytecount = 0;
167                 unsigned char *data = (unsigned char *) buf;
168                 int cookie = desc->cookie;
169                 unsigned long ts;
170
171                 /* Gotta split this one up (so the stack won't blow??) */
172                 PRINTF ("%s:%d: Function Table:\n"
173                                 "  base   0x%p\n"
174                                 "  struct 0x%p\n"
175                                 "  pre    0x%p\n"
176                                 "  prog   0x%p\n"
177                                 "  init   0x%p\n"
178                                 "  error  0x%p\n",
179                                 __FUNCTION__, __LINE__,
180                                 &fn, fn, fn->pre, fn->pgm, fn->init, fn->err);
181                 PRINTF ("  clock  0x%p\n"
182                                 "  cs     0x%p\n"
183                                 "  write  0x%p\n"
184                                 "  rdata  0x%p\n"
185                                 "  wdata  0x%p\n"
186                                 "  busy   0x%p\n"
187                                 "  abort  0x%p\n"
188                                 "  post   0x%p\n\n",
189                                 fn->clk, fn->cs, fn->wr, fn->rdata, fn->wdata,
190                                 fn->busy, fn->abort, fn->post);
191
192 #ifdef CONFIG_SYS_FPGA_PROG_FEEDBACK
193                 printf ("Initializing FPGA Device %d...\n", cookie);
194 #endif
195                 /*
196                  * Run the pre configuration function if there is one.
197                  */
198                 if (*fn->pre) {
199                         (*fn->pre) (cookie);
200                 }
201
202                 /*
203                  * Assert the program line.  The minimum pulse width for
204                  * Virtex II devices is 300 nS (Tprogram parameter in datasheet).
205                  * There is no maximum value for the pulse width.  Check to make
206                  * sure that INIT_B goes low after assertion of PROG_B
207                  */
208                 (*fn->pgm) (true, true, cookie);
209                 udelay (10);
210                 ts = get_timer (0);
211                 do {
212                         if (get_timer (ts) > CONFIG_SYS_FPGA_WAIT_INIT) {
213                                 printf ("%s:%d: ** Timeout after %d ticks waiting for INIT"
214                                                 " to assert.\n", __FUNCTION__, __LINE__,
215                                                 CONFIG_SYS_FPGA_WAIT_INIT);
216                                 (*fn->abort) (cookie);
217                                 return FPGA_FAIL;
218                         }
219                 } while (!(*fn->init) (cookie));
220
221                 (*fn->pgm) (false, true, cookie);
222                 CONFIG_FPGA_DELAY ();
223                 (*fn->clk) (true, true, cookie);
224
225                 /*
226                  * Start a timer and wait for INIT_B to go high
227                  */
228                 ts = get_timer (0);
229                 do {
230                         CONFIG_FPGA_DELAY ();
231                         if (get_timer (ts) > CONFIG_SYS_FPGA_WAIT_INIT) {
232                                 printf ("%s:%d: ** Timeout after %d ticks waiting for INIT"
233                                                 " to deassert.\n", __FUNCTION__, __LINE__,
234                                                 CONFIG_SYS_FPGA_WAIT_INIT);
235                                 (*fn->abort) (cookie);
236                                 return FPGA_FAIL;
237                         }
238                 } while ((*fn->init) (cookie) && (*fn->busy) (cookie));
239
240                 (*fn->wr) (true, true, cookie);
241                 (*fn->cs) (true, true, cookie);
242
243                 udelay (10000);
244
245                 /*
246                  * Load the data byte by byte
247                  */
248                 while (bytecount < bsize) {
249 #ifdef CONFIG_SYS_FPGA_CHECK_CTRLC
250                         if (ctrlc ()) {
251                                 (*fn->abort) (cookie);
252                                 return FPGA_FAIL;
253                         }
254 #endif
255
256                         if ((*fn->done) (cookie) == FPGA_SUCCESS) {
257                             PRINTF ("%s:%d:done went active early, bytecount = %d\n",
258                                     __FUNCTION__, __LINE__, bytecount);
259                             break;
260                         }
261
262 #ifdef CONFIG_SYS_FPGA_CHECK_ERROR
263                         if ((*fn->init) (cookie)) {
264                                 printf ("\n%s:%d:  ** Error: INIT asserted during"
265                                                 " configuration\n", __FUNCTION__, __LINE__);
266                                 printf ("%d = buffer offset, %d = buffer size\n",
267                                         bytecount, bsize);
268                                 (*fn->abort) (cookie);
269                                 return FPGA_FAIL;
270                         }
271 #endif
272
273                         (*fn->wdata) (data[bytecount++], true, cookie);
274                         CONFIG_FPGA_DELAY ();
275
276                         /*
277                          * Cycle the clock pin
278                          */
279                         (*fn->clk) (false, true, cookie);
280                         CONFIG_FPGA_DELAY ();
281                         (*fn->clk) (true, true, cookie);
282
283 #ifdef CONFIG_SYS_FPGA_CHECK_BUSY
284                         ts = get_timer (0);
285                         while ((*fn->busy) (cookie)) {
286                                 if (get_timer (ts) > CONFIG_SYS_FPGA_WAIT_BUSY) {
287                                         printf ("%s:%d: ** Timeout after %d ticks waiting for"
288                                                         " BUSY to deassert\n",
289                                                         __FUNCTION__, __LINE__, CONFIG_SYS_FPGA_WAIT_BUSY);
290                                         (*fn->abort) (cookie);
291                                         return FPGA_FAIL;
292                                 }
293                         }
294 #endif
295
296 #ifdef CONFIG_SYS_FPGA_PROG_FEEDBACK
297                         if (bytecount % (bsize / 40) == 0)
298                                 putc ('.');
299 #endif
300                 }
301
302                 /*
303                  * Finished writing the data; deassert FPGA CS_B and WRITE_B signals.
304                  */
305                 CONFIG_FPGA_DELAY ();
306                 (*fn->cs) (false, true, cookie);
307                 (*fn->wr) (false, true, cookie);
308
309 #ifdef CONFIG_SYS_FPGA_PROG_FEEDBACK
310                 putc ('\n');
311 #endif
312
313                 /*
314                  * Check for successful configuration.  FPGA INIT_B and DONE should
315                  * both be high upon successful configuration.
316                  */
317                 ts = get_timer (0);
318                 ret_val = FPGA_SUCCESS;
319                 while (((*fn->done) (cookie) == FPGA_FAIL) || (*fn->init) (cookie)) {
320                         if (get_timer (ts) > CONFIG_SYS_FPGA_WAIT_CONFIG) {
321                                 printf ("%s:%d: ** Timeout after %d ticks waiting for DONE to"
322                                                 "assert and INIT to deassert\n",
323                                                 __FUNCTION__, __LINE__, CONFIG_SYS_FPGA_WAIT_CONFIG);
324                                 (*fn->abort) (cookie);
325                                 ret_val = FPGA_FAIL;
326                                 break;
327                         }
328                 }
329
330                 if (ret_val == FPGA_SUCCESS) {
331 #ifdef CONFIG_SYS_FPGA_PROG_FEEDBACK
332                         printf ("Initialization of FPGA device %d complete\n", cookie);
333 #endif
334                         /*
335                          * Run the post configuration function if there is one.
336                          */
337                         if (*fn->post) {
338                                 (*fn->post) (cookie);
339                         }
340                 } else {
341 #ifdef CONFIG_SYS_FPGA_PROG_FEEDBACK
342                         printf ("** Initialization of FPGA device %d FAILED\n",
343                                         cookie);
344 #endif
345                 }
346         } else {
347                 printf ("%s:%d: NULL Interface function table!\n",
348                                 __FUNCTION__, __LINE__);
349         }
350         return ret_val;
351 }
352
353 /*
354  * Read the FPGA configuration data
355  */
356 static int virtex2_ssm_dump(xilinx_desc *desc, const void *buf, size_t bsize)
357 {
358         int ret_val = FPGA_FAIL;
359         xilinx_virtex2_slave_selectmap_fns *fn = desc->iface_fns;
360
361         if (fn) {
362                 unsigned char *data = (unsigned char *) buf;
363                 size_t bytecount = 0;
364                 int cookie = desc->cookie;
365
366                 printf ("Starting Dump of FPGA Device %d...\n", cookie);
367
368                 (*fn->cs) (true, true, cookie);
369                 (*fn->clk) (true, true, cookie);
370
371                 while (bytecount < bsize) {
372 #ifdef CONFIG_SYS_FPGA_CHECK_CTRLC
373                         if (ctrlc ()) {
374                                 (*fn->abort) (cookie);
375                                 return FPGA_FAIL;
376                         }
377 #endif
378                         /*
379                          * Cycle the clock and read the data
380                          */
381                         (*fn->clk) (false, true, cookie);
382                         (*fn->clk) (true, true, cookie);
383                         (*fn->rdata) (&(data[bytecount++]), cookie);
384 #ifdef CONFIG_SYS_FPGA_PROG_FEEDBACK
385                         if (bytecount % (bsize / 40) == 0)
386                                 putc ('.');
387 #endif
388                 }
389
390                 /*
391                  * Deassert CS_B and cycle the clock to deselect the device.
392                  */
393                 (*fn->cs) (false, false, cookie);
394                 (*fn->clk) (false, true, cookie);
395                 (*fn->clk) (true, true, cookie);
396
397 #ifdef CONFIG_SYS_FPGA_PROG_FEEDBACK
398                 putc ('\n');
399 #endif
400                 puts ("Done.\n");
401         } else {
402                 printf ("%s:%d: NULL Interface function table!\n",
403                                 __FUNCTION__, __LINE__);
404         }
405         return ret_val;
406 }
407
408 static int virtex2_ss_load(xilinx_desc *desc, const void *buf, size_t bsize)
409 {
410         printf ("%s: Slave Serial Loading is unsupported\n", __FUNCTION__);
411         return FPGA_FAIL;
412 }
413
414 static int virtex2_ss_dump(xilinx_desc *desc, const void *buf, size_t bsize)
415 {
416         printf ("%s: Slave Serial Dumping is unsupported\n", __FUNCTION__);
417         return FPGA_FAIL;
418 }
419
420 /* vim: set ts=4 tw=78: */
421
422 struct xilinx_fpga_op virtex2_op = {
423         .load = virtex2_load,
424         .dump = virtex2_dump,
425         .info = virtex2_info,
426 };