net/mac80211/driver-ops.h

   1 #ifndef __MAC80211_DRIVER_OPS
   2 #define __MAC80211_DRIVER_OPS
   3
   4 #include <net/mac80211.h>
   5 #include "ieee80211_i.h"
   6 #include "driver-trace.h"
   7
   8 static inline int drv_tx(struct ieee80211_local *local, struct sk_buff *skb)
   9 {
  10         return local->ops->tx(&local->hw, skb);
  11 }
  12
  13 static inline int drv_start(struct ieee80211_local *local)
  14 {
  15         int ret;
  16
  17         might_sleep();
  18
  19         trace_drv_start(local);
  20         local->started = true;
  21         smp_mb();
  22         ret = local->ops->start(&local->hw);
  23         trace_drv_return_int(local, ret);
  24         return ret;
  25 }
  26
  27 static inline void drv_stop(struct ieee80211_local *local)
  28 {
  29         might_sleep();
  30
  31         trace_drv_stop(local);
  32         local->ops->stop(&local->hw);
  33         trace_drv_return_void(local);
  34
  35         /* sync away all work on the tasklet before clearing started */
  36         tasklet_disable(&local->tasklet);
  37         tasklet_enable(&local->tasklet);
  38
  39         barrier();
  40
  41         local->started = false;
  42 }
  43
  44 static inline int drv_add_interface(struct ieee80211_local *local,
  45                                     struct ieee80211_vif *vif)
  46 {
  47         int ret;
  48
  49         might_sleep();
  50
  51         trace_drv_add_interface(local, vif_to_sdata(vif));
  52         ret = local->ops->add_interface(&local->hw, vif);
  53         trace_drv_return_int(local, ret);
  54         return ret;
  55 }
  56
  57 static inline void drv_remove_interface(struct ieee80211_local *local,
  58                                         struct ieee80211_vif *vif)
  59 {
  60         might_sleep();
  61
  62         trace_drv_remove_interface(local, vif_to_sdata(vif));
  63         local->ops->remove_interface(&local->hw, vif);
  64         trace_drv_return_void(local);
  65 }
  66
  67 static inline int drv_config(struct ieee80211_local *local, u32 changed)
  68 {
  69         int ret;
  70
  71         might_sleep();
  72
  73         trace_drv_config(local, changed);
  74         ret = local->ops->config(&local->hw, changed);
  75         trace_drv_return_int(local, ret);
  76         return ret;
  77 }
  78
  79 static inline void drv_bss_info_changed(struct ieee80211_local *local,
  80                                         struct ieee80211_sub_if_data *sdata,
  81                                         struct ieee80211_bss_conf *info,
  82                                         u32 changed)
  83 {
  84         might_sleep();
  85
  86         trace_drv_bss_info_changed(local, sdata, info, changed);
  87         if (local->ops->bss_info_changed)
  88                 local->ops->bss_info_changed(&local->hw, &sdata->vif, info, changed);
  89         trace_drv_return_void(local);
  90 }
  91
  92 static inline u64 drv_prepare_multicast(struct ieee80211_local *local,
  93                                         struct netdev_hw_addr_list *mc_list)
  94 {
  95         u64 ret = 0;
  96
  97         trace_drv_prepare_multicast(local, mc_list->count);
  98
  99         if (local->ops->prepare_multicast)
 100                 ret = local->ops->prepare_multicast(&local->hw, mc_list);
 101
 102         trace_drv_return_u64(local, ret);
 103
 104         return ret;
 105 }
 106
 107 static inline void drv_configure_filter(struct ieee80211_local *local,
 108                                         unsigned int changed_flags,
 109                                         unsigned int *total_flags,
 110                                         u64 multicast)
 111 {
 112         might_sleep();
 113
 114         trace_drv_configure_filter(local, changed_flags, total_flags,
 115                                    multicast);
 116         local->ops->configure_filter(&local->hw, changed_flags, total_flags,
 117                                      multicast);
 118         trace_drv_return_void(local);
 119 }
 120
 121 static inline int drv_set_tim(struct ieee80211_local *local,
 122                               struct ieee80211_sta *sta, bool set)
 123 {
 124         int ret = 0;
 125         trace_drv_set_tim(local, sta, set);
 126         if (local->ops->set_tim)
 127                 ret = local->ops->set_tim(&local->hw, sta, set);
 128         trace_drv_return_int(local, ret);
 129         return ret;
 130 }
 131
 132 static inline int drv_set_key(struct ieee80211_local *local,
 133                               enum set_key_cmd cmd,
 134                               struct ieee80211_sub_if_data *sdata,
 135                               struct ieee80211_sta *sta,
 136                               struct ieee80211_key_conf *key)
 137 {
 138         int ret;
 139
 140         might_sleep();
 141
 142         trace_drv_set_key(local, cmd, sdata, sta, key);
 143         ret = local->ops->set_key(&local->hw, cmd, &sdata->vif, sta, key);
 144         trace_drv_return_int(local, ret);
 145         return ret;
 146 }
 147
 148 static inline void drv_update_tkip_key(struct ieee80211_local *local,
 149                                        struct ieee80211_sub_if_data *sdata,
 150                                        struct ieee80211_key_conf *conf,
 151                                        struct sta_info *sta, u32 iv32,
 152                                        u16 *phase1key)
 153 {
 154         struct ieee80211_sta *ista = NULL;
 155
 156         if (sta)
 157                 ista = &sta->sta;
 158
 159         trace_drv_update_tkip_key(local, sdata, conf, ista, iv32);
 160         if (local->ops->update_tkip_key)
 161                 local->ops->update_tkip_key(&local->hw, &sdata->vif, conf,
 162                                             ista, iv32, phase1key);
 163         trace_drv_return_void(local);
 164 }
 165
 166 static inline int drv_hw_scan(struct ieee80211_local *local,
 167                               struct ieee80211_sub_if_data *sdata,
 168                               struct cfg80211_scan_request *req)
 169 {
 170         int ret;
 171
 172         might_sleep();
 173
 174         trace_drv_hw_scan(local, sdata, req);
 175         ret = local->ops->hw_scan(&local->hw, &sdata->vif, req);
 176         trace_drv_return_int(local, ret);
 177         return ret;
 178 }
 179
 180 static inline void drv_sw_scan_start(struct ieee80211_local *local)
 181 {
 182         might_sleep();
 183
 184         trace_drv_sw_scan_start(local);
 185         if (local->ops->sw_scan_start)
 186                 local->ops->sw_scan_start(&local->hw);
 187         trace_drv_return_void(local);
 188 }
 189
 190 static inline void drv_sw_scan_complete(struct ieee80211_local *local)
 191 {
 192         might_sleep();
 193
 194         trace_drv_sw_scan_complete(local);
 195         if (local->ops->sw_scan_complete)
 196                 local->ops->sw_scan_complete(&local->hw);
 197         trace_drv_return_void(local);
 198 }
 199
 200 static inline int drv_get_stats(struct ieee80211_local *local,
 201                                 struct ieee80211_low_level_stats *stats)
 202 {
 203         int ret = -EOPNOTSUPP;
 204
 205         might_sleep();
 206
 207         if (local->ops->get_stats)
 208                 ret = local->ops->get_stats(&local->hw, stats);
 209         trace_drv_get_stats(local, stats, ret);
 210
 211         return ret;
 212 }
 213
 214 static inline void drv_get_tkip_seq(struct ieee80211_local *local,
 215                                     u8 hw_key_idx, u32 *iv32, u16 *iv16)
 216 {
 217         if (local->ops->get_tkip_seq)
 218                 local->ops->get_tkip_seq(&local->hw, hw_key_idx, iv32, iv16);
 219         trace_drv_get_tkip_seq(local, hw_key_idx, iv32, iv16);
 220 }
 221
 222 static inline int drv_set_rts_threshold(struct ieee80211_local *local,
 223                                         u32 value)
 224 {
 225         int ret = 0;
 226
 227         might_sleep();
 228
 229         trace_drv_set_rts_threshold(local, value);
 230         if (local->ops->set_rts_threshold)
 231                 ret = local->ops->set_rts_threshold(&local->hw, value);
 232         trace_drv_return_int(local, ret);
 233         return ret;
 234 }
 235
 236 static inline int drv_set_coverage_class(struct ieee80211_local *local,
 237                                          u8 value)
 238 {
 239         int ret = 0;
 240         might_sleep();
 241
 242         trace_drv_set_coverage_class(local, value);
 243         if (local->ops->set_coverage_class)
 244                 local->ops->set_coverage_class(&local->hw, value);
 245         else
 246                 ret = -EOPNOTSUPP;
 247
 248         trace_drv_return_int(local, ret);
 249         return ret;
 250 }
 251
 252 static inline void drv_sta_notify(struct ieee80211_local *local,
 253                                   struct ieee80211_sub_if_data *sdata,
 254                                   enum sta_notify_cmd cmd,
 255                                   struct ieee80211_sta *sta)
 256 {
 257         trace_drv_sta_notify(local, sdata, cmd, sta);
 258         if (local->ops->sta_notify)
 259                 local->ops->sta_notify(&local->hw, &sdata->vif, cmd, sta);
 260         trace_drv_return_void(local);
 261 }
 262
 263 static inline int drv_sta_add(struct ieee80211_local *local,
 264                               struct ieee80211_sub_if_data *sdata,
 265                               struct ieee80211_sta *sta)
 266 {
 267         int ret = 0;
 268
 269         might_sleep();
 270
 271         trace_drv_sta_add(local, sdata, sta);
 272         if (local->ops->sta_add)
 273                 ret = local->ops->sta_add(&local->hw, &sdata->vif, sta);
 274
 275         trace_drv_return_int(local, ret);
 276
 277         return ret;
 278 }
 279
 280 static inline void drv_sta_remove(struct ieee80211_local *local,
 281                                   struct ieee80211_sub_if_data *sdata,
 282                                   struct ieee80211_sta *sta)
 283 {
 284         might_sleep();
 285
 286         trace_drv_sta_remove(local, sdata, sta);
 287         if (local->ops->sta_remove)
 288                 local->ops->sta_remove(&local->hw, &sdata->vif, sta);
 289
 290         trace_drv_return_void(local);
 291 }
 292
 293 static inline int drv_conf_tx(struct ieee80211_local *local, u16 queue,
 294                               const struct ieee80211_tx_queue_params *params)
 295 {
 296         int ret = -EOPNOTSUPP;
 297
 298         might_sleep();
 299
 300         trace_drv_conf_tx(local, queue, params);
 301         if (local->ops->conf_tx)
 302                 ret = local->ops->conf_tx(&local->hw, queue, params);
 303         trace_drv_return_int(local, ret);
 304         return ret;
 305 }
 306
 307 static inline u64 drv_get_tsf(struct ieee80211_local *local)
 308 {
 309         u64 ret = -1ULL;
 310
 311         might_sleep();
 312
 313         trace_drv_get_tsf(local);
 314         if (local->ops->get_tsf)
 315                 ret = local->ops->get_tsf(&local->hw);
 316         trace_drv_return_u64(local, ret);
 317         return ret;
 318 }
 319
 320 static inline void drv_set_tsf(struct ieee80211_local *local, u64 tsf)
 321 {
 322         might_sleep();
 323
 324         trace_drv_set_tsf(local, tsf);
 325         if (local->ops->set_tsf)
 326                 local->ops->set_tsf(&local->hw, tsf);
 327         trace_drv_return_void(local);
 328 }
 329
 330 static inline void drv_reset_tsf(struct ieee80211_local *local)
 331 {
 332         might_sleep();
 333
 334         trace_drv_reset_tsf(local);
 335         if (local->ops->reset_tsf)
 336                 local->ops->reset_tsf(&local->hw);
 337         trace_drv_return_void(local);
 338 }
 339
 340 static inline int drv_tx_last_beacon(struct ieee80211_local *local)
 341 {
 342         int ret = 1;
 343
 344         might_sleep();
 345
 346         trace_drv_tx_last_beacon(local);
 347         if (local->ops->tx_last_beacon)
 348                 ret = local->ops->tx_last_beacon(&local->hw);
 349         trace_drv_return_int(local, ret);
 350         return ret;
 351 }
 352
 353 static inline int drv_ampdu_action(struct ieee80211_local *local,
 354                                    struct ieee80211_sub_if_data *sdata,
 355                                    enum ieee80211_ampdu_mlme_action action,
 356                                    struct ieee80211_sta *sta, u16 tid,
 357                                    u16 *ssn)
 358 {
 359         int ret = -EOPNOTSUPP;
 360
 361         might_sleep();
 362
 363         trace_drv_ampdu_action(local, sdata, action, sta, tid, ssn);
 364
 365         if (local->ops->ampdu_action)
 366                 ret = local->ops->ampdu_action(&local->hw, &sdata->vif, action,
 367                                                sta, tid, ssn);
 368
 369         trace_drv_return_int(local, ret);
 370
 371         return ret;
 372 }
 373
 374 static inline int drv_get_survey(struct ieee80211_local *local, int idx,
 375                                 struct survey_info *survey)
 376 {
 377         int ret = -EOPNOTSUPP;
 378
 379         trace_drv_get_survey(local, idx, survey);
 380
 381         if (local->ops->get_survey)
 382                 ret = local->ops->get_survey(&local->hw, idx, survey);
 383
 384         trace_drv_return_int(local, ret);
 385
 386         return ret;
 387 }
 388
 389 static inline void drv_rfkill_poll(struct ieee80211_local *local)
 390 {
 391         might_sleep();
 392
 393         if (local->ops->rfkill_poll)
 394                 local->ops->rfkill_poll(&local->hw);
 395 }
 396
 397 static inline void drv_flush(struct ieee80211_local *local, bool drop)
 398 {
 399         might_sleep();
 400
 401         trace_drv_flush(local, drop);
 402         if (local->ops->flush)
 403                 local->ops->flush(&local->hw, drop);
 404         trace_drv_return_void(local);
 405 }
 406
 407 static inline void drv_channel_switch(struct ieee80211_local *local,
 408                                      struct ieee80211_channel_switch *ch_switch)
 409 {
 410         might_sleep();
 411
 412         trace_drv_channel_switch(local, ch_switch);
 413         local->ops->channel_switch(&local->hw, ch_switch);
 414         trace_drv_return_void(local);
 415 }
 416
 417 #endif /* __MAC80211_DRIVER_OPS */