xref: /openbmc/linux/net/mac80211/driver-ops.h (revision 63dc02bd) 
1 #ifndef __MAC80211_DRIVER_OPS
2 #define __MAC80211_DRIVER_OPS
3 
4 #include <net/mac80211.h>
5 #include "ieee80211_i.h"
6 #include "driver-trace.h"
7 
8 static inline void check_sdata_in_driver(struct ieee80211_sub_if_data *sdata)
9 {
10 	WARN_ON(!(sdata->flags & IEEE80211_SDATA_IN_DRIVER));
11 }
12 
13 static inline struct ieee80211_sub_if_data *
14 get_bss_sdata(struct ieee80211_sub_if_data *sdata)
15 {
16 	if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
17 		sdata = container_of(sdata->bss, struct ieee80211_sub_if_data,
18 				     u.ap);
19 
20 	return sdata;
21 }
22 
23 static inline void drv_tx(struct ieee80211_local *local, struct sk_buff *skb)
24 {
25 	local->ops->tx(&local->hw, skb);
26 }
27 
28 static inline void drv_tx_frags(struct ieee80211_local *local,
29 				struct ieee80211_vif *vif,
30 				struct ieee80211_sta *sta,
31 				struct sk_buff_head *skbs)
32 {
33 	local->ops->tx_frags(&local->hw, vif, sta, skbs);
34 }
35 
36 static inline int drv_start(struct ieee80211_local *local)
37 {
38 	int ret;
39 
40 	might_sleep();
41 
42 	trace_drv_start(local);
43 	local->started = true;
44 	smp_mb();
45 	ret = local->ops->start(&local->hw);
46 	trace_drv_return_int(local, ret);
47 	return ret;
48 }
49 
50 static inline void drv_stop(struct ieee80211_local *local)
51 {
52 	might_sleep();
53 
54 	trace_drv_stop(local);
55 	local->ops->stop(&local->hw);
56 	trace_drv_return_void(local);
57 
58 	/* sync away all work on the tasklet before clearing started */
59 	tasklet_disable(&local->tasklet);
60 	tasklet_enable(&local->tasklet);
61 
62 	barrier();
63 
64 	local->started = false;
65 }
66 
67 #ifdef CONFIG_PM
68 static inline int drv_suspend(struct ieee80211_local *local,
69 			      struct cfg80211_wowlan *wowlan)
70 {
71 	int ret;
72 
73 	might_sleep();
74 
75 	trace_drv_suspend(local);
76 	ret = local->ops->suspend(&local->hw, wowlan);
77 	trace_drv_return_int(local, ret);
78 	return ret;
79 }
80 
81 static inline int drv_resume(struct ieee80211_local *local)
82 {
83 	int ret;
84 
85 	might_sleep();
86 
87 	trace_drv_resume(local);
88 	ret = local->ops->resume(&local->hw);
89 	trace_drv_return_int(local, ret);
90 	return ret;
91 }
92 #endif
93 
94 static inline int drv_add_interface(struct ieee80211_local *local,
95 				    struct ieee80211_sub_if_data *sdata)
96 {
97 	int ret;
98 
99 	might_sleep();
100 
101 	if (WARN_ON(sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
102 		    sdata->vif.type == NL80211_IFTYPE_MONITOR))
103 		return -EINVAL;
104 
105 	trace_drv_add_interface(local, sdata);
106 	ret = local->ops->add_interface(&local->hw, &sdata->vif);
107 	trace_drv_return_int(local, ret);
108 
109 	if (ret == 0)
110 		sdata->flags |= IEEE80211_SDATA_IN_DRIVER;
111 
112 	return ret;
113 }
114 
115 static inline int drv_change_interface(struct ieee80211_local *local,
116 				       struct ieee80211_sub_if_data *sdata,
117 				       enum nl80211_iftype type, bool p2p)
118 {
119 	int ret;
120 
121 	might_sleep();
122 
123 	check_sdata_in_driver(sdata);
124 
125 	trace_drv_change_interface(local, sdata, type, p2p);
126 	ret = local->ops->change_interface(&local->hw, &sdata->vif, type, p2p);
127 	trace_drv_return_int(local, ret);
128 	return ret;
129 }
130 
131 static inline void drv_remove_interface(struct ieee80211_local *local,
132 					struct ieee80211_sub_if_data *sdata)
133 {
134 	might_sleep();
135 
136 	check_sdata_in_driver(sdata);
137 
138 	trace_drv_remove_interface(local, sdata);
139 	local->ops->remove_interface(&local->hw, &sdata->vif);
140 	sdata->flags &= ~IEEE80211_SDATA_IN_DRIVER;
141 	trace_drv_return_void(local);
142 }
143 
144 static inline int drv_config(struct ieee80211_local *local, u32 changed)
145 {
146 	int ret;
147 
148 	might_sleep();
149 
150 	trace_drv_config(local, changed);
151 	ret = local->ops->config(&local->hw, changed);
152 	trace_drv_return_int(local, ret);
153 	return ret;
154 }
155 
156 static inline void drv_bss_info_changed(struct ieee80211_local *local,
157 					struct ieee80211_sub_if_data *sdata,
158 					struct ieee80211_bss_conf *info,
159 					u32 changed)
160 {
161 	might_sleep();
162 
163 	check_sdata_in_driver(sdata);
164 
165 	trace_drv_bss_info_changed(local, sdata, info, changed);
166 	if (local->ops->bss_info_changed)
167 		local->ops->bss_info_changed(&local->hw, &sdata->vif, info, changed);
168 	trace_drv_return_void(local);
169 }
170 
171 static inline u64 drv_prepare_multicast(struct ieee80211_local *local,
172 					struct netdev_hw_addr_list *mc_list)
173 {
174 	u64 ret = 0;
175 
176 	trace_drv_prepare_multicast(local, mc_list->count);
177 
178 	if (local->ops->prepare_multicast)
179 		ret = local->ops->prepare_multicast(&local->hw, mc_list);
180 
181 	trace_drv_return_u64(local, ret);
182 
183 	return ret;
184 }
185 
186 static inline void drv_configure_filter(struct ieee80211_local *local,
187 					unsigned int changed_flags,
188 					unsigned int *total_flags,
189 					u64 multicast)
190 {
191 	might_sleep();
192 
193 	trace_drv_configure_filter(local, changed_flags, total_flags,
194 				   multicast);
195 	local->ops->configure_filter(&local->hw, changed_flags, total_flags,
196 				     multicast);
197 	trace_drv_return_void(local);
198 }
199 
200 static inline int drv_set_tim(struct ieee80211_local *local,
201 			      struct ieee80211_sta *sta, bool set)
202 {
203 	int ret = 0;
204 	trace_drv_set_tim(local, sta, set);
205 	if (local->ops->set_tim)
206 		ret = local->ops->set_tim(&local->hw, sta, set);
207 	trace_drv_return_int(local, ret);
208 	return ret;
209 }
210 
211 static inline int drv_set_key(struct ieee80211_local *local,
212 			      enum set_key_cmd cmd,
213 			      struct ieee80211_sub_if_data *sdata,
214 			      struct ieee80211_sta *sta,
215 			      struct ieee80211_key_conf *key)
216 {
217 	int ret;
218 
219 	might_sleep();
220 
221 	sdata = get_bss_sdata(sdata);
222 	check_sdata_in_driver(sdata);
223 
224 	trace_drv_set_key(local, cmd, sdata, sta, key);
225 	ret = local->ops->set_key(&local->hw, cmd, &sdata->vif, sta, key);
226 	trace_drv_return_int(local, ret);
227 	return ret;
228 }
229 
230 static inline void drv_update_tkip_key(struct ieee80211_local *local,
231 				       struct ieee80211_sub_if_data *sdata,
232 				       struct ieee80211_key_conf *conf,
233 				       struct sta_info *sta, u32 iv32,
234 				       u16 *phase1key)
235 {
236 	struct ieee80211_sta *ista = NULL;
237 
238 	if (sta)
239 		ista = &sta->sta;
240 
241 	sdata = get_bss_sdata(sdata);
242 	check_sdata_in_driver(sdata);
243 
244 	trace_drv_update_tkip_key(local, sdata, conf, ista, iv32);
245 	if (local->ops->update_tkip_key)
246 		local->ops->update_tkip_key(&local->hw, &sdata->vif, conf,
247 					    ista, iv32, phase1key);
248 	trace_drv_return_void(local);
249 }
250 
251 static inline int drv_hw_scan(struct ieee80211_local *local,
252 			      struct ieee80211_sub_if_data *sdata,
253 			      struct cfg80211_scan_request *req)
254 {
255 	int ret;
256 
257 	might_sleep();
258 
259 	check_sdata_in_driver(sdata);
260 
261 	trace_drv_hw_scan(local, sdata);
262 	ret = local->ops->hw_scan(&local->hw, &sdata->vif, req);
263 	trace_drv_return_int(local, ret);
264 	return ret;
265 }
266 
267 static inline void drv_cancel_hw_scan(struct ieee80211_local *local,
268 				      struct ieee80211_sub_if_data *sdata)
269 {
270 	might_sleep();
271 
272 	check_sdata_in_driver(sdata);
273 
274 	trace_drv_cancel_hw_scan(local, sdata);
275 	local->ops->cancel_hw_scan(&local->hw, &sdata->vif);
276 	trace_drv_return_void(local);
277 }
278 
279 static inline int
280 drv_sched_scan_start(struct ieee80211_local *local,
281 		     struct ieee80211_sub_if_data *sdata,
282 		     struct cfg80211_sched_scan_request *req,
283 		     struct ieee80211_sched_scan_ies *ies)
284 {
285 	int ret;
286 
287 	might_sleep();
288 
289 	check_sdata_in_driver(sdata);
290 
291 	trace_drv_sched_scan_start(local, sdata);
292 	ret = local->ops->sched_scan_start(&local->hw, &sdata->vif,
293 					      req, ies);
294 	trace_drv_return_int(local, ret);
295 	return ret;
296 }
297 
298 static inline void drv_sched_scan_stop(struct ieee80211_local *local,
299 				       struct ieee80211_sub_if_data *sdata)
300 {
301 	might_sleep();
302 
303 	check_sdata_in_driver(sdata);
304 
305 	trace_drv_sched_scan_stop(local, sdata);
306 	local->ops->sched_scan_stop(&local->hw, &sdata->vif);
307 	trace_drv_return_void(local);
308 }
309 
310 static inline void drv_sw_scan_start(struct ieee80211_local *local)
311 {
312 	might_sleep();
313 
314 	trace_drv_sw_scan_start(local);
315 	if (local->ops->sw_scan_start)
316 		local->ops->sw_scan_start(&local->hw);
317 	trace_drv_return_void(local);
318 }
319 
320 static inline void drv_sw_scan_complete(struct ieee80211_local *local)
321 {
322 	might_sleep();
323 
324 	trace_drv_sw_scan_complete(local);
325 	if (local->ops->sw_scan_complete)
326 		local->ops->sw_scan_complete(&local->hw);
327 	trace_drv_return_void(local);
328 }
329 
330 static inline int drv_get_stats(struct ieee80211_local *local,
331 				struct ieee80211_low_level_stats *stats)
332 {
333 	int ret = -EOPNOTSUPP;
334 
335 	might_sleep();
336 
337 	if (local->ops->get_stats)
338 		ret = local->ops->get_stats(&local->hw, stats);
339 	trace_drv_get_stats(local, stats, ret);
340 
341 	return ret;
342 }
343 
344 static inline void drv_get_tkip_seq(struct ieee80211_local *local,
345 				    u8 hw_key_idx, u32 *iv32, u16 *iv16)
346 {
347 	if (local->ops->get_tkip_seq)
348 		local->ops->get_tkip_seq(&local->hw, hw_key_idx, iv32, iv16);
349 	trace_drv_get_tkip_seq(local, hw_key_idx, iv32, iv16);
350 }
351 
352 static inline int drv_set_frag_threshold(struct ieee80211_local *local,
353 					u32 value)
354 {
355 	int ret = 0;
356 
357 	might_sleep();
358 
359 	trace_drv_set_frag_threshold(local, value);
360 	if (local->ops->set_frag_threshold)
361 		ret = local->ops->set_frag_threshold(&local->hw, value);
362 	trace_drv_return_int(local, ret);
363 	return ret;
364 }
365 
366 static inline int drv_set_rts_threshold(struct ieee80211_local *local,
367 					u32 value)
368 {
369 	int ret = 0;
370 
371 	might_sleep();
372 
373 	trace_drv_set_rts_threshold(local, value);
374 	if (local->ops->set_rts_threshold)
375 		ret = local->ops->set_rts_threshold(&local->hw, value);
376 	trace_drv_return_int(local, ret);
377 	return ret;
378 }
379 
380 static inline int drv_set_coverage_class(struct ieee80211_local *local,
381 					 u8 value)
382 {
383 	int ret = 0;
384 	might_sleep();
385 
386 	trace_drv_set_coverage_class(local, value);
387 	if (local->ops->set_coverage_class)
388 		local->ops->set_coverage_class(&local->hw, value);
389 	else
390 		ret = -EOPNOTSUPP;
391 
392 	trace_drv_return_int(local, ret);
393 	return ret;
394 }
395 
396 static inline void drv_sta_notify(struct ieee80211_local *local,
397 				  struct ieee80211_sub_if_data *sdata,
398 				  enum sta_notify_cmd cmd,
399 				  struct ieee80211_sta *sta)
400 {
401 	sdata = get_bss_sdata(sdata);
402 	check_sdata_in_driver(sdata);
403 
404 	trace_drv_sta_notify(local, sdata, cmd, sta);
405 	if (local->ops->sta_notify)
406 		local->ops->sta_notify(&local->hw, &sdata->vif, cmd, sta);
407 	trace_drv_return_void(local);
408 }
409 
410 static inline int drv_sta_add(struct ieee80211_local *local,
411 			      struct ieee80211_sub_if_data *sdata,
412 			      struct ieee80211_sta *sta)
413 {
414 	int ret = 0;
415 
416 	might_sleep();
417 
418 	sdata = get_bss_sdata(sdata);
419 	check_sdata_in_driver(sdata);
420 
421 	trace_drv_sta_add(local, sdata, sta);
422 	if (local->ops->sta_add)
423 		ret = local->ops->sta_add(&local->hw, &sdata->vif, sta);
424 
425 	trace_drv_return_int(local, ret);
426 
427 	return ret;
428 }
429 
430 static inline void drv_sta_remove(struct ieee80211_local *local,
431 				  struct ieee80211_sub_if_data *sdata,
432 				  struct ieee80211_sta *sta)
433 {
434 	might_sleep();
435 
436 	sdata = get_bss_sdata(sdata);
437 	check_sdata_in_driver(sdata);
438 
439 	trace_drv_sta_remove(local, sdata, sta);
440 	if (local->ops->sta_remove)
441 		local->ops->sta_remove(&local->hw, &sdata->vif, sta);
442 
443 	trace_drv_return_void(local);
444 }
445 
446 static inline __must_check
447 int drv_sta_state(struct ieee80211_local *local,
448 		  struct ieee80211_sub_if_data *sdata,
449 		  struct sta_info *sta,
450 		  enum ieee80211_sta_state old_state,
451 		  enum ieee80211_sta_state new_state)
452 {
453 	int ret = 0;
454 
455 	might_sleep();
456 
457 	sdata = get_bss_sdata(sdata);
458 	check_sdata_in_driver(sdata);
459 
460 	trace_drv_sta_state(local, sdata, &sta->sta, old_state, new_state);
461 	if (local->ops->sta_state) {
462 		ret = local->ops->sta_state(&local->hw, &sdata->vif, &sta->sta,
463 					    old_state, new_state);
464 	} else if (old_state == IEEE80211_STA_AUTH &&
465 		   new_state == IEEE80211_STA_ASSOC) {
466 		ret = drv_sta_add(local, sdata, &sta->sta);
467 		if (ret == 0)
468 			sta->uploaded = true;
469 	} else if (old_state == IEEE80211_STA_ASSOC &&
470 		   new_state == IEEE80211_STA_AUTH) {
471 		drv_sta_remove(local, sdata, &sta->sta);
472 	}
473 	trace_drv_return_int(local, ret);
474 	return ret;
475 }
476 
477 static inline int drv_conf_tx(struct ieee80211_local *local,
478 			      struct ieee80211_sub_if_data *sdata, u16 queue,
479 			      const struct ieee80211_tx_queue_params *params)
480 {
481 	int ret = -EOPNOTSUPP;
482 
483 	might_sleep();
484 
485 	check_sdata_in_driver(sdata);
486 
487 	trace_drv_conf_tx(local, sdata, queue, params);
488 	if (local->ops->conf_tx)
489 		ret = local->ops->conf_tx(&local->hw, &sdata->vif,
490 					  queue, params);
491 	trace_drv_return_int(local, ret);
492 	return ret;
493 }
494 
495 static inline u64 drv_get_tsf(struct ieee80211_local *local,
496 			      struct ieee80211_sub_if_data *sdata)
497 {
498 	u64 ret = -1ULL;
499 
500 	might_sleep();
501 
502 	check_sdata_in_driver(sdata);
503 
504 	trace_drv_get_tsf(local, sdata);
505 	if (local->ops->get_tsf)
506 		ret = local->ops->get_tsf(&local->hw, &sdata->vif);
507 	trace_drv_return_u64(local, ret);
508 	return ret;
509 }
510 
511 static inline void drv_set_tsf(struct ieee80211_local *local,
512 			       struct ieee80211_sub_if_data *sdata,
513 			       u64 tsf)
514 {
515 	might_sleep();
516 
517 	check_sdata_in_driver(sdata);
518 
519 	trace_drv_set_tsf(local, sdata, tsf);
520 	if (local->ops->set_tsf)
521 		local->ops->set_tsf(&local->hw, &sdata->vif, tsf);
522 	trace_drv_return_void(local);
523 }
524 
525 static inline void drv_reset_tsf(struct ieee80211_local *local,
526 				 struct ieee80211_sub_if_data *sdata)
527 {
528 	might_sleep();
529 
530 	check_sdata_in_driver(sdata);
531 
532 	trace_drv_reset_tsf(local, sdata);
533 	if (local->ops->reset_tsf)
534 		local->ops->reset_tsf(&local->hw, &sdata->vif);
535 	trace_drv_return_void(local);
536 }
537 
538 static inline int drv_tx_last_beacon(struct ieee80211_local *local)
539 {
540 	int ret = 0; /* default unsuported op for less congestion */
541 
542 	might_sleep();
543 
544 	trace_drv_tx_last_beacon(local);
545 	if (local->ops->tx_last_beacon)
546 		ret = local->ops->tx_last_beacon(&local->hw);
547 	trace_drv_return_int(local, ret);
548 	return ret;
549 }
550 
551 static inline int drv_ampdu_action(struct ieee80211_local *local,
552 				   struct ieee80211_sub_if_data *sdata,
553 				   enum ieee80211_ampdu_mlme_action action,
554 				   struct ieee80211_sta *sta, u16 tid,
555 				   u16 *ssn, u8 buf_size)
556 {
557 	int ret = -EOPNOTSUPP;
558 
559 	might_sleep();
560 
561 	sdata = get_bss_sdata(sdata);
562 	check_sdata_in_driver(sdata);
563 
564 	trace_drv_ampdu_action(local, sdata, action, sta, tid, ssn, buf_size);
565 
566 	if (local->ops->ampdu_action)
567 		ret = local->ops->ampdu_action(&local->hw, &sdata->vif, action,
568 					       sta, tid, ssn, buf_size);
569 
570 	trace_drv_return_int(local, ret);
571 
572 	return ret;
573 }
574 
575 static inline int drv_get_survey(struct ieee80211_local *local, int idx,
576 				struct survey_info *survey)
577 {
578 	int ret = -EOPNOTSUPP;
579 
580 	trace_drv_get_survey(local, idx, survey);
581 
582 	if (local->ops->get_survey)
583 		ret = local->ops->get_survey(&local->hw, idx, survey);
584 
585 	trace_drv_return_int(local, ret);
586 
587 	return ret;
588 }
589 
590 static inline void drv_rfkill_poll(struct ieee80211_local *local)
591 {
592 	might_sleep();
593 
594 	if (local->ops->rfkill_poll)
595 		local->ops->rfkill_poll(&local->hw);
596 }
597 
598 static inline void drv_flush(struct ieee80211_local *local, bool drop)
599 {
600 	might_sleep();
601 
602 	trace_drv_flush(local, drop);
603 	if (local->ops->flush)
604 		local->ops->flush(&local->hw, drop);
605 	trace_drv_return_void(local);
606 }
607 
608 static inline void drv_channel_switch(struct ieee80211_local *local,
609 				     struct ieee80211_channel_switch *ch_switch)
610 {
611 	might_sleep();
612 
613 	trace_drv_channel_switch(local, ch_switch);
614 	local->ops->channel_switch(&local->hw, ch_switch);
615 	trace_drv_return_void(local);
616 }
617 
618 
619 static inline int drv_set_antenna(struct ieee80211_local *local,
620 				  u32 tx_ant, u32 rx_ant)
621 {
622 	int ret = -EOPNOTSUPP;
623 	might_sleep();
624 	if (local->ops->set_antenna)
625 		ret = local->ops->set_antenna(&local->hw, tx_ant, rx_ant);
626 	trace_drv_set_antenna(local, tx_ant, rx_ant, ret);
627 	return ret;
628 }
629 
630 static inline int drv_get_antenna(struct ieee80211_local *local,
631 				  u32 *tx_ant, u32 *rx_ant)
632 {
633 	int ret = -EOPNOTSUPP;
634 	might_sleep();
635 	if (local->ops->get_antenna)
636 		ret = local->ops->get_antenna(&local->hw, tx_ant, rx_ant);
637 	trace_drv_get_antenna(local, *tx_ant, *rx_ant, ret);
638 	return ret;
639 }
640 
641 static inline int drv_remain_on_channel(struct ieee80211_local *local,
642 					struct ieee80211_channel *chan,
643 					enum nl80211_channel_type chantype,
644 					unsigned int duration)
645 {
646 	int ret;
647 
648 	might_sleep();
649 
650 	trace_drv_remain_on_channel(local, chan, chantype, duration);
651 	ret = local->ops->remain_on_channel(&local->hw, chan, chantype,
652 					    duration);
653 	trace_drv_return_int(local, ret);
654 
655 	return ret;
656 }
657 
658 static inline int drv_cancel_remain_on_channel(struct ieee80211_local *local)
659 {
660 	int ret;
661 
662 	might_sleep();
663 
664 	trace_drv_cancel_remain_on_channel(local);
665 	ret = local->ops->cancel_remain_on_channel(&local->hw);
666 	trace_drv_return_int(local, ret);
667 
668 	return ret;
669 }
670 
671 static inline int drv_set_ringparam(struct ieee80211_local *local,
672 				    u32 tx, u32 rx)
673 {
674 	int ret = -ENOTSUPP;
675 
676 	might_sleep();
677 
678 	trace_drv_set_ringparam(local, tx, rx);
679 	if (local->ops->set_ringparam)
680 		ret = local->ops->set_ringparam(&local->hw, tx, rx);
681 	trace_drv_return_int(local, ret);
682 
683 	return ret;
684 }
685 
686 static inline void drv_get_ringparam(struct ieee80211_local *local,
687 				     u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max)
688 {
689 	might_sleep();
690 
691 	trace_drv_get_ringparam(local, tx, tx_max, rx, rx_max);
692 	if (local->ops->get_ringparam)
693 		local->ops->get_ringparam(&local->hw, tx, tx_max, rx, rx_max);
694 	trace_drv_return_void(local);
695 }
696 
697 static inline bool drv_tx_frames_pending(struct ieee80211_local *local)
698 {
699 	bool ret = false;
700 
701 	might_sleep();
702 
703 	trace_drv_tx_frames_pending(local);
704 	if (local->ops->tx_frames_pending)
705 		ret = local->ops->tx_frames_pending(&local->hw);
706 	trace_drv_return_bool(local, ret);
707 
708 	return ret;
709 }
710 
711 static inline int drv_set_bitrate_mask(struct ieee80211_local *local,
712 				       struct ieee80211_sub_if_data *sdata,
713 				       const struct cfg80211_bitrate_mask *mask)
714 {
715 	int ret = -EOPNOTSUPP;
716 
717 	might_sleep();
718 
719 	check_sdata_in_driver(sdata);
720 
721 	trace_drv_set_bitrate_mask(local, sdata, mask);
722 	if (local->ops->set_bitrate_mask)
723 		ret = local->ops->set_bitrate_mask(&local->hw,
724 						   &sdata->vif, mask);
725 	trace_drv_return_int(local, ret);
726 
727 	return ret;
728 }
729 
730 static inline void drv_set_rekey_data(struct ieee80211_local *local,
731 				      struct ieee80211_sub_if_data *sdata,
732 				      struct cfg80211_gtk_rekey_data *data)
733 {
734 	check_sdata_in_driver(sdata);
735 
736 	trace_drv_set_rekey_data(local, sdata, data);
737 	if (local->ops->set_rekey_data)
738 		local->ops->set_rekey_data(&local->hw, &sdata->vif, data);
739 	trace_drv_return_void(local);
740 }
741 
742 static inline void drv_rssi_callback(struct ieee80211_local *local,
743 				     const enum ieee80211_rssi_event event)
744 {
745 	trace_drv_rssi_callback(local, event);
746 	if (local->ops->rssi_callback)
747 		local->ops->rssi_callback(&local->hw, event);
748 	trace_drv_return_void(local);
749 }
750 
751 static inline void
752 drv_release_buffered_frames(struct ieee80211_local *local,
753 			    struct sta_info *sta, u16 tids, int num_frames,
754 			    enum ieee80211_frame_release_type reason,
755 			    bool more_data)
756 {
757 	trace_drv_release_buffered_frames(local, &sta->sta, tids, num_frames,
758 					  reason, more_data);
759 	if (local->ops->release_buffered_frames)
760 		local->ops->release_buffered_frames(&local->hw, &sta->sta, tids,
761 						    num_frames, reason,
762 						    more_data);
763 	trace_drv_return_void(local);
764 }
765 
766 static inline void
767 drv_allow_buffered_frames(struct ieee80211_local *local,
768 			  struct sta_info *sta, u16 tids, int num_frames,
769 			  enum ieee80211_frame_release_type reason,
770 			  bool more_data)
771 {
772 	trace_drv_allow_buffered_frames(local, &sta->sta, tids, num_frames,
773 					reason, more_data);
774 	if (local->ops->allow_buffered_frames)
775 		local->ops->allow_buffered_frames(&local->hw, &sta->sta,
776 						  tids, num_frames, reason,
777 						  more_data);
778 	trace_drv_return_void(local);
779 }
780 #endif /* __MAC80211_DRIVER_OPS */
781