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