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