git.sur5r.net Git - u-boot/blob - common/xilinx.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  *  Xilinx FPGA support
  28  */
  29
  30 #include <common.h>
  31 #include <virtex2.h>
  32 #include <spartan2.h>
  33 #include <spartan3.h>
  34
  35 #if defined(CONFIG_FPGA) && defined(CONFIG_FPGA_XILINX)
  36
  37 #if 0
  38 #define FPGA_DEBUG
  39 #endif
  40
  41 /* Define FPGA_DEBUG to get debug printf's */
  42 #ifdef  FPGA_DEBUG
  43 #define PRINTF(fmt,args...)     printf (fmt ,##args)
  44 #else
  45 #define PRINTF(fmt,args...)
  46 #endif
  47
  48 /* Local Static Functions */
  49 static int xilinx_validate (Xilinx_desc * desc, char *fn);
  50
  51 /* ------------------------------------------------------------------------- */
  52
  53 int xilinx_load (Xilinx_desc * desc, void *buf, size_t bsize)
  54 {
  55         int ret_val = FPGA_FAIL;        /* assume a failure */
  56
  57         if (!xilinx_validate (desc, (char *)__FUNCTION__)) {
  58                 printf ("%s: Invalid device descriptor\n", __FUNCTION__);
  59         } else
  60                 switch (desc->family) {
  61                 case Xilinx_Spartan2:
  62 #if defined(CONFIG_FPGA_SPARTAN2)
  63                         PRINTF ("%s: Launching the Spartan-II Loader...\n",
  64                                         __FUNCTION__);
  65                         ret_val = Spartan2_load (desc, buf, bsize);
  66 #else
  67                         printf ("%s: No support for Spartan-II devices.\n",
  68                                         __FUNCTION__);
  69 #endif
  70                         break;
  71                 case Xilinx_Spartan3:
  72 #if defined(CONFIG_FPGA_SPARTAN3)
  73                         PRINTF ("%s: Launching the Spartan-III Loader...\n",
  74                                         __FUNCTION__);
  75                         ret_val = Spartan3_load (desc, buf, bsize);
  76 #else
  77                         printf ("%s: No support for Spartan-III devices.\n",
  78                                         __FUNCTION__);
  79 #endif
  80                         break;
  81                 case Xilinx_Virtex2:
  82 #if defined(CONFIG_FPGA_VIRTEX2)
  83                         PRINTF ("%s: Launching the Virtex-II Loader...\n",
  84                                         __FUNCTION__);
  85                         ret_val = Virtex2_load (desc, buf, bsize);
  86 #else
  87                         printf ("%s: No support for Virtex-II devices.\n",
  88                                         __FUNCTION__);
  89 #endif
  90                         break;
  91
  92                 default:
  93                         printf ("%s: Unsupported family type, %d\n",
  94                                         __FUNCTION__, desc->family);
  95                 }
  96
  97         return ret_val;
  98 }
  99
 100 int xilinx_dump (Xilinx_desc * desc, void *buf, size_t bsize)
 101 {
 102         int ret_val = FPGA_FAIL;        /* assume a failure */
 103
 104         if (!xilinx_validate (desc, (char *)__FUNCTION__)) {
 105                 printf ("%s: Invalid device descriptor\n", __FUNCTION__);
 106         } else
 107                 switch (desc->family) {
 108                 case Xilinx_Spartan2:
 109 #if defined(CONFIG_FPGA_SPARTAN2)
 110                         PRINTF ("%s: Launching the Spartan-II Reader...\n",
 111                                         __FUNCTION__);
 112                         ret_val = Spartan2_dump (desc, buf, bsize);
 113 #else
 114                         printf ("%s: No support for Spartan-II devices.\n",
 115                                         __FUNCTION__);
 116 #endif
 117                         break;
 118                 case Xilinx_Spartan3:
 119 #if defined(CONFIG_FPGA_SPARTAN3)
 120                         PRINTF ("%s: Launching the Spartan-III Reader...\n",
 121                                         __FUNCTION__);
 122                         ret_val = Spartan3_dump (desc, buf, bsize);
 123 #else
 124                         printf ("%s: No support for Spartan-III devices.\n",
 125                                         __FUNCTION__);
 126 #endif
 127                         break;
 128                 case Xilinx_Virtex2:
 129 #if defined( CONFIG_FPGA_VIRTEX2)
 130                         PRINTF ("%s: Launching the Virtex-II Reader...\n",
 131                                         __FUNCTION__);
 132                         ret_val = Virtex2_dump (desc, buf, bsize);
 133 #else
 134                         printf ("%s: No support for Virtex-II devices.\n",
 135                                         __FUNCTION__);
 136 #endif
 137                         break;
 138
 139                 default:
 140                         printf ("%s: Unsupported family type, %d\n",
 141                                         __FUNCTION__, desc->family);
 142                 }
 143
 144         return ret_val;
 145 }
 146
 147 int xilinx_info (Xilinx_desc * desc)
 148 {
 149         int ret_val = FPGA_FAIL;
 150
 151         if (xilinx_validate (desc, (char *)__FUNCTION__)) {
 152                 printf ("Family:        \t");
 153                 switch (desc->family) {
 154                 case Xilinx_Spartan2:
 155                         printf ("Spartan-II\n");
 156                         break;
 157                 case Xilinx_Spartan3:
 158                         printf ("Spartan-III\n");
 159                         break;
 160                 case Xilinx_Virtex2:
 161                         printf ("Virtex-II\n");
 162                         break;
 163                         /* Add new family types here */
 164                 default:
 165                         printf ("Unknown family type, %d\n", desc->family);
 166                 }
 167
 168                 printf ("Interface type:\t");
 169                 switch (desc->iface) {
 170                 case slave_serial:
 171                         printf ("Slave Serial\n");
 172                         break;
 173                 case master_serial:     /* Not used */
 174                         printf ("Master Serial\n");
 175                         break;
 176                 case slave_parallel:
 177                         printf ("Slave Parallel\n");
 178                         break;
 179                 case jtag_mode:         /* Not used */
 180                         printf ("JTAG Mode\n");
 181                         break;
 182                 case slave_selectmap:
 183                         printf ("Slave SelectMap Mode\n");
 184                         break;
 185                 case master_selectmap:
 186                         printf ("Master SelectMap Mode\n");
 187                         break;
 188                         /* Add new interface types here */
 189                 default:
 190                         printf ("Unsupported interface type, %d\n", desc->iface);
 191                 }
 192
 193                 printf ("Device Size:   \t%d bytes\n"
 194                                 "Cookie:        \t0x%x (%d)\n",
 195                                 desc->size, desc->cookie, desc->cookie);
 196
 197                 if (desc->iface_fns) {
 198                         printf ("Device Function Table @ 0x%p\n", desc->iface_fns);
 199                         switch (desc->family) {
 200                         case Xilinx_Spartan2:
 201 #if defined(CONFIG_FPGA_SPARTAN2)
 202                                 Spartan2_info (desc);
 203 #else
 204                                 /* just in case */
 205                                 printf ("%s: No support for Spartan-II devices.\n",
 206                                                 __FUNCTION__);
 207 #endif
 208                                 break;
 209                         case Xilinx_Spartan3:
 210 #if defined(CONFIG_FPGA_SPARTAN3)
 211                                 Spartan3_info (desc);
 212 #else
 213                                 /* just in case */
 214                                 printf ("%s: No support for Spartan-III devices.\n",
 215                                                 __FUNCTION__);
 216 #endif
 217                                 break;
 218                         case Xilinx_Virtex2:
 219 #if defined(CONFIG_FPGA_VIRTEX2)
 220                                 Virtex2_info (desc);
 221 #else
 222                                 /* just in case */
 223                                 printf ("%s: No support for Virtex-II devices.\n",
 224                                                 __FUNCTION__);
 225 #endif
 226                                 break;
 227                                 /* Add new family types here */
 228                         default:
 229                                 /* we don't need a message here - we give one up above */
 230                                 ;
 231                         }
 232                 } else
 233                         printf ("No Device Function Table.\n");
 234
 235                 ret_val = FPGA_SUCCESS;
 236         } else {
 237                 printf ("%s: Invalid device descriptor\n", __FUNCTION__);
 238         }
 239
 240         return ret_val;
 241 }
 242
 243 int xilinx_reloc (Xilinx_desc * desc, ulong reloc_offset)
 244 {
 245         int ret_val = FPGA_FAIL;        /* assume a failure */
 246
 247         if (!xilinx_validate (desc, (char *)__FUNCTION__)) {
 248                 printf ("%s: Invalid device descriptor\n", __FUNCTION__);
 249         } else
 250                 switch (desc->family) {
 251                 case Xilinx_Spartan2:
 252 #if defined(CONFIG_FPGA_SPARTAN2)
 253                         ret_val = Spartan2_reloc (desc, reloc_offset);
 254 #else
 255                         printf ("%s: No support for Spartan-II devices.\n",
 256                                         __FUNCTION__);
 257 #endif
 258                         break;
 259                 case Xilinx_Spartan3:
 260 #if defined(CONFIG_FPGA_SPARTAN3)
 261                         ret_val = Spartan3_reloc (desc, reloc_offset);
 262 #else
 263                         printf ("%s: No support for Spartan-III devices.\n",
 264                                         __FUNCTION__);
 265 #endif
 266                         break;
 267                 case Xilinx_Virtex2:
 268 #if defined(CONFIG_FPGA_VIRTEX2)
 269                         ret_val = Virtex2_reloc (desc, reloc_offset);
 270 #else
 271                         printf ("%s: No support for Virtex-II devices.\n",
 272                                         __FUNCTION__);
 273 #endif
 274                         break;
 275                         /* Add new family types here */
 276                 default:
 277                         printf ("%s: Unsupported family type, %d\n",
 278                                         __FUNCTION__, desc->family);
 279                 }
 280
 281         return ret_val;
 282 }
 283
 284
 285 /* ------------------------------------------------------------------------- */
 286
 287 static int xilinx_validate (Xilinx_desc * desc, char *fn)
 288 {
 289         int ret_val = FALSE;
 290
 291         if (desc) {
 292                 if ((desc->family > min_xilinx_type) &&
 293                         (desc->family < max_xilinx_type)) {
 294                         if ((desc->iface > min_xilinx_iface_type) &&
 295                                 (desc->iface < max_xilinx_iface_type)) {
 296                                 if (desc->size) {
 297                                         ret_val = TRUE;
 298                                 } else
 299                                         printf ("%s: NULL part size\n", fn);
 300                         } else
 301                                 printf ("%s: Invalid Interface type, %d\n",
 302                                                 fn, desc->iface);
 303                 } else
 304                         printf ("%s: Invalid family type, %d\n", fn, desc->family);
 305         } else
 306                 printf ("%s: NULL descriptor!\n", fn);
 307
 308         return ret_val;
 309 }
 310
 311 #endif  /* CONFIG_FPGA && CONFIG_FPGA_XILINX */