]> git.sur5r.net Git - u-boot/blob - drivers/fpga/fpga.c
Merge branch 'master' of git://git.denx.de/u-boot-mips
[u-boot] / drivers / fpga / fpga.c
1 /*
2  * (C) Copyright 2002
3  * Rich Ireland, Enterasys Networks, rireland@enterasys.com.
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  */
24
25 /*
26  *  Generic FPGA support
27  */
28 #include <common.h>             /* core U-Boot definitions */
29 #include <xilinx.h>             /* xilinx specific definitions */
30 #include <altera.h>             /* altera specific definitions */
31 #include <lattice.h>
32
33 #if 0
34 #define FPGA_DEBUG              /* define FPGA_DEBUG to get debug messages */
35 #endif
36
37 /* Local definitions */
38 #ifndef CONFIG_MAX_FPGA_DEVICES
39 #define CONFIG_MAX_FPGA_DEVICES         5
40 #endif
41
42 /* Enable/Disable debug console messages */
43 #ifdef FPGA_DEBUG
44 #define PRINTF(fmt,args...)     printf (fmt ,##args)
45 #else
46 #define PRINTF(fmt,args...)
47 #endif
48
49 /* Local static data */
50 static int next_desc = FPGA_INVALID_DEVICE;
51 static fpga_desc desc_table[CONFIG_MAX_FPGA_DEVICES];
52
53 /* Local static functions */
54 static __attribute__((__const__)) fpga_desc * __attribute__((__const__)) fpga_get_desc( int devnum );
55 static __attribute__((__const__)) fpga_desc * __attribute__((__const__)) fpga_validate(int devnum, const void *buf,
56                                          size_t bsize, char *fn );
57 static int fpga_dev_info( int devnum );
58
59
60 /* ------------------------------------------------------------------------- */
61
62 /* fpga_no_sup
63  * 'no support' message function
64  */
65 static void fpga_no_sup( char *fn, char *msg )
66 {
67         if ( fn && msg ) {
68                 printf( "%s: No support for %s.\n", fn, msg);
69         } else if ( msg ) {
70                 printf( "No support for %s.\n", msg);
71         } else {
72                 printf( "No FPGA suport!\n");
73         }
74 }
75
76
77 /* fpga_get_desc
78  *      map a device number to a descriptor
79  */
80 static __attribute__((__const__)) fpga_desc * __attribute__((__const__)) fpga_get_desc( int devnum )
81 {
82         fpga_desc *desc = (fpga_desc * )NULL;
83
84         if (( devnum >= 0 ) && (devnum < next_desc )) {
85                 desc = &desc_table[devnum];
86                 PRINTF( "%s: found fpga descriptor #%d @ 0x%p\n",
87                                 __FUNCTION__, devnum, desc );
88         }
89
90         return desc;
91 }
92
93
94 /* fpga_validate
95  *      generic parameter checking code
96  */
97 static __attribute__((__const__)) fpga_desc * __attribute__((__const__)) fpga_validate(int devnum, const void *buf,
98                                          size_t bsize, char *fn )
99 {
100         fpga_desc * desc = fpga_get_desc( devnum );
101
102         if ( !desc ) {
103                 printf( "%s: Invalid device number %d\n", fn, devnum );
104         }
105
106         if ( !buf ) {
107                 printf( "%s: Null buffer.\n", fn );
108                 return (fpga_desc * const)NULL;
109         }
110         return desc;
111 }
112
113
114 /* fpga_dev_info
115  *      generic multiplexing code
116  */
117 static int fpga_dev_info( int devnum )
118 {
119         int ret_val = FPGA_FAIL;           /* assume failure */
120         const fpga_desc * const desc = fpga_get_desc( devnum );
121
122         if ( desc ) {
123                 PRINTF( "%s: Device Descriptor @ 0x%p\n",
124                                 __FUNCTION__, desc->devdesc );
125
126                 switch ( desc->devtype ) {
127                 case fpga_xilinx:
128 #if defined(CONFIG_FPGA_XILINX)
129                         printf( "Xilinx Device\nDescriptor @ 0x%p\n", desc );
130                         ret_val = xilinx_info( desc->devdesc );
131 #else
132                         fpga_no_sup( (char *)__FUNCTION__, "Xilinx devices" );
133 #endif
134                         break;
135                 case fpga_altera:
136 #if defined(CONFIG_FPGA_ALTERA)
137                         printf( "Altera Device\nDescriptor @ 0x%p\n", desc );
138                         ret_val = altera_info( desc->devdesc );
139 #else
140                         fpga_no_sup( (char *)__FUNCTION__, "Altera devices" );
141 #endif
142                         break;
143                 case fpga_lattice:
144 #if defined(CONFIG_FPGA_LATTICE)
145                         printf("Lattice Device\nDescriptor @ 0x%p\n", desc);
146                         ret_val = lattice_info(desc->devdesc);
147 #else
148                         fpga_no_sup( (char *)__FUNCTION__, "Lattice devices" );
149 #endif
150                         break;
151                 default:
152                         printf( "%s: Invalid or unsupported device type %d\n",
153                                         __FUNCTION__, desc->devtype );
154                 }
155         } else {
156                 printf( "%s: Invalid device number %d\n",
157                         __FUNCTION__, devnum );
158         }
159
160         return ret_val;
161 }
162
163
164 /* ------------------------------------------------------------------------- */
165 /* fgpa_init is usually called from misc_init_r() and MUST be called
166  * before any of the other fpga functions are used.
167  */
168 void fpga_init(void)
169 {
170         next_desc = 0;
171         memset( desc_table, 0, sizeof(desc_table));
172
173         PRINTF( "%s: CONFIG_FPGA = 0x%x\n", __FUNCTION__, CONFIG_FPGA );
174 }
175
176 /* fpga_count
177  * Basic interface function to get the current number of devices available.
178  */
179 int fpga_count( void )
180 {
181         return next_desc;
182 }
183
184 /* fpga_add
185  *      Add the device descriptor to the device table.
186  */
187 int fpga_add( fpga_type devtype, void *desc )
188 {
189         int devnum = FPGA_INVALID_DEVICE;
190
191         if ( next_desc  < 0 ) {
192                 printf( "%s: FPGA support not initialized!\n", __FUNCTION__ );
193         } else if (( devtype > fpga_min_type ) && ( devtype < fpga_undefined )) {
194                 if ( desc ) {
195                         if ( next_desc < CONFIG_MAX_FPGA_DEVICES ) {
196                                 devnum = next_desc;
197                                 desc_table[next_desc].devtype = devtype;
198                                 desc_table[next_desc++].devdesc = desc;
199                         } else {
200                                 printf( "%s: Exceeded Max FPGA device count\n", __FUNCTION__ );
201                         }
202                 } else {
203                         printf( "%s: NULL device descriptor\n", __FUNCTION__ );
204                 }
205         } else {
206                 printf( "%s: Unsupported FPGA type %d\n", __FUNCTION__, devtype );
207         }
208
209         return devnum;
210 }
211
212 /*
213  *      Generic multiplexing code
214  */
215 int fpga_load(int devnum, const void *buf, size_t bsize)
216 {
217         int ret_val = FPGA_FAIL;           /* assume failure */
218         fpga_desc * desc = fpga_validate( devnum, buf, bsize, (char *)__FUNCTION__ );
219
220         if ( desc ) {
221                 switch ( desc->devtype ) {
222                 case fpga_xilinx:
223 #if defined(CONFIG_FPGA_XILINX)
224                         ret_val = xilinx_load( desc->devdesc, buf, bsize );
225 #else
226                         fpga_no_sup( (char *)__FUNCTION__, "Xilinx devices" );
227 #endif
228                         break;
229                 case fpga_altera:
230 #if defined(CONFIG_FPGA_ALTERA)
231                         ret_val = altera_load( desc->devdesc, buf, bsize );
232 #else
233                         fpga_no_sup( (char *)__FUNCTION__, "Altera devices" );
234 #endif
235                         break;
236                 case fpga_lattice:
237 #if defined(CONFIG_FPGA_LATTICE)
238                         ret_val = lattice_load(desc->devdesc, buf, bsize);
239 #else
240                         fpga_no_sup( (char *)__FUNCTION__, "Lattice devices" );
241 #endif
242                         break;
243                 default:
244                         printf( "%s: Invalid or unsupported device type %d\n",
245                                 __FUNCTION__, desc->devtype );
246                 }
247         }
248
249         return ret_val;
250 }
251
252 /* fpga_dump
253  *      generic multiplexing code
254  */
255 int fpga_dump(int devnum, const void *buf, size_t bsize)
256 {
257         int ret_val = FPGA_FAIL;           /* assume failure */
258         fpga_desc * desc = fpga_validate( devnum, buf, bsize, (char *)__FUNCTION__ );
259
260         if ( desc ) {
261                 switch ( desc->devtype ) {
262                 case fpga_xilinx:
263 #if defined(CONFIG_FPGA_XILINX)
264                         ret_val = xilinx_dump( desc->devdesc, buf, bsize );
265 #else
266                         fpga_no_sup( (char *)__FUNCTION__, "Xilinx devices" );
267 #endif
268                         break;
269                 case fpga_altera:
270 #if defined(CONFIG_FPGA_ALTERA)
271                         ret_val = altera_dump( desc->devdesc, buf, bsize );
272 #else
273                         fpga_no_sup( (char *)__FUNCTION__, "Altera devices" );
274 #endif
275                         break;
276                 case fpga_lattice:
277 #if defined(CONFIG_FPGA_LATTICE)
278                         ret_val = lattice_dump(desc->devdesc, buf, bsize);
279 #else
280                         fpga_no_sup( (char *)__FUNCTION__, "Lattice devices" );
281 #endif
282                         break;
283                 default:
284                         printf( "%s: Invalid or unsupported device type %d\n",
285                                 __FUNCTION__, desc->devtype );
286                 }
287         }
288
289         return ret_val;
290 }
291
292
293 /* fpga_info
294  *      front end to fpga_dev_info.  If devnum is invalid, report on all
295  *      available devices.
296  */
297 int fpga_info( int devnum )
298 {
299         if ( devnum == FPGA_INVALID_DEVICE ) {
300                 if ( next_desc > 0 ) {
301                         int dev;
302
303                         for ( dev = 0; dev < next_desc; dev++ ) {
304                                 fpga_dev_info( dev );
305                         }
306                         return FPGA_SUCCESS;
307                 } else {
308                         printf( "%s: No FPGA devices available.\n", __FUNCTION__ );
309                         return FPGA_FAIL;
310                 }
311         }
312         else return fpga_dev_info( devnum );
313 }
314
315 /* ------------------------------------------------------------------------- */