1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
2 /* Copyright(c) 2019-2020 Realtek Corporation
3 */
4
5 #include "cam.h"
6 #include "chan.h"
7 #include "coex.h"
8 #include "debug.h"
9 #include "fw.h"
10 #include "mac.h"
11 #include "phy.h"
12 #include "reg.h"
13
rtw89_fw_h2c_alloc_skb(struct rtw89_dev * rtwdev,u32 len,bool header)14 static struct sk_buff *rtw89_fw_h2c_alloc_skb(struct rtw89_dev *rtwdev, u32 len,
15 bool header)
16 {
17 struct sk_buff *skb;
18 u32 header_len = 0;
19 u32 h2c_desc_size = rtwdev->chip->h2c_desc_size;
20
21 if (header)
22 header_len = H2C_HEADER_LEN;
23
24 skb = dev_alloc_skb(len + header_len + h2c_desc_size);
25 if (!skb)
26 return NULL;
27 skb_reserve(skb, header_len + h2c_desc_size);
28 memset(skb->data, 0, len);
29
30 return skb;
31 }
32
rtw89_fw_h2c_alloc_skb_with_hdr(struct rtw89_dev * rtwdev,u32 len)33 struct sk_buff *rtw89_fw_h2c_alloc_skb_with_hdr(struct rtw89_dev *rtwdev, u32 len)
34 {
35 return rtw89_fw_h2c_alloc_skb(rtwdev, len, true);
36 }
37
rtw89_fw_h2c_alloc_skb_no_hdr(struct rtw89_dev * rtwdev,u32 len)38 struct sk_buff *rtw89_fw_h2c_alloc_skb_no_hdr(struct rtw89_dev *rtwdev, u32 len)
39 {
40 return rtw89_fw_h2c_alloc_skb(rtwdev, len, false);
41 }
42
_fw_get_rdy(struct rtw89_dev * rtwdev)43 static u8 _fw_get_rdy(struct rtw89_dev *rtwdev)
44 {
45 u8 val = rtw89_read8(rtwdev, R_AX_WCPU_FW_CTRL);
46
47 return FIELD_GET(B_AX_WCPU_FWDL_STS_MASK, val);
48 }
49
50 #define FWDL_WAIT_CNT 400000
rtw89_fw_check_rdy(struct rtw89_dev * rtwdev)51 int rtw89_fw_check_rdy(struct rtw89_dev *rtwdev)
52 {
53 u8 val;
54 int ret;
55
56 ret = read_poll_timeout_atomic(_fw_get_rdy, val,
57 val == RTW89_FWDL_WCPU_FW_INIT_RDY,
58 1, FWDL_WAIT_CNT, false, rtwdev);
59 if (ret) {
60 switch (val) {
61 case RTW89_FWDL_CHECKSUM_FAIL:
62 rtw89_err(rtwdev, "fw checksum fail\n");
63 return -EINVAL;
64
65 case RTW89_FWDL_SECURITY_FAIL:
66 rtw89_err(rtwdev, "fw security fail\n");
67 return -EINVAL;
68
69 case RTW89_FWDL_CV_NOT_MATCH:
70 rtw89_err(rtwdev, "fw cv not match\n");
71 return -EINVAL;
72
73 default:
74 return -EBUSY;
75 }
76 }
77
78 set_bit(RTW89_FLAG_FW_RDY, rtwdev->flags);
79
80 return 0;
81 }
82
rtw89_fw_hdr_parser(struct rtw89_dev * rtwdev,const u8 * fw,u32 len,struct rtw89_fw_bin_info * info)83 static int rtw89_fw_hdr_parser(struct rtw89_dev *rtwdev, const u8 *fw, u32 len,
84 struct rtw89_fw_bin_info *info)
85 {
86 struct rtw89_fw_hdr_section_info *section_info;
87 const u8 *fw_end = fw + len;
88 const u8 *bin;
89 u32 i;
90
91 if (!info)
92 return -EINVAL;
93
94 info->section_num = GET_FW_HDR_SEC_NUM(fw);
95 info->hdr_len = RTW89_FW_HDR_SIZE +
96 info->section_num * RTW89_FW_SECTION_HDR_SIZE;
97
98 bin = fw + info->hdr_len;
99
100 /* jump to section header */
101 fw += RTW89_FW_HDR_SIZE;
102 section_info = info->section_info;
103 for (i = 0; i < info->section_num; i++) {
104 section_info->len = GET_FWSECTION_HDR_SEC_SIZE(fw);
105 if (GET_FWSECTION_HDR_CHECKSUM(fw))
106 section_info->len += FWDL_SECTION_CHKSUM_LEN;
107 section_info->redl = GET_FWSECTION_HDR_REDL(fw);
108 section_info->dladdr =
109 GET_FWSECTION_HDR_DL_ADDR(fw) & 0x1fffffff;
110 section_info->addr = bin;
111 bin += section_info->len;
112 fw += RTW89_FW_SECTION_HDR_SIZE;
113 section_info++;
114 }
115
116 if (fw_end != bin) {
117 rtw89_err(rtwdev, "[ERR]fw bin size\n");
118 return -EINVAL;
119 }
120
121 return 0;
122 }
123
124 static
rtw89_mfw_recognize(struct rtw89_dev * rtwdev,enum rtw89_fw_type type,struct rtw89_fw_suit * fw_suit)125 int rtw89_mfw_recognize(struct rtw89_dev *rtwdev, enum rtw89_fw_type type,
126 struct rtw89_fw_suit *fw_suit)
127 {
128 struct rtw89_fw_info *fw_info = &rtwdev->fw;
129 const u8 *mfw = fw_info->firmware->data;
130 u32 mfw_len = fw_info->firmware->size;
131 const struct rtw89_mfw_hdr *mfw_hdr = (const struct rtw89_mfw_hdr *)mfw;
132 const struct rtw89_mfw_info *mfw_info;
133 int i;
134
135 if (mfw_hdr->sig != RTW89_MFW_SIG) {
136 rtw89_debug(rtwdev, RTW89_DBG_FW, "use legacy firmware\n");
137 /* legacy firmware support normal type only */
138 if (type != RTW89_FW_NORMAL)
139 return -EINVAL;
140 fw_suit->data = mfw;
141 fw_suit->size = mfw_len;
142 return 0;
143 }
144
145 for (i = 0; i < mfw_hdr->fw_nr; i++) {
146 mfw_info = &mfw_hdr->info[i];
147 if (mfw_info->cv != rtwdev->hal.cv ||
148 mfw_info->type != type ||
149 mfw_info->mp)
150 continue;
151
152 fw_suit->data = mfw + le32_to_cpu(mfw_info->shift);
153 fw_suit->size = le32_to_cpu(mfw_info->size);
154 return 0;
155 }
156
157 rtw89_err(rtwdev, "no suitable firmware found\n");
158 return -ENOENT;
159 }
160
rtw89_fw_update_ver(struct rtw89_dev * rtwdev,enum rtw89_fw_type type,struct rtw89_fw_suit * fw_suit)161 static void rtw89_fw_update_ver(struct rtw89_dev *rtwdev,
162 enum rtw89_fw_type type,
163 struct rtw89_fw_suit *fw_suit)
164 {
165 const u8 *hdr = fw_suit->data;
166
167 fw_suit->major_ver = GET_FW_HDR_MAJOR_VERSION(hdr);
168 fw_suit->minor_ver = GET_FW_HDR_MINOR_VERSION(hdr);
169 fw_suit->sub_ver = GET_FW_HDR_SUBVERSION(hdr);
170 fw_suit->sub_idex = GET_FW_HDR_SUBINDEX(hdr);
171 fw_suit->build_year = GET_FW_HDR_YEAR(hdr);
172 fw_suit->build_mon = GET_FW_HDR_MONTH(hdr);
173 fw_suit->build_date = GET_FW_HDR_DATE(hdr);
174 fw_suit->build_hour = GET_FW_HDR_HOUR(hdr);
175 fw_suit->build_min = GET_FW_HDR_MIN(hdr);
176 fw_suit->cmd_ver = GET_FW_HDR_CMD_VERSERION(hdr);
177
178 rtw89_info(rtwdev,
179 "Firmware version %u.%u.%u.%u, cmd version %u, type %u\n",
180 fw_suit->major_ver, fw_suit->minor_ver, fw_suit->sub_ver,
181 fw_suit->sub_idex, fw_suit->cmd_ver, type);
182 }
183
184 static
__rtw89_fw_recognize(struct rtw89_dev * rtwdev,enum rtw89_fw_type type)185 int __rtw89_fw_recognize(struct rtw89_dev *rtwdev, enum rtw89_fw_type type)
186 {
187 struct rtw89_fw_suit *fw_suit = rtw89_fw_suit_get(rtwdev, type);
188 int ret;
189
190 ret = rtw89_mfw_recognize(rtwdev, type, fw_suit);
191 if (ret)
192 return ret;
193
194 rtw89_fw_update_ver(rtwdev, type, fw_suit);
195
196 return 0;
197 }
198
199 #define __DEF_FW_FEAT_COND(__cond, __op) \
200 static bool __fw_feat_cond_ ## __cond(u32 suit_ver_code, u32 comp_ver_code) \
201 { \
202 return suit_ver_code __op comp_ver_code; \
203 }
204
205 __DEF_FW_FEAT_COND(ge, >=); /* greater or equal */
206 __DEF_FW_FEAT_COND(le, <=); /* less or equal */
207
208 struct __fw_feat_cfg {
209 enum rtw89_core_chip_id chip_id;
210 enum rtw89_fw_feature feature;
211 u32 ver_code;
212 bool (*cond)(u32 suit_ver_code, u32 comp_ver_code);
213 };
214
215 #define __CFG_FW_FEAT(_chip, _cond, _maj, _min, _sub, _idx, _feat) \
216 { \
217 .chip_id = _chip, \
218 .feature = RTW89_FW_FEATURE_ ## _feat, \
219 .ver_code = RTW89_FW_VER_CODE(_maj, _min, _sub, _idx), \
220 .cond = __fw_feat_cond_ ## _cond, \
221 }
222
223 static const struct __fw_feat_cfg fw_feat_tbl[] = {
224 __CFG_FW_FEAT(RTL8852A, le, 0, 13, 29, 0, OLD_HT_RA_FORMAT),
225 __CFG_FW_FEAT(RTL8852A, ge, 0, 13, 35, 0, SCAN_OFFLOAD),
226 __CFG_FW_FEAT(RTL8852A, ge, 0, 13, 35, 0, TX_WAKE),
227 __CFG_FW_FEAT(RTL8852A, ge, 0, 13, 36, 0, CRASH_TRIGGER),
228 };
229
rtw89_fw_recognize_features(struct rtw89_dev * rtwdev)230 static void rtw89_fw_recognize_features(struct rtw89_dev *rtwdev)
231 {
232 const struct rtw89_chip_info *chip = rtwdev->chip;
233 const struct __fw_feat_cfg *ent;
234 const struct rtw89_fw_suit *fw_suit;
235 u32 suit_ver_code;
236 int i;
237
238 fw_suit = rtw89_fw_suit_get(rtwdev, RTW89_FW_NORMAL);
239 suit_ver_code = RTW89_FW_SUIT_VER_CODE(fw_suit);
240
241 for (i = 0; i < ARRAY_SIZE(fw_feat_tbl); i++) {
242 ent = &fw_feat_tbl[i];
243 if (chip->chip_id != ent->chip_id)
244 continue;
245
246 if (ent->cond(suit_ver_code, ent->ver_code))
247 RTW89_SET_FW_FEATURE(ent->feature, &rtwdev->fw);
248 }
249 }
250
rtw89_early_fw_feature_recognize(struct device * device,const struct rtw89_chip_info * chip,u32 * early_feat_map)251 void rtw89_early_fw_feature_recognize(struct device *device,
252 const struct rtw89_chip_info *chip,
253 u32 *early_feat_map)
254 {
255 union {
256 struct rtw89_mfw_hdr mfw_hdr;
257 u8 fw_hdr[RTW89_FW_HDR_SIZE];
258 } buf = {};
259 const struct firmware *firmware;
260 u32 ver_code;
261 int ret;
262 int i;
263
264 ret = request_partial_firmware_into_buf(&firmware, chip->fw_name,
265 device, &buf, sizeof(buf), 0);
266 if (ret) {
267 dev_err(device, "failed to early request firmware: %d\n", ret);
268 goto out;
269 }
270
271 ver_code = buf.mfw_hdr.sig != RTW89_MFW_SIG ?
272 RTW89_FW_HDR_VER_CODE(&buf.fw_hdr) :
273 RTW89_MFW_HDR_VER_CODE(&buf.mfw_hdr);
274 if (!ver_code)
275 goto out;
276
277 for (i = 0; i < ARRAY_SIZE(fw_feat_tbl); i++) {
278 const struct __fw_feat_cfg *ent = &fw_feat_tbl[i];
279
280 if (chip->chip_id != ent->chip_id)
281 continue;
282
283 if (ent->cond(ver_code, ent->ver_code))
284 *early_feat_map |= BIT(ent->feature);
285 }
286
287 out:
288 release_firmware(firmware);
289 }
290
rtw89_fw_recognize(struct rtw89_dev * rtwdev)291 int rtw89_fw_recognize(struct rtw89_dev *rtwdev)
292 {
293 int ret;
294
295 ret = __rtw89_fw_recognize(rtwdev, RTW89_FW_NORMAL);
296 if (ret)
297 return ret;
298
299 /* It still works if wowlan firmware isn't existing. */
300 __rtw89_fw_recognize(rtwdev, RTW89_FW_WOWLAN);
301
302 rtw89_fw_recognize_features(rtwdev);
303
304 return 0;
305 }
306
rtw89_h2c_pkt_set_hdr(struct rtw89_dev * rtwdev,struct sk_buff * skb,u8 type,u8 cat,u8 class,u8 func,bool rack,bool dack,u32 len)307 void rtw89_h2c_pkt_set_hdr(struct rtw89_dev *rtwdev, struct sk_buff *skb,
308 u8 type, u8 cat, u8 class, u8 func,
309 bool rack, bool dack, u32 len)
310 {
311 struct fwcmd_hdr *hdr;
312
313 hdr = (struct fwcmd_hdr *)skb_push(skb, 8);
314
315 if (!(rtwdev->fw.h2c_seq % 4))
316 rack = true;
317 hdr->hdr0 = cpu_to_le32(FIELD_PREP(H2C_HDR_DEL_TYPE, type) |
318 FIELD_PREP(H2C_HDR_CAT, cat) |
319 FIELD_PREP(H2C_HDR_CLASS, class) |
320 FIELD_PREP(H2C_HDR_FUNC, func) |
321 FIELD_PREP(H2C_HDR_H2C_SEQ, rtwdev->fw.h2c_seq));
322
323 hdr->hdr1 = cpu_to_le32(FIELD_PREP(H2C_HDR_TOTAL_LEN,
324 len + H2C_HEADER_LEN) |
325 (rack ? H2C_HDR_REC_ACK : 0) |
326 (dack ? H2C_HDR_DONE_ACK : 0));
327
328 rtwdev->fw.h2c_seq++;
329 }
330
rtw89_h2c_pkt_set_hdr_fwdl(struct rtw89_dev * rtwdev,struct sk_buff * skb,u8 type,u8 cat,u8 class,u8 func,u32 len)331 static void rtw89_h2c_pkt_set_hdr_fwdl(struct rtw89_dev *rtwdev,
332 struct sk_buff *skb,
333 u8 type, u8 cat, u8 class, u8 func,
334 u32 len)
335 {
336 struct fwcmd_hdr *hdr;
337
338 hdr = (struct fwcmd_hdr *)skb_push(skb, 8);
339
340 hdr->hdr0 = cpu_to_le32(FIELD_PREP(H2C_HDR_DEL_TYPE, type) |
341 FIELD_PREP(H2C_HDR_CAT, cat) |
342 FIELD_PREP(H2C_HDR_CLASS, class) |
343 FIELD_PREP(H2C_HDR_FUNC, func) |
344 FIELD_PREP(H2C_HDR_H2C_SEQ, rtwdev->fw.h2c_seq));
345
346 hdr->hdr1 = cpu_to_le32(FIELD_PREP(H2C_HDR_TOTAL_LEN,
347 len + H2C_HEADER_LEN));
348 }
349
__rtw89_fw_download_hdr(struct rtw89_dev * rtwdev,const u8 * fw,u32 len)350 static int __rtw89_fw_download_hdr(struct rtw89_dev *rtwdev, const u8 *fw, u32 len)
351 {
352 struct sk_buff *skb;
353 u32 ret = 0;
354
355 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, len);
356 if (!skb) {
357 rtw89_err(rtwdev, "failed to alloc skb for fw hdr dl\n");
358 return -ENOMEM;
359 }
360
361 skb_put_data(skb, fw, len);
362 SET_FW_HDR_PART_SIZE(skb->data, FWDL_SECTION_PER_PKT_LEN);
363 rtw89_h2c_pkt_set_hdr_fwdl(rtwdev, skb, FWCMD_TYPE_H2C,
364 H2C_CAT_MAC, H2C_CL_MAC_FWDL,
365 H2C_FUNC_MAC_FWHDR_DL, len);
366
367 ret = rtw89_h2c_tx(rtwdev, skb, false);
368 if (ret) {
369 rtw89_err(rtwdev, "failed to send h2c\n");
370 ret = -1;
371 goto fail;
372 }
373
374 return 0;
375 fail:
376 dev_kfree_skb_any(skb);
377
378 return ret;
379 }
380
rtw89_fw_download_hdr(struct rtw89_dev * rtwdev,const u8 * fw,u32 len)381 static int rtw89_fw_download_hdr(struct rtw89_dev *rtwdev, const u8 *fw, u32 len)
382 {
383 u8 val;
384 int ret;
385
386 ret = __rtw89_fw_download_hdr(rtwdev, fw, len);
387 if (ret) {
388 rtw89_err(rtwdev, "[ERR]FW header download\n");
389 return ret;
390 }
391
392 ret = read_poll_timeout_atomic(rtw89_read8, val, val & B_AX_FWDL_PATH_RDY,
393 1, FWDL_WAIT_CNT, false,
394 rtwdev, R_AX_WCPU_FW_CTRL);
395 if (ret) {
396 rtw89_err(rtwdev, "[ERR]FWDL path ready\n");
397 return ret;
398 }
399
400 rtw89_write32(rtwdev, R_AX_HALT_H2C_CTRL, 0);
401 rtw89_write32(rtwdev, R_AX_HALT_C2H_CTRL, 0);
402
403 return 0;
404 }
405
__rtw89_fw_download_main(struct rtw89_dev * rtwdev,struct rtw89_fw_hdr_section_info * info)406 static int __rtw89_fw_download_main(struct rtw89_dev *rtwdev,
407 struct rtw89_fw_hdr_section_info *info)
408 {
409 struct sk_buff *skb;
410 const u8 *section = info->addr;
411 u32 residue_len = info->len;
412 u32 pkt_len;
413 int ret;
414
415 while (residue_len) {
416 if (residue_len >= FWDL_SECTION_PER_PKT_LEN)
417 pkt_len = FWDL_SECTION_PER_PKT_LEN;
418 else
419 pkt_len = residue_len;
420
421 skb = rtw89_fw_h2c_alloc_skb_no_hdr(rtwdev, pkt_len);
422 if (!skb) {
423 rtw89_err(rtwdev, "failed to alloc skb for fw dl\n");
424 return -ENOMEM;
425 }
426 skb_put_data(skb, section, pkt_len);
427
428 ret = rtw89_h2c_tx(rtwdev, skb, true);
429 if (ret) {
430 rtw89_err(rtwdev, "failed to send h2c\n");
431 ret = -1;
432 goto fail;
433 }
434
435 section += pkt_len;
436 residue_len -= pkt_len;
437 }
438
439 return 0;
440 fail:
441 dev_kfree_skb_any(skb);
442
443 return ret;
444 }
445
rtw89_fw_download_main(struct rtw89_dev * rtwdev,const u8 * fw,struct rtw89_fw_bin_info * info)446 static int rtw89_fw_download_main(struct rtw89_dev *rtwdev, const u8 *fw,
447 struct rtw89_fw_bin_info *info)
448 {
449 struct rtw89_fw_hdr_section_info *section_info = info->section_info;
450 u8 section_num = info->section_num;
451 int ret;
452
453 while (section_num--) {
454 ret = __rtw89_fw_download_main(rtwdev, section_info);
455 if (ret)
456 return ret;
457 section_info++;
458 }
459
460 mdelay(5);
461
462 ret = rtw89_fw_check_rdy(rtwdev);
463 if (ret) {
464 rtw89_warn(rtwdev, "download firmware fail\n");
465 return ret;
466 }
467
468 return 0;
469 }
470
rtw89_fw_prog_cnt_dump(struct rtw89_dev * rtwdev)471 static void rtw89_fw_prog_cnt_dump(struct rtw89_dev *rtwdev)
472 {
473 u32 val32;
474 u16 index;
475
476 rtw89_write32(rtwdev, R_AX_DBG_CTRL,
477 FIELD_PREP(B_AX_DBG_SEL0, FW_PROG_CNTR_DBG_SEL) |
478 FIELD_PREP(B_AX_DBG_SEL1, FW_PROG_CNTR_DBG_SEL));
479 rtw89_write32_mask(rtwdev, R_AX_SYS_STATUS1, B_AX_SEL_0XC0_MASK, MAC_DBG_SEL);
480
481 for (index = 0; index < 15; index++) {
482 val32 = rtw89_read32(rtwdev, R_AX_DBG_PORT_SEL);
483 rtw89_err(rtwdev, "[ERR]fw PC = 0x%x\n", val32);
484 #if defined(__linux__)
485 fsleep(10);
486 #elif defined(__FreeBSD__)
487 /* Seems we are called from a context we cannot sleep. */
488 udelay(10);
489 #endif
490 }
491 }
492
rtw89_fw_dl_fail_dump(struct rtw89_dev * rtwdev)493 static void rtw89_fw_dl_fail_dump(struct rtw89_dev *rtwdev)
494 {
495 u32 val32;
496 u16 val16;
497
498 val32 = rtw89_read32(rtwdev, R_AX_WCPU_FW_CTRL);
499 rtw89_err(rtwdev, "[ERR]fwdl 0x1E0 = 0x%x\n", val32);
500
501 val16 = rtw89_read16(rtwdev, R_AX_BOOT_DBG + 2);
502 rtw89_err(rtwdev, "[ERR]fwdl 0x83F2 = 0x%x\n", val16);
503
504 rtw89_fw_prog_cnt_dump(rtwdev);
505 }
506
rtw89_fw_download(struct rtw89_dev * rtwdev,enum rtw89_fw_type type)507 int rtw89_fw_download(struct rtw89_dev *rtwdev, enum rtw89_fw_type type)
508 {
509 struct rtw89_fw_info *fw_info = &rtwdev->fw;
510 struct rtw89_fw_suit *fw_suit = rtw89_fw_suit_get(rtwdev, type);
511 struct rtw89_fw_bin_info info;
512 const u8 *fw = fw_suit->data;
513 u32 len = fw_suit->size;
514 u8 val;
515 int ret;
516
517 if (!fw || !len) {
518 rtw89_err(rtwdev, "fw type %d isn't recognized\n", type);
519 return -ENOENT;
520 }
521
522 ret = rtw89_fw_hdr_parser(rtwdev, fw, len, &info);
523 if (ret) {
524 rtw89_err(rtwdev, "parse fw header fail\n");
525 goto fwdl_err;
526 }
527
528 ret = read_poll_timeout_atomic(rtw89_read8, val, val & B_AX_H2C_PATH_RDY,
529 1, FWDL_WAIT_CNT, false,
530 rtwdev, R_AX_WCPU_FW_CTRL);
531 if (ret) {
532 rtw89_err(rtwdev, "[ERR]H2C path ready\n");
533 goto fwdl_err;
534 }
535
536 ret = rtw89_fw_download_hdr(rtwdev, fw, info.hdr_len);
537 if (ret) {
538 ret = -EBUSY;
539 goto fwdl_err;
540 }
541
542 ret = rtw89_fw_download_main(rtwdev, fw, &info);
543 if (ret) {
544 ret = -EBUSY;
545 goto fwdl_err;
546 }
547
548 fw_info->h2c_seq = 0;
549 fw_info->rec_seq = 0;
550 rtwdev->mac.rpwm_seq_num = RPWM_SEQ_NUM_MAX;
551 rtwdev->mac.cpwm_seq_num = CPWM_SEQ_NUM_MAX;
552
553 return ret;
554
555 fwdl_err:
556 rtw89_fw_dl_fail_dump(rtwdev);
557 return ret;
558 }
559
rtw89_wait_firmware_completion(struct rtw89_dev * rtwdev)560 int rtw89_wait_firmware_completion(struct rtw89_dev *rtwdev)
561 {
562 struct rtw89_fw_info *fw = &rtwdev->fw;
563
564 wait_for_completion(&fw->completion);
565 if (!fw->firmware)
566 return -EINVAL;
567
568 return 0;
569 }
570
rtw89_load_firmware_cb(const struct firmware * firmware,void * context)571 static void rtw89_load_firmware_cb(const struct firmware *firmware, void *context)
572 {
573 struct rtw89_fw_info *fw = context;
574 struct rtw89_dev *rtwdev = fw->rtwdev;
575
576 if (!firmware || !firmware->data) {
577 rtw89_err(rtwdev, "failed to request firmware\n");
578 complete_all(&fw->completion);
579 return;
580 }
581
582 fw->firmware = firmware;
583 complete_all(&fw->completion);
584 }
585
rtw89_load_firmware(struct rtw89_dev * rtwdev)586 int rtw89_load_firmware(struct rtw89_dev *rtwdev)
587 {
588 struct rtw89_fw_info *fw = &rtwdev->fw;
589 const char *fw_name = rtwdev->chip->fw_name;
590 int ret;
591
592 fw->rtwdev = rtwdev;
593 init_completion(&fw->completion);
594
595 ret = request_firmware_nowait(THIS_MODULE, true, fw_name, rtwdev->dev,
596 GFP_KERNEL, fw, rtw89_load_firmware_cb);
597 if (ret) {
598 rtw89_err(rtwdev, "failed to async firmware request\n");
599 return ret;
600 }
601
602 return 0;
603 }
604
rtw89_unload_firmware(struct rtw89_dev * rtwdev)605 void rtw89_unload_firmware(struct rtw89_dev *rtwdev)
606 {
607 struct rtw89_fw_info *fw = &rtwdev->fw;
608
609 rtw89_wait_firmware_completion(rtwdev);
610
611 if (fw->firmware)
612 release_firmware(fw->firmware);
613 }
614
615 #define H2C_CAM_LEN 60
rtw89_fw_h2c_cam(struct rtw89_dev * rtwdev,struct rtw89_vif * rtwvif,struct rtw89_sta * rtwsta,const u8 * scan_mac_addr)616 int rtw89_fw_h2c_cam(struct rtw89_dev *rtwdev, struct rtw89_vif *rtwvif,
617 struct rtw89_sta *rtwsta, const u8 *scan_mac_addr)
618 {
619 struct sk_buff *skb;
620
621 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_CAM_LEN);
622 if (!skb) {
623 rtw89_err(rtwdev, "failed to alloc skb for fw dl\n");
624 return -ENOMEM;
625 }
626 skb_put(skb, H2C_CAM_LEN);
627 rtw89_cam_fill_addr_cam_info(rtwdev, rtwvif, rtwsta, scan_mac_addr, skb->data);
628 rtw89_cam_fill_bssid_cam_info(rtwdev, rtwvif, rtwsta, skb->data);
629
630 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
631 H2C_CAT_MAC,
632 H2C_CL_MAC_ADDR_CAM_UPDATE,
633 H2C_FUNC_MAC_ADDR_CAM_UPD, 0, 1,
634 H2C_CAM_LEN);
635
636 if (rtw89_h2c_tx(rtwdev, skb, false)) {
637 rtw89_err(rtwdev, "failed to send h2c\n");
638 goto fail;
639 }
640
641 return 0;
642 fail:
643 dev_kfree_skb_any(skb);
644
645 return -EBUSY;
646 }
647
648 #define H2C_DCTL_SEC_CAM_LEN 68
rtw89_fw_h2c_dctl_sec_cam_v1(struct rtw89_dev * rtwdev,struct rtw89_vif * rtwvif,struct rtw89_sta * rtwsta)649 int rtw89_fw_h2c_dctl_sec_cam_v1(struct rtw89_dev *rtwdev,
650 struct rtw89_vif *rtwvif,
651 struct rtw89_sta *rtwsta)
652 {
653 struct sk_buff *skb;
654
655 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_DCTL_SEC_CAM_LEN);
656 if (!skb) {
657 rtw89_err(rtwdev, "failed to alloc skb for dctl sec cam\n");
658 return -ENOMEM;
659 }
660 skb_put(skb, H2C_DCTL_SEC_CAM_LEN);
661
662 rtw89_cam_fill_dctl_sec_cam_info_v1(rtwdev, rtwvif, rtwsta, skb->data);
663
664 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
665 H2C_CAT_MAC,
666 H2C_CL_MAC_FR_EXCHG,
667 H2C_FUNC_MAC_DCTLINFO_UD_V1, 0, 0,
668 H2C_DCTL_SEC_CAM_LEN);
669
670 if (rtw89_h2c_tx(rtwdev, skb, false)) {
671 rtw89_err(rtwdev, "failed to send h2c\n");
672 goto fail;
673 }
674
675 return 0;
676 fail:
677 dev_kfree_skb_any(skb);
678
679 return -EBUSY;
680 }
681 EXPORT_SYMBOL(rtw89_fw_h2c_dctl_sec_cam_v1);
682
683 #define H2C_BA_CAM_LEN 8
rtw89_fw_h2c_ba_cam(struct rtw89_dev * rtwdev,struct rtw89_sta * rtwsta,bool valid,struct ieee80211_ampdu_params * params)684 int rtw89_fw_h2c_ba_cam(struct rtw89_dev *rtwdev, struct rtw89_sta *rtwsta,
685 bool valid, struct ieee80211_ampdu_params *params)
686 {
687 const struct rtw89_chip_info *chip = rtwdev->chip;
688 struct rtw89_vif *rtwvif = rtwsta->rtwvif;
689 u8 macid = rtwsta->mac_id;
690 struct sk_buff *skb;
691 u8 entry_idx;
692 int ret;
693
694 ret = valid ?
695 rtw89_core_acquire_sta_ba_entry(rtwdev, rtwsta, params->tid, &entry_idx) :
696 rtw89_core_release_sta_ba_entry(rtwdev, rtwsta, params->tid, &entry_idx);
697 if (ret) {
698 /* it still works even if we don't have static BA CAM, because
699 * hardware can create dynamic BA CAM automatically.
700 */
701 rtw89_debug(rtwdev, RTW89_DBG_TXRX,
702 "failed to %s entry tid=%d for h2c ba cam\n",
703 valid ? "alloc" : "free", params->tid);
704 return 0;
705 }
706
707 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_BA_CAM_LEN);
708 if (!skb) {
709 rtw89_err(rtwdev, "failed to alloc skb for h2c ba cam\n");
710 return -ENOMEM;
711 }
712 skb_put(skb, H2C_BA_CAM_LEN);
713 SET_BA_CAM_MACID(skb->data, macid);
714 if (chip->bacam_v1)
715 SET_BA_CAM_ENTRY_IDX_V1(skb->data, entry_idx);
716 else
717 SET_BA_CAM_ENTRY_IDX(skb->data, entry_idx);
718 if (!valid)
719 goto end;
720 SET_BA_CAM_VALID(skb->data, valid);
721 SET_BA_CAM_TID(skb->data, params->tid);
722 if (params->buf_size > 64)
723 SET_BA_CAM_BMAP_SIZE(skb->data, 4);
724 else
725 SET_BA_CAM_BMAP_SIZE(skb->data, 0);
726 /* If init req is set, hw will set the ssn */
727 SET_BA_CAM_INIT_REQ(skb->data, 1);
728 SET_BA_CAM_SSN(skb->data, params->ssn);
729
730 if (chip->bacam_v1) {
731 SET_BA_CAM_STD_EN(skb->data, 1);
732 SET_BA_CAM_BAND(skb->data, rtwvif->mac_idx);
733 }
734
735 end:
736 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
737 H2C_CAT_MAC,
738 H2C_CL_BA_CAM,
739 H2C_FUNC_MAC_BA_CAM, 0, 1,
740 H2C_BA_CAM_LEN);
741
742 if (rtw89_h2c_tx(rtwdev, skb, false)) {
743 rtw89_err(rtwdev, "failed to send h2c\n");
744 goto fail;
745 }
746
747 return 0;
748 fail:
749 dev_kfree_skb_any(skb);
750
751 return -EBUSY;
752 }
753
rtw89_fw_h2c_init_dynamic_ba_cam_v1(struct rtw89_dev * rtwdev,u8 entry_idx,u8 uid)754 static int rtw89_fw_h2c_init_dynamic_ba_cam_v1(struct rtw89_dev *rtwdev,
755 u8 entry_idx, u8 uid)
756 {
757 struct sk_buff *skb;
758
759 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_BA_CAM_LEN);
760 if (!skb) {
761 rtw89_err(rtwdev, "failed to alloc skb for dynamic h2c ba cam\n");
762 return -ENOMEM;
763 }
764 skb_put(skb, H2C_BA_CAM_LEN);
765
766 SET_BA_CAM_VALID(skb->data, 1);
767 SET_BA_CAM_ENTRY_IDX_V1(skb->data, entry_idx);
768 SET_BA_CAM_UID(skb->data, uid);
769 SET_BA_CAM_BAND(skb->data, 0);
770 SET_BA_CAM_STD_EN(skb->data, 0);
771
772 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
773 H2C_CAT_MAC,
774 H2C_CL_BA_CAM,
775 H2C_FUNC_MAC_BA_CAM, 0, 1,
776 H2C_BA_CAM_LEN);
777
778 if (rtw89_h2c_tx(rtwdev, skb, false)) {
779 rtw89_err(rtwdev, "failed to send h2c\n");
780 goto fail;
781 }
782
783 return 0;
784 fail:
785 dev_kfree_skb_any(skb);
786
787 return -EBUSY;
788 }
789
rtw89_fw_h2c_init_ba_cam_v1(struct rtw89_dev * rtwdev)790 void rtw89_fw_h2c_init_ba_cam_v1(struct rtw89_dev *rtwdev)
791 {
792 const struct rtw89_chip_info *chip = rtwdev->chip;
793 u8 entry_idx = chip->bacam_num;
794 u8 uid = 0;
795 int i;
796
797 for (i = 0; i < chip->bacam_dynamic_num; i++) {
798 rtw89_fw_h2c_init_dynamic_ba_cam_v1(rtwdev, entry_idx, uid);
799 entry_idx++;
800 uid++;
801 }
802 }
803
804 #define H2C_LOG_CFG_LEN 12
rtw89_fw_h2c_fw_log(struct rtw89_dev * rtwdev,bool enable)805 int rtw89_fw_h2c_fw_log(struct rtw89_dev *rtwdev, bool enable)
806 {
807 struct sk_buff *skb;
808 u32 comp = enable ? BIT(RTW89_FW_LOG_COMP_INIT) | BIT(RTW89_FW_LOG_COMP_TASK) |
809 BIT(RTW89_FW_LOG_COMP_PS) | BIT(RTW89_FW_LOG_COMP_ERROR) : 0;
810
811 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_LOG_CFG_LEN);
812 if (!skb) {
813 rtw89_err(rtwdev, "failed to alloc skb for fw log cfg\n");
814 return -ENOMEM;
815 }
816
817 skb_put(skb, H2C_LOG_CFG_LEN);
818 SET_LOG_CFG_LEVEL(skb->data, RTW89_FW_LOG_LEVEL_SER);
819 SET_LOG_CFG_PATH(skb->data, BIT(RTW89_FW_LOG_LEVEL_C2H));
820 SET_LOG_CFG_COMP(skb->data, comp);
821 SET_LOG_CFG_COMP_EXT(skb->data, 0);
822
823 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
824 H2C_CAT_MAC,
825 H2C_CL_FW_INFO,
826 H2C_FUNC_LOG_CFG, 0, 0,
827 H2C_LOG_CFG_LEN);
828
829 if (rtw89_h2c_tx(rtwdev, skb, false)) {
830 rtw89_err(rtwdev, "failed to send h2c\n");
831 goto fail;
832 }
833
834 return 0;
835 fail:
836 dev_kfree_skb_any(skb);
837
838 return -EBUSY;
839 }
840
841 #define H2C_GENERAL_PKT_LEN 6
842 #define H2C_GENERAL_PKT_ID_UND 0xff
rtw89_fw_h2c_general_pkt(struct rtw89_dev * rtwdev,u8 macid)843 int rtw89_fw_h2c_general_pkt(struct rtw89_dev *rtwdev, u8 macid)
844 {
845 struct sk_buff *skb;
846
847 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_GENERAL_PKT_LEN);
848 if (!skb) {
849 rtw89_err(rtwdev, "failed to alloc skb for fw dl\n");
850 return -ENOMEM;
851 }
852 skb_put(skb, H2C_GENERAL_PKT_LEN);
853 SET_GENERAL_PKT_MACID(skb->data, macid);
854 SET_GENERAL_PKT_PROBRSP_ID(skb->data, H2C_GENERAL_PKT_ID_UND);
855 SET_GENERAL_PKT_PSPOLL_ID(skb->data, H2C_GENERAL_PKT_ID_UND);
856 SET_GENERAL_PKT_NULL_ID(skb->data, H2C_GENERAL_PKT_ID_UND);
857 SET_GENERAL_PKT_QOS_NULL_ID(skb->data, H2C_GENERAL_PKT_ID_UND);
858 SET_GENERAL_PKT_CTS2SELF_ID(skb->data, H2C_GENERAL_PKT_ID_UND);
859
860 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
861 H2C_CAT_MAC,
862 H2C_CL_FW_INFO,
863 H2C_FUNC_MAC_GENERAL_PKT, 0, 1,
864 H2C_GENERAL_PKT_LEN);
865
866 if (rtw89_h2c_tx(rtwdev, skb, false)) {
867 rtw89_err(rtwdev, "failed to send h2c\n");
868 goto fail;
869 }
870
871 return 0;
872 fail:
873 dev_kfree_skb_any(skb);
874
875 return -EBUSY;
876 }
877
878 #define H2C_LPS_PARM_LEN 8
rtw89_fw_h2c_lps_parm(struct rtw89_dev * rtwdev,struct rtw89_lps_parm * lps_param)879 int rtw89_fw_h2c_lps_parm(struct rtw89_dev *rtwdev,
880 struct rtw89_lps_parm *lps_param)
881 {
882 struct sk_buff *skb;
883
884 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_LPS_PARM_LEN);
885 if (!skb) {
886 rtw89_err(rtwdev, "failed to alloc skb for fw dl\n");
887 return -ENOMEM;
888 }
889 skb_put(skb, H2C_LPS_PARM_LEN);
890
891 SET_LPS_PARM_MACID(skb->data, lps_param->macid);
892 SET_LPS_PARM_PSMODE(skb->data, lps_param->psmode);
893 SET_LPS_PARM_LASTRPWM(skb->data, lps_param->lastrpwm);
894 SET_LPS_PARM_RLBM(skb->data, 1);
895 SET_LPS_PARM_SMARTPS(skb->data, 1);
896 SET_LPS_PARM_AWAKEINTERVAL(skb->data, 1);
897 SET_LPS_PARM_VOUAPSD(skb->data, 0);
898 SET_LPS_PARM_VIUAPSD(skb->data, 0);
899 SET_LPS_PARM_BEUAPSD(skb->data, 0);
900 SET_LPS_PARM_BKUAPSD(skb->data, 0);
901
902 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
903 H2C_CAT_MAC,
904 H2C_CL_MAC_PS,
905 H2C_FUNC_MAC_LPS_PARM, 0, 1,
906 H2C_LPS_PARM_LEN);
907
908 if (rtw89_h2c_tx(rtwdev, skb, false)) {
909 rtw89_err(rtwdev, "failed to send h2c\n");
910 goto fail;
911 }
912
913 return 0;
914 fail:
915 dev_kfree_skb_any(skb);
916
917 return -EBUSY;
918 }
919
920 #define H2C_CMC_TBL_LEN 68
rtw89_fw_h2c_default_cmac_tbl(struct rtw89_dev * rtwdev,struct rtw89_vif * rtwvif)921 int rtw89_fw_h2c_default_cmac_tbl(struct rtw89_dev *rtwdev,
922 struct rtw89_vif *rtwvif)
923 {
924 const struct rtw89_chip_info *chip = rtwdev->chip;
925 struct rtw89_hal *hal = &rtwdev->hal;
926 struct sk_buff *skb;
927 u8 ntx_path = hal->antenna_tx ? hal->antenna_tx : RF_B;
928 u8 map_b = hal->antenna_tx == RF_AB ? 1 : 0;
929 u8 macid = rtwvif->mac_id;
930
931 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_CMC_TBL_LEN);
932 if (!skb) {
933 rtw89_err(rtwdev, "failed to alloc skb for fw dl\n");
934 return -ENOMEM;
935 }
936 skb_put(skb, H2C_CMC_TBL_LEN);
937 SET_CTRL_INFO_MACID(skb->data, macid);
938 SET_CTRL_INFO_OPERATION(skb->data, 1);
939 if (chip->h2c_cctl_func_id == H2C_FUNC_MAC_CCTLINFO_UD) {
940 SET_CMC_TBL_TXPWR_MODE(skb->data, 0);
941 SET_CMC_TBL_NTX_PATH_EN(skb->data, ntx_path);
942 SET_CMC_TBL_PATH_MAP_A(skb->data, 0);
943 SET_CMC_TBL_PATH_MAP_B(skb->data, map_b);
944 SET_CMC_TBL_PATH_MAP_C(skb->data, 0);
945 SET_CMC_TBL_PATH_MAP_D(skb->data, 0);
946 SET_CMC_TBL_ANTSEL_A(skb->data, 0);
947 SET_CMC_TBL_ANTSEL_B(skb->data, 0);
948 SET_CMC_TBL_ANTSEL_C(skb->data, 0);
949 SET_CMC_TBL_ANTSEL_D(skb->data, 0);
950 }
951 SET_CMC_TBL_DOPPLER_CTRL(skb->data, 0);
952 SET_CMC_TBL_TXPWR_TOLERENCE(skb->data, 0);
953 if (rtwvif->net_type == RTW89_NET_TYPE_AP_MODE)
954 SET_CMC_TBL_DATA_DCM(skb->data, 0);
955
956 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
957 H2C_CAT_MAC, H2C_CL_MAC_FR_EXCHG,
958 chip->h2c_cctl_func_id, 0, 1,
959 H2C_CMC_TBL_LEN);
960
961 if (rtw89_h2c_tx(rtwdev, skb, false)) {
962 rtw89_err(rtwdev, "failed to send h2c\n");
963 goto fail;
964 }
965
966 return 0;
967 fail:
968 dev_kfree_skb_any(skb);
969
970 return -EBUSY;
971 }
972
__get_sta_he_pkt_padding(struct rtw89_dev * rtwdev,struct ieee80211_sta * sta,u8 * pads)973 static void __get_sta_he_pkt_padding(struct rtw89_dev *rtwdev,
974 struct ieee80211_sta *sta, u8 *pads)
975 {
976 bool ppe_th;
977 u8 ppe16, ppe8;
978 u8 nss = min(sta->deflink.rx_nss, rtwdev->hal.tx_nss) - 1;
979 u8 ppe_thres_hdr = sta->deflink.he_cap.ppe_thres[0];
980 u8 ru_bitmap;
981 u8 n, idx, sh;
982 u16 ppe;
983 int i;
984
985 if (!sta->deflink.he_cap.has_he)
986 return;
987
988 ppe_th = FIELD_GET(IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT,
989 sta->deflink.he_cap.he_cap_elem.phy_cap_info[6]);
990 if (!ppe_th) {
991 u8 pad;
992
993 pad = FIELD_GET(IEEE80211_HE_PHY_CAP9_NOMINAL_PKT_PADDING_MASK,
994 sta->deflink.he_cap.he_cap_elem.phy_cap_info[9]);
995
996 for (i = 0; i < RTW89_PPE_BW_NUM; i++)
997 pads[i] = pad;
998
999 return;
1000 }
1001
1002 ru_bitmap = FIELD_GET(IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK, ppe_thres_hdr);
1003 n = hweight8(ru_bitmap);
1004 n = 7 + (n * IEEE80211_PPE_THRES_INFO_PPET_SIZE * 2) * nss;
1005
1006 for (i = 0; i < RTW89_PPE_BW_NUM; i++) {
1007 if (!(ru_bitmap & BIT(i))) {
1008 pads[i] = 1;
1009 continue;
1010 }
1011
1012 idx = n >> 3;
1013 sh = n & 7;
1014 n += IEEE80211_PPE_THRES_INFO_PPET_SIZE * 2;
1015
1016 ppe = le16_to_cpu(*((__le16 *)&sta->deflink.he_cap.ppe_thres[idx]));
1017 ppe16 = (ppe >> sh) & IEEE80211_PPE_THRES_NSS_MASK;
1018 sh += IEEE80211_PPE_THRES_INFO_PPET_SIZE;
1019 ppe8 = (ppe >> sh) & IEEE80211_PPE_THRES_NSS_MASK;
1020
1021 if (ppe16 != 7 && ppe8 == 7)
1022 pads[i] = 2;
1023 else if (ppe8 != 7)
1024 pads[i] = 1;
1025 else
1026 pads[i] = 0;
1027 }
1028 }
1029
rtw89_fw_h2c_assoc_cmac_tbl(struct rtw89_dev * rtwdev,struct ieee80211_vif * vif,struct ieee80211_sta * sta)1030 int rtw89_fw_h2c_assoc_cmac_tbl(struct rtw89_dev *rtwdev,
1031 struct ieee80211_vif *vif,
1032 struct ieee80211_sta *sta)
1033 {
1034 const struct rtw89_chip_info *chip = rtwdev->chip;
1035 struct rtw89_sta *rtwsta = sta_to_rtwsta_safe(sta);
1036 struct rtw89_vif *rtwvif = (struct rtw89_vif *)vif->drv_priv;
1037 const struct rtw89_chan *chan = rtw89_chan_get(rtwdev, RTW89_SUB_ENTITY_0);
1038 struct sk_buff *skb;
1039 u8 pads[RTW89_PPE_BW_NUM];
1040 u8 mac_id = rtwsta ? rtwsta->mac_id : rtwvif->mac_id;
1041
1042 memset(pads, 0, sizeof(pads));
1043 if (sta)
1044 __get_sta_he_pkt_padding(rtwdev, sta, pads);
1045
1046 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_CMC_TBL_LEN);
1047 if (!skb) {
1048 rtw89_err(rtwdev, "failed to alloc skb for fw dl\n");
1049 return -ENOMEM;
1050 }
1051 skb_put(skb, H2C_CMC_TBL_LEN);
1052 SET_CTRL_INFO_MACID(skb->data, mac_id);
1053 SET_CTRL_INFO_OPERATION(skb->data, 1);
1054 SET_CMC_TBL_DISRTSFB(skb->data, 1);
1055 SET_CMC_TBL_DISDATAFB(skb->data, 1);
1056 if (chan->band_type == RTW89_BAND_2G)
1057 SET_CMC_TBL_RTS_RTY_LOWEST_RATE(skb->data, RTW89_HW_RATE_CCK1);
1058 else
1059 SET_CMC_TBL_RTS_RTY_LOWEST_RATE(skb->data, RTW89_HW_RATE_OFDM6);
1060 SET_CMC_TBL_RTS_TXCNT_LMT_SEL(skb->data, 0);
1061 SET_CMC_TBL_DATA_TXCNT_LMT_SEL(skb->data, 0);
1062 if (vif->type == NL80211_IFTYPE_STATION)
1063 SET_CMC_TBL_ULDL(skb->data, 1);
1064 else
1065 SET_CMC_TBL_ULDL(skb->data, 0);
1066 SET_CMC_TBL_MULTI_PORT_ID(skb->data, rtwvif->port);
1067 if (chip->h2c_cctl_func_id == H2C_FUNC_MAC_CCTLINFO_UD_V1) {
1068 SET_CMC_TBL_NOMINAL_PKT_PADDING_V1(skb->data, pads[RTW89_CHANNEL_WIDTH_20]);
1069 SET_CMC_TBL_NOMINAL_PKT_PADDING40_V1(skb->data, pads[RTW89_CHANNEL_WIDTH_40]);
1070 SET_CMC_TBL_NOMINAL_PKT_PADDING80_V1(skb->data, pads[RTW89_CHANNEL_WIDTH_80]);
1071 SET_CMC_TBL_NOMINAL_PKT_PADDING160_V1(skb->data, pads[RTW89_CHANNEL_WIDTH_160]);
1072 } else if (chip->h2c_cctl_func_id == H2C_FUNC_MAC_CCTLINFO_UD) {
1073 SET_CMC_TBL_NOMINAL_PKT_PADDING(skb->data, pads[RTW89_CHANNEL_WIDTH_20]);
1074 SET_CMC_TBL_NOMINAL_PKT_PADDING40(skb->data, pads[RTW89_CHANNEL_WIDTH_40]);
1075 SET_CMC_TBL_NOMINAL_PKT_PADDING80(skb->data, pads[RTW89_CHANNEL_WIDTH_80]);
1076 SET_CMC_TBL_NOMINAL_PKT_PADDING160(skb->data, pads[RTW89_CHANNEL_WIDTH_160]);
1077 }
1078 if (sta)
1079 SET_CMC_TBL_BSR_QUEUE_SIZE_FORMAT(skb->data,
1080 sta->deflink.he_cap.has_he);
1081 if (rtwvif->net_type == RTW89_NET_TYPE_AP_MODE)
1082 SET_CMC_TBL_DATA_DCM(skb->data, 0);
1083
1084 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
1085 H2C_CAT_MAC, H2C_CL_MAC_FR_EXCHG,
1086 chip->h2c_cctl_func_id, 0, 1,
1087 H2C_CMC_TBL_LEN);
1088
1089 if (rtw89_h2c_tx(rtwdev, skb, false)) {
1090 rtw89_err(rtwdev, "failed to send h2c\n");
1091 goto fail;
1092 }
1093
1094 return 0;
1095 fail:
1096 dev_kfree_skb_any(skb);
1097
1098 return -EBUSY;
1099 }
1100
rtw89_fw_h2c_txtime_cmac_tbl(struct rtw89_dev * rtwdev,struct rtw89_sta * rtwsta)1101 int rtw89_fw_h2c_txtime_cmac_tbl(struct rtw89_dev *rtwdev,
1102 struct rtw89_sta *rtwsta)
1103 {
1104 const struct rtw89_chip_info *chip = rtwdev->chip;
1105 struct sk_buff *skb;
1106
1107 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_CMC_TBL_LEN);
1108 if (!skb) {
1109 rtw89_err(rtwdev, "failed to alloc skb for fw dl\n");
1110 return -ENOMEM;
1111 }
1112 skb_put(skb, H2C_CMC_TBL_LEN);
1113 SET_CTRL_INFO_MACID(skb->data, rtwsta->mac_id);
1114 SET_CTRL_INFO_OPERATION(skb->data, 1);
1115 if (rtwsta->cctl_tx_time) {
1116 SET_CMC_TBL_AMPDU_TIME_SEL(skb->data, 1);
1117 SET_CMC_TBL_AMPDU_MAX_TIME(skb->data, rtwsta->ampdu_max_time);
1118 }
1119 if (rtwsta->cctl_tx_retry_limit) {
1120 SET_CMC_TBL_DATA_TXCNT_LMT_SEL(skb->data, 1);
1121 SET_CMC_TBL_DATA_TX_CNT_LMT(skb->data, rtwsta->data_tx_cnt_lmt);
1122 }
1123
1124 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
1125 H2C_CAT_MAC, H2C_CL_MAC_FR_EXCHG,
1126 chip->h2c_cctl_func_id, 0, 1,
1127 H2C_CMC_TBL_LEN);
1128
1129 if (rtw89_h2c_tx(rtwdev, skb, false)) {
1130 rtw89_err(rtwdev, "failed to send h2c\n");
1131 goto fail;
1132 }
1133
1134 return 0;
1135 fail:
1136 dev_kfree_skb_any(skb);
1137
1138 return -EBUSY;
1139 }
1140
1141 #define H2C_BCN_BASE_LEN 12
rtw89_fw_h2c_update_beacon(struct rtw89_dev * rtwdev,struct rtw89_vif * rtwvif)1142 int rtw89_fw_h2c_update_beacon(struct rtw89_dev *rtwdev,
1143 struct rtw89_vif *rtwvif)
1144 {
1145 struct ieee80211_vif *vif = rtwvif_to_vif(rtwvif);
1146 const struct rtw89_chan *chan = rtw89_chan_get(rtwdev, RTW89_SUB_ENTITY_0);
1147 struct sk_buff *skb;
1148 struct sk_buff *skb_beacon;
1149 u16 tim_offset;
1150 int bcn_total_len;
1151
1152 skb_beacon = ieee80211_beacon_get_tim(rtwdev->hw, vif, &tim_offset,
1153 NULL, 0);
1154 if (!skb_beacon) {
1155 rtw89_err(rtwdev, "failed to get beacon skb\n");
1156 return -ENOMEM;
1157 }
1158
1159 bcn_total_len = H2C_BCN_BASE_LEN + skb_beacon->len;
1160 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, bcn_total_len);
1161 if (!skb) {
1162 rtw89_err(rtwdev, "failed to alloc skb for fw dl\n");
1163 dev_kfree_skb_any(skb_beacon);
1164 return -ENOMEM;
1165 }
1166 skb_put(skb, H2C_BCN_BASE_LEN);
1167
1168 SET_BCN_UPD_PORT(skb->data, rtwvif->port);
1169 SET_BCN_UPD_MBSSID(skb->data, 0);
1170 SET_BCN_UPD_BAND(skb->data, rtwvif->mac_idx);
1171 SET_BCN_UPD_GRP_IE_OFST(skb->data, tim_offset);
1172 SET_BCN_UPD_MACID(skb->data, rtwvif->mac_id);
1173 SET_BCN_UPD_SSN_SEL(skb->data, RTW89_MGMT_HW_SSN_SEL);
1174 SET_BCN_UPD_SSN_MODE(skb->data, RTW89_MGMT_HW_SEQ_MODE);
1175 SET_BCN_UPD_RATE(skb->data, chan->band_type == RTW89_BAND_2G ?
1176 RTW89_HW_RATE_CCK1 : RTW89_HW_RATE_OFDM6);
1177
1178 skb_put_data(skb, skb_beacon->data, skb_beacon->len);
1179 dev_kfree_skb_any(skb_beacon);
1180
1181 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
1182 H2C_CAT_MAC, H2C_CL_MAC_FR_EXCHG,
1183 H2C_FUNC_MAC_BCN_UPD, 0, 1,
1184 bcn_total_len);
1185
1186 if (rtw89_h2c_tx(rtwdev, skb, false)) {
1187 rtw89_err(rtwdev, "failed to send h2c\n");
1188 dev_kfree_skb_any(skb);
1189 return -EBUSY;
1190 }
1191
1192 return 0;
1193 }
1194
1195 #define H2C_ROLE_MAINTAIN_LEN 4
rtw89_fw_h2c_role_maintain(struct rtw89_dev * rtwdev,struct rtw89_vif * rtwvif,struct rtw89_sta * rtwsta,enum rtw89_upd_mode upd_mode)1196 int rtw89_fw_h2c_role_maintain(struct rtw89_dev *rtwdev,
1197 struct rtw89_vif *rtwvif,
1198 struct rtw89_sta *rtwsta,
1199 enum rtw89_upd_mode upd_mode)
1200 {
1201 struct sk_buff *skb;
1202 u8 mac_id = rtwsta ? rtwsta->mac_id : rtwvif->mac_id;
1203 u8 self_role;
1204
1205 if (rtwvif->net_type == RTW89_NET_TYPE_AP_MODE) {
1206 if (rtwsta)
1207 self_role = RTW89_SELF_ROLE_AP_CLIENT;
1208 else
1209 self_role = rtwvif->self_role;
1210 } else {
1211 self_role = rtwvif->self_role;
1212 }
1213
1214 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_ROLE_MAINTAIN_LEN);
1215 if (!skb) {
1216 rtw89_err(rtwdev, "failed to alloc skb for h2c join\n");
1217 return -ENOMEM;
1218 }
1219 skb_put(skb, H2C_ROLE_MAINTAIN_LEN);
1220 SET_FWROLE_MAINTAIN_MACID(skb->data, mac_id);
1221 SET_FWROLE_MAINTAIN_SELF_ROLE(skb->data, self_role);
1222 SET_FWROLE_MAINTAIN_UPD_MODE(skb->data, upd_mode);
1223 SET_FWROLE_MAINTAIN_WIFI_ROLE(skb->data, rtwvif->wifi_role);
1224
1225 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
1226 H2C_CAT_MAC, H2C_CL_MAC_MEDIA_RPT,
1227 H2C_FUNC_MAC_FWROLE_MAINTAIN, 0, 1,
1228 H2C_ROLE_MAINTAIN_LEN);
1229
1230 if (rtw89_h2c_tx(rtwdev, skb, false)) {
1231 rtw89_err(rtwdev, "failed to send h2c\n");
1232 goto fail;
1233 }
1234
1235 return 0;
1236 fail:
1237 dev_kfree_skb_any(skb);
1238
1239 return -EBUSY;
1240 }
1241
1242 #define H2C_JOIN_INFO_LEN 4
rtw89_fw_h2c_join_info(struct rtw89_dev * rtwdev,struct rtw89_vif * rtwvif,struct rtw89_sta * rtwsta,bool dis_conn)1243 int rtw89_fw_h2c_join_info(struct rtw89_dev *rtwdev, struct rtw89_vif *rtwvif,
1244 struct rtw89_sta *rtwsta, bool dis_conn)
1245 {
1246 struct sk_buff *skb;
1247 u8 mac_id = rtwsta ? rtwsta->mac_id : rtwvif->mac_id;
1248 u8 self_role = rtwvif->self_role;
1249 u8 net_type = rtwvif->net_type;
1250
1251 if (net_type == RTW89_NET_TYPE_AP_MODE && rtwsta) {
1252 self_role = RTW89_SELF_ROLE_AP_CLIENT;
1253 net_type = dis_conn ? RTW89_NET_TYPE_NO_LINK : net_type;
1254 }
1255
1256 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_JOIN_INFO_LEN);
1257 if (!skb) {
1258 rtw89_err(rtwdev, "failed to alloc skb for h2c join\n");
1259 return -ENOMEM;
1260 }
1261 skb_put(skb, H2C_JOIN_INFO_LEN);
1262 SET_JOININFO_MACID(skb->data, mac_id);
1263 SET_JOININFO_OP(skb->data, dis_conn);
1264 SET_JOININFO_BAND(skb->data, rtwvif->mac_idx);
1265 SET_JOININFO_WMM(skb->data, rtwvif->wmm);
1266 SET_JOININFO_TGR(skb->data, rtwvif->trigger);
1267 SET_JOININFO_ISHESTA(skb->data, 0);
1268 SET_JOININFO_DLBW(skb->data, 0);
1269 SET_JOININFO_TF_MAC_PAD(skb->data, 0);
1270 SET_JOININFO_DL_T_PE(skb->data, 0);
1271 SET_JOININFO_PORT_ID(skb->data, rtwvif->port);
1272 SET_JOININFO_NET_TYPE(skb->data, net_type);
1273 SET_JOININFO_WIFI_ROLE(skb->data, rtwvif->wifi_role);
1274 SET_JOININFO_SELF_ROLE(skb->data, self_role);
1275
1276 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
1277 H2C_CAT_MAC, H2C_CL_MAC_MEDIA_RPT,
1278 H2C_FUNC_MAC_JOININFO, 0, 1,
1279 H2C_JOIN_INFO_LEN);
1280
1281 if (rtw89_h2c_tx(rtwdev, skb, false)) {
1282 rtw89_err(rtwdev, "failed to send h2c\n");
1283 goto fail;
1284 }
1285
1286 return 0;
1287 fail:
1288 dev_kfree_skb_any(skb);
1289
1290 return -EBUSY;
1291 }
1292
rtw89_fw_h2c_macid_pause(struct rtw89_dev * rtwdev,u8 sh,u8 grp,bool pause)1293 int rtw89_fw_h2c_macid_pause(struct rtw89_dev *rtwdev, u8 sh, u8 grp,
1294 bool pause)
1295 {
1296 struct rtw89_fw_macid_pause_grp h2c = {{0}};
1297 u8 len = sizeof(struct rtw89_fw_macid_pause_grp);
1298 struct sk_buff *skb;
1299
1300 #if defined(__linux__)
1301 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_JOIN_INFO_LEN);
1302 #elif defined(__FreeBSD__)
1303 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, len);
1304 #endif
1305 if (!skb) {
1306 rtw89_err(rtwdev, "failed to alloc skb for h2c join\n");
1307 return -ENOMEM;
1308 }
1309 h2c.mask_grp[grp] = cpu_to_le32(BIT(sh));
1310 if (pause)
1311 h2c.pause_grp[grp] = cpu_to_le32(BIT(sh));
1312 skb_put_data(skb, &h2c, len);
1313
1314 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
1315 H2C_CAT_MAC, H2C_CL_MAC_FW_OFLD,
1316 H2C_FUNC_MAC_MACID_PAUSE, 1, 0,
1317 len);
1318
1319 if (rtw89_h2c_tx(rtwdev, skb, false)) {
1320 rtw89_err(rtwdev, "failed to send h2c\n");
1321 goto fail;
1322 }
1323
1324 return 0;
1325 fail:
1326 dev_kfree_skb_any(skb);
1327
1328 return -EBUSY;
1329 }
1330
1331 #define H2C_EDCA_LEN 12
rtw89_fw_h2c_set_edca(struct rtw89_dev * rtwdev,struct rtw89_vif * rtwvif,u8 ac,u32 val)1332 int rtw89_fw_h2c_set_edca(struct rtw89_dev *rtwdev, struct rtw89_vif *rtwvif,
1333 u8 ac, u32 val)
1334 {
1335 struct sk_buff *skb;
1336
1337 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_EDCA_LEN);
1338 if (!skb) {
1339 rtw89_err(rtwdev, "failed to alloc skb for h2c edca\n");
1340 return -ENOMEM;
1341 }
1342 skb_put(skb, H2C_EDCA_LEN);
1343 RTW89_SET_EDCA_SEL(skb->data, 0);
1344 RTW89_SET_EDCA_BAND(skb->data, rtwvif->mac_idx);
1345 RTW89_SET_EDCA_WMM(skb->data, 0);
1346 RTW89_SET_EDCA_AC(skb->data, ac);
1347 RTW89_SET_EDCA_PARAM(skb->data, val);
1348
1349 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
1350 H2C_CAT_MAC, H2C_CL_MAC_FW_OFLD,
1351 H2C_FUNC_USR_EDCA, 0, 1,
1352 H2C_EDCA_LEN);
1353
1354 if (rtw89_h2c_tx(rtwdev, skb, false)) {
1355 rtw89_err(rtwdev, "failed to send h2c\n");
1356 goto fail;
1357 }
1358
1359 return 0;
1360 fail:
1361 dev_kfree_skb_any(skb);
1362
1363 return -EBUSY;
1364 }
1365
1366 #define H2C_OFLD_CFG_LEN 8
rtw89_fw_h2c_set_ofld_cfg(struct rtw89_dev * rtwdev)1367 int rtw89_fw_h2c_set_ofld_cfg(struct rtw89_dev *rtwdev)
1368 {
1369 static const u8 cfg[] = {0x09, 0x00, 0x00, 0x00, 0x5e, 0x00, 0x00, 0x00};
1370 struct sk_buff *skb;
1371
1372 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_OFLD_CFG_LEN);
1373 if (!skb) {
1374 rtw89_err(rtwdev, "failed to alloc skb for h2c ofld\n");
1375 return -ENOMEM;
1376 }
1377 skb_put_data(skb, cfg, H2C_OFLD_CFG_LEN);
1378
1379 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
1380 H2C_CAT_MAC, H2C_CL_MAC_FW_OFLD,
1381 H2C_FUNC_OFLD_CFG, 0, 1,
1382 H2C_OFLD_CFG_LEN);
1383
1384 if (rtw89_h2c_tx(rtwdev, skb, false)) {
1385 rtw89_err(rtwdev, "failed to send h2c\n");
1386 goto fail;
1387 }
1388
1389 return 0;
1390 fail:
1391 dev_kfree_skb_any(skb);
1392
1393 return -EBUSY;
1394 }
1395
1396 #define H2C_RA_LEN 16
rtw89_fw_h2c_ra(struct rtw89_dev * rtwdev,struct rtw89_ra_info * ra,bool csi)1397 int rtw89_fw_h2c_ra(struct rtw89_dev *rtwdev, struct rtw89_ra_info *ra, bool csi)
1398 {
1399 struct sk_buff *skb;
1400 u8 *cmd;
1401
1402 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_RA_LEN);
1403 if (!skb) {
1404 rtw89_err(rtwdev, "failed to alloc skb for h2c join\n");
1405 return -ENOMEM;
1406 }
1407 skb_put(skb, H2C_RA_LEN);
1408 cmd = skb->data;
1409 rtw89_debug(rtwdev, RTW89_DBG_RA,
1410 #if defined(__linux__)
1411 "ra cmd msk: %llx ", ra->ra_mask);
1412 #elif defined(__FreeBSD__)
1413 "ra cmd msk: %jx ", (uintmax_t)ra->ra_mask);
1414 #endif
1415
1416 RTW89_SET_FWCMD_RA_MODE(cmd, ra->mode_ctrl);
1417 RTW89_SET_FWCMD_RA_BW_CAP(cmd, ra->bw_cap);
1418 RTW89_SET_FWCMD_RA_MACID(cmd, ra->macid);
1419 RTW89_SET_FWCMD_RA_DCM(cmd, ra->dcm_cap);
1420 RTW89_SET_FWCMD_RA_ER(cmd, ra->er_cap);
1421 RTW89_SET_FWCMD_RA_INIT_RATE_LV(cmd, ra->init_rate_lv);
1422 RTW89_SET_FWCMD_RA_UPD_ALL(cmd, ra->upd_all);
1423 RTW89_SET_FWCMD_RA_SGI(cmd, ra->en_sgi);
1424 RTW89_SET_FWCMD_RA_LDPC(cmd, ra->ldpc_cap);
1425 RTW89_SET_FWCMD_RA_STBC(cmd, ra->stbc_cap);
1426 RTW89_SET_FWCMD_RA_SS_NUM(cmd, ra->ss_num);
1427 RTW89_SET_FWCMD_RA_GILTF(cmd, ra->giltf);
1428 RTW89_SET_FWCMD_RA_UPD_BW_NSS_MASK(cmd, ra->upd_bw_nss_mask);
1429 RTW89_SET_FWCMD_RA_UPD_MASK(cmd, ra->upd_mask);
1430 RTW89_SET_FWCMD_RA_MASK_0(cmd, FIELD_GET(MASKBYTE0, ra->ra_mask));
1431 RTW89_SET_FWCMD_RA_MASK_1(cmd, FIELD_GET(MASKBYTE1, ra->ra_mask));
1432 RTW89_SET_FWCMD_RA_MASK_2(cmd, FIELD_GET(MASKBYTE2, ra->ra_mask));
1433 RTW89_SET_FWCMD_RA_MASK_3(cmd, FIELD_GET(MASKBYTE3, ra->ra_mask));
1434 RTW89_SET_FWCMD_RA_MASK_4(cmd, FIELD_GET(MASKBYTE4, ra->ra_mask));
1435
1436 if (csi) {
1437 RTW89_SET_FWCMD_RA_BFEE_CSI_CTL(cmd, 1);
1438 RTW89_SET_FWCMD_RA_BAND_NUM(cmd, ra->band_num);
1439 RTW89_SET_FWCMD_RA_CR_TBL_SEL(cmd, ra->cr_tbl_sel);
1440 RTW89_SET_FWCMD_RA_FIXED_CSI_RATE_EN(cmd, ra->fixed_csi_rate_en);
1441 RTW89_SET_FWCMD_RA_RA_CSI_RATE_EN(cmd, ra->ra_csi_rate_en);
1442 RTW89_SET_FWCMD_RA_FIXED_CSI_MCS_SS_IDX(cmd, ra->csi_mcs_ss_idx);
1443 RTW89_SET_FWCMD_RA_FIXED_CSI_MODE(cmd, ra->csi_mode);
1444 RTW89_SET_FWCMD_RA_FIXED_CSI_GI_LTF(cmd, ra->csi_gi_ltf);
1445 RTW89_SET_FWCMD_RA_FIXED_CSI_BW(cmd, ra->csi_bw);
1446 }
1447
1448 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
1449 H2C_CAT_OUTSRC, H2C_CL_OUTSRC_RA,
1450 H2C_FUNC_OUTSRC_RA_MACIDCFG, 0, 0,
1451 H2C_RA_LEN);
1452
1453 if (rtw89_h2c_tx(rtwdev, skb, false)) {
1454 rtw89_err(rtwdev, "failed to send h2c\n");
1455 goto fail;
1456 }
1457
1458 return 0;
1459 fail:
1460 dev_kfree_skb_any(skb);
1461
1462 return -EBUSY;
1463 }
1464
1465 #define H2C_LEN_CXDRVHDR 2
1466 #define H2C_LEN_CXDRVINFO_INIT (12 + H2C_LEN_CXDRVHDR)
rtw89_fw_h2c_cxdrv_init(struct rtw89_dev * rtwdev)1467 int rtw89_fw_h2c_cxdrv_init(struct rtw89_dev *rtwdev)
1468 {
1469 struct rtw89_btc *btc = &rtwdev->btc;
1470 struct rtw89_btc_dm *dm = &btc->dm;
1471 struct rtw89_btc_init_info *init_info = &dm->init_info;
1472 struct rtw89_btc_module *module = &init_info->module;
1473 struct rtw89_btc_ant_info *ant = &module->ant;
1474 struct sk_buff *skb;
1475 u8 *cmd;
1476
1477 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_LEN_CXDRVINFO_INIT);
1478 if (!skb) {
1479 rtw89_err(rtwdev, "failed to alloc skb for h2c cxdrv_init\n");
1480 return -ENOMEM;
1481 }
1482 skb_put(skb, H2C_LEN_CXDRVINFO_INIT);
1483 cmd = skb->data;
1484
1485 RTW89_SET_FWCMD_CXHDR_TYPE(cmd, CXDRVINFO_INIT);
1486 RTW89_SET_FWCMD_CXHDR_LEN(cmd, H2C_LEN_CXDRVINFO_INIT - H2C_LEN_CXDRVHDR);
1487
1488 RTW89_SET_FWCMD_CXINIT_ANT_TYPE(cmd, ant->type);
1489 RTW89_SET_FWCMD_CXINIT_ANT_NUM(cmd, ant->num);
1490 RTW89_SET_FWCMD_CXINIT_ANT_ISO(cmd, ant->isolation);
1491 RTW89_SET_FWCMD_CXINIT_ANT_POS(cmd, ant->single_pos);
1492 RTW89_SET_FWCMD_CXINIT_ANT_DIVERSITY(cmd, ant->diversity);
1493
1494 RTW89_SET_FWCMD_CXINIT_MOD_RFE(cmd, module->rfe_type);
1495 RTW89_SET_FWCMD_CXINIT_MOD_CV(cmd, module->cv);
1496 RTW89_SET_FWCMD_CXINIT_MOD_BT_SOLO(cmd, module->bt_solo);
1497 RTW89_SET_FWCMD_CXINIT_MOD_BT_POS(cmd, module->bt_pos);
1498 RTW89_SET_FWCMD_CXINIT_MOD_SW_TYPE(cmd, module->switch_type);
1499
1500 RTW89_SET_FWCMD_CXINIT_WL_GCH(cmd, init_info->wl_guard_ch);
1501 RTW89_SET_FWCMD_CXINIT_WL_ONLY(cmd, init_info->wl_only);
1502 RTW89_SET_FWCMD_CXINIT_WL_INITOK(cmd, init_info->wl_init_ok);
1503 RTW89_SET_FWCMD_CXINIT_DBCC_EN(cmd, init_info->dbcc_en);
1504 RTW89_SET_FWCMD_CXINIT_CX_OTHER(cmd, init_info->cx_other);
1505 RTW89_SET_FWCMD_CXINIT_BT_ONLY(cmd, init_info->bt_only);
1506
1507 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
1508 H2C_CAT_OUTSRC, BTFC_SET,
1509 SET_DRV_INFO, 0, 0,
1510 H2C_LEN_CXDRVINFO_INIT);
1511
1512 if (rtw89_h2c_tx(rtwdev, skb, false)) {
1513 rtw89_err(rtwdev, "failed to send h2c\n");
1514 goto fail;
1515 }
1516
1517 return 0;
1518 fail:
1519 dev_kfree_skb_any(skb);
1520
1521 return -EBUSY;
1522 }
1523
1524 #define PORT_DATA_OFFSET 4
1525 #define H2C_LEN_CXDRVINFO_ROLE_DBCC_LEN 12
1526 #define H2C_LEN_CXDRVINFO_ROLE (4 + 12 * RTW89_PORT_NUM + H2C_LEN_CXDRVHDR)
1527 #define H2C_LEN_CXDRVINFO_ROLE_V1 (4 + 16 * RTW89_PORT_NUM + \
1528 H2C_LEN_CXDRVINFO_ROLE_DBCC_LEN + \
1529 H2C_LEN_CXDRVHDR)
rtw89_fw_h2c_cxdrv_role(struct rtw89_dev * rtwdev)1530 int rtw89_fw_h2c_cxdrv_role(struct rtw89_dev *rtwdev)
1531 {
1532 struct rtw89_btc *btc = &rtwdev->btc;
1533 struct rtw89_btc_wl_info *wl = &btc->cx.wl;
1534 struct rtw89_btc_wl_role_info *role_info = &wl->role_info;
1535 struct rtw89_btc_wl_role_info_bpos *bpos = &role_info->role_map.role;
1536 struct rtw89_btc_wl_active_role *active = role_info->active_role;
1537 struct sk_buff *skb;
1538 u8 offset = 0;
1539 u8 *cmd;
1540 int i;
1541
1542 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_LEN_CXDRVINFO_ROLE);
1543 if (!skb) {
1544 rtw89_err(rtwdev, "failed to alloc skb for h2c cxdrv_role\n");
1545 return -ENOMEM;
1546 }
1547 skb_put(skb, H2C_LEN_CXDRVINFO_ROLE);
1548 cmd = skb->data;
1549
1550 RTW89_SET_FWCMD_CXHDR_TYPE(cmd, CXDRVINFO_ROLE);
1551 RTW89_SET_FWCMD_CXHDR_LEN(cmd, H2C_LEN_CXDRVINFO_ROLE - H2C_LEN_CXDRVHDR);
1552
1553 RTW89_SET_FWCMD_CXROLE_CONNECT_CNT(cmd, role_info->connect_cnt);
1554 RTW89_SET_FWCMD_CXROLE_LINK_MODE(cmd, role_info->link_mode);
1555
1556 RTW89_SET_FWCMD_CXROLE_ROLE_NONE(cmd, bpos->none);
1557 RTW89_SET_FWCMD_CXROLE_ROLE_STA(cmd, bpos->station);
1558 RTW89_SET_FWCMD_CXROLE_ROLE_AP(cmd, bpos->ap);
1559 RTW89_SET_FWCMD_CXROLE_ROLE_VAP(cmd, bpos->vap);
1560 RTW89_SET_FWCMD_CXROLE_ROLE_ADHOC(cmd, bpos->adhoc);
1561 RTW89_SET_FWCMD_CXROLE_ROLE_ADHOC_MASTER(cmd, bpos->adhoc_master);
1562 RTW89_SET_FWCMD_CXROLE_ROLE_MESH(cmd, bpos->mesh);
1563 RTW89_SET_FWCMD_CXROLE_ROLE_MONITOR(cmd, bpos->moniter);
1564 RTW89_SET_FWCMD_CXROLE_ROLE_P2P_DEV(cmd, bpos->p2p_device);
1565 RTW89_SET_FWCMD_CXROLE_ROLE_P2P_GC(cmd, bpos->p2p_gc);
1566 RTW89_SET_FWCMD_CXROLE_ROLE_P2P_GO(cmd, bpos->p2p_go);
1567 RTW89_SET_FWCMD_CXROLE_ROLE_NAN(cmd, bpos->nan);
1568
1569 for (i = 0; i < RTW89_PORT_NUM; i++, active++) {
1570 RTW89_SET_FWCMD_CXROLE_ACT_CONNECTED(cmd, active->connected, i, offset);
1571 RTW89_SET_FWCMD_CXROLE_ACT_PID(cmd, active->pid, i, offset);
1572 RTW89_SET_FWCMD_CXROLE_ACT_PHY(cmd, active->phy, i, offset);
1573 RTW89_SET_FWCMD_CXROLE_ACT_NOA(cmd, active->noa, i, offset);
1574 RTW89_SET_FWCMD_CXROLE_ACT_BAND(cmd, active->band, i, offset);
1575 RTW89_SET_FWCMD_CXROLE_ACT_CLIENT_PS(cmd, active->client_ps, i, offset);
1576 RTW89_SET_FWCMD_CXROLE_ACT_BW(cmd, active->bw, i, offset);
1577 RTW89_SET_FWCMD_CXROLE_ACT_ROLE(cmd, active->role, i, offset);
1578 RTW89_SET_FWCMD_CXROLE_ACT_CH(cmd, active->ch, i, offset);
1579 RTW89_SET_FWCMD_CXROLE_ACT_TX_LVL(cmd, active->tx_lvl, i, offset);
1580 RTW89_SET_FWCMD_CXROLE_ACT_RX_LVL(cmd, active->rx_lvl, i, offset);
1581 RTW89_SET_FWCMD_CXROLE_ACT_TX_RATE(cmd, active->tx_rate, i, offset);
1582 RTW89_SET_FWCMD_CXROLE_ACT_RX_RATE(cmd, active->rx_rate, i, offset);
1583 }
1584
1585 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
1586 H2C_CAT_OUTSRC, BTFC_SET,
1587 SET_DRV_INFO, 0, 0,
1588 H2C_LEN_CXDRVINFO_ROLE);
1589
1590 if (rtw89_h2c_tx(rtwdev, skb, false)) {
1591 rtw89_err(rtwdev, "failed to send h2c\n");
1592 goto fail;
1593 }
1594
1595 return 0;
1596 fail:
1597 dev_kfree_skb_any(skb);
1598
1599 return -EBUSY;
1600 }
1601
rtw89_fw_h2c_cxdrv_role_v1(struct rtw89_dev * rtwdev)1602 int rtw89_fw_h2c_cxdrv_role_v1(struct rtw89_dev *rtwdev)
1603 {
1604 struct rtw89_btc *btc = &rtwdev->btc;
1605 struct rtw89_btc_wl_info *wl = &btc->cx.wl;
1606 struct rtw89_btc_wl_role_info_v1 *role_info = &wl->role_info_v1;
1607 struct rtw89_btc_wl_role_info_bpos *bpos = &role_info->role_map.role;
1608 struct rtw89_btc_wl_active_role_v1 *active = role_info->active_role_v1;
1609 struct sk_buff *skb;
1610 u8 *cmd, offset;
1611 int i;
1612
1613 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_LEN_CXDRVINFO_ROLE_V1);
1614 if (!skb) {
1615 rtw89_err(rtwdev, "failed to alloc skb for h2c cxdrv_role\n");
1616 return -ENOMEM;
1617 }
1618 skb_put(skb, H2C_LEN_CXDRVINFO_ROLE_V1);
1619 cmd = skb->data;
1620
1621 RTW89_SET_FWCMD_CXHDR_TYPE(cmd, CXDRVINFO_ROLE);
1622 RTW89_SET_FWCMD_CXHDR_LEN(cmd, H2C_LEN_CXDRVINFO_ROLE_V1 - H2C_LEN_CXDRVHDR);
1623
1624 RTW89_SET_FWCMD_CXROLE_CONNECT_CNT(cmd, role_info->connect_cnt);
1625 RTW89_SET_FWCMD_CXROLE_LINK_MODE(cmd, role_info->link_mode);
1626
1627 RTW89_SET_FWCMD_CXROLE_ROLE_NONE(cmd, bpos->none);
1628 RTW89_SET_FWCMD_CXROLE_ROLE_STA(cmd, bpos->station);
1629 RTW89_SET_FWCMD_CXROLE_ROLE_AP(cmd, bpos->ap);
1630 RTW89_SET_FWCMD_CXROLE_ROLE_VAP(cmd, bpos->vap);
1631 RTW89_SET_FWCMD_CXROLE_ROLE_ADHOC(cmd, bpos->adhoc);
1632 RTW89_SET_FWCMD_CXROLE_ROLE_ADHOC_MASTER(cmd, bpos->adhoc_master);
1633 RTW89_SET_FWCMD_CXROLE_ROLE_MESH(cmd, bpos->mesh);
1634 RTW89_SET_FWCMD_CXROLE_ROLE_MONITOR(cmd, bpos->moniter);
1635 RTW89_SET_FWCMD_CXROLE_ROLE_P2P_DEV(cmd, bpos->p2p_device);
1636 RTW89_SET_FWCMD_CXROLE_ROLE_P2P_GC(cmd, bpos->p2p_gc);
1637 RTW89_SET_FWCMD_CXROLE_ROLE_P2P_GO(cmd, bpos->p2p_go);
1638 RTW89_SET_FWCMD_CXROLE_ROLE_NAN(cmd, bpos->nan);
1639
1640 offset = PORT_DATA_OFFSET;
1641 for (i = 0; i < RTW89_PORT_NUM; i++, active++) {
1642 RTW89_SET_FWCMD_CXROLE_ACT_CONNECTED(cmd, active->connected, i, offset);
1643 RTW89_SET_FWCMD_CXROLE_ACT_PID(cmd, active->pid, i, offset);
1644 RTW89_SET_FWCMD_CXROLE_ACT_PHY(cmd, active->phy, i, offset);
1645 RTW89_SET_FWCMD_CXROLE_ACT_NOA(cmd, active->noa, i, offset);
1646 RTW89_SET_FWCMD_CXROLE_ACT_BAND(cmd, active->band, i, offset);
1647 RTW89_SET_FWCMD_CXROLE_ACT_CLIENT_PS(cmd, active->client_ps, i, offset);
1648 RTW89_SET_FWCMD_CXROLE_ACT_BW(cmd, active->bw, i, offset);
1649 RTW89_SET_FWCMD_CXROLE_ACT_ROLE(cmd, active->role, i, offset);
1650 RTW89_SET_FWCMD_CXROLE_ACT_CH(cmd, active->ch, i, offset);
1651 RTW89_SET_FWCMD_CXROLE_ACT_TX_LVL(cmd, active->tx_lvl, i, offset);
1652 RTW89_SET_FWCMD_CXROLE_ACT_RX_LVL(cmd, active->rx_lvl, i, offset);
1653 RTW89_SET_FWCMD_CXROLE_ACT_TX_RATE(cmd, active->tx_rate, i, offset);
1654 RTW89_SET_FWCMD_CXROLE_ACT_RX_RATE(cmd, active->rx_rate, i, offset);
1655 RTW89_SET_FWCMD_CXROLE_ACT_NOA_DUR(cmd, active->noa_duration, i, offset);
1656 }
1657
1658 offset = H2C_LEN_CXDRVINFO_ROLE_V1 - H2C_LEN_CXDRVINFO_ROLE_DBCC_LEN;
1659 RTW89_SET_FWCMD_CXROLE_MROLE_TYPE(cmd, role_info->mrole_type, offset);
1660 RTW89_SET_FWCMD_CXROLE_MROLE_NOA(cmd, role_info->mrole_noa_duration, offset);
1661 RTW89_SET_FWCMD_CXROLE_DBCC_EN(cmd, role_info->dbcc_en, offset);
1662 RTW89_SET_FWCMD_CXROLE_DBCC_CHG(cmd, role_info->dbcc_chg, offset);
1663 RTW89_SET_FWCMD_CXROLE_DBCC_2G_PHY(cmd, role_info->dbcc_2g_phy, offset);
1664 RTW89_SET_FWCMD_CXROLE_LINK_MODE_CHG(cmd, role_info->link_mode_chg, offset);
1665
1666 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
1667 H2C_CAT_OUTSRC, BTFC_SET,
1668 SET_DRV_INFO, 0, 0,
1669 H2C_LEN_CXDRVINFO_ROLE_V1);
1670
1671 if (rtw89_h2c_tx(rtwdev, skb, false)) {
1672 rtw89_err(rtwdev, "failed to send h2c\n");
1673 goto fail;
1674 }
1675
1676 return 0;
1677 fail:
1678 dev_kfree_skb_any(skb);
1679
1680 return -EBUSY;
1681 }
1682
1683 #define H2C_LEN_CXDRVINFO_CTRL (4 + H2C_LEN_CXDRVHDR)
rtw89_fw_h2c_cxdrv_ctrl(struct rtw89_dev * rtwdev)1684 int rtw89_fw_h2c_cxdrv_ctrl(struct rtw89_dev *rtwdev)
1685 {
1686 struct rtw89_btc *btc = &rtwdev->btc;
1687 struct rtw89_btc_ctrl *ctrl = &btc->ctrl;
1688 struct sk_buff *skb;
1689 u8 *cmd;
1690
1691 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_LEN_CXDRVINFO_CTRL);
1692 if (!skb) {
1693 rtw89_err(rtwdev, "failed to alloc skb for h2c cxdrv_ctrl\n");
1694 return -ENOMEM;
1695 }
1696 skb_put(skb, H2C_LEN_CXDRVINFO_CTRL);
1697 cmd = skb->data;
1698
1699 RTW89_SET_FWCMD_CXHDR_TYPE(cmd, CXDRVINFO_CTRL);
1700 RTW89_SET_FWCMD_CXHDR_LEN(cmd, H2C_LEN_CXDRVINFO_CTRL - H2C_LEN_CXDRVHDR);
1701
1702 RTW89_SET_FWCMD_CXCTRL_MANUAL(cmd, ctrl->manual);
1703 RTW89_SET_FWCMD_CXCTRL_IGNORE_BT(cmd, ctrl->igno_bt);
1704 RTW89_SET_FWCMD_CXCTRL_ALWAYS_FREERUN(cmd, ctrl->always_freerun);
1705 RTW89_SET_FWCMD_CXCTRL_TRACE_STEP(cmd, ctrl->trace_step);
1706
1707 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
1708 H2C_CAT_OUTSRC, BTFC_SET,
1709 SET_DRV_INFO, 0, 0,
1710 H2C_LEN_CXDRVINFO_CTRL);
1711
1712 if (rtw89_h2c_tx(rtwdev, skb, false)) {
1713 rtw89_err(rtwdev, "failed to send h2c\n");
1714 goto fail;
1715 }
1716
1717 return 0;
1718 fail:
1719 dev_kfree_skb_any(skb);
1720
1721 return -EBUSY;
1722 }
1723
1724 #define H2C_LEN_CXDRVINFO_RFK (4 + H2C_LEN_CXDRVHDR)
rtw89_fw_h2c_cxdrv_rfk(struct rtw89_dev * rtwdev)1725 int rtw89_fw_h2c_cxdrv_rfk(struct rtw89_dev *rtwdev)
1726 {
1727 struct rtw89_btc *btc = &rtwdev->btc;
1728 struct rtw89_btc_wl_info *wl = &btc->cx.wl;
1729 struct rtw89_btc_wl_rfk_info *rfk_info = &wl->rfk_info;
1730 struct sk_buff *skb;
1731 u8 *cmd;
1732
1733 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_LEN_CXDRVINFO_RFK);
1734 if (!skb) {
1735 rtw89_err(rtwdev, "failed to alloc skb for h2c cxdrv_ctrl\n");
1736 return -ENOMEM;
1737 }
1738 skb_put(skb, H2C_LEN_CXDRVINFO_RFK);
1739 cmd = skb->data;
1740
1741 RTW89_SET_FWCMD_CXHDR_TYPE(cmd, CXDRVINFO_RFK);
1742 RTW89_SET_FWCMD_CXHDR_LEN(cmd, H2C_LEN_CXDRVINFO_RFK - H2C_LEN_CXDRVHDR);
1743
1744 RTW89_SET_FWCMD_CXRFK_STATE(cmd, rfk_info->state);
1745 RTW89_SET_FWCMD_CXRFK_PATH_MAP(cmd, rfk_info->path_map);
1746 RTW89_SET_FWCMD_CXRFK_PHY_MAP(cmd, rfk_info->phy_map);
1747 RTW89_SET_FWCMD_CXRFK_BAND(cmd, rfk_info->band);
1748 RTW89_SET_FWCMD_CXRFK_TYPE(cmd, rfk_info->type);
1749
1750 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
1751 H2C_CAT_OUTSRC, BTFC_SET,
1752 SET_DRV_INFO, 0, 0,
1753 H2C_LEN_CXDRVINFO_RFK);
1754
1755 if (rtw89_h2c_tx(rtwdev, skb, false)) {
1756 rtw89_err(rtwdev, "failed to send h2c\n");
1757 goto fail;
1758 }
1759
1760 return 0;
1761 fail:
1762 dev_kfree_skb_any(skb);
1763
1764 return -EBUSY;
1765 }
1766
1767 #define H2C_LEN_PKT_OFLD 4
rtw89_fw_h2c_del_pkt_offload(struct rtw89_dev * rtwdev,u8 id)1768 int rtw89_fw_h2c_del_pkt_offload(struct rtw89_dev *rtwdev, u8 id)
1769 {
1770 struct sk_buff *skb;
1771 u8 *cmd;
1772
1773 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_LEN_PKT_OFLD);
1774 if (!skb) {
1775 rtw89_err(rtwdev, "failed to alloc skb for h2c pkt offload\n");
1776 return -ENOMEM;
1777 }
1778 skb_put(skb, H2C_LEN_PKT_OFLD);
1779 cmd = skb->data;
1780
1781 RTW89_SET_FWCMD_PACKET_OFLD_PKT_IDX(cmd, id);
1782 RTW89_SET_FWCMD_PACKET_OFLD_PKT_OP(cmd, RTW89_PKT_OFLD_OP_DEL);
1783
1784 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
1785 H2C_CAT_MAC, H2C_CL_MAC_FW_OFLD,
1786 H2C_FUNC_PACKET_OFLD, 1, 1,
1787 H2C_LEN_PKT_OFLD);
1788
1789 if (rtw89_h2c_tx(rtwdev, skb, false)) {
1790 rtw89_err(rtwdev, "failed to send h2c\n");
1791 goto fail;
1792 }
1793
1794 return 0;
1795 fail:
1796 dev_kfree_skb_any(skb);
1797
1798 return -EBUSY;
1799 }
1800
rtw89_fw_h2c_add_pkt_offload(struct rtw89_dev * rtwdev,u8 * id,struct sk_buff * skb_ofld)1801 int rtw89_fw_h2c_add_pkt_offload(struct rtw89_dev *rtwdev, u8 *id,
1802 struct sk_buff *skb_ofld)
1803 {
1804 struct sk_buff *skb;
1805 u8 *cmd;
1806 u8 alloc_id;
1807
1808 alloc_id = rtw89_core_acquire_bit_map(rtwdev->pkt_offload,
1809 RTW89_MAX_PKT_OFLD_NUM);
1810 if (alloc_id == RTW89_MAX_PKT_OFLD_NUM)
1811 return -ENOSPC;
1812
1813 *id = alloc_id;
1814
1815 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_LEN_PKT_OFLD + skb_ofld->len);
1816 if (!skb) {
1817 rtw89_err(rtwdev, "failed to alloc skb for h2c pkt offload\n");
1818 return -ENOMEM;
1819 }
1820 skb_put(skb, H2C_LEN_PKT_OFLD);
1821 cmd = skb->data;
1822
1823 RTW89_SET_FWCMD_PACKET_OFLD_PKT_IDX(cmd, alloc_id);
1824 RTW89_SET_FWCMD_PACKET_OFLD_PKT_OP(cmd, RTW89_PKT_OFLD_OP_ADD);
1825 RTW89_SET_FWCMD_PACKET_OFLD_PKT_LENGTH(cmd, skb_ofld->len);
1826 skb_put_data(skb, skb_ofld->data, skb_ofld->len);
1827
1828 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
1829 H2C_CAT_MAC, H2C_CL_MAC_FW_OFLD,
1830 H2C_FUNC_PACKET_OFLD, 1, 1,
1831 H2C_LEN_PKT_OFLD + skb_ofld->len);
1832
1833 if (rtw89_h2c_tx(rtwdev, skb, false)) {
1834 rtw89_err(rtwdev, "failed to send h2c\n");
1835 goto fail;
1836 }
1837
1838 return 0;
1839 fail:
1840 dev_kfree_skb_any(skb);
1841
1842 return -EBUSY;
1843 }
1844
1845 #define H2C_LEN_SCAN_LIST_OFFLOAD 4
rtw89_fw_h2c_scan_list_offload(struct rtw89_dev * rtwdev,int len,struct list_head * chan_list)1846 int rtw89_fw_h2c_scan_list_offload(struct rtw89_dev *rtwdev, int len,
1847 struct list_head *chan_list)
1848 {
1849 struct rtw89_mac_chinfo *ch_info;
1850 struct sk_buff *skb;
1851 int skb_len = H2C_LEN_SCAN_LIST_OFFLOAD + len * RTW89_MAC_CHINFO_SIZE;
1852 u8 *cmd;
1853
1854 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, skb_len);
1855 if (!skb) {
1856 rtw89_err(rtwdev, "failed to alloc skb for h2c scan list\n");
1857 return -ENOMEM;
1858 }
1859 skb_put(skb, H2C_LEN_SCAN_LIST_OFFLOAD);
1860 cmd = skb->data;
1861
1862 RTW89_SET_FWCMD_SCANOFLD_CH_NUM(cmd, len);
1863 /* in unit of 4 bytes */
1864 RTW89_SET_FWCMD_SCANOFLD_CH_SIZE(cmd, RTW89_MAC_CHINFO_SIZE / 4);
1865
1866 list_for_each_entry(ch_info, chan_list, list) {
1867 cmd = skb_put(skb, RTW89_MAC_CHINFO_SIZE);
1868
1869 RTW89_SET_FWCMD_CHINFO_PERIOD(cmd, ch_info->period);
1870 RTW89_SET_FWCMD_CHINFO_DWELL(cmd, ch_info->dwell_time);
1871 RTW89_SET_FWCMD_CHINFO_CENTER_CH(cmd, ch_info->central_ch);
1872 RTW89_SET_FWCMD_CHINFO_PRI_CH(cmd, ch_info->pri_ch);
1873 RTW89_SET_FWCMD_CHINFO_BW(cmd, ch_info->bw);
1874 RTW89_SET_FWCMD_CHINFO_ACTION(cmd, ch_info->notify_action);
1875 RTW89_SET_FWCMD_CHINFO_NUM_PKT(cmd, ch_info->num_pkt);
1876 RTW89_SET_FWCMD_CHINFO_TX(cmd, ch_info->tx_pkt);
1877 RTW89_SET_FWCMD_CHINFO_PAUSE_DATA(cmd, ch_info->pause_data);
1878 RTW89_SET_FWCMD_CHINFO_BAND(cmd, ch_info->ch_band);
1879 RTW89_SET_FWCMD_CHINFO_PKT_ID(cmd, ch_info->probe_id);
1880 RTW89_SET_FWCMD_CHINFO_DFS(cmd, ch_info->dfs_ch);
1881 RTW89_SET_FWCMD_CHINFO_TX_NULL(cmd, ch_info->tx_null);
1882 RTW89_SET_FWCMD_CHINFO_RANDOM(cmd, ch_info->rand_seq_num);
1883 RTW89_SET_FWCMD_CHINFO_PKT0(cmd, ch_info->pkt_id[0]);
1884 RTW89_SET_FWCMD_CHINFO_PKT1(cmd, ch_info->pkt_id[1]);
1885 RTW89_SET_FWCMD_CHINFO_PKT2(cmd, ch_info->pkt_id[2]);
1886 RTW89_SET_FWCMD_CHINFO_PKT3(cmd, ch_info->pkt_id[3]);
1887 RTW89_SET_FWCMD_CHINFO_PKT4(cmd, ch_info->pkt_id[4]);
1888 RTW89_SET_FWCMD_CHINFO_PKT5(cmd, ch_info->pkt_id[5]);
1889 RTW89_SET_FWCMD_CHINFO_PKT6(cmd, ch_info->pkt_id[6]);
1890 RTW89_SET_FWCMD_CHINFO_PKT7(cmd, ch_info->pkt_id[7]);
1891 }
1892
1893 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
1894 H2C_CAT_MAC, H2C_CL_MAC_FW_OFLD,
1895 H2C_FUNC_ADD_SCANOFLD_CH, 1, 1, skb_len);
1896
1897 if (rtw89_h2c_tx(rtwdev, skb, false)) {
1898 rtw89_err(rtwdev, "failed to send h2c\n");
1899 goto fail;
1900 }
1901
1902 return 0;
1903 fail:
1904 dev_kfree_skb_any(skb);
1905
1906 return -EBUSY;
1907 }
1908
1909 #define H2C_LEN_SCAN_OFFLOAD 20
rtw89_fw_h2c_scan_offload(struct rtw89_dev * rtwdev,struct rtw89_scan_option * option,struct rtw89_vif * rtwvif)1910 int rtw89_fw_h2c_scan_offload(struct rtw89_dev *rtwdev,
1911 struct rtw89_scan_option *option,
1912 struct rtw89_vif *rtwvif)
1913 {
1914 struct rtw89_hw_scan_info *scan_info = &rtwdev->scan_info;
1915 struct sk_buff *skb;
1916 u8 *cmd;
1917
1918 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_LEN_SCAN_OFFLOAD);
1919 if (!skb) {
1920 rtw89_err(rtwdev, "failed to alloc skb for h2c scan offload\n");
1921 return -ENOMEM;
1922 }
1923 skb_put(skb, H2C_LEN_SCAN_OFFLOAD);
1924 cmd = skb->data;
1925
1926 RTW89_SET_FWCMD_SCANOFLD_MACID(cmd, rtwvif->mac_id);
1927 RTW89_SET_FWCMD_SCANOFLD_PORT_ID(cmd, rtwvif->port);
1928 RTW89_SET_FWCMD_SCANOFLD_BAND(cmd, RTW89_PHY_0);
1929 RTW89_SET_FWCMD_SCANOFLD_OPERATION(cmd, option->enable);
1930 RTW89_SET_FWCMD_SCANOFLD_NOTIFY_END(cmd, true);
1931 RTW89_SET_FWCMD_SCANOFLD_TARGET_CH_MODE(cmd, option->target_ch_mode);
1932 RTW89_SET_FWCMD_SCANOFLD_START_MODE(cmd, RTW89_SCAN_IMMEDIATE);
1933 RTW89_SET_FWCMD_SCANOFLD_SCAN_TYPE(cmd, RTW89_SCAN_ONCE);
1934 if (option->target_ch_mode) {
1935 RTW89_SET_FWCMD_SCANOFLD_TARGET_CH_BW(cmd, scan_info->op_bw);
1936 RTW89_SET_FWCMD_SCANOFLD_TARGET_PRI_CH(cmd,
1937 scan_info->op_pri_ch);
1938 RTW89_SET_FWCMD_SCANOFLD_TARGET_CENTRAL_CH(cmd,
1939 scan_info->op_chan);
1940 }
1941
1942 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
1943 H2C_CAT_MAC, H2C_CL_MAC_FW_OFLD,
1944 H2C_FUNC_SCANOFLD, 1, 1,
1945 H2C_LEN_SCAN_OFFLOAD);
1946
1947 if (rtw89_h2c_tx(rtwdev, skb, false)) {
1948 rtw89_err(rtwdev, "failed to send h2c\n");
1949 goto fail;
1950 }
1951
1952 return 0;
1953 fail:
1954 dev_kfree_skb_any(skb);
1955
1956 return -EBUSY;
1957 }
1958
rtw89_fw_h2c_rf_reg(struct rtw89_dev * rtwdev,struct rtw89_fw_h2c_rf_reg_info * info,u16 len,u8 page)1959 int rtw89_fw_h2c_rf_reg(struct rtw89_dev *rtwdev,
1960 struct rtw89_fw_h2c_rf_reg_info *info,
1961 u16 len, u8 page)
1962 {
1963 struct sk_buff *skb;
1964 u8 class = info->rf_path == RF_PATH_A ?
1965 H2C_CL_OUTSRC_RF_REG_A : H2C_CL_OUTSRC_RF_REG_B;
1966
1967 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, len);
1968 if (!skb) {
1969 rtw89_err(rtwdev, "failed to alloc skb for h2c rf reg\n");
1970 return -ENOMEM;
1971 }
1972 skb_put_data(skb, info->rtw89_phy_config_rf_h2c[page], len);
1973
1974 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
1975 H2C_CAT_OUTSRC, class, page, 0, 0,
1976 len);
1977
1978 if (rtw89_h2c_tx(rtwdev, skb, false)) {
1979 rtw89_err(rtwdev, "failed to send h2c\n");
1980 goto fail;
1981 }
1982
1983 return 0;
1984 fail:
1985 dev_kfree_skb_any(skb);
1986
1987 return -EBUSY;
1988 }
1989
rtw89_fw_h2c_rf_ntfy_mcc(struct rtw89_dev * rtwdev)1990 int rtw89_fw_h2c_rf_ntfy_mcc(struct rtw89_dev *rtwdev)
1991 {
1992 const struct rtw89_chan *chan = rtw89_chan_get(rtwdev, RTW89_SUB_ENTITY_0);
1993 struct rtw89_mcc_info *mcc_info = &rtwdev->mcc;
1994 struct rtw89_fw_h2c_rf_get_mccch *mccch;
1995 struct sk_buff *skb;
1996
1997 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, sizeof(*mccch));
1998 if (!skb) {
1999 rtw89_err(rtwdev, "failed to alloc skb for h2c cxdrv_ctrl\n");
2000 return -ENOMEM;
2001 }
2002 skb_put(skb, sizeof(*mccch));
2003 mccch = (struct rtw89_fw_h2c_rf_get_mccch *)skb->data;
2004
2005 mccch->ch_0 = cpu_to_le32(mcc_info->ch[0]);
2006 mccch->ch_1 = cpu_to_le32(mcc_info->ch[1]);
2007 mccch->band_0 = cpu_to_le32(mcc_info->band[0]);
2008 mccch->band_1 = cpu_to_le32(mcc_info->band[1]);
2009 mccch->current_channel = cpu_to_le32(chan->channel);
2010 mccch->current_band_type = cpu_to_le32(chan->band_type);
2011
2012 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
2013 H2C_CAT_OUTSRC, H2C_CL_OUTSRC_RF_FW_NOTIFY,
2014 H2C_FUNC_OUTSRC_RF_GET_MCCCH, 0, 0,
2015 sizeof(*mccch));
2016
2017 if (rtw89_h2c_tx(rtwdev, skb, false)) {
2018 rtw89_err(rtwdev, "failed to send h2c\n");
2019 goto fail;
2020 }
2021
2022 return 0;
2023 fail:
2024 dev_kfree_skb_any(skb);
2025
2026 return -EBUSY;
2027 }
2028 EXPORT_SYMBOL(rtw89_fw_h2c_rf_ntfy_mcc);
2029
rtw89_fw_h2c_raw_with_hdr(struct rtw89_dev * rtwdev,u8 h2c_class,u8 h2c_func,u8 * buf,u16 len,bool rack,bool dack)2030 int rtw89_fw_h2c_raw_with_hdr(struct rtw89_dev *rtwdev,
2031 u8 h2c_class, u8 h2c_func, u8 *buf, u16 len,
2032 bool rack, bool dack)
2033 {
2034 struct sk_buff *skb;
2035
2036 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, len);
2037 if (!skb) {
2038 rtw89_err(rtwdev, "failed to alloc skb for raw with hdr\n");
2039 return -ENOMEM;
2040 }
2041 skb_put_data(skb, buf, len);
2042
2043 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
2044 H2C_CAT_OUTSRC, h2c_class, h2c_func, rack, dack,
2045 len);
2046
2047 if (rtw89_h2c_tx(rtwdev, skb, false)) {
2048 rtw89_err(rtwdev, "failed to send h2c\n");
2049 goto fail;
2050 }
2051
2052 return 0;
2053 fail:
2054 dev_kfree_skb_any(skb);
2055
2056 return -EBUSY;
2057 }
2058
rtw89_fw_h2c_raw(struct rtw89_dev * rtwdev,const u8 * buf,u16 len)2059 int rtw89_fw_h2c_raw(struct rtw89_dev *rtwdev, const u8 *buf, u16 len)
2060 {
2061 struct sk_buff *skb;
2062
2063 skb = rtw89_fw_h2c_alloc_skb_no_hdr(rtwdev, len);
2064 if (!skb) {
2065 rtw89_err(rtwdev, "failed to alloc skb for h2c raw\n");
2066 return -ENOMEM;
2067 }
2068 skb_put_data(skb, buf, len);
2069
2070 if (rtw89_h2c_tx(rtwdev, skb, false)) {
2071 rtw89_err(rtwdev, "failed to send h2c\n");
2072 goto fail;
2073 }
2074
2075 return 0;
2076 fail:
2077 dev_kfree_skb_any(skb);
2078
2079 return -EBUSY;
2080 }
2081
rtw89_fw_send_all_early_h2c(struct rtw89_dev * rtwdev)2082 void rtw89_fw_send_all_early_h2c(struct rtw89_dev *rtwdev)
2083 {
2084 struct rtw89_early_h2c *early_h2c;
2085
2086 lockdep_assert_held(&rtwdev->mutex);
2087
2088 list_for_each_entry(early_h2c, &rtwdev->early_h2c_list, list) {
2089 rtw89_fw_h2c_raw(rtwdev, early_h2c->h2c, early_h2c->h2c_len);
2090 }
2091 }
2092
rtw89_fw_free_all_early_h2c(struct rtw89_dev * rtwdev)2093 void rtw89_fw_free_all_early_h2c(struct rtw89_dev *rtwdev)
2094 {
2095 struct rtw89_early_h2c *early_h2c, *tmp;
2096
2097 mutex_lock(&rtwdev->mutex);
2098 list_for_each_entry_safe(early_h2c, tmp, &rtwdev->early_h2c_list, list) {
2099 list_del(&early_h2c->list);
2100 kfree(early_h2c->h2c);
2101 kfree(early_h2c);
2102 }
2103 mutex_unlock(&rtwdev->mutex);
2104 }
2105
rtw89_fw_c2h_irqsafe(struct rtw89_dev * rtwdev,struct sk_buff * c2h)2106 void rtw89_fw_c2h_irqsafe(struct rtw89_dev *rtwdev, struct sk_buff *c2h)
2107 {
2108 skb_queue_tail(&rtwdev->c2h_queue, c2h);
2109 ieee80211_queue_work(rtwdev->hw, &rtwdev->c2h_work);
2110 }
2111
rtw89_fw_c2h_cmd_handle(struct rtw89_dev * rtwdev,struct sk_buff * skb)2112 static void rtw89_fw_c2h_cmd_handle(struct rtw89_dev *rtwdev,
2113 struct sk_buff *skb)
2114 {
2115 u8 category = RTW89_GET_C2H_CATEGORY(skb->data);
2116 u8 class = RTW89_GET_C2H_CLASS(skb->data);
2117 u8 func = RTW89_GET_C2H_FUNC(skb->data);
2118 u16 len = RTW89_GET_C2H_LEN(skb->data);
2119 bool dump = true;
2120
2121 if (!test_bit(RTW89_FLAG_RUNNING, rtwdev->flags))
2122 return;
2123
2124 switch (category) {
2125 case RTW89_C2H_CAT_TEST:
2126 break;
2127 case RTW89_C2H_CAT_MAC:
2128 rtw89_mac_c2h_handle(rtwdev, skb, len, class, func);
2129 if (class == RTW89_MAC_C2H_CLASS_INFO &&
2130 func == RTW89_MAC_C2H_FUNC_C2H_LOG)
2131 dump = false;
2132 break;
2133 case RTW89_C2H_CAT_OUTSRC:
2134 if (class >= RTW89_PHY_C2H_CLASS_BTC_MIN &&
2135 class <= RTW89_PHY_C2H_CLASS_BTC_MAX)
2136 rtw89_btc_c2h_handle(rtwdev, skb, len, class, func);
2137 else
2138 rtw89_phy_c2h_handle(rtwdev, skb, len, class, func);
2139 break;
2140 }
2141
2142 if (dump)
2143 rtw89_hex_dump(rtwdev, RTW89_DBG_FW, "C2H: ", skb->data, skb->len);
2144 }
2145
rtw89_fw_c2h_work(struct work_struct * work)2146 void rtw89_fw_c2h_work(struct work_struct *work)
2147 {
2148 struct rtw89_dev *rtwdev = container_of(work, struct rtw89_dev,
2149 c2h_work);
2150 struct sk_buff *skb, *tmp;
2151
2152 skb_queue_walk_safe(&rtwdev->c2h_queue, skb, tmp) {
2153 skb_unlink(skb, &rtwdev->c2h_queue);
2154 mutex_lock(&rtwdev->mutex);
2155 rtw89_fw_c2h_cmd_handle(rtwdev, skb);
2156 mutex_unlock(&rtwdev->mutex);
2157 dev_kfree_skb_any(skb);
2158 }
2159 }
2160
rtw89_fw_write_h2c_reg(struct rtw89_dev * rtwdev,struct rtw89_mac_h2c_info * info)2161 static int rtw89_fw_write_h2c_reg(struct rtw89_dev *rtwdev,
2162 struct rtw89_mac_h2c_info *info)
2163 {
2164 const struct rtw89_chip_info *chip = rtwdev->chip;
2165 const u32 *h2c_reg = chip->h2c_regs;
2166 u8 i, val, len;
2167 int ret;
2168
2169 ret = read_poll_timeout(rtw89_read8, val, val == 0, 1000, 5000, false,
2170 rtwdev, chip->h2c_ctrl_reg);
2171 if (ret) {
2172 rtw89_warn(rtwdev, "FW does not process h2c registers\n");
2173 return ret;
2174 }
2175
2176 len = DIV_ROUND_UP(info->content_len + RTW89_H2CREG_HDR_LEN,
2177 sizeof(info->h2creg[0]));
2178
2179 RTW89_SET_H2CREG_HDR_FUNC(&info->h2creg[0], info->id);
2180 RTW89_SET_H2CREG_HDR_LEN(&info->h2creg[0], len);
2181 for (i = 0; i < RTW89_H2CREG_MAX; i++)
2182 rtw89_write32(rtwdev, h2c_reg[i], info->h2creg[i]);
2183
2184 rtw89_write8(rtwdev, chip->h2c_ctrl_reg, B_AX_H2CREG_TRIGGER);
2185
2186 return 0;
2187 }
2188
rtw89_fw_read_c2h_reg(struct rtw89_dev * rtwdev,struct rtw89_mac_c2h_info * info)2189 static int rtw89_fw_read_c2h_reg(struct rtw89_dev *rtwdev,
2190 struct rtw89_mac_c2h_info *info)
2191 {
2192 const struct rtw89_chip_info *chip = rtwdev->chip;
2193 const u32 *c2h_reg = chip->c2h_regs;
2194 u32 ret;
2195 u8 i, val;
2196
2197 info->id = RTW89_FWCMD_C2HREG_FUNC_NULL;
2198
2199 ret = read_poll_timeout_atomic(rtw89_read8, val, val, 1,
2200 RTW89_C2H_TIMEOUT, false, rtwdev,
2201 chip->c2h_ctrl_reg);
2202 if (ret) {
2203 rtw89_warn(rtwdev, "c2h reg timeout\n");
2204 return ret;
2205 }
2206
2207 for (i = 0; i < RTW89_C2HREG_MAX; i++)
2208 info->c2hreg[i] = rtw89_read32(rtwdev, c2h_reg[i]);
2209
2210 rtw89_write8(rtwdev, chip->c2h_ctrl_reg, 0);
2211
2212 info->id = RTW89_GET_C2H_HDR_FUNC(*info->c2hreg);
2213 info->content_len = (RTW89_GET_C2H_HDR_LEN(*info->c2hreg) << 2) -
2214 RTW89_C2HREG_HDR_LEN;
2215
2216 return 0;
2217 }
2218
rtw89_fw_msg_reg(struct rtw89_dev * rtwdev,struct rtw89_mac_h2c_info * h2c_info,struct rtw89_mac_c2h_info * c2h_info)2219 int rtw89_fw_msg_reg(struct rtw89_dev *rtwdev,
2220 struct rtw89_mac_h2c_info *h2c_info,
2221 struct rtw89_mac_c2h_info *c2h_info)
2222 {
2223 u32 ret;
2224
2225 if (h2c_info && h2c_info->id != RTW89_FWCMD_H2CREG_FUNC_GET_FEATURE)
2226 lockdep_assert_held(&rtwdev->mutex);
2227
2228 if (!h2c_info && !c2h_info)
2229 return -EINVAL;
2230
2231 if (!h2c_info)
2232 goto recv_c2h;
2233
2234 ret = rtw89_fw_write_h2c_reg(rtwdev, h2c_info);
2235 if (ret)
2236 return ret;
2237
2238 recv_c2h:
2239 if (!c2h_info)
2240 return 0;
2241
2242 ret = rtw89_fw_read_c2h_reg(rtwdev, c2h_info);
2243 if (ret)
2244 return ret;
2245
2246 return 0;
2247 }
2248
rtw89_fw_st_dbg_dump(struct rtw89_dev * rtwdev)2249 void rtw89_fw_st_dbg_dump(struct rtw89_dev *rtwdev)
2250 {
2251 if (!test_bit(RTW89_FLAG_POWERON, rtwdev->flags)) {
2252 rtw89_err(rtwdev, "[ERR]pwr is off\n");
2253 return;
2254 }
2255
2256 rtw89_info(rtwdev, "FW status = 0x%x\n", rtw89_read32(rtwdev, R_AX_UDM0));
2257 rtw89_info(rtwdev, "FW BADADDR = 0x%x\n", rtw89_read32(rtwdev, R_AX_UDM1));
2258 rtw89_info(rtwdev, "FW EPC/RA = 0x%x\n", rtw89_read32(rtwdev, R_AX_UDM2));
2259 rtw89_info(rtwdev, "FW MISC = 0x%x\n", rtw89_read32(rtwdev, R_AX_UDM3));
2260 rtw89_info(rtwdev, "R_AX_HALT_C2H = 0x%x\n",
2261 rtw89_read32(rtwdev, R_AX_HALT_C2H));
2262 rtw89_info(rtwdev, "R_AX_SER_DBG_INFO = 0x%x\n",
2263 rtw89_read32(rtwdev, R_AX_SER_DBG_INFO));
2264
2265 rtw89_fw_prog_cnt_dump(rtwdev);
2266 }
2267
rtw89_release_pkt_list(struct rtw89_dev * rtwdev)2268 static void rtw89_release_pkt_list(struct rtw89_dev *rtwdev)
2269 {
2270 struct list_head *pkt_list = rtwdev->scan_info.pkt_list;
2271 struct rtw89_pktofld_info *info, *tmp;
2272 u8 idx;
2273
2274 for (idx = NL80211_BAND_2GHZ; idx < NUM_NL80211_BANDS; idx++) {
2275 if (!(rtwdev->chip->support_bands & BIT(idx)))
2276 continue;
2277
2278 list_for_each_entry_safe(info, tmp, &pkt_list[idx], list) {
2279 rtw89_fw_h2c_del_pkt_offload(rtwdev, info->id);
2280 rtw89_core_release_bit_map(rtwdev->pkt_offload,
2281 info->id);
2282 list_del(&info->list);
2283 kfree(info);
2284 }
2285 }
2286 }
2287
rtw89_append_probe_req_ie(struct rtw89_dev * rtwdev,struct rtw89_vif * rtwvif,struct sk_buff * skb)2288 static int rtw89_append_probe_req_ie(struct rtw89_dev *rtwdev,
2289 struct rtw89_vif *rtwvif,
2290 struct sk_buff *skb)
2291 {
2292 struct rtw89_hw_scan_info *scan_info = &rtwdev->scan_info;
2293 struct ieee80211_scan_ies *ies = rtwvif->scan_ies;
2294 struct rtw89_pktofld_info *info;
2295 struct sk_buff *new;
2296 int ret = 0;
2297 u8 band;
2298
2299 for (band = NL80211_BAND_2GHZ; band < NUM_NL80211_BANDS; band++) {
2300 if (!(rtwdev->chip->support_bands & BIT(band)))
2301 continue;
2302
2303 new = skb_copy(skb, GFP_KERNEL);
2304 if (!new) {
2305 ret = -ENOMEM;
2306 goto out;
2307 }
2308 skb_put_data(new, ies->ies[band], ies->len[band]);
2309 skb_put_data(new, ies->common_ies, ies->common_ie_len);
2310
2311 info = kzalloc(sizeof(*info), GFP_KERNEL);
2312 if (!info) {
2313 ret = -ENOMEM;
2314 kfree_skb(new);
2315 goto out;
2316 }
2317
2318 list_add_tail(&info->list, &scan_info->pkt_list[band]);
2319 ret = rtw89_fw_h2c_add_pkt_offload(rtwdev, &info->id, new);
2320 if (ret)
2321 goto out;
2322
2323 kfree_skb(new);
2324 }
2325 out:
2326 return ret;
2327 }
2328
rtw89_hw_scan_update_probe_req(struct rtw89_dev * rtwdev,struct rtw89_vif * rtwvif)2329 static int rtw89_hw_scan_update_probe_req(struct rtw89_dev *rtwdev,
2330 struct rtw89_vif *rtwvif)
2331 {
2332 struct cfg80211_scan_request *req = rtwvif->scan_req;
2333 struct sk_buff *skb;
2334 u8 num = req->n_ssids, i;
2335 int ret;
2336
2337 for (i = 0; i < num; i++) {
2338 skb = ieee80211_probereq_get(rtwdev->hw, rtwvif->mac_addr,
2339 req->ssids[i].ssid,
2340 req->ssids[i].ssid_len,
2341 req->ie_len);
2342 if (!skb)
2343 return -ENOMEM;
2344
2345 ret = rtw89_append_probe_req_ie(rtwdev, rtwvif, skb);
2346 kfree_skb(skb);
2347
2348 if (ret)
2349 return ret;
2350 }
2351
2352 return 0;
2353 }
2354
rtw89_hw_scan_add_chan(struct rtw89_dev * rtwdev,int chan_type,int ssid_num,struct rtw89_mac_chinfo * ch_info)2355 static void rtw89_hw_scan_add_chan(struct rtw89_dev *rtwdev, int chan_type,
2356 int ssid_num,
2357 struct rtw89_mac_chinfo *ch_info)
2358 {
2359 struct rtw89_hw_scan_info *scan_info = &rtwdev->scan_info;
2360 struct rtw89_pktofld_info *info;
2361 u8 band, probe_count = 0;
2362
2363 ch_info->notify_action = RTW89_SCANOFLD_DEBUG_MASK;
2364 ch_info->dfs_ch = chan_type == RTW89_CHAN_DFS;
2365 ch_info->bw = RTW89_SCAN_WIDTH;
2366 ch_info->tx_pkt = true;
2367 ch_info->cfg_tx_pwr = false;
2368 ch_info->tx_pwr_idx = 0;
2369 ch_info->tx_null = false;
2370 ch_info->pause_data = false;
2371
2372 if (ssid_num) {
2373 ch_info->num_pkt = ssid_num;
2374 band = ch_info->ch_band;
2375
2376 list_for_each_entry(info, &scan_info->pkt_list[band], list) {
2377 ch_info->probe_id = info->id;
2378 ch_info->pkt_id[probe_count] = info->id;
2379 if (++probe_count >= ssid_num)
2380 break;
2381 }
2382 if (probe_count != ssid_num)
2383 rtw89_err(rtwdev, "SSID num differs from list len\n");
2384 }
2385
2386 switch (chan_type) {
2387 case RTW89_CHAN_OPERATE:
2388 ch_info->probe_id = RTW89_SCANOFLD_PKT_NONE;
2389 ch_info->central_ch = scan_info->op_chan;
2390 ch_info->pri_ch = scan_info->op_pri_ch;
2391 ch_info->ch_band = scan_info->op_band;
2392 ch_info->bw = scan_info->op_bw;
2393 ch_info->tx_null = true;
2394 ch_info->num_pkt = 0;
2395 break;
2396 case RTW89_CHAN_DFS:
2397 ch_info->period = max_t(u8, ch_info->period,
2398 RTW89_DFS_CHAN_TIME);
2399 ch_info->dwell_time = RTW89_DWELL_TIME;
2400 break;
2401 case RTW89_CHAN_ACTIVE:
2402 break;
2403 default:
2404 rtw89_err(rtwdev, "Channel type out of bound\n");
2405 }
2406 }
2407
rtw89_hw_scan_add_chan_list(struct rtw89_dev * rtwdev,struct rtw89_vif * rtwvif)2408 static int rtw89_hw_scan_add_chan_list(struct rtw89_dev *rtwdev,
2409 struct rtw89_vif *rtwvif)
2410 {
2411 struct cfg80211_scan_request *req = rtwvif->scan_req;
2412 struct rtw89_mac_chinfo *ch_info, *tmp;
2413 struct ieee80211_channel *channel;
2414 struct list_head chan_list;
2415 bool random_seq = req->flags & NL80211_SCAN_FLAG_RANDOM_SN;
2416 int list_len = req->n_channels, off_chan_time = 0;
2417 enum rtw89_chan_type type;
2418 int ret = 0, i;
2419
2420 INIT_LIST_HEAD(&chan_list);
2421 for (i = 0; i < req->n_channels; i++) {
2422 channel = req->channels[i];
2423 ch_info = kzalloc(sizeof(*ch_info), GFP_KERNEL);
2424 if (!ch_info) {
2425 ret = -ENOMEM;
2426 goto out;
2427 }
2428
2429 ch_info->period = req->duration_mandatory ?
2430 req->duration : RTW89_CHANNEL_TIME;
2431 ch_info->ch_band = channel->band;
2432 ch_info->central_ch = channel->hw_value;
2433 ch_info->pri_ch = channel->hw_value;
2434 ch_info->rand_seq_num = random_seq;
2435
2436 if (channel->flags &
2437 (IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IR))
2438 type = RTW89_CHAN_DFS;
2439 else
2440 type = RTW89_CHAN_ACTIVE;
2441 rtw89_hw_scan_add_chan(rtwdev, type, req->n_ssids, ch_info);
2442
2443 if (rtwvif->net_type != RTW89_NET_TYPE_NO_LINK &&
2444 off_chan_time + ch_info->period > RTW89_OFF_CHAN_TIME) {
2445 tmp = kzalloc(sizeof(*tmp), GFP_KERNEL);
2446 if (!tmp) {
2447 ret = -ENOMEM;
2448 kfree(ch_info);
2449 goto out;
2450 }
2451
2452 type = RTW89_CHAN_OPERATE;
2453 tmp->period = req->duration_mandatory ?
2454 req->duration : RTW89_CHANNEL_TIME;
2455 rtw89_hw_scan_add_chan(rtwdev, type, 0, tmp);
2456 list_add_tail(&tmp->list, &chan_list);
2457 off_chan_time = 0;
2458 list_len++;
2459 }
2460 list_add_tail(&ch_info->list, &chan_list);
2461 off_chan_time += ch_info->period;
2462 }
2463 ret = rtw89_fw_h2c_scan_list_offload(rtwdev, list_len, &chan_list);
2464
2465 out:
2466 list_for_each_entry_safe(ch_info, tmp, &chan_list, list) {
2467 list_del(&ch_info->list);
2468 kfree(ch_info);
2469 }
2470
2471 return ret;
2472 }
2473
rtw89_hw_scan_prehandle(struct rtw89_dev * rtwdev,struct rtw89_vif * rtwvif)2474 static int rtw89_hw_scan_prehandle(struct rtw89_dev *rtwdev,
2475 struct rtw89_vif *rtwvif)
2476 {
2477 int ret;
2478
2479 ret = rtw89_hw_scan_update_probe_req(rtwdev, rtwvif);
2480 if (ret) {
2481 #if defined(__linux__)
2482 rtw89_err(rtwdev, "Update probe request failed\n");
2483 #elif defined(__FreeBSD__)
2484 rtw89_err(rtwdev, "Update probe request failed: ret %d\n", ret);
2485 #endif
2486 goto out;
2487 }
2488 ret = rtw89_hw_scan_add_chan_list(rtwdev, rtwvif);
2489 out:
2490 return ret;
2491 }
2492
rtw89_hw_scan_start(struct rtw89_dev * rtwdev,struct ieee80211_vif * vif,struct ieee80211_scan_request * scan_req)2493 void rtw89_hw_scan_start(struct rtw89_dev *rtwdev, struct ieee80211_vif *vif,
2494 struct ieee80211_scan_request *scan_req)
2495 {
2496 struct rtw89_vif *rtwvif = (struct rtw89_vif *)vif->drv_priv;
2497 struct cfg80211_scan_request *req = &scan_req->req;
2498 u8 mac_addr[ETH_ALEN];
2499
2500 rtwdev->scan_info.scanning_vif = vif;
2501 rtwvif->scan_ies = &scan_req->ies;
2502 rtwvif->scan_req = req;
2503 ieee80211_stop_queues(rtwdev->hw);
2504
2505 if (req->flags & NL80211_SCAN_FLAG_RANDOM_ADDR)
2506 get_random_mask_addr(mac_addr, req->mac_addr,
2507 req->mac_addr_mask);
2508 else
2509 ether_addr_copy(mac_addr, vif->addr);
2510 rtw89_core_scan_start(rtwdev, rtwvif, mac_addr, true);
2511
2512 rtwdev->hal.rx_fltr &= ~B_AX_A_BCN_CHK_EN;
2513 rtwdev->hal.rx_fltr &= ~B_AX_A_BC;
2514 rtwdev->hal.rx_fltr &= ~B_AX_A_A1_MATCH;
2515 rtw89_write32_mask(rtwdev,
2516 rtw89_mac_reg_by_idx(R_AX_RX_FLTR_OPT, RTW89_MAC_0),
2517 B_AX_RX_FLTR_CFG_MASK,
2518 rtwdev->hal.rx_fltr);
2519 }
2520
rtw89_hw_scan_complete(struct rtw89_dev * rtwdev,struct ieee80211_vif * vif,bool aborted)2521 void rtw89_hw_scan_complete(struct rtw89_dev *rtwdev, struct ieee80211_vif *vif,
2522 bool aborted)
2523 {
2524 struct cfg80211_scan_info info = {
2525 .aborted = aborted,
2526 };
2527 struct rtw89_vif *rtwvif;
2528
2529 if (!vif)
2530 return;
2531
2532 rtwdev->hal.rx_fltr |= B_AX_A_BCN_CHK_EN;
2533 rtwdev->hal.rx_fltr |= B_AX_A_BC;
2534 rtwdev->hal.rx_fltr |= B_AX_A_A1_MATCH;
2535 rtw89_write32_mask(rtwdev,
2536 rtw89_mac_reg_by_idx(R_AX_RX_FLTR_OPT, RTW89_MAC_0),
2537 B_AX_RX_FLTR_CFG_MASK,
2538 rtwdev->hal.rx_fltr);
2539
2540 rtw89_core_scan_complete(rtwdev, vif, true);
2541 ieee80211_scan_completed(rtwdev->hw, &info);
2542 ieee80211_wake_queues(rtwdev->hw);
2543
2544 rtw89_release_pkt_list(rtwdev);
2545 rtwvif = (struct rtw89_vif *)vif->drv_priv;
2546 rtwvif->scan_req = NULL;
2547 rtwvif->scan_ies = NULL;
2548 rtwdev->scan_info.scanning_vif = NULL;
2549
2550 if (rtwvif->net_type != RTW89_NET_TYPE_NO_LINK)
2551 rtw89_store_op_chan(rtwdev, false);
2552 }
2553
rtw89_hw_scan_abort(struct rtw89_dev * rtwdev,struct ieee80211_vif * vif)2554 void rtw89_hw_scan_abort(struct rtw89_dev *rtwdev, struct ieee80211_vif *vif)
2555 {
2556 rtw89_hw_scan_offload(rtwdev, vif, false);
2557 rtw89_hw_scan_complete(rtwdev, vif, true);
2558 }
2559
rtw89_hw_scan_offload(struct rtw89_dev * rtwdev,struct ieee80211_vif * vif,bool enable)2560 int rtw89_hw_scan_offload(struct rtw89_dev *rtwdev, struct ieee80211_vif *vif,
2561 bool enable)
2562 {
2563 struct rtw89_scan_option opt = {0};
2564 struct rtw89_vif *rtwvif;
2565 int ret = 0;
2566
2567 rtwvif = vif ? (struct rtw89_vif *)vif->drv_priv : NULL;
2568 if (!rtwvif)
2569 return -EINVAL;
2570
2571 opt.enable = enable;
2572 opt.target_ch_mode = rtwvif->net_type != RTW89_NET_TYPE_NO_LINK;
2573 if (enable) {
2574 ret = rtw89_hw_scan_prehandle(rtwdev, rtwvif);
2575 if (ret)
2576 goto out;
2577 }
2578 ret = rtw89_fw_h2c_scan_offload(rtwdev, &opt, rtwvif);
2579 out:
2580 return ret;
2581 }
2582
rtw89_store_op_chan(struct rtw89_dev * rtwdev,bool backup)2583 void rtw89_store_op_chan(struct rtw89_dev *rtwdev, bool backup)
2584 {
2585 struct rtw89_hw_scan_info *scan_info = &rtwdev->scan_info;
2586 const struct rtw89_chan *cur = rtw89_chan_get(rtwdev, RTW89_SUB_ENTITY_0);
2587 struct rtw89_chan new;
2588
2589 if (backup) {
2590 scan_info->op_pri_ch = cur->primary_channel;
2591 scan_info->op_chan = cur->channel;
2592 scan_info->op_bw = cur->band_width;
2593 scan_info->op_band = cur->band_type;
2594 } else {
2595 rtw89_chan_create(&new, scan_info->op_chan, scan_info->op_pri_ch,
2596 scan_info->op_band, scan_info->op_bw);
2597 rtw89_assign_entity_chan(rtwdev, RTW89_SUB_ENTITY_0, &new);
2598 }
2599 }
2600
2601 #define H2C_FW_CPU_EXCEPTION_LEN 4
2602 #define H2C_FW_CPU_EXCEPTION_TYPE_DEF 0x5566
rtw89_fw_h2c_trigger_cpu_exception(struct rtw89_dev * rtwdev)2603 int rtw89_fw_h2c_trigger_cpu_exception(struct rtw89_dev *rtwdev)
2604 {
2605 struct sk_buff *skb;
2606
2607 skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, H2C_FW_CPU_EXCEPTION_LEN);
2608 if (!skb) {
2609 rtw89_err(rtwdev,
2610 "failed to alloc skb for fw cpu exception\n");
2611 return -ENOMEM;
2612 }
2613
2614 skb_put(skb, H2C_FW_CPU_EXCEPTION_LEN);
2615 RTW89_SET_FWCMD_CPU_EXCEPTION_TYPE(skb->data,
2616 H2C_FW_CPU_EXCEPTION_TYPE_DEF);
2617
2618 rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
2619 H2C_CAT_TEST,
2620 H2C_CL_FW_STATUS_TEST,
2621 H2C_FUNC_CPU_EXCEPTION, 0, 0,
2622 H2C_FW_CPU_EXCEPTION_LEN);
2623
2624 if (rtw89_h2c_tx(rtwdev, skb, false)) {
2625 rtw89_err(rtwdev, "failed to send h2c\n");
2626 goto fail;
2627 }
2628
2629 return 0;
2630
2631 fail:
2632 dev_kfree_skb_any(skb);
2633 return -EBUSY;
2634 }
2635