[ar71xx]: Belkin AC 1750 DB (F9K1115v2) support
[openwrt/svn-archive/archive.git] / tools / firmware-utils / src / edimax_fw_header.c
1 /*
2 * Copyright (C) 2014 Gabor Juhos <juhosg@openwrt.org>
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 2 as published
6 * by the Free Software Foundation.
7 *
8 */
9
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <stdint.h>
13 #include <string.h>
14 #include <unistd.h> /* for unlink() */
15 #include <libgen.h>
16 #include <getopt.h> /* for getopt() */
17 #include <stdarg.h>
18 #include <errno.h>
19 #include <sys/stat.h>
20
21 #include <arpa/inet.h>
22 #include <netinet/in.h>
23
24 #define MAX_MAGIC_LEN 16
25 #define MAX_MODEL_LEN 32
26 #define MAX_VERSION_LEN 14
27 #define MAX_MTD_NAME_LEN 16
28
29 #define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f))
30
31 struct edimax_header {
32 char magic[MAX_MAGIC_LEN];
33 char model[MAX_MODEL_LEN];
34 unsigned char force;
35 unsigned char header_csum;
36 unsigned char data_csum;
37 uint32_t data_size;
38 uint32_t start_addr;
39 uint32_t end_addr;
40 char fw_version[MAX_VERSION_LEN];
41 unsigned char type;
42 char mtd_name[MAX_MTD_NAME_LEN];
43 } __attribute__ ((packed));
44
45 /*
46 * Globals
47 */
48 static char *ofname;
49 static char *ifname;
50 static char *progname;
51
52 static char *model;
53 static char *magic = "eDiMaX";
54 static char *fw_version = "";
55 static char *mtd_name;
56 static int force;
57 static uint32_t start_addr;
58 static uint32_t end_addr;
59 static uint8_t image_type;
60 static int data_size;
61
62 /*
63 * Message macros
64 */
65 #define ERR(fmt, ...) do { \
66 fflush(0); \
67 fprintf(stderr, "[%s] *** error: " fmt "\n", \
68 progname, ## __VA_ARGS__ ); \
69 } while (0)
70
71 #define ERRS(fmt, ...) do { \
72 int save = errno; \
73 fflush(0); \
74 fprintf(stderr, "[%s] *** error: " fmt " (%s)\n", \
75 progname, ## __VA_ARGS__, strerror(save)); \
76 } while (0)
77
78 #define DBG(fmt, ...) do { \
79 fprintf(stderr, "[%s] " fmt "\n", progname, ## __VA_ARGS__ ); \
80 } while (0)
81
82 static void usage(int status)
83 {
84 FILE *stream = (status != EXIT_SUCCESS) ? stderr : stdout;
85
86 fprintf(stream, "Usage: %s [OPTIONS...]\n", progname);
87 fprintf(stream,
88 "\n"
89 "Options:\n"
90 " -e <addr> set end addr to <addr>\n"
91 " -f set force flag\n"
92 " -h show this screen\n"
93 " -i <file> read input data from the file <file>\n"
94 " -o <file> write output to the file <file>\n"
95 " -m <model> set model to <model>\n"
96 " -M <magic> set image magic to <magic>\n"
97 " -n <name> set MTD device name to <name>\n"
98 " -s <addr> set start address to <addr>\n"
99 " -t <type> set image type to <type>\n"
100 " -v <version> set firmware version to <version>\n"
101 );
102
103 exit(status);
104 }
105
106 int
107 str2u32(char *arg, uint32_t *val)
108 {
109 char *err = NULL;
110 uint32_t t;
111
112 errno=0;
113 t = strtoul(arg, &err, 0);
114 if (errno || (err==arg) || ((err != NULL) && *err)) {
115 return -1;
116 }
117
118 *val = t;
119 return 0;
120 }
121
122 int
123 str2u8(char *arg, uint8_t *val)
124 {
125 char *err = NULL;
126 uint32_t t;
127
128 errno=0;
129 t = strtoul(arg, &err, 0);
130 if (errno || (err==arg) || ((err != NULL) && *err) || (t >= 0x100)) {
131 return -1;
132 }
133
134 *val = t & 0xFF;
135 return 0;
136 }
137
138 static int get_file_size(char *name)
139 {
140 struct stat st;
141 int res;
142
143 res = stat(name, &st);
144 if (res){
145 ERRS("stat failed on %s", name);
146 return -1;
147 }
148
149 return st.st_size;
150 }
151
152 static int read_to_buf(char *name, char *buf, int buflen)
153 {
154 FILE *f;
155 int ret = EXIT_FAILURE;
156
157 f = fopen(name, "r");
158 if (f == NULL) {
159 ERRS("could not open \"%s\" for reading", name);
160 goto out;
161 }
162
163 errno = 0;
164 fread(buf, buflen, 1, f);
165 if (errno != 0) {
166 ERRS("unable to read from file \"%s\"", name);
167 goto out_close;
168 }
169
170 ret = EXIT_SUCCESS;
171
172 out_close:
173 fclose(f);
174 out:
175 return ret;
176 }
177
178 static int check_options(void)
179 {
180 #define CHKSTR(_name, _msg) \
181 do { \
182 if (_name == NULL) { \
183 ERR("no %s specified", _msg); \
184 return -1; \
185 } \
186 } while (0)
187
188 #define CHKSTRLEN(_name, _msg) \
189 do { \
190 int field_len; \
191 CHKSTR(_name, _msg); \
192 field_len = FIELD_SIZEOF(struct edimax_header, _name) - 1; \
193 if (strlen(_name) > field_len) { \
194 ERR("'%s' is too long, max %s length is %d", \
195 _name, _msg, field_len); \
196 return -1; \
197 } \
198 } while (0)
199
200 CHKSTR(ofname, "output file");
201 CHKSTR(ifname, "input file");
202
203 CHKSTRLEN(magic, "magic");
204 CHKSTRLEN(model, "model");
205 CHKSTRLEN(mtd_name, "MTD device name");
206 CHKSTRLEN(fw_version, "firware version");
207
208 data_size = get_file_size(ifname);
209 if (data_size < 0)
210 return -1;
211
212 return 0;
213 }
214
215 static int write_fw(char *data, int len)
216 {
217 FILE *f;
218 int ret = EXIT_FAILURE;
219
220 f = fopen(ofname, "w");
221 if (f == NULL) {
222 ERRS("could not open \"%s\" for writing", ofname);
223 goto out;
224 }
225
226 errno = 0;
227 fwrite(data, len, 1, f);
228 if (errno) {
229 ERRS("unable to write output file");
230 goto out_flush;
231 }
232
233 DBG("firmware file \"%s\" completed", ofname);
234
235 ret = EXIT_SUCCESS;
236
237 out_flush:
238 fflush(f);
239 fclose(f);
240 if (ret != EXIT_SUCCESS) {
241 unlink(ofname);
242 }
243 out:
244 return ret;
245 }
246
247 static unsigned char checksum(unsigned char *p, unsigned len)
248 {
249 unsigned char csum = 0;
250
251 while (len--)
252 csum += *p++;
253
254 csum ^= 0xb9;
255
256 return csum;
257 }
258
259 static int build_fw(void)
260 {
261 int buflen;
262 char *buf;
263 char *data;
264 struct edimax_header *hdr;
265 int ret = EXIT_FAILURE;
266
267 buflen = sizeof(struct edimax_header) + data_size;
268
269 buf = malloc(buflen);
270 if (!buf) {
271 ERR("no memory for buffer\n");
272 goto out;
273 }
274
275 data = buf + sizeof(struct edimax_header);
276
277 /* read input file */
278 ret = read_to_buf(ifname, data, data_size);
279 if (ret)
280 goto out_free_buf;
281
282 /* fill firmware header */
283 hdr = (struct edimax_header *)buf;
284 memset(hdr, 0, sizeof(struct edimax_header *));
285
286 strncpy(hdr->model, model, sizeof(hdr->model));
287 strncpy(hdr->magic, magic, sizeof(hdr->magic));
288 strncpy(hdr->fw_version, fw_version, sizeof(hdr->fw_version));
289 strncpy(hdr->mtd_name, mtd_name, sizeof(hdr->mtd_name));
290
291 hdr->force = force;
292 hdr->start_addr = htonl(start_addr);
293 hdr->end_addr = htonl(end_addr);
294 hdr->data_size = htonl(data_size);
295 hdr->type = image_type;
296
297 hdr->data_csum = checksum((unsigned char *)data, data_size);
298 hdr->header_csum = checksum((unsigned char *)hdr,
299 sizeof(struct edimax_header));
300
301 ret = write_fw(buf, buflen);
302 if (ret)
303 goto out_free_buf;
304
305 ret = EXIT_SUCCESS;
306
307 out_free_buf:
308 free(buf);
309 out:
310 return ret;
311 }
312
313 int main(int argc, char *argv[])
314 {
315 int ret = EXIT_FAILURE;
316
317 progname = basename(argv[0]);
318
319 while (1) {
320 int c;
321
322 c = getopt(argc, argv, "e:fhi:o:m:M:n:s:t:v:");
323 if (c == -1)
324 break;
325
326 switch (c) {
327 case 'e':
328 if (str2u32(optarg, &end_addr)) {
329 ERR("%s is invalid '%s'",
330 "end address", optarg);
331 goto out;
332 }
333 break;
334 case 'f':
335 force = 1;
336 break;
337 case 'i':
338 ifname = optarg;
339 break;
340 case 'h':
341 usage(EXIT_SUCCESS);
342 break;
343 case 'o':
344 ofname = optarg;
345 break;
346 case 'm':
347 model = optarg;
348 break;
349 case 'M':
350 magic = optarg;
351 break;
352 case 'n':
353 mtd_name = optarg;
354 break;
355 case 's':
356 if (str2u32(optarg, &start_addr)) {
357 ERR("%s is invalid '%s'",
358 "start address", optarg);
359 goto out;
360 }
361 break;
362 case 't':
363 if (str2u8(optarg, &image_type)) {
364 ERR("%s is invalid '%s'",
365 "image type", optarg);
366 goto out;
367 }
368 break;
369 case 'v':
370 fw_version = optarg;
371 break;
372 default:
373 usage(EXIT_FAILURE);
374 break;
375 }
376 }
377
378 ret = check_options();
379 if (ret)
380 goto out;
381
382 ret = build_fw();
383
384 out:
385 return ret;
386 }