drivers/net/wireless/mediatek/mt76-6e-usb/mt7921/init.c

   1 // SPDX-License-Identifier: ISC
   2 /* Copyright (C) 2020 MediaTek Inc. */
   3
   4 #include <linux/etherdevice.h>
   5 #include "mt7921.h"
   6 #include "mac.h"
   7 #include "mcu.h"
   8 #include "eeprom.h"
   9
  10 static const struct ieee80211_iface_limit if_limits[] = {
  11         {
  12                 .max = MT7921_MAX_INTERFACES,
  13                 .types = BIT(NL80211_IFTYPE_STATION)
  14         }
  15 };
  16
  17 static const struct ieee80211_iface_combination if_comb[] = {
  18         {
  19                 .limits = if_limits,
  20                 .n_limits = ARRAY_SIZE(if_limits),
  21                 .max_interfaces = MT7921_MAX_INTERFACES,
  22                 .num_different_channels = 1,
  23                 .beacon_int_infra_match = true,
  24         }
  25 };
  26
  27 static void
  28 mt7921_regd_notifier(struct wiphy *wiphy,
  29                      struct regulatory_request *request)
  30 {
  31         struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
  32         struct mt7921_dev *dev = mt7921_hw_dev(hw);
  33         struct mt7921_phy *phy = mt7921_hw_phy(hw);
  34
  35         memcpy(dev->mt76.alpha2, request->alpha2, sizeof(dev->mt76.alpha2));
  36         dev->mt76.region = request->dfs_region;
  37
  38         mt7921_mutex_acquire(dev);
  39         mt76_connac_mcu_set_channel_domain(hw->priv);
  40         mt76_connac_mcu_set_rate_txpower(phy->mt76);
  41         mt7921_mutex_release(dev);
  42 }
  43
  44 static int
  45 mt7921_init_wiphy(struct ieee80211_hw *hw)
  46 {
  47         struct mt7921_phy *phy = mt7921_hw_phy(hw);
  48         struct mt7921_dev *dev = phy->dev;
  49         struct wiphy *wiphy = hw->wiphy;
  50
  51         hw->queues = 4;
  52         hw->max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HE;
  53         hw->max_tx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HE;
  54         hw->netdev_features = NETIF_F_RXCSUM;
  55
  56         hw->radiotap_timestamp.units_pos =
  57                 IEEE80211_RADIOTAP_TIMESTAMP_UNIT_US;
  58
  59         phy->slottime = 9;
  60
  61         hw->sta_data_size = sizeof(struct mt7921_sta);
  62         hw->vif_data_size = sizeof(struct mt7921_vif);
  63
  64         wiphy->iface_combinations = if_comb;
  65         wiphy->flags &= ~(WIPHY_FLAG_IBSS_RSN | WIPHY_FLAG_4ADDR_AP |
  66                           WIPHY_FLAG_4ADDR_STATION);
  67         wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
  68         wiphy->n_iface_combinations = ARRAY_SIZE(if_comb);
  69         wiphy->max_scan_ie_len = MT76_CONNAC_SCAN_IE_LEN;
  70         wiphy->max_scan_ssids = 4;
  71         wiphy->max_sched_scan_plan_interval =
  72                 MT76_CONNAC_MAX_TIME_SCHED_SCAN_INTERVAL;
  73         wiphy->max_sched_scan_ie_len = IEEE80211_MAX_DATA_LEN;
  74         wiphy->max_sched_scan_ssids = MT76_CONNAC_MAX_SCHED_SCAN_SSID;
  75         wiphy->max_match_sets = MT76_CONNAC_MAX_SCAN_MATCH;
  76         wiphy->max_sched_scan_reqs = 1;
  77         wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
  78         wiphy->reg_notifier = mt7921_regd_notifier;
  79
  80         wiphy->features |= NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR |
  81                            NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;
  82         wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_SET_SCAN_DWELL);
  83
  84         ieee80211_hw_set(hw, SINGLE_SCAN_ON_ALL_BANDS);
  85         ieee80211_hw_set(hw, HAS_RATE_CONTROL);
  86         ieee80211_hw_set(hw, SUPPORTS_TX_ENCAP_OFFLOAD);
  87         ieee80211_hw_set(hw, SUPPORTS_RX_DECAP_OFFLOAD);
  88         ieee80211_hw_set(hw, WANT_MONITOR_VIF);
  89         ieee80211_hw_set(hw, SUPPORTS_PS);
  90         ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS);
  91
  92         if (dev->pm.enable)
  93                 ieee80211_hw_set(hw, CONNECTION_MONITOR);
  94
  95         hw->max_tx_fragments = 4;
  96
  97         return 0;
  98 }
  99
 100 static void
 101 mt7921_mac_init_band(struct mt7921_dev *dev, u8 band)
 102 {
 103         mt76_rmw_field(dev, MT_TMAC_CTCR0(band),
 104                        MT_TMAC_CTCR0_INS_DDLMT_REFTIME, 0x3f);
 105         mt76_set(dev, MT_TMAC_CTCR0(band),
 106                  MT_TMAC_CTCR0_INS_DDLMT_VHT_SMPDU_EN |
 107                  MT_TMAC_CTCR0_INS_DDLMT_EN);
 108
 109         mt76_set(dev, MT_WF_RMAC_MIB_TIME0(band), MT_WF_RMAC_MIB_RXTIME_EN);
 110         mt76_set(dev, MT_WF_RMAC_MIB_AIRTIME0(band), MT_WF_RMAC_MIB_RXTIME_EN);
 111
 112         /* enable MIB tx-rx time reporting */
 113         mt76_set(dev, MT_MIB_SCR1(band), MT_MIB_TXDUR_EN);
 114         mt76_set(dev, MT_MIB_SCR1(band), MT_MIB_RXDUR_EN);
 115
 116         mt76_rmw_field(dev, MT_DMA_DCR0(band), MT_DMA_DCR0_MAX_RX_LEN, 1536);
 117         /* disable rx rate report by default due to hw issues */
 118         mt76_clear(dev, MT_DMA_DCR0(band), MT_DMA_DCR0_RXD_G5_EN);
 119 }
 120
 121 int mt7921_mac_init(struct mt7921_dev *dev)
 122 {
 123         int i;
 124
 125         mt76_rmw_field(dev, MT_MDP_DCR1, MT_MDP_DCR1_MAX_RX_LEN, 1536);
 126         /* enable hardware de-agg */
 127         mt76_set(dev, MT_MDP_DCR0, MT_MDP_DCR0_DAMSDU_EN);
 128         /* enable hardware rx header translation */
 129         mt76_set(dev, MT_MDP_DCR0, MT_MDP_DCR0_RX_HDR_TRANS_EN);
 130
 131         for (i = 0; i < MT7921_WTBL_SIZE; i++)
 132                 mt7921_mac_wtbl_update(dev, i,
 133                                        MT_WTBL_UPDATE_ADM_COUNT_CLEAR);
 134         for (i = 0; i < 2; i++)
 135                 mt7921_mac_init_band(dev, i);
 136
 137         dev->mt76.rxfilter = mt76_rr(dev, MT_WF_RFCR(0));
 138
 139         return mt76_connac_mcu_set_rts_thresh(&dev->mt76, 0x92b, 0);
 140 }
 141 EXPORT_SYMBOL_GPL(mt7921_mac_init);
 142
 143 static int __mt7921_init_hardware(struct mt7921_dev *dev)
 144 {
 145         int ret;
 146
 147         /* force firmware operation mode into normal state,
 148          * which should be set before firmware download stage.
 149          */
 150         mt76_wr(dev, MT_SWDEF_MODE, MT_SWDEF_NORMAL_MODE);
 151         ret = mt7921_mcu_init(dev);
 152         if (ret)
 153                 goto out;
 154
 155         mt76_eeprom_override(&dev->mphy);
 156
 157         ret = mt7921_mcu_set_eeprom(dev);
 158         if (ret)
 159                 goto out;
 160
 161         ret = mt7921_mac_init(dev);
 162 out:
 163         return ret;
 164 }
 165
 166 static int mt7921_init_hardware(struct mt7921_dev *dev)
 167 {
 168         int ret, i;
 169
 170         set_bit(MT76_STATE_INITIALIZED, &dev->mphy.state);
 171
 172         for (i = 0; i < MT7921_MCU_INIT_RETRY_COUNT; i++) {
 173                 ret = __mt7921_init_hardware(dev);
 174                 if (!ret)
 175                         break;
 176
 177                 mt7921_init_reset(dev);
 178         }
 179
 180         if (i == MT7921_MCU_INIT_RETRY_COUNT) {
 181                 dev_err(dev->mt76.dev, "hardware init failed\n");
 182                 return ret;
 183         }
 184
 185         return 0;
 186 }
 187
 188 static int mt7921_init_wcid(struct mt7921_dev *dev)
 189 {
 190         int idx;
 191
 192         /* Beacon and mgmt frames should occupy wcid 0 */
 193         idx = mt76_wcid_alloc(dev->mt76.wcid_mask, MT7921_WTBL_STA - 1);
 194         if (idx)
 195                 return -ENOSPC;
 196
 197         dev->mt76.global_wcid.idx = idx;
 198         dev->mt76.global_wcid.hw_key_idx = -1;
 199         dev->mt76.global_wcid.tx_info |= MT_WCID_TX_INFO_SET;
 200         rcu_assign_pointer(dev->mt76.wcid[idx], &dev->mt76.global_wcid);
 201
 202         return 0;
 203 }
 204
 205 static void mt7921_init_work(struct work_struct *work)
 206 {
 207         struct mt7921_dev *dev = container_of(work, struct mt7921_dev,
 208                                               init_work);
 209         int ret;
 210
 211         ret = mt7921_init_hardware(dev);
 212         if (ret)
 213                 return;
 214
 215         mt76_set_stream_caps(&dev->mphy, true);
 216         mt7921_set_stream_he_caps(&dev->phy);
 217
 218         ret = mt76_register_device(&dev->mt76, true, mt76_rates,
 219                                    ARRAY_SIZE(mt76_rates));
 220         if (ret) {
 221                 dev_err(dev->mt76.dev, "register device failed\n");
 222                 return;
 223         }
 224
 225         ret = mt7921_init_debugfs(dev);
 226         if (ret) {
 227                 dev_err(dev->mt76.dev, "register debugfs failed\n");
 228                 return;
 229         }
 230
 231         /* we support chip reset now */
 232         dev->hw_init_done = true;
 233
 234         mt76_connac_mcu_set_deep_sleep(&dev->mt76, dev->pm.ds_enable);
 235 }
 236
 237 int mt7921_register_device(struct mt7921_dev *dev)
 238 {
 239         struct ieee80211_hw *hw = mt76_hw(dev);
 240         int ret;
 241
 242         dev->phy.dev = dev;
 243         dev->phy.mt76 = &dev->mt76.phy;
 244         dev->mt76.phy.priv = &dev->phy;
 245         dev->mt76.tx_worker.fn = mt7921_tx_worker;
 246
 247         INIT_DELAYED_WORK(&dev->pm.ps_work, mt7921_pm_power_save_work);
 248         INIT_WORK(&dev->pm.wake_work, mt7921_pm_wake_work);
 249         spin_lock_init(&dev->pm.wake.lock);
 250         mutex_init(&dev->pm.mutex);
 251         init_waitqueue_head(&dev->pm.wait);
 252         if (mt76_is_sdio(&dev->mt76))
 253                 init_waitqueue_head(&dev->mt76.sdio.wait);
 254         spin_lock_init(&dev->pm.txq_lock);
 255         INIT_DELAYED_WORK(&dev->mphy.mac_work, mt7921_mac_work);
 256         INIT_DELAYED_WORK(&dev->phy.scan_work, mt7921_scan_work);
 257         INIT_DELAYED_WORK(&dev->coredump.work, mt7921_coredump_work);
 258         skb_queue_head_init(&dev->phy.scan_event_list);
 259         skb_queue_head_init(&dev->coredump.msg_list);
 260         INIT_LIST_HEAD(&dev->sta_poll_list);
 261         spin_lock_init(&dev->sta_poll_lock);
 262
 263         INIT_WORK(&dev->reset_work, mt7921_mac_reset_work);
 264         INIT_WORK(&dev->init_work, mt7921_init_work);
 265
 266         dev->pm.idle_timeout = MT7921_PM_TIMEOUT;
 267         dev->pm.stats.last_wake_event = jiffies;
 268         dev->pm.stats.last_doze_event = jiffies;
 269         if (!mt76_is_usb(&dev->mt76)) {
 270                 dev->pm.enable_user = true;
 271                 dev->pm.enable = true;
 272                 dev->pm.ds_enable_user = true;
 273                 dev->pm.ds_enable = true;
 274         }
 275
 276         if (!mt76_is_mmio(&dev->mt76))
 277                 hw->extra_tx_headroom += MT_SDIO_TXD_SIZE + MT_SDIO_HDR_SIZE;
 278
 279         ret = mt7921_init_wcid(dev);
 280         if (ret)
 281                 return ret;
 282
 283         ret = mt7921_init_wiphy(hw);
 284         if (ret)
 285                 return ret;
 286
 287         dev->mphy.sband_2g.sband.ht_cap.cap |=
 288                         IEEE80211_HT_CAP_LDPC_CODING |
 289                         IEEE80211_HT_CAP_MAX_AMSDU;
 290         dev->mphy.sband_5g.sband.ht_cap.cap |=
 291                         IEEE80211_HT_CAP_LDPC_CODING |
 292                         IEEE80211_HT_CAP_MAX_AMSDU;
 293         dev->mphy.sband_5g.sband.vht_cap.cap |=
 294                         IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454 |
 295                         IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK |
 296                         IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
 297                         IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE |
 298                         (3 << IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT);
 299         if (is_mt7922(&dev->mt76))
 300                 dev->mphy.sband_5g.sband.vht_cap.cap |=
 301                         IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ |
 302                         IEEE80211_VHT_CAP_SHORT_GI_160;
 303
 304         dev->mphy.hw->wiphy->available_antennas_rx = dev->mphy.chainmask;
 305         dev->mphy.hw->wiphy->available_antennas_tx = dev->mphy.chainmask;
 306
 307         queue_work(system_wq, &dev->init_work);
 308
 309         return 0;
 310 }
 311 EXPORT_SYMBOL_GPL(mt7921_register_device);