[thirdparty/u-boot.git] / drivers / fpga / zynqmppl.c

// SPDX-License-Identifier: GPL-2.0
/*
 * (C) Copyright 2015 - 2016, Xilinx, Inc,
 * Michal Simek <michal.simek@xilinx.com>
 * Siva Durga Prasad <siva.durga.paladugu@xilinx.com>
 */

#include <console.h>
#include <common.h>
#include <cpu_func.h>
#include <zynqmppl.h>
#include <zynqmp_firmware.h>
#include <asm/cache.h>
#include <linux/sizes.h>
#include <asm/arch/sys_proto.h>
#include <memalign.h>

#define DUMMY_WORD	0xffffffff

/* Xilinx binary format header */
static const u32 bin_format[] = {
	DUMMY_WORD, /* Dummy words */
	DUMMY_WORD,
	DUMMY_WORD,
	DUMMY_WORD,
	DUMMY_WORD,
	DUMMY_WORD,
	DUMMY_WORD,
	DUMMY_WORD,
	DUMMY_WORD,
	DUMMY_WORD,
	DUMMY_WORD,
	DUMMY_WORD,
	DUMMY_WORD,
	DUMMY_WORD,
	DUMMY_WORD,
	DUMMY_WORD,
	0x000000bb, /* Sync word */
	0x11220044, /* Sync word */
	DUMMY_WORD,
	DUMMY_WORD,
	0xaa995566, /* Sync word */
};

#define SWAP_NO		1
#define SWAP_DONE	2

/*
 * Load the whole word from unaligned buffer
 * Keep in your mind that it is byte loading on little-endian system
 */
static u32 load_word(const void *buf, u32 swap)
{
	u32 word = 0;
	u8 *bitc = (u8 *)buf;
	int p;

	if (swap == SWAP_NO) {
		for (p = 0; p < 4; p++) {
			word <<= 8;
			word |= bitc[p];
		}
	} else {
		for (p = 3; p >= 0; p--) {
			word <<= 8;
			word |= bitc[p];
		}
	}

	return word;
}

static u32 check_header(const void *buf)
{
	u32 i, pattern;
	int swap = SWAP_NO;
	u32 *test = (u32 *)buf;

	debug("%s: Let's check bitstream header\n", __func__);

	/* Checking that passing bin is not a bitstream */
	for (i = 0; i < ARRAY_SIZE(bin_format); i++) {
		pattern = load_word(&test[i], swap);

		/*
		 * Bitstreams in binary format are swapped
		 * compare to regular bistream.
		 * Do not swap dummy word but if swap is done assume
		 * that parsing buffer is binary format
		 */
		if ((__swab32(pattern) != DUMMY_WORD) &&
		    (__swab32(pattern) == bin_format[i])) {
			swap = SWAP_DONE;
			debug("%s: data swapped - let's swap\n", __func__);
		}

		debug("%s: %d/%px: pattern %x/%x bin_format\n", __func__, i,
		      &test[i], pattern, bin_format[i]);
	}
	debug("%s: Found bitstream header at %px %s swapinng\n", __func__,
	      buf, swap == SWAP_NO ? "without" : "with");

	return swap;
}

static void *check_data(u8 *buf, size_t bsize, u32 *swap)
{
	u32 word, p = 0; /* possition */

	/* Because buf doesn't need to be aligned let's read it by chars */
	for (p = 0; p < bsize; p++) {
		word = load_word(&buf[p], SWAP_NO);
		debug("%s: word %x %x/%px\n", __func__, word, p, &buf[p]);

		/* Find the first bitstream dummy word */
		if (word == DUMMY_WORD) {
			debug("%s: Found dummy word at position %x/%px\n",
			      __func__, p, &buf[p]);
			*swap = check_header(&buf[p]);
			if (*swap) {
				/* FIXME add full bitstream checking here */
				return &buf[p];
			}
		}
		/* Loop can be huge - support CTRL + C */
		if (ctrlc())
			return NULL;
	}
	return NULL;
}

static ulong zynqmp_align_dma_buffer(u32 *buf, u32 len, u32 swap)
{
	u32 *new_buf;
	u32 i;

	if ((ulong)buf != ALIGN((ulong)buf, ARCH_DMA_MINALIGN)) {
		new_buf = (u32 *)ALIGN((ulong)buf, ARCH_DMA_MINALIGN);

		/*
		 * This might be dangerous but permits to flash if
		 * ARCH_DMA_MINALIGN is greater than header size
		 */
		if (new_buf > (u32 *)buf) {
			debug("%s: Aligned buffer is after buffer start\n",
			      __func__);
			new_buf -= ARCH_DMA_MINALIGN;
		}
		printf("%s: Align buffer at %px to %px(swap %d)\n", __func__,
		       buf, new_buf, swap);

		for (i = 0; i < (len/4); i++)
			new_buf[i] = load_word(&buf[i], swap);

		buf = new_buf;
	} else if ((swap != SWAP_DONE) &&
		   (zynqmp_firmware_version() <= PMUFW_V1_0)) {
		/* For bitstream which are aligned */
		new_buf = buf;

		printf("%s: Bitstream is not swapped(%d) - swap it\n", __func__,
		       swap);

		for (i = 0; i < (len/4); i++)
			new_buf[i] = load_word(&buf[i], swap);
	}

	return (ulong)buf;
}

static int zynqmp_validate_bitstream(xilinx_desc *desc, const void *buf,
				   size_t bsize, u32 blocksize, u32 *swap)
{
	ulong *buf_start;
	ulong diff;

	buf_start = check_data((u8 *)buf, blocksize, swap);

	if (!buf_start)
		return FPGA_FAIL;

	/* Check if data is postpone from start */
	diff = (ulong)buf_start - (ulong)buf;
	if (diff) {
		printf("%s: Bitstream is not validated yet (diff %lx)\n",
		       __func__, diff);
		return FPGA_FAIL;
	}

	if ((ulong)buf < SZ_1M) {
		printf("%s: Bitstream has to be placed up to 1MB (%px)\n",
		       __func__, buf);
		return FPGA_FAIL;
	}

	return 0;
}

static int zynqmp_load(xilinx_desc *desc, const void *buf, size_t bsize,
		     bitstream_type bstype)
{
	ALLOC_CACHE_ALIGN_BUFFER(u32, bsizeptr, 1);
	u32 swap = 0;
	ulong bin_buf;
	int ret;
	u32 buf_lo, buf_hi;
	u32 ret_payload[PAYLOAD_ARG_CNT];
	bool xilfpga_old = false;

	if (zynqmp_firmware_version() <= PMUFW_V1_0) {
		puts("WARN: PMUFW v1.0 or less is detected\n");
		puts("WARN: Not all bitstream formats are supported\n");
		puts("WARN: Please upgrade PMUFW\n");
		xilfpga_old = true;
		if (zynqmp_validate_bitstream(desc, buf, bsize, bsize, &swap))
			return FPGA_FAIL;
		bsizeptr = (u32 *)&bsize;
		flush_dcache_range((ulong)bsizeptr,
				   (ulong)bsizeptr + sizeof(size_t));
		bstype |= BIT(ZYNQMP_FPGA_BIT_NS);
	}

	bin_buf = zynqmp_align_dma_buffer((u32 *)buf, bsize, swap);

	debug("%s called!\n", __func__);
	flush_dcache_range(bin_buf, bin_buf + bsize);

	buf_lo = (u32)bin_buf;
	buf_hi = upper_32_bits(bin_buf);

	if (xilfpga_old)
		ret = xilinx_pm_request(ZYNQMP_SIP_SVC_PM_FPGA_LOAD, buf_lo,
					buf_hi, (u32)(uintptr_t)bsizeptr,
					bstype, ret_payload);
	else
		ret = xilinx_pm_request(ZYNQMP_SIP_SVC_PM_FPGA_LOAD, buf_lo,
					buf_hi, (u32)bsize, 0, ret_payload);

	if (ret)
		puts("PL FPGA LOAD fail\n");

	return ret;
}

#if defined(CONFIG_CMD_FPGA_LOAD_SECURE) && !defined(CONFIG_SPL_BUILD)
static int zynqmp_loads(xilinx_desc *desc, const void *buf, size_t bsize,
			struct fpga_secure_info *fpga_sec_info)
{
	int ret;
	u32 buf_lo, buf_hi;
	u32 ret_payload[PAYLOAD_ARG_CNT];
	u8 flag = 0;

	flush_dcache_range((ulong)buf, (ulong)buf +
			   ALIGN(bsize, CONFIG_SYS_CACHELINE_SIZE));

	if (!fpga_sec_info->encflag)
		flag |= BIT(ZYNQMP_FPGA_BIT_ENC_DEV_KEY);

	if (fpga_sec_info->userkey_addr &&
	    fpga_sec_info->encflag == FPGA_ENC_USR_KEY) {
		flush_dcache_range((ulong)fpga_sec_info->userkey_addr,
				   (ulong)fpga_sec_info->userkey_addr +
				   ALIGN(KEY_PTR_LEN,
					 CONFIG_SYS_CACHELINE_SIZE));
		flag |= BIT(ZYNQMP_FPGA_BIT_ENC_USR_KEY);
	}

	if (!fpga_sec_info->authflag)
		flag |= BIT(ZYNQMP_FPGA_BIT_AUTH_OCM);

	if (fpga_sec_info->authflag == ZYNQMP_FPGA_AUTH_DDR)
		flag |= BIT(ZYNQMP_FPGA_BIT_AUTH_DDR);

	buf_lo = lower_32_bits((ulong)buf);
	buf_hi = upper_32_bits((ulong)buf);

	ret = xilinx_pm_request(ZYNQMP_SIP_SVC_PM_FPGA_LOAD, buf_lo,
				buf_hi,
			 (u32)(uintptr_t)fpga_sec_info->userkey_addr,
			 flag, ret_payload);
	if (ret)
		puts("PL FPGA LOAD fail\n");
	else
		puts("Bitstream successfully loaded\n");

	return ret;
}
#endif

static int zynqmp_pcap_info(xilinx_desc *desc)
{
	int ret;
	u32 ret_payload[PAYLOAD_ARG_CNT];

	ret = xilinx_pm_request(ZYNQMP_SIP_SVC_PM_FPGA_STATUS, 0, 0, 0,
				0, ret_payload);
	if (!ret)
		printf("PCAP status\t0x%x\n", ret_payload[1]);

	return ret;
}

struct xilinx_fpga_op zynqmp_op = {
	.load = zynqmp_load,
#if defined CONFIG_CMD_FPGA_LOAD_SECURE
	.loads = zynqmp_loads,
#endif
	.info = zynqmp_pcap_info,
};
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0
6b245014 SDPP	2	/*
	3	* (C) Copyright 2015 - 2016, Xilinx, Inc,
	4	* Michal Simek <michal.simek@xilinx.com>
	5	* Siva Durga Prasad <siva.durga.paladugu@xilinx.com>
6b245014 SDPP	6	*/
	7
	8	#include <console.h>
	9	#include <common.h>
1eb69ae4	10	#include <cpu_func.h>
6b245014	11	#include <zynqmppl.h>
009ab7b9	12	#include <zynqmp_firmware.h>
90526e9f	13	#include <asm/cache.h>
6b245014	14	#include <linux/sizes.h>
7033ae27	15	#include <asm/arch/sys_proto.h>
31bcb344	16	#include <memalign.h>
6b245014 SDPP	17
	18	#define DUMMY_WORD 0xffffffff
	19
	20	/* Xilinx binary format header */
	21	static const u32 bin_format[] = {
	22	DUMMY_WORD, /* Dummy words */
	23	DUMMY_WORD,
	24	DUMMY_WORD,
	25	DUMMY_WORD,
	26	DUMMY_WORD,
	27	DUMMY_WORD,
	28	DUMMY_WORD,
	29	DUMMY_WORD,
	30	DUMMY_WORD,
	31	DUMMY_WORD,
	32	DUMMY_WORD,
	33	DUMMY_WORD,
	34	DUMMY_WORD,
	35	DUMMY_WORD,
	36	DUMMY_WORD,
	37	DUMMY_WORD,
	38	0x000000bb, /* Sync word */
	39	0x11220044, /* Sync word */
	40	DUMMY_WORD,
	41	DUMMY_WORD,
	42	0xaa995566, /* Sync word */
	43	};
	44
	45	#define SWAP_NO 1
	46	#define SWAP_DONE 2
	47
	48	/*
	49	* Load the whole word from unaligned buffer
	50	* Keep in your mind that it is byte loading on little-endian system
	51	*/
	52	static u32 load_word(const void *buf, u32 swap)
	53	{
	54	u32 word = 0;
	55	u8 bitc = (u8 )buf;
	56	int p;
	57
	58	if (swap == SWAP_NO) {
	59	for (p = 0; p < 4; p++) {
	60	word <<= 8;
	61	word \|= bitc[p];
	62	}
	63	} else {
	64	for (p = 3; p >= 0; p--) {
	65	word <<= 8;
	66	word \|= bitc[p];
	67	}
	68	}
	69
	70	return word;
	71	}
	72
	73	static u32 check_header(const void *buf)
	74	{
	75	u32 i, pattern;
	76	int swap = SWAP_NO;
	77	u32 test = (u32 )buf;
	78
	79	debug("%s: Let's check bitstream header\n", __func__);
	80
81	/* Checking that passing bin is not a bitstream */
82	for (i = 0; i < ARRAY_SIZE(bin_format); i++) {
83	pattern = load_word(&test[i], swap);
84
85	/*
86	* Bitstreams in binary format are swapped
87	* compare to regular bistream.
88	* Do not swap dummy word but if swap is done assume
89	* that parsing buffer is binary format
90	*/
91	if ((__swab32(pattern) != DUMMY_WORD) &&
92	(__swab32(pattern) == bin_format[i])) {
93	swap = SWAP_DONE;
94	debug("%s: data swapped - let's swap\n", __func__);
95	}
96
97	debug("%s: %d/%px: pattern %x/%x bin_format\n", __func__, i,
98	&test[i], pattern, bin_format[i]);
99	}
100	debug("%s: Found bitstream header at %px %s swapinng\n", __func__,
101	buf, swap == SWAP_NO ? "without" : "with");
102
103	return swap;
104	}
105
106	static void check_data(u8 buf, size_t bsize, u32 *swap)
107	{
108	u32 word, p = 0; /* possition */
109
110	/* Because buf doesn't need to be aligned let's read it by chars */
111	for (p = 0; p < bsize; p++) {
112	word = load_word(&buf[p], SWAP_NO);
113	debug("%s: word %x %x/%px\n", __func__, word, p, &buf[p]);
114
115	/* Find the first bitstream dummy word */
116	if (word == DUMMY_WORD) {
117	debug("%s: Found dummy word at position %x/%px\n",
118	__func__, p, &buf[p]);
119	*swap = check_header(&buf[p]);
120	if (*swap) {
121	/* FIXME add full bitstream checking here */
122	return &buf[p];
123	}
124	}
125	/* Loop can be huge - support CTRL + C */
126	if (ctrlc())
127	return NULL;
128	}
129	return NULL;
130	}
131
132	static ulong zynqmp_align_dma_buffer(u32 *buf, u32 len, u32 swap)
133	{
134	u32 *new_buf;
135	u32 i;
136
137	if ((ulong)buf != ALIGN((ulong)buf, ARCH_DMA_MINALIGN)) {
138	new_buf = (u32 *)ALIGN((ulong)buf, ARCH_DMA_MINALIGN);
139
140	/*
141	* This might be dangerous but permits to flash if
142	* ARCH_DMA_MINALIGN is greater than header size
143	*/
144	if (new_buf > (u32 *)buf) {
145	debug("%s: Aligned buffer is after buffer start\n",
146	__func__);
147	new_buf -= ARCH_DMA_MINALIGN;
148	}
149	printf("%s: Align buffer at %px to %px(swap %d)\n", __func__,
150	buf, new_buf, swap);
151
152	for (i = 0; i < (len/4); i++)
153	new_buf[i] = load_word(&buf[i], swap);
154
155	buf = new_buf;
fbf7fb0f	156	} else if ((swap != SWAP_DONE) &&
5743981e	157	(zynqmp_firmware_version() <= PMUFW_V1_0)) {
6b245014	158	/* For bitstream which are aligned */
23decf01	159	new_buf = buf;
6b245014 SDPP	160
	161	printf("%s: Bitstream is not swapped(%d) - swap it\n", __func__,
	162	swap);
	163
	164	for (i = 0; i < (len/4); i++)
	165	new_buf[i] = load_word(&buf[i], swap);
	166	}
	167
	168	return (ulong)buf;
	169	}
	170
	171	static int zynqmp_validate_bitstream(xilinx_desc desc, const void buf,
	172	size_t bsize, u32 blocksize, u32 *swap)
	173	{
	174	ulong *buf_start;
	175	ulong diff;
	176
	177	buf_start = check_data((u8 *)buf, blocksize, swap);
	178
	179	if (!buf_start)
	180	return FPGA_FAIL;
	181
	182	/* Check if data is postpone from start */
	183	diff = (ulong)buf_start - (ulong)buf;
	184	if (diff) {
	185	printf("%s: Bitstream is not validated yet (diff %lx)\n",
	186	__func__, diff);
	187	return FPGA_FAIL;
	188	}
	189
	190	if ((ulong)buf < SZ_1M) {
	191	printf("%s: Bitstream has to be placed up to 1MB (%px)\n",
	192	__func__, buf);
	193	return FPGA_FAIL;
	194	}
	195
	196	return 0;
	197	}
	198
6b245014 SDPP	199	static int zynqmp_load(xilinx_desc desc, const void buf, size_t bsize,
	200	bitstream_type bstype)
	201	{
31bcb344	202	ALLOC_CACHE_ALIGN_BUFFER(u32, bsizeptr, 1);
fbf7fb0f	203	u32 swap = 0;
7033ae27	204	ulong bin_buf;
6b245014	205	int ret;
7033ae27 SDPP	206	u32 buf_lo, buf_hi;
7033ae27 SDPP	207	u32 ret_payload[PAYLOAD_ARG_CNT];
fbf7fb0f SDPP	208	bool xilfpga_old = false;
fbf7fb0f SDPP	209
5743981e	210	if (zynqmp_firmware_version() <= PMUFW_V1_0) {
fbf7fb0f SDPP	211	puts("WARN: PMUFW v1.0 or less is detected\n");
	212	puts("WARN: Not all bitstream formats are supported\n");
	213	puts("WARN: Please upgrade PMUFW\n");
	214	xilfpga_old = true;
	215	if (zynqmp_validate_bitstream(desc, buf, bsize, bsize, &swap))
	216	return FPGA_FAIL;
	217	bsizeptr = (u32 *)&bsize;
	218	flush_dcache_range((ulong)bsizeptr,
	219	(ulong)bsizeptr + sizeof(size_t));
	220	bstype \|= BIT(ZYNQMP_FPGA_BIT_NS);
	221	}
6b245014 SDPP	222
	223	bin_buf = zynqmp_align_dma_buffer((u32 *)buf, bsize, swap);
	224
	225	debug("%s called!\n", __func__);
	226	flush_dcache_range(bin_buf, bin_buf + bsize);
	227
7033ae27 SDPP	228	buf_lo = (u32)bin_buf;
7033ae27 SDPP	229	buf_hi = upper_32_bits(bin_buf);
fbf7fb0f SDPP	230
fbf7fb0f SDPP	231	if (xilfpga_old)
40361951 MS	232	ret = xilinx_pm_request(ZYNQMP_SIP_SVC_PM_FPGA_LOAD, buf_lo,
	233	buf_hi, (u32)(uintptr_t)bsizeptr,
	234	bstype, ret_payload);
fbf7fb0f	235	else
40361951 MS	236	ret = xilinx_pm_request(ZYNQMP_SIP_SVC_PM_FPGA_LOAD, buf_lo,
40361951 MS	237	buf_hi, (u32)bsize, 0, ret_payload);
fbf7fb0f	238
6b245014	239	if (ret)
8df324a2	240	puts("PL FPGA LOAD fail\n");
6b245014 SDPP	241
	242	return ret;
	243	}
	244
a18d09ea SDPP	245	#if defined(CONFIG_CMD_FPGA_LOAD_SECURE) && !defined(CONFIG_SPL_BUILD)
	246	static int zynqmp_loads(xilinx_desc desc, const void buf, size_t bsize,
	247	struct fpga_secure_info *fpga_sec_info)
	248	{
	249	int ret;
	250	u32 buf_lo, buf_hi;
	251	u32 ret_payload[PAYLOAD_ARG_CNT];
	252	u8 flag = 0;
	253
	254	flush_dcache_range((ulong)buf, (ulong)buf +
	255	ALIGN(bsize, CONFIG_SYS_CACHELINE_SIZE));
	256
	257	if (!fpga_sec_info->encflag)
	258	flag \|= BIT(ZYNQMP_FPGA_BIT_ENC_DEV_KEY);
	259
	260	if (fpga_sec_info->userkey_addr &&
	261	fpga_sec_info->encflag == FPGA_ENC_USR_KEY) {
	262	flush_dcache_range((ulong)fpga_sec_info->userkey_addr,
	263	(ulong)fpga_sec_info->userkey_addr +
	264	ALIGN(KEY_PTR_LEN,
	265	CONFIG_SYS_CACHELINE_SIZE));
	266	flag \|= BIT(ZYNQMP_FPGA_BIT_ENC_USR_KEY);
	267	}
	268
	269	if (!fpga_sec_info->authflag)
	270	flag \|= BIT(ZYNQMP_FPGA_BIT_AUTH_OCM);
	271
	272	if (fpga_sec_info->authflag == ZYNQMP_FPGA_AUTH_DDR)
	273	flag \|= BIT(ZYNQMP_FPGA_BIT_AUTH_DDR);
	274
	275	buf_lo = lower_32_bits((ulong)buf);
	276	buf_hi = upper_32_bits((ulong)buf);
	277
40361951 MS	278	ret = xilinx_pm_request(ZYNQMP_SIP_SVC_PM_FPGA_LOAD, buf_lo,
40361951 MS	279	buf_hi,
a18d09ea SDPP	280	(u32)(uintptr_t)fpga_sec_info->userkey_addr,
	281	flag, ret_payload);
	282	if (ret)
	283	puts("PL FPGA LOAD fail\n");
	284	else
	285	puts("Bitstream successfully loaded\n");
	286
	287	return ret;
	288	}
	289	#endif
	290
b32e11a7 NJ	291	static int zynqmp_pcap_info(xilinx_desc *desc)
	292	{
	293	int ret;
	294	u32 ret_payload[PAYLOAD_ARG_CNT];
	295
40361951 MS	296	ret = xilinx_pm_request(ZYNQMP_SIP_SVC_PM_FPGA_STATUS, 0, 0, 0,
40361951 MS	297	0, ret_payload);
b32e11a7 NJ	298	if (!ret)
	299	printf("PCAP status\t0x%x\n", ret_payload[1]);
	300
	301	return ret;
	302	}
	303
6b245014 SDPP	304	struct xilinx_fpga_op zynqmp_op = {
6b245014 SDPP	305	.load = zynqmp_load,
a18d09ea SDPP	306	#if defined CONFIG_CMD_FPGA_LOAD_SECURE
	307	.loads = zynqmp_loads,
	308	#endif
b32e11a7	309	.info = zynqmp_pcap_info,
6b245014	310	};