xref: /openbmc/u-boot/tools/pblimage.c (revision aa04fef4)
1 /*
2  * Copyright 2012 Freescale Semiconductor, Inc.
3  *
4  * SPDX-License-Identifier:	GPL-2.0+
5  */
6 #include "mkimage.h"
7 #include <image.h>
8 #include "pblimage.h"
9 
10 /*
11  * Initialize to an invalid value.
12  */
13 static uint32_t next_pbl_cmd = 0x82000000;
14 /*
15  * need to store all bytes in memory for calculating crc32, then write the
16  * bytes to image file for PBL boot.
17  */
18 static unsigned char mem_buf[1000000];
19 static unsigned char *pmem_buf = mem_buf;
20 static int pbl_size;
21 static char *fname = "Unknown";
22 static int lineno = -1;
23 static struct pbl_header pblimage_header;
24 
25 static union
26 {
27 	char c[4];
28 	unsigned char l;
29 } endian_test = { {'l', '?', '?', 'b'} };
30 
31 #define ENDIANNESS ((char)endian_test.l)
32 
33 /*
34  * The PBL can load up to 64 bytes at a time, so we split the U-Boot
35  * image into 64 byte chunks. PBL needs a command for each piece, of
36  * the form "81xxxxxx", where "xxxxxx" is the offset. Calculate the
37  * start offset by subtracting the size of the u-boot image from the
38  * top of the allowable 24-bit range.
39  */
40 static void init_next_pbl_cmd(FILE *fp_uboot)
41 {
42 	struct stat st;
43 	int fd = fileno(fp_uboot);
44 
45 	if (fstat(fd, &st) == -1) {
46 		printf("Error: Could not determine u-boot image size. %s\n",
47 			strerror(errno));
48 		exit(EXIT_FAILURE);
49 	}
50 
51 	next_pbl_cmd = 0x82000000 - st.st_size;
52 }
53 
54 static void generate_pbl_cmd(void)
55 {
56 	uint32_t val = next_pbl_cmd;
57 	next_pbl_cmd += 0x40;
58 	int i;
59 
60 	for (i = 3; i >= 0; i--) {
61 		*pmem_buf++ = (val >> (i * 8)) & 0xff;
62 		pbl_size++;
63 	}
64 }
65 
66 static void pbl_fget(size_t size, FILE *stream)
67 {
68 	unsigned char c;
69 	int c_temp;
70 
71 	while (size && (c_temp = fgetc(stream)) != EOF) {
72 		c = (unsigned char)c_temp;
73 		*pmem_buf++ = c;
74 		pbl_size++;
75 		size--;
76 	}
77 }
78 
79 /* load split u-boot with PBI command 81xxxxxx. */
80 static void load_uboot(FILE *fp_uboot)
81 {
82 	init_next_pbl_cmd(fp_uboot);
83 	while (next_pbl_cmd < 0x82000000) {
84 		generate_pbl_cmd();
85 		pbl_fget(64, fp_uboot);
86 	}
87 }
88 
89 static void check_get_hexval(char *token)
90 {
91 	uint32_t hexval;
92 	int i;
93 
94 	if (!sscanf(token, "%x", &hexval)) {
95 		printf("Error:%s[%d] - Invalid hex data(%s)\n", fname,
96 			lineno, token);
97 		exit(EXIT_FAILURE);
98 	}
99 	for (i = 3; i >= 0; i--) {
100 		*pmem_buf++ = (hexval >> (i * 8)) & 0xff;
101 		pbl_size++;
102 	}
103 }
104 
105 static void pbl_parser(char *name)
106 {
107 	FILE *fd = NULL;
108 	char *line = NULL;
109 	char *token, *saveptr1, *saveptr2;
110 	size_t len = 0;
111 
112 	fname = name;
113 	fd = fopen(name, "r");
114 	if (fd == NULL) {
115 		printf("Error:%s - Can't open\n", fname);
116 		exit(EXIT_FAILURE);
117 	}
118 
119 	while ((getline(&line, &len, fd)) > 0) {
120 		lineno++;
121 		token = strtok_r(line, "\r\n", &saveptr1);
122 		/* drop all lines with zero tokens (= empty lines) */
123 		if (token == NULL)
124 			continue;
125 		for (line = token;; line = NULL) {
126 			token = strtok_r(line, " \t", &saveptr2);
127 			if (token == NULL)
128 				break;
129 			/* Drop all text starting with '#' as comments */
130 			if (token[0] == '#')
131 				break;
132 			check_get_hexval(token);
133 		}
134 	}
135 	if (line)
136 		free(line);
137 	fclose(fd);
138 }
139 
140 static uint32_t crc_table[256];
141 
142 static void make_crc_table(void)
143 {
144 	uint32_t mask;
145 	int i, j;
146 	uint32_t poly; /* polynomial exclusive-or pattern */
147 
148 	/*
149 	 * the polynomial used by PBL is 1 + x1 + x2 + x4 + x5 + x7 + x8 + x10
150 	 * + x11 + x12 + x16 + x22 + x23 + x26 + x32.
151 	 */
152 	poly = 0x04c11db7;
153 
154 	for (i = 0; i < 256; i++) {
155 		mask = i << 24;
156 		for (j = 0; j < 8; j++) {
157 			if (mask & 0x80000000)
158 				mask = (mask << 1) ^ poly;
159 			else
160 				mask <<= 1;
161 		}
162 		crc_table[i] = mask;
163 	}
164 }
165 
166 unsigned long pbl_crc32(unsigned long crc, const char *buf, uint32_t len)
167 {
168 	uint32_t crc32_val = 0xffffffff;
169 	uint32_t xor = 0x0;
170 	int i;
171 
172 	make_crc_table();
173 
174 	for (i = 0; i < len; i++)
175 		crc32_val = (crc32_val << 8) ^
176 			crc_table[(crc32_val >> 24) ^ (*buf++ & 0xff)];
177 
178 	crc32_val = crc32_val ^ xor;
179 	if (crc32_val < 0) {
180 		crc32_val += 0xffffffff;
181 		crc32_val += 1;
182 	}
183 	return crc32_val;
184 }
185 
186 static uint32_t reverse_byte(uint32_t val)
187 {
188 	uint32_t temp;
189 	unsigned char *p1;
190 	int j;
191 
192 	temp = val;
193 	p1 = (unsigned char *)&temp;
194 	for (j = 3; j >= 0; j--)
195 		*p1++ = (val >> (j * 8)) & 0xff;
196 	return temp;
197 }
198 
199 /* write end command and crc command to memory. */
200 static void add_end_cmd(void)
201 {
202 	uint32_t pbl_end_cmd[4] = {0x09138000, 0x00000000,
203 		0x091380c0, 0x00000000};
204 	uint32_t crc32_pbl;
205 	int i;
206 	unsigned char *p = (unsigned char *)&pbl_end_cmd;
207 
208 	if (ENDIANNESS == 'l') {
209 		for (i = 0; i < 4; i++)
210 			pbl_end_cmd[i] = reverse_byte(pbl_end_cmd[i]);
211 	}
212 
213 	for (i = 0; i < 16; i++) {
214 		*pmem_buf++ = *p++;
215 		pbl_size++;
216 	}
217 
218 	/* Add PBI CRC command. */
219 	*pmem_buf++ = 0x08;
220 	*pmem_buf++ = 0x13;
221 	*pmem_buf++ = 0x80;
222 	*pmem_buf++ = 0x40;
223 	pbl_size += 4;
224 
225 	/* calculated CRC32 and write it to memory. */
226 	crc32_pbl = pbl_crc32(0, (const char *)mem_buf, pbl_size);
227 	*pmem_buf++ = (crc32_pbl >> 24) & 0xff;
228 	*pmem_buf++ = (crc32_pbl >> 16) & 0xff;
229 	*pmem_buf++ = (crc32_pbl >> 8) & 0xff;
230 	*pmem_buf++ = (crc32_pbl) & 0xff;
231 	pbl_size += 4;
232 
233 	if ((pbl_size % 16) != 0) {
234 		for (i = 0; i < 8; i++) {
235 			*pmem_buf++ = 0x0;
236 			pbl_size++;
237 		}
238 	}
239 	if ((pbl_size % 16 != 0)) {
240 		printf("Error: Bad size of image file\n");
241 		exit(EXIT_FAILURE);
242 	}
243 }
244 
245 void pbl_load_uboot(int ifd, struct mkimage_params *params)
246 {
247 	FILE *fp_uboot;
248 	int size;
249 
250 	/* parse the rcw.cfg file. */
251 	pbl_parser(params->imagename);
252 
253 	/* parse the pbi.cfg file. */
254 	pbl_parser(params->imagename2);
255 
256 	fp_uboot = fopen(params->datafile, "r");
257 	if (fp_uboot == NULL) {
258 		printf("Error: %s open failed\n", params->datafile);
259 		exit(EXIT_FAILURE);
260 	}
261 
262 	load_uboot(fp_uboot);
263 	add_end_cmd();
264 	fclose(fp_uboot);
265 	lseek(ifd, 0, SEEK_SET);
266 
267 	size = pbl_size;
268 	if (write(ifd, (const void *)&mem_buf, size) != size) {
269 		fprintf(stderr, "Write error on %s: %s\n",
270 			params->imagefile, strerror(errno));
271 		exit(EXIT_FAILURE);
272 	}
273 }
274 
275 static int pblimage_check_image_types(uint8_t type)
276 {
277 	if (type == IH_TYPE_PBLIMAGE)
278 		return EXIT_SUCCESS;
279 	else
280 		return EXIT_FAILURE;
281 }
282 
283 static int pblimage_verify_header(unsigned char *ptr, int image_size,
284 			struct mkimage_params *params)
285 {
286 	struct pbl_header *pbl_hdr = (struct pbl_header *) ptr;
287 
288 	/* Only a few checks can be done: search for magic numbers */
289 	if (ENDIANNESS == 'l') {
290 		if (pbl_hdr->preamble != reverse_byte(RCW_PREAMBLE))
291 			return -FDT_ERR_BADSTRUCTURE;
292 
293 		if (pbl_hdr->rcwheader != reverse_byte(RCW_HEADER))
294 			return -FDT_ERR_BADSTRUCTURE;
295 	} else {
296 		if (pbl_hdr->preamble != RCW_PREAMBLE)
297 			return -FDT_ERR_BADSTRUCTURE;
298 
299 		if (pbl_hdr->rcwheader != RCW_HEADER)
300 			return -FDT_ERR_BADSTRUCTURE;
301 	}
302 	return 0;
303 }
304 
305 static void pblimage_print_header(const void *ptr)
306 {
307 	printf("Image Type:   Freescale PBL Boot Image\n");
308 }
309 
310 static void pblimage_set_header(void *ptr, struct stat *sbuf, int ifd,
311 				struct mkimage_params *params)
312 {
313 	/*nothing need to do, pbl_load_uboot takes care of whole file. */
314 }
315 
316 /* pblimage parameters */
317 static struct image_type_params pblimage_params = {
318 	.name		= "Freescale PBL Boot Image support",
319 	.header_size	= sizeof(struct pbl_header),
320 	.hdr		= (void *)&pblimage_header,
321 	.check_image_type = pblimage_check_image_types,
322 	.verify_header	= pblimage_verify_header,
323 	.print_header	= pblimage_print_header,
324 	.set_header	= pblimage_set_header,
325 };
326 
327 void init_pbl_image_type(void)
328 {
329 	pbl_size = 0;
330 	mkimage_register(&pblimage_params);
331 }
332