1 // SPDX-License-Identifier: ISC 2 /* Copyright (C) 2019 MediaTek Inc. 3 * 4 * Author: Roy Luo <royluo@google.com> 5 * Ryder Lee <ryder.lee@mediatek.com> 6 * Felix Fietkau <nbd@nbd.name> 7 */ 8 9 #include <linux/etherdevice.h> 10 #include <linux/platform_device.h> 11 #include <linux/pci.h> 12 #include <linux/module.h> 13 #include "mt7615.h" 14 15 static int mt7615_start(struct ieee80211_hw *hw) 16 { 17 struct mt7615_dev *dev = hw->priv; 18 19 set_bit(MT76_STATE_RUNNING, &dev->mt76.state); 20 ieee80211_queue_delayed_work(mt76_hw(dev), &dev->mt76.mac_work, 21 MT7615_WATCHDOG_TIME); 22 23 return 0; 24 } 25 26 static void mt7615_stop(struct ieee80211_hw *hw) 27 { 28 struct mt7615_dev *dev = hw->priv; 29 30 clear_bit(MT76_STATE_RUNNING, &dev->mt76.state); 31 cancel_delayed_work_sync(&dev->mt76.mac_work); 32 } 33 34 static int get_omac_idx(enum nl80211_iftype type, u32 mask) 35 { 36 int i; 37 38 switch (type) { 39 case NL80211_IFTYPE_AP: 40 case NL80211_IFTYPE_MESH_POINT: 41 /* ap use hw bssid 0 and ext bssid */ 42 if (~mask & BIT(HW_BSSID_0)) 43 return HW_BSSID_0; 44 45 for (i = EXT_BSSID_1; i < EXT_BSSID_END; i++) 46 if (~mask & BIT(i)) 47 return i; 48 49 break; 50 case NL80211_IFTYPE_STATION: 51 /* sta use hw bssid other than 0 */ 52 for (i = HW_BSSID_1; i < HW_BSSID_MAX; i++) 53 if (~mask & BIT(i)) 54 return i; 55 56 break; 57 default: 58 WARN_ON(1); 59 break; 60 }; 61 62 return -1; 63 } 64 65 static int mt7615_add_interface(struct ieee80211_hw *hw, 66 struct ieee80211_vif *vif) 67 { 68 struct mt7615_vif *mvif = (struct mt7615_vif *)vif->drv_priv; 69 struct mt7615_dev *dev = hw->priv; 70 struct mt76_txq *mtxq; 71 int idx, ret = 0; 72 73 mutex_lock(&dev->mt76.mutex); 74 75 mvif->idx = ffs(~dev->vif_mask) - 1; 76 if (mvif->idx >= MT7615_MAX_INTERFACES) { 77 ret = -ENOSPC; 78 goto out; 79 } 80 81 idx = get_omac_idx(vif->type, dev->omac_mask); 82 if (idx < 0) { 83 ret = -ENOSPC; 84 goto out; 85 } 86 mvif->omac_idx = idx; 87 88 /* TODO: DBDC support. Use band 0 and wmm 0 for now */ 89 mvif->band_idx = 0; 90 mvif->wmm_idx = 0; 91 92 ret = mt7615_mcu_set_dev_info(dev, vif, 1); 93 if (ret) 94 goto out; 95 96 dev->vif_mask |= BIT(mvif->idx); 97 dev->omac_mask |= BIT(mvif->omac_idx); 98 idx = MT7615_WTBL_RESERVED - mvif->idx; 99 mvif->sta.wcid.idx = idx; 100 mvif->sta.wcid.hw_key_idx = -1; 101 102 rcu_assign_pointer(dev->mt76.wcid[idx], &mvif->sta.wcid); 103 mtxq = (struct mt76_txq *)vif->txq->drv_priv; 104 mtxq->wcid = &mvif->sta.wcid; 105 mt76_txq_init(&dev->mt76, vif->txq); 106 107 out: 108 mutex_unlock(&dev->mt76.mutex); 109 110 return ret; 111 } 112 113 static void mt7615_remove_interface(struct ieee80211_hw *hw, 114 struct ieee80211_vif *vif) 115 { 116 struct mt7615_vif *mvif = (struct mt7615_vif *)vif->drv_priv; 117 struct mt7615_dev *dev = hw->priv; 118 int idx = mvif->sta.wcid.idx; 119 120 /* TODO: disable beacon for the bss */ 121 122 mt7615_mcu_set_dev_info(dev, vif, 0); 123 124 rcu_assign_pointer(dev->mt76.wcid[idx], NULL); 125 mt76_txq_remove(&dev->mt76, vif->txq); 126 127 mutex_lock(&dev->mt76.mutex); 128 dev->vif_mask &= ~BIT(mvif->idx); 129 dev->omac_mask &= ~BIT(mvif->omac_idx); 130 mutex_unlock(&dev->mt76.mutex); 131 } 132 133 static int mt7615_set_channel(struct mt7615_dev *dev) 134 { 135 int ret; 136 137 cancel_delayed_work_sync(&dev->mt76.mac_work); 138 set_bit(MT76_RESET, &dev->mt76.state); 139 140 mt76_set_channel(&dev->mt76); 141 142 ret = mt7615_mcu_set_channel(dev); 143 if (ret) 144 return ret; 145 146 clear_bit(MT76_RESET, &dev->mt76.state); 147 148 mt76_txq_schedule_all(&dev->mt76); 149 ieee80211_queue_delayed_work(mt76_hw(dev), &dev->mt76.mac_work, 150 MT7615_WATCHDOG_TIME); 151 return 0; 152 } 153 154 static int mt7615_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 155 struct ieee80211_vif *vif, struct ieee80211_sta *sta, 156 struct ieee80211_key_conf *key) 157 { 158 struct mt7615_dev *dev = hw->priv; 159 struct mt7615_vif *mvif = (struct mt7615_vif *)vif->drv_priv; 160 struct mt7615_sta *msta = sta ? (struct mt7615_sta *)sta->drv_priv : 161 &mvif->sta; 162 struct mt76_wcid *wcid = &msta->wcid; 163 int idx = key->keyidx; 164 165 /* The hardware does not support per-STA RX GTK, fallback 166 * to software mode for these. 167 */ 168 if ((vif->type == NL80211_IFTYPE_ADHOC || 169 vif->type == NL80211_IFTYPE_MESH_POINT) && 170 (key->cipher == WLAN_CIPHER_SUITE_TKIP || 171 key->cipher == WLAN_CIPHER_SUITE_CCMP) && 172 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) 173 return -EOPNOTSUPP; 174 175 if (cmd == SET_KEY) { 176 key->hw_key_idx = wcid->idx; 177 wcid->hw_key_idx = idx; 178 } else { 179 if (idx == wcid->hw_key_idx) 180 wcid->hw_key_idx = -1; 181 182 key = NULL; 183 } 184 mt76_wcid_key_setup(&dev->mt76, wcid, key); 185 186 return mt7615_mcu_set_wtbl_key(dev, wcid->idx, key, cmd); 187 } 188 189 static int mt7615_config(struct ieee80211_hw *hw, u32 changed) 190 { 191 struct mt7615_dev *dev = hw->priv; 192 int ret = 0; 193 194 mutex_lock(&dev->mt76.mutex); 195 196 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) { 197 ieee80211_stop_queues(hw); 198 ret = mt7615_set_channel(dev); 199 ieee80211_wake_queues(hw); 200 } 201 202 if (changed & IEEE80211_CONF_CHANGE_POWER) 203 ret = mt7615_mcu_set_tx_power(dev); 204 205 if (changed & IEEE80211_CONF_CHANGE_MONITOR) { 206 if (!(hw->conf.flags & IEEE80211_CONF_MONITOR)) 207 dev->mt76.rxfilter |= MT_WF_RFCR_DROP_OTHER_UC; 208 else 209 dev->mt76.rxfilter &= ~MT_WF_RFCR_DROP_OTHER_UC; 210 211 mt76_wr(dev, MT_WF_RFCR, dev->mt76.rxfilter); 212 } 213 214 mutex_unlock(&dev->mt76.mutex); 215 216 return ret; 217 } 218 219 static int 220 mt7615_conf_tx(struct ieee80211_hw *hw, struct ieee80211_vif *vif, u16 queue, 221 const struct ieee80211_tx_queue_params *params) 222 { 223 struct mt7615_dev *dev = hw->priv; 224 static const u8 wmm_queue_map[] = { 225 [IEEE80211_AC_BK] = 0, 226 [IEEE80211_AC_BE] = 1, 227 [IEEE80211_AC_VI] = 2, 228 [IEEE80211_AC_VO] = 3, 229 }; 230 231 /* TODO: hw wmm_set 1~3 */ 232 return mt7615_mcu_set_wmm(dev, wmm_queue_map[queue], params); 233 } 234 235 static void mt7615_configure_filter(struct ieee80211_hw *hw, 236 unsigned int changed_flags, 237 unsigned int *total_flags, 238 u64 multicast) 239 { 240 struct mt7615_dev *dev = hw->priv; 241 u32 flags = 0; 242 243 #define MT76_FILTER(_flag, _hw) do { \ 244 flags |= *total_flags & FIF_##_flag; \ 245 dev->mt76.rxfilter &= ~(_hw); \ 246 dev->mt76.rxfilter |= !(flags & FIF_##_flag) * (_hw); \ 247 } while (0) 248 249 dev->mt76.rxfilter &= ~(MT_WF_RFCR_DROP_OTHER_BSS | 250 MT_WF_RFCR_DROP_OTHER_BEACON | 251 MT_WF_RFCR_DROP_FRAME_REPORT | 252 MT_WF_RFCR_DROP_PROBEREQ | 253 MT_WF_RFCR_DROP_MCAST_FILTERED | 254 MT_WF_RFCR_DROP_MCAST | 255 MT_WF_RFCR_DROP_BCAST | 256 MT_WF_RFCR_DROP_DUPLICATE | 257 MT_WF_RFCR_DROP_A2_BSSID | 258 MT_WF_RFCR_DROP_UNWANTED_CTL | 259 MT_WF_RFCR_DROP_STBC_MULTI); 260 261 MT76_FILTER(OTHER_BSS, MT_WF_RFCR_DROP_OTHER_TIM | 262 MT_WF_RFCR_DROP_A3_MAC | 263 MT_WF_RFCR_DROP_A3_BSSID); 264 265 MT76_FILTER(FCSFAIL, MT_WF_RFCR_DROP_FCSFAIL); 266 267 MT76_FILTER(CONTROL, MT_WF_RFCR_DROP_CTS | 268 MT_WF_RFCR_DROP_RTS | 269 MT_WF_RFCR_DROP_CTL_RSV | 270 MT_WF_RFCR_DROP_NDPA); 271 272 *total_flags = flags; 273 mt76_wr(dev, MT_WF_RFCR, dev->mt76.rxfilter); 274 } 275 276 static void mt7615_bss_info_changed(struct ieee80211_hw *hw, 277 struct ieee80211_vif *vif, 278 struct ieee80211_bss_conf *info, 279 u32 changed) 280 { 281 struct mt7615_dev *dev = hw->priv; 282 283 mutex_lock(&dev->mt76.mutex); 284 285 if (changed & BSS_CHANGED_ASSOC) 286 mt7615_mcu_set_bss_info(dev, vif, info->assoc); 287 288 /* TODO: update beacon content 289 * BSS_CHANGED_BEACON 290 */ 291 292 if (changed & BSS_CHANGED_BEACON_ENABLED) { 293 mt7615_mcu_set_bss_info(dev, vif, info->enable_beacon); 294 mt7615_mcu_wtbl_bmc(dev, vif, info->enable_beacon); 295 mt7615_mcu_set_sta_rec_bmc(dev, vif, info->enable_beacon); 296 mt7615_mcu_set_bcn(dev, vif, info->enable_beacon); 297 } 298 299 mutex_unlock(&dev->mt76.mutex); 300 } 301 302 int mt7615_sta_add(struct mt76_dev *mdev, struct ieee80211_vif *vif, 303 struct ieee80211_sta *sta) 304 { 305 struct mt7615_dev *dev = container_of(mdev, struct mt7615_dev, mt76); 306 struct mt7615_sta *msta = (struct mt7615_sta *)sta->drv_priv; 307 struct mt7615_vif *mvif = (struct mt7615_vif *)vif->drv_priv; 308 int idx; 309 310 idx = mt76_wcid_alloc(dev->mt76.wcid_mask, MT7615_WTBL_STA - 1); 311 if (idx < 0) 312 return -ENOSPC; 313 314 msta->vif = mvif; 315 msta->wcid.sta = 1; 316 msta->wcid.idx = idx; 317 318 mt7615_mcu_add_wtbl(dev, vif, sta); 319 mt7615_mcu_set_sta_rec(dev, vif, sta, 1); 320 321 return 0; 322 } 323 324 void mt7615_sta_assoc(struct mt76_dev *mdev, struct ieee80211_vif *vif, 325 struct ieee80211_sta *sta) 326 { 327 struct mt7615_dev *dev = container_of(mdev, struct mt7615_dev, mt76); 328 329 if (sta->ht_cap.ht_supported) 330 mt7615_mcu_set_ht_cap(dev, vif, sta); 331 } 332 333 void mt7615_sta_remove(struct mt76_dev *mdev, struct ieee80211_vif *vif, 334 struct ieee80211_sta *sta) 335 { 336 struct mt7615_dev *dev = container_of(mdev, struct mt7615_dev, mt76); 337 338 mt7615_mcu_set_sta_rec(dev, vif, sta, 0); 339 mt7615_mcu_del_wtbl(dev, sta); 340 } 341 342 static void mt7615_sta_rate_tbl_update(struct ieee80211_hw *hw, 343 struct ieee80211_vif *vif, 344 struct ieee80211_sta *sta) 345 { 346 struct mt7615_dev *dev = hw->priv; 347 struct mt7615_sta *msta = (struct mt7615_sta *)sta->drv_priv; 348 struct ieee80211_sta_rates *sta_rates = rcu_dereference(sta->rates); 349 int i; 350 351 spin_lock_bh(&dev->mt76.lock); 352 for (i = 0; i < ARRAY_SIZE(msta->rates); i++) { 353 msta->rates[i].idx = sta_rates->rate[i].idx; 354 msta->rates[i].count = sta_rates->rate[i].count; 355 msta->rates[i].flags = sta_rates->rate[i].flags; 356 357 if (msta->rates[i].idx < 0 || !msta->rates[i].count) 358 break; 359 } 360 msta->n_rates = i; 361 mt7615_mcu_set_rates(dev, msta, NULL, msta->rates); 362 msta->rate_probe = false; 363 spin_unlock_bh(&dev->mt76.lock); 364 } 365 366 static void mt7615_tx(struct ieee80211_hw *hw, 367 struct ieee80211_tx_control *control, 368 struct sk_buff *skb) 369 { 370 struct mt7615_dev *dev = hw->priv; 371 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 372 struct ieee80211_vif *vif = info->control.vif; 373 struct mt76_wcid *wcid = &dev->mt76.global_wcid; 374 375 if (control->sta) { 376 struct mt7615_sta *sta; 377 378 sta = (struct mt7615_sta *)control->sta->drv_priv; 379 wcid = &sta->wcid; 380 } 381 382 if (vif && !control->sta) { 383 struct mt7615_vif *mvif; 384 385 mvif = (struct mt7615_vif *)vif->drv_priv; 386 wcid = &mvif->sta.wcid; 387 } 388 389 mt76_tx(&dev->mt76, control->sta, wcid, skb); 390 } 391 392 static int mt7615_set_rts_threshold(struct ieee80211_hw *hw, u32 val) 393 { 394 struct mt7615_dev *dev = hw->priv; 395 396 mutex_lock(&dev->mt76.mutex); 397 mt7615_mcu_set_rts_thresh(dev, val); 398 mutex_unlock(&dev->mt76.mutex); 399 400 return 0; 401 } 402 403 static int 404 mt7615_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 405 struct ieee80211_ampdu_params *params) 406 { 407 enum ieee80211_ampdu_mlme_action action = params->action; 408 struct mt7615_dev *dev = hw->priv; 409 struct ieee80211_sta *sta = params->sta; 410 struct ieee80211_txq *txq = sta->txq[params->tid]; 411 struct mt7615_sta *msta = (struct mt7615_sta *)sta->drv_priv; 412 u16 tid = params->tid; 413 u16 *ssn = ¶ms->ssn; 414 struct mt76_txq *mtxq; 415 416 if (!txq) 417 return -EINVAL; 418 419 mtxq = (struct mt76_txq *)txq->drv_priv; 420 421 switch (action) { 422 case IEEE80211_AMPDU_RX_START: 423 mt76_rx_aggr_start(&dev->mt76, &msta->wcid, tid, *ssn, 424 params->buf_size); 425 mt7615_mcu_set_rx_ba(dev, params, 1); 426 break; 427 case IEEE80211_AMPDU_RX_STOP: 428 mt76_rx_aggr_stop(&dev->mt76, &msta->wcid, tid); 429 mt7615_mcu_set_rx_ba(dev, params, 0); 430 break; 431 case IEEE80211_AMPDU_TX_OPERATIONAL: 432 mtxq->aggr = true; 433 mtxq->send_bar = false; 434 mt7615_mcu_set_tx_ba(dev, params, 1); 435 break; 436 case IEEE80211_AMPDU_TX_STOP_FLUSH: 437 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 438 mtxq->aggr = false; 439 ieee80211_send_bar(vif, sta->addr, tid, mtxq->agg_ssn); 440 mt7615_mcu_set_tx_ba(dev, params, 0); 441 break; 442 case IEEE80211_AMPDU_TX_START: 443 mtxq->agg_ssn = IEEE80211_SN_TO_SEQ(*ssn); 444 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid); 445 break; 446 case IEEE80211_AMPDU_TX_STOP_CONT: 447 mtxq->aggr = false; 448 mt7615_mcu_set_tx_ba(dev, params, 0); 449 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid); 450 break; 451 } 452 453 return 0; 454 } 455 456 static void 457 mt7615_sw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 458 const u8 *mac) 459 { 460 struct mt7615_dev *dev = hw->priv; 461 462 set_bit(MT76_SCANNING, &dev->mt76.state); 463 } 464 465 static void 466 mt7615_sw_scan_complete(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 467 { 468 struct mt7615_dev *dev = hw->priv; 469 470 clear_bit(MT76_SCANNING, &dev->mt76.state); 471 } 472 473 const struct ieee80211_ops mt7615_ops = { 474 .tx = mt7615_tx, 475 .start = mt7615_start, 476 .stop = mt7615_stop, 477 .add_interface = mt7615_add_interface, 478 .remove_interface = mt7615_remove_interface, 479 .config = mt7615_config, 480 .conf_tx = mt7615_conf_tx, 481 .configure_filter = mt7615_configure_filter, 482 .bss_info_changed = mt7615_bss_info_changed, 483 .sta_state = mt76_sta_state, 484 .set_key = mt7615_set_key, 485 .ampdu_action = mt7615_ampdu_action, 486 .set_rts_threshold = mt7615_set_rts_threshold, 487 .wake_tx_queue = mt76_wake_tx_queue, 488 .sta_rate_tbl_update = mt7615_sta_rate_tbl_update, 489 .sw_scan_start = mt7615_sw_scan, 490 .sw_scan_complete = mt7615_sw_scan_complete, 491 .release_buffered_frames = mt76_release_buffered_frames, 492 .get_txpower = mt76_get_txpower, 493 }; 494