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