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