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