projects / openwrt / staging / mkresin.git / blob
? search:


c919a2a13145b34c6e3a706540c4ad289e1df552
[openwrt/staging/mkresin.git] / tools / firmware-utils / src / mkfwimage.c
1 /*
2 * Copyright (C) 2007 Ubiquiti Networks, Inc.
3 * Copyright (C) 2008 Lukas Kuna <ValXdater@seznam.cz>
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation; either version 2 of the
8 * License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19
20 #include <sys/types.h>
21 #include <sys/stat.h>
22 #include <fcntl.h>
23 #include <unistd.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <zlib.h>
27 #include <sys/mman.h>
28 #include <netinet/in.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <limits.h>
32 #include <stdbool.h>
33 #include "fw.h"
34
35 typedef struct fw_layout_data {
36 u_int32_t kern_start;
37 u_int32_t kern_entry;
38 u_int32_t firmware_max_length;
39 } fw_layout_t;
40
41 struct fw_info {
42 char name[PATH_MAX];
43 struct fw_layout_data fw_layout;
44 bool sign;
45 };
46
47 struct fw_info fw_info[] = {
48 {
49 .name = "XS2",
50 .fw_layout = {
51 .kern_start = 0xbfc30000,
52 .kern_entry = 0x80041000,
53 .firmware_max_length= 0x00390000,
54 },
55 .sign = false,
56 },
57 {
58 .name = "XS5",
59 .fw_layout = {
60 .kern_start = 0xbe030000,
61 .kern_entry = 0x80041000,
62 .firmware_max_length= 0x00390000,
63 },
64 .sign = false,
65 },
66 {
67 .name = "RS",
68 .fw_layout = {
69 .kern_start = 0xbf030000,
70 .kern_entry = 0x80060000,
71 .firmware_max_length= 0x00B00000,
72 },
73 .sign = false,
74 },
75 {
76 .name = "RSPRO",
77 .fw_layout = {
78 .kern_start = 0xbf030000,
79 .kern_entry = 0x80060000,
80 .firmware_max_length= 0x00F00000,
81 },
82 .sign = false,
83 },
84 {
85 .name = "LS-SR71",
86 .fw_layout = {
87 .kern_start = 0xbf030000,
88 .kern_entry = 0x80060000,
89 .firmware_max_length= 0x00640000,
90 },
91 .sign = false,
92 },
93 {
94 .name = "XS2-8",
95 .fw_layout = {
96 .kern_start = 0xa8030000,
97 .kern_entry = 0x80041000,
98 .firmware_max_length= 0x006C0000,
99 },
100 .sign = false,
101
102 },
103 {
104 .name = "XM",
105 .fw_layout = {
106 .kern_start = 0x9f050000,
107 .kern_entry = 0x80002000,
108 .firmware_max_length= 0x00760000,
109 },
110 .sign = false,
111 },
112 {
113 .name = "UBDEV01",
114 .fw_layout = {
115 .kern_start = 0x9f050000,
116 .kern_entry = 0x80002000,
117 .firmware_max_length= 0x006A0000,
118 },
119 .sign = false,
120 },
121 {
122 .name = "WA",
123 .fw_layout = {
124 .kern_start = 0x9f050000,
125 .kern_entry = 0x80002000,
126 .firmware_max_length= 0x00F60000,
127 },
128 .sign = true,
129 },
130 {
131 .name = "",
132 },
133 };
134
135 typedef struct part_data {
136 char partition_name[64];
137 int partition_index;
138 u_int32_t partition_baseaddr;
139 u_int32_t partition_startaddr;
140 u_int32_t partition_memaddr;
141 u_int32_t partition_entryaddr;
142 u_int32_t partition_length;
143
144 char filename[PATH_MAX];
145 struct stat stats;
146 } part_data_t;
147
148 #define MAX_SECTIONS 8
149 #define DEFAULT_OUTPUT_FILE "firmware-image.bin"
150 #define DEFAULT_VERSION "UNKNOWN"
151
152 #define OPTIONS "B:hv:m:o:r:k:"
153
154 typedef struct image_info {
155 char magic[16];
156 char version[256];
157 char outputfile[PATH_MAX];
158 u_int32_t part_count;
159 part_data_t parts[MAX_SECTIONS];
160 struct fw_info* fwinfo;
161 } image_info_t;
162
163 static struct fw_info* get_fwinfo(char* board_name) {
164 struct fw_info *fwinfo = fw_info;
165 while(strlen(fwinfo->name)) {
166 if(strcmp(fwinfo->name, board_name) == 0) {
167 return fwinfo;
168 }
169 fwinfo++;
170 }
171 return NULL;
172 }
173
174 static void write_header(void* mem, const char *magic, const char* version)
175 {
176 header_t* header = mem;
177 memset(header, 0, sizeof(header_t));
178
179 memcpy(header->magic, magic, MAGIC_LENGTH);
180 strncpy(header->version, version, sizeof(header->version));
181 header->crc = htonl(crc32(0L, (unsigned char *)header,
182 sizeof(header_t) - 2 * sizeof(u_int32_t)));
183 header->pad = 0L;
184 }
185
186
187 static void write_signature(void* mem, u_int32_t sig_offset)
188 {
189 /* write signature */
190 signature_t* sign = (signature_t*)(mem + sig_offset);
191 memset(sign, 0, sizeof(signature_t));
192
193 memcpy(sign->magic, MAGIC_END, MAGIC_LENGTH);
194 sign->crc = htonl(crc32(0L,(unsigned char *)mem, sig_offset));
195 sign->pad = 0L;
196 }
197
198 static void write_signature_rsa(void* mem, u_int32_t sig_offset)
199 {
200 /* write signature */
201 signature_rsa_t* sign = (signature_rsa_t*)(mem + sig_offset);
202 memset(sign, 0, sizeof(signature_rsa_t));
203
204 memcpy(sign->magic, MAGIC_ENDS, MAGIC_LENGTH);
205 // sign->crc = htonl(crc32(0L,(unsigned char *)mem, sig_offset));
206 sign->pad = 0L;
207 }
208
209 static int write_part(void* mem, part_data_t* d)
210 {
211 char* addr;
212 int fd;
213 part_t* p = mem;
214 part_crc_t* crc = mem + sizeof(part_t) + d->stats.st_size;
215
216 fd = open(d->filename, O_RDONLY);
217 if (fd < 0)
218 {
219 ERROR("Failed opening file '%s'\n", d->filename);
220 return -1;
221 }
222
223 if ((addr=(char*)mmap(0, d->stats.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED)
224 {
225 ERROR("Failed mmaping memory for file '%s'\n", d->filename);
226 close(fd);
227 return -2;
228 }
229
230 memcpy(mem + sizeof(part_t), addr, d->stats.st_size);
231 munmap(addr, d->stats.st_size);
232
233 memset(p->name, 0, sizeof(p->name));
234 strncpy(p->magic, MAGIC_PART, MAGIC_LENGTH);
235 strncpy(p->name, d->partition_name, sizeof(p->name));
236 p->index = htonl(d->partition_index);
237 p->data_size = htonl(d->stats.st_size);
238 p->part_size = htonl(d->partition_length);
239 p->baseaddr = htonl(d->partition_baseaddr);
240 p->memaddr = htonl(d->partition_memaddr);
241 p->entryaddr = htonl(d->partition_entryaddr);
242
243 crc->crc = htonl(crc32(0L, mem, d->stats.st_size + sizeof(part_t)));
244 crc->pad = 0L;
245
246 return 0;
247 }
248
249 static void usage(const char* progname)
250 {
251 INFO("Version %s\n"
252 "Usage: %s [options]\n"
253 "\t-v <version string>\t - firmware version information, default: %s\n"
254 "\t-o <output file>\t - firmware output file, default: %s\n"
255 "\t-m <magic>\t - firmware magic, default: %s\n"
256 "\t-k <kernel file>\t\t - kernel file\n"
257 "\t-r <rootfs file>\t\t - rootfs file\n"
258 "\t-B <board name>\t\t - choose firmware layout for specified board (XS2, XS5, RS, XM)\n"
259 "\t-h\t\t\t - this help\n", VERSION,
260 progname, DEFAULT_VERSION, DEFAULT_OUTPUT_FILE, MAGIC_HEADER);
261 }
262
263 static void print_image_info(const image_info_t* im)
264 {
265 unsigned int i = 0;
266
267 INFO("Firmware version: '%s'\n"
268 "Output file: '%s'\n"
269 "Part count: %u\n",
270 im->version, im->outputfile,
271 im->part_count);
272
273 for (i = 0; i < im->part_count; ++i)
274 {
275 const part_data_t* d = &im->parts[i];
276 INFO(" %10s: %8ld bytes (free: %8ld)\n",
277 d->partition_name,
278 d->stats.st_size,
279 d->partition_length - d->stats.st_size);
280 }
281 }
282
283 static u_int32_t filelength(const char* file)
284 {
285 FILE *p;
286 int ret = -1;
287
288 if ( (p = fopen(file, "rb") ) == NULL) return (-1);
289
290 fseek(p, 0, SEEK_END);
291 ret = ftell(p);
292
293 fclose (p);
294
295 return (ret);
296 }
297
298 static int create_image_layout(const char* kernelfile, const char* rootfsfile, char* board_name, image_info_t* im)
299 {
300 part_data_t* kernel = &im->parts[0];
301 part_data_t* rootfs = &im->parts[1];
302
303 fw_layout_t* p = &im->fwinfo->fw_layout;
304
305 printf("board = %s\n", im->fwinfo->name);
306 strcpy(kernel->partition_name, "kernel");
307 kernel->partition_index = 1;
308 kernel->partition_baseaddr = p->kern_start;
309 if ( (kernel->partition_length = filelength(kernelfile)) == (u_int32_t)-1) return (-1);
310 kernel->partition_memaddr = p->kern_entry;
311 kernel->partition_entryaddr = p->kern_entry;
312 strncpy(kernel->filename, kernelfile, sizeof(kernel->filename));
313
314 if (filelength(rootfsfile) + kernel->partition_length > p->firmware_max_length)
315 return (-2);
316
317 strcpy(rootfs->partition_name, "rootfs");
318 rootfs->partition_index = 2;
319 rootfs->partition_baseaddr = kernel->partition_baseaddr + kernel->partition_length;
320 rootfs->partition_length = p->firmware_max_length - kernel->partition_length;
321 rootfs->partition_memaddr = 0x00000000;
322 rootfs->partition_entryaddr = 0x00000000;
323 strncpy(rootfs->filename, rootfsfile, sizeof(rootfs->filename));
324
325 printf("kernel: %d 0x%08x\n", kernel->partition_length, kernel->partition_baseaddr);
326 printf("root: %d 0x%08x\n", rootfs->partition_length, rootfs->partition_baseaddr);
327 im->part_count = 2;
328
329 return 0;
330 }
331
332 /**
333 * Checks the availability and validity of all image components.
334 * Fills in stats member of the part_data structure.
335 */
336 static int validate_image_layout(image_info_t* im)
337 {
338 unsigned int i;
339
340 if (im->part_count == 0 || im->part_count > MAX_SECTIONS)
341 {
342 ERROR("Invalid part count '%d'\n", im->part_count);
343 return -1;
344 }
345
346 for (i = 0; i < im->part_count; ++i)
347 {
348 part_data_t* d = &im->parts[i];
349 int len = strlen(d->partition_name);
350 if (len == 0 || len > 16)
351 {
352 ERROR("Invalid partition name '%s' of the part %d\n",
353 d->partition_name, i);
354 return -1;
355 }
356 if (stat(d->filename, &d->stats) < 0)
357 {
358 ERROR("Couldn't stat file '%s' from part '%s'\n",
359 d->filename, d->partition_name);
360 return -2;
361 }
362 if (d->stats.st_size == 0)
363 {
364 ERROR("File '%s' from part '%s' is empty!\n",
365 d->filename, d->partition_name);
366 return -3;
367 }
368 if (d->stats.st_size > d->partition_length) {
369 ERROR("File '%s' too big (%d) - max size: 0x%08X (exceeds %lu bytes)\n",
370 d->filename, i, d->partition_length,
371 d->stats.st_size - d->partition_length);
372 return -4;
373 }
374 }
375
376 return 0;
377 }
378
379 static int build_image(image_info_t* im)
380 {
381 char* mem;
382 char* ptr;
383 u_int32_t mem_size;
384 FILE* f;
385 unsigned int i;
386
387 // build in-memory buffer
388 mem_size = sizeof(header_t);
389 if(im->fwinfo->sign) {
390 mem_size += sizeof(signature_rsa_t);
391 } else {
392 mem_size += sizeof(signature_t);
393 }
394 for (i = 0; i < im->part_count; ++i)
395 {
396 part_data_t* d = &im->parts[i];
397 mem_size += sizeof(part_t) + d->stats.st_size + sizeof(part_crc_t);
398 }
399
400 mem = (char*)calloc(mem_size, 1);
401 if (mem == NULL)
402 {
403 ERROR("Cannot allocate memory chunk of size '%u'\n", mem_size);
404 return -1;
405 }
406
407 // write header
408 write_header(mem, im->magic, im->version);
409 ptr = mem + sizeof(header_t);
410 // write all parts
411 for (i = 0; i < im->part_count; ++i)
412 {
413 part_data_t* d = &im->parts[i];
414 int rc;
415 if ((rc = write_part(ptr, d)) != 0)
416 {
417 ERROR("ERROR: failed writing part %u '%s'\n", i, d->partition_name);
418 }
419 ptr += sizeof(part_t) + d->stats.st_size + sizeof(part_crc_t);
420 }
421 // write signature
422 if(im->fwinfo->sign) {
423 write_signature_rsa(mem, mem_size - sizeof(signature_rsa_t));
424 } else {
425 write_signature(mem, mem_size - sizeof(signature_t));
426 }
427
428 // write in-memory buffer into file
429 if ((f = fopen(im->outputfile, "w")) == NULL)
430 {
431 ERROR("Can not create output file: '%s'\n", im->outputfile);
432 return -10;
433 }
434
435 if (fwrite(mem, mem_size, 1, f) != 1)
436 {
437 ERROR("Could not write %d bytes into file: '%s'\n",
438 mem_size, im->outputfile);
439 return -11;
440 }
441
442 free(mem);
443 fclose(f);
444 return 0;
445 }
446
447
448 int main(int argc, char* argv[])
449 {
450 char kernelfile[PATH_MAX];
451 char rootfsfile[PATH_MAX];
452 char board_name[PATH_MAX];
453 int o, rc;
454 image_info_t im;
455 struct fw_info *fwinfo;
456
457 memset(&im, 0, sizeof(im));
458 memset(kernelfile, 0, sizeof(kernelfile));
459 memset(rootfsfile, 0, sizeof(rootfsfile));
460 memset(board_name, 0, sizeof(board_name));
461
462 strcpy(im.outputfile, DEFAULT_OUTPUT_FILE);
463 strcpy(im.version, DEFAULT_VERSION);
464 strncpy(im.magic, MAGIC_HEADER, sizeof(im.magic));
465
466 while ((o = getopt(argc, argv, OPTIONS)) != -1)
467 {
468 switch (o) {
469 case 'v':
470 if (optarg)
471 strncpy(im.version, optarg, sizeof(im.version));
472 break;
473 case 'o':
474 if (optarg)
475 strncpy(im.outputfile, optarg, sizeof(im.outputfile));
476 break;
477 case 'm':
478 if (optarg)
479 strncpy(im.magic, optarg, sizeof(im.magic));
480 break;
481 case 'h':
482 usage(argv[0]);
483 return -1;
484 case 'k':
485 if (optarg)
486 strncpy(kernelfile, optarg, sizeof(kernelfile));
487 break;
488 case 'r':
489 if (optarg)
490 strncpy(rootfsfile, optarg, sizeof(rootfsfile));
491 break;
492 case 'B':
493 if (optarg)
494 strncpy(board_name, optarg, sizeof(board_name));
495 break;
496 }
497 }
498 if (strlen(board_name) == 0)
499 strcpy(board_name, "XS2"); /* default to XS2 */
500
501 if (strlen(kernelfile) == 0)
502 {
503 ERROR("Kernel file is not specified, cannot continue\n");
504 usage(argv[0]);
505 return -2;
506 }
507
508 if (strlen(rootfsfile) == 0)
509 {
510 ERROR("Root FS file is not specified, cannot continue\n");
511 usage(argv[0]);
512 return -2;
513 }
514
515 if ((fwinfo = get_fwinfo(board_name)) == NULL) {
516 ERROR("Invalid baord name '%s'\n", board_name);
517 usage(argv[0]);
518 return -2;
519 }
520
521 im.fwinfo = fwinfo;
522
523 if ((rc = create_image_layout(kernelfile, rootfsfile, board_name, &im)) != 0)
524 {
525 ERROR("Failed creating firmware layout description - error code: %d\n", rc);
526 return -3;
527 }
528
529 if ((rc = validate_image_layout(&im)) != 0)
530 {
531 ERROR("Failed validating firmware layout - error code: %d\n", rc);
532 return -4;
533 }
534
535 print_image_info(&im);
536
537 if ((rc = build_image(&im)) != 0)
538 {
539 ERROR("Failed building image file '%s' - error code: %d\n", im.outputfile, rc);
540 return -5;
541 }
542
543 return 0;
544 }
Staging tree of Mathias Kresin