2 Copyright (c) 2014, Matthias Schiffer <mschiffer@universe-factory.net>
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions are met:
8 1. Redistributions of source code must retain the above copyright notice,
9 this list of conditions and the following disclaimer.
10 2. Redistributions in binary form must reproduce the above copyright notice,
11 this list of conditions and the following disclaimer in the documentation
12 and/or other materials provided with the distribution.
14 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
15 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
18 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
20 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
21 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
22 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 Image generation tool for the TP-LINK SafeLoader as seen on
31 TP-LINK Pharos devices (CPE210/220/510/520)
45 #include <arpa/inet.h>
47 #include <sys/types.h>
53 #define ALIGN(x,a) ({ typeof(a) __a = (a); (((x) + __a - 1) & ~(__a - 1)); })
56 /** An image partition table entry */
57 struct image_partition_entry
{
63 /** A flash partition table entry */
64 struct flash_partition_entry
{
71 /** The content of the soft-version structure */
72 struct __attribute__((__packed__
)) soft_version
{
76 uint8_t version_major
;
77 uint8_t version_minor
;
78 uint8_t version_patch
;
88 static const uint8_t jffs2_eof_mark
[4] = {0xde, 0xad, 0xc0, 0xde};
94 Fortunately, TP-LINK seems to use the same salt for most devices which use
97 static const uint8_t md5_salt
[16] = {
98 0x7a, 0x2b, 0x15, 0xed,
99 0x9b, 0x98, 0x59, 0x6d,
100 0xe5, 0x04, 0xab, 0x44,
101 0xac, 0x2a, 0x9f, 0x4e,
105 /** Vendor information for CPE210/220/510/520 */
106 static const char cpe510_vendor
[] = "CPE510(TP-LINK|UN|N300-5):1.0\r\n";
108 /** Vendor information for C2600 */
109 static const char c2600_vendor
[] = "";
111 /** Vendor information for EAP120 */
112 static const char eap120_vendor
[] = "EAP120(TP-LINK|UN|N300-2):1.0\r\n";
115 The flash partition table for CPE210/220/510/520;
116 it is the same as the one used by the stock images.
118 static const struct flash_partition_entry cpe510_partitions
[] = {
119 {"fs-uboot", 0x00000, 0x20000},
120 {"partition-table", 0x20000, 0x02000},
121 {"default-mac", 0x30000, 0x00020},
122 {"product-info", 0x31100, 0x00100},
123 {"signature", 0x32000, 0x00400},
124 {"os-image", 0x40000, 0x170000},
125 {"soft-version", 0x1b0000, 0x00100},
126 {"support-list", 0x1b1000, 0x00400},
127 {"file-system", 0x1c0000, 0x600000},
128 {"user-config", 0x7c0000, 0x10000},
129 {"default-config", 0x7d0000, 0x10000},
130 {"log", 0x7e0000, 0x10000},
131 {"radio", 0x7f0000, 0x10000},
136 The flash partition table for C2600;
137 it is the same as the one used by the stock images.
139 static const struct flash_partition_entry c2600_partitions
[] = {
140 {"SBL1", 0x00000, 0x20000},
141 {"MIBIB", 0x20000, 0x20000},
142 {"SBL2", 0x40000, 0x20000},
143 {"SBL3", 0x60000, 0x30000},
144 {"DDRCONFIG", 0x90000, 0x10000},
145 {"SSD", 0xa0000, 0x10000},
146 {"TZ", 0xb0000, 0x30000},
147 {"RPM", 0xe0000, 0x20000},
148 {"fs-uboot", 0x100000, 0x70000},
149 {"uboot-env", 0x170000, 0x40000},
150 {"radio", 0x1b0000, 0x40000},
151 {"os-image", 0x1f0000, 0x200000},
152 {"file-system", 0x3f0000, 0x1b00000},
153 {"default-mac", 0x1ef0000, 0x00200},
154 {"pin", 0x1ef0200, 0x00200},
155 {"product-info", 0x1ef0400, 0x0fc00},
156 {"partition-table", 0x1f00000, 0x10000},
157 {"soft-version", 0x1f10000, 0x10000},
158 {"support-list", 0x1f20000, 0x10000},
159 {"profile", 0x1f30000, 0x10000},
160 {"default-config", 0x1f40000, 0x10000},
161 {"user-config", 0x1f50000, 0x40000},
162 {"qos-db", 0x1f90000, 0x40000},
163 {"usb-config", 0x1fd0000, 0x10000},
164 {"log", 0x1fe0000, 0x20000},
168 /** The flash partition table for EAP120;
169 it is the same as the one used by the stock images.
171 static const struct flash_partition_entry eap120_partitions
[] = {
172 {"fs-uboot", 0x00000, 0x20000},
173 {"partition-table", 0x20000, 0x02000},
174 {"default-mac", 0x30000, 0x00020},
175 {"support-list", 0x31000, 0x00100},
176 {"product-info", 0x31100, 0x00100},
177 {"soft-version", 0x32000, 0x00100},
178 {"os-image", 0x40000, 0x180000},
179 {"file-system", 0x1c0000, 0x600000},
180 {"user-config", 0x7c0000, 0x10000},
181 {"backup-config", 0x7d0000, 0x10000},
182 {"log", 0x7e0000, 0x10000},
183 {"radio", 0x7f0000, 0x10000},
188 The support list for CPE210/220
190 static const char cpe210_support_list
[] =
192 "CPE210(TP-LINK|UN|N300-2):1.0\r\n"
193 "CPE210(TP-LINK|UN|N300-2):1.1\r\n"
194 "CPE220(TP-LINK|UN|N300-2):1.0\r\n"
195 "CPE220(TP-LINK|UN|N300-2):1.1\r\n";
197 The support list for CPE210/220/510/520
199 static const char cpe510_support_list
[] =
201 "CPE510(TP-LINK|UN|N300-5):1.0\r\n"
202 "CPE510(TP-LINK|UN|N300-5):1.1\r\n"
203 "CPE520(TP-LINK|UN|N300-5):1.0\r\n"
204 "CPE520(TP-LINK|UN|N300-5):1.1\r\n";
207 The support list for C2600
209 static const char c2600_support_list
[] =
211 "{product_name:Archer C2600,product_ver:1.0.0,special_id:00000000}\r\n";
214 The support list for EAP120
216 static const char eap120_support_list
[] =
218 "EAP120(TP-LINK|UN|N300-2):1.0\r\n";
220 #define error(_ret, _errno, _str, ...) \
222 fprintf(stderr, _str ": %s\n", ## __VA_ARGS__, \
229 /** Stores a uint32 as big endian */
230 static inline void put32(uint8_t *buf
, uint32_t val
) {
237 /** Allocates a new image partition */
238 static struct image_partition_entry
alloc_image_partition(const char *name
, size_t len
) {
239 struct image_partition_entry entry
= {name
, len
, malloc(len
)};
241 error(1, errno
, "malloc");
246 /** Frees an image partition */
247 static void free_image_partition(struct image_partition_entry entry
) {
251 /** Generates the partition-table partition */
252 static struct image_partition_entry
make_partition_table(const struct flash_partition_entry
*p
) {
253 struct image_partition_entry entry
= alloc_image_partition("partition-table", 0x800);
255 char *s
= (char *)entry
.data
, *end
= (char *)(s
+entry
.size
);
263 for (i
= 0; p
[i
].name
; i
++) {
265 size_t w
= snprintf(s
, len
, "partition %s base 0x%05x size 0x%05x\n", p
[i
].name
, p
[i
].base
, p
[i
].size
);
268 error(1, 0, "flash partition table overflow?");
275 memset(s
, 0xff, end
-s
);
281 /** Generates a binary-coded decimal representation of an integer in the range [0, 99] */
282 static inline uint8_t bcd(uint8_t v
) {
283 return 0x10 * (v
/10) + v
%10;
287 /** Generates the soft-version partition */
288 static struct image_partition_entry
make_soft_version(uint32_t rev
) {
289 struct image_partition_entry entry
= alloc_image_partition("soft-version", sizeof(struct soft_version
));
290 struct soft_version
*s
= (struct soft_version
*)entry
.data
;
294 if (time(&t
) == (time_t)(-1))
295 error(1, errno
, "time");
297 struct tm
*tm
= localtime(&t
);
299 s
->magic
= htonl(0x0000000c);
303 s
->version_major
= 0;
304 s
->version_minor
= 0;
305 s
->version_patch
= 0;
307 s
->year_hi
= bcd((1900+tm
->tm_year
)/100);
308 s
->year_lo
= bcd(tm
->tm_year
%100);
309 s
->month
= bcd(tm
->tm_mon
+1);
310 s
->day
= bcd(tm
->tm_mday
);
318 /** Generates the support-list partition */
319 static struct image_partition_entry
make_support_list(const char *support_list
, bool trailzero
) {
320 size_t len
= strlen(support_list
);
321 struct image_partition_entry entry
= alloc_image_partition("support-list", len
+ 9);
323 put32(entry
.data
, len
);
324 memset(entry
.data
+4, 0, 4);
325 memcpy(entry
.data
+8, support_list
, len
);
326 entry
.data
[len
+8] = trailzero
? '\x00' : '\xff';
331 /** Creates a new image partition with an arbitrary name from a file */
332 static struct image_partition_entry
read_file(const char *part_name
, const char *filename
, bool add_jffs2_eof
) {
335 if (stat(filename
, &statbuf
) < 0)
336 error(1, errno
, "unable to stat file `%s'", filename
);
338 size_t len
= statbuf
.st_size
;
341 len
= ALIGN(len
, 0x10000) + sizeof(jffs2_eof_mark
);
343 struct image_partition_entry entry
= alloc_image_partition(part_name
, len
);
345 FILE *file
= fopen(filename
, "rb");
347 error(1, errno
, "unable to open file `%s'", filename
);
349 if (fread(entry
.data
, statbuf
.st_size
, 1, file
) != 1)
350 error(1, errno
, "unable to read file `%s'", filename
);
353 uint8_t *eof
= entry
.data
+ statbuf
.st_size
, *end
= entry
.data
+entry
.size
;
355 memset(eof
, 0xff, end
- eof
- sizeof(jffs2_eof_mark
));
356 memcpy(end
- sizeof(jffs2_eof_mark
), jffs2_eof_mark
, sizeof(jffs2_eof_mark
));
366 Copies a list of image partitions into an image buffer and generates the image partition table while doing so
368 Example image partition table:
370 fwup-ptn partition-table base 0x00800 size 0x00800
371 fwup-ptn os-image base 0x01000 size 0x113b45
372 fwup-ptn file-system base 0x114b45 size 0x1d0004
373 fwup-ptn support-list base 0x2e4b49 size 0x000d1
375 Each line of the partition table is terminated with the bytes 09 0d 0a ("\t\r\n"),
376 the end of the partition table is marked with a zero byte.
378 The firmware image must contain at least the partition-table and support-list partitions
379 to be accepted. There aren't any alignment constraints for the image partitions.
381 The partition-table partition contains the actual flash layout; partitions
382 from the image partition table are mapped to the corresponding flash partitions during
383 the firmware upgrade. The support-list partition contains a list of devices supported by
386 The base offsets in the firmware partition table are relative to the end
387 of the vendor information block, so the partition-table partition will
388 actually start at offset 0x1814 of the image.
390 I think partition-table must be the first partition in the firmware image.
392 static void put_partitions(uint8_t *buffer
, const struct image_partition_entry
*parts
) {
394 char *image_pt
= (char *)buffer
, *end
= image_pt
+ 0x800;
397 for (i
= 0; parts
[i
].name
; i
++) {
398 memcpy(buffer
+ base
, parts
[i
].data
, parts
[i
].size
);
400 size_t len
= end
-image_pt
;
401 size_t w
= snprintf(image_pt
, len
, "fwup-ptn %s base 0x%05x size 0x%05x\t\r\n", parts
[i
].name
, (unsigned)base
, (unsigned)parts
[i
].size
);
404 error(1, 0, "image partition table overflow?");
408 base
+= parts
[i
].size
;
413 memset(image_pt
, 0xff, end
-image_pt
);
416 /** Generates and writes the image MD5 checksum */
417 static void put_md5(uint8_t *md5
, uint8_t *buffer
, unsigned int len
) {
421 MD5_Update(&ctx
, md5_salt
, (unsigned int)sizeof(md5_salt
));
422 MD5_Update(&ctx
, buffer
, len
);
423 MD5_Final(md5
, &ctx
);
428 Generates the firmware image in factory format
434 0000-0003 Image size (4 bytes, big endian)
435 0004-0013 MD5 hash (hash of a 16 byte salt and the image data starting with byte 0x14)
436 0014-0017 Vendor information length (without padding) (4 bytes, big endian)
437 0018-1013 Vendor information (4092 bytes, padded with 0xff; there seem to be older
438 (VxWorks-based) TP-LINK devices which use a smaller vendor information block)
439 1014-1813 Image partition table (2048 bytes, padded with 0xff)
440 1814-xxxx Firmware partitions
442 static void * generate_factory_image(const char *vendor
, const struct image_partition_entry
*parts
, size_t *len
) {
446 for (i
= 0; parts
[i
].name
; i
++)
447 *len
+= parts
[i
].size
;
449 uint8_t *image
= malloc(*len
);
451 error(1, errno
, "malloc");
455 size_t vendor_len
= strlen(vendor
);
456 put32(image
+0x14, vendor_len
);
457 memcpy(image
+0x18, vendor
, vendor_len
);
458 memset(image
+0x18+vendor_len
, 0xff, 4092-vendor_len
);
460 put_partitions(image
+ 0x1014, parts
);
461 put_md5(image
+0x04, image
+0x14, *len
-0x14);
467 Generates the firmware image in sysupgrade format
469 This makes some assumptions about the provided flash and image partition tables and
470 should be generalized when TP-LINK starts building its safeloader into hardware with
471 different flash layouts.
473 static void * generate_sysupgrade_image(const struct flash_partition_entry
*flash_parts
, const struct image_partition_entry
*image_parts
, size_t *len
) {
474 const struct flash_partition_entry
*flash_os_image
= &flash_parts
[5];
475 const struct flash_partition_entry
*flash_soft_version
= &flash_parts
[6];
476 const struct flash_partition_entry
*flash_support_list
= &flash_parts
[7];
477 const struct flash_partition_entry
*flash_file_system
= &flash_parts
[8];
479 const struct image_partition_entry
*image_os_image
= &image_parts
[3];
480 const struct image_partition_entry
*image_soft_version
= &image_parts
[1];
481 const struct image_partition_entry
*image_support_list
= &image_parts
[2];
482 const struct image_partition_entry
*image_file_system
= &image_parts
[4];
484 assert(strcmp(flash_os_image
->name
, "os-image") == 0);
485 assert(strcmp(flash_soft_version
->name
, "soft-version") == 0);
486 assert(strcmp(flash_support_list
->name
, "support-list") == 0);
487 assert(strcmp(flash_file_system
->name
, "file-system") == 0);
489 assert(strcmp(image_os_image
->name
, "os-image") == 0);
490 assert(strcmp(image_soft_version
->name
, "soft-version") == 0);
491 assert(strcmp(image_support_list
->name
, "support-list") == 0);
492 assert(strcmp(image_file_system
->name
, "file-system") == 0);
494 if (image_os_image
->size
> flash_os_image
->size
)
495 error(1, 0, "kernel image too big (more than %u bytes)", (unsigned)flash_os_image
->size
);
496 if (image_file_system
->size
> flash_file_system
->size
)
497 error(1, 0, "rootfs image too big (more than %u bytes)", (unsigned)flash_file_system
->size
);
499 *len
= flash_file_system
->base
- flash_os_image
->base
+ image_file_system
->size
;
501 uint8_t *image
= malloc(*len
);
503 error(1, errno
, "malloc");
505 memset(image
, 0xff, *len
);
507 memcpy(image
, image_os_image
->data
, image_os_image
->size
);
508 memcpy(image
+ flash_soft_version
->base
- flash_os_image
->base
, image_soft_version
->data
, image_soft_version
->size
);
509 memcpy(image
+ flash_support_list
->base
- flash_os_image
->base
, image_support_list
->data
, image_support_list
->size
);
510 memcpy(image
+ flash_file_system
->base
- flash_os_image
->base
, image_file_system
->data
, image_file_system
->size
);
515 static void * generate_sysupgrade_image_c2600(const struct flash_partition_entry
*flash_parts
, const struct image_partition_entry
*image_parts
, size_t *len
) {
516 const struct flash_partition_entry
*flash_os_image
= &flash_parts
[11];
517 const struct flash_partition_entry
*flash_file_system
= &flash_parts
[12];
519 const struct image_partition_entry
*image_os_image
= &image_parts
[3];
520 const struct image_partition_entry
*image_file_system
= &image_parts
[4];
522 assert(strcmp(flash_os_image
->name
, "os-image") == 0);
523 assert(strcmp(flash_file_system
->name
, "file-system") == 0);
525 assert(strcmp(image_os_image
->name
, "os-image") == 0);
526 assert(strcmp(image_file_system
->name
, "file-system") == 0);
528 if (image_os_image
->size
> flash_os_image
->size
)
529 error(1, 0, "kernel image too big (more than %u bytes)", (unsigned)flash_os_image
->size
);
530 if (image_file_system
->size
> flash_file_system
->size
)
531 error(1, 0, "rootfs image too big (more than %u bytes)", (unsigned)flash_file_system
->size
);
533 *len
= flash_file_system
->base
- flash_os_image
->base
+ image_file_system
->size
;
535 uint8_t *image
= malloc(*len
);
537 error(1, errno
, "malloc");
539 memset(image
, 0xff, *len
);
541 memcpy(image
, image_os_image
->data
, image_os_image
->size
);
542 memcpy(image
+ flash_file_system
->base
- flash_os_image
->base
, image_file_system
->data
, image_file_system
->size
);
546 static void *generate_sysupgrade_image_eap120(const struct flash_partition_entry
*flash_parts
, const struct image_partition_entry
*image_parts
, size_t *len
)
548 const struct flash_partition_entry
*flash_os_image
= &flash_parts
[6];
549 const struct flash_partition_entry
*flash_file_system
= &flash_parts
[7];
551 const struct image_partition_entry
*image_os_image
= &image_parts
[3];
552 const struct image_partition_entry
*image_file_system
= &image_parts
[4];
554 assert(strcmp(flash_os_image
->name
, "os-image") == 0);
555 assert(strcmp(flash_file_system
->name
, "file-system") == 0);
557 assert(strcmp(image_os_image
->name
, "os-image") == 0);
558 assert(strcmp(image_file_system
->name
, "file-system") == 0);
560 if (image_os_image
->size
> flash_os_image
->size
)
561 error(1, 0, "kernel image too big (more than %u bytes)", (unsigned)flash_os_image
->size
);
562 if (image_file_system
->size
> flash_file_system
->size
)
563 error(1, 0, "rootfs image too big (more than %u bytes)", (unsigned)flash_file_system
->size
);
565 *len
= flash_file_system
->base
- flash_os_image
->base
+ image_file_system
->size
;
567 uint8_t *image
= malloc(*len
);
569 error(1, errno
, "malloc");
571 memset(image
, 0xff, *len
);
572 memcpy(image
, image_os_image
->data
, image_os_image
->size
);
573 memcpy(image
+ flash_file_system
->base
- flash_os_image
->base
, image_file_system
->data
, image_file_system
->size
);
578 /** Generates an image for CPE210/220/510/520 and writes it to a file */
579 static void do_cpe(const char *output
,
580 const char *kernel_image
,
581 const char *rootfs_image
,
585 const char *support_list
) {
586 struct image_partition_entry parts
[6] = {};
588 parts
[0] = make_partition_table(cpe510_partitions
);
589 parts
[1] = make_soft_version(rev
);
590 parts
[2] = make_support_list(support_list
, false);
591 parts
[3] = read_file("os-image", kernel_image
, false);
592 parts
[4] = read_file("file-system", rootfs_image
, add_jffs2_eof
);
597 image
= generate_sysupgrade_image(cpe510_partitions
, parts
, &len
);
599 image
= generate_factory_image(cpe510_vendor
, parts
, &len
);
601 FILE *file
= fopen(output
, "wb");
603 error(1, errno
, "unable to open output file");
605 if (fwrite(image
, len
, 1, file
) != 1)
606 error(1, 0, "unable to write output file");
613 for (i
= 0; parts
[i
].name
; i
++)
614 free_image_partition(parts
[i
]);
617 /** Generates an image for C2600 and writes it to a file */
618 static void do_c2600(const char *output
, const char *kernel_image
, const char *rootfs_image
, uint32_t rev
, bool add_jffs2_eof
, bool sysupgrade
) {
619 struct image_partition_entry parts
[6] = {};
621 parts
[0] = make_partition_table(c2600_partitions
);
622 parts
[1] = make_soft_version(rev
);
623 parts
[2] = make_support_list(c2600_support_list
, true);
624 parts
[3] = read_file("os-image", kernel_image
, false);
625 parts
[4] = read_file("file-system", rootfs_image
, add_jffs2_eof
);
630 image
= generate_sysupgrade_image_c2600(c2600_partitions
, parts
, &len
);
632 image
= generate_factory_image(c2600_vendor
, parts
, &len
);
634 FILE *file
= fopen(output
, "wb");
636 error(1, errno
, "unable to open output file");
638 if (fwrite(image
, len
, 1, file
) != 1)
639 error(1, 0, "unable to write output file");
646 for (i
= 0; parts
[i
].name
; i
++)
647 free_image_partition(parts
[i
]);
651 /** Generates an image for EAP120 and writes it to a file */
652 static void do_eap(const char *output
,
653 const char *kernel_image
,
654 const char *rootfs_image
,
658 const char *support_list
) {
659 struct image_partition_entry parts
[6] = {};
661 parts
[0] = make_partition_table(eap120_partitions
);
662 parts
[1] = make_soft_version(rev
);
663 parts
[2] = make_support_list(support_list
, false);
664 parts
[3] = read_file("os-image", kernel_image
, false);
665 parts
[4] = read_file("file-system", rootfs_image
, add_jffs2_eof
);
670 image
= generate_sysupgrade_image_eap120(eap120_partitions
, parts
, &len
);
672 image
= generate_factory_image(eap120_vendor
, parts
, &len
);
674 FILE *file
= fopen(output
, "wb");
676 error(1, errno
, "unable to open output file");
678 if (fwrite(image
, len
, 1, file
) != 1)
679 error(1, 0, "unable to write output file");
686 for (i
= 0; parts
[i
].name
; i
++)
687 free_image_partition(parts
[i
]);
691 static void usage(const char *argv0
) {
693 "Usage: %s [OPTIONS...]\n"
696 " -B <board> create image for the board specified with <board>\n"
697 " -k <file> read kernel image from the file <file>\n"
698 " -r <file> read rootfs image from the file <file>\n"
699 " -o <file> write output to the file <file>\n"
700 " -V <rev> sets the revision number to <rev>\n"
701 " -j add jffs2 end-of-filesystem markers\n"
702 " -S create sysupgrade instead of factory image\n"
703 " -h show this help\n",
709 int main(int argc
, char *argv
[]) {
710 const char *board
= NULL
, *kernel_image
= NULL
, *rootfs_image
= NULL
, *output
= NULL
;
711 bool add_jffs2_eof
= false, sysupgrade
= false;
717 c
= getopt(argc
, argv
, "B:k:r:o:V:jSh");
727 kernel_image
= optarg
;
731 rootfs_image
= optarg
;
739 sscanf(optarg
, "r%u", &rev
);
743 add_jffs2_eof
= true;
761 error(1, 0, "no board has been specified");
763 error(1, 0, "no kernel image has been specified");
765 error(1, 0, "no rootfs image has been specified");
767 error(1, 0, "no output filename has been specified");
769 if (strcmp(board
, "CPE210") == 0)
770 do_cpe(output
, kernel_image
, rootfs_image
, rev
, add_jffs2_eof
, sysupgrade
, cpe210_support_list
);
771 else if (strcmp(board
, "CPE510") == 0)
772 do_cpe(output
, kernel_image
, rootfs_image
, rev
, add_jffs2_eof
, sysupgrade
, cpe510_support_list
);
773 else if (strcmp(board
, "C2600") == 0)
774 do_c2600(output
, kernel_image
, rootfs_image
, rev
, add_jffs2_eof
, sysupgrade
);
775 else if (strcmp(board
, "EAP120") == 0)
776 do_eap(output
, kernel_image
, rootfs_image
, rev
, add_jffs2_eof
, sysupgrade
, eap120_support_list
);
778 error(1, 0, "unsupported board %s", board
);