| // SPDX-License-Identifier: ISC |
| /* Copyright (C) 2019 MediaTek Inc. |
| * |
| * Author: Roy Luo <royluo@google.com> |
| * Ryder Lee <ryder.lee@mediatek.com> |
| * Felix Fietkau <nbd@nbd.name> |
| */ |
| |
| #include <linux/etherdevice.h> |
| #include <linux/platform_device.h> |
| #include <linux/pci.h> |
| #include <linux/module.h> |
| #include "mt7615.h" |
| |
| static int mt7615_start(struct ieee80211_hw *hw) |
| { |
| struct mt7615_dev *dev = hw->priv; |
| |
| dev->mt76.survey_time = ktime_get_boottime(); |
| set_bit(MT76_STATE_RUNNING, &dev->mt76.state); |
| ieee80211_queue_delayed_work(mt76_hw(dev), &dev->mt76.mac_work, |
| MT7615_WATCHDOG_TIME); |
| |
| return 0; |
| } |
| |
| static void mt7615_stop(struct ieee80211_hw *hw) |
| { |
| struct mt7615_dev *dev = hw->priv; |
| |
| clear_bit(MT76_STATE_RUNNING, &dev->mt76.state); |
| cancel_delayed_work_sync(&dev->mt76.mac_work); |
| } |
| |
| static int get_omac_idx(enum nl80211_iftype type, u32 mask) |
| { |
| int i; |
| |
| switch (type) { |
| case NL80211_IFTYPE_AP: |
| case NL80211_IFTYPE_MESH_POINT: |
| /* ap use hw bssid 0 and ext bssid */ |
| if (~mask & BIT(HW_BSSID_0)) |
| return HW_BSSID_0; |
| |
| for (i = EXT_BSSID_1; i < EXT_BSSID_END; i++) |
| if (~mask & BIT(i)) |
| return i; |
| |
| break; |
| case NL80211_IFTYPE_STATION: |
| /* sta use hw bssid other than 0 */ |
| for (i = HW_BSSID_1; i < HW_BSSID_MAX; i++) |
| if (~mask & BIT(i)) |
| return i; |
| |
| break; |
| default: |
| WARN_ON(1); |
| break; |
| }; |
| |
| return -1; |
| } |
| |
| static int mt7615_add_interface(struct ieee80211_hw *hw, |
| struct ieee80211_vif *vif) |
| { |
| struct mt7615_vif *mvif = (struct mt7615_vif *)vif->drv_priv; |
| struct mt7615_dev *dev = hw->priv; |
| struct mt76_txq *mtxq; |
| int idx, ret = 0; |
| |
| mutex_lock(&dev->mt76.mutex); |
| |
| mvif->idx = ffs(~dev->vif_mask) - 1; |
| if (mvif->idx >= MT7615_MAX_INTERFACES) { |
| ret = -ENOSPC; |
| goto out; |
| } |
| |
| idx = get_omac_idx(vif->type, dev->omac_mask); |
| if (idx < 0) { |
| ret = -ENOSPC; |
| goto out; |
| } |
| mvif->omac_idx = idx; |
| |
| /* TODO: DBDC support. Use band 0 for now */ |
| mvif->band_idx = 0; |
| mvif->wmm_idx = mvif->idx % MT7615_MAX_WMM_SETS; |
| |
| ret = mt7615_mcu_set_dev_info(dev, vif, 1); |
| if (ret) |
| goto out; |
| |
| dev->vif_mask |= BIT(mvif->idx); |
| dev->omac_mask |= BIT(mvif->omac_idx); |
| idx = MT7615_WTBL_RESERVED - mvif->idx; |
| mvif->sta.wcid.idx = idx; |
| mvif->sta.wcid.hw_key_idx = -1; |
| |
| rcu_assign_pointer(dev->mt76.wcid[idx], &mvif->sta.wcid); |
| mtxq = (struct mt76_txq *)vif->txq->drv_priv; |
| mtxq->wcid = &mvif->sta.wcid; |
| mt76_txq_init(&dev->mt76, vif->txq); |
| |
| out: |
| mutex_unlock(&dev->mt76.mutex); |
| |
| return ret; |
| } |
| |
| static void mt7615_remove_interface(struct ieee80211_hw *hw, |
| struct ieee80211_vif *vif) |
| { |
| struct mt7615_vif *mvif = (struct mt7615_vif *)vif->drv_priv; |
| struct mt7615_dev *dev = hw->priv; |
| int idx = mvif->sta.wcid.idx; |
| |
| /* TODO: disable beacon for the bss */ |
| |
| mt7615_mcu_set_dev_info(dev, vif, 0); |
| |
| rcu_assign_pointer(dev->mt76.wcid[idx], NULL); |
| mt76_txq_remove(&dev->mt76, vif->txq); |
| |
| mutex_lock(&dev->mt76.mutex); |
| dev->vif_mask &= ~BIT(mvif->idx); |
| dev->omac_mask &= ~BIT(mvif->omac_idx); |
| mutex_unlock(&dev->mt76.mutex); |
| } |
| |
| static int mt7615_set_channel(struct mt7615_dev *dev) |
| { |
| int ret; |
| |
| cancel_delayed_work_sync(&dev->mt76.mac_work); |
| |
| mutex_lock(&dev->mt76.mutex); |
| set_bit(MT76_RESET, &dev->mt76.state); |
| |
| mt7615_dfs_check_channel(dev); |
| |
| mt76_set_channel(&dev->mt76); |
| |
| ret = mt7615_mcu_set_channel(dev); |
| if (ret) |
| goto out; |
| |
| ret = mt7615_dfs_init_radar_detector(dev); |
| mt7615_mac_cca_stats_reset(dev); |
| dev->mt76.survey_time = ktime_get_boottime(); |
| /* TODO: add DBDC support */ |
| mt76_rr(dev, MT_MIB_SDR16(0)); |
| |
| out: |
| clear_bit(MT76_RESET, &dev->mt76.state); |
| mutex_unlock(&dev->mt76.mutex); |
| |
| mt76_txq_schedule_all(&dev->mt76); |
| ieee80211_queue_delayed_work(mt76_hw(dev), &dev->mt76.mac_work, |
| MT7615_WATCHDOG_TIME); |
| return ret; |
| } |
| |
| static int mt7615_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, |
| struct ieee80211_vif *vif, struct ieee80211_sta *sta, |
| struct ieee80211_key_conf *key) |
| { |
| struct mt7615_dev *dev = hw->priv; |
| struct mt7615_vif *mvif = (struct mt7615_vif *)vif->drv_priv; |
| struct mt7615_sta *msta = sta ? (struct mt7615_sta *)sta->drv_priv : |
| &mvif->sta; |
| struct mt76_wcid *wcid = &msta->wcid; |
| int idx = key->keyidx; |
| |
| /* The hardware does not support per-STA RX GTK, fallback |
| * to software mode for these. |
| */ |
| if ((vif->type == NL80211_IFTYPE_ADHOC || |
| vif->type == NL80211_IFTYPE_MESH_POINT) && |
| (key->cipher == WLAN_CIPHER_SUITE_TKIP || |
| key->cipher == WLAN_CIPHER_SUITE_CCMP) && |
| !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) |
| return -EOPNOTSUPP; |
| |
| /* fall back to sw encryption for unsupported ciphers */ |
| switch (key->cipher) { |
| case WLAN_CIPHER_SUITE_AES_CMAC: |
| key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIE; |
| break; |
| case WLAN_CIPHER_SUITE_WEP40: |
| case WLAN_CIPHER_SUITE_WEP104: |
| case WLAN_CIPHER_SUITE_TKIP: |
| case WLAN_CIPHER_SUITE_CCMP: |
| case WLAN_CIPHER_SUITE_CCMP_256: |
| case WLAN_CIPHER_SUITE_GCMP: |
| case WLAN_CIPHER_SUITE_GCMP_256: |
| case WLAN_CIPHER_SUITE_SMS4: |
| break; |
| default: |
| return -EOPNOTSUPP; |
| } |
| |
| if (cmd == SET_KEY) { |
| key->hw_key_idx = wcid->idx; |
| wcid->hw_key_idx = idx; |
| } else if (idx == wcid->hw_key_idx) { |
| wcid->hw_key_idx = -1; |
| } |
| mt76_wcid_key_setup(&dev->mt76, wcid, |
| cmd == SET_KEY ? key : NULL); |
| |
| return mt7615_mac_wtbl_set_key(dev, wcid, key, cmd); |
| } |
| |
| static int mt7615_config(struct ieee80211_hw *hw, u32 changed) |
| { |
| struct mt7615_dev *dev = hw->priv; |
| int ret = 0; |
| |
| if (changed & IEEE80211_CONF_CHANGE_CHANNEL) { |
| ieee80211_stop_queues(hw); |
| ret = mt7615_set_channel(dev); |
| ieee80211_wake_queues(hw); |
| } |
| |
| mutex_lock(&dev->mt76.mutex); |
| |
| if (changed & IEEE80211_CONF_CHANGE_POWER) |
| ret = mt7615_mcu_set_tx_power(dev); |
| |
| if (changed & IEEE80211_CONF_CHANGE_MONITOR) { |
| if (!(hw->conf.flags & IEEE80211_CONF_MONITOR)) |
| dev->mt76.rxfilter |= MT_WF_RFCR_DROP_OTHER_UC; |
| else |
| dev->mt76.rxfilter &= ~MT_WF_RFCR_DROP_OTHER_UC; |
| |
| mt76_wr(dev, MT_WF_RFCR, dev->mt76.rxfilter); |
| } |
| |
| mutex_unlock(&dev->mt76.mutex); |
| |
| return ret; |
| } |
| |
| static int |
| mt7615_conf_tx(struct ieee80211_hw *hw, struct ieee80211_vif *vif, u16 queue, |
| const struct ieee80211_tx_queue_params *params) |
| { |
| struct mt7615_vif *mvif = (struct mt7615_vif *)vif->drv_priv; |
| struct mt7615_dev *dev = hw->priv; |
| |
| queue += mvif->wmm_idx * MT7615_MAX_WMM_SETS; |
| |
| return mt7615_mcu_set_wmm(dev, queue, params); |
| } |
| |
| static void mt7615_configure_filter(struct ieee80211_hw *hw, |
| unsigned int changed_flags, |
| unsigned int *total_flags, |
| u64 multicast) |
| { |
| struct mt7615_dev *dev = hw->priv; |
| u32 flags = 0; |
| |
| #define MT76_FILTER(_flag, _hw) do { \ |
| flags |= *total_flags & FIF_##_flag; \ |
| dev->mt76.rxfilter &= ~(_hw); \ |
| dev->mt76.rxfilter |= !(flags & FIF_##_flag) * (_hw); \ |
| } while (0) |
| |
| dev->mt76.rxfilter &= ~(MT_WF_RFCR_DROP_OTHER_BSS | |
| MT_WF_RFCR_DROP_OTHER_BEACON | |
| MT_WF_RFCR_DROP_FRAME_REPORT | |
| MT_WF_RFCR_DROP_PROBEREQ | |
| MT_WF_RFCR_DROP_MCAST_FILTERED | |
| MT_WF_RFCR_DROP_MCAST | |
| MT_WF_RFCR_DROP_BCAST | |
| MT_WF_RFCR_DROP_DUPLICATE | |
| MT_WF_RFCR_DROP_A2_BSSID | |
| MT_WF_RFCR_DROP_UNWANTED_CTL | |
| MT_WF_RFCR_DROP_STBC_MULTI); |
| |
| MT76_FILTER(OTHER_BSS, MT_WF_RFCR_DROP_OTHER_TIM | |
| MT_WF_RFCR_DROP_A3_MAC | |
| MT_WF_RFCR_DROP_A3_BSSID); |
| |
| MT76_FILTER(FCSFAIL, MT_WF_RFCR_DROP_FCSFAIL); |
| |
| MT76_FILTER(CONTROL, MT_WF_RFCR_DROP_CTS | |
| MT_WF_RFCR_DROP_RTS | |
| MT_WF_RFCR_DROP_CTL_RSV | |
| MT_WF_RFCR_DROP_NDPA); |
| |
| *total_flags = flags; |
| mt76_wr(dev, MT_WF_RFCR, dev->mt76.rxfilter); |
| } |
| |
| static void mt7615_bss_info_changed(struct ieee80211_hw *hw, |
| struct ieee80211_vif *vif, |
| struct ieee80211_bss_conf *info, |
| u32 changed) |
| { |
| struct mt7615_dev *dev = hw->priv; |
| |
| mutex_lock(&dev->mt76.mutex); |
| |
| if (changed & BSS_CHANGED_ASSOC) |
| mt7615_mcu_set_bss_info(dev, vif, info->assoc); |
| |
| /* TODO: update beacon content |
| * BSS_CHANGED_BEACON |
| */ |
| |
| if (changed & BSS_CHANGED_BEACON_ENABLED) { |
| mt7615_mcu_set_bss_info(dev, vif, info->enable_beacon); |
| mt7615_mcu_wtbl_bmc(dev, vif, info->enable_beacon); |
| mt7615_mcu_set_sta_rec_bmc(dev, vif, info->enable_beacon); |
| mt7615_mcu_set_bcn(dev, vif, info->enable_beacon); |
| } |
| |
| mutex_unlock(&dev->mt76.mutex); |
| } |
| |
| static void |
| mt7615_channel_switch_beacon(struct ieee80211_hw *hw, |
| struct ieee80211_vif *vif, |
| struct cfg80211_chan_def *chandef) |
| { |
| struct mt7615_dev *dev = hw->priv; |
| |
| mutex_lock(&dev->mt76.mutex); |
| mt7615_mcu_set_bcn(dev, vif, true); |
| mutex_unlock(&dev->mt76.mutex); |
| } |
| |
| int mt7615_sta_add(struct mt76_dev *mdev, struct ieee80211_vif *vif, |
| struct ieee80211_sta *sta) |
| { |
| struct mt7615_dev *dev = container_of(mdev, struct mt7615_dev, mt76); |
| struct mt7615_sta *msta = (struct mt7615_sta *)sta->drv_priv; |
| struct mt7615_vif *mvif = (struct mt7615_vif *)vif->drv_priv; |
| int idx; |
| |
| idx = mt76_wcid_alloc(dev->mt76.wcid_mask, MT7615_WTBL_STA - 1); |
| if (idx < 0) |
| return -ENOSPC; |
| |
| msta->vif = mvif; |
| msta->wcid.sta = 1; |
| msta->wcid.idx = idx; |
| |
| mt7615_mcu_add_wtbl(dev, vif, sta); |
| mt7615_mcu_set_sta_rec(dev, vif, sta, 1); |
| |
| return 0; |
| } |
| |
| void mt7615_sta_assoc(struct mt76_dev *mdev, struct ieee80211_vif *vif, |
| struct ieee80211_sta *sta) |
| { |
| struct mt7615_dev *dev = container_of(mdev, struct mt7615_dev, mt76); |
| |
| if (sta->ht_cap.ht_supported) |
| mt7615_mcu_set_ht_cap(dev, vif, sta); |
| } |
| |
| void mt7615_sta_remove(struct mt76_dev *mdev, struct ieee80211_vif *vif, |
| struct ieee80211_sta *sta) |
| { |
| struct mt7615_dev *dev = container_of(mdev, struct mt7615_dev, mt76); |
| |
| mt7615_mcu_set_sta_rec(dev, vif, sta, 0); |
| mt7615_mcu_del_wtbl(dev, sta); |
| } |
| |
| static void mt7615_sta_rate_tbl_update(struct ieee80211_hw *hw, |
| struct ieee80211_vif *vif, |
| struct ieee80211_sta *sta) |
| { |
| struct mt7615_dev *dev = hw->priv; |
| struct mt7615_sta *msta = (struct mt7615_sta *)sta->drv_priv; |
| struct ieee80211_sta_rates *sta_rates = rcu_dereference(sta->rates); |
| int i; |
| |
| if (!sta_rates) |
| return; |
| |
| spin_lock_bh(&dev->mt76.lock); |
| for (i = 0; i < ARRAY_SIZE(msta->rates); i++) { |
| msta->rates[i].idx = sta_rates->rate[i].idx; |
| msta->rates[i].count = sta_rates->rate[i].count; |
| msta->rates[i].flags = sta_rates->rate[i].flags; |
| |
| if (msta->rates[i].idx < 0 || !msta->rates[i].count) |
| break; |
| } |
| msta->n_rates = i; |
| mt7615_mac_set_rates(dev, msta, NULL, msta->rates); |
| msta->rate_probe = false; |
| spin_unlock_bh(&dev->mt76.lock); |
| } |
| |
| static void mt7615_tx(struct ieee80211_hw *hw, |
| struct ieee80211_tx_control *control, |
| struct sk_buff *skb) |
| { |
| struct mt7615_dev *dev = hw->priv; |
| struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); |
| struct ieee80211_vif *vif = info->control.vif; |
| struct mt76_wcid *wcid = &dev->mt76.global_wcid; |
| |
| if (control->sta) { |
| struct mt7615_sta *sta; |
| |
| sta = (struct mt7615_sta *)control->sta->drv_priv; |
| wcid = &sta->wcid; |
| } |
| |
| if (vif && !control->sta) { |
| struct mt7615_vif *mvif; |
| |
| mvif = (struct mt7615_vif *)vif->drv_priv; |
| wcid = &mvif->sta.wcid; |
| } |
| |
| mt76_tx(&dev->mt76, control->sta, wcid, skb); |
| } |
| |
| static int mt7615_set_rts_threshold(struct ieee80211_hw *hw, u32 val) |
| { |
| struct mt7615_dev *dev = hw->priv; |
| |
| mutex_lock(&dev->mt76.mutex); |
| mt7615_mcu_set_rts_thresh(dev, val); |
| mutex_unlock(&dev->mt76.mutex); |
| |
| return 0; |
| } |
| |
| static int |
| mt7615_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif, |
| struct ieee80211_ampdu_params *params) |
| { |
| enum ieee80211_ampdu_mlme_action action = params->action; |
| struct mt7615_dev *dev = hw->priv; |
| struct ieee80211_sta *sta = params->sta; |
| struct ieee80211_txq *txq = sta->txq[params->tid]; |
| struct mt7615_sta *msta = (struct mt7615_sta *)sta->drv_priv; |
| u16 tid = params->tid; |
| u16 ssn = params->ssn; |
| struct mt76_txq *mtxq; |
| |
| if (!txq) |
| return -EINVAL; |
| |
| mtxq = (struct mt76_txq *)txq->drv_priv; |
| |
| mutex_lock(&dev->mt76.mutex); |
| switch (action) { |
| case IEEE80211_AMPDU_RX_START: |
| mt76_rx_aggr_start(&dev->mt76, &msta->wcid, tid, ssn, |
| params->buf_size); |
| mt7615_mcu_set_rx_ba(dev, params, 1); |
| break; |
| case IEEE80211_AMPDU_RX_STOP: |
| mt76_rx_aggr_stop(&dev->mt76, &msta->wcid, tid); |
| mt7615_mcu_set_rx_ba(dev, params, 0); |
| break; |
| case IEEE80211_AMPDU_TX_OPERATIONAL: |
| mtxq->aggr = true; |
| mtxq->send_bar = false; |
| mt7615_mcu_set_tx_ba(dev, params, 1); |
| break; |
| case IEEE80211_AMPDU_TX_STOP_FLUSH: |
| case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: |
| mtxq->aggr = false; |
| mt7615_mcu_set_tx_ba(dev, params, 0); |
| break; |
| case IEEE80211_AMPDU_TX_START: |
| mtxq->agg_ssn = IEEE80211_SN_TO_SEQ(ssn); |
| ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid); |
| break; |
| case IEEE80211_AMPDU_TX_STOP_CONT: |
| mtxq->aggr = false; |
| mt7615_mcu_set_tx_ba(dev, params, 0); |
| ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid); |
| break; |
| } |
| mutex_unlock(&dev->mt76.mutex); |
| |
| return 0; |
| } |
| |
| const struct ieee80211_ops mt7615_ops = { |
| .tx = mt7615_tx, |
| .start = mt7615_start, |
| .stop = mt7615_stop, |
| .add_interface = mt7615_add_interface, |
| .remove_interface = mt7615_remove_interface, |
| .config = mt7615_config, |
| .conf_tx = mt7615_conf_tx, |
| .configure_filter = mt7615_configure_filter, |
| .bss_info_changed = mt7615_bss_info_changed, |
| .sta_state = mt76_sta_state, |
| .set_key = mt7615_set_key, |
| .ampdu_action = mt7615_ampdu_action, |
| .set_rts_threshold = mt7615_set_rts_threshold, |
| .wake_tx_queue = mt76_wake_tx_queue, |
| .sta_rate_tbl_update = mt7615_sta_rate_tbl_update, |
| .sw_scan_start = mt76_sw_scan, |
| .sw_scan_complete = mt76_sw_scan_complete, |
| .release_buffered_frames = mt76_release_buffered_frames, |
| .get_txpower = mt76_get_txpower, |
| .channel_switch_beacon = mt7615_channel_switch_beacon, |
| .get_survey = mt76_get_survey, |
| }; |