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