drivers/fpga/zynqpl.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2012-2013, Xilinx, Michal Simek
   4  *
   5  * (C) Copyright 2012
   6  * Joe Hershberger <joe.hershberger@ni.com>
   7  */
   8
   9 #include <common.h>
  10 #include <console.h>
  11 #include <cpu_func.h>
  12 #include <log.h>
  13 #include <asm/cache.h>
  14 #include <asm/io.h>
  15 #include <fs.h>
  16 #include <zynqpl.h>
  17 #include <linux/delay.h>
  18 #include <linux/sizes.h>
  19 #include <asm/arch/hardware.h>
  20 #include <asm/arch/sys_proto.h>
  21
  22 #define DEVCFG_CTRL_PCFG_PROG_B         0x40000000
  23 #define DEVCFG_CTRL_PCFG_AES_EFUSE_MASK 0x00001000
  24 #define DEVCFG_CTRL_PCAP_RATE_EN_MASK   0x02000000
  25 #define DEVCFG_ISR_FATAL_ERROR_MASK     0x00740040
  26 #define DEVCFG_ISR_ERROR_FLAGS_MASK     0x00340840
  27 #define DEVCFG_ISR_RX_FIFO_OV           0x00040000
  28 #define DEVCFG_ISR_DMA_DONE             0x00002000
  29 #define DEVCFG_ISR_PCFG_DONE            0x00000004
  30 #define DEVCFG_STATUS_DMA_CMD_Q_F       0x80000000
  31 #define DEVCFG_STATUS_DMA_CMD_Q_E       0x40000000
  32 #define DEVCFG_STATUS_DMA_DONE_CNT_MASK 0x30000000
  33 #define DEVCFG_STATUS_PCFG_INIT         0x00000010
  34 #define DEVCFG_MCTRL_PCAP_LPBK          0x00000010
  35 #define DEVCFG_MCTRL_RFIFO_FLUSH        0x00000002
  36 #define DEVCFG_MCTRL_WFIFO_FLUSH        0x00000001
  37
  38 #ifndef CONFIG_SYS_FPGA_WAIT
  39 #define CONFIG_SYS_FPGA_WAIT CONFIG_SYS_HZ/100  /* 10 ms */
  40 #endif
  41
  42 #ifndef CONFIG_SYS_FPGA_PROG_TIME
  43 #define CONFIG_SYS_FPGA_PROG_TIME       (CONFIG_SYS_HZ * 4) /* 4 s */
  44 #endif
  45
  46 #define DUMMY_WORD      0xffffffff
  47
  48 /* Xilinx binary format header */
  49 static const u32 bin_format[] = {
  50         DUMMY_WORD, /* Dummy words */
  51         DUMMY_WORD,
  52         DUMMY_WORD,
  53         DUMMY_WORD,
  54         DUMMY_WORD,
  55         DUMMY_WORD,
  56         DUMMY_WORD,
  57         DUMMY_WORD,
  58         0x000000bb, /* Sync word */
  59         0x11220044, /* Sync word */
  60         DUMMY_WORD,
  61         DUMMY_WORD,
  62         0xaa995566, /* Sync word */
  63 };
  64
  65 #define SWAP_NO         1
  66 #define SWAP_DONE       2
  67
  68 /*
  69  * Load the whole word from unaligned buffer
  70  * Keep in your mind that it is byte loading on little-endian system
  71  */
  72 static u32 load_word(const void *buf, u32 swap)
  73 {
  74         u32 word = 0;
  75         u8 *bitc = (u8 *)buf;
  76         int p;
  77
  78         if (swap == SWAP_NO) {
  79                 for (p = 0; p < 4; p++) {
  80                         word <<= 8;
  81                         word |= bitc[p];
  82                 }
  83         } else {
  84                 for (p = 3; p >= 0; p--) {
  85                         word <<= 8;
  86                         word |= bitc[p];
  87                 }
  88         }
  89
  90         return word;
  91 }
  92
  93 static u32 check_header(const void *buf)
  94 {
  95         u32 i, pattern;
  96         int swap = SWAP_NO;
  97         u32 *test = (u32 *)buf;
  98
  99         debug("%s: Let's check bitstream header\n", __func__);
 100
 101         /* Checking that passing bin is not a bitstream */
 102         for (i = 0; i < ARRAY_SIZE(bin_format); i++) {
 103                 pattern = load_word(&test[i], swap);
 104
 105                 /*
 106                  * Bitstreams in binary format are swapped
 107                  * compare to regular bistream.
 108                  * Do not swap dummy word but if swap is done assume
 109                  * that parsing buffer is binary format
 110                  */
 111                 if ((__swab32(pattern) != DUMMY_WORD) &&
 112                     (__swab32(pattern) == bin_format[i])) {
 113                         pattern = __swab32(pattern);
 114                         swap = SWAP_DONE;
 115                         debug("%s: data swapped - let's swap\n", __func__);
 116                 }
 117
 118                 debug("%s: %d/%x: pattern %x/%x bin_format\n", __func__, i,
 119                       (u32)&test[i], pattern, bin_format[i]);
 120                 if (pattern != bin_format[i]) {
 121                         debug("%s: Bitstream is not recognized\n", __func__);
 122                         return 0;
 123                 }
 124         }
 125         debug("%s: Found bitstream header at %x %s swapinng\n", __func__,
 126               (u32)buf, swap == SWAP_NO ? "without" : "with");
 127
 128         return swap;
 129 }
 130
 131 static void *check_data(u8 *buf, size_t bsize, u32 *swap)
 132 {
 133         u32 word, p = 0; /* possition */
 134
 135         /* Because buf doesn't need to be aligned let's read it by chars */
 136         for (p = 0; p < bsize; p++) {
 137                 word = load_word(&buf[p], SWAP_NO);
 138                 debug("%s: word %x %x/%x\n", __func__, word, p, (u32)&buf[p]);
 139
 140                 /* Find the first bitstream dummy word */
 141                 if (word == DUMMY_WORD) {
 142                         debug("%s: Found dummy word at position %x/%x\n",
 143                               __func__, p, (u32)&buf[p]);
 144                         *swap = check_header(&buf[p]);
 145                         if (*swap) {
 146                                 /* FIXME add full bitstream checking here */
 147                                 return &buf[p];
 148                         }
 149                 }
 150                 /* Loop can be huge - support CTRL + C */
 151                 if (ctrlc())
 152                         return NULL;
 153         }
 154         return NULL;
 155 }
 156
 157 static int zynq_dma_transfer(u32 srcbuf, u32 srclen, u32 dstbuf, u32 dstlen)
 158 {
 159         unsigned long ts;
 160         u32 isr_status;
 161
 162         /* Set up the transfer */
 163         writel((u32)srcbuf, &devcfg_base->dma_src_addr);
 164         writel(dstbuf, &devcfg_base->dma_dst_addr);
 165         writel(srclen, &devcfg_base->dma_src_len);
 166         writel(dstlen, &devcfg_base->dma_dst_len);
 167
 168         isr_status = readl(&devcfg_base->int_sts);
 169
 170         /* Polling the PCAP_INIT status for Set */
 171         ts = get_timer(0);
 172         while (!(isr_status & DEVCFG_ISR_DMA_DONE)) {
 173                 if (isr_status & DEVCFG_ISR_ERROR_FLAGS_MASK) {
 174                         debug("%s: Error: isr = 0x%08X\n", __func__,
 175                               isr_status);
 176                         debug("%s: Write count = 0x%08X\n", __func__,
 177                               readl(&devcfg_base->write_count));
 178                         debug("%s: Read count = 0x%08X\n", __func__,
 179                               readl(&devcfg_base->read_count));
 180
 181                         return FPGA_FAIL;
 182                 }
 183                 if (get_timer(ts) > CONFIG_SYS_FPGA_PROG_TIME) {
 184                         printf("%s: Timeout wait for DMA to complete\n",
 185                                __func__);
 186                         return FPGA_FAIL;
 187                 }
 188                 isr_status = readl(&devcfg_base->int_sts);
 189         }
 190
 191         debug("%s: DMA transfer is done\n", __func__);
 192
 193         /* Clear out the DMA status */
 194         writel(DEVCFG_ISR_DMA_DONE, &devcfg_base->int_sts);
 195
 196         return FPGA_SUCCESS;
 197 }
 198
 199 static int zynq_dma_xfer_init(bitstream_type bstype)
 200 {
 201         u32 status, control, isr_status;
 202         unsigned long ts;
 203
 204         /* Clear loopback bit */
 205         clrbits_le32(&devcfg_base->mctrl, DEVCFG_MCTRL_PCAP_LPBK);
 206
 207         if (bstype != BIT_PARTIAL) {
 208                 zynq_slcr_devcfg_disable();
 209
 210                 /* Setting PCFG_PROG_B signal to high */
 211                 control = readl(&devcfg_base->ctrl);
 212                 writel(control | DEVCFG_CTRL_PCFG_PROG_B, &devcfg_base->ctrl);
 213
 214                 /*
 215                  * Delay is required if AES efuse is selected as
 216                  * key source.
 217                  */
 218                 if (control & DEVCFG_CTRL_PCFG_AES_EFUSE_MASK)
 219                         mdelay(5);
 220
 221                 /* Setting PCFG_PROG_B signal to low */
 222                 writel(control & ~DEVCFG_CTRL_PCFG_PROG_B, &devcfg_base->ctrl);
 223
 224                 /*
 225                  * Delay is required if AES efuse is selected as
 226                  * key source.
 227                  */
 228                 if (control & DEVCFG_CTRL_PCFG_AES_EFUSE_MASK)
 229                         mdelay(5);
 230
 231                 /* Polling the PCAP_INIT status for Reset */
 232                 ts = get_timer(0);
 233                 while (readl(&devcfg_base->status) & DEVCFG_STATUS_PCFG_INIT) {
 234                         if (get_timer(ts) > CONFIG_SYS_FPGA_WAIT) {
 235                                 printf("%s: Timeout wait for INIT to clear\n",
 236                                        __func__);
 237                                 return FPGA_FAIL;
 238                         }
 239                 }
 240
 241                 /* Setting PCFG_PROG_B signal to high */
 242                 writel(control | DEVCFG_CTRL_PCFG_PROG_B, &devcfg_base->ctrl);
 243
 244                 /* Polling the PCAP_INIT status for Set */
 245                 ts = get_timer(0);
 246                 while (!(readl(&devcfg_base->status) &
 247                         DEVCFG_STATUS_PCFG_INIT)) {
 248                         if (get_timer(ts) > CONFIG_SYS_FPGA_WAIT) {
 249                                 printf("%s: Timeout wait for INIT to set\n",
 250                                        __func__);
 251                                 return FPGA_FAIL;
 252                         }
 253                 }
 254         }
 255
 256         isr_status = readl(&devcfg_base->int_sts);
 257
 258         /* Clear it all, so if Boot ROM comes back, it can proceed */
 259         writel(0xFFFFFFFF, &devcfg_base->int_sts);
 260
 261         if (isr_status & DEVCFG_ISR_FATAL_ERROR_MASK) {
 262                 debug("%s: Fatal errors in PCAP 0x%X\n", __func__, isr_status);
 263
 264                 /* If RX FIFO overflow, need to flush RX FIFO first */
 265                 if (isr_status & DEVCFG_ISR_RX_FIFO_OV) {
 266                         writel(DEVCFG_MCTRL_RFIFO_FLUSH, &devcfg_base->mctrl);
 267                         writel(0xFFFFFFFF, &devcfg_base->int_sts);
 268                 }
 269                 return FPGA_FAIL;
 270         }
 271
 272         status = readl(&devcfg_base->status);
 273
 274         debug("%s: Status = 0x%08X\n", __func__, status);
 275
 276         if (status & DEVCFG_STATUS_DMA_CMD_Q_F) {
 277                 debug("%s: Error: device busy\n", __func__);
 278                 return FPGA_FAIL;
 279         }
 280
 281         debug("%s: Device ready\n", __func__);
 282
 283         if (!(status & DEVCFG_STATUS_DMA_CMD_Q_E)) {
 284                 if (!(readl(&devcfg_base->int_sts) & DEVCFG_ISR_DMA_DONE)) {
 285                         /* Error state, transfer cannot occur */
 286                         debug("%s: ISR indicates error\n", __func__);
 287                         return FPGA_FAIL;
 288                 } else {
 289                         /* Clear out the status */
 290                         writel(DEVCFG_ISR_DMA_DONE, &devcfg_base->int_sts);
 291                 }
 292         }
 293
 294         if (status & DEVCFG_STATUS_DMA_DONE_CNT_MASK) {
 295                 /* Clear the count of completed DMA transfers */
 296                 writel(DEVCFG_STATUS_DMA_DONE_CNT_MASK, &devcfg_base->status);
 297         }
 298
 299         return FPGA_SUCCESS;
 300 }
 301
 302 static u32 *zynq_align_dma_buffer(u32 *buf, u32 len, u32 swap)
 303 {
 304         u32 *new_buf;
 305         u32 i;
 306
 307         if ((u32)buf != ALIGN((u32)buf, ARCH_DMA_MINALIGN)) {
 308                 new_buf = (u32 *)ALIGN((u32)buf, ARCH_DMA_MINALIGN);
 309
 310                 /*
 311                  * This might be dangerous but permits to flash if
 312                  * ARCH_DMA_MINALIGN is greater than header size
 313                  */
 314                 if (new_buf > buf) {
 315                         debug("%s: Aligned buffer is after buffer start\n",
 316                               __func__);
 317                         new_buf -= ARCH_DMA_MINALIGN;
 318                 }
 319                 printf("%s: Align buffer at %x to %x(swap %d)\n", __func__,
 320                        (u32)buf, (u32)new_buf, swap);
 321
 322                 for (i = 0; i < (len/4); i++)
 323                         new_buf[i] = load_word(&buf[i], swap);
 324
 325                 buf = new_buf;
 326         } else if (swap != SWAP_DONE) {
 327                 /* For bitstream which are aligned */
 328                 u32 *new_buf = (u32 *)buf;
 329
 330                 printf("%s: Bitstream is not swapped(%d) - swap it\n", __func__,
 331                        swap);
 332
 333                 for (i = 0; i < (len/4); i++)
 334                         new_buf[i] = load_word(&buf[i], swap);
 335         }
 336
 337         return buf;
 338 }
 339
 340 static int zynq_validate_bitstream(xilinx_desc *desc, const void *buf,
 341                                    size_t bsize, u32 blocksize, u32 *swap,
 342                                    bitstream_type *bstype)
 343 {
 344         u32 *buf_start;
 345         u32 diff;
 346
 347         buf_start = check_data((u8 *)buf, blocksize, swap);
 348
 349         if (!buf_start)
 350                 return FPGA_FAIL;
 351
 352         /* Check if data is postpone from start */
 353         diff = (u32)buf_start - (u32)buf;
 354         if (diff) {
 355                 printf("%s: Bitstream is not validated yet (diff %x)\n",
 356                        __func__, diff);
 357                 return FPGA_FAIL;
 358         }
 359
 360         if ((u32)buf < SZ_1M) {
 361                 printf("%s: Bitstream has to be placed up to 1MB (%x)\n",
 362                        __func__, (u32)buf);
 363                 return FPGA_FAIL;
 364         }
 365
 366         if (zynq_dma_xfer_init(*bstype))
 367                 return FPGA_FAIL;
 368
 369         return 0;
 370 }
 371
 372 static int zynq_load(xilinx_desc *desc, const void *buf, size_t bsize,
 373                      bitstream_type bstype)
 374 {
 375         unsigned long ts; /* Timestamp */
 376         u32 isr_status, swap;
 377
 378         /*
 379          * send bsize inplace of blocksize as it was not a bitstream
 380          * in chunks
 381          */
 382         if (zynq_validate_bitstream(desc, buf, bsize, bsize, &swap,
 383                                     &bstype))
 384                 return FPGA_FAIL;
 385
 386         buf = zynq_align_dma_buffer((u32 *)buf, bsize, swap);
 387
 388         debug("%s: Source = 0x%08X\n", __func__, (u32)buf);
 389         debug("%s: Size = %zu\n", __func__, bsize);
 390
 391         /* flush(clean & invalidate) d-cache range buf */
 392         flush_dcache_range((u32)buf, (u32)buf +
 393                            roundup(bsize, ARCH_DMA_MINALIGN));
 394
 395         if (zynq_dma_transfer((u32)buf | 1, bsize >> 2, 0xffffffff, 0))
 396                 return FPGA_FAIL;
 397
 398         isr_status = readl(&devcfg_base->int_sts);
 399         /* Check FPGA configuration completion */
 400         ts = get_timer(0);
 401         while (!(isr_status & DEVCFG_ISR_PCFG_DONE)) {
 402                 if (get_timer(ts) > CONFIG_SYS_FPGA_WAIT) {
 403                         printf("%s: Timeout wait for FPGA to config\n",
 404                                __func__);
 405                         return FPGA_FAIL;
 406                 }
 407                 isr_status = readl(&devcfg_base->int_sts);
 408         }
 409
 410         debug("%s: FPGA config done\n", __func__);
 411
 412         if (bstype != BIT_PARTIAL)
 413                 zynq_slcr_devcfg_enable();
 414
 415         puts("INFO:post config was not run, please run manually if needed\n");
 416
 417         return FPGA_SUCCESS;
 418 }
 419
 420 #if defined(CONFIG_CMD_FPGA_LOADFS) && !defined(CONFIG_SPL_BUILD)
 421 static int zynq_loadfs(xilinx_desc *desc, const void *buf, size_t bsize,
 422                        fpga_fs_info *fsinfo)
 423 {
 424         unsigned long ts; /* Timestamp */
 425         u32 isr_status, swap;
 426         u32 partialbit = 0;
 427         loff_t blocksize, actread;
 428         loff_t pos = 0;
 429         int fstype;
 430         char *interface, *dev_part;
 431         const char *filename;
 432
 433         blocksize = fsinfo->blocksize;
 434         interface = fsinfo->interface;
 435         dev_part = fsinfo->dev_part;
 436         filename = fsinfo->filename;
 437         fstype = fsinfo->fstype;
 438
 439         if (fs_set_blk_dev(interface, dev_part, fstype))
 440                 return FPGA_FAIL;
 441
 442         if (fs_read(filename, (u32) buf, pos, blocksize, &actread) < 0)
 443                 return FPGA_FAIL;
 444
 445         if (zynq_validate_bitstream(desc, buf, bsize, blocksize, &swap,
 446                                     &partialbit))
 447                 return FPGA_FAIL;
 448
 449         dcache_disable();
 450
 451         do {
 452                 buf = zynq_align_dma_buffer((u32 *)buf, blocksize, swap);
 453
 454                 if (zynq_dma_transfer((u32)buf | 1, blocksize >> 2,
 455                                       0xffffffff, 0))
 456                         return FPGA_FAIL;
 457
 458                 bsize -= blocksize;
 459                 pos   += blocksize;
 460
 461                 if (fs_set_blk_dev(interface, dev_part, fstype))
 462                         return FPGA_FAIL;
 463
 464                 if (bsize > blocksize) {
 465                         if (fs_read(filename, (u32) buf, pos, blocksize, &actread) < 0)
 466                                 return FPGA_FAIL;
 467                 } else {
 468                         if (fs_read(filename, (u32) buf, pos, bsize, &actread) < 0)
 469                                 return FPGA_FAIL;
 470                 }
 471         } while (bsize > blocksize);
 472
 473         buf = zynq_align_dma_buffer((u32 *)buf, blocksize, swap);
 474
 475         if (zynq_dma_transfer((u32)buf | 1, bsize >> 2, 0xffffffff, 0))
 476                 return FPGA_FAIL;
 477
 478         dcache_enable();
 479
 480         isr_status = readl(&devcfg_base->int_sts);
 481
 482         /* Check FPGA configuration completion */
 483         ts = get_timer(0);
 484         while (!(isr_status & DEVCFG_ISR_PCFG_DONE)) {
 485                 if (get_timer(ts) > CONFIG_SYS_FPGA_WAIT) {
 486                         printf("%s: Timeout wait for FPGA to config\n",
 487                                __func__);
 488                         return FPGA_FAIL;
 489                 }
 490                 isr_status = readl(&devcfg_base->int_sts);
 491         }
 492
 493         debug("%s: FPGA config done\n", __func__);
 494
 495         if (!partialbit)
 496                 zynq_slcr_devcfg_enable();
 497
 498         return FPGA_SUCCESS;
 499 }
 500 #endif
 501
 502 struct xilinx_fpga_op zynq_op = {
 503         .load = zynq_load,
 504 #if defined(CONFIG_CMD_FPGA_LOADFS) && !defined(CONFIG_SPL_BUILD)
 505         .loadfs = zynq_loadfs,
 506 #endif
 507 };
 508
 509 #ifdef CONFIG_CMD_ZYNQ_AES
 510 /*
 511  * Load the encrypted image from src addr and decrypt the image and
 512  * place it back the decrypted image into dstaddr.
 513  */
 514 int zynq_decrypt_load(u32 srcaddr, u32 srclen, u32 dstaddr, u32 dstlen)
 515 {
 516         if (srcaddr < SZ_1M || dstaddr < SZ_1M) {
 517                 printf("%s: src and dst addr should be > 1M\n",
 518                        __func__);
 519                 return FPGA_FAIL;
 520         }
 521
 522         if (zynq_dma_xfer_init(BIT_NONE)) {
 523                 printf("%s: zynq_dma_xfer_init FAIL\n", __func__);
 524                 return FPGA_FAIL;
 525         }
 526
 527         writel((readl(&devcfg_base->ctrl) | DEVCFG_CTRL_PCAP_RATE_EN_MASK),
 528                &devcfg_base->ctrl);
 529
 530         debug("%s: Source = 0x%08X\n", __func__, (u32)srcaddr);
 531         debug("%s: Size = %zu\n", __func__, srclen);
 532
 533         /* flush(clean & invalidate) d-cache range buf */
 534         flush_dcache_range((u32)srcaddr, (u32)srcaddr +
 535                         roundup(srclen << 2, ARCH_DMA_MINALIGN));
 536         /*
 537          * Flush destination address range only if image is not
 538          * bitstream.
 539          */
 540         flush_dcache_range((u32)dstaddr, (u32)dstaddr +
 541                            roundup(dstlen << 2, ARCH_DMA_MINALIGN));
 542
 543         if (zynq_dma_transfer(srcaddr | 1, srclen, dstaddr | 1, dstlen))
 544                 return FPGA_FAIL;
 545
 546         writel((readl(&devcfg_base->ctrl) & ~DEVCFG_CTRL_PCAP_RATE_EN_MASK),
 547                &devcfg_base->ctrl);
 548
 549         return FPGA_SUCCESS;
 550 }
 551 #endif