]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - drivers/net/wireless/mediatek/mt7601u/phy.c
projects / mirror_ubuntu-jammy-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
timekeeping: Repair ktime_get_coarse*() granularity
[mirror_ubuntu-jammy-kernel.git] / drivers / net / wireless / mediatek / mt7601u / phy.c
1 /*
2 * (c) Copyright 2002-2010, Ralink Technology, Inc.
3 * Copyright (C) 2014 Felix Fietkau <nbd@openwrt.org>
4 * Copyright (C) 2015 Jakub Kicinski <kubakici@wp.pl>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2
8 * as published by the Free Software Foundation
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 */
15
16 #include "mt7601u.h"
17 #include "mcu.h"
18 #include "eeprom.h"
19 #include "trace.h"
20 #include "initvals_phy.h"
21
22 #include <linux/etherdevice.h>
23
24 static void mt7601u_agc_reset(struct mt7601u_dev *dev);
25
26 static int
27 mt7601u_rf_wr(struct mt7601u_dev *dev, u8 bank, u8 offset, u8 value)
28 {
29 int ret = 0;
30
31 if (WARN_ON(!test_bit(MT7601U_STATE_WLAN_RUNNING, &dev->state)) ||
32 WARN_ON(offset > 63))
33 return -EINVAL;
34 if (test_bit(MT7601U_STATE_REMOVED, &dev->state))
35 return 0;
36
37 mutex_lock(&dev->reg_atomic_mutex);
38
39 if (!mt76_poll(dev, MT_RF_CSR_CFG, MT_RF_CSR_CFG_KICK, 0, 100)) {
40 ret = -ETIMEDOUT;
41 goto out;
42 }
43
44 mt7601u_wr(dev, MT_RF_CSR_CFG,
45 FIELD_PREP(MT_RF_CSR_CFG_DATA, value) |
46 FIELD_PREP(MT_RF_CSR_CFG_REG_BANK, bank) |
47 FIELD_PREP(MT_RF_CSR_CFG_REG_ID, offset) |
48 MT_RF_CSR_CFG_WR |
49 MT_RF_CSR_CFG_KICK);
50 trace_rf_write(dev, bank, offset, value);
51 out:
52 mutex_unlock(&dev->reg_atomic_mutex);
53
54 if (ret < 0)
55 dev_err(dev->dev, "Error: RF write %02hhx:%02hhx failed:%d!!\n",
56 bank, offset, ret);
57
58 return ret;
59 }
60
61 static int
62 mt7601u_rf_rr(struct mt7601u_dev *dev, u8 bank, u8 offset)
63 {
64 int ret = -ETIMEDOUT;
65 u32 val;
66
67 if (WARN_ON(!test_bit(MT7601U_STATE_WLAN_RUNNING, &dev->state)) ||
68 WARN_ON(offset > 63))
69 return -EINVAL;
70 if (test_bit(MT7601U_STATE_REMOVED, &dev->state))
71 return 0xff;
72
73 mutex_lock(&dev->reg_atomic_mutex);
74
75 if (!mt76_poll(dev, MT_RF_CSR_CFG, MT_RF_CSR_CFG_KICK, 0, 100))
76 goto out;
77
78 mt7601u_wr(dev, MT_RF_CSR_CFG,
79 FIELD_PREP(MT_RF_CSR_CFG_REG_BANK, bank) |
80 FIELD_PREP(MT_RF_CSR_CFG_REG_ID, offset) |
81 MT_RF_CSR_CFG_KICK);
82
83 if (!mt76_poll(dev, MT_RF_CSR_CFG, MT_RF_CSR_CFG_KICK, 0, 100))
84 goto out;
85
86 val = mt7601u_rr(dev, MT_RF_CSR_CFG);
87 if (FIELD_GET(MT_RF_CSR_CFG_REG_ID, val) == offset &&
88 FIELD_GET(MT_RF_CSR_CFG_REG_BANK, val) == bank) {
89 ret = FIELD_GET(MT_RF_CSR_CFG_DATA, val);
90 trace_rf_read(dev, bank, offset, ret);
91 }
92 out:
93 mutex_unlock(&dev->reg_atomic_mutex);
94
95 if (ret < 0)
96 dev_err(dev->dev, "Error: RF read %02hhx:%02hhx failed:%d!!\n",
97 bank, offset, ret);
98
99 return ret;
100 }
101
102 static int
103 mt7601u_rf_rmw(struct mt7601u_dev *dev, u8 bank, u8 offset, u8 mask, u8 val)
104 {
105 int ret;
106
107 ret = mt7601u_rf_rr(dev, bank, offset);
108 if (ret < 0)
109 return ret;
110 val |= ret & ~mask;
111 ret = mt7601u_rf_wr(dev, bank, offset, val);
112 if (ret)
113 return ret;
114
115 return val;
116 }
117
118 static int
119 mt7601u_rf_set(struct mt7601u_dev *dev, u8 bank, u8 offset, u8 val)
120 {
121 return mt7601u_rf_rmw(dev, bank, offset, 0, val);
122 }
123
124 static int
125 mt7601u_rf_clear(struct mt7601u_dev *dev, u8 bank, u8 offset, u8 mask)
126 {
127 return mt7601u_rf_rmw(dev, bank, offset, mask, 0);
128 }
129
130 static void mt7601u_bbp_wr(struct mt7601u_dev *dev, u8 offset, u8 val)
131 {
132 if (WARN_ON(!test_bit(MT7601U_STATE_WLAN_RUNNING, &dev->state)) ||
133 test_bit(MT7601U_STATE_REMOVED, &dev->state))
134 return;
135
136 mutex_lock(&dev->reg_atomic_mutex);
137
138 if (!mt76_poll(dev, MT_BBP_CSR_CFG, MT_BBP_CSR_CFG_BUSY, 0, 1000)) {
139 dev_err(dev->dev, "Error: BBP write %02hhx failed!!\n", offset);
140 goto out;
141 }
142
143 mt7601u_wr(dev, MT_BBP_CSR_CFG,
144 FIELD_PREP(MT_BBP_CSR_CFG_VAL, val) |
145 FIELD_PREP(MT_BBP_CSR_CFG_REG_NUM, offset) |
146 MT_BBP_CSR_CFG_RW_MODE | MT_BBP_CSR_CFG_BUSY);
147 trace_bbp_write(dev, offset, val);
148 out:
149 mutex_unlock(&dev->reg_atomic_mutex);
150 }
151
152 static int mt7601u_bbp_rr(struct mt7601u_dev *dev, u8 offset)
153 {
154 u32 val;
155 int ret = -ETIMEDOUT;
156
157 if (WARN_ON(!test_bit(MT7601U_STATE_WLAN_RUNNING, &dev->state)))
158 return -EINVAL;
159 if (test_bit(MT7601U_STATE_REMOVED, &dev->state))
160 return 0xff;
161
162 mutex_lock(&dev->reg_atomic_mutex);
163
164 if (!mt76_poll(dev, MT_BBP_CSR_CFG, MT_BBP_CSR_CFG_BUSY, 0, 1000))
165 goto out;
166
167 mt7601u_wr(dev, MT_BBP_CSR_CFG,
168 FIELD_PREP(MT_BBP_CSR_CFG_REG_NUM, offset) |
169 MT_BBP_CSR_CFG_RW_MODE | MT_BBP_CSR_CFG_BUSY |
170 MT_BBP_CSR_CFG_READ);
171
172 if (!mt76_poll(dev, MT_BBP_CSR_CFG, MT_BBP_CSR_CFG_BUSY, 0, 1000))
173 goto out;
174
175 val = mt7601u_rr(dev, MT_BBP_CSR_CFG);
176 if (FIELD_GET(MT_BBP_CSR_CFG_REG_NUM, val) == offset) {
177 ret = FIELD_GET(MT_BBP_CSR_CFG_VAL, val);
178 trace_bbp_read(dev, offset, ret);
179 }
180 out:
181 mutex_unlock(&dev->reg_atomic_mutex);
182
183 if (ret < 0)
184 dev_err(dev->dev, "Error: BBP read %02hhx failed:%d!!\n",
185 offset, ret);
186
187 return ret;
188 }
189
190 static int mt7601u_bbp_rmw(struct mt7601u_dev *dev, u8 offset, u8 mask, u8 val)
191 {
192 int ret;
193
194 ret = mt7601u_bbp_rr(dev, offset);
195 if (ret < 0)
196 return ret;
197 val |= ret & ~mask;
198 mt7601u_bbp_wr(dev, offset, val);
199
200 return val;
201 }
202
203 static u8 mt7601u_bbp_rmc(struct mt7601u_dev *dev, u8 offset, u8 mask, u8 val)
204 {
205 int ret;
206
207 ret = mt7601u_bbp_rr(dev, offset);
208 if (ret < 0)
209 return ret;
210 val |= ret & ~mask;
211 if (ret != val)
212 mt7601u_bbp_wr(dev, offset, val);
213
214 return val;
215 }
216
217 int mt7601u_wait_bbp_ready(struct mt7601u_dev *dev)
218 {
219 int i = 20;
220 u8 val;
221
222 do {
223 val = mt7601u_bbp_rr(dev, MT_BBP_REG_VERSION);
224 if (val && ~val)
225 break;
226 } while (--i);
227
228 if (!i) {
229 dev_err(dev->dev, "Error: BBP is not ready\n");
230 return -EIO;
231 }
232
233 return 0;
234 }
235
236 u32 mt7601u_bbp_set_ctrlch(struct mt7601u_dev *dev, bool below)
237 {
238 return mt7601u_bbp_rmc(dev, 3, 0x20, below ? 0x20 : 0);
239 }
240
241 int mt7601u_phy_get_rssi(struct mt7601u_dev *dev,
242 struct mt7601u_rxwi *rxwi, u16 rate)
243 {
244 static const s8 lna[2][2][3] = {
245 /* main LNA */ {
246 /* bw20 */ { -2, 15, 33 },
247 /* bw40 */ { 0, 16, 34 }
248 },
249 /* aux LNA */ {
250 /* bw20 */ { -2, 15, 33 },
251 /* bw40 */ { -2, 16, 34 }
252 }
253 };
254 int bw = FIELD_GET(MT_RXWI_RATE_BW, rate);
255 int aux_lna = FIELD_GET(MT_RXWI_ANT_AUX_LNA, rxwi->ant);
256 int lna_id = FIELD_GET(MT_RXWI_GAIN_RSSI_LNA_ID, rxwi->gain);
257 int val;
258
259 if (lna_id) /* LNA id can be 0, 2, 3. */
260 lna_id--;
261
262 val = 8;
263 val -= lna[aux_lna][bw][lna_id];
264 val -= FIELD_GET(MT_RXWI_GAIN_RSSI_VAL, rxwi->gain);
265 val -= dev->ee->lna_gain;
266 val -= dev->ee->rssi_offset[0];
267
268 return val;
269 }
270
271 static void mt7601u_vco_cal(struct mt7601u_dev *dev)
272 {
273 mt7601u_rf_wr(dev, 0, 4, 0x0a);
274 mt7601u_rf_wr(dev, 0, 5, 0x20);
275 mt7601u_rf_set(dev, 0, 4, BIT(7));
276 msleep(2);
277 }
278
279 static int mt7601u_set_bw_filter(struct mt7601u_dev *dev, bool cal)
280 {
281 u32 filter = 0;
282 int ret;
283
284 if (!cal)
285 filter |= 0x10000;
286 if (dev->bw != MT_BW_20)
287 filter |= 0x00100;
288
289 /* TX */
290 ret = mt7601u_mcu_calibrate(dev, MCU_CAL_BW, filter | 1);
291 if (ret)
292 return ret;
293 /* RX */
294 return mt7601u_mcu_calibrate(dev, MCU_CAL_BW, filter);
295 }
296
297 static int mt7601u_load_bbp_temp_table_bw(struct mt7601u_dev *dev)
298 {
299 const struct reg_table *t;
300
301 if (WARN_ON(dev->temp_mode > MT_TEMP_MODE_LOW))
302 return -EINVAL;
303
304 t = &bbp_mode_table[dev->temp_mode][dev->bw];
305
306 return mt7601u_write_reg_pairs(dev, MT_MCU_MEMMAP_BBP, t->regs, t->n);
307 }
308
309 static int mt7601u_bbp_temp(struct mt7601u_dev *dev, int mode, const char *name)
310 {
311 const struct reg_table *t;
312 int ret;
313
314 if (dev->temp_mode == mode)
315 return 0;
316
317 dev->temp_mode = mode;
318 trace_temp_mode(dev, mode);
319
320 t = bbp_mode_table[dev->temp_mode];
321 ret = mt7601u_write_reg_pairs(dev, MT_MCU_MEMMAP_BBP,
322 t[2].regs, t[2].n);
323 if (ret)
324 return ret;
325
326 return mt7601u_write_reg_pairs(dev, MT_MCU_MEMMAP_BBP,
327 t[dev->bw].regs, t[dev->bw].n);
328 }
329
330 static void mt7601u_apply_ch14_fixup(struct mt7601u_dev *dev, int hw_chan)
331 {
332 struct mt7601u_rate_power *t = &dev->ee->power_rate_table;
333
334 if (hw_chan != 14 || dev->bw != MT_BW_20) {
335 mt7601u_bbp_rmw(dev, 4, 0x20, 0);
336 mt7601u_bbp_wr(dev, 178, 0xff);
337
338 t->cck[0].bw20 = dev->ee->real_cck_bw20[0];
339 t->cck[1].bw20 = dev->ee->real_cck_bw20[1];
340 } else { /* Apply CH14 OBW fixup */
341 mt7601u_bbp_wr(dev, 4, 0x60);
342 mt7601u_bbp_wr(dev, 178, 0);
343
344 /* Note: vendor code is buggy here for negative values */
345 t->cck[0].bw20 = dev->ee->real_cck_bw20[0] - 2;
346 t->cck[1].bw20 = dev->ee->real_cck_bw20[1] - 2;
347 }
348 }
349
350 static int __mt7601u_phy_set_channel(struct mt7601u_dev *dev,
351 struct cfg80211_chan_def *chandef)
352 {
353 #define FREQ_PLAN_REGS 4
354 static const u8 freq_plan[14][FREQ_PLAN_REGS] = {
355 { 0x99, 0x99, 0x09, 0x50 },
356 { 0x46, 0x44, 0x0a, 0x50 },
357 { 0xec, 0xee, 0x0a, 0x50 },
358 { 0x99, 0x99, 0x0b, 0x50 },
359 { 0x46, 0x44, 0x08, 0x51 },
360 { 0xec, 0xee, 0x08, 0x51 },
361 { 0x99, 0x99, 0x09, 0x51 },
362 { 0x46, 0x44, 0x0a, 0x51 },
363 { 0xec, 0xee, 0x0a, 0x51 },
364 { 0x99, 0x99, 0x0b, 0x51 },
365 { 0x46, 0x44, 0x08, 0x52 },
366 { 0xec, 0xee, 0x08, 0x52 },
367 { 0x99, 0x99, 0x09, 0x52 },
368 { 0x33, 0x33, 0x0b, 0x52 },
369 };
370 struct mt76_reg_pair channel_freq_plan[FREQ_PLAN_REGS] = {
371 { 17, 0 }, { 18, 0 }, { 19, 0 }, { 20, 0 },
372 };
373 struct mt76_reg_pair bbp_settings[3] = {
374 { 62, 0x37 - dev->ee->lna_gain },
375 { 63, 0x37 - dev->ee->lna_gain },
376 { 64, 0x37 - dev->ee->lna_gain },
377 };
378
379 struct ieee80211_channel *chan = chandef->chan;
380 enum nl80211_channel_type chan_type =
381 cfg80211_get_chandef_type(chandef);
382 struct mt7601u_rate_power *t = &dev->ee->power_rate_table;
383 int chan_idx;
384 bool chan_ext_below;
385 u8 bw;
386 int i, ret;
387
388 bw = MT_BW_20;
389 chan_ext_below = (chan_type == NL80211_CHAN_HT40MINUS);
390 chan_idx = chan->hw_value - 1;
391
392 if (chandef->width == NL80211_CHAN_WIDTH_40) {
393 bw = MT_BW_40;
394
395 if (chan_idx > 1 && chan_type == NL80211_CHAN_HT40MINUS)
396 chan_idx -= 2;
397 else if (chan_idx < 12 && chan_type == NL80211_CHAN_HT40PLUS)
398 chan_idx += 2;
399 else
400 dev_err(dev->dev, "Error: invalid 40MHz channel!!\n");
401 }
402
403 if (bw != dev->bw || chan_ext_below != dev->chan_ext_below) {
404 dev_dbg(dev->dev, "Info: switching HT mode bw:%d below:%d\n",
405 bw, chan_ext_below);
406
407 mt7601u_bbp_set_bw(dev, bw);
408
409 mt7601u_bbp_set_ctrlch(dev, chan_ext_below);
410 mt7601u_mac_set_ctrlch(dev, chan_ext_below);
411 dev->chan_ext_below = chan_ext_below;
412 }
413
414 for (i = 0; i < FREQ_PLAN_REGS; i++)
415 channel_freq_plan[i].value = freq_plan[chan_idx][i];
416
417 ret = mt7601u_write_reg_pairs(dev, MT_MCU_MEMMAP_RF,
418 channel_freq_plan, FREQ_PLAN_REGS);
419 if (ret)
420 return ret;
421
422 mt7601u_rmw(dev, MT_TX_ALC_CFG_0, 0x3f3f,
423 dev->ee->chan_pwr[chan_idx] & 0x3f);
424
425 ret = mt7601u_write_reg_pairs(dev, MT_MCU_MEMMAP_BBP,
426 bbp_settings, ARRAY_SIZE(bbp_settings));
427 if (ret)
428 return ret;
429
430 mt7601u_vco_cal(dev);
431 mt7601u_bbp_set_bw(dev, bw);
432 ret = mt7601u_set_bw_filter(dev, false);
433 if (ret)
434 return ret;
435
436 mt7601u_apply_ch14_fixup(dev, chan->hw_value);
437 mt7601u_wr(dev, MT_TX_PWR_CFG_0, int_to_s6(t->ofdm[1].bw20) << 24 |
438 int_to_s6(t->ofdm[0].bw20) << 16 |
439 int_to_s6(t->cck[1].bw20) << 8 |
440 int_to_s6(t->cck[0].bw20));
441
442 if (test_bit(MT7601U_STATE_SCANNING, &dev->state))
443 mt7601u_agc_reset(dev);
444
445 dev->chandef = *chandef;
446
447 return 0;
448 }
449
450 int mt7601u_phy_set_channel(struct mt7601u_dev *dev,
451 struct cfg80211_chan_def *chandef)
452 {
453 int ret;
454
455 cancel_delayed_work_sync(&dev->cal_work);
456 cancel_delayed_work_sync(&dev->freq_cal.work);
457
458 mutex_lock(&dev->hw_atomic_mutex);
459 ret = __mt7601u_phy_set_channel(dev, chandef);
460 mutex_unlock(&dev->hw_atomic_mutex);
461 if (ret)
462 return ret;
463
464 if (test_bit(MT7601U_STATE_SCANNING, &dev->state))
465 return 0;
466
467 ieee80211_queue_delayed_work(dev->hw, &dev->cal_work,
468 MT_CALIBRATE_INTERVAL);
469 if (dev->freq_cal.enabled)
470 ieee80211_queue_delayed_work(dev->hw, &dev->freq_cal.work,
471 MT_FREQ_CAL_INIT_DELAY);
472 return 0;
473 }
474
475 #define BBP_R47_FLAG GENMASK(2, 0)
476 #define BBP_R47_F_TSSI 0
477 #define BBP_R47_F_PKT_T 1
478 #define BBP_R47_F_TX_RATE 2
479 #define BBP_R47_F_TEMP 4
480 /**
481 * mt7601u_bbp_r47_get - read value through BBP R47/R49 pair
482 * @dev: pointer to adapter structure
483 * @reg: value of BBP R47 before the operation
484 * @flag: one of the BBP_R47_F_* flags
485 *
486 * Convenience helper for reading values through BBP R47/R49 pair.
487 * Takes old value of BBP R47 as @reg, because callers usually have it
488 * cached already.
489 *
490 * Return: value of BBP R49.
491 */
492 static u8 mt7601u_bbp_r47_get(struct mt7601u_dev *dev, u8 reg, u8 flag)
493 {
494 flag |= reg & ~BBP_R47_FLAG;
495 mt7601u_bbp_wr(dev, 47, flag);
496 usleep_range(500, 700);
497 return mt7601u_bbp_rr(dev, 49);
498 }
499
500 static s8 mt7601u_read_bootup_temp(struct mt7601u_dev *dev)
501 {
502 u8 bbp_val, temp;
503 u32 rf_bp, rf_set;
504 int i;
505
506 rf_set = mt7601u_rr(dev, MT_RF_SETTING_0);
507 rf_bp = mt7601u_rr(dev, MT_RF_BYPASS_0);
508
509 mt7601u_wr(dev, MT_RF_BYPASS_0, 0);
510 mt7601u_wr(dev, MT_RF_SETTING_0, 0x00000010);
511 mt7601u_wr(dev, MT_RF_BYPASS_0, 0x00000010);
512
513 bbp_val = mt7601u_bbp_rmw(dev, 47, 0, 0x10);
514
515 mt7601u_bbp_wr(dev, 22, 0x40);
516
517 for (i = 100; i && (bbp_val & 0x10); i--)
518 bbp_val = mt7601u_bbp_rr(dev, 47);
519
520 temp = mt7601u_bbp_r47_get(dev, bbp_val, BBP_R47_F_TEMP);
521
522 mt7601u_bbp_wr(dev, 22, 0);
523
524 bbp_val = mt7601u_bbp_rr(dev, 21);
525 bbp_val |= 0x02;
526 mt7601u_bbp_wr(dev, 21, bbp_val);
527 bbp_val &= ~0x02;
528 mt7601u_bbp_wr(dev, 21, bbp_val);
529
530 mt7601u_wr(dev, MT_RF_BYPASS_0, 0);
531 mt7601u_wr(dev, MT_RF_SETTING_0, rf_set);
532 mt7601u_wr(dev, MT_RF_BYPASS_0, rf_bp);
533
534 trace_read_temp(dev, temp);
535 return temp;
536 }
537
538 static s8 mt7601u_read_temp(struct mt7601u_dev *dev)
539 {
540 int i;
541 u8 val;
542 s8 temp;
543
544 val = mt7601u_bbp_rmw(dev, 47, 0x7f, 0x10);
545
546 /* Note: this rarely succeeds, temp can change even if it fails. */
547 for (i = 100; i && (val & 0x10); i--)
548 val = mt7601u_bbp_rr(dev, 47);
549
550 temp = mt7601u_bbp_r47_get(dev, val, BBP_R47_F_TEMP);
551
552 trace_read_temp(dev, temp);
553 return temp;
554 }
555
556 static void mt7601u_rxdc_cal(struct mt7601u_dev *dev)
557 {
558 static const struct mt76_reg_pair intro[] = {
559 { 158, 0x8d }, { 159, 0xfc },
560 { 158, 0x8c }, { 159, 0x4c },
561 }, outro[] = {
562 { 158, 0x8d }, { 159, 0xe0 },
563 };
564 u32 mac_ctrl;
565 int i, ret;
566
567 mac_ctrl = mt7601u_rr(dev, MT_MAC_SYS_CTRL);
568 mt7601u_wr(dev, MT_MAC_SYS_CTRL, MT_MAC_SYS_CTRL_ENABLE_RX);
569
570 ret = mt7601u_write_reg_pairs(dev, MT_MCU_MEMMAP_BBP,
571 intro, ARRAY_SIZE(intro));
572 if (ret)
573 dev_err(dev->dev, "%s intro failed:%d\n", __func__, ret);
574
575 for (i = 20; i; i--) {
576 usleep_range(300, 500);
577
578 mt7601u_bbp_wr(dev, 158, 0x8c);
579 if (mt7601u_bbp_rr(dev, 159) == 0x0c)
580 break;
581 }
582 if (!i)
583 dev_err(dev->dev, "%s timed out\n", __func__);
584
585 mt7601u_wr(dev, MT_MAC_SYS_CTRL, 0);
586
587 ret = mt7601u_write_reg_pairs(dev, MT_MCU_MEMMAP_BBP,
588 outro, ARRAY_SIZE(outro));
589 if (ret)
590 dev_err(dev->dev, "%s outro failed:%d\n", __func__, ret);
591
592 mt7601u_wr(dev, MT_MAC_SYS_CTRL, mac_ctrl);
593 }
594
595 void mt7601u_phy_recalibrate_after_assoc(struct mt7601u_dev *dev)
596 {
597 mt7601u_mcu_calibrate(dev, MCU_CAL_DPD, dev->curr_temp);
598
599 mt7601u_rxdc_cal(dev);
600 }
601
602 /* Note: function copied from vendor driver */
603 static s16 lin2dBd(u16 linear)
604 {
605 short exp = 0;
606 unsigned int mantisa;
607 int app, dBd;
608
609 if (WARN_ON(!linear))
610 return -10000;
611
612 mantisa = linear;
613
614 exp = fls(mantisa) - 16;
615 if (exp > 0)
616 mantisa >>= exp;
617 else
618 mantisa <<= abs(exp);
619
620 if (mantisa <= 0xb800)
621 app = (mantisa + (mantisa >> 3) + (mantisa >> 4) - 0x9600);
622 else
623 app = (mantisa - (mantisa >> 3) - (mantisa >> 6) - 0x5a00);
624 if (app < 0)
625 app = 0;
626
627 dBd = ((15 + exp) << 15) + app;
628 dBd = (dBd << 2) + (dBd << 1) + (dBd >> 6) + (dBd >> 7);
629 dBd = (dBd >> 10);
630
631 return dBd;
632 }
633
634 static void
635 mt7601u_set_initial_tssi(struct mt7601u_dev *dev, s16 tssi_db, s16 tssi_hvga_db)
636 {
637 struct tssi_data *d = &dev->ee->tssi_data;
638 int init_offset;
639
640 init_offset = -((tssi_db * d->slope + d->offset[1]) / 4096) + 10;
641
642 mt76_rmw(dev, MT_TX_ALC_CFG_1, MT_TX_ALC_CFG_1_TEMP_COMP,
643 int_to_s6(init_offset) & MT_TX_ALC_CFG_1_TEMP_COMP);
644 }
645
646 static void mt7601u_tssi_dc_gain_cal(struct mt7601u_dev *dev)
647 {
648 u8 rf_vga, rf_mixer, bbp_r47;
649 int i, j;
650 s8 res[4];
651 s16 tssi_init_db, tssi_init_hvga_db;
652
653 mt7601u_wr(dev, MT_RF_SETTING_0, 0x00000030);
654 mt7601u_wr(dev, MT_RF_BYPASS_0, 0x000c0030);
655 mt7601u_wr(dev, MT_MAC_SYS_CTRL, 0);
656
657 mt7601u_bbp_wr(dev, 58, 0);
658 mt7601u_bbp_wr(dev, 241, 0x2);
659 mt7601u_bbp_wr(dev, 23, 0x8);
660 bbp_r47 = mt7601u_bbp_rr(dev, 47);
661
662 /* Set VGA gain */
663 rf_vga = mt7601u_rf_rr(dev, 5, 3);
664 mt7601u_rf_wr(dev, 5, 3, 8);
665
666 /* Mixer disable */
667 rf_mixer = mt7601u_rf_rr(dev, 4, 39);
668 mt7601u_rf_wr(dev, 4, 39, 0);
669
670 for (i = 0; i < 4; i++) {
671 mt7601u_rf_wr(dev, 4, 39, (i & 1) ? rf_mixer : 0);
672
673 mt7601u_bbp_wr(dev, 23, (i < 2) ? 0x08 : 0x02);
674 mt7601u_rf_wr(dev, 5, 3, (i < 2) ? 0x08 : 0x11);
675
676 /* BBP TSSI initial and soft reset */
677 mt7601u_bbp_wr(dev, 22, 0);
678 mt7601u_bbp_wr(dev, 244, 0);
679
680 mt7601u_bbp_wr(dev, 21, 1);
681 udelay(1);
682 mt7601u_bbp_wr(dev, 21, 0);
683
684 /* TSSI measurement */
685 mt7601u_bbp_wr(dev, 47, 0x50);
686 mt7601u_bbp_wr(dev, (i & 1) ? 244 : 22, (i & 1) ? 0x31 : 0x40);
687
688 for (j = 20; j; j--)
689 if (!(mt7601u_bbp_rr(dev, 47) & 0x10))
690 break;
691 if (!j)
692 dev_err(dev->dev, "%s timed out\n", __func__);
693
694 /* TSSI read */
695 mt7601u_bbp_wr(dev, 47, 0x40);
696 res[i] = mt7601u_bbp_rr(dev, 49);
697 }
698
699 tssi_init_db = lin2dBd((short)res[1] - res[0]);
700 tssi_init_hvga_db = lin2dBd(((short)res[3] - res[2]) * 4);
701 dev->tssi_init = res[0];
702 dev->tssi_init_hvga = res[2];
703 dev->tssi_init_hvga_offset_db = tssi_init_hvga_db - tssi_init_db;
704
705 dev_dbg(dev->dev,
706 "TSSI_init:%hhx db:%hx hvga:%hhx hvga_db:%hx off_db:%hx\n",
707 dev->tssi_init, tssi_init_db, dev->tssi_init_hvga,
708 tssi_init_hvga_db, dev->tssi_init_hvga_offset_db);
709
710 mt7601u_bbp_wr(dev, 22, 0);
711 mt7601u_bbp_wr(dev, 244, 0);
712
713 mt7601u_bbp_wr(dev, 21, 1);
714 udelay(1);
715 mt7601u_bbp_wr(dev, 21, 0);
716
717 mt7601u_wr(dev, MT_RF_BYPASS_0, 0);
718 mt7601u_wr(dev, MT_RF_SETTING_0, 0);
719
720 mt7601u_rf_wr(dev, 5, 3, rf_vga);
721 mt7601u_rf_wr(dev, 4, 39, rf_mixer);
722 mt7601u_bbp_wr(dev, 47, bbp_r47);
723
724 mt7601u_set_initial_tssi(dev, tssi_init_db, tssi_init_hvga_db);
725 }
726
727 static int mt7601u_temp_comp(struct mt7601u_dev *dev, bool on)
728 {
729 int ret, temp, hi_temp = 400, lo_temp = -200;
730
731 temp = (dev->raw_temp - dev->ee->ref_temp) * MT_EE_TEMPERATURE_SLOPE;
732 dev->curr_temp = temp;
733
734 /* DPD Calibration */
735 if (temp - dev->dpd_temp > 450 || temp - dev->dpd_temp < -450) {
736 dev->dpd_temp = temp;
737
738 ret = mt7601u_mcu_calibrate(dev, MCU_CAL_DPD, dev->dpd_temp);
739 if (ret)
740 return ret;
741
742 mt7601u_vco_cal(dev);
743
744 dev_dbg(dev->dev, "Recalibrate DPD\n");
745 }
746
747 /* PLL Lock Protect */
748 if (temp < -50 && !dev->pll_lock_protect) { /* < 20C */
749 dev->pll_lock_protect = true;
750
751 mt7601u_rf_wr(dev, 4, 4, 6);
752 mt7601u_rf_clear(dev, 4, 10, 0x30);
753
754 dev_dbg(dev->dev, "PLL lock protect on - too cold\n");
755 } else if (temp > 50 && dev->pll_lock_protect) { /* > 30C */
756 dev->pll_lock_protect = false;
757
758 mt7601u_rf_wr(dev, 4, 4, 0);
759 mt7601u_rf_rmw(dev, 4, 10, 0x30, 0x10);
760
761 dev_dbg(dev->dev, "PLL lock protect off\n");
762 }
763
764 if (on) {
765 hi_temp -= 50;
766 lo_temp -= 50;
767 }
768
769 /* BBP CR for H, L, N temperature */
770 if (temp > hi_temp)
771 return mt7601u_bbp_temp(dev, MT_TEMP_MODE_HIGH, "high");
772 else if (temp > lo_temp)
773 return mt7601u_bbp_temp(dev, MT_TEMP_MODE_NORMAL, "normal");
774 else
775 return mt7601u_bbp_temp(dev, MT_TEMP_MODE_LOW, "low");
776 }
777
778 /* Note: this is used only with TSSI, we can just use trgt_pwr from eeprom. */
779 static int mt7601u_current_tx_power(struct mt7601u_dev *dev)
780 {
781 return dev->ee->chan_pwr[dev->chandef.chan->hw_value - 1];
782 }
783
784 static bool mt7601u_use_hvga(struct mt7601u_dev *dev)
785 {
786 return !(mt7601u_current_tx_power(dev) > 20);
787 }
788
789 static s16
790 mt7601u_phy_rf_pa_mode_val(struct mt7601u_dev *dev, int phy_mode, int tx_rate)
791 {
792 static const s16 decode_tb[] = { 0, 8847, -5734, -5734 };
793 u32 reg;
794
795 switch (phy_mode) {
796 case MT_PHY_TYPE_OFDM:
797 tx_rate += 4;
798 /* fall through */
799 case MT_PHY_TYPE_CCK:
800 reg = dev->rf_pa_mode[0];
801 break;
802 default:
803 reg = dev->rf_pa_mode[1];
804 break;
805 }
806
807 return decode_tb[(reg >> (tx_rate * 2)) & 0x3];
808 }
809
810 static struct mt7601u_tssi_params
811 mt7601u_tssi_params_get(struct mt7601u_dev *dev)
812 {
813 static const u8 ofdm_pkt2rate[8] = { 6, 4, 2, 0, 7, 5, 3, 1 };
814 static const int static_power[4] = { 0, -49152, -98304, 49152 };
815 struct mt7601u_tssi_params p;
816 u8 bbp_r47, pkt_type, tx_rate;
817 struct power_per_rate *rate_table;
818
819 bbp_r47 = mt7601u_bbp_rr(dev, 47);
820
821 p.tssi0 = mt7601u_bbp_r47_get(dev, bbp_r47, BBP_R47_F_TSSI);
822 dev->raw_temp = mt7601u_bbp_r47_get(dev, bbp_r47, BBP_R47_F_TEMP);
823 pkt_type = mt7601u_bbp_r47_get(dev, bbp_r47, BBP_R47_F_PKT_T);
824
825 p.trgt_power = mt7601u_current_tx_power(dev);
826
827 switch (pkt_type & 0x03) {
828 case MT_PHY_TYPE_CCK:
829 tx_rate = (pkt_type >> 4) & 0x03;
830 rate_table = dev->ee->power_rate_table.cck;
831 break;
832
833 case MT_PHY_TYPE_OFDM:
834 tx_rate = ofdm_pkt2rate[(pkt_type >> 4) & 0x07];
835 rate_table = dev->ee->power_rate_table.ofdm;
836 break;
837
838 default:
839 tx_rate = mt7601u_bbp_r47_get(dev, bbp_r47, BBP_R47_F_TX_RATE);
840 tx_rate &= 0x7f;
841 rate_table = dev->ee->power_rate_table.ht;
842 break;
843 }
844
845 if (dev->bw == MT_BW_20)
846 p.trgt_power += rate_table[tx_rate / 2].bw20;
847 else
848 p.trgt_power += rate_table[tx_rate / 2].bw40;
849
850 p.trgt_power <<= 12;
851
852 dev_dbg(dev->dev, "tx_rate:%02hhx pwr:%08x\n", tx_rate, p.trgt_power);
853
854 p.trgt_power += mt7601u_phy_rf_pa_mode_val(dev, pkt_type & 0x03,
855 tx_rate);
856
857 /* Channel 14, cck, bw20 */
858 if ((pkt_type & 0x03) == MT_PHY_TYPE_CCK) {
859 if (mt7601u_bbp_rr(dev, 4) & 0x20)
860 p.trgt_power += mt7601u_bbp_rr(dev, 178) ? 18022 : 9830;
861 else
862 p.trgt_power += mt7601u_bbp_rr(dev, 178) ? 819 : 24576;
863 }
864
865 p.trgt_power += static_power[mt7601u_bbp_rr(dev, 1) & 0x03];
866
867 p.trgt_power += dev->ee->tssi_data.tx0_delta_offset;
868
869 dev_dbg(dev->dev,
870 "tssi:%02hhx t_power:%08x temp:%02hhx pkt_type:%02hhx\n",
871 p.tssi0, p.trgt_power, dev->raw_temp, pkt_type);
872
873 return p;
874 }
875
876 static bool mt7601u_tssi_read_ready(struct mt7601u_dev *dev)
877 {
878 return !(mt7601u_bbp_rr(dev, 47) & 0x10);
879 }
880
881 static int mt7601u_tssi_cal(struct mt7601u_dev *dev)
882 {
883 struct mt7601u_tssi_params params;
884 int curr_pwr, diff_pwr;
885 char tssi_offset;
886 s8 tssi_init;
887 s16 tssi_m_dc, tssi_db;
888 bool hvga;
889 u32 val;
890
891 if (!dev->ee->tssi_enabled)
892 return 0;
893
894 hvga = mt7601u_use_hvga(dev);
895 if (!dev->tssi_read_trig)
896 return mt7601u_mcu_tssi_read_kick(dev, hvga);
897
898 if (!mt7601u_tssi_read_ready(dev))
899 return 0;
900
901 params = mt7601u_tssi_params_get(dev);
902
903 tssi_init = (hvga ? dev->tssi_init_hvga : dev->tssi_init);
904 tssi_m_dc = params.tssi0 - tssi_init;
905 tssi_db = lin2dBd(tssi_m_dc);
906 dev_dbg(dev->dev, "tssi dc:%04hx db:%04hx hvga:%d\n",
907 tssi_m_dc, tssi_db, hvga);
908
909 if (dev->chandef.chan->hw_value < 5)
910 tssi_offset = dev->ee->tssi_data.offset[0];
911 else if (dev->chandef.chan->hw_value < 9)
912 tssi_offset = dev->ee->tssi_data.offset[1];
913 else
914 tssi_offset = dev->ee->tssi_data.offset[2];
915
916 if (hvga)
917 tssi_db -= dev->tssi_init_hvga_offset_db;
918
919 curr_pwr = tssi_db * dev->ee->tssi_data.slope + (tssi_offset << 9);
920 diff_pwr = params.trgt_power - curr_pwr;
921 dev_dbg(dev->dev, "Power curr:%08x diff:%08x\n", curr_pwr, diff_pwr);
922
923 if (params.tssi0 > 126 && diff_pwr > 0) {
924 dev_err(dev->dev, "Error: TSSI upper saturation\n");
925 diff_pwr = 0;
926 }
927 if (params.tssi0 - tssi_init < 1 && diff_pwr < 0) {
928 dev_err(dev->dev, "Error: TSSI lower saturation\n");
929 diff_pwr = 0;
930 }
931
932 if ((dev->prev_pwr_diff ^ diff_pwr) < 0 && abs(diff_pwr) < 4096 &&
933 (abs(diff_pwr) > abs(dev->prev_pwr_diff) ||
934 (diff_pwr > 0 && diff_pwr == -dev->prev_pwr_diff)))
935 diff_pwr = 0;
936 else
937 dev->prev_pwr_diff = diff_pwr;
938
939 diff_pwr += (diff_pwr > 0) ? 2048 : -2048;
940 diff_pwr /= 4096;
941
942 dev_dbg(dev->dev, "final diff: %08x\n", diff_pwr);
943
944 val = mt7601u_rr(dev, MT_TX_ALC_CFG_1);
945 curr_pwr = s6_to_int(FIELD_GET(MT_TX_ALC_CFG_1_TEMP_COMP, val));
946 diff_pwr += curr_pwr;
947 val = (val & ~MT_TX_ALC_CFG_1_TEMP_COMP) | int_to_s6(diff_pwr);
948 mt7601u_wr(dev, MT_TX_ALC_CFG_1, val);
949
950 return mt7601u_mcu_tssi_read_kick(dev, hvga);
951 }
952
953 static u8 mt7601u_agc_default(struct mt7601u_dev *dev)
954 {
955 return (dev->ee->lna_gain - 8) * 2 + 0x34;
956 }
957
958 static void mt7601u_agc_reset(struct mt7601u_dev *dev)
959 {
960 u8 agc = mt7601u_agc_default(dev);
961
962 mt7601u_bbp_wr(dev, 66, agc);
963 }
964
965 void mt7601u_agc_save(struct mt7601u_dev *dev)
966 {
967 dev->agc_save = mt7601u_bbp_rr(dev, 66);
968 }
969
970 void mt7601u_agc_restore(struct mt7601u_dev *dev)
971 {
972 mt7601u_bbp_wr(dev, 66, dev->agc_save);
973 }
974
975 static void mt7601u_agc_tune(struct mt7601u_dev *dev)
976 {
977 u8 val = mt7601u_agc_default(dev);
978 long avg_rssi;
979
980 if (test_bit(MT7601U_STATE_SCANNING, &dev->state))
981 return;
982
983 /* Note: only in STA mode and not dozing; perhaps do this only if
984 * there is enough rssi updates since last run?
985 * Rssi updates are only on beacons and U2M so should work...
986 */
987 spin_lock_bh(&dev->con_mon_lock);
988 avg_rssi = ewma_rssi_read(&dev->avg_rssi);
989 spin_unlock_bh(&dev->con_mon_lock);
990 if (avg_rssi == 0)
991 return;
992
993 avg_rssi = -avg_rssi;
994 if (avg_rssi <= -70)
995 val -= 0x20;
996 else if (avg_rssi <= -60)
997 val -= 0x10;
998
999 if (val != mt7601u_bbp_rr(dev, 66))
1000 mt7601u_bbp_wr(dev, 66, val);
1001
1002 /* TODO: also if lost a lot of beacons try resetting
1003 * (see RTMPSetAGCInitValue() call in mlme.c).
1004 */
1005 }
1006
1007 static void mt7601u_phy_calibrate(struct work_struct *work)
1008 {
1009 struct mt7601u_dev *dev = container_of(work, struct mt7601u_dev,
1010 cal_work.work);
1011
1012 mt7601u_agc_tune(dev);
1013 mt7601u_tssi_cal(dev);
1014 /* If TSSI calibration was run it already updated temperature. */
1015 if (!dev->ee->tssi_enabled)
1016 dev->raw_temp = mt7601u_read_temp(dev);
1017 mt7601u_temp_comp(dev, true); /* TODO: find right value for @on */
1018
1019 ieee80211_queue_delayed_work(dev->hw, &dev->cal_work,
1020 MT_CALIBRATE_INTERVAL);
1021 }
1022
1023 static unsigned long
1024 __mt7601u_phy_freq_cal(struct mt7601u_dev *dev, s8 last_offset, u8 phy_mode)
1025 {
1026 u8 activate_threshold, deactivate_threshold;
1027
1028 trace_freq_cal_offset(dev, phy_mode, last_offset);
1029
1030 /* No beacons received - reschedule soon */
1031 if (last_offset == MT_FREQ_OFFSET_INVALID)
1032 return MT_FREQ_CAL_ADJ_INTERVAL;
1033
1034 switch (phy_mode) {
1035 case MT_PHY_TYPE_CCK:
1036 activate_threshold = 19;
1037 deactivate_threshold = 5;
1038 break;
1039 case MT_PHY_TYPE_OFDM:
1040 activate_threshold = 102;
1041 deactivate_threshold = 32;
1042 break;
1043 case MT_PHY_TYPE_HT:
1044 case MT_PHY_TYPE_HT_GF:
1045 activate_threshold = 82;
1046 deactivate_threshold = 20;
1047 break;
1048 default:
1049 WARN_ON(1);
1050 return MT_FREQ_CAL_CHECK_INTERVAL;
1051 }
1052
1053 if (abs(last_offset) >= activate_threshold)
1054 dev->freq_cal.adjusting = true;
1055 else if (abs(last_offset) <= deactivate_threshold)
1056 dev->freq_cal.adjusting = false;
1057
1058 if (!dev->freq_cal.adjusting)
1059 return MT_FREQ_CAL_CHECK_INTERVAL;
1060
1061 if (last_offset > deactivate_threshold) {
1062 if (dev->freq_cal.freq > 0)
1063 dev->freq_cal.freq--;
1064 else
1065 dev->freq_cal.adjusting = false;
1066 } else if (last_offset < -deactivate_threshold) {
1067 if (dev->freq_cal.freq < 0xbf)
1068 dev->freq_cal.freq++;
1069 else
1070 dev->freq_cal.adjusting = false;
1071 }
1072
1073 trace_freq_cal_adjust(dev, dev->freq_cal.freq);
1074 mt7601u_rf_wr(dev, 0, 12, dev->freq_cal.freq);
1075 mt7601u_vco_cal(dev);
1076
1077 return dev->freq_cal.adjusting ? MT_FREQ_CAL_ADJ_INTERVAL :
1078 MT_FREQ_CAL_CHECK_INTERVAL;
1079 }
1080
1081 static void mt7601u_phy_freq_cal(struct work_struct *work)
1082 {
1083 struct mt7601u_dev *dev = container_of(work, struct mt7601u_dev,
1084 freq_cal.work.work);
1085 s8 last_offset;
1086 u8 phy_mode;
1087 unsigned long delay;
1088
1089 spin_lock_bh(&dev->con_mon_lock);
1090 last_offset = dev->bcn_freq_off;
1091 phy_mode = dev->bcn_phy_mode;
1092 spin_unlock_bh(&dev->con_mon_lock);
1093
1094 delay = __mt7601u_phy_freq_cal(dev, last_offset, phy_mode);
1095 ieee80211_queue_delayed_work(dev->hw, &dev->freq_cal.work, delay);
1096
1097 spin_lock_bh(&dev->con_mon_lock);
1098 dev->bcn_freq_off = MT_FREQ_OFFSET_INVALID;
1099 spin_unlock_bh(&dev->con_mon_lock);
1100 }
1101
1102 void mt7601u_phy_con_cal_onoff(struct mt7601u_dev *dev,
1103 struct ieee80211_bss_conf *info)
1104 {
1105 if (!info->assoc)
1106 cancel_delayed_work_sync(&dev->freq_cal.work);
1107
1108 /* Start/stop collecting beacon data */
1109 spin_lock_bh(&dev->con_mon_lock);
1110 ether_addr_copy(dev->ap_bssid, info->bssid);
1111 ewma_rssi_init(&dev->avg_rssi);
1112 dev->bcn_freq_off = MT_FREQ_OFFSET_INVALID;
1113 spin_unlock_bh(&dev->con_mon_lock);
1114
1115 dev->freq_cal.freq = dev->ee->rf_freq_off;
1116 dev->freq_cal.enabled = info->assoc;
1117 dev->freq_cal.adjusting = false;
1118
1119 if (info->assoc)
1120 ieee80211_queue_delayed_work(dev->hw, &dev->freq_cal.work,
1121 MT_FREQ_CAL_INIT_DELAY);
1122 }
1123
1124 static int mt7601u_init_cal(struct mt7601u_dev *dev)
1125 {
1126 u32 mac_ctrl;
1127 int ret;
1128
1129 dev->raw_temp = mt7601u_read_bootup_temp(dev);
1130 dev->curr_temp = (dev->raw_temp - dev->ee->ref_temp) *
1131 MT_EE_TEMPERATURE_SLOPE;
1132 dev->dpd_temp = dev->curr_temp;
1133
1134 mac_ctrl = mt7601u_rr(dev, MT_MAC_SYS_CTRL);
1135
1136 ret = mt7601u_mcu_calibrate(dev, MCU_CAL_R, 0);
1137 if (ret)
1138 return ret;
1139
1140 ret = mt7601u_rf_rr(dev, 0, 4);
1141 if (ret < 0)
1142 return ret;
1143 ret |= 0x80;
1144 ret = mt7601u_rf_wr(dev, 0, 4, ret);
1145 if (ret)
1146 return ret;
1147 msleep(2);
1148
1149 ret = mt7601u_mcu_calibrate(dev, MCU_CAL_TXDCOC, 0);
1150 if (ret)
1151 return ret;
1152
1153 mt7601u_rxdc_cal(dev);
1154
1155 ret = mt7601u_set_bw_filter(dev, true);
1156 if (ret)
1157 return ret;
1158 ret = mt7601u_mcu_calibrate(dev, MCU_CAL_LOFT, 0);
1159 if (ret)
1160 return ret;
1161 ret = mt7601u_mcu_calibrate(dev, MCU_CAL_TXIQ, 0);
1162 if (ret)
1163 return ret;
1164 ret = mt7601u_mcu_calibrate(dev, MCU_CAL_RXIQ, 0);
1165 if (ret)
1166 return ret;
1167 ret = mt7601u_mcu_calibrate(dev, MCU_CAL_DPD, dev->dpd_temp);
1168 if (ret)
1169 return ret;
1170
1171 mt7601u_rxdc_cal(dev);
1172
1173 mt7601u_tssi_dc_gain_cal(dev);
1174
1175 mt7601u_wr(dev, MT_MAC_SYS_CTRL, mac_ctrl);
1176
1177 mt7601u_temp_comp(dev, true);
1178
1179 return 0;
1180 }
1181
1182 int mt7601u_bbp_set_bw(struct mt7601u_dev *dev, int bw)
1183 {
1184 u32 val, old;
1185
1186 if (bw == dev->bw) {
1187 /* Vendor driver does the rmc even when no change is needed. */
1188 mt7601u_bbp_rmc(dev, 4, 0x18, bw == MT_BW_20 ? 0 : 0x10);
1189
1190 return 0;
1191 }
1192 dev->bw = bw;
1193
1194 /* Stop MAC for the time of bw change */
1195 old = mt7601u_rr(dev, MT_MAC_SYS_CTRL);
1196 val = old & ~(MT_MAC_SYS_CTRL_ENABLE_TX | MT_MAC_SYS_CTRL_ENABLE_RX);
1197 mt7601u_wr(dev, MT_MAC_SYS_CTRL, val);
1198 mt76_poll(dev, MT_MAC_STATUS, MT_MAC_STATUS_TX | MT_MAC_STATUS_RX,
1199 0, 500000);
1200
1201 mt7601u_bbp_rmc(dev, 4, 0x18, bw == MT_BW_20 ? 0 : 0x10);
1202
1203 mt7601u_wr(dev, MT_MAC_SYS_CTRL, old);
1204
1205 return mt7601u_load_bbp_temp_table_bw(dev);
1206 }
1207
1208 /**
1209 * mt7601u_set_rx_path - set rx path in BBP
1210 * @dev: pointer to adapter structure
1211 * @path: rx path to set values are 0-based
1212 */
1213 void mt7601u_set_rx_path(struct mt7601u_dev *dev, u8 path)
1214 {
1215 mt7601u_bbp_rmw(dev, 3, 0x18, path << 3);
1216 }
1217
1218 /**
1219 * mt7601u_set_tx_dac - set which tx DAC to use
1220 * @dev: pointer to adapter structure
1221 * @path: DAC index, values are 0-based
1222 */
1223 void mt7601u_set_tx_dac(struct mt7601u_dev *dev, u8 dac)
1224 {
1225 mt7601u_bbp_rmc(dev, 1, 0x18, dac << 3);
1226 }
1227
1228 int mt7601u_phy_init(struct mt7601u_dev *dev)
1229 {
1230 int ret;
1231
1232 dev->rf_pa_mode[0] = mt7601u_rr(dev, MT_RF_PA_MODE_CFG0);
1233 dev->rf_pa_mode[1] = mt7601u_rr(dev, MT_RF_PA_MODE_CFG1);
1234
1235 ret = mt7601u_rf_wr(dev, 0, 12, dev->ee->rf_freq_off);
1236 if (ret)
1237 return ret;
1238 ret = mt7601u_write_reg_pairs(dev, 0, rf_central,
1239 ARRAY_SIZE(rf_central));
1240 if (ret)
1241 return ret;
1242 ret = mt7601u_write_reg_pairs(dev, 0, rf_channel,
1243 ARRAY_SIZE(rf_channel));
1244 if (ret)
1245 return ret;
1246 ret = mt7601u_write_reg_pairs(dev, 0, rf_vga, ARRAY_SIZE(rf_vga));
1247 if (ret)
1248 return ret;
1249
1250 ret = mt7601u_init_cal(dev);
1251 if (ret)
1252 return ret;
1253
1254 dev->prev_pwr_diff = 100;
1255
1256 INIT_DELAYED_WORK(&dev->cal_work, mt7601u_phy_calibrate);
1257 INIT_DELAYED_WORK(&dev->freq_cal.work, mt7601u_phy_freq_cal);
1258
1259 return 0;
1260 }
Ubuntu Jammy Linux kernel mirror