source: branches/backfire/tools/firmware-utils/src/mktplinkfw.c @ 29033

Last change on this file since 29033 was 29033, checked in by jow, 5 years ago

[backfire] tools: backport r23137

  • Property svn:eol-style set to native
File size: 10.9 KB
Line 
1/*
2 * Copyright (C) 2009 Gabor Juhos <juhosg@openwrt.org>
3 *
4 * This tool was based on:
5 *   TP-Link WR941 V2 firmware checksum fixing tool.
6 *   Copyright (C) 2008,2009 Wang Jian <lark@linux.net.cn>
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License version 2 as published
10 * by the Free Software Foundation.
11 *
12 */
13
14#include <stdio.h>
15#include <stdlib.h>
16#include <stdint.h>
17#include <string.h>
18#include <unistd.h>     /* for unlink() */
19#include <libgen.h>
20#include <getopt.h>     /* for getopt() */
21#include <stdarg.h>
22#include <errno.h>
23#include <sys/stat.h>
24
25#include "md5.h"
26
27#if (__BYTE_ORDER == __BIG_ENDIAN)
28#  define HOST_TO_BE32(x)       (x)
29#  define BE32_TO_HOST(x)       (x)
30#else
31#  define HOST_TO_BE32(x)       bswap_32(x)
32#  define BE32_TO_HOST(x)       bswap_32(x)
33#endif
34
35#define HEADER_VERSION_V1       0x01000000
36#define HWID_TL_MR3420_V1       0x34200001
37#define HWID_TL_WR741ND_V1      0x07410001
38#define HWID_TL_WR740N_V1       0x07400001
39#define HWID_TL_WR841N_V1_5     0x08410002
40#define HWID_TL_WR841ND_V3      0x08410003
41#define HWID_TL_WR841ND_V5      0x08410005
42#define HWID_TL_WR941ND_V2      0x09410002
43#define HWID_TL_WR941ND_V4      0x09410004
44#define HWID_TL_WR1043ND_V1     0x10430001
45
46#define MD5SUM_LEN      16
47
48struct file_info {
49        char            *file_name;     /* name of the file */
50        uint32_t        file_size;      /* length of the file */
51};
52
53struct fw_header {
54        uint32_t        version;        /* header version */
55        char            vendor_name[24];
56        char            fw_version[36];
57        uint32_t        hw_id;          /* hardware id */
58        uint32_t        hw_rev;         /* hardware revision */
59        uint32_t        unk1;
60        uint8_t         md5sum1[MD5SUM_LEN];
61        uint32_t        unk2;
62        uint8_t         md5sum2[MD5SUM_LEN];
63        uint32_t        unk3;
64        uint32_t        kernel_la;      /* kernel load address */
65        uint32_t        kernel_ep;      /* kernel entry point */
66        uint32_t        fw_length;      /* total length of the firmware */
67        uint32_t        kernel_ofs;     /* kernel data offset */
68        uint32_t        kernel_len;     /* kernel data length */
69        uint32_t        rootfs_ofs;     /* rootfs data offset */
70        uint32_t        rootfs_len;     /* rootfs data length */
71        uint32_t        boot_ofs;       /* bootloader data offset */
72        uint32_t        boot_len;       /* bootloader data length */
73        uint8_t         pad[360];
74} __attribute__ ((packed));
75
76struct board_info {
77        char            *id;
78        uint32_t        hw_id;
79        uint32_t        hw_rev;
80        uint32_t        fw_max_len;
81        uint32_t        kernel_la;
82        uint32_t        kernel_ep;
83        uint32_t        rootfs_ofs;
84};
85
86/*
87 * Globals
88 */
89static char *ofname;
90static char *progname;
91static char *vendor = "TP-LINK Technologies";
92static char *version = "ver. 1.0";
93
94static char *board_id;
95static struct board_info *board;
96static struct file_info kernel_info;
97static struct file_info rootfs_info;
98static struct file_info boot_info;
99static int combined;
100static int strip_padding;
101
102char md5salt_normal[MD5SUM_LEN] = {
103        0xdc, 0xd7, 0x3a, 0xa5, 0xc3, 0x95, 0x98, 0xfb,
104        0xdd, 0xf9, 0xe7, 0xf4, 0x0e, 0xae, 0x47, 0x38,
105};
106
107char md5salt_boot[MD5SUM_LEN] = {
108        0x8c, 0xef, 0x33, 0x5b, 0xd5, 0xc5, 0xce, 0xfa,
109        0xa7, 0x9c, 0x28, 0xda, 0xb2, 0xe9, 0x0f, 0x42,
110};
111
112static struct board_info boards[] = {
113        {
114                .id             = "TL-MR3420v1",
115                .hw_id          = HWID_TL_MR3420_V1,
116                .hw_rev         = 1,
117                .fw_max_len     = 0x3c0000,
118                .kernel_la      = 0x80060000,
119                .kernel_ep      = 0x80060000,
120                .rootfs_ofs     = 0x140000,
121        }, {
122                .id             = "TL-WR741NDv1",
123                .hw_id          = HWID_TL_WR741ND_V1,
124                .hw_rev         = 1,
125                .fw_max_len     = 0x3c0000,
126                .kernel_la      = 0x80060000,
127                .kernel_ep      = 0x80060000,
128                .rootfs_ofs     = 0x140000,
129        }, {
130                .id             = "TL-WR740Nv1",
131                .hw_id          = HWID_TL_WR740N_V1,
132                .hw_rev         = 1,
133                .fw_max_len     = 0x3c0000,
134                .kernel_la      = 0x80060000,
135                .kernel_ep      = 0x80060000,
136                .rootfs_ofs     = 0x140000,
137        }, {
138                .id             = "TL-WR841Nv1.5",
139                .hw_id          = HWID_TL_WR841N_V1_5,
140                .hw_rev         = 2,
141                .fw_max_len     = 0x3c0000,
142                .kernel_la      = 0x80060000,
143                .kernel_ep      = 0x80060000,
144                .rootfs_ofs     = 0x140000,
145        }, {
146                .id             = "TL-WR841NDv3",
147                .hw_id          = HWID_TL_WR841ND_V3,
148                .hw_rev         = 3,
149                .fw_max_len     = 0x3c0000,
150                .kernel_la      = 0x80060000,
151                .kernel_ep      = 0x80060000,
152                .rootfs_ofs     = 0x140000,
153        }, {
154                .id             = "TL-WR841NDv5",
155                .hw_id          = HWID_TL_WR841ND_V5,
156                .hw_rev         = 1,
157                .fw_max_len     = 0x3c0000,
158                .kernel_la      = 0x80060000,
159                .kernel_ep      = 0x80060000,
160                .rootfs_ofs     = 0x140000,
161        }, {
162                .id             = "TL-WR941NDv2",
163                .hw_id          = HWID_TL_WR941ND_V2,
164                .hw_rev         = 2,
165                .fw_max_len     = 0x3c0000,
166                .kernel_la      = 0x80060000,
167                .kernel_ep      = 0x80060000,
168                .rootfs_ofs     = 0x140000,
169        }, {
170                .id             = "TL-WR941NDv4",
171                .hw_id          = HWID_TL_WR941ND_V4,
172                .hw_rev         = 1,
173                .fw_max_len     = 0x3c0000,
174                .kernel_la      = 0x80060000,
175                .kernel_ep      = 0x80060000,
176                .rootfs_ofs     = 0x140000,
177        }, {
178                .id             = "TL-WR1043NDv1",
179                .hw_id          = HWID_TL_WR1043ND_V1,
180                .hw_rev         = 1,
181                .fw_max_len     = 0x7c0000,
182                .kernel_la      = 0x80060000,
183                .kernel_ep      = 0x80060000,
184                .rootfs_ofs     = 0x140000,
185        }, {
186                /* terminating entry */
187        }
188};
189
190/*
191 * Message macros
192 */
193#define ERR(fmt, ...) do { \
194        fflush(0); \
195        fprintf(stderr, "[%s] *** error: " fmt "\n", \
196                        progname, ## __VA_ARGS__ ); \
197} while (0)
198
199#define ERRS(fmt, ...) do { \
200        int save = errno; \
201        fflush(0); \
202        fprintf(stderr, "[%s] *** error: " fmt "\n", \
203                        progname, ## __VA_ARGS__, strerror(save)); \
204} while (0)
205
206#define DBG(fmt, ...) do { \
207        fprintf(stderr, "[%s] " fmt "\n", progname, ## __VA_ARGS__ ); \
208} while (0)
209
210static struct board_info *find_board(char *id)
211{
212        struct board_info *ret;
213        struct board_info *board;
214
215        ret = NULL;
216        for (board = boards; board->id != NULL; board++){
217                if (strcasecmp(id, board->id) == 0) {
218                        ret = board;
219                        break;
220                }
221        };
222
223        return ret;
224}
225
226static void usage(int status)
227{
228        FILE *stream = (status != EXIT_SUCCESS) ? stderr : stdout;
229        struct board_info *board;
230
231        fprintf(stream, "Usage: %s [OPTIONS...]\n", progname);
232        fprintf(stream,
233"\n"
234"Options:\n"
235"  -B <board>      create image for the board specified with <board>\n"
236"  -c              use combined kernel image\n"
237"  -k <file>       read kernel image from the file <file>\n"
238"  -r <file>       read rootfs image from the file <file>\n"
239"  -o <file>       write output to the file <file>\n"
240"  -s              strip padding from the end of the image\n"
241"  -N <vendor>     set image vendor to <vendor>\n"
242"  -V <version>    set image version to <version>\n"
243"  -h              show this screen\n"
244        );
245
246        exit(status);
247}
248
249static int get_md5(char *data, int size, char *md5)
250{
251        MD5_CTX ctx;
252
253        MD5_Init(&ctx);
254        MD5_Update(&ctx, data, size);
255        MD5_Final(md5, &ctx);
256}
257
258static int get_file_stat(struct file_info *fdata)
259{
260        struct stat st;
261        int res;
262
263        if (fdata->file_name == NULL)
264                return 0;
265
266        res = stat(fdata->file_name, &st);
267        if (res){
268                ERRS("stat failed on %s", fdata->file_name);
269                return res;
270        }
271
272        fdata->file_size = st.st_size;
273        return 0;
274}
275
276static int read_to_buf(struct file_info *fdata, char *buf)
277{
278        FILE *f;
279        int ret = EXIT_FAILURE;
280
281        f = fopen(fdata->file_name, "r");
282        if (f == NULL) {
283                ERRS("could not open \"%s\" for reading", fdata->file_name);
284                goto out;
285        }
286
287        errno = 0;
288        fread(buf, fdata->file_size, 1, f);
289        if (errno != 0) {
290                ERRS("unable to read from file \"%s\"", fdata->file_name);
291                goto out_close;
292        }
293
294        ret = EXIT_SUCCESS;
295
296 out_close:
297        fclose(f);
298 out:
299        return ret;
300}
301
302static int check_options(void)
303{
304        int ret;
305
306        if (board_id == NULL) {
307                ERR("no board specified");
308                return -1;
309        }
310
311        board = find_board(board_id);
312        if (board == NULL) {
313                ERR("unknown/unsupported board id \"%s\"", board_id);
314                return -1;
315        }
316
317        if (kernel_info.file_name == NULL) {
318                ERR("no kernel image specified");
319                return -1;
320        }
321
322        ret = get_file_stat(&kernel_info);
323        if (ret)
324                return ret;
325
326        if (combined) {
327                if (kernel_info.file_size >
328                    board->fw_max_len - sizeof(struct fw_header)) {
329                        ERR("kernel image is too big");
330                        return -1;
331                }
332        } else {
333                if (kernel_info.file_size >
334                    board->rootfs_ofs - sizeof(struct fw_header)) {
335                        ERR("kernel image is too big");
336                        return -1;
337                }
338                if (rootfs_info.file_name == NULL) {
339                        ERR("no rootfs image specified");
340                        return -1;
341                }
342
343                ret = get_file_stat(&rootfs_info);
344                if (ret)
345                        return ret;
346
347                if (rootfs_info.file_size >
348                    (board->fw_max_len - board->rootfs_ofs)) {
349                        ERR("rootfs image is too big");
350                        return -1;
351                }
352        }
353
354        if (ofname == NULL) {
355                ERR("no output file specified");
356                return -1;
357        }
358
359        return 0;
360}
361
362static void fill_header(char *buf, int len)
363{
364        struct fw_header *hdr = (struct fw_header *)buf;
365
366        memset(hdr, 0, sizeof(struct fw_header));
367
368        hdr->version = HOST_TO_BE32(HEADER_VERSION_V1);
369        strncpy(hdr->vendor_name, vendor, sizeof(hdr->vendor_name));
370        strncpy(hdr->fw_version, version, sizeof(hdr->fw_version));
371        hdr->hw_id = HOST_TO_BE32(board->hw_id);
372        hdr->hw_rev = HOST_TO_BE32(board->hw_rev);
373
374        if (boot_info.file_size == 0)
375                memcpy(hdr->md5sum1, md5salt_normal, sizeof(hdr->md5sum1));
376        else
377                memcpy(hdr->md5sum1, md5salt_boot, sizeof(hdr->md5sum1));
378
379        hdr->kernel_la = HOST_TO_BE32(board->kernel_la);
380        hdr->kernel_ep = HOST_TO_BE32(board->kernel_ep);
381        hdr->fw_length = HOST_TO_BE32(board->fw_max_len);
382        hdr->kernel_ofs = HOST_TO_BE32(sizeof(struct fw_header));
383        hdr->kernel_len = HOST_TO_BE32(kernel_info.file_size);
384        if (!combined) {
385                hdr->rootfs_ofs = HOST_TO_BE32(board->rootfs_ofs);
386                hdr->rootfs_len = HOST_TO_BE32(rootfs_info.file_size);
387        }
388
389        get_md5(buf, len, hdr->md5sum1);
390}
391
392static int write_fw(char *data, int len)
393{
394        FILE *f;
395        int ret = EXIT_FAILURE;
396
397        f = fopen(ofname, "w");
398        if (f == NULL) {
399                ERRS("could not open \"%s\" for writing", ofname);
400                goto out;
401        }
402
403        errno = 0;
404        fwrite(data, len, 1, f);
405        if (errno) {
406                ERRS("unable to write output file");
407                goto out_flush;
408        }
409
410        DBG("firmware file \"%s\" completed", ofname);
411
412        ret = EXIT_SUCCESS;
413
414 out_flush:
415        fflush(f);
416        fclose(f);
417        if (ret != EXIT_SUCCESS) {
418                unlink(ofname);
419        }
420 out:
421        return ret;
422}
423
424static int build_fw(void)
425{
426        int buflen;
427        char *buf;
428        char *p;
429        int ret = EXIT_FAILURE;
430        int writelen = 0;
431
432        buflen = board->fw_max_len;
433
434        buf = malloc(buflen);
435        if (!buf) {
436                ERR("no memory for buffer\n");
437                goto out;
438        }
439
440        memset(buf, 0xff, buflen);
441        p = buf + sizeof(struct fw_header);
442        ret = read_to_buf(&kernel_info, p);
443        if (ret)
444                goto out_free_buf;
445
446        writelen = kernel_info.file_size;
447
448        if (!combined) {
449                p = buf + board->rootfs_ofs;
450                ret = read_to_buf(&rootfs_info, p);
451                if (ret)
452                        goto out_free_buf;
453
454                writelen = board->rootfs_ofs + rootfs_info.file_size;
455        }
456
457        if (!strip_padding)
458                writelen = buflen;
459
460        fill_header(buf, writelen);
461        ret = write_fw(buf, writelen);
462        if (ret)
463                goto out_free_buf;
464
465        ret = EXIT_SUCCESS;
466
467 out_free_buf:
468        free(buf);
469 out:
470        return ret;
471}
472
473int main(int argc, char *argv[])
474{
475        int ret = EXIT_FAILURE;
476        int err;
477
478        FILE *outfile;
479
480        progname = basename(argv[0]);
481
482        while ( 1 ) {
483                int c;
484
485                c = getopt(argc, argv, "B:V:N:ck:r:o:hs");
486                if (c == -1)
487                        break;
488
489                switch (c) {
490                case 'B':
491                        board_id = optarg;
492                        break;
493                case 'V':
494                        version = optarg;
495                        break;
496                case 'N':
497                        vendor = optarg;
498                        break;
499                case 'c':
500                        combined++;
501                        break;
502                case 'k':
503                        kernel_info.file_name = optarg;
504                        break;
505                case 'r':
506                        rootfs_info.file_name = optarg;
507                        break;
508                case 'o':
509                        ofname = optarg;
510                        break;
511                case 's':
512                        strip_padding = 1;
513                        break;
514                case 'h':
515                        usage(EXIT_SUCCESS);
516                        break;
517                default:
518                        usage(EXIT_FAILURE);
519                        break;
520                }
521        }
522
523        ret = check_options();
524        if (ret)
525                goto out;
526
527        ret = build_fw();
528
529 out:
530        return ret;
531}
532
Note: See TracBrowser for help on using the repository browser.