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