projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'batman-adv-for-davem' of git://git.open-mesh.org/linux-merge
[deliverable/linux.git] / drivers / net / wireless / brcm80211 / brcmsmac / phy / phy_lcn.c
1 /*
2 * Copyright (c) 2010 Broadcom Corporation
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
11 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
13 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
14 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16
17 #include <linux/kernel.h>
18 #include <linux/delay.h>
19 #include <linux/cordic.h>
20
21 #include <pmu.h>
22 #include <d11.h>
23 #include <phy_shim.h>
24 #include "phy_qmath.h"
25 #include "phy_hal.h"
26 #include "phy_radio.h"
27 #include "phytbl_lcn.h"
28 #include "phy_lcn.h"
29
30 #define PLL_2064_NDIV 90
31 #define PLL_2064_LOW_END_VCO 3000
32 #define PLL_2064_LOW_END_KVCO 27
33 #define PLL_2064_HIGH_END_VCO 4200
34 #define PLL_2064_HIGH_END_KVCO 68
35 #define PLL_2064_LOOP_BW_DOUBLER 200
36 #define PLL_2064_D30_DOUBLER 10500
37 #define PLL_2064_LOOP_BW 260
38 #define PLL_2064_D30 8000
39 #define PLL_2064_CAL_REF_TO 8
40 #define PLL_2064_MHZ 1000000
41 #define PLL_2064_OPEN_LOOP_DELAY 5
42
43 #define TEMPSENSE 1
44 #define VBATSENSE 2
45
46 #define NOISE_IF_UPD_CHK_INTERVAL 1
47 #define NOISE_IF_UPD_RST_INTERVAL 60
48 #define NOISE_IF_UPD_THRESHOLD_CNT 1
49 #define NOISE_IF_UPD_TRHRESHOLD 50
50 #define NOISE_IF_UPD_TIMEOUT 1000
51 #define NOISE_IF_OFF 0
52 #define NOISE_IF_CHK 1
53 #define NOISE_IF_ON 2
54
55 #define PAPD_BLANKING_PROFILE 3
56 #define PAPD2LUT 0
57 #define PAPD_CORR_NORM 0
58 #define PAPD_BLANKING_THRESHOLD 0
59 #define PAPD_STOP_AFTER_LAST_UPDATE 0
60
61 #define LCN_TARGET_PWR 60
62
63 #define LCN_VBAT_OFFSET_433X 34649679
64 #define LCN_VBAT_SLOPE_433X 8258032
65
66 #define LCN_VBAT_SCALE_NOM 53
67 #define LCN_VBAT_SCALE_DEN 432
68
69 #define LCN_TEMPSENSE_OFFSET 80812
70 #define LCN_TEMPSENSE_DEN 2647
71
72 #define LCN_BW_LMT 200
73 #define LCN_CUR_LMT 1250
74 #define LCN_MULT 1
75 #define LCN_VCO_DIV 30
76 #define LCN_OFFSET 680
77 #define LCN_FACT 490
78 #define LCN_CUR_DIV 2640
79
80 #define LCNPHY_txgainctrlovrval1_pagain_ovr_val1_SHIFT \
81 (0 + 8)
82 #define LCNPHY_txgainctrlovrval1_pagain_ovr_val1_MASK \
83 (0x7f << LCNPHY_txgainctrlovrval1_pagain_ovr_val1_SHIFT)
84
85 #define LCNPHY_stxtxgainctrlovrval1_pagain_ovr_val1_SHIFT \
86 (0 + 8)
87 #define LCNPHY_stxtxgainctrlovrval1_pagain_ovr_val1_MASK \
88 (0x7f << LCNPHY_stxtxgainctrlovrval1_pagain_ovr_val1_SHIFT)
89
90 #define wlc_lcnphy_enable_tx_gain_override(pi) \
91 wlc_lcnphy_set_tx_gain_override(pi, true)
92 #define wlc_lcnphy_disable_tx_gain_override(pi) \
93 wlc_lcnphy_set_tx_gain_override(pi, false)
94
95 #define wlc_lcnphy_iqcal_active(pi) \
96 (read_phy_reg((pi), 0x451) & \
97 ((0x1 << 15) | (0x1 << 14)))
98
99 #define txpwrctrl_off(pi) (0x7 != ((read_phy_reg(pi, 0x4a4) & 0xE000) >> 13))
100 #define wlc_lcnphy_tempsense_based_pwr_ctrl_enabled(pi) \
101 (pi->temppwrctrl_capable)
102 #define wlc_lcnphy_tssi_based_pwr_ctrl_enabled(pi) \
103 (pi->hwpwrctrl_capable)
104
105 #define SWCTRL_BT_TX 0x18
106 #define SWCTRL_OVR_DISABLE 0x40
107
108 #define AFE_CLK_INIT_MODE_TXRX2X 1
109 #define AFE_CLK_INIT_MODE_PAPD 0
110
111 #define LCNPHY_TBL_ID_IQLOCAL 0x00
112
113 #define LCNPHY_TBL_ID_RFSEQ 0x08
114 #define LCNPHY_TBL_ID_GAIN_IDX 0x0d
115 #define LCNPHY_TBL_ID_SW_CTRL 0x0f
116 #define LCNPHY_TBL_ID_GAIN_TBL 0x12
117 #define LCNPHY_TBL_ID_SPUR 0x14
118 #define LCNPHY_TBL_ID_SAMPLEPLAY 0x15
119 #define LCNPHY_TBL_ID_SAMPLEPLAY1 0x16
120
121 #define LCNPHY_TX_PWR_CTRL_RATE_OFFSET 832
122 #define LCNPHY_TX_PWR_CTRL_MAC_OFFSET 128
123 #define LCNPHY_TX_PWR_CTRL_GAIN_OFFSET 192
124 #define LCNPHY_TX_PWR_CTRL_IQ_OFFSET 320
125 #define LCNPHY_TX_PWR_CTRL_LO_OFFSET 448
126 #define LCNPHY_TX_PWR_CTRL_PWR_OFFSET 576
127
128 #define LCNPHY_TX_PWR_CTRL_START_INDEX_2G_4313 140
129
130 #define LCNPHY_TX_PWR_CTRL_START_NPT 1
131 #define LCNPHY_TX_PWR_CTRL_MAX_NPT 7
132
133 #define LCNPHY_NOISE_SAMPLES_DEFAULT 5000
134
135 #define LCNPHY_ACI_DETECT_START 1
136 #define LCNPHY_ACI_DETECT_PROGRESS 2
137 #define LCNPHY_ACI_DETECT_STOP 3
138
139 #define LCNPHY_ACI_CRSHIFRMLO_TRSH 100
140 #define LCNPHY_ACI_GLITCH_TRSH 2000
141 #define LCNPHY_ACI_TMOUT 250
142 #define LCNPHY_ACI_DETECT_TIMEOUT 2
143 #define LCNPHY_ACI_START_DELAY 0
144
145 #define wlc_lcnphy_tx_gain_override_enabled(pi) \
146 (0 != (read_phy_reg((pi), 0x43b) & (0x1 << 6)))
147
148 #define wlc_lcnphy_total_tx_frames(pi) \
149 wlapi_bmac_read_shm((pi)->sh->physhim, M_UCODE_MACSTAT + \
150 offsetof(struct macstat, txallfrm))
151
152 struct lcnphy_txgains {
153 u16 gm_gain;
154 u16 pga_gain;
155 u16 pad_gain;
156 u16 dac_gain;
157 };
158
159 enum lcnphy_cal_mode {
160 LCNPHY_CAL_FULL,
161 LCNPHY_CAL_RECAL,
162 LCNPHY_CAL_CURRECAL,
163 LCNPHY_CAL_DIGCAL,
164 LCNPHY_CAL_GCTRL
165 };
166
167 struct lcnphy_rx_iqcomp {
168 u8 chan;
169 s16 a;
170 s16 b;
171 };
172
173 struct lcnphy_spb_tone {
174 s16 re;
175 s16 im;
176 };
177
178 struct lcnphy_unsign16_struct {
179 u16 re;
180 u16 im;
181 };
182
183 struct lcnphy_iq_est {
184 u32 iq_prod;
185 u32 i_pwr;
186 u32 q_pwr;
187 };
188
189 struct lcnphy_sfo_cfg {
190 u16 ptcentreTs20;
191 u16 ptcentreFactor;
192 };
193
194 enum lcnphy_papd_cal_type {
195 LCNPHY_PAPD_CAL_CW,
196 LCNPHY_PAPD_CAL_OFDM
197 };
198
199 typedef u16 iqcal_gain_params_lcnphy[9];
200
201 static const iqcal_gain_params_lcnphy tbl_iqcal_gainparams_lcnphy_2G[] = {
202 {0, 0, 0, 0, 0, 0, 0, 0, 0},
203 };
204
205 static const iqcal_gain_params_lcnphy *tbl_iqcal_gainparams_lcnphy[1] = {
206 tbl_iqcal_gainparams_lcnphy_2G,
207 };
208
209 static const u16 iqcal_gainparams_numgains_lcnphy[1] = {
210 sizeof(tbl_iqcal_gainparams_lcnphy_2G) /
211 sizeof(*tbl_iqcal_gainparams_lcnphy_2G),
212 };
213
214 static const struct lcnphy_sfo_cfg lcnphy_sfo_cfg[] = {
215 {965, 1087},
216 {967, 1085},
217 {969, 1082},
218 {971, 1080},
219 {973, 1078},
220 {975, 1076},
221 {977, 1073},
222 {979, 1071},
223 {981, 1069},
224 {983, 1067},
225 {985, 1065},
226 {987, 1063},
227 {989, 1060},
228 {994, 1055}
229 };
230
231 static const
232 u16 lcnphy_iqcal_loft_gainladder[] = {
233 ((2 << 8) | 0),
234 ((3 << 8) | 0),
235 ((4 << 8) | 0),
236 ((6 << 8) | 0),
237 ((8 << 8) | 0),
238 ((11 << 8) | 0),
239 ((16 << 8) | 0),
240 ((16 << 8) | 1),
241 ((16 << 8) | 2),
242 ((16 << 8) | 3),
243 ((16 << 8) | 4),
244 ((16 << 8) | 5),
245 ((16 << 8) | 6),
246 ((16 << 8) | 7),
247 ((23 << 8) | 7),
248 ((32 << 8) | 7),
249 ((45 << 8) | 7),
250 ((64 << 8) | 7),
251 ((91 << 8) | 7),
252 ((128 << 8) | 7)
253 };
254
255 static const
256 u16 lcnphy_iqcal_ir_gainladder[] = {
257 ((1 << 8) | 0),
258 ((2 << 8) | 0),
259 ((4 << 8) | 0),
260 ((6 << 8) | 0),
261 ((8 << 8) | 0),
262 ((11 << 8) | 0),
263 ((16 << 8) | 0),
264 ((23 << 8) | 0),
265 ((32 << 8) | 0),
266 ((45 << 8) | 0),
267 ((64 << 8) | 0),
268 ((64 << 8) | 1),
269 ((64 << 8) | 2),
270 ((64 << 8) | 3),
271 ((64 << 8) | 4),
272 ((64 << 8) | 5),
273 ((64 << 8) | 6),
274 ((64 << 8) | 7),
275 ((91 << 8) | 7),
276 ((128 << 8) | 7)
277 };
278
279 static const
280 struct lcnphy_spb_tone lcnphy_spb_tone_3750[] = {
281 {88, 0},
282 {73, 49},
283 {34, 81},
284 {-17, 86},
285 {-62, 62},
286 {-86, 17},
287 {-81, -34},
288 {-49, -73},
289 {0, -88},
290 {49, -73},
291 {81, -34},
292 {86, 17},
293 {62, 62},
294 {17, 86},
295 {-34, 81},
296 {-73, 49},
297 {-88, 0},
298 {-73, -49},
299 {-34, -81},
300 {17, -86},
301 {62, -62},
302 {86, -17},
303 {81, 34},
304 {49, 73},
305 {0, 88},
306 {-49, 73},
307 {-81, 34},
308 {-86, -17},
309 {-62, -62},
310 {-17, -86},
311 {34, -81},
312 {73, -49},
313 };
314
315 static const
316 u16 iqlo_loopback_rf_regs[20] = {
317 RADIO_2064_REG036,
318 RADIO_2064_REG11A,
319 RADIO_2064_REG03A,
320 RADIO_2064_REG025,
321 RADIO_2064_REG028,
322 RADIO_2064_REG005,
323 RADIO_2064_REG112,
324 RADIO_2064_REG0FF,
325 RADIO_2064_REG11F,
326 RADIO_2064_REG00B,
327 RADIO_2064_REG113,
328 RADIO_2064_REG007,
329 RADIO_2064_REG0FC,
330 RADIO_2064_REG0FD,
331 RADIO_2064_REG012,
332 RADIO_2064_REG057,
333 RADIO_2064_REG059,
334 RADIO_2064_REG05C,
335 RADIO_2064_REG078,
336 RADIO_2064_REG092,
337 };
338
339 static const
340 u16 tempsense_phy_regs[14] = {
341 0x503,
342 0x4a4,
343 0x4d0,
344 0x4d9,
345 0x4da,
346 0x4a6,
347 0x938,
348 0x939,
349 0x4d8,
350 0x4d0,
351 0x4d7,
352 0x4a5,
353 0x40d,
354 0x4a2,
355 };
356
357 static const
358 u16 rxiq_cal_rf_reg[11] = {
359 RADIO_2064_REG098,
360 RADIO_2064_REG116,
361 RADIO_2064_REG12C,
362 RADIO_2064_REG06A,
363 RADIO_2064_REG00B,
364 RADIO_2064_REG01B,
365 RADIO_2064_REG113,
366 RADIO_2064_REG01D,
367 RADIO_2064_REG114,
368 RADIO_2064_REG02E,
369 RADIO_2064_REG12A,
370 };
371
372 static const
373 struct lcnphy_rx_iqcomp lcnphy_rx_iqcomp_table_rev0[] = {
374 {1, 0, 0},
375 {2, 0, 0},
376 {3, 0, 0},
377 {4, 0, 0},
378 {5, 0, 0},
379 {6, 0, 0},
380 {7, 0, 0},
381 {8, 0, 0},
382 {9, 0, 0},
383 {10, 0, 0},
384 {11, 0, 0},
385 {12, 0, 0},
386 {13, 0, 0},
387 {14, 0, 0},
388 {34, 0, 0},
389 {38, 0, 0},
390 {42, 0, 0},
391 {46, 0, 0},
392 {36, 0, 0},
393 {40, 0, 0},
394 {44, 0, 0},
395 {48, 0, 0},
396 {52, 0, 0},
397 {56, 0, 0},
398 {60, 0, 0},
399 {64, 0, 0},
400 {100, 0, 0},
401 {104, 0, 0},
402 {108, 0, 0},
403 {112, 0, 0},
404 {116, 0, 0},
405 {120, 0, 0},
406 {124, 0, 0},
407 {128, 0, 0},
408 {132, 0, 0},
409 {136, 0, 0},
410 {140, 0, 0},
411 {149, 0, 0},
412 {153, 0, 0},
413 {157, 0, 0},
414 {161, 0, 0},
415 {165, 0, 0},
416 {184, 0, 0},
417 {188, 0, 0},
418 {192, 0, 0},
419 {196, 0, 0},
420 {200, 0, 0},
421 {204, 0, 0},
422 {208, 0, 0},
423 {212, 0, 0},
424 {216, 0, 0},
425 };
426
427 static const u32 lcnphy_23bitgaincode_table[] = {
428 0x200100,
429 0x200200,
430 0x200004,
431 0x200014,
432 0x200024,
433 0x200034,
434 0x200134,
435 0x200234,
436 0x200334,
437 0x200434,
438 0x200037,
439 0x200137,
440 0x200237,
441 0x200337,
442 0x200437,
443 0x000035,
444 0x000135,
445 0x000235,
446 0x000037,
447 0x000137,
448 0x000237,
449 0x000337,
450 0x00013f,
451 0x00023f,
452 0x00033f,
453 0x00034f,
454 0x00044f,
455 0x00144f,
456 0x00244f,
457 0x00254f,
458 0x00354f,
459 0x00454f,
460 0x00464f,
461 0x01464f,
462 0x02464f,
463 0x03464f,
464 0x04464f,
465 };
466
467 static const s8 lcnphy_gain_table[] = {
468 -16,
469 -13,
470 10,
471 7,
472 4,
473 0,
474 3,
475 6,
476 9,
477 12,
478 15,
479 18,
480 21,
481 24,
482 27,
483 30,
484 33,
485 36,
486 39,
487 42,
488 45,
489 48,
490 50,
491 53,
492 56,
493 59,
494 62,
495 65,
496 68,
497 71,
498 74,
499 77,
500 80,
501 83,
502 86,
503 89,
504 92,
505 };
506
507 static const s8 lcnphy_gain_index_offset_for_rssi[] = {
508 7,
509 7,
510 7,
511 7,
512 7,
513 7,
514 7,
515 8,
516 7,
517 7,
518 6,
519 7,
520 7,
521 4,
522 4,
523 4,
524 4,
525 4,
526 4,
527 4,
528 4,
529 3,
530 3,
531 3,
532 3,
533 3,
534 3,
535 4,
536 2,
537 2,
538 2,
539 2,
540 2,
541 2,
542 -1,
543 -2,
544 -2,
545 -2
546 };
547
548 struct chan_info_2064_lcnphy {
549 uint chan;
550 uint freq;
551 u8 logen_buftune;
552 u8 logen_rccr_tx;
553 u8 txrf_mix_tune_ctrl;
554 u8 pa_input_tune_g;
555 u8 logen_rccr_rx;
556 u8 pa_rxrf_lna1_freq_tune;
557 u8 pa_rxrf_lna2_freq_tune;
558 u8 rxrf_rxrf_spare1;
559 };
560
561 static const struct chan_info_2064_lcnphy chan_info_2064_lcnphy[] = {
562 {1, 2412, 0x0B, 0x0A, 0x00, 0x07, 0x0A, 0x88, 0x88, 0x80},
563 {2, 2417, 0x0B, 0x0A, 0x00, 0x07, 0x0A, 0x88, 0x88, 0x80},
564 {3, 2422, 0x0B, 0x0A, 0x00, 0x07, 0x0A, 0x88, 0x88, 0x80},
565 {4, 2427, 0x0B, 0x0A, 0x00, 0x07, 0x0A, 0x88, 0x88, 0x80},
566 {5, 2432, 0x0B, 0x0A, 0x00, 0x07, 0x0A, 0x88, 0x88, 0x80},
567 {6, 2437, 0x0B, 0x0A, 0x00, 0x07, 0x0A, 0x88, 0x88, 0x80},
568 {7, 2442, 0x0B, 0x0A, 0x00, 0x07, 0x0A, 0x88, 0x88, 0x80},
569 {8, 2447, 0x0B, 0x0A, 0x00, 0x07, 0x0A, 0x88, 0x88, 0x80},
570 {9, 2452, 0x0B, 0x0A, 0x00, 0x07, 0x0A, 0x88, 0x88, 0x80},
571 {10, 2457, 0x0B, 0x0A, 0x00, 0x07, 0x0A, 0x88, 0x88, 0x80},
572 {11, 2462, 0x0B, 0x0A, 0x00, 0x07, 0x0A, 0x88, 0x88, 0x80},
573 {12, 2467, 0x0B, 0x0A, 0x00, 0x07, 0x0A, 0x88, 0x88, 0x80},
574 {13, 2472, 0x0B, 0x0A, 0x00, 0x07, 0x0A, 0x88, 0x88, 0x80},
575 {14, 2484, 0x0B, 0x0A, 0x00, 0x07, 0x0A, 0x88, 0x88, 0x80},
576 };
577
578 static const struct lcnphy_radio_regs lcnphy_radio_regs_2064[] = {
579 {0x00, 0, 0, 0, 0},
580 {0x01, 0x64, 0x64, 0, 0},
581 {0x02, 0x20, 0x20, 0, 0},
582 {0x03, 0x66, 0x66, 0, 0},
583 {0x04, 0xf8, 0xf8, 0, 0},
584 {0x05, 0, 0, 0, 0},
585 {0x06, 0x10, 0x10, 0, 0},
586 {0x07, 0, 0, 0, 0},
587 {0x08, 0, 0, 0, 0},
588 {0x09, 0, 0, 0, 0},
589 {0x0A, 0x37, 0x37, 0, 0},
590 {0x0B, 0x6, 0x6, 0, 0},
591 {0x0C, 0x55, 0x55, 0, 0},
592 {0x0D, 0x8b, 0x8b, 0, 0},
593 {0x0E, 0, 0, 0, 0},
594 {0x0F, 0x5, 0x5, 0, 0},
595 {0x10, 0, 0, 0, 0},
596 {0x11, 0xe, 0xe, 0, 0},
597 {0x12, 0, 0, 0, 0},
598 {0x13, 0xb, 0xb, 0, 0},
599 {0x14, 0x2, 0x2, 0, 0},
600 {0x15, 0x12, 0x12, 0, 0},
601 {0x16, 0x12, 0x12, 0, 0},
602 {0x17, 0xc, 0xc, 0, 0},
603 {0x18, 0xc, 0xc, 0, 0},
604 {0x19, 0xc, 0xc, 0, 0},
605 {0x1A, 0x8, 0x8, 0, 0},
606 {0x1B, 0x2, 0x2, 0, 0},
607 {0x1C, 0, 0, 0, 0},
608 {0x1D, 0x1, 0x1, 0, 0},
609 {0x1E, 0x12, 0x12, 0, 0},
610 {0x1F, 0x6e, 0x6e, 0, 0},
611 {0x20, 0x2, 0x2, 0, 0},
612 {0x21, 0x23, 0x23, 0, 0},
613 {0x22, 0x8, 0x8, 0, 0},
614 {0x23, 0, 0, 0, 0},
615 {0x24, 0, 0, 0, 0},
616 {0x25, 0xc, 0xc, 0, 0},
617 {0x26, 0x33, 0x33, 0, 0},
618 {0x27, 0x55, 0x55, 0, 0},
619 {0x28, 0, 0, 0, 0},
620 {0x29, 0x30, 0x30, 0, 0},
621 {0x2A, 0xb, 0xb, 0, 0},
622 {0x2B, 0x1b, 0x1b, 0, 0},
623 {0x2C, 0x3, 0x3, 0, 0},
624 {0x2D, 0x1b, 0x1b, 0, 0},
625 {0x2E, 0, 0, 0, 0},
626 {0x2F, 0x20, 0x20, 0, 0},
627 {0x30, 0xa, 0xa, 0, 0},
628 {0x31, 0, 0, 0, 0},
629 {0x32, 0x62, 0x62, 0, 0},
630 {0x33, 0x19, 0x19, 0, 0},
631 {0x34, 0x33, 0x33, 0, 0},
632 {0x35, 0x77, 0x77, 0, 0},
633 {0x36, 0, 0, 0, 0},
634 {0x37, 0x70, 0x70, 0, 0},
635 {0x38, 0x3, 0x3, 0, 0},
636 {0x39, 0xf, 0xf, 0, 0},
637 {0x3A, 0x6, 0x6, 0, 0},
638 {0x3B, 0xcf, 0xcf, 0, 0},
639 {0x3C, 0x1a, 0x1a, 0, 0},
640 {0x3D, 0x6, 0x6, 0, 0},
641 {0x3E, 0x42, 0x42, 0, 0},
642 {0x3F, 0, 0, 0, 0},
643 {0x40, 0xfb, 0xfb, 0, 0},
644 {0x41, 0x9a, 0x9a, 0, 0},
645 {0x42, 0x7a, 0x7a, 0, 0},
646 {0x43, 0x29, 0x29, 0, 0},
647 {0x44, 0, 0, 0, 0},
648 {0x45, 0x8, 0x8, 0, 0},
649 {0x46, 0xce, 0xce, 0, 0},
650 {0x47, 0x27, 0x27, 0, 0},
651 {0x48, 0x62, 0x62, 0, 0},
652 {0x49, 0x6, 0x6, 0, 0},
653 {0x4A, 0x58, 0x58, 0, 0},
654 {0x4B, 0xf7, 0xf7, 0, 0},
655 {0x4C, 0, 0, 0, 0},
656 {0x4D, 0xb3, 0xb3, 0, 0},
657 {0x4E, 0, 0, 0, 0},
658 {0x4F, 0x2, 0x2, 0, 0},
659 {0x50, 0, 0, 0, 0},
660 {0x51, 0x9, 0x9, 0, 0},
661 {0x52, 0x5, 0x5, 0, 0},
662 {0x53, 0x17, 0x17, 0, 0},
663 {0x54, 0x38, 0x38, 0, 0},
664 {0x55, 0, 0, 0, 0},
665 {0x56, 0, 0, 0, 0},
666 {0x57, 0xb, 0xb, 0, 0},
667 {0x58, 0, 0, 0, 0},
668 {0x59, 0, 0, 0, 0},
669 {0x5A, 0, 0, 0, 0},
670 {0x5B, 0, 0, 0, 0},
671 {0x5C, 0, 0, 0, 0},
672 {0x5D, 0, 0, 0, 0},
673 {0x5E, 0x88, 0x88, 0, 0},
674 {0x5F, 0xcc, 0xcc, 0, 0},
675 {0x60, 0x74, 0x74, 0, 0},
676 {0x61, 0x74, 0x74, 0, 0},
677 {0x62, 0x74, 0x74, 0, 0},
678 {0x63, 0x44, 0x44, 0, 0},
679 {0x64, 0x77, 0x77, 0, 0},
680 {0x65, 0x44, 0x44, 0, 0},
681 {0x66, 0x77, 0x77, 0, 0},
682 {0x67, 0x55, 0x55, 0, 0},
683 {0x68, 0x77, 0x77, 0, 0},
684 {0x69, 0x77, 0x77, 0, 0},
685 {0x6A, 0, 0, 0, 0},
686 {0x6B, 0x7f, 0x7f, 0, 0},
687 {0x6C, 0x8, 0x8, 0, 0},
688 {0x6D, 0, 0, 0, 0},
689 {0x6E, 0x88, 0x88, 0, 0},
690 {0x6F, 0x66, 0x66, 0, 0},
691 {0x70, 0x66, 0x66, 0, 0},
692 {0x71, 0x28, 0x28, 0, 0},
693 {0x72, 0x55, 0x55, 0, 0},
694 {0x73, 0x4, 0x4, 0, 0},
695 {0x74, 0, 0, 0, 0},
696 {0x75, 0, 0, 0, 0},
697 {0x76, 0, 0, 0, 0},
698 {0x77, 0x1, 0x1, 0, 0},
699 {0x78, 0xd6, 0xd6, 0, 0},
700 {0x79, 0, 0, 0, 0},
701 {0x7A, 0, 0, 0, 0},
702 {0x7B, 0, 0, 0, 0},
703 {0x7C, 0, 0, 0, 0},
704 {0x7D, 0, 0, 0, 0},
705 {0x7E, 0, 0, 0, 0},
706 {0x7F, 0, 0, 0, 0},
707 {0x80, 0, 0, 0, 0},
708 {0x81, 0, 0, 0, 0},
709 {0x82, 0, 0, 0, 0},
710 {0x83, 0xb4, 0xb4, 0, 0},
711 {0x84, 0x1, 0x1, 0, 0},
712 {0x85, 0x20, 0x20, 0, 0},
713 {0x86, 0x5, 0x5, 0, 0},
714 {0x87, 0xff, 0xff, 0, 0},
715 {0x88, 0x7, 0x7, 0, 0},
716 {0x89, 0x77, 0x77, 0, 0},
717 {0x8A, 0x77, 0x77, 0, 0},
718 {0x8B, 0x77, 0x77, 0, 0},
719 {0x8C, 0x77, 0x77, 0, 0},
720 {0x8D, 0x8, 0x8, 0, 0},
721 {0x8E, 0xa, 0xa, 0, 0},
722 {0x8F, 0x8, 0x8, 0, 0},
723 {0x90, 0x18, 0x18, 0, 0},
724 {0x91, 0x5, 0x5, 0, 0},
725 {0x92, 0x1f, 0x1f, 0, 0},
726 {0x93, 0x10, 0x10, 0, 0},
727 {0x94, 0x3, 0x3, 0, 0},
728 {0x95, 0, 0, 0, 0},
729 {0x96, 0, 0, 0, 0},
730 {0x97, 0xaa, 0xaa, 0, 0},
731 {0x98, 0, 0, 0, 0},
732 {0x99, 0x23, 0x23, 0, 0},
733 {0x9A, 0x7, 0x7, 0, 0},
734 {0x9B, 0xf, 0xf, 0, 0},
735 {0x9C, 0x10, 0x10, 0, 0},
736 {0x9D, 0x3, 0x3, 0, 0},
737 {0x9E, 0x4, 0x4, 0, 0},
738 {0x9F, 0x20, 0x20, 0, 0},
739 {0xA0, 0, 0, 0, 0},
740 {0xA1, 0, 0, 0, 0},
741 {0xA2, 0, 0, 0, 0},
742 {0xA3, 0, 0, 0, 0},
743 {0xA4, 0x1, 0x1, 0, 0},
744 {0xA5, 0x77, 0x77, 0, 0},
745 {0xA6, 0x77, 0x77, 0, 0},
746 {0xA7, 0x77, 0x77, 0, 0},
747 {0xA8, 0x77, 0x77, 0, 0},
748 {0xA9, 0x8c, 0x8c, 0, 0},
749 {0xAA, 0x88, 0x88, 0, 0},
750 {0xAB, 0x78, 0x78, 0, 0},
751 {0xAC, 0x57, 0x57, 0, 0},
752 {0xAD, 0x88, 0x88, 0, 0},
753 {0xAE, 0, 0, 0, 0},
754 {0xAF, 0x8, 0x8, 0, 0},
755 {0xB0, 0x88, 0x88, 0, 0},
756 {0xB1, 0, 0, 0, 0},
757 {0xB2, 0x1b, 0x1b, 0, 0},
758 {0xB3, 0x3, 0x3, 0, 0},
759 {0xB4, 0x24, 0x24, 0, 0},
760 {0xB5, 0x3, 0x3, 0, 0},
761 {0xB6, 0x1b, 0x1b, 0, 0},
762 {0xB7, 0x24, 0x24, 0, 0},
763 {0xB8, 0x3, 0x3, 0, 0},
764 {0xB9, 0, 0, 0, 0},
765 {0xBA, 0xaa, 0xaa, 0, 0},
766 {0xBB, 0, 0, 0, 0},
767 {0xBC, 0x4, 0x4, 0, 0},
768 {0xBD, 0, 0, 0, 0},
769 {0xBE, 0x8, 0x8, 0, 0},
770 {0xBF, 0x11, 0x11, 0, 0},
771 {0xC0, 0, 0, 0, 0},
772 {0xC1, 0, 0, 0, 0},
773 {0xC2, 0x62, 0x62, 0, 0},
774 {0xC3, 0x1e, 0x1e, 0, 0},
775 {0xC4, 0x33, 0x33, 0, 0},
776 {0xC5, 0x37, 0x37, 0, 0},
777 {0xC6, 0, 0, 0, 0},
778 {0xC7, 0x70, 0x70, 0, 0},
779 {0xC8, 0x1e, 0x1e, 0, 0},
780 {0xC9, 0x6, 0x6, 0, 0},
781 {0xCA, 0x4, 0x4, 0, 0},
782 {0xCB, 0x2f, 0x2f, 0, 0},
783 {0xCC, 0xf, 0xf, 0, 0},
784 {0xCD, 0, 0, 0, 0},
785 {0xCE, 0xff, 0xff, 0, 0},
786 {0xCF, 0x8, 0x8, 0, 0},
787 {0xD0, 0x3f, 0x3f, 0, 0},
788 {0xD1, 0x3f, 0x3f, 0, 0},
789 {0xD2, 0x3f, 0x3f, 0, 0},
790 {0xD3, 0, 0, 0, 0},
791 {0xD4, 0, 0, 0, 0},
792 {0xD5, 0, 0, 0, 0},
793 {0xD6, 0xcc, 0xcc, 0, 0},
794 {0xD7, 0, 0, 0, 0},
795 {0xD8, 0x8, 0x8, 0, 0},
796 {0xD9, 0x8, 0x8, 0, 0},
797 {0xDA, 0x8, 0x8, 0, 0},
798 {0xDB, 0x11, 0x11, 0, 0},
799 {0xDC, 0, 0, 0, 0},
800 {0xDD, 0x87, 0x87, 0, 0},
801 {0xDE, 0x88, 0x88, 0, 0},
802 {0xDF, 0x8, 0x8, 0, 0},
803 {0xE0, 0x8, 0x8, 0, 0},
804 {0xE1, 0x8, 0x8, 0, 0},
805 {0xE2, 0, 0, 0, 0},
806 {0xE3, 0, 0, 0, 0},
807 {0xE4, 0, 0, 0, 0},
808 {0xE5, 0xf5, 0xf5, 0, 0},
809 {0xE6, 0x30, 0x30, 0, 0},
810 {0xE7, 0x1, 0x1, 0, 0},
811 {0xE8, 0, 0, 0, 0},
812 {0xE9, 0xff, 0xff, 0, 0},
813 {0xEA, 0, 0, 0, 0},
814 {0xEB, 0, 0, 0, 0},
815 {0xEC, 0x22, 0x22, 0, 0},
816 {0xED, 0, 0, 0, 0},
817 {0xEE, 0, 0, 0, 0},
818 {0xEF, 0, 0, 0, 0},
819 {0xF0, 0x3, 0x3, 0, 0},
820 {0xF1, 0x1, 0x1, 0, 0},
821 {0xF2, 0, 0, 0, 0},
822 {0xF3, 0, 0, 0, 0},
823 {0xF4, 0, 0, 0, 0},
824 {0xF5, 0, 0, 0, 0},
825 {0xF6, 0, 0, 0, 0},
826 {0xF7, 0x6, 0x6, 0, 0},
827 {0xF8, 0, 0, 0, 0},
828 {0xF9, 0, 0, 0, 0},
829 {0xFA, 0x40, 0x40, 0, 0},
830 {0xFB, 0, 0, 0, 0},
831 {0xFC, 0x1, 0x1, 0, 0},
832 {0xFD, 0x80, 0x80, 0, 0},
833 {0xFE, 0x2, 0x2, 0, 0},
834 {0xFF, 0x10, 0x10, 0, 0},
835 {0x100, 0x2, 0x2, 0, 0},
836 {0x101, 0x1e, 0x1e, 0, 0},
837 {0x102, 0x1e, 0x1e, 0, 0},
838 {0x103, 0, 0, 0, 0},
839 {0x104, 0x1f, 0x1f, 0, 0},
840 {0x105, 0, 0x8, 0, 1},
841 {0x106, 0x2a, 0x2a, 0, 0},
842 {0x107, 0xf, 0xf, 0, 0},
843 {0x108, 0, 0, 0, 0},
844 {0x109, 0, 0, 0, 0},
845 {0x10A, 0, 0, 0, 0},
846 {0x10B, 0, 0, 0, 0},
847 {0x10C, 0, 0, 0, 0},
848 {0x10D, 0, 0, 0, 0},
849 {0x10E, 0, 0, 0, 0},
850 {0x10F, 0, 0, 0, 0},
851 {0x110, 0, 0, 0, 0},
852 {0x111, 0, 0, 0, 0},
853 {0x112, 0, 0, 0, 0},
854 {0x113, 0, 0, 0, 0},
855 {0x114, 0, 0, 0, 0},
856 {0x115, 0, 0, 0, 0},
857 {0x116, 0, 0, 0, 0},
858 {0x117, 0, 0, 0, 0},
859 {0x118, 0, 0, 0, 0},
860 {0x119, 0, 0, 0, 0},
861 {0x11A, 0, 0, 0, 0},
862 {0x11B, 0, 0, 0, 0},
863 {0x11C, 0x1, 0x1, 0, 0},
864 {0x11D, 0, 0, 0, 0},
865 {0x11E, 0, 0, 0, 0},
866 {0x11F, 0, 0, 0, 0},
867 {0x120, 0, 0, 0, 0},
868 {0x121, 0, 0, 0, 0},
869 {0x122, 0x80, 0x80, 0, 0},
870 {0x123, 0, 0, 0, 0},
871 {0x124, 0xf8, 0xf8, 0, 0},
872 {0x125, 0, 0, 0, 0},
873 {0x126, 0, 0, 0, 0},
874 {0x127, 0, 0, 0, 0},
875 {0x128, 0, 0, 0, 0},
876 {0x129, 0, 0, 0, 0},
877 {0x12A, 0, 0, 0, 0},
878 {0x12B, 0, 0, 0, 0},
879 {0x12C, 0, 0, 0, 0},
880 {0x12D, 0, 0, 0, 0},
881 {0x12E, 0, 0, 0, 0},
882 {0x12F, 0, 0, 0, 0},
883 {0x130, 0, 0, 0, 0},
884 {0xFFFF, 0, 0, 0, 0}
885 };
886
887 #define LCNPHY_NUM_DIG_FILT_COEFFS 16
888 #define LCNPHY_NUM_TX_DIG_FILTERS_CCK 13
889
890 static const u16 LCNPHY_txdigfiltcoeffs_cck[LCNPHY_NUM_TX_DIG_FILTERS_CCK]
891 [LCNPHY_NUM_DIG_FILT_COEFFS + 1] = {
892 {0, 1, 415, 1874, 64, 128, 64, 792, 1656, 64, 128, 64, 778, 1582, 64,
893 128, 64,},
894 {1, 1, 402, 1847, 259, 59, 259, 671, 1794, 68, 54, 68, 608, 1863, 93,
895 167, 93,},
896 {2, 1, 415, 1874, 64, 128, 64, 792, 1656, 192, 384, 192, 778, 1582, 64,
897 128, 64,},
898 {3, 1, 302, 1841, 129, 258, 129, 658, 1720, 205, 410, 205, 754, 1760,
899 170, 340, 170,},
900 {20, 1, 360, 1884, 242, 1734, 242, 752, 1720, 205, 1845, 205, 767, 1760,
901 256, 185, 256,},
902 {21, 1, 360, 1884, 149, 1874, 149, 752, 1720, 205, 1883, 205, 767, 1760,
903 256, 273, 256,},
904 {22, 1, 360, 1884, 98, 1948, 98, 752, 1720, 205, 1924, 205, 767, 1760,
905 256, 352, 256,},
906 {23, 1, 350, 1884, 116, 1966, 116, 752, 1720, 205, 2008, 205, 767, 1760,
907 128, 233, 128,},
908 {24, 1, 325, 1884, 32, 40, 32, 756, 1720, 256, 471, 256, 766, 1760, 256,
909 1881, 256,},
910 {25, 1, 299, 1884, 51, 64, 51, 736, 1720, 256, 471, 256, 765, 1760, 256,
911 1881, 256,},
912 {26, 1, 277, 1943, 39, 117, 88, 637, 1838, 64, 192, 144, 614, 1864, 128,
913 384, 288,},
914 {27, 1, 245, 1943, 49, 147, 110, 626, 1838, 256, 768, 576, 613, 1864,
915 128, 384, 288,},
916 {30, 1, 302, 1841, 61, 122, 61, 658, 1720, 205, 410, 205, 754, 1760,
917 170, 340, 170,},
918 };
919
920 #define LCNPHY_NUM_TX_DIG_FILTERS_OFDM 3
921 static const u16 LCNPHY_txdigfiltcoeffs_ofdm[LCNPHY_NUM_TX_DIG_FILTERS_OFDM]
922 [LCNPHY_NUM_DIG_FILT_COEFFS + 1] = {
923 {0, 0, 0xa2, 0x0, 0x100, 0x100, 0x0, 0x0, 0x0, 0x100, 0x0, 0x0,
924 0x278, 0xfea0, 0x80, 0x100, 0x80,},
925 {1, 0, 374, 0xFF79, 16, 32, 16, 799, 0xFE74, 50, 32, 50,
926 750, 0xFE2B, 212, 0xFFCE, 212,},
927 {2, 0, 375, 0xFF16, 37, 76, 37, 799, 0xFE74, 32, 20, 32, 748,
928 0xFEF2, 128, 0xFFE2, 128}
929 };
930
931 #define wlc_lcnphy_set_start_tx_pwr_idx(pi, idx) \
932 mod_phy_reg(pi, 0x4a4, \
933 (0x1ff << 0), \
934 (u16)(idx) << 0)
935
936 #define wlc_lcnphy_set_tx_pwr_npt(pi, npt) \
937 mod_phy_reg(pi, 0x4a5, \
938 (0x7 << 8), \
939 (u16)(npt) << 8)
940
941 #define wlc_lcnphy_get_tx_pwr_ctrl(pi) \
942 (read_phy_reg((pi), 0x4a4) & \
943 ((0x1 << 15) | \
944 (0x1 << 14) | \
945 (0x1 << 13)))
946
947 #define wlc_lcnphy_get_tx_pwr_npt(pi) \
948 ((read_phy_reg(pi, 0x4a5) & \
949 (0x7 << 8)) >> \
950 8)
951
952 #define wlc_lcnphy_get_current_tx_pwr_idx_if_pwrctrl_on(pi) \
953 (read_phy_reg(pi, 0x473) & 0x1ff)
954
955 #define wlc_lcnphy_get_target_tx_pwr(pi) \
956 ((read_phy_reg(pi, 0x4a7) & \
957 (0xff << 0)) >> \
958 0)
959
960 #define wlc_lcnphy_set_target_tx_pwr(pi, target) \
961 mod_phy_reg(pi, 0x4a7, \
962 (0xff << 0), \
963 (u16)(target) << 0)
964
965 #define wlc_radio_2064_rcal_done(pi) \
966 (0 != (read_radio_reg(pi, RADIO_2064_REG05C) & 0x20))
967
968 #define tempsense_done(pi) \
969 (0x8000 == (read_phy_reg(pi, 0x476) & 0x8000))
970
971 #define LCNPHY_IQLOCC_READ(val) \
972 ((u8)(-(s8)(((val) & 0xf0) >> 4) + (s8)((val) & 0x0f)))
973
974 #define FIXED_TXPWR 78
975 #define LCNPHY_TEMPSENSE(val) ((s16)((val > 255) ? (val - 512) : val))
976
977 void wlc_lcnphy_write_table(struct brcms_phy *pi, const struct phytbl_info *pti)
978 {
979 wlc_phy_write_table(pi, pti, 0x455, 0x457, 0x456);
980 }
981
982 void wlc_lcnphy_read_table(struct brcms_phy *pi, struct phytbl_info *pti)
983 {
984 wlc_phy_read_table(pi, pti, 0x455, 0x457, 0x456);
985 }
986
987 static void
988 wlc_lcnphy_common_read_table(struct brcms_phy *pi, u32 tbl_id,
989 const u16 *tbl_ptr, u32 tbl_len,
990 u32 tbl_width, u32 tbl_offset)
991 {
992 struct phytbl_info tab;
993 tab.tbl_id = tbl_id;
994 tab.tbl_ptr = tbl_ptr;
995 tab.tbl_len = tbl_len;
996 tab.tbl_width = tbl_width;
997 tab.tbl_offset = tbl_offset;
998 wlc_lcnphy_read_table(pi, &tab);
999 }
1000
1001 static void
1002 wlc_lcnphy_common_write_table(struct brcms_phy *pi, u32 tbl_id,
1003 const u16 *tbl_ptr, u32 tbl_len,
1004 u32 tbl_width, u32 tbl_offset)
1005 {
1006
1007 struct phytbl_info tab;
1008 tab.tbl_id = tbl_id;
1009 tab.tbl_ptr = tbl_ptr;
1010 tab.tbl_len = tbl_len;
1011 tab.tbl_width = tbl_width;
1012 tab.tbl_offset = tbl_offset;
1013 wlc_lcnphy_write_table(pi, &tab);
1014 }
1015
1016 static u32
1017 wlc_lcnphy_qdiv_roundup(u32 dividend, u32 divisor, u8 precision)
1018 {
1019 u32 quotient, remainder, roundup, rbit;
1020
1021 quotient = dividend / divisor;
1022 remainder = dividend % divisor;
1023 rbit = divisor & 1;
1024 roundup = (divisor >> 1) + rbit;
1025
1026 while (precision--) {
1027 quotient <<= 1;
1028 if (remainder >= roundup) {
1029 quotient++;
1030 remainder = ((remainder - roundup) << 1) + rbit;
1031 } else {
1032 remainder <<= 1;
1033 }
1034 }
1035
1036 if (remainder >= roundup)
1037 quotient++;
1038
1039 return quotient;
1040 }
1041
1042 static int wlc_lcnphy_calc_floor(s16 coeff_x, int type)
1043 {
1044 int k;
1045 k = 0;
1046 if (type == 0) {
1047 if (coeff_x < 0)
1048 k = (coeff_x - 1) / 2;
1049 else
1050 k = coeff_x / 2;
1051 }
1052
1053 if (type == 1) {
1054 if ((coeff_x + 1) < 0)
1055 k = (coeff_x) / 2;
1056 else
1057 k = (coeff_x + 1) / 2;
1058 }
1059 return k;
1060 }
1061
1062 static void
1063 wlc_lcnphy_get_tx_gain(struct brcms_phy *pi, struct lcnphy_txgains *gains)
1064 {
1065 u16 dac_gain, rfgain0, rfgain1;
1066
1067 dac_gain = read_phy_reg(pi, 0x439) >> 0;
1068 gains->dac_gain = (dac_gain & 0x380) >> 7;
1069
1070 rfgain0 = (read_phy_reg(pi, 0x4b5) & (0xffff << 0)) >> 0;
1071 rfgain1 = (read_phy_reg(pi, 0x4fb) & (0x7fff << 0)) >> 0;
1072
1073 gains->gm_gain = rfgain0 & 0xff;
1074 gains->pga_gain = (rfgain0 >> 8) & 0xff;
1075 gains->pad_gain = rfgain1 & 0xff;
1076 }
1077
1078
1079 static void wlc_lcnphy_set_dac_gain(struct brcms_phy *pi, u16 dac_gain)
1080 {
1081 u16 dac_ctrl;
1082
1083 dac_ctrl = (read_phy_reg(pi, 0x439) >> 0);
1084 dac_ctrl = dac_ctrl & 0xc7f;
1085 dac_ctrl = dac_ctrl | (dac_gain << 7);
1086 mod_phy_reg(pi, 0x439, (0xfff << 0), (dac_ctrl) << 0);
1087
1088 }
1089
1090 static void wlc_lcnphy_set_tx_gain_override(struct brcms_phy *pi, bool bEnable)
1091 {
1092 u16 bit = bEnable ? 1 : 0;
1093
1094 mod_phy_reg(pi, 0x4b0, (0x1 << 7), bit << 7);
1095
1096 mod_phy_reg(pi, 0x4b0, (0x1 << 14), bit << 14);
1097
1098 mod_phy_reg(pi, 0x43b, (0x1 << 6), bit << 6);
1099 }
1100
1101 static void
1102 wlc_lcnphy_rx_gain_override_enable(struct brcms_phy *pi, bool enable)
1103 {
1104 u16 ebit = enable ? 1 : 0;
1105
1106 mod_phy_reg(pi, 0x4b0, (0x1 << 8), ebit << 8);
1107
1108 mod_phy_reg(pi, 0x44c, (0x1 << 0), ebit << 0);
1109
1110 if (LCNREV_LT(pi->pubpi.phy_rev, 2)) {
1111 mod_phy_reg(pi, 0x44c, (0x1 << 4), ebit << 4);
1112 mod_phy_reg(pi, 0x44c, (0x1 << 6), ebit << 6);
1113 mod_phy_reg(pi, 0x4b0, (0x1 << 5), ebit << 5);
1114 mod_phy_reg(pi, 0x4b0, (0x1 << 6), ebit << 6);
1115 } else {
1116 mod_phy_reg(pi, 0x4b0, (0x1 << 12), ebit << 12);
1117 mod_phy_reg(pi, 0x4b0, (0x1 << 13), ebit << 13);
1118 mod_phy_reg(pi, 0x4b0, (0x1 << 5), ebit << 5);
1119 }
1120
1121 if (CHSPEC_IS2G(pi->radio_chanspec)) {
1122 mod_phy_reg(pi, 0x4b0, (0x1 << 10), ebit << 10);
1123 mod_phy_reg(pi, 0x4e5, (0x1 << 3), ebit << 3);
1124 }
1125 }
1126
1127 static void
1128 wlc_lcnphy_set_rx_gain_by_distribution(struct brcms_phy *pi,
1129 u16 trsw,
1130 u16 ext_lna,
1131 u16 biq2,
1132 u16 biq1,
1133 u16 tia, u16 lna2, u16 lna1)
1134 {
1135 u16 gain0_15, gain16_19;
1136
1137 gain16_19 = biq2 & 0xf;
1138 gain0_15 = ((biq1 & 0xf) << 12) |
1139 ((tia & 0xf) << 8) |
1140 ((lna2 & 0x3) << 6) |
1141 ((lna2 &
1142 0x3) << 4) | ((lna1 & 0x3) << 2) | ((lna1 & 0x3) << 0);
1143
1144 mod_phy_reg(pi, 0x4b6, (0xffff << 0), gain0_15 << 0);
1145 mod_phy_reg(pi, 0x4b7, (0xf << 0), gain16_19 << 0);
1146 mod_phy_reg(pi, 0x4b1, (0x3 << 11), lna1 << 11);
1147
1148 if (LCNREV_LT(pi->pubpi.phy_rev, 2)) {
1149 mod_phy_reg(pi, 0x4b1, (0x1 << 9), ext_lna << 9);
1150 mod_phy_reg(pi, 0x4b1, (0x1 << 10), ext_lna << 10);
1151 } else {
1152 mod_phy_reg(pi, 0x4b1, (0x1 << 10), 0 << 10);
1153
1154 mod_phy_reg(pi, 0x4b1, (0x1 << 15), 0 << 15);
1155
1156 mod_phy_reg(pi, 0x4b1, (0x1 << 9), ext_lna << 9);
1157 }
1158
1159 mod_phy_reg(pi, 0x44d, (0x1 << 0), (!trsw) << 0);
1160
1161 }
1162
1163 static void wlc_lcnphy_set_trsw_override(struct brcms_phy *pi, bool tx, bool rx)
1164 {
1165
1166 mod_phy_reg(pi, 0x44d,
1167 (0x1 << 1) |
1168 (0x1 << 0), (tx ? (0x1 << 1) : 0) | (rx ? (0x1 << 0) : 0));
1169
1170 or_phy_reg(pi, 0x44c, (0x1 << 1) | (0x1 << 0));
1171 }
1172
1173 static void wlc_lcnphy_clear_trsw_override(struct brcms_phy *pi)
1174 {
1175
1176 and_phy_reg(pi, 0x44c, (u16) ~((0x1 << 1) | (0x1 << 0)));
1177 }
1178
1179 static void wlc_lcnphy_set_rx_iq_comp(struct brcms_phy *pi, u16 a, u16 b)
1180 {
1181 mod_phy_reg(pi, 0x645, (0x3ff << 0), (a) << 0);
1182
1183 mod_phy_reg(pi, 0x646, (0x3ff << 0), (b) << 0);
1184
1185 mod_phy_reg(pi, 0x647, (0x3ff << 0), (a) << 0);
1186
1187 mod_phy_reg(pi, 0x648, (0x3ff << 0), (b) << 0);
1188
1189 mod_phy_reg(pi, 0x649, (0x3ff << 0), (a) << 0);
1190
1191 mod_phy_reg(pi, 0x64a, (0x3ff << 0), (b) << 0);
1192
1193 }
1194
1195 static bool
1196 wlc_lcnphy_rx_iq_est(struct brcms_phy *pi,
1197 u16 num_samps,
1198 u8 wait_time, struct lcnphy_iq_est *iq_est)
1199 {
1200 int wait_count = 0;
1201 bool result = true;
1202 u8 phybw40;
1203 phybw40 = CHSPEC_IS40(pi->radio_chanspec);
1204
1205 mod_phy_reg(pi, 0x6da, (0x1 << 5), (1) << 5);
1206
1207 mod_phy_reg(pi, 0x410, (0x1 << 3), (0) << 3);
1208
1209 mod_phy_reg(pi, 0x482, (0xffff << 0), (num_samps) << 0);
1210
1211 mod_phy_reg(pi, 0x481, (0xff << 0), ((u16) wait_time) << 0);
1212
1213 mod_phy_reg(pi, 0x481, (0x1 << 8), (0) << 8);
1214
1215 mod_phy_reg(pi, 0x481, (0x1 << 9), (1) << 9);
1216
1217 while (read_phy_reg(pi, 0x481) & (0x1 << 9)) {
1218
1219 if (wait_count > (10 * 500)) {
1220 result = false;
1221 goto cleanup;
1222 }
1223 udelay(100);
1224 wait_count++;
1225 }
1226
1227 iq_est->iq_prod = ((u32) read_phy_reg(pi, 0x483) << 16) |
1228 (u32) read_phy_reg(pi, 0x484);
1229 iq_est->i_pwr = ((u32) read_phy_reg(pi, 0x485) << 16) |
1230 (u32) read_phy_reg(pi, 0x486);
1231 iq_est->q_pwr = ((u32) read_phy_reg(pi, 0x487) << 16) |
1232 (u32) read_phy_reg(pi, 0x488);
1233
1234 cleanup:
1235 mod_phy_reg(pi, 0x410, (0x1 << 3), (1) << 3);
1236
1237 mod_phy_reg(pi, 0x6da, (0x1 << 5), (0) << 5);
1238
1239 return result;
1240 }
1241
1242 static bool wlc_lcnphy_calc_rx_iq_comp(struct brcms_phy *pi, u16 num_samps)
1243 {
1244 #define LCNPHY_MIN_RXIQ_PWR 2
1245 bool result;
1246 u16 a0_new, b0_new;
1247 struct lcnphy_iq_est iq_est = { 0, 0, 0 };
1248 s32 a, b, temp;
1249 s16 iq_nbits, qq_nbits, arsh, brsh;
1250 s32 iq;
1251 u32 ii, qq;
1252 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
1253
1254 a0_new = ((read_phy_reg(pi, 0x645) & (0x3ff << 0)) >> 0);
1255 b0_new = ((read_phy_reg(pi, 0x646) & (0x3ff << 0)) >> 0);
1256 mod_phy_reg(pi, 0x6d1, (0x1 << 2), (0) << 2);
1257
1258 mod_phy_reg(pi, 0x64b, (0x1 << 6), (1) << 6);
1259
1260 wlc_lcnphy_set_rx_iq_comp(pi, 0, 0);
1261
1262 result = wlc_lcnphy_rx_iq_est(pi, num_samps, 32, &iq_est);
1263 if (!result)
1264 goto cleanup;
1265
1266 iq = (s32) iq_est.iq_prod;
1267 ii = iq_est.i_pwr;
1268 qq = iq_est.q_pwr;
1269
1270 if ((ii + qq) < LCNPHY_MIN_RXIQ_PWR) {
1271 result = false;
1272 goto cleanup;
1273 }
1274
1275 iq_nbits = wlc_phy_nbits(iq);
1276 qq_nbits = wlc_phy_nbits(qq);
1277
1278 arsh = 10 - (30 - iq_nbits);
1279 if (arsh >= 0) {
1280 a = (-(iq << (30 - iq_nbits)) + (ii >> (1 + arsh)));
1281 temp = (s32) (ii >> arsh);
1282 if (temp == 0)
1283 return false;
1284 } else {
1285 a = (-(iq << (30 - iq_nbits)) + (ii << (-1 - arsh)));
1286 temp = (s32) (ii << -arsh);
1287 if (temp == 0)
1288 return false;
1289 }
1290 a /= temp;
1291 brsh = qq_nbits - 31 + 20;
1292 if (brsh >= 0) {
1293 b = (qq << (31 - qq_nbits));
1294 temp = (s32) (ii >> brsh);
1295 if (temp == 0)
1296 return false;
1297 } else {
1298 b = (qq << (31 - qq_nbits));
1299 temp = (s32) (ii << -brsh);
1300 if (temp == 0)
1301 return false;
1302 }
1303 b /= temp;
1304 b -= a * a;
1305 b = (s32) int_sqrt((unsigned long) b);
1306 b -= (1 << 10);
1307 a0_new = (u16) (a & 0x3ff);
1308 b0_new = (u16) (b & 0x3ff);
1309 cleanup:
1310
1311 wlc_lcnphy_set_rx_iq_comp(pi, a0_new, b0_new);
1312
1313 mod_phy_reg(pi, 0x64b, (0x1 << 0), (1) << 0);
1314
1315 mod_phy_reg(pi, 0x64b, (0x1 << 3), (1) << 3);
1316
1317 pi_lcn->lcnphy_cal_results.rxiqcal_coeff_a0 = a0_new;
1318 pi_lcn->lcnphy_cal_results.rxiqcal_coeff_b0 = b0_new;
1319
1320 return result;
1321 }
1322
1323 static u32 wlc_lcnphy_measure_digital_power(struct brcms_phy *pi, u16 nsamples)
1324 {
1325 struct lcnphy_iq_est iq_est = { 0, 0, 0 };
1326
1327 if (!wlc_lcnphy_rx_iq_est(pi, nsamples, 32, &iq_est))
1328 return 0;
1329 return (iq_est.i_pwr + iq_est.q_pwr) / nsamples;
1330 }
1331
1332 static bool
1333 wlc_lcnphy_rx_iq_cal(struct brcms_phy *pi,
1334 const struct lcnphy_rx_iqcomp *iqcomp,
1335 int iqcomp_sz, bool tx_switch, bool rx_switch, int module,
1336 int tx_gain_idx)
1337 {
1338 struct lcnphy_txgains old_gains;
1339 u16 tx_pwr_ctrl;
1340 u8 tx_gain_index_old = 0;
1341 bool result = false, tx_gain_override_old = false;
1342 u16 i, Core1TxControl_old, RFOverride0_old,
1343 RFOverrideVal0_old, rfoverride2_old, rfoverride2val_old,
1344 rfoverride3_old, rfoverride3val_old, rfoverride4_old,
1345 rfoverride4val_old, afectrlovr_old, afectrlovrval_old;
1346 int tia_gain;
1347 u32 received_power, rx_pwr_threshold;
1348 u16 old_sslpnCalibClkEnCtrl, old_sslpnRxFeClkEnCtrl;
1349 u16 values_to_save[11];
1350 s16 *ptr;
1351 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
1352
1353 ptr = kmalloc(sizeof(s16) * 131, GFP_ATOMIC);
1354 if (NULL == ptr)
1355 return false;
1356 if (module == 2) {
1357 while (iqcomp_sz--) {
1358 if (iqcomp[iqcomp_sz].chan ==
1359 CHSPEC_CHANNEL(pi->radio_chanspec)) {
1360 wlc_lcnphy_set_rx_iq_comp(pi,
1361 (u16)
1362 iqcomp[iqcomp_sz].a,
1363 (u16)
1364 iqcomp[iqcomp_sz].b);
1365 result = true;
1366 break;
1367 }
1368 }
1369 goto cal_done;
1370 }
1371
1372 if (module == 1) {
1373
1374 tx_pwr_ctrl = wlc_lcnphy_get_tx_pwr_ctrl(pi);
1375 wlc_lcnphy_set_tx_pwr_ctrl(pi, LCNPHY_TX_PWR_CTRL_OFF);
1376
1377 for (i = 0; i < 11; i++)
1378 values_to_save[i] =
1379 read_radio_reg(pi, rxiq_cal_rf_reg[i]);
1380 Core1TxControl_old = read_phy_reg(pi, 0x631);
1381
1382 or_phy_reg(pi, 0x631, 0x0015);
1383
1384 RFOverride0_old = read_phy_reg(pi, 0x44c);
1385 RFOverrideVal0_old = read_phy_reg(pi, 0x44d);
1386 rfoverride2_old = read_phy_reg(pi, 0x4b0);
1387 rfoverride2val_old = read_phy_reg(pi, 0x4b1);
1388 rfoverride3_old = read_phy_reg(pi, 0x4f9);
1389 rfoverride3val_old = read_phy_reg(pi, 0x4fa);
1390 rfoverride4_old = read_phy_reg(pi, 0x938);
1391 rfoverride4val_old = read_phy_reg(pi, 0x939);
1392 afectrlovr_old = read_phy_reg(pi, 0x43b);
1393 afectrlovrval_old = read_phy_reg(pi, 0x43c);
1394 old_sslpnCalibClkEnCtrl = read_phy_reg(pi, 0x6da);
1395 old_sslpnRxFeClkEnCtrl = read_phy_reg(pi, 0x6db);
1396
1397 tx_gain_override_old = wlc_lcnphy_tx_gain_override_enabled(pi);
1398 if (tx_gain_override_old) {
1399 wlc_lcnphy_get_tx_gain(pi, &old_gains);
1400 tx_gain_index_old = pi_lcn->lcnphy_current_index;
1401 }
1402
1403 wlc_lcnphy_set_tx_pwr_by_index(pi, tx_gain_idx);
1404
1405 mod_phy_reg(pi, 0x4f9, (0x1 << 0), 1 << 0);
1406 mod_phy_reg(pi, 0x4fa, (0x1 << 0), 0 << 0);
1407
1408 mod_phy_reg(pi, 0x43b, (0x1 << 1), 1 << 1);
1409 mod_phy_reg(pi, 0x43c, (0x1 << 1), 0 << 1);
1410
1411 write_radio_reg(pi, RADIO_2064_REG116, 0x06);
1412 write_radio_reg(pi, RADIO_2064_REG12C, 0x07);
1413 write_radio_reg(pi, RADIO_2064_REG06A, 0xd3);
1414 write_radio_reg(pi, RADIO_2064_REG098, 0x03);
1415 write_radio_reg(pi, RADIO_2064_REG00B, 0x7);
1416 mod_radio_reg(pi, RADIO_2064_REG113, 1 << 4, 1 << 4);
1417 write_radio_reg(pi, RADIO_2064_REG01D, 0x01);
1418 write_radio_reg(pi, RADIO_2064_REG114, 0x01);
1419 write_radio_reg(pi, RADIO_2064_REG02E, 0x10);
1420 write_radio_reg(pi, RADIO_2064_REG12A, 0x08);
1421
1422 mod_phy_reg(pi, 0x938, (0x1 << 0), 1 << 0);
1423 mod_phy_reg(pi, 0x939, (0x1 << 0), 0 << 0);
1424 mod_phy_reg(pi, 0x938, (0x1 << 1), 1 << 1);
1425 mod_phy_reg(pi, 0x939, (0x1 << 1), 1 << 1);
1426 mod_phy_reg(pi, 0x938, (0x1 << 2), 1 << 2);
1427 mod_phy_reg(pi, 0x939, (0x1 << 2), 1 << 2);
1428 mod_phy_reg(pi, 0x938, (0x1 << 3), 1 << 3);
1429 mod_phy_reg(pi, 0x939, (0x1 << 3), 1 << 3);
1430 mod_phy_reg(pi, 0x938, (0x1 << 5), 1 << 5);
1431 mod_phy_reg(pi, 0x939, (0x1 << 5), 0 << 5);
1432
1433 mod_phy_reg(pi, 0x43b, (0x1 << 0), 1 << 0);
1434 mod_phy_reg(pi, 0x43c, (0x1 << 0), 0 << 0);
1435
1436 wlc_lcnphy_start_tx_tone(pi, 2000, 120, 0);
1437 write_phy_reg(pi, 0x6da, 0xffff);
1438 or_phy_reg(pi, 0x6db, 0x3);
1439 wlc_lcnphy_set_trsw_override(pi, tx_switch, rx_switch);
1440 wlc_lcnphy_rx_gain_override_enable(pi, true);
1441
1442 tia_gain = 8;
1443 rx_pwr_threshold = 950;
1444 while (tia_gain > 0) {
1445 tia_gain -= 1;
1446 wlc_lcnphy_set_rx_gain_by_distribution(pi,
1447 0, 0, 2, 2,
1448 (u16)
1449 tia_gain, 1, 0);
1450 udelay(500);
1451
1452 received_power =
1453 wlc_lcnphy_measure_digital_power(pi, 2000);
1454 if (received_power < rx_pwr_threshold)
1455 break;
1456 }
1457 result = wlc_lcnphy_calc_rx_iq_comp(pi, 0xffff);
1458
1459 wlc_lcnphy_stop_tx_tone(pi);
1460
1461 write_phy_reg(pi, 0x631, Core1TxControl_old);
1462
1463 write_phy_reg(pi, 0x44c, RFOverrideVal0_old);
1464 write_phy_reg(pi, 0x44d, RFOverrideVal0_old);
1465 write_phy_reg(pi, 0x4b0, rfoverride2_old);
1466 write_phy_reg(pi, 0x4b1, rfoverride2val_old);
1467 write_phy_reg(pi, 0x4f9, rfoverride3_old);
1468 write_phy_reg(pi, 0x4fa, rfoverride3val_old);
1469 write_phy_reg(pi, 0x938, rfoverride4_old);
1470 write_phy_reg(pi, 0x939, rfoverride4val_old);
1471 write_phy_reg(pi, 0x43b, afectrlovr_old);
1472 write_phy_reg(pi, 0x43c, afectrlovrval_old);
1473 write_phy_reg(pi, 0x6da, old_sslpnCalibClkEnCtrl);
1474 write_phy_reg(pi, 0x6db, old_sslpnRxFeClkEnCtrl);
1475
1476 wlc_lcnphy_clear_trsw_override(pi);
1477
1478 mod_phy_reg(pi, 0x44c, (0x1 << 2), 0 << 2);
1479
1480 for (i = 0; i < 11; i++)
1481 write_radio_reg(pi, rxiq_cal_rf_reg[i],
1482 values_to_save[i]);
1483
1484 if (tx_gain_override_old)
1485 wlc_lcnphy_set_tx_pwr_by_index(pi, tx_gain_index_old);
1486 else
1487 wlc_lcnphy_disable_tx_gain_override(pi);
1488
1489 wlc_lcnphy_set_tx_pwr_ctrl(pi, tx_pwr_ctrl);
1490 wlc_lcnphy_rx_gain_override_enable(pi, false);
1491 }
1492
1493 cal_done:
1494 kfree(ptr);
1495 return result;
1496 }
1497
1498 s8 wlc_lcnphy_get_current_tx_pwr_idx(struct brcms_phy *pi)
1499 {
1500 s8 index;
1501 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
1502
1503 if (txpwrctrl_off(pi))
1504 index = pi_lcn->lcnphy_current_index;
1505 else if (wlc_lcnphy_tssi_based_pwr_ctrl_enabled(pi))
1506 index = (s8) (wlc_lcnphy_get_current_tx_pwr_idx_if_pwrctrl_on(
1507 pi) / 2);
1508 else
1509 index = pi_lcn->lcnphy_current_index;
1510 return index;
1511 }
1512
1513 void wlc_lcnphy_crsuprs(struct brcms_phy *pi, int channel)
1514 {
1515 u16 afectrlovr, afectrlovrval;
1516 afectrlovr = read_phy_reg(pi, 0x43b);
1517 afectrlovrval = read_phy_reg(pi, 0x43c);
1518 if (channel != 0) {
1519 mod_phy_reg(pi, 0x43b, (0x1 << 1), (1) << 1);
1520
1521 mod_phy_reg(pi, 0x43c, (0x1 << 1), (0) << 1);
1522
1523 mod_phy_reg(pi, 0x43b, (0x1 << 4), (1) << 4);
1524
1525 mod_phy_reg(pi, 0x43c, (0x1 << 6), (0) << 6);
1526
1527 write_phy_reg(pi, 0x44b, 0xffff);
1528 wlc_lcnphy_tx_pu(pi, 1);
1529
1530 mod_phy_reg(pi, 0x634, (0xff << 8), (0) << 8);
1531
1532 or_phy_reg(pi, 0x6da, 0x0080);
1533
1534 or_phy_reg(pi, 0x00a, 0x228);
1535 } else {
1536 and_phy_reg(pi, 0x00a, ~(0x228));
1537
1538 and_phy_reg(pi, 0x6da, 0xFF7F);
1539 write_phy_reg(pi, 0x43b, afectrlovr);
1540 write_phy_reg(pi, 0x43c, afectrlovrval);
1541 }
1542 }
1543
1544 static void wlc_lcnphy_toggle_afe_pwdn(struct brcms_phy *pi)
1545 {
1546 u16 save_AfeCtrlOvrVal, save_AfeCtrlOvr;
1547
1548 save_AfeCtrlOvrVal = read_phy_reg(pi, 0x43c);
1549 save_AfeCtrlOvr = read_phy_reg(pi, 0x43b);
1550
1551 write_phy_reg(pi, 0x43c, save_AfeCtrlOvrVal | 0x1);
1552 write_phy_reg(pi, 0x43b, save_AfeCtrlOvr | 0x1);
1553
1554 write_phy_reg(pi, 0x43c, save_AfeCtrlOvrVal & 0xfffe);
1555 write_phy_reg(pi, 0x43b, save_AfeCtrlOvr & 0xfffe);
1556
1557 write_phy_reg(pi, 0x43c, save_AfeCtrlOvrVal);
1558 write_phy_reg(pi, 0x43b, save_AfeCtrlOvr);
1559 }
1560
1561 static void
1562 wlc_lcnphy_txrx_spur_avoidance_mode(struct brcms_phy *pi, bool enable)
1563 {
1564 if (enable) {
1565 write_phy_reg(pi, 0x942, 0x7);
1566 write_phy_reg(pi, 0x93b, ((1 << 13) + 23));
1567 write_phy_reg(pi, 0x93c, ((1 << 13) + 1989));
1568
1569 write_phy_reg(pi, 0x44a, 0x084);
1570 write_phy_reg(pi, 0x44a, 0x080);
1571 write_phy_reg(pi, 0x6d3, 0x2222);
1572 write_phy_reg(pi, 0x6d3, 0x2220);
1573 } else {
1574 write_phy_reg(pi, 0x942, 0x0);
1575 write_phy_reg(pi, 0x93b, ((0 << 13) + 23));
1576 write_phy_reg(pi, 0x93c, ((0 << 13) + 1989));
1577 }
1578 wlapi_switch_macfreq(pi->sh->physhim, enable);
1579 }
1580
1581 static void
1582 wlc_lcnphy_set_chanspec_tweaks(struct brcms_phy *pi, u16 chanspec)
1583 {
1584 u8 channel = CHSPEC_CHANNEL(chanspec);
1585 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
1586
1587 if (channel == 14)
1588 mod_phy_reg(pi, 0x448, (0x3 << 8), (2) << 8);
1589 else
1590 mod_phy_reg(pi, 0x448, (0x3 << 8), (1) << 8);
1591
1592 pi_lcn->lcnphy_bandedge_corr = 2;
1593 if (channel == 1)
1594 pi_lcn->lcnphy_bandedge_corr = 4;
1595
1596 if (channel == 1 || channel == 2 || channel == 3 ||
1597 channel == 4 || channel == 9 ||
1598 channel == 10 || channel == 11 || channel == 12) {
1599 si_pmu_pllcontrol(pi->sh->sih, 0x2, 0xffffffff, 0x03000c04);
1600 si_pmu_pllcontrol(pi->sh->sih, 0x3, 0xffffff, 0x0);
1601 si_pmu_pllcontrol(pi->sh->sih, 0x4, 0xffffffff, 0x200005c0);
1602
1603 si_pmu_pllupd(pi->sh->sih);
1604 write_phy_reg(pi, 0x942, 0);
1605 wlc_lcnphy_txrx_spur_avoidance_mode(pi, false);
1606 pi_lcn->lcnphy_spurmod = false;
1607 mod_phy_reg(pi, 0x424, (0xff << 8), (0x1b) << 8);
1608
1609 write_phy_reg(pi, 0x425, 0x5907);
1610 } else {
1611 si_pmu_pllcontrol(pi->sh->sih, 0x2, 0xffffffff, 0x03140c04);
1612 si_pmu_pllcontrol(pi->sh->sih, 0x3, 0xffffff, 0x333333);
1613 si_pmu_pllcontrol(pi->sh->sih, 0x4, 0xffffffff, 0x202c2820);
1614
1615 si_pmu_pllupd(pi->sh->sih);
1616 write_phy_reg(pi, 0x942, 0);
1617 wlc_lcnphy_txrx_spur_avoidance_mode(pi, true);
1618
1619 pi_lcn->lcnphy_spurmod = false;
1620 mod_phy_reg(pi, 0x424, (0xff << 8), (0x1f) << 8);
1621
1622 write_phy_reg(pi, 0x425, 0x590a);
1623 }
1624
1625 or_phy_reg(pi, 0x44a, 0x44);
1626 write_phy_reg(pi, 0x44a, 0x80);
1627 }
1628
1629 static void
1630 wlc_lcnphy_radio_2064_channel_tune_4313(struct brcms_phy *pi, u8 channel)
1631 {
1632 uint i;
1633 const struct chan_info_2064_lcnphy *ci;
1634 u8 rfpll_doubler = 0;
1635 u8 pll_pwrup, pll_pwrup_ovr;
1636 s32 qFxtal, qFref, qFvco, qFcal;
1637 u8 d15, d16, f16, e44, e45;
1638 u32 div_int, div_frac, fvco3, fpfd, fref3, fcal_div;
1639 u16 loop_bw, d30, setCount;
1640
1641 u8 h29, h28_ten, e30, h30_ten, cp_current;
1642 u16 g30, d28;
1643
1644 ci = &chan_info_2064_lcnphy[0];
1645 rfpll_doubler = 1;
1646
1647 mod_radio_reg(pi, RADIO_2064_REG09D, 0x4, 0x1 << 2);
1648
1649 write_radio_reg(pi, RADIO_2064_REG09E, 0xf);
1650 if (!rfpll_doubler) {
1651 loop_bw = PLL_2064_LOOP_BW;
1652 d30 = PLL_2064_D30;
1653 } else {
1654 loop_bw = PLL_2064_LOOP_BW_DOUBLER;
1655 d30 = PLL_2064_D30_DOUBLER;
1656 }
1657
1658 if (CHSPEC_IS2G(pi->radio_chanspec)) {
1659 for (i = 0; i < ARRAY_SIZE(chan_info_2064_lcnphy); i++)
1660 if (chan_info_2064_lcnphy[i].chan == channel)
1661 break;
1662
1663 if (i >= ARRAY_SIZE(chan_info_2064_lcnphy))
1664 return;
1665
1666 ci = &chan_info_2064_lcnphy[i];
1667 }
1668
1669 write_radio_reg(pi, RADIO_2064_REG02A, ci->logen_buftune);
1670
1671 mod_radio_reg(pi, RADIO_2064_REG030, 0x3, ci->logen_rccr_tx);
1672
1673 mod_radio_reg(pi, RADIO_2064_REG091, 0x3, ci->txrf_mix_tune_ctrl);
1674
1675 mod_radio_reg(pi, RADIO_2064_REG038, 0xf, ci->pa_input_tune_g);
1676
1677 mod_radio_reg(pi, RADIO_2064_REG030, 0x3 << 2,
1678 (ci->logen_rccr_rx) << 2);
1679
1680 mod_radio_reg(pi, RADIO_2064_REG05E, 0xf, ci->pa_rxrf_lna1_freq_tune);
1681
1682 mod_radio_reg(pi, RADIO_2064_REG05E, (0xf) << 4,
1683 (ci->pa_rxrf_lna2_freq_tune) << 4);
1684
1685 write_radio_reg(pi, RADIO_2064_REG06C, ci->rxrf_rxrf_spare1);
1686
1687 pll_pwrup = (u8) read_radio_reg(pi, RADIO_2064_REG044);
1688 pll_pwrup_ovr = (u8) read_radio_reg(pi, RADIO_2064_REG12B);
1689
1690 or_radio_reg(pi, RADIO_2064_REG044, 0x07);
1691
1692 or_radio_reg(pi, RADIO_2064_REG12B, (0x07) << 1);
1693 e44 = 0;
1694 e45 = 0;
1695
1696 fpfd = rfpll_doubler ? (pi->xtalfreq << 1) : (pi->xtalfreq);
1697 if (pi->xtalfreq > 26000000)
1698 e44 = 1;
1699 if (pi->xtalfreq > 52000000)
1700 e45 = 1;
1701 if (e44 == 0)
1702 fcal_div = 1;
1703 else if (e45 == 0)
1704 fcal_div = 2;
1705 else
1706 fcal_div = 4;
1707 fvco3 = (ci->freq * 3);
1708 fref3 = 2 * fpfd;
1709
1710 qFxtal = wlc_lcnphy_qdiv_roundup(pi->xtalfreq, PLL_2064_MHZ, 16);
1711 qFref = wlc_lcnphy_qdiv_roundup(fpfd, PLL_2064_MHZ, 16);
1712 qFcal = pi->xtalfreq * fcal_div / PLL_2064_MHZ;
1713 qFvco = wlc_lcnphy_qdiv_roundup(fvco3, 2, 16);
1714
1715 write_radio_reg(pi, RADIO_2064_REG04F, 0x02);
1716
1717 d15 = (pi->xtalfreq * fcal_div * 4 / 5) / PLL_2064_MHZ - 1;
1718 write_radio_reg(pi, RADIO_2064_REG052, (0x07 & (d15 >> 2)));
1719 write_radio_reg(pi, RADIO_2064_REG053, (d15 & 0x3) << 5);
1720
1721 d16 = (qFcal * 8 / (d15 + 1)) - 1;
1722 write_radio_reg(pi, RADIO_2064_REG051, d16);
1723
1724 f16 = ((d16 + 1) * (d15 + 1)) / qFcal;
1725 setCount = f16 * 3 * (ci->freq) / 32 - 1;
1726 mod_radio_reg(pi, RADIO_2064_REG053, (0x0f << 0),
1727 (u8) (setCount >> 8));
1728
1729 or_radio_reg(pi, RADIO_2064_REG053, 0x10);
1730 write_radio_reg(pi, RADIO_2064_REG054, (u8) (setCount & 0xff));
1731
1732 div_int = ((fvco3 * (PLL_2064_MHZ >> 4)) / fref3) << 4;
1733
1734 div_frac = ((fvco3 * (PLL_2064_MHZ >> 4)) % fref3) << 4;
1735 while (div_frac >= fref3) {
1736 div_int++;
1737 div_frac -= fref3;
1738 }
1739 div_frac = wlc_lcnphy_qdiv_roundup(div_frac, fref3, 20);
1740
1741 mod_radio_reg(pi, RADIO_2064_REG045, (0x1f << 0),
1742 (u8) (div_int >> 4));
1743 mod_radio_reg(pi, RADIO_2064_REG046, (0x1f << 4),
1744 (u8) (div_int << 4));
1745 mod_radio_reg(pi, RADIO_2064_REG046, (0x0f << 0),
1746 (u8) (div_frac >> 16));
1747 write_radio_reg(pi, RADIO_2064_REG047, (u8) (div_frac >> 8) & 0xff);
1748 write_radio_reg(pi, RADIO_2064_REG048, (u8) div_frac & 0xff);
1749
1750 write_radio_reg(pi, RADIO_2064_REG040, 0xfb);
1751
1752 write_radio_reg(pi, RADIO_2064_REG041, 0x9A);
1753 write_radio_reg(pi, RADIO_2064_REG042, 0xA3);
1754 write_radio_reg(pi, RADIO_2064_REG043, 0x0C);
1755
1756 h29 = LCN_BW_LMT / loop_bw;
1757 d28 = (((PLL_2064_HIGH_END_KVCO - PLL_2064_LOW_END_KVCO) *
1758 (fvco3 / 2 - PLL_2064_LOW_END_VCO)) /
1759 (PLL_2064_HIGH_END_VCO - PLL_2064_LOW_END_VCO))
1760 + PLL_2064_LOW_END_KVCO;
1761 h28_ten = (d28 * 10) / LCN_VCO_DIV;
1762 e30 = (d30 - LCN_OFFSET) / LCN_FACT;
1763 g30 = LCN_OFFSET + (e30 * LCN_FACT);
1764 h30_ten = (g30 * 10) / LCN_CUR_DIV;
1765 cp_current = ((LCN_CUR_LMT * h29 * LCN_MULT * 100) / h28_ten) / h30_ten;
1766 mod_radio_reg(pi, RADIO_2064_REG03C, 0x3f, cp_current);
1767
1768 if (channel >= 1 && channel <= 5)
1769 write_radio_reg(pi, RADIO_2064_REG03C, 0x8);
1770 else
1771 write_radio_reg(pi, RADIO_2064_REG03C, 0x7);
1772 write_radio_reg(pi, RADIO_2064_REG03D, 0x3);
1773
1774 mod_radio_reg(pi, RADIO_2064_REG044, 0x0c, 0x0c);
1775 udelay(1);
1776
1777 wlc_2064_vco_cal(pi);
1778
1779 write_radio_reg(pi, RADIO_2064_REG044, pll_pwrup);
1780 write_radio_reg(pi, RADIO_2064_REG12B, pll_pwrup_ovr);
1781 if (LCNREV_IS(pi->pubpi.phy_rev, 1)) {
1782 write_radio_reg(pi, RADIO_2064_REG038, 3);
1783 write_radio_reg(pi, RADIO_2064_REG091, 7);
1784 }
1785 }
1786
1787 static int
1788 wlc_lcnphy_load_tx_iir_filter(struct brcms_phy *pi, bool is_ofdm, s16 filt_type)
1789 {
1790 s16 filt_index = -1;
1791 int j;
1792
1793 u16 addr[] = {
1794 0x910,
1795 0x91e,
1796 0x91f,
1797 0x924,
1798 0x925,
1799 0x926,
1800 0x920,
1801 0x921,
1802 0x927,
1803 0x928,
1804 0x929,
1805 0x922,
1806 0x923,
1807 0x930,
1808 0x931,
1809 0x932
1810 };
1811
1812 u16 addr_ofdm[] = {
1813 0x90f,
1814 0x900,
1815 0x901,
1816 0x906,
1817 0x907,
1818 0x908,
1819 0x902,
1820 0x903,
1821 0x909,
1822 0x90a,
1823 0x90b,
1824 0x904,
1825 0x905,
1826 0x90c,
1827 0x90d,
1828 0x90e
1829 };
1830
1831 if (!is_ofdm) {
1832 for (j = 0; j < LCNPHY_NUM_TX_DIG_FILTERS_CCK; j++) {
1833 if (filt_type == LCNPHY_txdigfiltcoeffs_cck[j][0]) {
1834 filt_index = (s16) j;
1835 break;
1836 }
1837 }
1838
1839 if (filt_index != -1) {
1840 for (j = 0; j < LCNPHY_NUM_DIG_FILT_COEFFS; j++)
1841 write_phy_reg(pi, addr[j],
1842 LCNPHY_txdigfiltcoeffs_cck
1843 [filt_index][j + 1]);
1844 }
1845 } else {
1846 for (j = 0; j < LCNPHY_NUM_TX_DIG_FILTERS_OFDM; j++) {
1847 if (filt_type == LCNPHY_txdigfiltcoeffs_ofdm[j][0]) {
1848 filt_index = (s16) j;
1849 break;
1850 }
1851 }
1852
1853 if (filt_index != -1) {
1854 for (j = 0; j < LCNPHY_NUM_DIG_FILT_COEFFS; j++)
1855 write_phy_reg(pi, addr_ofdm[j],
1856 LCNPHY_txdigfiltcoeffs_ofdm
1857 [filt_index][j + 1]);
1858 }
1859 }
1860
1861 return (filt_index != -1) ? 0 : -1;
1862 }
1863
1864 void wlc_phy_chanspec_set_lcnphy(struct brcms_phy *pi, u16 chanspec)
1865 {
1866 u8 channel = CHSPEC_CHANNEL(chanspec);
1867
1868 wlc_phy_chanspec_radio_set((struct brcms_phy_pub *) pi, chanspec);
1869
1870 wlc_lcnphy_set_chanspec_tweaks(pi, pi->radio_chanspec);
1871
1872 or_phy_reg(pi, 0x44a, 0x44);
1873 write_phy_reg(pi, 0x44a, 0x80);
1874
1875 wlc_lcnphy_radio_2064_channel_tune_4313(pi, channel);
1876 udelay(1000);
1877
1878 wlc_lcnphy_toggle_afe_pwdn(pi);
1879
1880 write_phy_reg(pi, 0x657, lcnphy_sfo_cfg[channel - 1].ptcentreTs20);
1881 write_phy_reg(pi, 0x658, lcnphy_sfo_cfg[channel - 1].ptcentreFactor);
1882
1883 if (CHSPEC_CHANNEL(pi->radio_chanspec) == 14) {
1884 mod_phy_reg(pi, 0x448, (0x3 << 8), (2) << 8);
1885
1886 wlc_lcnphy_load_tx_iir_filter(pi, false, 3);
1887 } else {
1888 mod_phy_reg(pi, 0x448, (0x3 << 8), (1) << 8);
1889
1890 wlc_lcnphy_load_tx_iir_filter(pi, false, 2);
1891 }
1892
1893 wlc_lcnphy_load_tx_iir_filter(pi, true, 0);
1894
1895 mod_phy_reg(pi, 0x4eb, (0x7 << 3), (1) << 3);
1896
1897 }
1898
1899 static u16 wlc_lcnphy_get_pa_gain(struct brcms_phy *pi)
1900 {
1901 u16 pa_gain;
1902
1903 pa_gain = (read_phy_reg(pi, 0x4fb) &
1904 LCNPHY_txgainctrlovrval1_pagain_ovr_val1_MASK) >>
1905 LCNPHY_txgainctrlovrval1_pagain_ovr_val1_SHIFT;
1906
1907 return pa_gain;
1908 }
1909
1910 static void wlc_lcnphy_set_tx_gain(struct brcms_phy *pi,
1911 struct lcnphy_txgains *target_gains)
1912 {
1913 u16 pa_gain = wlc_lcnphy_get_pa_gain(pi);
1914
1915 mod_phy_reg(
1916 pi, 0x4b5,
1917 (0xffff << 0),
1918 ((target_gains->gm_gain) |
1919 (target_gains->pga_gain << 8)) <<
1920 0);
1921 mod_phy_reg(pi, 0x4fb,
1922 (0x7fff << 0),
1923 ((target_gains->pad_gain) | (pa_gain << 8)) << 0);
1924
1925 mod_phy_reg(
1926 pi, 0x4fc,
1927 (0xffff << 0),
1928 ((target_gains->gm_gain) |
1929 (target_gains->pga_gain << 8)) <<
1930 0);
1931 mod_phy_reg(pi, 0x4fd,
1932 (0x7fff << 0),
1933 ((target_gains->pad_gain) | (pa_gain << 8)) << 0);
1934
1935 wlc_lcnphy_set_dac_gain(pi, target_gains->dac_gain);
1936
1937 wlc_lcnphy_enable_tx_gain_override(pi);
1938 }
1939
1940 static void wlc_lcnphy_set_bbmult(struct brcms_phy *pi, u8 m0)
1941 {
1942 u16 m0m1 = (u16) m0 << 8;
1943 struct phytbl_info tab;
1944
1945 tab.tbl_ptr = &m0m1;
1946 tab.tbl_len = 1;
1947 tab.tbl_id = LCNPHY_TBL_ID_IQLOCAL;
1948 tab.tbl_offset = 87;
1949 tab.tbl_width = 16;
1950 wlc_lcnphy_write_table(pi, &tab);
1951 }
1952
1953 static void wlc_lcnphy_clear_tx_power_offsets(struct brcms_phy *pi)
1954 {
1955 u32 data_buf[64];
1956 struct phytbl_info tab;
1957
1958 memset(data_buf, 0, sizeof(data_buf));
1959
1960 tab.tbl_id = LCNPHY_TBL_ID_TXPWRCTL;
1961 tab.tbl_width = 32;
1962 tab.tbl_ptr = data_buf;
1963
1964 if (!wlc_lcnphy_tempsense_based_pwr_ctrl_enabled(pi)) {
1965
1966 tab.tbl_len = 30;
1967 tab.tbl_offset = LCNPHY_TX_PWR_CTRL_RATE_OFFSET;
1968 wlc_lcnphy_write_table(pi, &tab);
1969 }
1970
1971 tab.tbl_len = 64;
1972 tab.tbl_offset = LCNPHY_TX_PWR_CTRL_MAC_OFFSET;
1973 wlc_lcnphy_write_table(pi, &tab);
1974 }
1975
1976 enum lcnphy_tssi_mode {
1977 LCNPHY_TSSI_PRE_PA,
1978 LCNPHY_TSSI_POST_PA,
1979 LCNPHY_TSSI_EXT
1980 };
1981
1982 static void
1983 wlc_lcnphy_set_tssi_mux(struct brcms_phy *pi, enum lcnphy_tssi_mode pos)
1984 {
1985 mod_phy_reg(pi, 0x4d7, (0x1 << 0), (0x1) << 0);
1986
1987 mod_phy_reg(pi, 0x4d7, (0x1 << 6), (1) << 6);
1988
1989 if (LCNPHY_TSSI_POST_PA == pos) {
1990 mod_phy_reg(pi, 0x4d9, (0x1 << 2), (0) << 2);
1991
1992 mod_phy_reg(pi, 0x4d9, (0x1 << 3), (1) << 3);
1993
1994 if (LCNREV_IS(pi->pubpi.phy_rev, 2)) {
1995 mod_radio_reg(pi, RADIO_2064_REG086, 0x4, 0x4);
1996 } else {
1997 mod_radio_reg(pi, RADIO_2064_REG03A, 1, 0x1);
1998 mod_radio_reg(pi, RADIO_2064_REG11A, 0x8, 0x8);
1999 }
2000 } else {
2001 mod_phy_reg(pi, 0x4d9, (0x1 << 2), (0x1) << 2);
2002
2003 mod_phy_reg(pi, 0x4d9, (0x1 << 3), (0) << 3);
2004
2005 if (LCNREV_IS(pi->pubpi.phy_rev, 2)) {
2006 mod_radio_reg(pi, RADIO_2064_REG086, 0x4, 0x4);
2007 } else {
2008 mod_radio_reg(pi, RADIO_2064_REG03A, 1, 0);
2009 mod_radio_reg(pi, RADIO_2064_REG11A, 0x8, 0x8);
2010 }
2011 }
2012 mod_phy_reg(pi, 0x637, (0x3 << 14), (0) << 14);
2013
2014 if (LCNPHY_TSSI_EXT == pos) {
2015 write_radio_reg(pi, RADIO_2064_REG07F, 1);
2016 mod_radio_reg(pi, RADIO_2064_REG005, 0x7, 0x2);
2017 mod_radio_reg(pi, RADIO_2064_REG112, 0x80, 0x1 << 7);
2018 mod_radio_reg(pi, RADIO_2064_REG028, 0x1f, 0x3);
2019 }
2020 }
2021
2022 static u16 wlc_lcnphy_rfseq_tbl_adc_pwrup(struct brcms_phy *pi)
2023 {
2024 u16 N1, N2, N3, N4, N5, N6, N;
2025 N1 = ((read_phy_reg(pi, 0x4a5) & (0xff << 0))
2026 >> 0);
2027 N2 = 1 << ((read_phy_reg(pi, 0x4a5) & (0x7 << 12))
2028 >> 12);
2029 N3 = ((read_phy_reg(pi, 0x40d) & (0xff << 0))
2030 >> 0);
2031 N4 = 1 << ((read_phy_reg(pi, 0x40d) & (0x7 << 8))
2032 >> 8);
2033 N5 = ((read_phy_reg(pi, 0x4a2) & (0xff << 0))
2034 >> 0);
2035 N6 = 1 << ((read_phy_reg(pi, 0x4a2) & (0x7 << 8))
2036 >> 8);
2037 N = 2 * (N1 + N2 + N3 + N4 + 2 * (N5 + N6)) + 80;
2038 if (N < 1600)
2039 N = 1600;
2040 return N;
2041 }
2042
2043 static void wlc_lcnphy_pwrctrl_rssiparams(struct brcms_phy *pi)
2044 {
2045 u16 auxpga_vmid, auxpga_vmid_temp, auxpga_gain_temp;
2046 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
2047
2048 auxpga_vmid = (2 << 8) |
2049 (pi_lcn->lcnphy_rssi_vc << 4) | pi_lcn->lcnphy_rssi_vf;
2050 auxpga_vmid_temp = (2 << 8) | (8 << 4) | 4;
2051 auxpga_gain_temp = 2;
2052
2053 mod_phy_reg(pi, 0x4d8, (0x1 << 0), (0) << 0);
2054
2055 mod_phy_reg(pi, 0x4d8, (0x1 << 1), (0) << 1);
2056
2057 mod_phy_reg(pi, 0x4d7, (0x1 << 3), (0) << 3);
2058
2059 mod_phy_reg(pi, 0x4db,
2060 (0x3ff << 0) |
2061 (0x7 << 12),
2062 (auxpga_vmid << 0) | (pi_lcn->lcnphy_rssi_gs << 12));
2063
2064 mod_phy_reg(pi, 0x4dc,
2065 (0x3ff << 0) |
2066 (0x7 << 12),
2067 (auxpga_vmid << 0) | (pi_lcn->lcnphy_rssi_gs << 12));
2068
2069 mod_phy_reg(pi, 0x40a,
2070 (0x3ff << 0) |
2071 (0x7 << 12),
2072 (auxpga_vmid << 0) | (pi_lcn->lcnphy_rssi_gs << 12));
2073
2074 mod_phy_reg(pi, 0x40b,
2075 (0x3ff << 0) |
2076 (0x7 << 12),
2077 (auxpga_vmid_temp << 0) | (auxpga_gain_temp << 12));
2078
2079 mod_phy_reg(pi, 0x40c,
2080 (0x3ff << 0) |
2081 (0x7 << 12),
2082 (auxpga_vmid_temp << 0) | (auxpga_gain_temp << 12));
2083
2084 mod_radio_reg(pi, RADIO_2064_REG082, (1 << 5), (1 << 5));
2085 }
2086
2087 static void wlc_lcnphy_tssi_setup(struct brcms_phy *pi)
2088 {
2089 struct phytbl_info tab;
2090 u32 rfseq, ind;
2091
2092 tab.tbl_id = LCNPHY_TBL_ID_TXPWRCTL;
2093 tab.tbl_width = 32;
2094 tab.tbl_ptr = &ind;
2095 tab.tbl_len = 1;
2096 tab.tbl_offset = 0;
2097 for (ind = 0; ind < 128; ind++) {
2098 wlc_lcnphy_write_table(pi, &tab);
2099 tab.tbl_offset++;
2100 }
2101 tab.tbl_offset = 704;
2102 for (ind = 0; ind < 128; ind++) {
2103 wlc_lcnphy_write_table(pi, &tab);
2104 tab.tbl_offset++;
2105 }
2106 mod_phy_reg(pi, 0x503, (0x1 << 0), (0) << 0);
2107
2108 mod_phy_reg(pi, 0x503, (0x1 << 2), (0) << 2);
2109
2110 mod_phy_reg(pi, 0x503, (0x1 << 4), (1) << 4);
2111
2112 wlc_lcnphy_set_tssi_mux(pi, LCNPHY_TSSI_EXT);
2113 mod_phy_reg(pi, 0x4a4, (0x1 << 14), (0) << 14);
2114
2115 mod_phy_reg(pi, 0x4a4, (0x1 << 15), (1) << 15);
2116
2117 mod_phy_reg(pi, 0x4d0, (0x1 << 5), (0) << 5);
2118
2119 mod_phy_reg(pi, 0x4a4, (0x1ff << 0), (0) << 0);
2120
2121 mod_phy_reg(pi, 0x4a5, (0xff << 0), (255) << 0);
2122
2123 mod_phy_reg(pi, 0x4a5, (0x7 << 12), (5) << 12);
2124
2125 mod_phy_reg(pi, 0x4a5, (0x7 << 8), (0) << 8);
2126
2127 mod_phy_reg(pi, 0x40d, (0xff << 0), (64) << 0);
2128
2129 mod_phy_reg(pi, 0x40d, (0x7 << 8), (4) << 8);
2130
2131 mod_phy_reg(pi, 0x4a2, (0xff << 0), (64) << 0);
2132
2133 mod_phy_reg(pi, 0x4a2, (0x7 << 8), (4) << 8);
2134
2135 mod_phy_reg(pi, 0x4d0, (0x1ff << 6), (0) << 6);
2136
2137 mod_phy_reg(pi, 0x4a8, (0xff << 0), (0x1) << 0);
2138
2139 wlc_lcnphy_clear_tx_power_offsets(pi);
2140
2141 mod_phy_reg(pi, 0x4a6, (0x1 << 15), (1) << 15);
2142
2143 mod_phy_reg(pi, 0x4a6, (0x1ff << 0), (0xff) << 0);
2144
2145 mod_phy_reg(pi, 0x49a, (0x1ff << 0), (0xff) << 0);
2146
2147 if (LCNREV_IS(pi->pubpi.phy_rev, 2)) {
2148 mod_radio_reg(pi, RADIO_2064_REG028, 0xf, 0xe);
2149 mod_radio_reg(pi, RADIO_2064_REG086, 0x4, 0x4);
2150 } else {
2151 mod_radio_reg(pi, RADIO_2064_REG03A, 0x1, 1);
2152 mod_radio_reg(pi, RADIO_2064_REG11A, 0x8, 1 << 3);
2153 }
2154
2155 write_radio_reg(pi, RADIO_2064_REG025, 0xc);
2156
2157 if (LCNREV_IS(pi->pubpi.phy_rev, 2)) {
2158 mod_radio_reg(pi, RADIO_2064_REG03A, 0x1, 1);
2159 } else {
2160 if (CHSPEC_IS2G(pi->radio_chanspec))
2161 mod_radio_reg(pi, RADIO_2064_REG03A, 0x2, 1 << 1);
2162 else
2163 mod_radio_reg(pi, RADIO_2064_REG03A, 0x2, 0 << 1);
2164 }
2165
2166 if (LCNREV_IS(pi->pubpi.phy_rev, 2))
2167 mod_radio_reg(pi, RADIO_2064_REG03A, 0x2, 1 << 1);
2168 else
2169 mod_radio_reg(pi, RADIO_2064_REG03A, 0x4, 1 << 2);
2170
2171 mod_radio_reg(pi, RADIO_2064_REG11A, 0x1, 1 << 0);
2172
2173 mod_radio_reg(pi, RADIO_2064_REG005, 0x8, 1 << 3);
2174
2175 if (!wlc_lcnphy_tempsense_based_pwr_ctrl_enabled(pi))
2176 mod_phy_reg(pi, 0x4d7,
2177 (0x1 << 3) | (0x7 << 12), 0 << 3 | 2 << 12);
2178
2179 rfseq = wlc_lcnphy_rfseq_tbl_adc_pwrup(pi);
2180 tab.tbl_id = LCNPHY_TBL_ID_RFSEQ;
2181 tab.tbl_width = 16;
2182 tab.tbl_ptr = &rfseq;
2183 tab.tbl_len = 1;
2184 tab.tbl_offset = 6;
2185 wlc_lcnphy_write_table(pi, &tab);
2186
2187 mod_phy_reg(pi, 0x938, (0x1 << 2), (1) << 2);
2188
2189 mod_phy_reg(pi, 0x939, (0x1 << 2), (1) << 2);
2190
2191 mod_phy_reg(pi, 0x4a4, (0x1 << 12), (1) << 12);
2192
2193 mod_phy_reg(pi, 0x4d7, (0x1 << 2), (1) << 2);
2194
2195 mod_phy_reg(pi, 0x4d7, (0xf << 8), (0) << 8);
2196
2197 wlc_lcnphy_pwrctrl_rssiparams(pi);
2198 }
2199
2200 void wlc_lcnphy_tx_pwr_update_npt(struct brcms_phy *pi)
2201 {
2202 u16 tx_cnt, tx_total, npt;
2203 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
2204
2205 tx_total = wlc_lcnphy_total_tx_frames(pi);
2206 tx_cnt = tx_total - pi_lcn->lcnphy_tssi_tx_cnt;
2207 npt = wlc_lcnphy_get_tx_pwr_npt(pi);
2208
2209 if (tx_cnt > (1 << npt)) {
2210
2211 pi_lcn->lcnphy_tssi_tx_cnt = tx_total;
2212
2213 pi_lcn->lcnphy_tssi_idx = wlc_lcnphy_get_current_tx_pwr_idx(pi);
2214 pi_lcn->lcnphy_tssi_npt = npt;
2215
2216 }
2217 }
2218
2219 s32 wlc_lcnphy_tssi2dbm(s32 tssi, s32 a1, s32 b0, s32 b1)
2220 {
2221 s32 a, b, p;
2222
2223 a = 32768 + (a1 * tssi);
2224 b = (1024 * b0) + (64 * b1 * tssi);
2225 p = ((2 * b) + a) / (2 * a);
2226
2227 return p;
2228 }
2229
2230 static void wlc_lcnphy_txpower_reset_npt(struct brcms_phy *pi)
2231 {
2232 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
2233 if (wlc_lcnphy_tempsense_based_pwr_ctrl_enabled(pi))
2234 return;
2235
2236 pi_lcn->lcnphy_tssi_idx = LCNPHY_TX_PWR_CTRL_START_INDEX_2G_4313;
2237 pi_lcn->lcnphy_tssi_npt = LCNPHY_TX_PWR_CTRL_START_NPT;
2238 }
2239
2240 void wlc_lcnphy_txpower_recalc_target(struct brcms_phy *pi)
2241 {
2242 struct phytbl_info tab;
2243 u32 rate_table[BRCMS_NUM_RATES_CCK + BRCMS_NUM_RATES_OFDM +
2244 BRCMS_NUM_RATES_MCS_1_STREAM];
2245 uint i, j;
2246 if (wlc_lcnphy_tempsense_based_pwr_ctrl_enabled(pi))
2247 return;
2248
2249 for (i = 0, j = 0; i < ARRAY_SIZE(rate_table); i++, j++) {
2250
2251 if (i == BRCMS_NUM_RATES_CCK + BRCMS_NUM_RATES_OFDM)
2252 j = TXP_FIRST_MCS_20_SISO;
2253
2254 rate_table[i] = (u32) ((s32) (-pi->tx_power_offset[j]));
2255 }
2256
2257 tab.tbl_id = LCNPHY_TBL_ID_TXPWRCTL;
2258 tab.tbl_width = 32;
2259 tab.tbl_len = ARRAY_SIZE(rate_table);
2260 tab.tbl_ptr = rate_table;
2261 tab.tbl_offset = LCNPHY_TX_PWR_CTRL_RATE_OFFSET;
2262 wlc_lcnphy_write_table(pi, &tab);
2263
2264 if (wlc_lcnphy_get_target_tx_pwr(pi) != pi->tx_power_min) {
2265 wlc_lcnphy_set_target_tx_pwr(pi, pi->tx_power_min);
2266
2267 wlc_lcnphy_txpower_reset_npt(pi);
2268 }
2269 }
2270
2271 static void wlc_lcnphy_set_tx_pwr_soft_ctrl(struct brcms_phy *pi, s8 index)
2272 {
2273 u32 cck_offset[4] = { 22, 22, 22, 22 };
2274 u32 ofdm_offset, reg_offset_cck;
2275 int i;
2276 u16 index2;
2277 struct phytbl_info tab;
2278
2279 if (wlc_lcnphy_tssi_based_pwr_ctrl_enabled(pi))
2280 return;
2281
2282 mod_phy_reg(pi, 0x4a4, (0x1 << 14), (0x1) << 14);
2283
2284 mod_phy_reg(pi, 0x4a4, (0x1 << 14), (0x0) << 14);
2285
2286 or_phy_reg(pi, 0x6da, 0x0040);
2287
2288 reg_offset_cck = 0;
2289 for (i = 0; i < 4; i++)
2290 cck_offset[i] -= reg_offset_cck;
2291 tab.tbl_id = LCNPHY_TBL_ID_TXPWRCTL;
2292 tab.tbl_width = 32;
2293 tab.tbl_len = 4;
2294 tab.tbl_ptr = cck_offset;
2295 tab.tbl_offset = LCNPHY_TX_PWR_CTRL_RATE_OFFSET;
2296 wlc_lcnphy_write_table(pi, &tab);
2297 ofdm_offset = 0;
2298 tab.tbl_len = 1;
2299 tab.tbl_ptr = &ofdm_offset;
2300 for (i = 836; i < 862; i++) {
2301 tab.tbl_offset = i;
2302 wlc_lcnphy_write_table(pi, &tab);
2303 }
2304
2305 mod_phy_reg(pi, 0x4a4, (0x1 << 15), (0x1) << 15);
2306
2307 mod_phy_reg(pi, 0x4a4, (0x1 << 14), (0x1) << 14);
2308
2309 mod_phy_reg(pi, 0x4a4, (0x1 << 13), (0x1) << 13);
2310
2311 mod_phy_reg(pi, 0x4b0, (0x1 << 7), (0) << 7);
2312
2313 mod_phy_reg(pi, 0x43b, (0x1 << 6), (0) << 6);
2314
2315 mod_phy_reg(pi, 0x4a9, (0x1 << 15), (1) << 15);
2316
2317 index2 = (u16) (index * 2);
2318 mod_phy_reg(pi, 0x4a9, (0x1ff << 0), (index2) << 0);
2319
2320 mod_phy_reg(pi, 0x6a3, (0x1 << 4), (0) << 4);
2321
2322 }
2323
2324 static s8 wlc_lcnphy_tempcompensated_txpwrctrl(struct brcms_phy *pi)
2325 {
2326 s8 index, delta_brd, delta_temp, new_index, tempcorrx;
2327 s16 manp, meas_temp, temp_diff;
2328 bool neg = false;
2329 u16 temp;
2330 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
2331
2332 if (wlc_lcnphy_tssi_based_pwr_ctrl_enabled(pi))
2333 return pi_lcn->lcnphy_current_index;
2334
2335 index = FIXED_TXPWR;
2336
2337 if (pi_lcn->lcnphy_tempsense_slope == 0)
2338 return index;
2339
2340 temp = (u16) wlc_lcnphy_tempsense(pi, 0);
2341 meas_temp = LCNPHY_TEMPSENSE(temp);
2342
2343 if (pi->tx_power_min != 0)
2344 delta_brd = (pi_lcn->lcnphy_measPower - pi->tx_power_min);
2345 else
2346 delta_brd = 0;
2347
2348 manp = LCNPHY_TEMPSENSE(pi_lcn->lcnphy_rawtempsense);
2349 temp_diff = manp - meas_temp;
2350 if (temp_diff < 0) {
2351 neg = true;
2352 temp_diff = -temp_diff;
2353 }
2354
2355 delta_temp = (s8) wlc_lcnphy_qdiv_roundup((u32) (temp_diff * 192),
2356 (u32) (pi_lcn->
2357 lcnphy_tempsense_slope
2358 * 10), 0);
2359 if (neg)
2360 delta_temp = -delta_temp;
2361
2362 if (pi_lcn->lcnphy_tempsense_option == 3
2363 && LCNREV_IS(pi->pubpi.phy_rev, 0))
2364 delta_temp = 0;
2365 if (pi_lcn->lcnphy_tempcorrx > 31)
2366 tempcorrx = (s8) (pi_lcn->lcnphy_tempcorrx - 64);
2367 else
2368 tempcorrx = (s8) pi_lcn->lcnphy_tempcorrx;
2369 if (LCNREV_IS(pi->pubpi.phy_rev, 1))
2370 tempcorrx = 4;
2371 new_index =
2372 index + delta_brd + delta_temp - pi_lcn->lcnphy_bandedge_corr;
2373 new_index += tempcorrx;
2374
2375 if (LCNREV_IS(pi->pubpi.phy_rev, 1))
2376 index = 127;
2377
2378 if (new_index < 0 || new_index > 126)
2379 return index;
2380
2381 return new_index;
2382 }
2383
2384 static u16 wlc_lcnphy_set_tx_pwr_ctrl_mode(struct brcms_phy *pi, u16 mode)
2385 {
2386
2387 u16 current_mode = mode;
2388 if (wlc_lcnphy_tempsense_based_pwr_ctrl_enabled(pi) &&
2389 mode == LCNPHY_TX_PWR_CTRL_HW)
2390 current_mode = LCNPHY_TX_PWR_CTRL_TEMPBASED;
2391 if (wlc_lcnphy_tssi_based_pwr_ctrl_enabled(pi) &&
2392 mode == LCNPHY_TX_PWR_CTRL_TEMPBASED)
2393 current_mode = LCNPHY_TX_PWR_CTRL_HW;
2394 return current_mode;
2395 }
2396
2397 void wlc_lcnphy_set_tx_pwr_ctrl(struct brcms_phy *pi, u16 mode)
2398 {
2399 u16 old_mode = wlc_lcnphy_get_tx_pwr_ctrl(pi);
2400 s8 index;
2401 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
2402
2403 mode = wlc_lcnphy_set_tx_pwr_ctrl_mode(pi, mode);
2404 old_mode = wlc_lcnphy_set_tx_pwr_ctrl_mode(pi, old_mode);
2405
2406 mod_phy_reg(pi, 0x6da, (0x1 << 6),
2407 ((LCNPHY_TX_PWR_CTRL_HW == mode) ? 1 : 0) << 6);
2408
2409 mod_phy_reg(pi, 0x6a3, (0x1 << 4),
2410 ((LCNPHY_TX_PWR_CTRL_HW == mode) ? 0 : 1) << 4);
2411
2412 if (old_mode != mode) {
2413 if (LCNPHY_TX_PWR_CTRL_HW == old_mode) {
2414
2415 wlc_lcnphy_tx_pwr_update_npt(pi);
2416
2417 wlc_lcnphy_clear_tx_power_offsets(pi);
2418 }
2419 if (LCNPHY_TX_PWR_CTRL_HW == mode) {
2420
2421 wlc_lcnphy_txpower_recalc_target(pi);
2422
2423 wlc_lcnphy_set_start_tx_pwr_idx(pi,
2424 pi_lcn->
2425 lcnphy_tssi_idx);
2426 wlc_lcnphy_set_tx_pwr_npt(pi, pi_lcn->lcnphy_tssi_npt);
2427 mod_radio_reg(pi, RADIO_2064_REG11F, 0x4, 0);
2428
2429 pi_lcn->lcnphy_tssi_tx_cnt =
2430 wlc_lcnphy_total_tx_frames(pi);
2431
2432 wlc_lcnphy_disable_tx_gain_override(pi);
2433 pi_lcn->lcnphy_tx_power_idx_override = -1;
2434 } else
2435 wlc_lcnphy_enable_tx_gain_override(pi);
2436
2437 mod_phy_reg(pi, 0x4a4,
2438 ((0x1 << 15) | (0x1 << 14) | (0x1 << 13)), mode);
2439 if (mode == LCNPHY_TX_PWR_CTRL_TEMPBASED) {
2440 index = wlc_lcnphy_tempcompensated_txpwrctrl(pi);
2441 wlc_lcnphy_set_tx_pwr_soft_ctrl(pi, index);
2442 pi_lcn->lcnphy_current_index = (s8)
2443 ((read_phy_reg(pi,
2444 0x4a9) &
2445 0xFF) / 2);
2446 }
2447 }
2448 }
2449
2450 static void
2451 wlc_lcnphy_tx_iqlo_loopback(struct brcms_phy *pi, u16 *values_to_save)
2452 {
2453 u16 vmid;
2454 int i;
2455 for (i = 0; i < 20; i++)
2456 values_to_save[i] =
2457 read_radio_reg(pi, iqlo_loopback_rf_regs[i]);
2458
2459 mod_phy_reg(pi, 0x44c, (0x1 << 12), 1 << 12);
2460 mod_phy_reg(pi, 0x44d, (0x1 << 14), 1 << 14);
2461
2462 mod_phy_reg(pi, 0x44c, (0x1 << 11), 1 << 11);
2463 mod_phy_reg(pi, 0x44d, (0x1 << 13), 0 << 13);
2464
2465 mod_phy_reg(pi, 0x43b, (0x1 << 1), 1 << 1);
2466 mod_phy_reg(pi, 0x43c, (0x1 << 1), 0 << 1);
2467
2468 mod_phy_reg(pi, 0x43b, (0x1 << 0), 1 << 0);
2469 mod_phy_reg(pi, 0x43c, (0x1 << 0), 0 << 0);
2470
2471 if (LCNREV_IS(pi->pubpi.phy_rev, 2))
2472 and_radio_reg(pi, RADIO_2064_REG03A, 0xFD);
2473 else
2474 and_radio_reg(pi, RADIO_2064_REG03A, 0xF9);
2475 or_radio_reg(pi, RADIO_2064_REG11A, 0x1);
2476
2477 or_radio_reg(pi, RADIO_2064_REG036, 0x01);
2478 or_radio_reg(pi, RADIO_2064_REG11A, 0x18);
2479 udelay(20);
2480
2481 if (LCNREV_IS(pi->pubpi.phy_rev, 2)) {
2482 if (CHSPEC_IS5G(pi->radio_chanspec))
2483 mod_radio_reg(pi, RADIO_2064_REG03A, 1, 0);
2484 else
2485 or_radio_reg(pi, RADIO_2064_REG03A, 1);
2486 } else {
2487 if (CHSPEC_IS5G(pi->radio_chanspec))
2488 mod_radio_reg(pi, RADIO_2064_REG03A, 3, 1);
2489 else
2490 or_radio_reg(pi, RADIO_2064_REG03A, 0x3);
2491 }
2492
2493 udelay(20);
2494
2495 write_radio_reg(pi, RADIO_2064_REG025, 0xF);
2496 if (LCNREV_IS(pi->pubpi.phy_rev, 2)) {
2497 if (CHSPEC_IS5G(pi->radio_chanspec))
2498 mod_radio_reg(pi, RADIO_2064_REG028, 0xF, 0x4);
2499 else
2500 mod_radio_reg(pi, RADIO_2064_REG028, 0xF, 0x6);
2501 } else {
2502 if (CHSPEC_IS5G(pi->radio_chanspec))
2503 mod_radio_reg(pi, RADIO_2064_REG028, 0x1e, 0x4 << 1);
2504 else
2505 mod_radio_reg(pi, RADIO_2064_REG028, 0x1e, 0x6 << 1);
2506 }
2507
2508 udelay(20);
2509
2510 write_radio_reg(pi, RADIO_2064_REG005, 0x8);
2511 or_radio_reg(pi, RADIO_2064_REG112, 0x80);
2512 udelay(20);
2513
2514 or_radio_reg(pi, RADIO_2064_REG0FF, 0x10);
2515 or_radio_reg(pi, RADIO_2064_REG11F, 0x44);
2516 udelay(20);
2517
2518 or_radio_reg(pi, RADIO_2064_REG00B, 0x7);
2519 or_radio_reg(pi, RADIO_2064_REG113, 0x10);
2520 udelay(20);
2521
2522 write_radio_reg(pi, RADIO_2064_REG007, 0x1);
2523 udelay(20);
2524
2525 vmid = 0x2A6;
2526 mod_radio_reg(pi, RADIO_2064_REG0FC, 0x3 << 0, (vmid >> 8) & 0x3);
2527 write_radio_reg(pi, RADIO_2064_REG0FD, (vmid & 0xff));
2528 or_radio_reg(pi, RADIO_2064_REG11F, 0x44);
2529 udelay(20);
2530
2531 or_radio_reg(pi, RADIO_2064_REG0FF, 0x10);
2532 udelay(20);
2533 write_radio_reg(pi, RADIO_2064_REG012, 0x02);
2534 or_radio_reg(pi, RADIO_2064_REG112, 0x06);
2535 write_radio_reg(pi, RADIO_2064_REG036, 0x11);
2536 write_radio_reg(pi, RADIO_2064_REG059, 0xcc);
2537 write_radio_reg(pi, RADIO_2064_REG05C, 0x2e);
2538 write_radio_reg(pi, RADIO_2064_REG078, 0xd7);
2539 write_radio_reg(pi, RADIO_2064_REG092, 0x15);
2540 }
2541
2542 static bool wlc_lcnphy_iqcal_wait(struct brcms_phy *pi)
2543 {
2544 uint delay_count = 0;
2545
2546 while (wlc_lcnphy_iqcal_active(pi)) {
2547 udelay(100);
2548 delay_count++;
2549
2550 if (delay_count > (10 * 500))
2551 break;
2552 }
2553
2554 return (0 == wlc_lcnphy_iqcal_active(pi));
2555 }
2556
2557 static void
2558 wlc_lcnphy_tx_iqlo_loopback_cleanup(struct brcms_phy *pi, u16 *values_to_save)
2559 {
2560 int i;
2561
2562 and_phy_reg(pi, 0x44c, 0x0 >> 11);
2563
2564 and_phy_reg(pi, 0x43b, 0xC);
2565
2566 for (i = 0; i < 20; i++)
2567 write_radio_reg(pi, iqlo_loopback_rf_regs[i],
2568 values_to_save[i]);
2569 }
2570
2571 static void
2572 wlc_lcnphy_tx_iqlo_cal(struct brcms_phy *pi,
2573 struct lcnphy_txgains *target_gains,
2574 enum lcnphy_cal_mode cal_mode, bool keep_tone)
2575 {
2576
2577 struct lcnphy_txgains cal_gains, temp_gains;
2578 u16 hash;
2579 u8 band_idx;
2580 int j;
2581 u16 ncorr_override[5];
2582 u16 syst_coeffs[] = { 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
2583 0x0000, 0x0000, 0x0000, 0x0000, 0x0000};
2584
2585 u16 commands_fullcal[] = {
2586 0x8434, 0x8334, 0x8084, 0x8267, 0x8056, 0x8234
2587 };
2588
2589 u16 commands_recal[] = {
2590 0x8434, 0x8334, 0x8084, 0x8267, 0x8056, 0x8234
2591 };
2592
2593 u16 command_nums_fullcal[] = {
2594 0x7a97, 0x7a97, 0x7a97, 0x7a87, 0x7a87, 0x7b97
2595 };
2596
2597 u16 command_nums_recal[] = {
2598 0x7a97, 0x7a97, 0x7a97, 0x7a87, 0x7a87, 0x7b97
2599 };
2600 u16 *command_nums = command_nums_fullcal;
2601
2602 u16 *start_coeffs = NULL, *cal_cmds = NULL, cal_type, diq_start;
2603 u16 tx_pwr_ctrl_old, save_txpwrctrlrfctrl2;
2604 u16 save_sslpnCalibClkEnCtrl, save_sslpnRxFeClkEnCtrl;
2605 bool tx_gain_override_old;
2606 struct lcnphy_txgains old_gains;
2607 uint i, n_cal_cmds = 0, n_cal_start = 0;
2608 u16 *values_to_save;
2609 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
2610
2611 values_to_save = kmalloc(sizeof(u16) * 20, GFP_ATOMIC);
2612 if (NULL == values_to_save)
2613 return;
2614
2615 save_sslpnRxFeClkEnCtrl = read_phy_reg(pi, 0x6db);
2616 save_sslpnCalibClkEnCtrl = read_phy_reg(pi, 0x6da);
2617
2618 or_phy_reg(pi, 0x6da, 0x40);
2619 or_phy_reg(pi, 0x6db, 0x3);
2620
2621 switch (cal_mode) {
2622 case LCNPHY_CAL_FULL:
2623 start_coeffs = syst_coeffs;
2624 cal_cmds = commands_fullcal;
2625 n_cal_cmds = ARRAY_SIZE(commands_fullcal);
2626 break;
2627
2628 case LCNPHY_CAL_RECAL:
2629 start_coeffs = syst_coeffs;
2630 cal_cmds = commands_recal;
2631 n_cal_cmds = ARRAY_SIZE(commands_recal);
2632 command_nums = command_nums_recal;
2633 break;
2634
2635 default:
2636 break;
2637 }
2638
2639 wlc_lcnphy_common_write_table(pi, LCNPHY_TBL_ID_IQLOCAL,
2640 start_coeffs, 11, 16, 64);
2641
2642 write_phy_reg(pi, 0x6da, 0xffff);
2643 mod_phy_reg(pi, 0x503, (0x1 << 3), (1) << 3);
2644
2645 tx_pwr_ctrl_old = wlc_lcnphy_get_tx_pwr_ctrl(pi);
2646
2647 mod_phy_reg(pi, 0x4a4, (0x1 << 12), (1) << 12);
2648
2649 wlc_lcnphy_set_tx_pwr_ctrl(pi, LCNPHY_TX_PWR_CTRL_OFF);
2650
2651 save_txpwrctrlrfctrl2 = read_phy_reg(pi, 0x4db);
2652
2653 mod_phy_reg(pi, 0x4db, (0x3ff << 0), (0x2a6) << 0);
2654
2655 mod_phy_reg(pi, 0x4db, (0x7 << 12), (2) << 12);
2656
2657 wlc_lcnphy_tx_iqlo_loopback(pi, values_to_save);
2658
2659 tx_gain_override_old = wlc_lcnphy_tx_gain_override_enabled(pi);
2660 if (tx_gain_override_old)
2661 wlc_lcnphy_get_tx_gain(pi, &old_gains);
2662
2663 if (!target_gains) {
2664 if (!tx_gain_override_old)
2665 wlc_lcnphy_set_tx_pwr_by_index(pi,
2666 pi_lcn->lcnphy_tssi_idx);
2667 wlc_lcnphy_get_tx_gain(pi, &temp_gains);
2668 target_gains = &temp_gains;
2669 }
2670
2671 hash = (target_gains->gm_gain << 8) |
2672 (target_gains->pga_gain << 4) | (target_gains->pad_gain);
2673
2674 band_idx = (CHSPEC_IS5G(pi->radio_chanspec) ? 1 : 0);
2675
2676 cal_gains = *target_gains;
2677 memset(ncorr_override, 0, sizeof(ncorr_override));
2678 for (j = 0; j < iqcal_gainparams_numgains_lcnphy[band_idx]; j++) {
2679 if (hash == tbl_iqcal_gainparams_lcnphy[band_idx][j][0]) {
2680 cal_gains.gm_gain =
2681 tbl_iqcal_gainparams_lcnphy[band_idx][j][1];
2682 cal_gains.pga_gain =
2683 tbl_iqcal_gainparams_lcnphy[band_idx][j][2];
2684 cal_gains.pad_gain =
2685 tbl_iqcal_gainparams_lcnphy[band_idx][j][3];
2686 memcpy(ncorr_override,
2687 &tbl_iqcal_gainparams_lcnphy[band_idx][j][3],
2688 sizeof(ncorr_override));
2689 break;
2690 }
2691 }
2692
2693 wlc_lcnphy_set_tx_gain(pi, &cal_gains);
2694
2695 write_phy_reg(pi, 0x453, 0xaa9);
2696 write_phy_reg(pi, 0x93d, 0xc0);
2697
2698 wlc_lcnphy_common_write_table(pi, LCNPHY_TBL_ID_IQLOCAL,
2699 lcnphy_iqcal_loft_gainladder,
2700 ARRAY_SIZE(lcnphy_iqcal_loft_gainladder),
2701 16, 0);
2702
2703 wlc_lcnphy_common_write_table(pi, LCNPHY_TBL_ID_IQLOCAL,
2704 lcnphy_iqcal_ir_gainladder,
2705 ARRAY_SIZE(
2706 lcnphy_iqcal_ir_gainladder), 16,
2707 32);
2708
2709 if (pi->phy_tx_tone_freq) {
2710
2711 wlc_lcnphy_stop_tx_tone(pi);
2712 udelay(5);
2713 wlc_lcnphy_start_tx_tone(pi, 3750, 88, 1);
2714 } else {
2715 wlc_lcnphy_start_tx_tone(pi, 3750, 88, 1);
2716 }
2717
2718 write_phy_reg(pi, 0x6da, 0xffff);
2719
2720 for (i = n_cal_start; i < n_cal_cmds; i++) {
2721 u16 zero_diq = 0;
2722 u16 best_coeffs[11];
2723 u16 command_num;
2724
2725 cal_type = (cal_cmds[i] & 0x0f00) >> 8;
2726
2727 command_num = command_nums[i];
2728 if (ncorr_override[cal_type])
2729 command_num =
2730 ncorr_override[cal_type] << 8 | (command_num &
2731 0xff);
2732
2733 write_phy_reg(pi, 0x452, command_num);
2734
2735 if ((cal_type == 3) || (cal_type == 4)) {
2736 wlc_lcnphy_common_read_table(pi, LCNPHY_TBL_ID_IQLOCAL,
2737 &diq_start, 1, 16, 69);
2738
2739 wlc_lcnphy_common_write_table(pi, LCNPHY_TBL_ID_IQLOCAL,
2740 &zero_diq, 1, 16, 69);
2741 }
2742
2743 write_phy_reg(pi, 0x451, cal_cmds[i]);
2744
2745 if (!wlc_lcnphy_iqcal_wait(pi))
2746 goto cleanup;
2747
2748 wlc_lcnphy_common_read_table(pi, LCNPHY_TBL_ID_IQLOCAL,
2749 best_coeffs,
2750 ARRAY_SIZE(best_coeffs), 16, 96);
2751 wlc_lcnphy_common_write_table(pi, LCNPHY_TBL_ID_IQLOCAL,
2752 best_coeffs,
2753 ARRAY_SIZE(best_coeffs), 16, 64);
2754
2755 if ((cal_type == 3) || (cal_type == 4))
2756 wlc_lcnphy_common_write_table(pi, LCNPHY_TBL_ID_IQLOCAL,
2757 &diq_start, 1, 16, 69);
2758 wlc_lcnphy_common_read_table(pi, LCNPHY_TBL_ID_IQLOCAL,
2759 pi_lcn->lcnphy_cal_results.
2760 txiqlocal_bestcoeffs,
2761 ARRAY_SIZE(pi_lcn->
2762 lcnphy_cal_results.
2763 txiqlocal_bestcoeffs),
2764 16, 96);
2765 }
2766
2767 wlc_lcnphy_common_read_table(pi, LCNPHY_TBL_ID_IQLOCAL,
2768 pi_lcn->lcnphy_cal_results.
2769 txiqlocal_bestcoeffs,
2770 ARRAY_SIZE(pi_lcn->lcnphy_cal_results.
2771 txiqlocal_bestcoeffs), 16, 96);
2772 pi_lcn->lcnphy_cal_results.txiqlocal_bestcoeffs_valid = true;
2773
2774 wlc_lcnphy_common_write_table(pi, LCNPHY_TBL_ID_IQLOCAL,
2775 &pi_lcn->lcnphy_cal_results.
2776 txiqlocal_bestcoeffs[0], 4, 16, 80);
2777
2778 wlc_lcnphy_common_write_table(pi, LCNPHY_TBL_ID_IQLOCAL,
2779 &pi_lcn->lcnphy_cal_results.
2780 txiqlocal_bestcoeffs[5], 2, 16, 85);
2781
2782 cleanup:
2783 wlc_lcnphy_tx_iqlo_loopback_cleanup(pi, values_to_save);
2784 kfree(values_to_save);
2785
2786 if (!keep_tone)
2787 wlc_lcnphy_stop_tx_tone(pi);
2788
2789 write_phy_reg(pi, 0x4db, save_txpwrctrlrfctrl2);
2790
2791 write_phy_reg(pi, 0x453, 0);
2792
2793 if (tx_gain_override_old)
2794 wlc_lcnphy_set_tx_gain(pi, &old_gains);
2795 wlc_lcnphy_set_tx_pwr_ctrl(pi, tx_pwr_ctrl_old);
2796
2797 write_phy_reg(pi, 0x6da, save_sslpnCalibClkEnCtrl);
2798 write_phy_reg(pi, 0x6db, save_sslpnRxFeClkEnCtrl);
2799
2800 }
2801
2802 static void wlc_lcnphy_idle_tssi_est(struct brcms_phy_pub *ppi)
2803 {
2804 bool suspend, tx_gain_override_old;
2805 struct lcnphy_txgains old_gains;
2806 struct brcms_phy *pi = (struct brcms_phy *) ppi;
2807 u16 idleTssi, idleTssi0_2C, idleTssi0_OB, idleTssi0_regvalue_OB,
2808 idleTssi0_regvalue_2C;
2809 u16 SAVE_txpwrctrl = wlc_lcnphy_get_tx_pwr_ctrl(pi);
2810 u16 SAVE_lpfgain = read_radio_reg(pi, RADIO_2064_REG112);
2811 u16 SAVE_jtag_bb_afe_switch =
2812 read_radio_reg(pi, RADIO_2064_REG007) & 1;
2813 u16 SAVE_jtag_auxpga = read_radio_reg(pi, RADIO_2064_REG0FF) & 0x10;
2814 u16 SAVE_iqadc_aux_en = read_radio_reg(pi, RADIO_2064_REG11F) & 4;
2815 idleTssi = read_phy_reg(pi, 0x4ab);
2816 suspend = (0 == (bcma_read32(pi->d11core, D11REGOFFS(maccontrol)) &
2817 MCTL_EN_MAC));
2818 if (!suspend)
2819 wlapi_suspend_mac_and_wait(pi->sh->physhim);
2820 wlc_lcnphy_set_tx_pwr_ctrl(pi, LCNPHY_TX_PWR_CTRL_OFF);
2821
2822 tx_gain_override_old = wlc_lcnphy_tx_gain_override_enabled(pi);
2823 wlc_lcnphy_get_tx_gain(pi, &old_gains);
2824
2825 wlc_lcnphy_enable_tx_gain_override(pi);
2826 wlc_lcnphy_set_tx_pwr_by_index(pi, 127);
2827 write_radio_reg(pi, RADIO_2064_REG112, 0x6);
2828 mod_radio_reg(pi, RADIO_2064_REG007, 0x1, 1);
2829 mod_radio_reg(pi, RADIO_2064_REG0FF, 0x10, 1 << 4);
2830 mod_radio_reg(pi, RADIO_2064_REG11F, 0x4, 1 << 2);
2831 wlc_lcnphy_tssi_setup(pi);
2832 wlc_phy_do_dummy_tx(pi, true, OFF);
2833 idleTssi = ((read_phy_reg(pi, 0x4ab) & (0x1ff << 0))
2834 >> 0);
2835
2836 idleTssi0_2C = ((read_phy_reg(pi, 0x63e) & (0x1ff << 0))
2837 >> 0);
2838
2839 if (idleTssi0_2C >= 256)
2840 idleTssi0_OB = idleTssi0_2C - 256;
2841 else
2842 idleTssi0_OB = idleTssi0_2C + 256;
2843
2844 idleTssi0_regvalue_OB = idleTssi0_OB;
2845 if (idleTssi0_regvalue_OB >= 256)
2846 idleTssi0_regvalue_2C = idleTssi0_regvalue_OB - 256;
2847 else
2848 idleTssi0_regvalue_2C = idleTssi0_regvalue_OB + 256;
2849 mod_phy_reg(pi, 0x4a6, (0x1ff << 0), (idleTssi0_regvalue_2C) << 0);
2850
2851 mod_phy_reg(pi, 0x44c, (0x1 << 12), (0) << 12);
2852
2853 wlc_lcnphy_set_tx_gain_override(pi, tx_gain_override_old);
2854 wlc_lcnphy_set_tx_gain(pi, &old_gains);
2855 wlc_lcnphy_set_tx_pwr_ctrl(pi, SAVE_txpwrctrl);
2856
2857 write_radio_reg(pi, RADIO_2064_REG112, SAVE_lpfgain);
2858 mod_radio_reg(pi, RADIO_2064_REG007, 0x1, SAVE_jtag_bb_afe_switch);
2859 mod_radio_reg(pi, RADIO_2064_REG0FF, 0x10, SAVE_jtag_auxpga);
2860 mod_radio_reg(pi, RADIO_2064_REG11F, 0x4, SAVE_iqadc_aux_en);
2861 mod_radio_reg(pi, RADIO_2064_REG112, 0x80, 1 << 7);
2862 if (!suspend)
2863 wlapi_enable_mac(pi->sh->physhim);
2864 }
2865
2866 static void wlc_lcnphy_vbat_temp_sense_setup(struct brcms_phy *pi, u8 mode)
2867 {
2868 bool suspend;
2869 u16 save_txpwrCtrlEn;
2870 u8 auxpga_vmidcourse, auxpga_vmidfine, auxpga_gain;
2871 u16 auxpga_vmid;
2872 struct phytbl_info tab;
2873 u32 val;
2874 u8 save_reg007, save_reg0FF, save_reg11F, save_reg005, save_reg025,
2875 save_reg112;
2876 u16 values_to_save[14];
2877 s8 index;
2878 int i;
2879 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
2880 udelay(999);
2881
2882 save_reg007 = (u8) read_radio_reg(pi, RADIO_2064_REG007);
2883 save_reg0FF = (u8) read_radio_reg(pi, RADIO_2064_REG0FF);
2884 save_reg11F = (u8) read_radio_reg(pi, RADIO_2064_REG11F);
2885 save_reg005 = (u8) read_radio_reg(pi, RADIO_2064_REG005);
2886 save_reg025 = (u8) read_radio_reg(pi, RADIO_2064_REG025);
2887 save_reg112 = (u8) read_radio_reg(pi, RADIO_2064_REG112);
2888
2889 for (i = 0; i < 14; i++)
2890 values_to_save[i] = read_phy_reg(pi, tempsense_phy_regs[i]);
2891 suspend = (0 == (bcma_read32(pi->d11core, D11REGOFFS(maccontrol)) &
2892 MCTL_EN_MAC));
2893 if (!suspend)
2894 wlapi_suspend_mac_and_wait(pi->sh->physhim);
2895 save_txpwrCtrlEn = read_radio_reg(pi, 0x4a4);
2896
2897 wlc_lcnphy_set_tx_pwr_ctrl(pi, LCNPHY_TX_PWR_CTRL_OFF);
2898 index = pi_lcn->lcnphy_current_index;
2899 wlc_lcnphy_set_tx_pwr_by_index(pi, 127);
2900 mod_radio_reg(pi, RADIO_2064_REG007, 0x1, 0x1);
2901 mod_radio_reg(pi, RADIO_2064_REG0FF, 0x10, 0x1 << 4);
2902 mod_radio_reg(pi, RADIO_2064_REG11F, 0x4, 0x1 << 2);
2903 mod_phy_reg(pi, 0x503, (0x1 << 0), (0) << 0);
2904
2905 mod_phy_reg(pi, 0x503, (0x1 << 2), (0) << 2);
2906
2907 mod_phy_reg(pi, 0x4a4, (0x1 << 14), (0) << 14);
2908
2909 mod_phy_reg(pi, 0x4a4, (0x1 << 15), (0) << 15);
2910
2911 mod_phy_reg(pi, 0x4d0, (0x1 << 5), (0) << 5);
2912
2913 mod_phy_reg(pi, 0x4a5, (0xff << 0), (255) << 0);
2914
2915 mod_phy_reg(pi, 0x4a5, (0x7 << 12), (5) << 12);
2916
2917 mod_phy_reg(pi, 0x4a5, (0x7 << 8), (0) << 8);
2918
2919 mod_phy_reg(pi, 0x40d, (0xff << 0), (64) << 0);
2920
2921 mod_phy_reg(pi, 0x40d, (0x7 << 8), (6) << 8);
2922
2923 mod_phy_reg(pi, 0x4a2, (0xff << 0), (64) << 0);
2924
2925 mod_phy_reg(pi, 0x4a2, (0x7 << 8), (6) << 8);
2926
2927 mod_phy_reg(pi, 0x4d9, (0x7 << 4), (2) << 4);
2928
2929 mod_phy_reg(pi, 0x4d9, (0x7 << 8), (3) << 8);
2930
2931 mod_phy_reg(pi, 0x4d9, (0x7 << 12), (1) << 12);
2932
2933 mod_phy_reg(pi, 0x4da, (0x1 << 12), (0) << 12);
2934
2935 mod_phy_reg(pi, 0x4da, (0x1 << 13), (1) << 13);
2936
2937 mod_phy_reg(pi, 0x4a6, (0x1 << 15), (1) << 15);
2938
2939 write_radio_reg(pi, RADIO_2064_REG025, 0xC);
2940
2941 mod_radio_reg(pi, RADIO_2064_REG005, 0x8, 0x1 << 3);
2942
2943 mod_phy_reg(pi, 0x938, (0x1 << 2), (1) << 2);
2944
2945 mod_phy_reg(pi, 0x939, (0x1 << 2), (1) << 2);
2946
2947 mod_phy_reg(pi, 0x4a4, (0x1 << 12), (1) << 12);
2948
2949 val = wlc_lcnphy_rfseq_tbl_adc_pwrup(pi);
2950 tab.tbl_id = LCNPHY_TBL_ID_RFSEQ;
2951 tab.tbl_width = 16;
2952 tab.tbl_len = 1;
2953 tab.tbl_ptr = &val;
2954 tab.tbl_offset = 6;
2955 wlc_lcnphy_write_table(pi, &tab);
2956 if (mode == TEMPSENSE) {
2957 mod_phy_reg(pi, 0x4d7, (0x1 << 3), (1) << 3);
2958
2959 mod_phy_reg(pi, 0x4d7, (0x7 << 12), (1) << 12);
2960
2961 auxpga_vmidcourse = 8;
2962 auxpga_vmidfine = 0x4;
2963 auxpga_gain = 2;
2964 mod_radio_reg(pi, RADIO_2064_REG082, 0x20, 1 << 5);
2965 } else {
2966 mod_phy_reg(pi, 0x4d7, (0x1 << 3), (1) << 3);
2967
2968 mod_phy_reg(pi, 0x4d7, (0x7 << 12), (3) << 12);
2969
2970 auxpga_vmidcourse = 7;
2971 auxpga_vmidfine = 0xa;
2972 auxpga_gain = 2;
2973 }
2974 auxpga_vmid =
2975 (u16) ((2 << 8) | (auxpga_vmidcourse << 4) | auxpga_vmidfine);
2976 mod_phy_reg(pi, 0x4d8, (0x1 << 0), (1) << 0);
2977
2978 mod_phy_reg(pi, 0x4d8, (0x3ff << 2), (auxpga_vmid) << 2);
2979
2980 mod_phy_reg(pi, 0x4d8, (0x1 << 1), (1) << 1);
2981
2982 mod_phy_reg(pi, 0x4d8, (0x7 << 12), (auxpga_gain) << 12);
2983
2984 mod_phy_reg(pi, 0x4d0, (0x1 << 5), (1) << 5);
2985
2986 write_radio_reg(pi, RADIO_2064_REG112, 0x6);
2987
2988 wlc_phy_do_dummy_tx(pi, true, OFF);
2989 if (!tempsense_done(pi))
2990 udelay(10);
2991
2992 write_radio_reg(pi, RADIO_2064_REG007, (u16) save_reg007);
2993 write_radio_reg(pi, RADIO_2064_REG0FF, (u16) save_reg0FF);
2994 write_radio_reg(pi, RADIO_2064_REG11F, (u16) save_reg11F);
2995 write_radio_reg(pi, RADIO_2064_REG005, (u16) save_reg005);
2996 write_radio_reg(pi, RADIO_2064_REG025, (u16) save_reg025);
2997 write_radio_reg(pi, RADIO_2064_REG112, (u16) save_reg112);
2998 for (i = 0; i < 14; i++)
2999 write_phy_reg(pi, tempsense_phy_regs[i], values_to_save[i]);
3000 wlc_lcnphy_set_tx_pwr_by_index(pi, (int)index);
3001
3002 write_radio_reg(pi, 0x4a4, save_txpwrCtrlEn);
3003 if (!suspend)
3004 wlapi_enable_mac(pi->sh->physhim);
3005 udelay(999);
3006 }
3007
3008 static void wlc_lcnphy_tx_pwr_ctrl_init(struct brcms_phy_pub *ppi)
3009 {
3010 struct lcnphy_txgains tx_gains;
3011 u8 bbmult;
3012 struct phytbl_info tab;
3013 s32 a1, b0, b1;
3014 s32 tssi, pwr, maxtargetpwr, mintargetpwr;
3015 bool suspend;
3016 struct brcms_phy *pi = (struct brcms_phy *) ppi;
3017
3018 suspend = (0 == (bcma_read32(pi->d11core, D11REGOFFS(maccontrol)) &
3019 MCTL_EN_MAC));
3020 if (!suspend)
3021 wlapi_suspend_mac_and_wait(pi->sh->physhim);
3022
3023 if (!pi->hwpwrctrl_capable) {
3024 if (CHSPEC_IS2G(pi->radio_chanspec)) {
3025 tx_gains.gm_gain = 4;
3026 tx_gains.pga_gain = 12;
3027 tx_gains.pad_gain = 12;
3028 tx_gains.dac_gain = 0;
3029
3030 bbmult = 150;
3031 } else {
3032 tx_gains.gm_gain = 7;
3033 tx_gains.pga_gain = 15;
3034 tx_gains.pad_gain = 14;
3035 tx_gains.dac_gain = 0;
3036
3037 bbmult = 150;
3038 }
3039 wlc_lcnphy_set_tx_gain(pi, &tx_gains);
3040 wlc_lcnphy_set_bbmult(pi, bbmult);
3041 wlc_lcnphy_vbat_temp_sense_setup(pi, TEMPSENSE);
3042 } else {
3043
3044 wlc_lcnphy_idle_tssi_est(ppi);
3045
3046 wlc_lcnphy_clear_tx_power_offsets(pi);
3047
3048 b0 = pi->txpa_2g[0];
3049 b1 = pi->txpa_2g[1];
3050 a1 = pi->txpa_2g[2];
3051 maxtargetpwr = wlc_lcnphy_tssi2dbm(10, a1, b0, b1);
3052 mintargetpwr = wlc_lcnphy_tssi2dbm(125, a1, b0, b1);
3053
3054 tab.tbl_id = LCNPHY_TBL_ID_TXPWRCTL;
3055 tab.tbl_width = 32;
3056 tab.tbl_ptr = &pwr;
3057 tab.tbl_len = 1;
3058 tab.tbl_offset = 0;
3059 for (tssi = 0; tssi < 128; tssi++) {
3060 pwr = wlc_lcnphy_tssi2dbm(tssi, a1, b0, b1);
3061
3062 pwr = (pwr < mintargetpwr) ? mintargetpwr : pwr;
3063 wlc_lcnphy_write_table(pi, &tab);
3064 tab.tbl_offset++;
3065 }
3066
3067 mod_phy_reg(pi, 0x410, (0x1 << 7), (0) << 7);
3068
3069 write_phy_reg(pi, 0x4a8, 10);
3070
3071 wlc_lcnphy_set_target_tx_pwr(pi, LCN_TARGET_PWR);
3072
3073 wlc_lcnphy_set_tx_pwr_ctrl(pi, LCNPHY_TX_PWR_CTRL_HW);
3074 }
3075 if (!suspend)
3076 wlapi_enable_mac(pi->sh->physhim);
3077 }
3078
3079 static u8 wlc_lcnphy_get_bbmult(struct brcms_phy *pi)
3080 {
3081 u16 m0m1;
3082 struct phytbl_info tab;
3083
3084 tab.tbl_ptr = &m0m1;
3085 tab.tbl_len = 1;
3086 tab.tbl_id = LCNPHY_TBL_ID_IQLOCAL;
3087 tab.tbl_offset = 87;
3088 tab.tbl_width = 16;
3089 wlc_lcnphy_read_table(pi, &tab);
3090
3091 return (u8) ((m0m1 & 0xff00) >> 8);
3092 }
3093
3094 static void wlc_lcnphy_set_pa_gain(struct brcms_phy *pi, u16 gain)
3095 {
3096 mod_phy_reg(pi, 0x4fb,
3097 LCNPHY_txgainctrlovrval1_pagain_ovr_val1_MASK,
3098 gain << LCNPHY_txgainctrlovrval1_pagain_ovr_val1_SHIFT);
3099 mod_phy_reg(pi, 0x4fd,
3100 LCNPHY_stxtxgainctrlovrval1_pagain_ovr_val1_MASK,
3101 gain << LCNPHY_stxtxgainctrlovrval1_pagain_ovr_val1_SHIFT);
3102 }
3103
3104 void
3105 wlc_lcnphy_get_radio_loft(struct brcms_phy *pi,
3106 u8 *ei0, u8 *eq0, u8 *fi0, u8 *fq0)
3107 {
3108 *ei0 = LCNPHY_IQLOCC_READ(read_radio_reg(pi, RADIO_2064_REG089));
3109 *eq0 = LCNPHY_IQLOCC_READ(read_radio_reg(pi, RADIO_2064_REG08A));
3110 *fi0 = LCNPHY_IQLOCC_READ(read_radio_reg(pi, RADIO_2064_REG08B));
3111 *fq0 = LCNPHY_IQLOCC_READ(read_radio_reg(pi, RADIO_2064_REG08C));
3112 }
3113
3114 void wlc_lcnphy_set_tx_iqcc(struct brcms_phy *pi, u16 a, u16 b)
3115 {
3116 struct phytbl_info tab;
3117 u16 iqcc[2];
3118
3119 iqcc[0] = a;
3120 iqcc[1] = b;
3121
3122 tab.tbl_id = LCNPHY_TBL_ID_IQLOCAL;
3123 tab.tbl_width = 16;
3124 tab.tbl_ptr = iqcc;
3125 tab.tbl_len = 2;
3126 tab.tbl_offset = 80;
3127 wlc_lcnphy_write_table(pi, &tab);
3128 }
3129
3130 void wlc_lcnphy_set_tx_locc(struct brcms_phy *pi, u16 didq)
3131 {
3132 struct phytbl_info tab;
3133
3134 tab.tbl_id = LCNPHY_TBL_ID_IQLOCAL;
3135 tab.tbl_width = 16;
3136 tab.tbl_ptr = &didq;
3137 tab.tbl_len = 1;
3138 tab.tbl_offset = 85;
3139 wlc_lcnphy_write_table(pi, &tab);
3140 }
3141
3142 void wlc_lcnphy_set_tx_pwr_by_index(struct brcms_phy *pi, int index)
3143 {
3144 struct phytbl_info tab;
3145 u16 a, b;
3146 u8 bb_mult;
3147 u32 bbmultiqcomp, txgain, locoeffs, rfpower;
3148 struct lcnphy_txgains gains;
3149 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
3150
3151 pi_lcn->lcnphy_tx_power_idx_override = (s8) index;
3152 pi_lcn->lcnphy_current_index = (u8) index;
3153
3154 tab.tbl_id = LCNPHY_TBL_ID_TXPWRCTL;
3155 tab.tbl_width = 32;
3156 tab.tbl_len = 1;
3157
3158 wlc_lcnphy_set_tx_pwr_ctrl(pi, LCNPHY_TX_PWR_CTRL_OFF);
3159
3160 tab.tbl_offset = LCNPHY_TX_PWR_CTRL_IQ_OFFSET + index;
3161 tab.tbl_ptr = &bbmultiqcomp;
3162 wlc_lcnphy_read_table(pi, &tab);
3163
3164 tab.tbl_offset = LCNPHY_TX_PWR_CTRL_GAIN_OFFSET + index;
3165 tab.tbl_width = 32;
3166 tab.tbl_ptr = &txgain;
3167 wlc_lcnphy_read_table(pi, &tab);
3168
3169 gains.gm_gain = (u16) (txgain & 0xff);
3170 gains.pga_gain = (u16) (txgain >> 8) & 0xff;
3171 gains.pad_gain = (u16) (txgain >> 16) & 0xff;
3172 gains.dac_gain = (u16) (bbmultiqcomp >> 28) & 0x07;
3173 wlc_lcnphy_set_tx_gain(pi, &gains);
3174 wlc_lcnphy_set_pa_gain(pi, (u16) (txgain >> 24) & 0x7f);
3175
3176 bb_mult = (u8) ((bbmultiqcomp >> 20) & 0xff);
3177 wlc_lcnphy_set_bbmult(pi, bb_mult);
3178
3179 wlc_lcnphy_enable_tx_gain_override(pi);
3180
3181 if (!wlc_lcnphy_tempsense_based_pwr_ctrl_enabled(pi)) {
3182
3183 a = (u16) ((bbmultiqcomp >> 10) & 0x3ff);
3184 b = (u16) (bbmultiqcomp & 0x3ff);
3185 wlc_lcnphy_set_tx_iqcc(pi, a, b);
3186
3187 tab.tbl_offset = LCNPHY_TX_PWR_CTRL_LO_OFFSET + index;
3188 tab.tbl_ptr = &locoeffs;
3189 wlc_lcnphy_read_table(pi, &tab);
3190
3191 wlc_lcnphy_set_tx_locc(pi, (u16) locoeffs);
3192
3193 tab.tbl_offset = LCNPHY_TX_PWR_CTRL_PWR_OFFSET + index;
3194 tab.tbl_ptr = &rfpower;
3195 wlc_lcnphy_read_table(pi, &tab);
3196 mod_phy_reg(pi, 0x6a6, (0x1fff << 0), (rfpower * 8) << 0);
3197
3198 }
3199 }
3200
3201 static void wlc_lcnphy_clear_papd_comptable(struct brcms_phy *pi)
3202 {
3203 u32 j;
3204 struct phytbl_info tab;
3205 u32 temp_offset[128];
3206 tab.tbl_ptr = temp_offset;
3207 tab.tbl_len = 128;
3208 tab.tbl_id = LCNPHY_TBL_ID_PAPDCOMPDELTATBL;
3209 tab.tbl_width = 32;
3210 tab.tbl_offset = 0;
3211
3212 memset(temp_offset, 0, sizeof(temp_offset));
3213 for (j = 1; j < 128; j += 2)
3214 temp_offset[j] = 0x80000;
3215
3216 wlc_lcnphy_write_table(pi, &tab);
3217 return;
3218 }
3219
3220 void wlc_lcnphy_tx_pu(struct brcms_phy *pi, bool bEnable)
3221 {
3222 if (!bEnable) {
3223
3224 and_phy_reg(pi, 0x43b, ~(u16) ((0x1 << 1) | (0x1 << 4)));
3225
3226 mod_phy_reg(pi, 0x43c, (0x1 << 1), 1 << 1);
3227
3228 and_phy_reg(pi, 0x44c,
3229 ~(u16) ((0x1 << 3) |
3230 (0x1 << 5) |
3231 (0x1 << 12) |
3232 (0x1 << 0) | (0x1 << 1) | (0x1 << 2)));
3233
3234 and_phy_reg(pi, 0x44d,
3235 ~(u16) ((0x1 << 3) | (0x1 << 5) | (0x1 << 14)));
3236 mod_phy_reg(pi, 0x44d, (0x1 << 2), 1 << 2);
3237
3238 mod_phy_reg(pi, 0x44d, (0x1 << 1) | (0x1 << 0), (0x1 << 0));
3239
3240 and_phy_reg(pi, 0x4f9,
3241 ~(u16) ((0x1 << 0) | (0x1 << 1) | (0x1 << 2)));
3242
3243 and_phy_reg(pi, 0x4fa,
3244 ~(u16) ((0x1 << 0) | (0x1 << 1) | (0x1 << 2)));
3245 } else {
3246
3247 mod_phy_reg(pi, 0x43b, (0x1 << 1), 1 << 1);
3248 mod_phy_reg(pi, 0x43c, (0x1 << 1), 0 << 1);
3249
3250 mod_phy_reg(pi, 0x43b, (0x1 << 4), 1 << 4);
3251 mod_phy_reg(pi, 0x43c, (0x1 << 6), 0 << 6);
3252
3253 mod_phy_reg(pi, 0x44c, (0x1 << 12), 1 << 12);
3254 mod_phy_reg(pi, 0x44d, (0x1 << 14), 1 << 14);
3255
3256 wlc_lcnphy_set_trsw_override(pi, true, false);
3257
3258 mod_phy_reg(pi, 0x44d, (0x1 << 2), 0 << 2);
3259 mod_phy_reg(pi, 0x44c, (0x1 << 2), 1 << 2);
3260
3261 if (CHSPEC_IS2G(pi->radio_chanspec)) {
3262
3263 mod_phy_reg(pi, 0x44c, (0x1 << 3), 1 << 3);
3264 mod_phy_reg(pi, 0x44d, (0x1 << 3), 1 << 3);
3265
3266 mod_phy_reg(pi, 0x44c, (0x1 << 5), 1 << 5);
3267 mod_phy_reg(pi, 0x44d, (0x1 << 5), 0 << 5);
3268
3269 mod_phy_reg(pi, 0x4f9, (0x1 << 1), 1 << 1);
3270 mod_phy_reg(pi, 0x4fa, (0x1 << 1), 1 << 1);
3271
3272 mod_phy_reg(pi, 0x4f9, (0x1 << 2), 1 << 2);
3273 mod_phy_reg(pi, 0x4fa, (0x1 << 2), 1 << 2);
3274
3275 mod_phy_reg(pi, 0x4f9, (0x1 << 0), 1 << 0);
3276 mod_phy_reg(pi, 0x4fa, (0x1 << 0), 1 << 0);
3277 } else {
3278
3279 mod_phy_reg(pi, 0x44c, (0x1 << 3), 1 << 3);
3280 mod_phy_reg(pi, 0x44d, (0x1 << 3), 0 << 3);
3281
3282 mod_phy_reg(pi, 0x44c, (0x1 << 5), 1 << 5);
3283 mod_phy_reg(pi, 0x44d, (0x1 << 5), 1 << 5);
3284
3285 mod_phy_reg(pi, 0x4f9, (0x1 << 1), 1 << 1);
3286 mod_phy_reg(pi, 0x4fa, (0x1 << 1), 0 << 1);
3287
3288 mod_phy_reg(pi, 0x4f9, (0x1 << 2), 1 << 2);
3289 mod_phy_reg(pi, 0x4fa, (0x1 << 2), 0 << 2);
3290
3291 mod_phy_reg(pi, 0x4f9, (0x1 << 0), 1 << 0);
3292 mod_phy_reg(pi, 0x4fa, (0x1 << 0), 0 << 0);
3293 }
3294 }
3295 }
3296
3297 static void
3298 wlc_lcnphy_run_samples(struct brcms_phy *pi,
3299 u16 num_samps,
3300 u16 num_loops, u16 wait, bool iqcalmode)
3301 {
3302
3303 or_phy_reg(pi, 0x6da, 0x8080);
3304
3305 mod_phy_reg(pi, 0x642, (0x7f << 0), (num_samps - 1) << 0);
3306 if (num_loops != 0xffff)
3307 num_loops--;
3308 mod_phy_reg(pi, 0x640, (0xffff << 0), num_loops << 0);
3309
3310 mod_phy_reg(pi, 0x641, (0xffff << 0), wait << 0);
3311
3312 if (iqcalmode) {
3313
3314 and_phy_reg(pi, 0x453, (u16) ~(0x1 << 15));
3315 or_phy_reg(pi, 0x453, (0x1 << 15));
3316 } else {
3317 write_phy_reg(pi, 0x63f, 1);
3318 wlc_lcnphy_tx_pu(pi, 1);
3319 }
3320
3321 or_radio_reg(pi, RADIO_2064_REG112, 0x6);
3322 }
3323
3324 void wlc_lcnphy_deaf_mode(struct brcms_phy *pi, bool mode)
3325 {
3326
3327 u8 phybw40;
3328 phybw40 = CHSPEC_IS40(pi->radio_chanspec);
3329
3330 if (LCNREV_LT(pi->pubpi.phy_rev, 2)) {
3331 mod_phy_reg(pi, 0x4b0, (0x1 << 5), (mode) << 5);
3332 mod_phy_reg(pi, 0x4b1, (0x1 << 9), 0 << 9);
3333 } else {
3334 mod_phy_reg(pi, 0x4b0, (0x1 << 5), (mode) << 5);
3335 mod_phy_reg(pi, 0x4b1, (0x1 << 9), 0 << 9);
3336 }
3337
3338 if (phybw40 == 0) {
3339 mod_phy_reg((pi), 0x410,
3340 (0x1 << 6) |
3341 (0x1 << 5),
3342 ((CHSPEC_IS2G(
3343 pi->radio_chanspec)) ? (!mode) : 0) <<
3344 6 | (!mode) << 5);
3345 mod_phy_reg(pi, 0x410, (0x1 << 7), (mode) << 7);
3346 }
3347 }
3348
3349 void
3350 wlc_lcnphy_start_tx_tone(struct brcms_phy *pi, s32 f_kHz, u16 max_val,
3351 bool iqcalmode)
3352 {
3353 u8 phy_bw;
3354 u16 num_samps, t, k;
3355 u32 bw;
3356 s32 theta = 0, rot = 0;
3357 struct cordic_iq tone_samp;
3358 u32 data_buf[64];
3359 u16 i_samp, q_samp;
3360 struct phytbl_info tab;
3361 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
3362
3363 pi->phy_tx_tone_freq = f_kHz;
3364
3365 wlc_lcnphy_deaf_mode(pi, true);
3366
3367 phy_bw = 40;
3368 if (pi_lcn->lcnphy_spurmod) {
3369 write_phy_reg(pi, 0x942, 0x2);
3370 write_phy_reg(pi, 0x93b, 0x0);
3371 write_phy_reg(pi, 0x93c, 0x0);
3372 wlc_lcnphy_txrx_spur_avoidance_mode(pi, false);
3373 }
3374
3375 if (f_kHz) {
3376 k = 1;
3377 do {
3378 bw = phy_bw * 1000 * k;
3379 num_samps = bw / abs(f_kHz);
3380 k++;
3381 } while ((num_samps * (u32) (abs(f_kHz))) != bw);
3382 } else
3383 num_samps = 2;
3384
3385 rot = ((f_kHz * 36) / phy_bw) / 100;
3386 theta = 0;
3387
3388 for (t = 0; t < num_samps; t++) {
3389
3390 tone_samp = cordic_calc_iq(theta);
3391
3392 theta += rot;
3393
3394 i_samp = (u16) (FLOAT(tone_samp.i * max_val) & 0x3ff);
3395 q_samp = (u16) (FLOAT(tone_samp.q * max_val) & 0x3ff);
3396 data_buf[t] = (i_samp << 10) | q_samp;
3397 }
3398
3399 mod_phy_reg(pi, 0x6d6, (0x3 << 0), 0 << 0);
3400
3401 mod_phy_reg(pi, 0x6da, (0x1 << 3), 1 << 3);
3402
3403 tab.tbl_ptr = data_buf;
3404 tab.tbl_len = num_samps;
3405 tab.tbl_id = LCNPHY_TBL_ID_SAMPLEPLAY;
3406 tab.tbl_offset = 0;
3407 tab.tbl_width = 32;
3408 wlc_lcnphy_write_table(pi, &tab);
3409
3410 wlc_lcnphy_run_samples(pi, num_samps, 0xffff, 0, iqcalmode);
3411 }
3412
3413 void wlc_lcnphy_stop_tx_tone(struct brcms_phy *pi)
3414 {
3415 s16 playback_status;
3416 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
3417
3418 pi->phy_tx_tone_freq = 0;
3419 if (pi_lcn->lcnphy_spurmod) {
3420 write_phy_reg(pi, 0x942, 0x7);
3421 write_phy_reg(pi, 0x93b, 0x2017);
3422 write_phy_reg(pi, 0x93c, 0x27c5);
3423 wlc_lcnphy_txrx_spur_avoidance_mode(pi, true);
3424 }
3425
3426 playback_status = read_phy_reg(pi, 0x644);
3427 if (playback_status & (0x1 << 0)) {
3428 wlc_lcnphy_tx_pu(pi, 0);
3429 mod_phy_reg(pi, 0x63f, (0x1 << 1), 1 << 1);
3430 } else if (playback_status & (0x1 << 1))
3431 mod_phy_reg(pi, 0x453, (0x1 << 15), 0 << 15);
3432
3433 mod_phy_reg(pi, 0x6d6, (0x3 << 0), 1 << 0);
3434
3435 mod_phy_reg(pi, 0x6da, (0x1 << 3), 0 << 3);
3436
3437 mod_phy_reg(pi, 0x6da, (0x1 << 7), 0 << 7);
3438
3439 and_radio_reg(pi, RADIO_2064_REG112, 0xFFF9);
3440
3441 wlc_lcnphy_deaf_mode(pi, false);
3442 }
3443
3444 static void
3445 wlc_lcnphy_set_cc(struct brcms_phy *pi, int cal_type, s16 coeff_x, s16 coeff_y)
3446 {
3447 u16 di0dq0;
3448 u16 x, y, data_rf;
3449 int k;
3450 switch (cal_type) {
3451 case 0:
3452 wlc_lcnphy_set_tx_iqcc(pi, coeff_x, coeff_y);
3453 break;
3454 case 2:
3455 di0dq0 = (coeff_x & 0xff) << 8 | (coeff_y & 0xff);
3456 wlc_lcnphy_set_tx_locc(pi, di0dq0);
3457 break;
3458 case 3:
3459 k = wlc_lcnphy_calc_floor(coeff_x, 0);
3460 y = 8 + k;
3461 k = wlc_lcnphy_calc_floor(coeff_x, 1);
3462 x = 8 - k;
3463 data_rf = (x * 16 + y);
3464 write_radio_reg(pi, RADIO_2064_REG089, data_rf);
3465 k = wlc_lcnphy_calc_floor(coeff_y, 0);
3466 y = 8 + k;
3467 k = wlc_lcnphy_calc_floor(coeff_y, 1);
3468 x = 8 - k;
3469 data_rf = (x * 16 + y);
3470 write_radio_reg(pi, RADIO_2064_REG08A, data_rf);
3471 break;
3472 case 4:
3473 k = wlc_lcnphy_calc_floor(coeff_x, 0);
3474 y = 8 + k;
3475 k = wlc_lcnphy_calc_floor(coeff_x, 1);
3476 x = 8 - k;
3477 data_rf = (x * 16 + y);
3478 write_radio_reg(pi, RADIO_2064_REG08B, data_rf);
3479 k = wlc_lcnphy_calc_floor(coeff_y, 0);
3480 y = 8 + k;
3481 k = wlc_lcnphy_calc_floor(coeff_y, 1);
3482 x = 8 - k;
3483 data_rf = (x * 16 + y);
3484 write_radio_reg(pi, RADIO_2064_REG08C, data_rf);
3485 break;
3486 }
3487 }
3488
3489 static struct lcnphy_unsign16_struct
3490 wlc_lcnphy_get_cc(struct brcms_phy *pi, int cal_type)
3491 {
3492 u16 a, b, didq;
3493 u8 di0, dq0, ei, eq, fi, fq;
3494 struct lcnphy_unsign16_struct cc;
3495 cc.re = 0;
3496 cc.im = 0;
3497 switch (cal_type) {
3498 case 0:
3499 wlc_lcnphy_get_tx_iqcc(pi, &a, &b);
3500 cc.re = a;
3501 cc.im = b;
3502 break;
3503 case 2:
3504 didq = wlc_lcnphy_get_tx_locc(pi);
3505 di0 = (((didq & 0xff00) << 16) >> 24);
3506 dq0 = (((didq & 0x00ff) << 24) >> 24);
3507 cc.re = (u16) di0;
3508 cc.im = (u16) dq0;
3509 break;
3510 case 3:
3511 wlc_lcnphy_get_radio_loft(pi, &ei, &eq, &fi, &fq);
3512 cc.re = (u16) ei;
3513 cc.im = (u16) eq;
3514 break;
3515 case 4:
3516 wlc_lcnphy_get_radio_loft(pi, &ei, &eq, &fi, &fq);
3517 cc.re = (u16) fi;
3518 cc.im = (u16) fq;
3519 break;
3520 }
3521 return cc;
3522 }
3523
3524 static void
3525 wlc_lcnphy_samp_cap(struct brcms_phy *pi, int clip_detect_algo, u16 thresh,
3526 s16 *ptr, int mode)
3527 {
3528 u32 curval1, curval2, stpptr, curptr, strptr, val;
3529 u16 sslpnCalibClkEnCtrl, timer;
3530 u16 old_sslpnCalibClkEnCtrl;
3531 s16 imag, real;
3532 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
3533
3534 timer = 0;
3535 old_sslpnCalibClkEnCtrl = read_phy_reg(pi, 0x6da);
3536
3537 curval1 = bcma_read16(pi->d11core, D11REGOFFS(psm_corectlsts));
3538 ptr[130] = 0;
3539 bcma_write16(pi->d11core, D11REGOFFS(psm_corectlsts),
3540 ((1 << 6) | curval1));
3541
3542 bcma_write16(pi->d11core, D11REGOFFS(smpl_clct_strptr), 0x7E00);
3543 bcma_write16(pi->d11core, D11REGOFFS(smpl_clct_stpptr), 0x8000);
3544 udelay(20);
3545 curval2 = bcma_read16(pi->d11core, D11REGOFFS(psm_phy_hdr_param));
3546 bcma_write16(pi->d11core, D11REGOFFS(psm_phy_hdr_param),
3547 curval2 | 0x30);
3548
3549 write_phy_reg(pi, 0x555, 0x0);
3550 write_phy_reg(pi, 0x5a6, 0x5);
3551
3552 write_phy_reg(pi, 0x5a2, (u16) (mode | mode << 6));
3553 write_phy_reg(pi, 0x5cf, 3);
3554 write_phy_reg(pi, 0x5a5, 0x3);
3555 write_phy_reg(pi, 0x583, 0x0);
3556 write_phy_reg(pi, 0x584, 0x0);
3557 write_phy_reg(pi, 0x585, 0x0fff);
3558 write_phy_reg(pi, 0x586, 0x0000);
3559
3560 write_phy_reg(pi, 0x580, 0x4501);
3561
3562 sslpnCalibClkEnCtrl = read_phy_reg(pi, 0x6da);
3563 write_phy_reg(pi, 0x6da, (u32) (sslpnCalibClkEnCtrl | 0x2008));
3564 stpptr = bcma_read16(pi->d11core, D11REGOFFS(smpl_clct_stpptr));
3565 curptr = bcma_read16(pi->d11core, D11REGOFFS(smpl_clct_curptr));
3566 do {
3567 udelay(10);
3568 curptr = bcma_read16(pi->d11core, D11REGOFFS(smpl_clct_curptr));
3569 timer++;
3570 } while ((curptr != stpptr) && (timer < 500));
3571
3572 bcma_write16(pi->d11core, D11REGOFFS(psm_phy_hdr_param), 0x2);
3573 strptr = 0x7E00;
3574 bcma_write32(pi->d11core, D11REGOFFS(tplatewrptr), strptr);
3575 while (strptr < 0x8000) {
3576 val = bcma_read32(pi->d11core, D11REGOFFS(tplatewrdata));
3577 imag = ((val >> 16) & 0x3ff);
3578 real = ((val) & 0x3ff);
3579 if (imag > 511)
3580 imag -= 1024;
3581
3582 if (real > 511)
3583 real -= 1024;
3584
3585 if (pi_lcn->lcnphy_iqcal_swp_dis)
3586 ptr[(strptr - 0x7E00) / 4] = real;
3587 else
3588 ptr[(strptr - 0x7E00) / 4] = imag;
3589
3590 if (clip_detect_algo) {
3591 if (imag > thresh || imag < -thresh) {
3592 strptr = 0x8000;
3593 ptr[130] = 1;
3594 }
3595 }
3596
3597 strptr += 4;
3598 }
3599
3600 write_phy_reg(pi, 0x6da, old_sslpnCalibClkEnCtrl);
3601 bcma_write16(pi->d11core, D11REGOFFS(psm_phy_hdr_param), curval2);
3602 bcma_write16(pi->d11core, D11REGOFFS(psm_corectlsts), curval1);
3603 }
3604
3605 static void
3606 wlc_lcnphy_a1(struct brcms_phy *pi, int cal_type, int num_levels,
3607 int step_size_lg2)
3608 {
3609 const struct lcnphy_spb_tone *phy_c1;
3610 struct lcnphy_spb_tone phy_c2;
3611 struct lcnphy_unsign16_struct phy_c3;
3612 int phy_c4, phy_c5, k, l, j, phy_c6;
3613 u16 phy_c7, phy_c8, phy_c9;
3614 s16 phy_c10, phy_c11, phy_c12, phy_c13, phy_c14, phy_c15, phy_c16;
3615 s16 *ptr, phy_c17;
3616 s32 phy_c18, phy_c19;
3617 u32 phy_c20, phy_c21;
3618 bool phy_c22, phy_c23, phy_c24, phy_c25;
3619 u16 phy_c26, phy_c27;
3620 u16 phy_c28, phy_c29, phy_c30;
3621 u16 phy_c31;
3622 u16 *phy_c32;
3623 phy_c21 = 0;
3624 phy_c10 = phy_c13 = phy_c14 = phy_c8 = 0;
3625 ptr = kmalloc(sizeof(s16) * 131, GFP_ATOMIC);
3626 if (NULL == ptr)
3627 return;
3628
3629 phy_c32 = kmalloc(sizeof(u16) * 20, GFP_ATOMIC);
3630 if (NULL == phy_c32) {
3631 kfree(ptr);
3632 return;
3633 }
3634 phy_c26 = read_phy_reg(pi, 0x6da);
3635 phy_c27 = read_phy_reg(pi, 0x6db);
3636 phy_c31 = read_radio_reg(pi, RADIO_2064_REG026);
3637 write_phy_reg(pi, 0x93d, 0xC0);
3638
3639 wlc_lcnphy_start_tx_tone(pi, 3750, 88, 0);
3640 write_phy_reg(pi, 0x6da, 0xffff);
3641 or_phy_reg(pi, 0x6db, 0x3);
3642
3643 wlc_lcnphy_tx_iqlo_loopback(pi, phy_c32);
3644 udelay(500);
3645 phy_c28 = read_phy_reg(pi, 0x938);
3646 phy_c29 = read_phy_reg(pi, 0x4d7);
3647 phy_c30 = read_phy_reg(pi, 0x4d8);
3648 or_phy_reg(pi, 0x938, 0x1 << 2);
3649 or_phy_reg(pi, 0x4d7, 0x1 << 2);
3650 or_phy_reg(pi, 0x4d7, 0x1 << 3);
3651 mod_phy_reg(pi, 0x4d7, (0x7 << 12), 0x2 << 12);
3652 or_phy_reg(pi, 0x4d8, 1 << 0);
3653 or_phy_reg(pi, 0x4d8, 1 << 1);
3654 mod_phy_reg(pi, 0x4d8, (0x3ff << 2), 0x23A << 2);
3655 mod_phy_reg(pi, 0x4d8, (0x7 << 12), 0x7 << 12);
3656 phy_c1 = &lcnphy_spb_tone_3750[0];
3657 phy_c4 = 32;
3658
3659 if (num_levels == 0) {
3660 if (cal_type != 0)
3661 num_levels = 4;
3662 else
3663 num_levels = 9;
3664 }
3665 if (step_size_lg2 == 0) {
3666 if (cal_type != 0)
3667 step_size_lg2 = 3;
3668 else
3669 step_size_lg2 = 8;
3670 }
3671
3672 phy_c7 = (1 << step_size_lg2);
3673 phy_c3 = wlc_lcnphy_get_cc(pi, cal_type);
3674 phy_c15 = (s16) phy_c3.re;
3675 phy_c16 = (s16) phy_c3.im;
3676 if (cal_type == 2) {
3677 if (phy_c3.re > 127)
3678 phy_c15 = phy_c3.re - 256;
3679 if (phy_c3.im > 127)
3680 phy_c16 = phy_c3.im - 256;
3681 }
3682 wlc_lcnphy_set_cc(pi, cal_type, phy_c15, phy_c16);
3683 udelay(20);
3684 for (phy_c8 = 0; phy_c7 != 0 && phy_c8 < num_levels; phy_c8++) {
3685 phy_c23 = true;
3686 phy_c22 = false;
3687 switch (cal_type) {
3688 case 0:
3689 phy_c10 = 511;
3690 break;
3691 case 2:
3692 phy_c10 = 127;
3693 break;
3694 case 3:
3695 phy_c10 = 15;
3696 break;
3697 case 4:
3698 phy_c10 = 15;
3699 break;
3700 }
3701
3702 phy_c9 = read_phy_reg(pi, 0x93d);
3703 phy_c9 = 2 * phy_c9;
3704 phy_c24 = false;
3705 phy_c5 = 7;
3706 phy_c25 = true;
3707 while (1) {
3708 write_radio_reg(pi, RADIO_2064_REG026,
3709 (phy_c5 & 0x7) | ((phy_c5 & 0x7) << 4));
3710 udelay(50);
3711 phy_c22 = false;
3712 ptr[130] = 0;
3713 wlc_lcnphy_samp_cap(pi, 1, phy_c9, &ptr[0], 2);
3714 if (ptr[130] == 1)
3715 phy_c22 = true;
3716 if (phy_c22)
3717 phy_c5 -= 1;
3718 if ((phy_c22 != phy_c24) && (!phy_c25))
3719 break;
3720 if (!phy_c22)
3721 phy_c5 += 1;
3722 if (phy_c5 <= 0 || phy_c5 >= 7)
3723 break;
3724 phy_c24 = phy_c22;
3725 phy_c25 = false;
3726 }
3727
3728 if (phy_c5 < 0)
3729 phy_c5 = 0;
3730 else if (phy_c5 > 7)
3731 phy_c5 = 7;
3732
3733 for (k = -phy_c7; k <= phy_c7; k += phy_c7) {
3734 for (l = -phy_c7; l <= phy_c7; l += phy_c7) {
3735 phy_c11 = phy_c15 + k;
3736 phy_c12 = phy_c16 + l;
3737
3738 if (phy_c11 < -phy_c10)
3739 phy_c11 = -phy_c10;
3740 else if (phy_c11 > phy_c10)
3741 phy_c11 = phy_c10;
3742 if (phy_c12 < -phy_c10)
3743 phy_c12 = -phy_c10;
3744 else if (phy_c12 > phy_c10)
3745 phy_c12 = phy_c10;
3746 wlc_lcnphy_set_cc(pi, cal_type, phy_c11,
3747 phy_c12);
3748 udelay(20);
3749 wlc_lcnphy_samp_cap(pi, 0, 0, ptr, 2);
3750
3751 phy_c18 = 0;
3752 phy_c19 = 0;
3753 for (j = 0; j < 128; j++) {
3754 if (cal_type != 0)
3755 phy_c6 = j % phy_c4;
3756 else
3757 phy_c6 = (2 * j) % phy_c4;
3758
3759 phy_c2.re = phy_c1[phy_c6].re;
3760 phy_c2.im = phy_c1[phy_c6].im;
3761 phy_c17 = ptr[j];
3762 phy_c18 = phy_c18 + phy_c17 * phy_c2.re;
3763 phy_c19 = phy_c19 + phy_c17 * phy_c2.im;
3764 }
3765
3766 phy_c18 = phy_c18 >> 10;
3767 phy_c19 = phy_c19 >> 10;
3768 phy_c20 = ((phy_c18 * phy_c18) +
3769 (phy_c19 * phy_c19));
3770
3771 if (phy_c23 || phy_c20 < phy_c21) {
3772 phy_c21 = phy_c20;
3773 phy_c13 = phy_c11;
3774 phy_c14 = phy_c12;
3775 }
3776 phy_c23 = false;
3777 }
3778 }
3779 phy_c23 = true;
3780 phy_c15 = phy_c13;
3781 phy_c16 = phy_c14;
3782 phy_c7 = phy_c7 >> 1;
3783 wlc_lcnphy_set_cc(pi, cal_type, phy_c15, phy_c16);
3784 udelay(20);
3785 }
3786 goto cleanup;
3787 cleanup:
3788 wlc_lcnphy_tx_iqlo_loopback_cleanup(pi, phy_c32);
3789 wlc_lcnphy_stop_tx_tone(pi);
3790 write_phy_reg(pi, 0x6da, phy_c26);
3791 write_phy_reg(pi, 0x6db, phy_c27);
3792 write_phy_reg(pi, 0x938, phy_c28);
3793 write_phy_reg(pi, 0x4d7, phy_c29);
3794 write_phy_reg(pi, 0x4d8, phy_c30);
3795 write_radio_reg(pi, RADIO_2064_REG026, phy_c31);
3796
3797 kfree(phy_c32);
3798 kfree(ptr);
3799 }
3800
3801 void wlc_lcnphy_get_tx_iqcc(struct brcms_phy *pi, u16 *a, u16 *b)
3802 {
3803 u16 iqcc[2];
3804 struct phytbl_info tab;
3805
3806 tab.tbl_ptr = iqcc;
3807 tab.tbl_len = 2;
3808 tab.tbl_id = 0;
3809 tab.tbl_offset = 80;
3810 tab.tbl_width = 16;
3811 wlc_lcnphy_read_table(pi, &tab);
3812
3813 *a = iqcc[0];
3814 *b = iqcc[1];
3815 }
3816
3817 static void wlc_lcnphy_tx_iqlo_soft_cal_full(struct brcms_phy *pi)
3818 {
3819 struct lcnphy_unsign16_struct iqcc0, locc2, locc3, locc4;
3820
3821 wlc_lcnphy_set_cc(pi, 0, 0, 0);
3822 wlc_lcnphy_set_cc(pi, 2, 0, 0);
3823 wlc_lcnphy_set_cc(pi, 3, 0, 0);
3824 wlc_lcnphy_set_cc(pi, 4, 0, 0);
3825
3826 wlc_lcnphy_a1(pi, 4, 0, 0);
3827 wlc_lcnphy_a1(pi, 3, 0, 0);
3828 wlc_lcnphy_a1(pi, 2, 3, 2);
3829 wlc_lcnphy_a1(pi, 0, 5, 8);
3830 wlc_lcnphy_a1(pi, 2, 2, 1);
3831 wlc_lcnphy_a1(pi, 0, 4, 3);
3832
3833 iqcc0 = wlc_lcnphy_get_cc(pi, 0);
3834 locc2 = wlc_lcnphy_get_cc(pi, 2);
3835 locc3 = wlc_lcnphy_get_cc(pi, 3);
3836 locc4 = wlc_lcnphy_get_cc(pi, 4);
3837 }
3838
3839 u16 wlc_lcnphy_get_tx_locc(struct brcms_phy *pi)
3840 {
3841 struct phytbl_info tab;
3842 u16 didq;
3843
3844 tab.tbl_id = 0;
3845 tab.tbl_width = 16;
3846 tab.tbl_ptr = &didq;
3847 tab.tbl_len = 1;
3848 tab.tbl_offset = 85;
3849 wlc_lcnphy_read_table(pi, &tab);
3850
3851 return didq;
3852 }
3853
3854 static void wlc_lcnphy_txpwrtbl_iqlo_cal(struct brcms_phy *pi)
3855 {
3856
3857 struct lcnphy_txgains target_gains, old_gains;
3858 u8 save_bb_mult;
3859 u16 a, b, didq, save_pa_gain = 0;
3860 uint idx, SAVE_txpwrindex = 0xFF;
3861 u32 val;
3862 u16 SAVE_txpwrctrl = wlc_lcnphy_get_tx_pwr_ctrl(pi);
3863 struct phytbl_info tab;
3864 u8 ei0, eq0, fi0, fq0;
3865 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
3866
3867 wlc_lcnphy_get_tx_gain(pi, &old_gains);
3868 save_pa_gain = wlc_lcnphy_get_pa_gain(pi);
3869
3870 save_bb_mult = wlc_lcnphy_get_bbmult(pi);
3871
3872 if (SAVE_txpwrctrl == LCNPHY_TX_PWR_CTRL_OFF)
3873 SAVE_txpwrindex = wlc_lcnphy_get_current_tx_pwr_idx(pi);
3874
3875 wlc_lcnphy_set_tx_pwr_ctrl(pi, LCNPHY_TX_PWR_CTRL_OFF);
3876
3877 target_gains.gm_gain = 7;
3878 target_gains.pga_gain = 0;
3879 target_gains.pad_gain = 21;
3880 target_gains.dac_gain = 0;
3881 wlc_lcnphy_set_tx_gain(pi, &target_gains);
3882 wlc_lcnphy_set_tx_pwr_by_index(pi, 16);
3883
3884 if (LCNREV_IS(pi->pubpi.phy_rev, 1) || pi_lcn->lcnphy_hw_iqcal_en) {
3885
3886 wlc_lcnphy_set_tx_pwr_by_index(pi, 30);
3887
3888 wlc_lcnphy_tx_iqlo_cal(pi, &target_gains,
3889 (pi_lcn->
3890 lcnphy_recal ? LCNPHY_CAL_RECAL :
3891 LCNPHY_CAL_FULL), false);
3892 } else {
3893 wlc_lcnphy_tx_iqlo_soft_cal_full(pi);
3894 }
3895
3896 wlc_lcnphy_get_radio_loft(pi, &ei0, &eq0, &fi0, &fq0);
3897 if ((abs((s8) fi0) == 15) && (abs((s8) fq0) == 15)) {
3898 if (CHSPEC_IS5G(pi->radio_chanspec)) {
3899 target_gains.gm_gain = 255;
3900 target_gains.pga_gain = 255;
3901 target_gains.pad_gain = 0xf0;
3902 target_gains.dac_gain = 0;
3903 } else {
3904 target_gains.gm_gain = 7;
3905 target_gains.pga_gain = 45;
3906 target_gains.pad_gain = 186;
3907 target_gains.dac_gain = 0;
3908 }
3909
3910 if (LCNREV_IS(pi->pubpi.phy_rev, 1)
3911 || pi_lcn->lcnphy_hw_iqcal_en) {
3912
3913 target_gains.pga_gain = 0;
3914 target_gains.pad_gain = 30;
3915 wlc_lcnphy_set_tx_pwr_by_index(pi, 16);
3916 wlc_lcnphy_tx_iqlo_cal(pi, &target_gains,
3917 LCNPHY_CAL_FULL, false);
3918 } else {
3919 wlc_lcnphy_tx_iqlo_soft_cal_full(pi);
3920 }
3921 }
3922
3923 wlc_lcnphy_get_tx_iqcc(pi, &a, &b);
3924
3925 didq = wlc_lcnphy_get_tx_locc(pi);
3926
3927 tab.tbl_id = LCNPHY_TBL_ID_TXPWRCTL;
3928 tab.tbl_width = 32;
3929 tab.tbl_ptr = &val;
3930
3931 tab.tbl_len = 1;
3932 tab.tbl_offset = LCNPHY_TX_PWR_CTRL_RATE_OFFSET;
3933
3934 for (idx = 0; idx < 128; idx++) {
3935 tab.tbl_offset = LCNPHY_TX_PWR_CTRL_IQ_OFFSET + idx;
3936
3937 wlc_lcnphy_read_table(pi, &tab);
3938 val = (val & 0xfff00000) |
3939 ((u32) (a & 0x3FF) << 10) | (b & 0x3ff);
3940 wlc_lcnphy_write_table(pi, &tab);
3941
3942 val = didq;
3943 tab.tbl_offset = LCNPHY_TX_PWR_CTRL_LO_OFFSET + idx;
3944 wlc_lcnphy_write_table(pi, &tab);
3945 }
3946
3947 pi_lcn->lcnphy_cal_results.txiqlocal_a = a;
3948 pi_lcn->lcnphy_cal_results.txiqlocal_b = b;
3949 pi_lcn->lcnphy_cal_results.txiqlocal_didq = didq;
3950 pi_lcn->lcnphy_cal_results.txiqlocal_ei0 = ei0;
3951 pi_lcn->lcnphy_cal_results.txiqlocal_eq0 = eq0;
3952 pi_lcn->lcnphy_cal_results.txiqlocal_fi0 = fi0;
3953 pi_lcn->lcnphy_cal_results.txiqlocal_fq0 = fq0;
3954
3955 wlc_lcnphy_set_bbmult(pi, save_bb_mult);
3956 wlc_lcnphy_set_pa_gain(pi, save_pa_gain);
3957 wlc_lcnphy_set_tx_gain(pi, &old_gains);
3958
3959 if (SAVE_txpwrctrl != LCNPHY_TX_PWR_CTRL_OFF)
3960 wlc_lcnphy_set_tx_pwr_ctrl(pi, SAVE_txpwrctrl);
3961 else
3962 wlc_lcnphy_set_tx_pwr_by_index(pi, SAVE_txpwrindex);
3963 }
3964
3965 s16 wlc_lcnphy_tempsense_new(struct brcms_phy *pi, bool mode)
3966 {
3967 u16 tempsenseval1, tempsenseval2;
3968 s16 avg = 0;
3969 bool suspend = false;
3970
3971 if (mode == 1) {
3972 suspend = (0 == (bcma_read32(pi->d11core,
3973 D11REGOFFS(maccontrol)) &
3974 MCTL_EN_MAC));
3975 if (!suspend)
3976 wlapi_suspend_mac_and_wait(pi->sh->physhim);
3977 wlc_lcnphy_vbat_temp_sense_setup(pi, TEMPSENSE);
3978 }
3979 tempsenseval1 = read_phy_reg(pi, 0x476) & 0x1FF;
3980 tempsenseval2 = read_phy_reg(pi, 0x477) & 0x1FF;
3981
3982 if (tempsenseval1 > 255)
3983 avg = (s16) (tempsenseval1 - 512);
3984 else
3985 avg = (s16) tempsenseval1;
3986
3987 if (tempsenseval2 > 255)
3988 avg += (s16) (tempsenseval2 - 512);
3989 else
3990 avg += (s16) tempsenseval2;
3991
3992 avg /= 2;
3993
3994 if (mode == 1) {
3995
3996 mod_phy_reg(pi, 0x448, (0x1 << 14), (1) << 14);
3997
3998 udelay(100);
3999 mod_phy_reg(pi, 0x448, (0x1 << 14), (0) << 14);
4000
4001 if (!suspend)
4002 wlapi_enable_mac(pi->sh->physhim);
4003 }
4004 return avg;
4005 }
4006
4007 u16 wlc_lcnphy_tempsense(struct brcms_phy *pi, bool mode)
4008 {
4009 u16 tempsenseval1, tempsenseval2;
4010 s32 avg = 0;
4011 bool suspend = false;
4012 u16 SAVE_txpwrctrl = wlc_lcnphy_get_tx_pwr_ctrl(pi);
4013 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
4014
4015 if (mode == 1) {
4016 suspend = (0 == (bcma_read32(pi->d11core,
4017 D11REGOFFS(maccontrol)) &
4018 MCTL_EN_MAC));
4019 if (!suspend)
4020 wlapi_suspend_mac_and_wait(pi->sh->physhim);
4021 wlc_lcnphy_vbat_temp_sense_setup(pi, TEMPSENSE);
4022 }
4023 tempsenseval1 = read_phy_reg(pi, 0x476) & 0x1FF;
4024 tempsenseval2 = read_phy_reg(pi, 0x477) & 0x1FF;
4025
4026 if (tempsenseval1 > 255)
4027 avg = (int)(tempsenseval1 - 512);
4028 else
4029 avg = (int)tempsenseval1;
4030
4031 if (pi_lcn->lcnphy_tempsense_option == 1 || pi->hwpwrctrl_capable) {
4032 if (tempsenseval2 > 255)
4033 avg = (int)(avg - tempsenseval2 + 512);
4034 else
4035 avg = (int)(avg - tempsenseval2);
4036 } else {
4037 if (tempsenseval2 > 255)
4038 avg = (int)(avg + tempsenseval2 - 512);
4039 else
4040 avg = (int)(avg + tempsenseval2);
4041 avg = avg / 2;
4042 }
4043 if (avg < 0)
4044 avg = avg + 512;
4045
4046 if (pi_lcn->lcnphy_tempsense_option == 2)
4047 avg = tempsenseval1;
4048
4049 if (mode)
4050 wlc_lcnphy_set_tx_pwr_ctrl(pi, SAVE_txpwrctrl);
4051
4052 if (mode == 1) {
4053
4054 mod_phy_reg(pi, 0x448, (0x1 << 14), (1) << 14);
4055
4056 udelay(100);
4057 mod_phy_reg(pi, 0x448, (0x1 << 14), (0) << 14);
4058
4059 if (!suspend)
4060 wlapi_enable_mac(pi->sh->physhim);
4061 }
4062 return (u16) avg;
4063 }
4064
4065 s8 wlc_lcnphy_tempsense_degree(struct brcms_phy *pi, bool mode)
4066 {
4067 s32 degree = wlc_lcnphy_tempsense_new(pi, mode);
4068 degree =
4069 ((degree <<
4070 10) + LCN_TEMPSENSE_OFFSET + (LCN_TEMPSENSE_DEN >> 1))
4071 / LCN_TEMPSENSE_DEN;
4072 return (s8) degree;
4073 }
4074
4075 s8 wlc_lcnphy_vbatsense(struct brcms_phy *pi, bool mode)
4076 {
4077 u16 vbatsenseval;
4078 s32 avg = 0;
4079 bool suspend = false;
4080
4081 if (mode == 1) {
4082 suspend = (0 == (bcma_read32(pi->d11core,
4083 D11REGOFFS(maccontrol)) &
4084 MCTL_EN_MAC));
4085 if (!suspend)
4086 wlapi_suspend_mac_and_wait(pi->sh->physhim);
4087 wlc_lcnphy_vbat_temp_sense_setup(pi, VBATSENSE);
4088 }
4089
4090 vbatsenseval = read_phy_reg(pi, 0x475) & 0x1FF;
4091
4092 if (vbatsenseval > 255)
4093 avg = (s32) (vbatsenseval - 512);
4094 else
4095 avg = (s32) vbatsenseval;
4096
4097 avg = (avg * LCN_VBAT_SCALE_NOM +
4098 (LCN_VBAT_SCALE_DEN >> 1)) / LCN_VBAT_SCALE_DEN;
4099
4100 if (mode == 1) {
4101 if (!suspend)
4102 wlapi_enable_mac(pi->sh->physhim);
4103 }
4104 return (s8) avg;
4105 }
4106
4107 static void wlc_lcnphy_afe_clk_init(struct brcms_phy *pi, u8 mode)
4108 {
4109 u8 phybw40;
4110 phybw40 = CHSPEC_IS40(pi->radio_chanspec);
4111
4112 mod_phy_reg(pi, 0x6d1, (0x1 << 7), (1) << 7);
4113
4114 if (((mode == AFE_CLK_INIT_MODE_PAPD) && (phybw40 == 0)) ||
4115 (mode == AFE_CLK_INIT_MODE_TXRX2X))
4116 write_phy_reg(pi, 0x6d0, 0x7);
4117
4118 wlc_lcnphy_toggle_afe_pwdn(pi);
4119 }
4120
4121 static void wlc_lcnphy_temp_adj(struct brcms_phy *pi)
4122 {
4123 }
4124
4125 static void wlc_lcnphy_glacial_timer_based_cal(struct brcms_phy *pi)
4126 {
4127 bool suspend;
4128 s8 index;
4129 u16 SAVE_pwrctrl = wlc_lcnphy_get_tx_pwr_ctrl(pi);
4130 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
4131 suspend = (0 == (bcma_read32(pi->d11core, D11REGOFFS(maccontrol)) &
4132 MCTL_EN_MAC));
4133 if (!suspend)
4134 wlapi_suspend_mac_and_wait(pi->sh->physhim);
4135 wlc_lcnphy_deaf_mode(pi, true);
4136 pi->phy_lastcal = pi->sh->now;
4137 pi->phy_forcecal = false;
4138 index = pi_lcn->lcnphy_current_index;
4139
4140 wlc_lcnphy_txpwrtbl_iqlo_cal(pi);
4141
4142 wlc_lcnphy_set_tx_pwr_by_index(pi, index);
4143 wlc_lcnphy_set_tx_pwr_ctrl(pi, SAVE_pwrctrl);
4144 wlc_lcnphy_deaf_mode(pi, false);
4145 if (!suspend)
4146 wlapi_enable_mac(pi->sh->physhim);
4147
4148 }
4149
4150 static void wlc_lcnphy_periodic_cal(struct brcms_phy *pi)
4151 {
4152 bool suspend, full_cal;
4153 const struct lcnphy_rx_iqcomp *rx_iqcomp;
4154 int rx_iqcomp_sz;
4155 u16 SAVE_pwrctrl = wlc_lcnphy_get_tx_pwr_ctrl(pi);
4156 s8 index;
4157 struct phytbl_info tab;
4158 s32 a1, b0, b1;
4159 s32 tssi, pwr, maxtargetpwr, mintargetpwr;
4160 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
4161
4162 pi->phy_lastcal = pi->sh->now;
4163 pi->phy_forcecal = false;
4164 full_cal =
4165 (pi_lcn->lcnphy_full_cal_channel !=
4166 CHSPEC_CHANNEL(pi->radio_chanspec));
4167 pi_lcn->lcnphy_full_cal_channel = CHSPEC_CHANNEL(pi->radio_chanspec);
4168 index = pi_lcn->lcnphy_current_index;
4169
4170 suspend = (0 == (bcma_read32(pi->d11core, D11REGOFFS(maccontrol)) &
4171 MCTL_EN_MAC));
4172 if (!suspend) {
4173 wlapi_bmac_write_shm(pi->sh->physhim, M_CTS_DURATION, 10000);
4174 wlapi_suspend_mac_and_wait(pi->sh->physhim);
4175 }
4176
4177 wlc_lcnphy_deaf_mode(pi, true);
4178
4179 wlc_lcnphy_txpwrtbl_iqlo_cal(pi);
4180
4181 rx_iqcomp = lcnphy_rx_iqcomp_table_rev0;
4182 rx_iqcomp_sz = ARRAY_SIZE(lcnphy_rx_iqcomp_table_rev0);
4183
4184 if (LCNREV_IS(pi->pubpi.phy_rev, 1))
4185 wlc_lcnphy_rx_iq_cal(pi, NULL, 0, true, false, 1, 40);
4186 else
4187 wlc_lcnphy_rx_iq_cal(pi, NULL, 0, true, false, 1, 127);
4188
4189 if (wlc_lcnphy_tssi_based_pwr_ctrl_enabled(pi)) {
4190
4191 wlc_lcnphy_idle_tssi_est((struct brcms_phy_pub *) pi);
4192
4193 b0 = pi->txpa_2g[0];
4194 b1 = pi->txpa_2g[1];
4195 a1 = pi->txpa_2g[2];
4196 maxtargetpwr = wlc_lcnphy_tssi2dbm(10, a1, b0, b1);
4197 mintargetpwr = wlc_lcnphy_tssi2dbm(125, a1, b0, b1);
4198
4199 tab.tbl_id = LCNPHY_TBL_ID_TXPWRCTL;
4200 tab.tbl_width = 32;
4201 tab.tbl_ptr = &pwr;
4202 tab.tbl_len = 1;
4203 tab.tbl_offset = 0;
4204 for (tssi = 0; tssi < 128; tssi++) {
4205 pwr = wlc_lcnphy_tssi2dbm(tssi, a1, b0, b1);
4206 pwr = (pwr < mintargetpwr) ? mintargetpwr : pwr;
4207 wlc_lcnphy_write_table(pi, &tab);
4208 tab.tbl_offset++;
4209 }
4210 }
4211
4212 wlc_lcnphy_set_tx_pwr_by_index(pi, index);
4213 wlc_lcnphy_set_tx_pwr_ctrl(pi, SAVE_pwrctrl);
4214 wlc_lcnphy_deaf_mode(pi, false);
4215 if (!suspend)
4216 wlapi_enable_mac(pi->sh->physhim);
4217 }
4218
4219 void wlc_lcnphy_calib_modes(struct brcms_phy *pi, uint mode)
4220 {
4221 u16 temp_new;
4222 int temp1, temp2, temp_diff;
4223 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
4224
4225 switch (mode) {
4226 case PHY_PERICAL_CHAN:
4227 break;
4228 case PHY_FULLCAL:
4229 wlc_lcnphy_periodic_cal(pi);
4230 break;
4231 case PHY_PERICAL_PHYINIT:
4232 wlc_lcnphy_periodic_cal(pi);
4233 break;
4234 case PHY_PERICAL_WATCHDOG:
4235 if (wlc_lcnphy_tempsense_based_pwr_ctrl_enabled(pi)) {
4236 temp_new = wlc_lcnphy_tempsense(pi, 0);
4237 temp1 = LCNPHY_TEMPSENSE(temp_new);
4238 temp2 = LCNPHY_TEMPSENSE(pi_lcn->lcnphy_cal_temper);
4239 temp_diff = temp1 - temp2;
4240 if ((pi_lcn->lcnphy_cal_counter > 90) ||
4241 (temp_diff > 60) || (temp_diff < -60)) {
4242 wlc_lcnphy_glacial_timer_based_cal(pi);
4243 wlc_2064_vco_cal(pi);
4244 pi_lcn->lcnphy_cal_temper = temp_new;
4245 pi_lcn->lcnphy_cal_counter = 0;
4246 } else
4247 pi_lcn->lcnphy_cal_counter++;
4248 }
4249 break;
4250 case LCNPHY_PERICAL_TEMPBASED_TXPWRCTRL:
4251 if (wlc_lcnphy_tempsense_based_pwr_ctrl_enabled(pi))
4252 wlc_lcnphy_tx_power_adjustment(
4253 (struct brcms_phy_pub *) pi);
4254 break;
4255 }
4256 }
4257
4258 void wlc_lcnphy_get_tssi(struct brcms_phy *pi, s8 *ofdm_pwr, s8 *cck_pwr)
4259 {
4260 s8 cck_offset;
4261 u16 status;
4262 status = (read_phy_reg(pi, 0x4ab));
4263 if (wlc_lcnphy_tssi_based_pwr_ctrl_enabled(pi) &&
4264 (status & (0x1 << 15))) {
4265 *ofdm_pwr = (s8) (((read_phy_reg(pi, 0x4ab) & (0x1ff << 0))
4266 >> 0) >> 1);
4267
4268 if (wlc_phy_tpc_isenabled_lcnphy(pi))
4269 cck_offset = pi->tx_power_offset[TXP_FIRST_CCK];
4270 else
4271 cck_offset = 0;
4272
4273 *cck_pwr = *ofdm_pwr + cck_offset;
4274 } else {
4275 *cck_pwr = 0;
4276 *ofdm_pwr = 0;
4277 }
4278 }
4279
4280 void wlc_phy_cal_init_lcnphy(struct brcms_phy *pi)
4281 {
4282 return;
4283
4284 }
4285
4286 void wlc_lcnphy_tx_power_adjustment(struct brcms_phy_pub *ppi)
4287 {
4288 s8 index;
4289 u16 index2;
4290 struct brcms_phy *pi = (struct brcms_phy *) ppi;
4291 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
4292 u16 SAVE_txpwrctrl = wlc_lcnphy_get_tx_pwr_ctrl(pi);
4293 if (wlc_lcnphy_tempsense_based_pwr_ctrl_enabled(pi) &&
4294 SAVE_txpwrctrl) {
4295 index = wlc_lcnphy_tempcompensated_txpwrctrl(pi);
4296 index2 = (u16) (index * 2);
4297 mod_phy_reg(pi, 0x4a9, (0x1ff << 0), (index2) << 0);
4298
4299 pi_lcn->lcnphy_current_index =
4300 (s8)((read_phy_reg(pi, 0x4a9) & 0xFF) / 2);
4301 }
4302 }
4303
4304 static void
4305 wlc_lcnphy_load_tx_gain_table(struct brcms_phy *pi,
4306 const struct lcnphy_tx_gain_tbl_entry *gain_table)
4307 {
4308 u32 j;
4309 struct phytbl_info tab;
4310 u32 val;
4311 u16 pa_gain;
4312 u16 gm_gain;
4313
4314 if (CHSPEC_IS5G(pi->radio_chanspec))
4315 pa_gain = 0x70;
4316 else
4317 pa_gain = 0x70;
4318
4319 if (pi->sh->boardflags & BFL_FEM)
4320 pa_gain = 0x10;
4321 tab.tbl_id = LCNPHY_TBL_ID_TXPWRCTL;
4322 tab.tbl_width = 32;
4323 tab.tbl_len = 1;
4324 tab.tbl_ptr = &val;
4325
4326 for (j = 0; j < 128; j++) {
4327 gm_gain = gain_table[j].gm;
4328 val = (((u32) pa_gain << 24) |
4329 (gain_table[j].pad << 16) |
4330 (gain_table[j].pga << 8) | gm_gain);
4331
4332 tab.tbl_offset = LCNPHY_TX_PWR_CTRL_GAIN_OFFSET + j;
4333 wlc_lcnphy_write_table(pi, &tab);
4334
4335 val = (gain_table[j].dac << 28) | (gain_table[j].bb_mult << 20);
4336 tab.tbl_offset = LCNPHY_TX_PWR_CTRL_IQ_OFFSET + j;
4337 wlc_lcnphy_write_table(pi, &tab);
4338 }
4339 }
4340
4341 static void wlc_lcnphy_load_rfpower(struct brcms_phy *pi)
4342 {
4343 struct phytbl_info tab;
4344 u32 val, bbmult, rfgain;
4345 u8 index;
4346 u8 scale_factor = 1;
4347 s16 temp, temp1, temp2, qQ, qQ1, qQ2, shift;
4348
4349 tab.tbl_id = LCNPHY_TBL_ID_TXPWRCTL;
4350 tab.tbl_width = 32;
4351 tab.tbl_len = 1;
4352
4353 for (index = 0; index < 128; index++) {
4354 tab.tbl_ptr = &bbmult;
4355 tab.tbl_offset = LCNPHY_TX_PWR_CTRL_IQ_OFFSET + index;
4356 wlc_lcnphy_read_table(pi, &tab);
4357 bbmult = bbmult >> 20;
4358
4359 tab.tbl_ptr = &rfgain;
4360 tab.tbl_offset = LCNPHY_TX_PWR_CTRL_GAIN_OFFSET + index;
4361 wlc_lcnphy_read_table(pi, &tab);
4362
4363 qm_log10((s32) (bbmult), 0, &temp1, &qQ1);
4364 qm_log10((s32) (1 << 6), 0, &temp2, &qQ2);
4365
4366 if (qQ1 < qQ2) {
4367 temp2 = qm_shr16(temp2, qQ2 - qQ1);
4368 qQ = qQ1;
4369 } else {
4370 temp1 = qm_shr16(temp1, qQ1 - qQ2);
4371 qQ = qQ2;
4372 }
4373 temp = qm_sub16(temp1, temp2);
4374
4375 if (qQ >= 4)
4376 shift = qQ - 4;
4377 else
4378 shift = 4 - qQ;
4379
4380 val = (((index << shift) + (5 * temp) +
4381 (1 << (scale_factor + shift - 3))) >> (scale_factor +
4382 shift - 2));
4383
4384 tab.tbl_ptr = &val;
4385 tab.tbl_offset = LCNPHY_TX_PWR_CTRL_PWR_OFFSET + index;
4386 wlc_lcnphy_write_table(pi, &tab);
4387 }
4388 }
4389
4390 static void wlc_lcnphy_bu_tweaks(struct brcms_phy *pi)
4391 {
4392 or_phy_reg(pi, 0x805, 0x1);
4393
4394 mod_phy_reg(pi, 0x42f, (0x7 << 0), (0x3) << 0);
4395
4396 mod_phy_reg(pi, 0x030, (0x7 << 0), (0x3) << 0);
4397
4398 write_phy_reg(pi, 0x414, 0x1e10);
4399 write_phy_reg(pi, 0x415, 0x0640);
4400
4401 mod_phy_reg(pi, 0x4df, (0xff << 8), -9 << 8);
4402
4403 or_phy_reg(pi, 0x44a, 0x44);
4404 write_phy_reg(pi, 0x44a, 0x80);
4405 mod_phy_reg(pi, 0x434, (0xff << 0), (0xFD) << 0);
4406
4407 mod_phy_reg(pi, 0x420, (0xff << 0), (16) << 0);
4408
4409 if (!(pi->sh->boardrev < 0x1204))
4410 mod_radio_reg(pi, RADIO_2064_REG09B, 0xF0, 0xF0);
4411
4412 write_phy_reg(pi, 0x7d6, 0x0902);
4413 mod_phy_reg(pi, 0x429, (0xf << 0), (0x9) << 0);
4414
4415 mod_phy_reg(pi, 0x429, (0x3f << 4), (0xe) << 4);
4416
4417 if (LCNREV_IS(pi->pubpi.phy_rev, 1)) {
4418 mod_phy_reg(pi, 0x423, (0xff << 0), (0x46) << 0);
4419
4420 mod_phy_reg(pi, 0x411, (0xff << 0), (1) << 0);
4421
4422 mod_phy_reg(pi, 0x434, (0xff << 0), (0xFF) << 0);
4423
4424 mod_phy_reg(pi, 0x656, (0xf << 0), (2) << 0);
4425
4426 mod_phy_reg(pi, 0x44d, (0x1 << 2), (1) << 2);
4427
4428 mod_radio_reg(pi, RADIO_2064_REG0F7, 0x4, 0x4);
4429 mod_radio_reg(pi, RADIO_2064_REG0F1, 0x3, 0);
4430 mod_radio_reg(pi, RADIO_2064_REG0F2, 0xF8, 0x90);
4431 mod_radio_reg(pi, RADIO_2064_REG0F3, 0x3, 0x2);
4432 mod_radio_reg(pi, RADIO_2064_REG0F3, 0xf0, 0xa0);
4433
4434 mod_radio_reg(pi, RADIO_2064_REG11F, 0x2, 0x2);
4435
4436 wlc_lcnphy_clear_tx_power_offsets(pi);
4437 mod_phy_reg(pi, 0x4d0, (0x1ff << 6), (10) << 6);
4438
4439 }
4440 }
4441
4442 static void wlc_lcnphy_rcal(struct brcms_phy *pi)
4443 {
4444 u8 rcal_value;
4445
4446 and_radio_reg(pi, RADIO_2064_REG05B, 0xfD);
4447
4448 or_radio_reg(pi, RADIO_2064_REG004, 0x40);
4449 or_radio_reg(pi, RADIO_2064_REG120, 0x10);
4450
4451 or_radio_reg(pi, RADIO_2064_REG078, 0x80);
4452 or_radio_reg(pi, RADIO_2064_REG129, 0x02);
4453
4454 or_radio_reg(pi, RADIO_2064_REG057, 0x01);
4455
4456 or_radio_reg(pi, RADIO_2064_REG05B, 0x02);
4457 mdelay(5);
4458 SPINWAIT(!wlc_radio_2064_rcal_done(pi), 10 * 1000 * 1000);
4459
4460 if (wlc_radio_2064_rcal_done(pi)) {
4461 rcal_value = (u8) read_radio_reg(pi, RADIO_2064_REG05C);
4462 rcal_value = rcal_value & 0x1f;
4463 }
4464
4465 and_radio_reg(pi, RADIO_2064_REG05B, 0xfD);
4466
4467 and_radio_reg(pi, RADIO_2064_REG057, 0xFE);
4468 }
4469
4470 static void wlc_lcnphy_rc_cal(struct brcms_phy *pi)
4471 {
4472 u8 dflt_rc_cal_val;
4473 u16 flt_val;
4474
4475 dflt_rc_cal_val = 7;
4476 if (LCNREV_IS(pi->pubpi.phy_rev, 1))
4477 dflt_rc_cal_val = 11;
4478 flt_val =
4479 (dflt_rc_cal_val << 10) | (dflt_rc_cal_val << 5) |
4480 (dflt_rc_cal_val);
4481 write_phy_reg(pi, 0x933, flt_val);
4482 write_phy_reg(pi, 0x934, flt_val);
4483 write_phy_reg(pi, 0x935, flt_val);
4484 write_phy_reg(pi, 0x936, flt_val);
4485 write_phy_reg(pi, 0x937, (flt_val & 0x1FF));
4486
4487 return;
4488 }
4489
4490 static void wlc_radio_2064_init(struct brcms_phy *pi)
4491 {
4492 u32 i;
4493 const struct lcnphy_radio_regs *lcnphyregs = NULL;
4494
4495 lcnphyregs = lcnphy_radio_regs_2064;
4496
4497 for (i = 0; lcnphyregs[i].address != 0xffff; i++)
4498 if (CHSPEC_IS5G(pi->radio_chanspec) && lcnphyregs[i].do_init_a)
4499 write_radio_reg(pi,
4500 ((lcnphyregs[i].address & 0x3fff) |
4501 RADIO_DEFAULT_CORE),
4502 (u16) lcnphyregs[i].init_a);
4503 else if (lcnphyregs[i].do_init_g)
4504 write_radio_reg(pi,
4505 ((lcnphyregs[i].address & 0x3fff) |
4506 RADIO_DEFAULT_CORE),
4507 (u16) lcnphyregs[i].init_g);
4508
4509 write_radio_reg(pi, RADIO_2064_REG032, 0x62);
4510 write_radio_reg(pi, RADIO_2064_REG033, 0x19);
4511
4512 write_radio_reg(pi, RADIO_2064_REG090, 0x10);
4513
4514 write_radio_reg(pi, RADIO_2064_REG010, 0x00);
4515
4516 if (LCNREV_IS(pi->pubpi.phy_rev, 1)) {
4517
4518 write_radio_reg(pi, RADIO_2064_REG060, 0x7f);
4519 write_radio_reg(pi, RADIO_2064_REG061, 0x72);
4520 write_radio_reg(pi, RADIO_2064_REG062, 0x7f);
4521 }
4522
4523 write_radio_reg(pi, RADIO_2064_REG01D, 0x02);
4524 write_radio_reg(pi, RADIO_2064_REG01E, 0x06);
4525
4526 mod_phy_reg(pi, 0x4ea, (0x7 << 0), 0 << 0);
4527
4528 mod_phy_reg(pi, 0x4ea, (0x7 << 3), 1 << 3);
4529
4530 mod_phy_reg(pi, 0x4ea, (0x7 << 6), 2 << 6);
4531
4532 mod_phy_reg(pi, 0x4ea, (0x7 << 9), 3 << 9);
4533
4534 mod_phy_reg(pi, 0x4ea, (0x7 << 12), 4 << 12);
4535
4536 write_phy_reg(pi, 0x4ea, 0x4688);
4537
4538 mod_phy_reg(pi, 0x4eb, (0x7 << 0), 2 << 0);
4539
4540 mod_phy_reg(pi, 0x4eb, (0x7 << 6), 0 << 6);
4541
4542 mod_phy_reg(pi, 0x46a, (0xffff << 0), 25 << 0);
4543
4544 wlc_lcnphy_set_tx_locc(pi, 0);
4545
4546 wlc_lcnphy_rcal(pi);
4547
4548 wlc_lcnphy_rc_cal(pi);
4549 }
4550
4551 static void wlc_lcnphy_radio_init(struct brcms_phy *pi)
4552 {
4553 wlc_radio_2064_init(pi);
4554 }
4555
4556 static void wlc_lcnphy_tbl_init(struct brcms_phy *pi)
4557 {
4558 uint idx;
4559 u8 phybw40;
4560 struct phytbl_info tab;
4561 u32 val;
4562
4563 phybw40 = CHSPEC_IS40(pi->radio_chanspec);
4564
4565 for (idx = 0; idx < dot11lcnphytbl_info_sz_rev0; idx++)
4566 wlc_lcnphy_write_table(pi, &dot11lcnphytbl_info_rev0[idx]);
4567
4568 if (pi->sh->boardflags & BFL_FEM_BT) {
4569 tab.tbl_id = LCNPHY_TBL_ID_RFSEQ;
4570 tab.tbl_width = 16;
4571 tab.tbl_ptr = &val;
4572 tab.tbl_len = 1;
4573 val = 100;
4574 tab.tbl_offset = 4;
4575 wlc_lcnphy_write_table(pi, &tab);
4576 }
4577
4578 tab.tbl_id = LCNPHY_TBL_ID_RFSEQ;
4579 tab.tbl_width = 16;
4580 tab.tbl_ptr = &val;
4581 tab.tbl_len = 1;
4582
4583 val = 114;
4584 tab.tbl_offset = 0;
4585 wlc_lcnphy_write_table(pi, &tab);
4586
4587 val = 130;
4588 tab.tbl_offset = 1;
4589 wlc_lcnphy_write_table(pi, &tab);
4590
4591 val = 6;
4592 tab.tbl_offset = 8;
4593 wlc_lcnphy_write_table(pi, &tab);
4594
4595 if (CHSPEC_IS2G(pi->radio_chanspec)) {
4596 if (pi->sh->boardflags & BFL_FEM)
4597 wlc_lcnphy_load_tx_gain_table(
4598 pi,
4599 dot11lcnphy_2GHz_extPA_gaintable_rev0);
4600 else
4601 wlc_lcnphy_load_tx_gain_table(
4602 pi,
4603 dot11lcnphy_2GHz_gaintable_rev0);
4604 }
4605
4606 if (LCNREV_IS(pi->pubpi.phy_rev, 2)) {
4607 const struct phytbl_info *tb;
4608 int l;
4609
4610 if (CHSPEC_IS2G(pi->radio_chanspec)) {
4611 l = dot11lcnphytbl_rx_gain_info_2G_rev2_sz;
4612 if (pi->sh->boardflags & BFL_EXTLNA)
4613 tb = dot11lcnphytbl_rx_gain_info_extlna_2G_rev2;
4614 else
4615 tb = dot11lcnphytbl_rx_gain_info_2G_rev2;
4616 } else {
4617 l = dot11lcnphytbl_rx_gain_info_5G_rev2_sz;
4618 if (pi->sh->boardflags & BFL_EXTLNA_5GHz)
4619 tb = dot11lcnphytbl_rx_gain_info_extlna_5G_rev2;
4620 else
4621 tb = dot11lcnphytbl_rx_gain_info_5G_rev2;
4622 }
4623
4624 for (idx = 0; idx < l; idx++)
4625 wlc_lcnphy_write_table(pi, &tb[idx]);
4626 }
4627
4628 if ((pi->sh->boardflags & BFL_FEM)
4629 && !(pi->sh->boardflags & BFL_FEM_BT))
4630 wlc_lcnphy_write_table(pi, &dot11lcn_sw_ctrl_tbl_info_4313_epa);
4631 else if (pi->sh->boardflags & BFL_FEM_BT) {
4632 if (pi->sh->boardrev < 0x1250)
4633 wlc_lcnphy_write_table(
4634 pi,
4635 &dot11lcn_sw_ctrl_tbl_info_4313_bt_epa);
4636 else
4637 wlc_lcnphy_write_table(
4638 pi,
4639 &dot11lcn_sw_ctrl_tbl_info_4313_bt_epa_p250);
4640 } else
4641 wlc_lcnphy_write_table(pi, &dot11lcn_sw_ctrl_tbl_info_4313);
4642
4643 wlc_lcnphy_load_rfpower(pi);
4644
4645 wlc_lcnphy_clear_papd_comptable(pi);
4646 }
4647
4648 static void wlc_lcnphy_rev0_baseband_init(struct brcms_phy *pi)
4649 {
4650 u16 afectrl1;
4651 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
4652
4653 write_radio_reg(pi, RADIO_2064_REG11C, 0x0);
4654
4655 write_phy_reg(pi, 0x43b, 0x0);
4656 write_phy_reg(pi, 0x43c, 0x0);
4657 write_phy_reg(pi, 0x44c, 0x0);
4658 write_phy_reg(pi, 0x4e6, 0x0);
4659 write_phy_reg(pi, 0x4f9, 0x0);
4660 write_phy_reg(pi, 0x4b0, 0x0);
4661 write_phy_reg(pi, 0x938, 0x0);
4662 write_phy_reg(pi, 0x4b0, 0x0);
4663 write_phy_reg(pi, 0x44e, 0);
4664
4665 or_phy_reg(pi, 0x567, 0x03);
4666
4667 or_phy_reg(pi, 0x44a, 0x44);
4668 write_phy_reg(pi, 0x44a, 0x80);
4669
4670 if (!(pi->sh->boardflags & BFL_FEM))
4671 wlc_lcnphy_set_tx_pwr_by_index(pi, 52);
4672
4673 if (0) {
4674 afectrl1 = 0;
4675 afectrl1 = (u16) ((pi_lcn->lcnphy_rssi_vf) |
4676 (pi_lcn->lcnphy_rssi_vc << 4) |
4677 (pi_lcn->lcnphy_rssi_gs << 10));
4678 write_phy_reg(pi, 0x43e, afectrl1);
4679 }
4680
4681 mod_phy_reg(pi, 0x634, (0xff << 0), 0xC << 0);
4682 if (pi->sh->boardflags & BFL_FEM) {
4683 mod_phy_reg(pi, 0x634, (0xff << 0), 0xA << 0);
4684
4685 write_phy_reg(pi, 0x910, 0x1);
4686 }
4687
4688 mod_phy_reg(pi, 0x448, (0x3 << 8), 1 << 8);
4689 mod_phy_reg(pi, 0x608, (0xff << 0), 0x17 << 0);
4690 mod_phy_reg(pi, 0x604, (0x7ff << 0), 0x3EA << 0);
4691
4692 }
4693
4694 static void wlc_lcnphy_rev2_baseband_init(struct brcms_phy *pi)
4695 {
4696 if (CHSPEC_IS5G(pi->radio_chanspec)) {
4697 mod_phy_reg(pi, 0x416, (0xff << 0), 80 << 0);
4698 mod_phy_reg(pi, 0x416, (0xff << 8), 80 << 8);
4699 }
4700 }
4701
4702 static void wlc_lcnphy_agc_temp_init(struct brcms_phy *pi)
4703 {
4704 s16 temp;
4705 struct phytbl_info tab;
4706 u32 tableBuffer[2];
4707 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
4708
4709 temp = (s16) read_phy_reg(pi, 0x4df);
4710 pi_lcn->lcnphy_ofdmgainidxtableoffset = (temp & (0xff << 0)) >> 0;
4711
4712 if (pi_lcn->lcnphy_ofdmgainidxtableoffset > 127)
4713 pi_lcn->lcnphy_ofdmgainidxtableoffset -= 256;
4714
4715 pi_lcn->lcnphy_dsssgainidxtableoffset = (temp & (0xff << 8)) >> 8;
4716
4717 if (pi_lcn->lcnphy_dsssgainidxtableoffset > 127)
4718 pi_lcn->lcnphy_dsssgainidxtableoffset -= 256;
4719
4720 tab.tbl_ptr = tableBuffer;
4721 tab.tbl_len = 2;
4722 tab.tbl_id = 17;
4723 tab.tbl_offset = 59;
4724 tab.tbl_width = 32;
4725 wlc_lcnphy_read_table(pi, &tab);
4726
4727 if (tableBuffer[0] > 63)
4728 tableBuffer[0] -= 128;
4729 pi_lcn->lcnphy_tr_R_gain_val = tableBuffer[0];
4730
4731 if (tableBuffer[1] > 63)
4732 tableBuffer[1] -= 128;
4733 pi_lcn->lcnphy_tr_T_gain_val = tableBuffer[1];
4734
4735 temp = (s16) (read_phy_reg(pi, 0x434) & (0xff << 0));
4736 if (temp > 127)
4737 temp -= 256;
4738 pi_lcn->lcnphy_input_pwr_offset_db = (s8) temp;
4739
4740 pi_lcn->lcnphy_Med_Low_Gain_db =
4741 (read_phy_reg(pi, 0x424) & (0xff << 8)) >> 8;
4742 pi_lcn->lcnphy_Very_Low_Gain_db =
4743 (read_phy_reg(pi, 0x425) & (0xff << 0)) >> 0;
4744
4745 tab.tbl_ptr = tableBuffer;
4746 tab.tbl_len = 2;
4747 tab.tbl_id = LCNPHY_TBL_ID_GAIN_IDX;
4748 tab.tbl_offset = 28;
4749 tab.tbl_width = 32;
4750 wlc_lcnphy_read_table(pi, &tab);
4751
4752 pi_lcn->lcnphy_gain_idx_14_lowword = tableBuffer[0];
4753 pi_lcn->lcnphy_gain_idx_14_hiword = tableBuffer[1];
4754
4755 }
4756
4757 static void wlc_lcnphy_baseband_init(struct brcms_phy *pi)
4758 {
4759
4760 wlc_lcnphy_tbl_init(pi);
4761 wlc_lcnphy_rev0_baseband_init(pi);
4762 if (LCNREV_IS(pi->pubpi.phy_rev, 2))
4763 wlc_lcnphy_rev2_baseband_init(pi);
4764 wlc_lcnphy_bu_tweaks(pi);
4765 }
4766
4767 void wlc_phy_init_lcnphy(struct brcms_phy *pi)
4768 {
4769 u8 phybw40;
4770 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
4771 phybw40 = CHSPEC_IS40(pi->radio_chanspec);
4772
4773 pi_lcn->lcnphy_cal_counter = 0;
4774 pi_lcn->lcnphy_cal_temper = pi_lcn->lcnphy_rawtempsense;
4775
4776 or_phy_reg(pi, 0x44a, 0x80);
4777 and_phy_reg(pi, 0x44a, 0x7f);
4778
4779 wlc_lcnphy_afe_clk_init(pi, AFE_CLK_INIT_MODE_TXRX2X);
4780
4781 write_phy_reg(pi, 0x60a, 160);
4782
4783 write_phy_reg(pi, 0x46a, 25);
4784
4785 wlc_lcnphy_baseband_init(pi);
4786
4787 wlc_lcnphy_radio_init(pi);
4788
4789 if (CHSPEC_IS2G(pi->radio_chanspec))
4790 wlc_lcnphy_tx_pwr_ctrl_init((struct brcms_phy_pub *) pi);
4791
4792 wlc_phy_chanspec_set((struct brcms_phy_pub *) pi, pi->radio_chanspec);
4793
4794 si_pmu_regcontrol(pi->sh->sih, 0, 0xf, 0x9);
4795
4796 si_pmu_chipcontrol(pi->sh->sih, 0, 0xffffffff, 0x03CDDDDD);
4797
4798 if ((pi->sh->boardflags & BFL_FEM)
4799 && wlc_lcnphy_tempsense_based_pwr_ctrl_enabled(pi))
4800 wlc_lcnphy_set_tx_pwr_by_index(pi, FIXED_TXPWR);
4801
4802 wlc_lcnphy_agc_temp_init(pi);
4803
4804 wlc_lcnphy_temp_adj(pi);
4805
4806 mod_phy_reg(pi, 0x448, (0x1 << 14), (1) << 14);
4807
4808 udelay(100);
4809 mod_phy_reg(pi, 0x448, (0x1 << 14), (0) << 14);
4810
4811 wlc_lcnphy_set_tx_pwr_ctrl(pi, LCNPHY_TX_PWR_CTRL_HW);
4812 pi_lcn->lcnphy_noise_samples = LCNPHY_NOISE_SAMPLES_DEFAULT;
4813 wlc_lcnphy_calib_modes(pi, PHY_PERICAL_PHYINIT);
4814 }
4815
4816 static bool wlc_phy_txpwr_srom_read_lcnphy(struct brcms_phy *pi)
4817 {
4818 s8 txpwr = 0;
4819 int i;
4820 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
4821 struct phy_shim_info *shim = pi->sh->physhim;
4822
4823 if (CHSPEC_IS2G(pi->radio_chanspec)) {
4824 u16 cckpo = 0;
4825 u32 offset_ofdm, offset_mcs;
4826
4827 pi_lcn->lcnphy_tr_isolation_mid =
4828 (u8)wlapi_getintvar(shim, BRCMS_SROM_TRISO2G);
4829
4830 pi_lcn->lcnphy_rx_power_offset =
4831 (u8)wlapi_getintvar(shim, BRCMS_SROM_RXPO2G);
4832
4833 pi->txpa_2g[0] = (s16)wlapi_getintvar(shim, BRCMS_SROM_PA0B0);
4834 pi->txpa_2g[1] = (s16)wlapi_getintvar(shim, BRCMS_SROM_PA0B1);
4835 pi->txpa_2g[2] = (s16)wlapi_getintvar(shim, BRCMS_SROM_PA0B2);
4836
4837 pi_lcn->lcnphy_rssi_vf =
4838 (u8)wlapi_getintvar(shim, BRCMS_SROM_RSSISMF2G);
4839 pi_lcn->lcnphy_rssi_vc =
4840 (u8)wlapi_getintvar(shim, BRCMS_SROM_RSSISMC2G);
4841 pi_lcn->lcnphy_rssi_gs =
4842 (u8)wlapi_getintvar(shim, BRCMS_SROM_RSSISAV2G);
4843
4844 pi_lcn->lcnphy_rssi_vf_lowtemp = pi_lcn->lcnphy_rssi_vf;
4845 pi_lcn->lcnphy_rssi_vc_lowtemp = pi_lcn->lcnphy_rssi_vc;
4846 pi_lcn->lcnphy_rssi_gs_lowtemp = pi_lcn->lcnphy_rssi_gs;
4847
4848 pi_lcn->lcnphy_rssi_vf_hightemp = pi_lcn->lcnphy_rssi_vf;
4849 pi_lcn->lcnphy_rssi_vc_hightemp = pi_lcn->lcnphy_rssi_vc;
4850 pi_lcn->lcnphy_rssi_gs_hightemp = pi_lcn->lcnphy_rssi_gs;
4851
4852 txpwr = (s8)wlapi_getintvar(shim, BRCMS_SROM_MAXP2GA0);
4853 pi->tx_srom_max_2g = txpwr;
4854
4855 for (i = 0; i < PWRTBL_NUM_COEFF; i++) {
4856 pi->txpa_2g_low_temp[i] = pi->txpa_2g[i];
4857 pi->txpa_2g_high_temp[i] = pi->txpa_2g[i];
4858 }
4859
4860 cckpo = (u16)wlapi_getintvar(shim, BRCMS_SROM_CCK2GPO);
4861 offset_ofdm = (u32)wlapi_getintvar(shim, BRCMS_SROM_OFDM2GPO);
4862 if (cckpo) {
4863 uint max_pwr_chan = txpwr;
4864
4865 for (i = TXP_FIRST_CCK; i <= TXP_LAST_CCK; i++) {
4866 pi->tx_srom_max_rate_2g[i] =
4867 max_pwr_chan - ((cckpo & 0xf) * 2);
4868 cckpo >>= 4;
4869 }
4870
4871 for (i = TXP_FIRST_OFDM; i <= TXP_LAST_OFDM; i++) {
4872 pi->tx_srom_max_rate_2g[i] =
4873 max_pwr_chan -
4874 ((offset_ofdm & 0xf) * 2);
4875 offset_ofdm >>= 4;
4876 }
4877 } else {
4878 u8 opo = 0;
4879
4880 opo = (u8)wlapi_getintvar(shim, BRCMS_SROM_OPO);
4881
4882 for (i = TXP_FIRST_CCK; i <= TXP_LAST_CCK; i++)
4883 pi->tx_srom_max_rate_2g[i] = txpwr;
4884
4885 for (i = TXP_FIRST_OFDM; i <= TXP_LAST_OFDM; i++) {
4886 pi->tx_srom_max_rate_2g[i] = txpwr -
4887 ((offset_ofdm & 0xf) * 2);
4888 offset_ofdm >>= 4;
4889 }
4890 offset_mcs =
4891 wlapi_getintvar(shim,
4892 BRCMS_SROM_MCS2GPO1) << 16;
4893 offset_mcs |=
4894 (u16) wlapi_getintvar(shim,
4895 BRCMS_SROM_MCS2GPO0);
4896 pi_lcn->lcnphy_mcs20_po = offset_mcs;
4897 for (i = TXP_FIRST_SISO_MCS_20;
4898 i <= TXP_LAST_SISO_MCS_20; i++) {
4899 pi->tx_srom_max_rate_2g[i] =
4900 txpwr - ((offset_mcs & 0xf) * 2);
4901 offset_mcs >>= 4;
4902 }
4903 }
4904
4905 pi_lcn->lcnphy_rawtempsense =
4906 (u16)wlapi_getintvar(shim, BRCMS_SROM_RAWTEMPSENSE);
4907 pi_lcn->lcnphy_measPower =
4908 (u8)wlapi_getintvar(shim, BRCMS_SROM_MEASPOWER);
4909 pi_lcn->lcnphy_tempsense_slope =
4910 (u8)wlapi_getintvar(shim, BRCMS_SROM_TEMPSENSE_SLOPE);
4911 pi_lcn->lcnphy_hw_iqcal_en =
4912 (bool)wlapi_getintvar(shim, BRCMS_SROM_HW_IQCAL_EN);
4913 pi_lcn->lcnphy_iqcal_swp_dis =
4914 (bool)wlapi_getintvar(shim, BRCMS_SROM_IQCAL_SWP_DIS);
4915 pi_lcn->lcnphy_tempcorrx =
4916 (u8)wlapi_getintvar(shim, BRCMS_SROM_TEMPCORRX);
4917 pi_lcn->lcnphy_tempsense_option =
4918 (u8)wlapi_getintvar(shim, BRCMS_SROM_TEMPSENSE_OPTION);
4919 pi_lcn->lcnphy_freqoffset_corr =
4920 (u8)wlapi_getintvar(shim, BRCMS_SROM_FREQOFFSET_CORR);
4921 if ((u8)wlapi_getintvar(shim, BRCMS_SROM_AA2G) > 1)
4922 wlc_phy_ant_rxdiv_set((struct brcms_phy_pub *) pi,
4923 (u8) wlapi_getintvar(shim, BRCMS_SROM_AA2G));
4924 }
4925 pi_lcn->lcnphy_cck_dig_filt_type = -1;
4926
4927 return true;
4928 }
4929
4930 void wlc_2064_vco_cal(struct brcms_phy *pi)
4931 {
4932 u8 calnrst;
4933
4934 mod_radio_reg(pi, RADIO_2064_REG057, 1 << 3, 1 << 3);
4935 calnrst = (u8) read_radio_reg(pi, RADIO_2064_REG056) & 0xf8;
4936 write_radio_reg(pi, RADIO_2064_REG056, calnrst);
4937 udelay(1);
4938 write_radio_reg(pi, RADIO_2064_REG056, calnrst | 0x03);
4939 udelay(1);
4940 write_radio_reg(pi, RADIO_2064_REG056, calnrst | 0x07);
4941 udelay(300);
4942 mod_radio_reg(pi, RADIO_2064_REG057, 1 << 3, 0);
4943 }
4944
4945 bool wlc_phy_tpc_isenabled_lcnphy(struct brcms_phy *pi)
4946 {
4947 if (wlc_lcnphy_tempsense_based_pwr_ctrl_enabled(pi))
4948 return 0;
4949 else
4950 return (LCNPHY_TX_PWR_CTRL_HW ==
4951 wlc_lcnphy_get_tx_pwr_ctrl((pi)));
4952 }
4953
4954 void wlc_phy_txpower_recalc_target_lcnphy(struct brcms_phy *pi)
4955 {
4956 u16 pwr_ctrl;
4957 if (wlc_lcnphy_tempsense_based_pwr_ctrl_enabled(pi)) {
4958 wlc_lcnphy_calib_modes(pi, LCNPHY_PERICAL_TEMPBASED_TXPWRCTRL);
4959 } else if (wlc_lcnphy_tssi_based_pwr_ctrl_enabled(pi)) {
4960 pwr_ctrl = wlc_lcnphy_get_tx_pwr_ctrl(pi);
4961 wlc_lcnphy_set_tx_pwr_ctrl(pi, LCNPHY_TX_PWR_CTRL_OFF);
4962 wlc_lcnphy_txpower_recalc_target(pi);
4963 wlc_lcnphy_set_tx_pwr_ctrl(pi, pwr_ctrl);
4964 }
4965 }
4966
4967 void wlc_phy_detach_lcnphy(struct brcms_phy *pi)
4968 {
4969 kfree(pi->u.pi_lcnphy);
4970 }
4971
4972 bool wlc_phy_attach_lcnphy(struct brcms_phy *pi)
4973 {
4974 struct brcms_phy_lcnphy *pi_lcn;
4975
4976 pi->u.pi_lcnphy = kzalloc(sizeof(struct brcms_phy_lcnphy), GFP_ATOMIC);
4977 if (pi->u.pi_lcnphy == NULL)
4978 return false;
4979
4980 pi_lcn = pi->u.pi_lcnphy;
4981
4982 if (0 == (pi->sh->boardflags & BFL_NOPA)) {
4983 pi->hwpwrctrl = true;
4984 pi->hwpwrctrl_capable = true;
4985 }
4986
4987 pi->xtalfreq = si_pmu_alp_clock(pi->sh->sih);
4988 pi_lcn->lcnphy_papd_rxGnCtrl_init = 0;
4989
4990 pi->pi_fptr.init = wlc_phy_init_lcnphy;
4991 pi->pi_fptr.calinit = wlc_phy_cal_init_lcnphy;
4992 pi->pi_fptr.chanset = wlc_phy_chanspec_set_lcnphy;
4993 pi->pi_fptr.txpwrrecalc = wlc_phy_txpower_recalc_target_lcnphy;
4994 pi->pi_fptr.txiqccget = wlc_lcnphy_get_tx_iqcc;
4995 pi->pi_fptr.txiqccset = wlc_lcnphy_set_tx_iqcc;
4996 pi->pi_fptr.txloccget = wlc_lcnphy_get_tx_locc;
4997 pi->pi_fptr.radioloftget = wlc_lcnphy_get_radio_loft;
4998 pi->pi_fptr.detach = wlc_phy_detach_lcnphy;
4999
5000 if (!wlc_phy_txpwr_srom_read_lcnphy(pi))
5001 return false;
5002
5003 if ((pi->sh->boardflags & BFL_FEM) &&
5004 (LCNREV_IS(pi->pubpi.phy_rev, 1))) {
5005 if (pi_lcn->lcnphy_tempsense_option == 3) {
5006 pi->hwpwrctrl = true;
5007 pi->hwpwrctrl_capable = true;
5008 pi->temppwrctrl_capable = false;
5009 } else {
5010 pi->hwpwrctrl = false;
5011 pi->hwpwrctrl_capable = false;
5012 pi->temppwrctrl_capable = true;
5013 }
5014 }
5015
5016 return true;
5017 }
5018
5019 static void wlc_lcnphy_set_rx_gain(struct brcms_phy *pi, u32 gain)
5020 {
5021 u16 trsw, ext_lna, lna1, lna2, tia, biq0, biq1, gain0_15, gain16_19;
5022
5023 trsw = (gain & ((u32) 1 << 28)) ? 0 : 1;
5024 ext_lna = (u16) (gain >> 29) & 0x01;
5025 lna1 = (u16) (gain >> 0) & 0x0f;
5026 lna2 = (u16) (gain >> 4) & 0x0f;
5027 tia = (u16) (gain >> 8) & 0xf;
5028 biq0 = (u16) (gain >> 12) & 0xf;
5029 biq1 = (u16) (gain >> 16) & 0xf;
5030
5031 gain0_15 = (u16) ((lna1 & 0x3) | ((lna1 & 0x3) << 2) |
5032 ((lna2 & 0x3) << 4) | ((lna2 & 0x3) << 6) |
5033 ((tia & 0xf) << 8) | ((biq0 & 0xf) << 12));
5034 gain16_19 = biq1;
5035
5036 mod_phy_reg(pi, 0x44d, (0x1 << 0), trsw << 0);
5037 mod_phy_reg(pi, 0x4b1, (0x1 << 9), ext_lna << 9);
5038 mod_phy_reg(pi, 0x4b1, (0x1 << 10), ext_lna << 10);
5039 mod_phy_reg(pi, 0x4b6, (0xffff << 0), gain0_15 << 0);
5040 mod_phy_reg(pi, 0x4b7, (0xf << 0), gain16_19 << 0);
5041
5042 if (CHSPEC_IS2G(pi->radio_chanspec)) {
5043 mod_phy_reg(pi, 0x4b1, (0x3 << 11), lna1 << 11);
5044 mod_phy_reg(pi, 0x4e6, (0x3 << 3), lna1 << 3);
5045 }
5046 wlc_lcnphy_rx_gain_override_enable(pi, true);
5047 }
5048
5049 static u32 wlc_lcnphy_get_receive_power(struct brcms_phy *pi, s32 *gain_index)
5050 {
5051 u32 received_power = 0;
5052 s32 max_index = 0;
5053 u32 gain_code = 0;
5054 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
5055
5056 max_index = 36;
5057 if (*gain_index >= 0)
5058 gain_code = lcnphy_23bitgaincode_table[*gain_index];
5059
5060 if (-1 == *gain_index) {
5061 *gain_index = 0;
5062 while ((*gain_index <= (s32) max_index)
5063 && (received_power < 700)) {
5064 wlc_lcnphy_set_rx_gain(pi,
5065 lcnphy_23bitgaincode_table
5066 [*gain_index]);
5067 received_power =
5068 wlc_lcnphy_measure_digital_power(
5069 pi,
5070 pi_lcn->
5071 lcnphy_noise_samples);
5072 (*gain_index)++;
5073 }
5074 (*gain_index)--;
5075 } else {
5076 wlc_lcnphy_set_rx_gain(pi, gain_code);
5077 received_power =
5078 wlc_lcnphy_measure_digital_power(pi,
5079 pi_lcn->
5080 lcnphy_noise_samples);
5081 }
5082
5083 return received_power;
5084 }
5085
5086 s32 wlc_lcnphy_rx_signal_power(struct brcms_phy *pi, s32 gain_index)
5087 {
5088 s32 gain = 0;
5089 s32 nominal_power_db;
5090 s32 log_val, gain_mismatch, desired_gain, input_power_offset_db,
5091 input_power_db;
5092 s32 received_power, temperature;
5093 u32 power;
5094 u32 msb1, msb2, val1, val2, diff1, diff2;
5095 uint freq;
5096 struct brcms_phy_lcnphy *pi_lcn = pi->u.pi_lcnphy;
5097
5098 received_power = wlc_lcnphy_get_receive_power(pi, &gain_index);
5099
5100 gain = lcnphy_gain_table[gain_index];
5101
5102 nominal_power_db = read_phy_reg(pi, 0x425) >> 8;
5103
5104 power = (received_power * 16);
5105 msb1 = ffs(power) - 1;
5106 msb2 = msb1 + 1;
5107 val1 = 1 << msb1;
5108 val2 = 1 << msb2;
5109 diff1 = (power - val1);
5110 diff2 = (val2 - power);
5111 if (diff1 < diff2)
5112 log_val = msb1;
5113 else
5114 log_val = msb2;
5115
5116 log_val = log_val * 3;
5117
5118 gain_mismatch = (nominal_power_db / 2) - (log_val);
5119
5120 desired_gain = gain + gain_mismatch;
5121
5122 input_power_offset_db = read_phy_reg(pi, 0x434) & 0xFF;
5123
5124 if (input_power_offset_db > 127)
5125 input_power_offset_db -= 256;
5126
5127 input_power_db = input_power_offset_db - desired_gain;
5128
5129 input_power_db =
5130 input_power_db + lcnphy_gain_index_offset_for_rssi[gain_index];
5131
5132 freq = wlc_phy_channel2freq(CHSPEC_CHANNEL(pi->radio_chanspec));
5133 if ((freq > 2427) && (freq <= 2467))
5134 input_power_db = input_power_db - 1;
5135
5136 temperature = pi_lcn->lcnphy_lastsensed_temperature;
5137
5138 if ((temperature - 15) < -30)
5139 input_power_db =
5140 input_power_db +
5141 (((temperature - 10 - 25) * 286) >> 12) -
5142 7;
5143 else if ((temperature - 15) < 4)
5144 input_power_db =
5145 input_power_db +
5146 (((temperature - 10 - 25) * 286) >> 12) -
5147 3;
5148 else
5149 input_power_db = input_power_db +
5150 (((temperature - 10 - 25) * 286) >> 12);
5151
5152 wlc_lcnphy_rx_gain_override_enable(pi, 0);
5153
5154 return input_power_db;
5155 }
Linux kernel - Deliverables
This page took 0.221916 seconds and 5 git commands to generate.