xref: /linux/net/mac80211/driver-ops.h (revision 0ad9617c78acbc71373fb341a6f75d4012b01d69) 
1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3 * Portions of this file
4 * Copyright(c) 2016 Intel Deutschland GmbH
5 * Copyright (C) 2018-2019, 2021-2024 Intel Corporation
6 */
7 
8 #ifndef __MAC80211_DRIVER_OPS
9 #define __MAC80211_DRIVER_OPS
10 
11 #include <net/mac80211.h>
12 #include "ieee80211_i.h"
13 #include "trace.h"
14 
15 #define check_sdata_in_driver(sdata)	({					\
16 	WARN_ONCE(!sdata->local->reconfig_failure &&				\
17 		  !(sdata->flags & IEEE80211_SDATA_IN_DRIVER),			\
18 		  "%s: Failed check-sdata-in-driver check, flags: 0x%x\n",	\
19 		  sdata->dev ? sdata->dev->name : sdata->name, sdata->flags);	\
20 	!!(sdata->flags & IEEE80211_SDATA_IN_DRIVER);				\
21 })
22 
23 static inline struct ieee80211_sub_if_data *
24 get_bss_sdata(struct ieee80211_sub_if_data *sdata)
25 {
26 	if (sdata && sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
27 		sdata = container_of(sdata->bss, struct ieee80211_sub_if_data,
28 				     u.ap);
29 
30 	return sdata;
31 }
32 
33 static inline void drv_tx(struct ieee80211_local *local,
34 			  struct ieee80211_tx_control *control,
35 			  struct sk_buff *skb)
36 {
37 	local->ops->tx(&local->hw, control, skb);
38 }
39 
40 static inline void drv_sync_rx_queues(struct ieee80211_local *local,
41 				      struct sta_info *sta)
42 {
43 	might_sleep();
44 	lockdep_assert_wiphy(local->hw.wiphy);
45 
46 	if (local->ops->sync_rx_queues) {
47 		trace_drv_sync_rx_queues(local, sta->sdata, &sta->sta);
48 		local->ops->sync_rx_queues(&local->hw);
49 		trace_drv_return_void(local);
50 	}
51 }
52 
53 static inline void drv_get_et_strings(struct ieee80211_sub_if_data *sdata,
54 				      u32 sset, u8 *data)
55 {
56 	struct ieee80211_local *local = sdata->local;
57 	if (local->ops->get_et_strings) {
58 		trace_drv_get_et_strings(local, sset);
59 		local->ops->get_et_strings(&local->hw, &sdata->vif, sset, data);
60 		trace_drv_return_void(local);
61 	}
62 }
63 
64 static inline void drv_get_et_stats(struct ieee80211_sub_if_data *sdata,
65 				    struct ethtool_stats *stats,
66 				    u64 *data)
67 {
68 	struct ieee80211_local *local = sdata->local;
69 	if (local->ops->get_et_stats) {
70 		trace_drv_get_et_stats(local);
71 		local->ops->get_et_stats(&local->hw, &sdata->vif, stats, data);
72 		trace_drv_return_void(local);
73 	}
74 }
75 
76 static inline int drv_get_et_sset_count(struct ieee80211_sub_if_data *sdata,
77 					int sset)
78 {
79 	struct ieee80211_local *local = sdata->local;
80 	int rv = 0;
81 	if (local->ops->get_et_sset_count) {
82 		trace_drv_get_et_sset_count(local, sset);
83 		rv = local->ops->get_et_sset_count(&local->hw, &sdata->vif,
84 						   sset);
85 		trace_drv_return_int(local, rv);
86 	}
87 	return rv;
88 }
89 
90 int drv_start(struct ieee80211_local *local);
91 void drv_stop(struct ieee80211_local *local, bool suspend);
92 
93 #ifdef CONFIG_PM
94 static inline int drv_suspend(struct ieee80211_local *local,
95 			      struct cfg80211_wowlan *wowlan)
96 {
97 	int ret;
98 
99 	might_sleep();
100 	lockdep_assert_wiphy(local->hw.wiphy);
101 
102 	trace_drv_suspend(local);
103 	ret = local->ops->suspend(&local->hw, wowlan);
104 	trace_drv_return_int(local, ret);
105 	return ret;
106 }
107 
108 static inline int drv_resume(struct ieee80211_local *local)
109 {
110 	int ret;
111 
112 	might_sleep();
113 	lockdep_assert_wiphy(local->hw.wiphy);
114 
115 	trace_drv_resume(local);
116 	ret = local->ops->resume(&local->hw);
117 	trace_drv_return_int(local, ret);
118 	return ret;
119 }
120 
121 static inline void drv_set_wakeup(struct ieee80211_local *local,
122 				  bool enabled)
123 {
124 	might_sleep();
125 	lockdep_assert_wiphy(local->hw.wiphy);
126 
127 	if (!local->ops->set_wakeup)
128 		return;
129 
130 	trace_drv_set_wakeup(local, enabled);
131 	local->ops->set_wakeup(&local->hw, enabled);
132 	trace_drv_return_void(local);
133 }
134 #endif
135 
136 int drv_add_interface(struct ieee80211_local *local,
137 		      struct ieee80211_sub_if_data *sdata);
138 
139 int drv_change_interface(struct ieee80211_local *local,
140 			 struct ieee80211_sub_if_data *sdata,
141 			 enum nl80211_iftype type, bool p2p);
142 
143 void drv_remove_interface(struct ieee80211_local *local,
144 			  struct ieee80211_sub_if_data *sdata);
145 
146 static inline int drv_config(struct ieee80211_local *local, u32 changed)
147 {
148 	int ret;
149 
150 	might_sleep();
151 	lockdep_assert_wiphy(local->hw.wiphy);
152 
153 	trace_drv_config(local, changed);
154 	ret = local->ops->config(&local->hw, changed);
155 	trace_drv_return_int(local, ret);
156 	return ret;
157 }
158 
159 static inline void drv_vif_cfg_changed(struct ieee80211_local *local,
160 				       struct ieee80211_sub_if_data *sdata,
161 				       u64 changed)
162 {
163 	might_sleep();
164 	lockdep_assert_wiphy(local->hw.wiphy);
165 
166 	if (!check_sdata_in_driver(sdata))
167 		return;
168 
169 	trace_drv_vif_cfg_changed(local, sdata, changed);
170 	if (local->ops->vif_cfg_changed)
171 		local->ops->vif_cfg_changed(&local->hw, &sdata->vif, changed);
172 	else if (local->ops->bss_info_changed)
173 		local->ops->bss_info_changed(&local->hw, &sdata->vif,
174 					     &sdata->vif.bss_conf, changed);
175 	trace_drv_return_void(local);
176 }
177 
178 void drv_link_info_changed(struct ieee80211_local *local,
179 			   struct ieee80211_sub_if_data *sdata,
180 			   struct ieee80211_bss_conf *info,
181 			   int link_id, u64 changed);
182 
183 static inline u64 drv_prepare_multicast(struct ieee80211_local *local,
184 					struct netdev_hw_addr_list *mc_list)
185 {
186 	u64 ret = 0;
187 
188 	trace_drv_prepare_multicast(local, mc_list->count);
189 
190 	if (local->ops->prepare_multicast)
191 		ret = local->ops->prepare_multicast(&local->hw, mc_list);
192 
193 	trace_drv_return_u64(local, ret);
194 
195 	return ret;
196 }
197 
198 static inline void drv_configure_filter(struct ieee80211_local *local,
199 					unsigned int changed_flags,
200 					unsigned int *total_flags,
201 					u64 multicast)
202 {
203 	might_sleep();
204 	lockdep_assert_wiphy(local->hw.wiphy);
205 
206 	trace_drv_configure_filter(local, changed_flags, total_flags,
207 				   multicast);
208 	local->ops->configure_filter(&local->hw, changed_flags, total_flags,
209 				     multicast);
210 	trace_drv_return_void(local);
211 }
212 
213 static inline void drv_config_iface_filter(struct ieee80211_local *local,
214 					   struct ieee80211_sub_if_data *sdata,
215 					   unsigned int filter_flags,
216 					   unsigned int changed_flags)
217 {
218 	might_sleep();
219 	lockdep_assert_wiphy(local->hw.wiphy);
220 
221 	trace_drv_config_iface_filter(local, sdata, filter_flags,
222 				      changed_flags);
223 	if (local->ops->config_iface_filter)
224 		local->ops->config_iface_filter(&local->hw, &sdata->vif,
225 						filter_flags,
226 						changed_flags);
227 	trace_drv_return_void(local);
228 }
229 
230 static inline int drv_set_tim(struct ieee80211_local *local,
231 			      struct ieee80211_sta *sta, bool set)
232 {
233 	int ret = 0;
234 	trace_drv_set_tim(local, sta, set);
235 	if (local->ops->set_tim)
236 		ret = local->ops->set_tim(&local->hw, sta, set);
237 	trace_drv_return_int(local, ret);
238 	return ret;
239 }
240 
241 int drv_set_key(struct ieee80211_local *local,
242 		enum set_key_cmd cmd,
243 		struct ieee80211_sub_if_data *sdata,
244 		struct ieee80211_sta *sta,
245 		struct ieee80211_key_conf *key);
246 
247 static inline void drv_update_tkip_key(struct ieee80211_local *local,
248 				       struct ieee80211_sub_if_data *sdata,
249 				       struct ieee80211_key_conf *conf,
250 				       struct sta_info *sta, u32 iv32,
251 				       u16 *phase1key)
252 {
253 	struct ieee80211_sta *ista = NULL;
254 
255 	if (sta)
256 		ista = &sta->sta;
257 
258 	sdata = get_bss_sdata(sdata);
259 	if (!check_sdata_in_driver(sdata))
260 		return;
261 
262 	trace_drv_update_tkip_key(local, sdata, conf, ista, iv32);
263 	if (local->ops->update_tkip_key)
264 		local->ops->update_tkip_key(&local->hw, &sdata->vif, conf,
265 					    ista, iv32, phase1key);
266 	trace_drv_return_void(local);
267 }
268 
269 static inline int drv_hw_scan(struct ieee80211_local *local,
270 			      struct ieee80211_sub_if_data *sdata,
271 			      struct ieee80211_scan_request *req)
272 {
273 	int ret;
274 
275 	might_sleep();
276 	lockdep_assert_wiphy(local->hw.wiphy);
277 
278 	if (!check_sdata_in_driver(sdata))
279 		return -EIO;
280 
281 	trace_drv_hw_scan(local, sdata);
282 	ret = local->ops->hw_scan(&local->hw, &sdata->vif, req);
283 	trace_drv_return_int(local, ret);
284 	return ret;
285 }
286 
287 static inline void drv_cancel_hw_scan(struct ieee80211_local *local,
288 				      struct ieee80211_sub_if_data *sdata)
289 {
290 	might_sleep();
291 	lockdep_assert_wiphy(local->hw.wiphy);
292 
293 	if (!check_sdata_in_driver(sdata))
294 		return;
295 
296 	trace_drv_cancel_hw_scan(local, sdata);
297 	local->ops->cancel_hw_scan(&local->hw, &sdata->vif);
298 	trace_drv_return_void(local);
299 }
300 
301 static inline int
302 drv_sched_scan_start(struct ieee80211_local *local,
303 		     struct ieee80211_sub_if_data *sdata,
304 		     struct cfg80211_sched_scan_request *req,
305 		     struct ieee80211_scan_ies *ies)
306 {
307 	int ret;
308 
309 	might_sleep();
310 	lockdep_assert_wiphy(local->hw.wiphy);
311 
312 	if (!check_sdata_in_driver(sdata))
313 		return -EIO;
314 
315 	trace_drv_sched_scan_start(local, sdata);
316 	ret = local->ops->sched_scan_start(&local->hw, &sdata->vif,
317 					      req, ies);
318 	trace_drv_return_int(local, ret);
319 	return ret;
320 }
321 
322 static inline int drv_sched_scan_stop(struct ieee80211_local *local,
323 				      struct ieee80211_sub_if_data *sdata)
324 {
325 	int ret;
326 
327 	might_sleep();
328 	lockdep_assert_wiphy(local->hw.wiphy);
329 
330 	if (!check_sdata_in_driver(sdata))
331 		return -EIO;
332 
333 	trace_drv_sched_scan_stop(local, sdata);
334 	ret = local->ops->sched_scan_stop(&local->hw, &sdata->vif);
335 	trace_drv_return_int(local, ret);
336 
337 	return ret;
338 }
339 
340 static inline void drv_sw_scan_start(struct ieee80211_local *local,
341 				     struct ieee80211_sub_if_data *sdata,
342 				     const u8 *mac_addr)
343 {
344 	might_sleep();
345 	lockdep_assert_wiphy(local->hw.wiphy);
346 
347 	trace_drv_sw_scan_start(local, sdata, mac_addr);
348 	if (local->ops->sw_scan_start)
349 		local->ops->sw_scan_start(&local->hw, &sdata->vif, mac_addr);
350 	trace_drv_return_void(local);
351 }
352 
353 static inline void drv_sw_scan_complete(struct ieee80211_local *local,
354 					struct ieee80211_sub_if_data *sdata)
355 {
356 	might_sleep();
357 	lockdep_assert_wiphy(local->hw.wiphy);
358 
359 	trace_drv_sw_scan_complete(local, sdata);
360 	if (local->ops->sw_scan_complete)
361 		local->ops->sw_scan_complete(&local->hw, &sdata->vif);
362 	trace_drv_return_void(local);
363 }
364 
365 static inline int drv_get_stats(struct ieee80211_local *local,
366 				struct ieee80211_low_level_stats *stats)
367 {
368 	int ret = -EOPNOTSUPP;
369 
370 	might_sleep();
371 	lockdep_assert_wiphy(local->hw.wiphy);
372 
373 	if (local->ops->get_stats)
374 		ret = local->ops->get_stats(&local->hw, stats);
375 	trace_drv_get_stats(local, stats, ret);
376 
377 	return ret;
378 }
379 
380 static inline void drv_get_key_seq(struct ieee80211_local *local,
381 				   struct ieee80211_key *key,
382 				   struct ieee80211_key_seq *seq)
383 {
384 	if (local->ops->get_key_seq)
385 		local->ops->get_key_seq(&local->hw, &key->conf, seq);
386 	trace_drv_get_key_seq(local, &key->conf);
387 }
388 
389 static inline int drv_set_frag_threshold(struct ieee80211_local *local,
390 					u32 value)
391 {
392 	int ret = 0;
393 
394 	might_sleep();
395 	lockdep_assert_wiphy(local->hw.wiphy);
396 
397 	trace_drv_set_frag_threshold(local, value);
398 	if (local->ops->set_frag_threshold)
399 		ret = local->ops->set_frag_threshold(&local->hw, value);
400 	trace_drv_return_int(local, ret);
401 	return ret;
402 }
403 
404 static inline int drv_set_rts_threshold(struct ieee80211_local *local,
405 					u32 value)
406 {
407 	int ret = 0;
408 
409 	might_sleep();
410 	lockdep_assert_wiphy(local->hw.wiphy);
411 
412 	trace_drv_set_rts_threshold(local, value);
413 	if (local->ops->set_rts_threshold)
414 		ret = local->ops->set_rts_threshold(&local->hw, value);
415 	trace_drv_return_int(local, ret);
416 	return ret;
417 }
418 
419 static inline int drv_set_coverage_class(struct ieee80211_local *local,
420 					 s16 value)
421 {
422 	int ret = 0;
423 	might_sleep();
424 	lockdep_assert_wiphy(local->hw.wiphy);
425 
426 	trace_drv_set_coverage_class(local, value);
427 	if (local->ops->set_coverage_class)
428 		local->ops->set_coverage_class(&local->hw, value);
429 	else
430 		ret = -EOPNOTSUPP;
431 
432 	trace_drv_return_int(local, ret);
433 	return ret;
434 }
435 
436 static inline void drv_sta_notify(struct ieee80211_local *local,
437 				  struct ieee80211_sub_if_data *sdata,
438 				  enum sta_notify_cmd cmd,
439 				  struct ieee80211_sta *sta)
440 {
441 	sdata = get_bss_sdata(sdata);
442 	if (!check_sdata_in_driver(sdata))
443 		return;
444 
445 	trace_drv_sta_notify(local, sdata, cmd, sta);
446 	if (local->ops->sta_notify)
447 		local->ops->sta_notify(&local->hw, &sdata->vif, cmd, sta);
448 	trace_drv_return_void(local);
449 }
450 
451 static inline int drv_sta_add(struct ieee80211_local *local,
452 			      struct ieee80211_sub_if_data *sdata,
453 			      struct ieee80211_sta *sta)
454 {
455 	int ret = 0;
456 
457 	might_sleep();
458 	lockdep_assert_wiphy(local->hw.wiphy);
459 
460 	sdata = get_bss_sdata(sdata);
461 	if (!check_sdata_in_driver(sdata))
462 		return -EIO;
463 
464 	trace_drv_sta_add(local, sdata, sta);
465 	if (local->ops->sta_add)
466 		ret = local->ops->sta_add(&local->hw, &sdata->vif, sta);
467 
468 	trace_drv_return_int(local, ret);
469 
470 	return ret;
471 }
472 
473 static inline void drv_sta_remove(struct ieee80211_local *local,
474 				  struct ieee80211_sub_if_data *sdata,
475 				  struct ieee80211_sta *sta)
476 {
477 	might_sleep();
478 	lockdep_assert_wiphy(local->hw.wiphy);
479 
480 	sdata = get_bss_sdata(sdata);
481 	if (!check_sdata_in_driver(sdata))
482 		return;
483 
484 	trace_drv_sta_remove(local, sdata, sta);
485 	if (local->ops->sta_remove)
486 		local->ops->sta_remove(&local->hw, &sdata->vif, sta);
487 
488 	trace_drv_return_void(local);
489 }
490 
491 #ifdef CONFIG_MAC80211_DEBUGFS
492 static inline void drv_vif_add_debugfs(struct ieee80211_local *local,
493 				       struct ieee80211_sub_if_data *sdata)
494 {
495 	might_sleep();
496 
497 	if (sdata->vif.type == NL80211_IFTYPE_MONITOR ||
498 	    WARN_ON(!sdata->vif.debugfs_dir))
499 		return;
500 
501 	sdata = get_bss_sdata(sdata);
502 	if (!check_sdata_in_driver(sdata))
503 		return;
504 
505 	if (local->ops->vif_add_debugfs)
506 		local->ops->vif_add_debugfs(&local->hw, &sdata->vif);
507 }
508 
509 static inline void drv_link_add_debugfs(struct ieee80211_local *local,
510 					struct ieee80211_sub_if_data *sdata,
511 					struct ieee80211_bss_conf *link_conf,
512 					struct dentry *dir)
513 {
514 	might_sleep();
515 	lockdep_assert_wiphy(local->hw.wiphy);
516 
517 	sdata = get_bss_sdata(sdata);
518 	if (!check_sdata_in_driver(sdata))
519 		return;
520 
521 	if (local->ops->link_add_debugfs)
522 		local->ops->link_add_debugfs(&local->hw, &sdata->vif,
523 					     link_conf, dir);
524 }
525 
526 static inline void drv_sta_add_debugfs(struct ieee80211_local *local,
527 				       struct ieee80211_sub_if_data *sdata,
528 				       struct ieee80211_sta *sta,
529 				       struct dentry *dir)
530 {
531 	might_sleep();
532 	lockdep_assert_wiphy(local->hw.wiphy);
533 
534 	sdata = get_bss_sdata(sdata);
535 	if (!check_sdata_in_driver(sdata))
536 		return;
537 
538 	if (local->ops->sta_add_debugfs)
539 		local->ops->sta_add_debugfs(&local->hw, &sdata->vif,
540 					    sta, dir);
541 }
542 
543 static inline void drv_link_sta_add_debugfs(struct ieee80211_local *local,
544 					    struct ieee80211_sub_if_data *sdata,
545 					    struct ieee80211_link_sta *link_sta,
546 					    struct dentry *dir)
547 {
548 	might_sleep();
549 	lockdep_assert_wiphy(local->hw.wiphy);
550 
551 	sdata = get_bss_sdata(sdata);
552 	if (!check_sdata_in_driver(sdata))
553 		return;
554 
555 	if (local->ops->link_sta_add_debugfs)
556 		local->ops->link_sta_add_debugfs(&local->hw, &sdata->vif,
557 						 link_sta, dir);
558 }
559 #else
560 static inline void drv_vif_add_debugfs(struct ieee80211_local *local,
561 				       struct ieee80211_sub_if_data *sdata)
562 {
563 	might_sleep();
564 }
565 #endif
566 
567 static inline void drv_sta_pre_rcu_remove(struct ieee80211_local *local,
568 					  struct ieee80211_sub_if_data *sdata,
569 					  struct sta_info *sta)
570 {
571 	might_sleep();
572 	lockdep_assert_wiphy(local->hw.wiphy);
573 
574 	sdata = get_bss_sdata(sdata);
575 	if (!check_sdata_in_driver(sdata))
576 		return;
577 
578 	trace_drv_sta_pre_rcu_remove(local, sdata, &sta->sta);
579 	if (local->ops->sta_pre_rcu_remove)
580 		local->ops->sta_pre_rcu_remove(&local->hw, &sdata->vif,
581 					       &sta->sta);
582 	trace_drv_return_void(local);
583 }
584 
585 __must_check
586 int drv_sta_state(struct ieee80211_local *local,
587 		  struct ieee80211_sub_if_data *sdata,
588 		  struct sta_info *sta,
589 		  enum ieee80211_sta_state old_state,
590 		  enum ieee80211_sta_state new_state);
591 
592 __must_check
593 int drv_sta_set_txpwr(struct ieee80211_local *local,
594 		      struct ieee80211_sub_if_data *sdata,
595 		      struct sta_info *sta);
596 
597 void drv_link_sta_rc_update(struct ieee80211_local *local,
598 			    struct ieee80211_sub_if_data *sdata,
599 			    struct ieee80211_link_sta *link_sta, u32 changed);
600 
601 static inline void drv_sta_rate_tbl_update(struct ieee80211_local *local,
602 					   struct ieee80211_sub_if_data *sdata,
603 					   struct ieee80211_sta *sta)
604 {
605 	sdata = get_bss_sdata(sdata);
606 	if (!check_sdata_in_driver(sdata))
607 		return;
608 
609 	trace_drv_sta_rate_tbl_update(local, sdata, sta);
610 	if (local->ops->sta_rate_tbl_update)
611 		local->ops->sta_rate_tbl_update(&local->hw, &sdata->vif, sta);
612 
613 	trace_drv_return_void(local);
614 }
615 
616 static inline void drv_sta_statistics(struct ieee80211_local *local,
617 				      struct ieee80211_sub_if_data *sdata,
618 				      struct ieee80211_sta *sta,
619 				      struct station_info *sinfo)
620 {
621 	might_sleep();
622 	lockdep_assert_wiphy(local->hw.wiphy);
623 
624 	sdata = get_bss_sdata(sdata);
625 	if (!check_sdata_in_driver(sdata))
626 		return;
627 
628 	trace_drv_sta_statistics(local, sdata, sta);
629 	if (local->ops->sta_statistics)
630 		local->ops->sta_statistics(&local->hw, &sdata->vif, sta, sinfo);
631 	trace_drv_return_void(local);
632 }
633 
634 int drv_conf_tx(struct ieee80211_local *local,
635 		struct ieee80211_link_data *link, u16 ac,
636 		const struct ieee80211_tx_queue_params *params);
637 
638 u64 drv_get_tsf(struct ieee80211_local *local,
639 		struct ieee80211_sub_if_data *sdata);
640 void drv_set_tsf(struct ieee80211_local *local,
641 		 struct ieee80211_sub_if_data *sdata,
642 		 u64 tsf);
643 void drv_offset_tsf(struct ieee80211_local *local,
644 		    struct ieee80211_sub_if_data *sdata,
645 		    s64 offset);
646 void drv_reset_tsf(struct ieee80211_local *local,
647 		   struct ieee80211_sub_if_data *sdata);
648 
649 static inline int drv_tx_last_beacon(struct ieee80211_local *local)
650 {
651 	int ret = 0; /* default unsupported op for less congestion */
652 
653 	might_sleep();
654 	lockdep_assert_wiphy(local->hw.wiphy);
655 
656 	trace_drv_tx_last_beacon(local);
657 	if (local->ops->tx_last_beacon)
658 		ret = local->ops->tx_last_beacon(&local->hw);
659 	trace_drv_return_int(local, ret);
660 	return ret;
661 }
662 
663 int drv_ampdu_action(struct ieee80211_local *local,
664 		     struct ieee80211_sub_if_data *sdata,
665 		     struct ieee80211_ampdu_params *params);
666 
667 static inline int drv_get_survey(struct ieee80211_local *local, int idx,
668 				struct survey_info *survey)
669 {
670 	int ret = -EOPNOTSUPP;
671 
672 	might_sleep();
673 	lockdep_assert_wiphy(local->hw.wiphy);
674 
675 	trace_drv_get_survey(local, idx, survey);
676 
677 	if (local->ops->get_survey)
678 		ret = local->ops->get_survey(&local->hw, idx, survey);
679 
680 	trace_drv_return_int(local, ret);
681 
682 	return ret;
683 }
684 
685 static inline void drv_rfkill_poll(struct ieee80211_local *local)
686 {
687 	might_sleep();
688 	lockdep_assert_wiphy(local->hw.wiphy);
689 
690 	if (local->ops->rfkill_poll)
691 		local->ops->rfkill_poll(&local->hw);
692 }
693 
694 static inline void drv_flush(struct ieee80211_local *local,
695 			     struct ieee80211_sub_if_data *sdata,
696 			     u32 queues, bool drop)
697 {
698 	struct ieee80211_vif *vif;
699 
700 	might_sleep();
701 	lockdep_assert_wiphy(local->hw.wiphy);
702 
703 	sdata = get_bss_sdata(sdata);
704 	vif = sdata ? &sdata->vif : NULL;
705 
706 	if (sdata && !check_sdata_in_driver(sdata))
707 		return;
708 
709 	trace_drv_flush(local, queues, drop);
710 	if (local->ops->flush)
711 		local->ops->flush(&local->hw, vif, queues, drop);
712 	trace_drv_return_void(local);
713 }
714 
715 static inline void drv_flush_sta(struct ieee80211_local *local,
716 				 struct ieee80211_sub_if_data *sdata,
717 				 struct sta_info *sta)
718 {
719 	might_sleep();
720 	lockdep_assert_wiphy(local->hw.wiphy);
721 
722 	sdata = get_bss_sdata(sdata);
723 
724 	if (sdata && !check_sdata_in_driver(sdata))
725 		return;
726 
727 	if (!sta->uploaded)
728 		return;
729 
730 	trace_drv_flush_sta(local, sdata, &sta->sta);
731 	if (local->ops->flush_sta)
732 		local->ops->flush_sta(&local->hw, &sdata->vif, &sta->sta);
733 	trace_drv_return_void(local);
734 }
735 
736 static inline void drv_channel_switch(struct ieee80211_local *local,
737 				      struct ieee80211_sub_if_data *sdata,
738 				      struct ieee80211_channel_switch *ch_switch)
739 {
740 	might_sleep();
741 	lockdep_assert_wiphy(local->hw.wiphy);
742 
743 	trace_drv_channel_switch(local, sdata, ch_switch);
744 	local->ops->channel_switch(&local->hw, &sdata->vif, ch_switch);
745 	trace_drv_return_void(local);
746 }
747 
748 
749 static inline int drv_set_antenna(struct ieee80211_local *local,
750 				  u32 tx_ant, u32 rx_ant)
751 {
752 	int ret = -EOPNOTSUPP;
753 	might_sleep();
754 	lockdep_assert_wiphy(local->hw.wiphy);
755 	if (local->ops->set_antenna)
756 		ret = local->ops->set_antenna(&local->hw, tx_ant, rx_ant);
757 	trace_drv_set_antenna(local, tx_ant, rx_ant, ret);
758 	return ret;
759 }
760 
761 static inline int drv_get_antenna(struct ieee80211_local *local,
762 				  u32 *tx_ant, u32 *rx_ant)
763 {
764 	int ret = -EOPNOTSUPP;
765 	might_sleep();
766 	lockdep_assert_wiphy(local->hw.wiphy);
767 	if (local->ops->get_antenna)
768 		ret = local->ops->get_antenna(&local->hw, tx_ant, rx_ant);
769 	trace_drv_get_antenna(local, *tx_ant, *rx_ant, ret);
770 	return ret;
771 }
772 
773 static inline int drv_remain_on_channel(struct ieee80211_local *local,
774 					struct ieee80211_sub_if_data *sdata,
775 					struct ieee80211_channel *chan,
776 					unsigned int duration,
777 					enum ieee80211_roc_type type)
778 {
779 	int ret;
780 
781 	might_sleep();
782 	lockdep_assert_wiphy(local->hw.wiphy);
783 
784 	trace_drv_remain_on_channel(local, sdata, chan, duration, type);
785 	ret = local->ops->remain_on_channel(&local->hw, &sdata->vif,
786 					    chan, duration, type);
787 	trace_drv_return_int(local, ret);
788 
789 	return ret;
790 }
791 
792 static inline int
793 drv_cancel_remain_on_channel(struct ieee80211_local *local,
794 			     struct ieee80211_sub_if_data *sdata)
795 {
796 	int ret;
797 
798 	might_sleep();
799 	lockdep_assert_wiphy(local->hw.wiphy);
800 
801 	trace_drv_cancel_remain_on_channel(local, sdata);
802 	ret = local->ops->cancel_remain_on_channel(&local->hw, &sdata->vif);
803 	trace_drv_return_int(local, ret);
804 
805 	return ret;
806 }
807 
808 static inline int drv_set_ringparam(struct ieee80211_local *local,
809 				    u32 tx, u32 rx)
810 {
811 	int ret = -EOPNOTSUPP;
812 
813 	might_sleep();
814 	lockdep_assert_wiphy(local->hw.wiphy);
815 
816 	trace_drv_set_ringparam(local, tx, rx);
817 	if (local->ops->set_ringparam)
818 		ret = local->ops->set_ringparam(&local->hw, tx, rx);
819 	trace_drv_return_int(local, ret);
820 
821 	return ret;
822 }
823 
824 static inline void drv_get_ringparam(struct ieee80211_local *local,
825 				     u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max)
826 {
827 	might_sleep();
828 	lockdep_assert_wiphy(local->hw.wiphy);
829 
830 	trace_drv_get_ringparam(local, tx, tx_max, rx, rx_max);
831 	if (local->ops->get_ringparam)
832 		local->ops->get_ringparam(&local->hw, tx, tx_max, rx, rx_max);
833 	trace_drv_return_void(local);
834 }
835 
836 static inline bool drv_tx_frames_pending(struct ieee80211_local *local)
837 {
838 	bool ret = false;
839 
840 	might_sleep();
841 	lockdep_assert_wiphy(local->hw.wiphy);
842 
843 	trace_drv_tx_frames_pending(local);
844 	if (local->ops->tx_frames_pending)
845 		ret = local->ops->tx_frames_pending(&local->hw);
846 	trace_drv_return_bool(local, ret);
847 
848 	return ret;
849 }
850 
851 static inline int drv_set_bitrate_mask(struct ieee80211_local *local,
852 				       struct ieee80211_sub_if_data *sdata,
853 				       const struct cfg80211_bitrate_mask *mask)
854 {
855 	int ret = -EOPNOTSUPP;
856 
857 	might_sleep();
858 	lockdep_assert_wiphy(local->hw.wiphy);
859 
860 	if (!check_sdata_in_driver(sdata))
861 		return -EIO;
862 
863 	trace_drv_set_bitrate_mask(local, sdata, mask);
864 	if (local->ops->set_bitrate_mask)
865 		ret = local->ops->set_bitrate_mask(&local->hw,
866 						   &sdata->vif, mask);
867 	trace_drv_return_int(local, ret);
868 
869 	return ret;
870 }
871 
872 static inline void drv_set_rekey_data(struct ieee80211_local *local,
873 				      struct ieee80211_sub_if_data *sdata,
874 				      struct cfg80211_gtk_rekey_data *data)
875 {
876 	might_sleep();
877 	lockdep_assert_wiphy(local->hw.wiphy);
878 
879 	if (!check_sdata_in_driver(sdata))
880 		return;
881 
882 	trace_drv_set_rekey_data(local, sdata, data);
883 	if (local->ops->set_rekey_data)
884 		local->ops->set_rekey_data(&local->hw, &sdata->vif, data);
885 	trace_drv_return_void(local);
886 }
887 
888 static inline void drv_event_callback(struct ieee80211_local *local,
889 				      struct ieee80211_sub_if_data *sdata,
890 				      const struct ieee80211_event *event)
891 {
892 	trace_drv_event_callback(local, sdata, event);
893 	if (local->ops->event_callback)
894 		local->ops->event_callback(&local->hw, &sdata->vif, event);
895 	trace_drv_return_void(local);
896 }
897 
898 static inline void
899 drv_release_buffered_frames(struct ieee80211_local *local,
900 			    struct sta_info *sta, u16 tids, int num_frames,
901 			    enum ieee80211_frame_release_type reason,
902 			    bool more_data)
903 {
904 	trace_drv_release_buffered_frames(local, &sta->sta, tids, num_frames,
905 					  reason, more_data);
906 	if (local->ops->release_buffered_frames)
907 		local->ops->release_buffered_frames(&local->hw, &sta->sta, tids,
908 						    num_frames, reason,
909 						    more_data);
910 	trace_drv_return_void(local);
911 }
912 
913 static inline void
914 drv_allow_buffered_frames(struct ieee80211_local *local,
915 			  struct sta_info *sta, u16 tids, int num_frames,
916 			  enum ieee80211_frame_release_type reason,
917 			  bool more_data)
918 {
919 	trace_drv_allow_buffered_frames(local, &sta->sta, tids, num_frames,
920 					reason, more_data);
921 	if (local->ops->allow_buffered_frames)
922 		local->ops->allow_buffered_frames(&local->hw, &sta->sta,
923 						  tids, num_frames, reason,
924 						  more_data);
925 	trace_drv_return_void(local);
926 }
927 
928 static inline void drv_mgd_prepare_tx(struct ieee80211_local *local,
929 				      struct ieee80211_sub_if_data *sdata,
930 				      struct ieee80211_prep_tx_info *info)
931 {
932 	might_sleep();
933 	lockdep_assert_wiphy(local->hw.wiphy);
934 
935 	if (!check_sdata_in_driver(sdata))
936 		return;
937 	WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION);
938 
939 	info->link_id = info->link_id < 0 ? 0 : info->link_id;
940 	trace_drv_mgd_prepare_tx(local, sdata, info->duration,
941 				 info->subtype, info->success);
942 	if (local->ops->mgd_prepare_tx)
943 		local->ops->mgd_prepare_tx(&local->hw, &sdata->vif, info);
944 	trace_drv_return_void(local);
945 }
946 
947 static inline void drv_mgd_complete_tx(struct ieee80211_local *local,
948 				       struct ieee80211_sub_if_data *sdata,
949 				       struct ieee80211_prep_tx_info *info)
950 {
951 	might_sleep();
952 	lockdep_assert_wiphy(local->hw.wiphy);
953 
954 	if (!check_sdata_in_driver(sdata))
955 		return;
956 	WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION);
957 
958 	trace_drv_mgd_complete_tx(local, sdata, info->duration,
959 				  info->subtype, info->success);
960 	if (local->ops->mgd_complete_tx)
961 		local->ops->mgd_complete_tx(&local->hw, &sdata->vif, info);
962 	trace_drv_return_void(local);
963 }
964 
965 static inline void
966 drv_mgd_protect_tdls_discover(struct ieee80211_local *local,
967 			      struct ieee80211_sub_if_data *sdata,
968 			      int link_id)
969 {
970 	might_sleep();
971 	lockdep_assert_wiphy(local->hw.wiphy);
972 
973 	if (!check_sdata_in_driver(sdata))
974 		return;
975 	WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION);
976 
977 	link_id = link_id > 0 ? link_id : 0;
978 
979 	trace_drv_mgd_protect_tdls_discover(local, sdata);
980 	if (local->ops->mgd_protect_tdls_discover)
981 		local->ops->mgd_protect_tdls_discover(&local->hw, &sdata->vif,
982 						      link_id);
983 	trace_drv_return_void(local);
984 }
985 
986 static inline int drv_add_chanctx(struct ieee80211_local *local,
987 				  struct ieee80211_chanctx *ctx)
988 {
989 	int ret = -EOPNOTSUPP;
990 
991 	might_sleep();
992 	lockdep_assert_wiphy(local->hw.wiphy);
993 
994 	trace_drv_add_chanctx(local, ctx);
995 	if (local->ops->add_chanctx)
996 		ret = local->ops->add_chanctx(&local->hw, &ctx->conf);
997 	trace_drv_return_int(local, ret);
998 	if (!ret)
999 		ctx->driver_present = true;
1000 
1001 	return ret;
1002 }
1003 
1004 static inline void drv_remove_chanctx(struct ieee80211_local *local,
1005 				      struct ieee80211_chanctx *ctx)
1006 {
1007 	might_sleep();
1008 	lockdep_assert_wiphy(local->hw.wiphy);
1009 
1010 	if (WARN_ON(!ctx->driver_present))
1011 		return;
1012 
1013 	trace_drv_remove_chanctx(local, ctx);
1014 	if (local->ops->remove_chanctx)
1015 		local->ops->remove_chanctx(&local->hw, &ctx->conf);
1016 	trace_drv_return_void(local);
1017 	ctx->driver_present = false;
1018 }
1019 
1020 static inline void drv_change_chanctx(struct ieee80211_local *local,
1021 				      struct ieee80211_chanctx *ctx,
1022 				      u32 changed)
1023 {
1024 	might_sleep();
1025 	lockdep_assert_wiphy(local->hw.wiphy);
1026 
1027 	trace_drv_change_chanctx(local, ctx, changed);
1028 	if (local->ops->change_chanctx) {
1029 		WARN_ON_ONCE(!ctx->driver_present);
1030 		local->ops->change_chanctx(&local->hw, &ctx->conf, changed);
1031 	}
1032 	trace_drv_return_void(local);
1033 }
1034 
1035 int drv_assign_vif_chanctx(struct ieee80211_local *local,
1036 			   struct ieee80211_sub_if_data *sdata,
1037 			   struct ieee80211_bss_conf *link_conf,
1038 			   struct ieee80211_chanctx *ctx);
1039 void drv_unassign_vif_chanctx(struct ieee80211_local *local,
1040 			      struct ieee80211_sub_if_data *sdata,
1041 			      struct ieee80211_bss_conf *link_conf,
1042 			      struct ieee80211_chanctx *ctx);
1043 int drv_switch_vif_chanctx(struct ieee80211_local *local,
1044 			   struct ieee80211_vif_chanctx_switch *vifs,
1045 			   int n_vifs, enum ieee80211_chanctx_switch_mode mode);
1046 
1047 static inline int drv_start_ap(struct ieee80211_local *local,
1048 			       struct ieee80211_sub_if_data *sdata,
1049 			       struct ieee80211_bss_conf *link_conf)
1050 {
1051 	int ret = 0;
1052 
1053 	might_sleep();
1054 	lockdep_assert_wiphy(local->hw.wiphy);
1055 
1056 	if (!check_sdata_in_driver(sdata))
1057 		return -EIO;
1058 
1059 	trace_drv_start_ap(local, sdata, link_conf);
1060 	if (local->ops->start_ap)
1061 		ret = local->ops->start_ap(&local->hw, &sdata->vif, link_conf);
1062 	trace_drv_return_int(local, ret);
1063 	return ret;
1064 }
1065 
1066 static inline void drv_stop_ap(struct ieee80211_local *local,
1067 			       struct ieee80211_sub_if_data *sdata,
1068 			       struct ieee80211_bss_conf *link_conf)
1069 {
1070 	might_sleep();
1071 	lockdep_assert_wiphy(local->hw.wiphy);
1072 
1073 	if (!check_sdata_in_driver(sdata))
1074 		return;
1075 
1076 	trace_drv_stop_ap(local, sdata, link_conf);
1077 	if (local->ops->stop_ap)
1078 		local->ops->stop_ap(&local->hw, &sdata->vif, link_conf);
1079 	trace_drv_return_void(local);
1080 }
1081 
1082 static inline void
1083 drv_reconfig_complete(struct ieee80211_local *local,
1084 		      enum ieee80211_reconfig_type reconfig_type)
1085 {
1086 	might_sleep();
1087 	lockdep_assert_wiphy(local->hw.wiphy);
1088 
1089 	trace_drv_reconfig_complete(local, reconfig_type);
1090 	if (local->ops->reconfig_complete)
1091 		local->ops->reconfig_complete(&local->hw, reconfig_type);
1092 	trace_drv_return_void(local);
1093 }
1094 
1095 static inline void
1096 drv_set_default_unicast_key(struct ieee80211_local *local,
1097 			    struct ieee80211_sub_if_data *sdata,
1098 			    int key_idx)
1099 {
1100 	might_sleep();
1101 	lockdep_assert_wiphy(local->hw.wiphy);
1102 
1103 	if (!check_sdata_in_driver(sdata))
1104 		return;
1105 
1106 	WARN_ON_ONCE(key_idx < -1 || key_idx > 3);
1107 
1108 	trace_drv_set_default_unicast_key(local, sdata, key_idx);
1109 	if (local->ops->set_default_unicast_key)
1110 		local->ops->set_default_unicast_key(&local->hw, &sdata->vif,
1111 						    key_idx);
1112 	trace_drv_return_void(local);
1113 }
1114 
1115 #if IS_ENABLED(CONFIG_IPV6)
1116 static inline void drv_ipv6_addr_change(struct ieee80211_local *local,
1117 					struct ieee80211_sub_if_data *sdata,
1118 					struct inet6_dev *idev)
1119 {
1120 	trace_drv_ipv6_addr_change(local, sdata);
1121 	if (local->ops->ipv6_addr_change)
1122 		local->ops->ipv6_addr_change(&local->hw, &sdata->vif, idev);
1123 	trace_drv_return_void(local);
1124 }
1125 #endif
1126 
1127 static inline void
1128 drv_channel_switch_beacon(struct ieee80211_sub_if_data *sdata,
1129 			  struct cfg80211_chan_def *chandef)
1130 {
1131 	struct ieee80211_local *local = sdata->local;
1132 
1133 	might_sleep();
1134 	lockdep_assert_wiphy(local->hw.wiphy);
1135 
1136 	if (local->ops->channel_switch_beacon) {
1137 		trace_drv_channel_switch_beacon(local, sdata, chandef);
1138 		local->ops->channel_switch_beacon(&local->hw, &sdata->vif,
1139 						  chandef);
1140 	}
1141 }
1142 
1143 static inline int
1144 drv_pre_channel_switch(struct ieee80211_sub_if_data *sdata,
1145 		       struct ieee80211_channel_switch *ch_switch)
1146 {
1147 	struct ieee80211_local *local = sdata->local;
1148 	int ret = 0;
1149 
1150 	might_sleep();
1151 	lockdep_assert_wiphy(local->hw.wiphy);
1152 
1153 	if (!check_sdata_in_driver(sdata))
1154 		return -EIO;
1155 
1156 	if (!ieee80211_vif_link_active(&sdata->vif, ch_switch->link_id))
1157 		return 0;
1158 
1159 	trace_drv_pre_channel_switch(local, sdata, ch_switch);
1160 	if (local->ops->pre_channel_switch)
1161 		ret = local->ops->pre_channel_switch(&local->hw, &sdata->vif,
1162 						     ch_switch);
1163 	trace_drv_return_int(local, ret);
1164 	return ret;
1165 }
1166 
1167 static inline int
1168 drv_post_channel_switch(struct ieee80211_link_data *link)
1169 {
1170 	struct ieee80211_sub_if_data *sdata = link->sdata;
1171 	struct ieee80211_local *local = sdata->local;
1172 	int ret = 0;
1173 
1174 	might_sleep();
1175 	lockdep_assert_wiphy(local->hw.wiphy);
1176 
1177 	if (!check_sdata_in_driver(sdata))
1178 		return -EIO;
1179 
1180 	if (!ieee80211_vif_link_active(&sdata->vif, link->link_id))
1181 		return 0;
1182 
1183 	trace_drv_post_channel_switch(local, sdata);
1184 	if (local->ops->post_channel_switch)
1185 		ret = local->ops->post_channel_switch(&local->hw, &sdata->vif,
1186 						      link->conf);
1187 	trace_drv_return_int(local, ret);
1188 	return ret;
1189 }
1190 
1191 static inline void
1192 drv_abort_channel_switch(struct ieee80211_link_data *link)
1193 {
1194 	struct ieee80211_sub_if_data *sdata = link->sdata;
1195 	struct ieee80211_local *local = sdata->local;
1196 
1197 	might_sleep();
1198 	lockdep_assert_wiphy(local->hw.wiphy);
1199 
1200 	if (!check_sdata_in_driver(sdata))
1201 		return;
1202 
1203 	if (!ieee80211_vif_link_active(&sdata->vif, link->link_id))
1204 		return;
1205 
1206 	trace_drv_abort_channel_switch(local, sdata);
1207 
1208 	if (local->ops->abort_channel_switch)
1209 		local->ops->abort_channel_switch(&local->hw, &sdata->vif,
1210 						 link->conf);
1211 }
1212 
1213 static inline void
1214 drv_channel_switch_rx_beacon(struct ieee80211_sub_if_data *sdata,
1215 			     struct ieee80211_channel_switch *ch_switch)
1216 {
1217 	struct ieee80211_local *local = sdata->local;
1218 
1219 	might_sleep();
1220 	lockdep_assert_wiphy(local->hw.wiphy);
1221 
1222 	if (!check_sdata_in_driver(sdata))
1223 		return;
1224 
1225 	if (!ieee80211_vif_link_active(&sdata->vif, ch_switch->link_id))
1226 		return;
1227 
1228 	trace_drv_channel_switch_rx_beacon(local, sdata, ch_switch);
1229 	if (local->ops->channel_switch_rx_beacon)
1230 		local->ops->channel_switch_rx_beacon(&local->hw, &sdata->vif,
1231 						     ch_switch);
1232 }
1233 
1234 static inline int drv_join_ibss(struct ieee80211_local *local,
1235 				struct ieee80211_sub_if_data *sdata)
1236 {
1237 	int ret = 0;
1238 
1239 	might_sleep();
1240 	lockdep_assert_wiphy(local->hw.wiphy);
1241 	if (!check_sdata_in_driver(sdata))
1242 		return -EIO;
1243 
1244 	trace_drv_join_ibss(local, sdata, &sdata->vif.bss_conf);
1245 	if (local->ops->join_ibss)
1246 		ret = local->ops->join_ibss(&local->hw, &sdata->vif);
1247 	trace_drv_return_int(local, ret);
1248 	return ret;
1249 }
1250 
1251 static inline void drv_leave_ibss(struct ieee80211_local *local,
1252 				  struct ieee80211_sub_if_data *sdata)
1253 {
1254 	might_sleep();
1255 	lockdep_assert_wiphy(local->hw.wiphy);
1256 	if (!check_sdata_in_driver(sdata))
1257 		return;
1258 
1259 	trace_drv_leave_ibss(local, sdata);
1260 	if (local->ops->leave_ibss)
1261 		local->ops->leave_ibss(&local->hw, &sdata->vif);
1262 	trace_drv_return_void(local);
1263 }
1264 
1265 static inline u32 drv_get_expected_throughput(struct ieee80211_local *local,
1266 					      struct sta_info *sta)
1267 {
1268 	u32 ret = 0;
1269 
1270 	trace_drv_get_expected_throughput(&sta->sta);
1271 	if (local->ops->get_expected_throughput && sta->uploaded)
1272 		ret = local->ops->get_expected_throughput(&local->hw, &sta->sta);
1273 	trace_drv_return_u32(local, ret);
1274 
1275 	return ret;
1276 }
1277 
1278 static inline int drv_get_txpower(struct ieee80211_local *local,
1279 				  struct ieee80211_sub_if_data *sdata,
1280 				  unsigned int link_id, int *dbm)
1281 {
1282 	int ret;
1283 
1284 	might_sleep();
1285 	lockdep_assert_wiphy(local->hw.wiphy);
1286 
1287 	if (!local->ops->get_txpower)
1288 		return -EOPNOTSUPP;
1289 
1290 	ret = local->ops->get_txpower(&local->hw, &sdata->vif, link_id, dbm);
1291 	trace_drv_get_txpower(local, sdata, link_id, *dbm, ret);
1292 
1293 	return ret;
1294 }
1295 
1296 static inline int
1297 drv_tdls_channel_switch(struct ieee80211_local *local,
1298 			struct ieee80211_sub_if_data *sdata,
1299 			struct ieee80211_sta *sta, u8 oper_class,
1300 			struct cfg80211_chan_def *chandef,
1301 			struct sk_buff *tmpl_skb, u32 ch_sw_tm_ie)
1302 {
1303 	int ret;
1304 
1305 	might_sleep();
1306 	lockdep_assert_wiphy(local->hw.wiphy);
1307 	if (!check_sdata_in_driver(sdata))
1308 		return -EIO;
1309 
1310 	if (!local->ops->tdls_channel_switch)
1311 		return -EOPNOTSUPP;
1312 
1313 	trace_drv_tdls_channel_switch(local, sdata, sta, oper_class, chandef);
1314 	ret = local->ops->tdls_channel_switch(&local->hw, &sdata->vif, sta,
1315 					      oper_class, chandef, tmpl_skb,
1316 					      ch_sw_tm_ie);
1317 	trace_drv_return_int(local, ret);
1318 	return ret;
1319 }
1320 
1321 static inline void
1322 drv_tdls_cancel_channel_switch(struct ieee80211_local *local,
1323 			       struct ieee80211_sub_if_data *sdata,
1324 			       struct ieee80211_sta *sta)
1325 {
1326 	might_sleep();
1327 	lockdep_assert_wiphy(local->hw.wiphy);
1328 	if (!check_sdata_in_driver(sdata))
1329 		return;
1330 
1331 	if (!local->ops->tdls_cancel_channel_switch)
1332 		return;
1333 
1334 	trace_drv_tdls_cancel_channel_switch(local, sdata, sta);
1335 	local->ops->tdls_cancel_channel_switch(&local->hw, &sdata->vif, sta);
1336 	trace_drv_return_void(local);
1337 }
1338 
1339 static inline void
1340 drv_tdls_recv_channel_switch(struct ieee80211_local *local,
1341 			     struct ieee80211_sub_if_data *sdata,
1342 			     struct ieee80211_tdls_ch_sw_params *params)
1343 {
1344 	trace_drv_tdls_recv_channel_switch(local, sdata, params);
1345 	if (local->ops->tdls_recv_channel_switch)
1346 		local->ops->tdls_recv_channel_switch(&local->hw, &sdata->vif,
1347 						     params);
1348 	trace_drv_return_void(local);
1349 }
1350 
1351 static inline void drv_wake_tx_queue(struct ieee80211_local *local,
1352 				     struct txq_info *txq)
1353 {
1354 	struct ieee80211_sub_if_data *sdata = vif_to_sdata(txq->txq.vif);
1355 
1356 	/* In reconfig don't transmit now, but mark for waking later */
1357 	if (local->in_reconfig) {
1358 		set_bit(IEEE80211_TXQ_DIRTY, &txq->flags);
1359 		return;
1360 	}
1361 
1362 	if (!check_sdata_in_driver(sdata))
1363 		return;
1364 
1365 	trace_drv_wake_tx_queue(local, sdata, txq);
1366 	local->ops->wake_tx_queue(&local->hw, &txq->txq);
1367 }
1368 
1369 static inline void schedule_and_wake_txq(struct ieee80211_local *local,
1370 					 struct txq_info *txqi)
1371 {
1372 	ieee80211_schedule_txq(&local->hw, &txqi->txq);
1373 	drv_wake_tx_queue(local, txqi);
1374 }
1375 
1376 static inline int drv_can_aggregate_in_amsdu(struct ieee80211_local *local,
1377 					     struct sk_buff *head,
1378 					     struct sk_buff *skb)
1379 {
1380 	if (!local->ops->can_aggregate_in_amsdu)
1381 		return true;
1382 
1383 	return local->ops->can_aggregate_in_amsdu(&local->hw, head, skb);
1384 }
1385 
1386 static inline int
1387 drv_get_ftm_responder_stats(struct ieee80211_local *local,
1388 			    struct ieee80211_sub_if_data *sdata,
1389 			    struct cfg80211_ftm_responder_stats *ftm_stats)
1390 {
1391 	u32 ret = -EOPNOTSUPP;
1392 
1393 	might_sleep();
1394 	lockdep_assert_wiphy(local->hw.wiphy);
1395 	if (!check_sdata_in_driver(sdata))
1396 		return -EIO;
1397 
1398 	if (local->ops->get_ftm_responder_stats)
1399 		ret = local->ops->get_ftm_responder_stats(&local->hw,
1400 							 &sdata->vif,
1401 							 ftm_stats);
1402 	trace_drv_get_ftm_responder_stats(local, sdata, ftm_stats);
1403 
1404 	return ret;
1405 }
1406 
1407 static inline int drv_start_pmsr(struct ieee80211_local *local,
1408 				 struct ieee80211_sub_if_data *sdata,
1409 				 struct cfg80211_pmsr_request *request)
1410 {
1411 	int ret = -EOPNOTSUPP;
1412 
1413 	might_sleep();
1414 	lockdep_assert_wiphy(local->hw.wiphy);
1415 	if (!check_sdata_in_driver(sdata))
1416 		return -EIO;
1417 
1418 	trace_drv_start_pmsr(local, sdata);
1419 
1420 	if (local->ops->start_pmsr)
1421 		ret = local->ops->start_pmsr(&local->hw, &sdata->vif, request);
1422 	trace_drv_return_int(local, ret);
1423 
1424 	return ret;
1425 }
1426 
1427 static inline void drv_abort_pmsr(struct ieee80211_local *local,
1428 				  struct ieee80211_sub_if_data *sdata,
1429 				  struct cfg80211_pmsr_request *request)
1430 {
1431 	trace_drv_abort_pmsr(local, sdata);
1432 
1433 	might_sleep();
1434 	lockdep_assert_wiphy(local->hw.wiphy);
1435 	if (!check_sdata_in_driver(sdata))
1436 		return;
1437 
1438 	if (local->ops->abort_pmsr)
1439 		local->ops->abort_pmsr(&local->hw, &sdata->vif, request);
1440 	trace_drv_return_void(local);
1441 }
1442 
1443 static inline int drv_start_nan(struct ieee80211_local *local,
1444 				struct ieee80211_sub_if_data *sdata,
1445 				struct cfg80211_nan_conf *conf)
1446 {
1447 	int ret;
1448 
1449 	might_sleep();
1450 	lockdep_assert_wiphy(local->hw.wiphy);
1451 	check_sdata_in_driver(sdata);
1452 
1453 	trace_drv_start_nan(local, sdata, conf);
1454 	ret = local->ops->start_nan(&local->hw, &sdata->vif, conf);
1455 	trace_drv_return_int(local, ret);
1456 	return ret;
1457 }
1458 
1459 static inline void drv_stop_nan(struct ieee80211_local *local,
1460 				struct ieee80211_sub_if_data *sdata)
1461 {
1462 	might_sleep();
1463 	lockdep_assert_wiphy(local->hw.wiphy);
1464 	check_sdata_in_driver(sdata);
1465 
1466 	trace_drv_stop_nan(local, sdata);
1467 	local->ops->stop_nan(&local->hw, &sdata->vif);
1468 	trace_drv_return_void(local);
1469 }
1470 
1471 static inline int drv_nan_change_conf(struct ieee80211_local *local,
1472 				       struct ieee80211_sub_if_data *sdata,
1473 				       struct cfg80211_nan_conf *conf,
1474 				       u32 changes)
1475 {
1476 	int ret;
1477 
1478 	might_sleep();
1479 	lockdep_assert_wiphy(local->hw.wiphy);
1480 	check_sdata_in_driver(sdata);
1481 
1482 	if (!local->ops->nan_change_conf)
1483 		return -EOPNOTSUPP;
1484 
1485 	trace_drv_nan_change_conf(local, sdata, conf, changes);
1486 	ret = local->ops->nan_change_conf(&local->hw, &sdata->vif, conf,
1487 					  changes);
1488 	trace_drv_return_int(local, ret);
1489 
1490 	return ret;
1491 }
1492 
1493 static inline int drv_add_nan_func(struct ieee80211_local *local,
1494 				   struct ieee80211_sub_if_data *sdata,
1495 				   const struct cfg80211_nan_func *nan_func)
1496 {
1497 	int ret;
1498 
1499 	might_sleep();
1500 	lockdep_assert_wiphy(local->hw.wiphy);
1501 	check_sdata_in_driver(sdata);
1502 
1503 	if (!local->ops->add_nan_func)
1504 		return -EOPNOTSUPP;
1505 
1506 	trace_drv_add_nan_func(local, sdata, nan_func);
1507 	ret = local->ops->add_nan_func(&local->hw, &sdata->vif, nan_func);
1508 	trace_drv_return_int(local, ret);
1509 
1510 	return ret;
1511 }
1512 
1513 static inline void drv_del_nan_func(struct ieee80211_local *local,
1514 				   struct ieee80211_sub_if_data *sdata,
1515 				   u8 instance_id)
1516 {
1517 	might_sleep();
1518 	lockdep_assert_wiphy(local->hw.wiphy);
1519 	check_sdata_in_driver(sdata);
1520 
1521 	trace_drv_del_nan_func(local, sdata, instance_id);
1522 	if (local->ops->del_nan_func)
1523 		local->ops->del_nan_func(&local->hw, &sdata->vif, instance_id);
1524 	trace_drv_return_void(local);
1525 }
1526 
1527 static inline int drv_set_tid_config(struct ieee80211_local *local,
1528 				     struct ieee80211_sub_if_data *sdata,
1529 				     struct ieee80211_sta *sta,
1530 				     struct cfg80211_tid_config *tid_conf)
1531 {
1532 	int ret;
1533 
1534 	might_sleep();
1535 	lockdep_assert_wiphy(local->hw.wiphy);
1536 	ret = local->ops->set_tid_config(&local->hw, &sdata->vif, sta,
1537 					 tid_conf);
1538 	trace_drv_return_int(local, ret);
1539 
1540 	return ret;
1541 }
1542 
1543 static inline int drv_reset_tid_config(struct ieee80211_local *local,
1544 				       struct ieee80211_sub_if_data *sdata,
1545 				       struct ieee80211_sta *sta, u8 tids)
1546 {
1547 	int ret;
1548 
1549 	might_sleep();
1550 	lockdep_assert_wiphy(local->hw.wiphy);
1551 	ret = local->ops->reset_tid_config(&local->hw, &sdata->vif, sta, tids);
1552 	trace_drv_return_int(local, ret);
1553 
1554 	return ret;
1555 }
1556 
1557 static inline void drv_update_vif_offload(struct ieee80211_local *local,
1558 					  struct ieee80211_sub_if_data *sdata)
1559 {
1560 	might_sleep();
1561 	lockdep_assert_wiphy(local->hw.wiphy);
1562 	check_sdata_in_driver(sdata);
1563 
1564 	if (!local->ops->update_vif_offload)
1565 		return;
1566 
1567 	trace_drv_update_vif_offload(local, sdata);
1568 	local->ops->update_vif_offload(&local->hw, &sdata->vif);
1569 	trace_drv_return_void(local);
1570 }
1571 
1572 static inline void drv_sta_set_4addr(struct ieee80211_local *local,
1573 				     struct ieee80211_sub_if_data *sdata,
1574 				     struct ieee80211_sta *sta, bool enabled)
1575 {
1576 	sdata = get_bss_sdata(sdata);
1577 
1578 	might_sleep();
1579 	lockdep_assert_wiphy(local->hw.wiphy);
1580 	if (!check_sdata_in_driver(sdata))
1581 		return;
1582 
1583 	trace_drv_sta_set_4addr(local, sdata, sta, enabled);
1584 	if (local->ops->sta_set_4addr)
1585 		local->ops->sta_set_4addr(&local->hw, &sdata->vif, sta, enabled);
1586 	trace_drv_return_void(local);
1587 }
1588 
1589 static inline void drv_sta_set_decap_offload(struct ieee80211_local *local,
1590 					     struct ieee80211_sub_if_data *sdata,
1591 					     struct ieee80211_sta *sta,
1592 					     bool enabled)
1593 {
1594 	sdata = get_bss_sdata(sdata);
1595 
1596 	might_sleep();
1597 	lockdep_assert_wiphy(local->hw.wiphy);
1598 	if (!check_sdata_in_driver(sdata))
1599 		return;
1600 
1601 	trace_drv_sta_set_decap_offload(local, sdata, sta, enabled);
1602 	if (local->ops->sta_set_decap_offload)
1603 		local->ops->sta_set_decap_offload(&local->hw, &sdata->vif, sta,
1604 						  enabled);
1605 	trace_drv_return_void(local);
1606 }
1607 
1608 static inline void drv_add_twt_setup(struct ieee80211_local *local,
1609 				     struct ieee80211_sub_if_data *sdata,
1610 				     struct ieee80211_sta *sta,
1611 				     struct ieee80211_twt_setup *twt)
1612 {
1613 	struct ieee80211_twt_params *twt_agrt;
1614 
1615 	might_sleep();
1616 	lockdep_assert_wiphy(local->hw.wiphy);
1617 
1618 	if (!check_sdata_in_driver(sdata))
1619 		return;
1620 
1621 	twt_agrt = (void *)twt->params;
1622 
1623 	trace_drv_add_twt_setup(local, sta, twt, twt_agrt);
1624 	local->ops->add_twt_setup(&local->hw, sta, twt);
1625 	trace_drv_return_void(local);
1626 }
1627 
1628 static inline void drv_twt_teardown_request(struct ieee80211_local *local,
1629 					    struct ieee80211_sub_if_data *sdata,
1630 					    struct ieee80211_sta *sta,
1631 					    u8 flowid)
1632 {
1633 	might_sleep();
1634 	lockdep_assert_wiphy(local->hw.wiphy);
1635 	if (!check_sdata_in_driver(sdata))
1636 		return;
1637 
1638 	if (!local->ops->twt_teardown_request)
1639 		return;
1640 
1641 	trace_drv_twt_teardown_request(local, sta, flowid);
1642 	local->ops->twt_teardown_request(&local->hw, sta, flowid);
1643 	trace_drv_return_void(local);
1644 }
1645 
1646 static inline int drv_net_fill_forward_path(struct ieee80211_local *local,
1647 					    struct ieee80211_sub_if_data *sdata,
1648 					    struct ieee80211_sta *sta,
1649 					    struct net_device_path_ctx *ctx,
1650 					    struct net_device_path *path)
1651 {
1652 	int ret = -EOPNOTSUPP;
1653 
1654 	sdata = get_bss_sdata(sdata);
1655 	if (!check_sdata_in_driver(sdata))
1656 		return -EIO;
1657 
1658 	trace_drv_net_fill_forward_path(local, sdata, sta);
1659 	if (local->ops->net_fill_forward_path)
1660 		ret = local->ops->net_fill_forward_path(&local->hw,
1661 							&sdata->vif, sta,
1662 							ctx, path);
1663 	trace_drv_return_int(local, ret);
1664 
1665 	return ret;
1666 }
1667 
1668 static inline int drv_net_setup_tc(struct ieee80211_local *local,
1669 				   struct ieee80211_sub_if_data *sdata,
1670 				   struct net_device *dev,
1671 				   enum tc_setup_type type, void *type_data)
1672 {
1673 	int ret = -EOPNOTSUPP;
1674 
1675 	might_sleep();
1676 
1677 	sdata = get_bss_sdata(sdata);
1678 	trace_drv_net_setup_tc(local, sdata, type);
1679 	if (local->ops->net_setup_tc)
1680 		ret = local->ops->net_setup_tc(&local->hw, &sdata->vif, dev,
1681 					       type, type_data);
1682 	trace_drv_return_int(local, ret);
1683 
1684 	return ret;
1685 }
1686 
1687 static inline bool drv_can_activate_links(struct ieee80211_local *local,
1688 					  struct ieee80211_sub_if_data *sdata,
1689 					  u16 active_links)
1690 {
1691 	bool ret = true;
1692 
1693 	lockdep_assert_wiphy(local->hw.wiphy);
1694 
1695 	if (!check_sdata_in_driver(sdata))
1696 		return false;
1697 
1698 	trace_drv_can_activate_links(local, sdata, active_links);
1699 	if (local->ops->can_activate_links)
1700 		ret = local->ops->can_activate_links(&local->hw, &sdata->vif,
1701 						     active_links);
1702 	trace_drv_return_bool(local, ret);
1703 
1704 	return ret;
1705 }
1706 
1707 int drv_change_vif_links(struct ieee80211_local *local,
1708 			 struct ieee80211_sub_if_data *sdata,
1709 			 u16 old_links, u16 new_links,
1710 			 struct ieee80211_bss_conf *old[IEEE80211_MLD_MAX_NUM_LINKS]);
1711 int drv_change_sta_links(struct ieee80211_local *local,
1712 			 struct ieee80211_sub_if_data *sdata,
1713 			 struct ieee80211_sta *sta,
1714 			 u16 old_links, u16 new_links);
1715 
1716 static inline enum ieee80211_neg_ttlm_res
1717 drv_can_neg_ttlm(struct ieee80211_local *local,
1718 		 struct ieee80211_sub_if_data *sdata,
1719 		 struct ieee80211_neg_ttlm *neg_ttlm)
1720 {
1721 	enum ieee80211_neg_ttlm_res res = NEG_TTLM_RES_REJECT;
1722 
1723 	might_sleep();
1724 	if (!check_sdata_in_driver(sdata))
1725 		return -EIO;
1726 
1727 	trace_drv_can_neg_ttlm(local, sdata, neg_ttlm);
1728 	if (local->ops->can_neg_ttlm)
1729 		res = local->ops->can_neg_ttlm(&local->hw, &sdata->vif,
1730 					       neg_ttlm);
1731 	trace_drv_neg_ttlm_res(local, sdata, res, neg_ttlm);
1732 
1733 	return res;
1734 }
1735 
1736 static inline void
1737 drv_prep_add_interface(struct ieee80211_local *local,
1738 		       enum nl80211_iftype type)
1739 {
1740 	trace_drv_prep_add_interface(local, type);
1741 	if (local->ops->prep_add_interface)
1742 		local->ops->prep_add_interface(&local->hw, type);
1743 
1744 	trace_drv_return_void(local);
1745 }
1746 
1747 #endif /* __MAC80211_DRIVER_OPS */
1748