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  *         Lorenzo Bianconi <lorenzo@kernel.org>
8  */
9 
10 #include <linux/etherdevice.h>
11 #include <linux/module.h>
12 #include "mt7615.h"
13 #include "mcu.h"
14 
15 static bool mt7615_dev_running(struct mt7615_dev *dev)
16 {
17 	struct mt7615_phy *phy;
18 
19 	if (test_bit(MT76_STATE_RUNNING, &dev->mphy.state))
20 		return true;
21 
22 	phy = mt7615_ext_phy(dev);
23 
24 	return phy && test_bit(MT76_STATE_RUNNING, &phy->mt76->state);
25 }
26 
27 static int mt7615_start(struct ieee80211_hw *hw)
28 {
29 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
30 	struct mt7615_phy *phy = mt7615_hw_phy(hw);
31 	unsigned long timeout;
32 	bool running;
33 	int ret;
34 
35 	if (!mt7615_wait_for_mcu_init(dev))
36 		return -EIO;
37 
38 	mt7615_mutex_acquire(dev);
39 
40 	running = mt7615_dev_running(dev);
41 
42 	if (!running) {
43 		ret = mt7615_mcu_set_pm(dev, 0, 0);
44 		if (ret)
45 			goto out;
46 
47 		ret = mt76_connac_mcu_set_mac_enable(&dev->mt76, 0, true, false);
48 		if (ret)
49 			goto out;
50 
51 		mt7615_mac_enable_nf(dev, 0);
52 	}
53 
54 	if (phy != &dev->phy) {
55 		ret = mt7615_mcu_set_pm(dev, 1, 0);
56 		if (ret)
57 			goto out;
58 
59 		ret = mt76_connac_mcu_set_mac_enable(&dev->mt76, 1, true, false);
60 		if (ret)
61 			goto out;
62 
63 		mt7615_mac_enable_nf(dev, 1);
64 	}
65 
66 	if (mt7615_firmware_offload(dev)) {
67 		ret = mt76_connac_mcu_set_channel_domain(phy->mt76);
68 		if (ret)
69 			goto out;
70 
71 		ret = mt76_connac_mcu_set_rate_txpower(phy->mt76);
72 		if (ret)
73 			goto out;
74 	}
75 
76 	ret = mt7615_mcu_set_chan_info(phy, MCU_EXT_CMD(SET_RX_PATH));
77 	if (ret)
78 		goto out;
79 
80 	set_bit(MT76_STATE_RUNNING, &phy->mt76->state);
81 
82 	timeout = mt7615_get_macwork_timeout(dev);
83 	ieee80211_queue_delayed_work(hw, &phy->mt76->mac_work, timeout);
84 
85 	if (!running)
86 		mt7615_mac_reset_counters(dev);
87 
88 out:
89 	mt7615_mutex_release(dev);
90 
91 	return ret;
92 }
93 
94 static void mt7615_stop(struct ieee80211_hw *hw)
95 {
96 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
97 	struct mt7615_phy *phy = mt7615_hw_phy(hw);
98 
99 	cancel_delayed_work_sync(&phy->mt76->mac_work);
100 	del_timer_sync(&phy->roc_timer);
101 	cancel_work_sync(&phy->roc_work);
102 
103 	cancel_delayed_work_sync(&dev->pm.ps_work);
104 	cancel_work_sync(&dev->pm.wake_work);
105 
106 	mt76_connac_free_pending_tx_skbs(&dev->pm, NULL);
107 
108 	mt7615_mutex_acquire(dev);
109 
110 	mt76_testmode_reset(phy->mt76, true);
111 
112 	clear_bit(MT76_STATE_RUNNING, &phy->mt76->state);
113 	cancel_delayed_work_sync(&phy->scan_work);
114 
115 	if (phy != &dev->phy) {
116 		mt7615_mcu_set_pm(dev, 1, 1);
117 		mt76_connac_mcu_set_mac_enable(&dev->mt76, 1, false, false);
118 	}
119 
120 	if (!mt7615_dev_running(dev)) {
121 		mt7615_mcu_set_pm(dev, 0, 1);
122 		mt76_connac_mcu_set_mac_enable(&dev->mt76, 0, false, false);
123 	}
124 
125 	mt7615_mutex_release(dev);
126 }
127 
128 static inline int get_free_idx(u32 mask, u8 start, u8 end)
129 {
130 	return ffs(~mask & GENMASK(end, start));
131 }
132 
133 static int get_omac_idx(enum nl80211_iftype type, u64 mask)
134 {
135 	int i;
136 
137 	switch (type) {
138 	case NL80211_IFTYPE_STATION:
139 		/* prefer hw bssid slot 1-3 */
140 		i = get_free_idx(mask, HW_BSSID_1, HW_BSSID_3);
141 		if (i)
142 			return i - 1;
143 
144 		/* next, try to find a free repeater entry for the sta */
145 		i = get_free_idx(mask >> REPEATER_BSSID_START, 0,
146 				 REPEATER_BSSID_MAX - REPEATER_BSSID_START);
147 		if (i)
148 			return i + 32 - 1;
149 
150 		i = get_free_idx(mask, EXT_BSSID_1, EXT_BSSID_MAX);
151 		if (i)
152 			return i - 1;
153 
154 		if (~mask & BIT(HW_BSSID_0))
155 			return HW_BSSID_0;
156 
157 		break;
158 	case NL80211_IFTYPE_ADHOC:
159 	case NL80211_IFTYPE_MESH_POINT:
160 	case NL80211_IFTYPE_MONITOR:
161 	case NL80211_IFTYPE_AP:
162 		/* ap uses hw bssid 0 and ext bssid */
163 		if (~mask & BIT(HW_BSSID_0))
164 			return HW_BSSID_0;
165 
166 		i = get_free_idx(mask, EXT_BSSID_1, EXT_BSSID_MAX);
167 		if (i)
168 			return i - 1;
169 
170 		break;
171 	default:
172 		WARN_ON(1);
173 		break;
174 	}
175 
176 	return -1;
177 }
178 
179 static int mt7615_add_interface(struct ieee80211_hw *hw,
180 				struct ieee80211_vif *vif)
181 {
182 	struct mt7615_vif *mvif = (struct mt7615_vif *)vif->drv_priv;
183 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
184 	struct mt7615_phy *phy = mt7615_hw_phy(hw);
185 	struct mt76_txq *mtxq;
186 	bool ext_phy = phy != &dev->phy;
187 	int idx, ret = 0;
188 
189 	mt7615_mutex_acquire(dev);
190 
191 	mt76_testmode_reset(phy->mt76, true);
192 
193 	if (vif->type == NL80211_IFTYPE_MONITOR &&
194 	    is_zero_ether_addr(vif->addr))
195 		phy->monitor_vif = vif;
196 
197 	mvif->mt76.idx = ffs(~dev->mt76.vif_mask) - 1;
198 	if (mvif->mt76.idx >= MT7615_MAX_INTERFACES) {
199 		ret = -ENOSPC;
200 		goto out;
201 	}
202 
203 	idx = get_omac_idx(vif->type, dev->omac_mask);
204 	if (idx < 0) {
205 		ret = -ENOSPC;
206 		goto out;
207 	}
208 	mvif->mt76.omac_idx = idx;
209 
210 	mvif->mt76.band_idx = ext_phy;
211 	mvif->mt76.wmm_idx = vif->type != NL80211_IFTYPE_AP;
212 	if (ext_phy)
213 		mvif->mt76.wmm_idx += 2;
214 
215 	dev->mt76.vif_mask |= BIT(mvif->mt76.idx);
216 	dev->omac_mask |= BIT_ULL(mvif->mt76.omac_idx);
217 	phy->omac_mask |= BIT_ULL(mvif->mt76.omac_idx);
218 
219 	ret = mt7615_mcu_set_dbdc(dev);
220 	if (ret)
221 		goto out;
222 
223 	idx = MT7615_WTBL_RESERVED - mvif->mt76.idx;
224 
225 	INIT_LIST_HEAD(&mvif->sta.poll_list);
226 	mvif->sta.wcid.idx = idx;
227 	mvif->sta.wcid.ext_phy = mvif->mt76.band_idx;
228 	mvif->sta.wcid.hw_key_idx = -1;
229 	mt76_packet_id_init(&mvif->sta.wcid);
230 
231 	mt7615_mac_wtbl_update(dev, idx,
232 			       MT_WTBL_UPDATE_ADM_COUNT_CLEAR);
233 
234 	rcu_assign_pointer(dev->mt76.wcid[idx], &mvif->sta.wcid);
235 	if (vif->txq) {
236 		mtxq = (struct mt76_txq *)vif->txq->drv_priv;
237 		mtxq->wcid = &mvif->sta.wcid;
238 	}
239 
240 	ret = mt7615_mcu_add_dev_info(phy, vif, true);
241 out:
242 	mt7615_mutex_release(dev);
243 
244 	return ret;
245 }
246 
247 static void mt7615_remove_interface(struct ieee80211_hw *hw,
248 				    struct ieee80211_vif *vif)
249 {
250 	struct mt7615_vif *mvif = (struct mt7615_vif *)vif->drv_priv;
251 	struct mt7615_sta *msta = &mvif->sta;
252 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
253 	struct mt7615_phy *phy = mt7615_hw_phy(hw);
254 	int idx = msta->wcid.idx;
255 
256 	mt7615_mutex_acquire(dev);
257 
258 	mt7615_mcu_add_bss_info(phy, vif, NULL, false);
259 	mt7615_mcu_sta_add(phy, vif, NULL, false);
260 
261 	mt76_testmode_reset(phy->mt76, true);
262 	if (vif == phy->monitor_vif)
263 	    phy->monitor_vif = NULL;
264 
265 	mt76_connac_free_pending_tx_skbs(&dev->pm, &msta->wcid);
266 
267 	mt7615_mcu_add_dev_info(phy, vif, false);
268 
269 	rcu_assign_pointer(dev->mt76.wcid[idx], NULL);
270 
271 	dev->mt76.vif_mask &= ~BIT(mvif->mt76.idx);
272 	dev->omac_mask &= ~BIT_ULL(mvif->mt76.omac_idx);
273 	phy->omac_mask &= ~BIT_ULL(mvif->mt76.omac_idx);
274 
275 	mt7615_mutex_release(dev);
276 
277 	spin_lock_bh(&dev->sta_poll_lock);
278 	if (!list_empty(&msta->poll_list))
279 		list_del_init(&msta->poll_list);
280 	spin_unlock_bh(&dev->sta_poll_lock);
281 
282 	mt76_packet_id_flush(&dev->mt76, &mvif->sta.wcid);
283 }
284 
285 static void mt7615_init_dfs_state(struct mt7615_phy *phy)
286 {
287 	struct mt76_phy *mphy = phy->mt76;
288 	struct ieee80211_hw *hw = mphy->hw;
289 	struct cfg80211_chan_def *chandef = &hw->conf.chandef;
290 
291 	if (hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)
292 		return;
293 
294 	if (!(chandef->chan->flags & IEEE80211_CHAN_RADAR) &&
295 	    !(mphy->chandef.chan->flags & IEEE80211_CHAN_RADAR))
296 		return;
297 
298 	if (mphy->chandef.chan->center_freq == chandef->chan->center_freq &&
299 	    mphy->chandef.width == chandef->width)
300 		return;
301 
302 	phy->dfs_state = -1;
303 }
304 
305 int mt7615_set_channel(struct mt7615_phy *phy)
306 {
307 	struct mt7615_dev *dev = phy->dev;
308 	bool ext_phy = phy != &dev->phy;
309 	int ret;
310 
311 	cancel_delayed_work_sync(&phy->mt76->mac_work);
312 
313 	mt7615_mutex_acquire(dev);
314 
315 	set_bit(MT76_RESET, &phy->mt76->state);
316 
317 	mt7615_init_dfs_state(phy);
318 	mt76_set_channel(phy->mt76);
319 
320 	if (is_mt7615(&dev->mt76) && dev->flash_eeprom) {
321 		ret = mt7615_mcu_apply_rx_dcoc(phy);
322 		if (ret)
323 			goto out;
324 
325 		ret = mt7615_mcu_apply_tx_dpd(phy);
326 		if (ret)
327 			goto out;
328 	}
329 
330 	ret = mt7615_mcu_set_chan_info(phy, MCU_EXT_CMD(CHANNEL_SWITCH));
331 	if (ret)
332 		goto out;
333 
334 	mt7615_mac_set_timing(phy);
335 	ret = mt7615_dfs_init_radar_detector(phy);
336 	if (ret)
337 		goto out;
338 
339 	mt7615_mac_cca_stats_reset(phy);
340 	ret = mt7615_mcu_set_sku_en(phy, true);
341 	if (ret)
342 		goto out;
343 
344 	mt7615_mac_reset_counters(dev);
345 	phy->noise = 0;
346 	phy->chfreq = mt76_rr(dev, MT_CHFREQ(ext_phy));
347 
348 out:
349 	clear_bit(MT76_RESET, &phy->mt76->state);
350 
351 	mt7615_mutex_release(dev);
352 
353 	mt76_worker_schedule(&dev->mt76.tx_worker);
354 	if (!mt76_testmode_enabled(phy->mt76)) {
355 		unsigned long timeout = mt7615_get_macwork_timeout(dev);
356 
357 		ieee80211_queue_delayed_work(phy->mt76->hw,
358 					     &phy->mt76->mac_work, timeout);
359 	}
360 
361 	return ret;
362 }
363 
364 static int mt7615_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
365 			  struct ieee80211_vif *vif, struct ieee80211_sta *sta,
366 			  struct ieee80211_key_conf *key)
367 {
368 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
369 	struct mt7615_phy *phy = mt7615_hw_phy(hw);
370 	struct mt7615_vif *mvif = (struct mt7615_vif *)vif->drv_priv;
371 	struct mt7615_sta *msta = sta ? (struct mt7615_sta *)sta->drv_priv :
372 				  &mvif->sta;
373 	struct mt76_wcid *wcid = &msta->wcid;
374 	int idx = key->keyidx, err = 0;
375 	u8 *wcid_keyidx = &wcid->hw_key_idx;
376 
377 	/* The hardware does not support per-STA RX GTK, fallback
378 	 * to software mode for these.
379 	 */
380 	if ((vif->type == NL80211_IFTYPE_ADHOC ||
381 	     vif->type == NL80211_IFTYPE_MESH_POINT) &&
382 	    (key->cipher == WLAN_CIPHER_SUITE_TKIP ||
383 	     key->cipher == WLAN_CIPHER_SUITE_CCMP) &&
384 	    !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE))
385 		return -EOPNOTSUPP;
386 
387 	/* fall back to sw encryption for unsupported ciphers */
388 	switch (key->cipher) {
389 	case WLAN_CIPHER_SUITE_AES_CMAC:
390 		wcid_keyidx = &wcid->hw_key_idx2;
391 		key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIE;
392 		break;
393 	case WLAN_CIPHER_SUITE_TKIP:
394 	case WLAN_CIPHER_SUITE_CCMP:
395 	case WLAN_CIPHER_SUITE_CCMP_256:
396 	case WLAN_CIPHER_SUITE_GCMP:
397 	case WLAN_CIPHER_SUITE_GCMP_256:
398 	case WLAN_CIPHER_SUITE_SMS4:
399 		break;
400 	case WLAN_CIPHER_SUITE_WEP40:
401 	case WLAN_CIPHER_SUITE_WEP104:
402 	default:
403 		return -EOPNOTSUPP;
404 	}
405 
406 	mt7615_mutex_acquire(dev);
407 
408 	if (cmd == SET_KEY && !sta && !mvif->mt76.cipher) {
409 		mvif->mt76.cipher = mt76_connac_mcu_get_cipher(key->cipher);
410 		mt7615_mcu_add_bss_info(phy, vif, NULL, true);
411 	}
412 
413 	if (cmd == SET_KEY)
414 		*wcid_keyidx = idx;
415 	else if (idx == *wcid_keyidx)
416 		*wcid_keyidx = -1;
417 	else
418 		goto out;
419 
420 	mt76_wcid_key_setup(&dev->mt76, wcid,
421 			    cmd == SET_KEY ? key : NULL);
422 
423 	if (mt76_is_mmio(&dev->mt76))
424 		err = mt7615_mac_wtbl_set_key(dev, wcid, key, cmd);
425 	else
426 		err = __mt7615_mac_wtbl_set_key(dev, wcid, key, cmd);
427 
428 out:
429 	mt7615_mutex_release(dev);
430 
431 	return err;
432 }
433 
434 static int mt7615_set_sar_specs(struct ieee80211_hw *hw,
435 				const struct cfg80211_sar_specs *sar)
436 {
437 	struct mt7615_phy *phy = mt7615_hw_phy(hw);
438 	int err;
439 
440 	if (!cfg80211_chandef_valid(&phy->mt76->chandef))
441 		return -EINVAL;
442 
443 	err = mt76_init_sar_power(hw, sar);
444 	if (err)
445 		return err;
446 
447 	if (mt7615_firmware_offload(phy->dev))
448 		return mt76_connac_mcu_set_rate_txpower(phy->mt76);
449 
450 	ieee80211_stop_queues(hw);
451 	err = mt7615_set_channel(phy);
452 	ieee80211_wake_queues(hw);
453 
454 	return err;
455 }
456 
457 static int mt7615_config(struct ieee80211_hw *hw, u32 changed)
458 {
459 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
460 	struct mt7615_phy *phy = mt7615_hw_phy(hw);
461 	bool band = phy != &dev->phy;
462 	int ret = 0;
463 
464 	if (changed & (IEEE80211_CONF_CHANGE_CHANNEL |
465 		       IEEE80211_CONF_CHANGE_POWER)) {
466 #ifdef CONFIG_NL80211_TESTMODE
467 		if (phy->mt76->test.state != MT76_TM_STATE_OFF) {
468 			mt7615_mutex_acquire(dev);
469 			mt76_testmode_reset(phy->mt76, false);
470 			mt7615_mutex_release(dev);
471 		}
472 #endif
473 		ieee80211_stop_queues(hw);
474 		ret = mt7615_set_channel(phy);
475 		ieee80211_wake_queues(hw);
476 	}
477 
478 	mt7615_mutex_acquire(dev);
479 
480 	if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
481 		mt76_testmode_reset(phy->mt76, true);
482 
483 		if (!(hw->conf.flags & IEEE80211_CONF_MONITOR))
484 			phy->rxfilter |= MT_WF_RFCR_DROP_OTHER_UC;
485 		else
486 			phy->rxfilter &= ~MT_WF_RFCR_DROP_OTHER_UC;
487 
488 		mt76_wr(dev, MT_WF_RFCR(band), phy->rxfilter);
489 	}
490 
491 	mt7615_mutex_release(dev);
492 
493 	return ret;
494 }
495 
496 static int
497 mt7615_conf_tx(struct ieee80211_hw *hw, struct ieee80211_vif *vif, u16 queue,
498 	       const struct ieee80211_tx_queue_params *params)
499 {
500 	struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv;
501 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
502 	int err;
503 
504 	mt7615_mutex_acquire(dev);
505 
506 	queue = mt7615_lmac_mapping(dev, queue);
507 	queue += mvif->wmm_idx * MT7615_MAX_WMM_SETS;
508 	err = mt7615_mcu_set_wmm(dev, queue, params);
509 
510 	mt7615_mutex_release(dev);
511 
512 	return err;
513 }
514 
515 static void mt7615_configure_filter(struct ieee80211_hw *hw,
516 				    unsigned int changed_flags,
517 				    unsigned int *total_flags,
518 				    u64 multicast)
519 {
520 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
521 	struct mt7615_phy *phy = mt7615_hw_phy(hw);
522 	bool band = phy != &dev->phy;
523 
524 	u32 ctl_flags = MT_WF_RFCR1_DROP_ACK |
525 			MT_WF_RFCR1_DROP_BF_POLL |
526 			MT_WF_RFCR1_DROP_BA |
527 			MT_WF_RFCR1_DROP_CFEND |
528 			MT_WF_RFCR1_DROP_CFACK;
529 	u32 flags = 0;
530 
531 	mt7615_mutex_acquire(dev);
532 
533 #define MT76_FILTER(_flag, _hw) do { \
534 		flags |= *total_flags & FIF_##_flag;			\
535 		phy->rxfilter &= ~(_hw);				\
536 		if (!mt76_testmode_enabled(phy->mt76))			\
537 			phy->rxfilter |= !(flags & FIF_##_flag) * (_hw);\
538 	} while (0)
539 
540 	phy->rxfilter &= ~(MT_WF_RFCR_DROP_OTHER_BSS |
541 			   MT_WF_RFCR_DROP_FRAME_REPORT |
542 			   MT_WF_RFCR_DROP_PROBEREQ |
543 			   MT_WF_RFCR_DROP_MCAST_FILTERED |
544 			   MT_WF_RFCR_DROP_MCAST |
545 			   MT_WF_RFCR_DROP_BCAST |
546 			   MT_WF_RFCR_DROP_DUPLICATE |
547 			   MT_WF_RFCR_DROP_A2_BSSID |
548 			   MT_WF_RFCR_DROP_UNWANTED_CTL |
549 			   MT_WF_RFCR_DROP_STBC_MULTI);
550 
551 	if (phy->n_beacon_vif || !mt7615_firmware_offload(dev))
552 		phy->rxfilter &= ~MT_WF_RFCR_DROP_OTHER_BEACON;
553 
554 	MT76_FILTER(OTHER_BSS, MT_WF_RFCR_DROP_OTHER_TIM |
555 			       MT_WF_RFCR_DROP_A3_MAC |
556 			       MT_WF_RFCR_DROP_A3_BSSID);
557 
558 	MT76_FILTER(FCSFAIL, MT_WF_RFCR_DROP_FCSFAIL);
559 
560 	MT76_FILTER(CONTROL, MT_WF_RFCR_DROP_CTS |
561 			     MT_WF_RFCR_DROP_RTS |
562 			     MT_WF_RFCR_DROP_CTL_RSV |
563 			     MT_WF_RFCR_DROP_NDPA);
564 
565 	*total_flags = flags;
566 	mt76_wr(dev, MT_WF_RFCR(band), phy->rxfilter);
567 
568 	if (*total_flags & FIF_CONTROL)
569 		mt76_clear(dev, MT_WF_RFCR1(band), ctl_flags);
570 	else
571 		mt76_set(dev, MT_WF_RFCR1(band), ctl_flags);
572 
573 	mt7615_mutex_release(dev);
574 }
575 
576 static void mt7615_bss_info_changed(struct ieee80211_hw *hw,
577 				    struct ieee80211_vif *vif,
578 				    struct ieee80211_bss_conf *info,
579 				    u32 changed)
580 {
581 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
582 	struct mt7615_phy *phy = mt7615_hw_phy(hw);
583 
584 	mt7615_mutex_acquire(dev);
585 
586 	if (changed & BSS_CHANGED_ERP_SLOT) {
587 		int slottime = info->use_short_slot ? 9 : 20;
588 
589 		if (slottime != phy->slottime) {
590 			phy->slottime = slottime;
591 			mt7615_mac_set_timing(phy);
592 		}
593 	}
594 
595 	if (changed & BSS_CHANGED_BEACON_ENABLED && info->enable_beacon) {
596 		mt7615_mcu_add_bss_info(phy, vif, NULL, true);
597 		mt7615_mcu_sta_add(phy, vif, NULL, true);
598 
599 		if (mt7615_firmware_offload(dev) && vif->p2p)
600 			mt76_connac_mcu_set_p2p_oppps(hw, vif);
601 	}
602 
603 	if (changed & (BSS_CHANGED_BEACON |
604 		       BSS_CHANGED_BEACON_ENABLED))
605 		mt7615_mcu_add_beacon(dev, hw, vif, info->enable_beacon);
606 
607 	if (changed & BSS_CHANGED_PS)
608 		mt76_connac_mcu_set_vif_ps(&dev->mt76, vif);
609 
610 	if ((changed & BSS_CHANGED_ARP_FILTER) &&
611 	    mt7615_firmware_offload(dev)) {
612 		struct mt7615_vif *mvif = (struct mt7615_vif *)vif->drv_priv;
613 
614 		mt76_connac_mcu_update_arp_filter(&dev->mt76, &mvif->mt76,
615 						  info);
616 	}
617 
618 	if (changed & BSS_CHANGED_ASSOC)
619 		mt7615_mac_set_beacon_filter(phy, vif, info->assoc);
620 
621 	mt7615_mutex_release(dev);
622 }
623 
624 static void
625 mt7615_channel_switch_beacon(struct ieee80211_hw *hw,
626 			     struct ieee80211_vif *vif,
627 			     struct cfg80211_chan_def *chandef)
628 {
629 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
630 
631 	mt7615_mutex_acquire(dev);
632 	mt7615_mcu_add_beacon(dev, hw, vif, true);
633 	mt7615_mutex_release(dev);
634 }
635 
636 int mt7615_mac_sta_add(struct mt76_dev *mdev, struct ieee80211_vif *vif,
637 		       struct ieee80211_sta *sta)
638 {
639 	struct mt7615_dev *dev = container_of(mdev, struct mt7615_dev, mt76);
640 	struct mt7615_sta *msta = (struct mt7615_sta *)sta->drv_priv;
641 	struct mt7615_vif *mvif = (struct mt7615_vif *)vif->drv_priv;
642 	struct mt7615_phy *phy;
643 	int idx, err;
644 
645 	idx = mt76_wcid_alloc(dev->mt76.wcid_mask, MT7615_WTBL_STA - 1);
646 	if (idx < 0)
647 		return -ENOSPC;
648 
649 	INIT_LIST_HEAD(&msta->poll_list);
650 	msta->vif = mvif;
651 	msta->wcid.sta = 1;
652 	msta->wcid.idx = idx;
653 	msta->wcid.ext_phy = mvif->mt76.band_idx;
654 
655 	phy = mvif->mt76.band_idx ? mt7615_ext_phy(dev) : &dev->phy;
656 	err = mt76_connac_pm_wake(phy->mt76, &dev->pm);
657 	if (err)
658 		return err;
659 
660 	if (vif->type == NL80211_IFTYPE_STATION && !sta->tdls) {
661 		err = mt7615_mcu_add_bss_info(phy, vif, sta, true);
662 		if (err)
663 			return err;
664 	}
665 
666 	mt7615_mac_wtbl_update(dev, idx,
667 			       MT_WTBL_UPDATE_ADM_COUNT_CLEAR);
668 	err = mt7615_mcu_sta_add(&dev->phy, vif, sta, true);
669 	if (err)
670 		return err;
671 
672 	mt76_connac_power_save_sched(phy->mt76, &dev->pm);
673 
674 	return err;
675 }
676 EXPORT_SYMBOL_GPL(mt7615_mac_sta_add);
677 
678 void mt7615_mac_sta_remove(struct mt76_dev *mdev, struct ieee80211_vif *vif,
679 			   struct ieee80211_sta *sta)
680 {
681 	struct mt7615_dev *dev = container_of(mdev, struct mt7615_dev, mt76);
682 	struct mt7615_sta *msta = (struct mt7615_sta *)sta->drv_priv;
683 	struct mt7615_vif *mvif = (struct mt7615_vif *)vif->drv_priv;
684 	struct mt7615_phy *phy;
685 
686 	mt76_connac_free_pending_tx_skbs(&dev->pm, &msta->wcid);
687 
688 	phy = mvif->mt76.band_idx ? mt7615_ext_phy(dev) : &dev->phy;
689 	mt76_connac_pm_wake(phy->mt76, &dev->pm);
690 
691 	mt7615_mcu_sta_add(&dev->phy, vif, sta, false);
692 	mt7615_mac_wtbl_update(dev, msta->wcid.idx,
693 			       MT_WTBL_UPDATE_ADM_COUNT_CLEAR);
694 	if (vif->type == NL80211_IFTYPE_STATION && !sta->tdls)
695 		mt7615_mcu_add_bss_info(phy, vif, sta, false);
696 
697 	spin_lock_bh(&dev->sta_poll_lock);
698 	if (!list_empty(&msta->poll_list))
699 		list_del_init(&msta->poll_list);
700 	spin_unlock_bh(&dev->sta_poll_lock);
701 
702 	mt76_connac_power_save_sched(phy->mt76, &dev->pm);
703 }
704 EXPORT_SYMBOL_GPL(mt7615_mac_sta_remove);
705 
706 static void mt7615_sta_rate_tbl_update(struct ieee80211_hw *hw,
707 				       struct ieee80211_vif *vif,
708 				       struct ieee80211_sta *sta)
709 {
710 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
711 	struct mt7615_phy *phy = mt7615_hw_phy(hw);
712 	struct mt7615_sta *msta = (struct mt7615_sta *)sta->drv_priv;
713 	struct ieee80211_sta_rates *sta_rates = rcu_dereference(sta->rates);
714 	int i;
715 
716 	if (!sta_rates)
717 		return;
718 
719 	spin_lock_bh(&dev->mt76.lock);
720 	for (i = 0; i < ARRAY_SIZE(msta->rates); i++) {
721 		msta->rates[i].idx = sta_rates->rate[i].idx;
722 		msta->rates[i].count = sta_rates->rate[i].count;
723 		msta->rates[i].flags = sta_rates->rate[i].flags;
724 
725 		if (msta->rates[i].idx < 0 || !msta->rates[i].count)
726 			break;
727 	}
728 	msta->n_rates = i;
729 	if (mt76_connac_pm_ref(phy->mt76, &dev->pm)) {
730 		mt7615_mac_set_rates(phy, msta, NULL, msta->rates);
731 		mt76_connac_pm_unref(phy->mt76, &dev->pm);
732 	}
733 	spin_unlock_bh(&dev->mt76.lock);
734 }
735 
736 void mt7615_tx_worker(struct mt76_worker *w)
737 {
738 	struct mt7615_dev *dev = container_of(w, struct mt7615_dev,
739 					      mt76.tx_worker);
740 
741 	if (!mt76_connac_pm_ref(&dev->mphy, &dev->pm)) {
742 		queue_work(dev->mt76.wq, &dev->pm.wake_work);
743 		return;
744 	}
745 
746 	mt76_tx_worker_run(&dev->mt76);
747 	mt76_connac_pm_unref(&dev->mphy, &dev->pm);
748 }
749 
750 static void mt7615_tx(struct ieee80211_hw *hw,
751 		      struct ieee80211_tx_control *control,
752 		      struct sk_buff *skb)
753 {
754 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
755 	struct mt76_phy *mphy = hw->priv;
756 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
757 	struct ieee80211_vif *vif = info->control.vif;
758 	struct mt76_wcid *wcid = &dev->mt76.global_wcid;
759 	struct mt7615_sta *msta = NULL;
760 	int qid;
761 
762 	if (control->sta) {
763 		msta = (struct mt7615_sta *)control->sta->drv_priv;
764 		wcid = &msta->wcid;
765 	}
766 
767 	if (vif && !control->sta) {
768 		struct mt7615_vif *mvif;
769 
770 		mvif = (struct mt7615_vif *)vif->drv_priv;
771 		msta = &mvif->sta;
772 		wcid = &msta->wcid;
773 	}
774 
775 	if (mt76_connac_pm_ref(mphy, &dev->pm)) {
776 		mt76_tx(mphy, control->sta, wcid, skb);
777 		mt76_connac_pm_unref(mphy, &dev->pm);
778 		return;
779 	}
780 
781 	qid = skb_get_queue_mapping(skb);
782 	if (qid >= MT_TXQ_PSD) {
783 		qid = IEEE80211_AC_BE;
784 		skb_set_queue_mapping(skb, qid);
785 	}
786 
787 	mt76_connac_pm_queue_skb(hw, &dev->pm, wcid, skb);
788 }
789 
790 static int mt7615_set_rts_threshold(struct ieee80211_hw *hw, u32 val)
791 {
792 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
793 	struct mt7615_phy *phy = mt7615_hw_phy(hw);
794 	int err, band = phy != &dev->phy;
795 
796 	mt7615_mutex_acquire(dev);
797 	err = mt76_connac_mcu_set_rts_thresh(&dev->mt76, val, band);
798 	mt7615_mutex_release(dev);
799 
800 	return err;
801 }
802 
803 static int
804 mt7615_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
805 		    struct ieee80211_ampdu_params *params)
806 {
807 	enum ieee80211_ampdu_mlme_action action = params->action;
808 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
809 	struct ieee80211_sta *sta = params->sta;
810 	struct ieee80211_txq *txq = sta->txq[params->tid];
811 	struct mt7615_sta *msta = (struct mt7615_sta *)sta->drv_priv;
812 	u16 tid = params->tid;
813 	u16 ssn = params->ssn;
814 	struct mt76_txq *mtxq;
815 	int ret = 0;
816 
817 	if (!txq)
818 		return -EINVAL;
819 
820 	mtxq = (struct mt76_txq *)txq->drv_priv;
821 
822 	mt7615_mutex_acquire(dev);
823 
824 	switch (action) {
825 	case IEEE80211_AMPDU_RX_START:
826 		mt76_rx_aggr_start(&dev->mt76, &msta->wcid, tid, ssn,
827 				   params->buf_size);
828 		ret = mt7615_mcu_add_rx_ba(dev, params, true);
829 		break;
830 	case IEEE80211_AMPDU_RX_STOP:
831 		mt76_rx_aggr_stop(&dev->mt76, &msta->wcid, tid);
832 		ret = mt7615_mcu_add_rx_ba(dev, params, false);
833 		break;
834 	case IEEE80211_AMPDU_TX_OPERATIONAL:
835 		mtxq->aggr = true;
836 		mtxq->send_bar = false;
837 		ret = mt7615_mcu_add_tx_ba(dev, params, true);
838 		ssn = mt7615_mac_get_sta_tid_sn(dev, msta->wcid.idx, tid);
839 		ieee80211_send_bar(vif, sta->addr, tid,
840 				   IEEE80211_SN_TO_SEQ(ssn));
841 		break;
842 	case IEEE80211_AMPDU_TX_STOP_FLUSH:
843 	case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
844 		mtxq->aggr = false;
845 		ret = mt7615_mcu_add_tx_ba(dev, params, false);
846 		break;
847 	case IEEE80211_AMPDU_TX_START:
848 		ssn = mt7615_mac_get_sta_tid_sn(dev, msta->wcid.idx, tid);
849 		params->ssn = ssn;
850 		ret = IEEE80211_AMPDU_TX_START_IMMEDIATE;
851 		break;
852 	case IEEE80211_AMPDU_TX_STOP_CONT:
853 		mtxq->aggr = false;
854 		ret = mt7615_mcu_add_tx_ba(dev, params, false);
855 		ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
856 		break;
857 	}
858 	mt7615_mutex_release(dev);
859 
860 	return ret;
861 }
862 
863 static int
864 mt7615_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
865 	       struct ieee80211_sta *sta)
866 {
867     return mt76_sta_state(hw, vif, sta, IEEE80211_STA_NOTEXIST,
868 			  IEEE80211_STA_NONE);
869 }
870 
871 static int
872 mt7615_sta_remove(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
873 		  struct ieee80211_sta *sta)
874 {
875     return mt76_sta_state(hw, vif, sta, IEEE80211_STA_NONE,
876 			  IEEE80211_STA_NOTEXIST);
877 }
878 
879 static int
880 mt7615_get_stats(struct ieee80211_hw *hw,
881 		 struct ieee80211_low_level_stats *stats)
882 {
883 	struct mt7615_phy *phy = mt7615_hw_phy(hw);
884 	struct mib_stats *mib = &phy->mib;
885 
886 	mt7615_mutex_acquire(phy->dev);
887 
888 	stats->dot11RTSSuccessCount = mib->rts_cnt;
889 	stats->dot11RTSFailureCount = mib->rts_retries_cnt;
890 	stats->dot11FCSErrorCount = mib->fcs_err_cnt;
891 	stats->dot11ACKFailureCount = mib->ack_fail_cnt;
892 
893 	mt7615_mutex_release(phy->dev);
894 
895 	return 0;
896 }
897 
898 static u64
899 mt7615_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
900 {
901 	struct mt7615_vif *mvif = (struct mt7615_vif *)vif->drv_priv;
902 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
903 	union {
904 		u64 t64;
905 		u32 t32[2];
906 	} tsf;
907 	u16 idx = mvif->mt76.omac_idx;
908 	u32 reg;
909 
910 	idx = idx > HW_BSSID_MAX ? HW_BSSID_0 : idx;
911 	reg = idx > 1 ? MT_LPON_TCR2(idx): MT_LPON_TCR0(idx);
912 
913 	mt7615_mutex_acquire(dev);
914 
915 	/* TSF read */
916 	mt76_rmw(dev, reg, MT_LPON_TCR_MODE, MT_LPON_TCR_READ);
917 	tsf.t32[0] = mt76_rr(dev, MT_LPON_UTTR0);
918 	tsf.t32[1] = mt76_rr(dev, MT_LPON_UTTR1);
919 
920 	mt7615_mutex_release(dev);
921 
922 	return tsf.t64;
923 }
924 
925 static void
926 mt7615_set_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
927 	       u64 timestamp)
928 {
929 	struct mt7615_vif *mvif = (struct mt7615_vif *)vif->drv_priv;
930 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
931 	union {
932 		u64 t64;
933 		u32 t32[2];
934 	} tsf = { .t64 = timestamp, };
935 	u16 idx = mvif->mt76.omac_idx;
936 	u32 reg;
937 
938 	idx = idx > HW_BSSID_MAX ? HW_BSSID_0 : idx;
939 	reg = idx > 1 ? MT_LPON_TCR2(idx): MT_LPON_TCR0(idx);
940 
941 	mt7615_mutex_acquire(dev);
942 
943 	mt76_wr(dev, MT_LPON_UTTR0, tsf.t32[0]);
944 	mt76_wr(dev, MT_LPON_UTTR1, tsf.t32[1]);
945 	/* TSF software overwrite */
946 	mt76_rmw(dev, reg, MT_LPON_TCR_MODE, MT_LPON_TCR_WRITE);
947 
948 	mt7615_mutex_release(dev);
949 }
950 
951 static void
952 mt7615_offset_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
953 		  s64 timestamp)
954 {
955 	struct mt7615_vif *mvif = (struct mt7615_vif *)vif->drv_priv;
956 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
957 	union {
958 		u64 t64;
959 		u32 t32[2];
960 	} tsf = { .t64 = timestamp, };
961 	u16 idx = mvif->mt76.omac_idx;
962 	u32 reg;
963 
964 	idx = idx > HW_BSSID_MAX ? HW_BSSID_0 : idx;
965 	reg = idx > 1 ? MT_LPON_TCR2(idx): MT_LPON_TCR0(idx);
966 
967 	mt7615_mutex_acquire(dev);
968 
969 	mt76_wr(dev, MT_LPON_UTTR0, tsf.t32[0]);
970 	mt76_wr(dev, MT_LPON_UTTR1, tsf.t32[1]);
971 	/* TSF software adjust*/
972 	mt76_rmw(dev, reg, MT_LPON_TCR_MODE, MT_LPON_TCR_ADJUST);
973 
974 	mt7615_mutex_release(dev);
975 }
976 
977 static void
978 mt7615_set_coverage_class(struct ieee80211_hw *hw, s16 coverage_class)
979 {
980 	struct mt7615_phy *phy = mt7615_hw_phy(hw);
981 	struct mt7615_dev *dev = phy->dev;
982 
983 	mt7615_mutex_acquire(dev);
984 	phy->coverage_class = max_t(s16, coverage_class, 0);
985 	mt7615_mac_set_timing(phy);
986 	mt7615_mutex_release(dev);
987 }
988 
989 static int
990 mt7615_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
991 {
992 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
993 	struct mt7615_phy *phy = mt7615_hw_phy(hw);
994 	int max_nss = hweight8(hw->wiphy->available_antennas_tx);
995 	bool ext_phy = phy != &dev->phy;
996 
997 	if (!tx_ant || tx_ant != rx_ant || ffs(tx_ant) > max_nss)
998 		return -EINVAL;
999 
1000 	if ((BIT(hweight8(tx_ant)) - 1) != tx_ant)
1001 		tx_ant = BIT(ffs(tx_ant) - 1) - 1;
1002 
1003 	mt7615_mutex_acquire(dev);
1004 
1005 	phy->mt76->antenna_mask = tx_ant;
1006 	if (ext_phy) {
1007 		if (dev->chainmask == 0xf)
1008 			tx_ant <<= 2;
1009 		else
1010 			tx_ant <<= 1;
1011 	}
1012 	phy->mt76->chainmask = tx_ant;
1013 
1014 	mt76_set_stream_caps(phy->mt76, true);
1015 
1016 	mt7615_mutex_release(dev);
1017 
1018 	return 0;
1019 }
1020 
1021 static void mt7615_roc_iter(void *priv, u8 *mac,
1022 			    struct ieee80211_vif *vif)
1023 {
1024 	struct mt7615_phy *phy = priv;
1025 
1026 	mt7615_mcu_set_roc(phy, vif, NULL, 0);
1027 }
1028 
1029 void mt7615_roc_work(struct work_struct *work)
1030 {
1031 	struct mt7615_phy *phy;
1032 
1033 	phy = (struct mt7615_phy *)container_of(work, struct mt7615_phy,
1034 						roc_work);
1035 
1036 	if (!test_and_clear_bit(MT76_STATE_ROC, &phy->mt76->state))
1037 		return;
1038 
1039 	mt7615_mutex_acquire(phy->dev);
1040 	ieee80211_iterate_active_interfaces(phy->mt76->hw,
1041 					    IEEE80211_IFACE_ITER_RESUME_ALL,
1042 					    mt7615_roc_iter, phy);
1043 	mt7615_mutex_release(phy->dev);
1044 	ieee80211_remain_on_channel_expired(phy->mt76->hw);
1045 }
1046 
1047 void mt7615_roc_timer(struct timer_list *timer)
1048 {
1049 	struct mt7615_phy *phy = from_timer(phy, timer, roc_timer);
1050 
1051 	ieee80211_queue_work(phy->mt76->hw, &phy->roc_work);
1052 }
1053 
1054 void mt7615_scan_work(struct work_struct *work)
1055 {
1056 	struct mt7615_phy *phy;
1057 
1058 	phy = (struct mt7615_phy *)container_of(work, struct mt7615_phy,
1059 						scan_work.work);
1060 
1061 	while (true) {
1062 		struct mt7615_mcu_rxd *rxd;
1063 		struct sk_buff *skb;
1064 
1065 		spin_lock_bh(&phy->dev->mt76.lock);
1066 		skb = __skb_dequeue(&phy->scan_event_list);
1067 		spin_unlock_bh(&phy->dev->mt76.lock);
1068 
1069 		if (!skb)
1070 			break;
1071 
1072 		rxd = (struct mt7615_mcu_rxd *)skb->data;
1073 		if (rxd->eid == MCU_EVENT_SCHED_SCAN_DONE) {
1074 			ieee80211_sched_scan_results(phy->mt76->hw);
1075 		} else if (test_and_clear_bit(MT76_HW_SCANNING,
1076 					      &phy->mt76->state)) {
1077 			struct cfg80211_scan_info info = {
1078 				.aborted = false,
1079 			};
1080 
1081 			ieee80211_scan_completed(phy->mt76->hw, &info);
1082 		}
1083 		dev_kfree_skb(skb);
1084 	}
1085 }
1086 
1087 static int
1088 mt7615_hw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1089 	       struct ieee80211_scan_request *req)
1090 {
1091 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
1092 	struct mt76_phy *mphy = hw->priv;
1093 	int err;
1094 
1095 	/* fall-back to sw-scan */
1096 	if (!mt7615_firmware_offload(dev))
1097 		return 1;
1098 
1099 	mt7615_mutex_acquire(dev);
1100 	err = mt76_connac_mcu_hw_scan(mphy, vif, req);
1101 	mt7615_mutex_release(dev);
1102 
1103 	return err;
1104 }
1105 
1106 static void
1107 mt7615_cancel_hw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
1108 {
1109 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
1110 	struct mt76_phy *mphy = hw->priv;
1111 
1112 	mt7615_mutex_acquire(dev);
1113 	mt76_connac_mcu_cancel_hw_scan(mphy, vif);
1114 	mt7615_mutex_release(dev);
1115 }
1116 
1117 static int
1118 mt7615_start_sched_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1119 			struct cfg80211_sched_scan_request *req,
1120 			struct ieee80211_scan_ies *ies)
1121 {
1122 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
1123 	struct mt76_phy *mphy = hw->priv;
1124 	int err;
1125 
1126 	if (!mt7615_firmware_offload(dev))
1127 		return -EOPNOTSUPP;
1128 
1129 	mt7615_mutex_acquire(dev);
1130 
1131 	err = mt76_connac_mcu_sched_scan_req(mphy, vif, req);
1132 	if (err < 0)
1133 		goto out;
1134 
1135 	err = mt76_connac_mcu_sched_scan_enable(mphy, vif, true);
1136 out:
1137 	mt7615_mutex_release(dev);
1138 
1139 	return err;
1140 }
1141 
1142 static int
1143 mt7615_stop_sched_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
1144 {
1145 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
1146 	struct mt76_phy *mphy = hw->priv;
1147 	int err;
1148 
1149 	if (!mt7615_firmware_offload(dev))
1150 		return -EOPNOTSUPP;
1151 
1152 	mt7615_mutex_acquire(dev);
1153 	err = mt76_connac_mcu_sched_scan_enable(mphy, vif, false);
1154 	mt7615_mutex_release(dev);
1155 
1156 	return err;
1157 }
1158 
1159 static int mt7615_remain_on_channel(struct ieee80211_hw *hw,
1160 				    struct ieee80211_vif *vif,
1161 				    struct ieee80211_channel *chan,
1162 				    int duration,
1163 				    enum ieee80211_roc_type type)
1164 {
1165 	struct mt7615_phy *phy = mt7615_hw_phy(hw);
1166 	int err;
1167 
1168 	if (test_and_set_bit(MT76_STATE_ROC, &phy->mt76->state))
1169 		return 0;
1170 
1171 	mt7615_mutex_acquire(phy->dev);
1172 
1173 	err = mt7615_mcu_set_roc(phy, vif, chan, duration);
1174 	if (err < 0) {
1175 		clear_bit(MT76_STATE_ROC, &phy->mt76->state);
1176 		goto out;
1177 	}
1178 
1179 	if (!wait_event_timeout(phy->roc_wait, phy->roc_grant, HZ)) {
1180 		mt7615_mcu_set_roc(phy, vif, NULL, 0);
1181 		clear_bit(MT76_STATE_ROC, &phy->mt76->state);
1182 		err = -ETIMEDOUT;
1183 	}
1184 
1185 out:
1186 	mt7615_mutex_release(phy->dev);
1187 
1188 	return err;
1189 }
1190 
1191 static int mt7615_cancel_remain_on_channel(struct ieee80211_hw *hw,
1192 					   struct ieee80211_vif *vif)
1193 {
1194 	struct mt7615_phy *phy = mt7615_hw_phy(hw);
1195 	int err;
1196 
1197 	if (!test_and_clear_bit(MT76_STATE_ROC, &phy->mt76->state))
1198 		return 0;
1199 
1200 	del_timer_sync(&phy->roc_timer);
1201 	cancel_work_sync(&phy->roc_work);
1202 
1203 	mt7615_mutex_acquire(phy->dev);
1204 	err = mt7615_mcu_set_roc(phy, vif, NULL, 0);
1205 	mt7615_mutex_release(phy->dev);
1206 
1207 	return err;
1208 }
1209 
1210 static void mt7615_sta_set_decap_offload(struct ieee80211_hw *hw,
1211 				 struct ieee80211_vif *vif,
1212 				 struct ieee80211_sta *sta,
1213 				 bool enabled)
1214 {
1215 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
1216 	struct mt7615_sta *msta = (struct mt7615_sta *)sta->drv_priv;
1217 
1218 	if (enabled)
1219 		set_bit(MT_WCID_FLAG_HDR_TRANS, &msta->wcid.flags);
1220 	else
1221 		clear_bit(MT_WCID_FLAG_HDR_TRANS, &msta->wcid.flags);
1222 
1223 	mt7615_mcu_set_sta_decap_offload(dev, vif, sta);
1224 }
1225 
1226 #ifdef CONFIG_PM
1227 static int mt7615_suspend(struct ieee80211_hw *hw,
1228 			  struct cfg80211_wowlan *wowlan)
1229 {
1230 	struct mt7615_phy *phy = mt7615_hw_phy(hw);
1231 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
1232 	int err = 0;
1233 
1234 	cancel_delayed_work_sync(&dev->pm.ps_work);
1235 	mt76_connac_free_pending_tx_skbs(&dev->pm, NULL);
1236 
1237 	mt7615_mutex_acquire(dev);
1238 
1239 	clear_bit(MT76_STATE_RUNNING, &phy->mt76->state);
1240 	cancel_delayed_work_sync(&phy->scan_work);
1241 	cancel_delayed_work_sync(&phy->mt76->mac_work);
1242 
1243 	set_bit(MT76_STATE_SUSPEND, &phy->mt76->state);
1244 	ieee80211_iterate_active_interfaces(hw,
1245 					    IEEE80211_IFACE_ITER_RESUME_ALL,
1246 					    mt76_connac_mcu_set_suspend_iter,
1247 					    phy->mt76);
1248 
1249 	if (!mt7615_dev_running(dev))
1250 		err = mt76_connac_mcu_set_hif_suspend(&dev->mt76, true);
1251 
1252 	mt7615_mutex_release(dev);
1253 
1254 	return err;
1255 }
1256 
1257 static int mt7615_resume(struct ieee80211_hw *hw)
1258 {
1259 	struct mt7615_phy *phy = mt7615_hw_phy(hw);
1260 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
1261 	unsigned long timeout;
1262 	bool running;
1263 
1264 	mt7615_mutex_acquire(dev);
1265 
1266 	running = mt7615_dev_running(dev);
1267 	set_bit(MT76_STATE_RUNNING, &phy->mt76->state);
1268 
1269 	if (!running) {
1270 		int err;
1271 
1272 		err = mt76_connac_mcu_set_hif_suspend(&dev->mt76, false);
1273 		if (err < 0) {
1274 			mt7615_mutex_release(dev);
1275 			return err;
1276 		}
1277 	}
1278 
1279 	clear_bit(MT76_STATE_SUSPEND, &phy->mt76->state);
1280 	ieee80211_iterate_active_interfaces(hw,
1281 					    IEEE80211_IFACE_ITER_RESUME_ALL,
1282 					    mt76_connac_mcu_set_suspend_iter,
1283 					    phy->mt76);
1284 
1285 	timeout = mt7615_get_macwork_timeout(dev);
1286 	ieee80211_queue_delayed_work(hw, &phy->mt76->mac_work, timeout);
1287 
1288 	mt7615_mutex_release(dev);
1289 
1290 	return 0;
1291 }
1292 
1293 static void mt7615_set_wakeup(struct ieee80211_hw *hw, bool enabled)
1294 {
1295 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
1296 	struct mt76_dev *mdev = &dev->mt76;
1297 
1298 	device_set_wakeup_enable(mdev->dev, enabled);
1299 }
1300 
1301 static void mt7615_set_rekey_data(struct ieee80211_hw *hw,
1302 				  struct ieee80211_vif *vif,
1303 				  struct cfg80211_gtk_rekey_data *data)
1304 {
1305 	struct mt7615_dev *dev = mt7615_hw_dev(hw);
1306 
1307 	mt7615_mutex_acquire(dev);
1308 	mt76_connac_mcu_update_gtk_rekey(hw, vif, data);
1309 	mt7615_mutex_release(dev);
1310 }
1311 #endif /* CONFIG_PM */
1312 
1313 const struct ieee80211_ops mt7615_ops = {
1314 	.tx = mt7615_tx,
1315 	.start = mt7615_start,
1316 	.stop = mt7615_stop,
1317 	.add_interface = mt7615_add_interface,
1318 	.remove_interface = mt7615_remove_interface,
1319 	.config = mt7615_config,
1320 	.conf_tx = mt7615_conf_tx,
1321 	.configure_filter = mt7615_configure_filter,
1322 	.bss_info_changed = mt7615_bss_info_changed,
1323 	.sta_add = mt7615_sta_add,
1324 	.sta_remove = mt7615_sta_remove,
1325 	.sta_pre_rcu_remove = mt76_sta_pre_rcu_remove,
1326 	.set_key = mt7615_set_key,
1327 	.sta_set_decap_offload = mt7615_sta_set_decap_offload,
1328 	.ampdu_action = mt7615_ampdu_action,
1329 	.set_rts_threshold = mt7615_set_rts_threshold,
1330 	.wake_tx_queue = mt76_wake_tx_queue,
1331 	.sta_rate_tbl_update = mt7615_sta_rate_tbl_update,
1332 	.sw_scan_start = mt76_sw_scan,
1333 	.sw_scan_complete = mt76_sw_scan_complete,
1334 	.release_buffered_frames = mt76_release_buffered_frames,
1335 	.get_txpower = mt76_get_txpower,
1336 	.channel_switch_beacon = mt7615_channel_switch_beacon,
1337 	.get_stats = mt7615_get_stats,
1338 	.get_tsf = mt7615_get_tsf,
1339 	.set_tsf = mt7615_set_tsf,
1340 	.offset_tsf = mt7615_offset_tsf,
1341 	.get_survey = mt76_get_survey,
1342 	.get_antenna = mt76_get_antenna,
1343 	.set_antenna = mt7615_set_antenna,
1344 	.set_coverage_class = mt7615_set_coverage_class,
1345 	.hw_scan = mt7615_hw_scan,
1346 	.cancel_hw_scan = mt7615_cancel_hw_scan,
1347 	.sched_scan_start = mt7615_start_sched_scan,
1348 	.sched_scan_stop = mt7615_stop_sched_scan,
1349 	.remain_on_channel = mt7615_remain_on_channel,
1350 	.cancel_remain_on_channel = mt7615_cancel_remain_on_channel,
1351 	CFG80211_TESTMODE_CMD(mt76_testmode_cmd)
1352 	CFG80211_TESTMODE_DUMP(mt76_testmode_dump)
1353 #ifdef CONFIG_PM
1354 	.suspend = mt7615_suspend,
1355 	.resume = mt7615_resume,
1356 	.set_wakeup = mt7615_set_wakeup,
1357 	.set_rekey_data = mt7615_set_rekey_data,
1358 #endif /* CONFIG_PM */
1359 	.set_sar_specs = mt7615_set_sar_specs,
1360 };
1361 EXPORT_SYMBOL_GPL(mt7615_ops);
1362 
1363 MODULE_LICENSE("Dual BSD/GPL");
1364