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 void drv_tx(struct ieee80211_local *local, struct sk_buff *skb)
   9 {
  10         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_frag_threshold(struct ieee80211_local *local,
 237                                         u32 value)
 238 {
 239         int ret = 0;
 240
 241         might_sleep();
 242
 243         trace_drv_set_frag_threshold(local, value);
 244         if (local->ops->set_frag_threshold)
 245                 ret = local->ops->set_frag_threshold(&local->hw, value);
 246         trace_drv_return_int(local, ret);
 247         return ret;
 248 }
 249
 250 static inline int drv_set_rts_threshold(struct ieee80211_local *local,
 251                                         u32 value)
 252 {
 253         int ret = 0;
 254
 255         might_sleep();
 256
 257         trace_drv_set_rts_threshold(local, value);
 258         if (local->ops->set_rts_threshold)
 259                 ret = local->ops->set_rts_threshold(&local->hw, value);
 260         trace_drv_return_int(local, ret);
 261         return ret;
 262 }
 263
 264 static inline int drv_set_coverage_class(struct ieee80211_local *local,
 265                                          u8 value)
 266 {
 267         int ret = 0;
 268         might_sleep();
 269
 270         trace_drv_set_coverage_class(local, value);
 271         if (local->ops->set_coverage_class)
 272                 local->ops->set_coverage_class(&local->hw, value);
 273         else
 274                 ret = -EOPNOTSUPP;
 275
 276         trace_drv_return_int(local, ret);
 277         return ret;
 278 }
 279
 280 static inline void drv_sta_notify(struct ieee80211_local *local,
 281                                   struct ieee80211_sub_if_data *sdata,
 282                                   enum sta_notify_cmd cmd,
 283                                   struct ieee80211_sta *sta)
 284 {
 285         trace_drv_sta_notify(local, sdata, cmd, sta);
 286         if (local->ops->sta_notify)
 287                 local->ops->sta_notify(&local->hw, &sdata->vif, cmd, sta);
 288         trace_drv_return_void(local);
 289 }
 290
 291 static inline int drv_sta_add(struct ieee80211_local *local,
 292                               struct ieee80211_sub_if_data *sdata,
 293                               struct ieee80211_sta *sta)
 294 {
 295         int ret = 0;
 296
 297         might_sleep();
 298
 299         trace_drv_sta_add(local, sdata, sta);
 300         if (local->ops->sta_add)
 301                 ret = local->ops->sta_add(&local->hw, &sdata->vif, sta);
 302
 303         trace_drv_return_int(local, ret);
 304
 305         return ret;
 306 }
 307
 308 static inline void drv_sta_remove(struct ieee80211_local *local,
 309                                   struct ieee80211_sub_if_data *sdata,
 310                                   struct ieee80211_sta *sta)
 311 {
 312         might_sleep();
 313
 314         trace_drv_sta_remove(local, sdata, sta);
 315         if (local->ops->sta_remove)
 316                 local->ops->sta_remove(&local->hw, &sdata->vif, sta);
 317
 318         trace_drv_return_void(local);
 319 }
 320
 321 static inline int drv_conf_tx(struct ieee80211_local *local, u16 queue,
 322                               const struct ieee80211_tx_queue_params *params)
 323 {
 324         int ret = -EOPNOTSUPP;
 325
 326         might_sleep();
 327
 328         trace_drv_conf_tx(local, queue, params);
 329         if (local->ops->conf_tx)
 330                 ret = local->ops->conf_tx(&local->hw, queue, params);
 331         trace_drv_return_int(local, ret);
 332         return ret;
 333 }
 334
 335 static inline u64 drv_get_tsf(struct ieee80211_local *local)
 336 {
 337         u64 ret = -1ULL;
 338
 339         might_sleep();
 340
 341         trace_drv_get_tsf(local);
 342         if (local->ops->get_tsf)
 343                 ret = local->ops->get_tsf(&local->hw);
 344         trace_drv_return_u64(local, ret);
 345         return ret;
 346 }
 347
 348 static inline void drv_set_tsf(struct ieee80211_local *local, u64 tsf)
 349 {
 350         might_sleep();
 351
 352         trace_drv_set_tsf(local, tsf);
 353         if (local->ops->set_tsf)
 354                 local->ops->set_tsf(&local->hw, tsf);
 355         trace_drv_return_void(local);
 356 }
 357
 358 static inline void drv_reset_tsf(struct ieee80211_local *local)
 359 {
 360         might_sleep();
 361
 362         trace_drv_reset_tsf(local);
 363         if (local->ops->reset_tsf)
 364                 local->ops->reset_tsf(&local->hw);
 365         trace_drv_return_void(local);
 366 }
 367
 368 static inline int drv_tx_last_beacon(struct ieee80211_local *local)
 369 {
 370         int ret = 0; /* default unsuported op for less congestion */
 371
 372         might_sleep();
 373
 374         trace_drv_tx_last_beacon(local);
 375         if (local->ops->tx_last_beacon)
 376                 ret = local->ops->tx_last_beacon(&local->hw);
 377         trace_drv_return_int(local, ret);
 378         return ret;
 379 }
 380
 381 static inline int drv_ampdu_action(struct ieee80211_local *local,
 382                                    struct ieee80211_sub_if_data *sdata,
 383                                    enum ieee80211_ampdu_mlme_action action,
 384                                    struct ieee80211_sta *sta, u16 tid,
 385                                    u16 *ssn, u8 buf_size)
 386 {
 387         int ret = -EOPNOTSUPP;
 388
 389         might_sleep();
 390
 391         trace_drv_ampdu_action(local, sdata, action, sta, tid, ssn, buf_size);
 392
 393         if (local->ops->ampdu_action)
 394                 ret = local->ops->ampdu_action(&local->hw, &sdata->vif, action,
 395                                                sta, tid, ssn, buf_size);
 396
 397         trace_drv_return_int(local, ret);
 398
 399         return ret;
 400 }
 401
 402 static inline int drv_get_survey(struct ieee80211_local *local, int idx,
 403                                 struct survey_info *survey)
 404 {
 405         int ret = -EOPNOTSUPP;
 406
 407         trace_drv_get_survey(local, idx, survey);
 408
 409         if (local->ops->get_survey)
 410                 ret = local->ops->get_survey(&local->hw, idx, survey);
 411
 412         trace_drv_return_int(local, ret);
 413
 414         return ret;
 415 }
 416
 417 static inline void drv_rfkill_poll(struct ieee80211_local *local)
 418 {
 419         might_sleep();
 420
 421         if (local->ops->rfkill_poll)
 422                 local->ops->rfkill_poll(&local->hw);
 423 }
 424
 425 static inline void drv_flush(struct ieee80211_local *local, bool drop)
 426 {
 427         might_sleep();
 428
 429         trace_drv_flush(local, drop);
 430         if (local->ops->flush)
 431                 local->ops->flush(&local->hw, drop);
 432         trace_drv_return_void(local);
 433 }
 434
 435 static inline void drv_channel_switch(struct ieee80211_local *local,
 436                                      struct ieee80211_channel_switch *ch_switch)
 437 {
 438         might_sleep();
 439
 440         trace_drv_channel_switch(local, ch_switch);
 441         local->ops->channel_switch(&local->hw, ch_switch);
 442         trace_drv_return_void(local);
 443 }
 444
 445
 446 static inline int drv_set_antenna(struct ieee80211_local *local,
 447                                   u32 tx_ant, u32 rx_ant)
 448 {
 449         int ret = -EOPNOTSUPP;
 450         might_sleep();
 451         if (local->ops->set_antenna)
 452                 ret = local->ops->set_antenna(&local->hw, tx_ant, rx_ant);
 453         trace_drv_set_antenna(local, tx_ant, rx_ant, ret);
 454         return ret;
 455 }
 456
 457 static inline int drv_get_antenna(struct ieee80211_local *local,
 458                                   u32 *tx_ant, u32 *rx_ant)
 459 {
 460         int ret = -EOPNOTSUPP;
 461         might_sleep();
 462         if (local->ops->get_antenna)
 463                 ret = local->ops->get_antenna(&local->hw, tx_ant, rx_ant);
 464         trace_drv_get_antenna(local, *tx_ant, *rx_ant, ret);
 465         return ret;
 466 }
 467
 468 static inline int drv_remain_on_channel(struct ieee80211_local *local,
 469                                         struct ieee80211_channel *chan,
 470                                         enum nl80211_channel_type chantype,
 471                                         unsigned int duration)
 472 {
 473         int ret;
 474
 475         might_sleep();
 476
 477         trace_drv_remain_on_channel(local, chan, chantype, duration);
 478         ret = local->ops->remain_on_channel(&local->hw, chan, chantype,
 479                                             duration);
 480         trace_drv_return_int(local, ret);
 481
 482         return ret;
 483 }
 484
 485 static inline int drv_cancel_remain_on_channel(struct ieee80211_local *local)
 486 {
 487         int ret;
 488
 489         might_sleep();
 490
 491         trace_drv_cancel_remain_on_channel(local);
 492         ret = local->ops->cancel_remain_on_channel(&local->hw);
 493         trace_drv_return_int(local, ret);
 494
 495         return ret;
 496 }
 497
 498 static inline int drv_offchannel_tx(struct ieee80211_local *local,
 499                                     struct sk_buff *skb,
 500                                     struct ieee80211_channel *chan,
 501                                     enum nl80211_channel_type channel_type,
 502                                     unsigned int wait)
 503 {
 504         int ret;
 505
 506         might_sleep();
 507
 508         trace_drv_offchannel_tx(local, skb, chan, channel_type, wait);
 509         ret = local->ops->offchannel_tx(&local->hw, skb, chan,
 510                                         channel_type, wait);
 511         trace_drv_return_int(local, ret);
 512
 513         return ret;
 514 }
 515
 516 static inline int drv_offchannel_tx_cancel_wait(struct ieee80211_local *local)
 517 {
 518         int ret;
 519
 520         might_sleep();
 521
 522         trace_drv_offchannel_tx_cancel_wait(local);
 523         ret = local->ops->offchannel_tx_cancel_wait(&local->hw);
 524         trace_drv_return_int(local, ret);
 525
 526         return ret;
 527 }
 528
 529 static inline int drv_set_ringparam(struct ieee80211_local *local,
 530                                     u32 tx, u32 rx)
 531 {
 532         int ret = -ENOTSUPP;
 533
 534         might_sleep();
 535
 536         trace_drv_set_ringparam(local, tx, rx);
 537         if (local->ops->set_ringparam)
 538                 ret = local->ops->set_ringparam(&local->hw, tx, rx);
 539         trace_drv_return_int(local, ret);
 540
 541         return ret;
 542 }
 543
 544 static inline void drv_get_ringparam(struct ieee80211_local *local,
 545                                      u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max)
 546 {
 547         might_sleep();
 548
 549         trace_drv_get_ringparam(local, tx, tx_max, rx, rx_max);
 550         if (local->ops->get_ringparam)
 551                 local->ops->get_ringparam(&local->hw, tx, tx_max, rx, rx_max);
 552         trace_drv_return_void(local);
 553 }
 554
 555 #endif /* __MAC80211_DRIVER_OPS */