?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / drivers / net / wireless / realtek / rtw88 / fw.c
blob243441453eade4db348110597fe00bf66159eba7
1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
2 /* Copyright(c) 2018-2019 Realtek Corporation
3 */
4
5 #include "main.h"
6 #include "coex.h"
7 #include "fw.h"
8 #include "tx.h"
9 #include "reg.h"
10 #include "sec.h"
11 #include "debug.h"
12 #include "util.h"
13 #include "wow.h"
14
15 static void rtw_fw_c2h_cmd_handle_ext(struct rtw_dev *rtwdev,
16 struct sk_buff *skb)
17 {
18 struct rtw_c2h_cmd *c2h;
19 u8 sub_cmd_id;
20
21 c2h = get_c2h_from_skb(skb);
22 sub_cmd_id = c2h->payload[0];
23
24 switch (sub_cmd_id) {
25 case C2H_CCX_RPT:
26 rtw_tx_report_handle(rtwdev, skb);
27 break;
28 default:
29 break;
30 }
31 }
32
33 static u16 get_max_amsdu_len(u32 bit_rate)
34 {
35 /* lower than ofdm, do not aggregate */
36 if (bit_rate < 550)
37 return 1;
38
39 /* lower than 20M 2ss mcs8, make it small */
40 if (bit_rate < 1800)
41 return 1200;
42
43 /* lower than 40M 2ss mcs9, make it medium */
44 if (bit_rate < 4000)
45 return 2600;
46
47 /* not yet 80M 2ss mcs8/9, make it twice regular packet size */
48 if (bit_rate < 7000)
49 return 3500;
50
51 /* unlimited */
52 return 0;
53 }
54
55 struct rtw_fw_iter_ra_data {
56 struct rtw_dev *rtwdev;
57 u8 *payload;
58 };
59
60 static void rtw_fw_ra_report_iter(void *data, struct ieee80211_sta *sta)
61 {
62 struct rtw_fw_iter_ra_data *ra_data = data;
63 struct rtw_sta_info *si = (struct rtw_sta_info *)sta->drv_priv;
64 u8 mac_id, rate, sgi, bw;
65 u8 mcs, nss;
66 u32 bit_rate;
67
68 mac_id = GET_RA_REPORT_MACID(ra_data->payload);
69 if (si->mac_id != mac_id)
70 return;
71
72 si->ra_report.txrate.flags = 0;
73
74 rate = GET_RA_REPORT_RATE(ra_data->payload);
75 sgi = GET_RA_REPORT_SGI(ra_data->payload);
76 bw = GET_RA_REPORT_BW(ra_data->payload);
77
78 if (rate < DESC_RATEMCS0) {
79 si->ra_report.txrate.legacy = rtw_desc_to_bitrate(rate);
80 goto legacy;
81 }
82
83 rtw_desc_to_mcsrate(rate, &mcs, &nss);
84 if (rate >= DESC_RATEVHT1SS_MCS0)
85 si->ra_report.txrate.flags |= RATE_INFO_FLAGS_VHT_MCS;
86 else if (rate >= DESC_RATEMCS0)
87 si->ra_report.txrate.flags |= RATE_INFO_FLAGS_MCS;
88
89 if (rate >= DESC_RATEMCS0) {
90 si->ra_report.txrate.mcs = mcs;
91 si->ra_report.txrate.nss = nss;
92 }
93
94 if (sgi)
95 si->ra_report.txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
96
97 if (bw == RTW_CHANNEL_WIDTH_80)
98 si->ra_report.txrate.bw = RATE_INFO_BW_80;
99 else if (bw == RTW_CHANNEL_WIDTH_40)
100 si->ra_report.txrate.bw = RATE_INFO_BW_40;
101 else
102 si->ra_report.txrate.bw = RATE_INFO_BW_20;
103
104 legacy:
105 bit_rate = cfg80211_calculate_bitrate(&si->ra_report.txrate);
106
107 si->ra_report.desc_rate = rate;
108 si->ra_report.bit_rate = bit_rate;
109
110 sta->max_rc_amsdu_len = get_max_amsdu_len(bit_rate);
111 }
112
113 static void rtw_fw_ra_report_handle(struct rtw_dev *rtwdev, u8 *payload,
114 u8 length)
115 {
116 struct rtw_fw_iter_ra_data ra_data;
117
118 if (WARN(length < 7, "invalid ra report c2h length\n"))
119 return;
120
121 rtwdev->dm_info.tx_rate = GET_RA_REPORT_RATE(payload);
122 ra_data.rtwdev = rtwdev;
123 ra_data.payload = payload;
124 rtw_iterate_stas_atomic(rtwdev, rtw_fw_ra_report_iter, &ra_data);
125 }
126
127 void rtw_fw_c2h_cmd_handle(struct rtw_dev *rtwdev, struct sk_buff *skb)
128 {
129 struct rtw_c2h_cmd *c2h;
130 u32 pkt_offset;
131 u8 len;
132
133 pkt_offset = *((u32 *)skb->cb);
134 c2h = (struct rtw_c2h_cmd *)(skb->data + pkt_offset);
135 len = skb->len - pkt_offset - 2;
136
137 mutex_lock(&rtwdev->mutex);
138
139 switch (c2h->id) {
140 case C2H_BT_INFO:
141 rtw_coex_bt_info_notify(rtwdev, c2h->payload, len);
142 break;
143 case C2H_WLAN_INFO:
144 rtw_coex_wl_fwdbginfo_notify(rtwdev, c2h->payload, len);
145 break;
146 case C2H_HALMAC:
147 rtw_fw_c2h_cmd_handle_ext(rtwdev, skb);
148 break;
149 case C2H_RA_RPT:
150 rtw_fw_ra_report_handle(rtwdev, c2h->payload, len);
151 break;
152 default:
153 break;
154 }
155
156 mutex_unlock(&rtwdev->mutex);
157 }
158
159 void rtw_fw_c2h_cmd_rx_irqsafe(struct rtw_dev *rtwdev, u32 pkt_offset,
160 struct sk_buff *skb)
161 {
162 struct rtw_c2h_cmd *c2h;
163 u8 len;
164
165 c2h = (struct rtw_c2h_cmd *)(skb->data + pkt_offset);
166 len = skb->len - pkt_offset - 2;
167 *((u32 *)skb->cb) = pkt_offset;
168
169 rtw_dbg(rtwdev, RTW_DBG_FW, "recv C2H, id=0x%02x, seq=0x%02x, len=%d\n",
170 c2h->id, c2h->seq, len);
171
172 switch (c2h->id) {
173 case C2H_BT_MP_INFO:
174 rtw_coex_info_response(rtwdev, skb);
175 break;
176 default:
177 /* pass offset for further operation */
178 *((u32 *)skb->cb) = pkt_offset;
179 skb_queue_tail(&rtwdev->c2h_queue, skb);
180 ieee80211_queue_work(rtwdev->hw, &rtwdev->c2h_work);
181 break;
182 }
183 }
184 EXPORT_SYMBOL(rtw_fw_c2h_cmd_rx_irqsafe);
185
186 static void rtw_fw_send_h2c_command(struct rtw_dev *rtwdev,
187 u8 *h2c)
188 {
189 u8 box;
190 u8 box_state;
191 u32 box_reg, box_ex_reg;
192 u32 h2c_wait;
193 int idx;
194
195 rtw_dbg(rtwdev, RTW_DBG_FW,
196 "send H2C content %02x%02x%02x%02x %02x%02x%02x%02x\n",
197 h2c[3], h2c[2], h2c[1], h2c[0],
198 h2c[7], h2c[6], h2c[5], h2c[4]);
199
200 spin_lock(&rtwdev->h2c.lock);
201
202 box = rtwdev->h2c.last_box_num;
203 switch (box) {
204 case 0:
205 box_reg = REG_HMEBOX0;
206 box_ex_reg = REG_HMEBOX0_EX;
207 break;
208 case 1:
209 box_reg = REG_HMEBOX1;
210 box_ex_reg = REG_HMEBOX1_EX;
211 break;
212 case 2:
213 box_reg = REG_HMEBOX2;
214 box_ex_reg = REG_HMEBOX2_EX;
215 break;
216 case 3:
217 box_reg = REG_HMEBOX3;
218 box_ex_reg = REG_HMEBOX3_EX;
219 break;
220 default:
221 WARN(1, "invalid h2c mail box number\n");
222 goto out;
223 }
224
225 h2c_wait = 20;
226 do {
227 box_state = rtw_read8(rtwdev, REG_HMETFR);
228 } while ((box_state >> box) & 0x1 && --h2c_wait > 0);
229
230 if (!h2c_wait) {
231 rtw_err(rtwdev, "failed to send h2c command\n");
232 goto out;
233 }
234
235 for (idx = 0; idx < 4; idx++)
236 rtw_write8(rtwdev, box_reg + idx, h2c[idx]);
237 for (idx = 0; idx < 4; idx++)
238 rtw_write8(rtwdev, box_ex_reg + idx, h2c[idx + 4]);
239
240 if (++rtwdev->h2c.last_box_num >= 4)
241 rtwdev->h2c.last_box_num = 0;
242
243 out:
244 spin_unlock(&rtwdev->h2c.lock);
245 }
246
247 static void rtw_fw_send_h2c_packet(struct rtw_dev *rtwdev, u8 *h2c_pkt)
248 {
249 int ret;
250
251 spin_lock(&rtwdev->h2c.lock);
252
253 FW_OFFLOAD_H2C_SET_SEQ_NUM(h2c_pkt, rtwdev->h2c.seq);
254 ret = rtw_hci_write_data_h2c(rtwdev, h2c_pkt, H2C_PKT_SIZE);
255 if (ret)
256 rtw_err(rtwdev, "failed to send h2c packet\n");
257 rtwdev->h2c.seq++;
258
259 spin_unlock(&rtwdev->h2c.lock);
260 }
261
262 void
263 rtw_fw_send_general_info(struct rtw_dev *rtwdev)
264 {
265 struct rtw_fifo_conf *fifo = &rtwdev->fifo;
266 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
267 u16 total_size = H2C_PKT_HDR_SIZE + 4;
268
269 rtw_h2c_pkt_set_header(h2c_pkt, H2C_PKT_GENERAL_INFO);
270
271 SET_PKT_H2C_TOTAL_LEN(h2c_pkt, total_size);
272
273 GENERAL_INFO_SET_FW_TX_BOUNDARY(h2c_pkt,
274 fifo->rsvd_fw_txbuf_addr -
275 fifo->rsvd_boundary);
276
277 rtw_fw_send_h2c_packet(rtwdev, h2c_pkt);
278 }
279
280 void
281 rtw_fw_send_phydm_info(struct rtw_dev *rtwdev)
282 {
283 struct rtw_hal *hal = &rtwdev->hal;
284 struct rtw_efuse *efuse = &rtwdev->efuse;
285 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
286 u16 total_size = H2C_PKT_HDR_SIZE + 8;
287 u8 fw_rf_type = 0;
288
289 if (hal->rf_type == RF_1T1R)
290 fw_rf_type = FW_RF_1T1R;
291 else if (hal->rf_type == RF_2T2R)
292 fw_rf_type = FW_RF_2T2R;
293
294 rtw_h2c_pkt_set_header(h2c_pkt, H2C_PKT_PHYDM_INFO);
295
296 SET_PKT_H2C_TOTAL_LEN(h2c_pkt, total_size);
297 PHYDM_INFO_SET_REF_TYPE(h2c_pkt, efuse->rfe_option);
298 PHYDM_INFO_SET_RF_TYPE(h2c_pkt, fw_rf_type);
299 PHYDM_INFO_SET_CUT_VER(h2c_pkt, hal->cut_version);
300 PHYDM_INFO_SET_RX_ANT_STATUS(h2c_pkt, hal->antenna_tx);
301 PHYDM_INFO_SET_TX_ANT_STATUS(h2c_pkt, hal->antenna_rx);
302
303 rtw_fw_send_h2c_packet(rtwdev, h2c_pkt);
304 }
305
306 void rtw_fw_do_iqk(struct rtw_dev *rtwdev, struct rtw_iqk_para *para)
307 {
308 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
309 u16 total_size = H2C_PKT_HDR_SIZE + 1;
310
311 rtw_h2c_pkt_set_header(h2c_pkt, H2C_PKT_IQK);
312 SET_PKT_H2C_TOTAL_LEN(h2c_pkt, total_size);
313 IQK_SET_CLEAR(h2c_pkt, para->clear);
314 IQK_SET_SEGMENT_IQK(h2c_pkt, para->segment_iqk);
315
316 rtw_fw_send_h2c_packet(rtwdev, h2c_pkt);
317 }
318
319 void rtw_fw_query_bt_info(struct rtw_dev *rtwdev)
320 {
321 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
322
323 SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_QUERY_BT_INFO);
324
325 SET_QUERY_BT_INFO(h2c_pkt, true);
326
327 rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
328 }
329
330 void rtw_fw_wl_ch_info(struct rtw_dev *rtwdev, u8 link, u8 ch, u8 bw)
331 {
332 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
333
334 SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_WL_CH_INFO);
335
336 SET_WL_CH_INFO_LINK(h2c_pkt, link);
337 SET_WL_CH_INFO_CHNL(h2c_pkt, ch);
338 SET_WL_CH_INFO_BW(h2c_pkt, bw);
339
340 rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
341 }
342
343 void rtw_fw_query_bt_mp_info(struct rtw_dev *rtwdev,
344 struct rtw_coex_info_req *req)
345 {
346 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
347
348 SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_QUERY_BT_MP_INFO);
349
350 SET_BT_MP_INFO_SEQ(h2c_pkt, req->seq);
351 SET_BT_MP_INFO_OP_CODE(h2c_pkt, req->op_code);
352 SET_BT_MP_INFO_PARA1(h2c_pkt, req->para1);
353 SET_BT_MP_INFO_PARA2(h2c_pkt, req->para2);
354 SET_BT_MP_INFO_PARA3(h2c_pkt, req->para3);
355
356 rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
357 }
358
359 void rtw_fw_force_bt_tx_power(struct rtw_dev *rtwdev, u8 bt_pwr_dec_lvl)
360 {
361 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
362 u8 index = 0 - bt_pwr_dec_lvl;
363
364 SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_FORCE_BT_TX_POWER);
365
366 SET_BT_TX_POWER_INDEX(h2c_pkt, index);
367
368 rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
369 }
370
371 void rtw_fw_bt_ignore_wlan_action(struct rtw_dev *rtwdev, bool enable)
372 {
373 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
374
375 SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_IGNORE_WLAN_ACTION);
376
377 SET_IGNORE_WLAN_ACTION_EN(h2c_pkt, enable);
378
379 rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
380 }
381
382 void rtw_fw_coex_tdma_type(struct rtw_dev *rtwdev,
383 u8 para1, u8 para2, u8 para3, u8 para4, u8 para5)
384 {
385 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
386
387 SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_COEX_TDMA_TYPE);
388
389 SET_COEX_TDMA_TYPE_PARA1(h2c_pkt, para1);
390 SET_COEX_TDMA_TYPE_PARA2(h2c_pkt, para2);
391 SET_COEX_TDMA_TYPE_PARA3(h2c_pkt, para3);
392 SET_COEX_TDMA_TYPE_PARA4(h2c_pkt, para4);
393 SET_COEX_TDMA_TYPE_PARA5(h2c_pkt, para5);
394
395 rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
396 }
397
398 void rtw_fw_bt_wifi_control(struct rtw_dev *rtwdev, u8 op_code, u8 *data)
399 {
400 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
401
402 SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_BT_WIFI_CONTROL);
403
404 SET_BT_WIFI_CONTROL_OP_CODE(h2c_pkt, op_code);
405
406 SET_BT_WIFI_CONTROL_DATA1(h2c_pkt, *data);
407 SET_BT_WIFI_CONTROL_DATA2(h2c_pkt, *(data + 1));
408 SET_BT_WIFI_CONTROL_DATA3(h2c_pkt, *(data + 2));
409 SET_BT_WIFI_CONTROL_DATA4(h2c_pkt, *(data + 3));
410 SET_BT_WIFI_CONTROL_DATA5(h2c_pkt, *(data + 4));
411
412 rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
413 }
414
415 void rtw_fw_send_rssi_info(struct rtw_dev *rtwdev, struct rtw_sta_info *si)
416 {
417 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
418 u8 rssi = ewma_rssi_read(&si->avg_rssi);
419 bool stbc_en = si->stbc_en ? true : false;
420
421 SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_RSSI_MONITOR);
422
423 SET_RSSI_INFO_MACID(h2c_pkt, si->mac_id);
424 SET_RSSI_INFO_RSSI(h2c_pkt, rssi);
425 SET_RSSI_INFO_STBC(h2c_pkt, stbc_en);
426
427 rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
428 }
429
430 void rtw_fw_send_ra_info(struct rtw_dev *rtwdev, struct rtw_sta_info *si)
431 {
432 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
433 bool no_update = si->updated;
434 bool disable_pt = true;
435
436 SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_RA_INFO);
437
438 SET_RA_INFO_MACID(h2c_pkt, si->mac_id);
439 SET_RA_INFO_RATE_ID(h2c_pkt, si->rate_id);
440 SET_RA_INFO_INIT_RA_LVL(h2c_pkt, si->init_ra_lv);
441 SET_RA_INFO_SGI_EN(h2c_pkt, si->sgi_enable);
442 SET_RA_INFO_BW_MODE(h2c_pkt, si->bw_mode);
443 SET_RA_INFO_LDPC(h2c_pkt, si->ldpc_en);
444 SET_RA_INFO_NO_UPDATE(h2c_pkt, no_update);
445 SET_RA_INFO_VHT_EN(h2c_pkt, si->vht_enable);
446 SET_RA_INFO_DIS_PT(h2c_pkt, disable_pt);
447 SET_RA_INFO_RA_MASK0(h2c_pkt, (si->ra_mask & 0xff));
448 SET_RA_INFO_RA_MASK1(h2c_pkt, (si->ra_mask & 0xff00) >> 8);
449 SET_RA_INFO_RA_MASK2(h2c_pkt, (si->ra_mask & 0xff0000) >> 16);
450 SET_RA_INFO_RA_MASK3(h2c_pkt, (si->ra_mask & 0xff000000) >> 24);
451
452 si->init_ra_lv = 0;
453 si->updated = true;
454
455 rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
456 }
457
458 void rtw_fw_media_status_report(struct rtw_dev *rtwdev, u8 mac_id, bool connect)
459 {
460 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
461
462 SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_MEDIA_STATUS_RPT);
463 MEDIA_STATUS_RPT_SET_OP_MODE(h2c_pkt, connect);
464 MEDIA_STATUS_RPT_SET_MACID(h2c_pkt, mac_id);
465
466 rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
467 }
468
469 void rtw_fw_set_pwr_mode(struct rtw_dev *rtwdev)
470 {
471 struct rtw_lps_conf *conf = &rtwdev->lps_conf;
472 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
473
474 SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_SET_PWR_MODE);
475
476 SET_PWR_MODE_SET_MODE(h2c_pkt, conf->mode);
477 SET_PWR_MODE_SET_RLBM(h2c_pkt, conf->rlbm);
478 SET_PWR_MODE_SET_SMART_PS(h2c_pkt, conf->smart_ps);
479 SET_PWR_MODE_SET_AWAKE_INTERVAL(h2c_pkt, conf->awake_interval);
480 SET_PWR_MODE_SET_PORT_ID(h2c_pkt, conf->port_id);
481 SET_PWR_MODE_SET_PWR_STATE(h2c_pkt, conf->state);
482
483 rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
484 }
485
486 void rtw_fw_set_keep_alive_cmd(struct rtw_dev *rtwdev, bool enable)
487 {
488 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
489 struct rtw_fw_wow_keep_alive_para mode = {
490 .adopt = true,
491 .pkt_type = KEEP_ALIVE_NULL_PKT,
492 .period = 5,
493 };
494
495 SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_KEEP_ALIVE);
496 SET_KEEP_ALIVE_ENABLE(h2c_pkt, enable);
497 SET_KEEP_ALIVE_ADOPT(h2c_pkt, mode.adopt);
498 SET_KEEP_ALIVE_PKT_TYPE(h2c_pkt, mode.pkt_type);
499 SET_KEEP_ALIVE_CHECK_PERIOD(h2c_pkt, mode.period);
500
501 rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
502 }
503
504 void rtw_fw_set_disconnect_decision_cmd(struct rtw_dev *rtwdev, bool enable)
505 {
506 struct rtw_wow_param *rtw_wow = &rtwdev->wow;
507 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
508 struct rtw_fw_wow_disconnect_para mode = {
509 .adopt = true,
510 .period = 30,
511 .retry_count = 5,
512 };
513
514 SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_DISCONNECT_DECISION);
515
516 if (test_bit(RTW_WOW_FLAG_EN_DISCONNECT, rtw_wow->flags)) {
517 SET_DISCONNECT_DECISION_ENABLE(h2c_pkt, enable);
518 SET_DISCONNECT_DECISION_ADOPT(h2c_pkt, mode.adopt);
519 SET_DISCONNECT_DECISION_CHECK_PERIOD(h2c_pkt, mode.period);
520 SET_DISCONNECT_DECISION_TRY_PKT_NUM(h2c_pkt, mode.retry_count);
521 }
522
523 rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
524 }
525
526 void rtw_fw_set_wowlan_ctrl_cmd(struct rtw_dev *rtwdev, bool enable)
527 {
528 struct rtw_wow_param *rtw_wow = &rtwdev->wow;
529 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
530
531 SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_WOWLAN);
532
533 SET_WOWLAN_FUNC_ENABLE(h2c_pkt, enable);
534 if (rtw_wow_mgd_linked(rtwdev)) {
535 if (test_bit(RTW_WOW_FLAG_EN_MAGIC_PKT, rtw_wow->flags))
536 SET_WOWLAN_MAGIC_PKT_ENABLE(h2c_pkt, enable);
537 if (test_bit(RTW_WOW_FLAG_EN_DISCONNECT, rtw_wow->flags))
538 SET_WOWLAN_DEAUTH_WAKEUP_ENABLE(h2c_pkt, enable);
539 if (test_bit(RTW_WOW_FLAG_EN_REKEY_PKT, rtw_wow->flags))
540 SET_WOWLAN_REKEY_WAKEUP_ENABLE(h2c_pkt, enable);
541 if (rtw_wow->pattern_cnt)
542 SET_WOWLAN_PATTERN_MATCH_ENABLE(h2c_pkt, enable);
543 }
544
545 rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
546 }
547
548 void rtw_fw_set_aoac_global_info_cmd(struct rtw_dev *rtwdev,
549 u8 pairwise_key_enc,
550 u8 group_key_enc)
551 {
552 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
553
554 SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_AOAC_GLOBAL_INFO);
555
556 SET_AOAC_GLOBAL_INFO_PAIRWISE_ENC_ALG(h2c_pkt, pairwise_key_enc);
557 SET_AOAC_GLOBAL_INFO_GROUP_ENC_ALG(h2c_pkt, group_key_enc);
558
559 rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
560 }
561
562 void rtw_fw_set_remote_wake_ctrl_cmd(struct rtw_dev *rtwdev, bool enable)
563 {
564 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
565
566 SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_REMOTE_WAKE_CTRL);
567
568 SET_REMOTE_WAKECTRL_ENABLE(h2c_pkt, enable);
569
570 if (rtw_wow_no_link(rtwdev))
571 SET_REMOTE_WAKE_CTRL_NLO_OFFLOAD_EN(h2c_pkt, enable);
572
573 rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
574 }
575
576 static u8 rtw_get_rsvd_page_location(struct rtw_dev *rtwdev,
577 enum rtw_rsvd_packet_type type)
578 {
579 struct rtw_rsvd_page *rsvd_pkt;
580 u8 location = 0;
581
582 list_for_each_entry(rsvd_pkt, &rtwdev->rsvd_page_list, list) {
583 if (type == rsvd_pkt->type)
584 location = rsvd_pkt->page;
585 }
586
587 return location;
588 }
589
590 void rtw_fw_set_nlo_info(struct rtw_dev *rtwdev, bool enable)
591 {
592 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
593 u8 loc_nlo;
594
595 loc_nlo = rtw_get_rsvd_page_location(rtwdev, RSVD_NLO_INFO);
596
597 SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_NLO_INFO);
598
599 SET_NLO_FUN_EN(h2c_pkt, enable);
600 if (enable) {
601 if (rtw_fw_lps_deep_mode)
602 SET_NLO_PS_32K(h2c_pkt, enable);
603 SET_NLO_IGNORE_SECURITY(h2c_pkt, enable);
604 SET_NLO_LOC_NLO_INFO(h2c_pkt, loc_nlo);
605 }
606
607 rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
608 }
609
610 void rtw_fw_set_pg_info(struct rtw_dev *rtwdev)
611 {
612 struct rtw_lps_conf *conf = &rtwdev->lps_conf;
613 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
614 u8 loc_pg, loc_dpk;
615
616 loc_pg = rtw_get_rsvd_page_location(rtwdev, RSVD_LPS_PG_INFO);
617 loc_dpk = rtw_get_rsvd_page_location(rtwdev, RSVD_LPS_PG_DPK);
618
619 SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_LPS_PG_INFO);
620
621 LPS_PG_INFO_LOC(h2c_pkt, loc_pg);
622 LPS_PG_DPK_LOC(h2c_pkt, loc_dpk);
623 LPS_PG_SEC_CAM_EN(h2c_pkt, conf->sec_cam_backup);
624 LPS_PG_PATTERN_CAM_EN(h2c_pkt, conf->pattern_cam_backup);
625
626 rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
627 }
628
629 u8 rtw_get_rsvd_page_probe_req_location(struct rtw_dev *rtwdev,
630 struct cfg80211_ssid *ssid)
631 {
632 struct rtw_rsvd_page *rsvd_pkt;
633 u8 location = 0;
634
635 list_for_each_entry(rsvd_pkt, &rtwdev->rsvd_page_list, list) {
636 if (rsvd_pkt->type != RSVD_PROBE_REQ)
637 continue;
638 if ((!ssid && !rsvd_pkt->ssid) ||
639 rtw_ssid_equal(rsvd_pkt->ssid, ssid))
640 location = rsvd_pkt->page;
641 }
642
643 return location;
644 }
645
646 u16 rtw_get_rsvd_page_probe_req_size(struct rtw_dev *rtwdev,
647 struct cfg80211_ssid *ssid)
648 {
649 struct rtw_rsvd_page *rsvd_pkt;
650 u16 size = 0;
651
652 list_for_each_entry(rsvd_pkt, &rtwdev->rsvd_page_list, list) {
653 if (rsvd_pkt->type != RSVD_PROBE_REQ)
654 continue;
655 if ((!ssid && !rsvd_pkt->ssid) ||
656 rtw_ssid_equal(rsvd_pkt->ssid, ssid))
657 size = rsvd_pkt->skb->len;
658 }
659
660 return size;
661 }
662
663 void rtw_send_rsvd_page_h2c(struct rtw_dev *rtwdev)
664 {
665 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
666 u8 location = 0;
667
668 SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_RSVD_PAGE);
669
670 location = rtw_get_rsvd_page_location(rtwdev, RSVD_PROBE_RESP);
671 *(h2c_pkt + 1) = location;
672 rtw_dbg(rtwdev, RTW_DBG_FW, "RSVD_PROBE_RESP loc: %d\n", location);
673
674 location = rtw_get_rsvd_page_location(rtwdev, RSVD_PS_POLL);
675 *(h2c_pkt + 2) = location;
676 rtw_dbg(rtwdev, RTW_DBG_FW, "RSVD_PS_POLL loc: %d\n", location);
677
678 location = rtw_get_rsvd_page_location(rtwdev, RSVD_NULL);
679 *(h2c_pkt + 3) = location;
680 rtw_dbg(rtwdev, RTW_DBG_FW, "RSVD_NULL loc: %d\n", location);
681
682 location = rtw_get_rsvd_page_location(rtwdev, RSVD_QOS_NULL);
683 *(h2c_pkt + 4) = location;
684 rtw_dbg(rtwdev, RTW_DBG_FW, "RSVD_QOS_NULL loc: %d\n", location);
685
686 rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
687 }
688
689 static struct sk_buff *
690 rtw_beacon_get(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
691 {
692 struct sk_buff *skb_new;
693
694 if (vif->type != NL80211_IFTYPE_AP &&
695 vif->type != NL80211_IFTYPE_ADHOC &&
696 !ieee80211_vif_is_mesh(vif)) {
697 skb_new = alloc_skb(1, GFP_KERNEL);
698 if (!skb_new)
699 return NULL;
700 skb_put(skb_new, 1);
701 } else {
702 skb_new = ieee80211_beacon_get(hw, vif);
703 }
704
705 return skb_new;
706 }
707
708 static struct sk_buff *rtw_nlo_info_get(struct ieee80211_hw *hw)
709 {
710 struct rtw_dev *rtwdev = hw->priv;
711 struct rtw_chip_info *chip = rtwdev->chip;
712 struct rtw_pno_request *pno_req = &rtwdev->wow.pno_req;
713 struct rtw_nlo_info_hdr *nlo_hdr;
714 struct cfg80211_ssid *ssid;
715 struct sk_buff *skb;
716 u8 *pos, loc;
717 u32 size;
718 int i;
719
720 if (!pno_req->inited || !pno_req->match_set_cnt)
721 return NULL;
722
723 size = sizeof(struct rtw_nlo_info_hdr) + pno_req->match_set_cnt *
724 IEEE80211_MAX_SSID_LEN + chip->tx_pkt_desc_sz;
725
726 skb = alloc_skb(size, GFP_KERNEL);
727 if (!skb)
728 return NULL;
729
730 skb_reserve(skb, chip->tx_pkt_desc_sz);
731
732 nlo_hdr = skb_put_zero(skb, sizeof(struct rtw_nlo_info_hdr));
733
734 nlo_hdr->nlo_count = pno_req->match_set_cnt;
735 nlo_hdr->hidden_ap_count = pno_req->match_set_cnt;
736
737 /* pattern check for firmware */
738 memset(nlo_hdr->pattern_check, 0xA5, FW_NLO_INFO_CHECK_SIZE);
739
740 for (i = 0; i < pno_req->match_set_cnt; i++)
741 nlo_hdr->ssid_len[i] = pno_req->match_sets[i].ssid.ssid_len;
742
743 for (i = 0; i < pno_req->match_set_cnt; i++) {
744 ssid = &pno_req->match_sets[i].ssid;
745 loc = rtw_get_rsvd_page_probe_req_location(rtwdev, ssid);
746 if (!loc) {
747 rtw_err(rtwdev, "failed to get probe req rsvd loc\n");
748 kfree(skb);
749 return NULL;
750 }
751 nlo_hdr->location[i] = loc;
752 }
753
754 for (i = 0; i < pno_req->match_set_cnt; i++) {
755 pos = skb_put_zero(skb, IEEE80211_MAX_SSID_LEN);
756 memcpy(pos, pno_req->match_sets[i].ssid.ssid,
757 pno_req->match_sets[i].ssid.ssid_len);
758 }
759
760 return skb;
761 }
762
763 static struct sk_buff *rtw_cs_channel_info_get(struct ieee80211_hw *hw)
764 {
765 struct rtw_dev *rtwdev = hw->priv;
766 struct rtw_chip_info *chip = rtwdev->chip;
767 struct rtw_pno_request *pno_req = &rtwdev->wow.pno_req;
768 struct ieee80211_channel *channels = pno_req->channels;
769 struct sk_buff *skb;
770 int count = pno_req->channel_cnt;
771 u8 *pos;
772 int i = 0;
773
774 skb = alloc_skb(4 * count + chip->tx_pkt_desc_sz, GFP_KERNEL);
775 if (!skb)
776 return NULL;
777
778 skb_reserve(skb, chip->tx_pkt_desc_sz);
779
780 for (i = 0; i < count; i++) {
781 pos = skb_put_zero(skb, 4);
782
783 CHSW_INFO_SET_CH(pos, channels[i].hw_value);
784
785 if (channels[i].flags & IEEE80211_CHAN_RADAR)
786 CHSW_INFO_SET_ACTION_ID(pos, 0);
787 else
788 CHSW_INFO_SET_ACTION_ID(pos, 1);
789 CHSW_INFO_SET_TIMEOUT(pos, 1);
790 CHSW_INFO_SET_PRI_CH_IDX(pos, 1);
791 CHSW_INFO_SET_BW(pos, 0);
792 }
793
794 return skb;
795 }
796
797 static struct sk_buff *rtw_lps_pg_dpk_get(struct ieee80211_hw *hw)
798 {
799 struct rtw_dev *rtwdev = hw->priv;
800 struct rtw_chip_info *chip = rtwdev->chip;
801 struct rtw_dpk_info *dpk_info = &rtwdev->dm_info.dpk_info;
802 struct rtw_lps_pg_dpk_hdr *dpk_hdr;
803 struct sk_buff *skb;
804 u32 size;
805
806 size = chip->tx_pkt_desc_sz + sizeof(*dpk_hdr);
807 skb = alloc_skb(size, GFP_KERNEL);
808 if (!skb)
809 return NULL;
810
811 skb_reserve(skb, chip->tx_pkt_desc_sz);
812 dpk_hdr = skb_put_zero(skb, sizeof(*dpk_hdr));
813 dpk_hdr->dpk_ch = dpk_info->dpk_ch;
814 dpk_hdr->dpk_path_ok = dpk_info->dpk_path_ok[0];
815 memcpy(dpk_hdr->dpk_txagc, dpk_info->dpk_txagc, 2);
816 memcpy(dpk_hdr->dpk_gs, dpk_info->dpk_gs, 4);
817 memcpy(dpk_hdr->coef, dpk_info->coef, 160);
818
819 return skb;
820 }
821
822 static struct sk_buff *rtw_lps_pg_info_get(struct ieee80211_hw *hw,
823 struct ieee80211_vif *vif)
824 {
825 struct rtw_dev *rtwdev = hw->priv;
826 struct rtw_chip_info *chip = rtwdev->chip;
827 struct rtw_lps_conf *conf = &rtwdev->lps_conf;
828 struct rtw_lps_pg_info_hdr *pg_info_hdr;
829 struct rtw_wow_param *rtw_wow = &rtwdev->wow;
830 struct sk_buff *skb;
831 u32 size;
832
833 size = chip->tx_pkt_desc_sz + sizeof(*pg_info_hdr);
834 skb = alloc_skb(size, GFP_KERNEL);
835 if (!skb)
836 return NULL;
837
838 skb_reserve(skb, chip->tx_pkt_desc_sz);
839 pg_info_hdr = skb_put_zero(skb, sizeof(*pg_info_hdr));
840 pg_info_hdr->tx_bu_page_count = rtwdev->fifo.rsvd_drv_pg_num;
841 pg_info_hdr->macid = find_first_bit(rtwdev->mac_id_map, RTW_MAX_MAC_ID_NUM);
842 pg_info_hdr->sec_cam_count =
843 rtw_sec_cam_pg_backup(rtwdev, pg_info_hdr->sec_cam);
844 pg_info_hdr->pattern_count = rtw_wow->pattern_cnt;
845
846 conf->sec_cam_backup = pg_info_hdr->sec_cam_count != 0;
847 conf->pattern_cam_backup = rtw_wow->pattern_cnt != 0;
848
849 return skb;
850 }
851
852 static struct sk_buff *rtw_get_rsvd_page_skb(struct ieee80211_hw *hw,
853 struct ieee80211_vif *vif,
854 struct rtw_rsvd_page *rsvd_pkt)
855 {
856 struct sk_buff *skb_new;
857 struct cfg80211_ssid *ssid;
858
859 switch (rsvd_pkt->type) {
860 case RSVD_BEACON:
861 skb_new = rtw_beacon_get(hw, vif);
862 break;
863 case RSVD_PS_POLL:
864 skb_new = ieee80211_pspoll_get(hw, vif);
865 break;
866 case RSVD_PROBE_RESP:
867 skb_new = ieee80211_proberesp_get(hw, vif);
868 break;
869 case RSVD_NULL:
870 skb_new = ieee80211_nullfunc_get(hw, vif, false);
871 break;
872 case RSVD_QOS_NULL:
873 skb_new = ieee80211_nullfunc_get(hw, vif, true);
874 break;
875 case RSVD_LPS_PG_DPK:
876 skb_new = rtw_lps_pg_dpk_get(hw);
877 break;
878 case RSVD_LPS_PG_INFO:
879 skb_new = rtw_lps_pg_info_get(hw, vif);
880 break;
881 case RSVD_PROBE_REQ:
882 ssid = (struct cfg80211_ssid *)rsvd_pkt->ssid;
883 if (ssid)
884 skb_new = ieee80211_probereq_get(hw, vif->addr,
885 ssid->ssid,
886 ssid->ssid_len, 0);
887 else
888 skb_new = ieee80211_probereq_get(hw, vif->addr, NULL, 0, 0);
889 break;
890 case RSVD_NLO_INFO:
891 skb_new = rtw_nlo_info_get(hw);
892 break;
893 case RSVD_CH_INFO:
894 skb_new = rtw_cs_channel_info_get(hw);
895 break;
896 default:
897 return NULL;
898 }
899
900 if (!skb_new)
901 return NULL;
902
903 return skb_new;
904 }
905
906 static void rtw_fill_rsvd_page_desc(struct rtw_dev *rtwdev, struct sk_buff *skb)
907 {
908 struct rtw_tx_pkt_info pkt_info;
909 struct rtw_chip_info *chip = rtwdev->chip;
910 u8 *pkt_desc;
911
912 memset(&pkt_info, 0, sizeof(pkt_info));
913 rtw_rsvd_page_pkt_info_update(rtwdev, &pkt_info, skb);
914 pkt_desc = skb_push(skb, chip->tx_pkt_desc_sz);
915 memset(pkt_desc, 0, chip->tx_pkt_desc_sz);
916 rtw_tx_fill_tx_desc(&pkt_info, skb);
917 }
918
919 static inline u8 rtw_len_to_page(unsigned int len, u8 page_size)
920 {
921 return DIV_ROUND_UP(len, page_size);
922 }
923
924 static void rtw_rsvd_page_list_to_buf(struct rtw_dev *rtwdev, u8 page_size,
925 u8 page_margin, u32 page, u8 *buf,
926 struct rtw_rsvd_page *rsvd_pkt)
927 {
928 struct sk_buff *skb = rsvd_pkt->skb;
929
930 if (page >= 1)
931 memcpy(buf + page_margin + page_size * (page - 1),
932 skb->data, skb->len);
933 else
934 memcpy(buf, skb->data, skb->len);
935 }
936
937 static struct rtw_rsvd_page *rtw_alloc_rsvd_page(struct rtw_dev *rtwdev,
938 enum rtw_rsvd_packet_type type,
939 bool txdesc)
940 {
941 struct rtw_rsvd_page *rsvd_pkt = NULL;
942
943 rsvd_pkt = kzalloc(sizeof(*rsvd_pkt), GFP_KERNEL);
944
945 if (!rsvd_pkt)
946 return NULL;
947
948 rsvd_pkt->type = type;
949 rsvd_pkt->add_txdesc = txdesc;
950
951 return rsvd_pkt;
952 }
953
954 static void rtw_insert_rsvd_page(struct rtw_dev *rtwdev,
955 struct rtw_rsvd_page *rsvd_pkt)
956 {
957 lockdep_assert_held(&rtwdev->mutex);
958 list_add_tail(&rsvd_pkt->list, &rtwdev->rsvd_page_list);
959 }
960
961 void rtw_add_rsvd_page(struct rtw_dev *rtwdev, enum rtw_rsvd_packet_type type,
962 bool txdesc)
963 {
964 struct rtw_rsvd_page *rsvd_pkt;
965
966 rsvd_pkt = rtw_alloc_rsvd_page(rtwdev, type, txdesc);
967 if (!rsvd_pkt)
968 return;
969
970 rtw_insert_rsvd_page(rtwdev, rsvd_pkt);
971 }
972
973 void rtw_add_rsvd_page_probe_req(struct rtw_dev *rtwdev,
974 struct cfg80211_ssid *ssid)
975 {
976 struct rtw_rsvd_page *rsvd_pkt;
977
978 rsvd_pkt = rtw_alloc_rsvd_page(rtwdev, RSVD_PROBE_REQ, true);
979 if (!rsvd_pkt)
980 return;
981
982 rsvd_pkt->ssid = ssid;
983 rtw_insert_rsvd_page(rtwdev, rsvd_pkt);
984 }
985
986 void rtw_reset_rsvd_page(struct rtw_dev *rtwdev)
987 {
988 struct rtw_rsvd_page *rsvd_pkt, *tmp;
989
990 lockdep_assert_held(&rtwdev->mutex);
991
992 list_for_each_entry_safe(rsvd_pkt, tmp, &rtwdev->rsvd_page_list, list) {
993 if (rsvd_pkt->type == RSVD_BEACON)
994 continue;
995 list_del(&rsvd_pkt->list);
996 kfree(rsvd_pkt);
997 }
998 }
999
1000 int rtw_fw_write_data_rsvd_page(struct rtw_dev *rtwdev, u16 pg_addr,
1001 u8 *buf, u32 size)
1002 {
1003 u8 bckp[2];
1004 u8 val;
1005 u16 rsvd_pg_head;
1006 int ret;
1007
1008 lockdep_assert_held(&rtwdev->mutex);
1009
1010 if (!size)
1011 return -EINVAL;
1012
1013 pg_addr &= BIT_MASK_BCN_HEAD_1_V1;
1014 rtw_write16(rtwdev, REG_FIFOPAGE_CTRL_2, pg_addr | BIT_BCN_VALID_V1);
1015
1016 val = rtw_read8(rtwdev, REG_CR + 1);
1017 bckp[0] = val;
1018 val |= BIT_ENSWBCN >> 8;
1019 rtw_write8(rtwdev, REG_CR + 1, val);
1020
1021 val = rtw_read8(rtwdev, REG_FWHW_TXQ_CTRL + 2);
1022 bckp[1] = val;
1023 val &= ~(BIT_EN_BCNQ_DL >> 16);
1024 rtw_write8(rtwdev, REG_FWHW_TXQ_CTRL + 2, val);
1025
1026 ret = rtw_hci_write_data_rsvd_page(rtwdev, buf, size);
1027 if (ret) {
1028 rtw_err(rtwdev, "failed to write data to rsvd page\n");
1029 goto restore;
1030 }
1031
1032 if (!check_hw_ready(rtwdev, REG_FIFOPAGE_CTRL_2, BIT_BCN_VALID_V1, 1)) {
1033 rtw_err(rtwdev, "error beacon valid\n");
1034 ret = -EBUSY;
1035 }
1036
1037 restore:
1038 rsvd_pg_head = rtwdev->fifo.rsvd_boundary;
1039 rtw_write16(rtwdev, REG_FIFOPAGE_CTRL_2,
1040 rsvd_pg_head | BIT_BCN_VALID_V1);
1041 rtw_write8(rtwdev, REG_FWHW_TXQ_CTRL + 2, bckp[1]);
1042 rtw_write8(rtwdev, REG_CR + 1, bckp[0]);
1043
1044 return ret;
1045 }
1046
1047 static int rtw_download_drv_rsvd_page(struct rtw_dev *rtwdev, u8 *buf, u32 size)
1048 {
1049 u32 pg_size;
1050 u32 pg_num = 0;
1051 u16 pg_addr = 0;
1052
1053 pg_size = rtwdev->chip->page_size;
1054 pg_num = size / pg_size + ((size & (pg_size - 1)) ? 1 : 0);
1055 if (pg_num > rtwdev->fifo.rsvd_drv_pg_num)
1056 return -ENOMEM;
1057
1058 pg_addr = rtwdev->fifo.rsvd_drv_addr;
1059
1060 return rtw_fw_write_data_rsvd_page(rtwdev, pg_addr, buf, size);
1061 }
1062
1063 static u8 *rtw_build_rsvd_page(struct rtw_dev *rtwdev,
1064 struct ieee80211_vif *vif, u32 *size)
1065 {
1066 struct ieee80211_hw *hw = rtwdev->hw;
1067 struct rtw_chip_info *chip = rtwdev->chip;
1068 struct sk_buff *iter;
1069 struct rtw_rsvd_page *rsvd_pkt;
1070 u32 page = 0;
1071 u8 total_page = 0;
1072 u8 page_size, page_margin, tx_desc_sz;
1073 u8 *buf;
1074
1075 page_size = chip->page_size;
1076 tx_desc_sz = chip->tx_pkt_desc_sz;
1077 page_margin = page_size - tx_desc_sz;
1078
1079 list_for_each_entry(rsvd_pkt, &rtwdev->rsvd_page_list, list) {
1080 iter = rtw_get_rsvd_page_skb(hw, vif, rsvd_pkt);
1081 if (!iter) {
1082 rtw_err(rtwdev, "failed to build rsvd packet\n");
1083 goto release_skb;
1084 }
1085
1086 /* Fill the tx_desc for the rsvd pkt that requires one.
1087 * And iter->len will be added with size of tx_desc_sz.
1088 */
1089 if (rsvd_pkt->add_txdesc)
1090 rtw_fill_rsvd_page_desc(rtwdev, iter);
1091
1092 rsvd_pkt->skb = iter;
1093 rsvd_pkt->page = total_page;
1094
1095 /* Reserved page is downloaded via TX path, and TX path will
1096 * generate a tx_desc at the header to describe length of
1097 * the buffer. If we are not counting page numbers with the
1098 * size of tx_desc added at the first rsvd_pkt (usually a
1099 * beacon, firmware default refer to the first page as the
1100 * content of beacon), we could generate a buffer which size
1101 * is smaller than the actual size of the whole rsvd_page
1102 */
1103 if (total_page == 0) {
1104 if (rsvd_pkt->type != RSVD_BEACON) {
1105 rtw_err(rtwdev, "first page should be a beacon\n");
1106 goto release_skb;
1107 }
1108 total_page += rtw_len_to_page(iter->len + tx_desc_sz,
1109 page_size);
1110 } else {
1111 total_page += rtw_len_to_page(iter->len, page_size);
1112 }
1113 }
1114
1115 if (total_page > rtwdev->fifo.rsvd_drv_pg_num) {
1116 rtw_err(rtwdev, "rsvd page over size: %d\n", total_page);
1117 goto release_skb;
1118 }
1119
1120 *size = (total_page - 1) * page_size + page_margin;
1121 buf = kzalloc(*size, GFP_KERNEL);
1122 if (!buf)
1123 goto release_skb;
1124
1125 /* Copy the content of each rsvd_pkt to the buf, and they should
1126 * be aligned to the pages.
1127 *
1128 * Note that the first rsvd_pkt is a beacon no matter what vif->type.
1129 * And that rsvd_pkt does not require tx_desc because when it goes
1130 * through TX path, the TX path will generate one for it.
1131 */
1132 list_for_each_entry(rsvd_pkt, &rtwdev->rsvd_page_list, list) {
1133 rtw_rsvd_page_list_to_buf(rtwdev, page_size, page_margin,
1134 page, buf, rsvd_pkt);
1135 if (page == 0)
1136 page += rtw_len_to_page(rsvd_pkt->skb->len +
1137 tx_desc_sz, page_size);
1138 else
1139 page += rtw_len_to_page(rsvd_pkt->skb->len, page_size);
1140
1141 kfree_skb(rsvd_pkt->skb);
1142 rsvd_pkt->skb = NULL;
1143 }
1144
1145 return buf;
1146
1147 release_skb:
1148 list_for_each_entry(rsvd_pkt, &rtwdev->rsvd_page_list, list) {
1149 kfree_skb(rsvd_pkt->skb);
1150 rsvd_pkt->skb = NULL;
1151 }
1152
1153 return NULL;
1154 }
1155
1156 static int
1157 rtw_download_beacon(struct rtw_dev *rtwdev, struct ieee80211_vif *vif)
1158 {
1159 struct ieee80211_hw *hw = rtwdev->hw;
1160 struct sk_buff *skb;
1161 int ret = 0;
1162
1163 skb = rtw_beacon_get(hw, vif);
1164 if (!skb) {
1165 rtw_err(rtwdev, "failed to get beacon skb\n");
1166 ret = -ENOMEM;
1167 goto out;
1168 }
1169
1170 ret = rtw_download_drv_rsvd_page(rtwdev, skb->data, skb->len);
1171 if (ret)
1172 rtw_err(rtwdev, "failed to download drv rsvd page\n");
1173
1174 dev_kfree_skb(skb);
1175
1176 out:
1177 return ret;
1178 }
1179
1180 int rtw_fw_download_rsvd_page(struct rtw_dev *rtwdev, struct ieee80211_vif *vif)
1181 {
1182 u8 *buf;
1183 u32 size;
1184 int ret;
1185
1186 buf = rtw_build_rsvd_page(rtwdev, vif, &size);
1187 if (!buf) {
1188 rtw_err(rtwdev, "failed to build rsvd page pkt\n");
1189 return -ENOMEM;
1190 }
1191
1192 ret = rtw_download_drv_rsvd_page(rtwdev, buf, size);
1193 if (ret) {
1194 rtw_err(rtwdev, "failed to download drv rsvd page\n");
1195 goto free;
1196 }
1197
1198 /* The last thing is to download the *ONLY* beacon again, because
1199 * the previous tx_desc is to describe the total rsvd page. Download
1200 * the beacon again to replace the TX desc header, and we will get
1201 * a correct tx_desc for the beacon in the rsvd page.
1202 */
1203 ret = rtw_download_beacon(rtwdev, vif);
1204 if (ret) {
1205 rtw_err(rtwdev, "failed to download beacon\n");
1206 goto free;
1207 }
1208
1209 free:
1210 kfree(buf);
1211
1212 return ret;
1213 }
1214
1215 int rtw_dump_drv_rsvd_page(struct rtw_dev *rtwdev,
1216 u32 offset, u32 size, u32 *buf)
1217 {
1218 struct rtw_fifo_conf *fifo = &rtwdev->fifo;
1219 u32 residue, i;
1220 u16 start_pg;
1221 u16 idx = 0;
1222 u16 ctl;
1223 u8 rcr;
1224
1225 if (size & 0x3) {
1226 rtw_warn(rtwdev, "should be 4-byte aligned\n");
1227 return -EINVAL;
1228 }
1229
1230 offset += fifo->rsvd_boundary << TX_PAGE_SIZE_SHIFT;
1231 residue = offset & (FIFO_PAGE_SIZE - 1);
1232 start_pg = offset >> FIFO_PAGE_SIZE_SHIFT;
1233 start_pg += RSVD_PAGE_START_ADDR;
1234
1235 rcr = rtw_read8(rtwdev, REG_RCR + 2);
1236 ctl = rtw_read16(rtwdev, REG_PKTBUF_DBG_CTRL) & 0xf000;
1237
1238 /* disable rx clock gate */
1239 rtw_write8(rtwdev, REG_RCR, rcr | BIT(3));
1240
1241 do {
1242 rtw_write16(rtwdev, REG_PKTBUF_DBG_CTRL, start_pg | ctl);
1243
1244 for (i = FIFO_DUMP_ADDR + residue;
1245 i < FIFO_DUMP_ADDR + FIFO_PAGE_SIZE; i += 4) {
1246 buf[idx++] = rtw_read32(rtwdev, i);
1247 size -= 4;
1248 if (size == 0)
1249 goto out;
1250 }
1251
1252 residue = 0;
1253 start_pg++;
1254 } while (size);
1255
1256 out:
1257 rtw_write16(rtwdev, REG_PKTBUF_DBG_CTRL, ctl);
1258 rtw_write8(rtwdev, REG_RCR + 2, rcr);
1259 return 0;
1260 }
1261
1262 static void __rtw_fw_update_pkt(struct rtw_dev *rtwdev, u8 pkt_id, u16 size,
1263 u8 location)
1264 {
1265 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
1266 u16 total_size = H2C_PKT_HDR_SIZE + H2C_PKT_UPDATE_PKT_LEN;
1267
1268 rtw_h2c_pkt_set_header(h2c_pkt, H2C_PKT_UPDATE_PKT);
1269
1270 SET_PKT_H2C_TOTAL_LEN(h2c_pkt, total_size);
1271 UPDATE_PKT_SET_PKT_ID(h2c_pkt, pkt_id);
1272 UPDATE_PKT_SET_LOCATION(h2c_pkt, location);
1273
1274 /* include txdesc size */
1275 UPDATE_PKT_SET_SIZE(h2c_pkt, size);
1276
1277 rtw_fw_send_h2c_packet(rtwdev, h2c_pkt);
1278 }
1279
1280 void rtw_fw_update_pkt_probe_req(struct rtw_dev *rtwdev,
1281 struct cfg80211_ssid *ssid)
1282 {
1283 u8 loc;
1284 u32 size;
1285
1286 loc = rtw_get_rsvd_page_probe_req_location(rtwdev, ssid);
1287 if (!loc) {
1288 rtw_err(rtwdev, "failed to get probe_req rsvd loc\n");
1289 return;
1290 }
1291
1292 size = rtw_get_rsvd_page_probe_req_size(rtwdev, ssid);
1293 if (!size) {
1294 rtw_err(rtwdev, "failed to get probe_req rsvd size\n");
1295 return;
1296 }
1297
1298 __rtw_fw_update_pkt(rtwdev, RTW_PACKET_PROBE_REQ, size, loc);
1299 }
1300
1301 void rtw_fw_channel_switch(struct rtw_dev *rtwdev, bool enable)
1302 {
1303 struct rtw_pno_request *rtw_pno_req = &rtwdev->wow.pno_req;
1304 u8 h2c_pkt[H2C_PKT_SIZE] = {0};
1305 u16 total_size = H2C_PKT_HDR_SIZE + H2C_PKT_CH_SWITCH_LEN;
1306 u8 loc_ch_info;
1307 const struct rtw_ch_switch_option cs_option = {
1308 .dest_ch_en = 1,
1309 .dest_ch = 1,
1310 .periodic_option = 2,
1311 .normal_period = 5,
1312 .normal_period_sel = 0,
1313 .normal_cycle = 10,
1314 .slow_period = 1,
1315 .slow_period_sel = 1,
1316 };
1317
1318 rtw_h2c_pkt_set_header(h2c_pkt, H2C_PKT_CH_SWITCH);
1319 SET_PKT_H2C_TOTAL_LEN(h2c_pkt, total_size);
1320
1321 CH_SWITCH_SET_START(h2c_pkt, enable);
1322 CH_SWITCH_SET_DEST_CH_EN(h2c_pkt, cs_option.dest_ch_en);
1323 CH_SWITCH_SET_DEST_CH(h2c_pkt, cs_option.dest_ch);
1324 CH_SWITCH_SET_NORMAL_PERIOD(h2c_pkt, cs_option.normal_period);
1325 CH_SWITCH_SET_NORMAL_PERIOD_SEL(h2c_pkt, cs_option.normal_period_sel);
1326 CH_SWITCH_SET_SLOW_PERIOD(h2c_pkt, cs_option.slow_period);
1327 CH_SWITCH_SET_SLOW_PERIOD_SEL(h2c_pkt, cs_option.slow_period_sel);
1328 CH_SWITCH_SET_NORMAL_CYCLE(h2c_pkt, cs_option.normal_cycle);
1329 CH_SWITCH_SET_PERIODIC_OPT(h2c_pkt, cs_option.periodic_option);
1330
1331 CH_SWITCH_SET_CH_NUM(h2c_pkt, rtw_pno_req->channel_cnt);
1332 CH_SWITCH_SET_INFO_SIZE(h2c_pkt, rtw_pno_req->channel_cnt * 4);
1333
1334 loc_ch_info = rtw_get_rsvd_page_location(rtwdev, RSVD_CH_INFO);
1335 CH_SWITCH_SET_INFO_LOC(h2c_pkt, loc_ch_info);
1336
1337 rtw_fw_send_h2c_packet(rtwdev, h2c_pkt);
1338 }
Linux with added FPC-III support