xref: /openbmc/linux/net/mac80211/driver-ops.h (revision 2359ccdd) 
1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3 * Portions of this file
4 * Copyright(c) 2016 Intel Deutschland GmbH
5 */
6 
7 #ifndef __MAC80211_DRIVER_OPS
8 #define __MAC80211_DRIVER_OPS
9 
10 #include <net/mac80211.h>
11 #include "ieee80211_i.h"
12 #include "trace.h"
13 
14 static inline bool check_sdata_in_driver(struct ieee80211_sub_if_data *sdata)
15 {
16 	return !WARN(!(sdata->flags & IEEE80211_SDATA_IN_DRIVER),
17 		     "%s:  Failed check-sdata-in-driver check, flags: 0x%x\n",
18 		     sdata->dev ? sdata->dev->name : sdata->name, sdata->flags);
19 }
20 
21 static inline struct ieee80211_sub_if_data *
22 get_bss_sdata(struct ieee80211_sub_if_data *sdata)
23 {
24 	if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
25 		sdata = container_of(sdata->bss, struct ieee80211_sub_if_data,
26 				     u.ap);
27 
28 	return sdata;
29 }
30 
31 static inline void drv_tx(struct ieee80211_local *local,
32 			  struct ieee80211_tx_control *control,
33 			  struct sk_buff *skb)
34 {
35 	local->ops->tx(&local->hw, control, skb);
36 }
37 
38 static inline void drv_sync_rx_queues(struct ieee80211_local *local,
39 				      struct sta_info *sta)
40 {
41 	if (local->ops->sync_rx_queues) {
42 		trace_drv_sync_rx_queues(local, sta->sdata, &sta->sta);
43 		local->ops->sync_rx_queues(&local->hw);
44 		trace_drv_return_void(local);
45 	}
46 }
47 
48 static inline void drv_get_et_strings(struct ieee80211_sub_if_data *sdata,
49 				      u32 sset, u8 *data)
50 {
51 	struct ieee80211_local *local = sdata->local;
52 	if (local->ops->get_et_strings) {
53 		trace_drv_get_et_strings(local, sset);
54 		local->ops->get_et_strings(&local->hw, &sdata->vif, sset, data);
55 		trace_drv_return_void(local);
56 	}
57 }
58 
59 static inline void drv_get_et_stats(struct ieee80211_sub_if_data *sdata,
60 				    struct ethtool_stats *stats,
61 				    u64 *data)
62 {
63 	struct ieee80211_local *local = sdata->local;
64 	if (local->ops->get_et_stats) {
65 		trace_drv_get_et_stats(local);
66 		local->ops->get_et_stats(&local->hw, &sdata->vif, stats, data);
67 		trace_drv_return_void(local);
68 	}
69 }
70 
71 static inline int drv_get_et_sset_count(struct ieee80211_sub_if_data *sdata,
72 					int sset)
73 {
74 	struct ieee80211_local *local = sdata->local;
75 	int rv = 0;
76 	if (local->ops->get_et_sset_count) {
77 		trace_drv_get_et_sset_count(local, sset);
78 		rv = local->ops->get_et_sset_count(&local->hw, &sdata->vif,
79 						   sset);
80 		trace_drv_return_int(local, rv);
81 	}
82 	return rv;
83 }
84 
85 int drv_start(struct ieee80211_local *local);
86 void drv_stop(struct ieee80211_local *local);
87 
88 #ifdef CONFIG_PM
89 static inline int drv_suspend(struct ieee80211_local *local,
90 			      struct cfg80211_wowlan *wowlan)
91 {
92 	int ret;
93 
94 	might_sleep();
95 
96 	trace_drv_suspend(local);
97 	ret = local->ops->suspend(&local->hw, wowlan);
98 	trace_drv_return_int(local, ret);
99 	return ret;
100 }
101 
102 static inline int drv_resume(struct ieee80211_local *local)
103 {
104 	int ret;
105 
106 	might_sleep();
107 
108 	trace_drv_resume(local);
109 	ret = local->ops->resume(&local->hw);
110 	trace_drv_return_int(local, ret);
111 	return ret;
112 }
113 
114 static inline void drv_set_wakeup(struct ieee80211_local *local,
115 				  bool enabled)
116 {
117 	might_sleep();
118 
119 	if (!local->ops->set_wakeup)
120 		return;
121 
122 	trace_drv_set_wakeup(local, enabled);
123 	local->ops->set_wakeup(&local->hw, enabled);
124 	trace_drv_return_void(local);
125 }
126 #endif
127 
128 int drv_add_interface(struct ieee80211_local *local,
129 		      struct ieee80211_sub_if_data *sdata);
130 
131 int drv_change_interface(struct ieee80211_local *local,
132 			 struct ieee80211_sub_if_data *sdata,
133 			 enum nl80211_iftype type, bool p2p);
134 
135 void drv_remove_interface(struct ieee80211_local *local,
136 			  struct ieee80211_sub_if_data *sdata);
137 
138 static inline int drv_config(struct ieee80211_local *local, u32 changed)
139 {
140 	int ret;
141 
142 	might_sleep();
143 
144 	trace_drv_config(local, changed);
145 	ret = local->ops->config(&local->hw, changed);
146 	trace_drv_return_int(local, ret);
147 	return ret;
148 }
149 
150 static inline void drv_bss_info_changed(struct ieee80211_local *local,
151 					struct ieee80211_sub_if_data *sdata,
152 					struct ieee80211_bss_conf *info,
153 					u32 changed)
154 {
155 	might_sleep();
156 
157 	if (WARN_ON_ONCE(changed & (BSS_CHANGED_BEACON |
158 				    BSS_CHANGED_BEACON_ENABLED) &&
159 			 sdata->vif.type != NL80211_IFTYPE_AP &&
160 			 sdata->vif.type != NL80211_IFTYPE_ADHOC &&
161 			 sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
162 			 sdata->vif.type != NL80211_IFTYPE_OCB))
163 		return;
164 
165 	if (WARN_ON_ONCE(sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE ||
166 			 sdata->vif.type == NL80211_IFTYPE_NAN ||
167 			 (sdata->vif.type == NL80211_IFTYPE_MONITOR &&
168 			  !sdata->vif.mu_mimo_owner &&
169 			  !(changed & BSS_CHANGED_TXPOWER))))
170 		return;
171 
172 	if (!check_sdata_in_driver(sdata))
173 		return;
174 
175 	trace_drv_bss_info_changed(local, sdata, info, changed);
176 	if (local->ops->bss_info_changed)
177 		local->ops->bss_info_changed(&local->hw, &sdata->vif, info, changed);
178 	trace_drv_return_void(local);
179 }
180 
181 static inline u64 drv_prepare_multicast(struct ieee80211_local *local,
182 					struct netdev_hw_addr_list *mc_list)
183 {
184 	u64 ret = 0;
185 
186 	trace_drv_prepare_multicast(local, mc_list->count);
187 
188 	if (local->ops->prepare_multicast)
189 		ret = local->ops->prepare_multicast(&local->hw, mc_list);
190 
191 	trace_drv_return_u64(local, ret);
192 
193 	return ret;
194 }
195 
196 static inline void drv_configure_filter(struct ieee80211_local *local,
197 					unsigned int changed_flags,
198 					unsigned int *total_flags,
199 					u64 multicast)
200 {
201 	might_sleep();
202 
203 	trace_drv_configure_filter(local, changed_flags, total_flags,
204 				   multicast);
205 	local->ops->configure_filter(&local->hw, changed_flags, total_flags,
206 				     multicast);
207 	trace_drv_return_void(local);
208 }
209 
210 static inline void drv_config_iface_filter(struct ieee80211_local *local,
211 					   struct ieee80211_sub_if_data *sdata,
212 					   unsigned int filter_flags,
213 					   unsigned int changed_flags)
214 {
215 	might_sleep();
216 
217 	trace_drv_config_iface_filter(local, sdata, filter_flags,
218 				      changed_flags);
219 	if (local->ops->config_iface_filter)
220 		local->ops->config_iface_filter(&local->hw, &sdata->vif,
221 						filter_flags,
222 						changed_flags);
223 	trace_drv_return_void(local);
224 }
225 
226 static inline int drv_set_tim(struct ieee80211_local *local,
227 			      struct ieee80211_sta *sta, bool set)
228 {
229 	int ret = 0;
230 	trace_drv_set_tim(local, sta, set);
231 	if (local->ops->set_tim)
232 		ret = local->ops->set_tim(&local->hw, sta, set);
233 	trace_drv_return_int(local, ret);
234 	return ret;
235 }
236 
237 static inline int drv_set_key(struct ieee80211_local *local,
238 			      enum set_key_cmd cmd,
239 			      struct ieee80211_sub_if_data *sdata,
240 			      struct ieee80211_sta *sta,
241 			      struct ieee80211_key_conf *key)
242 {
243 	int ret;
244 
245 	might_sleep();
246 
247 	sdata = get_bss_sdata(sdata);
248 	if (!check_sdata_in_driver(sdata))
249 		return -EIO;
250 
251 	trace_drv_set_key(local, cmd, sdata, sta, key);
252 	ret = local->ops->set_key(&local->hw, cmd, &sdata->vif, sta, key);
253 	trace_drv_return_int(local, ret);
254 	return ret;
255 }
256 
257 static inline void drv_update_tkip_key(struct ieee80211_local *local,
258 				       struct ieee80211_sub_if_data *sdata,
259 				       struct ieee80211_key_conf *conf,
260 				       struct sta_info *sta, u32 iv32,
261 				       u16 *phase1key)
262 {
263 	struct ieee80211_sta *ista = NULL;
264 
265 	if (sta)
266 		ista = &sta->sta;
267 
268 	sdata = get_bss_sdata(sdata);
269 	if (!check_sdata_in_driver(sdata))
270 		return;
271 
272 	trace_drv_update_tkip_key(local, sdata, conf, ista, iv32);
273 	if (local->ops->update_tkip_key)
274 		local->ops->update_tkip_key(&local->hw, &sdata->vif, conf,
275 					    ista, iv32, phase1key);
276 	trace_drv_return_void(local);
277 }
278 
279 static inline int drv_hw_scan(struct ieee80211_local *local,
280 			      struct ieee80211_sub_if_data *sdata,
281 			      struct ieee80211_scan_request *req)
282 {
283 	int ret;
284 
285 	might_sleep();
286 
287 	if (!check_sdata_in_driver(sdata))
288 		return -EIO;
289 
290 	trace_drv_hw_scan(local, sdata);
291 	ret = local->ops->hw_scan(&local->hw, &sdata->vif, req);
292 	trace_drv_return_int(local, ret);
293 	return ret;
294 }
295 
296 static inline void drv_cancel_hw_scan(struct ieee80211_local *local,
297 				      struct ieee80211_sub_if_data *sdata)
298 {
299 	might_sleep();
300 
301 	if (!check_sdata_in_driver(sdata))
302 		return;
303 
304 	trace_drv_cancel_hw_scan(local, sdata);
305 	local->ops->cancel_hw_scan(&local->hw, &sdata->vif);
306 	trace_drv_return_void(local);
307 }
308 
309 static inline int
310 drv_sched_scan_start(struct ieee80211_local *local,
311 		     struct ieee80211_sub_if_data *sdata,
312 		     struct cfg80211_sched_scan_request *req,
313 		     struct ieee80211_scan_ies *ies)
314 {
315 	int ret;
316 
317 	might_sleep();
318 
319 	if (!check_sdata_in_driver(sdata))
320 		return -EIO;
321 
322 	trace_drv_sched_scan_start(local, sdata);
323 	ret = local->ops->sched_scan_start(&local->hw, &sdata->vif,
324 					      req, ies);
325 	trace_drv_return_int(local, ret);
326 	return ret;
327 }
328 
329 static inline int drv_sched_scan_stop(struct ieee80211_local *local,
330 				      struct ieee80211_sub_if_data *sdata)
331 {
332 	int ret;
333 
334 	might_sleep();
335 
336 	if (!check_sdata_in_driver(sdata))
337 		return -EIO;
338 
339 	trace_drv_sched_scan_stop(local, sdata);
340 	ret = local->ops->sched_scan_stop(&local->hw, &sdata->vif);
341 	trace_drv_return_int(local, ret);
342 
343 	return ret;
344 }
345 
346 static inline void drv_sw_scan_start(struct ieee80211_local *local,
347 				     struct ieee80211_sub_if_data *sdata,
348 				     const u8 *mac_addr)
349 {
350 	might_sleep();
351 
352 	trace_drv_sw_scan_start(local, sdata, mac_addr);
353 	if (local->ops->sw_scan_start)
354 		local->ops->sw_scan_start(&local->hw, &sdata->vif, mac_addr);
355 	trace_drv_return_void(local);
356 }
357 
358 static inline void drv_sw_scan_complete(struct ieee80211_local *local,
359 					struct ieee80211_sub_if_data *sdata)
360 {
361 	might_sleep();
362 
363 	trace_drv_sw_scan_complete(local, sdata);
364 	if (local->ops->sw_scan_complete)
365 		local->ops->sw_scan_complete(&local->hw, &sdata->vif);
366 	trace_drv_return_void(local);
367 }
368 
369 static inline int drv_get_stats(struct ieee80211_local *local,
370 				struct ieee80211_low_level_stats *stats)
371 {
372 	int ret = -EOPNOTSUPP;
373 
374 	might_sleep();
375 
376 	if (local->ops->get_stats)
377 		ret = local->ops->get_stats(&local->hw, stats);
378 	trace_drv_get_stats(local, stats, ret);
379 
380 	return ret;
381 }
382 
383 static inline void drv_get_key_seq(struct ieee80211_local *local,
384 				   struct ieee80211_key *key,
385 				   struct ieee80211_key_seq *seq)
386 {
387 	if (local->ops->get_key_seq)
388 		local->ops->get_key_seq(&local->hw, &key->conf, seq);
389 	trace_drv_get_key_seq(local, &key->conf);
390 }
391 
392 static inline int drv_set_frag_threshold(struct ieee80211_local *local,
393 					u32 value)
394 {
395 	int ret = 0;
396 
397 	might_sleep();
398 
399 	trace_drv_set_frag_threshold(local, value);
400 	if (local->ops->set_frag_threshold)
401 		ret = local->ops->set_frag_threshold(&local->hw, value);
402 	trace_drv_return_int(local, ret);
403 	return ret;
404 }
405 
406 static inline int drv_set_rts_threshold(struct ieee80211_local *local,
407 					u32 value)
408 {
409 	int ret = 0;
410 
411 	might_sleep();
412 
413 	trace_drv_set_rts_threshold(local, value);
414 	if (local->ops->set_rts_threshold)
415 		ret = local->ops->set_rts_threshold(&local->hw, value);
416 	trace_drv_return_int(local, ret);
417 	return ret;
418 }
419 
420 static inline int drv_set_coverage_class(struct ieee80211_local *local,
421 					 s16 value)
422 {
423 	int ret = 0;
424 	might_sleep();
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 
459 	sdata = get_bss_sdata(sdata);
460 	if (!check_sdata_in_driver(sdata))
461 		return -EIO;
462 
463 	trace_drv_sta_add(local, sdata, sta);
464 	if (local->ops->sta_add)
465 		ret = local->ops->sta_add(&local->hw, &sdata->vif, sta);
466 
467 	trace_drv_return_int(local, ret);
468 
469 	return ret;
470 }
471 
472 static inline void drv_sta_remove(struct ieee80211_local *local,
473 				  struct ieee80211_sub_if_data *sdata,
474 				  struct ieee80211_sta *sta)
475 {
476 	might_sleep();
477 
478 	sdata = get_bss_sdata(sdata);
479 	if (!check_sdata_in_driver(sdata))
480 		return;
481 
482 	trace_drv_sta_remove(local, sdata, sta);
483 	if (local->ops->sta_remove)
484 		local->ops->sta_remove(&local->hw, &sdata->vif, sta);
485 
486 	trace_drv_return_void(local);
487 }
488 
489 #ifdef CONFIG_MAC80211_DEBUGFS
490 static inline void drv_sta_add_debugfs(struct ieee80211_local *local,
491 				       struct ieee80211_sub_if_data *sdata,
492 				       struct ieee80211_sta *sta,
493 				       struct dentry *dir)
494 {
495 	might_sleep();
496 
497 	sdata = get_bss_sdata(sdata);
498 	if (!check_sdata_in_driver(sdata))
499 		return;
500 
501 	if (local->ops->sta_add_debugfs)
502 		local->ops->sta_add_debugfs(&local->hw, &sdata->vif,
503 					    sta, dir);
504 }
505 #endif
506 
507 static inline void drv_sta_pre_rcu_remove(struct ieee80211_local *local,
508 					  struct ieee80211_sub_if_data *sdata,
509 					  struct sta_info *sta)
510 {
511 	might_sleep();
512 
513 	sdata = get_bss_sdata(sdata);
514 	if (!check_sdata_in_driver(sdata))
515 		return;
516 
517 	trace_drv_sta_pre_rcu_remove(local, sdata, &sta->sta);
518 	if (local->ops->sta_pre_rcu_remove)
519 		local->ops->sta_pre_rcu_remove(&local->hw, &sdata->vif,
520 					       &sta->sta);
521 	trace_drv_return_void(local);
522 }
523 
524 __must_check
525 int drv_sta_state(struct ieee80211_local *local,
526 		  struct ieee80211_sub_if_data *sdata,
527 		  struct sta_info *sta,
528 		  enum ieee80211_sta_state old_state,
529 		  enum ieee80211_sta_state new_state);
530 
531 void drv_sta_rc_update(struct ieee80211_local *local,
532 		       struct ieee80211_sub_if_data *sdata,
533 		       struct ieee80211_sta *sta, u32 changed);
534 
535 static inline void drv_sta_rate_tbl_update(struct ieee80211_local *local,
536 					   struct ieee80211_sub_if_data *sdata,
537 					   struct ieee80211_sta *sta)
538 {
539 	sdata = get_bss_sdata(sdata);
540 	if (!check_sdata_in_driver(sdata))
541 		return;
542 
543 	trace_drv_sta_rate_tbl_update(local, sdata, sta);
544 	if (local->ops->sta_rate_tbl_update)
545 		local->ops->sta_rate_tbl_update(&local->hw, &sdata->vif, sta);
546 
547 	trace_drv_return_void(local);
548 }
549 
550 static inline void drv_sta_statistics(struct ieee80211_local *local,
551 				      struct ieee80211_sub_if_data *sdata,
552 				      struct ieee80211_sta *sta,
553 				      struct station_info *sinfo)
554 {
555 	sdata = get_bss_sdata(sdata);
556 	if (!check_sdata_in_driver(sdata))
557 		return;
558 
559 	trace_drv_sta_statistics(local, sdata, sta);
560 	if (local->ops->sta_statistics)
561 		local->ops->sta_statistics(&local->hw, &sdata->vif, sta, sinfo);
562 	trace_drv_return_void(local);
563 }
564 
565 int drv_conf_tx(struct ieee80211_local *local,
566 		struct ieee80211_sub_if_data *sdata, u16 ac,
567 		const struct ieee80211_tx_queue_params *params);
568 
569 u64 drv_get_tsf(struct ieee80211_local *local,
570 		struct ieee80211_sub_if_data *sdata);
571 void drv_set_tsf(struct ieee80211_local *local,
572 		 struct ieee80211_sub_if_data *sdata,
573 		 u64 tsf);
574 void drv_offset_tsf(struct ieee80211_local *local,
575 		    struct ieee80211_sub_if_data *sdata,
576 		    s64 offset);
577 void drv_reset_tsf(struct ieee80211_local *local,
578 		   struct ieee80211_sub_if_data *sdata);
579 
580 static inline int drv_tx_last_beacon(struct ieee80211_local *local)
581 {
582 	int ret = 0; /* default unsupported op for less congestion */
583 
584 	might_sleep();
585 
586 	trace_drv_tx_last_beacon(local);
587 	if (local->ops->tx_last_beacon)
588 		ret = local->ops->tx_last_beacon(&local->hw);
589 	trace_drv_return_int(local, ret);
590 	return ret;
591 }
592 
593 int drv_ampdu_action(struct ieee80211_local *local,
594 		     struct ieee80211_sub_if_data *sdata,
595 		     struct ieee80211_ampdu_params *params);
596 
597 static inline int drv_get_survey(struct ieee80211_local *local, int idx,
598 				struct survey_info *survey)
599 {
600 	int ret = -EOPNOTSUPP;
601 
602 	trace_drv_get_survey(local, idx, survey);
603 
604 	if (local->ops->get_survey)
605 		ret = local->ops->get_survey(&local->hw, idx, survey);
606 
607 	trace_drv_return_int(local, ret);
608 
609 	return ret;
610 }
611 
612 static inline void drv_rfkill_poll(struct ieee80211_local *local)
613 {
614 	might_sleep();
615 
616 	if (local->ops->rfkill_poll)
617 		local->ops->rfkill_poll(&local->hw);
618 }
619 
620 static inline void drv_flush(struct ieee80211_local *local,
621 			     struct ieee80211_sub_if_data *sdata,
622 			     u32 queues, bool drop)
623 {
624 	struct ieee80211_vif *vif = sdata ? &sdata->vif : NULL;
625 
626 	might_sleep();
627 
628 	if (sdata && !check_sdata_in_driver(sdata))
629 		return;
630 
631 	trace_drv_flush(local, queues, drop);
632 	if (local->ops->flush)
633 		local->ops->flush(&local->hw, vif, queues, drop);
634 	trace_drv_return_void(local);
635 }
636 
637 static inline void drv_channel_switch(struct ieee80211_local *local,
638 				      struct ieee80211_sub_if_data *sdata,
639 				      struct ieee80211_channel_switch *ch_switch)
640 {
641 	might_sleep();
642 
643 	trace_drv_channel_switch(local, sdata, ch_switch);
644 	local->ops->channel_switch(&local->hw, &sdata->vif, ch_switch);
645 	trace_drv_return_void(local);
646 }
647 
648 
649 static inline int drv_set_antenna(struct ieee80211_local *local,
650 				  u32 tx_ant, u32 rx_ant)
651 {
652 	int ret = -EOPNOTSUPP;
653 	might_sleep();
654 	if (local->ops->set_antenna)
655 		ret = local->ops->set_antenna(&local->hw, tx_ant, rx_ant);
656 	trace_drv_set_antenna(local, tx_ant, rx_ant, ret);
657 	return ret;
658 }
659 
660 static inline int drv_get_antenna(struct ieee80211_local *local,
661 				  u32 *tx_ant, u32 *rx_ant)
662 {
663 	int ret = -EOPNOTSUPP;
664 	might_sleep();
665 	if (local->ops->get_antenna)
666 		ret = local->ops->get_antenna(&local->hw, tx_ant, rx_ant);
667 	trace_drv_get_antenna(local, *tx_ant, *rx_ant, ret);
668 	return ret;
669 }
670 
671 static inline int drv_remain_on_channel(struct ieee80211_local *local,
672 					struct ieee80211_sub_if_data *sdata,
673 					struct ieee80211_channel *chan,
674 					unsigned int duration,
675 					enum ieee80211_roc_type type)
676 {
677 	int ret;
678 
679 	might_sleep();
680 
681 	trace_drv_remain_on_channel(local, sdata, chan, duration, type);
682 	ret = local->ops->remain_on_channel(&local->hw, &sdata->vif,
683 					    chan, duration, type);
684 	trace_drv_return_int(local, ret);
685 
686 	return ret;
687 }
688 
689 static inline int drv_cancel_remain_on_channel(struct ieee80211_local *local)
690 {
691 	int ret;
692 
693 	might_sleep();
694 
695 	trace_drv_cancel_remain_on_channel(local);
696 	ret = local->ops->cancel_remain_on_channel(&local->hw);
697 	trace_drv_return_int(local, ret);
698 
699 	return ret;
700 }
701 
702 static inline int drv_set_ringparam(struct ieee80211_local *local,
703 				    u32 tx, u32 rx)
704 {
705 	int ret = -ENOTSUPP;
706 
707 	might_sleep();
708 
709 	trace_drv_set_ringparam(local, tx, rx);
710 	if (local->ops->set_ringparam)
711 		ret = local->ops->set_ringparam(&local->hw, tx, rx);
712 	trace_drv_return_int(local, ret);
713 
714 	return ret;
715 }
716 
717 static inline void drv_get_ringparam(struct ieee80211_local *local,
718 				     u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max)
719 {
720 	might_sleep();
721 
722 	trace_drv_get_ringparam(local, tx, tx_max, rx, rx_max);
723 	if (local->ops->get_ringparam)
724 		local->ops->get_ringparam(&local->hw, tx, tx_max, rx, rx_max);
725 	trace_drv_return_void(local);
726 }
727 
728 static inline bool drv_tx_frames_pending(struct ieee80211_local *local)
729 {
730 	bool ret = false;
731 
732 	might_sleep();
733 
734 	trace_drv_tx_frames_pending(local);
735 	if (local->ops->tx_frames_pending)
736 		ret = local->ops->tx_frames_pending(&local->hw);
737 	trace_drv_return_bool(local, ret);
738 
739 	return ret;
740 }
741 
742 static inline int drv_set_bitrate_mask(struct ieee80211_local *local,
743 				       struct ieee80211_sub_if_data *sdata,
744 				       const struct cfg80211_bitrate_mask *mask)
745 {
746 	int ret = -EOPNOTSUPP;
747 
748 	might_sleep();
749 
750 	if (!check_sdata_in_driver(sdata))
751 		return -EIO;
752 
753 	trace_drv_set_bitrate_mask(local, sdata, mask);
754 	if (local->ops->set_bitrate_mask)
755 		ret = local->ops->set_bitrate_mask(&local->hw,
756 						   &sdata->vif, mask);
757 	trace_drv_return_int(local, ret);
758 
759 	return ret;
760 }
761 
762 static inline void drv_set_rekey_data(struct ieee80211_local *local,
763 				      struct ieee80211_sub_if_data *sdata,
764 				      struct cfg80211_gtk_rekey_data *data)
765 {
766 	if (!check_sdata_in_driver(sdata))
767 		return;
768 
769 	trace_drv_set_rekey_data(local, sdata, data);
770 	if (local->ops->set_rekey_data)
771 		local->ops->set_rekey_data(&local->hw, &sdata->vif, data);
772 	trace_drv_return_void(local);
773 }
774 
775 static inline void drv_event_callback(struct ieee80211_local *local,
776 				      struct ieee80211_sub_if_data *sdata,
777 				      const struct ieee80211_event *event)
778 {
779 	trace_drv_event_callback(local, sdata, event);
780 	if (local->ops->event_callback)
781 		local->ops->event_callback(&local->hw, &sdata->vif, event);
782 	trace_drv_return_void(local);
783 }
784 
785 static inline void
786 drv_release_buffered_frames(struct ieee80211_local *local,
787 			    struct sta_info *sta, u16 tids, int num_frames,
788 			    enum ieee80211_frame_release_type reason,
789 			    bool more_data)
790 {
791 	trace_drv_release_buffered_frames(local, &sta->sta, tids, num_frames,
792 					  reason, more_data);
793 	if (local->ops->release_buffered_frames)
794 		local->ops->release_buffered_frames(&local->hw, &sta->sta, tids,
795 						    num_frames, reason,
796 						    more_data);
797 	trace_drv_return_void(local);
798 }
799 
800 static inline void
801 drv_allow_buffered_frames(struct ieee80211_local *local,
802 			  struct sta_info *sta, u16 tids, int num_frames,
803 			  enum ieee80211_frame_release_type reason,
804 			  bool more_data)
805 {
806 	trace_drv_allow_buffered_frames(local, &sta->sta, tids, num_frames,
807 					reason, more_data);
808 	if (local->ops->allow_buffered_frames)
809 		local->ops->allow_buffered_frames(&local->hw, &sta->sta,
810 						  tids, num_frames, reason,
811 						  more_data);
812 	trace_drv_return_void(local);
813 }
814 
815 static inline void drv_mgd_prepare_tx(struct ieee80211_local *local,
816 				      struct ieee80211_sub_if_data *sdata)
817 {
818 	might_sleep();
819 
820 	if (!check_sdata_in_driver(sdata))
821 		return;
822 	WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION);
823 
824 	trace_drv_mgd_prepare_tx(local, sdata);
825 	if (local->ops->mgd_prepare_tx)
826 		local->ops->mgd_prepare_tx(&local->hw, &sdata->vif);
827 	trace_drv_return_void(local);
828 }
829 
830 static inline void
831 drv_mgd_protect_tdls_discover(struct ieee80211_local *local,
832 			      struct ieee80211_sub_if_data *sdata)
833 {
834 	might_sleep();
835 
836 	if (!check_sdata_in_driver(sdata))
837 		return;
838 	WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION);
839 
840 	trace_drv_mgd_protect_tdls_discover(local, sdata);
841 	if (local->ops->mgd_protect_tdls_discover)
842 		local->ops->mgd_protect_tdls_discover(&local->hw, &sdata->vif);
843 	trace_drv_return_void(local);
844 }
845 
846 static inline int drv_add_chanctx(struct ieee80211_local *local,
847 				  struct ieee80211_chanctx *ctx)
848 {
849 	int ret = -EOPNOTSUPP;
850 
851 	might_sleep();
852 
853 	trace_drv_add_chanctx(local, ctx);
854 	if (local->ops->add_chanctx)
855 		ret = local->ops->add_chanctx(&local->hw, &ctx->conf);
856 	trace_drv_return_int(local, ret);
857 	if (!ret)
858 		ctx->driver_present = true;
859 
860 	return ret;
861 }
862 
863 static inline void drv_remove_chanctx(struct ieee80211_local *local,
864 				      struct ieee80211_chanctx *ctx)
865 {
866 	might_sleep();
867 
868 	if (WARN_ON(!ctx->driver_present))
869 		return;
870 
871 	trace_drv_remove_chanctx(local, ctx);
872 	if (local->ops->remove_chanctx)
873 		local->ops->remove_chanctx(&local->hw, &ctx->conf);
874 	trace_drv_return_void(local);
875 	ctx->driver_present = false;
876 }
877 
878 static inline void drv_change_chanctx(struct ieee80211_local *local,
879 				      struct ieee80211_chanctx *ctx,
880 				      u32 changed)
881 {
882 	might_sleep();
883 
884 	trace_drv_change_chanctx(local, ctx, changed);
885 	if (local->ops->change_chanctx) {
886 		WARN_ON_ONCE(!ctx->driver_present);
887 		local->ops->change_chanctx(&local->hw, &ctx->conf, changed);
888 	}
889 	trace_drv_return_void(local);
890 }
891 
892 static inline int drv_assign_vif_chanctx(struct ieee80211_local *local,
893 					 struct ieee80211_sub_if_data *sdata,
894 					 struct ieee80211_chanctx *ctx)
895 {
896 	int ret = 0;
897 
898 	if (!check_sdata_in_driver(sdata))
899 		return -EIO;
900 
901 	trace_drv_assign_vif_chanctx(local, sdata, ctx);
902 	if (local->ops->assign_vif_chanctx) {
903 		WARN_ON_ONCE(!ctx->driver_present);
904 		ret = local->ops->assign_vif_chanctx(&local->hw,
905 						     &sdata->vif,
906 						     &ctx->conf);
907 	}
908 	trace_drv_return_int(local, ret);
909 
910 	return ret;
911 }
912 
913 static inline void drv_unassign_vif_chanctx(struct ieee80211_local *local,
914 					    struct ieee80211_sub_if_data *sdata,
915 					    struct ieee80211_chanctx *ctx)
916 {
917 	might_sleep();
918 
919 	if (!check_sdata_in_driver(sdata))
920 		return;
921 
922 	trace_drv_unassign_vif_chanctx(local, sdata, ctx);
923 	if (local->ops->unassign_vif_chanctx) {
924 		WARN_ON_ONCE(!ctx->driver_present);
925 		local->ops->unassign_vif_chanctx(&local->hw,
926 						 &sdata->vif,
927 						 &ctx->conf);
928 	}
929 	trace_drv_return_void(local);
930 }
931 
932 int drv_switch_vif_chanctx(struct ieee80211_local *local,
933 			   struct ieee80211_vif_chanctx_switch *vifs,
934 			   int n_vifs, enum ieee80211_chanctx_switch_mode mode);
935 
936 static inline int drv_start_ap(struct ieee80211_local *local,
937 			       struct ieee80211_sub_if_data *sdata)
938 {
939 	int ret = 0;
940 
941 	might_sleep();
942 
943 	if (!check_sdata_in_driver(sdata))
944 		return -EIO;
945 
946 	trace_drv_start_ap(local, sdata, &sdata->vif.bss_conf);
947 	if (local->ops->start_ap)
948 		ret = local->ops->start_ap(&local->hw, &sdata->vif);
949 	trace_drv_return_int(local, ret);
950 	return ret;
951 }
952 
953 static inline void drv_stop_ap(struct ieee80211_local *local,
954 			       struct ieee80211_sub_if_data *sdata)
955 {
956 	if (!check_sdata_in_driver(sdata))
957 		return;
958 
959 	trace_drv_stop_ap(local, sdata);
960 	if (local->ops->stop_ap)
961 		local->ops->stop_ap(&local->hw, &sdata->vif);
962 	trace_drv_return_void(local);
963 }
964 
965 static inline void
966 drv_reconfig_complete(struct ieee80211_local *local,
967 		      enum ieee80211_reconfig_type reconfig_type)
968 {
969 	might_sleep();
970 
971 	trace_drv_reconfig_complete(local, reconfig_type);
972 	if (local->ops->reconfig_complete)
973 		local->ops->reconfig_complete(&local->hw, reconfig_type);
974 	trace_drv_return_void(local);
975 }
976 
977 static inline void
978 drv_set_default_unicast_key(struct ieee80211_local *local,
979 			    struct ieee80211_sub_if_data *sdata,
980 			    int key_idx)
981 {
982 	if (!check_sdata_in_driver(sdata))
983 		return;
984 
985 	WARN_ON_ONCE(key_idx < -1 || key_idx > 3);
986 
987 	trace_drv_set_default_unicast_key(local, sdata, key_idx);
988 	if (local->ops->set_default_unicast_key)
989 		local->ops->set_default_unicast_key(&local->hw, &sdata->vif,
990 						    key_idx);
991 	trace_drv_return_void(local);
992 }
993 
994 #if IS_ENABLED(CONFIG_IPV6)
995 static inline void drv_ipv6_addr_change(struct ieee80211_local *local,
996 					struct ieee80211_sub_if_data *sdata,
997 					struct inet6_dev *idev)
998 {
999 	trace_drv_ipv6_addr_change(local, sdata);
1000 	if (local->ops->ipv6_addr_change)
1001 		local->ops->ipv6_addr_change(&local->hw, &sdata->vif, idev);
1002 	trace_drv_return_void(local);
1003 }
1004 #endif
1005 
1006 static inline void
1007 drv_channel_switch_beacon(struct ieee80211_sub_if_data *sdata,
1008 			  struct cfg80211_chan_def *chandef)
1009 {
1010 	struct ieee80211_local *local = sdata->local;
1011 
1012 	if (local->ops->channel_switch_beacon) {
1013 		trace_drv_channel_switch_beacon(local, sdata, chandef);
1014 		local->ops->channel_switch_beacon(&local->hw, &sdata->vif,
1015 						  chandef);
1016 	}
1017 }
1018 
1019 static inline int
1020 drv_pre_channel_switch(struct ieee80211_sub_if_data *sdata,
1021 		       struct ieee80211_channel_switch *ch_switch)
1022 {
1023 	struct ieee80211_local *local = sdata->local;
1024 	int ret = 0;
1025 
1026 	if (!check_sdata_in_driver(sdata))
1027 		return -EIO;
1028 
1029 	trace_drv_pre_channel_switch(local, sdata, ch_switch);
1030 	if (local->ops->pre_channel_switch)
1031 		ret = local->ops->pre_channel_switch(&local->hw, &sdata->vif,
1032 						     ch_switch);
1033 	trace_drv_return_int(local, ret);
1034 	return ret;
1035 }
1036 
1037 static inline int
1038 drv_post_channel_switch(struct ieee80211_sub_if_data *sdata)
1039 {
1040 	struct ieee80211_local *local = sdata->local;
1041 	int ret = 0;
1042 
1043 	if (!check_sdata_in_driver(sdata))
1044 		return -EIO;
1045 
1046 	trace_drv_post_channel_switch(local, sdata);
1047 	if (local->ops->post_channel_switch)
1048 		ret = local->ops->post_channel_switch(&local->hw, &sdata->vif);
1049 	trace_drv_return_int(local, ret);
1050 	return ret;
1051 }
1052 
1053 static inline int drv_join_ibss(struct ieee80211_local *local,
1054 				struct ieee80211_sub_if_data *sdata)
1055 {
1056 	int ret = 0;
1057 
1058 	might_sleep();
1059 	if (!check_sdata_in_driver(sdata))
1060 		return -EIO;
1061 
1062 	trace_drv_join_ibss(local, sdata, &sdata->vif.bss_conf);
1063 	if (local->ops->join_ibss)
1064 		ret = local->ops->join_ibss(&local->hw, &sdata->vif);
1065 	trace_drv_return_int(local, ret);
1066 	return ret;
1067 }
1068 
1069 static inline void drv_leave_ibss(struct ieee80211_local *local,
1070 				  struct ieee80211_sub_if_data *sdata)
1071 {
1072 	might_sleep();
1073 	if (!check_sdata_in_driver(sdata))
1074 		return;
1075 
1076 	trace_drv_leave_ibss(local, sdata);
1077 	if (local->ops->leave_ibss)
1078 		local->ops->leave_ibss(&local->hw, &sdata->vif);
1079 	trace_drv_return_void(local);
1080 }
1081 
1082 static inline u32 drv_get_expected_throughput(struct ieee80211_local *local,
1083 					      struct sta_info *sta)
1084 {
1085 	u32 ret = 0;
1086 
1087 	trace_drv_get_expected_throughput(&sta->sta);
1088 	if (local->ops->get_expected_throughput && sta->uploaded)
1089 		ret = local->ops->get_expected_throughput(&local->hw, &sta->sta);
1090 	trace_drv_return_u32(local, ret);
1091 
1092 	return ret;
1093 }
1094 
1095 static inline int drv_get_txpower(struct ieee80211_local *local,
1096 				  struct ieee80211_sub_if_data *sdata, int *dbm)
1097 {
1098 	int ret;
1099 
1100 	if (!local->ops->get_txpower)
1101 		return -EOPNOTSUPP;
1102 
1103 	ret = local->ops->get_txpower(&local->hw, &sdata->vif, dbm);
1104 	trace_drv_get_txpower(local, sdata, *dbm, ret);
1105 
1106 	return ret;
1107 }
1108 
1109 static inline int
1110 drv_tdls_channel_switch(struct ieee80211_local *local,
1111 			struct ieee80211_sub_if_data *sdata,
1112 			struct ieee80211_sta *sta, u8 oper_class,
1113 			struct cfg80211_chan_def *chandef,
1114 			struct sk_buff *tmpl_skb, u32 ch_sw_tm_ie)
1115 {
1116 	int ret;
1117 
1118 	might_sleep();
1119 	if (!check_sdata_in_driver(sdata))
1120 		return -EIO;
1121 
1122 	if (!local->ops->tdls_channel_switch)
1123 		return -EOPNOTSUPP;
1124 
1125 	trace_drv_tdls_channel_switch(local, sdata, sta, oper_class, chandef);
1126 	ret = local->ops->tdls_channel_switch(&local->hw, &sdata->vif, sta,
1127 					      oper_class, chandef, tmpl_skb,
1128 					      ch_sw_tm_ie);
1129 	trace_drv_return_int(local, ret);
1130 	return ret;
1131 }
1132 
1133 static inline void
1134 drv_tdls_cancel_channel_switch(struct ieee80211_local *local,
1135 			       struct ieee80211_sub_if_data *sdata,
1136 			       struct ieee80211_sta *sta)
1137 {
1138 	might_sleep();
1139 	if (!check_sdata_in_driver(sdata))
1140 		return;
1141 
1142 	if (!local->ops->tdls_cancel_channel_switch)
1143 		return;
1144 
1145 	trace_drv_tdls_cancel_channel_switch(local, sdata, sta);
1146 	local->ops->tdls_cancel_channel_switch(&local->hw, &sdata->vif, sta);
1147 	trace_drv_return_void(local);
1148 }
1149 
1150 static inline void
1151 drv_tdls_recv_channel_switch(struct ieee80211_local *local,
1152 			     struct ieee80211_sub_if_data *sdata,
1153 			     struct ieee80211_tdls_ch_sw_params *params)
1154 {
1155 	trace_drv_tdls_recv_channel_switch(local, sdata, params);
1156 	if (local->ops->tdls_recv_channel_switch)
1157 		local->ops->tdls_recv_channel_switch(&local->hw, &sdata->vif,
1158 						     params);
1159 	trace_drv_return_void(local);
1160 }
1161 
1162 static inline void drv_wake_tx_queue(struct ieee80211_local *local,
1163 				     struct txq_info *txq)
1164 {
1165 	struct ieee80211_sub_if_data *sdata = vif_to_sdata(txq->txq.vif);
1166 
1167 	if (!check_sdata_in_driver(sdata))
1168 		return;
1169 
1170 	trace_drv_wake_tx_queue(local, sdata, txq);
1171 	local->ops->wake_tx_queue(&local->hw, &txq->txq);
1172 }
1173 
1174 static inline int drv_start_nan(struct ieee80211_local *local,
1175 				struct ieee80211_sub_if_data *sdata,
1176 				struct cfg80211_nan_conf *conf)
1177 {
1178 	int ret;
1179 
1180 	might_sleep();
1181 	check_sdata_in_driver(sdata);
1182 
1183 	trace_drv_start_nan(local, sdata, conf);
1184 	ret = local->ops->start_nan(&local->hw, &sdata->vif, conf);
1185 	trace_drv_return_int(local, ret);
1186 	return ret;
1187 }
1188 
1189 static inline void drv_stop_nan(struct ieee80211_local *local,
1190 				struct ieee80211_sub_if_data *sdata)
1191 {
1192 	might_sleep();
1193 	check_sdata_in_driver(sdata);
1194 
1195 	trace_drv_stop_nan(local, sdata);
1196 	local->ops->stop_nan(&local->hw, &sdata->vif);
1197 	trace_drv_return_void(local);
1198 }
1199 
1200 static inline int drv_nan_change_conf(struct ieee80211_local *local,
1201 				       struct ieee80211_sub_if_data *sdata,
1202 				       struct cfg80211_nan_conf *conf,
1203 				       u32 changes)
1204 {
1205 	int ret;
1206 
1207 	might_sleep();
1208 	check_sdata_in_driver(sdata);
1209 
1210 	if (!local->ops->nan_change_conf)
1211 		return -EOPNOTSUPP;
1212 
1213 	trace_drv_nan_change_conf(local, sdata, conf, changes);
1214 	ret = local->ops->nan_change_conf(&local->hw, &sdata->vif, conf,
1215 					  changes);
1216 	trace_drv_return_int(local, ret);
1217 
1218 	return ret;
1219 }
1220 
1221 static inline int drv_add_nan_func(struct ieee80211_local *local,
1222 				   struct ieee80211_sub_if_data *sdata,
1223 				   const struct cfg80211_nan_func *nan_func)
1224 {
1225 	int ret;
1226 
1227 	might_sleep();
1228 	check_sdata_in_driver(sdata);
1229 
1230 	if (!local->ops->add_nan_func)
1231 		return -EOPNOTSUPP;
1232 
1233 	trace_drv_add_nan_func(local, sdata, nan_func);
1234 	ret = local->ops->add_nan_func(&local->hw, &sdata->vif, nan_func);
1235 	trace_drv_return_int(local, ret);
1236 
1237 	return ret;
1238 }
1239 
1240 static inline void drv_del_nan_func(struct ieee80211_local *local,
1241 				   struct ieee80211_sub_if_data *sdata,
1242 				   u8 instance_id)
1243 {
1244 	might_sleep();
1245 	check_sdata_in_driver(sdata);
1246 
1247 	trace_drv_del_nan_func(local, sdata, instance_id);
1248 	if (local->ops->del_nan_func)
1249 		local->ops->del_nan_func(&local->hw, &sdata->vif, instance_id);
1250 	trace_drv_return_void(local);
1251 }
1252 
1253 #endif /* __MAC80211_DRIVER_OPS */
1254