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