1 /******************************************************************************
2 *
3 * Copyright(c) 2019 Realtek Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 *****************************************************************************/
15 #define _HAL_BTC_ACTION_C_
16 #include "../hal_headers_le.h"
17 #include "hal_btc.h"
18 #include "halbtc_fw.h"
19 #include "halbtc_fwdef.h"
20 #include "halbtc_action.h"
21 #include "halbtc_def.h"
22
23 #ifdef CONFIG_BTCOEX
24
25 #define _set_cx_ctrl(btc, val) rtw_hal_mac_set_coex_ctrl(btc->hal, val)
26
27 /* tdma policy template */
28 struct fbtc_tdma t_def[] = {
29 { CXTDMA_OFF, CXFLC_OFF, CXTPS_OFF, 0, 0, 0, 0, 0}, /*CXTD_OFF*/
30 { CXTDMA_OFF, CXFLC_OFF, CXTPS_OFF, 0, 0, 1, 0, 0}, /*CXTD_B2*/
31 { CXTDMA_OFF, CXFLC_OFF, CXTPS_OFF, 0, 0, 2, 0, 0}, /*CXTD_OFF_EXT*/
32 { CXTDMA_FIX, CXFLC_OFF, CXTPS_OFF, 0, 0, 0, 0, 0}, /* CXTD_FIX */
33 { CXTDMA_FIX, CXFLC_NULLP, CXTPS_ON, 0, 5, 0, 0, 0}, /* CXTD_PFIX */
34 { CXTDMA_AUTO, CXFLC_OFF, CXTPS_OFF, 0, 0, 0, 0, 0}, /* CXTD_AUTO */
35 { CXTDMA_AUTO, CXFLC_NULLP, CXTPS_ON, 0, 5, 0, 0, 0}, /* CXTD_PAUTO */
36 {CXTDMA_AUTO2, CXFLC_OFF, CXTPS_OFF, 0, 0, 0, 0, 0}, /* CXTD_AUTO2 */
37 {CXTDMA_AUTO2, CXFLC_NULLP, CXTPS_ON, 0, 5, 0, 0, 0} /* CXTD_PAUTO2 */
38 };
39
40 /* slot policy template */
41 struct fbtc_slot s_def[] = {
42 {100, 0x55555555, SLOT_MIX}, /* CXST_OFF */
43 { 5, 0xea5a5a5a, SLOT_ISO}, /* CXST_B2W */
44 { 70, 0xea5a5a5a, SLOT_ISO}, /* CXST_W1 */
45 { 15, 0xea5a5a5a, SLOT_ISO}, /* CXST_W2 */
46 { 15, 0xea5a5a5a, SLOT_ISO}, /* CXST_W2B */
47 {250, 0xe5555555, SLOT_MIX}, /* CXST_B1 */
48 { 7, 0xea5a5a5a, SLOT_MIX}, /* CXST_B2 */
49 { 5, 0xe5555555, SLOT_MIX}, /* CXST_B3 */
50 { 50, 0xe5555555, SLOT_MIX}, /* CXST_B4 */
51 { 20, 0xea5a5a5a, SLOT_ISO}, /* CXST_LK */
52 {400, 0x55555555, SLOT_MIX}, /* CXST_BLK */
53 { 0, 0xea5a5a5a, SLOT_MIX}, /* CXST_E2G */
54 { 0, 0xffffffff, SLOT_MIX}, /* CXST_E5G */
55 { 0, 0xe5555555, SLOT_MIX}, /* CXST_EBT */
56 { 0, 0xaaaaaaaa, SLOT_ISO}, /* CXST_ENULL */
57 {250, 0xea5a5a5a, SLOT_MIX}, /* CXST_WLK */
58 { 35, 0xfafafafa, SLOT_ISO}, /* CXST_W1FDD */
59 {250, 0xffffffff, SLOT_MIX} /* CXST_B1FDD */
60 };
61
62 const u32 cxtbl[] = {
63 0xffffffff, /* 0 */
64 0xaaaaaaaa, /* 1 */
65 0xe5555555, /* 2 */
66 0xee555555, /* 3 */
67 0xd5555555, /* 4 */
68 0x5a5a5a5a, /* 5 */
69 0x5a5a5aaa, /* 6 */
70 0xda5a5a5a, /* 7 */
71 0xea5a5a5a, /* 8 */
72 0x6a5a5aaa, /* 9 */
73 0x6a5a6a5a, /* 10 */
74 0x6a5a6aaa, /* 11 */
75 0x6afa5afa, /* 12 */
76 0xaaaa5aaa, /* 13 */
77 0xaaffffaa, /* 14 */
78 0xaa5555aa, /* 15 */
79 0xfafafafa, /* 16 */
80 0xffffddff, /* 17 */
81 0xdaffdaff, /* 18 */
82 0xfafadafa /* 19 */
83 };
84
_set_bt_ignore_wlan_act(struct btc_t * btc,u8 enable)85 void _set_bt_ignore_wlan_act(struct btc_t *btc, u8 enable)
86 {
87 u8 buf = 0;
88
89 PHL_TRACE(COMP_PHL_BTC, _PHL_DEBUG_, "[BTC], %s(): set bt %s wlan_act\n",
90 __func__, (enable? "ignore" : "do not ignore"));
91
92 buf = enable;
93 hal_btc_fw_set_bt(btc, SET_BT_IGNORE_WLAN_ACT, 1, &buf);
94 }
95
_set_wl_tx_power(struct btc_t * btc,u32 level)96 void _set_wl_tx_power(struct btc_t *btc, u32 level)
97 {
98 struct btc_wl_info *wl = &btc->cx.wl;
99
100 if (wl->rf_para.tx_pwr_freerun == level)
101 return;
102
103 wl->rf_para.tx_pwr_freerun = level;
104 btc->dm.rf_trx_para.wl_tx_power = level;
105
106 PHL_TRACE(COMP_PHL_BTC, _PHL_DEBUG_, "[BTC], %s(): level = %d\n",
107 __func__, level);
108
109 btc->chip->ops->wl_tx_power(btc, level);
110 }
111
_set_wl_rx_gain(struct btc_t * btc,u32 level)112 void _set_wl_rx_gain(struct btc_t *btc, u32 level)
113 {
114 struct btc_wl_info *wl = &btc->cx.wl;
115
116 if (wl->rf_para.rx_gain_freerun == level)
117 return;
118
119 wl->rf_para.rx_gain_freerun = level;
120 btc->dm.rf_trx_para.wl_rx_gain = level;
121
122 PHL_TRACE(COMP_PHL_BTC, _PHL_DEBUG_, "[BTC], %s(): level = %d\n",
123 __func__, level);
124
125 btc->chip->ops->wl_rx_gain(btc, level);
126 }
127
_set_bt_tx_power(struct btc_t * btc,u32 level)128 void _set_bt_tx_power(struct btc_t *btc, u32 level)
129 {
130 struct btc_bt_info *bt = &btc->cx.bt;
131 u8 buf = 0;
132
133 if (bt->rf_para.tx_pwr_freerun == level)
134 return;
135
136 bt->rf_para.tx_pwr_freerun = level;
137 btc->dm.rf_trx_para.bt_tx_power = level;
138
139 PHL_TRACE(COMP_PHL_BTC, _PHL_DEBUG_, "[BTC], %s(): level = %d\n",
140 __func__, level);
141
142 buf = (0x100 - level) & bMASKB0;
143 hal_btc_fw_set_bt(btc, SET_BT_TX_PWR, 1, &buf);
144 }
145
_set_bt_rx_gain(struct btc_t * btc,u32 level)146 void _set_bt_rx_gain(struct btc_t *btc, u32 level)
147 {
148 struct btc_bt_info *bt = &btc->cx.bt;
149 u8 buf = 0;
150
151 if (bt->rf_para.rx_gain_freerun == level ||
152 level > BTC_BT_RX_NORMAL_LVL)
153 return;
154
155 bt->rf_para.rx_gain_freerun = level;
156 btc->dm.rf_trx_para.bt_rx_gain = level;
157
158 PHL_TRACE(COMP_PHL_BTC, _PHL_DEBUG_, "[BTC], %s(): level = %d\n",
159 __func__, level);
160
161 buf = level & bMASKB0;
162
163 if (buf == BTC_BT_RX_NORMAL_LVL)
164 _write_scbd(btc, BTC_WSCB_RXGAIN, false);
165 else
166 _write_scbd(btc, BTC_WSCB_RXGAIN, true);
167
168 hal_btc_fw_set_bt(btc, SET_BT_LNA_CONSTRAIN, 1, &buf);
169 }
170
_set_rf_trx_para(struct btc_t * btc)171 static void _set_rf_trx_para(struct btc_t *btc)
172 {
173 struct btc_dm *dm = &btc->dm;
174 struct btc_wl_info *wl = &btc->cx.wl;
175 struct btc_bt_info *bt = &btc->cx.bt;
176 struct btc_bt_link_info *b = &bt->link_info;
177 struct btc_rf_trx_para para;
178 u8 level_id = 0;
179 u32 wl_stb_chg = 0;
180
181 if (!dm->freerun) {
182 dm->trx_para_level = 0;
183
184 #if 1
185 /* fix LNA2 = level-5 for BT ACI issue at BTG */
186 if (btc->hal->chip_id == CHIP_WIFI6_8852A &&
187 btc->dm.wl_btg_rx && b->profile_cnt.now != 0)
188 dm->trx_para_level = 1;
189 #endif
190 }
191
192 level_id = (u8)dm->trx_para_level;
193
194 if (level_id >= btc->chip->rf_para_dlink_num ||
195 level_id >= btc->chip->rf_para_ulink_num) {
196 PHL_TRACE(COMP_PHL_BTC, _PHL_DEBUG_, "[BTC], %s(): invalid level_id: %d\n",
197 __func__, level_id);
198 return;
199 }
200
201 if (wl->status.map.traffic_dir & BIT(TRAFFIC_UL))
202 para = btc->chip->rf_para_ulink[level_id];
203 else
204 para = btc->chip->rf_para_dlink[level_id];
205
206 _set_wl_tx_power(btc, para.wl_tx_power);
207 _set_wl_rx_gain(btc, para.wl_rx_gain);
208 _set_bt_tx_power(btc, para.bt_tx_power);
209 _set_bt_rx_gain(btc, para.bt_rx_gain);
210
211 if (!bt->enable.now || dm->wl_only || wl->status.map.rf_off ||
212 wl->status.map.lps == BTC_LPS_RF_OFF ||
213 wl->role_info.link_mode == BTC_WLINK_5G ||
214 wl->role_info.link_mode == BTC_WLINK_NOLINK)
215 wl_stb_chg = 0;
216 else
217 wl_stb_chg = 1;
218
219 if (wl_stb_chg != dm->wl_stb_chg) {
220 dm->wl_stb_chg = wl_stb_chg;
221 btc->chip->ops->wl_s1_standby(btc, dm->wl_stb_chg);
222 }
223
224 }
225
_update_btc_state_map(struct btc_t * btc)226 void _update_btc_state_map(struct btc_t *btc)
227 {
228 struct btc_cx *cx = &btc->cx;
229 struct btc_wl_info *wl = &cx->wl;
230 struct btc_bt_info *bt = &cx->bt;
231 struct btc_bt_link_info *bt_linfo = &bt->link_info;
232
233 if (wl->status.map.connecting || wl->status.map._4way ||
234 wl->status.map.roaming) {
235 cx->state_map = BTC_WLINKING;
236 } else if (wl->status.map.scan) { /* wl scan */
237 if (bt_linfo->status.map.inq_pag)
238 cx->state_map = BTC_WSCAN_BSCAN;
239 else
240 cx->state_map = BTC_WSCAN_BNOSCAN;
241 } else if (wl->status.map.busy) { /* only busy */
242 if (bt_linfo->status.map.inq_pag)
243 cx->state_map = BTC_WBUSY_BSCAN;
244 else
245 cx->state_map = BTC_WBUSY_BNOSCAN;
246 } else { /* wl idle */
247 cx->state_map = BTC_WIDLE;
248 }
249 }
250
_set_bt_golden_rx_range(struct btc_t * btc,u8 p_id,u8 level)251 static void _set_bt_golden_rx_range(struct btc_t *btc, u8 p_id, u8 level)
252 {
253 struct btc_bt_link_info *bt_linfo = &btc->cx.bt.link_info;
254 u8 buf[2] = {0}, pos = 0, i;
255
256 if (p_id > BTC_BT_PAN)
257 return;
258
259 for (i = 0; i< BTC_PROFILE_MAX; i++) {
260 if ((p_id >> i) & 0x1) {
261 pos = i;
262 break;
263 }
264 }
265
266 if (bt_linfo->golden_rx_shift[pos] == level)
267 return;
268
269 bt_linfo->golden_rx_shift[pos] = level;
270
271 PHL_TRACE(COMP_PHL_BTC, _PHL_DEBUG_, "[BTC], %s(): p_id=%d, level=%d\n",
272 __func__, p_id, level);
273
274 buf[0] = level;
275 buf[1] = pos;
276 hal_btc_fw_set_bt(btc, SET_BT_GOLDEN_RX_RANGE, sizeof(buf), buf);
277 }
278
_set_bt_afh_info(struct btc_t * btc)279 static void _set_bt_afh_info(struct btc_t *btc)
280 {
281 struct btc_wl_info *wl = &btc->cx.wl;
282 struct btc_bt_info *bt = &btc->cx.bt;
283 struct btc_bt_link_info *b = &bt->link_info;
284 struct btc_wl_role_info *wl_rinfo = &wl->role_info;
285 /*struct btc_module *module = &btc->mdinfo;*/
286 u8 en = 0, i, ch = 0, bw = CHANNEL_WIDTH_MAX;
287 u8 max_role_cnt = BTC_TDMA_WLROLE_MAX;
288
289 if (btc->ctrl.manual || wl->status.map.scan)
290 return;
291
292 if (btc->hal->dbcc_en)
293 max_role_cnt++;
294
295 /* TBD if include module->ant.type == BTC_ANT_SHARED */
296 if (wl->status.map.rf_off || bt->whql_test ||
297 wl_rinfo->link_mode == BTC_WLINK_NOLINK ||
298 wl_rinfo->link_mode == BTC_WLINK_5G ||
299 wl_rinfo->connect_cnt > max_role_cnt) {
300 en = false;
301 ch = 0;
302 bw = 0;
303 goto exit;
304 } else {
305 for (i = 0; i < MAX_WIFI_ROLE_NUMBER; i++) {
306 /* get p2p channel for MCC */
307 if (wl_rinfo->link_mode == BTC_WLINK_2G_MCC) {
308 if (wl_rinfo->active_role[i].role == PHL_RTYPE_AP ||
309 wl_rinfo->active_role[i].role == PHL_RTYPE_P2P_GO ||
310 wl_rinfo->active_role[i].role == PHL_RTYPE_P2P_GC) {
311 en = true;
312 ch = wl_rinfo->active_role[i].ch;
313 bw = wl_rinfo->active_role[i].bw;
314 break;
315 }
316 } else if (wl_rinfo->active_role[i].connected &&
317 wl_rinfo->active_role[i].band == BAND_ON_24G) {
318 en = true;
319 ch = wl_rinfo->active_role[i].ch;
320 bw = wl_rinfo->active_role[i].bw;
321
322 /* get the max bw if scc */
323 if (wl_rinfo->link_mode != BTC_WLINK_2G_SCC ||
324 wl_rinfo->active_role[i].bw == CHANNEL_WIDTH_40) {
325 break;
326 }
327 }
328 }
329 }
330
331
332 if (!en || ch > 14 || ch == 0)
333 bw = CHANNEL_WIDTH_MAX;
334
335 /* default AFH channel sapn = center-ch +- 6MHz */
336 switch (bw) {
337 case CHANNEL_WIDTH_20:
338 if (btc->dm.freerun)
339 bw = 48;
340 else
341 bw = 20 + btc->chip->afh_guard_ch * 2;
342 break;
343 case CHANNEL_WIDTH_40:
344 bw = 40 + btc->chip->afh_guard_ch * 2;
345 break;
346 case CHANNEL_WIDTH_5:
347 bw = 5 + btc->chip->afh_guard_ch * 2;
348 break;
349 case CHANNEL_WIDTH_10:
350 bw = 10 + btc->chip->afh_guard_ch * 2;
351 break;
352 default:
353 case CHANNEL_WIDTH_MAX:
354 en = false; /* turn off AFH info if invalid BW */
355 bw = 0;
356 ch = 0;
357 break;
358 }
359
360 exit:
361 if (wl->afh_info.en == en &&
362 wl->afh_info.ch == ch &&
363 wl->afh_info.bw == bw &&
364 b->profile_cnt.last == b->profile_cnt.now)
365 return;
366
367 wl->afh_info.en = en;
368 wl->afh_info.ch = ch;
369 wl->afh_info.bw = bw;
370 hal_btc_fw_set_bt(btc, SET_BT_WL_CH_INFO, 3, (u8*)&wl->afh_info);
371
372 PHL_TRACE(COMP_PHL_BTC, _PHL_DEBUG_, "[BTC], %s(): en=%d, ch=%d, bw=%d\n",
373 __func__, en, ch, bw);
374 btc->cx.cnt_wl[BTC_WCNT_CH_UPDATE]++;
375 }
376
_set_halbb_btg_ctrl(struct btc_t * btc)377 static void _set_halbb_btg_ctrl(struct btc_t *btc)
378 {
379 struct btc_wl_info *wl = &btc->cx.wl;
380 struct btc_wl_role_info *wl_rinfo = &wl->role_info;
381 struct btc_wl_dbcc_info *wl_dinfo = &wl->dbcc_info;
382 bool is_btg = false;
383
384 if (btc->ctrl.manual)
385 return;
386
387 /* notify halbb ignore GNT_BT or not for WL BB Rx-AGC control */
388 if (wl_rinfo->link_mode == BTC_WLINK_5G) /* always 0 if 5G */
389 is_btg = false;
390 else if (btc->dm.freerun)
391 is_btg = false;
392 else if (wl_rinfo->link_mode == BTC_WLINK_25G_DBCC &&
393 wl_dinfo->real_band[1] != BAND_ON_24G)
394 is_btg = false;
395 else
396 is_btg = true;
397
398 if (!run_rsn("_ntfy_init_coex") && is_btg == btc->dm.wl_btg_rx)
399 return;
400
401 btc->dm.wl_btg_rx = is_btg;
402 /* rtw_hal_bb_ctrl_btg control the following:
403 * if btc->dm.wl_btg_rx = false (gnt_wl always = 1)
404 * Lte_rx: 0x10980[17]=1, 0x10980[29]=0
405 * Gnt_wl: 0x10980[18]=1, 0x10980[28]=1
406 * Gnt_bt_tx: 0x10980[19]=1, 0x10980[27]=0
407 * Gnt_bt: 0x10980[20]=1, 0x10980[26]=0
408 * if if btc->dm.wl_btg_rx = true (gnt from MAC)
409 * Lte_rx: 0x10980[17]=0, 0x10980[29]=0
410 * Gnt_wl: 0x10980[18]=0, 0x10980[28]=1
411 * Gnt_bt_tx: 0x10980[19]=0, 0x10980[27]=0
412 * Gnt_bt: 0x10980[20]=0, 0x10980[26]=0
413 */
414
415 /* skip if MCC dual_band, call ctrl_btg8852a() in WL FW by slot */
416 if (wl_rinfo->link_mode == BTC_WLINK_25G_MCC)
417 return;
418
419 rtw_hal_bb_ctrl_btg(btc->hal, is_btg);
420 }
421
_set_bt_slot_req(struct btc_t * btc)422 static void _set_bt_slot_req(struct btc_t *btc)
423 {
424 struct btc_bt_link_info *b = &btc->cx.bt.link_info;
425 u8 len = 0;
426
427 /* don't change bt slot req state during RFK for p2p/mcc case*/
428 if (!run_rsn("_ntfy_wl_rfk") &&
429 btc->cx.wl.rfk_info.state == BTC_WRFK_STOP)
430 btc->bt_req_en = false;
431
432 /* enable bt-slot req if ext-slot-control */
433 if (btc->dm.tdma_now.type == CXTDMA_OFF &&
434 btc->dm.tdma_now.ext_ctrl == CXECTL_EXT)
435 btc->bt_req_en = true;
436
437 if (!btc->bt_req_en) {
438 len = 0;
439 } else {
440 if (b->a2dp_desc.exist || b->a2dp_desc.active ||
441 (b->profile_cnt.now == 1 &&
442 b->hid_desc.pair_cnt == 1 &&
443 b->multi_link.now)) /*a2dp, hid + acl-idle */ {
444 if (b->profile_cnt.now >= 2)
445 len = BTC_BSLOT_A2DP_HID;
446 else
447 len = BTC_BSLOT_A2DP;
448 } else if (b->pan_desc.exist || b->status.map.inq_pag) {
449 len = BTC_BSLOT_INQ;
450 } else {
451 len = BTC_BSLOT_IDLE;
452 }
453 }
454
455 if (len == btc->bt_req_len)
456 return;
457
458 btc->bt_req_len = len;
459
460 hal_btc_send_event(btc, (u8*)&btc->bt_req_len, 4, BTC_HMSG_SET_BT_REQ_SLOT);
461
462 PHL_INFO("[BTC], %s(): bt_req_len=%d\n", __func__, btc->bt_req_len);
463 }
464
_set_bt_rx_agc(struct btc_t * btc)465 static void _set_bt_rx_agc(struct btc_t *btc)
466 {
467 struct btc_wl_info *wl = &btc->cx.wl;
468 struct btc_wl_role_info *wl_rinfo = &wl->role_info;
469 struct btc_bt_info *bt = &btc->cx.bt;
470 bool bt_hi_lna_rx = false;
471
472 if (wl_rinfo->link_mode != BTC_WLINK_NOLINK && btc->dm.wl_btg_rx)
473 bt_hi_lna_rx = true;
474
475 if (bt_hi_lna_rx == bt->hi_lna_rx)
476 return;
477
478 /* true: bt use Hi-LNA rx gain table (f/e/3/2) in -3x~-9xdBm for co-rx
479 * false: bt use original rx gain table (f/b/7/3/2)
480 */
481
482 _write_scbd(btc, BTC_WSCB_BT_HILNA, bt_hi_lna_rx);
483 }
484
_set_bt_rx_scan_pri(struct btc_t * btc)485 static void _set_bt_rx_scan_pri(struct btc_t *btc)
486 {
487 struct btc_bt_info *bt = &btc->cx.bt;
488
489 _write_scbd(btc, BTC_WSCB_RXSCAN_PRI, (bool)(!!bt->scan_rx_low_pri));
490 }
491
_set_halmac_tx_limit(struct btc_t * btc)492 static void _set_halmac_tx_limit(struct btc_t *btc)
493 {
494 struct btc_cx *cx = &btc->cx;
495 struct btc_dm *dm = &btc->dm;
496 struct btc_wl_info *wl = &cx->wl;
497 struct btc_bt_info *bt = &cx->bt;
498 struct btc_bt_link_info *b = &bt->link_info;
499 struct btc_bt_hfp_desc *hfp = &b->hfp_desc;
500 struct btc_bt_hid_desc *hid = &b->hid_desc;
501 struct btc_wl_role_info *wl_rinfo = &wl->role_info;
502 struct btc_wl_link_info *plink = NULL;
503 u8 mode = wl_rinfo->link_mode, i, tx_1ss_limit = 0, tx_1ss_en = 0;
504 u8 tx_retry = 0, enable = 0, reenable = 0;
505 u32 tx_time = 0;
506
507 if (btc->ctrl.manual)
508 return;
509
510 if (mode == BTC_WLINK_2G_GO ||
511 mode == BTC_WLINK_2G_GC ||
512 mode == BTC_WLINK_2G_SCC ||
513 mode == BTC_WLINK_2G_MCC ||
514 mode == BTC_WLINK_25G_MCC) {
515 if (hfp->exist || hid->exist)
516 tx_1ss_limit = 1;
517 else
518 tx_1ss_limit = 0;
519 } else {
520 tx_1ss_limit = 0;
521 }
522
523 dm->wl_tx_limit.tx_1ss = tx_1ss_limit;
524
525 for (i = 0; i < MAX_WIFI_ROLE_NUMBER; i++) {
526
527 plink = &wl->link_info[i];
528
529 if (plink->connected == MLME_LINKED &&
530 plink->chdef.band == BAND_ON_24G)
531 tx_1ss_en = tx_1ss_limit;
532 else
533 tx_1ss_en = false;
534
535 if (tx_1ss_en != plink->stat.traffic.tx_1ss_limit)
536 rtw_hal_btc_cfg_tx_1ss(btc->hal, btc->phl,
537 i, tx_1ss_en);
538 }
539
540 if (btc->dm.freerun || btc->ctrl.igno_bt || b->profile_cnt.now == 0 ||
541 mode == BTC_WLINK_5G || mode == BTC_WLINK_NOLINK) {
542 enable = 0;
543 tx_time = BTC_MAX_TX_TIME_DEF;
544 tx_retry = BTC_MAX_TX_RETRY_DEF;
545 } else if ((hfp->exist && hid->exist) || hid->pair_cnt > 1) {
546 enable = 1;
547 tx_time = BTC_MAX_TX_TIME_L2;
548 tx_retry = BTC_MAX_TX_RETRY_L1;
549 } else if (hfp->exist || hid->exist) {
550 enable = 1;
551 tx_time = BTC_MAX_TX_TIME_L3;
552 tx_retry = BTC_MAX_TX_RETRY_L1;
553 } else {
554 enable = 0;
555 tx_time = BTC_MAX_TX_TIME_DEF;
556 tx_retry = BTC_MAX_TX_RETRY_DEF;
557 }
558
559 if (dm->wl_tx_limit.en == enable &&
560 dm->wl_tx_limit.tx_time == tx_time &&
561 dm->wl_tx_limit.tx_retry == tx_retry)
562 return;
563
564 if (!dm->wl_tx_limit.en && enable)
565 reenable = 1;
566
567 dm->wl_tx_limit.en = enable;
568 dm->wl_tx_limit.tx_time = tx_time;
569 dm->wl_tx_limit.tx_retry = tx_retry;
570
571 for (i = 0; i < MAX_WIFI_ROLE_NUMBER; i++) {
572
573 plink = &wl->link_info[i];
574
575 if (!plink->connected)
576 continue;
577
578 /* backup the original tx time before tx-limit on */
579 if (reenable) {
580 rtw_hal_mac_get_tx_time(btc->hal,
581 (u8)plink->mac_id,
582 &plink->tx_time);
583 rtw_hal_mac_get_tx_retry_limit(btc->hal,
584 (u8)plink->mac_id,
585 &plink->tx_retry);
586 }
587
588 /* restore the original tx time if no tx-limit */
589 if (!enable) {
590 rtw_hal_mac_set_tx_time(btc->hal, 1, 1,
591 (u8)plink->mac_id,
592 plink->tx_time);
593 rtw_hal_mac_set_tx_retry_limit(btc->hal, 1, 1,
594 (u8)plink->mac_id,
595 plink->tx_retry);
596 } else {
597 rtw_hal_mac_set_tx_time(btc->hal, 1, 0,
598 (u8)plink->mac_id, tx_time);
599 rtw_hal_mac_set_tx_retry_limit(btc->hal, 1, 0,
600 (u8)plink->mac_id,
601 tx_retry);
602 }
603 }
604 }
605
_check_freerun(struct btc_t * btc)606 static bool _check_freerun(struct btc_t *btc)
607 {
608 struct btc_wl_info *wl = &btc->cx.wl;
609 struct btc_bt_info *bt = &btc->cx.bt;
610 struct btc_wl_role_info *wl_rinfo = &wl->role_info;
611 struct btc_bt_link_info *bt_linfo = &bt->link_info;
612 struct btc_bt_hid_desc *hid = &bt_linfo->hid_desc;
613 u8 max_role_cnt = BTC_TDMA_WLROLE_MAX;
614
615 if (btc->hal->dbcc_en)
616 max_role_cnt++;
617
618 if (btc->mdinfo.ant.type == BTC_ANT_SHARED) {
619 btc->dm.trx_para_level = 0;
620 return false;
621 }
622
623 /* The below is dedicated antenna case */
624
625 if (wl_rinfo->connect_cnt > max_role_cnt) {
626 btc->dm.trx_para_level = 5;
627 return true;
628 }
629
630 if (bt_linfo->profile_cnt.now == 0) {
631 btc->dm.trx_para_level = 5;
632 return true;
633 }
634
635 if (hid->pair_cnt > BTC_TDMA_BTHID_MAX) {
636 btc->dm.trx_para_level = 5;
637 return true;
638 }
639
640 /* Todo: get isolation by BT psd */
641 if (btc->mdinfo.ant.isolation >= BTC_FREERUN_ANTISO_MIN) {
642 btc->dm.trx_para_level = 5;
643 return true;
644 }
645
646 if (!wl->status.map.busy) {/* wl idle -> freerun */
647 btc->dm.trx_para_level = 5;
648 return true;
649 } else if (wl->rssi_level > 1) {/* WL rssi < 50% (-60dBm) */
650 btc->dm.trx_para_level = 0;
651 return false;
652 } else if (wl->status.map.traffic_dir & BIT(TRAFFIC_UL)) { /* uplink */
653 if (wl->rssi_level == 0 && bt_linfo->rssi > 31) {
654 btc->dm.trx_para_level = 6;
655 return true;
656 } else if (wl->rssi_level == 1 && bt_linfo->rssi > 36) {
657 btc->dm.trx_para_level = 7;
658 return true;
659 } else {
660 btc->dm.trx_para_level = 0;
661 return false;
662 }
663 } else if (wl->status.map.traffic_dir & BIT(TRAFFIC_DL)) { /*downlink*/
664 if (bt_linfo->rssi > 28) {
665 btc->dm.trx_para_level = 6;
666 return true;
667 }
668 }
669
670 btc->dm.trx_para_level = 0;
671 return false;
672 }
673
_set_policy(struct btc_t * btc,u16 policy_type,const char * action)674 static void _set_policy(struct btc_t *btc, u16 policy_type, const char* action)
675 {
676 struct btc_dm *dm = &btc->dm;
677 struct fbtc_tdma *t = &dm->tdma;
678 struct fbtc_slot *s = dm->slot;
679 struct btc_wl_role_info *wl_rinfo = &btc->cx.wl.role_info;
680 struct btc_bt_hid_desc *hid = &btc->cx.bt.link_info.hid_desc;
681 u8 type, null_role = 0;
682 u16 dur = 0;
683 u32 tbl_w1, tbl_b1, tbl_b4;
684 bool mode = NM_EXEC;
685
686 type = (u8)((policy_type & bMASKB1) >> 8);
687
688 if (btc->mdinfo.ant.type == BTC_ANT_SHARED) {
689 if (btc->cx.wl.status.map._4way)
690 tbl_w1 = cxtbl[1];
691 else if (hid->exist && hid->type == BTC_HID_218)
692 tbl_w1 = cxtbl[7]; /* Ack/BA no break bt Hi-Pri-rx */
693 else
694 tbl_w1 = cxtbl[8];
695
696 if (dm->leak_ap &&
697 (type == BTC_CXP_PFIX || type == BTC_CXP_PAUTO2)) {
698 tbl_b1 = cxtbl[3];
699 tbl_b4 = cxtbl[3];
700 } else if (hid->exist && hid->type == BTC_HID_218) {
701 tbl_b1 = cxtbl[4]; /* Ack/BA no break bt Hi-Pri-rx */
702 tbl_b4 = cxtbl[4];
703 } else {
704 tbl_b1 = cxtbl[2];
705 tbl_b4 = cxtbl[2];
706 }
707 } else {
708 tbl_w1 = cxtbl[16]; /* 19 for HID exist */
709 tbl_b1 = cxtbl[17];
710 tbl_b4 = cxtbl[17];
711 }
712
713 switch(type) {
714 case BTC_CXP_USERDEF0:
715 mode = FC_EXEC;
716 _tdma_cpy(t, &t_def[CXTD_OFF]);
717 _slot_cpy(&s[CXST_OFF], &s_def[CXST_OFF]);
718 _slot_set_tbl(CXST_OFF, cxtbl[2]);
719 break;
720 case BTC_CXP_OFF: /* TDMA off */
721 _write_scbd(btc, BTC_WSCB_TDMA, false);
722 _tdma_cpy(t, &t_def[CXTD_OFF]);
723 _slot_cpy(&s[CXST_OFF], &s_def[CXST_OFF]);
724
725 switch (policy_type) {
726 case BTC_CXP_OFF_BT:
727 _slot_set_tbl(CXST_OFF, cxtbl[2]);
728 break;
729 case BTC_CXP_OFF_WL:
730 _slot_set_tbl(CXST_OFF, cxtbl[1]);
731 break;
732 case BTC_CXP_OFF_EQ0:
733 _slot_set_tbl(CXST_OFF, cxtbl[0]);
734 break;
735 case BTC_CXP_OFF_EQ1:
736 _slot_set_tbl(CXST_OFF, cxtbl[16]);
737 break;
738 case BTC_CXP_OFF_EQ2:
739 _slot_set_tbl(CXST_OFF, cxtbl[17]);
740 break;
741 case BTC_CXP_OFF_EQ3:
742 _slot_set_tbl(CXST_OFF, cxtbl[18]);
743 break;
744 case BTC_CXP_OFF_BWB0:
745 _slot_set_tbl(CXST_OFF, cxtbl[5]);
746 break;
747 case BTC_CXP_OFF_BWB1:
748 _slot_set_tbl(CXST_OFF, cxtbl[8]);
749 break;
750 case BTC_CXP_OFF_BWB2:
751 _slot_set_tbl(CXST_OFF, cxtbl[7]);
752 break;
753 }
754 break;
755 case BTC_CXP_OFFB: /* TDMA off + beacon protect */
756 _write_scbd(btc, BTC_WSCB_TDMA, false);
757 _tdma_cpy(t, &t_def[CXTD_OFF_B2]);
758 _slot_cpy(&s[CXST_OFF], &s_def[CXST_OFF]);
759 switch (policy_type) {
760 case BTC_CXP_OFFB_BWB0:
761 _slot_set_tbl(CXST_OFF, cxtbl[8]);
762 break;
763 }
764 break;
765 case BTC_CXP_OFFE: /* TDMA off + beacon protect + Ext_control */
766 _write_scbd(btc, BTC_WSCB_TDMA, true);
767 _tdma_cpy(t, &t_def[CXTD_OFF_EXT]);
768
769 if (wl_rinfo->link_mode == BTC_WLINK_2G_SCC &&
770 dm->wl_scc.ebt_null) {
771 _tdma_set_rxflctrl(1);
772 _tdma_set_txflctrl(1);
773 if ((wl_rinfo->mrole_noa_duration > 0) &&
774 (wl_rinfo->mrole_noa_duration +
775 2 * BTC_NULL1_EBT_EARLY_T < BTC_SCC_CYCLE))
776 dur = BTC_SCC_CYCLE - BTC_NULL1_EBT_EARLY_T -
777 wl_rinfo->mrole_noa_duration;
778 }
779
780 switch (policy_type) {
781 case BTC_CXP_OFFE_2GBWISOB: /* for normal-case */
782 _slot_set(CXST_E2G, dur, tbl_w1, SLOT_ISO);
783 _slot_cpy(&s[CXST_EBT], &s_def[CXST_EBT]);
784 break;
785 case BTC_CXP_OFFE_2GISOB: /* for bt no-link */
786 _slot_set(CXST_E2G, dur, cxtbl[1], SLOT_ISO);
787 _slot_cpy(&s[CXST_EBT], &s_def[CXST_EBT]);
788 break;
789 case BTC_CXP_OFFE_2GBWMIXB: /* for GC-only NOA < bt_slot_req */
790 _slot_set(CXST_E2G, dur, tbl_w1, SLOT_MIX);
791 _slot_cpy(&s[CXST_EBT], &s_def[CXST_EBT]);
792 break;
793 case BTC_CXP_OFFE_2GBWMIXB2: /* for GC+STA NOA < bt_slot_req */
794 _slot_set(CXST_E2G, dur, tbl_w1, SLOT_MIX);
795 _slot_set(CXST_EBT, BTC_BSLOT_A2DP_HID,
796 cxtbl[2], SLOT_MIX);
797 break;
798 case BTC_CXP_OFFE_WL: /*for 4-way */
799 _slot_set(CXST_E2G, dur, cxtbl[1], SLOT_MIX);
800 _slot_set(CXST_EBT, 0, cxtbl[1], SLOT_MIX);
801 break;
802 }
803
804 _slot_cpy(&s[CXST_E5G], &s_def[CXST_E5G]);
805 _slot_cpy(&s[CXST_ENULL], &s_def[CXST_ENULL]);
806 break;
807 case BTC_CXP_FIX: /* TDMA Fix-Slot */
808 _write_scbd(btc, BTC_WSCB_TDMA, true);
809 _tdma_cpy(t, &t_def[CXTD_FIX]);
810 switch (policy_type) {
811 case BTC_CXP_FIX_TD3030: /* W1:B1 = 30:30 */
812 _slot_set(CXST_W1, 30, tbl_w1, SLOT_ISO);
813 _slot_set(CXST_B1, 30, tbl_b1, SLOT_MIX);
814 break;
815 case BTC_CXP_FIX_TD5050: /* W1:B1 = 50:50 */
816 _slot_set(CXST_W1, 50, tbl_w1, SLOT_ISO);
817 _slot_set(CXST_B1, 50, tbl_b1, SLOT_MIX);
818 break;
819 case BTC_CXP_FIX_TD2030: /* W1:B1 = 20:30 */
820 _slot_set(CXST_W1, 20, tbl_w1, SLOT_ISO);
821 _slot_set(CXST_B1, 30, tbl_b1, SLOT_MIX);
822 break;
823 case BTC_CXP_FIX_TD4010: /* W1:B1 = 40:10 */
824 _slot_set(CXST_W1, 40, tbl_w1, SLOT_ISO);
825 _slot_set(CXST_B1, 10, tbl_b1, SLOT_MIX);
826 break;
827 case BTC_CXP_FIX_TD4010ISO: /* W1:B1 = 40:10 for WL busy/scan */
828 _slot_set(CXST_W1, 40, cxtbl[1], SLOT_ISO);
829 _slot_set(CXST_B1, 10, tbl_b1, SLOT_MIX);
830 break;
831 case BTC_CXP_FIX_TD7010: /* W1:B1 = 70:10 */
832 _slot_set(CXST_W1, 70, tbl_w1, SLOT_ISO);
833 _slot_set(CXST_B1, 10, tbl_b1, SLOT_MIX);
834 break;
835 case BTC_CXP_FIX_TD2060: /* W1:B1 = 20:60 */
836 _slot_set(CXST_W1, 20, tbl_w1, SLOT_ISO);
837 _slot_set(CXST_B1, 60, tbl_b1, SLOT_MIX);
838 break;
839 case BTC_CXP_FIX_TD3060: /* W1:B1 = 30:60 */
840 _slot_set(CXST_W1, 30, tbl_w1, SLOT_ISO);
841 _slot_set(CXST_B1, 60, tbl_b1, SLOT_MIX);
842 break;
843 case BTC_CXP_FIX_TD2080: /* W1:B1 = 20:80 */
844 _slot_set(CXST_W1, 20, tbl_w1, SLOT_ISO);
845 _slot_set(CXST_B1, 80, tbl_b1, SLOT_MIX);
846 break;
847 case BTC_CXP_FIX_TDW1B1: /* W1:B1 = user-define */
848 _slot_set(CXST_W1, dm->slot_dur[CXST_W1],
849 tbl_w1, SLOT_ISO);
850 _slot_set(CXST_B1, dm->slot_dur[CXST_B1],
851 tbl_b1, SLOT_MIX);
852 break;
853 }
854 break;
855 case BTC_CXP_PFIX: /* PS-TDMA Fix-Slot */
856 _write_scbd(btc, BTC_WSCB_TDMA, true);
857 _tdma_cpy(t, &t_def[CXTD_PFIX]);
858
859 switch (policy_type) {
860 case BTC_CXP_PFIX_TD3030: /* W1:B1 = 30:30 */
861 _slot_set(CXST_W1, 30, tbl_w1, SLOT_ISO);
862 _slot_set(CXST_B1, 30, tbl_b1, SLOT_MIX);
863 break;
864 case BTC_CXP_PFIX_TD5050: /* W1:B1 = 50:50 */
865 _slot_set(CXST_W1, 50, tbl_w1, SLOT_ISO);
866 _slot_set(CXST_B1, 50, tbl_b1, SLOT_MIX);
867 break;
868 case BTC_CXP_PFIX_TD2030: /* W1:B1 = 20:30 */
869 _slot_set(CXST_W1, 20, tbl_w1, SLOT_ISO);
870 _slot_set(CXST_B1, 30, tbl_b1, SLOT_MIX);
871 break;
872 case BTC_CXP_PFIX_TD2060: /* W1:B1 = 20:60 */
873 _slot_set(CXST_W1, 20, tbl_w1, SLOT_ISO);
874 _slot_set(CXST_B1, 60, tbl_b1, SLOT_MIX);
875 break;
876 case BTC_CXP_PFIX_TD3070: /* W1:B1 = 30:60 */
877 _slot_set(CXST_W1, 30, tbl_w1, SLOT_ISO);
878 _slot_set(CXST_B1, 60, tbl_b1, SLOT_MIX);
879 break;
880 case BTC_CXP_PFIX_TD2080: /* W1:B1 = 20:80 */
881 _slot_set(CXST_W1, 20, tbl_w1, SLOT_ISO);
882 _slot_set(CXST_B1, 80, tbl_b1, SLOT_MIX);
883 break;
884 case BTC_CXP_PFIX_TDW1B1: /* W1:B1 = user-define */
885 _slot_set(CXST_W1, dm->slot_dur[CXST_W1],
886 tbl_w1, SLOT_ISO);
887 _slot_set(CXST_B1, dm->slot_dur[CXST_B1],
888 tbl_b1, SLOT_MIX);
889 break;
890 }
891 break;
892 case BTC_CXP_AUTO: /* TDMA Auto-Slot */
893 _write_scbd(btc, BTC_WSCB_TDMA, true);
894 _tdma_cpy(t, &t_def[CXTD_AUTO]);
895 switch (policy_type) {
896 case BTC_CXP_AUTO_TD50B1: /* W1:B1 = 50:BTC_B1_MAX */
897 _slot_set(CXST_W1, 50, tbl_w1, SLOT_ISO);
898 _slot_set(CXST_B1, BTC_B1_MAX, tbl_b1, SLOT_MIX);
899 break;
900 case BTC_CXP_AUTO_TD60B1: /* W1:B1 = 60:BTC_B1_MAX */
901 _slot_set(CXST_W1, 60, tbl_w1, SLOT_ISO);
902 _slot_set(CXST_B1, BTC_B1_MAX, tbl_b1, SLOT_MIX);
903 break;
904 case BTC_CXP_AUTO_TD20B1: /* W1:B1 = 20:BTC_B1_MAX */
905 _slot_set(CXST_W1, 20, tbl_w1, SLOT_ISO);
906 _slot_set(CXST_B1, BTC_B1_MAX, tbl_b1, SLOT_MIX);
907 break;
908 case BTC_CXP_AUTO_TDW1B1: /* W1:B1 = user-define */
909 _slot_set(CXST_W1, dm->slot_dur[CXST_W1],
910 tbl_w1, SLOT_ISO);
911 _slot_set(CXST_B1, dm->slot_dur[CXST_B1],
912 tbl_b1, SLOT_MIX);
913 break;
914 }
915 break;
916 case BTC_CXP_PAUTO: /* PS-TDMA Auto-Slot */
917 _write_scbd(btc, BTC_WSCB_TDMA, true);
918 _tdma_cpy(t, &t_def[CXTD_PAUTO]);
919 switch (policy_type) {
920 case BTC_CXP_PAUTO_TD50B1: /* W1:B1 = 50:BTC_B1_MAX */
921 _slot_set(CXST_W1, 50, tbl_w1, SLOT_ISO);
922 _slot_set(CXST_B1, BTC_B1_MAX, tbl_b1, SLOT_MIX);
923 break;
924 case BTC_CXP_PAUTO_TD60B1: /* W1:B1 = 60:BTC_B1_MAX */
925 _slot_set(CXST_W1, 60, tbl_w1, SLOT_ISO);
926 _slot_set(CXST_B1, BTC_B1_MAX, tbl_b1, SLOT_MIX);
927 break;
928 case BTC_CXP_PAUTO_TD20B1: /* W1:B1 = 20:BTC_B1_MAX */
929 _slot_set(CXST_W1, 20, tbl_w1, SLOT_ISO);
930 _slot_set(CXST_B1, BTC_B1_MAX, tbl_b1, SLOT_MIX);
931 break;
932 case BTC_CXP_PAUTO_TDW1B1: /* W1:B1 = user-define */
933 _slot_set(CXST_W1, dm->slot_dur[CXST_W1],
934 tbl_w1, SLOT_ISO);
935 _slot_set(CXST_B1, dm->slot_dur[CXST_B1],
936 tbl_b1, SLOT_MIX);
937 break;
938 }
939 break;
940 case BTC_CXP_AUTO2: /* TDMA Auto-Slot2 */
941 _write_scbd(btc, BTC_WSCB_TDMA, true);
942 _tdma_cpy(t, &t_def[CXTD_AUTO2]);
943 switch (policy_type) {
944 case BTC_CXP_AUTO2_TD3050: /* W1:B4 = 30:50 */
945 _slot_set(CXST_W1, 30, tbl_w1, SLOT_ISO);
946 _slot_set(CXST_B1, BTC_B1_MAX, tbl_b1, SLOT_MIX);
947 _slot_set(CXST_B4, 50, tbl_b4, SLOT_MIX);
948 break;
949 case BTC_CXP_AUTO2_TD3070: /* W1:B4 = 30:70 */
950 _slot_set(CXST_W1, 30, tbl_w1, SLOT_ISO);
951 _slot_set(CXST_B1, BTC_B1_MAX, tbl_b1, SLOT_MIX);
952 _slot_set(CXST_B4, 70, tbl_b4, SLOT_MIX);
953 break;
954 case BTC_CXP_AUTO2_TD5050: /* W1:B4 = 50:50 */
955 _slot_set(CXST_W1, 50, tbl_w1, SLOT_ISO);
956 _slot_set(CXST_B1, BTC_B1_MAX, tbl_b1, SLOT_MIX);
957 _slot_set(CXST_B4, 50, tbl_b4, SLOT_MIX);
958 break;
959 case BTC_CXP_AUTO2_TD6060: /* W1:B4 = 60:60 */
960 _slot_set(CXST_W1, 60, tbl_w1, SLOT_ISO);
961 _slot_set(CXST_B1, BTC_B1_MAX, tbl_b1, SLOT_MIX);
962 _slot_set(CXST_B4, 60, tbl_b4, SLOT_MIX);
963 break;
964 case BTC_CXP_AUTO2_TD2080: /* W1:B4 = 20:80 */
965 _slot_set(CXST_W1, 20, tbl_w1, SLOT_ISO);
966 _slot_set(CXST_B1, BTC_B1_MAX, tbl_b1, SLOT_MIX);
967 _slot_set(CXST_B4, 80, tbl_b4, SLOT_MIX);
968 break;
969 case BTC_CXP_AUTO2_TDW1B4: /* W1:B1 = user-define */
970 _slot_set(CXST_W1, dm->slot_dur[CXST_W1],
971 tbl_w1, SLOT_ISO);
972 _slot_set(CXST_B1, dm->slot_dur[CXST_B1],
973 tbl_b1, SLOT_MIX);
974 _slot_set(CXST_B4, dm->slot_dur[CXST_B4],
975 tbl_b4, SLOT_MIX);
976 break;
977 }
978 break;
979 case BTC_CXP_PAUTO2: /* PS-TDMA Auto-Slot2 */
980 _write_scbd(btc, BTC_WSCB_TDMA, true);
981 _tdma_cpy(t, &t_def[CXTD_PAUTO2]);
982 switch (policy_type) {
983 case BTC_CXP_PAUTO2_TD3050: /* W1:B4 = 30:50 */
984 _slot_set(CXST_W1, 30, tbl_w1, SLOT_ISO);
985 _slot_set(CXST_B1, BTC_B1_MAX, tbl_b1, SLOT_MIX);
986 _slot_set(CXST_B4, 50, tbl_b4, SLOT_MIX);
987 break;
988 case BTC_CXP_PAUTO2_TD3070: /* W1:B4 = 30:70 */
989 _slot_set(CXST_W1, 30, tbl_w1, SLOT_ISO);
990 _slot_set(CXST_B1, BTC_B1_MAX, cxtbl[3], SLOT_MIX);
991 _slot_set(CXST_B4, 70, tbl_b4, SLOT_MIX);
992 break;
993 case BTC_CXP_PAUTO2_TD5050: /* W1:B4 = 50:50 */
994 _slot_set(CXST_W1, 50, tbl_w1, SLOT_ISO);
995 _slot_set(CXST_B1, BTC_B1_MAX, tbl_b1, SLOT_MIX);
996 _slot_set(CXST_B4, 50, tbl_b4, SLOT_MIX);
997 break;
998 case BTC_CXP_PAUTO2_TD6060: /* W1:B4 = 60:60 */
999 _slot_set(CXST_W1, 60, tbl_w1, SLOT_ISO);
1000 _slot_set(CXST_B1, BTC_B1_MAX, tbl_b1, SLOT_MIX);
1001 _slot_set(CXST_B4, 60, tbl_b4, SLOT_MIX);
1002 break;
1003 case BTC_CXP_PAUTO2_TD2080: /* W1:B4 = 20:80 */
1004 _slot_set(CXST_W1, 20, tbl_w1, SLOT_ISO);
1005 _slot_set(CXST_B1, BTC_B1_MAX, tbl_b1, SLOT_MIX);
1006 _slot_set(CXST_B4, 80, tbl_b4, SLOT_MIX);
1007 break;
1008 case BTC_CXP_PAUTO2_TDW1B4: /* W1:B1 = user-define */
1009 _slot_set(CXST_W1, dm->slot_dur[CXST_W1],
1010 tbl_w1, SLOT_ISO);
1011 _slot_set(CXST_B1, dm->slot_dur[CXST_B1],
1012 tbl_b1, SLOT_MIX);
1013 _slot_set(CXST_B4, dm->slot_dur[CXST_B4],
1014 tbl_b4, SLOT_MIX);
1015 break;
1016 }
1017 break;
1018 }
1019
1020 if (wl_rinfo->link_mode == BTC_WLINK_2G_SCC && dm->tdma.rxflctrl) {
1021 null_role = (dm->wl_scc.null_role1 & 0xf) +
1022 ((dm->wl_scc.null_role2 & 0xf) << 4);
1023 _tdma_set_flctrl_role(null_role);
1024 }
1025
1026 /* enter leak_slot after each null-1 */
1027 if (dm->leak_ap && dm->tdma.leak_n > 1)
1028 _tdma_set_lek(1);
1029
1030 if (run_rsn("_cmd_set_coex"))
1031 mode = FC_EXEC;
1032
1033 _update_poicy(btc, mode, policy_type, action);
1034 }
1035
_set_gnt_wl(struct btc_t * btc,u8 phy_map,u8 state)1036 void _set_gnt_wl(struct btc_t *btc, u8 phy_map, u8 state)
1037 {
1038 struct rtw_hal_com_t *h = btc->hal;
1039 struct btc_dm *dm = &btc->dm;
1040 struct btc_gnt_ctrl *g = dm->gnt;
1041 u8 i;
1042
1043 if (phy_map > BTC_PHY_ALL)
1044 return;
1045
1046 for (i = 0; i < BTC_PHY_MAX; i++) {
1047 if (!(phy_map & BIT(i)))
1048 continue;
1049
1050 switch (state) {
1051 case BTC_GNT_HW:
1052 g[i].gnt_wl_sw_en = 0;
1053 g[i].gnt_wl = 0;
1054 break;
1055 case BTC_GNT_SW_LO:
1056 g[i].gnt_wl_sw_en = 1;
1057 g[i].gnt_wl = 0;
1058 break;
1059 case BTC_GNT_SW_HI:
1060 g[i].gnt_wl_sw_en = 1;
1061 g[i].gnt_wl = 1;
1062 break;
1063 }
1064 }
1065
1066 rtw_hal_mac_set_grant(h, (u8*)g);
1067 }
1068
_set_gnt_bt(struct btc_t * btc,u8 phy_map,u8 state)1069 void _set_gnt_bt(struct btc_t *btc, u8 phy_map, u8 state)
1070 {
1071 struct rtw_hal_com_t *h = btc->hal;
1072 struct btc_dm *dm = &btc->dm;
1073 struct btc_gnt_ctrl *g = dm->gnt;
1074 u8 i;
1075
1076 if (phy_map > BTC_PHY_ALL)
1077 return;
1078
1079 for (i = 0; i < BTC_PHY_MAX; i++) {
1080 if (!(phy_map & BIT(i)))
1081 continue;
1082
1083 switch (state) {
1084 case BTC_GNT_HW:
1085 g[i].gnt_bt_sw_en = 0;
1086 g[i].gnt_bt = 0;
1087 break;
1088 case BTC_GNT_SW_LO:
1089 g[i].gnt_bt_sw_en = 1;
1090 g[i].gnt_bt = 0;
1091 break;
1092 case BTC_GNT_SW_HI:
1093 g[i].gnt_bt_sw_en = 1;
1094 g[i].gnt_bt = 1;
1095 break;
1096 }
1097 }
1098
1099 rtw_hal_mac_set_grant(h, (u8*)g);
1100 }
1101
_set_bt_plut(struct btc_t * btc,u8 phy_map,u8 tx_val,u8 rx_val)1102 static void _set_bt_plut(struct btc_t *btc, u8 phy_map, u8 tx_val, u8 rx_val)
1103 {
1104 if (phy_map & BTC_PHY_0) {
1105 rtw_hal_mac_set_polluted(btc->hal, HW_PHY_0, tx_val, rx_val);
1106 btc->cx.wl.bt_polut_type[HW_PHY_0] = tx_val;
1107 }
1108
1109 if (!btc->hal->dbcc_en)
1110 return;
1111
1112 if (phy_map & BTC_PHY_1) {
1113 rtw_hal_mac_set_polluted(btc->hal, HW_PHY_1, tx_val, rx_val);
1114 btc->cx.wl.bt_polut_type[HW_PHY_1] = tx_val;
1115 }
1116 }
1117
_set_ant(struct btc_t * btc,bool force_exec,u8 phy_map,u8 type)1118 static void _set_ant(struct btc_t *btc, bool force_exec, u8 phy_map, u8 type)
1119 {
1120 struct btc_dm *dm = &btc->dm;
1121 struct btc_cx *cx = &btc->cx;
1122 struct btc_wl_info *wl = &cx->wl;
1123 struct btc_bt_info *bt = &cx->bt;
1124 struct btc_wl_dbcc_info *wl_dinfo = &wl->dbcc_info;
1125 u8 gnt_wl_ctrl, gnt_bt_ctrl, plt_ctrl, i, b2g = 0;
1126 u32 ant_path_type;
1127
1128 ant_path_type = ((phy_map << 8) + type);
1129
1130 if (run_rsn("_cmd_set_coex") || run_rsn("_ntfy_power_off") ||
1131 run_rsn("_ntfy_radio_state"))
1132 force_exec = FC_EXEC;
1133
1134 if (!force_exec && (ant_path_type == dm->set_ant_path)) {
1135 PHL_TRACE(COMP_PHL_BTC, _PHL_DEBUG_, "[BTC], %s(): return by no change!!\n",
1136 __func__);
1137 return;
1138 } else if (bt->rfk_info.map.run) {
1139 PHL_INFO("[BTC], %s(): return by bt rfk!!\n", __func__);
1140 return;
1141 } else if (!run_rsn("_ntfy_wl_rfk") &&
1142 wl->rfk_info.state != BTC_WRFK_STOP) {
1143 PHL_INFO("[BTC], %s(): return by wl rfk!!\n", __func__);
1144 return;
1145 }
1146
1147 dm->set_ant_path = ant_path_type;
1148
1149 PHL_INFO("[BTC], %s(): path=0x%x, set_type=%s\n", __func__,
1150 phy_map, id_to_str(BTC_STR_ANTPATH, dm->set_ant_path & 0xff));
1151
1152 switch (type){
1153 case BTC_ANT_WPOWERON:
1154 _set_cx_ctrl(btc, BTC_CTRL_BY_BT);
1155 break;
1156 case BTC_ANT_WINIT:
1157 /* To avoid BT MP driver case (bt_enable but no mailbox) */
1158 if (bt->enable.now && bt->run_patch_code) {
1159 _set_gnt_wl(btc, phy_map, BTC_GNT_SW_LO);
1160 _set_gnt_bt(btc, phy_map, BTC_GNT_SW_HI);
1161 } else {
1162 _set_gnt_wl(btc, phy_map, BTC_GNT_SW_HI);
1163 _set_gnt_bt(btc, phy_map, BTC_GNT_SW_LO);
1164 }
1165 _set_cx_ctrl(btc, BTC_CTRL_BY_WL);
1166 _set_bt_plut(btc, BTC_PHY_ALL, BTC_PLT_BT, BTC_PLT_BT);
1167 break;
1168 case BTC_ANT_WONLY:
1169 _set_gnt_wl(btc, phy_map, BTC_GNT_SW_HI);
1170 _set_gnt_bt(btc, phy_map, BTC_GNT_SW_LO);
1171 _set_cx_ctrl(btc, BTC_CTRL_BY_WL);
1172 _set_bt_plut(btc, BTC_PHY_ALL, BTC_PLT_NONE, BTC_PLT_NONE);
1173 break;
1174 case BTC_ANT_WOFF:
1175 _set_cx_ctrl(btc, BTC_CTRL_BY_BT);
1176 _set_bt_plut(btc, BTC_PHY_ALL, BTC_PLT_NONE, BTC_PLT_NONE);
1177 break;
1178 case BTC_ANT_W2G:
1179 _set_cx_ctrl(btc, BTC_CTRL_BY_WL);
1180 if (btc->hal->dbcc_en) {
1181 for (i = 0; i < HW_PHY_MAX; i++) {
1182 b2g = (wl_dinfo->real_band[i] == BAND_ON_24G);
1183
1184 gnt_wl_ctrl = (b2g? BTC_GNT_HW : BTC_GNT_SW_HI);
1185 _set_gnt_wl(btc, BIT(i), gnt_wl_ctrl);
1186
1187 gnt_bt_ctrl = BTC_GNT_HW;
1188 _set_gnt_bt(btc, BIT(i), gnt_bt_ctrl);
1189
1190 plt_ctrl = (b2g? BTC_PLT_BT : BTC_PLT_NONE);
1191 _set_bt_plut(btc, BIT(i), plt_ctrl, plt_ctrl);
1192 }
1193 } else {
1194 _set_gnt_wl(btc, phy_map, BTC_GNT_HW);
1195 _set_gnt_bt(btc, phy_map, BTC_GNT_HW);
1196 plt_ctrl = BTC_PLT_BT;
1197 _set_bt_plut(btc, BTC_PHY_ALL, plt_ctrl, plt_ctrl);
1198 }
1199 break;
1200 case BTC_ANT_W5G:
1201 _set_cx_ctrl(btc, BTC_CTRL_BY_WL);
1202 _set_gnt_wl(btc, phy_map, BTC_GNT_SW_HI);
1203 _set_gnt_bt(btc, phy_map, BTC_GNT_HW);
1204 _set_bt_plut(btc, BTC_PHY_ALL, BTC_PLT_NONE, BTC_PLT_NONE);
1205 break;
1206 case BTC_ANT_W25G:
1207 _set_cx_ctrl(btc, BTC_CTRL_BY_WL);
1208 if (btc->hal->dbcc_en) {
1209 /* if BAND_ON_24G, the other role in the sane PHY = 5G*/
1210 for (i = 0; i < HW_PHY_MAX; i++) {
1211 b2g = (wl_dinfo->real_band[i] == BAND_ON_24G);
1212
1213 gnt_wl_ctrl = (b2g? BTC_GNT_HW : BTC_GNT_SW_HI);
1214 _set_gnt_wl(btc, BIT(i), gnt_wl_ctrl);
1215
1216 gnt_bt_ctrl = BTC_GNT_HW;
1217 _set_gnt_bt(btc, BIT(i), gnt_bt_ctrl);
1218
1219 plt_ctrl = (b2g? BTC_PLT_GNT_WL : BTC_PLT_NONE);
1220 _set_bt_plut(btc, BIT(i), plt_ctrl, plt_ctrl);
1221 }
1222 } else {
1223 _set_gnt_wl(btc, phy_map, BTC_GNT_HW);
1224 _set_gnt_bt(btc, phy_map, BTC_GNT_HW);
1225 plt_ctrl = BTC_PLT_GNT_WL;
1226 _set_bt_plut(btc, BTC_PHY_ALL, plt_ctrl, plt_ctrl);
1227 }
1228 break;
1229 case BTC_ANT_FREERUN:
1230 _set_cx_ctrl(btc, BTC_CTRL_BY_WL);
1231 _set_gnt_wl(btc, phy_map, BTC_GNT_SW_HI);
1232 _set_gnt_bt(btc, phy_map, BTC_GNT_SW_HI);
1233 _set_bt_plut(btc, BTC_PHY_ALL, BTC_PLT_NONE, BTC_PLT_NONE);
1234 break;
1235 case BTC_ANT_WRFK:
1236 _set_cx_ctrl(btc, BTC_CTRL_BY_WL);
1237 _set_gnt_wl(btc, phy_map, BTC_GNT_SW_HI);
1238 _set_gnt_bt(btc, phy_map, BTC_GNT_SW_LO);
1239 _set_bt_plut(btc, phy_map, BTC_PLT_NONE, BTC_PLT_NONE);
1240 break;
1241 case BTC_ANT_BRFK:
1242 _set_cx_ctrl(btc, BTC_CTRL_BY_BT);
1243 _set_gnt_wl(btc, phy_map, BTC_GNT_SW_LO);
1244 _set_gnt_bt(btc, phy_map, BTC_GNT_SW_HI);
1245 _set_bt_plut(btc, phy_map, BTC_PLT_NONE, BTC_PLT_NONE);
1246 break;
1247 }
1248 }
1249
_action_wl_only(struct btc_t * btc)1250 void _action_wl_only(struct btc_t *btc)
1251 {
1252 PHL_INFO("[BTC], %s !!\n", __func__);
1253
1254 _set_ant(btc, FC_EXEC, BTC_PHY_ALL, BTC_ANT_WONLY);
1255 _set_policy(btc, BTC_CXP_OFF_BT, __func__);
1256 }
1257
_action_wl_init(struct btc_t * btc)1258 void _action_wl_init(struct btc_t *btc)
1259 {
1260 PHL_INFO("[BTC], %s !!\n", __func__);
1261
1262 _set_ant(btc, FC_EXEC, BTC_PHY_ALL, BTC_ANT_WINIT);
1263 _set_policy(btc, BTC_CXP_OFF_BT, __func__);
1264 }
1265
_action_wl_off(struct btc_t * btc)1266 void _action_wl_off(struct btc_t *btc)
1267 {
1268 struct btc_wl_info *wl = &btc->cx.wl;
1269
1270 PHL_INFO("[BTC], %s !!\n", __func__);
1271
1272 /* don't set PTA control if LPS */
1273 if (wl->status.map.rf_off || btc->dm.bt_only) {
1274 _set_ant(btc, NM_EXEC, BTC_PHY_ALL, BTC_ANT_WOFF);
1275 } else if (wl->status.map.lps == BTC_LPS_RF_ON) {
1276 if (wl->role_info.link_mode == BTC_WLINK_5G)
1277 _set_ant(btc, FC_EXEC, BTC_PHY_ALL, BTC_ANT_W5G);
1278 else
1279 _set_ant(btc, FC_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
1280 }
1281
1282 if (wl->role_info.link_mode == BTC_WLINK_5G) {
1283 _set_policy(btc, BTC_CXP_OFF_EQ0, __func__);
1284 } else if (wl->status.map.lps == BTC_LPS_RF_ON) {
1285 if (btc->cx.bt.link_info.a2dp_desc.active)
1286 _set_policy(btc, BTC_CXP_OFF_BT, __func__);
1287 else
1288 _set_policy(btc, BTC_CXP_OFF_BWB1, __func__);
1289 } else {
1290 _set_policy(btc, BTC_CXP_OFF_BT, __func__);
1291 }
1292 }
1293
_action_freerun(struct btc_t * btc)1294 void _action_freerun(struct btc_t *btc)
1295 {
1296 PHL_INFO("[BTC], %s !!\n", __func__);
1297 btc->dm.freerun = true;
1298
1299 _set_ant(btc, FC_EXEC, BTC_PHY_ALL, BTC_ANT_FREERUN);
1300 _set_policy(btc, BTC_CXP_OFF_BT, __func__);
1301 }
1302
_action_bt_whql(struct btc_t * btc)1303 void _action_bt_whql(struct btc_t *btc)
1304 {
1305 PHL_INFO("[BTC], %s !!\n", __func__);
1306
1307 _set_ant(btc, FC_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
1308 _set_policy(btc, BTC_CXP_OFF_BT, __func__);
1309 }
1310
_action_bt_rfk(struct btc_t * btc)1311 void _action_bt_rfk(struct btc_t *btc)
1312 {
1313 PHL_INFO("[BTC], %s !!\n", __func__);
1314
1315 _set_ant(btc, NM_EXEC, BTC_PHY_ALL, BTC_ANT_BRFK);
1316 _set_policy(btc, BTC_CXP_OFF_BT, __func__);
1317 }
1318
_action_bt_off(struct btc_t * btc)1319 void _action_bt_off(struct btc_t *btc)
1320 {
1321 PHL_INFO("[BTC], %s !!\n", __func__);
1322
1323 _set_ant(btc, FC_EXEC, BTC_PHY_ALL, BTC_ANT_WONLY);
1324 _set_policy(btc, BTC_CXP_OFF_BT, __func__);
1325 }
1326
_action_bt_idle(struct btc_t * btc)1327 static void _action_bt_idle(struct btc_t *btc)
1328 {
1329 struct btc_bt_info *bt = &btc->cx.bt;
1330 struct btc_bt_link_info *b = &btc->cx.bt.link_info;
1331 u16 policy_type = BTC_CXP_OFF_BT;
1332
1333 if (btc->mdinfo.ant.type == BTC_ANT_SHARED) { /* shared-antenna */
1334 switch(btc->cx.state_map) {
1335 case BTC_WBUSY_BNOSCAN: /* wl-busy + bt idle*/
1336 case BTC_WSCAN_BNOSCAN: /* wl-scan + bt-idle */
1337 if (b->status.map.connect)
1338 policy_type = BTC_CXP_FIX_TD4010;
1339 else
1340 policy_type = BTC_CXP_FIX_TD4010ISO;
1341 break;
1342 case BTC_WBUSY_BSCAN: /*wl-busy + bt-inq */
1343 if (bt->pag)
1344 policy_type = BTC_CXP_PFIX_TD2080;
1345 else
1346 policy_type = BTC_CXP_PFIX_TD5050;
1347 break;
1348 case BTC_WSCAN_BSCAN: /* wl-scan + bt-inq */
1349 if (bt->pag)
1350 policy_type = BTC_CXP_FIX_TD2080;
1351 else
1352 policy_type = BTC_CXP_FIX_TD5050;
1353 break;
1354 case BTC_WLINKING: /* wl-connecting + bt-inq or bt-idle */
1355 if (bt->pag)
1356 policy_type = BTC_CXP_FIX_TD2080;
1357 else
1358 policy_type = BTC_CXP_FIX_TD7010;
1359 break;
1360 case BTC_WIDLE: /* wl-idle + bt-idle */
1361 policy_type = BTC_CXP_OFF_BWB1;
1362 break;
1363 }
1364 } else { /* dedicated-antenna */
1365 policy_type = BTC_CXP_OFF_EQ0;
1366 }
1367
1368 _set_ant(btc, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
1369 _set_policy(btc, policy_type, __func__);
1370 }
1371
_action_bt_hfp(struct btc_t * btc)1372 static void _action_bt_hfp(struct btc_t *btc)
1373 {
1374 u16 policy_type = BTC_CXP_OFF_BT;
1375
1376 if (btc->mdinfo.ant.type == BTC_ANT_SHARED) { /* shared-antenna */
1377 if (btc->cx.wl.status.map._4way)
1378 policy_type = BTC_CXP_OFF_WL;
1379 else
1380 policy_type = BTC_CXP_OFF_BWB1;
1381 } else { /* dedicated-antenna */
1382 policy_type = BTC_CXP_OFF_EQ2;
1383 }
1384
1385 _set_ant(btc, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
1386 _set_policy(btc, policy_type, __func__);
1387 }
1388
_action_bt_hid(struct btc_t * btc)1389 static void _action_bt_hid(struct btc_t *btc)
1390 {
1391 struct btc_bt_hid_desc *hid = &btc->cx.bt.link_info.hid_desc;
1392 u16 policy_type = BTC_CXP_OFF_BT;
1393
1394 if (btc->mdinfo.ant.type == BTC_ANT_SHARED) { /* shared-antenna */
1395 if (btc->cx.wl.status.map._4way) {
1396 policy_type = BTC_CXP_OFF_WL;
1397 } else if (hid->type == BTC_HID_218) {
1398 btc->cx.bt.scan_rx_low_pri = true;
1399 policy_type = BTC_CXP_OFF_BWB2;
1400 } else {
1401 policy_type = BTC_CXP_OFF_BWB1;
1402 }
1403 } else { /* dedicated-antenna */
1404 policy_type = BTC_CXP_OFF_EQ3;
1405 }
1406
1407 _set_ant(btc, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
1408 _set_policy(btc, policy_type, __func__);
1409 }
1410
_action_bt_a2dp(struct btc_t * btc)1411 static void _action_bt_a2dp(struct btc_t *btc)
1412 {
1413 struct btc_bt_link_info *bt_linfo = &btc->cx.bt.link_info;
1414 struct btc_bt_a2dp_desc a2dp = bt_linfo->a2dp_desc;
1415 struct btc_dm *dm = &btc->dm;
1416 u16 policy_type = BTC_CXP_OFF_BT;
1417
1418 switch(btc->cx.state_map) {
1419 case BTC_WBUSY_BNOSCAN: /* wl-busy + bt-A2DP */
1420 if (a2dp.vendor_id == 0x4c || dm->leak_ap ||
1421 bt_linfo->slave_role) {
1422 if (bt_linfo->slave_role)
1423 dm->slot_dur[CXST_W1] = 20;
1424 else
1425 dm->slot_dur[CXST_W1] = 40;
1426 dm->slot_dur[CXST_B1] = BTC_B1_MAX;
1427 policy_type = BTC_CXP_PAUTO_TDW1B1;
1428 } else {
1429 policy_type = BTC_CXP_PAUTO_TD50B1;
1430 }
1431 break;
1432 case BTC_WBUSY_BSCAN: /* wl-busy + bt-inq + bt-A2DP */
1433 policy_type = BTC_CXP_PAUTO2_TD3050;
1434 break;
1435 case BTC_WSCAN_BSCAN: /* wl-scan + bt-inq + bt-A2DP */
1436 policy_type = BTC_CXP_AUTO2_TD3050;
1437 break;
1438 case BTC_WSCAN_BNOSCAN: /* wl-scan + bt-A2DP */
1439 case BTC_WLINKING: /* wl-connecting + bt-A2DP */
1440 if (a2dp.vendor_id == 0x4c || dm->leak_ap ||
1441 bt_linfo->slave_role) {
1442 if (bt_linfo->slave_role)
1443 dm->slot_dur[CXST_W1] = 20;
1444 else
1445 dm->slot_dur[CXST_W1] = 40;
1446 dm->slot_dur[CXST_B1] = BTC_B1_MAX;
1447 policy_type = BTC_CXP_AUTO_TDW1B1;
1448 } else {
1449 policy_type = BTC_CXP_AUTO_TD50B1;
1450 }
1451 break;
1452 case BTC_WIDLE: /* wl-idle + bt-A2DP */
1453 policy_type = BTC_CXP_AUTO_TD20B1;
1454 break;
1455 }
1456
1457 _set_ant(btc, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
1458 _set_policy(btc, policy_type, __func__);
1459 }
1460
_action_bt_a2dpsink(struct btc_t * btc)1461 static void _action_bt_a2dpsink(struct btc_t *btc)
1462 {
1463 u16 policy_type = BTC_CXP_OFF_BT;
1464
1465 switch(btc->cx.state_map) {
1466 case BTC_WBUSY_BNOSCAN: /* wl-busy + bt-A2dp_Sink */
1467 policy_type = BTC_CXP_PFIX_TD2030;
1468 break;
1469 case BTC_WBUSY_BSCAN: /* wl-busy + bt-inq + bt-A2dp_Sink */
1470 policy_type = BTC_CXP_PFIX_TD2060;
1471 break;
1472 case BTC_WSCAN_BNOSCAN: /* wl-scan + bt-A2dp_Sink */
1473 policy_type = BTC_CXP_FIX_TD2030;
1474 break;
1475 case BTC_WSCAN_BSCAN: /* wl-scan + bt-inq + bt-A2dp_Sink */
1476 policy_type = BTC_CXP_FIX_TD2060;
1477 break;
1478 case BTC_WLINKING: /* wl-connecting + bt-A2dp_Sink */
1479 policy_type = BTC_CXP_FIX_TD3030;
1480 break;
1481 case BTC_WIDLE: /* wl-idle + bt-A2dp_Sink */
1482 policy_type = BTC_CXP_FIX_TD2080;
1483 break;
1484 }
1485
1486 _set_ant(btc, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
1487 _set_policy(btc, policy_type, __func__);
1488 }
1489
_action_bt_pan(struct btc_t * btc)1490 static void _action_bt_pan(struct btc_t *btc)
1491 {
1492 u16 policy_type = BTC_CXP_OFF_BT;
1493
1494 switch(btc->cx.state_map) {
1495 case BTC_WBUSY_BNOSCAN: /* wl-busy + bt-PAN */
1496 policy_type = BTC_CXP_PFIX_TD5050;
1497 break;
1498 case BTC_WBUSY_BSCAN: /* wl-busy + bt-inq + bt-PAN */
1499 policy_type = BTC_CXP_PFIX_TD3070;
1500 break;
1501 case BTC_WSCAN_BNOSCAN: /* wl-scan + bt-PAN */
1502 policy_type = BTC_CXP_FIX_TD3030;
1503 break;
1504 case BTC_WSCAN_BSCAN: /* wl-scan + bt-inq + bt-PAN */
1505 policy_type = BTC_CXP_FIX_TD3060;
1506 break;
1507 case BTC_WLINKING: /* wl-connecting + bt-PAN */
1508 policy_type = BTC_CXP_FIX_TD4010ISO;
1509 break;
1510 case BTC_WIDLE: /* wl-idle + bt-pan */
1511 policy_type = BTC_CXP_PFIX_TD2080;
1512 break;
1513 }
1514
1515 _set_ant(btc, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
1516 _set_policy(btc, policy_type, __func__);
1517 }
1518
_action_bt_a2dp_hid(struct btc_t * btc)1519 static void _action_bt_a2dp_hid(struct btc_t *btc)
1520 {
1521 struct btc_bt_link_info *bt_linfo = &btc->cx.bt.link_info;
1522 struct btc_bt_a2dp_desc a2dp = bt_linfo->a2dp_desc;
1523 struct btc_dm *dm = &btc->dm;
1524 u16 policy_type = BTC_CXP_OFF_BT;
1525
1526 switch(btc->cx.state_map) {
1527 case BTC_WBUSY_BNOSCAN: /* wl-busy + bt-A2DP */
1528 case BTC_WIDLE: /* wl-idle + bt-A2DP */
1529 if (a2dp.vendor_id == 0x4c || dm->leak_ap ||
1530 bt_linfo->slave_role) {
1531 if (bt_linfo->slave_role)
1532 dm->slot_dur[CXST_W1] = 20;
1533 else
1534 dm->slot_dur[CXST_W1] = 40;
1535 dm->slot_dur[CXST_W1] = 40;
1536 dm->slot_dur[CXST_B1] = BTC_B1_MAX;
1537 policy_type = BTC_CXP_PAUTO_TDW1B1;
1538 } else {
1539 policy_type = BTC_CXP_PAUTO_TD50B1;
1540 }
1541 break;
1542 case BTC_WBUSY_BSCAN: /* wl-busy + bt-inq + bt-A2DP */
1543 policy_type = BTC_CXP_PAUTO2_TD3050;
1544 break;
1545 case BTC_WSCAN_BSCAN: /* wl-scan + bt-inq + bt-A2DP */
1546 policy_type = BTC_CXP_AUTO2_TD3050;
1547 break;
1548 case BTC_WSCAN_BNOSCAN: /* wl-scan + bt-A2DP */
1549 case BTC_WLINKING: /* wl-connecting + bt-A2DP */
1550 if (a2dp.vendor_id == 0x4c || dm->leak_ap ||
1551 bt_linfo->slave_role) {
1552 if (bt_linfo->slave_role)
1553 dm->slot_dur[CXST_W1] = 20;
1554 else
1555 dm->slot_dur[CXST_W1] = 40;
1556 dm->slot_dur[CXST_B1] = BTC_B1_MAX;
1557 policy_type = BTC_CXP_AUTO_TDW1B1;
1558 } else {
1559 policy_type = BTC_CXP_AUTO_TD50B1;
1560 }
1561 break;
1562 }
1563
1564 _set_ant(btc, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
1565 _set_policy(btc, policy_type, __func__);
1566 }
1567
_action_bt_a2dp_pan(struct btc_t * btc)1568 static void _action_bt_a2dp_pan(struct btc_t *btc)
1569 {
1570 u16 policy_type = BTC_CXP_OFF_BT;
1571
1572 switch(btc->cx.state_map) {
1573 case BTC_WBUSY_BNOSCAN: /* wl-busy + bt-A2DP+PAN */
1574 policy_type = BTC_CXP_PAUTO2_TD3070;
1575 break;
1576 case BTC_WBUSY_BSCAN: /* wl-busy + bt-inq + bt-A2DP+PAN */
1577 policy_type = BTC_CXP_PAUTO2_TD3070;
1578 break;
1579 case BTC_WSCAN_BNOSCAN: /* wl-scan + bt-A2DP+PAN */
1580 policy_type = BTC_CXP_AUTO2_TD5050;
1581 break;
1582 case BTC_WSCAN_BSCAN: /* wl-scan + bt-inq + bt-A2DP+PAN */
1583 policy_type = BTC_CXP_AUTO2_TD3070;
1584 break;
1585 case BTC_WLINKING: /* wl-connecting + bt-A2DP+PAN */
1586 policy_type = BTC_CXP_AUTO2_TD3050;
1587 break;
1588 case BTC_WIDLE: /* wl-idle + bt-A2DP+PAN */
1589 policy_type = BTC_CXP_PAUTO2_TD2080;
1590 break;
1591 }
1592
1593 _set_ant(btc, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
1594 _set_policy(btc, policy_type, __func__);
1595 }
1596
_action_bt_pan_hid(struct btc_t * btc)1597 static void _action_bt_pan_hid(struct btc_t *btc)
1598 {
1599 u16 policy_type = BTC_CXP_OFF_BT;
1600
1601 switch(btc->cx.state_map) {
1602 case BTC_WBUSY_BNOSCAN: /* wl-busy + bt-PAN+HID */
1603 policy_type = BTC_CXP_PFIX_TD3030;
1604 break;
1605 case BTC_WBUSY_BSCAN: /* wl-busy + bt-inq + bt-PAN+HID */
1606 policy_type = BTC_CXP_PFIX_TD3070;
1607 break;
1608 case BTC_WSCAN_BNOSCAN: /* wl-scan + bt-PAN+HID */
1609 policy_type = BTC_CXP_FIX_TD3030;
1610 break;
1611 case BTC_WSCAN_BSCAN: /* wl-scan + bt-inq + bt-PAN+HID */
1612 policy_type = BTC_CXP_FIX_TD3060;
1613 break;
1614 case BTC_WLINKING: /* wl-connecting + bt-PAN+HID */
1615 policy_type = BTC_CXP_FIX_TD4010;
1616 break;
1617 case BTC_WIDLE: /* wl-idle + bt-PAN+HID */
1618 policy_type = BTC_CXP_PFIX_TD2080;
1619 break;
1620 }
1621
1622 _set_ant(btc, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
1623 _set_policy(btc, policy_type, __func__);
1624 }
1625
_action_bt_a2dp_pan_hid(struct btc_t * btc)1626 static void _action_bt_a2dp_pan_hid(struct btc_t *btc)
1627 {
1628 u16 policy_type = BTC_CXP_OFF_BT;
1629
1630 switch(btc->cx.state_map) {
1631 case BTC_WBUSY_BNOSCAN: /* wl-busy + bt-A2DP+PAN+HID */
1632 policy_type = BTC_CXP_PAUTO2_TD3070;
1633 break;
1634 case BTC_WBUSY_BSCAN: /* wl-busy + bt-inq + bt-A2DP+PAN+HID */
1635 policy_type = BTC_CXP_PAUTO2_TD3070;
1636 break;
1637 case BTC_WSCAN_BSCAN: /* wl-scan + bt-inq + bt-A2DP+PAN+HID */
1638 policy_type = BTC_CXP_AUTO2_TD3070;
1639 break;
1640 case BTC_WSCAN_BNOSCAN: /* wl-scan + bt-A2DP+PAN+HID */
1641 case BTC_WLINKING: /* wl-connecting + bt-A2DP+PAN+HID */
1642 policy_type = BTC_CXP_AUTO2_TD3050;
1643 break;
1644 case BTC_WIDLE: /* wl-idle + bt-A2DP+PAN+HID */
1645 policy_type = BTC_CXP_PAUTO2_TD2080;
1646 break;
1647 }
1648
1649 _set_ant(btc, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
1650 _set_policy(btc, policy_type, __func__);
1651 }
1652
_action_wl_5g(struct btc_t * btc)1653 void _action_wl_5g(struct btc_t *btc)
1654 {
1655 _set_ant(btc, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W5G);
1656 _set_policy(btc, BTC_CXP_OFF_EQ0, __func__);
1657 }
1658
_action_wl_other(struct btc_t * btc)1659 void _action_wl_other(struct btc_t *btc)
1660 {
1661 _set_ant(btc, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
1662
1663 if (btc->mdinfo.ant.type == BTC_ANT_SHARED)
1664 _set_policy(btc, BTC_CXP_OFFB_BWB0, __func__);
1665 else
1666 _set_policy(btc, BTC_CXP_OFF_EQ0, __func__);
1667 }
1668
_action_wl_idle(struct btc_t * btc)1669 void _action_wl_idle(struct btc_t *btc)
1670 {
1671 _set_ant(btc, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
1672
1673 if (btc->mdinfo.ant.type == BTC_ANT_SHARED)
1674 _set_policy(btc, BTC_CXP_OFFB_BWB0, __func__);
1675 else
1676 _set_policy(btc, BTC_CXP_OFF_EQ0, __func__);
1677 }
1678
_action_wl_nc(struct btc_t * btc)1679 void _action_wl_nc(struct btc_t *btc)
1680 {
1681 _set_ant(btc, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
1682 _set_policy(btc, BTC_CXP_OFF_BT, __func__);
1683 }
1684
_action_wl_rfk(struct btc_t * btc)1685 void _action_wl_rfk(struct btc_t *btc)
1686 {
1687 struct btc_wl_rfk_info rfk = btc->cx.wl.rfk_info;
1688
1689 if (rfk.state != BTC_WRFK_START)
1690 return;
1691
1692 PHL_INFO("[BTC], %s(): band = %d\n", __func__, rfk.band);
1693
1694 _set_ant(btc, FC_EXEC, BTC_PHY_ALL, BTC_ANT_WRFK);
1695 _set_policy(btc, BTC_CXP_OFF_WL, __func__);
1696
1697 #if 0
1698 if (rfk.band == BAND_ON_24G) {
1699 _set_ant(btc, FC_EXEC, BTC_PHY_ALL, BTC_ANT_WRFK);
1700 _set_policy(btc, BTC_CXP_OFF_WL, __func__);
1701 } else {
1702 _set_ant(btc, FC_EXEC, BTC_PHY_ALL, BTC_ANT_FREERUN);
1703 _set_policy(btc, BTC_CXP_OFF_EQ0, __func__);
1704 }
1705 #endif
1706 }
1707
_action_common(struct btc_t * btc)1708 void _action_common(struct btc_t *btc)
1709 {
1710 _set_halbb_btg_ctrl(btc);
1711 _set_halmac_tx_limit(btc);
1712 _set_bt_afh_info(btc);
1713 _set_bt_rx_agc(btc); /* must call after _set_halbb_btg_ctrl */
1714 _set_bt_slot_req(btc);
1715 _set_bt_rx_scan_pri(btc);
1716 _set_rf_trx_para(btc);
1717 }
1718
_action_by_bt(struct btc_t * btc)1719 static void _action_by_bt(struct btc_t *btc)
1720 {
1721 struct btc_bt_info *bt = &btc->cx.bt;
1722 struct btc_bt_link_info *bt_linfo = &bt->link_info;
1723 struct btc_bt_hid_desc hid = bt_linfo->hid_desc;
1724 struct btc_bt_a2dp_desc a2dp = bt_linfo->a2dp_desc;
1725 struct btc_bt_pan_desc pan = bt_linfo->pan_desc;
1726 u8 profile_map = 0;
1727
1728 if (bt_linfo->hfp_desc.exist)
1729 profile_map |= BTC_BT_HFP;
1730
1731 if (bt_linfo->hid_desc.exist)
1732 profile_map |= BTC_BT_HID;
1733
1734 if (bt_linfo->a2dp_desc.exist)
1735 profile_map |= BTC_BT_A2DP;
1736
1737 if (bt_linfo->pan_desc.exist)
1738 profile_map |= BTC_BT_PAN;
1739
1740 switch (profile_map) {
1741 case 0:
1742 if (_check_freerun(btc))
1743 _action_freerun(btc);
1744 else if (a2dp.active || pan.active)
1745 _action_bt_pan(btc);
1746 else
1747 _action_bt_idle(btc);
1748 break;
1749 case BTC_BT_HFP:
1750 if (_check_freerun(btc))
1751 _action_freerun(btc);
1752 else
1753 _action_bt_hfp(btc);
1754 break;
1755 case BTC_BT_HFP | BTC_BT_HID:
1756 case BTC_BT_HID:
1757 if (_check_freerun(btc))
1758 _action_freerun(btc);
1759 else
1760 _action_bt_hid(btc);
1761 break;
1762 case BTC_BT_A2DP:
1763 if (_check_freerun(btc))
1764 _action_freerun(btc);
1765 else if (a2dp.sink)
1766 _action_bt_a2dpsink(btc);
1767 else if (bt_linfo->multi_link.now && !hid.pair_cnt)
1768 _action_bt_a2dp_pan(btc);
1769 else
1770 _action_bt_a2dp(btc);
1771 break;
1772 case BTC_BT_PAN:
1773 _action_bt_pan(btc);
1774 break;
1775 case BTC_BT_A2DP | BTC_BT_HFP:
1776 case BTC_BT_A2DP | BTC_BT_HID:
1777 case BTC_BT_A2DP | BTC_BT_HFP | BTC_BT_HID:
1778 if (_check_freerun(btc))
1779 _action_freerun(btc);
1780 else
1781 _action_bt_a2dp_hid(btc);
1782 break;
1783 case BTC_BT_A2DP | BTC_BT_PAN:
1784 _action_bt_a2dp_pan(btc);
1785 break;
1786 case BTC_BT_PAN | BTC_BT_HFP:
1787 case BTC_BT_PAN | BTC_BT_HID:
1788 case BTC_BT_PAN | BTC_BT_HFP | BTC_BT_HID:
1789 _action_bt_pan_hid(btc);
1790 break;
1791 case BTC_BT_A2DP | BTC_BT_PAN | BTC_BT_HID:
1792 case BTC_BT_A2DP | BTC_BT_PAN | BTC_BT_HFP:
1793 default:
1794 _action_bt_a2dp_pan_hid(btc);
1795 break;
1796 }
1797 }
1798
_action_wl_2g_sta(struct btc_t * btc)1799 void _action_wl_2g_sta(struct btc_t *btc)
1800 {
1801 _action_by_bt(btc);
1802 }
1803
_action_wl_scan(struct btc_t * btc)1804 void _action_wl_scan(struct btc_t *btc)
1805 {
1806 struct btc_wl_info *wl = &btc->cx.wl;
1807 struct btc_wl_dbcc_info *wl_dinfo = &wl->dbcc_info;
1808
1809 if (btc->hal->dbcc_en) {
1810 if (wl_dinfo->real_band[HW_PHY_0] != BAND_ON_24G &&
1811 wl_dinfo->real_band[HW_PHY_1] != BAND_ON_24G)
1812 _action_wl_5g(btc);
1813 else
1814 _action_by_bt(btc);
1815 } else {
1816 if (wl->scan_info.band[HW_PHY_0] != BAND_ON_24G)
1817 _action_wl_5g(btc);
1818 else
1819 _action_by_bt(btc);
1820 }
1821 }
1822
_action_wl_25g_mcc(struct btc_t * btc)1823 void _action_wl_25g_mcc(struct btc_t *btc)
1824 {
1825 struct btc_wl_info *wl = &btc->cx.wl;
1826 struct btc_bt_info *bt = &btc->cx.bt;
1827 u16 policy_type = BTC_CXP_OFF_BT;
1828
1829 if (btc->mdinfo.ant.type == BTC_ANT_SHARED)/* shared-antenna */ {
1830 if (wl->status.map._4way)
1831 policy_type = BTC_CXP_OFFE_WL;
1832 else if (bt->link_info.status.map.connect == 0)
1833 policy_type = BTC_CXP_OFFE_2GISOB;
1834 else
1835 policy_type = BTC_CXP_OFFE_2GBWISOB;
1836 } else { /* dedicated-antenna */
1837 policy_type = BTC_CXP_OFF_EQ0;
1838 }
1839
1840 _set_ant(btc, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W25G);
1841 _set_policy(btc, policy_type, __func__);
1842 }
1843
_action_wl_2g_mcc(struct btc_t * btc)1844 void _action_wl_2g_mcc(struct btc_t *btc)
1845 {
1846 struct btc_wl_info *wl = &btc->cx.wl;
1847 struct btc_bt_info *bt = &btc->cx.bt;
1848 u16 policy_type = BTC_CXP_OFF_BT;
1849
1850 if (btc->mdinfo.ant.type == BTC_ANT_SHARED) { /* shared-antenna */
1851 if (wl->status.map._4way)
1852 policy_type = BTC_CXP_OFFE_WL;
1853 else if (bt->link_info.status.map.connect == 0)
1854 policy_type = BTC_CXP_OFFE_2GISOB;
1855 else
1856 policy_type = BTC_CXP_OFFE_2GBWISOB;
1857 } else { /* dedicated-antenna */
1858 policy_type = BTC_CXP_OFF_EQ0;
1859 }
1860
1861 _set_ant(btc, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
1862 _set_policy(btc, policy_type, __func__);
1863 }
1864
_action_wl_2g_scc(struct btc_t * btc)1865 void _action_wl_2g_scc(struct btc_t *btc)
1866 {
1867 struct btc_wl_info *wl = &btc->cx.wl;
1868 struct btc_bt_info *bt = &btc->cx.bt;
1869 struct btc_dm *dm = &btc->dm;
1870 struct btc_wl_role_info *wl_rinfo = &wl->role_info;
1871 u16 policy_type = BTC_CXP_OFF_BT;
1872 u32 dur;
1873
1874 if (btc->mdinfo.ant.type == BTC_ANT_DEDICATED) {
1875 policy_type = BTC_CXP_OFF_EQ0;
1876 goto exit;
1877 }
1878
1879 /* shared-antenna */
1880 switch(wl_rinfo->mrole_type) {
1881 default:
1882 #if 0
1883 case BTC_WLMROLE_STA_GO:
1884 case BTC_WLMROLE_STA_GO_NOA:
1885 dm->wl_scc.null_role1 = PHL_RTYPE_STATION;
1886 dm->wl_scc.null_role2 = PHL_RTYPE_NONE;
1887 dm->wl_scc.ebt_null = 0;
1888 policy_type = BTC_CXP_OFF_BWB1;
1889 #endif
1890 break;
1891 case BTC_WLMROLE_STA_GC:
1892 dm->wl_scc.null_role1 = PHL_RTYPE_STATION;
1893 dm->wl_scc.null_role2 = PHL_RTYPE_P2P_GC;
1894 dm->wl_scc.ebt_null = 0; /* no ext-slot-control */
1895 _action_by_bt(btc);
1896 return;
1897 case BTC_WLMROLE_STA_STA:
1898 dm->wl_scc.null_role1 = PHL_RTYPE_STATION;
1899 dm->wl_scc.null_role2 = PHL_RTYPE_STATION;
1900 dm->wl_scc.ebt_null = 0; /* no ext-slot-control */
1901 _action_by_bt(btc);
1902 return;
1903 case BTC_WLMROLE_STA_GC_NOA:
1904 case BTC_WLMROLE_STA_GO:
1905 case BTC_WLMROLE_STA_GO_NOA:
1906 dm->wl_scc.null_role1 = PHL_RTYPE_STATION;
1907 dm->wl_scc.null_role2 = PHL_RTYPE_NONE;
1908 dur = wl_rinfo->mrole_noa_duration;
1909
1910 if (wl->status.map._4way) {
1911 dm->wl_scc.ebt_null = 0;
1912 policy_type = BTC_CXP_OFFE_WL;
1913 } else if (bt->link_info.status.map.connect == 0) {
1914 dm->wl_scc.ebt_null = 0;
1915 policy_type = BTC_CXP_OFFE_2GISOB;
1916 } else if (bt->link_info.a2dp_desc.exist &&
1917 dur < btc->bt_req_len) {
1918 dm->wl_scc.ebt_null = 1; /* tx null at EBT */
1919 policy_type = BTC_CXP_OFFE_2GBWMIXB2;
1920 } else if (bt->link_info.a2dp_desc.exist ||
1921 bt->link_info.pan_desc.exist) {
1922 dm->wl_scc.ebt_null = 1; /* tx null at EBT */
1923 policy_type = BTC_CXP_OFFE_2GBWISOB;
1924 }else {
1925 dm->wl_scc.ebt_null = 0;
1926 policy_type = BTC_CXP_OFFE_2GBWISOB;
1927 }
1928
1929 break;
1930 }
1931
1932 exit:
1933 _set_ant(btc, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
1934 _set_policy(btc, policy_type, __func__);
1935 }
1936
_action_wl_2g_ap(struct btc_t * btc)1937 void _action_wl_2g_ap(struct btc_t *btc)
1938 {
1939 struct btc_wl_info *wl = &btc->cx.wl;
1940 struct btc_bt_info *bt = &btc->cx.bt;
1941 u16 policy_type = BTC_CXP_OFF_BT;
1942
1943 /* Todo:if client issue Null-P, ap should follow Null/Null-P slot */
1944 if (btc->mdinfo.ant.type == BTC_ANT_SHARED) { /* shared-antenna */
1945 if (wl->status.map._4way)
1946 policy_type = BTC_CXP_OFFE_WL;
1947 else if (bt->link_info.status.map.connect == 0)
1948 policy_type = BTC_CXP_OFFE_2GISOB;
1949 else
1950 policy_type = BTC_CXP_OFFE_2GBWISOB;
1951 } else {/* dedicated-antenna */
1952 policy_type = BTC_CXP_OFF_EQ0;
1953 }
1954
1955 _set_ant(btc, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
1956 _set_policy(btc, policy_type, __func__);
1957 }
1958
_action_wl_2g_go(struct btc_t * btc)1959 void _action_wl_2g_go(struct btc_t *btc)
1960 {
1961 struct btc_wl_info *wl = &btc->cx.wl;
1962 struct btc_bt_info *bt = &btc->cx.bt;
1963 u16 policy_type = BTC_CXP_OFF_BT;
1964
1965 if (btc->mdinfo.ant.type == BTC_ANT_SHARED) { /* shared-antenna */
1966 if (wl->status.map._4way)
1967 policy_type = BTC_CXP_OFFE_WL;
1968 else if (bt->link_info.status.map.connect == 0)
1969 policy_type = BTC_CXP_OFFE_2GISOB;
1970 else
1971 policy_type = BTC_CXP_OFFE_2GBWISOB;
1972 } else { /* dedicated-antenna */
1973 policy_type = BTC_CXP_OFF_EQ0;
1974 }
1975
1976 _set_ant(btc, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
1977 _set_policy(btc, policy_type, __func__);
1978 }
1979
_action_wl_2g_gc(struct btc_t * btc)1980 void _action_wl_2g_gc(struct btc_t *btc)
1981 {
1982 struct btc_wl_info *wl = &btc->cx.wl;
1983 struct btc_bt_info *bt = &btc->cx.bt;
1984 struct btc_wl_role_info *wl_rinfo = &wl->role_info;
1985 u8 noa = 0, pid = 0;
1986 u16 policy_type = BTC_CXP_OFF_BT;
1987 u32 noa_duration = 0;
1988
1989 pid = _get_wl_role_idx(btc, PHL_RTYPE_P2P_GC);
1990
1991 if (pid < MAX_WIFI_ROLE_NUMBER) {
1992 noa = wl_rinfo->active_role[pid].noa;
1993 noa_duration = wl_rinfo->active_role[pid].noa_duration;
1994 }
1995 /* Check GC, GC+NOA */
1996 if (btc->mdinfo.ant.type == BTC_ANT_SHARED) { /* shared-antenna */
1997 if (!noa) { /* Gc without NOA */
1998 _action_by_bt(btc);
1999 return;
2000 } else { /* Gc with NOA */
2001 if (wl->status.map._4way)
2002 policy_type = BTC_CXP_OFFE_WL;
2003 else if (bt->link_info.status.map.connect == 0)
2004 policy_type = BTC_CXP_OFFE_2GISOB;
2005 else if (bt->link_info.a2dp_desc.exist &&
2006 noa_duration < btc->bt_req_len)
2007 policy_type = BTC_CXP_OFFE_2GBWMIXB;
2008 else
2009 policy_type = BTC_CXP_OFFE_2GBWISOB;
2010 }
2011 } else {/* dedicated-antenna */
2012 policy_type = BTC_CXP_OFF_EQ0;
2013 }
2014
2015 _set_ant(btc, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
2016 _set_policy(btc, policy_type, __func__);
2017 }
2018
_action_wl_2g_nan(struct btc_t * btc)2019 void _action_wl_2g_nan(struct btc_t *btc)
2020 {
2021 struct btc_wl_info *wl = &btc->cx.wl;
2022 struct btc_bt_info *bt = &btc->cx.bt;
2023 u16 policy_type = BTC_CXP_OFF_BT;
2024
2025 if (btc->mdinfo.ant.type == BTC_ANT_SHARED) { /* shared-antenna */
2026 if (wl->status.map._4way)
2027 policy_type = BTC_CXP_OFFE_WL;
2028 else if (bt->link_info.status.map.connect == 0)
2029 policy_type = BTC_CXP_OFFE_2GISOB;
2030 else
2031 policy_type = BTC_CXP_OFFE_2GBWISOB;
2032 } else { /* dedicated-antenna */
2033 policy_type = BTC_CXP_OFF_EQ0;
2034 }
2035
2036 _set_ant(btc, NM_EXEC, BTC_PHY_ALL, BTC_ANT_W2G);
2037 _set_policy(btc, policy_type, __func__);
2038 }
2039
2040 #endif
2041