drivers/fpga/spartan3.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  * Configuration support for Xilinx Spartan3 devices.  Based
  27  * on spartan2.c (Rich Ireland, rireland@enterasys.com).
  28  */
  29
  30 #include <common.h>             /* core U-Boot definitions */
  31 #include <spartan3.h>           /* Spartan-II device family */
  32
  33 /* Define FPGA_DEBUG to get debug printf's */
  34 #ifdef  FPGA_DEBUG
  35 #define PRINTF(fmt,args...)     printf (fmt ,##args)
  36 #else
  37 #define PRINTF(fmt,args...)
  38 #endif
  39
  40 #undef CONFIG_SYS_FPGA_CHECK_BUSY
  41 #undef CONFIG_SYS_FPGA_PROG_FEEDBACK
  42
  43 /* Note: The assumption is that we cannot possibly run fast enough to
  44  * overrun the device (the Slave Parallel mode can free run at 50MHz).
  45  * If there is a need to operate slower, define CONFIG_FPGA_DELAY in
  46  * the board config file to slow things down.
  47  */
  48 #ifndef CONFIG_FPGA_DELAY
  49 #define CONFIG_FPGA_DELAY()
  50 #endif
  51
  52 #ifndef CONFIG_SYS_FPGA_WAIT
  53 #define CONFIG_SYS_FPGA_WAIT CONFIG_SYS_HZ/100  /* 10 ms */
  54 #endif
  55
  56 static int Spartan3_sp_load(Xilinx_desc *desc, const void *buf, size_t bsize);
  57 static int Spartan3_sp_dump(Xilinx_desc *desc, const void *buf, size_t bsize);
  58 /* static int Spartan3_sp_info(Xilinx_desc *desc ); */
  59
  60 static int Spartan3_ss_load(Xilinx_desc *desc, const void *buf, size_t bsize);
  61 static int Spartan3_ss_dump(Xilinx_desc *desc, const void *buf, size_t bsize);
  62 /* static int Spartan3_ss_info(Xilinx_desc *desc); */
  63
  64 /* ------------------------------------------------------------------------- */
  65 /* Spartan-II Generic Implementation */
  66 int Spartan3_load(Xilinx_desc *desc, const void *buf, size_t bsize)
  67 {
  68         int ret_val = FPGA_FAIL;
  69
  70         switch (desc->iface) {
  71         case slave_serial:
  72                 PRINTF ("%s: Launching Slave Serial Load\n", __FUNCTION__);
  73                 ret_val = Spartan3_ss_load (desc, buf, bsize);
  74                 break;
  75
  76         case slave_parallel:
  77                 PRINTF ("%s: Launching Slave Parallel Load\n", __FUNCTION__);
  78                 ret_val = Spartan3_sp_load (desc, buf, bsize);
  79                 break;
  80
  81         default:
  82                 printf ("%s: Unsupported interface type, %d\n",
  83                                 __FUNCTION__, desc->iface);
  84         }
  85
  86         return ret_val;
  87 }
  88
  89 int Spartan3_dump(Xilinx_desc *desc, const void *buf, size_t bsize)
  90 {
  91         int ret_val = FPGA_FAIL;
  92
  93         switch (desc->iface) {
  94         case slave_serial:
  95                 PRINTF ("%s: Launching Slave Serial Dump\n", __FUNCTION__);
  96                 ret_val = Spartan3_ss_dump (desc, buf, bsize);
  97                 break;
  98
  99         case slave_parallel:
 100                 PRINTF ("%s: Launching Slave Parallel Dump\n", __FUNCTION__);
 101                 ret_val = Spartan3_sp_dump (desc, buf, bsize);
 102                 break;
 103
 104         default:
 105                 printf ("%s: Unsupported interface type, %d\n",
 106                                 __FUNCTION__, desc->iface);
 107         }
 108
 109         return ret_val;
 110 }
 111
 112 int Spartan3_info( Xilinx_desc *desc )
 113 {
 114         return FPGA_SUCCESS;
 115 }
 116
 117
 118 /* ------------------------------------------------------------------------- */
 119 /* Spartan-II Slave Parallel Generic Implementation */
 120
 121 static int Spartan3_sp_load(Xilinx_desc *desc, const void *buf, size_t bsize)
 122 {
 123         int ret_val = FPGA_FAIL;        /* assume the worst */
 124         Xilinx_Spartan3_Slave_Parallel_fns *fn = desc->iface_fns;
 125
 126         PRINTF ("%s: start with interface functions @ 0x%p\n",
 127                         __FUNCTION__, fn);
 128
 129         if (fn) {
 130                 size_t bytecount = 0;
 131                 unsigned char *data = (unsigned char *) buf;
 132                 int cookie = desc->cookie;      /* make a local copy */
 133                 unsigned long ts;               /* timestamp */
 134
 135                 PRINTF ("%s: Function Table:\n"
 136                                 "ptr:\t0x%p\n"
 137                                 "struct: 0x%p\n"
 138                                 "pre: 0x%p\n"
 139                                 "pgm:\t0x%p\n"
 140                                 "init:\t0x%p\n"
 141                                 "err:\t0x%p\n"
 142                                 "clk:\t0x%p\n"
 143                                 "cs:\t0x%p\n"
 144                                 "wr:\t0x%p\n"
 145                                 "read data:\t0x%p\n"
 146                                 "write data:\t0x%p\n"
 147                                 "busy:\t0x%p\n"
 148                                 "abort:\t0x%p\n",
 149                                 "post:\t0x%p\n\n",
 150                                 __FUNCTION__, &fn, fn, fn->pre, fn->pgm, fn->init, fn->err,
 151                                 fn->clk, fn->cs, fn->wr, fn->rdata, fn->wdata, fn->busy,
 152                                 fn->abort, fn->post);
 153
 154                 /*
 155                  * This code is designed to emulate the "Express Style"
 156                  * Continuous Data Loading in Slave Parallel Mode for
 157                  * the Spartan-II Family.
 158                  */
 159 #ifdef CONFIG_SYS_FPGA_PROG_FEEDBACK
 160                 printf ("Loading FPGA Device %d...\n", cookie);
 161 #endif
 162                 /*
 163                  * Run the pre configuration function if there is one.
 164                  */
 165                 if (*fn->pre) {
 166                         (*fn->pre) (cookie);
 167                 }
 168
 169                 /* Establish the initial state */
 170                 (*fn->pgm) (TRUE, TRUE, cookie);        /* Assert the program, commit */
 171
 172                 /* Get ready for the burn */
 173                 CONFIG_FPGA_DELAY ();
 174                 (*fn->pgm) (FALSE, TRUE, cookie);       /* Deassert the program, commit */
 175
 176                 ts = get_timer (0);             /* get current time */
 177                 /* Now wait for INIT and BUSY to go high */
 178                 do {
 179                         CONFIG_FPGA_DELAY ();
 180                         if (get_timer (ts) > CONFIG_SYS_FPGA_WAIT) {    /* check the time */
 181                                 puts ("** Timeout waiting for INIT to clear.\n");
 182                                 (*fn->abort) (cookie);  /* abort the burn */
 183                                 return FPGA_FAIL;
 184                         }
 185                 } while ((*fn->init) (cookie) && (*fn->busy) (cookie));
 186
 187                 (*fn->wr) (TRUE, TRUE, cookie); /* Assert write, commit */
 188                 (*fn->cs) (TRUE, TRUE, cookie); /* Assert chip select, commit */
 189                 (*fn->clk) (TRUE, TRUE, cookie);        /* Assert the clock pin */
 190
 191                 /* Load the data */
 192                 while (bytecount < bsize) {
 193                         /* XXX - do we check for an Ctrl-C press in here ??? */
 194                         /* XXX - Check the error bit? */
 195
 196                         (*fn->wdata) (data[bytecount++], TRUE, cookie); /* write the data */
 197                         CONFIG_FPGA_DELAY ();
 198                         (*fn->clk) (FALSE, TRUE, cookie);       /* Deassert the clock pin */
 199                         CONFIG_FPGA_DELAY ();
 200                         (*fn->clk) (TRUE, TRUE, cookie);        /* Assert the clock pin */
 201
 202 #ifdef CONFIG_SYS_FPGA_CHECK_BUSY
 203                         ts = get_timer (0);     /* get current time */
 204                         while ((*fn->busy) (cookie)) {
 205                                 /* XXX - we should have a check in here somewhere to
 206                                  * make sure we aren't busy forever... */
 207
 208                                 CONFIG_FPGA_DELAY ();
 209                                 (*fn->clk) (FALSE, TRUE, cookie);       /* Deassert the clock pin */
 210                                 CONFIG_FPGA_DELAY ();
 211                                 (*fn->clk) (TRUE, TRUE, cookie);        /* Assert the clock pin */
 212
 213                                 if (get_timer (ts) > CONFIG_SYS_FPGA_WAIT) {    /* check the time */
 214                                         puts ("** Timeout waiting for BUSY to clear.\n");
 215                                         (*fn->abort) (cookie);  /* abort the burn */
 216                                         return FPGA_FAIL;
 217                                 }
 218                         }
 219 #endif
 220
 221 #ifdef CONFIG_SYS_FPGA_PROG_FEEDBACK
 222                         if (bytecount % (bsize / 40) == 0)
 223                                 putc ('.');             /* let them know we are alive */
 224 #endif
 225                 }
 226
 227                 CONFIG_FPGA_DELAY ();
 228                 (*fn->cs) (FALSE, TRUE, cookie);        /* Deassert the chip select */
 229                 (*fn->wr) (FALSE, TRUE, cookie);        /* Deassert the write pin */
 230
 231 #ifdef CONFIG_SYS_FPGA_PROG_FEEDBACK
 232                 putc ('\n');                    /* terminate the dotted line */
 233 #endif
 234
 235                 /* now check for done signal */
 236                 ts = get_timer (0);             /* get current time */
 237                 ret_val = FPGA_SUCCESS;
 238                 while ((*fn->done) (cookie) == FPGA_FAIL) {
 239                         /* XXX - we should have a check in here somewhere to
 240                          * make sure we aren't busy forever... */
 241
 242                         CONFIG_FPGA_DELAY ();
 243                         (*fn->clk) (FALSE, TRUE, cookie);       /* Deassert the clock pin */
 244                         CONFIG_FPGA_DELAY ();
 245                         (*fn->clk) (TRUE, TRUE, cookie);        /* Assert the clock pin */
 246
 247                         if (get_timer (ts) > CONFIG_SYS_FPGA_WAIT) {    /* check the time */
 248                                 puts ("** Timeout waiting for DONE to clear.\n");
 249                                 (*fn->abort) (cookie);  /* abort the burn */
 250                                 ret_val = FPGA_FAIL;
 251                                 break;
 252                         }
 253                 }
 254
 255                 /*
 256                  * Run the post configuration function if there is one.
 257                  */
 258                 if (*fn->post)
 259                         (*fn->post) (cookie);
 260
 261 #ifdef CONFIG_SYS_FPGA_PROG_FEEDBACK
 262                 if (ret_val == FPGA_SUCCESS)
 263                         puts ("Done.\n");
 264                 else
 265                         puts ("Fail.\n");
 266 #endif
 267
 268         } else {
 269                 printf ("%s: NULL Interface function table!\n", __FUNCTION__);
 270         }
 271
 272         return ret_val;
 273 }
 274
 275 static int Spartan3_sp_dump(Xilinx_desc *desc, const void *buf, size_t bsize)
 276 {
 277         int ret_val = FPGA_FAIL;        /* assume the worst */
 278         Xilinx_Spartan3_Slave_Parallel_fns *fn = desc->iface_fns;
 279
 280         if (fn) {
 281                 unsigned char *data = (unsigned char *) buf;
 282                 size_t bytecount = 0;
 283                 int cookie = desc->cookie;      /* make a local copy */
 284
 285                 printf ("Starting Dump of FPGA Device %d...\n", cookie);
 286
 287                 (*fn->cs) (TRUE, TRUE, cookie); /* Assert chip select, commit */
 288                 (*fn->clk) (TRUE, TRUE, cookie);        /* Assert the clock pin */
 289
 290                 /* dump the data */
 291                 while (bytecount < bsize) {
 292                         /* XXX - do we check for an Ctrl-C press in here ??? */
 293
 294                         (*fn->clk) (FALSE, TRUE, cookie);       /* Deassert the clock pin */
 295                         (*fn->clk) (TRUE, TRUE, cookie);        /* Assert the clock pin */
 296                         (*fn->rdata) (&(data[bytecount++]), cookie);    /* read the data */
 297 #ifdef CONFIG_SYS_FPGA_PROG_FEEDBACK
 298                         if (bytecount % (bsize / 40) == 0)
 299                                 putc ('.');             /* let them know we are alive */
 300 #endif
 301                 }
 302
 303                 (*fn->cs) (FALSE, FALSE, cookie);       /* Deassert the chip select */
 304                 (*fn->clk) (FALSE, TRUE, cookie);       /* Deassert the clock pin */
 305                 (*fn->clk) (TRUE, TRUE, cookie);        /* Assert the clock pin */
 306
 307 #ifdef CONFIG_SYS_FPGA_PROG_FEEDBACK
 308                 putc ('\n');                    /* terminate the dotted line */
 309 #endif
 310                 puts ("Done.\n");
 311
 312                 /* XXX - checksum the data? */
 313         } else {
 314                 printf ("%s: NULL Interface function table!\n", __FUNCTION__);
 315         }
 316
 317         return ret_val;
 318 }
 319
 320
 321 /* ------------------------------------------------------------------------- */
 322
 323 static int Spartan3_ss_load(Xilinx_desc *desc, const void *buf, size_t bsize)
 324 {
 325         int ret_val = FPGA_FAIL;        /* assume the worst */
 326         Xilinx_Spartan3_Slave_Serial_fns *fn = desc->iface_fns;
 327         int i;
 328         unsigned char val;
 329
 330         PRINTF ("%s: start with interface functions @ 0x%p\n",
 331                         __FUNCTION__, fn);
 332
 333         if (fn) {
 334                 size_t bytecount = 0;
 335                 unsigned char *data = (unsigned char *) buf;
 336                 int cookie = desc->cookie;      /* make a local copy */
 337                 unsigned long ts;               /* timestamp */
 338
 339                 PRINTF ("%s: Function Table:\n"
 340                                 "ptr:\t0x%p\n"
 341                                 "struct: 0x%p\n"
 342                                 "pgm:\t0x%p\n"
 343                                 "init:\t0x%p\n"
 344                                 "clk:\t0x%p\n"
 345                                 "wr:\t0x%p\n"
 346                                 "done:\t0x%p\n\n",
 347                                 __FUNCTION__, &fn, fn, fn->pgm, fn->init,
 348                                 fn->clk, fn->wr, fn->done);
 349 #ifdef CONFIG_SYS_FPGA_PROG_FEEDBACK
 350                 printf ("Loading FPGA Device %d...\n", cookie);
 351 #endif
 352
 353                 /*
 354                  * Run the pre configuration function if there is one.
 355                  */
 356                 if (*fn->pre) {
 357                         (*fn->pre) (cookie);
 358                 }
 359
 360                 /* Establish the initial state */
 361                 (*fn->pgm) (TRUE, TRUE, cookie);        /* Assert the program, commit */
 362
 363                 /* Wait for INIT state (init low)                            */
 364                 ts = get_timer (0);             /* get current time */
 365                 do {
 366                         CONFIG_FPGA_DELAY ();
 367                         if (get_timer (ts) > CONFIG_SYS_FPGA_WAIT) {    /* check the time */
 368                                 puts ("** Timeout waiting for INIT to start.\n");
 369                                 if (*fn->abort)
 370                                         (*fn->abort) (cookie);
 371                                 return FPGA_FAIL;
 372                         }
 373                 } while (!(*fn->init) (cookie));
 374
 375                 /* Get ready for the burn */
 376                 CONFIG_FPGA_DELAY ();
 377                 (*fn->pgm) (FALSE, TRUE, cookie);       /* Deassert the program, commit */
 378
 379                 ts = get_timer (0);             /* get current time */
 380                 /* Now wait for INIT to go high */
 381                 do {
 382                         CONFIG_FPGA_DELAY ();
 383                         if (get_timer (ts) > CONFIG_SYS_FPGA_WAIT) {    /* check the time */
 384                                 puts ("** Timeout waiting for INIT to clear.\n");
 385                                 if (*fn->abort)
 386                                         (*fn->abort) (cookie);
 387                                 return FPGA_FAIL;
 388                         }
 389                 } while ((*fn->init) (cookie));
 390
 391                 /* Load the data */
 392                 if(*fn->bwr)
 393                         (*fn->bwr) (data, bsize, TRUE, cookie);
 394                 else {
 395                         while (bytecount < bsize) {
 396
 397                                 /* Xilinx detects an error if INIT goes low (active)
 398                                    while DONE is low (inactive) */
 399                                 if ((*fn->done) (cookie) == 0 && (*fn->init) (cookie)) {
 400                                         puts ("** CRC error during FPGA load.\n");
 401                                         if (*fn->abort)
 402                                                 (*fn->abort) (cookie);
 403                                         return (FPGA_FAIL);
 404                                 }
 405                                 val = data [bytecount ++];
 406                                 i = 8;
 407                                 do {
 408                                         /* Deassert the clock */
 409                                         (*fn->clk) (FALSE, TRUE, cookie);
 410                                         CONFIG_FPGA_DELAY ();
 411                                         /* Write data */
 412                                         (*fn->wr) ((val & 0x80), TRUE, cookie);
 413                                         CONFIG_FPGA_DELAY ();
 414                                         /* Assert the clock */
 415                                         (*fn->clk) (TRUE, TRUE, cookie);
 416                                         CONFIG_FPGA_DELAY ();
 417                                         val <<= 1;
 418                                         i --;
 419                                 } while (i > 0);
 420
 421 #ifdef CONFIG_SYS_FPGA_PROG_FEEDBACK
 422                                 if (bytecount % (bsize / 40) == 0)
 423                                         putc ('.');             /* let them know we are alive */
 424 #endif
 425                         }
 426                 }
 427
 428                 CONFIG_FPGA_DELAY ();
 429
 430 #ifdef CONFIG_SYS_FPGA_PROG_FEEDBACK
 431                 putc ('\n');                    /* terminate the dotted line */
 432 #endif
 433
 434                 /* now check for done signal */
 435                 ts = get_timer (0);             /* get current time */
 436                 ret_val = FPGA_SUCCESS;
 437                 (*fn->wr) (TRUE, TRUE, cookie);
 438
 439                 while (! (*fn->done) (cookie)) {
 440                         /* XXX - we should have a check in here somewhere to
 441                          * make sure we aren't busy forever... */
 442
 443                         CONFIG_FPGA_DELAY ();
 444                         (*fn->clk) (FALSE, TRUE, cookie);       /* Deassert the clock pin */
 445                         CONFIG_FPGA_DELAY ();
 446                         (*fn->clk) (TRUE, TRUE, cookie);        /* Assert the clock pin */
 447
 448                         putc ('*');
 449
 450                         if (get_timer (ts) > CONFIG_SYS_FPGA_WAIT) {    /* check the time */
 451                                 puts ("** Timeout waiting for DONE to clear.\n");
 452                                 ret_val = FPGA_FAIL;
 453                                 break;
 454                         }
 455                 }
 456                 putc ('\n');                    /* terminate the dotted line */
 457
 458                 /*
 459                  * Run the post configuration function if there is one.
 460                  */
 461                 if (*fn->post)
 462                         (*fn->post) (cookie);
 463
 464 #ifdef CONFIG_SYS_FPGA_PROG_FEEDBACK
 465                 if (ret_val == FPGA_SUCCESS)
 466                         puts ("Done.\n");
 467                 else
 468                         puts ("Fail.\n");
 469 #endif
 470
 471         } else {
 472                 printf ("%s: NULL Interface function table!\n", __FUNCTION__);
 473         }
 474
 475         return ret_val;
 476 }
 477
 478 static int Spartan3_ss_dump(Xilinx_desc *desc, const void *buf, size_t bsize)
 479 {
 480         /* Readback is only available through the Slave Parallel and         */
 481         /* boundary-scan interfaces.                                         */
 482         printf ("%s: Slave Serial Dumping is unavailable\n",
 483                         __FUNCTION__);
 484         return FPGA_FAIL;
 485 }