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: */