drivers/net/wireless/mediatek/mt76/mt76x0/init.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 "eeprom.h"
  19 #include "trace.h"
  20 #include "mcu.h"
  21 #include "../mt76x02_util.h"
  22 #include "../mt76x02_dma.h"
  23
  24 #include "initvals.h"
  25
  26 static void mt76x0_vht_cap_mask(struct ieee80211_supported_band *sband)
  27 {
  28         struct ieee80211_sta_vht_cap *vht_cap = &sband->vht_cap;
  29         u16 mcs_map = 0;
  30         int i;
  31
  32         vht_cap->cap &= ~IEEE80211_VHT_CAP_RXLDPC;
  33         for (i = 0; i < 8; i++) {
  34                 if (!i)
  35                         mcs_map |= (IEEE80211_VHT_MCS_SUPPORT_0_7 << (i * 2));
  36                 else
  37                         mcs_map |=
  38                                 (IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2));
  39         }
  40         vht_cap->vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
  41         vht_cap->vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
  42 }
  43
  44 static void
  45 mt76x0_set_wlan_state(struct mt76x0_dev *dev, u32 val, bool enable)
  46 {
  47         u32 mask = MT_CMB_CTRL_XTAL_RDY | MT_CMB_CTRL_PLL_LD;
  48
  49         /* Note: we don't turn off WLAN_CLK because that makes the device
  50          *       not respond properly on the probe path.
  51          *       In case anyone (PSM?) wants to use this function we can
  52          *       bring the clock stuff back and fixup the probe path.
  53          */
  54
  55         if (enable)
  56                 val |= (MT_WLAN_FUN_CTRL_WLAN_EN |
  57                         MT_WLAN_FUN_CTRL_WLAN_CLK_EN);
  58         else
  59                 val &= ~(MT_WLAN_FUN_CTRL_WLAN_EN);
  60
  61         mt76_wr(dev, MT_WLAN_FUN_CTRL, val);
  62         udelay(20);
  63
  64         /* Note: vendor driver tries to disable/enable wlan here and retry
  65          *       but the code which does it is so buggy it must have never
  66          *       triggered, so don't bother.
  67          */
  68         if (enable && !mt76_poll(dev, MT_CMB_CTRL, mask, mask, 2000))
  69                 dev_err(dev->mt76.dev, "PLL and XTAL check failed\n");
  70 }
  71
  72 void mt76x0_chip_onoff(struct mt76x0_dev *dev, bool enable, bool reset)
  73 {
  74         u32 val;
  75
  76         val = mt76_rr(dev, MT_WLAN_FUN_CTRL);
  77
  78         if (reset) {
  79                 val |= MT_WLAN_FUN_CTRL_GPIO_OUT_EN;
  80                 val &= ~MT_WLAN_FUN_CTRL_FRC_WL_ANT_SEL;
  81
  82                 if (val & MT_WLAN_FUN_CTRL_WLAN_EN) {
  83                         val |= (MT_WLAN_FUN_CTRL_WLAN_RESET |
  84                                 MT_WLAN_FUN_CTRL_WLAN_RESET_RF);
  85                         mt76_wr(dev, MT_WLAN_FUN_CTRL, val);
  86                         udelay(20);
  87
  88                         val &= ~(MT_WLAN_FUN_CTRL_WLAN_RESET |
  89                                  MT_WLAN_FUN_CTRL_WLAN_RESET_RF);
  90                 }
  91         }
  92
  93         mt76_wr(dev, MT_WLAN_FUN_CTRL, val);
  94         udelay(20);
  95
  96         mt76x0_set_wlan_state(dev, val, enable);
  97 }
  98 EXPORT_SYMBOL_GPL(mt76x0_chip_onoff);
  99
 100 static void mt76x0_reset_csr_bbp(struct mt76x0_dev *dev)
 101 {
 102         mt76_wr(dev, MT_MAC_SYS_CTRL,
 103                 MT_MAC_SYS_CTRL_RESET_CSR |
 104                 MT_MAC_SYS_CTRL_RESET_BBP);
 105         msleep(200);
 106         mt76_clear(dev, MT_MAC_SYS_CTRL,
 107                    MT_MAC_SYS_CTRL_RESET_CSR |
 108                    MT_MAC_SYS_CTRL_RESET_BBP);
 109 }
 110
 111 #define RANDOM_WRITE(dev, tab)                  \
 112         mt76_wr_rp(dev, MT_MCU_MEMMAP_WLAN,     \
 113                    tab, ARRAY_SIZE(tab))
 114
 115 static int mt76x0_init_bbp(struct mt76x0_dev *dev)
 116 {
 117         int ret, i;
 118
 119         ret = mt76x0_wait_bbp_ready(dev);
 120         if (ret)
 121                 return ret;
 122
 123         RANDOM_WRITE(dev, mt76x0_bbp_init_tab);
 124
 125         for (i = 0; i < ARRAY_SIZE(mt76x0_bbp_switch_tab); i++) {
 126                 const struct mt76x0_bbp_switch_item *item = &mt76x0_bbp_switch_tab[i];
 127                 const struct mt76_reg_pair *pair = &item->reg_pair;
 128
 129                 if (((RF_G_BAND | RF_BW_20) & item->bw_band) == (RF_G_BAND | RF_BW_20))
 130                         mt76_wr(dev, pair->reg, pair->value);
 131         }
 132
 133         RANDOM_WRITE(dev, mt76x0_dcoc_tab);
 134
 135         return 0;
 136 }
 137
 138 static void mt76x0_init_mac_registers(struct mt76x0_dev *dev)
 139 {
 140         u32 reg;
 141
 142         RANDOM_WRITE(dev, common_mac_reg_table);
 143
 144         mt76x02_set_beacon_offsets(&dev->mt76);
 145
 146         /* Enable PBF and MAC clock SYS_CTRL[11:10] = 0x3 */
 147         RANDOM_WRITE(dev, mt76x0_mac_reg_table);
 148
 149         /* Release BBP and MAC reset MAC_SYS_CTRL[1:0] = 0x0 */
 150         reg = mt76_rr(dev, MT_MAC_SYS_CTRL);
 151         reg &= ~0x3;
 152         mt76_wr(dev, MT_MAC_SYS_CTRL, reg);
 153
 154         /* Set 0x141C[15:12]=0xF */
 155         reg = mt76_rr(dev, MT_EXT_CCA_CFG);
 156         reg |= 0x0000F000;
 157         mt76_wr(dev, MT_EXT_CCA_CFG, reg);
 158
 159         mt76_clear(dev, MT_FCE_L2_STUFF, MT_FCE_L2_STUFF_WR_MPDU_LEN_EN);
 160
 161         /*
 162                 TxRing 9 is for Mgmt frame.
 163                 TxRing 8 is for In-band command frame.
 164                 WMM_RG0_TXQMA: This register setting is for FCE to define the rule of TxRing 9.
 165                 WMM_RG1_TXQMA: This register setting is for FCE to define the rule of TxRing 8.
 166         */
 167         reg = mt76_rr(dev, MT_WMM_CTRL);
 168         reg &= ~0x000003FF;
 169         reg |= 0x00000201;
 170         mt76_wr(dev, MT_WMM_CTRL, reg);
 171 }
 172
 173 static int mt76x0_init_wcid_mem(struct mt76x0_dev *dev)
 174 {
 175         u32 *vals;
 176         int i;
 177
 178         vals = kmalloc(sizeof(*vals) * MT76_N_WCIDS * 2, GFP_KERNEL);
 179         if (!vals)
 180                 return -ENOMEM;
 181
 182         for (i = 0; i < MT76_N_WCIDS; i++)  {
 183                 vals[i * 2] = 0xffffffff;
 184                 vals[i * 2 + 1] = 0x00ffffff;
 185         }
 186
 187         mt76_wr_copy(dev, MT_WCID_ADDR_BASE, vals, MT76_N_WCIDS * 2);
 188         kfree(vals);
 189         return 0;
 190 }
 191
 192 static void mt76x0_init_key_mem(struct mt76x0_dev *dev)
 193 {
 194         u32 vals[4] = {};
 195
 196         mt76_wr_copy(dev, MT_SKEY_MODE_BASE_0, vals, ARRAY_SIZE(vals));
 197 }
 198
 199 static int mt76x0_init_wcid_attr_mem(struct mt76x0_dev *dev)
 200 {
 201         u32 *vals;
 202         int i;
 203
 204         vals = kmalloc(sizeof(*vals) * MT76_N_WCIDS * 2, GFP_KERNEL);
 205         if (!vals)
 206                 return -ENOMEM;
 207
 208         for (i = 0; i < MT76_N_WCIDS * 2; i++)
 209                 vals[i] = 1;
 210
 211         mt76_wr_copy(dev, MT_WCID_ATTR_BASE, vals, MT76_N_WCIDS * 2);
 212         kfree(vals);
 213         return 0;
 214 }
 215
 216 static void mt76x0_reset_counters(struct mt76x0_dev *dev)
 217 {
 218         mt76_rr(dev, MT_RX_STAT_0);
 219         mt76_rr(dev, MT_RX_STAT_1);
 220         mt76_rr(dev, MT_RX_STAT_2);
 221         mt76_rr(dev, MT_TX_STA_0);
 222         mt76_rr(dev, MT_TX_STA_1);
 223         mt76_rr(dev, MT_TX_STA_2);
 224 }
 225
 226 int mt76x0_mac_start(struct mt76x0_dev *dev)
 227 {
 228         mt76_wr(dev, MT_MAC_SYS_CTRL, MT_MAC_SYS_CTRL_ENABLE_TX);
 229
 230         if (!mt76x02_wait_for_wpdma(&dev->mt76, 200000))
 231                 return -ETIMEDOUT;
 232
 233         mt76_wr(dev, MT_RX_FILTR_CFG, dev->mt76.rxfilter);
 234         mt76_wr(dev, MT_MAC_SYS_CTRL,
 235                 MT_MAC_SYS_CTRL_ENABLE_TX | MT_MAC_SYS_CTRL_ENABLE_RX);
 236
 237         return !mt76x02_wait_for_wpdma(&dev->mt76, 50) ? -ETIMEDOUT : 0;
 238 }
 239 EXPORT_SYMBOL_GPL(mt76x0_mac_start);
 240
 241 void mt76x0_mac_stop(struct mt76x0_dev *dev)
 242 {
 243         int i = 200, ok = 0;
 244
 245         /* Page count on TxQ */
 246         while (i-- && ((mt76_rr(dev, 0x0438) & 0xffffffff) ||
 247                        (mt76_rr(dev, 0x0a30) & 0x000000ff) ||
 248                        (mt76_rr(dev, 0x0a34) & 0x00ff00ff)))
 249                 msleep(10);
 250
 251         if (!mt76_poll(dev, MT_MAC_STATUS, MT_MAC_STATUS_TX, 0, 1000))
 252                 dev_warn(dev->mt76.dev, "Warning: MAC TX did not stop!\n");
 253
 254         mt76_clear(dev, MT_MAC_SYS_CTRL, MT_MAC_SYS_CTRL_ENABLE_RX |
 255                                          MT_MAC_SYS_CTRL_ENABLE_TX);
 256
 257         /* Page count on RxQ */
 258         for (i = 0; i < 200; i++) {
 259                 if (!(mt76_rr(dev, MT_RXQ_STA) & 0x00ff0000) &&
 260                     !mt76_rr(dev, 0x0a30) &&
 261                     !mt76_rr(dev, 0x0a34)) {
 262                         if (ok++ > 5)
 263                                 break;
 264                         continue;
 265                 }
 266                 msleep(1);
 267         }
 268
 269         if (!mt76_poll(dev, MT_MAC_STATUS, MT_MAC_STATUS_RX, 0, 1000))
 270                 dev_warn(dev->mt76.dev, "Warning: MAC RX did not stop!\n");
 271 }
 272 EXPORT_SYMBOL_GPL(mt76x0_mac_stop);
 273
 274 int mt76x0_init_hardware(struct mt76x0_dev *dev)
 275 {
 276         int ret;
 277
 278         if (!mt76x02_wait_for_wpdma(&dev->mt76, 1000))
 279                 return -EIO;
 280
 281         /* Wait for ASIC ready after FW load. */
 282         if (!mt76x02_wait_for_mac(&dev->mt76))
 283                 return -ETIMEDOUT;
 284
 285         mt76x0_reset_csr_bbp(dev);
 286         ret = mt76x02_mcu_function_select(&dev->mt76, Q_SELECT, 1, false);
 287         if (ret)
 288                 return ret;
 289
 290         mt76x0_init_mac_registers(dev);
 291
 292         if (!mt76x02_wait_for_txrx_idle(&dev->mt76))
 293                 return -EIO;
 294
 295         ret = mt76x0_init_bbp(dev);
 296         if (ret)
 297                 return ret;
 298
 299         dev->mt76.rxfilter = mt76_rr(dev, MT_RX_FILTR_CFG);
 300
 301         ret = mt76x0_init_wcid_mem(dev);
 302         if (ret)
 303                 return ret;
 304
 305         mt76x0_init_key_mem(dev);
 306
 307         ret = mt76x0_init_wcid_attr_mem(dev);
 308         if (ret)
 309                 return ret;
 310
 311         mt76_clear(dev, MT_BEACON_TIME_CFG, (MT_BEACON_TIME_CFG_TIMER_EN |
 312                                              MT_BEACON_TIME_CFG_SYNC_MODE |
 313                                              MT_BEACON_TIME_CFG_TBTT_EN |
 314                                              MT_BEACON_TIME_CFG_BEACON_TX));
 315
 316         mt76x0_reset_counters(dev);
 317
 318         ret = mt76x0_eeprom_init(dev);
 319         if (ret)
 320                 return ret;
 321
 322         mt76x0_phy_init(dev);
 323
 324         return 0;
 325 }
 326 EXPORT_SYMBOL_GPL(mt76x0_init_hardware);
 327
 328 struct mt76x0_dev *
 329 mt76x0_alloc_device(struct device *pdev,
 330                     const struct mt76_driver_ops *drv_ops,
 331                     const struct ieee80211_ops *ops)
 332 {
 333         struct mt76x0_dev *dev;
 334         struct mt76_dev *mdev;
 335
 336         mdev = mt76_alloc_device(sizeof(*dev), ops);
 337         if (!mdev)
 338                 return NULL;
 339
 340         mdev->dev = pdev;
 341         mdev->drv = drv_ops;
 342
 343         dev = container_of(mdev, struct mt76x0_dev, mt76);
 344         mutex_init(&dev->reg_atomic_mutex);
 345         atomic_set(&dev->avg_ampdu_len, 1);
 346
 347         return dev;
 348 }
 349 EXPORT_SYMBOL_GPL(mt76x0_alloc_device);
 350
 351 int mt76x0_register_device(struct mt76x0_dev *dev)
 352 {
 353         struct mt76_dev *mdev = &dev->mt76;
 354         struct ieee80211_hw *hw = mdev->hw;
 355         struct wiphy *wiphy = hw->wiphy;
 356         int ret;
 357
 358         /* Reserve WCID 0 for mcast - thanks to this APs WCID will go to
 359          * entry no. 1 like it does in the vendor driver.
 360          */
 361         mdev->wcid_mask[0] |= 1;
 362
 363         /* init fake wcid for monitor interfaces */
 364         mdev->global_wcid.idx = 0xff;
 365         mdev->global_wcid.hw_key_idx = -1;
 366
 367         /* init antenna configuration */
 368         mdev->antenna_mask = 1;
 369
 370         hw->queues = 4;
 371         hw->max_rates = 1;
 372         hw->max_report_rates = 7;
 373         hw->max_rate_tries = 1;
 374         hw->extra_tx_headroom = sizeof(struct mt76x02_txwi) + 4 + 2;
 375
 376         hw->sta_data_size = sizeof(struct mt76x02_sta);
 377         hw->vif_data_size = sizeof(struct mt76x02_vif);
 378
 379         wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
 380
 381         INIT_DELAYED_WORK(&dev->mac_work, mt76x0_mac_work);
 382
 383         ret = mt76_register_device(mdev, true, mt76x02_rates,
 384                                    ARRAY_SIZE(mt76x02_rates));
 385         if (ret)
 386                 return ret;
 387
 388         /* overwrite unsupported features */
 389         if (mdev->cap.has_5ghz)
 390                 mt76x0_vht_cap_mask(&dev->mt76.sband_5g.sband);
 391
 392         mt76x0_init_debugfs(dev);
 393
 394         return 0;
 395 }
 396 EXPORT_SYMBOL_GPL(mt76x0_register_device);