1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/kernel.h>
24#include <linux/firmware.h>
25#include <linux/crc32.h>
26#include <linux/module.h>
27#include "carl9170.h"
28#include "fwcmd.h"
29#include "version.h"
30
31static const u8 otus_magic[4] = { OTUS_MAGIC };
32
33static const void *carl9170_fw_find_desc(struct ar9170 *ar, const u8 descid[4],
34 const unsigned int len, const u8 compatible_revision)
35{
36 const struct carl9170fw_desc_head *iter;
37
38 carl9170fw_for_each_hdr(iter, ar->fw.desc) {
39 if (carl9170fw_desc_cmp(iter, descid, len,
40 compatible_revision))
41 return (void *)iter;
42 }
43
44
45 if (carl9170fw_desc_cmp(iter, descid, len,
46 compatible_revision))
47 return (void *)iter;
48
49 return NULL;
50}
51
52static int carl9170_fw_verify_descs(struct ar9170 *ar,
53 const struct carl9170fw_desc_head *head, unsigned int max_len)
54{
55 const struct carl9170fw_desc_head *pos;
56 unsigned long pos_addr, end_addr;
57 unsigned int pos_length;
58
59 if (max_len < sizeof(*pos))
60 return -ENODATA;
61
62 max_len = min_t(unsigned int, CARL9170FW_DESC_MAX_LENGTH, max_len);
63
64 pos = head;
65 pos_addr = (unsigned long) pos;
66 end_addr = pos_addr + max_len;
67
68 while (pos_addr < end_addr) {
69 if (pos_addr + sizeof(*head) > end_addr)
70 return -E2BIG;
71
72 pos_length = le16_to_cpu(pos->length);
73
74 if (pos_length < sizeof(*head))
75 return -EBADMSG;
76
77 if (pos_length > max_len)
78 return -EOVERFLOW;
79
80 if (pos_addr + pos_length > end_addr)
81 return -EMSGSIZE;
82
83 if (carl9170fw_desc_cmp(pos, LAST_MAGIC,
84 CARL9170FW_LAST_DESC_SIZE,
85 CARL9170FW_LAST_DESC_CUR_VER))
86 return 0;
87
88 pos_addr += pos_length;
89 pos = (void *)pos_addr;
90 max_len -= pos_length;
91 }
92 return -EINVAL;
93}
94
95static void carl9170_fw_info(struct ar9170 *ar)
96{
97 const struct carl9170fw_motd_desc *motd_desc;
98 unsigned int str_ver_len;
99 u32 fw_date;
100
101 dev_info(&ar->udev->dev, "driver API: %s 2%03d-%02d-%02d [%d-%d]\n",
102 CARL9170FW_VERSION_GIT, CARL9170FW_VERSION_YEAR,
103 CARL9170FW_VERSION_MONTH, CARL9170FW_VERSION_DAY,
104 CARL9170FW_API_MIN_VER, CARL9170FW_API_MAX_VER);
105
106 motd_desc = carl9170_fw_find_desc(ar, MOTD_MAGIC,
107 sizeof(*motd_desc), CARL9170FW_MOTD_DESC_CUR_VER);
108
109 if (motd_desc) {
110 str_ver_len = strnlen(motd_desc->release,
111 CARL9170FW_MOTD_RELEASE_LEN);
112
113 fw_date = le32_to_cpu(motd_desc->fw_year_month_day);
114
115 dev_info(&ar->udev->dev, "firmware API: %.*s 2%03d-%02d-%02d\n",
116 str_ver_len, motd_desc->release,
117 CARL9170FW_GET_YEAR(fw_date),
118 CARL9170FW_GET_MONTH(fw_date),
119 CARL9170FW_GET_DAY(fw_date));
120
121 strlcpy(ar->hw->wiphy->fw_version, motd_desc->release,
122 sizeof(ar->hw->wiphy->fw_version));
123 }
124}
125
126static bool valid_dma_addr(const u32 address)
127{
128 if (address >= AR9170_SRAM_OFFSET &&
129 address < (AR9170_SRAM_OFFSET + AR9170_SRAM_SIZE))
130 return true;
131
132 return false;
133}
134
135static bool valid_cpu_addr(const u32 address)
136{
137 if (valid_dma_addr(address) || (address >= AR9170_PRAM_OFFSET &&
138 address < (AR9170_PRAM_OFFSET + AR9170_PRAM_SIZE)))
139 return true;
140
141 return false;
142}
143
144static int carl9170_fw_checksum(struct ar9170 *ar, const __u8 *data,
145 size_t len)
146{
147 const struct carl9170fw_otus_desc *otus_desc;
148 const struct carl9170fw_last_desc *last_desc;
149 const struct carl9170fw_chk_desc *chk_desc;
150 unsigned long fin, diff;
151 unsigned int dsc_len;
152 u32 crc32;
153
154 last_desc = carl9170_fw_find_desc(ar, LAST_MAGIC,
155 sizeof(*last_desc), CARL9170FW_LAST_DESC_CUR_VER);
156 if (!last_desc)
157 return -EINVAL;
158
159 otus_desc = carl9170_fw_find_desc(ar, OTUS_MAGIC,
160 sizeof(*otus_desc), CARL9170FW_OTUS_DESC_CUR_VER);
161 if (!otus_desc) {
162 dev_err(&ar->udev->dev, "failed to find compatible firmware "
163 "descriptor.\n");
164 return -ENODATA;
165 }
166
167 chk_desc = carl9170_fw_find_desc(ar, CHK_MAGIC,
168 sizeof(*chk_desc), CARL9170FW_CHK_DESC_CUR_VER);
169
170 if (!chk_desc) {
171 dev_warn(&ar->udev->dev, "Unprotected firmware image.\n");
172 return 0;
173 }
174
175 dsc_len = min_t(unsigned int, len,
176 (unsigned long)chk_desc - (unsigned long)otus_desc);
177
178 fin = (unsigned long) last_desc + sizeof(*last_desc);
179 diff = fin - (unsigned long) otus_desc;
180
181 if (diff < len)
182 len -= diff;
183
184 if (len < 256)
185 return -EIO;
186
187 crc32 = crc32_le(~0, data, len);
188 if (cpu_to_le32(crc32) != chk_desc->fw_crc32) {
189 dev_err(&ar->udev->dev, "fw checksum test failed.\n");
190 return -ENOEXEC;
191 }
192
193 crc32 = crc32_le(crc32, (void *)otus_desc, dsc_len);
194 if (cpu_to_le32(crc32) != chk_desc->hdr_crc32) {
195 dev_err(&ar->udev->dev, "descriptor check failed.\n");
196 return -EINVAL;
197 }
198 return 0;
199}
200
201static int carl9170_fw_tx_sequence(struct ar9170 *ar)
202{
203 const struct carl9170fw_txsq_desc *txsq_desc;
204
205 txsq_desc = carl9170_fw_find_desc(ar, TXSQ_MAGIC, sizeof(*txsq_desc),
206 CARL9170FW_TXSQ_DESC_CUR_VER);
207 if (txsq_desc) {
208 ar->fw.tx_seq_table = le32_to_cpu(txsq_desc->seq_table_addr);
209 if (!valid_cpu_addr(ar->fw.tx_seq_table))
210 return -EINVAL;
211 } else {
212 ar->fw.tx_seq_table = 0;
213 }
214
215 return 0;
216}
217
218static void carl9170_fw_set_if_combinations(struct ar9170 *ar,
219 u16 if_comb_types)
220{
221 if (ar->fw.vif_num < 2)
222 return;
223
224 ar->if_comb_limits[0].max = ar->fw.vif_num;
225 ar->if_comb_limits[0].types = if_comb_types;
226
227 ar->if_combs[0].num_different_channels = 1;
228 ar->if_combs[0].max_interfaces = ar->fw.vif_num;
229 ar->if_combs[0].limits = ar->if_comb_limits;
230 ar->if_combs[0].n_limits = ARRAY_SIZE(ar->if_comb_limits);
231
232 ar->hw->wiphy->iface_combinations = ar->if_combs;
233 ar->hw->wiphy->n_iface_combinations = ARRAY_SIZE(ar->if_combs);
234}
235
236static int carl9170_fw(struct ar9170 *ar, const __u8 *data, size_t len)
237{
238 const struct carl9170fw_otus_desc *otus_desc;
239 int err;
240 u16 if_comb_types;
241
242 err = carl9170_fw_checksum(ar, data, len);
243 if (err)
244 return err;
245
246 otus_desc = carl9170_fw_find_desc(ar, OTUS_MAGIC,
247 sizeof(*otus_desc), CARL9170FW_OTUS_DESC_CUR_VER);
248 if (!otus_desc) {
249 return -ENODATA;
250 }
251
252#define SUPP(feat) \
253 (carl9170fw_supports(otus_desc->feature_set, feat))
254
255 if (!SUPP(CARL9170FW_DUMMY_FEATURE)) {
256 dev_err(&ar->udev->dev, "invalid firmware descriptor "
257 "format detected.\n");
258 return -EINVAL;
259 }
260
261 ar->fw.api_version = otus_desc->api_ver;
262
263 if (ar->fw.api_version < CARL9170FW_API_MIN_VER ||
264 ar->fw.api_version > CARL9170FW_API_MAX_VER) {
265 dev_err(&ar->udev->dev, "unsupported firmware api version.\n");
266 return -EINVAL;
267 }
268
269 if (!SUPP(CARL9170FW_COMMAND_PHY) || SUPP(CARL9170FW_UNUSABLE) ||
270 !SUPP(CARL9170FW_HANDLE_BACK_REQ)) {
271 dev_err(&ar->udev->dev, "firmware does support "
272 "mandatory features.\n");
273 return -ECANCELED;
274 }
275
276 if (ilog2(le32_to_cpu(otus_desc->feature_set)) >=
277 __CARL9170FW_FEATURE_NUM) {
278 dev_warn(&ar->udev->dev, "driver does not support all "
279 "firmware features.\n");
280 }
281
282 if (!SUPP(CARL9170FW_COMMAND_CAM)) {
283 dev_info(&ar->udev->dev, "crypto offloading is disabled "
284 "by firmware.\n");
285 ar->fw.disable_offload_fw = true;
286 }
287
288 if (SUPP(CARL9170FW_PSM) && SUPP(CARL9170FW_FIXED_5GHZ_PSM))
289 ieee80211_hw_set(ar->hw, SUPPORTS_PS);
290
291 if (!SUPP(CARL9170FW_USB_INIT_FIRMWARE)) {
292 dev_err(&ar->udev->dev, "firmware does not provide "
293 "mandatory interfaces.\n");
294 return -EINVAL;
295 }
296
297 if (SUPP(CARL9170FW_MINIBOOT))
298 ar->fw.offset = le16_to_cpu(otus_desc->miniboot_size);
299 else
300 ar->fw.offset = 0;
301
302 if (SUPP(CARL9170FW_USB_DOWN_STREAM)) {
303 ar->hw->extra_tx_headroom += sizeof(struct ar9170_stream);
304 ar->fw.tx_stream = true;
305 }
306
307 if (SUPP(CARL9170FW_USB_UP_STREAM))
308 ar->fw.rx_stream = true;
309
310 if (SUPP(CARL9170FW_RX_FILTER)) {
311 ar->fw.rx_filter = true;
312 ar->rx_filter_caps = FIF_FCSFAIL | FIF_PLCPFAIL |
313 FIF_CONTROL | FIF_PSPOLL | FIF_OTHER_BSS;
314 }
315
316 if (SUPP(CARL9170FW_HW_COUNTERS))
317 ar->fw.hw_counters = true;
318
319 if (SUPP(CARL9170FW_WOL))
320 device_set_wakeup_enable(&ar->udev->dev, true);
321
322 if (SUPP(CARL9170FW_RX_BA_FILTER))
323 ar->fw.ba_filter = true;
324
325 if_comb_types = BIT(NL80211_IFTYPE_STATION) |
326 BIT(NL80211_IFTYPE_P2P_CLIENT);
327
328 ar->fw.vif_num = otus_desc->vif_num;
329 ar->fw.cmd_bufs = otus_desc->cmd_bufs;
330 ar->fw.address = le32_to_cpu(otus_desc->fw_address);
331 ar->fw.rx_size = le16_to_cpu(otus_desc->rx_max_frame_len);
332 ar->fw.mem_blocks = min_t(unsigned int, otus_desc->tx_descs, 0xfe);
333 atomic_set(&ar->mem_free_blocks, ar->fw.mem_blocks);
334 ar->fw.mem_block_size = le16_to_cpu(otus_desc->tx_frag_len);
335
336 if (ar->fw.vif_num >= AR9170_MAX_VIRTUAL_MAC || !ar->fw.vif_num ||
337 ar->fw.mem_blocks < 16 || !ar->fw.cmd_bufs ||
338 ar->fw.mem_block_size < 64 || ar->fw.mem_block_size > 512 ||
339 ar->fw.rx_size > 32768 || ar->fw.rx_size < 4096 ||
340 !valid_cpu_addr(ar->fw.address)) {
341 dev_err(&ar->udev->dev, "firmware shows obvious signs of "
342 "malicious tampering.\n");
343 return -EINVAL;
344 }
345
346 ar->fw.beacon_addr = le32_to_cpu(otus_desc->bcn_addr);
347 ar->fw.beacon_max_len = le16_to_cpu(otus_desc->bcn_len);
348
349 if (valid_dma_addr(ar->fw.beacon_addr) && ar->fw.beacon_max_len >=
350 AR9170_MAC_BCN_LENGTH_MAX) {
351 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
352
353 if (SUPP(CARL9170FW_WLANTX_CAB)) {
354 if_comb_types |=
355 BIT(NL80211_IFTYPE_AP) |
356 BIT(NL80211_IFTYPE_P2P_GO);
357
358#ifdef CONFIG_MAC80211_MESH
359 if_comb_types |=
360 BIT(NL80211_IFTYPE_MESH_POINT);
361#endif
362 }
363 }
364
365 carl9170_fw_set_if_combinations(ar, if_comb_types);
366
367 ar->hw->wiphy->interface_modes |= if_comb_types;
368
369 ar->hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
370
371
372 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL |
373 WIPHY_FLAG_IBSS_RSN | WIPHY_FLAG_SUPPORTS_TDLS;
374
375#undef SUPPORTED
376 return carl9170_fw_tx_sequence(ar);
377}
378
379static struct carl9170fw_desc_head *
380carl9170_find_fw_desc(struct ar9170 *ar, const __u8 *fw_data, const size_t len)
381
382{
383 int scan = 0, found = 0;
384
385 if (!carl9170fw_size_check(len)) {
386 dev_err(&ar->udev->dev, "firmware size is out of bound.\n");
387 return NULL;
388 }
389
390 while (scan < len - sizeof(struct carl9170fw_desc_head)) {
391 if (fw_data[scan++] == otus_magic[found])
392 found++;
393 else
394 found = 0;
395
396 if (scan >= len)
397 break;
398
399 if (found == sizeof(otus_magic))
400 break;
401 }
402
403 if (found != sizeof(otus_magic))
404 return NULL;
405
406 return (void *)&fw_data[scan - found];
407}
408
409int carl9170_parse_firmware(struct ar9170 *ar)
410{
411 const struct carl9170fw_desc_head *fw_desc = NULL;
412 const struct firmware *fw = ar->fw.fw;
413 unsigned long header_offset = 0;
414 int err;
415
416 if (WARN_ON(!fw))
417 return -EINVAL;
418
419 fw_desc = carl9170_find_fw_desc(ar, fw->data, fw->size);
420
421 if (!fw_desc) {
422 dev_err(&ar->udev->dev, "unsupported firmware.\n");
423 return -ENODATA;
424 }
425
426 header_offset = (unsigned long)fw_desc - (unsigned long)fw->data;
427
428 err = carl9170_fw_verify_descs(ar, fw_desc, fw->size - header_offset);
429 if (err) {
430 dev_err(&ar->udev->dev, "damaged firmware (%d).\n", err);
431 return err;
432 }
433
434 ar->fw.desc = fw_desc;
435
436 carl9170_fw_info(ar);
437
438 err = carl9170_fw(ar, fw->data, fw->size);
439 if (err) {
440 dev_err(&ar->udev->dev, "failed to parse firmware (%d).\n",
441 err);
442 return err;
443 }
444
445 return 0;
446}
447
