~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/mac80211/driver-ops.h

Version: ~ [ linux-5.6 ] ~ [ linux-5.5.13 ] ~ [ linux-5.4.28 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.113 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.174 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.217 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.217 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 */
1170 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp