1 /******************************************************************************
2 *
3 * Copyright(c) 2007 - 2017 Realtek Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 *****************************************************************************/
15
16 /*@===========================================================
17 * include files
18 *============================================================
19 */
20 #include "mp_precomp.h"
21 #include "phydm_precomp.h"
22
_sqrt(u64 x)23 u64 _sqrt(u64 x)
24 {
25 u64 i = 0;
26 u64 j = (x >> 1) + 1;
27
28 while (i <= j) {
29 u64 mid = (i + j) >> 1;
30
31 u64 sq = mid * mid;
32
33 if (sq == x)
34 return mid;
35 else if (sq < x)
36 i = mid + 1;
37 else
38 j = mid - 1;
39 }
40
41 return j;
42 }
43
halrf_get_psd_data(struct dm_struct * dm,u32 point)44 u32 halrf_get_psd_data(
45 struct dm_struct *dm,
46 u32 point)
47 {
48 struct _hal_rf_ *rf = &(dm->rf_table);
49 struct _halrf_psd_data *psd = &(rf->halrf_psd_data);
50 u32 psd_val = 0, psd_reg, psd_report, psd_point, psd_start, i, delay_time = 0;
51
52 #if (DEV_BUS_TYPE == RT_USB_INTERFACE) || (DEV_BUS_TYPE == RT_SDIO_INTERFACE)
53 if (dm->support_interface == ODM_ITRF_USB || dm->support_interface == ODM_ITRF_SDIO) {
54 if (psd->average == 0)
55 delay_time = 100;
56 else
57 delay_time = 0;
58 }
59 #endif
60 #if (DEV_BUS_TYPE == RT_PCI_INTERFACE)
61 if (dm->support_interface == ODM_ITRF_PCIE) {
62 if (psd->average == 0)
63 delay_time = 1000;
64 else
65 delay_time = 100;
66 }
67 #endif
68
69 if (dm->support_ic_type & (ODM_RTL8812 | ODM_RTL8821 | ODM_RTL8814A | ODM_RTL8822B | ODM_RTL8821C)) {
70 psd_reg = R_0x910;
71 psd_report = R_0xf44;
72 } else {
73 psd_reg = R_0x808;
74 psd_report = R_0x8b4;
75 }
76
77 if (dm->support_ic_type & ODM_RTL8710B) {
78 psd_point = 0xeffffc00;
79 psd_start = 0x10000000;
80 } else {
81 psd_point = 0xffbffc00;
82 psd_start = 0x00400000;
83 }
84
85 psd_val = odm_get_bb_reg(dm, psd_reg, MASKDWORD);
86
87 psd_val &= psd_point;
88 psd_val |= point;
89
90 odm_set_bb_reg(dm, psd_reg, MASKDWORD, psd_val);
91
92 psd_val |= psd_start;
93
94 odm_set_bb_reg(dm, psd_reg, MASKDWORD, psd_val);
95
96 for (i = 0; i < delay_time; i++)
97 ODM_delay_us(1);
98
99 psd_val = odm_get_bb_reg(dm, psd_report, MASKDWORD);
100
101 if (dm->support_ic_type & (ODM_RTL8821C | ODM_RTL8710B)) {
102 psd_val &= MASKL3BYTES;
103 psd_val = psd_val / 32;
104 } else {
105 psd_val &= MASKLWORD;
106 }
107
108 return psd_val;
109 }
110
halrf_psd(struct dm_struct * dm,u32 point,u32 start_point,u32 stop_point,u32 average)111 void halrf_psd(
112 struct dm_struct *dm,
113 u32 point,
114 u32 start_point,
115 u32 stop_point,
116 u32 average)
117 {
118 struct _hal_rf_ *rf = &(dm->rf_table);
119 struct _halrf_psd_data *psd = &(rf->halrf_psd_data);
120
121 u32 i = 0, j = 0, k = 0;
122 u32 psd_reg, avg_org, point_temp, average_tmp, mode;
123 u64 data_tatal = 0, data_temp[64] = {0};
124
125 psd->buf_size = 256;
126
127 mode = average >> 16;
128
129 if (mode == 2)
130 average_tmp = 1;
131 else
132 average_tmp = average & 0xffff;
133
134 if (dm->support_ic_type & (ODM_RTL8812 | ODM_RTL8821 | ODM_RTL8814A | ODM_RTL8822B | ODM_RTL8821C))
135 psd_reg = R_0x910;
136 else
137 psd_reg = R_0x808;
138
139 #if 0
140 dbg_print("[PSD]point=%d, start_point=%d, stop_point=%d, average=%d, average_tmp=%d, buf_size=%d\n",
141 point, start_point, stop_point, average, average_tmp, psd->buf_size);
142 #endif
143
144 for (i = 0; i < psd->buf_size; i++)
145 psd->psd_data[i] = 0;
146
147 if (dm->support_ic_type & ODM_RTL8710B)
148 avg_org = odm_get_bb_reg(dm, psd_reg, 0x30000);
149 else
150 avg_org = odm_get_bb_reg(dm, psd_reg, 0x3000);
151
152 if (mode == 1) {
153 if (dm->support_ic_type & ODM_RTL8710B)
154 odm_set_bb_reg(dm, psd_reg, 0x30000, 0x1);
155 else
156 odm_set_bb_reg(dm, psd_reg, 0x3000, 0x1);
157 }
158
159 #if 0
160 if (avg_temp == 0)
161 avg = 1;
162 else if (avg_temp == 1)
163 avg = 8;
164 else if (avg_temp == 2)
165 avg = 16;
166 else if (avg_temp == 3)
167 avg = 32;
168 #endif
169
170 i = start_point;
171 while (i < stop_point) {
172 data_tatal = 0;
173
174 if (i >= point)
175 point_temp = i - point;
176 else
177 point_temp = i;
178
179 for (k = 0; k < average_tmp; k++) {
180 data_temp[k] = halrf_get_psd_data(dm, point_temp);
181 data_tatal = data_tatal + (data_temp[k] * data_temp[k]);
182
183 #if 0
184 if ((k % 20) == 0)
185 dbg_print("\n ");
186
187 dbg_print("0x%x ", data_temp[k]);
188 #endif
189 }
190 #if 0
191 /*dbg_print("\n");*/
192 #endif
193
194 data_tatal = phydm_division64((data_tatal * 100), average_tmp);
195 psd->psd_data[j] = (u32)_sqrt(data_tatal);
196
197 i++;
198 j++;
199 }
200
201 #if 0
202 for (i = 0; i < psd->buf_size; i++) {
203 if ((i % 20) == 0)
204 dbg_print("\n ");
205
206 dbg_print("0x%x ", psd->psd_data[i]);
207 }
208 dbg_print("\n\n");
209 #endif
210
211 if (dm->support_ic_type & ODM_RTL8710B)
212 odm_set_bb_reg(dm, psd_reg, 0x30000, avg_org);
213 else
214 odm_set_bb_reg(dm, psd_reg, 0x3000, avg_org);
215 }
216
backup_bb_register(struct dm_struct * dm,u32 * bb_backup,u32 * backup_bb_reg,u32 counter)217 void backup_bb_register(struct dm_struct *dm, u32 *bb_backup, u32 *backup_bb_reg, u32 counter)
218 {
219 u32 i ;
220
221 for (i = 0; i < counter; i++)
222 bb_backup[i] = odm_get_bb_reg(dm, backup_bb_reg[i], MASKDWORD);
223 }
224
restore_bb_register(struct dm_struct * dm,u32 * bb_backup,u32 * backup_bb_reg,u32 counter)225 void restore_bb_register(struct dm_struct *dm, u32 *bb_backup, u32 *backup_bb_reg, u32 counter)
226 {
227 u32 i ;
228
229 for (i = 0; i < counter; i++)
230 odm_set_bb_reg(dm, backup_bb_reg[i], MASKDWORD, bb_backup[i]);
231 }
232
233
234
_halrf_psd_iqk_init(struct dm_struct * dm)235 void _halrf_psd_iqk_init(struct dm_struct *dm)
236 {
237 odm_set_bb_reg(dm, 0x1b04, MASKDWORD, 0x0);
238 odm_set_bb_reg(dm, 0x1b08, MASKDWORD, 0x80);
239 odm_set_bb_reg(dm, 0x1b0c, 0xc00, 0x3);
240 odm_set_bb_reg(dm, 0x1b14, MASKDWORD, 0x0);
241 odm_set_bb_reg(dm, 0x1b18, BIT(0), 0x1);
242
243 if (dm->support_ic_type & ODM_RTL8197G)
244 odm_set_bb_reg(dm, 0x1b20, MASKDWORD, 0x00040008);
245 if (dm->support_ic_type & ODM_RTL8198F)
246 odm_set_bb_reg(dm, 0x1b20, MASKDWORD, 0x00000000);
247
248 if (dm->support_ic_type & (ODM_RTL8197G | ODM_RTL8198F)) {
249 odm_set_bb_reg(dm, 0x1b24, MASKDWORD, 0x00030000);
250 odm_set_bb_reg(dm, 0x1b28, MASKDWORD, 0x00000000);
251 odm_set_bb_reg(dm, 0x1b2c, MASKDWORD, 0x00180018);
252 odm_set_bb_reg(dm, 0x1b30, MASKDWORD, 0x20000000);
253 /*odm_set_bb_reg(dm, 0x1b38, MASKDWORD, 0x20000000);*/
254 /*odm_set_bb_reg(dm, 0x1b3c, MASKDWORD, 0x20000000);*/
255 }
256
257 odm_set_bb_reg(dm, 0x1b1c, 0xfff, 0xd21);
258 odm_set_bb_reg(dm, 0x1b1c, 0xfff00000, 0x821);
259 odm_set_bb_reg(dm, 0x1b28, MASKDWORD, 0x0);
260 odm_set_bb_reg(dm, 0x1bcc, 0x3f, 0x3f);
261 }
262
263
halrf_get_iqk_psd_data(struct dm_struct * dm,u32 point)264 u32 halrf_get_iqk_psd_data(
265 struct dm_struct *dm,
266 u32 point)
267 {
268 struct _hal_rf_ *rf = &(dm->rf_table);
269 struct _halrf_psd_data *psd = &(rf->halrf_psd_data);
270 u32 psd_val, psd_val1, psd_val2, psd_point, i, delay_time = 0;
271
272 #if (DEV_BUS_TYPE == RT_USB_INTERFACE) || (DEV_BUS_TYPE == RT_SDIO_INTERFACE)
273 if (dm->support_interface == ODM_ITRF_USB || dm->support_interface == ODM_ITRF_SDIO) {
274 if (dm->support_ic_type & ODM_RTL8822C)
275 delay_time = 1000;
276 else
277 delay_time = 0;
278 }
279 #endif
280 #if (DEV_BUS_TYPE == RT_PCI_INTERFACE)
281 if (dm->support_interface == ODM_ITRF_PCIE) {
282 if (dm->support_ic_type & ODM_RTL8822C)
283 delay_time = 1000;
284 else
285 delay_time = 150;
286 }
287 #endif
288 psd_point = odm_get_bb_reg(dm, R_0x1b2c, MASKDWORD);
289
290 psd_point &= 0xF000FFFF;
291
292 point &= 0xFFF;
293
294 psd_point = psd_point | (point << 16);
295
296 odm_set_bb_reg(dm, R_0x1b2c, MASKDWORD, psd_point);
297
298 odm_set_bb_reg(dm, R_0x1b34, BIT(0), 0x1);
299
300 odm_set_bb_reg(dm, R_0x1b34, BIT(0), 0x0);
301
302 for (i = 0; i < delay_time; i++)
303 ODM_delay_us(1);
304
305 if (dm->support_ic_type & (ODM_RTL8197G | ODM_RTL8198F)) {
306 if (dm->support_ic_type & ODM_RTL8197G)
307 odm_set_bb_reg(dm, R_0x1bd4, MASKDWORD, 0x001a0001);
308 else
309 odm_set_bb_reg(dm, R_0x1bd4, MASKDWORD, 0x00250001);
310
311 psd_val1 = odm_get_bb_reg(dm, R_0x1bfc, MASKDWORD);
312
313 psd_val1 = (psd_val1 & 0x001f0000) >> 16;
314
315 if (dm->support_ic_type & ODM_RTL8197G)
316 odm_set_bb_reg(dm, R_0x1bd4, MASKDWORD, 0x001b0001);
317 else
318 odm_set_bb_reg(dm, R_0x1bd4, MASKDWORD, 0x002e0001);
319
320 psd_val2 = odm_get_bb_reg(dm, R_0x1bfc, MASKDWORD);
321
322 psd_val = (psd_val1 << 27) + (psd_val2 >> 5);
323 } else {
324 odm_set_bb_reg(dm, R_0x1bd4, MASKDWORD, 0x00250001);
325
326 psd_val1 = odm_get_bb_reg(dm, R_0x1bfc, MASKDWORD);
327
328 psd_val1 = (psd_val1 & 0x07FF0000) >> 16;
329
330 odm_set_bb_reg(dm, R_0x1bd4, MASKDWORD, 0x002e0001);
331
332 psd_val2 = odm_get_bb_reg(dm, R_0x1bfc, MASKDWORD);
333
334 psd_val = (psd_val1 << 21) + (psd_val2 >> 11);
335 }
336
337 return psd_val;
338 }
339
halrf_iqk_psd(struct dm_struct * dm,u32 point,u32 start_point,u32 stop_point,u32 average)340 void halrf_iqk_psd(
341 struct dm_struct *dm,
342 u32 point,
343 u32 start_point,
344 u32 stop_point,
345 u32 average)
346 {
347 struct _hal_rf_ *rf = &(dm->rf_table);
348 struct _halrf_psd_data *psd = &(rf->halrf_psd_data);
349
350 u32 i = 0, j = 0, k = 0;
351 u32 psd_reg, avg_org, point_temp, average_tmp = 32, mode, reg_tmp = 5;
352 u64 data_tatal = 0, data_temp[64] = {0};
353 s32 s_point_tmp;
354
355 psd->buf_size = 256;
356
357 mode = average >> 16;
358
359 if (mode == 2) {
360 if (dm->support_ic_type & ODM_RTL8822C)
361 average_tmp = 1;
362 else {
363 reg_tmp = odm_get_bb_reg(dm, R_0x1b1c, 0x000e0000);
364 if (reg_tmp == 0)
365 average_tmp = 1;
366 else if (reg_tmp == 3)
367 average_tmp = 8;
368 else if (reg_tmp == 4)
369 average_tmp = 16;
370 else if (reg_tmp == 5)
371 average_tmp = 32;
372 odm_set_bb_reg(dm, R_0x1b1c, 0x000e0000, 0x0);
373 }
374 } else {
375 reg_tmp = odm_get_bb_reg(dm, R_0x1b1c, 0x000e0000);
376 if (reg_tmp == 0)
377 average_tmp = 1;
378 else if (reg_tmp == 3)
379 average_tmp = 8;
380 else if (reg_tmp == 4)
381 average_tmp = 16;
382 else if (reg_tmp == 5)
383 average_tmp = 32;
384 odm_set_bb_reg(dm, R_0x1b1c, 0x000e0000, 0x0);
385 }
386
387 #if 0
388 DbgPrint("[PSD]point=%d, start_point=%d, stop_point=%d, average=0x%x, average_tmp=%d, buf_size=%d, mode=%d\n",
389 point, start_point, stop_point, average, average_tmp, psd->buf_size, mode);
390 #endif
391
392 for (i = 0; i < psd->buf_size; i++)
393 psd->psd_data[i] = 0;
394
395 i = start_point;
396 while (i < stop_point) {
397 data_tatal = 0;
398
399 if (i >= point)
400 point_temp = i - point;
401 else
402 {
403 if (dm->support_ic_type & ODM_RTL8814B)
404 {
405 s_point_tmp = i - point - 1;
406 point_temp = s_point_tmp & 0xfff;
407 }
408 else
409 point_temp = i;
410 }
411
412 for (k = 0; k < average_tmp; k++) {
413 data_temp[k] = halrf_get_iqk_psd_data(dm, point_temp);
414 /*data_tatal = data_tatal + (data_temp[k] * data_temp[k]);*/
415 data_tatal = data_tatal + data_temp[k];
416
417 #if 0
418 if ((k % 20) == 0)
419 DbgPrint("\n ");
420
421 DbgPrint("0x%x ", data_temp[k]);
422 #endif
423 }
424
425 data_tatal = phydm_division64((data_tatal * 10), average_tmp);
426 psd->psd_data[j] = (u32)data_tatal;
427
428 i++;
429 j++;
430 }
431
432 if (dm->support_ic_type & (ODM_RTL8814B | ODM_RTL8198F | ODM_RTL8197G))
433 odm_set_bb_reg(dm, R_0x1b1c, 0x000e0000, reg_tmp);
434
435 #if 0
436 DbgPrint("\n [iqk psd]psd result:\n");
437
438 for (i = 0; i < psd->buf_size; i++) {
439 if ((i % 20) == 0)
440 DbgPrint("\n ");
441
442 DbgPrint("0x%x ", psd->psd_data[i]);
443 }
444 DbgPrint("\n\n");
445 #endif
446 }
447
448
449 u32
halrf_psd_init(void * dm_void)450 halrf_psd_init(
451 void *dm_void)
452 {
453 enum rt_status ret_status = RT_STATUS_SUCCESS;
454 struct dm_struct *dm = (struct dm_struct *)dm_void;
455 struct _hal_rf_ *rf = &(dm->rf_table);
456 struct _halrf_psd_data *psd = &(rf->halrf_psd_data);
457
458 #if 0
459 u32 bb_backup[12];
460 u32 backup_bb_reg[12] = {0x1b04, 0x1b08, 0x1b0c, 0x1b14, 0x1b18,
461 0x1b1c, 0x1b28, 0x1bcc, 0x1b2c, 0x1b34,
462 0x1bd4, 0x1bfc};
463 #endif
464
465 if (psd->psd_progress) {
466 ret_status = RT_STATUS_PENDING;
467 } else {
468 psd->psd_progress = 1;
469 if (dm->support_ic_type & (ODM_RTL8822C | ODM_RTL8814B | ODM_RTL8198F | ODM_RTL8197G)) {
470 /*backup_bb_register(dm, bb_backup, backup_bb_reg, 12);*/
471 _halrf_psd_iqk_init(dm);
472 halrf_iqk_psd(dm, psd->point, psd->start_point, psd->stop_point, psd->average);
473 /*restore_bb_register(dm, bb_backup, backup_bb_reg, 12);*/
474 } else
475 halrf_psd(dm, psd->point, psd->start_point, psd->stop_point, psd->average);
476 psd->psd_progress = 0;
477 }
478 return ret_status;
479 }
480
481 u32
halrf_psd_query(void * dm_void,u32 * outbuf,u32 buf_size)482 halrf_psd_query(
483 void *dm_void,
484 u32 *outbuf,
485 u32 buf_size)
486 {
487 enum rt_status ret_status = RT_STATUS_SUCCESS;
488 struct dm_struct *dm = (struct dm_struct *)dm_void;
489 struct _hal_rf_ *rf = &(dm->rf_table);
490 struct _halrf_psd_data *psd = &(rf->halrf_psd_data);
491
492 if (psd->psd_progress)
493 ret_status = RT_STATUS_PENDING;
494 else
495 odm_move_memory(dm, outbuf, psd->psd_data,
496 sizeof(u32) * psd->buf_size);
497
498 return ret_status;
499 }
500
501 u32
halrf_psd_init_query(void * dm_void,u32 * outbuf,u32 point,u32 start_point,u32 stop_point,u32 average,u32 buf_size)502 halrf_psd_init_query(
503 void *dm_void,
504 u32 *outbuf,
505 u32 point,
506 u32 start_point,
507 u32 stop_point,
508 u32 average,
509 u32 buf_size)
510 {
511 enum rt_status ret_status = RT_STATUS_SUCCESS;
512 struct dm_struct *dm = (struct dm_struct *)dm_void;
513 struct _hal_rf_ *rf = &(dm->rf_table);
514 struct _halrf_psd_data *psd = &(rf->halrf_psd_data);
515
516 psd->point = point;
517 psd->start_point = start_point;
518 psd->stop_point = stop_point;
519 psd->average = average;
520
521 if (psd->psd_progress) {
522 ret_status = RT_STATUS_PENDING;
523 } else {
524 psd->psd_progress = 1;
525 halrf_psd(dm, psd->point, psd->start_point, psd->stop_point, psd->average);
526 odm_move_memory(dm, outbuf, psd->psd_data, 0x400);
527 psd->psd_progress = 0;
528 }
529
530 return ret_status;
531 }
532