mt76/mt7921/init.c

0001 // SPDX-License-Identifier: ISC
0002 /* Copyright (C) 2020 MediaTek Inc. */
0003
0004 #include <linux/etherdevice.h>
0005 #include "mt7921.h"
0006 #include "mac.h"
0007 #include "mcu.h"
0008 #include "eeprom.h"
0009
0010 static const struct ieee80211_iface_limit if_limits[] = {
0011     {
0012         .max = MT7921_MAX_INTERFACES,
0013         .types = BIT(NL80211_IFTYPE_STATION)
0014     },
0015     {
0016         .max = 1,
0017         .types = BIT(NL80211_IFTYPE_AP)
0018     }
0019 };
0020
0021 static const struct ieee80211_iface_combination if_comb[] = {
0022     {
0023         .limits = if_limits,
0024         .n_limits = ARRAY_SIZE(if_limits),
0025         .max_interfaces = MT7921_MAX_INTERFACES,
0026         .num_different_channels = 1,
0027         .beacon_int_infra_match = true,
0028     }
0029 };
0030
0031 static void
0032 mt7921_regd_notifier(struct wiphy *wiphy,
0033              struct regulatory_request *request)
0034 {
0035     struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
0036     struct mt7921_dev *dev = mt7921_hw_dev(hw);
0037
0038     memcpy(dev->mt76.alpha2, request->alpha2, sizeof(dev->mt76.alpha2));
0039     dev->mt76.region = request->dfs_region;
0040
0041     mt7921_mutex_acquire(dev);
0042     mt76_connac_mcu_set_channel_domain(hw->priv);
0043     mt7921_set_tx_sar_pwr(hw, NULL);
0044     mt7921_mutex_release(dev);
0045 }
0046
0047 static int
0048 mt7921_init_wiphy(struct ieee80211_hw *hw)
0049 {
0050     struct mt7921_phy *phy = mt7921_hw_phy(hw);
0051     struct mt7921_dev *dev = phy->dev;
0052     struct wiphy *wiphy = hw->wiphy;
0053
0054     hw->queues = 4;
0055     hw->max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HE;
0056     hw->max_tx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HE;
0057     hw->netdev_features = NETIF_F_RXCSUM;
0058
0059     hw->radiotap_timestamp.units_pos =
0060         IEEE80211_RADIOTAP_TIMESTAMP_UNIT_US;
0061
0062     phy->slottime = 9;
0063
0064     hw->sta_data_size = sizeof(struct mt7921_sta);
0065     hw->vif_data_size = sizeof(struct mt7921_vif);
0066
0067     wiphy->iface_combinations = if_comb;
0068     wiphy->flags &= ~(WIPHY_FLAG_IBSS_RSN | WIPHY_FLAG_4ADDR_AP |
0069               WIPHY_FLAG_4ADDR_STATION);
0070     wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
0071                  BIT(NL80211_IFTYPE_AP);
0072     wiphy->n_iface_combinations = ARRAY_SIZE(if_comb);
0073     wiphy->max_scan_ie_len = MT76_CONNAC_SCAN_IE_LEN;
0074     wiphy->max_scan_ssids = 4;
0075     wiphy->max_sched_scan_plan_interval =
0076         MT76_CONNAC_MAX_TIME_SCHED_SCAN_INTERVAL;
0077     wiphy->max_sched_scan_ie_len = IEEE80211_MAX_DATA_LEN;
0078     wiphy->max_sched_scan_ssids = MT76_CONNAC_MAX_SCHED_SCAN_SSID;
0079     wiphy->max_match_sets = MT76_CONNAC_MAX_SCAN_MATCH;
0080     wiphy->max_sched_scan_reqs = 1;
0081     wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
0082     wiphy->reg_notifier = mt7921_regd_notifier;
0083
0084     wiphy->features |= NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR |
0085                NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;
0086     wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_SET_SCAN_DWELL);
0087     wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_BEACON_RATE_LEGACY);
0088     wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_BEACON_RATE_HT);
0089     wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_BEACON_RATE_VHT);
0090     wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_BEACON_RATE_HE);
0091
0092     ieee80211_hw_set(hw, SINGLE_SCAN_ON_ALL_BANDS);
0093     ieee80211_hw_set(hw, HAS_RATE_CONTROL);
0094     ieee80211_hw_set(hw, SUPPORTS_TX_ENCAP_OFFLOAD);
0095     ieee80211_hw_set(hw, SUPPORTS_RX_DECAP_OFFLOAD);
0096     ieee80211_hw_set(hw, WANT_MONITOR_VIF);
0097     ieee80211_hw_set(hw, SUPPORTS_PS);
0098     ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS);
0099     ieee80211_hw_set(hw, SUPPORTS_VHT_EXT_NSS_BW);
0100     ieee80211_hw_set(hw, CONNECTION_MONITOR);
0101
0102     if (dev->pm.enable)
0103         ieee80211_hw_set(hw, CONNECTION_MONITOR);
0104
0105     hw->max_tx_fragments = 4;
0106
0107     return 0;
0108 }
0109
0110 static void
0111 mt7921_mac_init_band(struct mt7921_dev *dev, u8 band)
0112 {
0113     mt76_rmw_field(dev, MT_TMAC_CTCR0(band),
0114                MT_TMAC_CTCR0_INS_DDLMT_REFTIME, 0x3f);
0115     mt76_set(dev, MT_TMAC_CTCR0(band),
0116          MT_TMAC_CTCR0_INS_DDLMT_VHT_SMPDU_EN |
0117          MT_TMAC_CTCR0_INS_DDLMT_EN);
0118
0119     mt76_set(dev, MT_WF_RMAC_MIB_TIME0(band), MT_WF_RMAC_MIB_RXTIME_EN);
0120     mt76_set(dev, MT_WF_RMAC_MIB_AIRTIME0(band), MT_WF_RMAC_MIB_RXTIME_EN);
0121
0122     /* enable MIB tx-rx time reporting */
0123     mt76_set(dev, MT_MIB_SCR1(band), MT_MIB_TXDUR_EN);
0124     mt76_set(dev, MT_MIB_SCR1(band), MT_MIB_RXDUR_EN);
0125
0126     mt76_rmw_field(dev, MT_DMA_DCR0(band), MT_DMA_DCR0_MAX_RX_LEN, 1536);
0127     /* disable rx rate report by default due to hw issues */
0128     mt76_clear(dev, MT_DMA_DCR0(band), MT_DMA_DCR0_RXD_G5_EN);
0129 }
0130
0131 int mt7921_mac_init(struct mt7921_dev *dev)
0132 {
0133     int i;
0134
0135     mt76_rmw_field(dev, MT_MDP_DCR1, MT_MDP_DCR1_MAX_RX_LEN, 1536);
0136     /* enable hardware de-agg */
0137     mt76_set(dev, MT_MDP_DCR0, MT_MDP_DCR0_DAMSDU_EN);
0138     /* enable hardware rx header translation */
0139     mt76_set(dev, MT_MDP_DCR0, MT_MDP_DCR0_RX_HDR_TRANS_EN);
0140
0141     for (i = 0; i < MT7921_WTBL_SIZE; i++)
0142         mt7921_mac_wtbl_update(dev, i,
0143                        MT_WTBL_UPDATE_ADM_COUNT_CLEAR);
0144     for (i = 0; i < 2; i++)
0145         mt7921_mac_init_band(dev, i);
0146
0147     dev->mt76.rxfilter = mt76_rr(dev, MT_WF_RFCR(0));
0148
0149     return mt76_connac_mcu_set_rts_thresh(&dev->mt76, 0x92b, 0);
0150 }
0151 EXPORT_SYMBOL_GPL(mt7921_mac_init);
0152
0153 static int __mt7921_init_hardware(struct mt7921_dev *dev)
0154 {
0155     int ret;
0156
0157     /* force firmware operation mode into normal state,
0158      * which should be set before firmware download stage.
0159      */
0160     mt76_wr(dev, MT_SWDEF_MODE, MT_SWDEF_NORMAL_MODE);
0161     ret = mt7921_mcu_init(dev);
0162     if (ret)
0163         goto out;
0164
0165     mt76_eeprom_override(&dev->mphy);
0166
0167     ret = mt7921_mcu_set_eeprom(dev);
0168     if (ret)
0169         goto out;
0170
0171     ret = mt7921_mac_init(dev);
0172 out:
0173     return ret;
0174 }
0175
0176 static int mt7921_init_hardware(struct mt7921_dev *dev)
0177 {
0178     int ret, i;
0179
0180     set_bit(MT76_STATE_INITIALIZED, &dev->mphy.state);
0181
0182     for (i = 0; i < MT7921_MCU_INIT_RETRY_COUNT; i++) {
0183         ret = __mt7921_init_hardware(dev);
0184         if (!ret)
0185             break;
0186
0187         mt7921_init_reset(dev);
0188     }
0189
0190     if (i == MT7921_MCU_INIT_RETRY_COUNT) {
0191         dev_err(dev->mt76.dev, "hardware init failed\n");
0192         return ret;
0193     }
0194
0195     return 0;
0196 }
0197
0198 static int mt7921_init_wcid(struct mt7921_dev *dev)
0199 {
0200     int idx;
0201
0202     /* Beacon and mgmt frames should occupy wcid 0 */
0203     idx = mt76_wcid_alloc(dev->mt76.wcid_mask, MT7921_WTBL_STA - 1);
0204     if (idx)
0205         return -ENOSPC;
0206
0207     dev->mt76.global_wcid.idx = idx;
0208     dev->mt76.global_wcid.hw_key_idx = -1;
0209     dev->mt76.global_wcid.tx_info |= MT_WCID_TX_INFO_SET;
0210     rcu_assign_pointer(dev->mt76.wcid[idx], &dev->mt76.global_wcid);
0211
0212     return 0;
0213 }
0214
0215 static void mt7921_init_work(struct work_struct *work)
0216 {
0217     struct mt7921_dev *dev = container_of(work, struct mt7921_dev,
0218                           init_work);
0219     int ret;
0220
0221     ret = mt7921_init_hardware(dev);
0222     if (ret)
0223         return;
0224
0225     mt76_set_stream_caps(&dev->mphy, true);
0226     mt7921_set_stream_he_caps(&dev->phy);
0227
0228     ret = mt76_register_device(&dev->mt76, true, mt76_rates,
0229                    ARRAY_SIZE(mt76_rates));
0230     if (ret) {
0231         dev_err(dev->mt76.dev, "register device failed\n");
0232         return;
0233     }
0234
0235     ret = mt7921_init_debugfs(dev);
0236     if (ret) {
0237         dev_err(dev->mt76.dev, "register debugfs failed\n");
0238         return;
0239     }
0240
0241     /* we support chip reset now */
0242     dev->hw_init_done = true;
0243
0244     mt76_connac_mcu_set_deep_sleep(&dev->mt76, dev->pm.ds_enable);
0245 }
0246
0247 int mt7921_register_device(struct mt7921_dev *dev)
0248 {
0249     struct ieee80211_hw *hw = mt76_hw(dev);
0250     int ret;
0251
0252     dev->phy.dev = dev;
0253     dev->phy.mt76 = &dev->mt76.phy;
0254     dev->mt76.phy.priv = &dev->phy;
0255     dev->mt76.tx_worker.fn = mt7921_tx_worker;
0256
0257     INIT_DELAYED_WORK(&dev->pm.ps_work, mt7921_pm_power_save_work);
0258     INIT_WORK(&dev->pm.wake_work, mt7921_pm_wake_work);
0259     spin_lock_init(&dev->pm.wake.lock);
0260     mutex_init(&dev->pm.mutex);
0261     init_waitqueue_head(&dev->pm.wait);
0262     if (mt76_is_sdio(&dev->mt76))
0263         init_waitqueue_head(&dev->mt76.sdio.wait);
0264     spin_lock_init(&dev->pm.txq_lock);
0265     INIT_DELAYED_WORK(&dev->mphy.mac_work, mt7921_mac_work);
0266     INIT_DELAYED_WORK(&dev->phy.scan_work, mt7921_scan_work);
0267     INIT_DELAYED_WORK(&dev->coredump.work, mt7921_coredump_work);
0268 #if IS_ENABLED(CONFIG_IPV6)
0269     INIT_WORK(&dev->ipv6_ns_work, mt7921_set_ipv6_ns_work);
0270     skb_queue_head_init(&dev->ipv6_ns_list);
0271 #endif
0272     skb_queue_head_init(&dev->phy.scan_event_list);
0273     skb_queue_head_init(&dev->coredump.msg_list);
0274     INIT_LIST_HEAD(&dev->sta_poll_list);
0275     spin_lock_init(&dev->sta_poll_lock);
0276
0277     INIT_WORK(&dev->reset_work, mt7921_mac_reset_work);
0278     INIT_WORK(&dev->init_work, mt7921_init_work);
0279
0280     dev->pm.idle_timeout = MT7921_PM_TIMEOUT;
0281     dev->pm.stats.last_wake_event = jiffies;
0282     dev->pm.stats.last_doze_event = jiffies;
0283     if (!mt76_is_usb(&dev->mt76)) {
0284         dev->pm.enable_user = true;
0285         dev->pm.enable = true;
0286         dev->pm.ds_enable_user = true;
0287         dev->pm.ds_enable = true;
0288     }
0289
0290     if (!mt76_is_mmio(&dev->mt76))
0291         hw->extra_tx_headroom += MT_SDIO_TXD_SIZE + MT_SDIO_HDR_SIZE;
0292
0293     mt7921_init_acpi_sar(dev);
0294
0295     ret = mt7921_init_wcid(dev);
0296     if (ret)
0297         return ret;
0298
0299     ret = mt7921_init_wiphy(hw);
0300     if (ret)
0301         return ret;
0302
0303     dev->mphy.sband_2g.sband.ht_cap.cap |=
0304             IEEE80211_HT_CAP_LDPC_CODING |
0305             IEEE80211_HT_CAP_MAX_AMSDU;
0306     dev->mphy.sband_5g.sband.ht_cap.cap |=
0307             IEEE80211_HT_CAP_LDPC_CODING |
0308             IEEE80211_HT_CAP_MAX_AMSDU;
0309     dev->mphy.sband_5g.sband.vht_cap.cap |=
0310             IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454 |
0311             IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK |
0312             IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
0313             IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE |
0314             (3 << IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT);
0315     if (is_mt7922(&dev->mt76))
0316         dev->mphy.sband_5g.sband.vht_cap.cap |=
0317             IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ |
0318             IEEE80211_VHT_CAP_SHORT_GI_160;
0319
0320     dev->mphy.hw->wiphy->available_antennas_rx = dev->mphy.chainmask;
0321     dev->mphy.hw->wiphy->available_antennas_tx = dev->mphy.chainmask;
0322
0323     queue_work(system_wq, &dev->init_work);
0324
0325     return 0;
0326 }
0327 EXPORT_SYMBOL_GPL(mt7921_register_device);