rt2860_rf.c

   1
   2 /*-
   3  * Copyright (c) 2009-2010 Alexander Egorenkov <egorenar@gmail.com>
   4  * Copyright (c) 2009 Damien Bergamini <damien.bergamini@free.fr>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 #include "rt2860_rf.h"
  20 #include "rt2860_reg.h"
  21 #include "rt2860_eeprom.h"
  22 #include "rt2860_io.h"
  23 #include "rt2860_debug.h"
  24
  25 /*
  26  * Static variables
  27  */
  28
  29 static const struct rt2860_rf_prog
  30 {
  31         uint8_t chan;
  32         uint32_t r1, r2, r3, r4;
  33 } rt2860_rf_2850[] =
  34 {
  35         {   1, 0x98402ecc, 0x984c0786, 0x9816b455, 0x9800510b },
  36         {   2, 0x98402ecc, 0x984c0786, 0x98168a55, 0x9800519f },
  37         {   3, 0x98402ecc, 0x984c078a, 0x98168a55, 0x9800518b },
  38         {   4, 0x98402ecc, 0x984c078a, 0x98168a55, 0x9800519f },
  39         {   5, 0x98402ecc, 0x984c078e, 0x98168a55, 0x9800518b },
  40         {   6, 0x98402ecc, 0x984c078e, 0x98168a55, 0x9800519f },
  41         {   7, 0x98402ecc, 0x984c0792, 0x98168a55, 0x9800518b },
  42         {   8, 0x98402ecc, 0x984c0792, 0x98168a55, 0x9800519f },
  43         {   9, 0x98402ecc, 0x984c0796, 0x98168a55, 0x9800518b },
  44         {  10, 0x98402ecc, 0x984c0796, 0x98168a55, 0x9800519f },
  45         {  11, 0x98402ecc, 0x984c079a, 0x98168a55, 0x9800518b },
  46         {  12, 0x98402ecc, 0x984c079a, 0x98168a55, 0x9800519f },
  47         {  13, 0x98402ecc, 0x984c079e, 0x98168a55, 0x9800518b },
  48         {  14, 0x98402ecc, 0x984c07a2, 0x98168a55, 0x98005193 },
  49         {  36, 0x98402ecc, 0x984c099a, 0x98158a55, 0x980ed1a3 },
  50         {  38, 0x98402ecc, 0x984c099e, 0x98158a55, 0x980ed193 },
  51         {  40, 0x98402ec8, 0x984c0682, 0x98158a55, 0x980ed183 },
  52         {  44, 0x98402ec8, 0x984c0682, 0x98158a55, 0x980ed1a3 },
  53         {  46, 0x98402ec8, 0x984c0686, 0x98158a55, 0x980ed18b },
  54         {  48, 0x98402ec8, 0x984c0686, 0x98158a55, 0x980ed19b },
  55         {  52, 0x98402ec8, 0x984c068a, 0x98158a55, 0x980ed193 },
  56         {  54, 0x98402ec8, 0x984c068a, 0x98158a55, 0x980ed1a3 },
  57         {  56, 0x98402ec8, 0x984c068e, 0x98158a55, 0x980ed18b },
  58         {  60, 0x98402ec8, 0x984c0692, 0x98158a55, 0x980ed183 },
  59         {  62, 0x98402ec8, 0x984c0692, 0x98158a55, 0x980ed193 },
  60         {  64, 0x98402ec8, 0x984c0692, 0x98158a55, 0x980ed1a3 },
  61         { 100, 0x98402ec8, 0x984c06b2, 0x98178a55, 0x980ed783 },
  62         { 102, 0x98402ec8, 0x985c06b2, 0x98578a55, 0x980ed793 },
  63         { 104, 0x98402ec8, 0x985c06b2, 0x98578a55, 0x980ed1a3 },
  64         { 108, 0x98402ecc, 0x985c0a32, 0x98578a55, 0x980ed193 },
  65         { 110, 0x98402ecc, 0x984c0a36, 0x98178a55, 0x980ed183 },
  66         { 112, 0x98402ecc, 0x984c0a36, 0x98178a55, 0x980ed19b },
  67         { 116, 0x98402ecc, 0x984c0a3a, 0x98178a55, 0x980ed1a3 },
  68         { 118, 0x98402ecc, 0x984c0a3e, 0x98178a55, 0x980ed193 },
  69         { 120, 0x98402ec4, 0x984c0382, 0x98178a55, 0x980ed183 },
  70         { 124, 0x98402ec4, 0x984c0382, 0x98178a55, 0x980ed193 },
  71         { 126, 0x98402ec4, 0x984c0382, 0x98178a55, 0x980ed15b },
  72         { 128, 0x98402ec4, 0x984c0382, 0x98178a55, 0x980ed1a3 },
  73         { 132, 0x98402ec4, 0x984c0386, 0x98178a55, 0x980ed18b },
  74         { 134, 0x98402ec4, 0x984c0386, 0x98178a55, 0x980ed193 },
  75         { 136, 0x98402ec4, 0x984c0386, 0x98178a55, 0x980ed19b },
  76         { 140, 0x98402ec4, 0x984c038a, 0x98178a55, 0x980ed183 },
  77         { 149, 0x98402ec4, 0x984c038a, 0x98178a55, 0x980ed1a7 },
  78         { 151, 0x98402ec4, 0x984c038e, 0x98178a55, 0x980ed187 },
  79         { 153, 0x98402ec4, 0x984c038e, 0x98178a55, 0x980ed18f },
  80         { 157, 0x98402ec4, 0x984c038e, 0x98178a55, 0x980ed19f },
  81         { 159, 0x98402ec4, 0x984c038e, 0x98178a55, 0x980ed1a7 },
  82         { 161, 0x98402ec4, 0x984c0392, 0x98178a55, 0x980ed187 },
  83         { 165, 0x98402ec4, 0x984c0392, 0x98178a55, 0x980ed197 },
  84         { 184, 0x95002ccc, 0x9500491e, 0x9509be55, 0x950c0a0b },
  85         { 188, 0x95002ccc, 0x95004922, 0x9509be55, 0x950c0a13 },
  86         { 192, 0x95002ccc, 0x95004926, 0x9509be55, 0x950c0a1b },
  87         { 196, 0x95002ccc, 0x9500492a, 0x9509be55, 0x950c0a23 },
  88         { 208, 0x95002ccc, 0x9500493a, 0x9509be55, 0x950c0a13 },
  89         { 212, 0x95002ccc, 0x9500493e, 0x9509be55, 0x950c0a1b },
  90         { 216, 0x95002ccc, 0x95004982, 0x9509be55, 0x950c0a23 },
  91 };
  92
  93 /*
  94  * rt2860_rf_name
  95  */
  96 const char *rt2860_rf_name(int rf_rev)
  97 {
  98         switch (rf_rev)
  99         {
 100                 case RT2860_EEPROM_RF_2820:
 101                         return "RT2820";
 102
 103                 case RT2860_EEPROM_RF_2850:
 104                         return "RT2850";
 105
 106                 case RT2860_EEPROM_RF_2720:
 107                         return "RT2720";
 108
 109                 case RT2860_EEPROM_RF_2750:
 110                         return "RT2750";
 111
 112                 default:
 113                         return "unknown";
 114         }
 115 }
 116
 117 /*
 118  * rt2860_rf_select_chan_group
 119  */
 120 void rt2860_rf_select_chan_group(struct rt2860_softc *sc,
 121         struct ieee80211_channel *c)
 122 {
 123         struct ifnet *ifp;
 124         struct ieee80211com *ic;
 125         int chan, group;
 126         uint32_t tmp;
 127
 128         ifp = sc->ifp;
 129         ic = ifp->if_l2com;
 130
 131         chan = ieee80211_chan2ieee(ic, c);
 132         if (chan == 0 || chan == IEEE80211_CHAN_ANY)
 133                 return;
 134
 135         if (chan <= 14)
 136                 group = 0;
 137         else if (chan <= 64)
 138                 group = 1;
 139         else if (chan <= 128)
 140                 group = 2;
 141         else
 142                 group = 3;
 143
 144         rt2860_io_bbp_write(sc, 62, 0x37 - sc->lna_gain[group]);
 145         rt2860_io_bbp_write(sc, 63, 0x37 - sc->lna_gain[group]);
 146         rt2860_io_bbp_write(sc, 64, 0x37 - sc->lna_gain[group]);
 147         rt2860_io_bbp_write(sc, 86, 0x00);
 148
 149         if (group == 0)
 150         {
 151                 if (sc->ext_lna_2ghz)
 152                 {
 153                         rt2860_io_bbp_write(sc, 82, 0x62);
 154                         rt2860_io_bbp_write(sc, 75, 0x46);
 155                 }
 156                 else
 157                 {
 158                         rt2860_io_bbp_write(sc, 82, 0x84);
 159                         rt2860_io_bbp_write(sc, 75, 0x50);
 160                 }
 161         }
 162         else
 163         {
 164                 rt2860_io_bbp_write(sc, 82, 0xf2);
 165
 166                 if (sc->ext_lna_5ghz)
 167                         rt2860_io_bbp_write(sc, 75, 0x46);
 168                 else
 169                         rt2860_io_bbp_write(sc, 75, 0x50);
 170         }
 171
 172         if (group == 0)
 173         {
 174                 tmp = 0x2e + sc->lna_gain[group];
 175         }
 176         else
 177         {
 178                 if ((ic->ic_flags & IEEE80211_F_SCAN) || !IEEE80211_IS_CHAN_HT40(c))
 179                         tmp = 0x32 + sc->lna_gain[group] * 5 / 3;
 180                 else
 181                         tmp = 0x3a + sc->lna_gain[group] * 5 / 3;
 182         }
 183
 184         rt2860_io_bbp_write(sc, 66, tmp);
 185
 186         tmp = RT2860_REG_RFTR_ENABLE | RT2860_REG_TRSW_ENABLE;
 187
 188         if (group == 0)
 189         {
 190                 tmp |= RT2860_REG_LNA_PE_A1_ENABLE |
 191                         RT2860_REG_LNA_PE_G0_ENABLE |
 192                         RT2860_REG_LNA_PE_A0_ENABLE |
 193                         RT2860_REG_PA_PE_A1_ENABLE |
 194                         RT2860_REG_PA_PE_G0_ENABLE |
 195                         RT2860_REG_PA_PE_A0_ENABLE;
 196
 197                 if (sc->ntxpath > 1)
 198                         tmp |= RT2860_REG_PA_PE_G1_ENABLE;
 199
 200                 if (sc->nrxpath > 1)
 201                         tmp |= RT2860_REG_LNA_PE_G1_ENABLE;
 202         }
 203         else
 204         {
 205                 tmp |= RT2860_REG_LNA_PE_G1_ENABLE |
 206                         RT2860_REG_LNA_PE_G0_ENABLE |
 207                         RT2860_REG_LNA_PE_A0_ENABLE |
 208                         RT2860_REG_PA_PE_G1_ENABLE |
 209                         RT2860_REG_PA_PE_G0_ENABLE |
 210                         RT2860_REG_PA_PE_A0_ENABLE;
 211
 212                 if (sc->ntxpath > 1)
 213                         tmp |= RT2860_REG_PA_PE_A1_ENABLE;
 214
 215                 if (sc->nrxpath > 1)
 216                         tmp |= RT2860_REG_LNA_PE_A1_ENABLE;
 217         }
 218
 219         rt2860_io_mac_write(sc, RT2860_REG_TX_PIN_CFG, tmp);
 220
 221         tmp = rt2860_io_mac_read(sc, RT2860_REG_TX_BAND_CFG);
 222
 223         tmp &= ~(RT2860_REG_TX_BAND_BG | RT2860_REG_TX_BAND_A | RT2860_REG_TX_BAND_HT40_ABOVE);
 224
 225         if (group == 0)
 226                 tmp |= RT2860_REG_TX_BAND_BG;
 227         else
 228                 tmp |= RT2860_REG_TX_BAND_A;
 229
 230         /* set central channel position */
 231
 232         if (IEEE80211_IS_CHAN_HT40U(c))
 233                 tmp |= RT2860_REG_TX_BAND_HT40_BELOW;
 234         else if (IEEE80211_IS_CHAN_HT40D(c))
 235                 tmp |= RT2860_REG_TX_BAND_HT40_ABOVE;
 236         else
 237                 tmp |= RT2860_REG_TX_BAND_HT40_BELOW;
 238
 239         rt2860_io_mac_write(sc, RT2860_REG_TX_BAND_CFG, tmp);
 240
 241         /* set bandwidth (20MHz or 40MHz) */
 242
 243         tmp = rt2860_io_bbp_read(sc, 4);
 244
 245         tmp &= ~0x18;
 246
 247         if (IEEE80211_IS_CHAN_HT40(c))
 248                 tmp |= 0x10;
 249
 250         rt2860_io_bbp_write(sc, 4, tmp);
 251
 252         /* set central channel position */
 253
 254         tmp = rt2860_io_bbp_read(sc, 3);
 255
 256         tmp &= ~0x20;
 257
 258         if (IEEE80211_IS_CHAN_HT40D(c))
 259                 tmp |= 0x20;
 260
 261         rt2860_io_bbp_write(sc, 3, tmp);
 262
 263         if (sc->mac_rev == 0x28600100)
 264         {
 265                 if (!IEEE80211_IS_CHAN_HT40(c))
 266                 {
 267                         rt2860_io_bbp_write(sc, 69, 0x16);
 268                         rt2860_io_bbp_write(sc, 70, 0x08);
 269                         rt2860_io_bbp_write(sc, 73, 0x12);
 270                 }
 271                 else
 272                 {
 273                         rt2860_io_bbp_write(sc, 69, 0x1a);
 274                         rt2860_io_bbp_write(sc, 70, 0x0a);
 275                         rt2860_io_bbp_write(sc, 73, 0x16);
 276                 }
 277         }
 278 }
 279
 280 /*
 281  * rt2860_rf_set_chan
 282  */
 283 void rt2860_rf_set_chan(struct rt2860_softc *sc,
 284         struct ieee80211_channel *c)
 285 {
 286         struct ifnet *ifp;
 287         struct ieee80211com *ic;
 288         const struct rt2860_rf_prog *prog;
 289         uint32_t r1, r2, r3, r4;
 290         int8_t txpow1, txpow2;
 291         int i, chan;
 292
 293         ifp = sc->ifp;
 294         ic = ifp->if_l2com;
 295         prog = rt2860_rf_2850;
 296
 297         /* get central channel position */
 298
 299         chan = ieee80211_chan2ieee(ic, c);
 300
 301         if (IEEE80211_IS_CHAN_HT40U(c))
 302                 chan += 2;
 303         else if (IEEE80211_IS_CHAN_HT40D(c))
 304                 chan -= 2;
 305
 306         RT2860_DPRINTF(sc, RT2860_DEBUG_CHAN,
 307                 "%s: RF set channel: channel=%u, HT%s%s\n",
 308                 device_get_nameunit(sc->dev),
 309                 ieee80211_chan2ieee(ic, c),
 310                 !IEEE80211_IS_CHAN_HT(c) ? " disabled" :
 311                         IEEE80211_IS_CHAN_HT20(c) ? "20":
 312                                 IEEE80211_IS_CHAN_HT40U(c) ? "40U" : "40D",
 313                 (ic->ic_flags & IEEE80211_F_SCAN) ? ", scanning" : "");
 314
 315         if (chan == 0 || chan == IEEE80211_CHAN_ANY)
 316                 return;
 317
 318         for (i = 0; prog[i].chan != chan; i++);
 319
 320         r1 = prog[i].r1;
 321         r2 = prog[i].r2;
 322         r3 = prog[i].r3;
 323         r4 = prog[i].r4;
 324
 325         txpow1 = sc->txpow1[i];
 326         txpow2 = sc->txpow2[i];
 327
 328         if (sc->ntxpath == 1)
 329                 r2 |= (1 << 14);
 330
 331         if (sc->nrxpath == 2)
 332                 r2 |= (1 << 6);
 333         else if (sc->nrxpath == 1)
 334                 r2 |= (1 << 17) | (1 << 6);
 335
 336         if (IEEE80211_IS_CHAN_2GHZ(c))
 337         {
 338                 r3 = (r3 & 0xffffc1ff) | (txpow1 << 9);
 339                 r4 = (r4 & ~0x001f87c0) | (sc->rf_freq_off << 15) | (txpow2 << 6);
 340         }
 341         else
 342         {
 343                 r3 = r3 & 0xffffc1ff;
 344                 r4 = (r4 & ~0x001f87c0) | (sc->rf_freq_off << 15);
 345
 346                 if (txpow1 >= RT2860_EEPROM_TXPOW_5GHZ_MIN && txpow1 < 0)
 347                 {
 348                         txpow1 = (-RT2860_EEPROM_TXPOW_5GHZ_MIN + txpow1);
 349                         if (txpow1 > RT2860_EEPROM_TXPOW_5GHZ_MAX)
 350                                 txpow1 = RT2860_EEPROM_TXPOW_5GHZ_MAX;
 351
 352                         r3 |= (txpow1 << 10);
 353                 }
 354                 else
 355                 {
 356                         if (txpow1 > RT2860_EEPROM_TXPOW_5GHZ_MAX)
 357                                 txpow1 = RT2860_EEPROM_TXPOW_5GHZ_MAX;
 358
 359                         r3 |= (txpow1 << 10) | (1 << 9);
 360                 }
 361
 362                 if (txpow2 >= RT2860_EEPROM_TXPOW_5GHZ_MIN && txpow2 < 0)
 363                 {
 364                         txpow2 = (-RT2860_EEPROM_TXPOW_5GHZ_MIN + txpow2);
 365                         if (txpow2 > RT2860_EEPROM_TXPOW_5GHZ_MAX)
 366                                 txpow2 = RT2860_EEPROM_TXPOW_5GHZ_MAX;
 367
 368                         r4 |= (txpow2 << 7);
 369                 }
 370                 else
 371                 {
 372                         if (txpow2 > RT2860_EEPROM_TXPOW_5GHZ_MAX)
 373                                 txpow2 = RT2860_EEPROM_TXPOW_5GHZ_MAX;
 374
 375                         r4 |= (txpow2 << 7) | (1 << 6);
 376                 }
 377         }
 378
 379         if (!(ic->ic_flags & IEEE80211_F_SCAN) && IEEE80211_IS_CHAN_HT40(c))
 380                 r4 |= (1 << 21);
 381
 382         rt2860_io_rf_write(sc, RT2860_REG_RF_R1, r1);
 383         rt2860_io_rf_write(sc, RT2860_REG_RF_R2, r2);
 384         rt2860_io_rf_write(sc, RT2860_REG_RF_R3, r3 & ~(1 << 2));
 385         rt2860_io_rf_write(sc, RT2860_REG_RF_R4, r4);
 386
 387         DELAY(200);
 388
 389         rt2860_io_rf_write(sc, RT2860_REG_RF_R1, r1);
 390         rt2860_io_rf_write(sc, RT2860_REG_RF_R2, r2);
 391         rt2860_io_rf_write(sc, RT2860_REG_RF_R3, r3 | (1 << 2));
 392         rt2860_io_rf_write(sc, RT2860_REG_RF_R4, r4);
 393
 394         DELAY(200);
 395
 396         rt2860_io_rf_write(sc, RT2860_REG_RF_R1, r1);
 397         rt2860_io_rf_write(sc, RT2860_REG_RF_R2, r2);
 398         rt2860_io_rf_write(sc, RT2860_REG_RF_R3, r3 & ~(1 << 2));
 399         rt2860_io_rf_write(sc, RT2860_REG_RF_R4, r4);
 400
 401         rt2860_rf_select_chan_group(sc, c);
 402
 403         DELAY(1000);
 404 }