1 // SPDX-License-Identifier: GPL-2.0
2 /******************************************************************************
3 *
4 * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
5 *
6 ******************************************************************************/
7 #define _HAL_COM_PHYCFG_C_
8
9 #include <drv_types.h>
10 #include <rtw_debug.h>
11 #include <hal_data.h>
12 #include <linux/kernel.h>
13
PHY_GetTxPowerByRateBase(struct adapter * Adapter,u8 Band,u8 RfPath,u8 TxNum,enum RATE_SECTION RateSection)14 u8 PHY_GetTxPowerByRateBase(struct adapter *Adapter, u8 Band, u8 RfPath,
15 u8 TxNum, enum RATE_SECTION RateSection)
16 {
17 struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
18 u8 value = 0;
19
20 if (RfPath > ODM_RF_PATH_D) {
21 DBG_871X("Invalid Rf Path %d in PHY_GetTxPowerByRateBase()\n", RfPath);
22 return 0;
23 }
24
25 if (Band == BAND_ON_2_4G) {
26 switch (RateSection) {
27 case CCK:
28 value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][0];
29 break;
30 case OFDM:
31 value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][1];
32 break;
33 case HT_MCS0_MCS7:
34 value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][2];
35 break;
36 case HT_MCS8_MCS15:
37 value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][3];
38 break;
39 case HT_MCS16_MCS23:
40 value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][4];
41 break;
42 case HT_MCS24_MCS31:
43 value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][5];
44 break;
45 case VHT_1SSMCS0_1SSMCS9:
46 value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][6];
47 break;
48 case VHT_2SSMCS0_2SSMCS9:
49 value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][7];
50 break;
51 case VHT_3SSMCS0_3SSMCS9:
52 value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][8];
53 break;
54 case VHT_4SSMCS0_4SSMCS9:
55 value = pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][9];
56 break;
57 default:
58 DBG_871X("Invalid RateSection %d in Band 2.4G, Rf Path %d, %dTx in PHY_GetTxPowerByRateBase()\n",
59 RateSection, RfPath, TxNum);
60 break;
61 }
62 } else if (Band == BAND_ON_5G) {
63 switch (RateSection) {
64 case OFDM:
65 value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][0];
66 break;
67 case HT_MCS0_MCS7:
68 value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][1];
69 break;
70 case HT_MCS8_MCS15:
71 value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][2];
72 break;
73 case HT_MCS16_MCS23:
74 value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][3];
75 break;
76 case HT_MCS24_MCS31:
77 value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][4];
78 break;
79 case VHT_1SSMCS0_1SSMCS9:
80 value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][5];
81 break;
82 case VHT_2SSMCS0_2SSMCS9:
83 value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][6];
84 break;
85 case VHT_3SSMCS0_3SSMCS9:
86 value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][7];
87 break;
88 case VHT_4SSMCS0_4SSMCS9:
89 value = pHalData->TxPwrByRateBase5G[RfPath][TxNum][8];
90 break;
91 default:
92 DBG_871X("Invalid RateSection %d in Band 5G, Rf Path %d, %dTx in PHY_GetTxPowerByRateBase()\n",
93 RateSection, RfPath, TxNum);
94 break;
95 }
96 } else
97 DBG_871X("Invalid Band %d in PHY_GetTxPowerByRateBase()\n", Band);
98
99 return value;
100 }
101
102 static void
phy_SetTxPowerByRateBase(struct adapter * Adapter,u8 Band,u8 RfPath,enum RATE_SECTION RateSection,u8 TxNum,u8 Value)103 phy_SetTxPowerByRateBase(
104 struct adapter *Adapter,
105 u8 Band,
106 u8 RfPath,
107 enum RATE_SECTION RateSection,
108 u8 TxNum,
109 u8 Value
110 )
111 {
112 struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
113
114 if (RfPath > ODM_RF_PATH_D) {
115 DBG_871X("Invalid Rf Path %d in phy_SetTxPowerByRatBase()\n", RfPath);
116 return;
117 }
118
119 if (Band == BAND_ON_2_4G) {
120 switch (RateSection) {
121 case CCK:
122 pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][0] = Value;
123 break;
124 case OFDM:
125 pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][1] = Value;
126 break;
127 case HT_MCS0_MCS7:
128 pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][2] = Value;
129 break;
130 case HT_MCS8_MCS15:
131 pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][3] = Value;
132 break;
133 case HT_MCS16_MCS23:
134 pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][4] = Value;
135 break;
136 case HT_MCS24_MCS31:
137 pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][5] = Value;
138 break;
139 case VHT_1SSMCS0_1SSMCS9:
140 pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][6] = Value;
141 break;
142 case VHT_2SSMCS0_2SSMCS9:
143 pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][7] = Value;
144 break;
145 case VHT_3SSMCS0_3SSMCS9:
146 pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][8] = Value;
147 break;
148 case VHT_4SSMCS0_4SSMCS9:
149 pHalData->TxPwrByRateBase2_4G[RfPath][TxNum][9] = Value;
150 break;
151 default:
152 DBG_871X("Invalid RateSection %d in Band 2.4G, Rf Path %d, %dTx in phy_SetTxPowerByRateBase()\n",
153 RateSection, RfPath, TxNum);
154 break;
155 }
156 } else if (Band == BAND_ON_5G) {
157 switch (RateSection) {
158 case OFDM:
159 pHalData->TxPwrByRateBase5G[RfPath][TxNum][0] = Value;
160 break;
161 case HT_MCS0_MCS7:
162 pHalData->TxPwrByRateBase5G[RfPath][TxNum][1] = Value;
163 break;
164 case HT_MCS8_MCS15:
165 pHalData->TxPwrByRateBase5G[RfPath][TxNum][2] = Value;
166 break;
167 case HT_MCS16_MCS23:
168 pHalData->TxPwrByRateBase5G[RfPath][TxNum][3] = Value;
169 break;
170 case HT_MCS24_MCS31:
171 pHalData->TxPwrByRateBase5G[RfPath][TxNum][4] = Value;
172 break;
173 case VHT_1SSMCS0_1SSMCS9:
174 pHalData->TxPwrByRateBase5G[RfPath][TxNum][5] = Value;
175 break;
176 case VHT_2SSMCS0_2SSMCS9:
177 pHalData->TxPwrByRateBase5G[RfPath][TxNum][6] = Value;
178 break;
179 case VHT_3SSMCS0_3SSMCS9:
180 pHalData->TxPwrByRateBase5G[RfPath][TxNum][7] = Value;
181 break;
182 case VHT_4SSMCS0_4SSMCS9:
183 pHalData->TxPwrByRateBase5G[RfPath][TxNum][8] = Value;
184 break;
185 default:
186 DBG_871X("Invalid RateSection %d in Band 5G, Rf Path %d, %dTx in phy_SetTxPowerByRateBase()\n",
187 RateSection, RfPath, TxNum);
188 break;
189 }
190 } else
191 DBG_871X("Invalid Band %d in phy_SetTxPowerByRateBase()\n", Band);
192 }
193
194 static void
phy_StoreTxPowerByRateBase(struct adapter * padapter)195 phy_StoreTxPowerByRateBase(
196 struct adapter *padapter
197 )
198 {
199 u8 path, base;
200
201 /* DBG_871X("===>%s\n", __func__); */
202
203 for (path = ODM_RF_PATH_A; path <= ODM_RF_PATH_B; ++path) {
204 base = PHY_GetTxPowerByRate(padapter, BAND_ON_2_4G, path, RF_1TX, MGN_11M);
205 phy_SetTxPowerByRateBase(padapter, BAND_ON_2_4G, path, CCK, RF_1TX, base);
206 /* DBG_871X("Power index base of 2.4G path %d 1Tx CCK = > 0x%x\n", path, base); */
207
208 base = PHY_GetTxPowerByRate(padapter, BAND_ON_2_4G, path, RF_1TX, MGN_54M);
209 phy_SetTxPowerByRateBase(padapter, BAND_ON_2_4G, path, OFDM, RF_1TX, base);
210 /* DBG_871X("Power index base of 2.4G path %d 1Tx OFDM = > 0x%x\n", path, base); */
211
212 base = PHY_GetTxPowerByRate(padapter, BAND_ON_2_4G, path, RF_1TX, MGN_MCS7);
213 phy_SetTxPowerByRateBase(padapter, BAND_ON_2_4G, path, HT_MCS0_MCS7, RF_1TX, base);
214 /* DBG_871X("Power index base of 2.4G path %d 1Tx MCS0-7 = > 0x%x\n", path, base); */
215
216 base = PHY_GetTxPowerByRate(padapter, BAND_ON_2_4G, path, RF_2TX, MGN_MCS15);
217 phy_SetTxPowerByRateBase(padapter, BAND_ON_2_4G, path, HT_MCS8_MCS15, RF_2TX, base);
218 /* DBG_871X("Power index base of 2.4G path %d 2Tx MCS8-15 = > 0x%x\n", path, base); */
219
220 base = PHY_GetTxPowerByRate(padapter, BAND_ON_2_4G, path, RF_3TX, MGN_MCS23);
221 phy_SetTxPowerByRateBase(padapter, BAND_ON_2_4G, path, HT_MCS16_MCS23, RF_3TX, base);
222 /* DBG_871X("Power index base of 2.4G path %d 3Tx MCS16-23 = > 0x%x\n", path, base); */
223
224 base = PHY_GetTxPowerByRate(padapter, BAND_ON_2_4G, path, RF_1TX, MGN_VHT1SS_MCS7);
225 phy_SetTxPowerByRateBase(padapter, BAND_ON_2_4G, path, VHT_1SSMCS0_1SSMCS9, RF_1TX, base);
226 /* DBG_871X("Power index base of 2.4G path %d 1Tx VHT1SS = > 0x%x\n", path, base); */
227
228 base = PHY_GetTxPowerByRate(padapter, BAND_ON_2_4G, path, RF_2TX, MGN_VHT2SS_MCS7);
229 phy_SetTxPowerByRateBase(padapter, BAND_ON_2_4G, path, VHT_2SSMCS0_2SSMCS9, RF_2TX, base);
230 /* DBG_871X("Power index base of 2.4G path %d 2Tx VHT2SS = > 0x%x\n", path, base); */
231
232 base = PHY_GetTxPowerByRate(padapter, BAND_ON_2_4G, path, RF_3TX, MGN_VHT3SS_MCS7);
233 phy_SetTxPowerByRateBase(padapter, BAND_ON_2_4G, path, VHT_3SSMCS0_3SSMCS9, RF_3TX, base);
234 /* DBG_871X("Power index base of 2.4G path %d 3Tx VHT3SS = > 0x%x\n", path, base); */
235
236 base = PHY_GetTxPowerByRate(padapter, BAND_ON_5G, path, RF_1TX, MGN_54M);
237 phy_SetTxPowerByRateBase(padapter, BAND_ON_5G, path, OFDM, RF_1TX, base);
238 /* DBG_871X("Power index base of 5G path %d 1Tx OFDM = > 0x%x\n", path, base); */
239
240 base = PHY_GetTxPowerByRate(padapter, BAND_ON_5G, path, RF_1TX, MGN_MCS7);
241 phy_SetTxPowerByRateBase(padapter, BAND_ON_5G, path, HT_MCS0_MCS7, RF_1TX, base);
242 /* DBG_871X("Power index base of 5G path %d 1Tx MCS0~7 = > 0x%x\n", path, base); */
243
244 base = PHY_GetTxPowerByRate(padapter, BAND_ON_5G, path, RF_2TX, MGN_MCS15);
245 phy_SetTxPowerByRateBase(padapter, BAND_ON_5G, path, HT_MCS8_MCS15, RF_2TX, base);
246 /* DBG_871X("Power index base of 5G path %d 2Tx MCS8~15 = > 0x%x\n", path, base); */
247
248 base = PHY_GetTxPowerByRate(padapter, BAND_ON_5G, path, RF_3TX, MGN_MCS23);
249 phy_SetTxPowerByRateBase(padapter, BAND_ON_5G, path, HT_MCS16_MCS23, RF_3TX, base);
250 /* DBG_871X("Power index base of 5G path %d 3Tx MCS16~23 = > 0x%x\n", path, base); */
251
252 base = PHY_GetTxPowerByRate(padapter, BAND_ON_5G, path, RF_1TX, MGN_VHT1SS_MCS7);
253 phy_SetTxPowerByRateBase(padapter, BAND_ON_5G, path, VHT_1SSMCS0_1SSMCS9, RF_1TX, base);
254 /* DBG_871X("Power index base of 5G path %d 1Tx VHT1SS = > 0x%x\n", path, base); */
255
256 base = PHY_GetTxPowerByRate(padapter, BAND_ON_5G, path, RF_2TX, MGN_VHT2SS_MCS7);
257 phy_SetTxPowerByRateBase(padapter, BAND_ON_5G, path, VHT_2SSMCS0_2SSMCS9, RF_2TX, base);
258 /* DBG_871X("Power index base of 5G path %d 2Tx VHT2SS = > 0x%x\n", path, base); */
259
260 base = PHY_GetTxPowerByRate(padapter, BAND_ON_5G, path, RF_3TX, MGN_VHT2SS_MCS7);
261 phy_SetTxPowerByRateBase(padapter, BAND_ON_5G, path, VHT_3SSMCS0_3SSMCS9, RF_3TX, base);
262 /* DBG_871X("Power index base of 5G path %d 3Tx VHT3SS = > 0x%x\n", path, base); */
263 }
264
265 /* DBG_871X("<===%s\n", __func__); */
266 }
267
PHY_GetRateSectionIndexOfTxPowerByRate(struct adapter * padapter,u32 RegAddr,u32 BitMask)268 u8 PHY_GetRateSectionIndexOfTxPowerByRate(
269 struct adapter *padapter, u32 RegAddr, u32 BitMask
270 )
271 {
272 struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
273 PDM_ODM_T pDM_Odm = &pHalData->odmpriv;
274 u8 index = 0;
275
276 if (pDM_Odm->PhyRegPgVersion == 0) {
277 switch (RegAddr) {
278 case rTxAGC_A_Rate18_06:
279 index = 0;
280 break;
281 case rTxAGC_A_Rate54_24:
282 index = 1;
283 break;
284 case rTxAGC_A_CCK1_Mcs32:
285 index = 6;
286 break;
287 case rTxAGC_B_CCK11_A_CCK2_11:
288 if (BitMask == bMaskH3Bytes)
289 index = 7;
290 else if (BitMask == 0x000000ff)
291 index = 15;
292 break;
293
294 case rTxAGC_A_Mcs03_Mcs00:
295 index = 2;
296 break;
297 case rTxAGC_A_Mcs07_Mcs04:
298 index = 3;
299 break;
300 case rTxAGC_A_Mcs11_Mcs08:
301 index = 4;
302 break;
303 case rTxAGC_A_Mcs15_Mcs12:
304 index = 5;
305 break;
306 case rTxAGC_B_Rate18_06:
307 index = 8;
308 break;
309 case rTxAGC_B_Rate54_24:
310 index = 9;
311 break;
312 case rTxAGC_B_CCK1_55_Mcs32:
313 index = 14;
314 break;
315 case rTxAGC_B_Mcs03_Mcs00:
316 index = 10;
317 break;
318 case rTxAGC_B_Mcs07_Mcs04:
319 index = 11;
320 break;
321 case rTxAGC_B_Mcs11_Mcs08:
322 index = 12;
323 break;
324 case rTxAGC_B_Mcs15_Mcs12:
325 index = 13;
326 break;
327 default:
328 DBG_871X("Invalid RegAddr 0x3%x in PHY_GetRateSectionIndexOfTxPowerByRate()", RegAddr);
329 break;
330 }
331 }
332
333 return index;
334 }
335
336 void
PHY_GetRateValuesOfTxPowerByRate(struct adapter * padapter,u32 RegAddr,u32 BitMask,u32 Value,u8 * RateIndex,s8 * PwrByRateVal,u8 * RateNum)337 PHY_GetRateValuesOfTxPowerByRate(
338 struct adapter *padapter,
339 u32 RegAddr,
340 u32 BitMask,
341 u32 Value,
342 u8 *RateIndex,
343 s8 *PwrByRateVal,
344 u8 *RateNum
345 )
346 {
347 u8 i = 0;
348
349 switch (RegAddr) {
350 case rTxAGC_A_Rate18_06:
351 case rTxAGC_B_Rate18_06:
352 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_6M);
353 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_9M);
354 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_12M);
355 RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_18M);
356 for (i = 0; i < 4; ++i) {
357 PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
358 ((Value >> (i * 8)) & 0xF));
359 }
360 *RateNum = 4;
361 break;
362
363 case rTxAGC_A_Rate54_24:
364 case rTxAGC_B_Rate54_24:
365 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_24M);
366 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_36M);
367 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_48M);
368 RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_54M);
369 for (i = 0; i < 4; ++i) {
370 PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
371 ((Value >> (i * 8)) & 0xF));
372 }
373 *RateNum = 4;
374 break;
375
376 case rTxAGC_A_CCK1_Mcs32:
377 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_1M);
378 PwrByRateVal[0] = (s8) ((((Value >> (8 + 4)) & 0xF)) * 10 +
379 ((Value >> 8) & 0xF));
380 *RateNum = 1;
381 break;
382
383 case rTxAGC_B_CCK11_A_CCK2_11:
384 if (BitMask == 0xffffff00) {
385 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_2M);
386 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_5_5M);
387 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_11M);
388 for (i = 1; i < 4; ++i) {
389 PwrByRateVal[i - 1] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
390 ((Value >> (i * 8)) & 0xF));
391 }
392 *RateNum = 3;
393 } else if (BitMask == 0x000000ff) {
394 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_11M);
395 PwrByRateVal[0] = (s8) ((((Value >> 4) & 0xF)) * 10 + (Value & 0xF));
396 *RateNum = 1;
397 }
398 break;
399
400 case rTxAGC_A_Mcs03_Mcs00:
401 case rTxAGC_B_Mcs03_Mcs00:
402 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS0);
403 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS1);
404 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS2);
405 RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS3);
406 for (i = 0; i < 4; ++i) {
407 PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
408 ((Value >> (i * 8)) & 0xF));
409 }
410 *RateNum = 4;
411 break;
412
413 case rTxAGC_A_Mcs07_Mcs04:
414 case rTxAGC_B_Mcs07_Mcs04:
415 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS4);
416 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS5);
417 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS6);
418 RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS7);
419 for (i = 0; i < 4; ++i) {
420 PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
421 ((Value >> (i * 8)) & 0xF));
422 }
423 *RateNum = 4;
424 break;
425
426 case rTxAGC_A_Mcs11_Mcs08:
427 case rTxAGC_B_Mcs11_Mcs08:
428 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS8);
429 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS9);
430 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS10);
431 RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS11);
432 for (i = 0; i < 4; ++i) {
433 PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
434 ((Value >> (i * 8)) & 0xF));
435 }
436 *RateNum = 4;
437 break;
438
439 case rTxAGC_A_Mcs15_Mcs12:
440 case rTxAGC_B_Mcs15_Mcs12:
441 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS12);
442 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS13);
443 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS14);
444 RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS15);
445 for (i = 0; i < 4; ++i) {
446 PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
447 ((Value >> (i * 8)) & 0xF));
448 }
449 *RateNum = 4;
450
451 break;
452
453 case rTxAGC_B_CCK1_55_Mcs32:
454 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_1M);
455 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_2M);
456 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_5_5M);
457 for (i = 1; i < 4; ++i) {
458 PwrByRateVal[i - 1] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
459 ((Value >> (i * 8)) & 0xF));
460 }
461 *RateNum = 3;
462 break;
463
464 case 0xC20:
465 case 0xE20:
466 case 0x1820:
467 case 0x1a20:
468 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_1M);
469 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_2M);
470 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_5_5M);
471 RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_11M);
472 for (i = 0; i < 4; ++i) {
473 PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
474 ((Value >> (i * 8)) & 0xF));
475 }
476 *RateNum = 4;
477 break;
478
479 case 0xC24:
480 case 0xE24:
481 case 0x1824:
482 case 0x1a24:
483 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_6M);
484 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_9M);
485 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_12M);
486 RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_18M);
487 for (i = 0; i < 4; ++i) {
488 PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
489 ((Value >> (i * 8)) & 0xF));
490 }
491 *RateNum = 4;
492 break;
493
494 case 0xC28:
495 case 0xE28:
496 case 0x1828:
497 case 0x1a28:
498 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_24M);
499 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_36M);
500 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_48M);
501 RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_54M);
502 for (i = 0; i < 4; ++i) {
503 PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
504 ((Value >> (i * 8)) & 0xF));
505 }
506 *RateNum = 4;
507 break;
508
509 case 0xC2C:
510 case 0xE2C:
511 case 0x182C:
512 case 0x1a2C:
513 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS0);
514 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS1);
515 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS2);
516 RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS3);
517 for (i = 0; i < 4; ++i) {
518 PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
519 ((Value >> (i * 8)) & 0xF));
520 }
521 *RateNum = 4;
522 break;
523
524 case 0xC30:
525 case 0xE30:
526 case 0x1830:
527 case 0x1a30:
528 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS4);
529 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS5);
530 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS6);
531 RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS7);
532 for (i = 0; i < 4; ++i) {
533 PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
534 ((Value >> (i * 8)) & 0xF));
535 }
536 *RateNum = 4;
537 break;
538
539 case 0xC34:
540 case 0xE34:
541 case 0x1834:
542 case 0x1a34:
543 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS8);
544 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS9);
545 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS10);
546 RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS11);
547 for (i = 0; i < 4; ++i) {
548 PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
549 ((Value >> (i * 8)) & 0xF));
550 }
551 *RateNum = 4;
552 break;
553
554 case 0xC38:
555 case 0xE38:
556 case 0x1838:
557 case 0x1a38:
558 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS12);
559 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS13);
560 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS14);
561 RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS15);
562 for (i = 0; i < 4; ++i) {
563 PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
564 ((Value >> (i * 8)) & 0xF));
565 }
566 *RateNum = 4;
567 break;
568
569 case 0xC3C:
570 case 0xE3C:
571 case 0x183C:
572 case 0x1a3C:
573 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT1SS_MCS0);
574 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT1SS_MCS1);
575 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT1SS_MCS2);
576 RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT1SS_MCS3);
577 for (i = 0; i < 4; ++i) {
578 PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
579 ((Value >> (i * 8)) & 0xF));
580 }
581 *RateNum = 4;
582 break;
583
584 case 0xC40:
585 case 0xE40:
586 case 0x1840:
587 case 0x1a40:
588 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT1SS_MCS4);
589 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT1SS_MCS5);
590 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT1SS_MCS6);
591 RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT1SS_MCS7);
592 for (i = 0; i < 4; ++i) {
593 PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
594 ((Value >> (i * 8)) & 0xF));
595 }
596 *RateNum = 4;
597 break;
598
599 case 0xC44:
600 case 0xE44:
601 case 0x1844:
602 case 0x1a44:
603 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT1SS_MCS8);
604 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT1SS_MCS9);
605 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS0);
606 RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS1);
607 for (i = 0; i < 4; ++i) {
608 PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
609 ((Value >> (i * 8)) & 0xF));
610 }
611 *RateNum = 4;
612 break;
613
614 case 0xC48:
615 case 0xE48:
616 case 0x1848:
617 case 0x1a48:
618 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS2);
619 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS3);
620 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS4);
621 RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS5);
622 for (i = 0; i < 4; ++i) {
623 PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
624 ((Value >> (i * 8)) & 0xF));
625 }
626 *RateNum = 4;
627 break;
628
629 case 0xC4C:
630 case 0xE4C:
631 case 0x184C:
632 case 0x1a4C:
633 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS6);
634 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS7);
635 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS8);
636 RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS9);
637 for (i = 0; i < 4; ++i) {
638 PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
639 ((Value >> (i * 8)) & 0xF));
640 }
641 *RateNum = 4;
642 break;
643
644 case 0xCD8:
645 case 0xED8:
646 case 0x18D8:
647 case 0x1aD8:
648 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS16);
649 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS17);
650 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS18);
651 RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS19);
652 for (i = 0; i < 4; ++i) {
653 PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
654 ((Value >> (i * 8)) & 0xF));
655 }
656 *RateNum = 4;
657 break;
658
659 case 0xCDC:
660 case 0xEDC:
661 case 0x18DC:
662 case 0x1aDC:
663 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS20);
664 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS21);
665 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS22);
666 RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS23);
667 for (i = 0; i < 4; ++i) {
668 PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
669 ((Value >> (i * 8)) & 0xF));
670 }
671 *RateNum = 4;
672 break;
673
674 case 0xCE0:
675 case 0xEE0:
676 case 0x18E0:
677 case 0x1aE0:
678 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT3SS_MCS0);
679 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT3SS_MCS1);
680 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT3SS_MCS2);
681 RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT3SS_MCS3);
682 for (i = 0; i < 4; ++i) {
683 PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
684 ((Value >> (i * 8)) & 0xF));
685 }
686 *RateNum = 4;
687 break;
688
689 case 0xCE4:
690 case 0xEE4:
691 case 0x18E4:
692 case 0x1aE4:
693 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT3SS_MCS4);
694 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT3SS_MCS5);
695 RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT3SS_MCS6);
696 RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT3SS_MCS7);
697 for (i = 0; i < 4; ++i) {
698 PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
699 ((Value >> (i * 8)) & 0xF));
700 }
701 *RateNum = 4;
702 break;
703
704 case 0xCE8:
705 case 0xEE8:
706 case 0x18E8:
707 case 0x1aE8:
708 RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT3SS_MCS8);
709 RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_VHT3SS_MCS9);
710 for (i = 0; i < 2; ++i) {
711 PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
712 ((Value >> (i * 8)) & 0xF));
713 }
714 *RateNum = 4;
715 break;
716
717 default:
718 DBG_871X("Invalid RegAddr 0x%x in %s()\n", RegAddr, __func__);
719 break;
720 }
721 }
722
PHY_StoreTxPowerByRateNew(struct adapter * padapter,u32 Band,u32 RfPath,u32 TxNum,u32 RegAddr,u32 BitMask,u32 Data)723 static void PHY_StoreTxPowerByRateNew(
724 struct adapter *padapter,
725 u32 Band,
726 u32 RfPath,
727 u32 TxNum,
728 u32 RegAddr,
729 u32 BitMask,
730 u32 Data
731 )
732 {
733 struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
734 u8 i = 0, rateIndex[4] = {0}, rateNum = 0;
735 s8 PwrByRateVal[4] = {0};
736
737 PHY_GetRateValuesOfTxPowerByRate(padapter, RegAddr, BitMask, Data, rateIndex, PwrByRateVal, &rateNum);
738
739 if (Band != BAND_ON_2_4G && Band != BAND_ON_5G) {
740 DBG_871X("Invalid Band %d\n", Band);
741 return;
742 }
743
744 if (RfPath > ODM_RF_PATH_D) {
745 DBG_871X("Invalid RfPath %d\n", RfPath);
746 return;
747 }
748
749 if (TxNum > ODM_RF_PATH_D) {
750 DBG_871X("Invalid TxNum %d\n", TxNum);
751 return;
752 }
753
754 for (i = 0; i < rateNum; ++i) {
755 if (rateIndex[i] == PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS0) ||
756 rateIndex[i] == PHY_GetRateIndexOfTxPowerByRate(MGN_VHT2SS_MCS1))
757 TxNum = RF_2TX;
758
759 pHalData->TxPwrByRateOffset[Band][RfPath][TxNum][rateIndex[i]] = PwrByRateVal[i];
760 }
761 }
762
PHY_StoreTxPowerByRateOld(struct adapter * padapter,u32 RegAddr,u32 BitMask,u32 Data)763 static void PHY_StoreTxPowerByRateOld(
764 struct adapter *padapter, u32 RegAddr, u32 BitMask, u32 Data
765 )
766 {
767 struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
768 u8 index = PHY_GetRateSectionIndexOfTxPowerByRate(padapter, RegAddr, BitMask);
769
770 pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][index] = Data;
771 /* DBG_871X("MCSTxPowerLevelOriginalOffset[%d][0] = 0x%x\n", pHalData->pwrGroupCnt, */
772 /* pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][0]); */
773 }
774
PHY_InitTxPowerByRate(struct adapter * padapter)775 void PHY_InitTxPowerByRate(struct adapter *padapter)
776 {
777 struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
778 u8 band, rfPath, TxNum, rate;
779
780 for (band = BAND_ON_2_4G; band <= BAND_ON_5G; ++band)
781 for (rfPath = 0; rfPath < TX_PWR_BY_RATE_NUM_RF; ++rfPath)
782 for (TxNum = 0; TxNum < TX_PWR_BY_RATE_NUM_RF; ++TxNum)
783 for (rate = 0; rate < TX_PWR_BY_RATE_NUM_RATE; ++rate)
784 pHalData->TxPwrByRateOffset[band][rfPath][TxNum][rate] = 0;
785 }
786
PHY_StoreTxPowerByRate(struct adapter * padapter,u32 Band,u32 RfPath,u32 TxNum,u32 RegAddr,u32 BitMask,u32 Data)787 void PHY_StoreTxPowerByRate(
788 struct adapter *padapter,
789 u32 Band,
790 u32 RfPath,
791 u32 TxNum,
792 u32 RegAddr,
793 u32 BitMask,
794 u32 Data
795 )
796 {
797 struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
798 PDM_ODM_T pDM_Odm = &pHalData->odmpriv;
799
800 if (pDM_Odm->PhyRegPgVersion > 0)
801 PHY_StoreTxPowerByRateNew(padapter, Band, RfPath, TxNum, RegAddr, BitMask, Data);
802 else if (pDM_Odm->PhyRegPgVersion == 0) {
803 PHY_StoreTxPowerByRateOld(padapter, RegAddr, BitMask, Data);
804
805 if (RegAddr == rTxAGC_A_Mcs15_Mcs12 && pHalData->rf_type == RF_1T1R)
806 pHalData->pwrGroupCnt++;
807 else if (RegAddr == rTxAGC_B_Mcs15_Mcs12 && pHalData->rf_type != RF_1T1R)
808 pHalData->pwrGroupCnt++;
809 } else
810 DBG_871X("Invalid PHY_REG_PG.txt version %d\n", pDM_Odm->PhyRegPgVersion);
811
812 }
813
814 static void
phy_ConvertTxPowerByRateInDbmToRelativeValues(struct adapter * padapter)815 phy_ConvertTxPowerByRateInDbmToRelativeValues(
816 struct adapter *padapter
817 )
818 {
819 u8 base = 0, i = 0, value = 0, band = 0, path = 0, txNum = 0;
820 u8 cckRates[4] = {
821 MGN_1M, MGN_2M, MGN_5_5M, MGN_11M
822 };
823 u8 ofdmRates[8] = {
824 MGN_6M, MGN_9M, MGN_12M, MGN_18M, MGN_24M, MGN_36M, MGN_48M, MGN_54M
825 };
826 u8 mcs0_7Rates[8] = {
827 MGN_MCS0, MGN_MCS1, MGN_MCS2, MGN_MCS3, MGN_MCS4, MGN_MCS5, MGN_MCS6, MGN_MCS7
828 };
829 u8 mcs8_15Rates[8] = {
830 MGN_MCS8, MGN_MCS9, MGN_MCS10, MGN_MCS11, MGN_MCS12, MGN_MCS13, MGN_MCS14, MGN_MCS15
831 };
832 u8 mcs16_23Rates[8] = {
833 MGN_MCS16, MGN_MCS17, MGN_MCS18, MGN_MCS19, MGN_MCS20, MGN_MCS21, MGN_MCS22, MGN_MCS23
834 };
835 u8 vht1ssRates[10] = {
836 MGN_VHT1SS_MCS0, MGN_VHT1SS_MCS1, MGN_VHT1SS_MCS2, MGN_VHT1SS_MCS3, MGN_VHT1SS_MCS4,
837 MGN_VHT1SS_MCS5, MGN_VHT1SS_MCS6, MGN_VHT1SS_MCS7, MGN_VHT1SS_MCS8, MGN_VHT1SS_MCS9
838 };
839 u8 vht2ssRates[10] = {
840 MGN_VHT2SS_MCS0, MGN_VHT2SS_MCS1, MGN_VHT2SS_MCS2, MGN_VHT2SS_MCS3, MGN_VHT2SS_MCS4,
841 MGN_VHT2SS_MCS5, MGN_VHT2SS_MCS6, MGN_VHT2SS_MCS7, MGN_VHT2SS_MCS8, MGN_VHT2SS_MCS9
842 };
843 u8 vht3ssRates[10] = {
844 MGN_VHT3SS_MCS0, MGN_VHT3SS_MCS1, MGN_VHT3SS_MCS2, MGN_VHT3SS_MCS3, MGN_VHT3SS_MCS4,
845 MGN_VHT3SS_MCS5, MGN_VHT3SS_MCS6, MGN_VHT3SS_MCS7, MGN_VHT3SS_MCS8, MGN_VHT3SS_MCS9
846 };
847
848 /* DBG_871X("===>PHY_ConvertTxPowerByRateInDbmToRelativeValues()\n"); */
849
850 for (band = BAND_ON_2_4G; band <= BAND_ON_5G; ++band) {
851 for (path = ODM_RF_PATH_A; path <= ODM_RF_PATH_D; ++path) {
852 for (txNum = RF_1TX; txNum < RF_MAX_TX_NUM; ++txNum) {
853 /* CCK */
854 base = PHY_GetTxPowerByRate(padapter, band, path, txNum, MGN_11M);
855 for (i = 0; i < ARRAY_SIZE(cckRates); ++i) {
856 value = PHY_GetTxPowerByRate(padapter, band, path, txNum, cckRates[i]);
857 PHY_SetTxPowerByRate(padapter, band, path, txNum, cckRates[i], value - base);
858 }
859
860 /* OFDM */
861 base = PHY_GetTxPowerByRate(padapter, band, path, txNum, MGN_54M);
862 for (i = 0; i < sizeof(ofdmRates); ++i) {
863 value = PHY_GetTxPowerByRate(padapter, band, path, txNum, ofdmRates[i]);
864 PHY_SetTxPowerByRate(padapter, band, path, txNum, ofdmRates[i], value - base);
865 }
866
867 /* HT MCS0~7 */
868 base = PHY_GetTxPowerByRate(padapter, band, path, txNum, MGN_MCS7);
869 for (i = 0; i < sizeof(mcs0_7Rates); ++i) {
870 value = PHY_GetTxPowerByRate(padapter, band, path, txNum, mcs0_7Rates[i]);
871 PHY_SetTxPowerByRate(padapter, band, path, txNum, mcs0_7Rates[i], value - base);
872 }
873
874 /* HT MCS8~15 */
875 base = PHY_GetTxPowerByRate(padapter, band, path, txNum, MGN_MCS15);
876 for (i = 0; i < sizeof(mcs8_15Rates); ++i) {
877 value = PHY_GetTxPowerByRate(padapter, band, path, txNum, mcs8_15Rates[i]);
878 PHY_SetTxPowerByRate(padapter, band, path, txNum, mcs8_15Rates[i], value - base);
879 }
880
881 /* HT MCS16~23 */
882 base = PHY_GetTxPowerByRate(padapter, band, path, txNum, MGN_MCS23);
883 for (i = 0; i < sizeof(mcs16_23Rates); ++i) {
884 value = PHY_GetTxPowerByRate(padapter, band, path, txNum, mcs16_23Rates[i]);
885 PHY_SetTxPowerByRate(padapter, band, path, txNum, mcs16_23Rates[i], value - base);
886 }
887
888 /* VHT 1SS */
889 base = PHY_GetTxPowerByRate(padapter, band, path, txNum, MGN_VHT1SS_MCS7);
890 for (i = 0; i < sizeof(vht1ssRates); ++i) {
891 value = PHY_GetTxPowerByRate(padapter, band, path, txNum, vht1ssRates[i]);
892 PHY_SetTxPowerByRate(padapter, band, path, txNum, vht1ssRates[i], value - base);
893 }
894
895 /* VHT 2SS */
896 base = PHY_GetTxPowerByRate(padapter, band, path, txNum, MGN_VHT2SS_MCS7);
897 for (i = 0; i < sizeof(vht2ssRates); ++i) {
898 value = PHY_GetTxPowerByRate(padapter, band, path, txNum, vht2ssRates[i]);
899 PHY_SetTxPowerByRate(padapter, band, path, txNum, vht2ssRates[i], value - base);
900 }
901
902 /* VHT 3SS */
903 base = PHY_GetTxPowerByRate(padapter, band, path, txNum, MGN_VHT3SS_MCS7);
904 for (i = 0; i < sizeof(vht3ssRates); ++i) {
905 value = PHY_GetTxPowerByRate(padapter, band, path, txNum, vht3ssRates[i]);
906 PHY_SetTxPowerByRate(padapter, band, path, txNum, vht3ssRates[i], value - base);
907 }
908 }
909 }
910 }
911
912 /* DBG_871X("<===PHY_ConvertTxPowerByRateInDbmToRelativeValues()\n"); */
913 }
914
915 /*
916 * This function must be called if the value in the PHY_REG_PG.txt(or header)
917 * is exact dBm values
918 */
PHY_TxPowerByRateConfiguration(struct adapter * padapter)919 void PHY_TxPowerByRateConfiguration(struct adapter *padapter)
920 {
921 phy_StoreTxPowerByRateBase(padapter);
922 phy_ConvertTxPowerByRateInDbmToRelativeValues(padapter);
923 }
924
PHY_SetTxPowerIndexByRateSection(struct adapter * padapter,u8 RFPath,u8 Channel,u8 RateSection)925 void PHY_SetTxPowerIndexByRateSection(
926 struct adapter *padapter, u8 RFPath, u8 Channel, u8 RateSection
927 )
928 {
929 struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
930
931 if (RateSection == CCK) {
932 u8 cckRates[] = {MGN_1M, MGN_2M, MGN_5_5M, MGN_11M};
933 if (pHalData->CurrentBandType == BAND_ON_2_4G)
934 PHY_SetTxPowerIndexByRateArray(padapter, RFPath,
935 pHalData->CurrentChannelBW,
936 Channel, cckRates,
937 ARRAY_SIZE(cckRates));
938
939 } else if (RateSection == OFDM) {
940 u8 ofdmRates[] = {MGN_6M, MGN_9M, MGN_12M, MGN_18M, MGN_24M, MGN_36M, MGN_48M, MGN_54M};
941 PHY_SetTxPowerIndexByRateArray(padapter, RFPath,
942 pHalData->CurrentChannelBW,
943 Channel, ofdmRates,
944 ARRAY_SIZE(ofdmRates));
945
946 } else if (RateSection == HT_MCS0_MCS7) {
947 u8 htRates1T[] = {MGN_MCS0, MGN_MCS1, MGN_MCS2, MGN_MCS3, MGN_MCS4, MGN_MCS5, MGN_MCS6, MGN_MCS7};
948 PHY_SetTxPowerIndexByRateArray(padapter, RFPath,
949 pHalData->CurrentChannelBW,
950 Channel, htRates1T,
951 ARRAY_SIZE(htRates1T));
952
953 } else if (RateSection == HT_MCS8_MCS15) {
954 u8 htRates2T[] = {MGN_MCS8, MGN_MCS9, MGN_MCS10, MGN_MCS11, MGN_MCS12, MGN_MCS13, MGN_MCS14, MGN_MCS15};
955 PHY_SetTxPowerIndexByRateArray(padapter, RFPath,
956 pHalData->CurrentChannelBW,
957 Channel, htRates2T,
958 ARRAY_SIZE(htRates2T));
959
960 } else if (RateSection == HT_MCS16_MCS23) {
961 u8 htRates3T[] = {MGN_MCS16, MGN_MCS17, MGN_MCS18, MGN_MCS19, MGN_MCS20, MGN_MCS21, MGN_MCS22, MGN_MCS23};
962 PHY_SetTxPowerIndexByRateArray(padapter, RFPath,
963 pHalData->CurrentChannelBW,
964 Channel, htRates3T,
965 ARRAY_SIZE(htRates3T));
966
967 } else if (RateSection == HT_MCS24_MCS31) {
968 u8 htRates4T[] = {MGN_MCS24, MGN_MCS25, MGN_MCS26, MGN_MCS27, MGN_MCS28, MGN_MCS29, MGN_MCS30, MGN_MCS31};
969 PHY_SetTxPowerIndexByRateArray(padapter, RFPath,
970 pHalData->CurrentChannelBW,
971 Channel, htRates4T,
972 ARRAY_SIZE(htRates4T));
973
974 } else if (RateSection == VHT_1SSMCS0_1SSMCS9) {
975 u8 vhtRates1T[] = {MGN_VHT1SS_MCS0, MGN_VHT1SS_MCS1, MGN_VHT1SS_MCS2, MGN_VHT1SS_MCS3, MGN_VHT1SS_MCS4,
976 MGN_VHT1SS_MCS5, MGN_VHT1SS_MCS6, MGN_VHT1SS_MCS7, MGN_VHT1SS_MCS8, MGN_VHT1SS_MCS9};
977 PHY_SetTxPowerIndexByRateArray(padapter, RFPath,
978 pHalData->CurrentChannelBW,
979 Channel, vhtRates1T,
980 ARRAY_SIZE(vhtRates1T));
981
982 } else if (RateSection == VHT_2SSMCS0_2SSMCS9) {
983 u8 vhtRates2T[] = {MGN_VHT2SS_MCS0, MGN_VHT2SS_MCS1, MGN_VHT2SS_MCS2, MGN_VHT2SS_MCS3, MGN_VHT2SS_MCS4,
984 MGN_VHT2SS_MCS5, MGN_VHT2SS_MCS6, MGN_VHT2SS_MCS7, MGN_VHT2SS_MCS8, MGN_VHT2SS_MCS9};
985
986 PHY_SetTxPowerIndexByRateArray(padapter, RFPath,
987 pHalData->CurrentChannelBW,
988 Channel, vhtRates2T,
989 ARRAY_SIZE(vhtRates2T));
990 } else if (RateSection == VHT_3SSMCS0_3SSMCS9) {
991 u8 vhtRates3T[] = {MGN_VHT3SS_MCS0, MGN_VHT3SS_MCS1, MGN_VHT3SS_MCS2, MGN_VHT3SS_MCS3, MGN_VHT3SS_MCS4,
992 MGN_VHT3SS_MCS5, MGN_VHT3SS_MCS6, MGN_VHT3SS_MCS7, MGN_VHT3SS_MCS8, MGN_VHT3SS_MCS9};
993
994 PHY_SetTxPowerIndexByRateArray(padapter, RFPath,
995 pHalData->CurrentChannelBW,
996 Channel, vhtRates3T,
997 ARRAY_SIZE(vhtRates3T));
998 } else if (RateSection == VHT_4SSMCS0_4SSMCS9) {
999 u8 vhtRates4T[] = {MGN_VHT4SS_MCS0, MGN_VHT4SS_MCS1, MGN_VHT4SS_MCS2, MGN_VHT4SS_MCS3, MGN_VHT4SS_MCS4,
1000 MGN_VHT4SS_MCS5, MGN_VHT4SS_MCS6, MGN_VHT4SS_MCS7, MGN_VHT4SS_MCS8, MGN_VHT4SS_MCS9};
1001
1002 PHY_SetTxPowerIndexByRateArray(padapter, RFPath,
1003 pHalData->CurrentChannelBW,
1004 Channel, vhtRates4T,
1005 ARRAY_SIZE(vhtRates4T));
1006 } else
1007 DBG_871X("Invalid RateSection %d in %s", RateSection, __func__);
1008 }
1009
phy_GetChnlIndex(u8 Channel,u8 * ChannelIdx)1010 static bool phy_GetChnlIndex(u8 Channel, u8 *ChannelIdx)
1011 {
1012 u8 channel5G[CHANNEL_MAX_NUMBER_5G] = {
1013 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 100, 102,
1014 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130,
1015 132, 134, 136, 138, 140, 142, 144, 149, 151, 153, 155, 157, 159, 161,
1016 163, 165, 167, 168, 169, 171, 173, 175, 177
1017 };
1018 u8 i = 0;
1019 bool bIn24G = true;
1020
1021 if (Channel <= 14) {
1022 bIn24G = true;
1023 *ChannelIdx = Channel-1;
1024 } else {
1025 bIn24G = false;
1026
1027 for (i = 0; i < ARRAY_SIZE(channel5G); ++i) {
1028 if (channel5G[i] == Channel) {
1029 *ChannelIdx = i;
1030 return bIn24G;
1031 }
1032 }
1033 }
1034
1035 return bIn24G;
1036 }
1037
PHY_GetTxPowerIndexBase(struct adapter * padapter,u8 RFPath,u8 Rate,enum CHANNEL_WIDTH BandWidth,u8 Channel,bool * bIn24G)1038 u8 PHY_GetTxPowerIndexBase(
1039 struct adapter *padapter,
1040 u8 RFPath,
1041 u8 Rate,
1042 enum CHANNEL_WIDTH BandWidth,
1043 u8 Channel,
1044 bool *bIn24G
1045 )
1046 {
1047 struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
1048 u8 i = 0; /* default set to 1S */
1049 u8 txPower = 0;
1050 u8 chnlIdx = (Channel-1);
1051
1052 if (HAL_IsLegalChannel(padapter, Channel) == false) {
1053 chnlIdx = 0;
1054 DBG_871X("Illegal channel!!\n");
1055 }
1056
1057 *bIn24G = phy_GetChnlIndex(Channel, &chnlIdx);
1058
1059 /* DBG_871X("[%s] Channel Index: %d\n", (*bIn24G?"2.4G":"5G"), chnlIdx); */
1060
1061 if (*bIn24G) { /* 3 ============================== 2.4 G ============================== */
1062 if (IS_CCK_RATE(Rate))
1063 txPower = pHalData->Index24G_CCK_Base[RFPath][chnlIdx];
1064 else if (MGN_6M <= Rate)
1065 txPower = pHalData->Index24G_BW40_Base[RFPath][chnlIdx];
1066 else
1067 DBG_871X("PHY_GetTxPowerIndexBase: INVALID Rate.\n");
1068
1069 /* DBG_871X("Base Tx power(RF-%c, Rate #%d, Channel Index %d) = 0x%X\n", */
1070 /* ((RFPath == 0)?'A':'B'), Rate, chnlIdx, txPower); */
1071
1072 /* OFDM-1T */
1073 if ((MGN_6M <= Rate && Rate <= MGN_54M) && !IS_CCK_RATE(Rate)) {
1074 txPower += pHalData->OFDM_24G_Diff[RFPath][TX_1S];
1075 /* DBG_871X("+PowerDiff 2.4G (RF-%c): (OFDM-1T) = (%d)\n", ((RFPath == 0)?'A':'B'), pHalData->OFDM_24G_Diff[RFPath][TX_1S]); */
1076 }
1077 if (BandWidth == CHANNEL_WIDTH_20) { /* BW20-1S, BW20-2S */
1078 if ((MGN_MCS0 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT1SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1079 txPower += pHalData->BW20_24G_Diff[RFPath][TX_1S];
1080 if ((MGN_MCS8 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT2SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1081 txPower += pHalData->BW20_24G_Diff[RFPath][TX_2S];
1082 if ((MGN_MCS16 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT3SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1083 txPower += pHalData->BW20_24G_Diff[RFPath][TX_3S];
1084 if ((MGN_MCS24 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT4SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1085 txPower += pHalData->BW20_24G_Diff[RFPath][TX_4S];
1086
1087 /* DBG_871X("+PowerDiff 2.4G (RF-%c): (BW20-1S, BW20-2S, BW20-3S, BW20-4S) = (%d, %d, %d, %d)\n", ((RFPath == 0)?'A':(RFPath == 1)?'B':(RFPath ==2)?'C':'D'), */
1088 /* pHalData->BW20_24G_Diff[RFPath][TX_1S], pHalData->BW20_24G_Diff[RFPath][TX_2S], */
1089 /* pHalData->BW20_24G_Diff[RFPath][TX_3S], pHalData->BW20_24G_Diff[RFPath][TX_4S]); */
1090 } else if (BandWidth == CHANNEL_WIDTH_40) { /* BW40-1S, BW40-2S */
1091 if ((MGN_MCS0 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT1SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1092 txPower += pHalData->BW40_24G_Diff[RFPath][TX_1S];
1093 if ((MGN_MCS8 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT2SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1094 txPower += pHalData->BW40_24G_Diff[RFPath][TX_2S];
1095 if ((MGN_MCS16 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT3SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1096 txPower += pHalData->BW40_24G_Diff[RFPath][TX_3S];
1097 if ((MGN_MCS24 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT4SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1098 txPower += pHalData->BW40_24G_Diff[RFPath][TX_4S];
1099
1100 /* DBG_871X("+PowerDiff 2.4G (RF-%c): (BW40-1S, BW40-2S, BW40-3S, BW40-4S) = (%d, %d, %d, %d)\n", ((RFPath == 0)?'A':(RFPath == 1)?'B':(RFPath ==2)?'C':'D'), */
1101 /* pHalData->BW40_24G_Diff[RFPath][TX_1S], pHalData->BW40_24G_Diff[RFPath][TX_2S], */
1102 /* pHalData->BW40_24G_Diff[RFPath][TX_3S], pHalData->BW40_24G_Diff[RFPath][TX_4S]); */
1103 }
1104 /* Willis suggest adopt BW 40M power index while in BW 80 mode */
1105 else if (BandWidth == CHANNEL_WIDTH_80) {
1106 if ((MGN_MCS0 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT1SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1107 txPower += pHalData->BW40_24G_Diff[RFPath][TX_1S];
1108 if ((MGN_MCS8 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT2SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1109 txPower += pHalData->BW40_24G_Diff[RFPath][TX_2S];
1110 if ((MGN_MCS16 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT3SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1111 txPower += pHalData->BW40_24G_Diff[RFPath][TX_3S];
1112 if ((MGN_MCS24 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT4SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1113 txPower += pHalData->BW40_24G_Diff[RFPath][TX_4S];
1114
1115 /* DBG_871X("+PowerDiff 2.4G (RF-%c): (BW40-1S, BW40-2S, BW40-3S, BW40-4T) = (%d, %d, %d, %d) P.S. Current is in BW 80MHz\n", ((RFPath == 0)?'A':(RFPath == 1)?'B':(RFPath ==2)?'C':'D'), */
1116 /* pHalData->BW40_24G_Diff[RFPath][TX_1S], pHalData->BW40_24G_Diff[RFPath][TX_2S], */
1117 /* pHalData->BW40_24G_Diff[RFPath][TX_3S], pHalData->BW40_24G_Diff[RFPath][TX_4S]); */
1118 }
1119 } else {/* 3 ============================== 5 G ============================== */
1120 if (MGN_6M <= Rate)
1121 txPower = pHalData->Index5G_BW40_Base[RFPath][chnlIdx];
1122 else
1123 DBG_871X("===> mpt_ProQueryCalTxPower_Jaguar: INVALID Rate.\n");
1124
1125 /* DBG_871X("Base Tx power(RF-%c, Rate #%d, Channel Index %d) = 0x%X\n", */
1126 /* ((RFPath == 0)?'A':'B'), Rate, chnlIdx, txPower); */
1127
1128 /* OFDM-1T */
1129 if ((MGN_6M <= Rate && Rate <= MGN_54M) && !IS_CCK_RATE(Rate)) {
1130 txPower += pHalData->OFDM_5G_Diff[RFPath][TX_1S];
1131 /* DBG_871X("+PowerDiff 5G (RF-%c): (OFDM-1T) = (%d)\n", ((RFPath == 0)?'A':'B'), pHalData->OFDM_5G_Diff[RFPath][TX_1S]); */
1132 }
1133
1134 /* BW20-1S, BW20-2S */
1135 if (BandWidth == CHANNEL_WIDTH_20) {
1136 if ((MGN_MCS0 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT1SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1137 txPower += pHalData->BW20_5G_Diff[RFPath][TX_1S];
1138 if ((MGN_MCS8 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT2SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1139 txPower += pHalData->BW20_5G_Diff[RFPath][TX_2S];
1140 if ((MGN_MCS16 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT3SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1141 txPower += pHalData->BW20_5G_Diff[RFPath][TX_3S];
1142 if ((MGN_MCS24 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT4SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1143 txPower += pHalData->BW20_5G_Diff[RFPath][TX_4S];
1144
1145 /* DBG_871X("+PowerDiff 5G (RF-%c): (BW20-1S, BW20-2S, BW20-3S, BW20-4S) = (%d, %d, %d, %d)\n", ((RFPath == 0)?'A':(RFPath == 1)?'B':(RFPath ==2)?'C':'D'), */
1146 /* pHalData->BW20_5G_Diff[RFPath][TX_1S], pHalData->BW20_5G_Diff[RFPath][TX_2S], */
1147 /* pHalData->BW20_5G_Diff[RFPath][TX_3S], pHalData->BW20_5G_Diff[RFPath][TX_4S]); */
1148 } else if (BandWidth == CHANNEL_WIDTH_40) { /* BW40-1S, BW40-2S */
1149 if ((MGN_MCS0 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT1SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1150 txPower += pHalData->BW40_5G_Diff[RFPath][TX_1S];
1151 if ((MGN_MCS8 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT2SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1152 txPower += pHalData->BW40_5G_Diff[RFPath][TX_2S];
1153 if ((MGN_MCS16 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT3SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1154 txPower += pHalData->BW40_5G_Diff[RFPath][TX_3S];
1155 if ((MGN_MCS24 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT4SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1156 txPower += pHalData->BW40_5G_Diff[RFPath][TX_4S];
1157
1158 /* DBG_871X("+PowerDiff 5G(RF-%c): (BW40-1S, BW40-2S) = (%d, %d, %d, %d)\n", ((RFPath == 0)?'A':(RFPath == 1)?'B':(RFPath ==2)?'C':'D'), */
1159 /* pHalData->BW40_5G_Diff[RFPath][TX_1S], pHalData->BW40_5G_Diff[RFPath][TX_2S], */
1160 /* pHalData->BW40_5G_Diff[RFPath][TX_3S], pHalData->BW40_5G_Diff[RFPath][TX_4S]); */
1161 } else if (BandWidth == CHANNEL_WIDTH_80) { /* BW80-1S, BW80-2S */
1162 /* <20121220, Kordan> Get the index of array "Index5G_BW80_Base". */
1163 u8 channel5G_80M[CHANNEL_MAX_NUMBER_5G_80M] = {42, 58, 106, 122, 138, 155, 171};
1164 for (i = 0; i < ARRAY_SIZE(channel5G_80M); ++i)
1165 if (channel5G_80M[i] == Channel)
1166 chnlIdx = i;
1167
1168 txPower = pHalData->Index5G_BW80_Base[RFPath][chnlIdx];
1169
1170 if ((MGN_MCS0 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT1SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1171 txPower += + pHalData->BW80_5G_Diff[RFPath][TX_1S];
1172 if ((MGN_MCS8 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT2SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1173 txPower += pHalData->BW80_5G_Diff[RFPath][TX_2S];
1174 if ((MGN_MCS16 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT3SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1175 txPower += pHalData->BW80_5G_Diff[RFPath][TX_3S];
1176 if ((MGN_MCS23 <= Rate && Rate <= MGN_MCS31) || (MGN_VHT4SS_MCS0 <= Rate && Rate <= MGN_VHT4SS_MCS9))
1177 txPower += pHalData->BW80_5G_Diff[RFPath][TX_4S];
1178
1179 /* DBG_871X("+PowerDiff 5G(RF-%c): (BW80-1S, BW80-2S, BW80-3S, BW80-4S) = (%d, %d, %d, %d)\n", ((RFPath == 0)?'A':(RFPath == 1)?'B':(RFPath ==2)?'C':'D'), */
1180 /* pHalData->BW80_5G_Diff[RFPath][TX_1S], pHalData->BW80_5G_Diff[RFPath][TX_2S], */
1181 /* pHalData->BW80_5G_Diff[RFPath][TX_3S], pHalData->BW80_5G_Diff[RFPath][TX_4S]); */
1182 }
1183 }
1184
1185 return txPower;
1186 }
1187
PHY_GetTxPowerTrackingOffset(struct adapter * padapter,u8 RFPath,u8 Rate)1188 s8 PHY_GetTxPowerTrackingOffset(struct adapter *padapter, u8 RFPath, u8 Rate)
1189 {
1190 struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
1191 PDM_ODM_T pDM_Odm = &pHalData->odmpriv;
1192 s8 offset = 0;
1193
1194 if (pDM_Odm->RFCalibrateInfo.TxPowerTrackControl == false)
1195 return offset;
1196
1197 if ((Rate == MGN_1M) || (Rate == MGN_2M) || (Rate == MGN_5_5M) || (Rate == MGN_11M)) {
1198 offset = pDM_Odm->Remnant_CCKSwingIdx;
1199 /* DBG_871X("+Remnant_CCKSwingIdx = 0x%x\n", RFPath, Rate, pDM_Odm->Remnant_CCKSwingIdx); */
1200 } else {
1201 offset = pDM_Odm->Remnant_OFDMSwingIdx[RFPath];
1202 /* DBG_871X("+Remanant_OFDMSwingIdx[RFPath %u][Rate 0x%x] = 0x%x\n", RFPath, Rate, pDM_Odm->Remnant_OFDMSwingIdx[RFPath]); */
1203
1204 }
1205
1206 return offset;
1207 }
1208
PHY_GetRateIndexOfTxPowerByRate(u8 Rate)1209 u8 PHY_GetRateIndexOfTxPowerByRate(u8 Rate)
1210 {
1211 u8 index = 0;
1212 switch (Rate) {
1213 case MGN_1M:
1214 index = 0;
1215 break;
1216 case MGN_2M:
1217 index = 1;
1218 break;
1219 case MGN_5_5M:
1220 index = 2;
1221 break;
1222 case MGN_11M:
1223 index = 3;
1224 break;
1225 case MGN_6M:
1226 index = 4;
1227 break;
1228 case MGN_9M:
1229 index = 5;
1230 break;
1231 case MGN_12M:
1232 index = 6;
1233 break;
1234 case MGN_18M:
1235 index = 7;
1236 break;
1237 case MGN_24M:
1238 index = 8;
1239 break;
1240 case MGN_36M:
1241 index = 9;
1242 break;
1243 case MGN_48M:
1244 index = 10;
1245 break;
1246 case MGN_54M:
1247 index = 11;
1248 break;
1249 case MGN_MCS0:
1250 index = 12;
1251 break;
1252 case MGN_MCS1:
1253 index = 13;
1254 break;
1255 case MGN_MCS2:
1256 index = 14;
1257 break;
1258 case MGN_MCS3:
1259 index = 15;
1260 break;
1261 case MGN_MCS4:
1262 index = 16;
1263 break;
1264 case MGN_MCS5:
1265 index = 17;
1266 break;
1267 case MGN_MCS6:
1268 index = 18;
1269 break;
1270 case MGN_MCS7:
1271 index = 19;
1272 break;
1273 case MGN_MCS8:
1274 index = 20;
1275 break;
1276 case MGN_MCS9:
1277 index = 21;
1278 break;
1279 case MGN_MCS10:
1280 index = 22;
1281 break;
1282 case MGN_MCS11:
1283 index = 23;
1284 break;
1285 case MGN_MCS12:
1286 index = 24;
1287 break;
1288 case MGN_MCS13:
1289 index = 25;
1290 break;
1291 case MGN_MCS14:
1292 index = 26;
1293 break;
1294 case MGN_MCS15:
1295 index = 27;
1296 break;
1297 case MGN_MCS16:
1298 index = 28;
1299 break;
1300 case MGN_MCS17:
1301 index = 29;
1302 break;
1303 case MGN_MCS18:
1304 index = 30;
1305 break;
1306 case MGN_MCS19:
1307 index = 31;
1308 break;
1309 case MGN_MCS20:
1310 index = 32;
1311 break;
1312 case MGN_MCS21:
1313 index = 33;
1314 break;
1315 case MGN_MCS22:
1316 index = 34;
1317 break;
1318 case MGN_MCS23:
1319 index = 35;
1320 break;
1321 case MGN_MCS24:
1322 index = 36;
1323 break;
1324 case MGN_MCS25:
1325 index = 37;
1326 break;
1327 case MGN_MCS26:
1328 index = 38;
1329 break;
1330 case MGN_MCS27:
1331 index = 39;
1332 break;
1333 case MGN_MCS28:
1334 index = 40;
1335 break;
1336 case MGN_MCS29:
1337 index = 41;
1338 break;
1339 case MGN_MCS30:
1340 index = 42;
1341 break;
1342 case MGN_MCS31:
1343 index = 43;
1344 break;
1345 case MGN_VHT1SS_MCS0:
1346 index = 44;
1347 break;
1348 case MGN_VHT1SS_MCS1:
1349 index = 45;
1350 break;
1351 case MGN_VHT1SS_MCS2:
1352 index = 46;
1353 break;
1354 case MGN_VHT1SS_MCS3:
1355 index = 47;
1356 break;
1357 case MGN_VHT1SS_MCS4:
1358 index = 48;
1359 break;
1360 case MGN_VHT1SS_MCS5:
1361 index = 49;
1362 break;
1363 case MGN_VHT1SS_MCS6:
1364 index = 50;
1365 break;
1366 case MGN_VHT1SS_MCS7:
1367 index = 51;
1368 break;
1369 case MGN_VHT1SS_MCS8:
1370 index = 52;
1371 break;
1372 case MGN_VHT1SS_MCS9:
1373 index = 53;
1374 break;
1375 case MGN_VHT2SS_MCS0:
1376 index = 54;
1377 break;
1378 case MGN_VHT2SS_MCS1:
1379 index = 55;
1380 break;
1381 case MGN_VHT2SS_MCS2:
1382 index = 56;
1383 break;
1384 case MGN_VHT2SS_MCS3:
1385 index = 57;
1386 break;
1387 case MGN_VHT2SS_MCS4:
1388 index = 58;
1389 break;
1390 case MGN_VHT2SS_MCS5:
1391 index = 59;
1392 break;
1393 case MGN_VHT2SS_MCS6:
1394 index = 60;
1395 break;
1396 case MGN_VHT2SS_MCS7:
1397 index = 61;
1398 break;
1399 case MGN_VHT2SS_MCS8:
1400 index = 62;
1401 break;
1402 case MGN_VHT2SS_MCS9:
1403 index = 63;
1404 break;
1405 case MGN_VHT3SS_MCS0:
1406 index = 64;
1407 break;
1408 case MGN_VHT3SS_MCS1:
1409 index = 65;
1410 break;
1411 case MGN_VHT3SS_MCS2:
1412 index = 66;
1413 break;
1414 case MGN_VHT3SS_MCS3:
1415 index = 67;
1416 break;
1417 case MGN_VHT3SS_MCS4:
1418 index = 68;
1419 break;
1420 case MGN_VHT3SS_MCS5:
1421 index = 69;
1422 break;
1423 case MGN_VHT3SS_MCS6:
1424 index = 70;
1425 break;
1426 case MGN_VHT3SS_MCS7:
1427 index = 71;
1428 break;
1429 case MGN_VHT3SS_MCS8:
1430 index = 72;
1431 break;
1432 case MGN_VHT3SS_MCS9:
1433 index = 73;
1434 break;
1435 case MGN_VHT4SS_MCS0:
1436 index = 74;
1437 break;
1438 case MGN_VHT4SS_MCS1:
1439 index = 75;
1440 break;
1441 case MGN_VHT4SS_MCS2:
1442 index = 76;
1443 break;
1444 case MGN_VHT4SS_MCS3:
1445 index = 77;
1446 break;
1447 case MGN_VHT4SS_MCS4:
1448 index = 78;
1449 break;
1450 case MGN_VHT4SS_MCS5:
1451 index = 79;
1452 break;
1453 case MGN_VHT4SS_MCS6:
1454 index = 80;
1455 break;
1456 case MGN_VHT4SS_MCS7:
1457 index = 81;
1458 break;
1459 case MGN_VHT4SS_MCS8:
1460 index = 82;
1461 break;
1462 case MGN_VHT4SS_MCS9:
1463 index = 83;
1464 break;
1465 default:
1466 DBG_871X("Invalid rate 0x%x in %s\n", Rate, __func__);
1467 break;
1468 }
1469 return index;
1470 }
1471
PHY_GetTxPowerByRate(struct adapter * padapter,u8 Band,u8 RFPath,u8 TxNum,u8 Rate)1472 s8 PHY_GetTxPowerByRate(
1473 struct adapter *padapter, u8 Band, u8 RFPath, u8 TxNum, u8 Rate
1474 )
1475 {
1476 struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
1477 s8 value = 0;
1478 u8 rateIndex = PHY_GetRateIndexOfTxPowerByRate(Rate);
1479
1480 if ((padapter->registrypriv.RegEnableTxPowerByRate == 2 && pHalData->EEPROMRegulatory == 2) ||
1481 padapter->registrypriv.RegEnableTxPowerByRate == 0)
1482 return 0;
1483
1484 if (Band != BAND_ON_2_4G && Band != BAND_ON_5G) {
1485 DBG_871X("Invalid band %d in %s\n", Band, __func__);
1486 return value;
1487 }
1488 if (RFPath > ODM_RF_PATH_D) {
1489 DBG_871X("Invalid RfPath %d in %s\n", RFPath, __func__);
1490 return value;
1491 }
1492 if (TxNum >= RF_MAX_TX_NUM) {
1493 DBG_871X("Invalid TxNum %d in %s\n", TxNum, __func__);
1494 return value;
1495 }
1496 if (rateIndex >= TX_PWR_BY_RATE_NUM_RATE) {
1497 DBG_871X("Invalid RateIndex %d in %s\n", rateIndex, __func__);
1498 return value;
1499 }
1500
1501 value = pHalData->TxPwrByRateOffset[Band][RFPath][TxNum][rateIndex];
1502
1503 return value;
1504
1505 }
1506
PHY_SetTxPowerByRate(struct adapter * padapter,u8 Band,u8 RFPath,u8 TxNum,u8 Rate,s8 Value)1507 void PHY_SetTxPowerByRate(
1508 struct adapter *padapter,
1509 u8 Band,
1510 u8 RFPath,
1511 u8 TxNum,
1512 u8 Rate,
1513 s8 Value
1514 )
1515 {
1516 struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
1517 u8 rateIndex = PHY_GetRateIndexOfTxPowerByRate(Rate);
1518
1519 if (Band != BAND_ON_2_4G && Band != BAND_ON_5G) {
1520 DBG_871X("Invalid band %d in %s\n", Band, __func__);
1521 return;
1522 }
1523 if (RFPath > ODM_RF_PATH_D) {
1524 DBG_871X("Invalid RfPath %d in %s\n", RFPath, __func__);
1525 return;
1526 }
1527 if (TxNum >= RF_MAX_TX_NUM) {
1528 DBG_871X("Invalid TxNum %d in %s\n", TxNum, __func__);
1529 return;
1530 }
1531 if (rateIndex >= TX_PWR_BY_RATE_NUM_RATE) {
1532 DBG_871X("Invalid RateIndex %d in %s\n", rateIndex, __func__);
1533 return;
1534 }
1535
1536 pHalData->TxPwrByRateOffset[Band][RFPath][TxNum][rateIndex] = Value;
1537 }
1538
PHY_SetTxPowerLevelByPath(struct adapter * Adapter,u8 channel,u8 path)1539 void PHY_SetTxPowerLevelByPath(struct adapter *Adapter, u8 channel, u8 path)
1540 {
1541 struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
1542 bool bIsIn24G = (pHalData->CurrentBandType == BAND_ON_2_4G);
1543
1544 /* if (pMgntInfo->RegNByteAccess == 0) */
1545 {
1546 if (bIsIn24G)
1547 PHY_SetTxPowerIndexByRateSection(Adapter, path, channel, CCK);
1548
1549 PHY_SetTxPowerIndexByRateSection(Adapter, path, channel, OFDM);
1550 PHY_SetTxPowerIndexByRateSection(Adapter, path, channel, HT_MCS0_MCS7);
1551
1552 if (pHalData->NumTotalRFPath >= 2)
1553 PHY_SetTxPowerIndexByRateSection(Adapter, path, channel, HT_MCS8_MCS15);
1554
1555 }
1556 }
1557
PHY_SetTxPowerIndexByRateArray(struct adapter * padapter,u8 RFPath,enum CHANNEL_WIDTH BandWidth,u8 Channel,u8 * Rates,u8 RateArraySize)1558 void PHY_SetTxPowerIndexByRateArray(
1559 struct adapter *padapter,
1560 u8 RFPath,
1561 enum CHANNEL_WIDTH BandWidth,
1562 u8 Channel,
1563 u8 *Rates,
1564 u8 RateArraySize
1565 )
1566 {
1567 u32 powerIndex = 0;
1568 int i = 0;
1569
1570 for (i = 0; i < RateArraySize; ++i) {
1571 powerIndex = PHY_GetTxPowerIndex(padapter, RFPath, Rates[i], BandWidth, Channel);
1572 PHY_SetTxPowerIndex(padapter, powerIndex, RFPath, Rates[i]);
1573 }
1574 }
1575
phy_GetWorldWideLimit(s8 * LimitTable)1576 static s8 phy_GetWorldWideLimit(s8 *LimitTable)
1577 {
1578 s8 min = LimitTable[0];
1579 u8 i = 0;
1580
1581 for (i = 0; i < MAX_REGULATION_NUM; ++i) {
1582 if (LimitTable[i] < min)
1583 min = LimitTable[i];
1584 }
1585
1586 return min;
1587 }
1588
phy_GetChannelIndexOfTxPowerLimit(u8 Band,u8 Channel)1589 static s8 phy_GetChannelIndexOfTxPowerLimit(u8 Band, u8 Channel)
1590 {
1591 s8 channelIndex = -1;
1592 u8 channel5G[CHANNEL_MAX_NUMBER_5G] = {
1593 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 100, 102,
1594 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130,
1595 132, 134, 136, 138, 140, 142, 144, 149, 151, 153, 155, 157, 159, 161,
1596 163, 165, 167, 168, 169, 171, 173, 175, 177
1597 };
1598 u8 i = 0;
1599 if (Band == BAND_ON_2_4G)
1600 channelIndex = Channel - 1;
1601 else if (Band == BAND_ON_5G) {
1602 for (i = 0; i < ARRAY_SIZE(channel5G); ++i) {
1603 if (channel5G[i] == Channel)
1604 channelIndex = i;
1605 }
1606 } else
1607 DBG_871X("Invalid Band %d in %s", Band, __func__);
1608
1609 if (channelIndex == -1)
1610 DBG_871X("Invalid Channel %d of Band %d in %s", Channel, Band, __func__);
1611
1612 return channelIndex;
1613 }
1614
get_bandwidth_idx(const enum CHANNEL_WIDTH bandwidth)1615 static s16 get_bandwidth_idx(const enum CHANNEL_WIDTH bandwidth)
1616 {
1617 switch (bandwidth) {
1618 case CHANNEL_WIDTH_20:
1619 return 0;
1620 case CHANNEL_WIDTH_40:
1621 return 1;
1622 case CHANNEL_WIDTH_80:
1623 return 2;
1624 case CHANNEL_WIDTH_160:
1625 return 3;
1626 default:
1627 return -1;
1628 }
1629 }
1630
get_rate_sctn_idx(const u8 rate)1631 static s16 get_rate_sctn_idx(const u8 rate)
1632 {
1633 switch (rate) {
1634 case MGN_1M: case MGN_2M: case MGN_5_5M: case MGN_11M:
1635 return 0;
1636 case MGN_6M: case MGN_9M: case MGN_12M: case MGN_18M:
1637 case MGN_24M: case MGN_36M: case MGN_48M: case MGN_54M:
1638 return 1;
1639 case MGN_MCS0: case MGN_MCS1: case MGN_MCS2: case MGN_MCS3:
1640 case MGN_MCS4: case MGN_MCS5: case MGN_MCS6: case MGN_MCS7:
1641 return 2;
1642 case MGN_MCS8: case MGN_MCS9: case MGN_MCS10: case MGN_MCS11:
1643 case MGN_MCS12: case MGN_MCS13: case MGN_MCS14: case MGN_MCS15:
1644 return 3;
1645 case MGN_MCS16: case MGN_MCS17: case MGN_MCS18: case MGN_MCS19:
1646 case MGN_MCS20: case MGN_MCS21: case MGN_MCS22: case MGN_MCS23:
1647 return 4;
1648 case MGN_MCS24: case MGN_MCS25: case MGN_MCS26: case MGN_MCS27:
1649 case MGN_MCS28: case MGN_MCS29: case MGN_MCS30: case MGN_MCS31:
1650 return 5;
1651 case MGN_VHT1SS_MCS0: case MGN_VHT1SS_MCS1: case MGN_VHT1SS_MCS2:
1652 case MGN_VHT1SS_MCS3: case MGN_VHT1SS_MCS4: case MGN_VHT1SS_MCS5:
1653 case MGN_VHT1SS_MCS6: case MGN_VHT1SS_MCS7: case MGN_VHT1SS_MCS8:
1654 case MGN_VHT1SS_MCS9:
1655 return 6;
1656 case MGN_VHT2SS_MCS0: case MGN_VHT2SS_MCS1: case MGN_VHT2SS_MCS2:
1657 case MGN_VHT2SS_MCS3: case MGN_VHT2SS_MCS4: case MGN_VHT2SS_MCS5:
1658 case MGN_VHT2SS_MCS6: case MGN_VHT2SS_MCS7: case MGN_VHT2SS_MCS8:
1659 case MGN_VHT2SS_MCS9:
1660 return 7;
1661 case MGN_VHT3SS_MCS0: case MGN_VHT3SS_MCS1: case MGN_VHT3SS_MCS2:
1662 case MGN_VHT3SS_MCS3: case MGN_VHT3SS_MCS4: case MGN_VHT3SS_MCS5:
1663 case MGN_VHT3SS_MCS6: case MGN_VHT3SS_MCS7: case MGN_VHT3SS_MCS8:
1664 case MGN_VHT3SS_MCS9:
1665 return 8;
1666 case MGN_VHT4SS_MCS0: case MGN_VHT4SS_MCS1: case MGN_VHT4SS_MCS2:
1667 case MGN_VHT4SS_MCS3: case MGN_VHT4SS_MCS4: case MGN_VHT4SS_MCS5:
1668 case MGN_VHT4SS_MCS6: case MGN_VHT4SS_MCS7: case MGN_VHT4SS_MCS8:
1669 case MGN_VHT4SS_MCS9:
1670 return 9;
1671 default:
1672 DBG_871X("Wrong rate 0x%x\n", rate);
1673 return -1;
1674 }
1675 }
1676
phy_get_tx_pwr_lmt(struct adapter * adapter,u32 reg_pwr_tbl_sel,enum BAND_TYPE band_type,enum CHANNEL_WIDTH bandwidth,u8 rf_path,u8 data_rate,u8 channel)1677 s8 phy_get_tx_pwr_lmt(struct adapter *adapter, u32 reg_pwr_tbl_sel,
1678 enum BAND_TYPE band_type, enum CHANNEL_WIDTH bandwidth,
1679 u8 rf_path, u8 data_rate, u8 channel)
1680 {
1681 s16 idx_band = -1;
1682 s16 idx_regulation = -1;
1683 s16 idx_bandwidth = -1;
1684 s16 idx_rate_sctn = -1;
1685 s16 idx_channel = -1;
1686 s8 pwr_lmt = MAX_POWER_INDEX;
1687 struct hal_com_data *hal_data = GET_HAL_DATA(adapter);
1688
1689 if (((adapter->registrypriv.RegEnableTxPowerLimit == 2) &&
1690 (hal_data->EEPROMRegulatory != 1)) ||
1691 (adapter->registrypriv.RegEnableTxPowerLimit == 0))
1692 return MAX_POWER_INDEX;
1693
1694 switch (adapter->registrypriv.RegPwrTblSel) {
1695 case 1:
1696 idx_regulation = TXPWR_LMT_ETSI;
1697 break;
1698 case 2:
1699 idx_regulation = TXPWR_LMT_MKK;
1700 break;
1701 case 3:
1702 idx_regulation = TXPWR_LMT_FCC;
1703 break;
1704 case 4:
1705 idx_regulation = TXPWR_LMT_WW;
1706 break;
1707 default:
1708 idx_regulation = (band_type == BAND_ON_2_4G) ?
1709 hal_data->Regulation2_4G :
1710 hal_data->Regulation5G;
1711 break;
1712 }
1713
1714 /* DBG_871X("pMgntInfo->RegPwrTblSel %d, final regulation %d\n", */
1715 /* adapter->registrypriv.RegPwrTblSel, idx_regulation); */
1716
1717 if (band_type == BAND_ON_2_4G)
1718 idx_band = 0;
1719 else if (band_type == BAND_ON_5G)
1720 idx_band = 1;
1721
1722 idx_bandwidth = get_bandwidth_idx(bandwidth);
1723 idx_rate_sctn = get_rate_sctn_idx(data_rate);
1724
1725 if (band_type == BAND_ON_5G && idx_rate_sctn == 0)
1726 DBG_871X("Wrong rate 0x%x: No CCK in 5G Band\n", DataRate);
1727
1728 /* workaround for wrong index combination to obtain tx power limit, */
1729 /* OFDM only exists in BW 20M */
1730 /* CCK table will only be given in BW 20M */
1731 /* HT on 80M will reference to HT on 40M */
1732 if (idx_rate_sctn == 0 || idx_rate_sctn == 1)
1733 idx_bandwidth = 0;
1734 else if ((idx_rate_sctn == 2 || idx_rate_sctn == 3) &&
1735 (band_type == BAND_ON_5G) && (idx_bandwidth == 2))
1736 idx_bandwidth = 1;
1737
1738 if (band_type == BAND_ON_2_4G || band_type == BAND_ON_5G)
1739 channel = phy_GetChannelIndexOfTxPowerLimit(band_type, channel);
1740
1741 if (idx_band == -1 || idx_regulation == -1 || idx_bandwidth == -1 ||
1742 idx_rate_sctn == -1 || idx_channel == -1) {
1743 /* DBG_871X("Wrong index value to access power limit table [band %d][regulation %d][bandwidth %d][rf_path %d][rate_section %d][chnlGroup %d]\n", */
1744 /* idx_band, idx_regulation, idx_bandwidth, rf_path, */
1745 /* idx_rate_sctn, channel); */
1746
1747 return MAX_POWER_INDEX;
1748 }
1749
1750 if (band_type == BAND_ON_2_4G) {
1751 s8 limits[10] = {0}; u8 i = 0;
1752
1753 for (i = 0; i < MAX_REGULATION_NUM; i++)
1754 limits[i] = hal_data->TxPwrLimit_2_4G[i]
1755 [idx_bandwidth]
1756 [idx_rate_sctn]
1757 [idx_channel]
1758 [rf_path];
1759
1760 pwr_lmt = (idx_regulation == TXPWR_LMT_WW) ?
1761 phy_GetWorldWideLimit(limits) :
1762 hal_data->TxPwrLimit_2_4G[idx_regulation]
1763 [idx_bandwidth]
1764 [idx_rate_sctn]
1765 [idx_channel]
1766 [rf_path];
1767
1768 } else if (band_type == BAND_ON_5G) {
1769 s8 limits[10] = {0}; u8 i = 0;
1770
1771 for (i = 0; i < MAX_REGULATION_NUM; ++i)
1772 limits[i] = hal_data->TxPwrLimit_5G[i]
1773 [idx_bandwidth]
1774 [idx_rate_sctn]
1775 [idx_channel]
1776 [rf_path];
1777
1778 pwr_lmt = (idx_regulation == TXPWR_LMT_WW) ?
1779 phy_GetWorldWideLimit(limits) :
1780 hal_data->TxPwrLimit_5G[idx_regulation]
1781 [idx_bandwidth]
1782 [idx_rate_sctn]
1783 [idx_channel]
1784 [rf_path];
1785 } else {
1786 DBG_871X("No power limit table of the specified band\n");
1787 }
1788
1789 /* combine 5G VHT & HT rate */
1790 /* 5G 20M and 40M HT and VHT can cross reference */
1791 /*
1792 if (band_type == BAND_ON_5G && pwr_lmt == MAX_POWER_INDEX) {
1793 if (idx_bandwidth == 0 || idx_bandwidth == 1) {
1794 RT_TRACE(COMP_INIT, DBG_LOUD, ("No power limit table of the specified band %d, bandwidth %d, ratesection %d, rf path %d\n",
1795 idx_band, idx_bandwidth,
1796 idx_rate_sctn, rf_path));
1797 if (idx_rate_sctn == 2)
1798 pwr_lmt = hal_data->TxPwrLimit_5G[idx_regulation][idx_bandwidth][4][idx_channel][rf_path];
1799 else if (idx_rate_sctn == 4)
1800 pwr_lmt = hal_data->TxPwrLimit_5G[idx_regulation][idx_bandwidth][2][idx_channel][rf_path];
1801 else if (idx_rate_sctn == 3)
1802 pwr_lmt = hal_data->TxPwrLimit_5G[idx_regulation][idx_bandwidth][5][idx_channel][rf_path];
1803 else if (idx_rate_sctn == 5)
1804 pwr_lmt = hal_data->TxPwrLimit_5G[idx_regulation][idx_bandwidth][3][idx_channel][rf_path];
1805 }
1806 }
1807 */
1808
1809 /* DBG_871X("TxPwrLmt[Regulation %d][Band %d][BW %d][RFPath %d][Rate 0x%x][Chnl %d] = %d\n", */
1810 /* idx_regulation, hal_data->CurrentBandType, bandwidth, rf_path, data_rate, channel, pwr_lmt); */
1811 return pwr_lmt;
1812 }
1813
phy_CrossReferenceHTAndVHTTxPowerLimit(struct adapter * padapter)1814 static void phy_CrossReferenceHTAndVHTTxPowerLimit(struct adapter *padapter)
1815 {
1816 struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
1817 u8 regulation, bw, channel, rateSection;
1818 s8 tempPwrLmt = 0;
1819
1820 for (regulation = 0; regulation < MAX_REGULATION_NUM; ++regulation) {
1821 for (bw = 0; bw < MAX_5G_BANDWITH_NUM; ++bw) {
1822 for (channel = 0; channel < CHANNEL_MAX_NUMBER_5G; ++channel) {
1823 for (rateSection = 0; rateSection < MAX_RATE_SECTION_NUM; ++rateSection) {
1824 tempPwrLmt = pHalData->TxPwrLimit_5G[regulation][bw][rateSection][channel][ODM_RF_PATH_A];
1825 if (tempPwrLmt == MAX_POWER_INDEX) {
1826 u8 baseSection = 2, refSection = 6;
1827 if (bw == 0 || bw == 1) { /* 5G 20M 40M VHT and HT can cross reference */
1828 /* DBG_871X("No power limit table of the specified band %d, bandwidth %d, ratesection %d, channel %d, rf path %d\n", */
1829 /* 1, bw, rateSection, channel, ODM_RF_PATH_A); */
1830 if (rateSection >= 2 && rateSection <= 9) {
1831 if (rateSection == 2) {
1832 baseSection = 2;
1833 refSection = 6;
1834 } else if (rateSection == 3) {
1835 baseSection = 3;
1836 refSection = 7;
1837 } else if (rateSection == 4) {
1838 baseSection = 4;
1839 refSection = 8;
1840 } else if (rateSection == 5) {
1841 baseSection = 5;
1842 refSection = 9;
1843 } else if (rateSection == 6) {
1844 baseSection = 6;
1845 refSection = 2;
1846 } else if (rateSection == 7) {
1847 baseSection = 7;
1848 refSection = 3;
1849 } else if (rateSection == 8) {
1850 baseSection = 8;
1851 refSection = 4;
1852 } else if (rateSection == 9) {
1853 baseSection = 9;
1854 refSection = 5;
1855 }
1856 pHalData->TxPwrLimit_5G[regulation][bw][baseSection][channel][ODM_RF_PATH_A] =
1857 pHalData->TxPwrLimit_5G[regulation][bw][refSection][channel][ODM_RF_PATH_A];
1858 }
1859
1860 /* DBG_871X("use other value %d", tempPwrLmt); */
1861 }
1862 }
1863 }
1864 }
1865 }
1866 }
1867 }
1868
PHY_ConvertTxPowerLimitToPowerIndex(struct adapter * Adapter)1869 void PHY_ConvertTxPowerLimitToPowerIndex(struct adapter *Adapter)
1870 {
1871 struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
1872 u8 BW40PwrBasedBm2_4G = 0x2E;
1873 u8 regulation, bw, channel, rateSection;
1874 s8 tempValue = 0, tempPwrLmt = 0;
1875 u8 rfPath = 0;
1876
1877 /* DBG_871X("=====> PHY_ConvertTxPowerLimitToPowerIndex()\n"); */
1878
1879 phy_CrossReferenceHTAndVHTTxPowerLimit(Adapter);
1880
1881 for (regulation = 0; regulation < MAX_REGULATION_NUM; ++regulation) {
1882 for (bw = 0; bw < MAX_2_4G_BANDWITH_NUM; ++bw) {
1883 for (channel = 0; channel < CHANNEL_MAX_NUMBER_2G; ++channel) {
1884 for (rateSection = 0; rateSection < MAX_RATE_SECTION_NUM; ++rateSection) {
1885 tempPwrLmt = pHalData->TxPwrLimit_2_4G[regulation][bw][rateSection][channel][ODM_RF_PATH_A];
1886
1887 for (rfPath = ODM_RF_PATH_A; rfPath < MAX_RF_PATH_NUM; ++rfPath) {
1888 if (pHalData->odmpriv.PhyRegPgValueType == PHY_REG_PG_EXACT_VALUE) {
1889 if (rateSection == 5) /* HT 4T */
1890 BW40PwrBasedBm2_4G = PHY_GetTxPowerByRateBase(Adapter, BAND_ON_2_4G, rfPath, RF_4TX, HT_MCS24_MCS31);
1891 else if (rateSection == 4) /* HT 3T */
1892 BW40PwrBasedBm2_4G = PHY_GetTxPowerByRateBase(Adapter, BAND_ON_2_4G, rfPath, RF_3TX, HT_MCS16_MCS23);
1893 else if (rateSection == 3) /* HT 2T */
1894 BW40PwrBasedBm2_4G = PHY_GetTxPowerByRateBase(Adapter, BAND_ON_2_4G, rfPath, RF_2TX, HT_MCS8_MCS15);
1895 else if (rateSection == 2) /* HT 1T */
1896 BW40PwrBasedBm2_4G = PHY_GetTxPowerByRateBase(Adapter, BAND_ON_2_4G, rfPath, RF_1TX, HT_MCS0_MCS7);
1897 else if (rateSection == 1) /* OFDM */
1898 BW40PwrBasedBm2_4G = PHY_GetTxPowerByRateBase(Adapter, BAND_ON_2_4G, rfPath, RF_1TX, OFDM);
1899 else if (rateSection == 0) /* CCK */
1900 BW40PwrBasedBm2_4G = PHY_GetTxPowerByRateBase(Adapter, BAND_ON_2_4G, rfPath, RF_1TX, CCK);
1901 } else
1902 BW40PwrBasedBm2_4G = Adapter->registrypriv.RegPowerBase * 2;
1903
1904 if (tempPwrLmt != MAX_POWER_INDEX) {
1905 tempValue = tempPwrLmt - BW40PwrBasedBm2_4G;
1906 pHalData->TxPwrLimit_2_4G[regulation][bw][rateSection][channel][rfPath] = tempValue;
1907 }
1908 }
1909 }
1910 }
1911 }
1912 }
1913
1914 /* DBG_871X("<===== PHY_ConvertTxPowerLimitToPowerIndex()\n"); */
1915 }
1916
PHY_InitTxPowerLimit(struct adapter * Adapter)1917 void PHY_InitTxPowerLimit(struct adapter *Adapter)
1918 {
1919 struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
1920 u8 i, j, k, l, m;
1921
1922 /* DBG_871X("=====> PHY_InitTxPowerLimit()!\n"); */
1923
1924 for (i = 0; i < MAX_REGULATION_NUM; ++i) {
1925 for (j = 0; j < MAX_2_4G_BANDWITH_NUM; ++j)
1926 for (k = 0; k < MAX_RATE_SECTION_NUM; ++k)
1927 for (m = 0; m < CHANNEL_MAX_NUMBER_2G; ++m)
1928 for (l = 0; l < MAX_RF_PATH_NUM; ++l)
1929 pHalData->TxPwrLimit_2_4G[i][j][k][m][l] = MAX_POWER_INDEX;
1930 }
1931
1932 for (i = 0; i < MAX_REGULATION_NUM; ++i) {
1933 for (j = 0; j < MAX_5G_BANDWITH_NUM; ++j)
1934 for (k = 0; k < MAX_RATE_SECTION_NUM; ++k)
1935 for (m = 0; m < CHANNEL_MAX_NUMBER_5G; ++m)
1936 for (l = 0; l < MAX_RF_PATH_NUM; ++l)
1937 pHalData->TxPwrLimit_5G[i][j][k][m][l] = MAX_POWER_INDEX;
1938 }
1939
1940 /* DBG_871X("<===== PHY_InitTxPowerLimit()!\n"); */
1941 }
1942
PHY_SetTxPowerLimit(struct adapter * Adapter,u8 * Regulation,u8 * Band,u8 * Bandwidth,u8 * RateSection,u8 * RfPath,u8 * Channel,u8 * PowerLimit)1943 void PHY_SetTxPowerLimit(
1944 struct adapter *Adapter,
1945 u8 *Regulation,
1946 u8 *Band,
1947 u8 *Bandwidth,
1948 u8 *RateSection,
1949 u8 *RfPath,
1950 u8 *Channel,
1951 u8 *PowerLimit
1952 )
1953 {
1954 struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
1955 u8 regulation = 0, bandwidth = 0, rateSection = 0, channel;
1956 s8 powerLimit = 0, prevPowerLimit, channelIndex;
1957
1958 /* DBG_871X("Index of power limit table [band %s][regulation %s][bw %s][rate section %s][rf path %s][chnl %s][val %s]\n", */
1959 /* Band, Regulation, Bandwidth, RateSection, RfPath, Channel, PowerLimit); */
1960
1961 if (!GetU1ByteIntegerFromStringInDecimal((s8 *)Channel, &channel) ||
1962 !GetU1ByteIntegerFromStringInDecimal((s8 *)PowerLimit, &powerLimit))
1963 DBG_871X("Illegal index of power limit table [chnl %s][val %s]\n", Channel, PowerLimit);
1964
1965 powerLimit = powerLimit > MAX_POWER_INDEX ? MAX_POWER_INDEX : powerLimit;
1966
1967 if (eqNByte(Regulation, (u8 *)("FCC"), 3))
1968 regulation = 0;
1969 else if (eqNByte(Regulation, (u8 *)("MKK"), 3))
1970 regulation = 1;
1971 else if (eqNByte(Regulation, (u8 *)("ETSI"), 4))
1972 regulation = 2;
1973 else if (eqNByte(Regulation, (u8 *)("WW13"), 4))
1974 regulation = 3;
1975
1976 if (eqNByte(RateSection, (u8 *)("CCK"), 3) && eqNByte(RfPath, (u8 *)("1T"), 2))
1977 rateSection = 0;
1978 else if (eqNByte(RateSection, (u8 *)("OFDM"), 4) && eqNByte(RfPath, (u8 *)("1T"), 2))
1979 rateSection = 1;
1980 else if (eqNByte(RateSection, (u8 *)("HT"), 2) && eqNByte(RfPath, (u8 *)("1T"), 2))
1981 rateSection = 2;
1982 else if (eqNByte(RateSection, (u8 *)("HT"), 2) && eqNByte(RfPath, (u8 *)("2T"), 2))
1983 rateSection = 3;
1984 else if (eqNByte(RateSection, (u8 *)("HT"), 2) && eqNByte(RfPath, (u8 *)("3T"), 2))
1985 rateSection = 4;
1986 else if (eqNByte(RateSection, (u8 *)("HT"), 2) && eqNByte(RfPath, (u8 *)("4T"), 2))
1987 rateSection = 5;
1988 else if (eqNByte(RateSection, (u8 *)("VHT"), 3) && eqNByte(RfPath, (u8 *)("1T"), 2))
1989 rateSection = 6;
1990 else if (eqNByte(RateSection, (u8 *)("VHT"), 3) && eqNByte(RfPath, (u8 *)("2T"), 2))
1991 rateSection = 7;
1992 else if (eqNByte(RateSection, (u8 *)("VHT"), 3) && eqNByte(RfPath, (u8 *)("3T"), 2))
1993 rateSection = 8;
1994 else if (eqNByte(RateSection, (u8 *)("VHT"), 3) && eqNByte(RfPath, (u8 *)("4T"), 2))
1995 rateSection = 9;
1996 else {
1997 DBG_871X("Wrong rate section!\n");
1998 return;
1999 }
2000
2001
2002 if (eqNByte(Bandwidth, (u8 *)("20M"), 3))
2003 bandwidth = 0;
2004 else if (eqNByte(Bandwidth, (u8 *)("40M"), 3))
2005 bandwidth = 1;
2006 else if (eqNByte(Bandwidth, (u8 *)("80M"), 3))
2007 bandwidth = 2;
2008 else if (eqNByte(Bandwidth, (u8 *)("160M"), 4))
2009 bandwidth = 3;
2010
2011 if (eqNByte(Band, (u8 *)("2.4G"), 4)) {
2012 channelIndex = phy_GetChannelIndexOfTxPowerLimit(BAND_ON_2_4G, channel);
2013
2014 if (channelIndex == -1)
2015 return;
2016
2017 prevPowerLimit = pHalData->TxPwrLimit_2_4G[regulation][bandwidth][rateSection][channelIndex][ODM_RF_PATH_A];
2018
2019 if (powerLimit < prevPowerLimit)
2020 pHalData->TxPwrLimit_2_4G[regulation][bandwidth][rateSection][channelIndex][ODM_RF_PATH_A] = powerLimit;
2021
2022 /* DBG_871X("2.4G Band value : [regulation %d][bw %d][rate_section %d][chnl %d][val %d]\n", */
2023 /* regulation, bandwidth, rateSection, channelIndex, pHalData->TxPwrLimit_2_4G[regulation][bandwidth][rateSection][channelIndex][ODM_RF_PATH_A]); */
2024 } else if (eqNByte(Band, (u8 *)("5G"), 2)) {
2025 channelIndex = phy_GetChannelIndexOfTxPowerLimit(BAND_ON_5G, channel);
2026
2027 if (channelIndex == -1)
2028 return;
2029
2030 prevPowerLimit = pHalData->TxPwrLimit_5G[regulation][bandwidth][rateSection][channelIndex][ODM_RF_PATH_A];
2031
2032 if (powerLimit < prevPowerLimit)
2033 pHalData->TxPwrLimit_5G[regulation][bandwidth][rateSection][channelIndex][ODM_RF_PATH_A] = powerLimit;
2034
2035 /* DBG_871X("5G Band value : [regulation %d][bw %d][rate_section %d][chnl %d][val %d]\n", */
2036 /* regulation, bandwidth, rateSection, channel, pHalData->TxPwrLimit_5G[regulation][bandwidth][rateSection][channelIndex][ODM_RF_PATH_A]); */
2037 } else {
2038 DBG_871X("Cannot recognize the band info in %s\n", Band);
2039 return;
2040 }
2041 }
2042
Hal_ChannelPlanToRegulation(struct adapter * Adapter,u16 ChannelPlan)2043 void Hal_ChannelPlanToRegulation(struct adapter *Adapter, u16 ChannelPlan)
2044 {
2045 struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
2046 pHalData->Regulation2_4G = TXPWR_LMT_WW;
2047 pHalData->Regulation5G = TXPWR_LMT_WW;
2048
2049 switch (ChannelPlan) {
2050 case RT_CHANNEL_DOMAIN_WORLD_NULL:
2051 pHalData->Regulation2_4G = TXPWR_LMT_WW;
2052 break;
2053 case RT_CHANNEL_DOMAIN_ETSI1_NULL:
2054 pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2055 break;
2056 case RT_CHANNEL_DOMAIN_FCC1_NULL:
2057 pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2058 break;
2059 case RT_CHANNEL_DOMAIN_MKK1_NULL:
2060 pHalData->Regulation2_4G = TXPWR_LMT_MKK;
2061 break;
2062 case RT_CHANNEL_DOMAIN_ETSI2_NULL:
2063 pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2064 break;
2065 case RT_CHANNEL_DOMAIN_FCC1_FCC1:
2066 pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2067 pHalData->Regulation5G = TXPWR_LMT_FCC;
2068 break;
2069 case RT_CHANNEL_DOMAIN_WORLD_ETSI1:
2070 pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2071 pHalData->Regulation5G = TXPWR_LMT_ETSI;
2072 break;
2073 case RT_CHANNEL_DOMAIN_MKK1_MKK1:
2074 pHalData->Regulation2_4G = TXPWR_LMT_MKK;
2075 pHalData->Regulation5G = TXPWR_LMT_MKK;
2076 break;
2077 case RT_CHANNEL_DOMAIN_WORLD_KCC1:
2078 pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2079 pHalData->Regulation5G = TXPWR_LMT_MKK;
2080 break;
2081 case RT_CHANNEL_DOMAIN_WORLD_FCC2:
2082 pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2083 pHalData->Regulation5G = TXPWR_LMT_FCC;
2084 break;
2085 case RT_CHANNEL_DOMAIN_WORLD_FCC3:
2086 pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2087 pHalData->Regulation5G = TXPWR_LMT_FCC;
2088 break;
2089 case RT_CHANNEL_DOMAIN_WORLD_FCC4:
2090 pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2091 pHalData->Regulation5G = TXPWR_LMT_FCC;
2092 break;
2093 case RT_CHANNEL_DOMAIN_WORLD_FCC5:
2094 pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2095 pHalData->Regulation5G = TXPWR_LMT_FCC;
2096 break;
2097 case RT_CHANNEL_DOMAIN_WORLD_FCC6:
2098 pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2099 pHalData->Regulation5G = TXPWR_LMT_FCC;
2100 break;
2101 case RT_CHANNEL_DOMAIN_FCC1_FCC7:
2102 pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2103 pHalData->Regulation5G = TXPWR_LMT_FCC;
2104 break;
2105 case RT_CHANNEL_DOMAIN_WORLD_ETSI2:
2106 pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2107 pHalData->Regulation5G = TXPWR_LMT_FCC;
2108 break;
2109 case RT_CHANNEL_DOMAIN_WORLD_ETSI3:
2110 pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2111 pHalData->Regulation5G = TXPWR_LMT_FCC;
2112 break;
2113 case RT_CHANNEL_DOMAIN_MKK1_MKK2:
2114 pHalData->Regulation2_4G = TXPWR_LMT_MKK;
2115 pHalData->Regulation5G = TXPWR_LMT_FCC;
2116 break;
2117 case RT_CHANNEL_DOMAIN_MKK1_MKK3:
2118 pHalData->Regulation2_4G = TXPWR_LMT_MKK;
2119 pHalData->Regulation5G = TXPWR_LMT_FCC;
2120 break;
2121 case RT_CHANNEL_DOMAIN_FCC1_NCC1:
2122 pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2123 pHalData->Regulation5G = TXPWR_LMT_FCC;
2124 break;
2125 case RT_CHANNEL_DOMAIN_FCC1_NCC2:
2126 pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2127 pHalData->Regulation5G = TXPWR_LMT_FCC;
2128 break;
2129 case RT_CHANNEL_DOMAIN_GLOBAL_NULL:
2130 pHalData->Regulation2_4G = TXPWR_LMT_WW;
2131 pHalData->Regulation5G = TXPWR_LMT_WW;
2132 break;
2133 case RT_CHANNEL_DOMAIN_ETSI1_ETSI4:
2134 pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2135 pHalData->Regulation5G = TXPWR_LMT_ETSI;
2136 break;
2137 case RT_CHANNEL_DOMAIN_FCC1_FCC2:
2138 pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2139 pHalData->Regulation5G = TXPWR_LMT_FCC;
2140 break;
2141 case RT_CHANNEL_DOMAIN_FCC1_NCC3:
2142 pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2143 pHalData->Regulation5G = TXPWR_LMT_FCC;
2144 break;
2145 case RT_CHANNEL_DOMAIN_WORLD_ETSI5:
2146 pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2147 pHalData->Regulation5G = TXPWR_LMT_ETSI;
2148 break;
2149 case RT_CHANNEL_DOMAIN_FCC1_FCC8:
2150 pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2151 pHalData->Regulation5G = TXPWR_LMT_FCC;
2152 break;
2153 case RT_CHANNEL_DOMAIN_WORLD_ETSI6:
2154 pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2155 pHalData->Regulation5G = TXPWR_LMT_ETSI;
2156 break;
2157 case RT_CHANNEL_DOMAIN_WORLD_ETSI7:
2158 pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2159 pHalData->Regulation5G = TXPWR_LMT_ETSI;
2160 break;
2161 case RT_CHANNEL_DOMAIN_WORLD_ETSI8:
2162 pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2163 pHalData->Regulation5G = TXPWR_LMT_ETSI;
2164 break;
2165 case RT_CHANNEL_DOMAIN_WORLD_ETSI9:
2166 pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2167 pHalData->Regulation5G = TXPWR_LMT_ETSI;
2168 break;
2169 case RT_CHANNEL_DOMAIN_WORLD_ETSI10:
2170 pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2171 pHalData->Regulation5G = TXPWR_LMT_ETSI;
2172 break;
2173 case RT_CHANNEL_DOMAIN_WORLD_ETSI11:
2174 pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2175 pHalData->Regulation5G = TXPWR_LMT_ETSI;
2176 break;
2177 case RT_CHANNEL_DOMAIN_FCC1_NCC4:
2178 pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2179 pHalData->Regulation5G = TXPWR_LMT_FCC;
2180 break;
2181 case RT_CHANNEL_DOMAIN_WORLD_ETSI12:
2182 pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2183 pHalData->Regulation5G = TXPWR_LMT_ETSI;
2184 break;
2185 case RT_CHANNEL_DOMAIN_FCC1_FCC9:
2186 pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2187 pHalData->Regulation5G = TXPWR_LMT_FCC;
2188 break;
2189 case RT_CHANNEL_DOMAIN_WORLD_ETSI13:
2190 pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
2191 pHalData->Regulation5G = TXPWR_LMT_ETSI;
2192 break;
2193 case RT_CHANNEL_DOMAIN_FCC1_FCC10:
2194 pHalData->Regulation2_4G = TXPWR_LMT_FCC;
2195 pHalData->Regulation5G = TXPWR_LMT_FCC;
2196 break;
2197 case RT_CHANNEL_DOMAIN_REALTEK_DEFINE: /* Realtek Reserve */
2198 pHalData->Regulation2_4G = TXPWR_LMT_WW;
2199 pHalData->Regulation5G = TXPWR_LMT_WW;
2200 break;
2201 default:
2202 break;
2203 }
2204 }
2205
2206
2207 static char file_path_bs[PATH_MAX];
2208
2209 #define GetLineFromBuffer(buffer) strsep(&buffer, "\n")
2210
phy_ConfigMACWithParaFile(struct adapter * Adapter,char * pFileName)2211 int phy_ConfigMACWithParaFile(struct adapter *Adapter, char *pFileName)
2212 {
2213 struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
2214 int rlen = 0, rtStatus = _FAIL;
2215 char *szLine, *ptmp;
2216 u32 u4bRegOffset, u4bRegValue, u4bMove;
2217
2218 if (!(Adapter->registrypriv.load_phy_file & LOAD_MAC_PARA_FILE))
2219 return rtStatus;
2220
2221 memset(pHalData->para_file_buf, 0, MAX_PARA_FILE_BUF_LEN);
2222
2223 if ((pHalData->mac_reg_len == 0) && !pHalData->mac_reg) {
2224 rtw_merge_string(file_path_bs, PATH_MAX, rtw_phy_file_path, pFileName);
2225
2226 if (rtw_is_file_readable(file_path_bs) == true) {
2227 rlen = rtw_retrive_from_file(file_path_bs, pHalData->para_file_buf, MAX_PARA_FILE_BUF_LEN);
2228 if (rlen > 0) {
2229 rtStatus = _SUCCESS;
2230 pHalData->mac_reg = vzalloc(rlen);
2231 if (pHalData->mac_reg) {
2232 memcpy(pHalData->mac_reg, pHalData->para_file_buf, rlen);
2233 pHalData->mac_reg_len = rlen;
2234 } else
2235 DBG_871X("%s mac_reg alloc fail !\n", __func__);
2236 }
2237 }
2238 } else {
2239 if ((pHalData->mac_reg_len != 0) && (pHalData->mac_reg != NULL)) {
2240 memcpy(pHalData->para_file_buf, pHalData->mac_reg, pHalData->mac_reg_len);
2241 rtStatus = _SUCCESS;
2242 } else
2243 DBG_871X("%s(): Critical Error !!!\n", __func__);
2244 }
2245
2246 if (rtStatus == _SUCCESS) {
2247 ptmp = pHalData->para_file_buf;
2248 for (szLine = GetLineFromBuffer(ptmp); szLine != NULL; szLine = GetLineFromBuffer(ptmp)) {
2249 if (!IsCommentString(szLine)) {
2250 /* Get 1st hex value as register offset */
2251 if (GetHexValueFromString(szLine, &u4bRegOffset, &u4bMove)) {
2252 if (u4bRegOffset == 0xffff) /* Ending. */
2253 break;
2254
2255 /* Get 2nd hex value as register value. */
2256 szLine += u4bMove;
2257 if (GetHexValueFromString(szLine, &u4bRegValue, &u4bMove))
2258 rtw_write8(Adapter, u4bRegOffset, (u8)u4bRegValue);
2259 }
2260 }
2261 }
2262 } else
2263 DBG_871X("%s(): No File %s, Load from HWImg Array!\n", __func__, pFileName);
2264
2265 return rtStatus;
2266 }
2267
phy_ConfigBBWithParaFile(struct adapter * Adapter,char * pFileName,u32 ConfigType)2268 int phy_ConfigBBWithParaFile(
2269 struct adapter *Adapter, char *pFileName, u32 ConfigType
2270 )
2271 {
2272 struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
2273 int rlen = 0, rtStatus = _FAIL;
2274 char *szLine, *ptmp;
2275 u32 u4bRegOffset, u4bRegValue, u4bMove;
2276 char *pBuf = NULL;
2277 u32 *pBufLen = NULL;
2278
2279 if (!(Adapter->registrypriv.load_phy_file & LOAD_BB_PARA_FILE))
2280 return rtStatus;
2281
2282 switch (ConfigType) {
2283 case CONFIG_BB_PHY_REG:
2284 pBuf = pHalData->bb_phy_reg;
2285 pBufLen = &pHalData->bb_phy_reg_len;
2286 break;
2287 case CONFIG_BB_AGC_TAB:
2288 pBuf = pHalData->bb_agc_tab;
2289 pBufLen = &pHalData->bb_agc_tab_len;
2290 break;
2291 default:
2292 DBG_871X("Unknown ConfigType!! %d\r\n", ConfigType);
2293 break;
2294 }
2295
2296 memset(pHalData->para_file_buf, 0, MAX_PARA_FILE_BUF_LEN);
2297
2298 if (pBufLen && (*pBufLen == 0) && !pBuf) {
2299 rtw_merge_string(file_path_bs, PATH_MAX, rtw_phy_file_path, pFileName);
2300
2301 if (rtw_is_file_readable(file_path_bs) == true) {
2302 rlen = rtw_retrive_from_file(file_path_bs, pHalData->para_file_buf, MAX_PARA_FILE_BUF_LEN);
2303 if (rlen > 0) {
2304 rtStatus = _SUCCESS;
2305 pBuf = vzalloc(rlen);
2306 if (pBuf) {
2307 memcpy(pBuf, pHalData->para_file_buf, rlen);
2308 *pBufLen = rlen;
2309
2310 switch (ConfigType) {
2311 case CONFIG_BB_PHY_REG:
2312 pHalData->bb_phy_reg = pBuf;
2313 break;
2314 case CONFIG_BB_AGC_TAB:
2315 pHalData->bb_agc_tab = pBuf;
2316 break;
2317 }
2318 } else
2319 DBG_871X("%s(): ConfigType %d alloc fail !\n", __func__, ConfigType);
2320 }
2321 }
2322 } else {
2323 if (pBufLen && (*pBufLen == 0) && !pBuf) {
2324 memcpy(pHalData->para_file_buf, pBuf, *pBufLen);
2325 rtStatus = _SUCCESS;
2326 } else
2327 DBG_871X("%s(): Critical Error !!!\n", __func__);
2328 }
2329
2330 if (rtStatus == _SUCCESS) {
2331 ptmp = pHalData->para_file_buf;
2332 for (szLine = GetLineFromBuffer(ptmp); szLine != NULL; szLine = GetLineFromBuffer(ptmp)) {
2333 if (!IsCommentString(szLine)) {
2334 /* Get 1st hex value as register offset. */
2335 if (GetHexValueFromString(szLine, &u4bRegOffset, &u4bMove)) {
2336 if (u4bRegOffset == 0xffff) /* Ending. */
2337 break;
2338 else if (u4bRegOffset == 0xfe || u4bRegOffset == 0xffe)
2339 msleep(50);
2340 else if (u4bRegOffset == 0xfd)
2341 mdelay(5);
2342 else if (u4bRegOffset == 0xfc)
2343 mdelay(1);
2344 else if (u4bRegOffset == 0xfb)
2345 udelay(50);
2346 else if (u4bRegOffset == 0xfa)
2347 udelay(5);
2348 else if (u4bRegOffset == 0xf9)
2349 udelay(1);
2350
2351 /* Get 2nd hex value as register value. */
2352 szLine += u4bMove;
2353 if (GetHexValueFromString(szLine, &u4bRegValue, &u4bMove)) {
2354 /* DBG_871X("[BB-ADDR]%03lX =%08lX\n", u4bRegOffset, u4bRegValue); */
2355 PHY_SetBBReg(Adapter, u4bRegOffset, bMaskDWord, u4bRegValue);
2356
2357 if (u4bRegOffset == 0xa24)
2358 pHalData->odmpriv.RFCalibrateInfo.RegA24 = u4bRegValue;
2359
2360 /* Add 1us delay between BB/RF register setting. */
2361 udelay(1);
2362 }
2363 }
2364 }
2365 }
2366 } else
2367 DBG_871X("%s(): No File %s, Load from HWImg Array!\n", __func__, pFileName);
2368
2369 return rtStatus;
2370 }
2371
phy_DecryptBBPgParaFile(struct adapter * Adapter,char * buffer)2372 static void phy_DecryptBBPgParaFile(struct adapter *Adapter, char *buffer)
2373 {
2374 u32 i = 0, j = 0;
2375 u8 map[95] = {0};
2376 u8 currentChar;
2377 char *BufOfLines, *ptmp;
2378
2379 /* DBG_871X("=====>phy_DecryptBBPgParaFile()\n"); */
2380 /* 32 the ascii code of the first visable char, 126 the last one */
2381 for (i = 0; i < 95; ++i)
2382 map[i] = (u8) (94 - i);
2383
2384 ptmp = buffer;
2385 i = 0;
2386 for (BufOfLines = GetLineFromBuffer(ptmp); BufOfLines != NULL; BufOfLines = GetLineFromBuffer(ptmp)) {
2387 /* DBG_871X("Encrypted Line: %s\n", BufOfLines); */
2388
2389 for (j = 0; j < strlen(BufOfLines); ++j) {
2390 currentChar = BufOfLines[j];
2391
2392 if (currentChar == '\0')
2393 break;
2394
2395 currentChar -= (u8) ((((i + j) * 3) % 128));
2396
2397 BufOfLines[j] = map[currentChar - 32] + 32;
2398 }
2399 /* DBG_871X("Decrypted Line: %s\n", BufOfLines); */
2400 if (strlen(BufOfLines) != 0)
2401 i++;
2402 BufOfLines[strlen(BufOfLines)] = '\n';
2403 }
2404 }
2405
phy_ParseBBPgParaFile(struct adapter * Adapter,char * buffer)2406 static int phy_ParseBBPgParaFile(struct adapter *Adapter, char *buffer)
2407 {
2408 int rtStatus = _SUCCESS;
2409 struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
2410 char *szLine, *ptmp;
2411 u32 u4bRegOffset, u4bRegMask, u4bRegValue;
2412 u32 u4bMove;
2413 bool firstLine = true;
2414 u8 tx_num = 0;
2415 u8 band = 0, rf_path = 0;
2416
2417 /* DBG_871X("=====>phy_ParseBBPgParaFile()\n"); */
2418
2419 if (Adapter->registrypriv.RegDecryptCustomFile == 1)
2420 phy_DecryptBBPgParaFile(Adapter, buffer);
2421
2422 ptmp = buffer;
2423 for (szLine = GetLineFromBuffer(ptmp); szLine != NULL; szLine = GetLineFromBuffer(ptmp)) {
2424 if (!IsCommentString(szLine)) {
2425 if (isAllSpaceOrTab(szLine, sizeof(*szLine)))
2426 continue;
2427
2428 /* Get header info (relative value or exact value) */
2429 if (firstLine) {
2430 if (eqNByte(szLine, (u8 *)("#[v1]"), 5)) {
2431
2432 pHalData->odmpriv.PhyRegPgVersion = szLine[3] - '0';
2433 /* DBG_871X("This is a new format PHY_REG_PG.txt\n"); */
2434 } else if (eqNByte(szLine, (u8 *)("#[v0]"), 5)) {
2435 pHalData->odmpriv.PhyRegPgVersion = szLine[3] - '0';
2436 /* DBG_871X("This is a old format PHY_REG_PG.txt ok\n"); */
2437 } else {
2438 DBG_871X("The format in PHY_REG_PG are invalid %s\n", szLine);
2439 return _FAIL;
2440 }
2441
2442 if (eqNByte(szLine + 5, (u8 *)("[Exact]#"), 8)) {
2443 pHalData->odmpriv.PhyRegPgValueType = PHY_REG_PG_EXACT_VALUE;
2444 /* DBG_871X("The values in PHY_REG_PG are exact values ok\n"); */
2445 firstLine = false;
2446 continue;
2447 } else if (eqNByte(szLine + 5, (u8 *)("[Relative]#"), 11)) {
2448 pHalData->odmpriv.PhyRegPgValueType = PHY_REG_PG_RELATIVE_VALUE;
2449 /* DBG_871X("The values in PHY_REG_PG are relative values ok\n"); */
2450 firstLine = false;
2451 continue;
2452 } else {
2453 DBG_871X("The values in PHY_REG_PG are invalid %s\n", szLine);
2454 return _FAIL;
2455 }
2456 }
2457
2458 if (pHalData->odmpriv.PhyRegPgVersion == 0) {
2459 /* Get 1st hex value as register offset. */
2460 if (GetHexValueFromString(szLine, &u4bRegOffset, &u4bMove)) {
2461 szLine += u4bMove;
2462 if (u4bRegOffset == 0xffff) /* Ending. */
2463 break;
2464
2465 /* Get 2nd hex value as register mask. */
2466 if (GetHexValueFromString(szLine, &u4bRegMask, &u4bMove))
2467 szLine += u4bMove;
2468 else
2469 return _FAIL;
2470
2471 if (pHalData->odmpriv.PhyRegPgValueType == PHY_REG_PG_RELATIVE_VALUE) {
2472 /* Get 3rd hex value as register value. */
2473 if (GetHexValueFromString(szLine, &u4bRegValue, &u4bMove)) {
2474 PHY_StoreTxPowerByRate(Adapter, 0, 0, 1, u4bRegOffset, u4bRegMask, u4bRegValue);
2475 /* DBG_871X("[ADDR] %03X =%08X Mask =%08x\n", u4bRegOffset, u4bRegValue, u4bRegMask); */
2476 } else
2477 return _FAIL;
2478 } else if (pHalData->odmpriv.PhyRegPgValueType == PHY_REG_PG_EXACT_VALUE) {
2479 u32 combineValue = 0;
2480 u8 integer = 0, fraction = 0;
2481
2482 if (GetFractionValueFromString(szLine, &integer, &fraction, &u4bMove))
2483 szLine += u4bMove;
2484 else
2485 return _FAIL;
2486
2487 integer *= 2;
2488 if (fraction == 5)
2489 integer += 1;
2490 combineValue |= (((integer / 10) << 4) + (integer % 10));
2491 /* DBG_871X(" %d", integer); */
2492
2493 if (GetFractionValueFromString(szLine, &integer, &fraction, &u4bMove))
2494 szLine += u4bMove;
2495 else
2496 return _FAIL;
2497
2498 integer *= 2;
2499 if (fraction == 5)
2500 integer += 1;
2501 combineValue <<= 8;
2502 combineValue |= (((integer / 10) << 4) + (integer % 10));
2503 /* DBG_871X(" %d", integer); */
2504
2505 if (GetFractionValueFromString(szLine, &integer, &fraction, &u4bMove))
2506 szLine += u4bMove;
2507 else
2508 return _FAIL;
2509
2510 integer *= 2;
2511 if (fraction == 5)
2512 integer += 1;
2513 combineValue <<= 8;
2514 combineValue |= (((integer / 10) << 4) + (integer % 10));
2515 /* DBG_871X(" %d", integer); */
2516
2517 if (GetFractionValueFromString(szLine, &integer, &fraction, &u4bMove))
2518 szLine += u4bMove;
2519 else
2520 return _FAIL;
2521
2522 integer *= 2;
2523 if (fraction == 5)
2524 integer += 1;
2525 combineValue <<= 8;
2526 combineValue |= (((integer / 10) << 4) + (integer % 10));
2527 /* DBG_871X(" %d", integer); */
2528 PHY_StoreTxPowerByRate(Adapter, 0, 0, 1, u4bRegOffset, u4bRegMask, combineValue);
2529
2530 /* DBG_871X("[ADDR] 0x%3x = 0x%4x\n", u4bRegOffset, combineValue); */
2531 }
2532 }
2533 } else if (pHalData->odmpriv.PhyRegPgVersion > 0) {
2534 u32 index = 0;
2535
2536 if (eqNByte(szLine, "0xffff", 6))
2537 break;
2538
2539 if (!eqNByte("#[END]#", szLine, 7)) {
2540 /* load the table label info */
2541 if (szLine[0] == '#') {
2542 index = 0;
2543 if (eqNByte(szLine, "#[2.4G]", 7)) {
2544 band = BAND_ON_2_4G;
2545 index += 8;
2546 } else if (eqNByte(szLine, "#[5G]", 5)) {
2547 band = BAND_ON_5G;
2548 index += 6;
2549 } else {
2550 DBG_871X("Invalid band %s in PHY_REG_PG.txt\n", szLine);
2551 return _FAIL;
2552 }
2553
2554 rf_path = szLine[index] - 'A';
2555 /* DBG_871X(" Table label Band %d, RfPath %d\n", band, rf_path); */
2556 } else { /* load rows of tables */
2557 if (szLine[1] == '1')
2558 tx_num = RF_1TX;
2559 else if (szLine[1] == '2')
2560 tx_num = RF_2TX;
2561 else if (szLine[1] == '3')
2562 tx_num = RF_3TX;
2563 else if (szLine[1] == '4')
2564 tx_num = RF_4TX;
2565 else {
2566 DBG_871X("Invalid row in PHY_REG_PG.txt %c\n", szLine[1]);
2567 return _FAIL;
2568 }
2569
2570 while (szLine[index] != ']')
2571 ++index;
2572 ++index;/* skip ] */
2573
2574 /* Get 2nd hex value as register offset. */
2575 szLine += index;
2576 if (GetHexValueFromString(szLine, &u4bRegOffset, &u4bMove))
2577 szLine += u4bMove;
2578 else
2579 return _FAIL;
2580
2581 /* Get 2nd hex value as register mask. */
2582 if (GetHexValueFromString(szLine, &u4bRegMask, &u4bMove))
2583 szLine += u4bMove;
2584 else
2585 return _FAIL;
2586
2587 if (pHalData->odmpriv.PhyRegPgValueType == PHY_REG_PG_RELATIVE_VALUE) {
2588 /* Get 3rd hex value as register value. */
2589 if (GetHexValueFromString(szLine, &u4bRegValue, &u4bMove)) {
2590 PHY_StoreTxPowerByRate(Adapter, band, rf_path, tx_num, u4bRegOffset, u4bRegMask, u4bRegValue);
2591 /* DBG_871X("[ADDR] %03X (tx_num %d) =%08X Mask =%08x\n", u4bRegOffset, tx_num, u4bRegValue, u4bRegMask); */
2592 } else
2593 return _FAIL;
2594 } else if (pHalData->odmpriv.PhyRegPgValueType == PHY_REG_PG_EXACT_VALUE) {
2595 u32 combineValue = 0;
2596 u8 integer = 0, fraction = 0;
2597
2598 if (GetFractionValueFromString(szLine, &integer, &fraction, &u4bMove))
2599 szLine += u4bMove;
2600 else
2601 return _FAIL;
2602
2603 integer *= 2;
2604 if (fraction == 5)
2605 integer += 1;
2606 combineValue |= (((integer / 10) << 4) + (integer % 10));
2607 /* DBG_871X(" %d", integer); */
2608
2609 if (GetFractionValueFromString(szLine, &integer, &fraction, &u4bMove))
2610 szLine += u4bMove;
2611 else
2612 return _FAIL;
2613
2614 integer *= 2;
2615 if (fraction == 5)
2616 integer += 1;
2617 combineValue <<= 8;
2618 combineValue |= (((integer / 10) << 4) + (integer % 10));
2619 /* DBG_871X(" %d", integer); */
2620
2621 if (GetFractionValueFromString(szLine, &integer, &fraction, &u4bMove))
2622 szLine += u4bMove;
2623 else
2624 return _FAIL;
2625
2626 integer *= 2;
2627 if (fraction == 5)
2628 integer += 1;
2629 combineValue <<= 8;
2630 combineValue |= (((integer / 10) << 4) + (integer % 10));
2631 /* DBG_871X(" %d", integer); */
2632
2633 if (GetFractionValueFromString(szLine, &integer, &fraction, &u4bMove))
2634 szLine += u4bMove;
2635 else
2636 return _FAIL;
2637
2638 integer *= 2;
2639 if (fraction == 5)
2640 integer += 1;
2641 combineValue <<= 8;
2642 combineValue |= (((integer / 10) << 4) + (integer % 10));
2643 /* DBG_871X(" %d", integer); */
2644 PHY_StoreTxPowerByRate(Adapter, band, rf_path, tx_num, u4bRegOffset, u4bRegMask, combineValue);
2645
2646 /* DBG_871X("[ADDR] 0x%3x (tx_num %d) = 0x%4x\n", u4bRegOffset, tx_num, combineValue); */
2647 }
2648 }
2649 }
2650 }
2651 }
2652 }
2653 /* DBG_871X("<=====phy_ParseBBPgParaFile()\n"); */
2654 return rtStatus;
2655 }
2656
phy_ConfigBBWithPgParaFile(struct adapter * Adapter,char * pFileName)2657 int phy_ConfigBBWithPgParaFile(struct adapter *Adapter, char *pFileName)
2658 {
2659 struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
2660 int rlen = 0, rtStatus = _FAIL;
2661
2662 if (!(Adapter->registrypriv.load_phy_file & LOAD_BB_PG_PARA_FILE))
2663 return rtStatus;
2664
2665 memset(pHalData->para_file_buf, 0, MAX_PARA_FILE_BUF_LEN);
2666
2667 if ((pHalData->bb_phy_reg_pg_len == 0) && !pHalData->bb_phy_reg_pg) {
2668 rtw_merge_string(file_path_bs, PATH_MAX, rtw_phy_file_path, pFileName);
2669
2670 if (rtw_is_file_readable(file_path_bs) == true) {
2671 rlen = rtw_retrive_from_file(file_path_bs, pHalData->para_file_buf, MAX_PARA_FILE_BUF_LEN);
2672 if (rlen > 0) {
2673 rtStatus = _SUCCESS;
2674 pHalData->bb_phy_reg_pg = vzalloc(rlen);
2675 if (pHalData->bb_phy_reg_pg) {
2676 memcpy(pHalData->bb_phy_reg_pg, pHalData->para_file_buf, rlen);
2677 pHalData->bb_phy_reg_pg_len = rlen;
2678 } else
2679 DBG_871X("%s bb_phy_reg_pg alloc fail !\n", __func__);
2680 }
2681 }
2682 } else {
2683 if ((pHalData->bb_phy_reg_pg_len != 0) && (pHalData->bb_phy_reg_pg != NULL)) {
2684 memcpy(pHalData->para_file_buf, pHalData->bb_phy_reg_pg, pHalData->bb_phy_reg_pg_len);
2685 rtStatus = _SUCCESS;
2686 } else
2687 DBG_871X("%s(): Critical Error !!!\n", __func__);
2688 }
2689
2690 if (rtStatus == _SUCCESS) {
2691 /* DBG_871X("phy_ConfigBBWithPgParaFile(): read %s ok\n", pFileName); */
2692 phy_ParseBBPgParaFile(Adapter, pHalData->para_file_buf);
2693 } else
2694 DBG_871X("%s(): No File %s, Load from HWImg Array!\n", __func__, pFileName);
2695
2696 return rtStatus;
2697 }
2698
PHY_ConfigRFWithParaFile(struct adapter * Adapter,char * pFileName,u8 eRFPath)2699 int PHY_ConfigRFWithParaFile(
2700 struct adapter *Adapter, char *pFileName, u8 eRFPath
2701 )
2702 {
2703 struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
2704 int rlen = 0, rtStatus = _FAIL;
2705 char *szLine, *ptmp;
2706 u32 u4bRegOffset, u4bRegValue, u4bMove;
2707 u16 i;
2708 char *pBuf = NULL;
2709 u32 *pBufLen = NULL;
2710
2711 if (!(Adapter->registrypriv.load_phy_file & LOAD_RF_PARA_FILE))
2712 return rtStatus;
2713
2714 switch (eRFPath) {
2715 case ODM_RF_PATH_A:
2716 pBuf = pHalData->rf_radio_a;
2717 pBufLen = &pHalData->rf_radio_a_len;
2718 break;
2719 case ODM_RF_PATH_B:
2720 pBuf = pHalData->rf_radio_b;
2721 pBufLen = &pHalData->rf_radio_b_len;
2722 break;
2723 default:
2724 DBG_871X("Unknown RF path!! %d\r\n", eRFPath);
2725 break;
2726 }
2727
2728 memset(pHalData->para_file_buf, 0, MAX_PARA_FILE_BUF_LEN);
2729
2730 if (pBufLen && (*pBufLen == 0) && !pBuf) {
2731 rtw_merge_string(file_path_bs, PATH_MAX, rtw_phy_file_path, pFileName);
2732
2733 if (rtw_is_file_readable(file_path_bs) == true) {
2734 rlen = rtw_retrive_from_file(file_path_bs, pHalData->para_file_buf, MAX_PARA_FILE_BUF_LEN);
2735 if (rlen > 0) {
2736 rtStatus = _SUCCESS;
2737 pBuf = vzalloc(rlen);
2738 if (pBuf) {
2739 memcpy(pBuf, pHalData->para_file_buf, rlen);
2740 *pBufLen = rlen;
2741
2742 switch (eRFPath) {
2743 case ODM_RF_PATH_A:
2744 pHalData->rf_radio_a = pBuf;
2745 break;
2746 case ODM_RF_PATH_B:
2747 pHalData->rf_radio_b = pBuf;
2748 break;
2749 }
2750 } else
2751 DBG_871X("%s(): eRFPath =%d alloc fail !\n", __func__, eRFPath);
2752 }
2753 }
2754 } else {
2755 if (pBufLen && (*pBufLen == 0) && !pBuf) {
2756 memcpy(pHalData->para_file_buf, pBuf, *pBufLen);
2757 rtStatus = _SUCCESS;
2758 } else
2759 DBG_871X("%s(): Critical Error !!!\n", __func__);
2760 }
2761
2762 if (rtStatus == _SUCCESS) {
2763 /* DBG_871X("%s(): read %s successfully\n", __func__, pFileName); */
2764
2765 ptmp = pHalData->para_file_buf;
2766 for (szLine = GetLineFromBuffer(ptmp); szLine != NULL; szLine = GetLineFromBuffer(ptmp)) {
2767 if (!IsCommentString(szLine)) {
2768 /* Get 1st hex value as register offset. */
2769 if (GetHexValueFromString(szLine, &u4bRegOffset, &u4bMove)) {
2770 if (u4bRegOffset == 0xfe || u4bRegOffset == 0xffe) /* Deay specific ms. Only RF configuration require delay. */
2771 msleep(50);
2772 else if (u4bRegOffset == 0xfd) {
2773 /* mdelay(5); */
2774 for (i = 0; i < 100; i++)
2775 udelay(MAX_STALL_TIME);
2776 } else if (u4bRegOffset == 0xfc) {
2777 /* mdelay(1); */
2778 for (i = 0; i < 20; i++)
2779 udelay(MAX_STALL_TIME);
2780 } else if (u4bRegOffset == 0xfb)
2781 udelay(50);
2782 else if (u4bRegOffset == 0xfa)
2783 udelay(5);
2784 else if (u4bRegOffset == 0xf9)
2785 udelay(1);
2786 else if (u4bRegOffset == 0xffff)
2787 break;
2788
2789 /* Get 2nd hex value as register value. */
2790 szLine += u4bMove;
2791 if (GetHexValueFromString(szLine, &u4bRegValue, &u4bMove)) {
2792 PHY_SetRFReg(Adapter, eRFPath, u4bRegOffset, bRFRegOffsetMask, u4bRegValue);
2793
2794 /* Temp add, for frequency lock, if no delay, that may cause */
2795 /* frequency shift, ex: 2412MHz => 2417MHz */
2796 /* If frequency shift, the following action may works. */
2797 /* Fractional-N table in radio_a.txt */
2798 /* 0x2a 0x00001 channel 1 */
2799 /* 0x2b 0x00808 frequency divider. */
2800 /* 0x2b 0x53333 */
2801 /* 0x2c 0x0000c */
2802 udelay(1);
2803 }
2804 }
2805 }
2806 }
2807 } else
2808 DBG_871X("%s(): No File %s, Load from HWImg Array!\n", __func__, pFileName);
2809
2810 return rtStatus;
2811 }
2812
initDeltaSwingIndexTables(struct adapter * Adapter,char * Band,char * Path,char * Sign,char * Channel,char * Rate,char * Data)2813 static void initDeltaSwingIndexTables(
2814 struct adapter *Adapter,
2815 char *Band,
2816 char *Path,
2817 char *Sign,
2818 char *Channel,
2819 char *Rate,
2820 char *Data
2821 )
2822 {
2823 #define STR_EQUAL_5G(_band, _path, _sign, _rate, _chnl) \
2824 ((strcmp(Band, _band) == 0) && (strcmp(Path, _path) == 0) && (strcmp(Sign, _sign) == 0) &&\
2825 (strcmp(Rate, _rate) == 0) && (strcmp(Channel, _chnl) == 0)\
2826 )
2827 #define STR_EQUAL_2G(_band, _path, _sign, _rate) \
2828 ((strcmp(Band, _band) == 0) && (strcmp(Path, _path) == 0) && (strcmp(Sign, _sign) == 0) &&\
2829 (strcmp(Rate, _rate) == 0)\
2830 )
2831
2832 #define STORE_SWING_TABLE(_array, _iteratedIdx) \
2833 for (token = strsep(&Data, delim); token != NULL; token = strsep(&Data, delim)) {\
2834 sscanf(token, "%d", &idx);\
2835 _array[_iteratedIdx++] = (u8)idx;\
2836 } \
2837
2838 struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
2839 PDM_ODM_T pDM_Odm = &pHalData->odmpriv;
2840 PODM_RF_CAL_T pRFCalibrateInfo = &(pDM_Odm->RFCalibrateInfo);
2841 u32 j = 0;
2842 char *token;
2843 char delim[] = ",";
2844 u32 idx = 0;
2845
2846 /* DBG_871X("===>initDeltaSwingIndexTables(): Band: %s;\nPath: %s;\nSign: %s;\nChannel: %s;\nRate: %s;\n, Data: %s;\n", */
2847 /* Band, Path, Sign, Channel, Rate, Data); */
2848
2849 if (STR_EQUAL_2G("2G", "A", "+", "CCK")) {
2850 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKA_P, j);
2851 } else if (STR_EQUAL_2G("2G", "A", "-", "CCK")) {
2852 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKA_N, j);
2853 } else if (STR_EQUAL_2G("2G", "B", "+", "CCK")) {
2854 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKB_P, j);
2855 } else if (STR_EQUAL_2G("2G", "B", "-", "CCK")) {
2856 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKB_N, j);
2857 } else if (STR_EQUAL_2G("2G", "A", "+", "ALL")) {
2858 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_2GA_P, j);
2859 } else if (STR_EQUAL_2G("2G", "A", "-", "ALL")) {
2860 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_2GA_N, j);
2861 } else if (STR_EQUAL_2G("2G", "B", "+", "ALL")) {
2862 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_2GB_P, j);
2863 } else if (STR_EQUAL_2G("2G", "B", "-", "ALL")) {
2864 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_2GB_N, j);
2865 } else if (STR_EQUAL_5G("5G", "A", "+", "ALL", "0")) {
2866 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GA_P[0], j);
2867 } else if (STR_EQUAL_5G("5G", "A", "-", "ALL", "0")) {
2868 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GA_N[0], j);
2869 } else if (STR_EQUAL_5G("5G", "B", "+", "ALL", "0")) {
2870 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GB_P[0], j);
2871 } else if (STR_EQUAL_5G("5G", "B", "-", "ALL", "0")) {
2872 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GB_N[0], j);
2873 } else if (STR_EQUAL_5G("5G", "A", "+", "ALL", "1")) {
2874 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GA_P[1], j);
2875 } else if (STR_EQUAL_5G("5G", "A", "-", "ALL", "1")) {
2876 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GA_N[1], j);
2877 } else if (STR_EQUAL_5G("5G", "B", "+", "ALL", "1")) {
2878 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GB_P[1], j);
2879 } else if (STR_EQUAL_5G("5G", "B", "-", "ALL", "1")) {
2880 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GB_N[1], j);
2881 } else if (STR_EQUAL_5G("5G", "A", "+", "ALL", "2")) {
2882 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GA_P[2], j);
2883 } else if (STR_EQUAL_5G("5G", "A", "-", "ALL", "2")) {
2884 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GA_N[2], j);
2885 } else if (STR_EQUAL_5G("5G", "B", "+", "ALL", "2")) {
2886 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GB_P[2], j);
2887 } else if (STR_EQUAL_5G("5G", "B", "-", "ALL", "2")) {
2888 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GB_N[2], j);
2889 } else if (STR_EQUAL_5G("5G", "A", "+", "ALL", "3")) {
2890 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GA_P[3], j);
2891 } else if (STR_EQUAL_5G("5G", "A", "-", "ALL", "3")) {
2892 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GA_N[3], j);
2893 } else if (STR_EQUAL_5G("5G", "B", "+", "ALL", "3")) {
2894 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GB_P[3], j);
2895 } else if (STR_EQUAL_5G("5G", "B", "-", "ALL", "3")) {
2896 STORE_SWING_TABLE(pRFCalibrateInfo->DeltaSwingTableIdx_5GB_N[3], j);
2897 } else
2898 DBG_871X("===>initDeltaSwingIndexTables(): The input is invalid!!\n");
2899 }
2900
PHY_ConfigRFWithTxPwrTrackParaFile(struct adapter * Adapter,char * pFileName)2901 int PHY_ConfigRFWithTxPwrTrackParaFile(struct adapter *Adapter, char *pFileName)
2902 {
2903 struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
2904 int rlen = 0, rtStatus = _FAIL;
2905 char *szLine, *ptmp;
2906
2907 if (!(Adapter->registrypriv.load_phy_file & LOAD_RF_TXPWR_TRACK_PARA_FILE))
2908 return rtStatus;
2909
2910 memset(pHalData->para_file_buf, 0, MAX_PARA_FILE_BUF_LEN);
2911
2912 if ((pHalData->rf_tx_pwr_track_len == 0) && !pHalData->rf_tx_pwr_track) {
2913 rtw_merge_string(file_path_bs, PATH_MAX, rtw_phy_file_path, pFileName);
2914
2915 if (rtw_is_file_readable(file_path_bs) == true) {
2916 rlen = rtw_retrive_from_file(file_path_bs, pHalData->para_file_buf, MAX_PARA_FILE_BUF_LEN);
2917 if (rlen > 0) {
2918 rtStatus = _SUCCESS;
2919 pHalData->rf_tx_pwr_track = vzalloc(rlen);
2920 if (pHalData->rf_tx_pwr_track) {
2921 memcpy(pHalData->rf_tx_pwr_track, pHalData->para_file_buf, rlen);
2922 pHalData->rf_tx_pwr_track_len = rlen;
2923 } else
2924 DBG_871X("%s rf_tx_pwr_track alloc fail !\n", __func__);
2925 }
2926 }
2927 } else {
2928 if ((pHalData->rf_tx_pwr_track_len != 0) && (pHalData->rf_tx_pwr_track != NULL)) {
2929 memcpy(pHalData->para_file_buf, pHalData->rf_tx_pwr_track, pHalData->rf_tx_pwr_track_len);
2930 rtStatus = _SUCCESS;
2931 } else
2932 DBG_871X("%s(): Critical Error !!!\n", __func__);
2933 }
2934
2935 if (rtStatus == _SUCCESS) {
2936 /* DBG_871X("%s(): read %s successfully\n", __func__, pFileName); */
2937
2938 ptmp = pHalData->para_file_buf;
2939 for (szLine = GetLineFromBuffer(ptmp); szLine != NULL; szLine = GetLineFromBuffer(ptmp)) {
2940 if (!IsCommentString(szLine)) {
2941 char band[5] = "", path[5] = "", sign[5] = "";
2942 char chnl[5] = "", rate[10] = "";
2943 char data[300] = ""; /* 100 is too small */
2944 const int len = strlen(szLine);
2945 int i;
2946
2947 if (len < 10 || szLine[0] != '[')
2948 continue;
2949
2950 strncpy(band, szLine+1, 2);
2951 strncpy(path, szLine+5, 1);
2952 strncpy(sign, szLine+8, 1);
2953
2954 i = 10; /* szLine+10 */
2955 if (!ParseQualifiedString(szLine, &i, rate, '[', ']')) {
2956 /* DBG_871X("Fail to parse rate!\n"); */
2957 }
2958 if (!ParseQualifiedString(szLine, &i, chnl, '[', ']')) {
2959 /* DBG_871X("Fail to parse channel group!\n"); */
2960 }
2961 while (i < len && szLine[i] != '{')
2962 i++;
2963 if (!ParseQualifiedString(szLine, &i, data, '{', '}')) {
2964 /* DBG_871X("Fail to parse data!\n"); */
2965 }
2966
2967 initDeltaSwingIndexTables(Adapter, band, path, sign, chnl, rate, data);
2968 }
2969 }
2970 } else
2971 DBG_871X("%s(): No File %s, Load from HWImg Array!\n", __func__, pFileName);
2972
2973 return rtStatus;
2974 }
2975
phy_ParsePowerLimitTableFile(struct adapter * Adapter,char * buffer)2976 static int phy_ParsePowerLimitTableFile(struct adapter *Adapter, char *buffer)
2977 {
2978 u32 i = 0, forCnt = 0;
2979 u8 loadingStage = 0, limitValue = 0, fraction = 0;
2980 char *szLine, *ptmp;
2981 int rtStatus = _SUCCESS;
2982 char band[10], bandwidth[10], rateSection[10],
2983 regulation[TXPWR_LMT_MAX_REGULATION_NUM][10], rfPath[10], colNumBuf[10];
2984 u8 colNum = 0;
2985
2986 DBG_871X("===>phy_ParsePowerLimitTableFile()\n");
2987
2988 if (Adapter->registrypriv.RegDecryptCustomFile == 1)
2989 phy_DecryptBBPgParaFile(Adapter, buffer);
2990
2991 ptmp = buffer;
2992 for (szLine = GetLineFromBuffer(ptmp); szLine != NULL; szLine = GetLineFromBuffer(ptmp)) {
2993 /* skip comment */
2994 if (IsCommentString(szLine)) {
2995 continue;
2996 }
2997
2998 if (loadingStage == 0) {
2999 for (forCnt = 0; forCnt < TXPWR_LMT_MAX_REGULATION_NUM; ++forCnt)
3000 memset((void *) regulation[forCnt], 0, 10);
3001
3002 memset((void *) band, 0, 10);
3003 memset((void *) bandwidth, 0, 10);
3004 memset((void *) rateSection, 0, 10);
3005 memset((void *) rfPath, 0, 10);
3006 memset((void *) colNumBuf, 0, 10);
3007
3008 if (szLine[0] != '#' || szLine[1] != '#')
3009 continue;
3010
3011 /* skip the space */
3012 i = 2;
3013 while (szLine[i] == ' ' || szLine[i] == '\t')
3014 ++i;
3015
3016 szLine[--i] = ' '; /* return the space in front of the regulation info */
3017
3018 /* Parse the label of the table */
3019 if (!ParseQualifiedString(szLine, &i, band, ' ', ',')) {
3020 DBG_871X("Fail to parse band!\n");
3021 return _FAIL;
3022 }
3023 if (!ParseQualifiedString(szLine, &i, bandwidth, ' ', ',')) {
3024 DBG_871X("Fail to parse bandwidth!\n");
3025 return _FAIL;
3026 }
3027 if (!ParseQualifiedString(szLine, &i, rfPath, ' ', ',')) {
3028 DBG_871X("Fail to parse rf path!\n");
3029 return _FAIL;
3030 }
3031 if (!ParseQualifiedString(szLine, &i, rateSection, ' ', ',')) {
3032 DBG_871X("Fail to parse rate!\n");
3033 return _FAIL;
3034 }
3035
3036 loadingStage = 1;
3037 } else if (loadingStage == 1) {
3038 if (szLine[0] != '#' || szLine[1] != '#')
3039 continue;
3040
3041 /* skip the space */
3042 i = 2;
3043 while (szLine[i] == ' ' || szLine[i] == '\t')
3044 ++i;
3045
3046 if (!eqNByte((u8 *)(szLine + i), (u8 *)("START"), 5)) {
3047 DBG_871X("Lost \"## START\" label\n");
3048 return _FAIL;
3049 }
3050
3051 loadingStage = 2;
3052 } else if (loadingStage == 2) {
3053 if (szLine[0] != '#' || szLine[1] != '#')
3054 continue;
3055
3056 /* skip the space */
3057 i = 2;
3058 while (szLine[i] == ' ' || szLine[i] == '\t')
3059 ++i;
3060
3061 if (!ParseQualifiedString(szLine, &i, colNumBuf, '#', '#')) {
3062 DBG_871X("Fail to parse column number!\n");
3063 return _FAIL;
3064 }
3065
3066 if (!GetU1ByteIntegerFromStringInDecimal(colNumBuf, &colNum))
3067 return _FAIL;
3068
3069 if (colNum > TXPWR_LMT_MAX_REGULATION_NUM) {
3070 DBG_871X(
3071 "invalid col number %d (greater than max %d)\n",
3072 colNum, TXPWR_LMT_MAX_REGULATION_NUM
3073 );
3074 return _FAIL;
3075 }
3076
3077 for (forCnt = 0; forCnt < colNum; ++forCnt) {
3078 u8 regulation_name_cnt = 0;
3079
3080 /* skip the space */
3081 while (szLine[i] == ' ' || szLine[i] == '\t')
3082 ++i;
3083
3084 while (szLine[i] != ' ' && szLine[i] != '\t' && szLine[i] != '\0')
3085 regulation[forCnt][regulation_name_cnt++] = szLine[i++];
3086 /* DBG_871X("regulation %s!\n", regulation[forCnt]); */
3087
3088 if (regulation_name_cnt == 0) {
3089 DBG_871X("invalid number of regulation!\n");
3090 return _FAIL;
3091 }
3092 }
3093
3094 loadingStage = 3;
3095 } else if (loadingStage == 3) {
3096 char channel[10] = {0}, powerLimit[10] = {0};
3097 u8 cnt = 0;
3098
3099 /* the table ends */
3100 if (szLine[0] == '#' && szLine[1] == '#') {
3101 i = 2;
3102 while (szLine[i] == ' ' || szLine[i] == '\t')
3103 ++i;
3104
3105 if (eqNByte((u8 *)(szLine + i), (u8 *)("END"), 3)) {
3106 loadingStage = 0;
3107 continue;
3108 } else {
3109 DBG_871X("Wrong format\n");
3110 DBG_871X("<===== phy_ParsePowerLimitTableFile()\n");
3111 return _FAIL;
3112 }
3113 }
3114
3115 if ((szLine[0] != 'c' && szLine[0] != 'C') ||
3116 (szLine[1] != 'h' && szLine[1] != 'H')) {
3117 DBG_871X("Meet wrong channel => power limt pair\n");
3118 continue;
3119 }
3120 i = 2;/* move to the location behind 'h' */
3121
3122 /* load the channel number */
3123 cnt = 0;
3124 while (szLine[i] >= '0' && szLine[i] <= '9') {
3125 channel[cnt] = szLine[i];
3126 ++cnt;
3127 ++i;
3128 }
3129 /* DBG_871X("chnl %s!\n", channel); */
3130
3131 for (forCnt = 0; forCnt < colNum; ++forCnt) {
3132 /* skip the space between channel number and the power limit value */
3133 while (szLine[i] == ' ' || szLine[i] == '\t')
3134 ++i;
3135
3136 /* load the power limit value */
3137 cnt = 0;
3138 fraction = 0;
3139 memset((void *) powerLimit, 0, 10);
3140 while ((szLine[i] >= '0' && szLine[i] <= '9') || szLine[i] == '.') {
3141 if (szLine[i] == '.') {
3142 if ((szLine[i+1] >= '0' && szLine[i+1] <= '9')) {
3143 fraction = szLine[i+1];
3144 i += 2;
3145 } else {
3146 DBG_871X("Wrong fraction in TXPWR_LMT.txt\n");
3147 return _FAIL;
3148 }
3149
3150 break;
3151 }
3152
3153 powerLimit[cnt] = szLine[i];
3154 ++cnt;
3155 ++i;
3156 }
3157
3158 if (powerLimit[0] == '\0') {
3159 powerLimit[0] = '6';
3160 powerLimit[1] = '3';
3161 i += 2;
3162 } else {
3163 if (!GetU1ByteIntegerFromStringInDecimal(powerLimit, &limitValue))
3164 return _FAIL;
3165
3166 limitValue *= 2;
3167 cnt = 0;
3168 if (fraction == '5')
3169 ++limitValue;
3170
3171 /* the value is greater or equal to 100 */
3172 if (limitValue >= 100) {
3173 powerLimit[cnt++] = limitValue/100 + '0';
3174 limitValue %= 100;
3175
3176 if (limitValue >= 10) {
3177 powerLimit[cnt++] = limitValue/10 + '0';
3178 limitValue %= 10;
3179 } else
3180 powerLimit[cnt++] = '0';
3181
3182 powerLimit[cnt++] = limitValue + '0';
3183 } else if (limitValue >= 10) { /* the value is greater or equal to 10 */
3184 powerLimit[cnt++] = limitValue/10 + '0';
3185 limitValue %= 10;
3186 powerLimit[cnt++] = limitValue + '0';
3187 }
3188 /* the value is less than 10 */
3189 else
3190 powerLimit[cnt++] = limitValue + '0';
3191
3192 powerLimit[cnt] = '\0';
3193 }
3194
3195 /* DBG_871X("ch%s => %s\n", channel, powerLimit); */
3196
3197 /* store the power limit value */
3198 PHY_SetTxPowerLimit(Adapter, (u8 *)regulation[forCnt], (u8 *)band,
3199 (u8 *)bandwidth, (u8 *)rateSection, (u8 *)rfPath, (u8 *)channel, (u8 *)powerLimit);
3200
3201 }
3202 } else {
3203 DBG_871X("Abnormal loading stage in phy_ParsePowerLimitTableFile()!\n");
3204 rtStatus = _FAIL;
3205 break;
3206 }
3207 }
3208
3209 DBG_871X("<===phy_ParsePowerLimitTableFile()\n");
3210 return rtStatus;
3211 }
3212
PHY_ConfigRFWithPowerLimitTableParaFile(struct adapter * Adapter,char * pFileName)3213 int PHY_ConfigRFWithPowerLimitTableParaFile(
3214 struct adapter *Adapter, char *pFileName
3215 )
3216 {
3217 struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
3218 int rlen = 0, rtStatus = _FAIL;
3219
3220 if (!(Adapter->registrypriv.load_phy_file & LOAD_RF_TXPWR_LMT_PARA_FILE))
3221 return rtStatus;
3222
3223 memset(pHalData->para_file_buf, 0, MAX_PARA_FILE_BUF_LEN);
3224
3225 if ((pHalData->rf_tx_pwr_lmt_len == 0) && !pHalData->rf_tx_pwr_lmt) {
3226 rtw_merge_string(file_path_bs, PATH_MAX, rtw_phy_file_path, pFileName);
3227
3228 if (rtw_is_file_readable(file_path_bs) == true) {
3229 rlen = rtw_retrive_from_file(file_path_bs, pHalData->para_file_buf, MAX_PARA_FILE_BUF_LEN);
3230 if (rlen > 0) {
3231 rtStatus = _SUCCESS;
3232 pHalData->rf_tx_pwr_lmt = vzalloc(rlen);
3233 if (pHalData->rf_tx_pwr_lmt) {
3234 memcpy(pHalData->rf_tx_pwr_lmt, pHalData->para_file_buf, rlen);
3235 pHalData->rf_tx_pwr_lmt_len = rlen;
3236 } else
3237 DBG_871X("%s rf_tx_pwr_lmt alloc fail !\n", __func__);
3238 }
3239 }
3240 } else {
3241 if ((pHalData->rf_tx_pwr_lmt_len != 0) && (pHalData->rf_tx_pwr_lmt != NULL)) {
3242 memcpy(pHalData->para_file_buf, pHalData->rf_tx_pwr_lmt, pHalData->rf_tx_pwr_lmt_len);
3243 rtStatus = _SUCCESS;
3244 } else
3245 DBG_871X("%s(): Critical Error !!!\n", __func__);
3246 }
3247
3248 if (rtStatus == _SUCCESS) {
3249 /* DBG_871X("%s(): read %s ok\n", __func__, pFileName); */
3250 rtStatus = phy_ParsePowerLimitTableFile(Adapter, pHalData->para_file_buf);
3251 } else
3252 DBG_871X("%s(): No File %s, Load from HWImg Array!\n", __func__, pFileName);
3253
3254 return rtStatus;
3255 }
3256
phy_free_filebuf(struct adapter * padapter)3257 void phy_free_filebuf(struct adapter *padapter)
3258 {
3259 struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
3260
3261 if (pHalData->mac_reg)
3262 vfree(pHalData->mac_reg);
3263 if (pHalData->bb_phy_reg)
3264 vfree(pHalData->bb_phy_reg);
3265 if (pHalData->bb_agc_tab)
3266 vfree(pHalData->bb_agc_tab);
3267 if (pHalData->bb_phy_reg_pg)
3268 vfree(pHalData->bb_phy_reg_pg);
3269 if (pHalData->bb_phy_reg_mp)
3270 vfree(pHalData->bb_phy_reg_mp);
3271 if (pHalData->rf_radio_a)
3272 vfree(pHalData->rf_radio_a);
3273 if (pHalData->rf_radio_b)
3274 vfree(pHalData->rf_radio_b);
3275 if (pHalData->rf_tx_pwr_track)
3276 vfree(pHalData->rf_tx_pwr_track);
3277 if (pHalData->rf_tx_pwr_lmt)
3278 vfree(pHalData->rf_tx_pwr_lmt);
3279
3280 }
3281