mac80211: restrict peer's VHT capabilities to own
[carl9170fw.git] / tools / lib / carlfw.c
1 /*
2  * Copyright 2010-2011 Christian Lamparter <chunkeey@googlemail.com>
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation version 2 of the License.
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11  * GNU General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License along
14  * with this program; if not, write to the Free Software Foundation, Inc.,
15  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
16  */
17
18 #include <stdlib.h>
19 #include <stdio.h>
20 #include <error.h>
21 #include <string.h>
22 #include <errno.h>
23 #include <sys/types.h>
24 #include <sys/stat.h>
25 #include <unistd.h>
26
27 #include "carlfw.h"
28
29 struct carlfw_file {
30         char *name;
31         size_t len;
32         char *data;
33 };
34
35 struct carlfw {
36         struct carlfw_file fw;
37         struct carlfw_file hdr;
38
39         struct list_head desc_list;
40         unsigned int desc_list_entries,
41                      desc_list_len;
42 };
43
44 #define carlfw_walk_descs(iter, fw)                                     \
45         list_for_each_entry(iter, &fw->desc_list, h.list)
46
47 struct carlfw_list_entry_head {
48         struct list_head list;
49 };
50
51 struct carlfw_list_entry {
52         struct carlfw_list_entry_head h;
53         union {
54                 struct carl9170fw_desc_head head;
55                 uint32_t data[0];
56                 char text[0];
57         };
58 };
59
60 static inline struct carlfw_list_entry *carlfw_desc_to_entry(struct carl9170fw_desc_head *head)
61 {
62         return container_of(head, struct carlfw_list_entry, head);
63 }
64
65 static inline struct carl9170fw_desc_head *carlfw_entry_to_desc(struct carlfw_list_entry *entry)
66 {
67         return &entry->head;
68 }
69
70 static void carlfw_entry_unlink(struct carlfw *fw,
71         struct carlfw_list_entry *entry)
72 {
73         fw->desc_list_entries--;
74         fw->desc_list_len -= le16_to_cpu(entry->head.length);
75         list_del(&entry->h.list);
76 }
77
78 static void carlfw_entry_del(struct carlfw *fw,
79         struct carlfw_list_entry *entry)
80 {
81         carlfw_entry_unlink(fw, entry);
82         free(entry);
83 }
84
85 static struct carlfw_list_entry *carlfw_find_entry(struct carlfw *fw,
86                                                    const uint8_t descid[4],
87                                                    unsigned int len,
88                                                    uint8_t compatible_revision)
89 {
90         struct carlfw_list_entry *iter;
91
92         carlfw_walk_descs(iter, fw) {
93                 if (carl9170fw_desc_cmp(&iter->head, descid, len,
94                                          compatible_revision))
95                         return (void *)iter;
96         }
97
98         return NULL;
99 }
100
101 static struct carlfw_list_entry *__carlfw_entry_add_prepare(struct carlfw *fw,
102         const struct carl9170fw_desc_head *desc)
103 {
104         struct carlfw_list_entry *tmp;
105         unsigned int len;
106
107         len = le16_to_cpu(desc->length);
108
109         if (len < sizeof(struct carl9170fw_desc_head))
110                 return ERR_PTR(-EINVAL);
111
112         tmp = malloc(sizeof(*tmp) + len);
113         if (!tmp)
114                 return ERR_PTR(-ENOMEM);
115
116         fw->desc_list_entries++;
117         fw->desc_list_len += len;
118
119         memcpy(tmp->data, desc, len);
120         return tmp;
121 }
122
123 static void __carlfw_release(struct carlfw_file *f)
124 {
125         f->len = 0;
126         if (f->name)
127                 free(f->name);
128         f->name = NULL;
129
130         if (f->data)
131                 free(f->data);
132         f->data = NULL;
133 }
134
135 void carlfw_release(struct carlfw *fw)
136 {
137         struct carlfw_list_entry *entry;
138
139         if (!IS_ERR_OR_NULL(fw)) {
140                 while (!list_empty(&fw->desc_list)) {
141                         entry = list_entry(fw->desc_list.next,
142                                            struct carlfw_list_entry, h.list);
143                         carlfw_entry_del(fw, entry);
144                 }
145
146                 __carlfw_release(&fw->fw);
147                 __carlfw_release(&fw->hdr);
148                 free(fw);
149         }
150 }
151
152 static int __carlfw_load(struct carlfw_file *file, const char *name, const char *mode)
153 {
154         struct stat file_stat;
155         FILE *fh;
156         int err;
157
158         fh = fopen(name, mode);
159         if (fh == NULL)
160                 return errno ? -errno : -1;
161
162         err = fstat(fileno(fh), &file_stat);
163         if (err)
164                 return errno ? -errno : -1;
165
166         file->len = file_stat.st_size;
167         file->data = malloc(file->len);
168         if (file->data == NULL)
169                 return -ENOMEM;
170
171         err = fread(file->data, file->len, 1, fh);
172         if (err != 1)
173                 return -ferror(fh);
174
175         file->name = strdup(name);
176         fclose(fh);
177
178         if (!file->name)
179                 return -ENOMEM;
180
181         return 0;
182 }
183
184 static void *__carlfw_find_desc(struct carlfw_file *file,
185                                 uint8_t descid[4],
186                                 unsigned int len,
187                                 uint8_t compatible_revision)
188 {
189         int scan, found = 0;
190         struct carl9170fw_desc_head *tmp = NULL;
191
192         /*
193          * Note: the last desc also has atleast a full desc_head.
194          * There's no reason for looking beyond that point.
195          */
196         scan = (file->len - 1) - (sizeof(*tmp) - CARL9170FW_MAGIC_SIZE);
197         while (scan > 0) {
198                 if (file->data[scan] == descid[CARL9170FW_MAGIC_SIZE - found - 1])
199                         found++;
200                 else
201                         found = 0;
202
203                 if (found == CARL9170FW_MAGIC_SIZE)
204                         break;
205
206                 scan--;
207         }
208
209         if (found == CARL9170FW_MAGIC_SIZE) {
210                 u16 tmp_desc_len;
211
212                 tmp = (void *) &file->data[scan];
213                 tmp_desc_len = le16_to_cpu(tmp->length);
214
215                 if (!CHECK_HDR_VERSION(tmp, compatible_revision) &&
216                     (scan + tmp_desc_len <= file->len) && (tmp_desc_len >= len))
217                         return tmp;
218         }
219
220         return NULL;
221 }
222
223 void *carlfw_find_desc(struct carlfw *fw,
224                        const uint8_t descid[4],
225                        const unsigned int len,
226                        const uint8_t compatible_revision)
227 {
228         struct carlfw_list_entry *tmp;
229
230         tmp = carlfw_find_entry(fw, descid, len, compatible_revision);
231
232         return tmp ? carlfw_entry_to_desc(tmp) : NULL;
233 }
234
235 int carlfw_desc_add_tail(struct carlfw *fw,
236         const struct carl9170fw_desc_head *desc)
237 {
238         struct carlfw_list_entry *tmp;
239
240         tmp = __carlfw_entry_add_prepare(fw, desc);
241         if (IS_ERR(tmp))
242                 return PTR_ERR(tmp);
243
244         list_add_tail(&tmp->h.list, &fw->desc_list);
245         return 0;
246 }
247
248 int carlfw_desc_add(struct carlfw *fw,
249                     const struct carl9170fw_desc_head *desc,
250                     struct carl9170fw_desc_head *prev,
251                     struct carl9170fw_desc_head *next)
252 {
253         struct carlfw_list_entry *tmp;
254
255         tmp = __carlfw_entry_add_prepare(fw, desc);
256         if (IS_ERR(tmp))
257                 return PTR_ERR(tmp);
258
259         list_add(&tmp->h.list, &((carlfw_desc_to_entry(prev))->h.list),
260                  &((carlfw_desc_to_entry(next))->h.list));
261         return 0;
262 }
263
264 int carlfw_desc_add_before(struct carlfw *fw,
265                            const struct carl9170fw_desc_head *desc,
266                            struct carl9170fw_desc_head *pos)
267 {
268         struct carl9170fw_desc_head *prev;
269         struct carlfw_list_entry *prev_entry;
270
271         prev_entry = carlfw_desc_to_entry(pos);
272
273         prev = carlfw_entry_to_desc((struct carlfw_list_entry *) prev_entry->h.list.prev);
274
275         return carlfw_desc_add(fw, desc, prev, pos);
276 }
277
278 void carlfw_desc_unlink(struct carlfw *fw,
279         struct carl9170fw_desc_head *desc)
280 {
281         carlfw_entry_unlink(fw, carlfw_desc_to_entry(desc));
282 }
283
284 void carlfw_desc_del(struct carlfw *fw,
285         struct carl9170fw_desc_head *desc)
286 {
287         carlfw_entry_del(fw, carlfw_desc_to_entry(desc));
288 }
289
290 void *carlfw_desc_mod_len(struct carlfw *fw __unused,
291         struct carl9170fw_desc_head *desc, size_t len)
292 {
293         struct carlfw_list_entry *obj, tmp;
294         int new_len = le16_to_cpu(desc->length) + len;
295
296         if (new_len < (int)sizeof(*desc))
297                 return ERR_PTR(-EINVAL);
298
299         if (new_len > CARL9170FW_DESC_MAX_LENGTH)
300                 return ERR_PTR(-E2BIG);
301
302         obj = carlfw_desc_to_entry(desc);
303
304         memcpy(&tmp, obj, sizeof(tmp));
305         obj = realloc(obj, new_len + sizeof(struct carlfw_list_entry_head));
306         if (obj == NULL)
307                 return ERR_PTR(-ENOMEM);
308
309         list_replace(&tmp.h.list, &obj->h.list);
310
311         desc = carlfw_entry_to_desc(obj);
312         desc->length = le16_to_cpu(new_len);
313         fw->desc_list_len += len;
314
315         return desc;
316 }
317
318 void *carlfw_desc_next(struct carlfw *fw,
319                        struct carl9170fw_desc_head *pos)
320 {
321         struct carlfw_list_entry *entry;
322
323         if (!pos)
324                 entry = (struct carlfw_list_entry *) &fw->desc_list;
325         else
326                 entry = carlfw_desc_to_entry(pos);
327
328         if (list_at_tail(entry, &fw->desc_list, h.list))
329                 return NULL;
330
331         entry = (struct carlfw_list_entry *) entry->h.list.next;
332
333         return carlfw_entry_to_desc(entry);
334 }
335
336 static int carlfw_parse_descs(struct carlfw *fw,
337                               struct carl9170fw_otus_desc *otus_desc)
338 {
339         const struct carl9170fw_desc_head *iter = NULL;
340         int err;
341
342         carl9170fw_for_each_hdr(iter, &otus_desc->head) {
343                 err = carlfw_desc_add_tail(fw, iter);
344                 if (err)
345                         return err;
346         }
347         /* LAST is added automatically by carlfw_store */
348
349         return err;
350 }
351
352 #if BYTE_ORDER == LITTLE_ENDIAN
353 #define CRCPOLY_LE 0xedb88320
354
355 /* copied from the linux kernel  */
356 static uint32_t crc32_le(uint32_t crc, unsigned char const *p, size_t len)
357 {
358         int i;
359         while (len--) {
360                 crc ^= *p++;
361                 for (i = 0; i < 8; i++)
362                         crc = (crc >> 1) ^ ((crc & 1) ? CRCPOLY_LE : 0);
363         }
364         return crc;
365 }
366 #else
367 #error "this tool does not work with a big endian host yet!"
368 #endif
369
370 static int carlfw_check_crc32s(struct carlfw *fw)
371 {
372         struct carl9170fw_chk_desc *chk_desc;
373         struct carlfw_list_entry *iter;
374         unsigned int elen;
375         uint32_t crc32;
376
377         chk_desc = carlfw_find_desc(fw, (uint8_t *) CHK_MAGIC,
378                                     sizeof(*chk_desc),
379                                     CARL9170FW_CHK_DESC_CUR_VER);
380         if (!chk_desc)
381                 return -ENODATA;
382
383         crc32 = crc32_le(~0, (void *) fw->fw.data, fw->fw.len);
384         if (crc32 != le32_to_cpu(chk_desc->fw_crc32))
385                 return -EINVAL;
386
387         carlfw_walk_descs(iter, fw) {
388                 elen = le16_to_cpu(iter->head.length);
389
390                 if (carl9170fw_desc_cmp(&iter->head, (uint8_t *) CHK_MAGIC,
391                                         sizeof(*chk_desc),
392                                         CARL9170FW_CHK_DESC_CUR_VER))
393                         continue;
394
395                 crc32 = crc32_le(crc32, (void *) &iter->head, elen);
396         }
397
398         if (crc32 != le32_to_cpu(chk_desc->hdr_crc32))
399                 return -EINVAL;
400
401         return 0;
402 }
403
404 struct carlfw *carlfw_load(const char *basename)
405 {
406         char filename[256];
407         struct carlfw *fw;
408         struct carl9170fw_otus_desc *otus_desc;
409         struct carl9170fw_last_desc *last_desc;
410         struct carlfw_file *hdr_file;
411         unsigned long fin, diff, off, rem;
412         int err;
413
414         fw = calloc(1, sizeof(*fw));
415         if (!fw)
416                 return ERR_PTR(-ENOMEM);
417
418         init_list_head(&fw->desc_list);
419
420         err = __carlfw_load(&fw->fw, basename, "r");
421         if (err)
422                 goto err_out;
423
424         if (fw->hdr.name)
425                 hdr_file = &fw->hdr;
426         else
427                 hdr_file = &fw->fw;
428
429         otus_desc = __carlfw_find_desc(hdr_file, (uint8_t *) OTUS_MAGIC,
430                                        sizeof(*otus_desc),
431                                        CARL9170FW_OTUS_DESC_CUR_VER);
432         last_desc = __carlfw_find_desc(hdr_file, (uint8_t *) LAST_MAGIC,
433                                        sizeof(*last_desc),
434                                        CARL9170FW_LAST_DESC_CUR_VER);
435
436         if (!otus_desc || !last_desc ||
437             (unsigned long) otus_desc > (unsigned long) last_desc) {
438                 err = -ENODATA;
439                 goto err_out;
440         }
441
442         err = carlfw_parse_descs(fw, otus_desc);
443         if (err)
444                 goto err_out;
445
446         fin = (unsigned long)last_desc + sizeof(*last_desc);
447         diff = fin - (unsigned long)otus_desc;
448         rem = hdr_file->len - (fin - (unsigned long) hdr_file->data);
449
450         if (rem) {
451                 off = (unsigned long)otus_desc - (unsigned long)hdr_file->data;
452                 memmove(&hdr_file->data[off],
453                         ((uint8_t *)last_desc) + sizeof(*last_desc), rem);
454         }
455
456         hdr_file->len -= diff;
457         hdr_file->data = realloc(hdr_file->data, hdr_file->len);
458         if (!hdr_file->data && hdr_file->len) {
459                 err = -ENOMEM;
460                 goto err_out;
461         }
462
463         err = carlfw_check_crc32s(fw);
464         if (err && err != -ENODATA)
465                 goto err_out;
466
467         return fw;
468
469 err_out:
470         carlfw_release(fw);
471         return ERR_PTR(err);
472 }
473
474 static int carlfw_apply_checksums(struct carlfw *fw)
475 {
476         struct carlfw_list_entry *iter;
477         struct carl9170fw_chk_desc tmp = {
478                 CARL9170FW_FILL_DESC(CHK_MAGIC, sizeof(tmp),
479                                       CARL9170FW_CHK_DESC_MIN_VER,
480                                       CARL9170FW_CHK_DESC_CUR_VER) };
481         struct carl9170fw_chk_desc *chk_desc = NULL;
482         int err = 0;
483         unsigned int len = 0, elen, max_len;
484         uint32_t crc32;
485
486         chk_desc = carlfw_find_desc(fw, (uint8_t *) CHK_MAGIC,
487                                     sizeof(*chk_desc),
488                                     CARL9170FW_CHK_DESC_CUR_VER);
489         if (chk_desc) {
490                 carlfw_desc_del(fw, &chk_desc->head);
491                 chk_desc = NULL;
492         }
493
494         max_len = fw->desc_list_len;
495
496         crc32 = crc32_le(~0, (void *) fw->fw.data, fw->fw.len);
497         tmp.fw_crc32 = cpu_to_le32(crc32);
498
499         /*
500          * NOTE:
501          *
502          * The descriptor checksum is seeded with the firmware's crc32.
503          * This neat trick ensures that the driver can check whenever
504          * descriptor actually belongs to the firmware, or not.
505          */
506
507         carlfw_walk_descs(iter, fw) {
508                 elen = le16_to_cpu(iter->head.length);
509
510                 if (max_len < len + elen)
511                         return -EMSGSIZE;
512
513                 crc32 = crc32_le(crc32, (void *) &iter->head, elen);
514                 len += elen;
515         }
516
517         tmp.hdr_crc32 = cpu_to_le32(crc32);
518
519         err = carlfw_desc_add_tail(fw, &tmp.head);
520
521         return err;
522 }
523
524 int carlfw_store(struct carlfw *fw)
525 {
526         struct carl9170fw_last_desc last_desc = {
527                 CARL9170FW_FILL_DESC(LAST_MAGIC, sizeof(last_desc),
528                         CARL9170FW_LAST_DESC_MIN_VER,
529                         CARL9170FW_LAST_DESC_CUR_VER) };
530
531         struct carlfw_list_entry *iter;
532         FILE *fh;
533         int err, elen;
534
535         err = carlfw_apply_checksums(fw);
536         if (err)
537                 return err;
538
539         fh = fopen(fw->fw.name, "w");
540         if (!fh)
541                 return -errno;
542
543         err = fwrite(fw->fw.data, fw->fw.len, 1, fh);
544         if (err != 1) {
545                 err = -errno;
546                 goto close_out;
547         }
548
549         if (fw->hdr.name) {
550                 fclose(fh);
551
552                 fh = fopen(fw->hdr.name, "w");
553         }
554
555         carlfw_walk_descs(iter, fw) {
556                 elen = le16_to_cpu(iter->head.length);
557
558                 if (elen > CARL9170FW_DESC_MAX_LENGTH) {
559                         err = -E2BIG;
560                         goto close_out;
561                 }
562
563                 err = fwrite(iter->data, elen, 1, fh);
564                 if (err != 1) {
565                         err = -ferror(fh);
566                         goto close_out;
567                 }
568         }
569
570         err = fwrite(&last_desc, sizeof(last_desc), 1, fh);
571         if (err != 1) {
572                 err = -ferror(fh);
573                 goto close_out;
574         }
575
576         err = 0;
577
578 close_out:
579         fclose(fh);
580         return err;
581 }
582
583 void *carlfw_mod_tailroom(struct carlfw *fw, ssize_t len)
584 {
585         size_t new_len;
586         void *buf;
587
588         new_len = fw->fw.len + len;
589
590         if (!carl9170fw_size_check(new_len))
591                 return ERR_PTR(-EINVAL);
592
593         buf = realloc(fw->fw.data, new_len);
594         if (buf == NULL)
595                 return ERR_PTR(-ENOMEM);
596
597         fw->fw.len = new_len;
598         fw->fw.data = buf;
599         return &fw->fw.data[new_len - len];
600 }
601
602 void *carlfw_mod_headroom(struct carlfw *fw, ssize_t len)
603 {
604         size_t new_len;
605         void *ptr;
606
607         new_len = fw->fw.len + len;
608         if (!carl9170fw_size_check(new_len))
609                 return ERR_PTR(-EINVAL);
610
611         if (len < 0)
612                 memmove(fw->fw.data, &fw->fw.data[len], new_len);
613
614         ptr = carlfw_mod_tailroom(fw, len);
615         if (IS_ERR_OR_NULL(ptr))
616                 return ptr;
617
618         if (len > 0)
619                 memmove(&fw->fw.data[len], &fw->fw.data[0], new_len - len);
620
621         return fw->fw.data;
622 }
623
624 void *carlfw_get_fw(struct carlfw *fw, size_t *len)
625 {
626         *len = fw->fw.len;
627         return fw->fw.data;
628 }
629
630 unsigned int carlfw_get_descs_num(struct carlfw *fw)
631 {
632         return fw->desc_list_entries;
633 }
634
635 unsigned int carlfw_get_descs_size(struct carlfw *fw)
636 {
637         return fw->desc_list_len;
638 }