drivers/net/wireless/mediatek/mt76/mt76x0/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  * Copyright (C) 2018 Stanislaw Gruszka <stf_xl@wp.pl>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2
   9  * as published by the Free Software Foundation
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  */
  16
  17 #include "mt76x0.h"
  18 #include "mcu.h"
  19 #include "eeprom.h"
  20 #include "trace.h"
  21 #include "phy.h"
  22 #include "initvals.h"
  23 #include "initvals_phy.h"
  24 #include "../mt76x02_phy.h"
  25
  26 #include <linux/etherdevice.h>
  27
  28 static int
  29 mt76x0_rf_csr_wr(struct mt76x0_dev *dev, u32 offset, u8 value)
  30 {
  31         int ret = 0;
  32         u8 bank, reg;
  33
  34         if (test_bit(MT76_REMOVED, &dev->mt76.state))
  35                 return -ENODEV;
  36
  37         bank = MT_RF_BANK(offset);
  38         reg = MT_RF_REG(offset);
  39
  40         if (WARN_ON_ONCE(reg > 64) || WARN_ON_ONCE(bank) > 8)
  41                 return -EINVAL;
  42
  43         mutex_lock(&dev->reg_atomic_mutex);
  44
  45         if (!mt76_poll(dev, MT_RF_CSR_CFG, MT_RF_CSR_CFG_KICK, 0, 100)) {
  46                 ret = -ETIMEDOUT;
  47                 goto out;
  48         }
  49
  50         mt76_wr(dev, MT_RF_CSR_CFG,
  51                    FIELD_PREP(MT_RF_CSR_CFG_DATA, value) |
  52                    FIELD_PREP(MT_RF_CSR_CFG_REG_BANK, bank) |
  53                    FIELD_PREP(MT_RF_CSR_CFG_REG_ID, reg) |
  54                    MT_RF_CSR_CFG_WR |
  55                    MT_RF_CSR_CFG_KICK);
  56         trace_mt76x0_rf_write(&dev->mt76, bank, offset, value);
  57 out:
  58         mutex_unlock(&dev->reg_atomic_mutex);
  59
  60         if (ret < 0)
  61                 dev_err(dev->mt76.dev, "Error: RF write %d:%d failed:%d!!\n",
  62                         bank, reg, ret);
  63
  64         return ret;
  65 }
  66
  67 static int
  68 mt76x0_rf_csr_rr(struct mt76x0_dev *dev, u32 offset)
  69 {
  70         int ret = -ETIMEDOUT;
  71         u32 val;
  72         u8 bank, reg;
  73
  74         if (test_bit(MT76_REMOVED, &dev->mt76.state))
  75                 return -ENODEV;
  76
  77         bank = MT_RF_BANK(offset);
  78         reg = MT_RF_REG(offset);
  79
  80         if (WARN_ON_ONCE(reg > 64) || WARN_ON_ONCE(bank) > 8)
  81                 return -EINVAL;
  82
  83         mutex_lock(&dev->reg_atomic_mutex);
  84
  85         if (!mt76_poll(dev, MT_RF_CSR_CFG, MT_RF_CSR_CFG_KICK, 0, 100))
  86                 goto out;
  87
  88         mt76_wr(dev, MT_RF_CSR_CFG,
  89                    FIELD_PREP(MT_RF_CSR_CFG_REG_BANK, bank) |
  90                    FIELD_PREP(MT_RF_CSR_CFG_REG_ID, reg) |
  91                    MT_RF_CSR_CFG_KICK);
  92
  93         if (!mt76_poll(dev, MT_RF_CSR_CFG, MT_RF_CSR_CFG_KICK, 0, 100))
  94                 goto out;
  95
  96         val = mt76_rr(dev, MT_RF_CSR_CFG);
  97         if (FIELD_GET(MT_RF_CSR_CFG_REG_ID, val) == reg &&
  98             FIELD_GET(MT_RF_CSR_CFG_REG_BANK, val) == bank) {
  99                 ret = FIELD_GET(MT_RF_CSR_CFG_DATA, val);
 100                 trace_mt76x0_rf_read(&dev->mt76, bank, offset, ret);
 101         }
 102 out:
 103         mutex_unlock(&dev->reg_atomic_mutex);
 104
 105         if (ret < 0)
 106                 dev_err(dev->mt76.dev, "Error: RF read %d:%d failed:%d!!\n",
 107                         bank, reg, ret);
 108
 109         return ret;
 110 }
 111
 112 static int
 113 rf_wr(struct mt76x0_dev *dev, u32 offset, u8 val)
 114 {
 115         if (test_bit(MT76_STATE_MCU_RUNNING, &dev->mt76.state)) {
 116                 struct mt76_reg_pair pair = {
 117                         .reg = offset,
 118                         .value = val,
 119                 };
 120
 121                 return mt76_wr_rp(dev, MT_MCU_MEMMAP_RF, &pair, 1);
 122         } else {
 123                 WARN_ON_ONCE(1);
 124                 return mt76x0_rf_csr_wr(dev, offset, val);
 125         }
 126 }
 127
 128 static int
 129 rf_rr(struct mt76x0_dev *dev, u32 offset)
 130 {
 131         int ret;
 132         u32 val;
 133
 134         if (test_bit(MT76_STATE_MCU_RUNNING, &dev->mt76.state)) {
 135                 struct mt76_reg_pair pair = {
 136                         .reg = offset,
 137                 };
 138
 139                 ret = mt76_rd_rp(dev, MT_MCU_MEMMAP_RF, &pair, 1);
 140                 val = pair.value;
 141         } else {
 142                 WARN_ON_ONCE(1);
 143                 ret = val = mt76x0_rf_csr_rr(dev, offset);
 144         }
 145
 146         return (ret < 0) ? ret : val;
 147 }
 148
 149 static int
 150 rf_rmw(struct mt76x0_dev *dev, u32 offset, u8 mask, u8 val)
 151 {
 152         int ret;
 153
 154         ret = rf_rr(dev, offset);
 155         if (ret < 0)
 156                 return ret;
 157         val |= ret & ~mask;
 158         ret = rf_wr(dev, offset, val);
 159         if (ret)
 160                 return ret;
 161
 162         return val;
 163 }
 164
 165 static int
 166 rf_set(struct mt76x0_dev *dev, u32 offset, u8 val)
 167 {
 168         return rf_rmw(dev, offset, 0, val);
 169 }
 170
 171 #if 0
 172 static int
 173 rf_clear(struct mt76x0_dev *dev, u32 offset, u8 mask)
 174 {
 175         return rf_rmw(dev, offset, mask, 0);
 176 }
 177 #endif
 178
 179 #define RF_RANDOM_WRITE(dev, tab)               \
 180         mt76_wr_rp(dev, MT_MCU_MEMMAP_RF,       \
 181                    tab, ARRAY_SIZE(tab))
 182
 183 int mt76x0_wait_bbp_ready(struct mt76x0_dev *dev)
 184 {
 185         int i = 20;
 186         u32 val;
 187
 188         do {
 189                 val = mt76_rr(dev, MT_BBP(CORE, 0));
 190                 printk("BBP version %08x\n", val);
 191                 if (val && ~val)
 192                         break;
 193         } while (--i);
 194
 195         if (!i) {
 196                 dev_err(dev->mt76.dev, "Error: BBP is not ready\n");
 197                 return -EIO;
 198         }
 199
 200         return 0;
 201 }
 202
 203 static void
 204 mt76x0_bbp_set_ctrlch(struct mt76x0_dev *dev, enum nl80211_chan_width width,
 205                       u8 ctrl)
 206 {
 207         int core_val, agc_val;
 208
 209         switch (width) {
 210         case NL80211_CHAN_WIDTH_80:
 211                 core_val = 3;
 212                 agc_val = 7;
 213                 break;
 214         case NL80211_CHAN_WIDTH_40:
 215                 core_val = 2;
 216                 agc_val = 3;
 217                 break;
 218         default:
 219                 core_val = 0;
 220                 agc_val = 1;
 221                 break;
 222         }
 223
 224         mt76_rmw_field(dev, MT_BBP(CORE, 1), MT_BBP_CORE_R1_BW, core_val);
 225         mt76_rmw_field(dev, MT_BBP(AGC, 0), MT_BBP_AGC_R0_BW, agc_val);
 226         mt76_rmw_field(dev, MT_BBP(AGC, 0), MT_BBP_AGC_R0_CTRL_CHAN, ctrl);
 227         mt76_rmw_field(dev, MT_BBP(TXBE, 0), MT_BBP_TXBE_R0_CTRL_CHAN, ctrl);
 228 }
 229
 230 int mt76x0_phy_get_rssi(struct mt76x0_dev *dev, struct mt76x02_rxwi *rxwi)
 231 {
 232         struct mt76x0_caldata *caldata = &dev->caldata;
 233
 234         return rxwi->rssi[0] + caldata->rssi_offset[0] - caldata->lna_gain;
 235 }
 236
 237 static void mt76x0_vco_cal(struct mt76x0_dev *dev, u8 channel)
 238 {
 239         u8 val;
 240
 241         val = rf_rr(dev, MT_RF(0, 4));
 242         if ((val & 0x70) != 0x30)
 243                 return;
 244
 245         /*
 246          * Calibration Mode - Open loop, closed loop, and amplitude:
 247          * B0.R06.[0]: 1
 248          * B0.R06.[3:1] bp_close_code: 100
 249          * B0.R05.[7:0] bp_open_code: 0x0
 250          * B0.R04.[2:0] cal_bits: 000
 251          * B0.R03.[2:0] startup_time: 011
 252          * B0.R03.[6:4] settle_time:
 253          *  80MHz channel: 110
 254          *  40MHz channel: 101
 255          *  20MHz channel: 100
 256          */
 257         val = rf_rr(dev, MT_RF(0, 6));
 258         val &= ~0xf;
 259         val |= 0x09;
 260         rf_wr(dev, MT_RF(0, 6), val);
 261
 262         val = rf_rr(dev, MT_RF(0, 5));
 263         if (val != 0)
 264                 rf_wr(dev, MT_RF(0, 5), 0x0);
 265
 266         val = rf_rr(dev, MT_RF(0, 4));
 267         val &= ~0x07;
 268         rf_wr(dev, MT_RF(0, 4), val);
 269
 270         val = rf_rr(dev, MT_RF(0, 3));
 271         val &= ~0x77;
 272         if (channel == 1 || channel == 7 || channel == 9 || channel >= 13) {
 273                 val |= 0x63;
 274         } else if (channel == 3 || channel == 4 || channel == 10) {
 275                 val |= 0x53;
 276         } else if (channel == 2 || channel == 5 || channel == 6 ||
 277                    channel == 8 || channel == 11 || channel == 12) {
 278                 val |= 0x43;
 279         } else {
 280                 WARN(1, "Unknown channel %u\n", channel);
 281                 return;
 282         }
 283         rf_wr(dev, MT_RF(0, 3), val);
 284
 285         /* TODO replace by mt76x0_rf_set(dev, MT_RF(0, 4), BIT(7)); */
 286         val = rf_rr(dev, MT_RF(0, 4));
 287         val = ((val & ~(0x80)) | 0x80);
 288         rf_wr(dev, MT_RF(0, 4), val);
 289
 290         msleep(2);
 291 }
 292
 293 static void
 294 mt76x0_mac_set_ctrlch(struct mt76x0_dev *dev, bool primary_upper)
 295 {
 296         mt76_rmw_field(dev, MT_TX_BAND_CFG, MT_TX_BAND_CFG_UPPER_40M,
 297                        primary_upper);
 298 }
 299
 300 static void
 301 mt76x0_phy_set_band(struct mt76x0_dev *dev, enum nl80211_band band)
 302 {
 303         switch (band) {
 304         case NL80211_BAND_2GHZ:
 305                 RF_RANDOM_WRITE(dev, mt76x0_rf_2g_channel_0_tab);
 306
 307                 rf_wr(dev, MT_RF(5, 0), 0x45);
 308                 rf_wr(dev, MT_RF(6, 0), 0x44);
 309
 310                 mt76_set(dev, MT_TX_BAND_CFG, MT_TX_BAND_CFG_2G);
 311                 mt76_clear(dev, MT_TX_BAND_CFG, MT_TX_BAND_CFG_5G);
 312
 313                 mt76_wr(dev, MT_TX_ALC_VGA3, 0x00050007);
 314                 mt76_wr(dev, MT_TX0_RF_GAIN_CORR, 0x003E0002);
 315                 break;
 316         case NL80211_BAND_5GHZ:
 317                 RF_RANDOM_WRITE(dev, mt76x0_rf_5g_channel_0_tab);
 318
 319                 rf_wr(dev, MT_RF(5, 0), 0x44);
 320                 rf_wr(dev, MT_RF(6, 0), 0x45);
 321
 322                 mt76_clear(dev, MT_TX_BAND_CFG, MT_TX_BAND_CFG_2G);
 323                 mt76_set(dev, MT_TX_BAND_CFG, MT_TX_BAND_CFG_5G);
 324
 325                 mt76_wr(dev, MT_TX_ALC_VGA3, 0x00000005);
 326                 mt76_wr(dev, MT_TX0_RF_GAIN_CORR, 0x01010102);
 327                 break;
 328         default:
 329                 break;
 330         }
 331 }
 332
 333 static void
 334 mt76x0_phy_set_chan_rf_params(struct mt76x0_dev *dev, u8 channel, u16 rf_bw_band)
 335 {
 336         u16 rf_band = rf_bw_band & 0xff00;
 337         u16 rf_bw = rf_bw_band & 0x00ff;
 338         enum nl80211_band band;
 339         u32 mac_reg;
 340         u8 rf_val;
 341         int i;
 342         bool bSDM = false;
 343         const struct mt76x0_freq_item *freq_item;
 344
 345         for (i = 0; i < ARRAY_SIZE(mt76x0_sdm_channel); i++) {
 346                 if (channel == mt76x0_sdm_channel[i]) {
 347                         bSDM = true;
 348                         break;
 349                 }
 350         }
 351
 352         for (i = 0; i < ARRAY_SIZE(mt76x0_frequency_plan); i++) {
 353                 if (channel == mt76x0_frequency_plan[i].channel) {
 354                         rf_band = mt76x0_frequency_plan[i].band;
 355
 356                         if (bSDM)
 357                                 freq_item = &(mt76x0_sdm_frequency_plan[i]);
 358                         else
 359                                 freq_item = &(mt76x0_frequency_plan[i]);
 360
 361                         rf_wr(dev, MT_RF(0, 37), freq_item->pllR37);
 362                         rf_wr(dev, MT_RF(0, 36), freq_item->pllR36);
 363                         rf_wr(dev, MT_RF(0, 35), freq_item->pllR35);
 364                         rf_wr(dev, MT_RF(0, 34), freq_item->pllR34);
 365                         rf_wr(dev, MT_RF(0, 33), freq_item->pllR33);
 366
 367                         rf_val = rf_rr(dev, MT_RF(0, 32));
 368                         rf_val &= ~0xE0;
 369                         rf_val |= freq_item->pllR32_b7b5;
 370                         rf_wr(dev, MT_RF(0, 32), rf_val);
 371
 372                         /* R32<4:0> pll_den: (Denomina - 8) */
 373                         rf_val = rf_rr(dev, MT_RF(0, 32));
 374                         rf_val &= ~0x1F;
 375                         rf_val |= freq_item->pllR32_b4b0;
 376                         rf_wr(dev, MT_RF(0, 32), rf_val);
 377
 378                         /* R31<7:5> */
 379                         rf_val = rf_rr(dev, MT_RF(0, 31));
 380                         rf_val &= ~0xE0;
 381                         rf_val |= freq_item->pllR31_b7b5;
 382                         rf_wr(dev, MT_RF(0, 31), rf_val);
 383
 384                         /* R31<4:0> pll_k(Nominator) */
 385                         rf_val = rf_rr(dev, MT_RF(0, 31));
 386                         rf_val &= ~0x1F;
 387                         rf_val |= freq_item->pllR31_b4b0;
 388                         rf_wr(dev, MT_RF(0, 31), rf_val);
 389
 390                         /* R30<7> sdm_reset_n */
 391                         rf_val = rf_rr(dev, MT_RF(0, 30));
 392                         rf_val &= ~0x80;
 393                         if (bSDM) {
 394                                 rf_wr(dev, MT_RF(0, 30), rf_val);
 395                                 rf_val |= 0x80;
 396                                 rf_wr(dev, MT_RF(0, 30), rf_val);
 397                         } else {
 398                                 rf_val |= freq_item->pllR30_b7;
 399                                 rf_wr(dev, MT_RF(0, 30), rf_val);
 400                         }
 401
 402                         /* R30<6:2> sdmmash_prbs,sin */
 403                         rf_val = rf_rr(dev, MT_RF(0, 30));
 404                         rf_val &= ~0x7C;
 405                         rf_val |= freq_item->pllR30_b6b2;
 406                         rf_wr(dev, MT_RF(0, 30), rf_val);
 407
 408                         /* R30<1> sdm_bp */
 409                         rf_val = rf_rr(dev, MT_RF(0, 30));
 410                         rf_val &= ~0x02;
 411                         rf_val |= (freq_item->pllR30_b1 << 1);
 412                         rf_wr(dev, MT_RF(0, 30), rf_val);
 413
 414                         /* R30<0> R29<7:0> (hex) pll_n */
 415                         rf_val = freq_item->pll_n & 0x00FF;
 416                         rf_wr(dev, MT_RF(0, 29), rf_val);
 417
 418                         rf_val = rf_rr(dev, MT_RF(0, 30));
 419                         rf_val &= ~0x1;
 420                         rf_val |= ((freq_item->pll_n >> 8) & 0x0001);
 421                         rf_wr(dev, MT_RF(0, 30), rf_val);
 422
 423                         /* R28<7:6> isi_iso */
 424                         rf_val = rf_rr(dev, MT_RF(0, 28));
 425                         rf_val &= ~0xC0;
 426                         rf_val |= freq_item->pllR28_b7b6;
 427                         rf_wr(dev, MT_RF(0, 28), rf_val);
 428
 429                         /* R28<5:4> pfd_dly */
 430                         rf_val = rf_rr(dev, MT_RF(0, 28));
 431                         rf_val &= ~0x30;
 432                         rf_val |= freq_item->pllR28_b5b4;
 433                         rf_wr(dev, MT_RF(0, 28), rf_val);
 434
 435                         /* R28<3:2> clksel option */
 436                         rf_val = rf_rr(dev, MT_RF(0, 28));
 437                         rf_val &= ~0x0C;
 438                         rf_val |= freq_item->pllR28_b3b2;
 439                         rf_wr(dev, MT_RF(0, 28), rf_val);
 440
 441                         /* R28<1:0> R27<7:0> R26<7:0> (hex) sdm_k */
 442                         rf_val = freq_item->pll_sdm_k & 0x000000FF;
 443                         rf_wr(dev, MT_RF(0, 26), rf_val);
 444
 445                         rf_val = ((freq_item->pll_sdm_k >> 8) & 0x000000FF);
 446                         rf_wr(dev, MT_RF(0, 27), rf_val);
 447
 448                         rf_val = rf_rr(dev, MT_RF(0, 28));
 449                         rf_val &= ~0x3;
 450                         rf_val |= ((freq_item->pll_sdm_k >> 16) & 0x0003);
 451                         rf_wr(dev, MT_RF(0, 28), rf_val);
 452
 453                         /* R24<1:0> xo_div */
 454                         rf_val = rf_rr(dev, MT_RF(0, 24));
 455                         rf_val &= ~0x3;
 456                         rf_val |= freq_item->pllR24_b1b0;
 457                         rf_wr(dev, MT_RF(0, 24), rf_val);
 458
 459                         break;
 460                 }
 461         }
 462
 463         for (i = 0; i < ARRAY_SIZE(mt76x0_rf_bw_switch_tab); i++) {
 464                 if (rf_bw == mt76x0_rf_bw_switch_tab[i].bw_band) {
 465                         rf_wr(dev, mt76x0_rf_bw_switch_tab[i].rf_bank_reg,
 466                                    mt76x0_rf_bw_switch_tab[i].value);
 467                 } else if ((rf_bw == (mt76x0_rf_bw_switch_tab[i].bw_band & 0xFF)) &&
 468                            (rf_band & mt76x0_rf_bw_switch_tab[i].bw_band)) {
 469                         rf_wr(dev, mt76x0_rf_bw_switch_tab[i].rf_bank_reg,
 470                                    mt76x0_rf_bw_switch_tab[i].value);
 471                 }
 472         }
 473
 474         for (i = 0; i < ARRAY_SIZE(mt76x0_rf_band_switch_tab); i++) {
 475                 if (mt76x0_rf_band_switch_tab[i].bw_band & rf_band) {
 476                         rf_wr(dev, mt76x0_rf_band_switch_tab[i].rf_bank_reg,
 477                                    mt76x0_rf_band_switch_tab[i].value);
 478                 }
 479         }
 480
 481         mac_reg = mt76_rr(dev, MT_RF_MISC);
 482         mac_reg &= ~0xC; /* Clear 0x518[3:2] */
 483         mt76_wr(dev, MT_RF_MISC, mac_reg);
 484
 485         band = (rf_band & RF_G_BAND) ? NL80211_BAND_2GHZ : NL80211_BAND_5GHZ;
 486         if (mt76x02_ext_pa_enabled(&dev->mt76, band)) {
 487                 /*
 488                         MT_RF_MISC (offset: 0x0518)
 489                         [2]1'b1: enable external A band PA, 1'b0: disable external A band PA
 490                         [3]1'b1: enable external G band PA, 1'b0: disable external G band PA
 491                 */
 492                 if (rf_band & RF_A_BAND) {
 493                         mac_reg = mt76_rr(dev, MT_RF_MISC);
 494                         mac_reg |= 0x4;
 495                         mt76_wr(dev, MT_RF_MISC, mac_reg);
 496                 } else {
 497                         mac_reg = mt76_rr(dev, MT_RF_MISC);
 498                         mac_reg |= 0x8;
 499                         mt76_wr(dev, MT_RF_MISC, mac_reg);
 500                 }
 501
 502                 /* External PA */
 503                 for (i = 0; i < ARRAY_SIZE(mt76x0_rf_ext_pa_tab); i++)
 504                         if (mt76x0_rf_ext_pa_tab[i].bw_band & rf_band)
 505                                 rf_wr(dev, mt76x0_rf_ext_pa_tab[i].rf_bank_reg,
 506                                            mt76x0_rf_ext_pa_tab[i].value);
 507         }
 508
 509         if (rf_band & RF_G_BAND) {
 510                 mt76_wr(dev, MT_TX0_RF_GAIN_ATTEN, 0x63707400);
 511                 /* Set Atten mode = 2 For G band, Disable Tx Inc dcoc. */
 512                 mac_reg = mt76_rr(dev, MT_TX_ALC_CFG_1);
 513                 mac_reg &= 0x896400FF;
 514                 mt76_wr(dev, MT_TX_ALC_CFG_1, mac_reg);
 515         } else {
 516                 mt76_wr(dev, MT_TX0_RF_GAIN_ATTEN, 0x686A7800);
 517                 /* Set Atten mode = 0 For Ext A band, Disable Tx Inc dcoc Cal. */
 518                 mac_reg = mt76_rr(dev, MT_TX_ALC_CFG_1);
 519                 mac_reg &= 0x890400FF;
 520                 mt76_wr(dev, MT_TX_ALC_CFG_1, mac_reg);
 521         }
 522 }
 523
 524 static void
 525 mt76x0_phy_set_chan_bbp_params(struct mt76x0_dev *dev, u8 channel, u16 rf_bw_band)
 526 {
 527         int i;
 528
 529         for (i = 0; i < ARRAY_SIZE(mt76x0_bbp_switch_tab); i++) {
 530                 const struct mt76x0_bbp_switch_item *item = &mt76x0_bbp_switch_tab[i];
 531                 const struct mt76_reg_pair *pair = &item->reg_pair;
 532
 533                 if ((rf_bw_band & item->bw_band) != rf_bw_band)
 534                         continue;
 535
 536                 if (pair->reg == MT_BBP(AGC, 8)) {
 537                         u32 val = pair->value;
 538                         u8 gain;
 539
 540                         gain = FIELD_GET(MT_BBP_AGC_GAIN, val);
 541                         gain -= dev->caldata.lna_gain * 2;
 542                         val &= ~MT_BBP_AGC_GAIN;
 543                         val |= FIELD_PREP(MT_BBP_AGC_GAIN, gain);
 544                         mt76_wr(dev, pair->reg, val);
 545                 } else {
 546                         mt76_wr(dev, pair->reg, pair->value);
 547                 }
 548         }
 549 }
 550
 551 static void mt76x0_ant_select(struct mt76x0_dev *dev)
 552 {
 553         struct ieee80211_channel *chan = dev->mt76.chandef.chan;
 554
 555         /* single antenna mode */
 556         if (chan->band == NL80211_BAND_2GHZ) {
 557                 mt76_rmw(dev, MT_COEXCFG3,
 558                          BIT(5) | BIT(4) | BIT(3) | BIT(2), BIT(1));
 559                 mt76_rmw(dev, MT_WLAN_FUN_CTRL, BIT(5), BIT(6));
 560         } else {
 561                 mt76_rmw(dev, MT_COEXCFG3, BIT(5) | BIT(2),
 562                          BIT(4) | BIT(3));
 563                 mt76_clear(dev, MT_WLAN_FUN_CTRL,
 564                            BIT(6) | BIT(5));
 565         }
 566         mt76_clear(dev, MT_CMB_CTRL, BIT(14) | BIT(12));
 567         mt76_clear(dev, MT_COEXCFG0, BIT(2));
 568 }
 569
 570 static void
 571 mt76x0_bbp_set_bw(struct mt76x0_dev *dev, enum nl80211_chan_width width)
 572 {
 573         enum { BW_20 = 0, BW_40 = 1, BW_80 = 2, BW_10 = 4};
 574         int bw;
 575
 576         switch (width) {
 577         default:
 578         case NL80211_CHAN_WIDTH_20_NOHT:
 579         case NL80211_CHAN_WIDTH_20:
 580                 bw = BW_20;
 581                 break;
 582         case NL80211_CHAN_WIDTH_40:
 583                 bw = BW_40;
 584                 break;
 585         case NL80211_CHAN_WIDTH_80:
 586                 bw = BW_80;
 587                 break;
 588         case NL80211_CHAN_WIDTH_10:
 589                 bw = BW_10;
 590                 break;
 591         case NL80211_CHAN_WIDTH_80P80:
 592         case NL80211_CHAN_WIDTH_160:
 593         case NL80211_CHAN_WIDTH_5:
 594                 /* TODO error */
 595                 return ;
 596         }
 597
 598         mt76x02_mcu_function_select(&dev->mt76, BW_SETTING, bw, false);
 599 }
 600
 601 void mt76x0_phy_set_txpower(struct mt76x0_dev *dev)
 602 {
 603         struct mt76_rate_power *t = &dev->mt76.rate_power;
 604         u8 info[2];
 605
 606         mt76x0_get_power_info(dev, info);
 607         mt76x0_get_tx_power_per_rate(dev);
 608
 609         mt76x02_add_rate_power_offset(t, info[0]);
 610         mt76x02_limit_rate_power(t, dev->mt76.txpower_conf);
 611         dev->mt76.txpower_cur = mt76x02_get_max_rate_power(t);
 612         mt76x02_add_rate_power_offset(t, -info[0]);
 613
 614         mt76x02_phy_set_txpower(&dev->mt76, info[0], info[1]);
 615 }
 616
 617 static int
 618 __mt76x0_phy_set_channel(struct mt76x0_dev *dev,
 619                        struct cfg80211_chan_def *chandef)
 620 {
 621         u32 ext_cca_chan[4] = {
 622                 [0] = FIELD_PREP(MT_EXT_CCA_CFG_CCA0, 0) |
 623                       FIELD_PREP(MT_EXT_CCA_CFG_CCA1, 1) |
 624                       FIELD_PREP(MT_EXT_CCA_CFG_CCA2, 2) |
 625                       FIELD_PREP(MT_EXT_CCA_CFG_CCA3, 3) |
 626                       FIELD_PREP(MT_EXT_CCA_CFG_CCA_MASK, BIT(0)),
 627                 [1] = FIELD_PREP(MT_EXT_CCA_CFG_CCA0, 1) |
 628                       FIELD_PREP(MT_EXT_CCA_CFG_CCA1, 0) |
 629                       FIELD_PREP(MT_EXT_CCA_CFG_CCA2, 2) |
 630                       FIELD_PREP(MT_EXT_CCA_CFG_CCA3, 3) |
 631                       FIELD_PREP(MT_EXT_CCA_CFG_CCA_MASK, BIT(1)),
 632                 [2] = FIELD_PREP(MT_EXT_CCA_CFG_CCA0, 2) |
 633                       FIELD_PREP(MT_EXT_CCA_CFG_CCA1, 3) |
 634                       FIELD_PREP(MT_EXT_CCA_CFG_CCA2, 1) |
 635                       FIELD_PREP(MT_EXT_CCA_CFG_CCA3, 0) |
 636                       FIELD_PREP(MT_EXT_CCA_CFG_CCA_MASK, BIT(2)),
 637                 [3] = FIELD_PREP(MT_EXT_CCA_CFG_CCA0, 3) |
 638                       FIELD_PREP(MT_EXT_CCA_CFG_CCA1, 2) |
 639                       FIELD_PREP(MT_EXT_CCA_CFG_CCA2, 1) |
 640                       FIELD_PREP(MT_EXT_CCA_CFG_CCA3, 0) |
 641                       FIELD_PREP(MT_EXT_CCA_CFG_CCA_MASK, BIT(3)),
 642         };
 643         bool scan = test_bit(MT76_SCANNING, &dev->mt76.state);
 644         int ch_group_index, freq, freq1;
 645         u8 channel;
 646         u32 val;
 647         u16 rf_bw_band;
 648
 649         freq = chandef->chan->center_freq;
 650         freq1 = chandef->center_freq1;
 651         channel = chandef->chan->hw_value;
 652         rf_bw_band = (channel <= 14) ? RF_G_BAND : RF_A_BAND;
 653         dev->mt76.chandef = *chandef;
 654
 655         switch (chandef->width) {
 656         case NL80211_CHAN_WIDTH_40:
 657                 if (freq1 > freq)
 658                         ch_group_index = 0;
 659                 else
 660                         ch_group_index = 1;
 661                 channel += 2 - ch_group_index * 4;
 662                 rf_bw_band |= RF_BW_40;
 663                 break;
 664         case NL80211_CHAN_WIDTH_80:
 665                 ch_group_index = (freq - freq1 + 30) / 20;
 666                 if (WARN_ON(ch_group_index < 0 || ch_group_index > 3))
 667                         ch_group_index = 0;
 668                 channel += 6 - ch_group_index * 4;
 669                 rf_bw_band |= RF_BW_80;
 670                 break;
 671         default:
 672                 ch_group_index = 0;
 673                 rf_bw_band |= RF_BW_20;
 674                 break;
 675         }
 676
 677         mt76x0_bbp_set_bw(dev, chandef->width);
 678         mt76x0_bbp_set_ctrlch(dev, chandef->width, ch_group_index);
 679         mt76x0_mac_set_ctrlch(dev, ch_group_index & 1);
 680         mt76x0_ant_select(dev);
 681
 682         mt76_rmw(dev, MT_EXT_CCA_CFG,
 683                  (MT_EXT_CCA_CFG_CCA0 |
 684                   MT_EXT_CCA_CFG_CCA1 |
 685                   MT_EXT_CCA_CFG_CCA2 |
 686                   MT_EXT_CCA_CFG_CCA3 |
 687                   MT_EXT_CCA_CFG_CCA_MASK),
 688                  ext_cca_chan[ch_group_index]);
 689
 690         mt76x0_phy_set_band(dev, chandef->chan->band);
 691         mt76x0_phy_set_chan_rf_params(dev, channel, rf_bw_band);
 692         mt76x0_read_rx_gain(dev);
 693
 694         /* set Japan Tx filter at channel 14 */
 695         val = mt76_rr(dev, MT_BBP(CORE, 1));
 696         if (channel == 14)
 697                 val |= 0x20;
 698         else
 699                 val &= ~0x20;
 700         mt76_wr(dev, MT_BBP(CORE, 1), val);
 701
 702         mt76x0_phy_set_chan_bbp_params(dev, channel, rf_bw_band);
 703
 704         /* Vendor driver don't do it */
 705         /* mt76x0_phy_set_tx_power(dev, channel, rf_bw_band); */
 706
 707         mt76x0_vco_cal(dev, channel);
 708         if (scan)
 709                 mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_RXDCOC, 1, false);
 710
 711         mt76x0_phy_set_txpower(dev);
 712
 713         return 0;
 714 }
 715
 716 int mt76x0_phy_set_channel(struct mt76x0_dev *dev,
 717                            struct cfg80211_chan_def *chandef)
 718 {
 719         int ret;
 720
 721         mutex_lock(&dev->hw_atomic_mutex);
 722         ret = __mt76x0_phy_set_channel(dev, chandef);
 723         mutex_unlock(&dev->hw_atomic_mutex);
 724
 725         return ret;
 726 }
 727
 728 void mt76x0_phy_recalibrate_after_assoc(struct mt76x0_dev *dev)
 729 {
 730         u32 tx_alc, reg_val;
 731         u8 channel = dev->mt76.chandef.chan->hw_value;
 732         int is_5ghz = (dev->mt76.chandef.chan->band == NL80211_BAND_5GHZ) ? 1 : 0;
 733
 734         mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_R, 0, false);
 735
 736         mt76x0_vco_cal(dev, channel);
 737
 738         tx_alc = mt76_rr(dev, MT_TX_ALC_CFG_0);
 739         mt76_wr(dev, MT_TX_ALC_CFG_0, 0);
 740         usleep_range(500, 700);
 741
 742         reg_val = mt76_rr(dev, 0x2124);
 743         reg_val &= 0xffffff7e;
 744         mt76_wr(dev, 0x2124, reg_val);
 745
 746         mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_RXDCOC, 0, false);
 747
 748         mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_LC, is_5ghz, false);
 749         mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_LOFT, is_5ghz, false);
 750         mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_TXIQ, is_5ghz, false);
 751         mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_TX_GROUP_DELAY,
 752                               is_5ghz, false);
 753         mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_RXIQ, is_5ghz, false);
 754         mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_RX_GROUP_DELAY,
 755                               is_5ghz, false);
 756
 757         mt76_wr(dev, 0x2124, reg_val);
 758         mt76_wr(dev, MT_TX_ALC_CFG_0, tx_alc);
 759         msleep(100);
 760
 761         mt76x02_mcu_calibrate(&dev->mt76, MCU_CAL_RXDCOC, 1, false);
 762 }
 763
 764 void mt76x0_agc_save(struct mt76x0_dev *dev)
 765 {
 766         /* Only one RX path */
 767         dev->agc_save = FIELD_GET(MT_BBP_AGC_GAIN, mt76_rr(dev, MT_BBP(AGC, 8)));
 768 }
 769
 770 void mt76x0_agc_restore(struct mt76x0_dev *dev)
 771 {
 772         mt76_rmw_field(dev, MT_BBP(AGC, 8), MT_BBP_AGC_GAIN, dev->agc_save);
 773 }
 774
 775 static void mt76x0_temp_sensor(struct mt76x0_dev *dev)
 776 {
 777         u8 rf_b7_73, rf_b0_66, rf_b0_67;
 778         int cycle, temp;
 779         u32 val;
 780         s32 sval;
 781
 782         rf_b7_73 = rf_rr(dev, MT_RF(7, 73));
 783         rf_b0_66 = rf_rr(dev, MT_RF(0, 66));
 784         rf_b0_67 = rf_rr(dev, MT_RF(0, 73));
 785
 786         rf_wr(dev, MT_RF(7, 73), 0x02);
 787         rf_wr(dev, MT_RF(0, 66), 0x23);
 788         rf_wr(dev, MT_RF(0, 73), 0x01);
 789
 790         mt76_wr(dev, MT_BBP(CORE, 34), 0x00080055);
 791
 792         for (cycle = 0; cycle < 2000; cycle++) {
 793                 val = mt76_rr(dev, MT_BBP(CORE, 34));
 794                 if (!(val & 0x10))
 795                         break;
 796                 udelay(3);
 797         }
 798
 799         if (cycle >= 2000) {
 800                 val &= 0x10;
 801                 mt76_wr(dev, MT_BBP(CORE, 34), val);
 802                 goto done;
 803         }
 804
 805         sval = mt76_rr(dev, MT_BBP(CORE, 35)) & 0xff;
 806         if (!(sval & 0x80))
 807                 sval &= 0x7f; /* Positive */
 808         else
 809                 sval |= 0xffffff00; /* Negative */
 810
 811         temp = (35 * (sval - dev->caldata.temp_offset)) / 10 + 25;
 812
 813 done:
 814         rf_wr(dev, MT_RF(7, 73), rf_b7_73);
 815         rf_wr(dev, MT_RF(0, 66), rf_b0_66);
 816         rf_wr(dev, MT_RF(0, 73), rf_b0_67);
 817 }
 818
 819 static void mt76x0_dynamic_vga_tuning(struct mt76x0_dev *dev)
 820 {
 821         struct cfg80211_chan_def *chandef = &dev->mt76.chandef;
 822         u32 val, init_vga;
 823         int avg_rssi;
 824
 825         init_vga = chandef->chan->band == NL80211_BAND_5GHZ ? 0x54 : 0x4E;
 826         avg_rssi = mt76x02_phy_get_min_avg_rssi(&dev->mt76);
 827         if (avg_rssi > -60)
 828                 init_vga -= 0x20;
 829         else if (avg_rssi > -70)
 830                 init_vga -= 0x10;
 831
 832         val = mt76_rr(dev, MT_BBP(AGC, 8));
 833         val &= 0xFFFF80FF;
 834         val |= init_vga << 8;
 835         mt76_wr(dev, MT_BBP(AGC,8), val);
 836 }
 837
 838 static void mt76x0_phy_calibrate(struct work_struct *work)
 839 {
 840         struct mt76x0_dev *dev = container_of(work, struct mt76x0_dev,
 841                                             cal_work.work);
 842
 843         mt76x0_dynamic_vga_tuning(dev);
 844         mt76x0_temp_sensor(dev);
 845
 846         ieee80211_queue_delayed_work(dev->mt76.hw, &dev->cal_work,
 847                                      MT_CALIBRATE_INTERVAL);
 848 }
 849
 850 static void
 851 mt76x0_rf_init(struct mt76x0_dev *dev)
 852 {
 853         int i;
 854         u8 val;
 855
 856         RF_RANDOM_WRITE(dev, mt76x0_rf_central_tab);
 857         RF_RANDOM_WRITE(dev, mt76x0_rf_2g_channel_0_tab);
 858         RF_RANDOM_WRITE(dev, mt76x0_rf_5g_channel_0_tab);
 859         RF_RANDOM_WRITE(dev, mt76x0_rf_vga_channel_0_tab);
 860
 861         for (i = 0; i < ARRAY_SIZE(mt76x0_rf_bw_switch_tab); i++) {
 862                 const struct mt76x0_rf_switch_item *item = &mt76x0_rf_bw_switch_tab[i];
 863
 864                 if (item->bw_band == RF_BW_20)
 865                         rf_wr(dev, item->rf_bank_reg, item->value);
 866                 else if (((RF_G_BAND | RF_BW_20) & item->bw_band) == (RF_G_BAND | RF_BW_20))
 867                         rf_wr(dev, item->rf_bank_reg, item->value);
 868         }
 869
 870         for (i = 0; i < ARRAY_SIZE(mt76x0_rf_band_switch_tab); i++) {
 871                 if (mt76x0_rf_band_switch_tab[i].bw_band & RF_G_BAND) {
 872                         rf_wr(dev,
 873                               mt76x0_rf_band_switch_tab[i].rf_bank_reg,
 874                               mt76x0_rf_band_switch_tab[i].value);
 875                 }
 876         }
 877
 878         /*
 879            Frequency calibration
 880            E1: B0.R22<6:0>: xo_cxo<6:0>
 881            E2: B0.R21<0>: xo_cxo<0>, B0.R22<7:0>: xo_cxo<8:1>
 882          */
 883         rf_wr(dev, MT_RF(0, 22),
 884               min_t(u8, dev->caldata.freq_offset, 0xbf));
 885         val = rf_rr(dev, MT_RF(0, 22));
 886
 887         /*
 888            Reset the DAC (Set B0.R73<7>=1, then set B0.R73<7>=0, and then set B0.R73<7>) during power up.
 889          */
 890         val = rf_rr(dev, MT_RF(0, 73));
 891         val |= 0x80;
 892         rf_wr(dev, MT_RF(0, 73), val);
 893         val &= ~0x80;
 894         rf_wr(dev, MT_RF(0, 73), val);
 895         val |= 0x80;
 896         rf_wr(dev, MT_RF(0, 73), val);
 897
 898         /*
 899            vcocal_en (initiate VCO calibration (reset after completion)) - It should be at the end of RF configuration.
 900          */
 901         rf_set(dev, MT_RF(0, 4), 0x80);
 902 }
 903
 904 void mt76x0_phy_init(struct mt76x0_dev *dev)
 905 {
 906         INIT_DELAYED_WORK(&dev->cal_work, mt76x0_phy_calibrate);
 907
 908         mt76x0_rf_init(dev);
 909         mt76x02_phy_set_rxpath(&dev->mt76);
 910         mt76x02_phy_set_txdac(&dev->mt76);
 911 }