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