drivers/net/wireless/mediatek/mt76/mt7615/main.c

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