1 // SPDX-License-Identifier: GPL-2.0+
3 * (C) Copyright 2012-2013, Xilinx, Michal Simek
6 * Joe Hershberger <joe.hershberger@ni.com>
14 #include <linux/sizes.h>
15 #include <asm/arch/hardware.h>
16 #include <asm/arch/sys_proto.h>
18 #define DEVCFG_CTRL_PCFG_PROG_B 0x40000000
19 #define DEVCFG_CTRL_PCFG_AES_EFUSE_MASK 0x00001000
20 #define DEVCFG_CTRL_PCAP_RATE_EN_MASK 0x02000000
21 #define DEVCFG_ISR_FATAL_ERROR_MASK 0x00740040
22 #define DEVCFG_ISR_ERROR_FLAGS_MASK 0x00340840
23 #define DEVCFG_ISR_RX_FIFO_OV 0x00040000
24 #define DEVCFG_ISR_DMA_DONE 0x00002000
25 #define DEVCFG_ISR_PCFG_DONE 0x00000004
26 #define DEVCFG_STATUS_DMA_CMD_Q_F 0x80000000
27 #define DEVCFG_STATUS_DMA_CMD_Q_E 0x40000000
28 #define DEVCFG_STATUS_DMA_DONE_CNT_MASK 0x30000000
29 #define DEVCFG_STATUS_PCFG_INIT 0x00000010
30 #define DEVCFG_MCTRL_PCAP_LPBK 0x00000010
31 #define DEVCFG_MCTRL_RFIFO_FLUSH 0x00000002
32 #define DEVCFG_MCTRL_WFIFO_FLUSH 0x00000001
34 #ifndef CONFIG_SYS_FPGA_WAIT
35 #define CONFIG_SYS_FPGA_WAIT CONFIG_SYS_HZ/100 /* 10 ms */
38 #ifndef CONFIG_SYS_FPGA_PROG_TIME
39 #define CONFIG_SYS_FPGA_PROG_TIME (CONFIG_SYS_HZ * 4) /* 4 s */
42 #define DUMMY_WORD 0xffffffff
44 /* Xilinx binary format header */
45 static const u32 bin_format
[] = {
46 DUMMY_WORD
, /* Dummy words */
54 0x000000bb, /* Sync word */
55 0x11220044, /* Sync word */
58 0xaa995566, /* Sync word */
65 * Load the whole word from unaligned buffer
66 * Keep in your mind that it is byte loading on little-endian system
68 static u32
load_word(const void *buf
, u32 swap
)
74 if (swap
== SWAP_NO
) {
75 for (p
= 0; p
< 4; p
++) {
80 for (p
= 3; p
>= 0; p
--) {
89 static u32
check_header(const void *buf
)
93 u32
*test
= (u32
*)buf
;
95 debug("%s: Let's check bitstream header\n", __func__
);
97 /* Checking that passing bin is not a bitstream */
98 for (i
= 0; i
< ARRAY_SIZE(bin_format
); i
++) {
99 pattern
= load_word(&test
[i
], swap
);
102 * Bitstreams in binary format are swapped
103 * compare to regular bistream.
104 * Do not swap dummy word but if swap is done assume
105 * that parsing buffer is binary format
107 if ((__swab32(pattern
) != DUMMY_WORD
) &&
108 (__swab32(pattern
) == bin_format
[i
])) {
109 pattern
= __swab32(pattern
);
111 debug("%s: data swapped - let's swap\n", __func__
);
114 debug("%s: %d/%x: pattern %x/%x bin_format\n", __func__
, i
,
115 (u32
)&test
[i
], pattern
, bin_format
[i
]);
116 if (pattern
!= bin_format
[i
]) {
117 debug("%s: Bitstream is not recognized\n", __func__
);
121 debug("%s: Found bitstream header at %x %s swapinng\n", __func__
,
122 (u32
)buf
, swap
== SWAP_NO
? "without" : "with");
127 static void *check_data(u8
*buf
, size_t bsize
, u32
*swap
)
129 u32 word
, p
= 0; /* possition */
131 /* Because buf doesn't need to be aligned let's read it by chars */
132 for (p
= 0; p
< bsize
; p
++) {
133 word
= load_word(&buf
[p
], SWAP_NO
);
134 debug("%s: word %x %x/%x\n", __func__
, word
, p
, (u32
)&buf
[p
]);
136 /* Find the first bitstream dummy word */
137 if (word
== DUMMY_WORD
) {
138 debug("%s: Found dummy word at position %x/%x\n",
139 __func__
, p
, (u32
)&buf
[p
]);
140 *swap
= check_header(&buf
[p
]);
142 /* FIXME add full bitstream checking here */
146 /* Loop can be huge - support CTRL + C */
153 static int zynq_dma_transfer(u32 srcbuf
, u32 srclen
, u32 dstbuf
, u32 dstlen
)
158 /* Set up the transfer */
159 writel((u32
)srcbuf
, &devcfg_base
->dma_src_addr
);
160 writel(dstbuf
, &devcfg_base
->dma_dst_addr
);
161 writel(srclen
, &devcfg_base
->dma_src_len
);
162 writel(dstlen
, &devcfg_base
->dma_dst_len
);
164 isr_status
= readl(&devcfg_base
->int_sts
);
166 /* Polling the PCAP_INIT status for Set */
168 while (!(isr_status
& DEVCFG_ISR_DMA_DONE
)) {
169 if (isr_status
& DEVCFG_ISR_ERROR_FLAGS_MASK
) {
170 debug("%s: Error: isr = 0x%08X\n", __func__
,
172 debug("%s: Write count = 0x%08X\n", __func__
,
173 readl(&devcfg_base
->write_count
));
174 debug("%s: Read count = 0x%08X\n", __func__
,
175 readl(&devcfg_base
->read_count
));
179 if (get_timer(ts
) > CONFIG_SYS_FPGA_PROG_TIME
) {
180 printf("%s: Timeout wait for DMA to complete\n",
184 isr_status
= readl(&devcfg_base
->int_sts
);
187 debug("%s: DMA transfer is done\n", __func__
);
189 /* Clear out the DMA status */
190 writel(DEVCFG_ISR_DMA_DONE
, &devcfg_base
->int_sts
);
195 static int zynq_dma_xfer_init(bitstream_type bstype
)
197 u32 status
, control
, isr_status
;
200 /* Clear loopback bit */
201 clrbits_le32(&devcfg_base
->mctrl
, DEVCFG_MCTRL_PCAP_LPBK
);
203 if (bstype
!= BIT_PARTIAL
) {
204 zynq_slcr_devcfg_disable();
206 /* Setting PCFG_PROG_B signal to high */
207 control
= readl(&devcfg_base
->ctrl
);
208 writel(control
| DEVCFG_CTRL_PCFG_PROG_B
, &devcfg_base
->ctrl
);
211 * Delay is required if AES efuse is selected as
214 if (control
& DEVCFG_CTRL_PCFG_AES_EFUSE_MASK
)
217 /* Setting PCFG_PROG_B signal to low */
218 writel(control
& ~DEVCFG_CTRL_PCFG_PROG_B
, &devcfg_base
->ctrl
);
221 * Delay is required if AES efuse is selected as
224 if (control
& DEVCFG_CTRL_PCFG_AES_EFUSE_MASK
)
227 /* Polling the PCAP_INIT status for Reset */
229 while (readl(&devcfg_base
->status
) & DEVCFG_STATUS_PCFG_INIT
) {
230 if (get_timer(ts
) > CONFIG_SYS_FPGA_WAIT
) {
231 printf("%s: Timeout wait for INIT to clear\n",
237 /* Setting PCFG_PROG_B signal to high */
238 writel(control
| DEVCFG_CTRL_PCFG_PROG_B
, &devcfg_base
->ctrl
);
240 /* Polling the PCAP_INIT status for Set */
242 while (!(readl(&devcfg_base
->status
) &
243 DEVCFG_STATUS_PCFG_INIT
)) {
244 if (get_timer(ts
) > CONFIG_SYS_FPGA_WAIT
) {
245 printf("%s: Timeout wait for INIT to set\n",
252 isr_status
= readl(&devcfg_base
->int_sts
);
254 /* Clear it all, so if Boot ROM comes back, it can proceed */
255 writel(0xFFFFFFFF, &devcfg_base
->int_sts
);
257 if (isr_status
& DEVCFG_ISR_FATAL_ERROR_MASK
) {
258 debug("%s: Fatal errors in PCAP 0x%X\n", __func__
, isr_status
);
260 /* If RX FIFO overflow, need to flush RX FIFO first */
261 if (isr_status
& DEVCFG_ISR_RX_FIFO_OV
) {
262 writel(DEVCFG_MCTRL_RFIFO_FLUSH
, &devcfg_base
->mctrl
);
263 writel(0xFFFFFFFF, &devcfg_base
->int_sts
);
268 status
= readl(&devcfg_base
->status
);
270 debug("%s: Status = 0x%08X\n", __func__
, status
);
272 if (status
& DEVCFG_STATUS_DMA_CMD_Q_F
) {
273 debug("%s: Error: device busy\n", __func__
);
277 debug("%s: Device ready\n", __func__
);
279 if (!(status
& DEVCFG_STATUS_DMA_CMD_Q_E
)) {
280 if (!(readl(&devcfg_base
->int_sts
) & DEVCFG_ISR_DMA_DONE
)) {
281 /* Error state, transfer cannot occur */
282 debug("%s: ISR indicates error\n", __func__
);
285 /* Clear out the status */
286 writel(DEVCFG_ISR_DMA_DONE
, &devcfg_base
->int_sts
);
290 if (status
& DEVCFG_STATUS_DMA_DONE_CNT_MASK
) {
291 /* Clear the count of completed DMA transfers */
292 writel(DEVCFG_STATUS_DMA_DONE_CNT_MASK
, &devcfg_base
->status
);
298 static u32
*zynq_align_dma_buffer(u32
*buf
, u32 len
, u32 swap
)
303 if ((u32
)buf
!= ALIGN((u32
)buf
, ARCH_DMA_MINALIGN
)) {
304 new_buf
= (u32
*)ALIGN((u32
)buf
, ARCH_DMA_MINALIGN
);
307 * This might be dangerous but permits to flash if
308 * ARCH_DMA_MINALIGN is greater than header size
311 debug("%s: Aligned buffer is after buffer start\n",
313 new_buf
-= ARCH_DMA_MINALIGN
;
315 printf("%s: Align buffer at %x to %x(swap %d)\n", __func__
,
316 (u32
)buf
, (u32
)new_buf
, swap
);
318 for (i
= 0; i
< (len
/4); i
++)
319 new_buf
[i
] = load_word(&buf
[i
], swap
);
322 } else if (swap
!= SWAP_DONE
) {
323 /* For bitstream which are aligned */
324 u32
*new_buf
= (u32
*)buf
;
326 printf("%s: Bitstream is not swapped(%d) - swap it\n", __func__
,
329 for (i
= 0; i
< (len
/4); i
++)
330 new_buf
[i
] = load_word(&buf
[i
], swap
);
336 static int zynq_validate_bitstream(xilinx_desc
*desc
, const void *buf
,
337 size_t bsize
, u32 blocksize
, u32
*swap
,
338 bitstream_type
*bstype
)
343 buf_start
= check_data((u8
*)buf
, blocksize
, swap
);
348 /* Check if data is postpone from start */
349 diff
= (u32
)buf_start
- (u32
)buf
;
351 printf("%s: Bitstream is not validated yet (diff %x)\n",
356 if ((u32
)buf
< SZ_1M
) {
357 printf("%s: Bitstream has to be placed up to 1MB (%x)\n",
362 if (zynq_dma_xfer_init(*bstype
))
368 static int zynq_load(xilinx_desc
*desc
, const void *buf
, size_t bsize
,
369 bitstream_type bstype
)
371 unsigned long ts
; /* Timestamp */
372 u32 isr_status
, swap
;
375 * send bsize inplace of blocksize as it was not a bitstream
378 if (zynq_validate_bitstream(desc
, buf
, bsize
, bsize
, &swap
,
382 buf
= zynq_align_dma_buffer((u32
*)buf
, bsize
, swap
);
384 debug("%s: Source = 0x%08X\n", __func__
, (u32
)buf
);
385 debug("%s: Size = %zu\n", __func__
, bsize
);
387 /* flush(clean & invalidate) d-cache range buf */
388 flush_dcache_range((u32
)buf
, (u32
)buf
+
389 roundup(bsize
, ARCH_DMA_MINALIGN
));
391 if (zynq_dma_transfer((u32
)buf
| 1, bsize
>> 2, 0xffffffff, 0))
394 isr_status
= readl(&devcfg_base
->int_sts
);
395 /* Check FPGA configuration completion */
397 while (!(isr_status
& DEVCFG_ISR_PCFG_DONE
)) {
398 if (get_timer(ts
) > CONFIG_SYS_FPGA_WAIT
) {
399 printf("%s: Timeout wait for FPGA to config\n",
403 isr_status
= readl(&devcfg_base
->int_sts
);
406 debug("%s: FPGA config done\n", __func__
);
408 if (bstype
!= BIT_PARTIAL
)
409 zynq_slcr_devcfg_enable();
414 #if defined(CONFIG_CMD_FPGA_LOADFS) && !defined(CONFIG_SPL_BUILD)
415 static int zynq_loadfs(xilinx_desc
*desc
, const void *buf
, size_t bsize
,
416 fpga_fs_info
*fsinfo
)
418 unsigned long ts
; /* Timestamp */
419 u32 isr_status
, swap
;
421 loff_t blocksize
, actread
;
424 char *interface
, *dev_part
;
425 const char *filename
;
427 blocksize
= fsinfo
->blocksize
;
428 interface
= fsinfo
->interface
;
429 dev_part
= fsinfo
->dev_part
;
430 filename
= fsinfo
->filename
;
431 fstype
= fsinfo
->fstype
;
433 if (fs_set_blk_dev(interface
, dev_part
, fstype
))
436 if (fs_read(filename
, (u32
) buf
, pos
, blocksize
, &actread
) < 0)
439 if (zynq_validate_bitstream(desc
, buf
, bsize
, blocksize
, &swap
,
446 buf
= zynq_align_dma_buffer((u32
*)buf
, blocksize
, swap
);
448 if (zynq_dma_transfer((u32
)buf
| 1, blocksize
>> 2,
455 if (fs_set_blk_dev(interface
, dev_part
, fstype
))
458 if (bsize
> blocksize
) {
459 if (fs_read(filename
, (u32
) buf
, pos
, blocksize
, &actread
) < 0)
462 if (fs_read(filename
, (u32
) buf
, pos
, bsize
, &actread
) < 0)
465 } while (bsize
> blocksize
);
467 buf
= zynq_align_dma_buffer((u32
*)buf
, blocksize
, swap
);
469 if (zynq_dma_transfer((u32
)buf
| 1, bsize
>> 2, 0xffffffff, 0))
474 isr_status
= readl(&devcfg_base
->int_sts
);
476 /* Check FPGA configuration completion */
478 while (!(isr_status
& DEVCFG_ISR_PCFG_DONE
)) {
479 if (get_timer(ts
) > CONFIG_SYS_FPGA_WAIT
) {
480 printf("%s: Timeout wait for FPGA to config\n",
484 isr_status
= readl(&devcfg_base
->int_sts
);
487 debug("%s: FPGA config done\n", __func__
);
490 zynq_slcr_devcfg_enable();
496 struct xilinx_fpga_op zynq_op
= {
498 #if defined(CONFIG_CMD_FPGA_LOADFS) && !defined(CONFIG_SPL_BUILD)
499 .loadfs
= zynq_loadfs
,
503 #ifdef CONFIG_CMD_ZYNQ_AES
505 * Load the encrypted image from src addr and decrypt the image and
506 * place it back the decrypted image into dstaddr.
508 int zynq_decrypt_load(u32 srcaddr
, u32 srclen
, u32 dstaddr
, u32 dstlen
)
510 if (srcaddr
< SZ_1M
|| dstaddr
< SZ_1M
) {
511 printf("%s: src and dst addr should be > 1M\n",
516 if (zynq_dma_xfer_init(BIT_NONE
)) {
517 printf("%s: zynq_dma_xfer_init FAIL\n", __func__
);
521 writel((readl(&devcfg_base
->ctrl
) | DEVCFG_CTRL_PCAP_RATE_EN_MASK
),
524 debug("%s: Source = 0x%08X\n", __func__
, (u32
)srcaddr
);
525 debug("%s: Size = %zu\n", __func__
, srclen
);
527 /* flush(clean & invalidate) d-cache range buf */
528 flush_dcache_range((u32
)srcaddr
, (u32
)srcaddr
+
529 roundup(srclen
<< 2, ARCH_DMA_MINALIGN
));
531 * Flush destination address range only if image is not
534 flush_dcache_range((u32
)dstaddr
, (u32
)dstaddr
+
535 roundup(dstlen
<< 2, ARCH_DMA_MINALIGN
));
537 if (zynq_dma_transfer(srcaddr
| 1, srclen
, dstaddr
| 1, dstlen
))
540 writel((readl(&devcfg_base
->ctrl
) & ~DEVCFG_CTRL_PCAP_RATE_EN_MASK
),