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

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

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

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