1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
2 /* Copyright(c) 2019-2022 Realtek Corporation
3 */
4
5 #include "coex.h"
6 #include "debug.h"
7 #include "phy.h"
8 #include "reg.h"
9 #include "rtw8852c.h"
10 #include "rtw8852c_rfk.h"
11 #include "rtw8852c_rfk_table.h"
12 #include "rtw8852c_table.h"
13
14 struct rxck_def {
15 u32 ctl;
16 u32 en;
17 u32 bw0;
18 u32 bw1;
19 u32 mul;
20 u32 lp;
21 };
22
23 #define _TSSI_DE_MASK GENMASK(21, 12)
24 static const u32 _tssi_de_cck_long[RF_PATH_NUM_8852C] = {0x5858, 0x7858};
25 static const u32 _tssi_de_cck_short[RF_PATH_NUM_8852C] = {0x5860, 0x7860};
26 static const u32 _tssi_de_mcs_20m[RF_PATH_NUM_8852C] = {0x5838, 0x7838};
27 static const u32 _tssi_de_mcs_40m[RF_PATH_NUM_8852C] = {0x5840, 0x7840};
28 static const u32 _tssi_de_mcs_80m[RF_PATH_NUM_8852C] = {0x5848, 0x7848};
29 static const u32 _tssi_de_mcs_80m_80m[RF_PATH_NUM_8852C] = {0x5850, 0x7850};
30 static const u32 _tssi_de_mcs_5m[RF_PATH_NUM_8852C] = {0x5828, 0x7828};
31 static const u32 _tssi_de_mcs_10m[RF_PATH_NUM_8852C] = {0x5830, 0x7830};
32
33 static const u32 rtw8852c_backup_bb_regs[] = {
34 0x8120, 0xc0d4, 0xc0d8, 0xc0e8, 0x8220, 0xc1d4, 0xc1d8, 0xc1e8
35 };
36
37 static const u32 rtw8852c_backup_rf_regs[] = {
38 0xdf, 0x5f, 0x8f, 0x97, 0xa3, 0x5, 0x10005
39 };
40
41 #define BACKUP_BB_REGS_NR ARRAY_SIZE(rtw8852c_backup_bb_regs)
42 #define BACKUP_RF_REGS_NR ARRAY_SIZE(rtw8852c_backup_rf_regs)
43
44 #define RXK_GROUP_NR 4
45 static const u32 _rxk_a6_idxrxgain[RXK_GROUP_NR] = {0x190, 0x196, 0x290, 0x316};
46 static const u32 _rxk_a6_idxattc2[RXK_GROUP_NR] = {0x00, 0x0, 0x00, 0x00};
47 static const u32 _rxk_a_idxrxgain[RXK_GROUP_NR] = {0x190, 0x198, 0x310, 0x318};
48 static const u32 _rxk_a_idxattc2[RXK_GROUP_NR] = {0x00, 0x00, 0x00, 0x00};
49 static const u32 _rxk_g_idxrxgain[RXK_GROUP_NR] = {0x252, 0x26c, 0x350, 0x360};
50 static const u32 _rxk_g_idxattc2[RXK_GROUP_NR] = {0x00, 0x07, 0x00, 0x3};
51
52 #define TXK_GROUP_NR 3
53 static const u32 _txk_a6_power_range[TXK_GROUP_NR] = {0x0, 0x0, 0x0};
54 static const u32 _txk_a6_track_range[TXK_GROUP_NR] = {0x6, 0x7, 0x7};
55 static const u32 _txk_a6_gain_bb[TXK_GROUP_NR] = {0x12, 0x09, 0x0e};
56 static const u32 _txk_a6_itqt[TXK_GROUP_NR] = {0x12, 0x12, 0x12};
57 static const u32 _txk_a_power_range[TXK_GROUP_NR] = {0x0, 0x0, 0x0};
58 static const u32 _txk_a_track_range[TXK_GROUP_NR] = {0x5, 0x6, 0x7};
59 static const u32 _txk_a_gain_bb[TXK_GROUP_NR] = {0x12, 0x09, 0x0e};
60 static const u32 _txk_a_itqt[TXK_GROUP_NR] = {0x12, 0x12, 0x12};
61 static const u32 _txk_g_power_range[TXK_GROUP_NR] = {0x0, 0x0, 0x0};
62 static const u32 _txk_g_track_range[TXK_GROUP_NR] = {0x5, 0x6, 0x6};
63 static const u32 _txk_g_gain_bb[TXK_GROUP_NR] = {0x0e, 0x0a, 0x0e};
64 static const u32 _txk_g_itqt[TXK_GROUP_NR] = { 0x12, 0x12, 0x12};
65
66 static const u32 dpk_par_regs[RTW89_DPK_RF_PATH][4] = {
67 {0x8190, 0x8194, 0x8198, 0x81a4},
68 {0x81a8, 0x81c4, 0x81c8, 0x81e8},
69 };
70
71 static const u8 _dck_addr_bs[RF_PATH_NUM_8852C] = {0x0, 0x10};
72 static const u8 _dck_addr[RF_PATH_NUM_8852C] = {0xc, 0x1c};
73
74 static const struct rxck_def _ck480M = {0x8, 0x2, 0x3, 0xf, 0x0, 0x9};
75 static const struct rxck_def _ck960M = {0x8, 0x2, 0x2, 0x8, 0x0, 0x9};
76 static const struct rxck_def _ck1920M = {0x8, 0x0, 0x2, 0x4, 0x6, 0x9};
77
_kpath(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy_idx)78 static u8 _kpath(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy_idx)
79 {
80 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[RFK]dbcc_en: %x, PHY%d\n",
81 rtwdev->dbcc_en, phy_idx);
82
83 if (!rtwdev->dbcc_en)
84 return RF_AB;
85
86 if (phy_idx == RTW89_PHY_0)
87 return RF_A;
88 else
89 return RF_B;
90 }
91
_rfk_backup_bb_reg(struct rtw89_dev * rtwdev,u32 backup_bb_reg_val[])92 static void _rfk_backup_bb_reg(struct rtw89_dev *rtwdev, u32 backup_bb_reg_val[])
93 {
94 u32 i;
95
96 for (i = 0; i < BACKUP_BB_REGS_NR; i++) {
97 backup_bb_reg_val[i] =
98 rtw89_phy_read32_mask(rtwdev, rtw8852c_backup_bb_regs[i],
99 MASKDWORD);
100 rtw89_debug(rtwdev, RTW89_DBG_RFK,
101 "[IQK]backup bb reg : %x, value =%x\n",
102 rtw8852c_backup_bb_regs[i], backup_bb_reg_val[i]);
103 }
104 }
105
_rfk_backup_rf_reg(struct rtw89_dev * rtwdev,u32 backup_rf_reg_val[],u8 rf_path)106 static void _rfk_backup_rf_reg(struct rtw89_dev *rtwdev, u32 backup_rf_reg_val[],
107 u8 rf_path)
108 {
109 u32 i;
110
111 for (i = 0; i < BACKUP_RF_REGS_NR; i++) {
112 backup_rf_reg_val[i] =
113 rtw89_read_rf(rtwdev, rf_path,
114 rtw8852c_backup_rf_regs[i], RFREG_MASK);
115 rtw89_debug(rtwdev, RTW89_DBG_RFK,
116 "[IQK]backup rf S%d reg : %x, value =%x\n", rf_path,
117 rtw8852c_backup_rf_regs[i], backup_rf_reg_val[i]);
118 }
119 }
120
_rfk_restore_bb_reg(struct rtw89_dev * rtwdev,u32 backup_bb_reg_val[])121 static void _rfk_restore_bb_reg(struct rtw89_dev *rtwdev, u32 backup_bb_reg_val[])
122 {
123 u32 i;
124
125 for (i = 0; i < BACKUP_BB_REGS_NR; i++) {
126 rtw89_phy_write32_mask(rtwdev, rtw8852c_backup_bb_regs[i],
127 MASKDWORD, backup_bb_reg_val[i]);
128 rtw89_debug(rtwdev, RTW89_DBG_RFK,
129 "[IQK]restore bb reg : %x, value =%x\n",
130 rtw8852c_backup_bb_regs[i], backup_bb_reg_val[i]);
131 }
132 }
133
_rfk_restore_rf_reg(struct rtw89_dev * rtwdev,u32 backup_rf_reg_val[],u8 rf_path)134 static void _rfk_restore_rf_reg(struct rtw89_dev *rtwdev, u32 backup_rf_reg_val[],
135 u8 rf_path)
136 {
137 u32 i;
138
139 for (i = 0; i < BACKUP_RF_REGS_NR; i++) {
140 rtw89_write_rf(rtwdev, rf_path, rtw8852c_backup_rf_regs[i],
141 RFREG_MASK, backup_rf_reg_val[i]);
142
143 rtw89_debug(rtwdev, RTW89_DBG_RFK,
144 "[IQK]restore rf S%d reg: %x, value =%x\n", rf_path,
145 rtw8852c_backup_rf_regs[i], backup_rf_reg_val[i]);
146 }
147 }
148
_wait_rx_mode(struct rtw89_dev * rtwdev,u8 kpath)149 static void _wait_rx_mode(struct rtw89_dev *rtwdev, u8 kpath)
150 {
151 u8 path;
152 u32 rf_mode;
153 int ret;
154
155 for (path = 0; path < RF_PATH_MAX; path++) {
156 if (!(kpath & BIT(path)))
157 continue;
158
159 ret = read_poll_timeout_atomic(rtw89_read_rf, rf_mode, rf_mode != 2,
160 2, 5000, false, rtwdev, path, 0x00,
161 RR_MOD_MASK);
162 rtw89_debug(rtwdev, RTW89_DBG_RFK,
163 "[RFK] Wait S%d to Rx mode!! (ret = %d)\n",
164 path, ret);
165 }
166 }
167
_dack_dump(struct rtw89_dev * rtwdev)168 static void _dack_dump(struct rtw89_dev *rtwdev)
169 {
170 struct rtw89_dack_info *dack = &rtwdev->dack;
171 u8 i;
172 u8 t;
173
174 rtw89_debug(rtwdev, RTW89_DBG_RFK,
175 "[DACK]S0 ADC_DCK ic = 0x%x, qc = 0x%x\n",
176 dack->addck_d[0][0], dack->addck_d[0][1]);
177 rtw89_debug(rtwdev, RTW89_DBG_RFK,
178 "[DACK]S1 ADC_DCK ic = 0x%x, qc = 0x%x\n",
179 dack->addck_d[1][0], dack->addck_d[1][1]);
180 rtw89_debug(rtwdev, RTW89_DBG_RFK,
181 "[DACK]S0 DAC_DCK ic = 0x%x, qc = 0x%x\n",
182 dack->dadck_d[0][0], dack->dadck_d[0][1]);
183 rtw89_debug(rtwdev, RTW89_DBG_RFK,
184 "[DACK]S1 DAC_DCK ic = 0x%x, qc = 0x%x\n",
185 dack->dadck_d[1][0], dack->dadck_d[1][1]);
186
187 rtw89_debug(rtwdev, RTW89_DBG_RFK,
188 "[DACK]S0 biask ic = 0x%x, qc = 0x%x\n",
189 dack->biask_d[0][0], dack->biask_d[0][1]);
190 rtw89_debug(rtwdev, RTW89_DBG_RFK,
191 "[DACK]S1 biask ic = 0x%x, qc = 0x%x\n",
192 dack->biask_d[1][0], dack->biask_d[1][1]);
193
194 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]S0 MSBK ic:\n");
195 for (i = 0; i < RTW89_DACK_MSBK_NR; i++) {
196 t = dack->msbk_d[0][0][i];
197 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]0x%x\n", t);
198 }
199 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]S0 MSBK qc:\n");
200 for (i = 0; i < RTW89_DACK_MSBK_NR; i++) {
201 t = dack->msbk_d[0][1][i];
202 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]0x%x\n", t);
203 }
204 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]S1 MSBK ic:\n");
205 for (i = 0; i < RTW89_DACK_MSBK_NR; i++) {
206 t = dack->msbk_d[1][0][i];
207 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]0x%x\n", t);
208 }
209 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]S1 MSBK qc:\n");
210 for (i = 0; i < RTW89_DACK_MSBK_NR; i++) {
211 t = dack->msbk_d[1][1][i];
212 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]0x%x\n", t);
213 }
214 }
215
_addck_backup(struct rtw89_dev * rtwdev)216 static void _addck_backup(struct rtw89_dev *rtwdev)
217 {
218 struct rtw89_dack_info *dack = &rtwdev->dack;
219
220 rtw89_phy_write32_mask(rtwdev, R_ADDCK0, B_ADDCK0, 0x0);
221 dack->addck_d[0][0] = rtw89_phy_read32_mask(rtwdev, R_ADDCKR0,
222 B_ADDCKR0_A0);
223 dack->addck_d[0][1] = rtw89_phy_read32_mask(rtwdev, R_ADDCKR0,
224 B_ADDCKR0_A1);
225
226 rtw89_phy_write32_mask(rtwdev, R_ADDCK1, B_ADDCK1, 0x0);
227 dack->addck_d[1][0] = rtw89_phy_read32_mask(rtwdev, R_ADDCKR1,
228 B_ADDCKR1_A0);
229 dack->addck_d[1][1] = rtw89_phy_read32_mask(rtwdev, R_ADDCKR1,
230 B_ADDCKR1_A1);
231 }
232
_addck_reload(struct rtw89_dev * rtwdev)233 static void _addck_reload(struct rtw89_dev *rtwdev)
234 {
235 struct rtw89_dack_info *dack = &rtwdev->dack;
236
237 rtw89_phy_write32_mask(rtwdev, R_ADDCK0_RL, B_ADDCK0_RL1,
238 dack->addck_d[0][0]);
239 rtw89_phy_write32_mask(rtwdev, R_ADDCK0_RL, B_ADDCK0_RL0,
240 dack->addck_d[0][1]);
241 rtw89_phy_write32_mask(rtwdev, R_ADDCK0_RL, B_ADDCK0_RLS, 0x3);
242 rtw89_phy_write32_mask(rtwdev, R_ADDCK1_RL, B_ADDCK1_RL1,
243 dack->addck_d[1][0]);
244 rtw89_phy_write32_mask(rtwdev, R_ADDCK1_RL, B_ADDCK1_RL0,
245 dack->addck_d[1][1]);
246 rtw89_phy_write32_mask(rtwdev, R_ADDCK1_RL, B_ADDCK1_RLS, 0x3);
247 }
248
_dack_backup_s0(struct rtw89_dev * rtwdev)249 static void _dack_backup_s0(struct rtw89_dev *rtwdev)
250 {
251 struct rtw89_dack_info *dack = &rtwdev->dack;
252 u8 i;
253
254 rtw89_phy_write32_mask(rtwdev, R_P0_NRBW, B_P0_NRBW_DBG, 0x1);
255 for (i = 0; i < RTW89_DACK_MSBK_NR; i++) {
256 rtw89_phy_write32_mask(rtwdev, R_DCOF0, B_DCOF0_V, i);
257 dack->msbk_d[0][0][i] = rtw89_phy_read32_mask(rtwdev,
258 R_DACK_S0P2,
259 B_DACK_S0M0);
260 rtw89_phy_write32_mask(rtwdev, R_DCOF8, B_DCOF8_V, i);
261 dack->msbk_d[0][1][i] = rtw89_phy_read32_mask(rtwdev,
262 R_DACK_S0P3,
263 B_DACK_S0M1);
264 }
265 dack->biask_d[0][0] = rtw89_phy_read32_mask(rtwdev, R_DACK_BIAS00,
266 B_DACK_BIAS00);
267 dack->biask_d[0][1] = rtw89_phy_read32_mask(rtwdev, R_DACK_BIAS01,
268 B_DACK_BIAS01);
269 dack->dadck_d[0][0] = rtw89_phy_read32_mask(rtwdev, R_DACK_DADCK00,
270 B_DACK_DADCK00);
271 dack->dadck_d[0][1] = rtw89_phy_read32_mask(rtwdev, R_DACK_DADCK01,
272 B_DACK_DADCK01);
273 }
274
_dack_backup_s1(struct rtw89_dev * rtwdev)275 static void _dack_backup_s1(struct rtw89_dev *rtwdev)
276 {
277 struct rtw89_dack_info *dack = &rtwdev->dack;
278 u8 i;
279
280 rtw89_phy_write32_mask(rtwdev, R_P1_DBGMOD, B_P1_DBGMOD_ON, 0x1);
281 for (i = 0; i < RTW89_DACK_MSBK_NR; i++) {
282 rtw89_phy_write32_mask(rtwdev, R_DACK10, B_DACK10, i);
283 dack->msbk_d[1][0][i] = rtw89_phy_read32_mask(rtwdev,
284 R_DACK10S,
285 B_DACK10S);
286 rtw89_phy_write32_mask(rtwdev, R_DACK11, B_DACK11, i);
287 dack->msbk_d[1][1][i] = rtw89_phy_read32_mask(rtwdev,
288 R_DACK11S,
289 B_DACK11S);
290 }
291 dack->biask_d[1][0] = rtw89_phy_read32_mask(rtwdev, R_DACK_BIAS10,
292 B_DACK_BIAS10);
293 dack->biask_d[1][1] = rtw89_phy_read32_mask(rtwdev, R_DACK_BIAS11,
294 B_DACK_BIAS11);
295 dack->dadck_d[1][0] = rtw89_phy_read32_mask(rtwdev, R_DACK_DADCK10,
296 B_DACK_DADCK10);
297 dack->dadck_d[1][1] = rtw89_phy_read32_mask(rtwdev, R_DACK_DADCK11,
298 B_DACK_DADCK11);
299 }
300
_dack_reload_by_path(struct rtw89_dev * rtwdev,enum rtw89_rf_path path,u8 index)301 static void _dack_reload_by_path(struct rtw89_dev *rtwdev,
302 enum rtw89_rf_path path, u8 index)
303 {
304 struct rtw89_dack_info *dack = &rtwdev->dack;
305 u32 idx_offset, path_offset;
306 u32 val32, offset, addr;
307 u8 i;
308
309 idx_offset = (index == 0 ? 0 : 0x14);
310 path_offset = (path == RF_PATH_A ? 0 : 0x28);
311 offset = idx_offset + path_offset;
312
313 rtw89_rfk_parser(rtwdev, &rtw8852c_dack_reload_defs_tbl);
314
315 /* msbk_d: 15/14/13/12 */
316 val32 = 0x0;
317 for (i = 0; i < RTW89_DACK_MSBK_NR / 4; i++)
318 val32 |= dack->msbk_d[path][index][i + 12] << (i * 8);
319 addr = 0xc200 + offset;
320 rtw89_phy_write32(rtwdev, addr, val32);
321 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]0x%x=0x%x\n", addr,
322 rtw89_phy_read32_mask(rtwdev, addr, MASKDWORD));
323
324 /* msbk_d: 11/10/9/8 */
325 val32 = 0x0;
326 for (i = 0; i < RTW89_DACK_MSBK_NR / 4; i++)
327 val32 |= dack->msbk_d[path][index][i + 8] << (i * 8);
328 addr = 0xc204 + offset;
329 rtw89_phy_write32(rtwdev, addr, val32);
330 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]0x%x=0x%x\n", addr,
331 rtw89_phy_read32_mask(rtwdev, addr, MASKDWORD));
332
333 /* msbk_d: 7/6/5/4 */
334 val32 = 0x0;
335 for (i = 0; i < RTW89_DACK_MSBK_NR / 4; i++)
336 val32 |= dack->msbk_d[path][index][i + 4] << (i * 8);
337 addr = 0xc208 + offset;
338 rtw89_phy_write32(rtwdev, addr, val32);
339 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]0x%x=0x%x\n", addr,
340 rtw89_phy_read32_mask(rtwdev, addr, MASKDWORD));
341
342 /* msbk_d: 3/2/1/0 */
343 val32 = 0x0;
344 for (i = 0; i < RTW89_DACK_MSBK_NR / 4; i++)
345 val32 |= dack->msbk_d[path][index][i] << (i * 8);
346 addr = 0xc20c + offset;
347 rtw89_phy_write32(rtwdev, addr, val32);
348 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]0x%x=0x%x\n", addr,
349 rtw89_phy_read32_mask(rtwdev, addr, MASKDWORD));
350
351 /* dadak_d/biask_d */
352 val32 = (dack->biask_d[path][index] << 22) |
353 (dack->dadck_d[path][index] << 14);
354 addr = 0xc210 + offset;
355 rtw89_phy_write32(rtwdev, addr, val32);
356 rtw89_phy_write32_set(rtwdev, addr, BIT(0));
357 }
358
_dack_reload(struct rtw89_dev * rtwdev,enum rtw89_rf_path path)359 static void _dack_reload(struct rtw89_dev *rtwdev, enum rtw89_rf_path path)
360 {
361 u8 i;
362
363 for (i = 0; i < 2; i++)
364 _dack_reload_by_path(rtwdev, path, i);
365 }
366
_addck(struct rtw89_dev * rtwdev)367 static void _addck(struct rtw89_dev *rtwdev)
368 {
369 struct rtw89_dack_info *dack = &rtwdev->dack;
370 u32 val;
371 int ret;
372
373 /* S0 */
374 rtw89_phy_write32_mask(rtwdev, R_ADDCK0, B_ADDCK0_RST, 0x1);
375 rtw89_phy_write32_mask(rtwdev, R_ADDCK0, B_ADDCK0_EN, 0x1);
376 rtw89_phy_write32_mask(rtwdev, R_ADDCK0, B_ADDCK0_EN, 0x0);
377 fsleep(1);
378 rtw89_phy_write32_mask(rtwdev, R_ADDCK0, B_ADDCK0, 0x1);
379
380 ret = read_poll_timeout_atomic(rtw89_phy_read32_mask, val, val,
381 1, 10000, false, rtwdev, 0xc0fc, BIT(0));
382 if (ret) {
383 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]S0 ADDCK timeout\n");
384 dack->addck_timeout[0] = true;
385 }
386
387 rtw89_phy_write32_mask(rtwdev, R_ADDCK0, B_ADDCK0_RST, 0x0);
388
389 /* S1 */
390 rtw89_phy_write32_mask(rtwdev, R_ADDCK1, B_ADDCK1_RST, 0x1);
391 rtw89_phy_write32_mask(rtwdev, R_ADDCK1, B_ADDCK1_EN, 0x1);
392 rtw89_phy_write32_mask(rtwdev, R_ADDCK1, B_ADDCK1_EN, 0x0);
393 udelay(1);
394 rtw89_phy_write32_mask(rtwdev, R_ADDCK1, B_ADDCK1, 0x1);
395
396 ret = read_poll_timeout_atomic(rtw89_phy_read32_mask, val, val,
397 1, 10000, false, rtwdev, 0xc1fc, BIT(0));
398 if (ret) {
399 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]S1 ADDCK timeout\n");
400 dack->addck_timeout[0] = true;
401 }
402 rtw89_phy_write32_mask(rtwdev, R_ADDCK1, B_ADDCK1_RST, 0x0);
403 }
404
_dack_reset(struct rtw89_dev * rtwdev,u8 path)405 static void _dack_reset(struct rtw89_dev *rtwdev, u8 path)
406 {
407 rtw89_rfk_parser_by_cond(rtwdev, path == RF_PATH_A,
408 &rtw8852c_dack_reset_defs_a_tbl,
409 &rtw8852c_dack_reset_defs_b_tbl);
410 }
411
412 enum adc_ck {
413 ADC_NA = 0,
414 ADC_480M = 1,
415 ADC_960M = 2,
416 ADC_1920M = 3,
417 };
418
419 enum dac_ck {
420 DAC_40M = 0,
421 DAC_80M = 1,
422 DAC_120M = 2,
423 DAC_160M = 3,
424 DAC_240M = 4,
425 DAC_320M = 5,
426 DAC_480M = 6,
427 DAC_960M = 7,
428 };
429
430 enum rf_mode {
431 RF_SHUT_DOWN = 0x0,
432 RF_STANDBY = 0x1,
433 RF_TX = 0x2,
434 RF_RX = 0x3,
435 RF_TXIQK = 0x4,
436 RF_DPK = 0x5,
437 RF_RXK1 = 0x6,
438 RF_RXK2 = 0x7,
439 };
440
rtw8852c_txck_force(struct rtw89_dev * rtwdev,u8 path,bool force,enum dac_ck ck)441 static void rtw8852c_txck_force(struct rtw89_dev *rtwdev, u8 path, bool force,
442 enum dac_ck ck)
443 {
444 rtw89_phy_write32_mask(rtwdev, R_P0_RXCK | (path << 13), B_P0_TXCK_ON, 0x0);
445
446 if (!force)
447 return;
448
449 rtw89_phy_write32_mask(rtwdev, R_P0_RXCK | (path << 13), B_P0_TXCK_VAL, ck);
450 rtw89_phy_write32_mask(rtwdev, R_P0_RXCK | (path << 13), B_P0_TXCK_ON, 0x1);
451 }
452
rtw8852c_rxck_force(struct rtw89_dev * rtwdev,u8 path,bool force,enum adc_ck ck)453 static void rtw8852c_rxck_force(struct rtw89_dev *rtwdev, u8 path, bool force,
454 enum adc_ck ck)
455 {
456 const struct rxck_def *def;
457
458 rtw89_phy_write32_mask(rtwdev, R_P0_RXCK | (path << 13), B_P0_RXCK_ON, 0x0);
459
460 if (!force)
461 return;
462
463 rtw89_phy_write32_mask(rtwdev, R_P0_RXCK | (path << 13), B_P0_RXCK_VAL, ck);
464 rtw89_phy_write32_mask(rtwdev, R_P0_RXCK | (path << 13), B_P0_RXCK_ON, 0x1);
465
466 switch (ck) {
467 case ADC_480M:
468 def = &_ck480M;
469 break;
470 case ADC_960M:
471 def = &_ck960M;
472 break;
473 case ADC_1920M:
474 default:
475 def = &_ck1920M;
476 break;
477 }
478
479 rtw89_phy_write32_mask(rtwdev, R_P0_CFCH_BW0 | (path << 8), B_P0_CFCH_CTL, def->ctl);
480 rtw89_phy_write32_mask(rtwdev, R_P0_CFCH_BW0 | (path << 8), B_P0_CFCH_EN, def->en);
481 rtw89_phy_write32_mask(rtwdev, R_P0_CFCH_BW0 | (path << 8), B_P0_CFCH_BW0, def->bw0);
482 rtw89_phy_write32_mask(rtwdev, R_P0_CFCH_BW1 | (path << 8), B_P0_CFCH_BW1, def->bw1);
483 rtw89_phy_write32_mask(rtwdev, R_DRCK | (path << 8), B_DRCK_MUL, def->mul);
484 rtw89_phy_write32_mask(rtwdev, R_ADCMOD | (path << 8), B_ADCMOD_LP, def->lp);
485 }
486
_check_dack_done(struct rtw89_dev * rtwdev,bool s0)487 static bool _check_dack_done(struct rtw89_dev *rtwdev, bool s0)
488 {
489 if (s0) {
490 if (rtw89_phy_read32_mask(rtwdev, R_DACK_S0P0, B_DACK_S0P0_OK) == 0 ||
491 rtw89_phy_read32_mask(rtwdev, R_DACK_S0P1, B_DACK_S0P1_OK) == 0 ||
492 rtw89_phy_read32_mask(rtwdev, R_DACK_S0P2, B_DACK_S0P2_OK) == 0 ||
493 rtw89_phy_read32_mask(rtwdev, R_DACK_S0P3, B_DACK_S0P3_OK) == 0)
494 return false;
495 } else {
496 if (rtw89_phy_read32_mask(rtwdev, R_DACK_S1P0, B_DACK_S1P0_OK) == 0 ||
497 rtw89_phy_read32_mask(rtwdev, R_DACK_S1P1, B_DACK_S1P1_OK) == 0 ||
498 rtw89_phy_read32_mask(rtwdev, R_DACK_S1P2, B_DACK_S1P2_OK) == 0 ||
499 rtw89_phy_read32_mask(rtwdev, R_DACK_S1P3, B_DACK_S1P3_OK) == 0)
500 return false;
501 }
502
503 return true;
504 }
505
_dack_s0(struct rtw89_dev * rtwdev)506 static void _dack_s0(struct rtw89_dev *rtwdev)
507 {
508 struct rtw89_dack_info *dack = &rtwdev->dack;
509 bool done;
510 int ret;
511
512 rtw8852c_txck_force(rtwdev, RF_PATH_A, true, DAC_160M);
513 rtw89_rfk_parser(rtwdev, &rtw8852c_dack_defs_s0_tbl);
514
515 _dack_reset(rtwdev, RF_PATH_A);
516
517 rtw89_phy_write32_mask(rtwdev, R_DCOF1, B_DCOF1_S, 0x1);
518 ret = read_poll_timeout_atomic(_check_dack_done, done, done,
519 1, 10000, false, rtwdev, true);
520 if (ret) {
521 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]S0 DACK timeout\n");
522 dack->msbk_timeout[0] = true;
523 }
524 rtw89_phy_write32_mask(rtwdev, R_DCOF1, B_DCOF1_S, 0x0);
525 rtw8852c_txck_force(rtwdev, RF_PATH_A, false, DAC_960M);
526 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]after S0 DADCK\n");
527
528 _dack_backup_s0(rtwdev);
529 _dack_reload(rtwdev, RF_PATH_A);
530 rtw89_phy_write32_mask(rtwdev, R_P0_NRBW, B_P0_NRBW_DBG, 0x0);
531 }
532
_dack_s1(struct rtw89_dev * rtwdev)533 static void _dack_s1(struct rtw89_dev *rtwdev)
534 {
535 struct rtw89_dack_info *dack = &rtwdev->dack;
536 bool done;
537 int ret;
538
539 rtw8852c_txck_force(rtwdev, RF_PATH_B, true, DAC_160M);
540 rtw89_rfk_parser(rtwdev, &rtw8852c_dack_defs_s1_tbl);
541
542 _dack_reset(rtwdev, RF_PATH_B);
543
544 rtw89_phy_write32_mask(rtwdev, R_DACK1_K, B_DACK1_EN, 0x1);
545 ret = read_poll_timeout_atomic(_check_dack_done, done, done,
546 1, 10000, false, rtwdev, false);
547 if (ret) {
548 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]S1 DACK timeout\n");
549 dack->msbk_timeout[0] = true;
550 }
551 rtw89_phy_write32_mask(rtwdev, R_DACK1_K, B_DACK1_EN, 0x0);
552 rtw8852c_txck_force(rtwdev, RF_PATH_B, false, DAC_960M);
553 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]after S1 DADCK\n");
554
555 _dack_backup_s1(rtwdev);
556 _dack_reload(rtwdev, RF_PATH_B);
557 rtw89_phy_write32_mask(rtwdev, R_P1_DBGMOD, B_P1_DBGMOD_ON, 0x0);
558 }
559
_dack(struct rtw89_dev * rtwdev)560 static void _dack(struct rtw89_dev *rtwdev)
561 {
562 _dack_s0(rtwdev);
563 _dack_s1(rtwdev);
564 }
565
_drck(struct rtw89_dev * rtwdev)566 static void _drck(struct rtw89_dev *rtwdev)
567 {
568 u32 val;
569 int ret;
570
571 rtw89_phy_write32_mask(rtwdev, R_DRCK, B_DRCK_EN, 0x1);
572 ret = read_poll_timeout_atomic(rtw89_phy_read32_mask, val, val,
573 1, 10000, false, rtwdev, 0xc0c8, BIT(3));
574 if (ret)
575 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]DRCK timeout\n");
576
577 rtw89_rfk_parser(rtwdev, &rtw8852c_drck_defs_tbl);
578
579 val = rtw89_phy_read32_mask(rtwdev, R_DRCK_RES, B_DRCK_RES);
580 rtw89_phy_write32_mask(rtwdev, R_DRCK, B_DRCK_IDLE, 0x0);
581 rtw89_phy_write32_mask(rtwdev, R_DRCK, B_DRCK_VAL, val);
582 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]0xc0c4 = 0x%x\n",
583 rtw89_phy_read32_mask(rtwdev, R_DRCK, MASKDWORD));
584 }
585
_dac_cal(struct rtw89_dev * rtwdev,bool force)586 static void _dac_cal(struct rtw89_dev *rtwdev, bool force)
587 {
588 struct rtw89_dack_info *dack = &rtwdev->dack;
589 u32 rf0_0, rf1_0;
590 u8 phy_map = rtw89_btc_phymap(rtwdev, RTW89_PHY_0, RF_AB);
591
592 dack->dack_done = false;
593 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]DACK b\n");
594 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]DACK start!!!\n");
595 rf0_0 = rtw89_read_rf(rtwdev, RF_PATH_A, RR_MOD, RFREG_MASK);
596 rf1_0 = rtw89_read_rf(rtwdev, RF_PATH_B, RR_MOD, RFREG_MASK);
597 _drck(rtwdev);
598
599 rtw89_write_rf(rtwdev, RF_PATH_A, RR_RSV1, RR_RSV1_RST, 0x0);
600 rtw89_write_rf(rtwdev, RF_PATH_B, RR_RSV1, RR_RSV1_RST, 0x0);
601 rtw89_write_rf(rtwdev, RF_PATH_A, RR_MOD, RFREG_MASK, 0x337e1);
602 rtw89_write_rf(rtwdev, RF_PATH_B, RR_MOD, RFREG_MASK, 0x337e1);
603 rtw89_btc_ntfy_wl_rfk(rtwdev, phy_map, BTC_WRFKT_DACK, BTC_WRFK_ONESHOT_START);
604 _addck(rtwdev);
605 rtw89_btc_ntfy_wl_rfk(rtwdev, phy_map, BTC_WRFKT_DACK, BTC_WRFK_ONESHOT_STOP);
606
607 _addck_backup(rtwdev);
608 _addck_reload(rtwdev);
609 rtw89_write_rf(rtwdev, RF_PATH_A, RR_MODOPT, RFREG_MASK, 0x0);
610 rtw89_write_rf(rtwdev, RF_PATH_B, RR_MODOPT, RFREG_MASK, 0x0);
611 rtw89_btc_ntfy_wl_rfk(rtwdev, phy_map, BTC_WRFKT_DACK, BTC_WRFK_ONESHOT_START);
612 _dack(rtwdev);
613 rtw89_btc_ntfy_wl_rfk(rtwdev, phy_map, BTC_WRFKT_DACK, BTC_WRFK_ONESHOT_STOP);
614
615 _dack_dump(rtwdev);
616 dack->dack_done = true;
617 rtw89_write_rf(rtwdev, RF_PATH_A, RR_MOD, RFREG_MASK, rf0_0);
618 rtw89_write_rf(rtwdev, RF_PATH_B, RR_MOD, RFREG_MASK, rf1_0);
619 rtw89_write_rf(rtwdev, RF_PATH_A, RR_RSV1, RR_RSV1_RST, 0x1);
620 rtw89_write_rf(rtwdev, RF_PATH_B, RR_RSV1, RR_RSV1_RST, 0x1);
621 dack->dack_cnt++;
622 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DACK]DACK finish!!!\n");
623 }
624
625 #define RTW8852C_NCTL_VER 0xd
626 #define RTW8852C_IQK_VER 0x2a
627 #define RTW8852C_IQK_SS 2
628 #define RTW8852C_IQK_THR_REK 8
629 #define RTW8852C_IQK_CFIR_GROUP_NR 4
630
631 enum rtw8852c_iqk_type {
632 ID_TXAGC,
633 ID_G_FLOK_COARSE,
634 ID_A_FLOK_COARSE,
635 ID_G_FLOK_FINE,
636 ID_A_FLOK_FINE,
637 ID_FLOK_VBUFFER,
638 ID_TXK,
639 ID_RXAGC,
640 ID_RXK,
641 ID_NBTXK,
642 ID_NBRXK,
643 };
644
rtw8852c_disable_rxagc(struct rtw89_dev * rtwdev,u8 path,u8 en_rxgac)645 static void rtw8852c_disable_rxagc(struct rtw89_dev *rtwdev, u8 path, u8 en_rxgac)
646 {
647 if (path == RF_PATH_A)
648 rtw89_phy_write32_mask(rtwdev, R_P0_AGC_CTL, B_P0_AGC_EN, en_rxgac);
649 else
650 rtw89_phy_write32_mask(rtwdev, R_P1_AGC_CTL, B_P1_AGC_EN, en_rxgac);
651 }
652
_iqk_rxk_setting(struct rtw89_dev * rtwdev,u8 path)653 static void _iqk_rxk_setting(struct rtw89_dev *rtwdev, u8 path)
654 {
655 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
656
657 if (path == RF_PATH_A)
658 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_RXK, 0x0101);
659 else
660 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_RXK, 0x0202);
661
662 switch (iqk_info->iqk_bw[path]) {
663 case RTW89_CHANNEL_WIDTH_20:
664 case RTW89_CHANNEL_WIDTH_40:
665 rtw89_phy_write32_mask(rtwdev, R_UPD_CLK + (path << 13), B_DPD_GDIS, 0x1);
666 rtw8852c_rxck_force(rtwdev, path, true, ADC_480M);
667 rtw89_phy_write32_mask(rtwdev, R_UPD_CLK + (path << 13), B_ACK_VAL, 0x0);
668 rtw89_write_rf(rtwdev, path, RR_RXBB2, RR_RXBB2_CKT, 0x1);
669 rtw89_phy_write32_mask(rtwdev, R_P0_NRBW + (path << 13), B_P0_NRBW_DBG, 0x1);
670 break;
671 case RTW89_CHANNEL_WIDTH_80:
672 rtw89_phy_write32_mask(rtwdev, R_UPD_CLK + (path << 13), B_DPD_GDIS, 0x1);
673 rtw8852c_rxck_force(rtwdev, path, true, ADC_960M);
674 rtw89_phy_write32_mask(rtwdev, R_UPD_CLK + (path << 13), B_ACK_VAL, 0x1);
675 rtw89_write_rf(rtwdev, path, RR_RXBB2, RR_RXBB2_CKT, 0x1);
676 rtw89_phy_write32_mask(rtwdev, R_P0_NRBW + (path << 13), B_P0_NRBW_DBG, 0x1);
677 break;
678 case RTW89_CHANNEL_WIDTH_160:
679 rtw89_phy_write32_mask(rtwdev, R_UPD_CLK + (path << 13), B_DPD_GDIS, 0x1);
680 rtw8852c_rxck_force(rtwdev, path, true, ADC_1920M);
681 rtw89_phy_write32_mask(rtwdev, R_UPD_CLK + (path << 13), B_ACK_VAL, 0x2);
682 rtw89_write_rf(rtwdev, path, RR_RXBB2, RR_RXBB2_CKT, 0x1);
683 rtw89_phy_write32_mask(rtwdev, R_P0_NRBW + (path << 13), B_P0_NRBW_DBG, 0x1);
684 break;
685 default:
686 break;
687 }
688
689 rtw89_rfk_parser(rtwdev, &rtw8852c_iqk_rxk_cfg_defs_tbl);
690
691 if (path == RF_PATH_A)
692 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_RXK, 0x1101);
693 else
694 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_RXK, 0x2202);
695 }
696
_iqk_check_cal(struct rtw89_dev * rtwdev,u8 path,u8 ktype)697 static bool _iqk_check_cal(struct rtw89_dev *rtwdev, u8 path, u8 ktype)
698 {
699 u32 tmp;
700 u32 val;
701 int ret;
702
703 ret = read_poll_timeout_atomic(rtw89_phy_read32_mask, val, val == 0x55,
704 1, 8200, false, rtwdev, 0xbff8, MASKBYTE0);
705 if (ret)
706 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]IQK timeout!!!\n");
707
708 rtw89_phy_write32_clr(rtwdev, R_NCTL_N1, MASKBYTE0);
709 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]S%x, ret=%d\n", path, ret);
710 tmp = rtw89_phy_read32_mask(rtwdev, R_NCTL_RPT, MASKDWORD);
711 rtw89_debug(rtwdev, RTW89_DBG_RFK,
712 "[IQK]S%x, type= %x, 0x8008 = 0x%x\n", path, ktype, tmp);
713
714 return false;
715 }
716
_iqk_one_shot(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy_idx,u8 path,u8 ktype)717 static bool _iqk_one_shot(struct rtw89_dev *rtwdev,
718 enum rtw89_phy_idx phy_idx, u8 path, u8 ktype)
719 {
720 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
721 u32 addr_rfc_ctl = R_UPD_CLK + (path << 13);
722 u32 iqk_cmd;
723 bool fail;
724
725 switch (ktype) {
726 case ID_TXAGC:
727 iqk_cmd = 0x008 | (1 << (4 + path)) | (path << 1);
728 break;
729 case ID_A_FLOK_COARSE:
730 rtw89_phy_write32_mask(rtwdev, addr_rfc_ctl, 0x00000002, 0x1);
731 iqk_cmd = 0x008 | (1 << (4 + path));
732 break;
733 case ID_G_FLOK_COARSE:
734 rtw89_phy_write32_mask(rtwdev, addr_rfc_ctl, 0x00000002, 0x1);
735 iqk_cmd = 0x108 | (1 << (4 + path));
736 break;
737 case ID_A_FLOK_FINE:
738 rtw89_phy_write32_mask(rtwdev, addr_rfc_ctl, 0x00000002, 0x1);
739 iqk_cmd = 0x508 | (1 << (4 + path));
740 break;
741 case ID_G_FLOK_FINE:
742 rtw89_phy_write32_mask(rtwdev, addr_rfc_ctl, 0x00000002, 0x1);
743 iqk_cmd = 0x208 | (1 << (4 + path));
744 break;
745 case ID_FLOK_VBUFFER:
746 rtw89_phy_write32_mask(rtwdev, addr_rfc_ctl, 0x00000002, 0x1);
747 iqk_cmd = 0x308 | (1 << (4 + path));
748 break;
749 case ID_TXK:
750 rtw89_phy_write32_mask(rtwdev, addr_rfc_ctl, 0x00000002, 0x0);
751 iqk_cmd = 0x008 | (1 << (4 + path)) | ((0x8 + iqk_info->iqk_bw[path]) << 8);
752 break;
753 case ID_RXAGC:
754 iqk_cmd = 0x508 | (1 << (4 + path)) | (path << 1);
755 break;
756 case ID_RXK:
757 rtw89_phy_write32_mask(rtwdev, addr_rfc_ctl, 0x00000002, 0x1);
758 iqk_cmd = 0x008 | (1 << (4 + path)) | ((0xc + iqk_info->iqk_bw[path]) << 8);
759 break;
760 case ID_NBTXK:
761 rtw89_phy_write32_mask(rtwdev, addr_rfc_ctl, 0x00000002, 0x0);
762 iqk_cmd = 0x408 | (1 << (4 + path));
763 break;
764 case ID_NBRXK:
765 rtw89_phy_write32_mask(rtwdev, addr_rfc_ctl, 0x00000002, 0x1);
766 iqk_cmd = 0x608 | (1 << (4 + path));
767 break;
768 default:
769 return false;
770 }
771
772 rtw89_phy_write32_mask(rtwdev, R_NCTL_CFG, MASKDWORD, iqk_cmd + 1);
773 fsleep(15);
774 fail = _iqk_check_cal(rtwdev, path, ktype);
775 rtw89_phy_write32_mask(rtwdev, addr_rfc_ctl, 0x00000002, 0x0);
776
777 return fail;
778 }
779
_rxk_group_sel(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy_idx,u8 path)780 static bool _rxk_group_sel(struct rtw89_dev *rtwdev,
781 enum rtw89_phy_idx phy_idx, u8 path)
782 {
783 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
784 bool fail;
785 u32 tmp;
786 u32 bkrf0;
787 u8 gp;
788
789 bkrf0 = rtw89_read_rf(rtwdev, path, RR_MOD, RR_MOD_NBW);
790 if (path == RF_PATH_B) {
791 rtw89_write_rf(rtwdev, RF_PATH_B, RR_IQKPLL, RR_IQKPLL_MOD, 0x3);
792 tmp = rtw89_read_rf(rtwdev, RF_PATH_B, RR_CHTR, RR_CHTR_MOD);
793 rtw89_write_rf(rtwdev, RF_PATH_B, RR_RSV4, RR_RSV4_AGH, tmp);
794 tmp = rtw89_read_rf(rtwdev, RF_PATH_B, RR_CHTR, RR_CHTR_TXRX);
795 rtw89_write_rf(rtwdev, RF_PATH_B, RR_RSV4, RR_RSV4_PLLCH, tmp);
796 }
797
798 switch (iqk_info->iqk_band[path]) {
799 case RTW89_BAND_2G:
800 default:
801 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_MASK, 0xc);
802 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_NBW, 0x0);
803 rtw89_write_rf(rtwdev, path, RR_RXG, RR_RXG_IQKMOD, 0x9);
804 break;
805 case RTW89_BAND_5G:
806 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_MASK, 0xc);
807 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_NBW, 0x0);
808 rtw89_write_rf(rtwdev, path, RR_RXAE, RR_RXAE_IQKMOD, 0x8);
809 break;
810 case RTW89_BAND_6G:
811 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_MASK, 0xc);
812 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_NBW, 0x0);
813 rtw89_write_rf(rtwdev, path, RR_RXAE, RR_RXAE_IQKMOD, 0x9);
814 break;
815 }
816
817 fsleep(10);
818
819 for (gp = 0; gp < RXK_GROUP_NR; gp++) {
820 switch (iqk_info->iqk_band[path]) {
821 case RTW89_BAND_2G:
822 default:
823 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_M_RXG,
824 _rxk_g_idxrxgain[gp]);
825 rtw89_write_rf(rtwdev, path, RR_RXBB, RR_RXBB_VOBUF,
826 _rxk_g_idxattc2[gp]);
827 break;
828 case RTW89_BAND_5G:
829 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_M_RXG,
830 _rxk_a_idxrxgain[gp]);
831 rtw89_write_rf(rtwdev, path, RR_RXA2, RR_RXA2_IATT,
832 _rxk_a_idxattc2[gp]);
833 break;
834 case RTW89_BAND_6G:
835 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_M_RXG,
836 _rxk_a6_idxrxgain[gp]);
837 rtw89_write_rf(rtwdev, path, RR_RXA2, RR_RXA2_IATT,
838 _rxk_a6_idxattc2[gp]);
839 break;
840 }
841 rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8),
842 B_CFIR_LUT_SEL, 0x1);
843 rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8),
844 B_CFIR_LUT_SET, 0x0);
845 rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8),
846 B_CFIR_LUT_GP_V1, gp);
847 fail = _iqk_one_shot(rtwdev, phy_idx, path, ID_RXK);
848 }
849
850 if (path == RF_PATH_B)
851 rtw89_write_rf(rtwdev, path, RR_IQKPLL, RR_IQKPLL_MOD, 0x0);
852 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_NBW, bkrf0);
853
854 if (fail) {
855 iqk_info->nb_rxcfir[path] = 0x40000002;
856 iqk_info->is_wb_rxiqk[path] = false;
857 } else {
858 iqk_info->nb_rxcfir[path] = 0x40000000;
859 iqk_info->is_wb_rxiqk[path] = true;
860 }
861
862 return false;
863 }
864
_iqk_nbrxk(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy_idx,u8 path)865 static bool _iqk_nbrxk(struct rtw89_dev *rtwdev,
866 enum rtw89_phy_idx phy_idx, u8 path)
867 {
868 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
869 bool fail;
870 u32 tmp;
871 u32 bkrf0;
872 u8 gp = 0x2;
873
874 bkrf0 = rtw89_read_rf(rtwdev, path, RR_MOD, RR_MOD_NBW);
875 if (path == RF_PATH_B) {
876 rtw89_write_rf(rtwdev, RF_PATH_B, RR_IQKPLL, RR_IQKPLL_MOD, 0x3);
877 tmp = rtw89_read_rf(rtwdev, RF_PATH_B, RR_CHTR, RR_CHTR_MOD);
878 rtw89_write_rf(rtwdev, RF_PATH_B, RR_RSV4, RR_RSV4_AGH, tmp);
879 tmp = rtw89_read_rf(rtwdev, RF_PATH_B, RR_CHTR, RR_CHTR_TXRX);
880 rtw89_write_rf(rtwdev, RF_PATH_B, RR_RSV4, RR_RSV4_PLLCH, tmp);
881 }
882
883 switch (iqk_info->iqk_band[path]) {
884 case RTW89_BAND_2G:
885 default:
886 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_MASK, 0xc);
887 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_NBW, 0x0);
888 rtw89_write_rf(rtwdev, path, RR_RXG, RR_RXG_IQKMOD, 0x9);
889 break;
890 case RTW89_BAND_5G:
891 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_MASK, 0xc);
892 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_NBW, 0x0);
893 rtw89_write_rf(rtwdev, path, RR_RXAE, RR_RXAE_IQKMOD, 0x8);
894 break;
895 case RTW89_BAND_6G:
896 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_MASK, 0xc);
897 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_NBW, 0x0);
898 rtw89_write_rf(rtwdev, path, RR_RXAE, RR_RXAE_IQKMOD, 0x9);
899 break;
900 }
901
902 fsleep(10);
903
904 switch (iqk_info->iqk_band[path]) {
905 case RTW89_BAND_2G:
906 default:
907 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_M_RXG, _rxk_g_idxrxgain[gp]);
908 rtw89_write_rf(rtwdev, path, RR_RXBB, RR_RXBB_VOBUF, _rxk_g_idxattc2[gp]);
909 break;
910 case RTW89_BAND_5G:
911 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_M_RXG, _rxk_a_idxrxgain[gp]);
912 rtw89_write_rf(rtwdev, path, RR_RXA2, RR_RXA2_IATT, _rxk_a_idxattc2[gp]);
913 break;
914 case RTW89_BAND_6G:
915 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_M_RXG, _rxk_a6_idxrxgain[gp]);
916 rtw89_write_rf(rtwdev, path, RR_RXA2, RR_RXA2_IATT, _rxk_a6_idxattc2[gp]);
917 break;
918 }
919
920 rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8), B_CFIR_LUT_SEL, 0x1);
921 rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8), B_CFIR_LUT_SET, 0x0);
922 rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8), B_CFIR_LUT_GP_V1, gp);
923 fail = _iqk_one_shot(rtwdev, phy_idx, path, ID_RXK);
924
925 if (path == RF_PATH_B)
926 rtw89_write_rf(rtwdev, path, RR_IQKPLL, RR_IQKPLL_MOD, 0x0);
927
928 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_NBW, bkrf0);
929
930 if (fail)
931 iqk_info->nb_rxcfir[path] =
932 rtw89_phy_read32_mask(rtwdev, R_RXIQC + (path << 8),
933 MASKDWORD) | 0x2;
934 else
935 iqk_info->nb_rxcfir[path] = 0x40000002;
936
937 iqk_info->is_wb_rxiqk[path] = false;
938 return fail;
939 }
940
_txk_group_sel(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy_idx,u8 path)941 static bool _txk_group_sel(struct rtw89_dev *rtwdev,
942 enum rtw89_phy_idx phy_idx, u8 path)
943 {
944 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
945 bool fail;
946 u8 gp;
947
948 for (gp = 0; gp < TXK_GROUP_NR; gp++) {
949 switch (iqk_info->iqk_band[path]) {
950 case RTW89_BAND_2G:
951 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR0,
952 _txk_g_power_range[gp]);
953 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR1,
954 _txk_g_track_range[gp]);
955 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG,
956 _txk_g_gain_bb[gp]);
957 rtw89_phy_write32_mask(rtwdev,
958 R_KIP_IQP + (path << 8),
959 MASKDWORD, _txk_g_itqt[gp]);
960 break;
961 case RTW89_BAND_5G:
962 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR0,
963 _txk_a_power_range[gp]);
964 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR1,
965 _txk_a_track_range[gp]);
966 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG,
967 _txk_a_gain_bb[gp]);
968 rtw89_phy_write32_mask(rtwdev,
969 R_KIP_IQP + (path << 8),
970 MASKDWORD, _txk_a_itqt[gp]);
971 break;
972 case RTW89_BAND_6G:
973 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR0,
974 _txk_a6_power_range[gp]);
975 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR1,
976 _txk_a6_track_range[gp]);
977 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG,
978 _txk_a6_gain_bb[gp]);
979 rtw89_phy_write32_mask(rtwdev,
980 R_KIP_IQP + (path << 8),
981 MASKDWORD, _txk_a6_itqt[gp]);
982 break;
983 default:
984 break;
985 }
986 rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8),
987 B_CFIR_LUT_SEL, 0x1);
988 rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8),
989 B_CFIR_LUT_SET, 0x1);
990 rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8),
991 B_CFIR_LUT_G2, 0x0);
992 rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8),
993 B_CFIR_LUT_GP, gp + 1);
994 rtw89_phy_write32_mask(rtwdev, R_IQK_DIF4, B_IQK_DIF4_TXT, 0x00b);
995 rtw89_phy_write32_mask(rtwdev, R_NCTL_N1, B_NCTL_N1_CIP, 0x00);
996 fail = _iqk_one_shot(rtwdev, phy_idx, path, ID_TXK);
997 }
998
999 if (fail) {
1000 iqk_info->nb_txcfir[path] = 0x40000002;
1001 iqk_info->is_wb_txiqk[path] = false;
1002 } else {
1003 iqk_info->nb_txcfir[path] = 0x40000000;
1004 iqk_info->is_wb_txiqk[path] = true;
1005 }
1006
1007 return fail;
1008 }
1009
_iqk_nbtxk(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy_idx,u8 path)1010 static bool _iqk_nbtxk(struct rtw89_dev *rtwdev,
1011 enum rtw89_phy_idx phy_idx, u8 path)
1012 {
1013 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
1014 bool fail;
1015 u8 gp = 0x2;
1016
1017 switch (iqk_info->iqk_band[path]) {
1018 case RTW89_BAND_2G:
1019 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR0, _txk_g_power_range[gp]);
1020 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR1, _txk_g_track_range[gp]);
1021 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, _txk_g_gain_bb[gp]);
1022 rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
1023 MASKDWORD, _txk_g_itqt[gp]);
1024 break;
1025 case RTW89_BAND_5G:
1026 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR0, _txk_a_power_range[gp]);
1027 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR1, _txk_a_track_range[gp]);
1028 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, _txk_a_gain_bb[gp]);
1029 rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
1030 MASKDWORD, _txk_a_itqt[gp]);
1031 break;
1032 case RTW89_BAND_6G:
1033 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR0, _txk_a6_power_range[gp]);
1034 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR1, _txk_a6_track_range[gp]);
1035 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, _txk_a6_gain_bb[gp]);
1036 rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
1037 MASKDWORD, _txk_a6_itqt[gp]);
1038 break;
1039 default:
1040 break;
1041 }
1042
1043 rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8), B_CFIR_LUT_SEL, 0x1);
1044 rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8), B_CFIR_LUT_SET, 0x1);
1045 rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8), B_CFIR_LUT_G2, 0x0);
1046 rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8), B_CFIR_LUT_GP, gp + 1);
1047 rtw89_phy_write32_mask(rtwdev, R_IQK_DIF4, B_IQK_DIF4_TXT, 0x00b);
1048 rtw89_phy_write32_mask(rtwdev, R_NCTL_N1, B_NCTL_N1_CIP, 0x00);
1049 fail = _iqk_one_shot(rtwdev, phy_idx, path, ID_NBTXK);
1050
1051 if (!fail)
1052 iqk_info->nb_txcfir[path] =
1053 rtw89_phy_read32_mask(rtwdev, R_TXIQC + (path << 8),
1054 MASKDWORD) | 0x2;
1055 else
1056 iqk_info->nb_txcfir[path] = 0x40000002;
1057
1058 iqk_info->is_wb_txiqk[path] = false;
1059
1060 return fail;
1061 }
1062
_lok_finetune_check(struct rtw89_dev * rtwdev,u8 path)1063 static bool _lok_finetune_check(struct rtw89_dev *rtwdev, u8 path)
1064 {
1065 struct rtw89_rfk_mcc_info *rfk_mcc = &rtwdev->rfk_mcc;
1066 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
1067 u8 idx = rfk_mcc->table_idx;
1068 bool is_fail1, is_fail2;
1069 u32 val;
1070 u32 core_i;
1071 u32 core_q;
1072 u32 vbuff_i;
1073 u32 vbuff_q;
1074
1075 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]===>%s\n", __func__);
1076 val = rtw89_read_rf(rtwdev, path, RR_TXMO, RFREG_MASK);
1077 core_i = FIELD_GET(RR_TXMO_COI, val);
1078 core_q = FIELD_GET(RR_TXMO_COQ, val);
1079
1080 if (core_i < 0x2 || core_i > 0x1d || core_q < 0x2 || core_q > 0x1d)
1081 is_fail1 = true;
1082 else
1083 is_fail1 = false;
1084
1085 iqk_info->lok_idac[idx][path] = val;
1086
1087 val = rtw89_read_rf(rtwdev, path, RR_LOKVB, RFREG_MASK);
1088 vbuff_i = FIELD_GET(RR_LOKVB_COI, val);
1089 vbuff_q = FIELD_GET(RR_LOKVB_COQ, val);
1090
1091 if (vbuff_i < 0x2 || vbuff_i > 0x3d || vbuff_q < 0x2 || vbuff_q > 0x3d)
1092 is_fail2 = true;
1093 else
1094 is_fail2 = false;
1095
1096 iqk_info->lok_vbuf[idx][path] = val;
1097
1098 return is_fail1 || is_fail2;
1099 }
1100
_iqk_lok(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy_idx,u8 path)1101 static bool _iqk_lok(struct rtw89_dev *rtwdev,
1102 enum rtw89_phy_idx phy_idx, u8 path)
1103 {
1104 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
1105 u8 tmp_id = 0x0;
1106 bool fail = false;
1107 bool tmp = false;
1108
1109 /* Step 0: Init RF gain & tone idx= 8.25Mhz */
1110 rtw89_phy_write32_mask(rtwdev, R_IQK_DIF4, B_IQK_DIF4_TXT, IQK_DF4_TXT_8_25MHZ);
1111
1112 /* Step 1 START: _lok_coarse_fine_wi_swap */
1113 switch (iqk_info->iqk_band[path]) {
1114 case RTW89_BAND_2G:
1115 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x6);
1116 rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
1117 B_KIP_IQP_IQSW, 0x9);
1118 tmp_id = ID_G_FLOK_COARSE;
1119 break;
1120 case RTW89_BAND_5G:
1121 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x6);
1122 rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
1123 B_KIP_IQP_IQSW, 0x9);
1124 tmp_id = ID_A_FLOK_COARSE;
1125 break;
1126 case RTW89_BAND_6G:
1127 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x6);
1128 rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
1129 B_KIP_IQP_IQSW, 0x9);
1130 tmp_id = ID_A_FLOK_COARSE;
1131 break;
1132 default:
1133 break;
1134 }
1135 tmp = _iqk_one_shot(rtwdev, phy_idx, path, tmp_id);
1136 iqk_info->lok_cor_fail[0][path] = tmp;
1137
1138 /* Step 2 */
1139 switch (iqk_info->iqk_band[path]) {
1140 case RTW89_BAND_2G:
1141 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x12);
1142 rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
1143 B_KIP_IQP_IQSW, 0x1b);
1144 break;
1145 case RTW89_BAND_5G:
1146 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x12);
1147 rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
1148 B_KIP_IQP_IQSW, 0x1b);
1149 break;
1150 case RTW89_BAND_6G:
1151 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x12);
1152 rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
1153 B_KIP_IQP_IQSW, 0x1b);
1154 break;
1155 default:
1156 break;
1157 }
1158 tmp = _iqk_one_shot(rtwdev, phy_idx, path, ID_FLOK_VBUFFER);
1159
1160 /* Step 3 */
1161 switch (iqk_info->iqk_band[path]) {
1162 case RTW89_BAND_2G:
1163 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x6);
1164 rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
1165 B_KIP_IQP_IQSW, 0x9);
1166 tmp_id = ID_G_FLOK_FINE;
1167 break;
1168 case RTW89_BAND_5G:
1169 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x6);
1170 rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
1171 B_KIP_IQP_IQSW, 0x9);
1172 tmp_id = ID_A_FLOK_FINE;
1173 break;
1174 case RTW89_BAND_6G:
1175 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x6);
1176 rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
1177 B_KIP_IQP_IQSW, 0x9);
1178 tmp_id = ID_A_FLOK_FINE;
1179 break;
1180 default:
1181 break;
1182 }
1183 tmp = _iqk_one_shot(rtwdev, phy_idx, path, tmp_id);
1184 iqk_info->lok_fin_fail[0][path] = tmp;
1185
1186 /* Step 4 large rf gain */
1187 switch (iqk_info->iqk_band[path]) {
1188 case RTW89_BAND_2G:
1189 default:
1190 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x12);
1191 rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
1192 B_KIP_IQP_IQSW, 0x1b);
1193 break;
1194 case RTW89_BAND_5G:
1195 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x12);
1196 rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
1197 B_KIP_IQP_IQSW, 0x1b);
1198 break;
1199 case RTW89_BAND_6G:
1200 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0x12);
1201 rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8),
1202 B_KIP_IQP_IQSW, 0x1b);
1203 break;
1204 }
1205 tmp = _iqk_one_shot(rtwdev, phy_idx, path, ID_FLOK_VBUFFER);
1206 fail = _lok_finetune_check(rtwdev, path);
1207
1208 return fail;
1209 }
1210
_iqk_txk_setting(struct rtw89_dev * rtwdev,u8 path)1211 static void _iqk_txk_setting(struct rtw89_dev *rtwdev, u8 path)
1212 {
1213 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
1214
1215 switch (iqk_info->iqk_band[path]) {
1216 case RTW89_BAND_2G:
1217 default:
1218 rtw89_write_rf(rtwdev, path, RR_TXG1, RR_TXG1_ATT2, 0x0);
1219 rtw89_write_rf(rtwdev, path, RR_TXG1, RR_TXG1_ATT1, 0x0);
1220 rtw89_write_rf(rtwdev, path, RR_TXG2, RR_TXG2_ATT0, 0x1);
1221 rtw89_write_rf(rtwdev, path, RR_TXA2, RR_TXA2_LDO, 0xf);
1222 rtw89_write_rf(rtwdev, path, RR_TXGA, RR_TXGA_LOK_EXT, 0x0);
1223 rtw89_write_rf(rtwdev, path, RR_LUTWE, RR_LUTWE_LOK, 0x1);
1224 rtw89_write_rf(rtwdev, path, RR_MOD, RFREG_MASK,
1225 0x403e0 | iqk_info->syn1to2);
1226 fsleep(10);
1227 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR0, 0x0);
1228 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR1, 0x6);
1229 break;
1230 case RTW89_BAND_5G:
1231 rtw89_write_rf(rtwdev, path, RR_TXATANK, RR_TXATANK_LBSW2, 0x0);
1232 rtw89_write_rf(rtwdev, path, RR_TXPOW, RR_TXPOW_TXAS, 0x1);
1233 rtw89_write_rf(rtwdev, path, RR_TXA2, RR_TXA2_LDO, 0xf);
1234 rtw89_write_rf(rtwdev, path, RR_TXGA, RR_TXGA_LOK_EXT, 0x0);
1235 rtw89_write_rf(rtwdev, path, RR_LUTWE, RR_LUTWE_LOK, 0x1);
1236 rtw89_write_rf(rtwdev, path, RR_MOD, RFREG_MASK,
1237 0x403e0 | iqk_info->syn1to2);
1238 fsleep(10);
1239 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR0, 0x0);
1240 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR1, 0x6);
1241 break;
1242 case RTW89_BAND_6G:
1243 rtw89_write_rf(rtwdev, path, RR_TXATANK, RR_TXATANK_LBSW2, 0x0);
1244 rtw89_write_rf(rtwdev, path, RR_TXPOW, RR_TXPOW_TXAS, 0x1);
1245 rtw89_write_rf(rtwdev, path, RR_TXA2, RR_TXA2_LDO, 0xf);
1246 rtw89_write_rf(rtwdev, path, RR_TXGA, RR_TXGA_LOK_EXT, 0x0);
1247 rtw89_write_rf(rtwdev, path, RR_LUTWE, RR_LUTWE_LOK, 0x1);
1248 rtw89_write_rf(rtwdev, path, RR_MOD, RFREG_MASK,
1249 0x403e0 | iqk_info->syn1to2);
1250 fsleep(10);
1251 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR0, 0x0);
1252 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR1, 0x6);
1253 break;
1254 }
1255 }
1256
_iqk_info_iqk(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy_idx,u8 path)1257 static void _iqk_info_iqk(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy_idx,
1258 u8 path)
1259 {
1260 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
1261 u32 tmp;
1262 bool flag;
1263
1264 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]S%d_thermal = %lu\n", path,
1265 ewma_thermal_read(&rtwdev->phystat.avg_thermal[path]));
1266 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]S%d_LOK_COR_fail= %d\n", path,
1267 iqk_info->lok_cor_fail[0][path]);
1268 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]S%d_LOK_FIN_fail= %d\n", path,
1269 iqk_info->lok_fin_fail[0][path]);
1270 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]S%d_TXIQK_fail = %d\n", path,
1271 iqk_info->iqk_tx_fail[0][path]);
1272 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]S%d_RXIQK_fail= %d,\n", path,
1273 iqk_info->iqk_rx_fail[0][path]);
1274
1275 flag = iqk_info->lok_cor_fail[0][path];
1276 rtw89_phy_write32_mask(rtwdev, R_IQKINF, B_IQKINF_FCOR << (path * 4), flag);
1277 flag = iqk_info->lok_fin_fail[0][path];
1278 rtw89_phy_write32_mask(rtwdev, R_IQKINF, B_IQKINF_FFIN << (path * 4), flag);
1279 flag = iqk_info->iqk_tx_fail[0][path];
1280 rtw89_phy_write32_mask(rtwdev, R_IQKINF, B_IQKINF_FTX << (path * 4), flag);
1281 flag = iqk_info->iqk_rx_fail[0][path];
1282 rtw89_phy_write32_mask(rtwdev, R_IQKINF, B_IQKINF_F_RX << (path * 4), flag);
1283
1284 tmp = rtw89_phy_read32_mask(rtwdev, R_IQK_RES + (path << 8), MASKDWORD);
1285 iqk_info->bp_iqkenable[path] = tmp;
1286 tmp = rtw89_phy_read32_mask(rtwdev, R_TXIQC + (path << 8), MASKDWORD);
1287 iqk_info->bp_txkresult[path] = tmp;
1288 tmp = rtw89_phy_read32_mask(rtwdev, R_RXIQC + (path << 8), MASKDWORD);
1289 iqk_info->bp_rxkresult[path] = tmp;
1290
1291 rtw89_phy_write32_mask(rtwdev, R_IQKINF2, B_IQKINF2_KCNT,
1292 iqk_info->iqk_times);
1293
1294 tmp = rtw89_phy_read32_mask(rtwdev, R_IQKINF, B_IQKINF_FAIL << (path * 4));
1295 if (tmp != 0x0)
1296 iqk_info->iqk_fail_cnt++;
1297 rtw89_phy_write32_mask(rtwdev, R_IQKINF2, B_IQKINF2_FCNT << (path * 4),
1298 iqk_info->iqk_fail_cnt);
1299 }
1300
_iqk_by_path(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy_idx,u8 path)1301 static void _iqk_by_path(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy_idx, u8 path)
1302 {
1303 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
1304
1305 _iqk_txk_setting(rtwdev, path);
1306 iqk_info->lok_fail[path] = _iqk_lok(rtwdev, phy_idx, path);
1307
1308 if (iqk_info->is_nbiqk)
1309 iqk_info->iqk_tx_fail[0][path] = _iqk_nbtxk(rtwdev, phy_idx, path);
1310 else
1311 iqk_info->iqk_tx_fail[0][path] = _txk_group_sel(rtwdev, phy_idx, path);
1312
1313 _iqk_rxk_setting(rtwdev, path);
1314 if (iqk_info->is_nbiqk)
1315 iqk_info->iqk_rx_fail[0][path] = _iqk_nbrxk(rtwdev, phy_idx, path);
1316 else
1317 iqk_info->iqk_rx_fail[0][path] = _rxk_group_sel(rtwdev, phy_idx, path);
1318
1319 _iqk_info_iqk(rtwdev, phy_idx, path);
1320 }
1321
_iqk_get_ch_info(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,u8 path)1322 static void _iqk_get_ch_info(struct rtw89_dev *rtwdev,
1323 enum rtw89_phy_idx phy, u8 path)
1324 {
1325 const struct rtw89_chan *chan = rtw89_chan_get(rtwdev, RTW89_SUB_ENTITY_0);
1326 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
1327
1328 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]===>%s\n", __func__);
1329
1330 iqk_info->iqk_band[path] = chan->band_type;
1331 iqk_info->iqk_bw[path] = chan->band_width;
1332 iqk_info->iqk_ch[path] = chan->channel;
1333
1334 rtw89_debug(rtwdev, RTW89_DBG_RFK,
1335 "[IQK]iqk_info->iqk_band[%x] = 0x%x\n", path,
1336 iqk_info->iqk_band[path]);
1337 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]iqk_info->iqk_bw[%x] = 0x%x\n",
1338 path, iqk_info->iqk_bw[path]);
1339 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]iqk_info->iqk_ch[%x] = 0x%x\n",
1340 path, iqk_info->iqk_ch[path]);
1341 rtw89_debug(rtwdev, RTW89_DBG_RFK,
1342 "[IQK]S%d (PHY%d): / DBCC %s/ %s/ CH%d/ %s\n", path, phy,
1343 rtwdev->dbcc_en ? "on" : "off",
1344 iqk_info->iqk_band[path] == 0 ? "2G" :
1345 iqk_info->iqk_band[path] == 1 ? "5G" : "6G",
1346 iqk_info->iqk_ch[path],
1347 iqk_info->iqk_bw[path] == 0 ? "20M" :
1348 iqk_info->iqk_bw[path] == 1 ? "40M" : "80M");
1349 if (!rtwdev->dbcc_en)
1350 iqk_info->syn1to2 = 0x1;
1351 else
1352 iqk_info->syn1to2 = 0x3;
1353
1354 rtw89_phy_write32_mask(rtwdev, R_IQKINF, B_IQKINF_VER, RTW8852C_IQK_VER);
1355 rtw89_phy_write32_mask(rtwdev, R_IQKCH, B_IQKCH_BAND << (path * 16),
1356 iqk_info->iqk_band[path]);
1357 rtw89_phy_write32_mask(rtwdev, R_IQKCH, B_IQKCH_BW << (path * 16),
1358 iqk_info->iqk_bw[path]);
1359 rtw89_phy_write32_mask(rtwdev, R_IQKCH, B_IQKCH_CH << (path * 16),
1360 iqk_info->iqk_ch[path]);
1361
1362 rtw89_phy_write32_mask(rtwdev, R_IQKINF2, B_IQKINF2_NCTLV, RTW8852C_NCTL_VER);
1363 }
1364
_iqk_start_iqk(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy_idx,u8 path)1365 static void _iqk_start_iqk(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy_idx,
1366 u8 path)
1367 {
1368 _iqk_by_path(rtwdev, phy_idx, path);
1369 }
1370
_iqk_restore(struct rtw89_dev * rtwdev,u8 path)1371 static void _iqk_restore(struct rtw89_dev *rtwdev, u8 path)
1372 {
1373 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
1374 bool fail;
1375
1376 rtw89_phy_write32_mask(rtwdev, R_TXIQC + (path << 8), MASKDWORD,
1377 iqk_info->nb_txcfir[path]);
1378 rtw89_phy_write32_mask(rtwdev, R_RXIQC + (path << 8), MASKDWORD,
1379 iqk_info->nb_rxcfir[path]);
1380 rtw89_phy_write32_mask(rtwdev, R_NCTL_CFG, MASKDWORD,
1381 0x00001219 + (path << 4));
1382 fsleep(200);
1383 fail = _iqk_check_cal(rtwdev, path, 0x12);
1384 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK] restore fail = %x\n", fail);
1385
1386 rtw89_phy_write32_mask(rtwdev, R_NCTL_N1, B_NCTL_N1_CIP, 0x00);
1387 rtw89_phy_write32_mask(rtwdev, R_NCTL_RPT, MASKDWORD, 0x00000000);
1388 rtw89_phy_write32_mask(rtwdev, R_KIP_SYSCFG, MASKDWORD, 0x80000000);
1389
1390 rtw89_write_rf(rtwdev, path, RR_LUTWE, RR_LUTWE_LOK, 0x0);
1391 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_MASK, RR_MOD_V_RX);
1392 rtw89_write_rf(rtwdev, path, RR_RSV1, RR_RSV1_RST, 0x1);
1393 }
1394
_iqk_afebb_restore(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy_idx,u8 path)1395 static void _iqk_afebb_restore(struct rtw89_dev *rtwdev,
1396 enum rtw89_phy_idx phy_idx, u8 path)
1397 {
1398 rtw89_rfk_parser_by_cond(rtwdev, path == RF_PATH_A,
1399 &rtw8852c_iqk_afebb_restore_defs_a_tbl,
1400 &rtw8852c_iqk_afebb_restore_defs_b_tbl);
1401
1402 rtw8852c_disable_rxagc(rtwdev, path, 0x1);
1403 }
1404
_iqk_preset(struct rtw89_dev * rtwdev,u8 path)1405 static void _iqk_preset(struct rtw89_dev *rtwdev, u8 path)
1406 {
1407 struct rtw89_rfk_mcc_info *rfk_mcc = &rtwdev->rfk_mcc;
1408 u8 idx = 0;
1409
1410 idx = rfk_mcc->table_idx;
1411 rtw89_phy_write32_mask(rtwdev, R_COEF_SEL + (path << 8), B_COEF_SEL_IQC, idx);
1412 rtw89_phy_write32_mask(rtwdev, R_CFIR_LUT + (path << 8), B_CFIR_LUT_G3, idx);
1413 rtw89_write_rf(rtwdev, path, RR_RSV1, RR_RSV1_RST, 0x0);
1414 rtw89_phy_write32_mask(rtwdev, R_NCTL_RPT, MASKDWORD, 0x00000080);
1415 rtw89_phy_write32_mask(rtwdev, R_KIP_SYSCFG, MASKDWORD, 0x81ff010a);
1416 }
1417
_iqk_macbb_setting(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy_idx,u8 path)1418 static void _iqk_macbb_setting(struct rtw89_dev *rtwdev,
1419 enum rtw89_phy_idx phy_idx, u8 path)
1420 {
1421 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]===> %s\n", __func__);
1422
1423 /* 01_BB_AFE_for DPK_S0_20210820 */
1424 rtw89_write_rf(rtwdev, path, RR_BBDC, RR_BBDC_SEL, 0x0);
1425 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A0 << path, 0x1);
1426 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A1 << path, 0x0);
1427 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A2 << path, 0x1);
1428 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A3 << path, 0x0);
1429
1430 /* disable rxgac */
1431 rtw8852c_disable_rxagc(rtwdev, path, 0x0);
1432 rtw89_phy_write32_mask(rtwdev, R_UPD_CLK | (path << 13), MASKDWORD, 0xf801fffd);
1433 rtw89_phy_write32_mask(rtwdev, R_UPD_CLK | (path << 13), B_DPD_DIS, 0x1);
1434 rtw89_phy_write32_mask(rtwdev, R_UPD_CLK | (path << 13), B_DAC_VAL, 0x1);
1435
1436 rtw8852c_txck_force(rtwdev, path, true, DAC_960M);
1437 rtw89_phy_write32_mask(rtwdev, R_UPD_CLK | (path << 13), B_DPD_GDIS, 0x1);
1438
1439 rtw8852c_rxck_force(rtwdev, path, true, ADC_1920M);
1440 rtw89_phy_write32_mask(rtwdev, R_UPD_CLK | (path << 13), B_ACK_VAL, 0x2);
1441
1442 rtw89_phy_write32_mask(rtwdev, R_P0_NRBW | (path << 13), B_P0_NRBW_DBG, 0x1);
1443 rtw89_phy_write32_mask(rtwdev, R_ANAPAR_PW15, B_ANAPAR_PW15, 0x1f);
1444 rtw89_phy_write32_mask(rtwdev, R_ANAPAR_PW15, B_ANAPAR_PW15, 0x13);
1445 rtw89_phy_write32_mask(rtwdev, R_ANAPAR, B_ANAPAR_15, 0x0001);
1446 rtw89_phy_write32_mask(rtwdev, R_ANAPAR, B_ANAPAR_15, 0x0041);
1447 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A1 << path, 0x1);
1448 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A3 << path, 0x1);
1449 }
1450
_rck(struct rtw89_dev * rtwdev,enum rtw89_rf_path path)1451 static void _rck(struct rtw89_dev *rtwdev, enum rtw89_rf_path path)
1452 {
1453 u32 rf_reg5, rck_val = 0;
1454 u32 val;
1455 int ret;
1456
1457 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[RCK] ====== S%d RCK ======\n", path);
1458
1459 rf_reg5 = rtw89_read_rf(rtwdev, path, RR_RSV1, RFREG_MASK);
1460
1461 rtw89_write_rf(rtwdev, path, RR_RSV1, RR_RSV1_RST, 0x0);
1462 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_MASK, RR_MOD_V_RX);
1463
1464 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[RCK] RF0x00 = 0x%x\n",
1465 rtw89_read_rf(rtwdev, path, RR_MOD, RFREG_MASK));
1466
1467 /* RCK trigger */
1468 rtw89_write_rf(rtwdev, path, RR_RCKC, RFREG_MASK, 0x00240);
1469
1470 ret = read_poll_timeout_atomic(rtw89_read_rf, val, val, 2, 20,
1471 false, rtwdev, path, 0x1c, BIT(3));
1472 if (ret)
1473 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[RCK] RCK timeout\n");
1474
1475 rck_val = rtw89_read_rf(rtwdev, path, RR_RCKC, RR_RCKC_CA);
1476 rtw89_write_rf(rtwdev, path, RR_RCKC, RFREG_MASK, rck_val);
1477
1478 rtw89_write_rf(rtwdev, path, RR_RSV1, RFREG_MASK, rf_reg5);
1479
1480 rtw89_debug(rtwdev, RTW89_DBG_RFK,
1481 "[RCK] RF 0x1b / 0x1c = 0x%x / 0x%x\n",
1482 rtw89_read_rf(rtwdev, path, RR_RCKC, RFREG_MASK),
1483 rtw89_read_rf(rtwdev, path, RR_RCKS, RFREG_MASK));
1484 }
1485
_iqk_init(struct rtw89_dev * rtwdev)1486 static void _iqk_init(struct rtw89_dev *rtwdev)
1487 {
1488 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
1489 u8 ch, path;
1490
1491 rtw89_phy_write32_clr(rtwdev, R_IQKINF, MASKDWORD);
1492 if (iqk_info->is_iqk_init)
1493 return;
1494
1495 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]===>%s\n", __func__);
1496 iqk_info->is_iqk_init = true;
1497 iqk_info->is_nbiqk = false;
1498 iqk_info->iqk_fft_en = false;
1499 iqk_info->iqk_sram_en = false;
1500 iqk_info->iqk_cfir_en = false;
1501 iqk_info->iqk_xym_en = false;
1502 iqk_info->iqk_times = 0x0;
1503
1504 for (ch = 0; ch < RTW89_IQK_CHS_NR; ch++) {
1505 iqk_info->iqk_channel[ch] = 0x0;
1506 for (path = 0; path < RTW8852C_IQK_SS; path++) {
1507 iqk_info->lok_cor_fail[ch][path] = false;
1508 iqk_info->lok_fin_fail[ch][path] = false;
1509 iqk_info->iqk_tx_fail[ch][path] = false;
1510 iqk_info->iqk_rx_fail[ch][path] = false;
1511 iqk_info->iqk_mcc_ch[ch][path] = 0x0;
1512 iqk_info->iqk_table_idx[path] = 0x0;
1513 }
1514 }
1515 }
1516
_doiqk(struct rtw89_dev * rtwdev,bool force,enum rtw89_phy_idx phy_idx,u8 path)1517 static void _doiqk(struct rtw89_dev *rtwdev, bool force,
1518 enum rtw89_phy_idx phy_idx, u8 path)
1519 {
1520 struct rtw89_iqk_info *iqk_info = &rtwdev->iqk;
1521 u32 backup_bb_val[BACKUP_BB_REGS_NR];
1522 u32 backup_rf_val[RTW8852C_IQK_SS][BACKUP_RF_REGS_NR];
1523 u8 phy_map = rtw89_btc_phymap(rtwdev, phy_idx, RF_AB);
1524
1525 rtw89_btc_ntfy_wl_rfk(rtwdev, phy_map, BTC_WRFKT_IQK, BTC_WRFK_ONESHOT_START);
1526
1527 rtw89_debug(rtwdev, RTW89_DBG_RFK,
1528 "[IQK]==========IQK start!!!!!==========\n");
1529 iqk_info->iqk_times++;
1530 iqk_info->version = RTW8852C_IQK_VER;
1531
1532 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[IQK]Test Ver 0x%x\n", iqk_info->version);
1533 _iqk_get_ch_info(rtwdev, phy_idx, path);
1534 _rfk_backup_bb_reg(rtwdev, backup_bb_val);
1535 _rfk_backup_rf_reg(rtwdev, backup_rf_val[path], path);
1536 _iqk_macbb_setting(rtwdev, phy_idx, path);
1537 _iqk_preset(rtwdev, path);
1538 _iqk_start_iqk(rtwdev, phy_idx, path);
1539 _iqk_restore(rtwdev, path);
1540 _iqk_afebb_restore(rtwdev, phy_idx, path);
1541 _rfk_restore_bb_reg(rtwdev, backup_bb_val);
1542 _rfk_restore_rf_reg(rtwdev, backup_rf_val[path], path);
1543 rtw89_btc_ntfy_wl_rfk(rtwdev, phy_map, BTC_WRFKT_IQK, BTC_WRFK_ONESHOT_STOP);
1544 }
1545
_iqk(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy_idx,bool force)1546 static void _iqk(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy_idx, bool force)
1547 {
1548 switch (_kpath(rtwdev, phy_idx)) {
1549 case RF_A:
1550 _doiqk(rtwdev, force, phy_idx, RF_PATH_A);
1551 break;
1552 case RF_B:
1553 _doiqk(rtwdev, force, phy_idx, RF_PATH_B);
1554 break;
1555 case RF_AB:
1556 _doiqk(rtwdev, force, phy_idx, RF_PATH_A);
1557 _doiqk(rtwdev, force, phy_idx, RF_PATH_B);
1558 break;
1559 default:
1560 break;
1561 }
1562 }
1563
_rx_dck_value_rewrite(struct rtw89_dev * rtwdev,u8 path,u8 addr,u8 val_i,u8 val_q)1564 static void _rx_dck_value_rewrite(struct rtw89_dev *rtwdev, u8 path, u8 addr,
1565 u8 val_i, u8 val_q)
1566 {
1567 u32 ofst_val;
1568
1569 rtw89_debug(rtwdev, RTW89_DBG_RFK,
1570 "[RX_DCK] rewrite val_i = 0x%x, val_q = 0x%x\n", val_i, val_q);
1571
1572 /* val_i and val_q are 7 bits, and target is 6 bits. */
1573 ofst_val = u32_encode_bits(val_q >> 1, RR_LUTWD0_MB) |
1574 u32_encode_bits(val_i >> 1, RR_LUTWD0_LB);
1575
1576 rtw89_write_rf(rtwdev, path, RR_LUTPLL, RR_CAL_RW, 0x1);
1577 rtw89_write_rf(rtwdev, path, RR_RFC, RR_WCAL, 0x1);
1578 rtw89_write_rf(rtwdev, path, RR_DCK, RR_DCK_FINE, 0x1);
1579 rtw89_write_rf(rtwdev, path, RR_LUTWA, MASKBYTE0, addr);
1580 rtw89_write_rf(rtwdev, path, RR_LUTWD0, RFREG_MASK, ofst_val);
1581 rtw89_write_rf(rtwdev, path, RR_LUTWD0, RFREG_MASK, ofst_val);
1582 rtw89_write_rf(rtwdev, path, RR_DCK, RR_DCK_FINE, 0x0);
1583 rtw89_write_rf(rtwdev, path, RR_RFC, RR_WCAL, 0x0);
1584 rtw89_write_rf(rtwdev, path, RR_LUTPLL, RR_CAL_RW, 0x0);
1585
1586 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[RX_DCK] Final val_i = 0x%x, val_q = 0x%x\n",
1587 u32_get_bits(ofst_val, RR_LUTWD0_LB) << 1,
1588 u32_get_bits(ofst_val, RR_LUTWD0_MB) << 1);
1589 }
1590
_rx_dck_rek_check(struct rtw89_dev * rtwdev,u8 path)1591 static bool _rx_dck_rek_check(struct rtw89_dev *rtwdev, u8 path)
1592 {
1593 u8 i_even_bs, q_even_bs;
1594 u8 i_odd_bs, q_odd_bs;
1595 u8 i_even, q_even;
1596 u8 i_odd, q_odd;
1597 const u8 th = 10;
1598 u8 i;
1599
1600 for (i = 0; i < RF_PATH_NUM_8852C; i++) {
1601 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_DCK, _dck_addr_bs[i]);
1602 i_even_bs = rtw89_read_rf(rtwdev, path, RR_DCK, RR_DCK_TIA);
1603 q_even_bs = rtw89_read_rf(rtwdev, path, RR_DCK1, RR_DCK1_TIA);
1604 rtw89_debug(rtwdev, RTW89_DBG_RFK,
1605 "[RX_DCK] Gain[0x%x] i_even_bs/ q_even_bs = 0x%x/ 0x%x\n",
1606 _dck_addr_bs[i], i_even_bs, q_even_bs);
1607
1608 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_DCK, _dck_addr[i]);
1609 i_even = rtw89_read_rf(rtwdev, path, RR_DCK, RR_DCK_TIA);
1610 q_even = rtw89_read_rf(rtwdev, path, RR_DCK1, RR_DCK1_TIA);
1611 rtw89_debug(rtwdev, RTW89_DBG_RFK,
1612 "[RX_DCK] Gain[0x%x] i_even/ q_even = 0x%x/ 0x%x\n",
1613 _dck_addr[i], i_even, q_even);
1614
1615 if (abs(i_even_bs - i_even) > th || abs(q_even_bs - q_even) > th)
1616 return true;
1617
1618 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_DCK, _dck_addr_bs[i] + 1);
1619 i_odd_bs = rtw89_read_rf(rtwdev, path, RR_DCK, RR_DCK_TIA);
1620 q_odd_bs = rtw89_read_rf(rtwdev, path, RR_DCK1, RR_DCK1_TIA);
1621 rtw89_debug(rtwdev, RTW89_DBG_RFK,
1622 "[RX_DCK] Gain[0x%x] i_odd_bs/ q_odd_bs = 0x%x/ 0x%x\n",
1623 _dck_addr_bs[i] + 1, i_odd_bs, q_odd_bs);
1624
1625 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_DCK, _dck_addr[i] + 1);
1626 i_odd = rtw89_read_rf(rtwdev, path, RR_DCK, RR_DCK_TIA);
1627 q_odd = rtw89_read_rf(rtwdev, path, RR_DCK1, RR_DCK1_TIA);
1628 rtw89_debug(rtwdev, RTW89_DBG_RFK,
1629 "[RX_DCK] Gain[0x%x] i_odd/ q_odd = 0x%x/ 0x%x\n",
1630 _dck_addr[i] + 1, i_odd, q_odd);
1631
1632 if (abs(i_odd_bs - i_odd) > th || abs(q_odd_bs - q_odd) > th)
1633 return true;
1634 }
1635
1636 return false;
1637 }
1638
_rx_dck_fix_if_need(struct rtw89_dev * rtwdev,u8 path,u8 addr,u8 val_i_bs,u8 val_q_bs,u8 val_i,u8 val_q)1639 static void _rx_dck_fix_if_need(struct rtw89_dev *rtwdev, u8 path, u8 addr,
1640 u8 val_i_bs, u8 val_q_bs, u8 val_i, u8 val_q)
1641 {
1642 const u8 th = 10;
1643
1644 if ((abs(val_i_bs - val_i) < th) && (abs(val_q_bs - val_q) <= th)) {
1645 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[RX_DCK] offset check PASS!!\n");
1646 return;
1647 }
1648
1649 if (abs(val_i_bs - val_i) > th) {
1650 rtw89_debug(rtwdev, RTW89_DBG_RFK,
1651 "[RX_DCK] val_i over TH (0x%x / 0x%x)\n", val_i_bs, val_i);
1652 val_i = val_i_bs;
1653 }
1654
1655 if (abs(val_q_bs - val_q) > th) {
1656 rtw89_debug(rtwdev, RTW89_DBG_RFK,
1657 "[RX_DCK] val_q over TH (0x%x / 0x%x)\n", val_q_bs, val_q);
1658 val_q = val_q_bs;
1659 }
1660
1661 _rx_dck_value_rewrite(rtwdev, path, addr, val_i, val_q);
1662 }
1663
_rx_dck_recover(struct rtw89_dev * rtwdev,u8 path)1664 static void _rx_dck_recover(struct rtw89_dev *rtwdev, u8 path)
1665 {
1666 u8 i_even_bs, q_even_bs;
1667 u8 i_odd_bs, q_odd_bs;
1668 u8 i_even, q_even;
1669 u8 i_odd, q_odd;
1670 u8 i;
1671
1672 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[RX_DCK] ===> recovery\n");
1673
1674 for (i = 0; i < RF_PATH_NUM_8852C; i++) {
1675 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_DCK, _dck_addr_bs[i]);
1676 i_even_bs = rtw89_read_rf(rtwdev, path, RR_DCK, RR_DCK_TIA);
1677 q_even_bs = rtw89_read_rf(rtwdev, path, RR_DCK1, RR_DCK1_TIA);
1678
1679 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_DCK, _dck_addr_bs[i] + 1);
1680 i_odd_bs = rtw89_read_rf(rtwdev, path, RR_DCK, RR_DCK_TIA);
1681 q_odd_bs = rtw89_read_rf(rtwdev, path, RR_DCK1, RR_DCK1_TIA);
1682
1683 rtw89_debug(rtwdev, RTW89_DBG_RFK,
1684 "[RX_DCK] Gain[0x%x] i_even_bs/ q_even_bs = 0x%x/ 0x%x\n",
1685 _dck_addr_bs[i], i_even_bs, q_even_bs);
1686
1687 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_DCK, _dck_addr[i]);
1688 i_even = rtw89_read_rf(rtwdev, path, RR_DCK, RR_DCK_TIA);
1689 q_even = rtw89_read_rf(rtwdev, path, RR_DCK1, RR_DCK1_TIA);
1690
1691 rtw89_debug(rtwdev, RTW89_DBG_RFK,
1692 "[RX_DCK] Gain[0x%x] i_even/ q_even = 0x%x/ 0x%x\n",
1693 _dck_addr[i], i_even, q_even);
1694 _rx_dck_fix_if_need(rtwdev, path, _dck_addr[i],
1695 i_even_bs, q_even_bs, i_even, q_even);
1696
1697 rtw89_debug(rtwdev, RTW89_DBG_RFK,
1698 "[RX_DCK] Gain[0x%x] i_odd_bs/ q_odd_bs = 0x%x/ 0x%x\n",
1699 _dck_addr_bs[i] + 1, i_odd_bs, q_odd_bs);
1700
1701 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_DCK, _dck_addr[i] + 1);
1702 i_odd = rtw89_read_rf(rtwdev, path, RR_DCK, RR_DCK_TIA);
1703 q_odd = rtw89_read_rf(rtwdev, path, RR_DCK1, RR_DCK1_TIA);
1704
1705 rtw89_debug(rtwdev, RTW89_DBG_RFK,
1706 "[RX_DCK] Gain[0x%x] i_odd/ q_odd = 0x%x/ 0x%x\n",
1707 _dck_addr[i] + 1, i_odd, q_odd);
1708 _rx_dck_fix_if_need(rtwdev, path, _dck_addr[i] + 1,
1709 i_odd_bs, q_odd_bs, i_odd, q_odd);
1710 }
1711 }
1712
_rx_dck_toggle(struct rtw89_dev * rtwdev,u8 path)1713 static void _rx_dck_toggle(struct rtw89_dev *rtwdev, u8 path)
1714 {
1715 int ret;
1716 u32 val;
1717
1718 rtw89_write_rf(rtwdev, path, RR_DCK, RR_DCK_LV, 0x0);
1719 rtw89_write_rf(rtwdev, path, RR_DCK, RR_DCK_LV, 0x1);
1720
1721 ret = read_poll_timeout_atomic(rtw89_read_rf, val, val,
1722 2, 2000, false, rtwdev, path,
1723 RR_DCK1, RR_DCK1_DONE);
1724 if (ret)
1725 rtw89_warn(rtwdev, "[RX_DCK] S%d RXDCK timeout\n", path);
1726 else
1727 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[RX_DCK] S%d RXDCK finish\n", path);
1728
1729 rtw89_write_rf(rtwdev, path, RR_DCK, RR_DCK_LV, 0x0);
1730 }
1731
_set_rx_dck(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,u8 path,bool is_afe)1732 static void _set_rx_dck(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy, u8 path,
1733 bool is_afe)
1734 {
1735 u8 res;
1736
1737 rtw89_write_rf(rtwdev, path, RR_DCK1, RR_DCK1_CLR, 0x0);
1738
1739 _rx_dck_toggle(rtwdev, path);
1740 if (rtw89_read_rf(rtwdev, path, RR_DCKC, RR_DCKC_CHK) == 0)
1741 return;
1742 res = rtw89_read_rf(rtwdev, path, RR_DCK, RR_DCK_DONE);
1743 if (res > 1) {
1744 rtw89_write_rf(rtwdev, path, RR_RXBB2, RR_RXBB2_IDAC, res);
1745 _rx_dck_toggle(rtwdev, path);
1746 rtw89_write_rf(rtwdev, path, RR_RXBB2, RR_RXBB2_IDAC, 0x1);
1747 }
1748 }
1749
1750 static
_rx_dck_channel_calc(struct rtw89_dev * rtwdev,const struct rtw89_chan * chan)1751 u8 _rx_dck_channel_calc(struct rtw89_dev *rtwdev, const struct rtw89_chan *chan)
1752 {
1753 u8 target_ch = 0;
1754
1755 if (chan->band_type == RTW89_BAND_5G) {
1756 if (chan->channel >= 36 && chan->channel <= 64) {
1757 target_ch = 100;
1758 } else if (chan->channel >= 100 && chan->channel <= 144) {
1759 target_ch = chan->channel + 32;
1760 if (target_ch > 144)
1761 target_ch = chan->channel + 33;
1762 } else if (chan->channel >= 149 && chan->channel <= 177) {
1763 target_ch = chan->channel - 33;
1764 }
1765 } else if (chan->band_type == RTW89_BAND_6G) {
1766 if (chan->channel >= 1 && chan->channel <= 125)
1767 target_ch = chan->channel + 32;
1768 else
1769 target_ch = chan->channel - 32;
1770 } else {
1771 target_ch = chan->channel;
1772 }
1773
1774 rtw89_debug(rtwdev, RTW89_DBG_RFK,
1775 "[RX_DCK] cur_ch / target_ch = %d / %d\n",
1776 chan->channel, target_ch);
1777
1778 return target_ch;
1779 }
1780
1781 #define RTW8852C_RF_REL_VERSION 34
1782 #define RTW8852C_DPK_VER 0xf
1783 #define RTW8852C_DPK_TH_AVG_NUM 4
1784 #define RTW8852C_DPK_RF_PATH 2
1785 #define RTW8852C_DPK_KIP_REG_NUM 7
1786 #define RTW8852C_DPK_RXSRAM_DBG 0
1787
1788 enum rtw8852c_dpk_id {
1789 LBK_RXIQK = 0x06,
1790 SYNC = 0x10,
1791 MDPK_IDL = 0x11,
1792 MDPK_MPA = 0x12,
1793 GAIN_LOSS = 0x13,
1794 GAIN_CAL = 0x14,
1795 DPK_RXAGC = 0x15,
1796 KIP_PRESET = 0x16,
1797 KIP_RESTORE = 0x17,
1798 DPK_TXAGC = 0x19,
1799 D_KIP_PRESET = 0x28,
1800 D_TXAGC = 0x29,
1801 D_RXAGC = 0x2a,
1802 D_SYNC = 0x2b,
1803 D_GAIN_LOSS = 0x2c,
1804 D_MDPK_IDL = 0x2d,
1805 D_GAIN_NORM = 0x2f,
1806 D_KIP_THERMAL = 0x30,
1807 D_KIP_RESTORE = 0x31
1808 };
1809
1810 #define DPK_TXAGC_LOWER 0x2e
1811 #define DPK_TXAGC_UPPER 0x3f
1812 #define DPK_TXAGC_INVAL 0xff
1813
1814 enum dpk_agc_step {
1815 DPK_AGC_STEP_SYNC_DGAIN,
1816 DPK_AGC_STEP_GAIN_LOSS_IDX,
1817 DPK_AGC_STEP_GL_GT_CRITERION,
1818 DPK_AGC_STEP_GL_LT_CRITERION,
1819 DPK_AGC_STEP_SET_TX_GAIN,
1820 };
1821
1822 enum dpk_pas_result {
1823 DPK_PAS_NOR,
1824 DPK_PAS_GT,
1825 DPK_PAS_LT,
1826 };
1827
_rf_direct_cntrl(struct rtw89_dev * rtwdev,enum rtw89_rf_path path,bool is_bybb)1828 static void _rf_direct_cntrl(struct rtw89_dev *rtwdev,
1829 enum rtw89_rf_path path, bool is_bybb)
1830 {
1831 if (is_bybb)
1832 rtw89_write_rf(rtwdev, path, RR_RSV1, RR_RSV1_RST, 0x1);
1833 else
1834 rtw89_write_rf(rtwdev, path, RR_RSV1, RR_RSV1_RST, 0x0);
1835 }
1836
1837 static void _dpk_onoff(struct rtw89_dev *rtwdev,
1838 enum rtw89_rf_path path, bool off);
1839
_dpk_bkup_kip(struct rtw89_dev * rtwdev,const u32 reg[],u32 reg_bkup[][RTW8852C_DPK_KIP_REG_NUM],u8 path)1840 static void _dpk_bkup_kip(struct rtw89_dev *rtwdev, const u32 reg[],
1841 u32 reg_bkup[][RTW8852C_DPK_KIP_REG_NUM], u8 path)
1842 {
1843 u8 i;
1844
1845 for (i = 0; i < RTW8852C_DPK_KIP_REG_NUM; i++) {
1846 reg_bkup[path][i] =
1847 rtw89_phy_read32_mask(rtwdev, reg[i] + (path << 8), MASKDWORD);
1848
1849 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] Backup 0x%x = %x\n",
1850 reg[i] + (path << 8), reg_bkup[path][i]);
1851 }
1852 }
1853
_dpk_reload_kip(struct rtw89_dev * rtwdev,const u32 reg[],u32 reg_bkup[][RTW8852C_DPK_KIP_REG_NUM],u8 path)1854 static void _dpk_reload_kip(struct rtw89_dev *rtwdev, const u32 reg[],
1855 u32 reg_bkup[][RTW8852C_DPK_KIP_REG_NUM], u8 path)
1856 {
1857 u8 i;
1858
1859 for (i = 0; i < RTW8852C_DPK_KIP_REG_NUM; i++) {
1860 rtw89_phy_write32_mask(rtwdev, reg[i] + (path << 8),
1861 MASKDWORD, reg_bkup[path][i]);
1862 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] Reload 0x%x = %x\n",
1863 reg[i] + (path << 8), reg_bkup[path][i]);
1864 }
1865 }
1866
_dpk_one_shot(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path,enum rtw8852c_dpk_id id)1867 static u8 _dpk_one_shot(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
1868 enum rtw89_rf_path path, enum rtw8852c_dpk_id id)
1869 {
1870 u16 dpk_cmd;
1871 u32 val;
1872 int ret;
1873
1874 dpk_cmd = (u16)((id << 8) | (0x19 + path * 0x12));
1875
1876 rtw89_phy_write32_mask(rtwdev, R_NCTL_CFG, MASKDWORD, dpk_cmd);
1877
1878 ret = read_poll_timeout_atomic(rtw89_phy_read32_mask, val, val == 0x55,
1879 10, 20000, false, rtwdev, 0xbff8, MASKBYTE0);
1880 udelay(10);
1881 rtw89_phy_write32_clr(rtwdev, R_NCTL_N1, MASKBYTE0);
1882
1883 rtw89_debug(rtwdev, RTW89_DBG_RFK,
1884 "[DPK] one-shot for %s = 0x%x (ret=%d)\n",
1885 id == 0x06 ? "LBK_RXIQK" :
1886 id == 0x10 ? "SYNC" :
1887 id == 0x11 ? "MDPK_IDL" :
1888 id == 0x12 ? "MDPK_MPA" :
1889 id == 0x13 ? "GAIN_LOSS" : "PWR_CAL",
1890 dpk_cmd, ret);
1891
1892 if (ret) {
1893 rtw89_debug(rtwdev, RTW89_DBG_RFK,
1894 "[DPK] one-shot over 20ms!!!!\n");
1895 return 1;
1896 }
1897
1898 return 0;
1899 }
1900
_dpk_information(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path)1901 static void _dpk_information(struct rtw89_dev *rtwdev,
1902 enum rtw89_phy_idx phy,
1903 enum rtw89_rf_path path)
1904 {
1905 const struct rtw89_chan *chan = rtw89_chan_get(rtwdev, RTW89_SUB_ENTITY_0);
1906 struct rtw89_dpk_info *dpk = &rtwdev->dpk;
1907
1908 u8 kidx = dpk->cur_idx[path];
1909
1910 dpk->bp[path][kidx].band = chan->band_type;
1911 dpk->bp[path][kidx].ch = chan->channel;
1912 dpk->bp[path][kidx].bw = chan->band_width;
1913
1914 rtw89_debug(rtwdev, RTW89_DBG_RFK,
1915 "[DPK] S%d[%d] (PHY%d): TSSI %s/ DBCC %s/ %s/ CH%d/ %s\n",
1916 path, dpk->cur_idx[path], phy,
1917 rtwdev->is_tssi_mode[path] ? "on" : "off",
1918 rtwdev->dbcc_en ? "on" : "off",
1919 dpk->bp[path][kidx].band == 0 ? "2G" :
1920 dpk->bp[path][kidx].band == 1 ? "5G" : "6G",
1921 dpk->bp[path][kidx].ch,
1922 dpk->bp[path][kidx].bw == 0 ? "20M" :
1923 dpk->bp[path][kidx].bw == 1 ? "40M" : "80M");
1924 }
1925
_dpk_bb_afe_setting(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path,u8 kpath)1926 static void _dpk_bb_afe_setting(struct rtw89_dev *rtwdev,
1927 enum rtw89_phy_idx phy,
1928 enum rtw89_rf_path path, u8 kpath)
1929 {
1930 /*1. Keep ADC_fifo reset*/
1931 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A0 << path, 0x1);
1932 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A1 << path, 0x0);
1933 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A2 << path, 0x1);
1934 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A3 << path, 0x0);
1935
1936 /*2. BB for IQK DBG mode*/
1937 rtw89_phy_write32_mask(rtwdev, R_UPD_CLK + (path << 13), MASKDWORD, 0xd801dffd);
1938
1939 /*3.Set DAC clk*/
1940 rtw8852c_txck_force(rtwdev, path, true, DAC_960M);
1941
1942 /*4. Set ADC clk*/
1943 rtw8852c_rxck_force(rtwdev, path, true, ADC_1920M);
1944 rtw89_phy_write32_mask(rtwdev, R_P0_NRBW + (path << 13),
1945 B_P0_NRBW_DBG, 0x1);
1946 rtw89_phy_write32_mask(rtwdev, R_ANAPAR_PW15, MASKBYTE3, 0x1f);
1947 rtw89_phy_write32_mask(rtwdev, R_ANAPAR_PW15, MASKBYTE3, 0x13);
1948 rtw89_phy_write32_mask(rtwdev, R_ANAPAR, MASKHWORD, 0x0001);
1949 rtw89_phy_write32_mask(rtwdev, R_ANAPAR, MASKHWORD, 0x0041);
1950
1951 /*5. ADDA fifo rst*/
1952 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A1 << path, 0x1);
1953 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A3 << path, 0x1);
1954
1955 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] S%d BB/AFE setting\n", path);
1956 }
1957
_dpk_bb_afe_restore(struct rtw89_dev * rtwdev,u8 path)1958 static void _dpk_bb_afe_restore(struct rtw89_dev *rtwdev, u8 path)
1959 {
1960 rtw89_phy_write32_mask(rtwdev, R_P0_NRBW + (path << 13),
1961 B_P0_NRBW_DBG, 0x0);
1962 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A0 << path, 0x1);
1963 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A1 << path, 0x0);
1964 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A2 << path, 0x1);
1965 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A3 << path, 0x0);
1966 rtw89_phy_write32_mask(rtwdev, R_UPD_CLK + (path << 13), MASKDWORD, 0x00000000);
1967 rtw89_phy_write32_mask(rtwdev, R_P0_RXCK + (path << 13), B_P0_TXCK_ALL, 0x00);
1968 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A0 << path, 0x0);
1969 rtw89_phy_write32_mask(rtwdev, R_ADC_FIFO, B_ADC_FIFO_A2 << path, 0x0);
1970
1971 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] S%d BB/AFE restore\n", path);
1972 }
1973
_dpk_tssi_pause(struct rtw89_dev * rtwdev,enum rtw89_rf_path path,bool is_pause)1974 static void _dpk_tssi_pause(struct rtw89_dev *rtwdev,
1975 enum rtw89_rf_path path, bool is_pause)
1976 {
1977 rtw89_phy_write32_mask(rtwdev, R_P0_TSSI_TRK + (path << 13),
1978 B_P0_TSSI_TRK_EN, is_pause);
1979
1980 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] S%d TSSI %s\n", path,
1981 is_pause ? "pause" : "resume");
1982 }
1983
_dpk_kip_control_rfc(struct rtw89_dev * rtwdev,u8 path,bool ctrl_by_kip)1984 static void _dpk_kip_control_rfc(struct rtw89_dev *rtwdev, u8 path, bool ctrl_by_kip)
1985 {
1986 rtw89_phy_write32_mask(rtwdev, R_UPD_CLK + (path << 13), B_IQK_RFC_ON, ctrl_by_kip);
1987 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] RFC is controlled by %s\n",
1988 ctrl_by_kip ? "KIP" : "BB");
1989 }
1990
_dpk_txpwr_bb_force(struct rtw89_dev * rtwdev,u8 path,bool force)1991 static void _dpk_txpwr_bb_force(struct rtw89_dev *rtwdev, u8 path, bool force)
1992 {
1993 rtw89_phy_write32_mask(rtwdev, R_TXPWRB + (path << 13), B_TXPWRB_ON, force);
1994 rtw89_phy_write32_mask(rtwdev, R_TXPWRB_H + (path << 13), B_TXPWRB_RDY, force);
1995
1996 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] S%d txpwr_bb_force %s\n",
1997 path, force ? "on" : "off");
1998 }
1999
_dpk_kip_restore(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path)2000 static void _dpk_kip_restore(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
2001 enum rtw89_rf_path path)
2002 {
2003 _dpk_one_shot(rtwdev, phy, path, D_KIP_RESTORE);
2004 _dpk_kip_control_rfc(rtwdev, path, false);
2005 _dpk_txpwr_bb_force(rtwdev, path, false);
2006 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] S%d restore KIP\n", path);
2007 }
2008
_dpk_lbk_rxiqk(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path)2009 static void _dpk_lbk_rxiqk(struct rtw89_dev *rtwdev,
2010 enum rtw89_phy_idx phy,
2011 enum rtw89_rf_path path)
2012 {
2013 #define RX_TONE_IDX 0x00250025 /* Q.2 9.25MHz */
2014 u8 cur_rxbb;
2015 u32 rf_11, reg_81cc;
2016
2017 rtw89_phy_write32_mask(rtwdev, R_DPD_V1 + (path << 8), B_DPD_LBK, 0x1);
2018 rtw89_phy_write32_mask(rtwdev, R_MDPK_RX_DCK, B_MDPK_RX_DCK_EN, 0x1);
2019
2020 _dpk_kip_control_rfc(rtwdev, path, false);
2021
2022 cur_rxbb = rtw89_read_rf(rtwdev, path, RR_MOD, RR_MOD_M_RXBB);
2023 rf_11 = rtw89_read_rf(rtwdev, path, RR_TXIG, RFREG_MASK);
2024 reg_81cc = rtw89_phy_read32_mask(rtwdev, R_KIP_IQP + (path << 8),
2025 B_KIP_IQP_SW);
2026
2027 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR0, 0x0);
2028 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_GR1, 0x3);
2029 rtw89_write_rf(rtwdev, path, RR_TXIG, RR_TXIG_TG, 0xd);
2030 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_M_RXBB, 0x1f);
2031
2032 rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8), B_KIP_IQP_IQSW, 0x12);
2033 rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8), B_KIP_IQP_SW, 0x3);
2034
2035 _dpk_kip_control_rfc(rtwdev, path, true);
2036
2037 rtw89_phy_write32_mask(rtwdev, R_IQK_DIF4, MASKDWORD, RX_TONE_IDX);
2038
2039 _dpk_one_shot(rtwdev, phy, path, LBK_RXIQK);
2040
2041 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] S%d LBK RXIQC = 0x%x\n", path,
2042 rtw89_phy_read32_mask(rtwdev, R_RXIQC + (path << 8), MASKDWORD));
2043
2044 _dpk_kip_control_rfc(rtwdev, path, false);
2045
2046 rtw89_write_rf(rtwdev, path, RR_TXIG, RFREG_MASK, rf_11);
2047 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_M_RXBB, cur_rxbb);
2048 rtw89_phy_write32_mask(rtwdev, R_KIP_IQP + (path << 8), B_KIP_IQP_SW, reg_81cc);
2049
2050 rtw89_phy_write32_mask(rtwdev, R_MDPK_RX_DCK, B_MDPK_RX_DCK_EN, 0x0);
2051 rtw89_phy_write32_mask(rtwdev, R_KPATH_CFG, B_KPATH_CFG_ED, 0x0);
2052 rtw89_phy_write32_mask(rtwdev, R_LOAD_COEF + (path << 8), B_LOAD_COEF_DI, 0x1);
2053
2054 _dpk_kip_control_rfc(rtwdev, path, true);
2055 }
2056
_dpk_rf_setting(struct rtw89_dev * rtwdev,u8 gain,enum rtw89_rf_path path,u8 kidx)2057 static void _dpk_rf_setting(struct rtw89_dev *rtwdev, u8 gain,
2058 enum rtw89_rf_path path, u8 kidx)
2059 {
2060 struct rtw89_dpk_info *dpk = &rtwdev->dpk;
2061
2062 if (dpk->bp[path][kidx].band == RTW89_BAND_2G) {
2063 rtw89_write_rf(rtwdev, path, RR_MOD, RFREG_MASK,
2064 0x50121 | BIT(rtwdev->dbcc_en));
2065 rtw89_write_rf(rtwdev, path, RR_MOD_V1, RR_MOD_MASK, RF_DPK);
2066 rtw89_write_rf(rtwdev, path, RR_RXBB, RR_RXBB_ATTC, 0x2);
2067 rtw89_write_rf(rtwdev, path, RR_RXBB, RR_RXBB_ATTR, 0x4);
2068 rtw89_write_rf(rtwdev, path, RR_LUTDBG, RR_LUTDBG_TIA, 0x1);
2069 rtw89_write_rf(rtwdev, path, RR_TIA, RR_TIA_N6, 0x1);
2070
2071 rtw89_debug(rtwdev, RTW89_DBG_RFK,
2072 "[DPK] RF 0x0/0x83/0x9e/0x1a/0xdf/0x1001a = 0x%x/ 0x%x/ 0x%x/ 0x%x/ 0x%x/ 0x%x\n",
2073 rtw89_read_rf(rtwdev, path, RR_MOD, RFREG_MASK),
2074 rtw89_read_rf(rtwdev, path, RR_RXBB, RFREG_MASK),
2075 rtw89_read_rf(rtwdev, path, RR_TIA, RFREG_MASK),
2076 rtw89_read_rf(rtwdev, path, RR_BTC, RFREG_MASK),
2077 rtw89_read_rf(rtwdev, path, RR_LUTDBG, RFREG_MASK),
2078 rtw89_read_rf(rtwdev, path, 0x1001a, RFREG_MASK));
2079 } else {
2080 rtw89_write_rf(rtwdev, path, RR_MOD, RFREG_MASK,
2081 0x50101 | BIT(rtwdev->dbcc_en));
2082 rtw89_write_rf(rtwdev, path, RR_MOD_V1, RR_MOD_MASK, RF_DPK);
2083
2084 if (dpk->bp[path][kidx].band == RTW89_BAND_6G && dpk->bp[path][kidx].ch >= 161)
2085 rtw89_write_rf(rtwdev, path, RR_IQGEN, RR_IQGEN_BIAS, 0x8);
2086
2087 rtw89_write_rf(rtwdev, path, RR_LOGEN, RR_LOGEN_RPT, 0xd);
2088 rtw89_write_rf(rtwdev, path, RR_TXAC, RR_TXAC_IQG, 0x8);
2089
2090 rtw89_write_rf(rtwdev, path, RR_RXA2, RR_RXA2_ATT, 0x0);
2091 rtw89_write_rf(rtwdev, path, RR_TXIQK, RR_TXIQK_ATT2, 0x3);
2092 rtw89_write_rf(rtwdev, path, RR_LUTDBG, RR_LUTDBG_TIA, 0x1);
2093 rtw89_write_rf(rtwdev, path, RR_TIA, RR_TIA_N6, 0x1);
2094
2095 if (dpk->bp[path][kidx].bw == RTW89_CHANNEL_WIDTH_160)
2096 rtw89_write_rf(rtwdev, path, RR_RXBB2, RR_RXBB2_EBW, 0x0);
2097 }
2098 }
2099
_dpk_tpg_sel(struct rtw89_dev * rtwdev,enum rtw89_rf_path path,u8 kidx)2100 static void _dpk_tpg_sel(struct rtw89_dev *rtwdev, enum rtw89_rf_path path, u8 kidx)
2101 {
2102 struct rtw89_dpk_info *dpk = &rtwdev->dpk;
2103
2104 if (dpk->bp[path][kidx].bw == RTW89_CHANNEL_WIDTH_160) {
2105 rtw89_phy_write32_mask(rtwdev, R_TPG_MOD, B_TPG_MOD_F, 0x3);
2106 rtw89_phy_write32_mask(rtwdev, R_TPG_SEL, MASKDWORD, 0x0180ff30);
2107 } else if (dpk->bp[path][kidx].bw == RTW89_CHANNEL_WIDTH_80) {
2108 rtw89_phy_write32_mask(rtwdev, R_TPG_MOD, B_TPG_MOD_F, 0x0);
2109 rtw89_phy_write32_mask(rtwdev, R_TPG_SEL, MASKDWORD, 0xffe0fa00);
2110 } else if (dpk->bp[path][kidx].bw == RTW89_CHANNEL_WIDTH_40) {
2111 rtw89_phy_write32_mask(rtwdev, R_TPG_MOD, B_TPG_MOD_F, 0x2);
2112 rtw89_phy_write32_mask(rtwdev, R_TPG_SEL, MASKDWORD, 0xff4009e0);
2113 } else {
2114 rtw89_phy_write32_mask(rtwdev, R_TPG_MOD, B_TPG_MOD_F, 0x1);
2115 rtw89_phy_write32_mask(rtwdev, R_TPG_SEL, MASKDWORD, 0xf9f007d0);
2116 }
2117 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] TPG_Select for %s\n",
2118 dpk->bp[path][kidx].bw == RTW89_CHANNEL_WIDTH_160 ? "160M" :
2119 dpk->bp[path][kidx].bw == RTW89_CHANNEL_WIDTH_80 ? "80M" :
2120 dpk->bp[path][kidx].bw == RTW89_CHANNEL_WIDTH_40 ? "40M" : "20M");
2121 }
2122
_dpk_sync_check(struct rtw89_dev * rtwdev,enum rtw89_rf_path path,u8 kidx)2123 static bool _dpk_sync_check(struct rtw89_dev *rtwdev, enum rtw89_rf_path path, u8 kidx)
2124 {
2125 #define DPK_SYNC_TH_DC_I 200
2126 #define DPK_SYNC_TH_DC_Q 200
2127 #define DPK_SYNC_TH_CORR 170
2128 struct rtw89_dpk_info *dpk = &rtwdev->dpk;
2129 u16 dc_i, dc_q;
2130 u8 corr_val, corr_idx, rxbb;
2131 u8 rxbb_ov;
2132
2133 rtw89_phy_write32_mask(rtwdev, R_KIP_RPT1, B_KIP_RPT1_SEL, 0x0);
2134
2135 corr_idx = rtw89_phy_read32_mask(rtwdev, R_RPT_COM, B_PRT_COM_CORI);
2136 corr_val = rtw89_phy_read32_mask(rtwdev, R_RPT_COM, B_PRT_COM_CORV);
2137
2138 dpk->corr_idx[path][kidx] = corr_idx;
2139 dpk->corr_val[path][kidx] = corr_val;
2140
2141 rtw89_phy_write32_mask(rtwdev, R_KIP_RPT1, B_KIP_RPT1_SEL, 0x9);
2142
2143 dc_i = rtw89_phy_read32_mask(rtwdev, R_RPT_COM, B_PRT_COM_DCI);
2144 dc_q = rtw89_phy_read32_mask(rtwdev, R_RPT_COM, B_PRT_COM_DCQ);
2145
2146 dc_i = abs(sign_extend32(dc_i, 11));
2147 dc_q = abs(sign_extend32(dc_q, 11));
2148
2149 rtw89_debug(rtwdev, RTW89_DBG_RFK,
2150 "[DPK] S%d Corr_idx/ Corr_val /DC I/Q, = %d / %d / %d / %d\n",
2151 path, corr_idx, corr_val, dc_i, dc_q);
2152
2153 dpk->dc_i[path][kidx] = dc_i;
2154 dpk->dc_q[path][kidx] = dc_q;
2155
2156 rtw89_phy_write32_mask(rtwdev, R_KIP_RPT1, B_KIP_RPT1_SEL, 0x8);
2157 rxbb = rtw89_phy_read32_mask(rtwdev, R_RPT_COM, B_PRT_COM_RXBB);
2158
2159 rtw89_phy_write32_mask(rtwdev, R_KIP_RPT1, B_KIP_RPT1_SEL, 0x31);
2160 rxbb_ov = rtw89_phy_read32_mask(rtwdev, R_RPT_COM, B_PRT_COM_RXOV);
2161
2162 rtw89_debug(rtwdev, RTW89_DBG_RFK,
2163 "[DPK] S%d RXBB/ RXAGC_done /RXBB_ovlmt = %d / %d / %d\n",
2164 path, rxbb,
2165 rtw89_phy_read32_mask(rtwdev, R_RPT_COM, B_PRT_COM_DONE),
2166 rxbb_ov);
2167
2168 if (dc_i > DPK_SYNC_TH_DC_I || dc_q > DPK_SYNC_TH_DC_Q ||
2169 corr_val < DPK_SYNC_TH_CORR)
2170 return true;
2171 else
2172 return false;
2173 }
2174
_dpk_dgain_read(struct rtw89_dev * rtwdev)2175 static u16 _dpk_dgain_read(struct rtw89_dev *rtwdev)
2176 {
2177 u16 dgain = 0x0;
2178
2179 rtw89_phy_write32_clr(rtwdev, R_KIP_RPT1, B_KIP_RPT1_SEL);
2180
2181 dgain = rtw89_phy_read32_mask(rtwdev, R_RPT_COM, B_PRT_COM_DCI);
2182
2183 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] DGain = 0x%x (%d)\n", dgain, dgain);
2184
2185 return dgain;
2186 }
2187
_dpk_gainloss_read(struct rtw89_dev * rtwdev)2188 static u8 _dpk_gainloss_read(struct rtw89_dev *rtwdev)
2189 {
2190 u8 result;
2191
2192 rtw89_phy_write32_mask(rtwdev, R_KIP_RPT1, B_KIP_RPT1_SEL, 0x6);
2193 rtw89_phy_write32_mask(rtwdev, R_DPK_CFG2, B_DPK_CFG2_ST, 0x1);
2194
2195 result = rtw89_phy_read32_mask(rtwdev, R_RPT_COM, B_PRT_COM_GL);
2196
2197 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] tmp GL = %d\n", result);
2198
2199 return result;
2200 }
2201
_dpk_kset_query(struct rtw89_dev * rtwdev,enum rtw89_rf_path path)2202 static void _dpk_kset_query(struct rtw89_dev *rtwdev, enum rtw89_rf_path path)
2203 {
2204 struct rtw89_dpk_info *dpk = &rtwdev->dpk;
2205
2206 rtw89_phy_write32_mask(rtwdev, R_KIP_RPT + (path << 8), B_KIP_RPT_SEL, 0x10);
2207 dpk->cur_k_set =
2208 rtw89_phy_read32_mask(rtwdev, R_RPT_PER + (path << 8), 0xE0000000) - 1;
2209 }
2210
_dpk_kip_set_txagc(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path,u8 dbm,bool set_from_bb)2211 static void _dpk_kip_set_txagc(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
2212 enum rtw89_rf_path path, u8 dbm, bool set_from_bb)
2213 {
2214 if (set_from_bb) {
2215 dbm = clamp_t(u8, dbm, 7, 24);
2216 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] set S%d txagc to %ddBm\n", path, dbm);
2217 rtw89_phy_write32_mask(rtwdev, R_TXPWRB + (path << 13), B_TXPWRB_VAL, dbm << 2);
2218 }
2219 _dpk_one_shot(rtwdev, phy, path, D_TXAGC);
2220 _dpk_kset_query(rtwdev, path);
2221 }
2222
_dpk_gainloss(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path,u8 kidx)2223 static u8 _dpk_gainloss(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
2224 enum rtw89_rf_path path, u8 kidx)
2225 {
2226 _dpk_one_shot(rtwdev, phy, path, D_GAIN_LOSS);
2227 _dpk_kip_set_txagc(rtwdev, phy, path, 0xff, false);
2228
2229 rtw89_phy_write32_mask(rtwdev, R_DPK_GL + (path << 8), B_DPK_GL_A1, 0x0);
2230 rtw89_phy_write32_mask(rtwdev, R_DPK_GL + (path << 8), B_DPK_GL_A0, 0x0);
2231
2232 return _dpk_gainloss_read(rtwdev);
2233 }
2234
_dpk_pas_read(struct rtw89_dev * rtwdev,bool is_check)2235 static enum dpk_pas_result _dpk_pas_read(struct rtw89_dev *rtwdev, bool is_check)
2236 {
2237 u32 val1_i = 0, val1_q = 0, val2_i = 0, val2_q = 0;
2238 u32 val1_sqrt_sum, val2_sqrt_sum;
2239 u8 i;
2240
2241 rtw89_phy_write32_mask(rtwdev, R_KIP_RPT1, MASKBYTE2, 0x06);
2242 rtw89_phy_write32_mask(rtwdev, R_DPK_CFG2, B_DPK_CFG2_ST, 0x0);
2243 rtw89_phy_write32_mask(rtwdev, R_DPK_CFG3, MASKBYTE2, 0x08);
2244
2245 if (is_check) {
2246 rtw89_phy_write32_mask(rtwdev, R_DPK_CFG3, MASKBYTE3, 0x00);
2247 val1_i = rtw89_phy_read32_mask(rtwdev, R_RPT_COM, MASKHWORD);
2248 val1_i = abs(sign_extend32(val1_i, 11));
2249 val1_q = rtw89_phy_read32_mask(rtwdev, R_RPT_COM, MASKLWORD);
2250 val1_q = abs(sign_extend32(val1_q, 11));
2251
2252 rtw89_phy_write32_mask(rtwdev, R_DPK_CFG3, MASKBYTE3, 0x1f);
2253 val2_i = rtw89_phy_read32_mask(rtwdev, R_RPT_COM, MASKHWORD);
2254 val2_i = abs(sign_extend32(val2_i, 11));
2255 val2_q = rtw89_phy_read32_mask(rtwdev, R_RPT_COM, MASKLWORD);
2256 val2_q = abs(sign_extend32(val2_q, 11));
2257
2258 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] PAS_delta = 0x%x\n",
2259 phy_div(val1_i * val1_i + val1_q * val1_q,
2260 val2_i * val2_i + val2_q * val2_q));
2261 } else {
2262 for (i = 0; i < 32; i++) {
2263 rtw89_phy_write32_mask(rtwdev, R_DPK_CFG3, MASKBYTE3, i);
2264 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] PAS_Read[%02d]= 0x%08x\n", i,
2265 rtw89_phy_read32_mask(rtwdev, R_RPT_COM, MASKDWORD));
2266 }
2267 }
2268
2269 val1_sqrt_sum = val1_i * val1_i + val1_q * val1_q;
2270 val2_sqrt_sum = val2_i * val2_i + val2_q * val2_q;
2271
2272 if (val1_sqrt_sum < val2_sqrt_sum)
2273 return DPK_PAS_LT;
2274 else if (val1_sqrt_sum >= val2_sqrt_sum * 8 / 5)
2275 return DPK_PAS_GT;
2276 else
2277 return DPK_PAS_NOR;
2278 }
2279
_dpk_kip_set_rxagc(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path,u8 kidx)2280 static bool _dpk_kip_set_rxagc(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
2281 enum rtw89_rf_path path, u8 kidx)
2282 {
2283 _dpk_kip_control_rfc(rtwdev, path, false);
2284 rtw89_phy_write32_mask(rtwdev, R_KIP_MOD, B_KIP_MOD,
2285 rtw89_read_rf(rtwdev, path, RR_MOD, RFREG_MASK));
2286 _dpk_kip_control_rfc(rtwdev, path, true);
2287
2288 _dpk_one_shot(rtwdev, phy, path, D_RXAGC);
2289
2290 return _dpk_sync_check(rtwdev, path, kidx);
2291 }
2292
_dpk_read_rxsram(struct rtw89_dev * rtwdev)2293 static void _dpk_read_rxsram(struct rtw89_dev *rtwdev)
2294 {
2295 u32 addr;
2296
2297 rtw89_rfk_parser(rtwdev, &rtw8852c_read_rxsram_pre_defs_tbl);
2298
2299 for (addr = 0; addr < 0x200; addr++) {
2300 rtw89_phy_write32_mask(rtwdev, R_SRAM_IQRX, MASKDWORD, 0x00010000 | addr);
2301
2302 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] RXSRAM[%03d] = 0x%07x\n", addr,
2303 rtw89_phy_read32_mask(rtwdev, R_RPT_COM, MASKDWORD));
2304 }
2305
2306 rtw89_rfk_parser(rtwdev, &rtw8852c_read_rxsram_post_defs_tbl);
2307 }
2308
_dpk_bypass_rxiqc(struct rtw89_dev * rtwdev,enum rtw89_rf_path path)2309 static void _dpk_bypass_rxiqc(struct rtw89_dev *rtwdev, enum rtw89_rf_path path)
2310 {
2311 rtw89_phy_write32_mask(rtwdev, R_DPD_V1 + (path << 8), B_DPD_LBK, 0x1);
2312 rtw89_phy_write32_mask(rtwdev, R_RXIQC + (path << 8), MASKDWORD, 0x40000002);
2313
2314 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] Bypass RXIQC\n");
2315 }
2316
_dpk_agc(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path,u8 kidx,u8 init_xdbm,u8 loss_only)2317 static u8 _dpk_agc(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
2318 enum rtw89_rf_path path, u8 kidx, u8 init_xdbm, u8 loss_only)
2319 {
2320 struct rtw89_dpk_info *dpk = &rtwdev->dpk;
2321 u8 step = DPK_AGC_STEP_SYNC_DGAIN;
2322 u8 tmp_dbm = init_xdbm, tmp_gl_idx = 0;
2323 u8 tmp_rxbb;
2324 u8 goout = 0, agc_cnt = 0;
2325 enum dpk_pas_result pas;
2326 u16 dgain = 0;
2327 bool is_fail = false;
2328 int limit = 200;
2329
2330 do {
2331 switch (step) {
2332 case DPK_AGC_STEP_SYNC_DGAIN:
2333 is_fail = _dpk_kip_set_rxagc(rtwdev, phy, path, kidx);
2334
2335 if (RTW8852C_DPK_RXSRAM_DBG)
2336 _dpk_read_rxsram(rtwdev);
2337
2338 if (is_fail) {
2339 goout = 1;
2340 break;
2341 }
2342
2343 dgain = _dpk_dgain_read(rtwdev);
2344
2345 if (dgain > 0x5fc || dgain < 0x556) {
2346 _dpk_one_shot(rtwdev, phy, path, D_SYNC);
2347 dgain = _dpk_dgain_read(rtwdev);
2348 }
2349
2350 if (agc_cnt == 0) {
2351 if (dpk->bp[path][kidx].band == RTW89_BAND_2G)
2352 _dpk_bypass_rxiqc(rtwdev, path);
2353 else
2354 _dpk_lbk_rxiqk(rtwdev, phy, path);
2355 }
2356 step = DPK_AGC_STEP_GAIN_LOSS_IDX;
2357 break;
2358
2359 case DPK_AGC_STEP_GAIN_LOSS_IDX:
2360 tmp_gl_idx = _dpk_gainloss(rtwdev, phy, path, kidx);
2361 pas = _dpk_pas_read(rtwdev, true);
2362
2363 if (pas == DPK_PAS_LT && tmp_gl_idx > 0)
2364 step = DPK_AGC_STEP_GL_LT_CRITERION;
2365 else if (pas == DPK_PAS_GT && tmp_gl_idx == 0)
2366 step = DPK_AGC_STEP_GL_GT_CRITERION;
2367 else if (tmp_gl_idx >= 7)
2368 step = DPK_AGC_STEP_GL_GT_CRITERION;
2369 else if (tmp_gl_idx == 0)
2370 step = DPK_AGC_STEP_GL_LT_CRITERION;
2371 else
2372 step = DPK_AGC_STEP_SET_TX_GAIN;
2373 break;
2374
2375 case DPK_AGC_STEP_GL_GT_CRITERION:
2376 if (tmp_dbm <= 7) {
2377 goout = 1;
2378 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] Txagc@lower bound!!\n");
2379 } else {
2380 tmp_dbm = max_t(u8, tmp_dbm - 3, 7);
2381 _dpk_kip_set_txagc(rtwdev, phy, path, tmp_dbm, true);
2382 }
2383 step = DPK_AGC_STEP_SYNC_DGAIN;
2384 agc_cnt++;
2385 break;
2386
2387 case DPK_AGC_STEP_GL_LT_CRITERION:
2388 if (tmp_dbm >= 24) {
2389 goout = 1;
2390 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] Txagc@upper bound!!\n");
2391 } else {
2392 tmp_dbm = min_t(u8, tmp_dbm + 2, 24);
2393 _dpk_kip_set_txagc(rtwdev, phy, path, tmp_dbm, true);
2394 }
2395 step = DPK_AGC_STEP_SYNC_DGAIN;
2396 agc_cnt++;
2397 break;
2398
2399 case DPK_AGC_STEP_SET_TX_GAIN:
2400 _dpk_kip_control_rfc(rtwdev, path, false);
2401 tmp_rxbb = rtw89_read_rf(rtwdev, path, RR_MOD, RR_MOD_M_RXBB);
2402 if (tmp_rxbb + tmp_gl_idx > 0x1f)
2403 tmp_rxbb = 0x1f;
2404 else
2405 tmp_rxbb = tmp_rxbb + tmp_gl_idx;
2406
2407 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_M_RXBB, tmp_rxbb);
2408 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] Adjust RXBB (%+d) = 0x%x\n",
2409 tmp_gl_idx, tmp_rxbb);
2410 _dpk_kip_control_rfc(rtwdev, path, true);
2411 goout = 1;
2412 break;
2413 default:
2414 goout = 1;
2415 break;
2416 }
2417 } while (!goout && agc_cnt < 6 && --limit > 0);
2418
2419 if (limit <= 0)
2420 rtw89_warn(rtwdev, "[DPK] exceed loop limit\n");
2421
2422 return is_fail;
2423 }
2424
_dpk_set_mdpd_para(struct rtw89_dev * rtwdev,u8 order)2425 static void _dpk_set_mdpd_para(struct rtw89_dev *rtwdev, u8 order)
2426 {
2427 static const struct rtw89_rfk_tbl *order_tbls[] = {
2428 &rtw8852c_dpk_mdpd_order0_defs_tbl,
2429 &rtw8852c_dpk_mdpd_order1_defs_tbl,
2430 &rtw8852c_dpk_mdpd_order2_defs_tbl,
2431 &rtw8852c_dpk_mdpd_order3_defs_tbl,
2432 };
2433
2434 if (order >= ARRAY_SIZE(order_tbls)) {
2435 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] Wrong MDPD order!!(0x%x)\n", order);
2436 return;
2437 }
2438
2439 rtw89_rfk_parser(rtwdev, order_tbls[order]);
2440
2441 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] Set %s for IDL\n",
2442 order == 0x0 ? "(5,3,1)" :
2443 order == 0x1 ? "(5,3,0)" :
2444 order == 0x2 ? "(5,0,0)" : "(7,3,1)");
2445 }
2446
_dpk_idl_mpa(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path,u8 kidx)2447 static void _dpk_idl_mpa(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
2448 enum rtw89_rf_path path, u8 kidx)
2449 {
2450 struct rtw89_dpk_info *dpk = &rtwdev->dpk;
2451 u8 cnt;
2452 u8 ov_flag;
2453 u32 dpk_sync;
2454
2455 rtw89_phy_write32_mask(rtwdev, R_LDL_NORM, B_LDL_NORM_MA, 0x1);
2456
2457 if (rtw89_phy_read32_mask(rtwdev, R_DPK_MPA, B_DPK_MPA_T2) == 0x1)
2458 _dpk_set_mdpd_para(rtwdev, 0x2);
2459 else if (rtw89_phy_read32_mask(rtwdev, R_DPK_MPA, B_DPK_MPA_T1) == 0x1)
2460 _dpk_set_mdpd_para(rtwdev, 0x1);
2461 else if (rtw89_phy_read32_mask(rtwdev, R_DPK_MPA, B_DPK_MPA_T0) == 0x1)
2462 _dpk_set_mdpd_para(rtwdev, 0x0);
2463 else if (dpk->bp[path][kidx].bw == RTW89_CHANNEL_WIDTH_5 ||
2464 dpk->bp[path][kidx].bw == RTW89_CHANNEL_WIDTH_10 ||
2465 dpk->bp[path][kidx].bw == RTW89_CHANNEL_WIDTH_20)
2466 _dpk_set_mdpd_para(rtwdev, 0x2);
2467 else if (dpk->bp[path][kidx].bw == RTW89_CHANNEL_WIDTH_40 ||
2468 dpk->bp[path][kidx].bw == RTW89_CHANNEL_WIDTH_80)
2469 _dpk_set_mdpd_para(rtwdev, 0x1);
2470 else
2471 _dpk_set_mdpd_para(rtwdev, 0x0);
2472
2473 rtw89_phy_write32_mask(rtwdev, R_DPK_IDL, B_DPK_IDL, 0x0);
2474 fsleep(1000);
2475
2476 _dpk_one_shot(rtwdev, phy, path, D_MDPK_IDL);
2477 rtw89_phy_write32_mask(rtwdev, R_KIP_RPT1, B_KIP_RPT1_SEL, 0x0);
2478 dpk_sync = rtw89_phy_read32_mask(rtwdev, R_RPT_COM, MASKDWORD);
2479 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] dpk_sync = 0x%x\n", dpk_sync);
2480
2481 rtw89_phy_write32_mask(rtwdev, R_KIP_RPT1, B_KIP_RPT1_SEL, 0xf);
2482 ov_flag = rtw89_phy_read32_mask(rtwdev, R_RPT_COM, B_PRT_COM_SYNERR);
2483 for (cnt = 0; cnt < 5 && ov_flag == 0x1; cnt++) {
2484 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] ReK due to MDPK ov!!!\n");
2485 _dpk_one_shot(rtwdev, phy, path, D_MDPK_IDL);
2486 rtw89_phy_write32_mask(rtwdev, R_KIP_RPT1, B_KIP_RPT1_SEL, 0xf);
2487 ov_flag = rtw89_phy_read32_mask(rtwdev, R_RPT_COM, B_PRT_COM_SYNERR);
2488 }
2489
2490 if (ov_flag) {
2491 _dpk_set_mdpd_para(rtwdev, 0x2);
2492 _dpk_one_shot(rtwdev, phy, path, D_MDPK_IDL);
2493 }
2494 }
2495
_dpk_reload_check(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path)2496 static bool _dpk_reload_check(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
2497 enum rtw89_rf_path path)
2498 {
2499 const struct rtw89_chan *chan = rtw89_chan_get(rtwdev, RTW89_SUB_ENTITY_0);
2500 struct rtw89_dpk_info *dpk = &rtwdev->dpk;
2501 bool is_reload = false;
2502 u8 idx, cur_band, cur_ch;
2503
2504 cur_band = chan->band_type;
2505 cur_ch = chan->channel;
2506
2507 for (idx = 0; idx < RTW89_DPK_BKUP_NUM; idx++) {
2508 if (cur_band != dpk->bp[path][idx].band ||
2509 cur_ch != dpk->bp[path][idx].ch)
2510 continue;
2511
2512 rtw89_phy_write32_mask(rtwdev, R_COEF_SEL + (path << 8),
2513 B_COEF_SEL_MDPD, idx);
2514 dpk->cur_idx[path] = idx;
2515 is_reload = true;
2516 rtw89_debug(rtwdev, RTW89_DBG_RFK,
2517 "[DPK] reload S%d[%d] success\n", path, idx);
2518 }
2519
2520 return is_reload;
2521 }
2522
_dpk_kip_pwr_clk_onoff(struct rtw89_dev * rtwdev,bool turn_on)2523 static void _dpk_kip_pwr_clk_onoff(struct rtw89_dev *rtwdev, bool turn_on)
2524 {
2525 rtw89_rfk_parser(rtwdev, turn_on ? &rtw8852c_dpk_kip_pwr_clk_on_defs_tbl :
2526 &rtw8852c_dpk_kip_pwr_clk_off_defs_tbl);
2527 }
2528
_dpk_kip_preset_8852c(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path,u8 kidx)2529 static void _dpk_kip_preset_8852c(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
2530 enum rtw89_rf_path path, u8 kidx)
2531 {
2532 rtw89_phy_write32_mask(rtwdev, R_KIP_MOD, B_KIP_MOD,
2533 rtw89_read_rf(rtwdev, path, RR_MOD, RFREG_MASK));
2534
2535 if (rtwdev->hal.cv == CHIP_CAV)
2536 rtw89_phy_write32_mask(rtwdev,
2537 R_DPD_CH0A + (path << 8) + (kidx << 2),
2538 B_DPD_SEL, 0x01);
2539 else
2540 rtw89_phy_write32_mask(rtwdev,
2541 R_DPD_CH0A + (path << 8) + (kidx << 2),
2542 B_DPD_SEL, 0x0c);
2543
2544 _dpk_kip_control_rfc(rtwdev, path, true);
2545 rtw89_phy_write32_mask(rtwdev, R_COEF_SEL + (path << 8), B_COEF_SEL_MDPD, kidx);
2546
2547 _dpk_one_shot(rtwdev, phy, path, D_KIP_PRESET);
2548 }
2549
_dpk_para_query(struct rtw89_dev * rtwdev,enum rtw89_rf_path path,u8 kidx)2550 static void _dpk_para_query(struct rtw89_dev *rtwdev, enum rtw89_rf_path path, u8 kidx)
2551 {
2552 #define _DPK_PARA_TXAGC GENMASK(15, 10)
2553 #define _DPK_PARA_THER GENMASK(31, 26)
2554 struct rtw89_dpk_info *dpk = &rtwdev->dpk;
2555 u32 para;
2556
2557 para = rtw89_phy_read32_mask(rtwdev, dpk_par_regs[kidx][dpk->cur_k_set] + (path << 8),
2558 MASKDWORD);
2559
2560 dpk->bp[path][kidx].txagc_dpk = FIELD_GET(_DPK_PARA_TXAGC, para);
2561 dpk->bp[path][kidx].ther_dpk = FIELD_GET(_DPK_PARA_THER, para);
2562
2563 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] thermal/ txagc_RF (K%d) = 0x%x/ 0x%x\n",
2564 dpk->cur_k_set, dpk->bp[path][kidx].ther_dpk, dpk->bp[path][kidx].txagc_dpk);
2565 }
2566
_dpk_gain_normalize_8852c(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path,u8 kidx,bool is_execute)2567 static void _dpk_gain_normalize_8852c(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
2568 enum rtw89_rf_path path, u8 kidx, bool is_execute)
2569 {
2570 struct rtw89_dpk_info *dpk = &rtwdev->dpk;
2571
2572 if (is_execute) {
2573 rtw89_phy_write32_mask(rtwdev, R_DPK_GN + (path << 8), B_DPK_GN_AG, 0x200);
2574 rtw89_phy_write32_mask(rtwdev, R_DPK_GN + (path << 8), B_DPK_GN_EN, 0x3);
2575
2576 _dpk_one_shot(rtwdev, phy, path, D_GAIN_NORM);
2577 } else {
2578 rtw89_phy_write32_mask(rtwdev, dpk_par_regs[kidx][dpk->cur_k_set] + (path << 8),
2579 0x0000007F, 0x5b);
2580 }
2581 dpk->bp[path][kidx].gs =
2582 rtw89_phy_read32_mask(rtwdev, dpk_par_regs[kidx][dpk->cur_k_set] + (path << 8),
2583 0x0000007F);
2584 }
2585
_dpk_order_convert(struct rtw89_dev * rtwdev)2586 static u8 _dpk_order_convert(struct rtw89_dev *rtwdev)
2587 {
2588 u32 val32 = rtw89_phy_read32_mask(rtwdev, R_LDL_NORM, B_LDL_NORM_OP);
2589 u8 val;
2590
2591 switch (val32) {
2592 case 0:
2593 val = 0x6;
2594 break;
2595 case 1:
2596 val = 0x2;
2597 break;
2598 case 2:
2599 val = 0x0;
2600 break;
2601 case 3:
2602 val = 0x7;
2603 break;
2604 default:
2605 val = 0xff;
2606 break;
2607 }
2608
2609 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] convert MDPD order to 0x%x\n", val);
2610
2611 return val;
2612 }
2613
_dpk_on(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path,u8 kidx)2614 static void _dpk_on(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
2615 enum rtw89_rf_path path, u8 kidx)
2616 {
2617 struct rtw89_dpk_info *dpk = &rtwdev->dpk;
2618
2619 rtw89_phy_write32_mask(rtwdev, R_LOAD_COEF + (path << 8), B_LOAD_COEF_MDPD, 0x1);
2620 rtw89_phy_write32_mask(rtwdev, R_LOAD_COEF + (path << 8), B_LOAD_COEF_MDPD, 0x0);
2621 rtw89_phy_write32_mask(rtwdev, R_DPD_CH0A + (path << 8) + (kidx << 2),
2622 B_DPD_ORDER, _dpk_order_convert(rtwdev));
2623
2624 dpk->bp[path][kidx].mdpd_en = BIT(dpk->cur_k_set);
2625 dpk->bp[path][kidx].path_ok = true;
2626
2627 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] S%d[%d] path_ok = 0x%x\n",
2628 path, kidx, dpk->bp[path][kidx].mdpd_en);
2629
2630 rtw89_phy_write32_mask(rtwdev, R_DPD_CH0A + (path << 8) + (kidx << 2),
2631 B_DPD_MEN, dpk->bp[path][kidx].mdpd_en);
2632
2633 _dpk_gain_normalize_8852c(rtwdev, phy, path, kidx, false);
2634 }
2635
_dpk_main(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path,u8 gain)2636 static bool _dpk_main(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
2637 enum rtw89_rf_path path, u8 gain)
2638 {
2639 struct rtw89_dpk_info *dpk = &rtwdev->dpk;
2640 u8 kidx = dpk->cur_idx[path];
2641 u8 init_xdbm = 15;
2642 bool is_fail;
2643
2644 rtw89_debug(rtwdev, RTW89_DBG_RFK,
2645 "[DPK] ========= S%d[%d] DPK Start =========\n", path, kidx);
2646 _dpk_kip_control_rfc(rtwdev, path, false);
2647 _rf_direct_cntrl(rtwdev, path, false);
2648 rtw89_write_rf(rtwdev, path, RR_BBDC, RFREG_MASK, 0x03ffd);
2649 _dpk_rf_setting(rtwdev, gain, path, kidx);
2650 _set_rx_dck(rtwdev, phy, path, false);
2651 _dpk_kip_pwr_clk_onoff(rtwdev, true);
2652 _dpk_kip_preset_8852c(rtwdev, phy, path, kidx);
2653 _dpk_txpwr_bb_force(rtwdev, path, true);
2654 _dpk_kip_set_txagc(rtwdev, phy, path, init_xdbm, true);
2655 _dpk_tpg_sel(rtwdev, path, kidx);
2656
2657 is_fail = _dpk_agc(rtwdev, phy, path, kidx, init_xdbm, false);
2658 if (is_fail)
2659 goto _error;
2660
2661 _dpk_idl_mpa(rtwdev, phy, path, kidx);
2662 _dpk_para_query(rtwdev, path, kidx);
2663 _dpk_on(rtwdev, phy, path, kidx);
2664
2665 _error:
2666 _dpk_kip_control_rfc(rtwdev, path, false);
2667 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_MASK, RF_RX);
2668 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] S%d[%d]_K%d %s\n", path, kidx,
2669 dpk->cur_k_set, is_fail ? "need Check" : "is Success");
2670
2671 return is_fail;
2672 }
2673
_dpk_init(struct rtw89_dev * rtwdev,u8 path)2674 static void _dpk_init(struct rtw89_dev *rtwdev, u8 path)
2675 {
2676 struct rtw89_dpk_info *dpk = &rtwdev->dpk;
2677 u8 kidx = dpk->cur_idx[path];
2678
2679 dpk->bp[path][kidx].path_ok = false;
2680 }
2681
_dpk_drf_direct_cntrl(struct rtw89_dev * rtwdev,u8 path,bool is_bybb)2682 static void _dpk_drf_direct_cntrl(struct rtw89_dev *rtwdev, u8 path, bool is_bybb)
2683 {
2684 if (is_bybb)
2685 rtw89_write_rf(rtwdev, path, RR_BBDC, RR_BBDC_SEL, 0x1);
2686 else
2687 rtw89_write_rf(rtwdev, path, RR_BBDC, RR_BBDC_SEL, 0x0);
2688 }
2689
_dpk_cal_select(struct rtw89_dev * rtwdev,bool force,enum rtw89_phy_idx phy,u8 kpath)2690 static void _dpk_cal_select(struct rtw89_dev *rtwdev, bool force,
2691 enum rtw89_phy_idx phy, u8 kpath)
2692 {
2693 struct rtw89_dpk_info *dpk = &rtwdev->dpk;
2694 static const u32 kip_reg[] = {0x813c, 0x8124, 0x8120, 0xc0c4, 0xc0e8, 0xc0d4, 0xc0d8};
2695 u32 backup_rf_val[RTW8852C_DPK_RF_PATH][BACKUP_RF_REGS_NR];
2696 u32 kip_bkup[RTW8852C_DPK_RF_PATH][RTW8852C_DPK_KIP_REG_NUM] = {};
2697 u8 path;
2698 bool is_fail = true, reloaded[RTW8852C_DPK_RF_PATH] = {false};
2699
2700 #if defined(__linux__)
2701 static_assert(ARRAY_SIZE(kip_reg) == RTW8852C_DPK_KIP_REG_NUM);
2702 #elif defined(__FreeBSD__)
2703 rtw89_static_assert(ARRAY_SIZE(kip_reg) == RTW8852C_DPK_KIP_REG_NUM);
2704 #endif
2705
2706 if (dpk->is_dpk_reload_en) {
2707 for (path = 0; path < RTW8852C_DPK_RF_PATH; path++) {
2708 if (!(kpath & BIT(path)))
2709 continue;
2710
2711 reloaded[path] = _dpk_reload_check(rtwdev, phy, path);
2712 if (!reloaded[path] && dpk->bp[path][0].ch != 0)
2713 dpk->cur_idx[path] = !dpk->cur_idx[path];
2714 else
2715 _dpk_onoff(rtwdev, path, false);
2716 }
2717 } else {
2718 for (path = 0; path < RTW8852C_DPK_RF_PATH; path++)
2719 dpk->cur_idx[path] = 0;
2720 }
2721
2722 for (path = 0; path < RTW8852C_DPK_RF_PATH; path++) {
2723 rtw89_debug(rtwdev, RTW89_DBG_RFK,
2724 "[DPK] ========= S%d[%d] DPK Init =========\n",
2725 path, dpk->cur_idx[path]);
2726 _dpk_bkup_kip(rtwdev, kip_reg, kip_bkup, path);
2727 _rfk_backup_rf_reg(rtwdev, backup_rf_val[path], path);
2728 _dpk_information(rtwdev, phy, path);
2729 _dpk_init(rtwdev, path);
2730 if (rtwdev->is_tssi_mode[path])
2731 _dpk_tssi_pause(rtwdev, path, true);
2732 }
2733
2734 for (path = 0; path < RTW8852C_DPK_RF_PATH; path++) {
2735 rtw89_debug(rtwdev, RTW89_DBG_RFK,
2736 "[DPK] ========= S%d[%d] DPK Start =========\n",
2737 path, dpk->cur_idx[path]);
2738 rtw8852c_disable_rxagc(rtwdev, path, 0x0);
2739 _dpk_drf_direct_cntrl(rtwdev, path, false);
2740 _dpk_bb_afe_setting(rtwdev, phy, path, kpath);
2741 is_fail = _dpk_main(rtwdev, phy, path, 1);
2742 _dpk_onoff(rtwdev, path, is_fail);
2743 }
2744
2745 for (path = 0; path < RTW8852C_DPK_RF_PATH; path++) {
2746 rtw89_debug(rtwdev, RTW89_DBG_RFK,
2747 "[DPK] ========= S%d[%d] DPK Restore =========\n",
2748 path, dpk->cur_idx[path]);
2749 _dpk_kip_restore(rtwdev, phy, path);
2750 _dpk_reload_kip(rtwdev, kip_reg, kip_bkup, path);
2751 _rfk_restore_rf_reg(rtwdev, backup_rf_val[path], path);
2752 _dpk_bb_afe_restore(rtwdev, path);
2753 rtw8852c_disable_rxagc(rtwdev, path, 0x1);
2754 if (rtwdev->is_tssi_mode[path])
2755 _dpk_tssi_pause(rtwdev, path, false);
2756 }
2757
2758 _dpk_kip_pwr_clk_onoff(rtwdev, false);
2759 }
2760
_dpk_bypass_check(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy)2761 static bool _dpk_bypass_check(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy)
2762 {
2763 struct rtw89_fem_info *fem = &rtwdev->fem;
2764 const struct rtw89_chan *chan = rtw89_chan_get(rtwdev, RTW89_SUB_ENTITY_0);
2765 u8 band = chan->band_type;
2766
2767 if (rtwdev->hal.cv == CHIP_CAV && band != RTW89_BAND_2G) {
2768 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] Skip DPK due to CAV & not 2G!!\n");
2769 return true;
2770 } else if (fem->epa_2g && band == RTW89_BAND_2G) {
2771 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] Skip DPK due to 2G_ext_PA exist!!\n");
2772 return true;
2773 } else if (fem->epa_5g && band == RTW89_BAND_5G) {
2774 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] Skip DPK due to 5G_ext_PA exist!!\n");
2775 return true;
2776 } else if (fem->epa_6g && band == RTW89_BAND_6G) {
2777 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] Skip DPK due to 6G_ext_PA exist!!\n");
2778 return true;
2779 }
2780
2781 return false;
2782 }
2783
_dpk_force_bypass(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy)2784 static void _dpk_force_bypass(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy)
2785 {
2786 u8 path, kpath;
2787
2788 kpath = _kpath(rtwdev, phy);
2789
2790 for (path = 0; path < RTW8852C_DPK_RF_PATH; path++) {
2791 if (kpath & BIT(path))
2792 _dpk_onoff(rtwdev, path, true);
2793 }
2794 }
2795
_dpk(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,bool force)2796 static void _dpk(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy, bool force)
2797 {
2798 rtw89_debug(rtwdev, RTW89_DBG_RFK,
2799 "[DPK] ****** DPK Start (Ver: 0x%x, Cv: %d, RF_para: %d) ******\n",
2800 RTW8852C_DPK_VER, rtwdev->hal.cv,
2801 RTW8852C_RF_REL_VERSION);
2802
2803 if (_dpk_bypass_check(rtwdev, phy))
2804 _dpk_force_bypass(rtwdev, phy);
2805 else
2806 _dpk_cal_select(rtwdev, force, phy, _kpath(rtwdev, phy));
2807
2808 if (rtw89_read_rf(rtwdev, RF_PATH_A, RR_DCKC, RR_DCKC_CHK) == 0x1)
2809 rtw8852c_rx_dck(rtwdev, phy, false);
2810 }
2811
_dpk_onoff(struct rtw89_dev * rtwdev,enum rtw89_rf_path path,bool off)2812 static void _dpk_onoff(struct rtw89_dev *rtwdev,
2813 enum rtw89_rf_path path, bool off)
2814 {
2815 struct rtw89_dpk_info *dpk = &rtwdev->dpk;
2816 u8 val, kidx = dpk->cur_idx[path];
2817
2818 val = dpk->is_dpk_enable && !off && dpk->bp[path][kidx].path_ok ?
2819 dpk->bp[path][kidx].mdpd_en : 0;
2820
2821 rtw89_phy_write32_mask(rtwdev, R_DPD_CH0A + (path << 8) + (kidx << 2),
2822 B_DPD_MEN, val);
2823
2824 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[DPK] S%d[%d] DPK %s !!!\n", path,
2825 kidx, dpk->is_dpk_enable && !off ? "enable" : "disable");
2826 }
2827
_dpk_track(struct rtw89_dev * rtwdev)2828 static void _dpk_track(struct rtw89_dev *rtwdev)
2829 {
2830 struct rtw89_dpk_info *dpk = &rtwdev->dpk;
2831 u8 path, kidx;
2832 u8 txagc_rf = 0;
2833 s8 txagc_bb = 0, txagc_bb_tp = 0, txagc_ofst = 0;
2834 u8 cur_ther;
2835 s8 delta_ther = 0;
2836 s16 pwsf_tssi_ofst;
2837
2838 for (path = 0; path < RTW8852C_DPK_RF_PATH; path++) {
2839 kidx = dpk->cur_idx[path];
2840 rtw89_debug(rtwdev, RTW89_DBG_RFK_TRACK,
2841 "[DPK_TRK] ================[S%d[%d] (CH %d)]================\n",
2842 path, kidx, dpk->bp[path][kidx].ch);
2843
2844 txagc_rf =
2845 rtw89_phy_read32_mask(rtwdev, R_TXAGC_BB + (path << 13), 0x0000003f);
2846 txagc_bb =
2847 rtw89_phy_read32_mask(rtwdev, R_TXAGC_BB + (path << 13), MASKBYTE2);
2848 txagc_bb_tp =
2849 rtw89_phy_read32_mask(rtwdev, R_TXAGC_BTP + (path << 13), B_TXAGC_BTP);
2850
2851 /* report from KIP */
2852 rtw89_phy_write32_mask(rtwdev, R_KIP_RPT + (path << 8), B_KIP_RPT_SEL, 0xf);
2853 cur_ther =
2854 rtw89_phy_read32_mask(rtwdev, R_RPT_PER + (path << 8), B_RPT_PER_TH);
2855 txagc_ofst =
2856 rtw89_phy_read32_mask(rtwdev, R_RPT_PER + (path << 8), B_RPT_PER_OF);
2857 pwsf_tssi_ofst =
2858 rtw89_phy_read32_mask(rtwdev, R_RPT_PER + (path << 8), B_RPT_PER_TSSI);
2859 pwsf_tssi_ofst = sign_extend32(pwsf_tssi_ofst, 12);
2860
2861 cur_ther = ewma_thermal_read(&rtwdev->phystat.avg_thermal[path]);
2862
2863 rtw89_debug(rtwdev, RTW89_DBG_RFK_TRACK,
2864 "[DPK_TRK] thermal now = %d\n", cur_ther);
2865
2866 if (dpk->bp[path][kidx].ch != 0 && cur_ther != 0)
2867 delta_ther = dpk->bp[path][kidx].ther_dpk - cur_ther;
2868
2869 delta_ther = delta_ther * 1 / 2;
2870
2871 rtw89_debug(rtwdev, RTW89_DBG_RFK_TRACK,
2872 "[DPK_TRK] extra delta_ther = %d (0x%x / 0x%x@k)\n",
2873 delta_ther, cur_ther, dpk->bp[path][kidx].ther_dpk);
2874 rtw89_debug(rtwdev, RTW89_DBG_RFK_TRACK,
2875 "[DPK_TRK] delta_txagc = %d (0x%x / 0x%x@k)\n",
2876 txagc_rf - dpk->bp[path][kidx].txagc_dpk, txagc_rf,
2877 dpk->bp[path][kidx].txagc_dpk);
2878 rtw89_debug(rtwdev, RTW89_DBG_RFK_TRACK,
2879 "[DPK_TRK] txagc_offset / pwsf_tssi_ofst = 0x%x / %+d\n",
2880 txagc_ofst, pwsf_tssi_ofst);
2881 rtw89_debug(rtwdev, RTW89_DBG_RFK_TRACK,
2882 "[DPK_TRK] txagc_bb_tp / txagc_bb = 0x%x / 0x%x\n",
2883 txagc_bb_tp, txagc_bb);
2884
2885 if (rtw89_phy_read32_mask(rtwdev, R_DPK_WR, B_DPK_WR_ST) == 0x0 &&
2886 txagc_rf != 0 && rtwdev->hal.cv == CHIP_CAV) {
2887 rtw89_debug(rtwdev, RTW89_DBG_RFK_TRACK,
2888 "[DPK_TRK] New pwsf = 0x%x\n", 0x78 - delta_ther);
2889
2890 rtw89_phy_write32_mask(rtwdev, R_DPD_BND + (path << 8) + (kidx << 2),
2891 0x07FC0000, 0x78 - delta_ther);
2892 }
2893 }
2894 }
2895
_tssi_set_sys(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path)2896 static void _tssi_set_sys(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
2897 enum rtw89_rf_path path)
2898 {
2899 const struct rtw89_chan *chan = rtw89_chan_get(rtwdev, RTW89_SUB_ENTITY_0);
2900 enum rtw89_band band = chan->band_type;
2901
2902 rtw89_rfk_parser(rtwdev, &rtw8852c_tssi_sys_defs_tbl);
2903
2904 if (path == RF_PATH_A)
2905 rtw89_rfk_parser_by_cond(rtwdev, band == RTW89_BAND_2G,
2906 &rtw8852c_tssi_sys_defs_2g_a_tbl,
2907 &rtw8852c_tssi_sys_defs_5g_a_tbl);
2908 else
2909 rtw89_rfk_parser_by_cond(rtwdev, band == RTW89_BAND_2G,
2910 &rtw8852c_tssi_sys_defs_2g_b_tbl,
2911 &rtw8852c_tssi_sys_defs_5g_b_tbl);
2912 }
2913
_tssi_ini_txpwr_ctrl_bb(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path)2914 static void _tssi_ini_txpwr_ctrl_bb(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
2915 enum rtw89_rf_path path)
2916 {
2917 rtw89_rfk_parser_by_cond(rtwdev, path == RF_PATH_A,
2918 &rtw8852c_tssi_txpwr_ctrl_bb_defs_a_tbl,
2919 &rtw8852c_tssi_txpwr_ctrl_bb_defs_b_tbl);
2920 }
2921
_tssi_ini_txpwr_ctrl_bb_he_tb(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path)2922 static void _tssi_ini_txpwr_ctrl_bb_he_tb(struct rtw89_dev *rtwdev,
2923 enum rtw89_phy_idx phy,
2924 enum rtw89_rf_path path)
2925 {
2926 rtw89_rfk_parser_by_cond(rtwdev, path == RF_PATH_A,
2927 &rtw8852c_tssi_txpwr_ctrl_bb_he_tb_defs_a_tbl,
2928 &rtw8852c_tssi_txpwr_ctrl_bb_he_tb_defs_b_tbl);
2929 }
2930
_tssi_set_dck(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path)2931 static void _tssi_set_dck(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
2932 enum rtw89_rf_path path)
2933 {
2934 const struct rtw89_chan *chan = rtw89_chan_get(rtwdev, RTW89_SUB_ENTITY_0);
2935 enum rtw89_band band = chan->band_type;
2936
2937 if (path == RF_PATH_A) {
2938 rtw89_rfk_parser(rtwdev, &rtw8852c_tssi_dck_defs_a_tbl);
2939 rtw89_rfk_parser_by_cond(rtwdev, band == RTW89_BAND_2G,
2940 &rtw8852c_tssi_dck_defs_2g_a_tbl,
2941 &rtw8852c_tssi_dck_defs_5g_a_tbl);
2942 } else {
2943 rtw89_rfk_parser(rtwdev, &rtw8852c_tssi_dck_defs_b_tbl);
2944 rtw89_rfk_parser_by_cond(rtwdev, band == RTW89_BAND_2G,
2945 &rtw8852c_tssi_dck_defs_2g_b_tbl,
2946 &rtw8852c_tssi_dck_defs_5g_b_tbl);
2947 }
2948 }
2949
_tssi_set_bbgain_split(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path)2950 static void _tssi_set_bbgain_split(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
2951 enum rtw89_rf_path path)
2952 {
2953 rtw89_rfk_parser_by_cond(rtwdev, path == RF_PATH_A,
2954 &rtw8852c_tssi_set_bbgain_split_a_tbl,
2955 &rtw8852c_tssi_set_bbgain_split_b_tbl);
2956 }
2957
_tssi_set_tmeter_tbl(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path)2958 static void _tssi_set_tmeter_tbl(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
2959 enum rtw89_rf_path path)
2960 {
2961 #define RTW8852C_TSSI_GET_VAL(ptr, idx) \
2962 ({ \
2963 s8 *__ptr = (ptr); \
2964 u8 __idx = (idx), __i, __v; \
2965 u32 __val = 0; \
2966 for (__i = 0; __i < 4; __i++) { \
2967 __v = (__ptr[__idx + __i]); \
2968 __val |= (__v << (8 * __i)); \
2969 } \
2970 __val; \
2971 })
2972 struct rtw89_tssi_info *tssi_info = &rtwdev->tssi;
2973 const struct rtw89_chan *chan = rtw89_chan_get(rtwdev, RTW89_SUB_ENTITY_0);
2974 u8 ch = chan->channel;
2975 u8 subband = chan->subband_type;
2976 const s8 *thm_up_a = NULL;
2977 const s8 *thm_down_a = NULL;
2978 const s8 *thm_up_b = NULL;
2979 const s8 *thm_down_b = NULL;
2980 u8 thermal = 0xff;
2981 s8 thm_ofst[64] = {0};
2982 u32 tmp = 0;
2983 u8 i, j;
2984
2985 switch (subband) {
2986 default:
2987 case RTW89_CH_2G:
2988 thm_up_a = rtw89_8852c_trk_cfg.delta_swingidx_2ga_p;
2989 thm_down_a = rtw89_8852c_trk_cfg.delta_swingidx_2ga_n;
2990 thm_up_b = rtw89_8852c_trk_cfg.delta_swingidx_2gb_p;
2991 thm_down_b = rtw89_8852c_trk_cfg.delta_swingidx_2gb_n;
2992 break;
2993 case RTW89_CH_5G_BAND_1:
2994 thm_up_a = rtw89_8852c_trk_cfg.delta_swingidx_5ga_p[0];
2995 thm_down_a = rtw89_8852c_trk_cfg.delta_swingidx_5ga_n[0];
2996 thm_up_b = rtw89_8852c_trk_cfg.delta_swingidx_5gb_p[0];
2997 thm_down_b = rtw89_8852c_trk_cfg.delta_swingidx_5gb_n[0];
2998 break;
2999 case RTW89_CH_5G_BAND_3:
3000 thm_up_a = rtw89_8852c_trk_cfg.delta_swingidx_5ga_p[1];
3001 thm_down_a = rtw89_8852c_trk_cfg.delta_swingidx_5ga_n[1];
3002 thm_up_b = rtw89_8852c_trk_cfg.delta_swingidx_5gb_p[1];
3003 thm_down_b = rtw89_8852c_trk_cfg.delta_swingidx_5gb_n[1];
3004 break;
3005 case RTW89_CH_5G_BAND_4:
3006 thm_up_a = rtw89_8852c_trk_cfg.delta_swingidx_5ga_p[2];
3007 thm_down_a = rtw89_8852c_trk_cfg.delta_swingidx_5ga_n[2];
3008 thm_up_b = rtw89_8852c_trk_cfg.delta_swingidx_5gb_p[2];
3009 thm_down_b = rtw89_8852c_trk_cfg.delta_swingidx_5gb_n[2];
3010 break;
3011 case RTW89_CH_6G_BAND_IDX0:
3012 case RTW89_CH_6G_BAND_IDX1:
3013 thm_up_a = rtw89_8852c_trk_cfg.delta_swingidx_6ga_p[0];
3014 thm_down_a = rtw89_8852c_trk_cfg.delta_swingidx_6ga_n[0];
3015 thm_up_b = rtw89_8852c_trk_cfg.delta_swingidx_6gb_p[0];
3016 thm_down_b = rtw89_8852c_trk_cfg.delta_swingidx_6gb_n[0];
3017 break;
3018 case RTW89_CH_6G_BAND_IDX2:
3019 case RTW89_CH_6G_BAND_IDX3:
3020 thm_up_a = rtw89_8852c_trk_cfg.delta_swingidx_6ga_p[1];
3021 thm_down_a = rtw89_8852c_trk_cfg.delta_swingidx_6ga_n[1];
3022 thm_up_b = rtw89_8852c_trk_cfg.delta_swingidx_6gb_p[1];
3023 thm_down_b = rtw89_8852c_trk_cfg.delta_swingidx_6gb_n[1];
3024 break;
3025 case RTW89_CH_6G_BAND_IDX4:
3026 case RTW89_CH_6G_BAND_IDX5:
3027 thm_up_a = rtw89_8852c_trk_cfg.delta_swingidx_6ga_p[2];
3028 thm_down_a = rtw89_8852c_trk_cfg.delta_swingidx_6ga_n[2];
3029 thm_up_b = rtw89_8852c_trk_cfg.delta_swingidx_6gb_p[2];
3030 thm_down_b = rtw89_8852c_trk_cfg.delta_swingidx_6gb_n[2];
3031 break;
3032 case RTW89_CH_6G_BAND_IDX6:
3033 case RTW89_CH_6G_BAND_IDX7:
3034 thm_up_a = rtw89_8852c_trk_cfg.delta_swingidx_6ga_p[3];
3035 thm_down_a = rtw89_8852c_trk_cfg.delta_swingidx_6ga_n[3];
3036 thm_up_b = rtw89_8852c_trk_cfg.delta_swingidx_6gb_p[3];
3037 thm_down_b = rtw89_8852c_trk_cfg.delta_swingidx_6gb_n[3];
3038 break;
3039 }
3040
3041 if (path == RF_PATH_A) {
3042 thermal = tssi_info->thermal[RF_PATH_A];
3043
3044 rtw89_debug(rtwdev, RTW89_DBG_TSSI,
3045 "[TSSI] ch=%d thermal_pathA=0x%x\n", ch, thermal);
3046
3047 rtw89_phy_write32_mask(rtwdev, R_P0_TMETER, B_P0_TMETER_DIS, 0x0);
3048 rtw89_phy_write32_mask(rtwdev, R_P0_TMETER, B_P0_TMETER_TRK, 0x1);
3049
3050 if (thermal == 0xff) {
3051 rtw89_phy_write32_mask(rtwdev, R_P0_TMETER, B_P0_TMETER, 32);
3052 rtw89_phy_write32_mask(rtwdev, R_P0_RFCTM, B_P0_RFCTM_VAL, 32);
3053
3054 for (i = 0; i < 64; i += 4) {
3055 rtw89_phy_write32(rtwdev, R_P0_TSSI_BASE + i, 0x0);
3056
3057 rtw89_debug(rtwdev, RTW89_DBG_TSSI,
3058 "[TSSI] write 0x%x val=0x%08x\n",
3059 0x5c00 + i, 0x0);
3060 }
3061
3062 } else {
3063 rtw89_phy_write32_mask(rtwdev, R_P0_TMETER, B_P0_TMETER, thermal);
3064 rtw89_phy_write32_mask(rtwdev, R_P0_RFCTM, B_P0_RFCTM_VAL,
3065 thermal);
3066
3067 i = 0;
3068 for (j = 0; j < 32; j++)
3069 thm_ofst[j] = i < DELTA_SWINGIDX_SIZE ?
3070 -thm_down_a[i++] :
3071 -thm_down_a[DELTA_SWINGIDX_SIZE - 1];
3072
3073 i = 1;
3074 for (j = 63; j >= 32; j--)
3075 thm_ofst[j] = i < DELTA_SWINGIDX_SIZE ?
3076 thm_up_a[i++] :
3077 thm_up_a[DELTA_SWINGIDX_SIZE - 1];
3078
3079 for (i = 0; i < 64; i += 4) {
3080 tmp = RTW8852C_TSSI_GET_VAL(thm_ofst, i);
3081 rtw89_phy_write32(rtwdev, R_P0_TSSI_BASE + i, tmp);
3082
3083 rtw89_debug(rtwdev, RTW89_DBG_TSSI,
3084 "[TSSI] write 0x%x val=0x%08x\n",
3085 0x5c00 + i, tmp);
3086 }
3087 }
3088 rtw89_phy_write32_mask(rtwdev, R_P0_RFCTM, R_P0_RFCTM_RDY, 0x1);
3089 rtw89_phy_write32_mask(rtwdev, R_P0_RFCTM, R_P0_RFCTM_RDY, 0x0);
3090
3091 } else {
3092 thermal = tssi_info->thermal[RF_PATH_B];
3093
3094 rtw89_debug(rtwdev, RTW89_DBG_TSSI,
3095 "[TSSI] ch=%d thermal_pathB=0x%x\n", ch, thermal);
3096
3097 rtw89_phy_write32_mask(rtwdev, R_P1_TMETER, B_P1_TMETER_DIS, 0x0);
3098 rtw89_phy_write32_mask(rtwdev, R_P1_TMETER, B_P1_TMETER_TRK, 0x1);
3099
3100 if (thermal == 0xff) {
3101 rtw89_phy_write32_mask(rtwdev, R_P1_TMETER, B_P1_TMETER, 32);
3102 rtw89_phy_write32_mask(rtwdev, R_P1_RFCTM, B_P1_RFCTM_VAL, 32);
3103
3104 for (i = 0; i < 64; i += 4) {
3105 rtw89_phy_write32(rtwdev, R_TSSI_THOF + i, 0x0);
3106
3107 rtw89_debug(rtwdev, RTW89_DBG_TSSI,
3108 "[TSSI] write 0x%x val=0x%08x\n",
3109 0x7c00 + i, 0x0);
3110 }
3111
3112 } else {
3113 rtw89_phy_write32_mask(rtwdev, R_P1_TMETER, B_P1_TMETER, thermal);
3114 rtw89_phy_write32_mask(rtwdev, R_P1_RFCTM, B_P1_RFCTM_VAL,
3115 thermal);
3116
3117 i = 0;
3118 for (j = 0; j < 32; j++)
3119 thm_ofst[j] = i < DELTA_SWINGIDX_SIZE ?
3120 -thm_down_b[i++] :
3121 -thm_down_b[DELTA_SWINGIDX_SIZE - 1];
3122
3123 i = 1;
3124 for (j = 63; j >= 32; j--)
3125 thm_ofst[j] = i < DELTA_SWINGIDX_SIZE ?
3126 thm_up_b[i++] :
3127 thm_up_b[DELTA_SWINGIDX_SIZE - 1];
3128
3129 for (i = 0; i < 64; i += 4) {
3130 tmp = RTW8852C_TSSI_GET_VAL(thm_ofst, i);
3131 rtw89_phy_write32(rtwdev, R_TSSI_THOF + i, tmp);
3132
3133 rtw89_debug(rtwdev, RTW89_DBG_TSSI,
3134 "[TSSI] write 0x%x val=0x%08x\n",
3135 0x7c00 + i, tmp);
3136 }
3137 }
3138 rtw89_phy_write32_mask(rtwdev, R_P1_RFCTM, R_P1_RFCTM_RDY, 0x1);
3139 rtw89_phy_write32_mask(rtwdev, R_P1_RFCTM, R_P1_RFCTM_RDY, 0x0);
3140 }
3141 #undef RTW8852C_TSSI_GET_VAL
3142 }
3143
_tssi_slope_cal_org(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path)3144 static void _tssi_slope_cal_org(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
3145 enum rtw89_rf_path path)
3146 {
3147 const struct rtw89_chan *chan = rtw89_chan_get(rtwdev, RTW89_SUB_ENTITY_0);
3148 enum rtw89_band band = chan->band_type;
3149
3150 if (path == RF_PATH_A) {
3151 rtw89_rfk_parser_by_cond(rtwdev, band == RTW89_BAND_2G,
3152 &rtw8852c_tssi_slope_cal_org_defs_2g_a_tbl,
3153 &rtw8852c_tssi_slope_cal_org_defs_5g_a_tbl);
3154 } else {
3155 rtw89_rfk_parser_by_cond(rtwdev, band == RTW89_BAND_2G,
3156 &rtw8852c_tssi_slope_cal_org_defs_2g_b_tbl,
3157 &rtw8852c_tssi_slope_cal_org_defs_5g_b_tbl);
3158 }
3159 }
3160
_tssi_set_aligk_default(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path)3161 static void _tssi_set_aligk_default(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
3162 enum rtw89_rf_path path)
3163 {
3164 const struct rtw89_chan *chan = rtw89_chan_get(rtwdev, RTW89_SUB_ENTITY_0);
3165 enum rtw89_band band = chan->band_type;
3166 const struct rtw89_rfk_tbl *tbl;
3167
3168 if (path == RF_PATH_A) {
3169 if (band == RTW89_BAND_2G)
3170 tbl = &rtw8852c_tssi_set_aligk_default_defs_2g_a_tbl;
3171 else if (band == RTW89_BAND_6G)
3172 tbl = &rtw8852c_tssi_set_aligk_default_defs_6g_a_tbl;
3173 else
3174 tbl = &rtw8852c_tssi_set_aligk_default_defs_5g_a_tbl;
3175 } else {
3176 if (band == RTW89_BAND_2G)
3177 tbl = &rtw8852c_tssi_set_aligk_default_defs_2g_b_tbl;
3178 else if (band == RTW89_BAND_6G)
3179 tbl = &rtw8852c_tssi_set_aligk_default_defs_6g_b_tbl;
3180 else
3181 tbl = &rtw8852c_tssi_set_aligk_default_defs_5g_b_tbl;
3182 }
3183
3184 rtw89_rfk_parser(rtwdev, tbl);
3185 }
3186
_tssi_set_slope(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path)3187 static void _tssi_set_slope(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
3188 enum rtw89_rf_path path)
3189 {
3190 rtw89_rfk_parser_by_cond(rtwdev, path == RF_PATH_A,
3191 &rtw8852c_tssi_slope_defs_a_tbl,
3192 &rtw8852c_tssi_slope_defs_b_tbl);
3193 }
3194
_tssi_run_slope(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path)3195 static void _tssi_run_slope(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
3196 enum rtw89_rf_path path)
3197 {
3198 rtw89_rfk_parser_by_cond(rtwdev, path == RF_PATH_A,
3199 &rtw8852c_tssi_run_slope_defs_a_tbl,
3200 &rtw8852c_tssi_run_slope_defs_b_tbl);
3201 }
3202
_tssi_set_track(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path)3203 static void _tssi_set_track(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
3204 enum rtw89_rf_path path)
3205 {
3206 rtw89_rfk_parser_by_cond(rtwdev, path == RF_PATH_A,
3207 &rtw8852c_tssi_track_defs_a_tbl,
3208 &rtw8852c_tssi_track_defs_b_tbl);
3209 }
3210
_tssi_set_txagc_offset_mv_avg(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path)3211 static void _tssi_set_txagc_offset_mv_avg(struct rtw89_dev *rtwdev,
3212 enum rtw89_phy_idx phy,
3213 enum rtw89_rf_path path)
3214 {
3215 rtw89_rfk_parser_by_cond(rtwdev, path == RF_PATH_A,
3216 &rtw8852c_tssi_txagc_ofst_mv_avg_defs_a_tbl,
3217 &rtw8852c_tssi_txagc_ofst_mv_avg_defs_b_tbl);
3218 }
3219
_tssi_enable(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy)3220 static void _tssi_enable(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy)
3221 {
3222 struct rtw89_tssi_info *tssi_info = &rtwdev->tssi;
3223 u32 i, path = RF_PATH_A, path_max = RF_PATH_NUM_8852C;
3224
3225 if (rtwdev->dbcc_en) {
3226 if (phy == RTW89_PHY_0) {
3227 path = RF_PATH_A;
3228 path_max = RF_PATH_B;
3229 } else if (phy == RTW89_PHY_1) {
3230 path = RF_PATH_B;
3231 path_max = RF_PATH_NUM_8852C;
3232 }
3233 }
3234
3235 for (i = path; i < path_max; i++) {
3236 _tssi_set_track(rtwdev, phy, i);
3237 _tssi_set_txagc_offset_mv_avg(rtwdev, phy, i);
3238
3239 rtw89_rfk_parser_by_cond(rtwdev, i == RF_PATH_A,
3240 &rtw8852c_tssi_enable_defs_a_tbl,
3241 &rtw8852c_tssi_enable_defs_b_tbl);
3242
3243 tssi_info->base_thermal[i] =
3244 ewma_thermal_read(&rtwdev->phystat.avg_thermal[i]);
3245 rtwdev->is_tssi_mode[i] = true;
3246 }
3247 }
3248
_tssi_disable(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy)3249 static void _tssi_disable(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy)
3250 {
3251 u32 i, path = RF_PATH_A, path_max = RF_PATH_NUM_8852C;
3252
3253 if (rtwdev->dbcc_en) {
3254 if (phy == RTW89_PHY_0) {
3255 path = RF_PATH_A;
3256 path_max = RF_PATH_B;
3257 } else if (phy == RTW89_PHY_1) {
3258 path = RF_PATH_B;
3259 path_max = RF_PATH_NUM_8852C;
3260 }
3261 }
3262
3263 for (i = path; i < path_max; i++) {
3264 if (i == RF_PATH_A) {
3265 rtw89_rfk_parser(rtwdev, &rtw8852c_tssi_disable_defs_a_tbl);
3266 rtwdev->is_tssi_mode[RF_PATH_A] = false;
3267 } else if (i == RF_PATH_B) {
3268 rtw89_rfk_parser(rtwdev, &rtw8852c_tssi_disable_defs_b_tbl);
3269 rtwdev->is_tssi_mode[RF_PATH_B] = false;
3270 }
3271 }
3272 }
3273
_tssi_get_cck_group(struct rtw89_dev * rtwdev,u8 ch)3274 static u32 _tssi_get_cck_group(struct rtw89_dev *rtwdev, u8 ch)
3275 {
3276 switch (ch) {
3277 case 1 ... 2:
3278 return 0;
3279 case 3 ... 5:
3280 return 1;
3281 case 6 ... 8:
3282 return 2;
3283 case 9 ... 11:
3284 return 3;
3285 case 12 ... 13:
3286 return 4;
3287 case 14:
3288 return 5;
3289 }
3290
3291 return 0;
3292 }
3293
3294 #define TSSI_EXTRA_GROUP_BIT (BIT(31))
3295 #define TSSI_EXTRA_GROUP(idx) (TSSI_EXTRA_GROUP_BIT | (idx))
3296 #define IS_TSSI_EXTRA_GROUP(group) ((group) & TSSI_EXTRA_GROUP_BIT)
3297 #define TSSI_EXTRA_GET_GROUP_IDX1(group) ((group) & ~TSSI_EXTRA_GROUP_BIT)
3298 #define TSSI_EXTRA_GET_GROUP_IDX2(group) (TSSI_EXTRA_GET_GROUP_IDX1(group) + 1)
3299
_tssi_get_ofdm_group(struct rtw89_dev * rtwdev,u8 ch)3300 static u32 _tssi_get_ofdm_group(struct rtw89_dev *rtwdev, u8 ch)
3301 {
3302 switch (ch) {
3303 case 1 ... 2:
3304 return 0;
3305 case 3 ... 5:
3306 return 1;
3307 case 6 ... 8:
3308 return 2;
3309 case 9 ... 11:
3310 return 3;
3311 case 12 ... 14:
3312 return 4;
3313 case 36 ... 40:
3314 return 5;
3315 case 41 ... 43:
3316 return TSSI_EXTRA_GROUP(5);
3317 case 44 ... 48:
3318 return 6;
3319 case 49 ... 51:
3320 return TSSI_EXTRA_GROUP(6);
3321 case 52 ... 56:
3322 return 7;
3323 case 57 ... 59:
3324 return TSSI_EXTRA_GROUP(7);
3325 case 60 ... 64:
3326 return 8;
3327 case 100 ... 104:
3328 return 9;
3329 case 105 ... 107:
3330 return TSSI_EXTRA_GROUP(9);
3331 case 108 ... 112:
3332 return 10;
3333 case 113 ... 115:
3334 return TSSI_EXTRA_GROUP(10);
3335 case 116 ... 120:
3336 return 11;
3337 case 121 ... 123:
3338 return TSSI_EXTRA_GROUP(11);
3339 case 124 ... 128:
3340 return 12;
3341 case 129 ... 131:
3342 return TSSI_EXTRA_GROUP(12);
3343 case 132 ... 136:
3344 return 13;
3345 case 137 ... 139:
3346 return TSSI_EXTRA_GROUP(13);
3347 case 140 ... 144:
3348 return 14;
3349 case 149 ... 153:
3350 return 15;
3351 case 154 ... 156:
3352 return TSSI_EXTRA_GROUP(15);
3353 case 157 ... 161:
3354 return 16;
3355 case 162 ... 164:
3356 return TSSI_EXTRA_GROUP(16);
3357 case 165 ... 169:
3358 return 17;
3359 case 170 ... 172:
3360 return TSSI_EXTRA_GROUP(17);
3361 case 173 ... 177:
3362 return 18;
3363 }
3364
3365 return 0;
3366 }
3367
_tssi_get_6g_ofdm_group(struct rtw89_dev * rtwdev,u8 ch)3368 static u32 _tssi_get_6g_ofdm_group(struct rtw89_dev *rtwdev, u8 ch)
3369 {
3370 switch (ch) {
3371 case 1 ... 5:
3372 return 0;
3373 case 6 ... 8:
3374 return TSSI_EXTRA_GROUP(0);
3375 case 9 ... 13:
3376 return 1;
3377 case 14 ... 16:
3378 return TSSI_EXTRA_GROUP(1);
3379 case 17 ... 21:
3380 return 2;
3381 case 22 ... 24:
3382 return TSSI_EXTRA_GROUP(2);
3383 case 25 ... 29:
3384 return 3;
3385 case 33 ... 37:
3386 return 4;
3387 case 38 ... 40:
3388 return TSSI_EXTRA_GROUP(4);
3389 case 41 ... 45:
3390 return 5;
3391 case 46 ... 48:
3392 return TSSI_EXTRA_GROUP(5);
3393 case 49 ... 53:
3394 return 6;
3395 case 54 ... 56:
3396 return TSSI_EXTRA_GROUP(6);
3397 case 57 ... 61:
3398 return 7;
3399 case 65 ... 69:
3400 return 8;
3401 case 70 ... 72:
3402 return TSSI_EXTRA_GROUP(8);
3403 case 73 ... 77:
3404 return 9;
3405 case 78 ... 80:
3406 return TSSI_EXTRA_GROUP(9);
3407 case 81 ... 85:
3408 return 10;
3409 case 86 ... 88:
3410 return TSSI_EXTRA_GROUP(10);
3411 case 89 ... 93:
3412 return 11;
3413 case 97 ... 101:
3414 return 12;
3415 case 102 ... 104:
3416 return TSSI_EXTRA_GROUP(12);
3417 case 105 ... 109:
3418 return 13;
3419 case 110 ... 112:
3420 return TSSI_EXTRA_GROUP(13);
3421 case 113 ... 117:
3422 return 14;
3423 case 118 ... 120:
3424 return TSSI_EXTRA_GROUP(14);
3425 case 121 ... 125:
3426 return 15;
3427 case 129 ... 133:
3428 return 16;
3429 case 134 ... 136:
3430 return TSSI_EXTRA_GROUP(16);
3431 case 137 ... 141:
3432 return 17;
3433 case 142 ... 144:
3434 return TSSI_EXTRA_GROUP(17);
3435 case 145 ... 149:
3436 return 18;
3437 case 150 ... 152:
3438 return TSSI_EXTRA_GROUP(18);
3439 case 153 ... 157:
3440 return 19;
3441 case 161 ... 165:
3442 return 20;
3443 case 166 ... 168:
3444 return TSSI_EXTRA_GROUP(20);
3445 case 169 ... 173:
3446 return 21;
3447 case 174 ... 176:
3448 return TSSI_EXTRA_GROUP(21);
3449 case 177 ... 181:
3450 return 22;
3451 case 182 ... 184:
3452 return TSSI_EXTRA_GROUP(22);
3453 case 185 ... 189:
3454 return 23;
3455 case 193 ... 197:
3456 return 24;
3457 case 198 ... 200:
3458 return TSSI_EXTRA_GROUP(24);
3459 case 201 ... 205:
3460 return 25;
3461 case 206 ... 208:
3462 return TSSI_EXTRA_GROUP(25);
3463 case 209 ... 213:
3464 return 26;
3465 case 214 ... 216:
3466 return TSSI_EXTRA_GROUP(26);
3467 case 217 ... 221:
3468 return 27;
3469 case 225 ... 229:
3470 return 28;
3471 case 230 ... 232:
3472 return TSSI_EXTRA_GROUP(28);
3473 case 233 ... 237:
3474 return 29;
3475 case 238 ... 240:
3476 return TSSI_EXTRA_GROUP(29);
3477 case 241 ... 245:
3478 return 30;
3479 case 246 ... 248:
3480 return TSSI_EXTRA_GROUP(30);
3481 case 249 ... 253:
3482 return 31;
3483 }
3484
3485 return 0;
3486 }
3487
_tssi_get_trim_group(struct rtw89_dev * rtwdev,u8 ch)3488 static u32 _tssi_get_trim_group(struct rtw89_dev *rtwdev, u8 ch)
3489 {
3490 switch (ch) {
3491 case 1 ... 8:
3492 return 0;
3493 case 9 ... 14:
3494 return 1;
3495 case 36 ... 48:
3496 return 2;
3497 case 49 ... 51:
3498 return TSSI_EXTRA_GROUP(2);
3499 case 52 ... 64:
3500 return 3;
3501 case 100 ... 112:
3502 return 4;
3503 case 113 ... 115:
3504 return TSSI_EXTRA_GROUP(4);
3505 case 116 ... 128:
3506 return 5;
3507 case 132 ... 144:
3508 return 6;
3509 case 149 ... 177:
3510 return 7;
3511 }
3512
3513 return 0;
3514 }
3515
_tssi_get_6g_trim_group(struct rtw89_dev * rtwdev,u8 ch)3516 static u32 _tssi_get_6g_trim_group(struct rtw89_dev *rtwdev, u8 ch)
3517 {
3518 switch (ch) {
3519 case 1 ... 13:
3520 return 0;
3521 case 14 ... 16:
3522 return TSSI_EXTRA_GROUP(0);
3523 case 17 ... 29:
3524 return 1;
3525 case 33 ... 45:
3526 return 2;
3527 case 46 ... 48:
3528 return TSSI_EXTRA_GROUP(2);
3529 case 49 ... 61:
3530 return 3;
3531 case 65 ... 77:
3532 return 4;
3533 case 78 ... 80:
3534 return TSSI_EXTRA_GROUP(4);
3535 case 81 ... 93:
3536 return 5;
3537 case 97 ... 109:
3538 return 6;
3539 case 110 ... 112:
3540 return TSSI_EXTRA_GROUP(6);
3541 case 113 ... 125:
3542 return 7;
3543 case 129 ... 141:
3544 return 8;
3545 case 142 ... 144:
3546 return TSSI_EXTRA_GROUP(8);
3547 case 145 ... 157:
3548 return 9;
3549 case 161 ... 173:
3550 return 10;
3551 case 174 ... 176:
3552 return TSSI_EXTRA_GROUP(10);
3553 case 177 ... 189:
3554 return 11;
3555 case 193 ... 205:
3556 return 12;
3557 case 206 ... 208:
3558 return TSSI_EXTRA_GROUP(12);
3559 case 209 ... 221:
3560 return 13;
3561 case 225 ... 237:
3562 return 14;
3563 case 238 ... 240:
3564 return TSSI_EXTRA_GROUP(14);
3565 case 241 ... 253:
3566 return 15;
3567 }
3568
3569 return 0;
3570 }
3571
_tssi_get_ofdm_de(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path)3572 static s8 _tssi_get_ofdm_de(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
3573 enum rtw89_rf_path path)
3574 {
3575 struct rtw89_tssi_info *tssi_info = &rtwdev->tssi;
3576 const struct rtw89_chan *chan = rtw89_chan_get(rtwdev, RTW89_SUB_ENTITY_0);
3577 enum rtw89_band band = chan->band_type;
3578 u8 ch = chan->channel;
3579 u32 gidx, gidx_1st, gidx_2nd;
3580 s8 de_1st;
3581 s8 de_2nd;
3582 s8 val;
3583
3584 if (band == RTW89_BAND_2G || band == RTW89_BAND_5G) {
3585 gidx = _tssi_get_ofdm_group(rtwdev, ch);
3586
3587 rtw89_debug(rtwdev, RTW89_DBG_TSSI,
3588 "[TSSI][TRIM]: path=%d mcs group_idx=0x%x\n",
3589 path, gidx);
3590
3591 if (IS_TSSI_EXTRA_GROUP(gidx)) {
3592 gidx_1st = TSSI_EXTRA_GET_GROUP_IDX1(gidx);
3593 gidx_2nd = TSSI_EXTRA_GET_GROUP_IDX2(gidx);
3594 de_1st = tssi_info->tssi_mcs[path][gidx_1st];
3595 de_2nd = tssi_info->tssi_mcs[path][gidx_2nd];
3596 val = (de_1st + de_2nd) / 2;
3597
3598 rtw89_debug(rtwdev, RTW89_DBG_TSSI,
3599 "[TSSI][TRIM]: path=%d mcs de=%d 1st=%d 2nd=%d\n",
3600 path, val, de_1st, de_2nd);
3601 } else {
3602 val = tssi_info->tssi_mcs[path][gidx];
3603
3604 rtw89_debug(rtwdev, RTW89_DBG_TSSI,
3605 "[TSSI][TRIM]: path=%d mcs de=%d\n", path, val);
3606 }
3607 } else {
3608 gidx = _tssi_get_6g_ofdm_group(rtwdev, ch);
3609
3610 rtw89_debug(rtwdev, RTW89_DBG_TSSI,
3611 "[TSSI][TRIM]: path=%d mcs group_idx=0x%x\n",
3612 path, gidx);
3613
3614 if (IS_TSSI_EXTRA_GROUP(gidx)) {
3615 gidx_1st = TSSI_EXTRA_GET_GROUP_IDX1(gidx);
3616 gidx_2nd = TSSI_EXTRA_GET_GROUP_IDX2(gidx);
3617 de_1st = tssi_info->tssi_6g_mcs[path][gidx_1st];
3618 de_2nd = tssi_info->tssi_6g_mcs[path][gidx_2nd];
3619 val = (de_1st + de_2nd) / 2;
3620
3621 rtw89_debug(rtwdev, RTW89_DBG_TSSI,
3622 "[TSSI][TRIM]: path=%d mcs de=%d 1st=%d 2nd=%d\n",
3623 path, val, de_1st, de_2nd);
3624 } else {
3625 val = tssi_info->tssi_6g_mcs[path][gidx];
3626
3627 rtw89_debug(rtwdev, RTW89_DBG_TSSI,
3628 "[TSSI][TRIM]: path=%d mcs de=%d\n", path, val);
3629 }
3630 }
3631
3632 return val;
3633 }
3634
_tssi_get_ofdm_trim_de(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_rf_path path)3635 static s8 _tssi_get_ofdm_trim_de(struct rtw89_dev *rtwdev,
3636 enum rtw89_phy_idx phy,
3637 enum rtw89_rf_path path)
3638 {
3639 struct rtw89_tssi_info *tssi_info = &rtwdev->tssi;
3640 const struct rtw89_chan *chan = rtw89_chan_get(rtwdev, RTW89_SUB_ENTITY_0);
3641 enum rtw89_band band = chan->band_type;
3642 u8 ch = chan->channel;
3643 u32 tgidx, tgidx_1st, tgidx_2nd;
3644 s8 tde_1st = 0;
3645 s8 tde_2nd = 0;
3646 s8 val;
3647
3648 if (band == RTW89_BAND_2G || band == RTW89_BAND_5G) {
3649 tgidx = _tssi_get_trim_group(rtwdev, ch);
3650
3651 rtw89_debug(rtwdev, RTW89_DBG_TSSI,
3652 "[TSSI][TRIM]: path=%d mcs trim_group_idx=0x%x\n",
3653 path, tgidx);
3654
3655 if (IS_TSSI_EXTRA_GROUP(tgidx)) {
3656 tgidx_1st = TSSI_EXTRA_GET_GROUP_IDX1(tgidx);
3657 tgidx_2nd = TSSI_EXTRA_GET_GROUP_IDX2(tgidx);
3658 tde_1st = tssi_info->tssi_trim[path][tgidx_1st];
3659 tde_2nd = tssi_info->tssi_trim[path][tgidx_2nd];
3660 val = (tde_1st + tde_2nd) / 2;
3661
3662 rtw89_debug(rtwdev, RTW89_DBG_TSSI,
3663 "[TSSI][TRIM]: path=%d mcs trim_de=%d 1st=%d 2nd=%d\n",
3664 path, val, tde_1st, tde_2nd);
3665 } else {
3666 val = tssi_info->tssi_trim[path][tgidx];
3667
3668 rtw89_debug(rtwdev, RTW89_DBG_TSSI,
3669 "[TSSI][TRIM]: path=%d mcs trim_de=%d\n",
3670 path, val);
3671 }
3672 } else {
3673 tgidx = _tssi_get_6g_trim_group(rtwdev, ch);
3674
3675 rtw89_debug(rtwdev, RTW89_DBG_TSSI,
3676 "[TSSI][TRIM]: path=%d mcs trim_group_idx=0x%x\n",
3677 path, tgidx);
3678
3679 if (IS_TSSI_EXTRA_GROUP(tgidx)) {
3680 tgidx_1st = TSSI_EXTRA_GET_GROUP_IDX1(tgidx);
3681 tgidx_2nd = TSSI_EXTRA_GET_GROUP_IDX2(tgidx);
3682 tde_1st = tssi_info->tssi_trim_6g[path][tgidx_1st];
3683 tde_2nd = tssi_info->tssi_trim_6g[path][tgidx_2nd];
3684 val = (tde_1st + tde_2nd) / 2;
3685
3686 rtw89_debug(rtwdev, RTW89_DBG_TSSI,
3687 "[TSSI][TRIM]: path=%d mcs trim_de=%d 1st=%d 2nd=%d\n",
3688 path, val, tde_1st, tde_2nd);
3689 } else {
3690 val = tssi_info->tssi_trim_6g[path][tgidx];
3691
3692 rtw89_debug(rtwdev, RTW89_DBG_TSSI,
3693 "[TSSI][TRIM]: path=%d mcs trim_de=%d\n",
3694 path, val);
3695 }
3696 }
3697
3698 return val;
3699 }
3700
_tssi_set_efuse_to_de(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy)3701 static void _tssi_set_efuse_to_de(struct rtw89_dev *rtwdev,
3702 enum rtw89_phy_idx phy)
3703 {
3704 struct rtw89_tssi_info *tssi_info = &rtwdev->tssi;
3705 const struct rtw89_chan *chan = rtw89_chan_get(rtwdev, RTW89_SUB_ENTITY_0);
3706 u8 ch = chan->channel;
3707 u8 gidx;
3708 s8 ofdm_de;
3709 s8 trim_de;
3710 s32 val;
3711 u32 i, path = RF_PATH_A, path_max = RF_PATH_NUM_8852C;
3712
3713 rtw89_debug(rtwdev, RTW89_DBG_TSSI, "[TSSI][TRIM]: phy=%d ch=%d\n",
3714 phy, ch);
3715
3716 if (rtwdev->dbcc_en) {
3717 if (phy == RTW89_PHY_0) {
3718 path = RF_PATH_A;
3719 path_max = RF_PATH_B;
3720 } else if (phy == RTW89_PHY_1) {
3721 path = RF_PATH_B;
3722 path_max = RF_PATH_NUM_8852C;
3723 }
3724 }
3725
3726 for (i = path; i < path_max; i++) {
3727 gidx = _tssi_get_cck_group(rtwdev, ch);
3728 trim_de = _tssi_get_ofdm_trim_de(rtwdev, phy, i);
3729 val = tssi_info->tssi_cck[i][gidx] + trim_de;
3730
3731 rtw89_debug(rtwdev, RTW89_DBG_TSSI,
3732 "[TSSI][TRIM]: path=%d cck[%d]=0x%x trim=0x%x\n",
3733 i, gidx, tssi_info->tssi_cck[i][gidx], trim_de);
3734
3735 rtw89_phy_write32_mask(rtwdev, _tssi_de_cck_long[i], _TSSI_DE_MASK, val);
3736 rtw89_phy_write32_mask(rtwdev, _tssi_de_cck_short[i], _TSSI_DE_MASK, val);
3737
3738 rtw89_debug(rtwdev, RTW89_DBG_TSSI,
3739 "[TSSI] Set TSSI CCK DE 0x%x[21:12]=0x%x\n",
3740 _tssi_de_cck_long[i],
3741 rtw89_phy_read32_mask(rtwdev, _tssi_de_cck_long[i],
3742 _TSSI_DE_MASK));
3743
3744 ofdm_de = _tssi_get_ofdm_de(rtwdev, phy, i);
3745 trim_de = _tssi_get_ofdm_trim_de(rtwdev, phy, i);
3746 val = ofdm_de + trim_de;
3747
3748 rtw89_debug(rtwdev, RTW89_DBG_TSSI,
3749 "[TSSI][TRIM]: path=%d mcs=0x%x trim=0x%x\n",
3750 i, ofdm_de, trim_de);
3751
3752 rtw89_phy_write32_mask(rtwdev, _tssi_de_mcs_20m[i], _TSSI_DE_MASK, val);
3753 rtw89_phy_write32_mask(rtwdev, _tssi_de_mcs_40m[i], _TSSI_DE_MASK, val);
3754 rtw89_phy_write32_mask(rtwdev, _tssi_de_mcs_80m[i], _TSSI_DE_MASK, val);
3755 rtw89_phy_write32_mask(rtwdev, _tssi_de_mcs_80m_80m[i], _TSSI_DE_MASK, val);
3756 rtw89_phy_write32_mask(rtwdev, _tssi_de_mcs_5m[i], _TSSI_DE_MASK, val);
3757 rtw89_phy_write32_mask(rtwdev, _tssi_de_mcs_10m[i], _TSSI_DE_MASK, val);
3758
3759 rtw89_debug(rtwdev, RTW89_DBG_TSSI,
3760 "[TSSI] Set TSSI MCS DE 0x%x[21:12]=0x%x\n",
3761 _tssi_de_mcs_20m[i],
3762 rtw89_phy_read32_mask(rtwdev, _tssi_de_mcs_20m[i],
3763 _TSSI_DE_MASK));
3764 }
3765 }
3766
rtw8852c_tssi_cont_en(struct rtw89_dev * rtwdev,bool en,enum rtw89_rf_path path)3767 static void rtw8852c_tssi_cont_en(struct rtw89_dev *rtwdev, bool en,
3768 enum rtw89_rf_path path)
3769 {
3770 static const u32 tssi_trk[2] = {0x5818, 0x7818};
3771 static const u32 tssi_en[2] = {0x5820, 0x7820};
3772
3773 if (en) {
3774 rtw89_phy_write32_mask(rtwdev, tssi_trk[path], BIT(30), 0x0);
3775 rtw89_phy_write32_mask(rtwdev, tssi_en[path], BIT(31), 0x0);
3776 if (rtwdev->dbcc_en && path == RF_PATH_B)
3777 _tssi_set_efuse_to_de(rtwdev, RTW89_PHY_1);
3778 else
3779 _tssi_set_efuse_to_de(rtwdev, RTW89_PHY_0);
3780 } else {
3781 rtw89_phy_write32_mask(rtwdev, tssi_trk[path], BIT(30), 0x1);
3782 rtw89_phy_write32_mask(rtwdev, tssi_en[path], BIT(31), 0x1);
3783 }
3784 }
3785
rtw8852c_tssi_cont_en_phyidx(struct rtw89_dev * rtwdev,bool en,u8 phy_idx)3786 void rtw8852c_tssi_cont_en_phyidx(struct rtw89_dev *rtwdev, bool en, u8 phy_idx)
3787 {
3788 if (!rtwdev->dbcc_en) {
3789 rtw8852c_tssi_cont_en(rtwdev, en, RF_PATH_A);
3790 rtw8852c_tssi_cont_en(rtwdev, en, RF_PATH_B);
3791 } else {
3792 if (phy_idx == RTW89_PHY_0)
3793 rtw8852c_tssi_cont_en(rtwdev, en, RF_PATH_A);
3794 else
3795 rtw8852c_tssi_cont_en(rtwdev, en, RF_PATH_B);
3796 }
3797 }
3798
_bw_setting(struct rtw89_dev * rtwdev,enum rtw89_rf_path path,enum rtw89_bandwidth bw,bool is_dav)3799 static void _bw_setting(struct rtw89_dev *rtwdev, enum rtw89_rf_path path,
3800 enum rtw89_bandwidth bw, bool is_dav)
3801 {
3802 u32 rf_reg18;
3803 u32 reg_reg18_addr;
3804
3805 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[RFK]===>%s\n", __func__);
3806 if (is_dav)
3807 reg_reg18_addr = RR_CFGCH;
3808 else
3809 reg_reg18_addr = RR_CFGCH_V1;
3810
3811 rf_reg18 = rtw89_read_rf(rtwdev, path, reg_reg18_addr, RFREG_MASK);
3812 rf_reg18 &= ~RR_CFGCH_BW;
3813
3814 switch (bw) {
3815 case RTW89_CHANNEL_WIDTH_5:
3816 case RTW89_CHANNEL_WIDTH_10:
3817 case RTW89_CHANNEL_WIDTH_20:
3818 rf_reg18 |= FIELD_PREP(RR_CFGCH_BW, CFGCH_BW_20M);
3819 rtw89_phy_write32_mask(rtwdev, R_P0_CFCH_BW0 | (path << 8), B_P0_CFCH_BW0, 0x3);
3820 rtw89_phy_write32_mask(rtwdev, R_P0_CFCH_BW1 | (path << 8), B_P0_CFCH_BW1, 0xf);
3821 break;
3822 case RTW89_CHANNEL_WIDTH_40:
3823 rf_reg18 |= FIELD_PREP(RR_CFGCH_BW, CFGCH_BW_40M);
3824 rtw89_phy_write32_mask(rtwdev, R_P0_CFCH_BW0 | (path << 8), B_P0_CFCH_BW0, 0x3);
3825 rtw89_phy_write32_mask(rtwdev, R_P0_CFCH_BW1 | (path << 8), B_P0_CFCH_BW1, 0xf);
3826 break;
3827 case RTW89_CHANNEL_WIDTH_80:
3828 rf_reg18 |= FIELD_PREP(RR_CFGCH_BW, CFGCH_BW_80M);
3829 rtw89_phy_write32_mask(rtwdev, R_P0_CFCH_BW0 | (path << 8), B_P0_CFCH_BW0, 0x2);
3830 rtw89_phy_write32_mask(rtwdev, R_P0_CFCH_BW1 | (path << 8), B_P0_CFCH_BW1, 0xd);
3831 break;
3832 case RTW89_CHANNEL_WIDTH_160:
3833 rf_reg18 |= FIELD_PREP(RR_CFGCH_BW, CFGCH_BW_160M);
3834 rtw89_phy_write32_mask(rtwdev, R_P0_CFCH_BW0 | (path << 8), B_P0_CFCH_BW0, 0x1);
3835 rtw89_phy_write32_mask(rtwdev, R_P0_CFCH_BW1 | (path << 8), B_P0_CFCH_BW1, 0xb);
3836 break;
3837 default:
3838 break;
3839 }
3840
3841 rtw89_write_rf(rtwdev, path, reg_reg18_addr, RFREG_MASK, rf_reg18);
3842 }
3843
_ctrl_bw(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_bandwidth bw)3844 static void _ctrl_bw(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
3845 enum rtw89_bandwidth bw)
3846 {
3847 bool is_dav;
3848 u8 kpath, path;
3849 u32 tmp = 0;
3850
3851 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[RFK]===>%s\n", __func__);
3852 kpath = _kpath(rtwdev, phy);
3853
3854 for (path = 0; path < 2; path++) {
3855 if (!(kpath & BIT(path)))
3856 continue;
3857
3858 is_dav = true;
3859 _bw_setting(rtwdev, path, bw, is_dav);
3860 is_dav = false;
3861 _bw_setting(rtwdev, path, bw, is_dav);
3862 if (rtwdev->dbcc_en)
3863 continue;
3864
3865 if (path == RF_PATH_B && rtwdev->hal.cv == CHIP_CAV) {
3866 rtw89_write_rf(rtwdev, RF_PATH_B, RR_RSV1, RR_RSV1_RST, 0x0);
3867 tmp = rtw89_read_rf(rtwdev, RF_PATH_A, RR_CFGCH, RFREG_MASK);
3868 rtw89_write_rf(rtwdev, RF_PATH_B, RR_APK, RR_APK_MOD, 0x3);
3869 rtw89_write_rf(rtwdev, RF_PATH_B, RR_CFGCH, RFREG_MASK, tmp);
3870 fsleep(100);
3871 rtw89_write_rf(rtwdev, RF_PATH_B, RR_RSV1, RR_RSV1_RST, 0x1);
3872 }
3873 }
3874 }
3875
_ch_setting(struct rtw89_dev * rtwdev,enum rtw89_rf_path path,u8 central_ch,enum rtw89_band band,bool is_dav)3876 static void _ch_setting(struct rtw89_dev *rtwdev, enum rtw89_rf_path path,
3877 u8 central_ch, enum rtw89_band band, bool is_dav)
3878 {
3879 u32 rf_reg18;
3880 u32 reg_reg18_addr;
3881
3882 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[RFK]===>%s\n", __func__);
3883 if (is_dav)
3884 reg_reg18_addr = 0x18;
3885 else
3886 reg_reg18_addr = 0x10018;
3887
3888 rf_reg18 = rtw89_read_rf(rtwdev, path, reg_reg18_addr, RFREG_MASK);
3889 rf_reg18 &= ~(RR_CFGCH_BAND1 | RR_CFGCH_BAND0 | RR_CFGCH_CH);
3890 rf_reg18 |= FIELD_PREP(RR_CFGCH_CH, central_ch);
3891
3892 switch (band) {
3893 case RTW89_BAND_2G:
3894 rf_reg18 |= FIELD_PREP(RR_CFGCH_BAND1, CFGCH_BAND1_2G);
3895 rf_reg18 |= FIELD_PREP(RR_CFGCH_BAND0, CFGCH_BAND0_2G);
3896 break;
3897 case RTW89_BAND_5G:
3898 rf_reg18 |= FIELD_PREP(RR_CFGCH_BAND1, CFGCH_BAND1_5G);
3899 rf_reg18 |= FIELD_PREP(RR_CFGCH_BAND0, CFGCH_BAND0_5G);
3900 break;
3901 case RTW89_BAND_6G:
3902 rf_reg18 |= FIELD_PREP(RR_CFGCH_BAND1, CFGCH_BAND1_6G);
3903 rf_reg18 |= FIELD_PREP(RR_CFGCH_BAND0, CFGCH_BAND0_6G);
3904 break;
3905 default:
3906 break;
3907 }
3908 rtw89_write_rf(rtwdev, path, reg_reg18_addr, RFREG_MASK, rf_reg18);
3909 fsleep(100);
3910 }
3911
_ctrl_ch(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,u8 central_ch,enum rtw89_band band)3912 static void _ctrl_ch(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
3913 u8 central_ch, enum rtw89_band band)
3914 {
3915 u8 kpath, path;
3916
3917 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[RFK]===>%s\n", __func__);
3918 if (band != RTW89_BAND_6G) {
3919 if ((central_ch > 14 && central_ch < 36) ||
3920 (central_ch > 64 && central_ch < 100) ||
3921 (central_ch > 144 && central_ch < 149) || central_ch > 177)
3922 return;
3923 } else {
3924 if (central_ch > 253 || central_ch == 2)
3925 return;
3926 }
3927
3928 kpath = _kpath(rtwdev, phy);
3929
3930 for (path = 0; path < 2; path++) {
3931 if (kpath & BIT(path)) {
3932 _ch_setting(rtwdev, path, central_ch, band, true);
3933 _ch_setting(rtwdev, path, central_ch, band, false);
3934 }
3935 }
3936 }
3937
_rxbb_bw(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,enum rtw89_bandwidth bw)3938 static void _rxbb_bw(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
3939 enum rtw89_bandwidth bw)
3940 {
3941 u8 kpath;
3942 u8 path;
3943 u32 val;
3944
3945 kpath = _kpath(rtwdev, phy);
3946 for (path = 0; path < 2; path++) {
3947 if (!(kpath & BIT(path)))
3948 continue;
3949
3950 rtw89_write_rf(rtwdev, path, RR_LUTWE2, RR_LUTWE2_RTXBW, 0x1);
3951 rtw89_write_rf(rtwdev, path, RR_LUTWA, RR_LUTWA_M2, 0xa);
3952 switch (bw) {
3953 case RTW89_CHANNEL_WIDTH_20:
3954 val = 0x1b;
3955 break;
3956 case RTW89_CHANNEL_WIDTH_40:
3957 val = 0x13;
3958 break;
3959 case RTW89_CHANNEL_WIDTH_80:
3960 val = 0xb;
3961 break;
3962 case RTW89_CHANNEL_WIDTH_160:
3963 default:
3964 val = 0x3;
3965 break;
3966 }
3967 rtw89_write_rf(rtwdev, path, RR_LUTWD0, RR_LUTWD0_LB, val);
3968 rtw89_write_rf(rtwdev, path, RR_LUTWE2, RR_LUTWE2_RTXBW, 0x0);
3969 }
3970 }
3971
_lck_keep_thermal(struct rtw89_dev * rtwdev)3972 static void _lck_keep_thermal(struct rtw89_dev *rtwdev)
3973 {
3974 struct rtw89_lck_info *lck = &rtwdev->lck;
3975 int path;
3976
3977 for (path = 0; path < rtwdev->chip->rf_path_num; path++) {
3978 lck->thermal[path] =
3979 ewma_thermal_read(&rtwdev->phystat.avg_thermal[path]);
3980 rtw89_debug(rtwdev, RTW89_DBG_RFK_TRACK,
3981 "[LCK] path=%d thermal=0x%x", path, lck->thermal[path]);
3982 }
3983 }
3984
_lck(struct rtw89_dev * rtwdev)3985 static void _lck(struct rtw89_dev *rtwdev)
3986 {
3987 u32 tmp18[2];
3988 int path = rtwdev->dbcc_en ? 2 : 1;
3989 int i;
3990
3991 rtw89_debug(rtwdev, RTW89_DBG_RFK_TRACK, "[LCK] DO LCK\n");
3992
3993 tmp18[0] = rtw89_read_rf(rtwdev, RF_PATH_A, RR_CFGCH, RFREG_MASK);
3994 tmp18[1] = rtw89_read_rf(rtwdev, RF_PATH_B, RR_CFGCH, RFREG_MASK);
3995
3996 for (i = 0; i < path; i++) {
3997 rtw89_write_rf(rtwdev, i, RR_LCK_TRG, RR_LCK_TRGSEL, 0x1);
3998 rtw89_write_rf(rtwdev, i, RR_CFGCH, RFREG_MASK, tmp18[i]);
3999 rtw89_write_rf(rtwdev, i, RR_LCK_TRG, RR_LCK_TRGSEL, 0x0);
4000 }
4001
4002 _lck_keep_thermal(rtwdev);
4003 }
4004
4005 #define RTW8852C_LCK_TH 8
4006
rtw8852c_lck_track(struct rtw89_dev * rtwdev)4007 void rtw8852c_lck_track(struct rtw89_dev *rtwdev)
4008 {
4009 struct rtw89_lck_info *lck = &rtwdev->lck;
4010 u8 cur_thermal;
4011 int delta;
4012 int path;
4013
4014 for (path = 0; path < rtwdev->chip->rf_path_num; path++) {
4015 cur_thermal =
4016 ewma_thermal_read(&rtwdev->phystat.avg_thermal[path]);
4017 delta = abs((int)cur_thermal - lck->thermal[path]);
4018
4019 rtw89_debug(rtwdev, RTW89_DBG_RFK_TRACK,
4020 "[LCK] path=%d current thermal=0x%x delta=0x%x\n",
4021 path, cur_thermal, delta);
4022
4023 if (delta >= RTW8852C_LCK_TH) {
4024 _lck(rtwdev);
4025 return;
4026 }
4027 }
4028 }
4029
rtw8852c_lck_init(struct rtw89_dev * rtwdev)4030 void rtw8852c_lck_init(struct rtw89_dev *rtwdev)
4031 {
4032 _lck_keep_thermal(rtwdev);
4033 }
4034
4035 static
rtw8852c_ctrl_bw_ch(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,u8 central_ch,enum rtw89_band band,enum rtw89_bandwidth bw)4036 void rtw8852c_ctrl_bw_ch(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
4037 u8 central_ch, enum rtw89_band band,
4038 enum rtw89_bandwidth bw)
4039 {
4040 _ctrl_ch(rtwdev, phy, central_ch, band);
4041 _ctrl_bw(rtwdev, phy, bw);
4042 _rxbb_bw(rtwdev, phy, bw);
4043 }
4044
rtw8852c_set_channel_rf(struct rtw89_dev * rtwdev,const struct rtw89_chan * chan,enum rtw89_phy_idx phy_idx)4045 void rtw8852c_set_channel_rf(struct rtw89_dev *rtwdev,
4046 const struct rtw89_chan *chan,
4047 enum rtw89_phy_idx phy_idx)
4048 {
4049 rtw8852c_ctrl_bw_ch(rtwdev, phy_idx, chan->channel,
4050 chan->band_type,
4051 chan->band_width);
4052 }
4053
rtw8852c_mcc_get_ch_info(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy_idx)4054 void rtw8852c_mcc_get_ch_info(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy_idx)
4055 {
4056 const struct rtw89_chan *chan = rtw89_chan_get(rtwdev, RTW89_SUB_ENTITY_0);
4057 struct rtw89_rfk_mcc_info *rfk_mcc = &rtwdev->rfk_mcc;
4058 u8 idx = rfk_mcc->table_idx;
4059 int i;
4060
4061 for (i = 0; i < RTW89_IQK_CHS_NR; i++) {
4062 if (rfk_mcc->ch[idx] == 0)
4063 break;
4064 if (++idx >= RTW89_IQK_CHS_NR)
4065 idx = 0;
4066 }
4067
4068 rfk_mcc->table_idx = idx;
4069 rfk_mcc->ch[idx] = chan->channel;
4070 rfk_mcc->band[idx] = chan->band_type;
4071 }
4072
rtw8852c_rck(struct rtw89_dev * rtwdev)4073 void rtw8852c_rck(struct rtw89_dev *rtwdev)
4074 {
4075 u8 path;
4076
4077 for (path = 0; path < 2; path++)
4078 _rck(rtwdev, path);
4079 }
4080
rtw8852c_dack(struct rtw89_dev * rtwdev)4081 void rtw8852c_dack(struct rtw89_dev *rtwdev)
4082 {
4083 u8 phy_map = rtw89_btc_phymap(rtwdev, RTW89_PHY_0, 0);
4084
4085 rtw89_btc_ntfy_wl_rfk(rtwdev, phy_map, BTC_WRFKT_DACK, BTC_WRFK_START);
4086 _dac_cal(rtwdev, false);
4087 rtw89_btc_ntfy_wl_rfk(rtwdev, phy_map, BTC_WRFKT_DACK, BTC_WRFK_STOP);
4088 }
4089
rtw8852c_iqk(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy_idx)4090 void rtw8852c_iqk(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy_idx)
4091 {
4092 u32 tx_en;
4093 u8 phy_map = rtw89_btc_phymap(rtwdev, phy_idx, 0);
4094
4095 rtw89_btc_ntfy_wl_rfk(rtwdev, phy_map, BTC_WRFKT_IQK, BTC_WRFK_START);
4096 rtw89_chip_stop_sch_tx(rtwdev, phy_idx, &tx_en, RTW89_SCH_TX_SEL_ALL);
4097 _wait_rx_mode(rtwdev, _kpath(rtwdev, phy_idx));
4098
4099 _iqk_init(rtwdev);
4100 _iqk(rtwdev, phy_idx, false);
4101
4102 rtw89_chip_resume_sch_tx(rtwdev, phy_idx, tx_en);
4103 rtw89_btc_ntfy_wl_rfk(rtwdev, phy_map, BTC_WRFKT_IQK, BTC_WRFK_STOP);
4104 }
4105
4106 #define RXDCK_VER_8852C 0xe
4107
_rx_dck(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,bool is_afe,u8 retry_limit)4108 static void _rx_dck(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy,
4109 bool is_afe, u8 retry_limit)
4110 {
4111 struct rtw89_rx_dck_info *rx_dck = &rtwdev->rx_dck;
4112 u8 path, kpath;
4113 u32 rf_reg5;
4114 bool is_fail;
4115 u8 rek_cnt;
4116
4117 kpath = _kpath(rtwdev, phy);
4118 rtw89_debug(rtwdev, RTW89_DBG_RFK,
4119 "[RX_DCK] ****** RXDCK Start (Ver: 0x%x, Cv: %d) ******\n",
4120 RXDCK_VER_8852C, rtwdev->hal.cv);
4121
4122 for (path = 0; path < 2; path++) {
4123 rf_reg5 = rtw89_read_rf(rtwdev, path, RR_RSV1, RFREG_MASK);
4124 if (!(kpath & BIT(path)))
4125 continue;
4126
4127 if (rtwdev->is_tssi_mode[path])
4128 rtw89_phy_write32_mask(rtwdev, R_P0_TSSI_TRK + (path << 13),
4129 B_P0_TSSI_TRK_EN, 0x1);
4130 rtw89_write_rf(rtwdev, path, RR_RSV1, RR_RSV1_RST, 0x0);
4131 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_MASK, RR_MOD_V_RX);
4132 rtw89_write_rf(rtwdev, path, RR_MOD, RR_MOD_LO_SEL, rtwdev->dbcc_en);
4133
4134 for (rek_cnt = 0; rek_cnt < retry_limit; rek_cnt++) {
4135 _set_rx_dck(rtwdev, phy, path, is_afe);
4136
4137 /* To reduce IO of dck_rek_check(), the last try is seen
4138 * as failure always, and then do recovery procedure.
4139 */
4140 if (rek_cnt == retry_limit - 1) {
4141 _rx_dck_recover(rtwdev, path);
4142 break;
4143 }
4144
4145 is_fail = _rx_dck_rek_check(rtwdev, path);
4146 if (!is_fail)
4147 break;
4148 }
4149
4150 rtw89_debug(rtwdev, RTW89_DBG_RFK, "[RX_DCK] rek_cnt[%d]=%d",
4151 path, rek_cnt);
4152
4153 rx_dck->thermal[path] = ewma_thermal_read(&rtwdev->phystat.avg_thermal[path]);
4154 rtw89_write_rf(rtwdev, path, RR_RSV1, RFREG_MASK, rf_reg5);
4155
4156 if (rtwdev->is_tssi_mode[path])
4157 rtw89_phy_write32_mask(rtwdev, R_P0_TSSI_TRK + (path << 13),
4158 B_P0_TSSI_TRK_EN, 0x0);
4159 }
4160 }
4161
rtw8852c_rx_dck(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,bool is_afe)4162 void rtw8852c_rx_dck(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy, bool is_afe)
4163 {
4164 _rx_dck(rtwdev, phy, is_afe, 1);
4165 }
4166
4167 #define RTW8852C_RX_DCK_TH 12
4168
rtw8852c_rx_dck_track(struct rtw89_dev * rtwdev)4169 void rtw8852c_rx_dck_track(struct rtw89_dev *rtwdev)
4170 {
4171 const struct rtw89_chan *chan = rtw89_chan_get(rtwdev, RTW89_SUB_ENTITY_0);
4172 struct rtw89_rx_dck_info *rx_dck = &rtwdev->rx_dck;
4173 enum rtw89_phy_idx phy_idx = RTW89_PHY_0;
4174 u8 phy_map = rtw89_btc_phymap(rtwdev, phy_idx, 0);
4175 u8 dck_channel;
4176 u8 cur_thermal;
4177 u32 tx_en;
4178 int delta;
4179 int path;
4180
4181 if (chan->band_type == RTW89_BAND_2G)
4182 return;
4183
4184 if (rtwdev->scanning)
4185 return;
4186
4187 for (path = 0; path < RF_PATH_NUM_8852C; path++) {
4188 cur_thermal =
4189 ewma_thermal_read(&rtwdev->phystat.avg_thermal[path]);
4190 delta = abs((int)cur_thermal - rx_dck->thermal[path]);
4191
4192 rtw89_debug(rtwdev, RTW89_DBG_RFK_TRACK,
4193 "[RX_DCK] path=%d current thermal=0x%x delta=0x%x\n",
4194 path, cur_thermal, delta);
4195
4196 if (delta >= RTW8852C_RX_DCK_TH)
4197 goto trigger_rx_dck;
4198 }
4199
4200 return;
4201
4202 trigger_rx_dck:
4203 rtw89_btc_ntfy_wl_rfk(rtwdev, phy_map, BTC_WRFKT_RXDCK, BTC_WRFK_START);
4204 rtw89_chip_stop_sch_tx(rtwdev, phy_idx, &tx_en, RTW89_SCH_TX_SEL_ALL);
4205
4206 for (path = 0; path < RF_PATH_NUM_8852C; path++) {
4207 dck_channel = _rx_dck_channel_calc(rtwdev, chan);
4208 _ctrl_ch(rtwdev, RTW89_PHY_0, dck_channel, chan->band_type);
4209 }
4210
4211 _rx_dck(rtwdev, RTW89_PHY_0, false, 20);
4212
4213 for (path = 0; path < RF_PATH_NUM_8852C; path++)
4214 _ctrl_ch(rtwdev, RTW89_PHY_0, chan->channel, chan->band_type);
4215
4216 rtw89_chip_resume_sch_tx(rtwdev, phy_idx, tx_en);
4217 rtw89_btc_ntfy_wl_rfk(rtwdev, phy_map, BTC_WRFKT_RXDCK, BTC_WRFK_STOP);
4218 }
4219
rtw8852c_dpk(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy_idx)4220 void rtw8852c_dpk(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy_idx)
4221 {
4222 u32 tx_en;
4223 u8 phy_map = rtw89_btc_phymap(rtwdev, phy_idx, 0);
4224
4225 rtw89_btc_ntfy_wl_rfk(rtwdev, phy_map, BTC_WRFKT_DPK, BTC_WRFK_START);
4226 rtw89_chip_stop_sch_tx(rtwdev, phy_idx, &tx_en, RTW89_SCH_TX_SEL_ALL);
4227 _wait_rx_mode(rtwdev, _kpath(rtwdev, phy_idx));
4228
4229 rtwdev->dpk.is_dpk_enable = true;
4230 rtwdev->dpk.is_dpk_reload_en = false;
4231 _dpk(rtwdev, phy_idx, false);
4232
4233 rtw89_chip_resume_sch_tx(rtwdev, phy_idx, tx_en);
4234 rtw89_btc_ntfy_wl_rfk(rtwdev, phy_map, BTC_WRFKT_DPK, BTC_WRFK_STOP);
4235 }
4236
rtw8852c_dpk_track(struct rtw89_dev * rtwdev)4237 void rtw8852c_dpk_track(struct rtw89_dev *rtwdev)
4238 {
4239 _dpk_track(rtwdev);
4240 }
4241
rtw8852c_tssi(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy)4242 void rtw8852c_tssi(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy)
4243 {
4244 u32 i, path = RF_PATH_A, path_max = RF_PATH_NUM_8852C;
4245
4246 rtw89_debug(rtwdev, RTW89_DBG_TSSI, "[TSSI] %s: phy=%d\n", __func__, phy);
4247
4248 if (rtwdev->dbcc_en) {
4249 if (phy == RTW89_PHY_0) {
4250 path = RF_PATH_A;
4251 path_max = RF_PATH_B;
4252 } else if (phy == RTW89_PHY_1) {
4253 path = RF_PATH_B;
4254 path_max = RF_PATH_NUM_8852C;
4255 }
4256 }
4257
4258 _tssi_disable(rtwdev, phy);
4259
4260 for (i = path; i < path_max; i++) {
4261 _tssi_set_sys(rtwdev, phy, i);
4262 _tssi_ini_txpwr_ctrl_bb(rtwdev, phy, i);
4263 _tssi_ini_txpwr_ctrl_bb_he_tb(rtwdev, phy, i);
4264 _tssi_set_dck(rtwdev, phy, i);
4265 _tssi_set_bbgain_split(rtwdev, phy, i);
4266 _tssi_set_tmeter_tbl(rtwdev, phy, i);
4267 _tssi_slope_cal_org(rtwdev, phy, i);
4268 _tssi_set_aligk_default(rtwdev, phy, i);
4269 _tssi_set_slope(rtwdev, phy, i);
4270 _tssi_run_slope(rtwdev, phy, i);
4271 }
4272
4273 _tssi_enable(rtwdev, phy);
4274 _tssi_set_efuse_to_de(rtwdev, phy);
4275 }
4276
rtw8852c_tssi_scan(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy)4277 void rtw8852c_tssi_scan(struct rtw89_dev *rtwdev, enum rtw89_phy_idx phy)
4278 {
4279 u32 i, path = RF_PATH_A, path_max = RF_PATH_NUM_8852C;
4280
4281 rtw89_debug(rtwdev, RTW89_DBG_TSSI, "[TSSI] %s: phy=%d\n",
4282 __func__, phy);
4283
4284 if (!rtwdev->is_tssi_mode[RF_PATH_A])
4285 return;
4286 if (!rtwdev->is_tssi_mode[RF_PATH_B])
4287 return;
4288
4289 if (rtwdev->dbcc_en) {
4290 if (phy == RTW89_PHY_0) {
4291 path = RF_PATH_A;
4292 path_max = RF_PATH_B;
4293 } else if (phy == RTW89_PHY_1) {
4294 path = RF_PATH_B;
4295 path_max = RF_PATH_NUM_8852C;
4296 }
4297 }
4298
4299 _tssi_disable(rtwdev, phy);
4300
4301 for (i = path; i < path_max; i++) {
4302 _tssi_set_sys(rtwdev, phy, i);
4303 _tssi_set_dck(rtwdev, phy, i);
4304 _tssi_set_tmeter_tbl(rtwdev, phy, i);
4305 _tssi_slope_cal_org(rtwdev, phy, i);
4306 _tssi_set_aligk_default(rtwdev, phy, i);
4307 }
4308
4309 _tssi_enable(rtwdev, phy);
4310 _tssi_set_efuse_to_de(rtwdev, phy);
4311 }
4312
rtw8852c_tssi_default_txagc(struct rtw89_dev * rtwdev,enum rtw89_phy_idx phy,bool enable)4313 static void rtw8852c_tssi_default_txagc(struct rtw89_dev *rtwdev,
4314 enum rtw89_phy_idx phy, bool enable)
4315 {
4316 struct rtw89_tssi_info *tssi_info = &rtwdev->tssi;
4317 u8 i;
4318
4319 if (!rtwdev->is_tssi_mode[RF_PATH_A] && !rtwdev->is_tssi_mode[RF_PATH_B])
4320 return;
4321
4322 if (enable) {
4323 /* SCAN_START */
4324 if (rtw89_phy_read32_mask(rtwdev, R_TXAGC_BB, B_TXAGC_BB_OFT) != 0xc000 &&
4325 rtw89_phy_read32_mask(rtwdev, R_TXAGC_BB, B_TXAGC_BB_OFT) != 0x0) {
4326 for (i = 0; i < 6; i++) {
4327 tssi_info->default_txagc_offset[RF_PATH_A] =
4328 rtw89_phy_read32_mask(rtwdev, R_TXAGC_BB,
4329 B_TXAGC_BB);
4330 if (tssi_info->default_txagc_offset[RF_PATH_A])
4331 break;
4332 }
4333 }
4334
4335 if (rtw89_phy_read32_mask(rtwdev, R_TXAGC_BB_S1, B_TXAGC_BB_S1_OFT) != 0xc000 &&
4336 rtw89_phy_read32_mask(rtwdev, R_TXAGC_BB_S1, B_TXAGC_BB_S1_OFT) != 0x0) {
4337 for (i = 0; i < 6; i++) {
4338 tssi_info->default_txagc_offset[RF_PATH_B] =
4339 rtw89_phy_read32_mask(rtwdev, R_TXAGC_BB_S1,
4340 B_TXAGC_BB_S1);
4341 if (tssi_info->default_txagc_offset[RF_PATH_B])
4342 break;
4343 }
4344 }
4345 } else {
4346 /* SCAN_END */
4347 rtw89_phy_write32_mask(rtwdev, R_P0_TSSI_TRK, B_P0_TSSI_OFT,
4348 tssi_info->default_txagc_offset[RF_PATH_A]);
4349 rtw89_phy_write32_mask(rtwdev, R_P1_TSSI_TRK, B_P1_TSSI_OFT,
4350 tssi_info->default_txagc_offset[RF_PATH_B]);
4351
4352 rtw89_phy_write32_mask(rtwdev, R_P0_TSSI_TRK, B_P0_TSSI_OFT_EN, 0x0);
4353 rtw89_phy_write32_mask(rtwdev, R_P0_TSSI_TRK, B_P0_TSSI_OFT_EN, 0x1);
4354
4355 rtw89_phy_write32_mask(rtwdev, R_P1_TSSI_TRK, B_P1_TSSI_OFT_EN, 0x0);
4356 rtw89_phy_write32_mask(rtwdev, R_P1_TSSI_TRK, B_P1_TSSI_OFT_EN, 0x1);
4357 }
4358 }
4359
rtw8852c_wifi_scan_notify(struct rtw89_dev * rtwdev,bool scan_start,enum rtw89_phy_idx phy_idx)4360 void rtw8852c_wifi_scan_notify(struct rtw89_dev *rtwdev,
4361 bool scan_start, enum rtw89_phy_idx phy_idx)
4362 {
4363 if (scan_start)
4364 rtw8852c_tssi_default_txagc(rtwdev, phy_idx, true);
4365 else
4366 rtw8852c_tssi_default_txagc(rtwdev, phy_idx, false);
4367 }
4368