1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * (C) Copyright 2014
4 * Andreas Bießmann <andreas@biessmann.org>
5 */
6
7 #include "imagetool.h"
8 #include "mkimage.h"
9
10 #include <image.h>
11
12 #define pr_err(fmt, args...) fprintf(stderr, "atmelimage Error: " fmt, ##args)
13
atmel_check_image_type(uint8_t type)14 static int atmel_check_image_type(uint8_t type)
15 {
16 if (type == IH_TYPE_ATMELIMAGE)
17 return EXIT_SUCCESS;
18 else
19 return EXIT_FAILURE;
20 }
21
22 static uint32_t nand_pmecc_header[52];
23
24 /*
25 * A helper struct for parsing the mkimage -n parameter
26 *
27 * Keep in same order as the configs array!
28 */
29 static struct pmecc_config {
30 int use_pmecc;
31 int sector_per_page;
32 int spare_size;
33 int ecc_bits;
34 int sector_size;
35 int ecc_offset;
36 } pmecc;
37
38 /*
39 * Strings used for configure the PMECC header via -n mkimage switch
40 *
41 * We estimate a coma separated list of key=value pairs. The mkimage -n
42 * parameter argument should not contain any whitespace.
43 *
44 * Keep in same order as struct pmecc_config!
45 */
46 static const char * const configs[] = {
47 "usePmecc",
48 "sectorPerPage",
49 "spareSize",
50 "eccBits",
51 "sectorSize",
52 "eccOffset"
53 };
54
atmel_find_pmecc_parameter_in_token(const char * token)55 static int atmel_find_pmecc_parameter_in_token(const char *token)
56 {
57 size_t pos;
58 char *param;
59
60 debug("token: '%s'\n", token);
61
62 for (pos = 0; pos < ARRAY_SIZE(configs); pos++) {
63 if (strncmp(token, configs[pos], strlen(configs[pos])) == 0) {
64 param = strstr(token, "=");
65 if (!param)
66 goto err;
67
68 param++;
69 debug("\t%s parameter: '%s'\n", configs[pos], param);
70
71 switch (pos) {
72 case 0:
73 pmecc.use_pmecc = strtol(param, NULL, 10);
74 return EXIT_SUCCESS;
75 case 1:
76 pmecc.sector_per_page = strtol(param, NULL, 10);
77 return EXIT_SUCCESS;
78 case 2:
79 pmecc.spare_size = strtol(param, NULL, 10);
80 return EXIT_SUCCESS;
81 case 3:
82 pmecc.ecc_bits = strtol(param, NULL, 10);
83 return EXIT_SUCCESS;
84 case 4:
85 pmecc.sector_size = strtol(param, NULL, 10);
86 return EXIT_SUCCESS;
87 case 5:
88 pmecc.ecc_offset = strtol(param, NULL, 10);
89 return EXIT_SUCCESS;
90 }
91 }
92 }
93
94 err:
95 pr_err("Could not find parameter in token '%s'\n", token);
96 return EXIT_FAILURE;
97 }
98
atmel_parse_pmecc_params(char * txt)99 static int atmel_parse_pmecc_params(char *txt)
100 {
101 char *token;
102
103 token = strtok(txt, ",");
104 while (token != NULL) {
105 if (atmel_find_pmecc_parameter_in_token(token))
106 return EXIT_FAILURE;
107
108 token = strtok(NULL, ",");
109 }
110
111 return EXIT_SUCCESS;
112 }
113
atmel_verify_header(unsigned char * ptr,int image_size,struct image_tool_params * params)114 static int atmel_verify_header(unsigned char *ptr, int image_size,
115 struct image_tool_params *params)
116 {
117 uint32_t *ints = (uint32_t *)ptr;
118 size_t pos;
119 size_t size = image_size;
120
121 /* check if we have an PMECC header attached */
122 for (pos = 0; pos < ARRAY_SIZE(nand_pmecc_header); pos++)
123 if (ints[pos] >> 28 != 0xC)
124 break;
125
126 if (pos == ARRAY_SIZE(nand_pmecc_header)) {
127 ints += ARRAY_SIZE(nand_pmecc_header);
128 size -= sizeof(nand_pmecc_header);
129 }
130
131 /* check the seven interrupt vectors of binary */
132 for (pos = 0; pos < 7; pos++) {
133 debug("atmelimage: interrupt vector #%zu is 0x%08X\n", pos+1,
134 ints[pos]);
135 /*
136 * all vectors except the 6'th one must contain valid
137 * LDR or B Opcode
138 */
139 if (pos == 5)
140 /* 6'th vector has image size set, check later */
141 continue;
142 if ((ints[pos] & 0xff000000) == 0xea000000)
143 /* valid B Opcode */
144 continue;
145 if ((ints[pos] & 0xfffff000) == 0xe59ff000)
146 /* valid LDR (I=0, P=1, U=1, B=0, W=0, L=1) */
147 continue;
148 /* ouch, one of the checks has missed ... */
149 return 1;
150 }
151
152 return ints[5] != cpu_to_le32(size);
153 }
154
atmel_print_pmecc_header(const uint32_t word)155 static void atmel_print_pmecc_header(const uint32_t word)
156 {
157 int val;
158
159 printf("\t\tPMECC header\n");
160
161 printf("\t\t====================\n");
162
163 val = (word >> 18) & 0x1ff;
164 printf("\t\teccOffset: %9i\n", val);
165
166 val = (((word >> 16) & 0x3) == 0) ? 512 : 1024;
167 printf("\t\tsectorSize: %8i\n", val);
168
169 if (((word >> 13) & 0x7) <= 2)
170 val = (2 << ((word >> 13) & 0x7));
171 else
172 val = (12 << (((word >> 13) & 0x7) - 3));
173 printf("\t\teccBitReq: %9i\n", val);
174
175 val = (word >> 4) & 0x1ff;
176 printf("\t\tspareSize: %9i\n", val);
177
178 val = (1 << ((word >> 1) & 0x3));
179 printf("\t\tnbSectorPerPage: %3i\n", val);
180
181 printf("\t\tusePmecc: %10i\n", word & 0x1);
182 printf("\t\t====================\n");
183 }
184
atmel_print_header(const void * ptr)185 static void atmel_print_header(const void *ptr)
186 {
187 uint32_t *ints = (uint32_t *)ptr;
188 size_t pos;
189
190 /* check if we have an PMECC header attached */
191 for (pos = 0; pos < ARRAY_SIZE(nand_pmecc_header); pos++)
192 if (ints[pos] >> 28 != 0xC)
193 break;
194
195 if (pos == ARRAY_SIZE(nand_pmecc_header)) {
196 printf("Image Type:\tATMEL ROM-Boot Image with PMECC Header\n");
197 atmel_print_pmecc_header(ints[0]);
198 pos += 5;
199 } else {
200 printf("Image Type:\tATMEL ROM-Boot Image without PMECC Header\n");
201 pos = 5;
202 }
203 printf("\t\t6'th vector has %u set\n", le32_to_cpu(ints[pos]));
204 }
205
atmel_set_header(void * ptr,struct stat * sbuf,int ifd,struct image_tool_params * params)206 static void atmel_set_header(void *ptr, struct stat *sbuf, int ifd,
207 struct image_tool_params *params)
208 {
209 /* just save the image size into 6'th interrupt vector */
210 uint32_t *ints = (uint32_t *)ptr;
211 size_t cnt;
212 size_t pos = 5;
213 size_t size = sbuf->st_size;
214
215 for (cnt = 0; cnt < ARRAY_SIZE(nand_pmecc_header); cnt++)
216 if (ints[cnt] >> 28 != 0xC)
217 break;
218
219 if (cnt == ARRAY_SIZE(nand_pmecc_header)) {
220 pos += ARRAY_SIZE(nand_pmecc_header);
221 size -= sizeof(nand_pmecc_header);
222 }
223
224 ints[pos] = cpu_to_le32(size);
225 }
226
atmel_check_params(struct image_tool_params * params)227 static int atmel_check_params(struct image_tool_params *params)
228 {
229 if (strlen(params->imagename) > 0)
230 if (atmel_parse_pmecc_params(params->imagename))
231 return EXIT_FAILURE;
232
233 return !(!params->eflag &&
234 !params->fflag &&
235 !params->xflag &&
236 ((params->dflag && !params->lflag) ||
237 (params->lflag && !params->dflag)));
238 }
239
atmel_vrec_header(struct image_tool_params * params,struct image_type_params * tparams)240 static int atmel_vrec_header(struct image_tool_params *params,
241 struct image_type_params *tparams)
242 {
243 uint32_t tmp;
244 size_t pos;
245
246 if (strlen(params->imagename) == 0)
247 return EXIT_SUCCESS;
248
249 tmp = 0xC << 28;
250
251 tmp |= (pmecc.ecc_offset & 0x1ff) << 18;
252
253 switch (pmecc.sector_size) {
254 case 512:
255 tmp |= 0 << 16;
256 break;
257 case 1024:
258 tmp |= 1 << 16;
259 break;
260
261 default:
262 pr_err("Wrong sectorSize (%i) for PMECC header\n",
263 pmecc.sector_size);
264 return EXIT_FAILURE;
265 }
266
267 switch (pmecc.ecc_bits) {
268 case 2:
269 tmp |= 0 << 13;
270 break;
271 case 4:
272 tmp |= 1 << 13;
273 break;
274 case 8:
275 tmp |= 2 << 13;
276 break;
277 case 12:
278 tmp |= 3 << 13;
279 break;
280 case 24:
281 tmp |= 4 << 13;
282 break;
283
284 default:
285 pr_err("Wrong eccBits (%i) for PMECC header\n",
286 pmecc.ecc_bits);
287 return EXIT_FAILURE;
288 }
289
290 tmp |= (pmecc.spare_size & 0x1ff) << 4;
291
292 switch (pmecc.sector_per_page) {
293 case 1:
294 tmp |= 0 << 1;
295 break;
296 case 2:
297 tmp |= 1 << 1;
298 break;
299 case 4:
300 tmp |= 2 << 1;
301 break;
302 case 8:
303 tmp |= 3 << 1;
304 break;
305
306 default:
307 pr_err("Wrong sectorPerPage (%i) for PMECC header\n",
308 pmecc.sector_per_page);
309 return EXIT_FAILURE;
310 }
311
312 if (pmecc.use_pmecc)
313 tmp |= 1;
314
315 for (pos = 0; pos < ARRAY_SIZE(nand_pmecc_header); pos++)
316 nand_pmecc_header[pos] = tmp;
317
318 debug("PMECC header filled 52 times with 0x%08X\n", tmp);
319
320 tparams->header_size = sizeof(nand_pmecc_header);
321 tparams->hdr = nand_pmecc_header;
322
323 return EXIT_SUCCESS;
324 }
325
326 U_BOOT_IMAGE_TYPE(
327 atmelimage,
328 "ATMEL ROM-Boot Image support",
329 0,
330 NULL,
331 atmel_check_params,
332 atmel_verify_header,
333 atmel_print_header,
334 atmel_set_header,
335 NULL,
336 atmel_check_image_type,
337 NULL,
338 atmel_vrec_header
339 );
340