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

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

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

~ [ 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