2 * Copyright (C) 2007 Ubiquiti Networks, Inc.
3 * Copyright (C) 2008 Lukas Kuna <ValXdater@seznam.cz>
4 * Copyright (C) 2008 Gabor Juhos <juhosg@openwrt.org>
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation; either version 2 of the
9 * License, or (at your option) any later version.
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 #include <sys/types.h>
29 #include <netinet/in.h>
36 #define VERSION "1.2-OpenWrt.1"
38 #define MAX_SECTIONS 8
39 #define DEFAULT_OUTPUT_FILE "firmware-image.bin"
40 #define DEFAULT_VERSION "UNKNOWN"
41 #define DEFAULT_FLASH_BASE (0xbfc00000)
43 #define FIRMWARE_MAX_LENGTH (0x390000)
45 typedef struct part_data
{
46 char partition_name
[64];
48 u_int32_t partition_baseaddr
;
49 u_int32_t partition_offset
;
50 u_int32_t partition_memaddr
;
51 u_int32_t partition_entryaddr
;
52 u_int32_t partition_length
;
54 char filename
[PATH_MAX
];
58 typedef struct image_info
{
60 char outputfile
[PATH_MAX
];
61 char magic
[MAGIC_LENGTH
];
62 u_int32_t flash_baseaddr
;
64 part_data_t parts
[MAX_SECTIONS
];
67 static image_info_t im
;
69 static int zero_part_baseaddr
= 0;
71 static void write_header(void* mem
, const char* version
)
73 header_t
* header
= mem
;
74 memset(header
, 0, sizeof(header_t
));
76 memcpy(header
->magic
, im
.magic
, MAGIC_LENGTH
);
77 strncpy(header
->version
, version
, sizeof(header
->version
));
78 header
->crc
= htonl(crc32(0L, (unsigned char *)header
,
79 sizeof(header_t
) - 2 * sizeof(u_int32_t
)));
83 static void write_signature(void* mem
, u_int32_t sig_offset
)
86 signature_t
* sign
= (signature_t
*)(mem
+ sig_offset
);
87 memset(sign
, 0, sizeof(signature_t
));
89 memcpy(sign
->magic
, MAGIC_END
, MAGIC_LENGTH
);
90 sign
->crc
= htonl(crc32(0L,(unsigned char *)mem
, sig_offset
));
94 static int write_part(void* mem
, part_data_t
* d
)
99 part_crc_t
* crc
= mem
+ sizeof(part_t
) + d
->stats
.st_size
;
101 fd
= open(d
->filename
, O_RDONLY
);
103 ERROR("Failed opening file '%s'\n", d
->filename
);
107 if ((addr
=(char*)mmap(0, d
->stats
.st_size
, PROT_READ
, MAP_SHARED
, fd
, 0)) == MAP_FAILED
) {
108 ERROR("Failed mmaping memory for file '%s'\n", d
->filename
);
113 memcpy(mem
+ sizeof(part_t
), addr
, d
->stats
.st_size
);
114 munmap(addr
, d
->stats
.st_size
);
116 memset(p
->name
, 0, sizeof(p
->name
));
117 strncpy(p
->magic
, MAGIC_PART
, MAGIC_LENGTH
);
118 strncpy(p
->name
, d
->partition_name
, sizeof(p
->name
));
119 p
->index
= htonl(d
->partition_index
);
120 p
->data_size
= htonl(d
->stats
.st_size
);
121 p
->part_size
= htonl(d
->partition_length
);
122 p
->baseaddr
= htonl(d
->partition_baseaddr
);
123 p
->memaddr
= htonl(d
->partition_memaddr
);
124 p
->entryaddr
= htonl(d
->partition_entryaddr
);
126 crc
->crc
= htonl(crc32(0L, mem
, d
->stats
.st_size
+ sizeof(part_t
)));
132 static void usage(const char* progname
)
135 "Usage: %s [options]\n"
136 "\t-v <version string>\t - firmware version information, default: %s\n"
137 "\t-m <magic>\t\t - firmware magic, default: %s\n"
138 "\t-f <flash base>\t\t - flash base address, default: 0x%08x\n"
139 "\t-o <output file>\t - firmware output file, default: %s\n"
140 "\t-p <name>:<offset>:<len>:<memaddr>:<entry>:<file>\n "
141 "\t\t\t\t - create a partition from <file>\n"
142 "\t-z\t\t\t - set partition offsets to zero\n"
143 "\t-h\t\t\t - this help\n",
144 VERSION
, progname
, DEFAULT_VERSION
, MAGIC_HEADER
,
145 DEFAULT_FLASH_BASE
, DEFAULT_OUTPUT_FILE
);
148 static void print_image_info(void)
152 INFO("Firmware version : '%s'\n"
153 "Output file : '%s'\n"
155 im
.version
, im
.outputfile
, im
.part_count
);
157 for (i
= 0; i
< im
.part_count
; ++i
) {
158 const part_data_t
* d
= &im
.parts
[i
];
159 INFO(" %10s: %08x %08x %08x %08x %8ld bytes (free: %8ld)\n",
161 d
->partition_baseaddr
,
163 d
->partition_entryaddr
,
164 d
->partition_memaddr
,
166 d
->partition_length
- d
->stats
.st_size
);
170 static int filelength(const char* file
)
175 if ( (p
= fopen(file
, "rb") ) == NULL
) return (-1);
177 fseek(p
, 0, SEEK_END
);
185 int str2u32(char *arg
, u_int32_t
*val
)
191 t
= strtoul(arg
, &err
, 0);
192 if (errno
|| (err
== arg
) || ((err
!= NULL
) && *err
)) {
201 #define STRINGIFY2(X) #X
202 #define STRINGIFY(X) STRINGIFY2(X)
204 static int image_layout_add_partition(const char *part_desc
)
213 if (im
.part_count
>= MAX_SECTIONS
) {
214 ERROR("Too many partitions specified\n");
218 d
= &im
.parts
[im
.part_count
];
219 t
= sscanf(part_desc
, "%15[-0-9a-zA-Z]:%15[0-9a-fA-Fx]:%15[0-9a-fA-Fx]:%15[0-9a-fA-Fx]:%15[0-9a-fA-Fx]:%"STRINGIFY(PATH_MAX
)"s",
228 ERROR("Bad partition parameter %d, '%s'\n", t
, part_desc
);
232 if (strlen(d
->partition_name
) == 0) {
233 ERROR("No partition name specified in '%s'\n", part_desc
);
237 if (str2u32(offset
, &d
->partition_offset
)) {
238 ERROR("Bad offset value '%s'\n", offset
);
242 if (str2u32(length
, &d
->partition_length
)) {
243 ERROR("Bad length value '%s'\n", length
);
247 if (d
->partition_length
== 0) {
249 flen
= filelength(d
->filename
);
251 ERROR("Unable to determine size of '%s'\n",
255 d
->partition_length
= flen
;
258 if (str2u32(memaddr
, &d
->partition_memaddr
)) {
259 ERROR("Bad memaddr vaule '%s'\n", memaddr
);
263 if (str2u32(entryaddr
, &d
->partition_entryaddr
)) {
264 ERROR("Bad entry address value '%s'\n", entryaddr
);
269 d
->partition_index
= im
.part_count
;
274 static int image_layout_verify(void)
279 if (im
.part_count
== 0) {
280 ERROR("No partitions specified\n");
284 offset
= im
.parts
[0].partition_offset
;
285 for (i
= 0; i
< im
.part_count
; i
++)
287 part_data_t
* d
= &im
.parts
[i
];
289 if (stat(d
->filename
, &d
->stats
) < 0) {
290 ERROR("Couldn't stat file '%s' from part '%s'\n",
291 d
->filename
, d
->partition_name
);
295 if (d
->stats
.st_size
== 0) {
296 ERROR("File '%s' from part '%s' is empty!\n",
297 d
->filename
, d
->partition_name
);
301 if (d
->stats
.st_size
> d
->partition_length
) {
302 ERROR("File '%s' too big (%d) - max size: 0x%08X (exceeds %lu bytes)\n",
303 d
->filename
, i
, d
->partition_length
,
304 d
->stats
.st_size
- d
->partition_length
);
308 if (d
->partition_offset
< offset
)
309 d
->partition_offset
= offset
;
311 if (zero_part_baseaddr
) {
312 d
->partition_baseaddr
= 0;
314 d
->partition_baseaddr
=
315 im
.flash_baseaddr
+ d
->partition_offset
;
317 offset
+= d
->partition_length
;
323 static int build_image(void)
331 /* build in-memory buffer */
332 mem_size
= sizeof(header_t
) + sizeof(signature_t
);
333 for (i
= 0; i
< im
.part_count
; ++i
) {
334 part_data_t
* d
= &im
.parts
[i
];
335 mem_size
+= sizeof(part_t
) + d
->stats
.st_size
+ sizeof(part_crc_t
);
338 mem
= (char*)calloc(mem_size
, 1);
340 ERROR("Cannot allocate memory chunk of size '%u'\n", mem_size
);
345 write_header(mem
, im
.version
);
346 ptr
= mem
+ sizeof(header_t
);
348 /* write all parts */
349 for (i
= 0; i
< im
.part_count
; ++i
) {
350 part_data_t
* d
= &im
.parts
[i
];
352 if ((rc
= write_part(ptr
, d
)) != 0) {
353 ERROR("ERROR: failed writing part %u '%s'\n", i
, d
->partition_name
);
356 ptr
+= sizeof(part_t
) + d
->stats
.st_size
+ sizeof(part_crc_t
);
360 /* write signature */
361 write_signature(mem
, mem_size
- sizeof(signature_t
));
363 /* write in-memory buffer into file */
364 if ((f
= fopen(im
.outputfile
, "w")) == NULL
) {
365 ERROR("Can not create output file: '%s'\n", im
.outputfile
);
369 if (fwrite(mem
, mem_size
, 1, f
) != 1) {
370 ERROR("Could not write %d bytes into file: '%s'\n",
371 mem_size
, im
.outputfile
);
380 int main(int argc
, char* argv
[])
384 memset(&im
, 0, sizeof(im
));
386 strcpy(im
.outputfile
, DEFAULT_OUTPUT_FILE
);
387 strcpy(im
.version
, DEFAULT_VERSION
);
388 memcpy(im
.magic
, MAGIC_HEADER
, MAGIC_LENGTH
);
389 im
.flash_baseaddr
= DEFAULT_FLASH_BASE
;
391 while ((o
= getopt(argc
, argv
, "f:hm:o:p:v:z")) != -1)
396 if (str2u32(optarg
, &im
.flash_baseaddr
)) {
397 ERROR("Invalid flash start address %s\n", optarg
);
406 if (strlen(optarg
) != MAGIC_LENGTH
) {
407 ERROR("Invalid magic %s\n", optarg
);
411 memcpy(im
.magic
, optarg
, MAGIC_LENGTH
);
416 strncpy(im
.outputfile
, optarg
, sizeof(im
.outputfile
));
420 if (image_layout_add_partition(optarg
))
426 strncpy(im
.version
, optarg
, sizeof(im
.version
));
429 zero_part_baseaddr
= 1;
434 rc
= image_layout_verify();
436 ERROR("Failed validating firmware layout - error code: %d\n",
445 ERROR("Failed building image file '%s' - error code: %d\n",