1
2
3
4
5
6
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#include "mcu.h"
15
16static bool mt7615_dev_running(struct mt7615_dev *dev)
17{
18 struct mt7615_phy *phy;
19
20 if (test_bit(MT76_STATE_RUNNING, &dev->mphy.state))
21 return true;
22
23 phy = mt7615_ext_phy(dev);
24
25 return phy && test_bit(MT76_STATE_RUNNING, &phy->mt76->state);
26}
27
28static int mt7615_start(struct ieee80211_hw *hw)
29{
30 struct mt7615_dev *dev = mt7615_hw_dev(hw);
31 struct mt7615_phy *phy = mt7615_hw_phy(hw);
32 bool running;
33
34 if (!mt7615_wait_for_mcu_init(dev))
35 return -EIO;
36
37 mutex_lock(&dev->mt76.mutex);
38
39 running = mt7615_dev_running(dev);
40
41 if (!running) {
42 mt7615_mcu_set_pm(dev, 0, 0);
43 mt7615_mcu_set_mac_enable(dev, 0, true);
44 mt7615_mac_enable_nf(dev, 0);
45 }
46
47 if (phy != &dev->phy) {
48 mt7615_mcu_set_pm(dev, 1, 0);
49 mt7615_mcu_set_mac_enable(dev, 1, true);
50 mt7615_mac_enable_nf(dev, 1);
51 }
52
53 mt7615_mcu_set_chan_info(phy, MCU_EXT_CMD_SET_RX_PATH);
54
55 set_bit(MT76_STATE_RUNNING, &phy->mt76->state);
56
57 if (running)
58 goto out;
59
60 mt7615_mac_reset_counters(dev);
61
62 ieee80211_queue_delayed_work(mt76_hw(dev), &dev->mt76.mac_work,
63 MT7615_WATCHDOG_TIME);
64
65out:
66 mutex_unlock(&dev->mt76.mutex);
67
68 return 0;
69}
70
71static void mt7615_stop(struct ieee80211_hw *hw)
72{
73 struct mt7615_dev *dev = mt7615_hw_dev(hw);
74 struct mt7615_phy *phy = mt7615_hw_phy(hw);
75
76 mutex_lock(&dev->mt76.mutex);
77
78 clear_bit(MT76_STATE_RUNNING, &phy->mt76->state);
79
80 if (phy != &dev->phy) {
81 mt7615_mcu_set_pm(dev, 1, 1);
82 mt7615_mcu_set_mac_enable(dev, 1, false);
83 }
84
85 if (!mt7615_dev_running(dev)) {
86 cancel_delayed_work_sync(&dev->mt76.mac_work);
87
88 mt7615_mcu_set_pm(dev, 0, 1);
89 mt7615_mcu_set_mac_enable(dev, 0, false);
90 }
91
92 mutex_unlock(&dev->mt76.mutex);
93}
94
95static int get_omac_idx(enum nl80211_iftype type, u32 mask)
96{
97 int i;
98
99 switch (type) {
100 case NL80211_IFTYPE_MONITOR:
101 case NL80211_IFTYPE_AP:
102 case NL80211_IFTYPE_MESH_POINT:
103 case NL80211_IFTYPE_ADHOC:
104
105 if (~mask & BIT(HW_BSSID_0))
106 return HW_BSSID_0;
107
108 for (i = EXT_BSSID_1; i < EXT_BSSID_END; i++)
109 if (~mask & BIT(i))
110 return i;
111
112 break;
113 case NL80211_IFTYPE_STATION:
114
115 for (i = HW_BSSID_1; i < HW_BSSID_MAX; i++)
116 if (~mask & BIT(i))
117 return i;
118
119 break;
120 default:
121 WARN_ON(1);
122 break;
123 }
124
125 return -1;
126}
127
128static int mt7615_add_interface(struct ieee80211_hw *hw,
129 struct ieee80211_vif *vif)
130{
131 struct mt7615_vif *mvif = (struct mt7615_vif *)vif->drv_priv;
132 struct mt7615_dev *dev = mt7615_hw_dev(hw);
133 struct mt7615_phy *phy = mt7615_hw_phy(hw);
134 struct mt76_txq *mtxq;
135 bool ext_phy = phy != &dev->phy;
136 int idx, ret = 0;
137
138 mutex_lock(&dev->mt76.mutex);
139
140 mvif->idx = ffs(~dev->vif_mask) - 1;
141 if (mvif->idx >= MT7615_MAX_INTERFACES) {
142 ret = -ENOSPC;
143 goto out;
144 }
145
146 idx = get_omac_idx(vif->type, dev->omac_mask);
147 if (idx < 0) {
148 ret = -ENOSPC;
149 goto out;
150 }
151 mvif->omac_idx = idx;
152
153 mvif->band_idx = ext_phy;
154 if (mt7615_ext_phy(dev))
155 mvif->wmm_idx = ext_phy * (MT7615_MAX_WMM_SETS / 2) +
156 mvif->idx % (MT7615_MAX_WMM_SETS / 2);
157 else
158 mvif->wmm_idx = mvif->idx % MT7615_MAX_WMM_SETS;
159
160 ret = mt7615_mcu_add_dev_info(dev, vif, true);
161 if (ret)
162 goto out;
163
164 dev->vif_mask |= BIT(mvif->idx);
165 dev->omac_mask |= BIT(mvif->omac_idx);
166 phy->omac_mask |= BIT(mvif->omac_idx);
167
168 mt7615_mcu_set_dbdc(dev);
169
170 idx = MT7615_WTBL_RESERVED - mvif->idx;
171
172 INIT_LIST_HEAD(&mvif->sta.poll_list);
173 mvif->sta.wcid.idx = idx;
174 mvif->sta.wcid.ext_phy = mvif->band_idx;
175 mvif->sta.wcid.hw_key_idx = -1;
176 mt7615_mac_wtbl_update(dev, idx,
177 MT_WTBL_UPDATE_ADM_COUNT_CLEAR);
178
179 rcu_assign_pointer(dev->mt76.wcid[idx], &mvif->sta.wcid);
180 if (vif->txq) {
181 mtxq = (struct mt76_txq *)vif->txq->drv_priv;
182 mtxq->wcid = &mvif->sta.wcid;
183 mt76_txq_init(&dev->mt76, vif->txq);
184 }
185
186out:
187 mutex_unlock(&dev->mt76.mutex);
188
189 return ret;
190}
191
192static void mt7615_remove_interface(struct ieee80211_hw *hw,
193 struct ieee80211_vif *vif)
194{
195 struct mt7615_vif *mvif = (struct mt7615_vif *)vif->drv_priv;
196 struct mt7615_sta *msta = &mvif->sta;
197 struct mt7615_dev *dev = mt7615_hw_dev(hw);
198 struct mt7615_phy *phy = mt7615_hw_phy(hw);
199 int idx = msta->wcid.idx;
200
201
202
203 mt7615_mcu_add_dev_info(dev, vif, false);
204
205 rcu_assign_pointer(dev->mt76.wcid[idx], NULL);
206 if (vif->txq)
207 mt76_txq_remove(&dev->mt76, vif->txq);
208
209 mutex_lock(&dev->mt76.mutex);
210 dev->vif_mask &= ~BIT(mvif->idx);
211 dev->omac_mask &= ~BIT(mvif->omac_idx);
212 phy->omac_mask &= ~BIT(mvif->omac_idx);
213 mutex_unlock(&dev->mt76.mutex);
214
215 spin_lock_bh(&dev->sta_poll_lock);
216 if (!list_empty(&msta->poll_list))
217 list_del_init(&msta->poll_list);
218 spin_unlock_bh(&dev->sta_poll_lock);
219}
220
221static int mt7615_set_channel(struct mt7615_phy *phy)
222{
223 struct mt7615_dev *dev = phy->dev;
224 bool ext_phy = phy != &dev->phy;
225 int ret;
226
227 cancel_delayed_work_sync(&dev->mt76.mac_work);
228
229 mutex_lock(&dev->mt76.mutex);
230 set_bit(MT76_RESET, &phy->mt76->state);
231
232 phy->dfs_state = -1;
233 mt76_set_channel(phy->mt76);
234
235 ret = mt7615_mcu_set_chan_info(phy, MCU_EXT_CMD_CHANNEL_SWITCH);
236 if (ret)
237 goto out;
238
239 mt7615_mac_set_timing(phy);
240 ret = mt7615_dfs_init_radar_detector(phy);
241 mt7615_mac_cca_stats_reset(phy);
242 mt7615_mcu_set_sku_en(phy, true);
243
244 mt7615_mac_reset_counters(dev);
245 phy->noise = 0;
246 phy->chfreq = mt76_rr(dev, MT_CHFREQ(ext_phy));
247
248out:
249 clear_bit(MT76_RESET, &phy->mt76->state);
250 mutex_unlock(&dev->mt76.mutex);
251
252 mt76_txq_schedule_all(phy->mt76);
253 ieee80211_queue_delayed_work(mt76_hw(dev), &dev->mt76.mac_work,
254 MT7615_WATCHDOG_TIME);
255 return ret;
256}
257
258static int mt7615_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
259 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
260 struct ieee80211_key_conf *key)
261{
262 struct mt7615_dev *dev = mt7615_hw_dev(hw);
263 struct mt7615_vif *mvif = (struct mt7615_vif *)vif->drv_priv;
264 struct mt7615_sta *msta = sta ? (struct mt7615_sta *)sta->drv_priv :
265 &mvif->sta;
266 struct mt76_wcid *wcid = &msta->wcid;
267 int idx = key->keyidx;
268
269
270
271
272 if ((vif->type == NL80211_IFTYPE_ADHOC ||
273 vif->type == NL80211_IFTYPE_MESH_POINT) &&
274 (key->cipher == WLAN_CIPHER_SUITE_TKIP ||
275 key->cipher == WLAN_CIPHER_SUITE_CCMP) &&
276 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE))
277 return -EOPNOTSUPP;
278
279
280 switch (key->cipher) {
281 case WLAN_CIPHER_SUITE_AES_CMAC:
282 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIE;
283 break;
284 case WLAN_CIPHER_SUITE_WEP40:
285 case WLAN_CIPHER_SUITE_WEP104:
286 case WLAN_CIPHER_SUITE_TKIP:
287 case WLAN_CIPHER_SUITE_CCMP:
288 case WLAN_CIPHER_SUITE_CCMP_256:
289 case WLAN_CIPHER_SUITE_GCMP:
290 case WLAN_CIPHER_SUITE_GCMP_256:
291 case WLAN_CIPHER_SUITE_SMS4:
292 break;
293 default:
294 return -EOPNOTSUPP;
295 }
296
297 if (cmd == SET_KEY) {
298 key->hw_key_idx = wcid->idx;
299 wcid->hw_key_idx = idx;
300 } else if (idx == wcid->hw_key_idx) {
301 wcid->hw_key_idx = -1;
302 }
303 mt76_wcid_key_setup(&dev->mt76, wcid,
304 cmd == SET_KEY ? key : NULL);
305
306 return mt7615_mac_wtbl_set_key(dev, wcid, key, cmd);
307}
308
309static int mt7615_config(struct ieee80211_hw *hw, u32 changed)
310{
311 struct mt7615_dev *dev = mt7615_hw_dev(hw);
312 struct mt7615_phy *phy = mt7615_hw_phy(hw);
313 bool band = phy != &dev->phy;
314 int ret = 0;
315
316 if (changed & (IEEE80211_CONF_CHANGE_CHANNEL |
317 IEEE80211_CONF_CHANGE_POWER)) {
318 ieee80211_stop_queues(hw);
319 ret = mt7615_set_channel(phy);
320 ieee80211_wake_queues(hw);
321 }
322
323 mutex_lock(&dev->mt76.mutex);
324
325 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
326 if (!(hw->conf.flags & IEEE80211_CONF_MONITOR))
327 phy->rxfilter |= MT_WF_RFCR_DROP_OTHER_UC;
328 else
329 phy->rxfilter &= ~MT_WF_RFCR_DROP_OTHER_UC;
330
331 mt76_wr(dev, MT_WF_RFCR(band), phy->rxfilter);
332 }
333
334 mutex_unlock(&dev->mt76.mutex);
335
336 return ret;
337}
338
339static int
340mt7615_conf_tx(struct ieee80211_hw *hw, struct ieee80211_vif *vif, u16 queue,
341 const struct ieee80211_tx_queue_params *params)
342{
343 struct mt7615_vif *mvif = (struct mt7615_vif *)vif->drv_priv;
344 struct mt7615_dev *dev = mt7615_hw_dev(hw);
345
346 queue += mvif->wmm_idx * MT7615_MAX_WMM_SETS;
347
348 return mt7615_mcu_set_wmm(dev, queue, params);
349}
350
351static void mt7615_configure_filter(struct ieee80211_hw *hw,
352 unsigned int changed_flags,
353 unsigned int *total_flags,
354 u64 multicast)
355{
356 struct mt7615_dev *dev = mt7615_hw_dev(hw);
357 struct mt7615_phy *phy = mt7615_hw_phy(hw);
358 bool band = phy != &dev->phy;
359
360 u32 ctl_flags = MT_WF_RFCR1_DROP_ACK |
361 MT_WF_RFCR1_DROP_BF_POLL |
362 MT_WF_RFCR1_DROP_BA |
363 MT_WF_RFCR1_DROP_CFEND |
364 MT_WF_RFCR1_DROP_CFACK;
365 u32 flags = 0;
366
367#define MT76_FILTER(_flag, _hw) do { \
368 flags |= *total_flags & FIF_##_flag; \
369 phy->rxfilter &= ~(_hw); \
370 phy->rxfilter |= !(flags & FIF_##_flag) * (_hw); \
371 } while (0)
372
373 phy->rxfilter &= ~(MT_WF_RFCR_DROP_OTHER_BSS |
374 MT_WF_RFCR_DROP_OTHER_BEACON |
375 MT_WF_RFCR_DROP_FRAME_REPORT |
376 MT_WF_RFCR_DROP_PROBEREQ |
377 MT_WF_RFCR_DROP_MCAST_FILTERED |
378 MT_WF_RFCR_DROP_MCAST |
379 MT_WF_RFCR_DROP_BCAST |
380 MT_WF_RFCR_DROP_DUPLICATE |
381 MT_WF_RFCR_DROP_A2_BSSID |
382 MT_WF_RFCR_DROP_UNWANTED_CTL |
383 MT_WF_RFCR_DROP_STBC_MULTI);
384
385 MT76_FILTER(OTHER_BSS, MT_WF_RFCR_DROP_OTHER_TIM |
386 MT_WF_RFCR_DROP_A3_MAC |
387 MT_WF_RFCR_DROP_A3_BSSID);
388
389 MT76_FILTER(FCSFAIL, MT_WF_RFCR_DROP_FCSFAIL);
390
391 MT76_FILTER(CONTROL, MT_WF_RFCR_DROP_CTS |
392 MT_WF_RFCR_DROP_RTS |
393 MT_WF_RFCR_DROP_CTL_RSV |
394 MT_WF_RFCR_DROP_NDPA);
395
396 *total_flags = flags;
397 mt76_wr(dev, MT_WF_RFCR(band), phy->rxfilter);
398
399 if (*total_flags & FIF_CONTROL)
400 mt76_clear(dev, MT_WF_RFCR1(band), ctl_flags);
401 else
402 mt76_set(dev, MT_WF_RFCR1(band), ctl_flags);
403}
404
405static void mt7615_bss_info_changed(struct ieee80211_hw *hw,
406 struct ieee80211_vif *vif,
407 struct ieee80211_bss_conf *info,
408 u32 changed)
409{
410 struct mt7615_dev *dev = mt7615_hw_dev(hw);
411
412 mutex_lock(&dev->mt76.mutex);
413
414 if (changed & BSS_CHANGED_ASSOC)
415 mt7615_mcu_add_bss_info(dev, vif, info->assoc);
416
417 if (changed & BSS_CHANGED_ERP_SLOT) {
418 int slottime = info->use_short_slot ? 9 : 20;
419 struct mt7615_phy *phy = mt7615_hw_phy(hw);
420
421 if (slottime != phy->slottime) {
422 phy->slottime = slottime;
423 mt7615_mac_set_timing(phy);
424 }
425 }
426
427 if (changed & BSS_CHANGED_BEACON_ENABLED) {
428 mt7615_mcu_add_bss_info(dev, vif, info->enable_beacon);
429 mt7615_mcu_sta_add(dev, vif, NULL, info->enable_beacon);
430 }
431
432 if (changed & (BSS_CHANGED_BEACON |
433 BSS_CHANGED_BEACON_ENABLED))
434 mt7615_mcu_add_beacon(dev, hw, vif, info->enable_beacon);
435
436 mutex_unlock(&dev->mt76.mutex);
437}
438
439static void
440mt7615_channel_switch_beacon(struct ieee80211_hw *hw,
441 struct ieee80211_vif *vif,
442 struct cfg80211_chan_def *chandef)
443{
444 struct mt7615_dev *dev = mt7615_hw_dev(hw);
445
446 mutex_lock(&dev->mt76.mutex);
447 mt7615_mcu_add_beacon(dev, hw, vif, true);
448 mutex_unlock(&dev->mt76.mutex);
449}
450
451int mt7615_mac_sta_add(struct mt76_dev *mdev, struct ieee80211_vif *vif,
452 struct ieee80211_sta *sta)
453{
454 struct mt7615_dev *dev = container_of(mdev, struct mt7615_dev, mt76);
455 struct mt7615_sta *msta = (struct mt7615_sta *)sta->drv_priv;
456 struct mt7615_vif *mvif = (struct mt7615_vif *)vif->drv_priv;
457 int idx;
458
459 idx = mt76_wcid_alloc(dev->mt76.wcid_mask, MT7615_WTBL_STA - 1);
460 if (idx < 0)
461 return -ENOSPC;
462
463 INIT_LIST_HEAD(&msta->poll_list);
464 msta->vif = mvif;
465 msta->wcid.sta = 1;
466 msta->wcid.idx = idx;
467 msta->wcid.ext_phy = mvif->band_idx;
468
469 mt7615_mac_wtbl_update(dev, idx,
470 MT_WTBL_UPDATE_ADM_COUNT_CLEAR);
471
472 mt7615_mcu_sta_add(dev, vif, sta, true);
473
474 return 0;
475}
476
477void mt7615_mac_sta_remove(struct mt76_dev *mdev, struct ieee80211_vif *vif,
478 struct ieee80211_sta *sta)
479{
480 struct mt7615_dev *dev = container_of(mdev, struct mt7615_dev, mt76);
481 struct mt7615_sta *msta = (struct mt7615_sta *)sta->drv_priv;
482
483 mt7615_mcu_sta_add(dev, vif, sta, false);
484 mt7615_mac_wtbl_update(dev, msta->wcid.idx,
485 MT_WTBL_UPDATE_ADM_COUNT_CLEAR);
486
487 spin_lock_bh(&dev->sta_poll_lock);
488 if (!list_empty(&msta->poll_list))
489 list_del_init(&msta->poll_list);
490 spin_unlock_bh(&dev->sta_poll_lock);
491}
492
493static void mt7615_sta_rate_tbl_update(struct ieee80211_hw *hw,
494 struct ieee80211_vif *vif,
495 struct ieee80211_sta *sta)
496{
497 struct mt7615_dev *dev = mt7615_hw_dev(hw);
498 struct mt7615_phy *phy = mt7615_hw_phy(hw);
499 struct mt7615_sta *msta = (struct mt7615_sta *)sta->drv_priv;
500 struct ieee80211_sta_rates *sta_rates = rcu_dereference(sta->rates);
501 int i;
502
503 spin_lock_bh(&dev->mt76.lock);
504 for (i = 0; i < ARRAY_SIZE(msta->rates); i++) {
505 msta->rates[i].idx = sta_rates->rate[i].idx;
506 msta->rates[i].count = sta_rates->rate[i].count;
507 msta->rates[i].flags = sta_rates->rate[i].flags;
508
509 if (msta->rates[i].idx < 0 || !msta->rates[i].count)
510 break;
511 }
512 msta->n_rates = i;
513 mt7615_mac_set_rates(phy, msta, NULL, msta->rates);
514 msta->rate_probe = false;
515 spin_unlock_bh(&dev->mt76.lock);
516}
517
518static void mt7615_tx(struct ieee80211_hw *hw,
519 struct ieee80211_tx_control *control,
520 struct sk_buff *skb)
521{
522 struct mt7615_dev *dev = mt7615_hw_dev(hw);
523 struct mt76_phy *mphy = hw->priv;
524 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
525 struct ieee80211_vif *vif = info->control.vif;
526 struct mt76_wcid *wcid = &dev->mt76.global_wcid;
527
528 if (control->sta) {
529 struct mt7615_sta *sta;
530
531 sta = (struct mt7615_sta *)control->sta->drv_priv;
532 wcid = &sta->wcid;
533 }
534
535 if (vif && !control->sta) {
536 struct mt7615_vif *mvif;
537
538 mvif = (struct mt7615_vif *)vif->drv_priv;
539 wcid = &mvif->sta.wcid;
540 }
541
542 mt76_tx(mphy, control->sta, wcid, skb);
543}
544
545static int mt7615_set_rts_threshold(struct ieee80211_hw *hw, u32 val)
546{
547 struct mt7615_dev *dev = mt7615_hw_dev(hw);
548 struct mt7615_phy *phy = mt7615_hw_phy(hw);
549
550 mutex_lock(&dev->mt76.mutex);
551 mt7615_mcu_set_rts_thresh(phy, val);
552 mutex_unlock(&dev->mt76.mutex);
553
554 return 0;
555}
556
557static int
558mt7615_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
559 struct ieee80211_ampdu_params *params)
560{
561 enum ieee80211_ampdu_mlme_action action = params->action;
562 struct mt7615_dev *dev = mt7615_hw_dev(hw);
563 struct ieee80211_sta *sta = params->sta;
564 struct ieee80211_txq *txq = sta->txq[params->tid];
565 struct mt7615_sta *msta = (struct mt7615_sta *)sta->drv_priv;
566 u16 tid = params->tid;
567 u16 ssn = params->ssn;
568 struct mt76_txq *mtxq;
569 int ret = 0;
570
571 if (!txq)
572 return -EINVAL;
573
574 mtxq = (struct mt76_txq *)txq->drv_priv;
575
576 mutex_lock(&dev->mt76.mutex);
577 switch (action) {
578 case IEEE80211_AMPDU_RX_START:
579 mt76_rx_aggr_start(&dev->mt76, &msta->wcid, tid, ssn,
580 params->buf_size);
581 mt7615_mcu_add_rx_ba(dev, params, true);
582 break;
583 case IEEE80211_AMPDU_RX_STOP:
584 mt76_rx_aggr_stop(&dev->mt76, &msta->wcid, tid);
585 mt7615_mcu_add_rx_ba(dev, params, false);
586 break;
587 case IEEE80211_AMPDU_TX_OPERATIONAL:
588 mtxq->aggr = true;
589 mtxq->send_bar = false;
590 mt7615_mcu_add_tx_ba(dev, params, true);
591 break;
592 case IEEE80211_AMPDU_TX_STOP_FLUSH:
593 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
594 mtxq->aggr = false;
595 mt7615_mcu_add_tx_ba(dev, params, false);
596 break;
597 case IEEE80211_AMPDU_TX_START:
598 mtxq->agg_ssn = IEEE80211_SN_TO_SEQ(ssn);
599 ret = IEEE80211_AMPDU_TX_START_IMMEDIATE;
600 break;
601 case IEEE80211_AMPDU_TX_STOP_CONT:
602 mtxq->aggr = false;
603 mt7615_mcu_add_tx_ba(dev, params, false);
604 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
605 break;
606 }
607 mutex_unlock(&dev->mt76.mutex);
608
609 return ret;
610}
611
612static int
613mt7615_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
614 struct ieee80211_sta *sta)
615{
616 return mt76_sta_state(hw, vif, sta, IEEE80211_STA_NOTEXIST,
617 IEEE80211_STA_NONE);
618}
619
620static int
621mt7615_sta_remove(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
622 struct ieee80211_sta *sta)
623{
624 return mt76_sta_state(hw, vif, sta, IEEE80211_STA_NONE,
625 IEEE80211_STA_NOTEXIST);
626}
627
628static int
629mt7615_get_stats(struct ieee80211_hw *hw,
630 struct ieee80211_low_level_stats *stats)
631{
632 struct mt7615_phy *phy = mt7615_hw_phy(hw);
633 struct mib_stats *mib = &phy->mib;
634
635 stats->dot11RTSSuccessCount = mib->rts_cnt;
636 stats->dot11RTSFailureCount = mib->rts_retries_cnt;
637 stats->dot11FCSErrorCount = mib->fcs_err_cnt;
638 stats->dot11ACKFailureCount = mib->ack_fail_cnt;
639
640 return 0;
641}
642
643static u64
644mt7615_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
645{
646 struct mt7615_dev *dev = mt7615_hw_dev(hw);
647 union {
648 u64 t64;
649 u32 t32[2];
650 } tsf;
651
652 mutex_lock(&dev->mt76.mutex);
653
654 mt76_set(dev, MT_LPON_T0CR, MT_LPON_T0CR_MODE);
655 tsf.t32[0] = mt76_rr(dev, MT_LPON_UTTR0);
656 tsf.t32[1] = mt76_rr(dev, MT_LPON_UTTR1);
657
658 mutex_unlock(&dev->mt76.mutex);
659
660 return tsf.t64;
661}
662
663static void
664mt7615_set_coverage_class(struct ieee80211_hw *hw, s16 coverage_class)
665{
666 struct mt7615_phy *phy = mt7615_hw_phy(hw);
667
668 phy->coverage_class = max_t(s16, coverage_class, 0);
669 mt7615_mac_set_timing(phy);
670}
671
672static int
673mt7615_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
674{
675 struct mt7615_dev *dev = mt7615_hw_dev(hw);
676 struct mt7615_phy *phy = mt7615_hw_phy(hw);
677 int max_nss = hweight8(hw->wiphy->available_antennas_tx);
678 bool ext_phy = phy != &dev->phy;
679
680 if (!tx_ant || tx_ant != rx_ant || ffs(tx_ant) > max_nss)
681 return -EINVAL;
682
683 if ((BIT(hweight8(tx_ant)) - 1) != tx_ant)
684 tx_ant = BIT(ffs(tx_ant) - 1) - 1;
685
686 mutex_lock(&dev->mt76.mutex);
687
688 phy->mt76->antenna_mask = tx_ant;
689 if (ext_phy) {
690 if (dev->chainmask == 0xf)
691 tx_ant <<= 2;
692 else
693 tx_ant <<= 1;
694 }
695 phy->chainmask = tx_ant;
696
697 mt76_set_stream_caps(&dev->mt76, true);
698
699 mutex_unlock(&dev->mt76.mutex);
700
701 return 0;
702}
703
704const struct ieee80211_ops mt7615_ops = {
705 .tx = mt7615_tx,
706 .start = mt7615_start,
707 .stop = mt7615_stop,
708 .add_interface = mt7615_add_interface,
709 .remove_interface = mt7615_remove_interface,
710 .config = mt7615_config,
711 .conf_tx = mt7615_conf_tx,
712 .configure_filter = mt7615_configure_filter,
713 .bss_info_changed = mt7615_bss_info_changed,
714 .sta_add = mt7615_sta_add,
715 .sta_remove = mt7615_sta_remove,
716 .sta_pre_rcu_remove = mt76_sta_pre_rcu_remove,
717 .set_key = mt7615_set_key,
718 .ampdu_action = mt7615_ampdu_action,
719 .set_rts_threshold = mt7615_set_rts_threshold,
720 .wake_tx_queue = mt76_wake_tx_queue,
721 .sta_rate_tbl_update = mt7615_sta_rate_tbl_update,
722 .sw_scan_start = mt76_sw_scan,
723 .sw_scan_complete = mt76_sw_scan_complete,
724 .release_buffered_frames = mt76_release_buffered_frames,
725 .get_txpower = mt76_get_txpower,
726 .channel_switch_beacon = mt7615_channel_switch_beacon,
727 .get_stats = mt7615_get_stats,
728 .get_tsf = mt7615_get_tsf,
729 .get_survey = mt76_get_survey,
730 .get_antenna = mt76_get_antenna,
731 .set_antenna = mt7615_set_antenna,
732 .set_coverage_class = mt7615_set_coverage_class,
733};
734
735static int __init mt7615_init(void)
736{
737 int ret;
738
739 ret = pci_register_driver(&mt7615_pci_driver);
740 if (ret)
741 return ret;
742
743 if (IS_ENABLED(CONFIG_MT7622_WMAC)) {
744 ret = platform_driver_register(&mt7622_wmac_driver);
745 if (ret)
746 pci_unregister_driver(&mt7615_pci_driver);
747 }
748
749 return ret;
750}
751
752static void __exit mt7615_exit(void)
753{
754 if (IS_ENABLED(CONFIG_MT7622_WMAC))
755 platform_driver_unregister(&mt7622_wmac_driver);
756 pci_unregister_driver(&mt7615_pci_driver);
757}
758
759module_init(mt7615_init);
760module_exit(mt7615_exit);
761MODULE_LICENSE("Dual BSD/GPL");
762
